lib/libvgl/simple.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-3-Clause
   3  *
   4  * Copyright (c) 1991-1997 Søren Schmidt
   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
  12  *    in this position and unchanged.
  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  * 3. The name of the author may not be used to endorse or promote products
  17  *    derived from this software without specific prior written permission
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  20  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  21  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  22  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  23  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  24  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  28  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <signal.h>
  35 #include <sys/fbio.h>
  36 #include <sys/kbio.h>
  37 #include <sys/endian.h>
  38 #include "vgl.h"
  39
  40 static int VGLBlank;
  41 static byte VGLBorderColor;
  42 static byte VGLSavePaletteRed[256];
  43 static byte VGLSavePaletteGreen[256];
  44 static byte VGLSavePaletteBlue[256];
  45
  46 #define ABS(a)          (((a)<0) ? -(a) : (a))
  47 #define SGN(a)          (((a)<0) ? -1 : 1)
  48 #define min(x, y)       (((x) < (y)) ? (x) : (y))
  49 #define max(x, y)       (((x) > (y)) ? (x) : (y))
  50
  51 void
  52 VGLSetXY(VGLBitmap *object, int x, int y, u_long color)
  53 {
  54   int offset, soffset, undermouse;
  55
  56   VGLCheckSwitch();
  57   if (x>=0 && x<object->VXsize && y>=0 && y<object->VYsize) {
  58     if (object == VGLDisplay) {
  59       undermouse = VGLMouseFreezeXY(x, y);
  60       VGLSetXY(&VGLVDisplay, x, y, color);
  61     } else if (object->Type != MEMBUF)
  62       return;           /* invalid */
  63     else
  64       undermouse = 0;
  65     if (!undermouse) {
  66       offset = (y * object->VXsize + x) * object->PixelBytes;
  67       switch (object->Type) {
  68       case VIDBUF8S:
  69       case VIDBUF16S:
  70       case VIDBUF32S:
  71         offset = VGLSetSegment(offset);
  72         /* FALLTHROUGH */
  73       case MEMBUF:
  74       case VIDBUF8:
  75       case VIDBUF16:
  76       case VIDBUF24:
  77       case VIDBUF32:
  78         color = htole32(color);
  79         switch (object->PixelBytes) {
  80         case 1:
  81           memcpy(&object->Bitmap[offset], &color, 1);
  82           break;
  83         case 2:
  84           memcpy(&object->Bitmap[offset], &color, 2);
  85           break;
  86         case 3:
  87           memcpy(&object->Bitmap[offset], &color, 3);
  88           break;
  89         case 4:
  90           memcpy(&object->Bitmap[offset], &color, 4);
  91           break;
  92         }
  93         break;
  94       case VIDBUF24S:
  95         soffset = VGLSetSegment(offset);
  96         color = htole32(color);
  97         switch (VGLAdpInfo.va_window_size - soffset) {
  98         case 1:
  99           memcpy(&object->Bitmap[soffset], &color, 1);
 100           soffset = VGLSetSegment(offset + 1);
 101           memcpy(&object->Bitmap[soffset], (byte *)&color + 1, 2);
 102           break;
 103         case 2:
 104           memcpy(&object->Bitmap[soffset], &color, 2);
 105           soffset = VGLSetSegment(offset + 2);
 106           memcpy(&object->Bitmap[soffset], (byte *)&color + 2, 1);
 107           break;
 108         default:
 109           memcpy(&object->Bitmap[soffset], &color, 3);
 110           break;
 111         }
 112         break;
 113       case VIDBUF8X:
 114         outb(0x3c4, 0x02);
 115         outb(0x3c5, 0x01 << (x&0x3));
 116         object->Bitmap[(unsigned)(VGLAdpInfo.va_line_width*y)+(x/4)] = ((byte)color);
 117         break;
 118       case VIDBUF4S:
 119         offset = VGLSetSegment(y*VGLAdpInfo.va_line_width + x/8);
 120         goto set_planar;
 121       case VIDBUF4:
 122         offset = y*VGLAdpInfo.va_line_width + x/8;
 123 set_planar:
 124         outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 125         outb(0x3ce, 0x00); outb(0x3cf, (byte)color & 0x0f);     /* set/reset */
 126         outb(0x3ce, 0x01); outb(0x3cf, 0x0f);           /* set/reset enable */
 127         outb(0x3ce, 0x08); outb(0x3cf, 0x80 >> (x%8));  /* bit mask */
 128         object->Bitmap[offset] |= (byte)color;
 129       }
 130     }
 131     if (object == VGLDisplay)
 132       VGLMouseUnFreeze();
 133   }
 134 }
 135
 136 u_long
 137 VGLGetXY(VGLBitmap *object, int x, int y)
 138 {
 139   u_long color;
 140   int offset;
 141
 142   VGLCheckSwitch();
 143   if (x<0 || x>=object->VXsize || y<0 || y>=object->VYsize)
 144     return 0;
 145   if (object == VGLDisplay)
 146     object = &VGLVDisplay;
 147   else if (object->Type != MEMBUF)
 148     return 0;           /* invalid */
 149   offset = (y * object->VXsize + x) * object->PixelBytes;
 150   switch (object->PixelBytes) {
 151   case 1:
 152     memcpy(&color, &object->Bitmap[offset], 1);
 153     return le32toh(color) & 0xff;
 154   case 2:
 155     memcpy(&color, &object->Bitmap[offset], 2);
 156     return le32toh(color) & 0xffff;
 157   case 3:
 158     memcpy(&color, &object->Bitmap[offset], 3);
 159     return le32toh(color) & 0xffffff;
 160   case 4:
 161     memcpy(&color, &object->Bitmap[offset], 4);
 162     return le32toh(color);
 163   }
 164   return 0;             /* invalid */
 165 }
 166
 167  /*
 168   * Symmetric Double Step Line Algorithm by Brian Wyvill from
 169   * "Graphics Gems", Academic Press, 1990.
 170   */
 171
 172 #define SL_SWAP(a,b)           {a^=b; b^=a; a^=b;}
 173 #define SL_ABSOLUTE(i,j,k)     ( (i-j)*(k = ( (i-j)<0 ? -1 : 1)))
 174
 175 void
 176 plot(VGLBitmap * object, int x, int y, int flag, u_long color)
 177 {
 178   /* non-zero flag indicates the pixels need swapping back. */
 179   if (flag)
 180     VGLSetXY(object, y, x, color);
 181   else
 182     VGLSetXY(object, x, y, color);
 183 }
 184
 185
 186 void
 187 VGLLine(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 188 {
 189   int dx, dy, incr1, incr2, D, x, y, xend, c, pixels_left;
 190   int sign_x, sign_y, step, reverse, i;
 191
 192   dx = SL_ABSOLUTE(x2, x1, sign_x);
 193   dy = SL_ABSOLUTE(y2, y1, sign_y);
 194   /* decide increment sign by the slope sign */
 195   if (sign_x == sign_y)
 196     step = 1;
 197   else
 198     step = -1;
 199
 200   if (dy > dx) {        /* chooses axis of greatest movement (make dx) */
 201     SL_SWAP(x1, y1);
 202     SL_SWAP(x2, y2);
 203     SL_SWAP(dx, dy);
 204     reverse = 1;
 205   } else
 206     reverse = 0;
 207   /* note error check for dx==0 should be included here */
 208   if (x1 > x2) {      /* start from the smaller coordinate */
 209     x = x2;
 210     y = y2;
 211 /*  x1 = x1;
 212     y1 = y1; */
 213   } else {
 214     x = x1;
 215     y = y1;
 216     x1 = x2;
 217     y1 = y2;
 218   }
 219
 220
 221   /* Note dx=n implies 0 - n or (dx+1) pixels to be set */
 222   /* Go round loop dx/4 times then plot last 0,1,2 or 3 pixels */
 223   /* In fact (dx-1)/4 as 2 pixels are already plotted */
 224   xend = (dx - 1) / 4;
 225   pixels_left = (dx - 1) % 4;  /* number of pixels left over at the
 226            * end */
 227   plot(object, x, y, reverse, color);
 228   if (pixels_left < 0)
 229     return;      /* plot only one pixel for zero length
 230            * vectors */
 231   plot(object, x1, y1, reverse, color);  /* plot first two points */
 232   incr2 = 4 * dy - 2 * dx;
 233   if (incr2 < 0) {    /* slope less than 1/2 */
 234     c = 2 * dy;
 235     incr1 = 2 * c;
 236     D = incr1 - dx;
 237
 238     for (i = 0; i < xend; i++) {  /* plotting loop */
 239       ++x;
 240       --x1;
 241       if (D < 0) {
 242         /* pattern 1 forwards */
 243         plot(object, x, y, reverse, color);
 244         plot(object, ++x, y, reverse, color);
 245         /* pattern 1 backwards */
 246         plot(object, x1, y1, reverse, color);
 247         plot(object, --x1, y1, reverse, color);
 248         D += incr1;
 249       } else {
 250         if (D < c) {
 251           /* pattern 2 forwards */
 252           plot(object, x, y, reverse, color);
 253           plot(object, ++x, y += step, reverse,
 254               color);
 255           /* pattern 2 backwards */
 256           plot(object, x1, y1, reverse, color);
 257           plot(object, --x1, y1 -= step, reverse,
 258               color);
 259         } else {
 260           /* pattern 3 forwards */
 261           plot(object, x, y += step, reverse, color);
 262           plot(object, ++x, y, reverse, color);
 263           /* pattern 3 backwards */
 264           plot(object, x1, y1 -= step, reverse,
 265               color);
 266           plot(object, --x1, y1, reverse, color);
 267         }
 268         D += incr2;
 269       }
 270     }      /* end for */
 271
 272     /* plot last pattern */
 273     if (pixels_left) {
 274       if (D < 0) {
 275         plot(object, ++x, y, reverse, color);  /* pattern 1 */
 276         if (pixels_left > 1)
 277           plot(object, ++x, y, reverse, color);
 278         if (pixels_left > 2)
 279           plot(object, --x1, y1, reverse, color);
 280       } else {
 281         if (D < c) {
 282           plot(object, ++x, y, reverse, color);  /* pattern 2  */
 283           if (pixels_left > 1)
 284             plot(object, ++x, y += step, reverse, color);
 285           if (pixels_left > 2)
 286             plot(object, --x1, y1, reverse, color);
 287         } else {
 288           /* pattern 3 */
 289           plot(object, ++x, y += step, reverse, color);
 290           if (pixels_left > 1)
 291             plot(object, ++x, y, reverse, color);
 292           if (pixels_left > 2)
 293             plot(object, --x1, y1 -= step, reverse, color);
 294         }
 295       }
 296     }      /* end if pixels_left */
 297   }
 298   /* end slope < 1/2 */
 299   else {        /* slope greater than 1/2 */
 300     c = 2 * (dy - dx);
 301     incr1 = 2 * c;
 302     D = incr1 + dx;
 303     for (i = 0; i < xend; i++) {
 304       ++x;
 305       --x1;
 306       if (D > 0) {
 307         /* pattern 4 forwards */
 308         plot(object, x, y += step, reverse, color);
 309         plot(object, ++x, y += step, reverse, color);
 310         /* pattern 4 backwards */
 311         plot(object, x1, y1 -= step, reverse, color);
 312         plot(object, --x1, y1 -= step, reverse, color);
 313         D += incr1;
 314       } else {
 315         if (D < c) {
 316           /* pattern 2 forwards */
 317           plot(object, x, y, reverse, color);
 318           plot(object, ++x, y += step, reverse,
 319               color);
 320
 321           /* pattern 2 backwards */
 322           plot(object, x1, y1, reverse, color);
 323           plot(object, --x1, y1 -= step, reverse,
 324               color);
 325         } else {
 326           /* pattern 3 forwards */
 327           plot(object, x, y += step, reverse, color);
 328           plot(object, ++x, y, reverse, color);
 329           /* pattern 3 backwards */
 330           plot(object, x1, y1 -= step, reverse, color);
 331           plot(object, --x1, y1, reverse, color);
 332         }
 333         D += incr2;
 334       }
 335     }      /* end for */
 336     /* plot last pattern */
 337     if (pixels_left) {
 338       if (D > 0) {
 339         plot(object, ++x, y += step, reverse, color);  /* pattern 4 */
 340         if (pixels_left > 1)
 341           plot(object, ++x, y += step, reverse,
 342               color);
 343         if (pixels_left > 2)
 344           plot(object, --x1, y1 -= step, reverse,
 345               color);
 346       } else {
 347         if (D < c) {
 348           plot(object, ++x, y, reverse, color);  /* pattern 2  */
 349           if (pixels_left > 1)
 350             plot(object, ++x, y += step, reverse, color);
 351           if (pixels_left > 2)
 352             plot(object, --x1, y1, reverse, color);
 353         } else {
 354           /* pattern 3 */
 355           plot(object, ++x, y += step, reverse, color);
 356           if (pixels_left > 1)
 357             plot(object, ++x, y, reverse, color);
 358           if (pixels_left > 2) {
 359             if (D > c)  /* step 3 */
 360               plot(object, --x1, y1 -= step, reverse, color);
 361             else  /* step 2 */
 362               plot(object, --x1, y1, reverse, color);
 363           }
 364         }
 365       }
 366     }
 367   }
 368 }
 369
 370 void
 371 VGLBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 372 {
 373   VGLLine(object, x1, y1, x2, y1, color);
 374   VGLLine(object, x2, y1, x2, y2, color);
 375   VGLLine(object, x2, y2, x1, y2, color);
 376   VGLLine(object, x1, y2, x1, y1, color);
 377 }
 378
 379 void
 380 VGLFilledBox(VGLBitmap *object, int x1, int y1, int x2, int y2, u_long color)
 381 {
 382   int y;
 383
 384   for (y=y1; y<=y2; y++) VGLLine(object, x1, y, x2, y, color);
 385 }
 386
 387 static inline void
 388 set4pixels(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
 389 {
 390   if (x!=0) {
 391     VGLSetXY(object, xc+x, yc+y, color);
 392     VGLSetXY(object, xc-x, yc+y, color);
 393     if (y!=0) {
 394       VGLSetXY(object, xc+x, yc-y, color);
 395       VGLSetXY(object, xc-x, yc-y, color);
 396     }
 397   }
 398   else {
 399     VGLSetXY(object, xc, yc+y, color);
 400     if (y!=0)
 401       VGLSetXY(object, xc, yc-y, color);
 402   }
 403 }
 404
 405 void
 406 VGLEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
 407 {
 408   int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
 409   int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
 410
 411   while (dx<dy) {
 412     set4pixels(object, x, y, xc, yc, color);
 413     if (d>0) {
 414       y--; dy-=asq2; d-=dy;
 415     }
 416     x++; dx+=bsq2; d+=bsq+dx;
 417   }
 418   d+=(3*(asq-bsq)/2-(dx+dy))/2;
 419   while (y>=0) {
 420     set4pixels(object, x, y, xc, yc, color);
 421     if (d<0) {
 422       x++; dx+=bsq2; d+=dx;
 423     }
 424     y--; dy-=asq2; d+=asq-dy;
 425   }
 426 }
 427
 428 static inline void
 429 set2lines(VGLBitmap *object, int x, int y, int xc, int yc, u_long color)
 430 {
 431   if (x!=0) {
 432     VGLLine(object, xc+x, yc+y, xc-x, yc+y, color);
 433     if (y!=0)
 434       VGLLine(object, xc+x, yc-y, xc-x, yc-y, color);
 435   }
 436   else {
 437     VGLLine(object, xc, yc+y, xc, yc-y, color);
 438   }
 439 }
 440
 441 void
 442 VGLFilledEllipse(VGLBitmap *object, int xc, int yc, int a, int b, u_long color)
 443 {
 444   int x = 0, y = b, asq = a*a, asq2 = a*a*2, bsq = b*b;
 445   int bsq2 = b*b*2, d = bsq-asq*b+asq/4, dx = 0, dy = asq2*b;
 446
 447   while (dx<dy) {
 448     set2lines(object, x, y, xc, yc, color);
 449     if (d>0) {
 450       y--; dy-=asq2; d-=dy;
 451     }
 452     x++; dx+=bsq2; d+=bsq+dx;
 453   }
 454   d+=(3*(asq-bsq)/2-(dx+dy))/2;
 455   while (y>=0) {
 456     set2lines(object, x, y, xc, yc, color);
 457     if (d<0) {
 458       x++; dx+=bsq2; d+=dx;
 459     }
 460     y--; dy-=asq2; d+=asq-dy;
 461   }
 462 }
 463
 464 void
 465 VGLClear(VGLBitmap *object, u_long color)
 466 {
 467   VGLBitmap src;
 468   int i, len, mousemode, offset;
 469
 470   VGLCheckSwitch();
 471   if (object == VGLDisplay) {
 472     VGLMouseFreeze();
 473     VGLClear(&VGLVDisplay, color);
 474   } else if (object->Type != MEMBUF)
 475     return;             /* invalid */
 476   switch (object->Type) {
 477   case MEMBUF:
 478   case VIDBUF8:
 479   case VIDBUF8S:
 480   case VIDBUF16:
 481   case VIDBUF16S:
 482   case VIDBUF24:
 483   case VIDBUF24S:
 484   case VIDBUF32:
 485   case VIDBUF32S:
 486     src.Type = MEMBUF;
 487     src.Xsize = object->Xsize;
 488     src.VXsize = object->VXsize;
 489     src.Ysize = 1;
 490     src.VYsize = 1;
 491     src.Xorigin = 0;
 492     src.Yorigin = 0;
 493     src.Bitmap = alloca(object->VXsize * object->PixelBytes);
 494     src.PixelBytes = object->PixelBytes;
 495     color = htole32(color);
 496     for (i = 0; i < object->VXsize; i++)
 497       bcopy(&color, src.Bitmap + i * object->PixelBytes, object->PixelBytes);
 498     for (i = 0; i < object->VYsize; i++)
 499       __VGLBitmapCopy(&src, 0, 0, object, 0, i, object->VXsize, -1);
 500     break;
 501
 502   case VIDBUF8X:
 503     mousemode = __VGLMouseMode(VGL_MOUSEHIDE);
 504     /* XXX works only for Xsize % 4 = 0 */
 505     outb(0x3c6, 0xff);
 506     outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 507     memset(object->Bitmap, (byte)color, VGLAdpInfo.va_line_width*object->VYsize);
 508     __VGLMouseMode(mousemode);
 509     break;
 510
 511   case VIDBUF4:
 512   case VIDBUF4S:
 513     mousemode = __VGLMouseMode(VGL_MOUSEHIDE);
 514     /* XXX works only for Xsize % 8 = 0 */
 515     outb(0x3c4, 0x02); outb(0x3c5, 0x0f);
 516     outb(0x3ce, 0x05); outb(0x3cf, 0x02);               /* mode 2 */
 517     outb(0x3ce, 0x01); outb(0x3cf, 0x00);               /* set/reset enable */
 518     outb(0x3ce, 0x08); outb(0x3cf, 0xff);               /* bit mask */
 519     for (offset = 0; offset < VGLAdpInfo.va_line_width*object->VYsize; ) {
 520       VGLSetSegment(offset);
 521       len = min(object->VXsize*object->VYsize - offset,
 522                 VGLAdpInfo.va_window_size);
 523       memset(object->Bitmap, (byte)color, len);
 524       offset += len;
 525     }
 526     outb(0x3ce, 0x05); outb(0x3cf, 0x00);
 527     __VGLMouseMode(mousemode);
 528     break;
 529   }
 530   if (object == VGLDisplay)
 531     VGLMouseUnFreeze();
 532 }
 533
 534 static inline u_long
 535 VGLrgbToNative(uint16_t r, uint16_t g, uint16_t b)
 536 {
 537   int nr, ng, nb;
 538
 539   nr = VGLModeInfo.vi_pixel_fsizes[2];
 540   ng = VGLModeInfo.vi_pixel_fsizes[1];
 541   nb = VGLModeInfo.vi_pixel_fsizes[0];
 542   return (r >> (16 - nr) << (ng + nb)) | (g >> (16 - ng) << nb) |
 543          (b >> (16 - nb) << 0);
 544 }
 545
 546 u_long
 547 VGLrgb332ToNative(byte c)
 548 {
 549   uint16_t r, g, b;
 550
 551   /* 3:3:2 to 16:16:16 */
 552   r = ((c & 0xe0) >> 5) * 0xffff / 7;
 553   g = ((c & 0x1c) >> 2) * 0xffff / 7;
 554   b = ((c & 0x03) >> 0) * 0xffff / 3;
 555
 556   return VGLrgbToNative(r, g, b);
 557 }
 558
 559 void
 560 VGLRestorePalette()
 561 {
 562   int i;
 563
 564   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 565     return;
 566   outb(0x3C6, 0xFF);
 567   inb(0x3DA);
 568   outb(0x3C8, 0x00);
 569   for (i=0; i<256; i++) {
 570     outb(0x3C9, VGLSavePaletteRed[i]);
 571     inb(0x84);
 572     outb(0x3C9, VGLSavePaletteGreen[i]);
 573     inb(0x84);
 574     outb(0x3C9, VGLSavePaletteBlue[i]);
 575     inb(0x84);
 576   }
 577   inb(0x3DA);
 578   outb(0x3C0, 0x20);
 579 }
 580
 581 void
 582 VGLSavePalette()
 583 {
 584   int i;
 585
 586   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 587     return;
 588   outb(0x3C6, 0xFF);
 589   inb(0x3DA);
 590   outb(0x3C7, 0x00);
 591   for (i=0; i<256; i++) {
 592     VGLSavePaletteRed[i] = inb(0x3C9);
 593     inb(0x84);
 594     VGLSavePaletteGreen[i] = inb(0x3C9);
 595     inb(0x84);
 596     VGLSavePaletteBlue[i] = inb(0x3C9);
 597     inb(0x84);
 598   }
 599   inb(0x3DA);
 600   outb(0x3C0, 0x20);
 601 }
 602
 603 void
 604 VGLSetPalette(byte *red, byte *green, byte *blue)
 605 {
 606   int i;
 607
 608   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 609     return;
 610   for (i=0; i<256; i++) {
 611     VGLSavePaletteRed[i] = red[i];
 612     VGLSavePaletteGreen[i] = green[i];
 613     VGLSavePaletteBlue[i] = blue[i];
 614   }
 615   VGLCheckSwitch();
 616   outb(0x3C6, 0xFF);
 617   inb(0x3DA);
 618   outb(0x3C8, 0x00);
 619   for (i=0; i<256; i++) {
 620     outb(0x3C9, VGLSavePaletteRed[i]);
 621     inb(0x84);
 622     outb(0x3C9, VGLSavePaletteGreen[i]);
 623     inb(0x84);
 624     outb(0x3C9, VGLSavePaletteBlue[i]);
 625     inb(0x84);
 626   }
 627   inb(0x3DA);
 628   outb(0x3C0, 0x20);
 629 }
 630
 631 void
 632 VGLSetPaletteIndex(byte color, byte red, byte green, byte blue)
 633 {
 634   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 635     return;
 636   VGLSavePaletteRed[color] = red;
 637   VGLSavePaletteGreen[color] = green;
 638   VGLSavePaletteBlue[color] = blue;
 639   VGLCheckSwitch();
 640   outb(0x3C6, 0xFF);
 641   inb(0x3DA);
 642   outb(0x3C8, color);
 643   outb(0x3C9, red); outb(0x3C9, green); outb(0x3C9, blue);
 644   inb(0x3DA);
 645   outb(0x3C0, 0x20);
 646 }
 647
 648 void
 649 VGLRestoreBorder(void)
 650 {
 651   VGLSetBorder(VGLBorderColor);
 652 }
 653
 654 void
 655 VGLSetBorder(byte color)
 656 {
 657   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT && ioctl(0, KDENABIO, 0))
 658     return;
 659   VGLCheckSwitch();
 660   inb(0x3DA);
 661   outb(0x3C0,0x11); outb(0x3C0, color);
 662   inb(0x3DA);
 663   outb(0x3C0, 0x20);
 664   VGLBorderColor = color;
 665   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 666     ioctl(0, KDDISABIO, 0);
 667 }
 668
 669 void
 670 VGLRestoreBlank(void)
 671 {
 672   VGLBlankDisplay(VGLBlank);
 673 }
 674
 675 void
 676 VGLBlankDisplay(int blank)
 677 {
 678   byte val;
 679
 680   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT && ioctl(0, KDENABIO, 0))
 681     return;
 682   VGLCheckSwitch();
 683   outb(0x3C4, 0x01); val = inb(0x3C5); outb(0x3C4, 0x01);
 684   outb(0x3C5, ((blank) ? (val |= 0x20) : (val &= 0xDF)));
 685   VGLBlank = blank;
 686   if (VGLModeInfo.vi_mem_model == V_INFO_MM_DIRECT)
 687     ioctl(0, KDDISABIO, 0);
 688 }