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: src/sys/dev/syscons/scvtb.c,v 1.5.2.1 2001/07/16 05:21:23 yokota Exp $
   27  * $DragonFly: src/sys/dev/misc/syscons/scvtb.c,v 1.9 2006/09/05 03:48:10 dillon Exp $
   28  */
   29 
   30 #include "opt_syscons.h"
   31 
   32 #include <sys/param.h>
   33 #include <sys/systm.h>
   34 
   35 #include <machine/console.h>
   36 #include <machine/cpufunc.h>
   37 #include <machine/md_var.h>
   38 
   39 #include <dev/video/fb/fbreg.h>
   40 #include "syscons.h"
   41 
   42 #define vtb_wrap(vtb, at, offset)                               \
   43     (((at) + (offset) + (vtb)->vtb_size)%(vtb)->vtb_size)
   44 
   45 
   46 /*
   47  * Intel text mode emulations can't handle 32-bit or 64-bit writes.
   48  * Use 16-bit writes.  32 and 64-bit writes appear to simply get thrown
   49  * away.  (observed on D2500HN mobo).
   50  *
   51  * We don't care about performance so just use a word-write bcopy mode.
   52  */
   53 static
   54 void
   55 sc_vtb_bcopy(void *s, void *d, size_t bytes)
   56 {
   57         size_t count;
   58         size_t n;
   59         uint16_t *sw = s;
   60         uint16_t *dw = d;
   61 
   62         count = bytes >> 1;
   63         if (s < d) {
   64                 if (bytes & 1)
   65                         *(uint8_t *)(dw + count) = *(uint8_t *)(sw + count);
   66                 while (count--) {
   67                         dw[count] = sw[count];
   68                 }
   69         } else {
   70                 for (n = 0; n < count; ++n)
   71                         dw[n] = sw[n];
   72                 if (bytes & 1) {
   73                         *(uint8_t *)(dw + n) = *(uint8_t *)(sw + n);
   74                 }
   75         }
   76 }
   77 
   78 void
   79 sc_vtb_init(sc_vtb_t *vtb, int type, int cols, int rows, void *buf, int wait)
   80 {
   81         vtb->vtb_flags = 0;
   82         vtb->vtb_type = type;
   83         vtb->vtb_cols = cols;
   84         vtb->vtb_rows = rows;
   85         vtb->vtb_size = cols*rows;
   86         vtb->vtb_buffer = NULL;
   87         vtb->vtb_tail = 0;
   88 
   89         switch (type) {
   90         case VTB_MEMORY:
   91         case VTB_RINGBUFFER:
   92                 if ((buf == NULL) && (cols*rows != 0)) {
   93                         vtb->vtb_buffer = kmalloc(cols*rows*sizeof(uint16_t),
   94                                     M_SYSCONS,
   95                                     M_ZERO | ((wait) ? M_WAITOK : M_NOWAIT));
   96                         if (vtb->vtb_buffer != NULL) {
   97                                 vtb->vtb_flags |= VTB_VALID;
   98                                 vtb->vtb_flags |= VTB_ALLOCED;
   99                         }
  100                 } else {
  101                         vtb->vtb_buffer = buf;
  102                         vtb->vtb_flags |= VTB_VALID;
  103                 }
  104                 break;
  105         case VTB_FRAMEBUFFER:
  106                 vtb->vtb_buffer = buf;
  107                 vtb->vtb_flags |= VTB_VALID;
  108                 break;
  109         default:
  110                 break;
  111         }
  112 }
  113 
  114 void
  115 sc_vtb_destroy(sc_vtb_t *vtb)
  116 {
  117         uint16_t *p;
  118 
  119         vtb->vtb_cols = 0;
  120         vtb->vtb_rows = 0;
  121         vtb->vtb_size = 0;
  122         vtb->vtb_tail = 0;
  123 
  124         p = vtb->vtb_buffer;
  125         vtb->vtb_buffer = NULL;
  126         switch (vtb->vtb_type) {
  127         case VTB_MEMORY:
  128         case VTB_RINGBUFFER:
  129                 if ((vtb->vtb_flags & VTB_ALLOCED) && (p != NULL))
  130                         kfree(p, M_SYSCONS);
  131                 break;
  132         default:
  133                 break;
  134         }
  135         vtb->vtb_flags = 0;
  136         vtb->vtb_type = VTB_INVALID;
  137 }
  138 
  139 size_t
  140 sc_vtb_size(int cols, int rows)
  141 {
  142         return (size_t)(cols*rows*sizeof(uint16_t));
  143 }
  144 
  145 int
  146 sc_vtb_getc(sc_vtb_t *vtb, int at)
  147 {
  148         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  149                 return (readw(vtb->vtb_buffer + at) & 0x00ff);
  150         else
  151                 return (*(vtb->vtb_buffer + at) & 0x00ff);
  152 }
  153 
  154 int
  155 sc_vtb_geta(sc_vtb_t *vtb, int at)
  156 {
  157         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  158                 return (readw(vtb->vtb_buffer + at) & 0xff00);
  159         else
  160                 return (*(vtb->vtb_buffer + at) & 0xff00);
  161 }
  162 
  163 void
  164 sc_vtb_putc(sc_vtb_t *vtb, int at, int c, int a)
  165 {
  166         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  167                 writew(vtb->vtb_buffer + at, a | c);
  168         else
  169                 *(vtb->vtb_buffer + at) = a | c;
  170 }
  171 
  172 uint16_t *
  173 sc_vtb_putchar(sc_vtb_t *vtb, uint16_t *p, int c, int a)
  174 {
  175         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  176                 writew(p, a | c);
  177         else
  178                 *p = a | c;
  179         return (p + 1);
  180 }
  181 
  182 int
  183 sc_vtb_pos(sc_vtb_t *vtb, int pos, int offset)
  184 {
  185         return ((pos + offset + vtb->vtb_size)%vtb->vtb_size);
  186 }
  187 
  188 void
  189 sc_vtb_clear(sc_vtb_t *vtb, int c, int attr)
  190 {
  191         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  192                 fillw_io(attr | c, vtb->vtb_buffer, vtb->vtb_size);
  193         else
  194                 fillw(attr | c, vtb->vtb_buffer, vtb->vtb_size);
  195 }
  196 
  197 void
  198 sc_vtb_copy(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int to, int count)
  199 {
  200         /* XXX if both are VTB_VRAMEBUFFER... */
  201         if (vtb2->vtb_type == VTB_FRAMEBUFFER) {
  202                 sc_vtb_bcopy(vtb1->vtb_buffer + from, vtb2->vtb_buffer + to,
  203                            count*sizeof(uint16_t));
  204         } else if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  205                 sc_vtb_bcopy(vtb1->vtb_buffer + from, vtb2->vtb_buffer + to,
  206                              count*sizeof(uint16_t));
  207         } else {
  208                 sc_vtb_bcopy(vtb1->vtb_buffer + from, vtb2->vtb_buffer + to,
  209                       count*sizeof(uint16_t));
  210         }
  211 }
  212 
  213 void
  214 sc_vtb_append(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int count)
  215 {
  216         int len;
  217 
  218         if (vtb2->vtb_type != VTB_RINGBUFFER)
  219                 return;
  220 
  221         while (count > 0) {
  222                 len = imin(count, vtb2->vtb_size - vtb2->vtb_tail);
  223                 if (vtb1->vtb_type == VTB_FRAMEBUFFER) {
  224                         sc_vtb_bcopy(vtb1->vtb_buffer + from,
  225                                      vtb2->vtb_buffer + vtb2->vtb_tail,
  226                                      len*sizeof(uint16_t));
  227                 } else {
  228                         sc_vtb_bcopy(vtb1->vtb_buffer + from,
  229                               vtb2->vtb_buffer + vtb2->vtb_tail,
  230                               len*sizeof(uint16_t));
  231                 }
  232                 from += len;
  233                 count -= len;
  234                 vtb2->vtb_tail = vtb_wrap(vtb2, vtb2->vtb_tail, len);
  235         }
  236 }
  237 
  238 void
  239 sc_vtb_seek(sc_vtb_t *vtb, int pos)
  240 {
  241         vtb->vtb_tail = pos%vtb->vtb_size;
  242 }
  243 
  244 void
  245 sc_vtb_erase(sc_vtb_t *vtb, int at, int count, int c, int attr)
  246 {
  247         if (at + count > vtb->vtb_size)
  248                 count = vtb->vtb_size - at;
  249         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  250                 fillw_io(attr | c, vtb->vtb_buffer + at, count);
  251         else
  252                 fillw(attr | c, vtb->vtb_buffer + at, count);
  253 }
  254 
  255 void
  256 sc_vtb_move(sc_vtb_t *vtb, int from, int to, int count)
  257 {
  258         if (from + count > vtb->vtb_size)
  259                 count = vtb->vtb_size - from;
  260         if (to + count > vtb->vtb_size)
  261                 count = vtb->vtb_size - to;
  262         if (count <= 0)
  263                 return;
  264         if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  265                 sc_vtb_bcopy(vtb->vtb_buffer + from, vtb->vtb_buffer + to,
  266                          count*sizeof(uint16_t)); 
  267         } else {
  268                 sc_vtb_bcopy(vtb->vtb_buffer + from, vtb->vtb_buffer + to,
  269                       count*sizeof(uint16_t));
  270         }
  271 }
  272 
  273 void
  274 sc_vtb_delete(sc_vtb_t *vtb, int at, int count, int c, int attr)
  275 {
  276         int len;
  277 
  278         if (at + count > vtb->vtb_size)
  279                 count = vtb->vtb_size - at;
  280         len = vtb->vtb_size - at - count;
  281         if (len > 0) {
  282                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  283                         sc_vtb_bcopy(vtb->vtb_buffer + at + count,
  284                                  vtb->vtb_buffer + at,
  285                                  len*sizeof(uint16_t)); 
  286                 } else {
  287                         sc_vtb_bcopy(vtb->vtb_buffer + at + count,
  288                               vtb->vtb_buffer + at,
  289                               len*sizeof(uint16_t)); 
  290                 }
  291         }
  292         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  293                 fillw_io(attr | c, vtb->vtb_buffer + at + len,
  294                          vtb->vtb_size - at - len);
  295         else
  296                 fillw(attr | c, vtb->vtb_buffer + at + len,
  297                       vtb->vtb_size - at - len);
  298 }
  299 
  300 void
  301 sc_vtb_ins(sc_vtb_t *vtb, int at, int count, int c, int attr)
  302 {
  303         if (at + count > vtb->vtb_size) {
  304                 count = vtb->vtb_size - at;
  305         } else {
  306                 if (vtb->vtb_type == VTB_FRAMEBUFFER) {
  307                         sc_vtb_bcopy(vtb->vtb_buffer + at,
  308                                  vtb->vtb_buffer + at + count,
  309                                  (vtb->vtb_size - at - count)*sizeof(uint16_t));
  310                 } else {
  311                         sc_vtb_bcopy(vtb->vtb_buffer + at,
  312                               vtb->vtb_buffer + at + count,
  313                               (vtb->vtb_size - at - count)*sizeof(uint16_t)); 
  314                 }
  315         }
  316         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  317                 fillw_io(attr | c, vtb->vtb_buffer + at, count);
  318         else
  319                 fillw(attr | c, vtb->vtb_buffer + at, count);
  320 }
Cache object: be9b4e5bab1557f3864d95a25c39d949
[ 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/misc/syscons/scvtb.c

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