lib/libvgl/main.c

   1 /*-
   2  * Copyright (c) 1991-1997 Søren Schmidt
   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
  10  *    in this position and unchanged.
  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  * 3. The name of the author may not be used to endorse or promote products
  15  *    derived from this software withough specific prior written permission
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  18  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  19  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  20  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  21  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  22  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  *
  28  * $FreeBSD: src/lib/libvgl/main.c,v 1.6.2.2 2001/07/30 14:31:30 yokota Exp $
  29  * $DragonFly: src/lib/libvgl/main.c,v 1.2 2003/06/17 04:26:52 dillon Exp $
  30  */
  31
  32 #include <stdio.h>
  33 #include <sys/types.h>
  34 #include <sys/signal.h>
  35 #include <sys/file.h>
  36 #include <sys/ioctl.h>
  37 #include <sys/mman.h>
  38 #include <machine/console.h>
  39 #include "vgl.h"
  40
  41 #define min(x, y)       (((x) < (y)) ? (x) : (y))
  42 #define max(x, y)       (((x) > (y)) ? (x) : (y))
  43
  44 VGLBitmap *VGLDisplay;
  45 video_info_t VGLModeInfo;
  46 video_adapter_info_t VGLAdpInfo;
  47 byte *VGLBuf;
  48
  49 static int VGLMode;
  50 static int VGLOldMode;
  51 static size_t VGLBufSize;
  52 static byte *VGLMem = MAP_FAILED;
  53 static int VGLSwitchPending;
  54 static int VGLAbortPending;
  55 static int VGLOnDisplay;
  56 static unsigned int VGLCurWindow;
  57 static int VGLInitDone = 0;
  58 static struct winsize VGLOldWSize;
  59
  60 void
  61 VGLEnd()
  62 {
  63 struct vt_mode smode;
  64
  65   if (!VGLInitDone)
  66     return;
  67   VGLInitDone = 0;
  68   VGLSwitchPending = 0;
  69   VGLAbortPending = 0;
  70
  71   signal(SIGUSR1, SIG_IGN);
  72
  73   if (VGLMem != MAP_FAILED) {
  74     VGLClear(VGLDisplay, 0);
  75     munmap(VGLMem, VGLAdpInfo.va_window_size);
  76   }
  77
  78   if (VGLOldMode >= M_VESA_BASE) {
  79     /* ugly, but necessary */
  80     ioctl(0, _IO('V', VGLOldMode - M_VESA_BASE), 0);
  81     if (VGLOldMode == M_VESA_800x600) {
  82       int size[3];
  83       size[0] = VGLOldWSize.ws_col;
  84       size[1] = VGLOldWSize.ws_row;
  85       size[2] = 16;
  86       ioctl(0, KDRASTER, size);
  87     }
  88   } else {
  89     ioctl(0, _IO('S', VGLOldMode), 0);
  90   }
  91   ioctl(0, KDDISABIO, 0);
  92   ioctl(0, KDSETMODE, KD_TEXT);
  93   smode.mode = VT_AUTO;
  94   ioctl(0, VT_SETMODE, &smode);
  95   if (VGLBuf)
  96     free(VGLBuf);
  97   VGLBuf = NULL;
  98   free(VGLDisplay);
  99   VGLDisplay = NULL;
 100   VGLKeyboardEnd();
 101 }
 102
 103 static void
 104 VGLAbort()
 105 {
 106   VGLAbortPending = 1;
 107   signal(SIGINT, SIG_IGN);
 108   signal(SIGTERM, SIG_IGN);
 109   signal(SIGSEGV, SIG_IGN);
 110   signal(SIGBUS, SIG_IGN);
 111   signal(SIGUSR2, SIG_IGN);
 112 }
 113
 114 static void
 115 VGLSwitch()
 116 {
 117   if (!VGLOnDisplay)
 118     VGLOnDisplay = 1;
 119   else
 120     VGLOnDisplay = 0;
 121   VGLSwitchPending = 1;
 122   signal(SIGUSR1, VGLSwitch);
 123 }
 124
 125 int
 126 VGLInit(int mode)
 127 {
 128   struct vt_mode smode;
 129   int adptype;
 130
 131   if (VGLInitDone)
 132     return -1;
 133
 134   signal(SIGUSR1, VGLSwitch);
 135   signal(SIGINT, VGLAbort);
 136   signal(SIGTERM, VGLAbort);
 137   signal(SIGSEGV, VGLAbort);
 138   signal(SIGBUS, VGLAbort);
 139   signal(SIGUSR2, SIG_IGN);
 140
 141   VGLOnDisplay = 1;
 142   VGLSwitchPending = 0;
 143   VGLAbortPending = 0;
 144
 145   if (ioctl(0, CONS_GET, &VGLOldMode) || ioctl(0, CONS_CURRENT, &adptype))
 146     return -1;
 147   if (IOCGROUP(mode) == 'V')    /* XXX: this is ugly */
 148     VGLModeInfo.vi_mode = (mode & 0x0ff) + M_VESA_BASE;
 149   else
 150     VGLModeInfo.vi_mode = mode & 0x0ff;
 151   if (ioctl(0, CONS_MODEINFO, &VGLModeInfo))    /* FBIO_MODEINFO */
 152     return -1;
 153
 154   /* If current mode is VESA_800x600 then save its geometry to restore later */
 155   if ((VGLOldMode >= M_VESA_BASE) && (VGLOldMode == M_VESA_800x600))
 156     if (ioctl(0, TIOCGWINSZ, &VGLOldWSize))
 157       return -1;
 158
 159   VGLDisplay = (VGLBitmap *)malloc(sizeof(VGLBitmap));
 160   if (VGLDisplay == NULL)
 161     return -2;
 162
 163   if (ioctl(0, KDENABIO, 0)) {
 164     free(VGLDisplay);
 165     return -3;
 166   }
 167
 168   VGLInitDone = 1;
 169
 170   /*
 171    * vi_mem_model specifies the memory model of the current video mode
 172    * in -CURRENT.
 173    */
 174   switch (VGLModeInfo.vi_mem_model) {
 175   case V_INFO_MM_PLANAR:
 176     /* we can handle EGA/VGA planner modes only */
 177     if (VGLModeInfo.vi_depth != 4 || VGLModeInfo.vi_planes != 4
 178         || (adptype != KD_EGA && adptype != KD_VGA)) {
 179       VGLEnd();
 180       return -4;
 181     }
 182     VGLDisplay->Type = VIDBUF4;
 183     break;
 184   case V_INFO_MM_PACKED:
 185     /* we can do only 256 color packed modes */
 186     if (VGLModeInfo.vi_depth != 8) {
 187       VGLEnd();
 188       return -4;
 189     }
 190     VGLDisplay->Type = VIDBUF8;
 191     break;
 192   case V_INFO_MM_VGAX:
 193     VGLDisplay->Type = VIDBUF8X;
 194     break;
 195   default:
 196     VGLEnd();
 197     return -4;
 198   }
 199
 200   ioctl(0, VT_WAITACTIVE, 0);
 201   ioctl(0, KDSETMODE, KD_GRAPHICS);
 202   if (ioctl(0, mode, 0)) {
 203     VGLEnd();
 204     return -5;
 205   }
 206   if (ioctl(0, CONS_ADPINFO, &VGLAdpInfo)) {    /* FBIO_ADPINFO */
 207     VGLEnd();
 208     return -6;
 209   }
 210
 211   /*
 212    * Calculate the shadow screen buffer size.  In -CURRENT, va_buffer_size
 213    * always holds the entire frame buffer size, wheather it's in the linear
 214    * mode or windowed mode.
 215    *     VGLBufSize = VGLAdpInfo.va_buffer_size;
 216    * In -STABLE, va_buffer_size holds the frame buffer size, only if
 217    * the linear frame buffer mode is supported. Otherwise the field is zero.
 218    * We shall calculate the minimal size in this case:
 219    *     VGLAdpInfo.va_line_width*VGLModeInfo.vi_height*VGLModeInfo.vi_planes
 220    * or
 221    *     VGLAdpInfo.va_window_size*VGLModeInfo.vi_planes;
 222    * Use whichever is larger.
 223    */
 224   if (VGLAdpInfo.va_buffer_size != 0)
 225     VGLBufSize = VGLAdpInfo.va_buffer_size;
 226   else
 227     VGLBufSize = max(VGLAdpInfo.va_line_width*VGLModeInfo.vi_height,
 228                      VGLAdpInfo.va_window_size)*VGLModeInfo.vi_planes;
 229   VGLBuf = malloc(VGLBufSize);
 230   if (VGLBuf == NULL) {
 231     VGLEnd();
 232     return -7;
 233   }
 234
 235 #ifdef LIBVGL_DEBUG
 236   fprintf(stderr, "VGLBufSize:0x%x\n", VGLBufSize);
 237 #endif
 238
 239   /* see if we are in the windowed buffer mode or in the linear buffer mode */
 240   if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size) {
 241     if (VGLDisplay->Type == VIDBUF4)
 242       VGLDisplay->Type = VIDBUF4S;
 243     else if (VGLDisplay->Type == VIDBUF8)
 244       VGLDisplay->Type = VIDBUF8S;
 245   }
 246
 247   VGLMode = mode;
 248   VGLCurWindow = 0;
 249
 250   VGLDisplay->Xsize = VGLModeInfo.vi_width;
 251   VGLDisplay->Ysize = VGLModeInfo.vi_height;
 252   VGLDisplay->VXsize = VGLAdpInfo.va_line_width
 253                            *8/(VGLModeInfo.vi_depth/VGLModeInfo.vi_planes);
 254   VGLDisplay->VYsize = VGLBufSize/VGLModeInfo.vi_planes/VGLAdpInfo.va_line_width;
 255   VGLDisplay->Xorigin = 0;
 256   VGLDisplay->Yorigin = 0;
 257
 258   VGLMem = (byte*)mmap(0, VGLAdpInfo.va_window_size, PROT_READ|PROT_WRITE,
 259                        MAP_FILE, 0, 0);
 260   if (VGLMem == MAP_FAILED) {
 261     VGLEnd();
 262     return -7;
 263   }
 264   VGLDisplay->Bitmap = VGLMem;
 265
 266   VGLSavePalette();
 267
 268 #ifdef LIBVGL_DEBUG
 269   fprintf(stderr, "va_line_width:%d\n", VGLAdpInfo.va_line_width);
 270   fprintf(stderr, "VGLXsize:%d, Ysize:%d, VXsize:%d, VYsize:%d\n",
 271           VGLDisplay->Xsize, VGLDisplay->Ysize,
 272           VGLDisplay->VXsize, VGLDisplay->VYsize);
 273 #endif
 274
 275   smode.mode = VT_PROCESS;
 276   smode.waitv = 0;
 277   smode.relsig = SIGUSR1;
 278   smode.acqsig = SIGUSR1;
 279   smode.frsig  = SIGINT;
 280   if (ioctl(0, VT_SETMODE, &smode)) {
 281     VGLEnd();
 282     return -9;
 283   }
 284   VGLTextSetFontFile((byte*)0);
 285   VGLClear(VGLDisplay, 0);
 286   return 0;
 287 }
 288
 289 void
 290 VGLCheckSwitch()
 291 {
 292   if (VGLAbortPending) {
 293     VGLEnd();
 294     exit(0);
 295   }
 296   while (VGLSwitchPending) {
 297     unsigned int offset;
 298     unsigned int len;
 299     int i;
 300
 301     VGLSwitchPending = 0;
 302     if (VGLOnDisplay) {
 303       ioctl(0, KDENABIO, 0);
 304       ioctl(0, KDSETMODE, KD_GRAPHICS);
 305       ioctl(0, VGLMode, 0);
 306       VGLCurWindow = 0;
 307       VGLMem = (byte*)mmap(0, VGLAdpInfo.va_window_size, PROT_READ|PROT_WRITE,
 308                            MAP_FILE, 0, 0);
 309
 310       /* XXX: what if mmap() has failed! */
 311       VGLDisplay->Type = VIDBUF8;       /* XXX */
 312       switch (VGLModeInfo.vi_mem_model) {
 313       case V_INFO_MM_PLANAR:
 314         if (VGLModeInfo.vi_depth == 4 && VGLModeInfo.vi_planes == 4) {
 315           if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size)
 316             VGLDisplay->Type = VIDBUF4S;
 317           else
 318             VGLDisplay->Type = VIDBUF4;
 319         } else {
 320           /* shouldn't be happening */
 321         }
 322         break;
 323       case V_INFO_MM_PACKED:
 324         if (VGLModeInfo.vi_depth == 8) {
 325           if (VGLBufSize/VGLModeInfo.vi_planes > VGLAdpInfo.va_window_size)
 326             VGLDisplay->Type = VIDBUF8S;
 327           else
 328             VGLDisplay->Type = VIDBUF8;
 329         } else {
 330           /* shouldn't be happening */
 331         }
 332         break;
 333       case V_INFO_MM_VGAX:
 334         VGLDisplay->Type = VIDBUF8X;
 335         break;
 336       default:
 337         /* shouldn't be happening */
 338         break;
 339       }
 340
 341       VGLDisplay->Bitmap = VGLMem;
 342       VGLDisplay->Xsize = VGLModeInfo.vi_width;
 343       VGLDisplay->Ysize = VGLModeInfo.vi_height;
 344       VGLSetVScreenSize(VGLDisplay, VGLDisplay->VXsize, VGLDisplay->VYsize);
 345       VGLPanScreen(VGLDisplay, VGLDisplay->Xorigin, VGLDisplay->Yorigin);
 346       switch (VGLDisplay->Type) {
 347       case VIDBUF4S:
 348         outb(0x3c6, 0xff);
 349         outb(0x3ce, 0x01); outb(0x3cf, 0x00);           /* set/reset enable */
 350         outb(0x3ce, 0x08); outb(0x3cf, 0xff);           /* bit mask */
 351         for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes;
 352              offset += len) {
 353           VGLSetSegment(offset);
 354           len = min(VGLBufSize/VGLModeInfo.vi_planes - offset,
 355                     VGLAdpInfo.va_window_size);
 356           for (i = 0; i < VGLModeInfo.vi_planes; i++) {
 357             outb(0x3c4, 0x02);
 358             outb(0x3c5, 0x01<<i);
 359             bcopy(&VGLBuf[i*VGLBufSize/VGLModeInfo.vi_planes + offset],
 360                   VGLMem, len);
 361           }
 362         }
 363         break;
 364       case VIDBUF4:
 365       case VIDBUF8X:
 366         outb(0x3c6, 0xff);
 367         outb(0x3ce, 0x01); outb(0x3cf, 0x00);           /* set/reset enable */
 368         outb(0x3ce, 0x08); outb(0x3cf, 0xff);           /* bit mask */
 369         for (i = 0; i < VGLModeInfo.vi_planes; i++) {
 370           outb(0x3c4, 0x02);
 371           outb(0x3c5, 0x01<<i);
 372           bcopy(&VGLBuf[i*VGLAdpInfo.va_window_size], VGLMem,
 373                 VGLAdpInfo.va_window_size);
 374         }
 375         break;
 376       case VIDBUF8:
 377       case VIDBUF8S:
 378         for (offset = 0; offset < VGLBufSize; offset += len) {
 379           VGLSetSegment(offset);
 380           len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);
 381           bcopy(&VGLBuf[offset], VGLMem, len);
 382         }
 383         break;
 384       }
 385       VGLRestorePalette();
 386       ioctl(0, VT_RELDISP, VT_ACKACQ);
 387     }
 388     else {
 389       switch (VGLDisplay->Type) {
 390       case VIDBUF4S:
 391         for (offset = 0; offset < VGLBufSize/VGLModeInfo.vi_planes;
 392              offset += len) {
 393           VGLSetSegment(offset);
 394           len = min(VGLBufSize/VGLModeInfo.vi_planes - offset,
 395                     VGLAdpInfo.va_window_size);
 396           for (i = 0; i < VGLModeInfo.vi_planes; i++) {
 397             outb(0x3ce, 0x04);
 398             outb(0x3cf, i);
 399             bcopy(VGLMem, &VGLBuf[i*VGLBufSize/VGLModeInfo.vi_planes + offset],
 400                   len);
 401           }
 402         }
 403         break;
 404       case VIDBUF4:
 405       case VIDBUF8X:
 406         /*
 407          * NOTE: the saved buffer is NOT in the MEMBUF format which
 408          * the ordinary memory bitmap object is stored in. XXX
 409          */
 410         for (i = 0; i < VGLModeInfo.vi_planes; i++) {
 411           outb(0x3ce, 0x04);
 412           outb(0x3cf, i);
 413           bcopy(VGLMem, &VGLBuf[i*VGLAdpInfo.va_window_size],
 414                 VGLAdpInfo.va_window_size);
 415         }
 416         break;
 417       case VIDBUF8:
 418       case VIDBUF8S:
 419         for (offset = 0; offset < VGLBufSize; offset += len) {
 420           VGLSetSegment(offset);
 421           len = min(VGLBufSize - offset, VGLAdpInfo.va_window_size);
 422           bcopy(VGLMem, &VGLBuf[offset], len);
 423         }
 424         break;
 425       }
 426       VGLMem = MAP_FAILED;
 427       munmap(VGLDisplay->Bitmap, VGLAdpInfo.va_window_size);
 428       ioctl(0, VGLOldMode, 0);
 429       ioctl(0, KDSETMODE, KD_TEXT);
 430       ioctl(0, KDDISABIO, 0);
 431       ioctl(0, VT_RELDISP, VT_TRUE);
 432       VGLDisplay->Bitmap = VGLBuf;
 433       VGLDisplay->Type = MEMBUF;
 434       VGLDisplay->Xsize = VGLDisplay->VXsize;
 435       VGLDisplay->Ysize = VGLDisplay->VYsize;
 436       while (!VGLOnDisplay) pause();
 437     }
 438   }
 439 }
 440
 441 int
 442 VGLSetSegment(unsigned int offset)
 443 {
 444   if (offset/VGLAdpInfo.va_window_size != VGLCurWindow) {
 445     ioctl(0, CONS_SETWINORG, offset);           /* FBIO_SETWINORG */
 446     VGLCurWindow = offset/VGLAdpInfo.va_window_size;
 447   }
 448   return (offset%VGLAdpInfo.va_window_size);
 449 }
 450
 451 int
 452 VGLSetVScreenSize(VGLBitmap *object, int VXsize, int VYsize)
 453 {
 454   if (VXsize < object->Xsize || VYsize < object->Ysize)
 455     return -1;
 456   if (object->Type == MEMBUF)
 457     return -1;
 458   if (ioctl(0, FBIO_SETLINEWIDTH, &VXsize))
 459     return -1;
 460   ioctl(0, CONS_ADPINFO, &VGLAdpInfo);  /* FBIO_ADPINFO */
 461   object->VXsize = VGLAdpInfo.va_line_width
 462                            *8/(VGLModeInfo.vi_depth/VGLModeInfo.vi_planes);
 463   object->VYsize = VGLBufSize/VGLModeInfo.vi_planes/VGLAdpInfo.va_line_width;
 464   if (VYsize < object->VYsize)
 465     object->VYsize = VYsize;
 466
 467 #ifdef LIBVGL_DEBUG
 468   fprintf(stderr, "new size: VGLXsize:%d, Ysize:%d, VXsize:%d, VYsize:%d\n",
 469           object->Xsize, object->Ysize, object->VXsize, object->VYsize);
 470 #endif
 471
 472   return 0;
 473 }
 474
 475 int
 476 VGLPanScreen(VGLBitmap *object, int x, int y)
 477 {
 478   video_display_start_t origin;
 479
 480   if (x < 0 || x + object->Xsize > object->VXsize
 481       || y < 0 || y + object->Ysize > object->VYsize)
 482     return -1;
 483   if (object->Type == MEMBUF)
 484     return 0;
 485   origin.x = x;
 486   origin.y = y;
 487   if (ioctl(0, FBIO_SETDISPSTART, &origin))
 488     return -1;
 489   object->Xorigin = x;
 490   object->Yorigin = y;
 491
 492 #ifdef LIBVGL_DEBUG
 493   fprintf(stderr, "new origin: (%d, %d)\n", x, y);
 494 #endif
 495
 496   return 0;
 497 }