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