sys/dev/misc/syscons/scvgarndr.c

   1 /*-
   2  * Copyright (c) 1999 Kazutaka YOKOTA <yokota@zodiac.mech.utsunomiya-u.ac.jp>
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to The DragonFly Project
   6  * by Sascha Wildner <saw@online.de>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer as
  13  *    the first lines of this file unmodified.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in the
  16  *    documentation and/or other materials provided with the distribution.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $FreeBSD: src/sys/dev/syscons/scvgarndr.c,v 1.5.2.3 2001/07/28 12:51:47 yokota Exp $
  30  * $DragonFly: src/sys/dev/misc/syscons/scvgarndr.c,v 1.6 2004/09/04 12:03:14 eirikn Exp $
  31  */
  32
  33 #include "opt_syscons.h"
  34 #include "opt_vga.h"
  35
  36 #include <sys/param.h>
  37 #include <sys/systm.h>
  38 #include <sys/kernel.h>
  39
  40 #include <machine/console.h>
  41
  42 #include <dev/video/fb/fbreg.h>
  43 #include <dev/video/fb/vgareg.h>
  44 #include "syscons.h"
  45
  46 #include <bus/isa/isareg.h>
  47
  48 #ifndef SC_RENDER_DEBUG
  49 #define SC_RENDER_DEBUG         0
  50 #endif
  51
  52 static vr_clear_t               vga_txtclear;
  53 static vr_draw_border_t         vga_txtborder;
  54 static vr_draw_t                vga_txtdraw;
  55 static vr_set_cursor_t          vga_txtcursor_shape;
  56 static vr_draw_cursor_t         vga_txtcursor;
  57 static vr_blink_cursor_t        vga_txtblink;
  58 #ifndef SC_NO_CUTPASTE
  59 static vr_draw_mouse_t          vga_txtmouse;
  60 #else
  61 #define vga_txtmouse            (vr_draw_mouse_t *)vga_nop
  62 #endif
  63
  64 #ifdef SC_PIXEL_MODE
  65 static vr_init_t                vga_rndrinit;
  66 static vr_clear_t               vga_pxlclear_direct;
  67 static vr_clear_t               vga_pxlclear_planar;
  68 static vr_draw_border_t         vga_pxlborder_direct;
  69 static vr_draw_border_t         vga_pxlborder_planar;
  70 static vr_draw_t                vga_egadraw;
  71 static vr_draw_t                vga_vgadraw_direct;
  72 static vr_draw_t                vga_vgadraw_planar;
  73 static vr_set_cursor_t          vga_pxlcursor_shape;
  74 static vr_draw_cursor_t         vga_pxlcursor_direct;
  75 static vr_draw_cursor_t         vga_pxlcursor_planar;
  76 static vr_blink_cursor_t        vga_pxlblink_direct;
  77 static vr_blink_cursor_t        vga_pxlblink_planar;
  78 #ifndef SC_NO_CUTPASTE
  79 static vr_draw_mouse_t          vga_pxlmouse_direct;
  80 static vr_draw_mouse_t          vga_pxlmouse_planar;
  81 #else
  82 #define vga_pxlmouse_direct     (vr_draw_mouse_t *)vga_nop
  83 #define vga_pxlmouse_planar     (vr_draw_mouse_t *)vga_nop
  84 #endif
  85 #endif /* SC_PIXEL_MODE */
  86
  87 #ifndef SC_NO_MODE_CHANGE
  88 static vr_draw_border_t         vga_grborder;
  89 #endif
  90
  91 static void                     vga_nop(scr_stat *scp, ...);
  92
  93 static sc_rndr_sw_t txtrndrsw = {
  94         (vr_init_t *)vga_nop,
  95         vga_txtclear,
  96         vga_txtborder,
  97         vga_txtdraw,
  98         vga_txtcursor_shape,
  99         vga_txtcursor,
 100         vga_txtblink,
 101         (vr_set_mouse_t *)vga_nop,
 102         vga_txtmouse,
 103 };
 104 RENDERER(mda, 0, txtrndrsw, vga_set);
 105 RENDERER(cga, 0, txtrndrsw, vga_set);
 106 RENDERER(ega, 0, txtrndrsw, vga_set);
 107 RENDERER(vga, 0, txtrndrsw, vga_set);
 108
 109 #ifdef SC_PIXEL_MODE
 110 static sc_rndr_sw_t egarndrsw = {
 111         (vr_init_t *)vga_nop,
 112         vga_pxlclear_planar,
 113         vga_pxlborder_planar,
 114         vga_egadraw,
 115         vga_pxlcursor_shape,
 116         vga_pxlcursor_planar,
 117         vga_pxlblink_planar,
 118         (vr_set_mouse_t *)vga_nop,
 119         vga_pxlmouse_planar,
 120 };
 121 RENDERER(ega, PIXEL_MODE, egarndrsw, vga_set);
 122
 123 static sc_rndr_sw_t vgarndrsw = {
 124         vga_rndrinit,
 125         (vr_clear_t *)vga_nop,
 126         (vr_draw_border_t *)vga_nop,
 127         (vr_draw_t *)vga_nop,
 128         vga_pxlcursor_shape,
 129         (vr_draw_cursor_t *)vga_nop,
 130         (vr_blink_cursor_t *)vga_nop,
 131         (vr_set_mouse_t *)vga_nop,
 132         (vr_draw_mouse_t *)vga_nop,
 133 };
 134 RENDERER(vga, PIXEL_MODE, vgarndrsw, vga_set);
 135 #endif /* SC_PIXEL_MODE */
 136
 137 #ifndef SC_NO_MODE_CHANGE
 138 static sc_rndr_sw_t grrndrsw = {
 139         (vr_init_t *)vga_nop,
 140         (vr_clear_t *)vga_nop,
 141         vga_grborder,
 142         (vr_draw_t *)vga_nop,
 143         (vr_set_cursor_t *)vga_nop,
 144         (vr_draw_cursor_t *)vga_nop,
 145         (vr_blink_cursor_t *)vga_nop,
 146         (vr_set_mouse_t *)vga_nop,
 147         (vr_draw_mouse_t *)vga_nop,
 148 };
 149 RENDERER(cga, GRAPHICS_MODE, grrndrsw, vga_set);
 150 RENDERER(ega, GRAPHICS_MODE, grrndrsw, vga_set);
 151 RENDERER(vga, GRAPHICS_MODE, grrndrsw, vga_set);
 152 #endif /* SC_NO_MODE_CHANGE */
 153
 154 RENDERER_MODULE(vga, vga_set);
 155
 156 #ifndef SC_NO_CUTPASTE
 157 static u_short mouse_and_mask[16] = {
 158         0xc000, 0xe000, 0xf000, 0xf800, 0xfc00, 0xfe00, 0xff00, 0xff80,
 159         0xfe00, 0x1e00, 0x1f00, 0x0f00, 0x0f00, 0x0000, 0x0000, 0x0000
 160 };
 161 static u_short mouse_or_mask[16] = {
 162         0x0000, 0x4000, 0x6000, 0x7000, 0x7800, 0x7c00, 0x7e00, 0x6800,
 163         0x0c00, 0x0c00, 0x0600, 0x0600, 0x0000, 0x0000, 0x0000, 0x0000
 164 };
 165 #endif
 166
 167 #ifdef SC_PIXEL_MODE
 168 #define VIDEO_MEMORY_POS(scp, pos, x)                                   \
 169         scp->sc->adp->va_window +                                       \
 170         x * scp->xoff +                                                 \
 171         scp->yoff * scp->font_size * scp->sc->adp->va_line_width +      \
 172         x * (pos % scp->xsize) +                                        \
 173         scp->font_size * scp->sc->adp->va_line_width * (pos / scp->xsize)
 174
 175 #define vga_drawpxl(pos, color)                                         \
 176         switch (scp->sc->adp->va_info.vi_depth) {                       \
 177                 case 32:                                                \
 178                 case 24:                                                \
 179                         writel(pos, vga_palette32[color]);              \
 180                         break;                                          \
 181                 case 16:                                                \
 182                         if (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5)\
 183                                 writew(pos, vga_palette15[color]);      \
 184                         else                                            \
 185                                 writew(pos, vga_palette16[color]);      \
 186                         break;                                          \
 187                 case 15:                                                \
 188                         writew(pos, vga_palette15[color]);              \
 189                         break;                                          \
 190                 }
 191
 192 static uint32_t vga_palette32[16] = {
 193         0x000000, 0x0000ad, 0x00ad00, 0x00adad,
 194         0xad0000, 0xad00ad, 0xad5200, 0xadadad,
 195         0x525252, 0x5252ff, 0x52ff52, 0x52ffff,
 196         0xff5252, 0xff52ff, 0xffff52, 0xffffff
 197 };
 198
 199 static uint16_t vga_palette16[16] = {
 200         0x0000, 0x0016, 0x0560, 0x0576, 0xb000, 0xb016, 0xb2a0, 0xb576,
 201         0x52aa, 0x52bf, 0x57ea, 0x57ff, 0xfaaa, 0xfabf, 0xffea, 0xffff
 202 };
 203
 204 static uint16_t vga_palette15[16] = {
 205         0x0000, 0x0016, 0x02c0, 0x02d6, 0x5800, 0x5816, 0x5940, 0x5ad6,
 206         0x294a, 0x295f, 0x2bea, 0x2bff, 0x7d4a, 0x7d5f, 0x7fea, 0x7fff
 207 };
 208
 209 #ifndef SC_NO_CUTPASTE
 210 static uint32_t mouse_buf32[256];
 211 static uint16_t mouse_buf16[256];
 212 #endif
 213 #endif
 214
 215 static void
 216 vga_nop(scr_stat *scp, ...)
 217 {
 218 }
 219
 220 /* text mode renderer */
 221
 222 static void
 223 vga_txtclear(scr_stat *scp, int c, int attr)
 224 {
 225         sc_vtb_clear(&scp->scr, c, attr);
 226 }
 227
 228 static void
 229 vga_txtborder(scr_stat *scp, int color)
 230 {
 231         (*vidsw[scp->sc->adapter]->set_border)(scp->sc->adp, color);
 232 }
 233
 234 static void
 235 vga_txtdraw(scr_stat *scp, int from, int count, int flip)
 236 {
 237         vm_offset_t p;
 238         int c;
 239         int a;
 240
 241         if (from + count > scp->xsize*scp->ysize)
 242                 count = scp->xsize*scp->ysize - from;
 243
 244         if (flip) {
 245                 for (p = sc_vtb_pointer(&scp->scr, from); count-- > 0; ++from) {
 246                         c = sc_vtb_getc(&scp->vtb, from);
 247                         a = sc_vtb_geta(&scp->vtb, from);
 248                         a = (a & 0x8800) | ((a & 0x7000) >> 4)
 249                                 | ((a & 0x0700) << 4);
 250                         p = sc_vtb_putchar(&scp->scr, p, c, a);
 251                 }
 252         } else {
 253                 sc_vtb_copy(&scp->vtb, from, &scp->scr, from, count);
 254         }
 255 }
 256
 257 static void
 258 vga_txtcursor_shape(scr_stat *scp, int base, int height, int blink)
 259 {
 260         if (base < 0 || base >= scp->font_size)
 261                 return;
 262         /* the caller may set height <= 0 in order to disable the cursor */
 263 #if 0
 264         scp->cursor_base = base;
 265         scp->cursor_height = height;
 266 #endif
 267         (*vidsw[scp->sc->adapter]->set_hw_cursor_shape)(scp->sc->adp,
 268                                                         base, height,
 269                                                         scp->font_size, blink);
 270 }
 271
 272 static void
 273 draw_txtcharcursor(scr_stat *scp, int at, u_short c, u_short a, int flip)
 274 {
 275         sc_softc_t *sc;
 276
 277         sc = scp->sc;
 278         scp->cursor_saveunder_char = c;
 279         scp->cursor_saveunder_attr = a;
 280
 281 #ifndef SC_NO_FONT_LOADING
 282         if (sc->flags & SC_CHAR_CURSOR) {
 283                 unsigned char *font;
 284                 int h;
 285                 int i;
 286
 287                 if (scp->font_size < 14) {
 288                         font = sc->font_8;
 289                         h = 8;
 290                 } else if (scp->font_size >= 16) {
 291                         font = sc->font_16;
 292                         h = 16;
 293                 } else {
 294                         font = sc->font_14;
 295                         h = 14;
 296                 }
 297                 if (scp->cursor_base >= h)
 298                         return;
 299                 if (flip)
 300                         a = (a & 0x8800)
 301                                 | ((a & 0x7000) >> 4) | ((a & 0x0700) << 4);
 302                 bcopy(font + c*h, font + sc->cursor_char*h, h);
 303                 font = font + sc->cursor_char*h;
 304                 for (i = imax(h - scp->cursor_base - scp->cursor_height, 0);
 305                         i < h - scp->cursor_base; ++i) {
 306                         font[i] ^= 0xff;
 307                 }
 308                 sc->font_loading_in_progress = TRUE;
 309                 /* XXX */
 310                 (*vidsw[sc->adapter]->load_font)(sc->adp, 0, h, font,
 311                                                  sc->cursor_char, 1);
 312                 sc->font_loading_in_progress = FALSE;
 313                 sc_vtb_putc(&scp->scr, at, sc->cursor_char, a);
 314         } else
 315 #endif /* SC_NO_FONT_LOADING */
 316         {
 317                 if ((a & 0x7000) == 0x7000) {
 318                         a &= 0x8f00;
 319                         if ((a & 0x0700) == 0)
 320                                 a |= 0x0700;
 321                 } else {
 322                         a |= 0x7000;
 323                         if ((a & 0x0700) == 0x0700)
 324                                 a &= 0xf000;
 325                 }
 326                 if (flip)
 327                         a = (a & 0x8800)
 328                                 | ((a & 0x7000) >> 4) | ((a & 0x0700) << 4);
 329                 sc_vtb_putc(&scp->scr, at, c, a);
 330         }
 331 }
 332
 333 static void
 334 vga_txtcursor(scr_stat *scp, int at, int blink, int on, int flip)
 335 {
 336         video_adapter_t *adp;
 337         int cursor_attr;
 338
 339         if (scp->cursor_height <= 0)    /* the text cursor is disabled */
 340                 return;
 341
 342         adp = scp->sc->adp;
 343         if (blink) {
 344                 scp->status |= VR_CURSOR_BLINK;
 345                 if (on) {
 346                         scp->status |= VR_CURSOR_ON;
 347                         (*vidsw[adp->va_index]->set_hw_cursor)(adp,
 348                                                                at%scp->xsize,
 349                                                                at/scp->xsize);
 350                 } else {
 351                         if (scp->status & VR_CURSOR_ON)
 352                                 (*vidsw[adp->va_index]->set_hw_cursor)(adp,
 353                                                                        -1, -1);
 354                         scp->status &= ~VR_CURSOR_ON;
 355                 }
 356         } else {
 357                 scp->status &= ~VR_CURSOR_BLINK;
 358                 if (on) {
 359                         scp->status |= VR_CURSOR_ON;
 360                         draw_txtcharcursor(scp, at,
 361                                            sc_vtb_getc(&scp->scr, at),
 362                                            sc_vtb_geta(&scp->scr, at),
 363                                            flip);
 364                 } else {
 365                         cursor_attr = scp->cursor_saveunder_attr;
 366                         if (flip)
 367                                 cursor_attr = (cursor_attr & 0x8800)
 368                                         | ((cursor_attr & 0x7000) >> 4)
 369                                         | ((cursor_attr & 0x0700) << 4);
 370                         if (scp->status & VR_CURSOR_ON)
 371                                 sc_vtb_putc(&scp->scr, at,
 372                                             scp->cursor_saveunder_char,
 373                                             cursor_attr);
 374                         scp->status &= ~VR_CURSOR_ON;
 375                 }
 376         }
 377 }
 378
 379 static void
 380 vga_txtblink(scr_stat *scp, int at, int flip)
 381 {
 382 }
 383
 384 #ifndef SC_NO_CUTPASTE
 385
 386 static void
 387 draw_txtmouse(scr_stat *scp, int x, int y)
 388 {
 389 #ifndef SC_ALT_MOUSE_IMAGE
 390     if (ISMOUSEAVAIL(scp->sc->adp->va_flags)) {
 391         u_char font_buf[128];
 392         u_short cursor[32];
 393         u_char c;
 394         int pos;
 395         int xoffset, yoffset;
 396         int crtc_addr;
 397         int i;
 398
 399         /* prepare mousepointer char's bitmaps */
 400         pos = (y/scp->font_size - scp->yoff)*scp->xsize + x/8 - scp->xoff;
 401         bcopy(scp->font + sc_vtb_getc(&scp->scr, pos)*scp->font_size,
 402               &font_buf[0], scp->font_size);
 403         bcopy(scp->font + sc_vtb_getc(&scp->scr, pos + 1)*scp->font_size,
 404               &font_buf[32], scp->font_size);
 405         bcopy(scp->font
 406                  + sc_vtb_getc(&scp->scr, pos + scp->xsize)*scp->font_size,
 407               &font_buf[64], scp->font_size);
 408         bcopy(scp->font
 409                  + sc_vtb_getc(&scp->scr, pos + scp->xsize + 1)*scp->font_size,
 410               &font_buf[96], scp->font_size);
 411         for (i = 0; i < scp->font_size; ++i) {
 412                 cursor[i] = font_buf[i]<<8 | font_buf[i+32];
 413                 cursor[i + scp->font_size] = font_buf[i+64]<<8 | font_buf[i+96];
 414         }
 415
 416         /* now and-or in the mousepointer image */
 417         xoffset = x%8;
 418         yoffset = y%scp->font_size;
 419         for (i = 0; i < 16; ++i) {
 420                 cursor[i + yoffset] =
 421                         (cursor[i + yoffset] & ~(mouse_and_mask[i] >> xoffset))
 422                         | (mouse_or_mask[i] >> xoffset);
 423         }
 424         for (i = 0; i < scp->font_size; ++i) {
 425                 font_buf[i] = (cursor[i] & 0xff00) >> 8;
 426                 font_buf[i + 32] = cursor[i] & 0xff;
 427                 font_buf[i + 64] = (cursor[i + scp->font_size] & 0xff00) >> 8;
 428                 font_buf[i + 96] = cursor[i + scp->font_size] & 0xff;
 429         }
 430
 431 #if 1
 432         /* wait for vertical retrace to avoid jitter on some videocards */
 433         crtc_addr = scp->sc->adp->va_crtc_addr;
 434         while (!(inb(crtc_addr + 6) & 0x08)) /* idle */ ;
 435 #endif
 436         c = scp->sc->mouse_char;
 437         (*vidsw[scp->sc->adapter]->load_font)(scp->sc->adp, 0, 32, font_buf,
 438                                               c, 4);
 439
 440         sc_vtb_putc(&scp->scr, pos, c, sc_vtb_geta(&scp->scr, pos));
 441         /* FIXME: may be out of range! */
 442         sc_vtb_putc(&scp->scr, pos + scp->xsize, c + 2,
 443                     sc_vtb_geta(&scp->scr, pos + scp->xsize));
 444         if (x < (scp->xsize - 1)*8) {
 445                 sc_vtb_putc(&scp->scr, pos + 1, c + 1,
 446                             sc_vtb_geta(&scp->scr, pos + 1));
 447                 sc_vtb_putc(&scp->scr, pos + scp->xsize + 1, c + 3,
 448                             sc_vtb_geta(&scp->scr, pos + scp->xsize + 1));
 449         }
 450     } else
 451 #endif /* SC_ALT_MOUSE_IMAGE */
 452     {
 453         /* Red, magenta and brown are mapped to green to to keep it readable */
 454         static const int col_conv[16] = {
 455                 6, 6, 6, 6, 2, 2, 2, 6, 14, 14, 14, 14, 10, 10, 10, 14
 456         };
 457         int pos;
 458         int color;
 459         int a;
 460
 461         pos = (y/scp->font_size - scp->yoff)*scp->xsize + x/8 - scp->xoff;
 462         a = sc_vtb_geta(&scp->scr, pos);
 463         if (scp->sc->adp->va_flags & V_ADP_COLOR)
 464                 color = (col_conv[(a & 0xf000) >> 12] << 12)
 465                         | ((a & 0x0f00) | 0x0800);
 466         else
 467                 color = ((a & 0xf000) >> 4) | ((a & 0x0f00) << 4);
 468         sc_vtb_putc(&scp->scr, pos, sc_vtb_getc(&scp->scr, pos), color);
 469     }
 470 }
 471
 472 static void
 473 remove_txtmouse(scr_stat *scp, int x, int y)
 474 {
 475 }
 476
 477 static void
 478 vga_txtmouse(scr_stat *scp, int x, int y, int on)
 479 {
 480         if (on)
 481                 draw_txtmouse(scp, x, y);
 482         else
 483                 remove_txtmouse(scp, x, y);
 484 }
 485
 486 #endif /* SC_NO_CUTPASTE */
 487
 488 #ifdef SC_PIXEL_MODE
 489
 490 /* pixel (raster text) mode renderer */
 491
 492 static void
 493 vga_rndrinit(scr_stat *scp)
 494 {
 495         if (scp->sc->adp->va_info.vi_mem_model == V_INFO_MM_PLANAR) {
 496                 scp->rndr->clear = vga_pxlclear_planar;
 497                 scp->rndr->draw_border = vga_pxlborder_planar;
 498                 scp->rndr->draw = vga_vgadraw_planar;
 499                 scp->rndr->draw_cursor = vga_pxlcursor_planar;
 500                 scp->rndr->blink_cursor = vga_pxlblink_planar;
 501                 scp->rndr->draw_mouse = vga_pxlmouse_planar;
 502         } else if (scp->sc->adp->va_info.vi_mem_model == V_INFO_MM_DIRECT) {
 503                 scp->rndr->clear = vga_pxlclear_direct;
 504                 scp->rndr->draw_border = vga_pxlborder_direct;
 505                 scp->rndr->draw = vga_vgadraw_direct;
 506                 scp->rndr->draw_cursor = vga_pxlcursor_direct;
 507                 scp->rndr->blink_cursor = vga_pxlblink_direct;
 508                 scp->rndr->draw_mouse = vga_pxlmouse_direct;
 509         }
 510 }
 511
 512 static void
 513 vga_pxlclear_direct(scr_stat *scp, int c, int attr)
 514 {
 515         vm_offset_t p;
 516         int line_width;
 517         int pixel_size;
 518         int lines;
 519         int i;
 520
 521         line_width = scp->sc->adp->va_line_width;
 522         pixel_size = scp->sc->adp->va_info.vi_pixel_size;
 523         lines = scp->ysize * scp->font_size;
 524         p = scp->sc->adp->va_window +
 525             line_width * scp->yoff * scp->font_size +
 526             scp->xoff * 8 * pixel_size;
 527
 528         for (i = 0; i < lines; ++i) {
 529                 bzero_io((void *)p, scp->xsize * 8 * pixel_size);
 530                 p += line_width;
 531         }
 532 }
 533
 534 static void
 535 vga_pxlclear_planar(scr_stat *scp, int c, int attr)
 536 {
 537         vm_offset_t p;
 538         int line_width;
 539         int lines;
 540         int i;
 541
 542         /* XXX: we are just filling the screen with the background color... */
 543         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
 544         outw(GDCIDX, 0x0003);           /* data rotate/function select */
 545         outw(GDCIDX, 0x0f01);           /* set/reset enable */
 546         outw(GDCIDX, 0xff08);           /* bit mask */
 547         outw(GDCIDX, ((attr & 0xf000) >> 4) | 0x00); /* set/reset */
 548         line_width = scp->sc->adp->va_line_width;
 549         lines = scp->ysize*scp->font_size;
 550         p = scp->sc->adp->va_window + line_width*scp->yoff*scp->font_size
 551                 + scp->xoff;
 552         for (i = 0; i < lines; ++i) {
 553                 bzero_io((void *)p, scp->xsize);
 554                 p += line_width;
 555         }
 556         outw(GDCIDX, 0x0000);           /* set/reset */
 557         outw(GDCIDX, 0x0001);           /* set/reset enable */
 558 }
 559
 560 static void
 561 vga_pxlborder_direct(scr_stat *scp, int color)
 562 {
 563         vm_offset_t s;
 564         vm_offset_t e;
 565         vm_offset_t f;
 566         int line_width;
 567         int pixel_size;
 568         int x;
 569         int y;
 570         int i;
 571
 572         line_width = scp->sc->adp->va_line_width;
 573         pixel_size = scp->sc->adp->va_info.vi_pixel_size;
 574
 575         if (scp->yoff > 0) {
 576                 s = scp->sc->adp->va_window;
 577                 e = s + line_width * scp->yoff * scp->font_size;
 578
 579                 for (f = s; f < e; f += pixel_size)
 580                         vga_drawpxl(f, color);
 581         }
 582
 583         y = (scp->yoff + scp->ysize) * scp->font_size;
 584
 585         if (scp->ypixel > y) {
 586                 s = scp->sc->adp->va_window + line_width * y;
 587                 e = s + line_width * (scp->ypixel - y);
 588
 589                 for (f = s; f < e; f += pixel_size)
 590                         vga_drawpxl(f, color);
 591         }
 592
 593         y = scp->yoff * scp->font_size;
 594         x = scp->xpixel / 8 - scp->xoff - scp->xsize;
 595
 596         for (i = 0; i < scp->ysize * scp->font_size; ++i) {
 597                 if (scp->xoff > 0) {
 598                         s = scp->sc->adp->va_window + line_width * (y + i);
 599                         e = s + scp->xoff * 8 * pixel_size;
 600
 601                         for (f = s; f < e; f += pixel_size)
 602                                 vga_drawpxl(f, color);
 603                 }
 604
 605                 if (x > 0) {
 606                         s = scp->sc->adp->va_window + line_width * (y + i) +
 607                             scp->xoff * 8 * pixel_size +
 608                             scp->xsize * 8 * pixel_size;
 609                         e = s + x * 8 * pixel_size;
 610
 611                         for (f = s; f < e; f += pixel_size)
 612                                 vga_drawpxl(f, color);
 613                 }
 614         }
 615 }
 616
 617 static void
 618 vga_pxlborder_planar(scr_stat *scp, int color)
 619 {
 620         vm_offset_t p;
 621         int line_width;
 622         int x;
 623         int y;
 624         int i;
 625
 626         (*vidsw[scp->sc->adapter]->set_border)(scp->sc->adp, color);
 627
 628         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
 629         outw(GDCIDX, 0x0003);           /* data rotate/function select */
 630         outw(GDCIDX, 0x0f01);           /* set/reset enable */
 631         outw(GDCIDX, 0xff08);           /* bit mask */
 632         outw(GDCIDX, (color << 8) | 0x00);      /* set/reset */
 633         line_width = scp->sc->adp->va_line_width;
 634         p = scp->sc->adp->va_window;
 635         if (scp->yoff > 0)
 636                 bzero_io((void *)p, line_width*scp->yoff*scp->font_size);
 637         y = (scp->yoff + scp->ysize)*scp->font_size;
 638         if (scp->ypixel > y)
 639                 bzero_io((void *)(p + line_width*y), line_width*(scp->ypixel - y));
 640         y = scp->yoff*scp->font_size;
 641         x = scp->xpixel/8 - scp->xoff - scp->xsize;
 642         for (i = 0; i < scp->ysize*scp->font_size; ++i) {
 643                 if (scp->xoff > 0)
 644                         bzero_io((void *)(p + line_width*(y + i)), scp->xoff);
 645                 if (x > 0)
 646                         bzero_io((void *)(p + line_width*(y + i)
 647                                      + scp->xoff + scp->xsize), x);
 648         }
 649         outw(GDCIDX, 0x0000);           /* set/reset */
 650         outw(GDCIDX, 0x0001);           /* set/reset enable */
 651 }
 652
 653 static void
 654 vga_egadraw(scr_stat *scp, int from, int count, int flip)
 655 {
 656         vm_offset_t d;
 657         vm_offset_t e;
 658         u_char *f;
 659         u_short bg;
 660         u_short col1, col2;
 661         int line_width;
 662         int i, j;
 663         int a;
 664         u_char c;
 665
 666         line_width = scp->sc->adp->va_line_width;
 667
 668         d = VIDEO_MEMORY_POS(scp, from, 1);
 669
 670         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
 671         outw(GDCIDX, 0x0003);           /* data rotate/function select */
 672         outw(GDCIDX, 0x0f01);           /* set/reset enable */
 673         bg = -1;
 674         if (from + count > scp->xsize*scp->ysize)
 675                 count = scp->xsize*scp->ysize - from;
 676         for (i = from; count-- > 0; ++i) {
 677                 a = sc_vtb_geta(&scp->vtb, i);
 678                 if (flip) {
 679                         col1 = ((a & 0x7000) >> 4) | (a & 0x0800);
 680                         col2 = ((a & 0x8000) >> 4) | (a & 0x0700);
 681                 } else {
 682                         col1 = (a & 0x0f00);
 683                         col2 = (a & 0xf000) >> 4;
 684                 }
 685                 /* set background color in EGA/VGA latch */
 686                 if (bg != col2) {
 687                         bg = col2;
 688                         outw(GDCIDX, bg | 0x00);        /* set/reset */
 689                         outw(GDCIDX, 0xff08);           /* bit mask */
 690                         writeb(d, 0);
 691                         c = readb(d);   /* set bg color in the latch */
 692                 }
 693                 /* foreground color */
 694                 outw(GDCIDX, col1 | 0x00);              /* set/reset */
 695                 e = d;
 696                 f = &(scp->font[sc_vtb_getc(&scp->vtb, i)*scp->font_size]);
 697                 for (j = 0; j < scp->font_size; ++j, ++f) {
 698                         outw(GDCIDX, (*f << 8) | 0x08); /* bit mask */
 699                         writeb(e, 0);
 700                         e += line_width;
 701                 }
 702                 ++d;
 703                 if ((i % scp->xsize) == scp->xsize - 1)
 704                         d += scp->xoff*2
 705                                  + (scp->font_size - 1)*line_width;
 706         }
 707         outw(GDCIDX, 0x0000);           /* set/reset */
 708         outw(GDCIDX, 0x0001);           /* set/reset enable */
 709         outw(GDCIDX, 0xff08);           /* bit mask */
 710 }
 711
 712 static void
 713 vga_vgadraw_direct(scr_stat *scp, int from, int count, int flip)
 714 {
 715         vm_offset_t d = 0;
 716         vm_offset_t e;
 717         u_char *f;
 718         u_short col1, col2, color;
 719         int line_width, pixel_size;
 720         int i, j, k;
 721         int a;
 722
 723         line_width = scp->sc->adp->va_line_width;
 724         pixel_size = scp->sc->adp->va_info.vi_pixel_size;
 725
 726         d = VIDEO_MEMORY_POS(scp, from, 8 * pixel_size);
 727
 728         if (from + count > scp->xsize * scp->ysize)
 729                 count = scp->xsize * scp->ysize - from;
 730
 731         for (i = from; count-- > 0; ++i) {
 732                 a = sc_vtb_geta(&scp->vtb, i);
 733
 734                 if (flip) {
 735                         col1 = (((a & 0x7000) >> 4) | (a & 0x0800)) >> 8;
 736                         col2 = (((a & 0x8000) >> 4) | (a & 0x0700)) >> 8;
 737                 } else {
 738                         col1 = (a & 0x0f00) >> 8;
 739                         col2 = (a & 0xf000) >> 12;
 740                 }
 741
 742                 e = d;
 743                 f = &(scp->font[sc_vtb_getc(&scp->vtb, i) * scp->font_size]);
 744
 745                 for (j = 0; j < scp->font_size; ++j, ++f) {
 746                         for (k = 0; k < 8; ++k) {
 747                                 color = *f & (1 << (7 - k)) ? col1 : col2;
 748                                 vga_drawpxl(e + pixel_size * k, color);
 749                         }
 750
 751                         e += line_width;
 752                 }
 753
 754                 d += 8 * pixel_size;
 755
 756                 if ((i % scp->xsize) == scp->xsize - 1)
 757                         d += scp->xoff * 16 * pixel_size +
 758                              (scp->font_size - 1) * line_width;
 759         }
 760 }
 761
 762 static void
 763 vga_vgadraw_planar(scr_stat *scp, int from, int count, int flip)
 764 {
 765         vm_offset_t d;
 766         vm_offset_t e;
 767         u_char *f;
 768         u_short bg;
 769         u_short col1, col2;
 770         int line_width;
 771         int i, j;
 772         int a;
 773         u_char c;
 774
 775         d = VIDEO_MEMORY_POS(scp, from, 1);
 776
 777         line_width = scp->sc->adp->va_line_width;
 778
 779         outw(GDCIDX, 0x0305);           /* read mode 0, write mode 3 */
 780         outw(GDCIDX, 0x0003);           /* data rotate/function select */
 781         outw(GDCIDX, 0x0f01);           /* set/reset enable */
 782         outw(GDCIDX, 0xff08);           /* bit mask */
 783         bg = -1;
 784         if (from + count > scp->xsize*scp->ysize)
 785                 count = scp->xsize*scp->ysize - from;
 786         for (i = from; count-- > 0; ++i) {
 787                 a = sc_vtb_geta(&scp->vtb, i);
 788                 if (flip) {
 789                         col1 = ((a & 0x7000) >> 4) | (a & 0x0800);
 790                         col2 = ((a & 0x8000) >> 4) | (a & 0x0700);
 791                 } else {
 792                         col1 = (a & 0x0f00);
 793                         col2 = (a & 0xf000) >> 4;
 794                 }
 795                 /* set background color in EGA/VGA latch */
 796                 if (bg != col2) {
 797                         bg = col2;
 798                         outw(GDCIDX, 0x0005);   /* read mode 0, write mode 0 */
 799                         outw(GDCIDX, bg | 0x00); /* set/reset */
 800                         writeb(d, 0);
 801                         c = readb(d);           /* set bg color in the latch */
 802                         outw(GDCIDX, 0x0305);   /* read mode 0, write mode 3 */
 803                 }
 804                 /* foreground color */
 805                 outw(GDCIDX, col1 | 0x00);      /* set/reset */
 806                 e = d;
 807                 f = &(scp->font[sc_vtb_getc(&scp->vtb, i)*scp->font_size]);
 808                 for (j = 0; j < scp->font_size; ++j, ++f) {
 809                         writeb(e, *f);
 810                         e += line_width;
 811                 }
 812                 ++d;
 813                 if ((i % scp->xsize) == scp->xsize - 1)
 814                         d += scp->xoff*2
 815                                  + (scp->font_size - 1)*line_width;
 816         }
 817         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
 818         outw(GDCIDX, 0x0000);           /* set/reset */
 819         outw(GDCIDX, 0x0001);           /* set/reset enable */
 820 }
 821
 822 static void
 823 vga_pxlcursor_shape(scr_stat *scp, int base, int height, int blink)
 824 {
 825         if (base < 0 || base >= scp->font_size)
 826                 return;
 827         /* the caller may set height <= 0 in order to disable the cursor */
 828 #if 0
 829         scp->cursor_base = base;
 830         scp->cursor_height = height;
 831 #endif
 832 }
 833
 834 static void
 835 draw_pxlcursor_direct(scr_stat *scp, int at, int on, int flip)
 836 {
 837         vm_offset_t d = 0;
 838         u_char *f;
 839         int line_width, pixel_size;
 840         int height;
 841         int col1, col2, color;
 842         int a;
 843         int i, j;
 844
 845         line_width = scp->sc->adp->va_line_width;
 846         pixel_size = scp->sc->adp->va_info.vi_pixel_size;
 847
 848         d = VIDEO_MEMORY_POS(scp, at, 8 * pixel_size) +
 849             (scp->font_size - scp->cursor_base - 1) * line_width;
 850
 851         a = sc_vtb_geta(&scp->vtb, at);
 852
 853         if (flip) {
 854                 col1 = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
 855                 col2 = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
 856         } else {
 857                 col1 = ((on) ? ((a & 0xf000) >> 4) : (a & 0x0f00)) >> 8;
 858                 col2 = ((on) ? (a & 0x0f00) : ((a & 0xf000) >> 4)) >> 8;
 859         }
 860
 861         f = &(scp->font[sc_vtb_getc(&scp->vtb, at) * scp->font_size +
 862               scp->font_size - scp->cursor_base - 1]);
 863
 864         height = imin(scp->cursor_height, scp->font_size);
 865
 866         for (i = 0; i < height; ++i, --f) {
 867                 for (j = 0; j < 8; ++j) {
 868                         color = *f & (1 << (7 - j)) ? col1 : col2;
 869                         vga_drawpxl(d + pixel_size * j, color);
 870                 }
 871
 872                 d -= line_width;
 873         }
 874 }
 875
 876 static void
 877 draw_pxlcursor_planar(scr_stat *scp, int at, int on, int flip)
 878 {
 879         vm_offset_t d;
 880         u_char *f;
 881         int line_width;
 882         int height;
 883         int col;
 884         int a;
 885         int i;
 886         u_char c;
 887
 888         line_width = scp->sc->adp->va_line_width;
 889
 890         d = VIDEO_MEMORY_POS(scp, at, 1) +
 891             (scp->font_size - scp->cursor_base - 1) * line_width;
 892
 893         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
 894         outw(GDCIDX, 0x0003);           /* data rotate/function select */
 895         outw(GDCIDX, 0x0f01);           /* set/reset enable */
 896         /* set background color in EGA/VGA latch */
 897         a = sc_vtb_geta(&scp->vtb, at);
 898         if (flip)
 899                 col = (on) ? ((a & 0xf000) >> 4) : (a & 0x0f00);
 900         else
 901                 col = (on) ? (a & 0x0f00) : ((a & 0xf000) >> 4);
 902         outw(GDCIDX, col | 0x00);       /* set/reset */
 903         outw(GDCIDX, 0xff08);           /* bit mask */
 904         writeb(d, 0);
 905         c = readb(d);                   /* set bg color in the latch */
 906         /* foreground color */
 907         if (flip)
 908                 col = (on) ? (a & 0x0f00) : ((a & 0xf000) >> 4);
 909         else
 910                 col = (on) ? ((a & 0xf000) >> 4) : (a & 0x0f00);
 911         outw(GDCIDX, col | 0x00);       /* set/reset */
 912         f = &(scp->font[sc_vtb_getc(&scp->vtb, at)*scp->font_size
 913                 + scp->font_size - scp->cursor_base - 1]);
 914         height = imin(scp->cursor_height, scp->font_size);
 915         for (i = 0; i < height; ++i, --f) {
 916                 outw(GDCIDX, (*f << 8) | 0x08); /* bit mask */
 917                 writeb(d, 0);
 918                 d -= line_width;
 919         }
 920         outw(GDCIDX, 0x0000);           /* set/reset */
 921         outw(GDCIDX, 0x0001);           /* set/reset enable */
 922         outw(GDCIDX, 0xff08);           /* bit mask */
 923 }
 924
 925 static int pxlblinkrate = 0;
 926
 927 static void
 928 vga_pxlcursor_direct(scr_stat *scp, int at, int blink, int on, int flip)
 929 {
 930         if (scp->cursor_height <= 0)    /* the text cursor is disabled */
 931                 return;
 932
 933         if (on) {
 934                 if (!blink) {
 935                         scp->status |= VR_CURSOR_ON;
 936                         draw_pxlcursor_direct(scp, at, on, flip);
 937                 } else if (++pxlblinkrate & 4) {
 938                         pxlblinkrate = 0;
 939                         scp->status ^= VR_CURSOR_ON;
 940                         draw_pxlcursor_direct(scp, at,
 941                                               scp->status & VR_CURSOR_ON,
 942                                               flip);
 943                 }
 944         } else {
 945                 if (scp->status & VR_CURSOR_ON)
 946                         draw_pxlcursor_direct(scp, at, on, flip);
 947                 scp->status &= ~VR_CURSOR_ON;
 948         }
 949         if (blink)
 950                 scp->status |= VR_CURSOR_BLINK;
 951         else
 952                 scp->status &= ~VR_CURSOR_BLINK;
 953 }
 954
 955 static void
 956 vga_pxlcursor_planar(scr_stat *scp, int at, int blink, int on, int flip)
 957 {
 958         if (scp->cursor_height <= 0)    /* the text cursor is disabled */
 959                 return;
 960
 961         if (on) {
 962                 if (!blink) {
 963                         scp->status |= VR_CURSOR_ON;
 964                         draw_pxlcursor_planar(scp, at, on, flip);
 965                 } else if (++pxlblinkrate & 4) {
 966                         pxlblinkrate = 0;
 967                         scp->status ^= VR_CURSOR_ON;
 968                         draw_pxlcursor_planar(scp, at,
 969                                               scp->status & VR_CURSOR_ON,
 970                                               flip);
 971                 }
 972         } else {
 973                 if (scp->status & VR_CURSOR_ON)
 974                         draw_pxlcursor_planar(scp, at, on, flip);
 975                 scp->status &= ~VR_CURSOR_ON;
 976         }
 977         if (blink)
 978                 scp->status |= VR_CURSOR_BLINK;
 979         else
 980                 scp->status &= ~VR_CURSOR_BLINK;
 981 }
 982
 983 static void
 984 vga_pxlblink_direct(scr_stat *scp, int at, int flip)
 985 {
 986         if (!(scp->status & VR_CURSOR_BLINK))
 987                 return;
 988         if (!(++pxlblinkrate & 4))
 989                 return;
 990         pxlblinkrate = 0;
 991         scp->status ^= VR_CURSOR_ON;
 992         draw_pxlcursor_direct(scp, at, scp->status & VR_CURSOR_ON, flip);
 993 }
 994
 995 static void
 996 vga_pxlblink_planar(scr_stat *scp, int at, int flip)
 997 {
 998         if (!(scp->status & VR_CURSOR_BLINK))
 999                 return;
1000         if (!(++pxlblinkrate & 4))
1001                 return;
1002         pxlblinkrate = 0;
1003         scp->status ^= VR_CURSOR_ON;
1004         draw_pxlcursor_planar(scp, at, scp->status & VR_CURSOR_ON, flip);
1005 }
1006
1007 #ifndef SC_NO_CUTPASTE
1008
1009 static void
1010 draw_pxlmouse_planar(scr_stat *scp, int x, int y)
1011 {
1012         vm_offset_t p;
1013         int line_width;
1014         int xoff, yoff;
1015         int ymax;
1016         u_short m;
1017         int i, j;
1018
1019         line_width = scp->sc->adp->va_line_width;
1020         xoff = (x - scp->xoff*8)%8;
1021         yoff = y - (y/line_width)*line_width;
1022         ymax = imin(y + 16, scp->ypixel);
1023
1024         outw(GDCIDX, 0x0805);           /* read mode 1, write mode 0 */
1025         outw(GDCIDX, 0x0001);           /* set/reset enable */
1026         outw(GDCIDX, 0x0002);           /* color compare */
1027         outw(GDCIDX, 0x0007);           /* color don't care */
1028         outw(GDCIDX, 0xff08);           /* bit mask */
1029         outw(GDCIDX, 0x0803);           /* data rotate/function select (and) */
1030         p = scp->sc->adp->va_window + line_width*y + x/8;
1031         if (x < scp->xpixel - 8) {
1032                 for (i = y, j = 0; i < ymax; ++i, ++j) {
1033                         m = ~(mouse_and_mask[j] >> xoff);
1034 #ifdef __i386__
1035                         *(u_char *)p &= m >> 8;
1036                         *(u_char *)(p + 1) &= m;
1037 #elif defined(__alpha__)
1038                         writeb(p, readb(p) & (m >> 8));
1039                         writeb(p + 1, readb(p + 1) & (m >> 8));
1040 #endif
1041                         p += line_width;
1042                 }
1043         } else {
1044                 xoff += 8;
1045                 for (i = y, j = 0; i < ymax; ++i, ++j) {
1046                         m = ~(mouse_and_mask[j] >> xoff);
1047 #ifdef __i386__
1048                         *(u_char *)p &= m;
1049 #elif defined(__alpha__)
1050                         writeb(p, readb(p) & (m >> 8));
1051 #endif
1052                         p += line_width;
1053                 }
1054         }
1055         outw(GDCIDX, 0x1003);           /* data rotate/function select (or) */
1056         p = scp->sc->adp->va_window + line_width*y + x/8;
1057         if (x < scp->xpixel - 8) {
1058                 for (i = y, j = 0; i < ymax; ++i, ++j) {
1059                         m = mouse_or_mask[j] >> xoff;
1060 #ifdef __i386__
1061                         *(u_char *)p &= m >> 8;
1062                         *(u_char *)(p + 1) &= m;
1063 #elif defined(__alpha__)
1064                         writeb(p, readb(p) & (m >> 8));
1065                         writeb(p + 1, readb(p + 1) & (m >> 8));
1066 #endif
1067                         p += line_width;
1068                 }
1069         } else {
1070                 for (i = y, j = 0; i < ymax; ++i, ++j) {
1071                         m = mouse_or_mask[j] >> xoff;
1072 #ifdef __i386__
1073                         *(u_char *)p &= m;
1074 #elif defined(__alpha__)
1075                         writeb(p, readb(p) & (m >> 8));
1076 #endif
1077                         p += line_width;
1078                 }
1079         }
1080         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
1081         outw(GDCIDX, 0x0003);           /* data rotate/function select */
1082 }
1083
1084 static void
1085 remove_pxlmouse_planar(scr_stat *scp, int x, int y)
1086 {
1087         vm_offset_t p;
1088         int col, row;
1089         int pos;
1090         int line_width;
1091         int ymax;
1092         int i;
1093
1094         /* erase the mouse cursor image */
1095         col = x/8 - scp->xoff;
1096         row = y/scp->font_size - scp->yoff;
1097         pos = row*scp->xsize + col;
1098         i = (col < scp->xsize - 1) ? 2 : 1;
1099         (*scp->rndr->draw)(scp, pos, i, FALSE);
1100         if (row < scp->ysize - 1)
1101                 (*scp->rndr->draw)(scp, pos + scp->xsize, i, FALSE);
1102
1103         /* paint border if necessary */
1104         line_width = scp->sc->adp->va_line_width;
1105         outw(GDCIDX, 0x0005);           /* read mode 0, write mode 0 */
1106         outw(GDCIDX, 0x0003);           /* data rotate/function select */
1107         outw(GDCIDX, 0x0f01);           /* set/reset enable */
1108         outw(GDCIDX, 0xff08);           /* bit mask */
1109         outw(GDCIDX, (scp->border << 8) | 0x00);        /* set/reset */
1110         if (row == scp->ysize - 1) {
1111                 i = (scp->ysize + scp->yoff)*scp->font_size;
1112                 ymax = imin(i + scp->font_size, scp->ypixel);
1113                 p = scp->sc->adp->va_window + i*line_width + scp->xoff + col;
1114                 if (col < scp->xsize - 1) {
1115                         for (; i < ymax; ++i) {
1116                                 writeb(p, 0);
1117                                 writeb(p + 1, 0);
1118                                 p += line_width;
1119                         }
1120                 } else {
1121                         for (; i < ymax; ++i) {
1122                                 writeb(p, 0);
1123                                 p += line_width;
1124                         }
1125                 }
1126         }
1127         if ((col == scp->xsize - 1) && (scp->xoff > 0)) {
1128                 i = (row + scp->yoff)*scp->font_size;
1129                 ymax = imin(i + scp->font_size*2, scp->ypixel);
1130                 p = scp->sc->adp->va_window + i*line_width
1131                         + scp->xoff + scp->xsize;
1132                 for (; i < ymax; ++i) {
1133                         writeb(p, 0);
1134                         p += line_width;
1135                 }
1136         }
1137         outw(GDCIDX, 0x0000);           /* set/reset */
1138         outw(GDCIDX, 0x0001);           /* set/reset enable */
1139 }
1140
1141 static void
1142 vga_pxlmouse_direct(scr_stat *scp, int x, int y, int on)
1143 {
1144         vm_offset_t p;
1145         int line_width, pixel_size;
1146         int xend, yend;
1147         static int x_old = 0, xend_old = 0;
1148         static int y_old = 0, yend_old = 0;
1149         int i, j;
1150         uint32_t *u32;
1151         uint16_t *u16;
1152         int bpp;
1153
1154         if (!on)
1155                 return;
1156
1157         bpp = scp->sc->adp->va_info.vi_depth;
1158
1159         if ((bpp == 16) && (scp->sc->adp->va_info.vi_pixel_fsizes[1] == 5))
1160                 bpp = 15;
1161
1162         line_width = scp->sc->adp->va_line_width;
1163         pixel_size = scp->sc->adp->va_info.vi_pixel_size;
1164
1165         xend = imin(x + 16, scp->xpixel);
1166         yend = imin(y + 16, scp->ypixel);
1167
1168         p = scp->sc->adp->va_window + y_old * line_width + x_old * pixel_size;
1169
1170         for (i = 0; i < (yend_old - y_old); i++) {
1171                 for (j = (xend_old - x_old - 1); j >= 0; j--) {
1172                         switch (bpp) {
1173                         case 32:
1174                                 u32 = (uint32_t*)(p + j * pixel_size);
1175                                 writel(u32, mouse_buf32[i * 16 + j]);
1176                                 break;
1177                         case 16:
1178                                 /* FALLTHROUGH */
1179                         case 15:
1180                                 u16 = (uint16_t*)(p + j * pixel_size);
1181                                 writew(u16, mouse_buf16[i * 16 + j]);
1182                                 break;
1183                         }
1184                 }
1185
1186                 p += line_width;
1187         }
1188
1189         p = scp->sc->adp->va_window + y * line_width + x * pixel_size;
1190
1191         for (i = 0; i < (yend - y); i++) {
1192                 for (j = (xend - x - 1); j >= 0; j--) {
1193                         switch (bpp) {
1194                         case 32:
1195                                 u32 = (uint32_t*)(p + j * pixel_size);
1196                                 mouse_buf32[i * 16 + j] = *u32;
1197                                 if (mouse_or_mask[i] & (1 << (15 - j)))
1198                                         writel(u32, vga_palette32[15]);
1199                                 else if (mouse_and_mask[i] & (1 << (15 - j)))
1200                                         writel(u32, 0);
1201                                 break;
1202                         case 16:
1203                                 u16 = (uint16_t*)(p + j * pixel_size);
1204                                 mouse_buf16[i * 16 + j] = *u16;
1205                                 if (mouse_or_mask[i] & (1 << (15 - j)))
1206                                         writew(u16, vga_palette16[15]);
1207                                 else if (mouse_and_mask[i] & (1 << (15 - j)))
1208                                         writew(u16, 0);
1209                                 break;
1210                         case 15:
1211                                 u16 = (uint16_t*)(p  + j * pixel_size);
1212                                 mouse_buf16[i * 16 + j] = *u16;
1213                                 if (mouse_or_mask[i] & (1 << (15 - j)))
1214                                         writew(u16, vga_palette15[15]);
1215                                 else if (mouse_and_mask[i] & (1 << (15 - j)))
1216                                         writew(u16, 0);
1217                                 break;
1218                         }
1219                 }
1220
1221                 p += line_width;
1222         }
1223
1224         x_old = x;
1225         y_old = y;
1226         xend_old = xend;
1227         yend_old = yend;
1228 }
1229
1230 static void
1231 vga_pxlmouse_planar(scr_stat *scp, int x, int y, int on)
1232 {
1233         if (on)
1234                 draw_pxlmouse_planar(scp, x, y);
1235         else
1236                 remove_pxlmouse_planar(scp, x, y);
1237 }
1238
1239 #endif /* SC_NO_CUTPASTE */
1240 #endif /* SC_PIXEL_MODE */
1241
1242 #ifndef SC_NO_MODE_CHANGE
1243
1244 /* graphics mode renderer */
1245
1246 static void
1247 vga_grborder(scr_stat *scp, int color)
1248 {
1249         (*vidsw[scp->sc->adapter]->set_border)(scp->sc->adp, color);
1250 }
1251
1252 #endif