sys/dev/misc/syscons/scvtb.c

   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 }