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