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