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 FreeBSD(98) Porting Team.
    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$
   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/consio.h>
   35 #include <sys/fbio.h>
   36 
   37 #include <machine/md_var.h>
   38 
   39 #include <dev/fb/fbreg.h>
   40 #include <dev/syscons/syscons.h>
   41 
   42 #define ATTR_OFFSET_FB          0x2000
   43 #define attr_offset(vtb)        ((vtb)->vtb_size*sizeof(u_int16_t))
   44 
   45 #define vtb_pointer(vtb, at)                                    \
   46     ((vtb)->vtb_buffer + sizeof(u_int16_t)*(at))
   47 
   48 #define vtb_wrap(vtb, at, offset)                               \
   49     (((at) + (offset) + (vtb)->vtb_size)%(vtb)->vtb_size)
   50 
   51 static u_int8_t ibmpc_to_pc98[256] = {
   52         0x01, 0x21, 0x81, 0xa1, 0x41, 0x61, 0xc1, 0xe1,
   53         0x09, 0x29, 0x89, 0xa9, 0x49, 0x69, 0xc9, 0xe9,
   54         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
   55         0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25, 0x25,
   56         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
   57         0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85,
   58         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
   59         0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
   60         0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
   61         0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45, 0x45,
   62         0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65,
   63         0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65, 0x65,
   64         0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5,
   65         0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5, 0xc5,
   66         0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5,
   67         0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5, 0xe5,
   68 
   69         0x03, 0x23, 0x83, 0xa3, 0x43, 0x63, 0xc3, 0xe3,
   70         0x0b, 0x2b, 0x8b, 0xab, 0x4b, 0x6b, 0xcb, 0xeb,
   71         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
   72         0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f, 0x2f,
   73         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
   74         0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f, 0x8f,
   75         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
   76         0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf, 0xaf,
   77         0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
   78         0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f, 0x4f,
   79         0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
   80         0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f, 0x6f,
   81         0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf,
   82         0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf, 0xcf,
   83         0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef,
   84         0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 0xef, 
   85 };
   86 #define at2pc98(attr)   ((attr) | ibmpc_to_pc98[(unsigned)(attr) >> 8])
   87 
   88 void
   89 sc_vtb_init(sc_vtb_t *vtb, int type, int cols, int rows, void *buf, int wait)
   90 {
   91         vtb->vtb_flags = 0;
   92         vtb->vtb_type = type;
   93         vtb->vtb_cols = cols;
   94         vtb->vtb_rows = rows;
   95         vtb->vtb_size = cols*rows;
   96         vtb->vtb_buffer = 0;
   97         vtb->vtb_tail = 0;
   98 
   99         switch (type) {
  100         case VTB_MEMORY:
  101         case VTB_RINGBUFFER:
  102                 if ((buf == NULL) && (cols*rows != 0)) {
  103                         vtb->vtb_buffer =
  104                             (vm_offset_t)malloc(cols*rows*sizeof(u_int16_t)*2,
  105                                 M_DEVBUF, 
  106                                 ((wait) ? M_WAITOK : M_NOWAIT) | M_ZERO);
  107                         if (vtb->vtb_buffer != 0) {
  108                                 vtb->vtb_flags |= VTB_ALLOCED;
  109                         }
  110                 } else {
  111                         vtb->vtb_buffer = (vm_offset_t)buf;
  112                 }
  113                 vtb->vtb_flags |= VTB_VALID;
  114                 break;
  115         case VTB_FRAMEBUFFER:
  116                 vtb->vtb_buffer = (vm_offset_t)buf;
  117                 vtb->vtb_flags |= VTB_VALID;
  118                 break;
  119         default:
  120                 break;
  121         }
  122 }
  123 
  124 void
  125 sc_vtb_destroy(sc_vtb_t *vtb)
  126 {
  127         vm_offset_t p;
  128 
  129         vtb->vtb_cols = 0;
  130         vtb->vtb_rows = 0;
  131         vtb->vtb_size = 0;
  132         vtb->vtb_tail = 0;
  133 
  134         p = vtb->vtb_buffer;
  135         vtb->vtb_buffer = 0;
  136         switch (vtb->vtb_type) {
  137         case VTB_MEMORY:
  138         case VTB_RINGBUFFER:
  139                 if ((vtb->vtb_flags & VTB_ALLOCED) && (p != 0))
  140                         free((void *)p, M_DEVBUF);
  141                 break;
  142         default:
  143                 break;
  144         }
  145         vtb->vtb_flags = 0;
  146         vtb->vtb_type = VTB_INVALID;
  147 }
  148 
  149 size_t
  150 sc_vtb_size(int cols, int rows)
  151 {
  152         return (size_t)(cols*rows*sizeof(u_int16_t)*2);
  153 }
  154 
  155 int
  156 sc_vtb_getc(sc_vtb_t *vtb, int at)
  157 {
  158         vm_offset_t p = vtb_pointer(vtb, at);
  159 
  160         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  161                 return (readw(p) & 0x00ff);
  162         else
  163                 return (*(u_int16_t *)p & 0x00ff);
  164 }
  165 
  166 int
  167 sc_vtb_geta(sc_vtb_t *vtb, int at)
  168 {
  169         vm_offset_t p = vtb_pointer(vtb, at);
  170 
  171         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  172                 return (readw(p + ATTR_OFFSET_FB) & 0xff00);
  173         else
  174                 return (*(u_int16_t *)(p + attr_offset(vtb)) & 0xff00);
  175 }
  176 
  177 static inline void
  178 vtb_putc(sc_vtb_t *vtb, vm_offset_t p, int c, int a)
  179 {
  180         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  181                 writew(p, c);
  182                 writew(p + ATTR_OFFSET_FB, at2pc98(a));
  183         } else {
  184                 *(u_int16_t *)p = c;
  185                 *(u_int16_t *)(p + attr_offset(vtb)) = at2pc98(a);
  186         }
  187 }
  188 
  189 void
  190 sc_vtb_putc(sc_vtb_t *vtb, int at, int c, int a)
  191 {
  192         vtb_putc(vtb, vtb_pointer(vtb, at), c, a);
  193 }
  194 
  195 vm_offset_t
  196 sc_vtb_putchar(sc_vtb_t *vtb, vm_offset_t p, int c, int a)
  197 {
  198         vtb_putc(vtb, p, c, a);
  199         return (p + sizeof(u_int16_t));
  200 }
  201 
  202 vm_offset_t
  203 sc_vtb_pointer(sc_vtb_t *vtb, int at)
  204 {
  205         return (vtb_pointer(vtb, at));
  206 }
  207 
  208 int
  209 sc_vtb_pos(sc_vtb_t *vtb, int pos, int offset)
  210 {
  211         return ((pos + offset + vtb->vtb_size)%vtb->vtb_size);
  212 }
  213 
  214 void
  215 sc_vtb_clear(sc_vtb_t *vtb, int c, int attr)
  216 {
  217         vm_offset_t p = vtb_pointer(vtb, 0);
  218 
  219         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  220                 fillw_io(c, p, vtb->vtb_size);
  221                 fillw_io(at2pc98(attr), p + ATTR_OFFSET_FB, vtb->vtb_size);
  222         } else {
  223                 fillw(c, (void *)p, vtb->vtb_size);
  224                 fillw(at2pc98(attr), (void *)(p + attr_offset(vtb)),
  225                       vtb->vtb_size);
  226         }
  227 }
  228 
  229 void
  230 sc_vtb_copy(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int to, int count)
  231 {
  232         vm_offset_t p1, p2;
  233 
  234         p1 = vtb_pointer(vtb1, from);
  235         p2 = vtb_pointer(vtb2, to);
  236         if (vtb2->vtb_type == VTB_FRAMEBUFFER) {
  237                 bcopy_toio(p1, p2, count*sizeof(u_int16_t));
  238                 bcopy_toio(p1 + attr_offset(vtb1),
  239                            p2 + ATTR_OFFSET_FB,
  240                            count*sizeof(u_int16_t));
  241         } else if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  242                 bcopy_fromio(p1, p2, count*sizeof(u_int16_t));
  243                 bcopy_fromio(p1 + ATTR_OFFSET_FB,
  244                              p2 + attr_offset(vtb2),
  245                              count*sizeof(u_int16_t));
  246         } else {
  247                 bcopy((void *)p1, (void *)p2, count*sizeof(u_int16_t));
  248                 bcopy((void *)(p1 + attr_offset(vtb1)),
  249                       (void *)(p2 + attr_offset(vtb2)),
  250                       count*sizeof(u_int16_t));
  251         }
  252 }
  253 
  254 void
  255 sc_vtb_append(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int count)
  256 {
  257         int len;
  258         vm_offset_t p1, p2;
  259 
  260         if (vtb2->vtb_type != VTB_RINGBUFFER)
  261                 return;
  262 
  263         while (count > 0) {
  264                 p1 = vtb_pointer(vtb1, from);
  265                 p2 = vtb_pointer(vtb2, vtb2->vtb_tail);
  266                 len = imin(count, vtb2->vtb_size - vtb2->vtb_tail);
  267                 if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  268                         bcopy_fromio(p1, p2, len*sizeof(u_int16_t));
  269                         bcopy_fromio(p1 + ATTR_OFFSET_FB,
  270                                      p2 + attr_offset(vtb2),
  271                                      len*sizeof(u_int16_t));
  272                 } else {
  273                         bcopy((void *)p1, (void *)p2, len*sizeof(u_int16_t));
  274                         bcopy((void *)(p1 + attr_offset(vtb1)),
  275                               (void *)(p2 + attr_offset(vtb2)),
  276                               len*sizeof(u_int16_t));
  277                 }
  278                 from += len;
  279                 count -= len;
  280                 vtb2->vtb_tail = vtb_wrap(vtb2, vtb2->vtb_tail, len);
  281         }
  282 }
  283 
  284 void
  285 sc_vtb_seek(sc_vtb_t *vtb, int pos)
  286 {
  287         vtb->vtb_tail = pos%vtb->vtb_size;
  288 }
  289 
  290 void
  291 sc_vtb_erase(sc_vtb_t *vtb, int at, int count, int c, int attr)
  292 {
  293         vm_offset_t p;
  294 
  295         if (at + count > vtb->vtb_size)
  296                 count = vtb->vtb_size - at;
  297         p = vtb_pointer(vtb, at);
  298         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  299                 fillw_io(c, p, count);
  300                 fillw_io(at2pc98(attr), p + ATTR_OFFSET_FB, count);
  301         } else {
  302                 fillw(c, (void *)p, count);
  303                 fillw(at2pc98(attr), (void *)(p + attr_offset(vtb)), count);
  304         }
  305 }
  306 
  307 void
  308 sc_vtb_move(sc_vtb_t *vtb, int from, int to, int count)
  309 {
  310         vm_offset_t p1, p2;
  311 
  312         if (from + count > vtb->vtb_size)
  313                 count = vtb->vtb_size - from;
  314         if (to + count > vtb->vtb_size)
  315                 count = vtb->vtb_size - to;
  316         if (count <= 0)
  317                 return;
  318 
  319         p1 = vtb_pointer(vtb, from);
  320         p2 = vtb_pointer(vtb, to);
  321         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  322                 bcopy_io(p1, p2, count*sizeof(u_int16_t)); 
  323                 bcopy_io(p1 + ATTR_OFFSET_FB,
  324                          p2 + ATTR_OFFSET_FB, count*sizeof(u_int16_t));
  325         } else {
  326                 bcopy((void *)p1, (void *)p2, count*sizeof(u_int16_t));
  327                 bcopy((void *)(p1 + attr_offset(vtb)),
  328                       (void *)(p2 + attr_offset(vtb)), count*sizeof(u_int16_t));
  329         }
  330 }
  331 
  332 void
  333 sc_vtb_delete(sc_vtb_t *vtb, int at, int count, int c, int attr)
  334 {
  335         int len;
  336         vm_offset_t p1, p2;
  337 
  338         if (at + count > vtb->vtb_size)
  339                 count = vtb->vtb_size - at;
  340         len = vtb->vtb_size - at - count;
  341         if (len > 0) {
  342                 p1 = vtb_pointer(vtb, at + count);
  343                 p2 = vtb_pointer(vtb, at);
  344                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  345                         bcopy_io(p1, p2, len*sizeof(u_int16_t)); 
  346                         bcopy_io(p1 + ATTR_OFFSET_FB,
  347                                  p2 + ATTR_OFFSET_FB,
  348                                  len*sizeof(u_int16_t)); 
  349                 } else {
  350                         bcopy((void *)p1, (void *)p2, len*sizeof(u_int16_t)); 
  351                         bcopy((void *)(p1 + attr_offset(vtb)),
  352                               (void *)(p2 + attr_offset(vtb)),
  353                               len*sizeof(u_int16_t)); 
  354                 }
  355         }
  356         p1 = vtb_pointer(vtb, at + len);
  357         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  358                 fillw_io(c, p1, vtb->vtb_size - at - len);
  359                 fillw_io(at2pc98(attr), p1 + ATTR_OFFSET_FB,
  360                          vtb->vtb_size - at - len);
  361         } else {
  362                 fillw(c, (void *)p1, vtb->vtb_size - at - len);
  363                 fillw(at2pc98(attr), (void *)(p1 + attr_offset(vtb)),
  364                       vtb->vtb_size - at - len);
  365         }
  366 }
  367 
  368 void
  369 sc_vtb_ins(sc_vtb_t *vtb, int at, int count, int c, int attr)
  370 {
  371         vm_offset_t p1, p2;
  372 
  373         p1 = vtb_pointer(vtb, at);
  374         if (at + count > vtb->vtb_size) {
  375                 count = vtb->vtb_size - at;
  376         } else {
  377                 p2 = vtb_pointer(vtb, at + count);
  378                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  379                         bcopy_io(p1, p2, 
  380                                  (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  381                         bcopy_io(p1 + ATTR_OFFSET_FB,
  382                                  p2 + ATTR_OFFSET_FB,
  383                                  (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  384                 } else {
  385                         bcopy((void *)p1, (void *)p2,
  386                               (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  387                         bcopy((void *)(p1 + attr_offset(vtb)),
  388                               (void *)(p2 + attr_offset(vtb)),
  389                               (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  390                 }
  391         }
  392         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  393                 fillw_io(c, p1, count);
  394                 fillw_io(at2pc98(attr), p1 + ATTR_OFFSET_FB, count);
  395         } else {
  396                 fillw(c, (void *)p1, count);
  397                 fillw(at2pc98(attr), (void *)(p1 + attr_offset(vtb)), count);
  398         }
  399 }
Cache object: a53c57cb24781b7d1fc99477aafd253f
[ 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/pc98/cbus/scvtb.c

FreeBSD/Linux Kernel Cross Reference
sys/pc98/cbus/scvtb.c
