scvtb.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
    3  * All rights reserved.
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted provided that the following conditions
    7  * are met:
    8  * 1. Redistributions of source code must retain the above copyright
    9  *    notice, this list of conditions and the following disclaimer as
   10  *    the first lines of this file unmodified.
   11  * 2. Redistributions in binary form must reproduce the above copyright
   12  *    notice, this list of conditions and the following disclaimer in the
   13  *    documentation and/or other materials provided with the distribution.
   14  *
   15  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
   16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   18  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
   19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   25  *
   26  * $FreeBSD: releng/5.0/sys/dev/syscons/scvtb.c 102241 2002-08-21 23:39:52Z archie $
   27  */
   28 
   29 #include "opt_syscons.h"
   30 
   31 #include <sys/param.h>
   32 #include <sys/systm.h>
   33 #include <sys/malloc.h>
   34 #include <sys/fbio.h>
   35 #include <sys/consio.h>
   36 
   37 #include <machine/md_var.h>
   38 #include <machine/bus.h>
   39 
   40 #include <dev/fb/fbreg.h>
   41 #include <dev/syscons/syscons.h>
   42 
   43 #define vtb_wrap(vtb, at, offset)                               \
   44     (((at) + (offset) + (vtb)->vtb_size)%(vtb)->vtb_size)
   45 
   46 void
   47 sc_vtb_init(sc_vtb_t *vtb, int type, int cols, int rows, void *buf, int wait)
   48 {
   49         vtb->vtb_flags = 0;
   50         vtb->vtb_type = type;
   51         vtb->vtb_cols = cols;
   52         vtb->vtb_rows = rows;
   53         vtb->vtb_size = cols*rows;
   54         vtb->vtb_buffer = 0;
   55         vtb->vtb_tail = 0;
   56 
   57         switch (type) {
   58         case VTB_MEMORY:
   59         case VTB_RINGBUFFER:
   60                 if ((buf == NULL) && (cols*rows != 0)) {
   61                         vtb->vtb_buffer =
   62                                 (vm_offset_t)malloc(cols*rows*sizeof(u_int16_t),
   63                                                     M_DEVBUF, 
   64                                                     (wait) ? M_WAITOK : M_NOWAIT);
   65                         if (vtb->vtb_buffer != 0) {
   66                                 bzero((void *)sc_vtb_pointer(vtb, 0),
   67                                       cols*rows*sizeof(u_int16_t));
   68                                 vtb->vtb_flags |= VTB_ALLOCED;
   69                         }
   70                 } else {
   71                         vtb->vtb_buffer = (vm_offset_t)buf;
   72                 }
   73                 vtb->vtb_flags |= VTB_VALID;
   74                 break;
   75         case VTB_FRAMEBUFFER:
   76                 vtb->vtb_buffer = (vm_offset_t)buf;
   77                 vtb->vtb_flags |= VTB_VALID;
   78                 break;
   79         default:
   80                 break;
   81         }
   82 }
   83 
   84 void
   85 sc_vtb_destroy(sc_vtb_t *vtb)
   86 {
   87         vm_offset_t p;
   88 
   89         vtb->vtb_cols = 0;
   90         vtb->vtb_rows = 0;
   91         vtb->vtb_size = 0;
   92         vtb->vtb_tail = 0;
   93 
   94         p = vtb->vtb_buffer;
   95         vtb->vtb_buffer = 0;
   96         switch (vtb->vtb_type) {
   97         case VTB_MEMORY:
   98         case VTB_RINGBUFFER:
   99                 if ((vtb->vtb_flags & VTB_ALLOCED) && (p != 0))
  100                         free((void *)p, M_DEVBUF);
  101                 break;
  102         default:
  103                 break;
  104         }
  105         vtb->vtb_flags = 0;
  106         vtb->vtb_type = VTB_INVALID;
  107 }
  108 
  109 size_t
  110 sc_vtb_size(int cols, int rows)
  111 {
  112         return (size_t)(cols*rows*sizeof(u_int16_t));
  113 }
  114 
  115 int
  116 sc_vtb_getc(sc_vtb_t *vtb, int at)
  117 {
  118         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  119                 return (readw(sc_vtb_pointer(vtb, at)) & 0x00ff);
  120         else
  121                 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0x00ff);
  122 }
  123 
  124 int
  125 sc_vtb_geta(sc_vtb_t *vtb, int at)
  126 {
  127         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  128                 return (readw(sc_vtb_pointer(vtb, at)) & 0xff00);
  129         else
  130                 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0xff00);
  131 }
  132 
  133 void
  134 sc_vtb_putc(sc_vtb_t *vtb, int at, int c, int a)
  135 {
  136         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  137                 writew(sc_vtb_pointer(vtb, at), a | c);
  138         else
  139                 *(u_int16_t *)sc_vtb_pointer(vtb, at) = a | c;
  140 }
  141 
  142 vm_offset_t
  143 sc_vtb_putchar(sc_vtb_t *vtb, vm_offset_t p, int c, int a)
  144 {
  145         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  146                 writew(p, a | c);
  147         else
  148                 *(u_int16_t *)p = a | c;
  149         return (p + sizeof(u_int16_t));
  150 }
  151 
  152 vm_offset_t
  153 sc_vtb_pointer(sc_vtb_t *vtb, int at)
  154 {
  155         return (vtb->vtb_buffer + sizeof(u_int16_t)*(at));
  156 }
  157 
  158 int
  159 sc_vtb_pos(sc_vtb_t *vtb, int pos, int offset)
  160 {
  161         return ((pos + offset + vtb->vtb_size)%vtb->vtb_size);
  162 }
  163 
  164 void
  165 sc_vtb_clear(sc_vtb_t *vtb, int c, int attr)
  166 {
  167         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  168                 fillw_io(attr | c, sc_vtb_pointer(vtb, 0), vtb->vtb_size);
  169         else
  170                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, 0), vtb->vtb_size);
  171 }
  172 
  173 void
  174 sc_vtb_copy(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int to, int count)
  175 {
  176         /* XXX if both are VTB_VRAMEBUFFER... */
  177         if (vtb2->vtb_type == VTB_FRAMEBUFFER) {
  178                 bcopy_toio(sc_vtb_pointer(vtb1, from),
  179                            sc_vtb_pointer(vtb2, to),
  180                            count*sizeof(u_int16_t));
  181         } else if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  182                 bcopy_fromio(sc_vtb_pointer(vtb1, from),
  183                              sc_vtb_pointer(vtb2, to),
  184                              count*sizeof(u_int16_t));
  185         } else {
  186                 bcopy((void *)sc_vtb_pointer(vtb1, from),
  187                       (void *)sc_vtb_pointer(vtb2, to),
  188                       count*sizeof(u_int16_t));
  189         }
  190 }
  191 
  192 void
  193 sc_vtb_append(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int count)
  194 {
  195         int len;
  196 
  197         if (vtb2->vtb_type != VTB_RINGBUFFER)
  198                 return;
  199 
  200         while (count > 0) {
  201                 len = imin(count, vtb2->vtb_size - vtb2->vtb_tail);
  202                 if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  203                         bcopy_fromio(sc_vtb_pointer(vtb1, from),
  204                                      sc_vtb_pointer(vtb2, vtb2->vtb_tail),
  205                                      len*sizeof(u_int16_t));
  206                 } else {
  207                         bcopy((void *)sc_vtb_pointer(vtb1, from),
  208                               (void *)sc_vtb_pointer(vtb2, vtb2->vtb_tail),
  209                               len*sizeof(u_int16_t));
  210                 }
  211                 from += len;
  212                 count -= len;
  213                 vtb2->vtb_tail = vtb_wrap(vtb2, vtb2->vtb_tail, len);
  214         }
  215 }
  216 
  217 void
  218 sc_vtb_seek(sc_vtb_t *vtb, int pos)
  219 {
  220         vtb->vtb_tail = pos%vtb->vtb_size;
  221 }
  222 
  223 void
  224 sc_vtb_erase(sc_vtb_t *vtb, int at, int count, int c, int attr)
  225 {
  226         if (at + count > vtb->vtb_size)
  227                 count = vtb->vtb_size - at;
  228         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  229                 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count);
  230         else
  231                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count);
  232 }
  233 
  234 void
  235 sc_vtb_move(sc_vtb_t *vtb, int from, int to, int count)
  236 {
  237         if (from + count > vtb->vtb_size)
  238                 count = vtb->vtb_size - from;
  239         if (to + count > vtb->vtb_size)
  240                 count = vtb->vtb_size - to;
  241         if (count <= 0)
  242                 return;
  243         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  244                 bcopy_io(sc_vtb_pointer(vtb, from),
  245                          sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t)); 
  246         } else {
  247                 bcopy((void *)sc_vtb_pointer(vtb, from),
  248                       (void *)sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t));
  249         }
  250 }
  251 
  252 void
  253 sc_vtb_delete(sc_vtb_t *vtb, int at, int count, int c, int attr)
  254 {
  255         int len;
  256 
  257         if (at + count > vtb->vtb_size)
  258                 count = vtb->vtb_size - at;
  259         len = vtb->vtb_size - at - count;
  260         if (len > 0) {
  261                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  262                         bcopy_io(sc_vtb_pointer(vtb, at + count),
  263                                  sc_vtb_pointer(vtb, at),
  264                                  len*sizeof(u_int16_t)); 
  265                 } else {
  266                         bcopy((void *)sc_vtb_pointer(vtb, at + count),
  267                               (void *)sc_vtb_pointer(vtb, at),
  268                               len*sizeof(u_int16_t)); 
  269                 }
  270         }
  271         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  272                 fillw_io(attr | c, sc_vtb_pointer(vtb, at + len),
  273                          vtb->vtb_size - at - len);
  274         else
  275                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at + len),
  276                       vtb->vtb_size - at - len);
  277 }
  278 
  279 void
  280 sc_vtb_ins(sc_vtb_t *vtb, int at, int count, int c, int attr)
  281 {
  282         if (at + count > vtb->vtb_size) {
  283                 count = vtb->vtb_size - at;
  284         } else {
  285                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  286                         bcopy_io(sc_vtb_pointer(vtb, at),
  287                                  sc_vtb_pointer(vtb, at + count),
  288                                  (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  289                 } else {
  290                         bcopy((void *)sc_vtb_pointer(vtb, at),
  291                               (void *)sc_vtb_pointer(vtb, at + count),
  292                               (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  293                 }
  294         }
  295         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  296                 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count);
  297         else
  298                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count);
  299 }
Cache object: 0afc32c4ecbd4b05c867dc2c5a607657
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/dev/syscons/scvtb.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/syscons/scvtb.c
