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  */
   27 
   28 #include <sys/cdefs.h>
   29 __FBSDID("$FreeBSD: releng/9.0/sys/dev/syscons/scvtb.c 146476 2005-05-21 20:28:15Z marius $");
   30 
   31 #include "opt_syscons.h"
   32 
   33 #include <sys/param.h>
   34 #include <sys/systm.h>
   35 #include <sys/malloc.h>
   36 #include <sys/fbio.h>
   37 #include <sys/consio.h>
   38 
   39 #include <machine/md_var.h>
   40 #include <machine/bus.h>
   41 
   42 #include <dev/fb/fbreg.h>
   43 #include <dev/syscons/syscons.h>
   44 
   45 #define vtb_wrap(vtb, at, offset)                               \
   46     (((at) + (offset) + (vtb)->vtb_size)%(vtb)->vtb_size)
   47 
   48 void
   49 sc_vtb_init(sc_vtb_t *vtb, int type, int cols, int rows, void *buf, int wait)
   50 {
   51         vtb->vtb_flags = 0;
   52         vtb->vtb_type = type;
   53         vtb->vtb_cols = cols;
   54         vtb->vtb_rows = rows;
   55         vtb->vtb_size = cols*rows;
   56         vtb->vtb_buffer = 0;
   57         vtb->vtb_tail = 0;
   58 
   59         switch (type) {
   60         case VTB_MEMORY:
   61         case VTB_RINGBUFFER:
   62                 if ((buf == NULL) && (cols*rows != 0)) {
   63                         vtb->vtb_buffer =
   64                                 (vm_offset_t)malloc(cols*rows*sizeof(u_int16_t),
   65                                                     M_DEVBUF, 
   66                                                     (wait) ? M_WAITOK : M_NOWAIT);
   67                         if (vtb->vtb_buffer != 0) {
   68                                 bzero((void *)sc_vtb_pointer(vtb, 0),
   69                                       cols*rows*sizeof(u_int16_t));
   70                                 vtb->vtb_flags |= VTB_ALLOCED;
   71                         }
   72                 } else {
   73                         vtb->vtb_buffer = (vm_offset_t)buf;
   74                 }
   75                 vtb->vtb_flags |= VTB_VALID;
   76                 break;
   77 #ifndef __sparc64__
   78         case VTB_FRAMEBUFFER:
   79                 vtb->vtb_buffer = (vm_offset_t)buf;
   80                 vtb->vtb_flags |= VTB_VALID;
   81                 break;
   82 #endif
   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 #ifndef __sparc64__
  123         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  124                 return (readw(sc_vtb_pointer(vtb, at)) & 0x00ff);
  125         else
  126 #endif
  127                 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0x00ff);
  128 }
  129 
  130 int
  131 sc_vtb_geta(sc_vtb_t *vtb, int at)
  132 {
  133 #ifndef __sparc64__
  134         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  135                 return (readw(sc_vtb_pointer(vtb, at)) & 0xff00);
  136         else
  137 #endif
  138                 return (*(u_int16_t *)sc_vtb_pointer(vtb, at) & 0xff00);
  139 }
  140 
  141 void
  142 sc_vtb_putc(sc_vtb_t *vtb, int at, int c, int a)
  143 {
  144 #ifndef __sparc64__
  145         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  146                 writew(sc_vtb_pointer(vtb, at), a | c);
  147         else
  148 #endif
  149                 *(u_int16_t *)sc_vtb_pointer(vtb, at) = a | c;
  150 }
  151 
  152 vm_offset_t
  153 sc_vtb_putchar(sc_vtb_t *vtb, vm_offset_t p, int c, int a)
  154 {
  155 #ifndef __sparc64__
  156         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  157                 writew(p, a | c);
  158         else
  159 #endif
  160                 *(u_int16_t *)p = a | c;
  161         return (p + sizeof(u_int16_t));
  162 }
  163 
  164 vm_offset_t
  165 sc_vtb_pointer(sc_vtb_t *vtb, int at)
  166 {
  167         return (vtb->vtb_buffer + sizeof(u_int16_t)*(at));
  168 }
  169 
  170 int
  171 sc_vtb_pos(sc_vtb_t *vtb, int pos, int offset)
  172 {
  173         return ((pos + offset + vtb->vtb_size)%vtb->vtb_size);
  174 }
  175 
  176 void
  177 sc_vtb_clear(sc_vtb_t *vtb, int c, int attr)
  178 {
  179 #ifndef __sparc64__
  180         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  181                 fillw_io(attr | c, sc_vtb_pointer(vtb, 0), vtb->vtb_size);
  182         else
  183 #endif
  184                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, 0), vtb->vtb_size);
  185 }
  186 
  187 void
  188 sc_vtb_copy(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int to, int count)
  189 {
  190 #ifndef __sparc64__
  191         /* XXX if both are VTB_VRAMEBUFFER... */
  192         if (vtb2->vtb_type == VTB_FRAMEBUFFER)
  193                 bcopy_toio(sc_vtb_pointer(vtb1, from),
  194                            sc_vtb_pointer(vtb2, to),
  195                            count*sizeof(u_int16_t));
  196         else if (vtb1->vtb_type == VTB_FRAMEBUFFER)
  197                 bcopy_fromio(sc_vtb_pointer(vtb1, from),
  198                              sc_vtb_pointer(vtb2, to),
  199                              count*sizeof(u_int16_t));
  200         else
  201 #endif
  202                 bcopy((void *)sc_vtb_pointer(vtb1, from),
  203                       (void *)sc_vtb_pointer(vtb2, to),
  204                       count*sizeof(u_int16_t));
  205 }
  206 
  207 void
  208 sc_vtb_append(sc_vtb_t *vtb1, int from, sc_vtb_t *vtb2, int count)
  209 {
  210         int len;
  211 
  212         if (vtb2->vtb_type != VTB_RINGBUFFER)
  213                 return;
  214 
  215         while (count > 0) {
  216                 len = imin(count, vtb2->vtb_size - vtb2->vtb_tail);
  217 #ifndef __sparc64__
  218                 if (vtb1->vtb_type == VTB_FRAMEBUFFER)
  219                         bcopy_fromio(sc_vtb_pointer(vtb1, from),
  220                                      sc_vtb_pointer(vtb2, vtb2->vtb_tail),
  221                                      len*sizeof(u_int16_t));
  222                 else
  223 #endif
  224                         bcopy((void *)sc_vtb_pointer(vtb1, from),
  225                               (void *)sc_vtb_pointer(vtb2, vtb2->vtb_tail),
  226                               len*sizeof(u_int16_t));
  227                 from += len;
  228                 count -= len;
  229                 vtb2->vtb_tail = vtb_wrap(vtb2, vtb2->vtb_tail, len);
  230         }
  231 }
  232 
  233 void
  234 sc_vtb_seek(sc_vtb_t *vtb, int pos)
  235 {
  236         vtb->vtb_tail = pos%vtb->vtb_size;
  237 }
  238 
  239 void
  240 sc_vtb_erase(sc_vtb_t *vtb, int at, int count, int c, int attr)
  241 {
  242         if (at + count > vtb->vtb_size)
  243                 count = vtb->vtb_size - at;
  244 #ifndef __sparc64__
  245         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  246                 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count);
  247         else
  248 #endif
  249                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count);
  250 }
  251 
  252 void
  253 sc_vtb_move(sc_vtb_t *vtb, int from, int to, int count)
  254 {
  255         if (from + count > vtb->vtb_size)
  256                 count = vtb->vtb_size - from;
  257         if (to + count > vtb->vtb_size)
  258                 count = vtb->vtb_size - to;
  259         if (count <= 0)
  260                 return;
  261 #ifndef __sparc64__
  262         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  263                 bcopy_io(sc_vtb_pointer(vtb, from),
  264                          sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t)); 
  265         else
  266 #endif
  267                 bcopy((void *)sc_vtb_pointer(vtb, from),
  268                       (void *)sc_vtb_pointer(vtb, to), count*sizeof(u_int16_t));
  269 }
  270 
  271 void
  272 sc_vtb_delete(sc_vtb_t *vtb, int at, int count, int c, int attr)
  273 {
  274         int len;
  275 
  276         if (at + count > vtb->vtb_size)
  277                 count = vtb->vtb_size - at;
  278         len = vtb->vtb_size - at - count;
  279         if (len > 0) {
  280 #ifndef __sparc64__
  281                 if (vtb->vtb_type == VTB_FRAMEBUFFER)
  282                         bcopy_io(sc_vtb_pointer(vtb, at + count),
  283                                  sc_vtb_pointer(vtb, at),
  284                                  len*sizeof(u_int16_t)); 
  285                 else
  286 #endif
  287                         bcopy((void *)sc_vtb_pointer(vtb, at + count),
  288                               (void *)sc_vtb_pointer(vtb, at),
  289                               len*sizeof(u_int16_t)); 
  290         }
  291 #ifndef __sparc64__
  292         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  293                 fillw_io(attr | c, sc_vtb_pointer(vtb, at + len),
  294                          vtb->vtb_size - at - len);
  295         else
  296 #endif
  297                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at + len),
  298                       vtb->vtb_size - at - len);
  299 }
  300 
  301 void
  302 sc_vtb_ins(sc_vtb_t *vtb, int at, int count, int c, int attr)
  303 {
  304         if (at + count > vtb->vtb_size)
  305                 count = vtb->vtb_size - at;
  306         else {
  307 #ifndef __sparc64__
  308                 if (vtb->vtb_type == VTB_FRAMEBUFFER)
  309                         bcopy_io(sc_vtb_pointer(vtb, at),
  310                                  sc_vtb_pointer(vtb, at + count),
  311                                  (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  312                 else
  313 #endif
  314                         bcopy((void *)sc_vtb_pointer(vtb, at),
  315                               (void *)sc_vtb_pointer(vtb, at + count),
  316                               (vtb->vtb_size - at - count)*sizeof(u_int16_t)); 
  317         }
  318 #ifndef __sparc64__
  319         if (vtb->vtb_type == VTB_FRAMEBUFFER)
  320                 fillw_io(attr | c, sc_vtb_pointer(vtb, at), count);
  321         else
  322 #endif
  323                 fillw(attr | c, (void *)sc_vtb_pointer(vtb, at), count);
  324 }
Cache object: 12f119300445d4bf9a96290b980605cb
[ 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
