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