home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / src / vga.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-21  |  60.4 KB  |  2,496 lines
  1. /* VGAlib version 1.2 - (c) 1993 Tommy Frandsen            */
  2. /*                                   */
  3. /* This library is free software; you can redistribute it and/or   */
  4. /* modify it without any restrictions. This library is distributed */
  5. /* in the hope that it will be useful, but without any warranty.   */
  6.  
  7. /* Multi-chipset support Copyright (C) 1993 Harm Hanemaayer */
  8. /* partially copyrighted (C) 1993 by Hartmut Schirmer */
  9. /* Changes by Michael Weller. */
  10.  
  11.  
  12. /* The code is a bit of a mess; also note that the drawing functions */
  13. /* are not speed optimized (the gl functions are much faster). */
  14.  
  15. #include <stdlib.h>
  16. #include <stdio.h>
  17. #include <fcntl.h>
  18. #include <signal.h>
  19. #include <termios.h>
  20. #include <string.h>
  21. #include <unistd.h>
  22. #include <stdarg.h>
  23. #include <sys/mman.h>
  24. #include <sys/kd.h>
  25. #include <sys/ioctl.h>
  26. #include <sys/stat.h>
  27. #include <sys/vt.h>
  28. #include <sys/wait.h>
  29. #include <errno.h>
  30. #include <ctype.h>
  31. #include "vga.h"
  32. #include "libvga.h"
  33. #include "driver.h"
  34. #include "config.h"
  35. #include "mouse/vgamouse.h"
  36.  
  37.  
  38. /* Delay in microseconds after a mode is set (screen is blanked during this */
  39. /* time), allows video signals to stabilize */
  40. #define MODESWITCHDELAY 150000
  41.  
  42. /* Define this to disable video output during mode switches, in addition to */
  43. /* 'turning off the screen', which is always done. */
  44. /* Doesn't look very nice on my Cirrus. */
  45. /* #define DISABLE_VIDEO_OUTPUT */
  46.  
  47. /* #define DONT_WAIT_VC_ACTIVE */
  48.  
  49. /* Use /dev/tty instead of /dev/tty0 (the previous behaviour may have been
  50.  * silly). */
  51. #define USE_DEVTTY
  52.  
  53.  
  54. #define SETSIG(sa, sig, fun) \
  55.     sa.sa_handler = fun; \
  56.     sa.sa_flags = 0; \
  57.     sa.sa_mask = 0; \
  58.     sigaction(sig, &sa, NULL);
  59.  
  60. #define SETSIG2(sa, sig, fun, oldsa) \
  61.     sa.sa_handler = fun; \
  62.     sa.sa_flags = 0; \
  63.     sa.sa_mask = 0; \
  64.     sigaction(sig, &sa, &oldsa);
  65.  
  66.  
  67. /* variables used to shift between monchrome and color emulation */
  68. int CRT_I;            /* current CRT index register address */
  69. int CRT_D;            /* current CRT data register address */
  70. int IS1_R;            /* current input status register address */
  71. static int color_text;        /* true if color text emulation */
  72.  
  73.  
  74. struct info infotable[] = {
  75.     {   80,   25,    16,  160, 0 },        /* VGAlib VGA modes */
  76.     {  320,  200,    16,   40, 0 },
  77.     {  640,  200,    16,   80, 0 },
  78.     {  640,  350,    16,   80, 0 },
  79.     {  640,  480,    16,   80, 0 },
  80.     {  320,  200,   256,  320, 1 },
  81.     {  320,  240,   256,   80, 0 },
  82.     {  320,  400,   256,   80, 0 },
  83.     {  360,  480,   256,   90, 0 },
  84.     {  640,  480,     2,   80, 0 },
  85.  
  86.     {  640,  480,   256,  640, 1 },        /* VGAlib SVGA modes */
  87.     {  800,  600,   256,  800, 1 },
  88.     { 1024,  768,   256, 1024, 1 },
  89.     { 1280, 1024,   256, 1280, 1 },
  90.  
  91.     {  320,  200, 1<<15,  640, 2 },        /* Hicolor/truecolor modes */
  92.     {  320,  200, 1<<16,  640, 2 },
  93.     {  320,  200, 1<<24,  320 * 3, 3 },
  94.     {  640,  480, 1<<15,  640 * 2, 2 },
  95.     {  640,  480, 1<<16,  640 * 2, 2 },
  96.     {  640,  480, 1<<24,  640 * 3, 3 },
  97.     {  800,  600, 1<<15,  800 * 2, 2 },
  98.     {  800,  600, 1<<16,  800 * 2, 2 },
  99.     {  800,  600, 1<<24,  800 * 3, 3 },
  100.     { 1024,  768, 1<<15, 1024 * 2, 2 },
  101.     { 1024,  768, 1<<16, 1024 * 2, 2 },
  102.     { 1024,  768, 1<<24, 1024 * 3, 3 },
  103.     { 1280, 1024, 1<<15, 1280 * 2, 2 },
  104.     { 1280, 1024, 1<<16, 1280 * 2, 2 },
  105.     { 1280, 1024, 1<<24, 1280 * 3, 3 },
  106.  
  107.     {  800,  600,    16,  100, 0 },        /* SVGA 16-color modes */
  108.     { 1024,  768,    16,  128, 0 },
  109.     { 1280, 1024,    16,  160, 0 },
  110.  
  111.     {  720,  348,     2,   90, 0 },        /* Hercules emulation mode */
  112.  
  113.     {  320,  200, 1<<24,  320 * 4, 4 },
  114.     {  640,  480, 1<<24,  640 * 4, 4 },
  115.     {  800,  600, 1<<24,  800 * 4, 4 },
  116.     { 1024,  768, 1<<24, 1024 * 4, 4 },
  117.     { 1280, 1024, 1<<24, 1280 * 4, 4 },
  118.  
  119.     {    0,    0,     0,    0, 0 },    /* 16 user definable modes */
  120.     {    0,    0,     0,    0, 0 },
  121.     {    0,    0,     0,    0, 0 },
  122.     {    0,    0,     0,    0, 0 },
  123.     {    0,    0,     0,    0, 0 },
  124.     {    0,    0,     0,    0, 0 },
  125.     {    0,    0,     0,    0, 0 },
  126.     {    0,    0,     0,    0, 0 },
  127.     {    0,    0,     0,    0, 0 },
  128.     {    0,    0,     0,    0, 0 },
  129.     {    0,    0,     0,    0, 0 },
  130.     {    0,    0,     0,    0, 0 },
  131.     {    0,    0,     0,    0, 0 },
  132.     {    0,    0,     0,    0, 0 },
  133.     {    0,    0,     0,    0, 0 },
  134.     {    0,    0,     0,    0, 0 }
  135. };
  136.  
  137. #define MAX_MODES (sizeof(infotable) / sizeof(struct info))
  138.  
  139.  
  140. /* default palette values */
  141. static const unsigned char default_red[256]   
  142.              = { 0, 0, 0, 0,42,42,42,42,21,21,21,21,63,63,63,63,
  143.          0, 5, 8,11,14,17,20,24,28,32,36,40,45,50,56,63,
  144.          0,16,31,47,63,63,63,63,63,63,63,63,63,47,31,16,
  145.          0, 0, 0, 0, 0, 0, 0, 0,31,39,47,55,63,63,63,63,
  146.         63,63,63,63,63,55,47,39,31,31,31,31,31,31,31,31,
  147.         45,49,54,58,63,63,63,63,63,63,63,63,63,58,54,49,
  148.         45,45,45,45,45,45,45,45, 0, 7,14,21,28,28,28,28,
  149.         28,28,28,28,28,21,14, 7, 0, 0, 0, 0, 0, 0, 0, 0,
  150.         14,17,21,24,28,28,28,28,28,28,28,28,28,24,21,17,
  151.         14,14,14,14,14,14,14,14,20,22,24,26,28,28,28,28,
  152.         28,28,28,28,28,26,24,22,20,20,20,20,20,20,20,20,
  153.          0, 4, 8,12,16,16,16,16,16,16,16,16,16,12, 8, 4,
  154.          0, 0, 0, 0, 0, 0, 0, 0, 8,10,12,14,16,16,16,16,
  155.         16,16,16,16,16,14,12,10, 8, 8, 8, 8, 8, 8, 8, 8,
  156.         11,12,13,15,16,16,16,16,16,16,16,16,16,15,13,12,
  157.         11,11,11,11,11,11,11,11, 0, 0, 0, 0, 0, 0, 0, 0};
  158. static const unsigned char default_green[256] 
  159.          = { 0, 0,42,42, 0, 0,21,42,21,21,63,63,21,21,63,63,
  160.          0, 5, 8,11,14,17,20,24,28,32,36,40,45,50,56,63,
  161.          0, 0, 0, 0, 0, 0, 0, 0, 0,16,31,47,63,63,63,63,
  162.         63,63,63,63,63,47,31,16,31,31,31,31,31,31,31,31,
  163.         31,39,47,55,63,63,63,63,63,63,63,63,63,55,47,39,
  164.         45,45,45,45,45,45,45,45,45,49,54,58,63,63,63,63,
  165.         63,63,63,63,63,58,54,49, 0, 0, 0, 0, 0, 0, 0, 0,
  166.          0, 7,14,21,29,28,28,28,28,28,28,28,28,21,14, 7,
  167.         14,14,14,14,14,14,14,14,14,17,21,24,28,28,28,28,
  168.         28,28,28,28,28,24,21,17,20,20,20,20,20,20,20,20,
  169.         20,22,24,26,28,28,28,28,28,28,28,28,28,26,24,22,
  170.          0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 8,12,16,16,16,16,
  171.         16,16,16,16,16,12, 8, 4, 8, 8, 8, 8, 8, 8, 8, 8,
  172.          8,10,12,14,16,16,16,16,16,16,16,16,16,14,12,10,
  173.         11,11,11,11,11,11,11,11,11,12,13,15,16,16,16,16,
  174.         16,16,16,16,16,15,13,12, 0, 0, 0, 0, 0, 0, 0, 0};
  175. static const unsigned char default_blue[256]  
  176.              = { 0,42, 0,42, 0,42, 0,42,21,63,21,63,21,63,21,63,
  177.          0, 5, 8,11,14,17,20,24,28,32,36,40,45,50,56,63,
  178.         63,63,63,63,63,47,31,16, 0, 0, 0, 0, 0, 0, 0, 0,
  179.          0,16,31,47,63,63,63,63,63,63,63,63,63,55,47,39,
  180.         31,31,31,31,31,31,31,31,31,39,47,55,63,63,63,63,
  181.         63,63,63,63,63,58,54,49,45,45,45,45,45,45,45,45,
  182.         45,49,54,58,63,63,63,63,28,28,28,28,28,21,14, 7,
  183.          0, 0, 0, 0, 0, 0, 0, 0, 0, 7,14,21,28,28,28,28,
  184.         28,28,28,28,28,24,21,17,14,14,14,14,14,14,14,14,
  185.         14,17,21,24,28,28,28,28,28,28,28,28,28,26,24,22,
  186.         20,20,20,20,20,20,20,20,20,22,24,26,28,28,28,28,
  187.         16,16,16,16,16,12, 8, 4, 0, 0, 0, 0, 0, 0, 0, 0,
  188.          0, 4, 8,12,16,16,16,16,16,16,16,16,16,14,12,10,
  189.          8, 8, 8, 8, 8, 8, 8, 8, 8,10,12,14,16,16,16,16,
  190.         16,16,16,16,16,15,13,12,11,11,11,11,11,11,11,11,
  191.         11,12,13,15,16,16,16,16, 0, 0, 0, 0, 0, 0, 0, 0};
  192.  
  193.  
  194. static unsigned char text_regs[MAX_REGS];   /* VGA registers for saved text mode */   
  195.  
  196.  
  197. /* saved text mode palette values */ 
  198. static unsigned char text_red[256];  
  199. static unsigned char text_green[256];  
  200. static unsigned char text_blue[256];  
  201.  
  202. /* saved graphics mode palette values */ 
  203. static unsigned char graph_red[256];  
  204. static unsigned char graph_green[256];  
  205. static unsigned char graph_blue[256];  
  206.  
  207. static int         prv_mode  = TEXT;    /* previous video mode      */
  208. static int         flip_mode = TEXT;    /* flipped video mode       */
  209.  
  210. int         CM  = TEXT;            /* current video mode       */
  211. struct info CI;                /* current video parameters */
  212. int         COL;            /* current color            */
  213.  
  214.  
  215. static int initialized = 0;   /* flag: initialize() called ?  */
  216. static int flip        = 0;   /* flag: executing vga_flip() ? */
  217.  
  218. /* svgalib additions: */
  219.  
  220. int __svgalib_chipset = UNDEFINED;
  221. int __svgalib_driver_report = 1;
  222.     /* report driver used after chipset detection */
  223. int __svgalib_videomemoryused = -1;
  224. int __svgalib_modeX = 0;    /* true after vga_setmodeX() */
  225. int __svgalib_modeflags = 0;    /* copy of flags for current mode */
  226. int __svgalib_critical = 0;    /* indicates blitter is busy */
  227. int __svgalib_screenon = 1;     /* screen visible if != 0 */
  228. int __svgalib_monitortype = MON1024_43I; /* monitor type */
  229. int __svgalib_modeinfo_linearset = 0;    /* IS_LINEAR handled via extended vga_modeinfo */
  230. const int __svgalib_max_modes = MAX_MODES; /* Needed for dynamical allocated tables in mach32.c */
  231.  
  232. static int lastmodenumber = __GLASTMODE; /* Last defined mode */
  233. static int my_pid      = 0;   /* process PID, used with atexit() */
  234. static int currentpage;
  235. static int currentlogicalwidth;
  236. static int currentdisplaystart;
  237. static int mouse_support = 0;
  238. static int mouse_mode = 0;
  239. static int mouse_type = -1;
  240. static int mouse_modem_ctl = 0;
  241. static int runinbackground = 0;
  242. static int oktowrite = 1;
  243. static int modeinfo_mask= ~0;
  244.  
  245. int __svgalib_mem_fd = -1;    /* /dev/mem file descriptor  */
  246. int __svgalib_tty_fd = -1;    /* /dev/tty file descriptor */
  247. int __svgalib_console_fd = -1;    /* /dev/console file descriptor */
  248.  
  249. /* Dummy buffer for mmapping grahics memory; points to 64K VGA framebuffer. */
  250. unsigned char *__svgalib_graph_mem;
  251. /* Exported variable (read-only) is shadowed from internal variable, for */
  252. /* better shared library performance. */
  253. unsigned char *graph_mem;
  254.  
  255. static unsigned char* graph_buf = NULL;  /* saves graphics data during flip */
  256.  
  257. static unsigned char *font_buf1;    /* saved font data - plane 2 */
  258. static unsigned char *font_buf2;    /* saved font data - plane 3 */
  259.  
  260. static struct termios text_termio;  /* text mode termio parameters     */
  261. static struct termios graph_termio; /* graphics mode termio parameters */
  262.  
  263. int flipchar = '\x1b';   /* flip character - initially  ESCAPE */
  264.  
  265.  
  266. /* Chipset specific functions */
  267.  
  268. DriverSpecs *driverspecs = &vga_driverspecs;
  269.  
  270. static void (*setpage)();  /* gives little faster vga_setpage() */
  271. static void (*setrdpage)();
  272. static void (*setwrpage)();
  273.  
  274. static void readconfigfile();
  275.  
  276. DriverSpecs *driverspecslist[] = {
  277.     NULL,    /* chipset undefined */
  278.     &vga_driverspecs,
  279.     #ifdef INCLUDE_ET4000_DRIVER
  280.     &et4000_driverspecs,
  281.     #else
  282.     NULL,
  283.     #endif
  284.     #ifdef INCLUDE_CIRRUS_DRIVER
  285.     &cirrus_driverspecs,
  286.     #else
  287.     NULL,
  288.     #endif
  289.     #ifdef INCLUDE_TVGA_DRIVER
  290.     &tvga8900_driverspecs,
  291.     #else
  292.     NULL,
  293.     #endif
  294.     #ifdef INCLUDE_OAK_DRIVER
  295.     &oak_driverspecs,
  296.     #else
  297.     NULL,
  298.     #endif
  299.     #ifdef INCLUDE_EGA_DRIVER
  300.     &ega_driverspecs,
  301.     #else
  302.     NULL,
  303.     #endif
  304.     #ifdef INCLUDE_S3_DRIVER
  305.     &s3_driverspecs,
  306.     #else
  307.     NULL,
  308.     #endif
  309.     #ifdef INCLUDE_ET3000_DRIVER
  310.     &et3000_driverspecs,
  311.     #else
  312.     NULL,
  313.     #endif
  314.     #ifdef INCLUDE_MACH32_DRIVER
  315.     &mach32_driverspecs,
  316.     #else
  317.     NULL,
  318.     #endif
  319.     #ifdef INCLUDE_GVGA6400_DRIVER
  320.     &gvga6400_driverspecs,
  321.     #else
  322.     NULL,
  323.     #endif
  324.     #ifdef INCLUDE_ARK_DRIVER
  325.     &ark_driverspecs,
  326.     #else
  327.     NULL,
  328.     #endif
  329.     #ifdef INCLUDE_ATI_DRIVER
  330.     &ati_driverspecs,
  331.     #else
  332.     NULL,
  333.     #endif
  334. };
  335.  
  336. static char *driver_names[]={"","VGA","ET4000","Cirrus","TVGA","Oak","EGA","S3","ET3000","Mach32","GVGA6400","ARK","ATI",NULL};
  337.  
  338. /* Chipset drivers */
  339.  
  340. /* vgadrv    Standard VGA (also used by drivers below) */
  341. /* et4000    Tseng ET4000 (from original vgalib) */
  342. /* cirrus    Cirrus Logic GD542x */
  343. /* tvga8900     Trident TVGA 8900/9000 (derived from tvgalib) */
  344. /* oak        Oak Technologies 037/067/077 */
  345. /* egadrv    IBM EGA (subset of VGA) */
  346. /* s3        S3 911 */
  347. /* mach32    ATI MACH32 */
  348. /* ark        ARK Logic */
  349. /* gvga6400    Genoa 6400 (old SVGA) */
  350. /* ati        ATI */
  351.  
  352. /*#define DEBUG*/
  353. /*#define DEBUG_CONF*/ /*Debug config file parsing..*/
  354.  
  355. #ifdef DEBUG
  356. static void _DEBUG(int dnr) {
  357.   static int first = 1;
  358.   FILE *dfile;
  359.  
  360.   dfile = fopen("svgalib.debug", (first ? "w" : "a"));
  361.   first = 0;
  362.   if (dfile == NULL) exit(-1);
  363.   fprintf(dfile, "debug #%d\n", dnr);
  364.   fclose(dfile);
  365.   sync();
  366. }
  367. #else
  368. #define _DEBUG(d)
  369. #endif
  370.  
  371. static void set_graphtermio()
  372. {
  373.         /* set graphics mode termio parameters */
  374.         ioctl(0, TCSETSW, &graph_termio);
  375. }
  376.  
  377.  
  378. static void set_texttermio()
  379. {
  380.     /* restore text mode termio parameters */
  381.     ioctl(0, TCSETSW, &text_termio);
  382. }
  383.  
  384.  
  385. static void disable_interrupt()
  386. {
  387.     struct termios cur_termio;
  388.  
  389.     ioctl(0, TCGETS, &cur_termio);
  390.     cur_termio.c_lflag &= ~ISIG;
  391.     ioctl(0, TCSETSW, &cur_termio);
  392. }
  393.  
  394.  
  395. static void enable_interrupt()
  396. {
  397.     struct termios cur_termio;
  398.  
  399.     ioctl(0, TCGETS, &cur_termio);
  400.     cur_termio.c_lflag |= ISIG;
  401.     ioctl(0, TCSETSW, &cur_termio);
  402. }
  403.  
  404. /* The following is rather messy and inelegant. The only solution I can */
  405. /* see is getting a extra free VT for graphics like XFree86 does. */
  406.  
  407. void __svgalib_waitvtactive() {
  408.     struct stat chkbuf;
  409. /*    struct vt_stat vtstat; */
  410.     int major, minor;
  411.     int fd;
  412.  
  413.     /* get console number we are running in */
  414.     fd = dup(2);    /* stderr */
  415.     fstat(fd, &chkbuf);
  416.     major = chkbuf.st_rdev >> 8;
  417.     minor = chkbuf.st_rdev & 0xff;    /* console number */
  418.  
  419. /*    printf("major = %d, minor = %d\n", major, minor); */
  420.  
  421.     if (major != 4 || minor >= 64) {
  422.         printf("Not running in graphics-capable virtual console.\n");
  423.         exit(-1);
  424.     }
  425.     close(fd);
  426.  
  427.     fd = dup(2);
  428.     ioctl(fd, VT_WAITACTIVE, minor);
  429.     close(fd);
  430. }
  431.  
  432.  
  433. /* Check whether console is graphics-capable. If not, exit. */
  434.  
  435. #if 0
  436.  
  437. /* Check stderr (silly hack). This means stderr cannot be redirected when */
  438. /* runnning a graphics program. */
  439.  
  440. static void checkconsole() {
  441.     struct stat chkbuf;
  442.     int major, minor;
  443.     int fd;
  444.  
  445.     /* get console number we are running in */
  446.     fd = dup(2);    /* stderr */
  447.     fstat(fd, &chkbuf);
  448.     major = chkbuf.st_rdev >> 8;
  449.     minor = chkbuf.st_rdev & 0xff;    /* console number */
  450.  
  451.     if (major != 4 || minor >= 64) {
  452.         printf("Not running in graphics-capable virtual console.\n");
  453.         exit(-1);
  454.     }
  455.     close(fd);
  456. }
  457.  
  458. #else
  459.  
  460. /* Inspired by MKJ's article in Linux Journal #3 and #4. */
  461.  
  462. static int checkconsole() {
  463.     int e;
  464.     struct vt_mode vtm;
  465.     if (__svgalib_console_fd == -1)
  466.         open_devconsole();
  467.     e = ioctl(__svgalib_console_fd, VT_GETMODE, &vtm);
  468.     if (e < 0)
  469.         return 0;
  470.     return 1;
  471. }
  472.  
  473. static void doconsolecheck() {
  474.     if (!checkconsole()) {
  475.         printf("Not running in graphics-capable virtual console.\n");
  476.         exit(-1);
  477.     }
  478. }
  479.  
  480. #endif
  481.  
  482. /* open /dev/mem */
  483. static void open_mem(void) {
  484.     if (__svgalib_mem_fd < 0) 
  485.     if ((__svgalib_mem_fd = open("/dev/mem", O_RDWR) ) < 0) {
  486.         printf("svgalib: Cannot open /dev/mem.\n");
  487.         exit (-1);
  488.     }
  489. }
  490.  
  491. static void open_devconsole(void) {
  492.     if ((__svgalib_console_fd = open("/dev/console", O_RDONLY) ) < 0) {
  493.         printf("svgalib: Cannot open /dev/console.\n");
  494.         exit (-1);
  495.     }
  496. }
  497.  
  498.  
  499. void __vga_get_perm(void)
  500. {
  501.     static int done = 0;
  502.  
  503.     /* Only do this once. */
  504.     if (done)
  505.             return;
  506.     done = 1;
  507.  
  508.     /* Get I/O permissions for VGA registers. */
  509.     /* If IOPERM is set, assume permissions have already been obtained */
  510.     /* by a calling (exec-ing) process, e.g. ioperm(1). */
  511.  
  512.     if (getenv("IOPERM") == NULL)
  513.             if (ioperm(0x3b4, 0x3df - 0x3b4 + 1, 1)) {
  514.             printf("svgalib: Cannot get I/O permissions.\n");
  515.             exit(-1);
  516.         }
  517.  
  518.     /* Open /dev/mem (also needs supervisor rights; ioperm(1) can be */
  519.     /* used together with a special group that has r/w access on */
  520.     /* /dev/mem to facilitate this). */
  521.     open_mem();
  522.  
  523.      open_devconsole();
  524.  
  525.     /* color or monochrome text emulation? */
  526.     if (CHIPSET != EGA)
  527.     color_text = port_in(MIS_R)&0x01;
  528.     else
  529.         color_text = 1;    /* EGA is assumed color */
  530.  
  531.     /* chose registers for color/monochrome emulation */
  532.     if (color_text) {
  533.     CRT_I = CRT_IC;
  534.     CRT_D = CRT_DC;
  535.     IS1_R = IS1_RC;
  536.     } else {
  537.     CRT_I = CRT_IM;
  538.     CRT_D = CRT_DM;
  539.     IS1_R = IS1_RM;
  540.     }
  541. }
  542.  
  543.  
  544. void __vga_delay() {
  545.     int i;
  546.     for (i = 0; i < 10; i++);
  547. }
  548.  
  549. /* The Xfree server uses a slow copy, may help us too ... */
  550. static void slowcpy(unsigned char *dest, unsigned char *src, unsigned bytes)
  551. {
  552.     while (bytes-- > 0)
  553.     *(dest++) = *(src++);
  554. }
  555.  
  556. int __vga_saveregs(unsigned char *regs)
  557. {
  558.     int i;
  559.  
  560.     if (__svgalib_chipset == EGA) {
  561.         /* Special case: Don't save standard VGA registers. */
  562.         return chipset_saveregs(regs);
  563.     }
  564.  
  565.     /* save VGA registers */
  566.     for (i = 0; i < CRT_C; i++) {
  567.      port_out(i, CRT_I); 
  568.      regs[CRT+i] = port_in(CRT_D); 
  569.     }
  570.     for (i = 0; i < ATT_C; i++) {
  571.            port_in(IS1_R);
  572.            __vga_delay();
  573.          port_out(i, ATT_IW); 
  574.          __vga_delay();
  575.          regs[ATT+i] = port_in(ATT_R); 
  576.          __vga_delay();
  577.     }
  578.     for (i = 0; i < GRA_C; i++) {
  579.             port_out(i, GRA_I); 
  580.             regs[GRA+i] = port_in(GRA_D); 
  581.     }
  582.     for (i = 0; i < SEQ_C; i++) {
  583.             port_out(i, SEQ_I); 
  584.             regs[SEQ+i] = port_in(SEQ_D); 
  585.     }
  586.     regs[MIS] = port_in(MIS_R); 
  587.  
  588.     i = chipset_saveregs(regs);        /* save chipset-specific registers */
  589.                     /* i : additional registers */
  590.     if (!SCREENON) {            /* We turned off the screen */
  591.            port_in(IS1_R);
  592.            __vga_delay();
  593.          port_out(0x20, ATT_IW);
  594.     }
  595.     return CRT_C + ATT_C + GRA_C + SEQ_C + 1 + i;
  596. }
  597.  
  598.  
  599. int __vga_setregs(const unsigned char *regs)
  600. {
  601.     int i;
  602.  
  603.     if (__svgalib_chipset == EGA) {
  604.         /* Enable graphics register modification */
  605.     port_out(0x00, GRA_E0);
  606.     port_out(0x01, GRA_E1);
  607.     }
  608.  
  609.     /* update misc output register */
  610.     port_out(regs[MIS], MIS_W);         
  611.  
  612.     /* synchronous reset on */
  613.     port_out(0x00,SEQ_I); 
  614.     port_out(0x01,SEQ_D);            
  615.   
  616.     /* write sequencer registers */
  617.     port_out(1, SEQ_I);
  618.     port_out(regs[SEQ+1]|0x20, SEQ_D);
  619.     for (i = 2; i < SEQ_C; i++) {       
  620.     port_out(i, SEQ_I); 
  621.     port_out(regs[SEQ+i], SEQ_D); 
  622.     }
  623.  
  624.     /* synchronous reset off */
  625.     port_out(0x00, SEQ_I); 
  626.     port_out(0x03, SEQ_D);            
  627.  
  628.     if (__svgalib_chipset != EGA) {  
  629.         /* deprotect CRT registers 0-7 */
  630.         port_out(0x11, CRT_I);          
  631.         port_out(port_in(CRT_D)&0x7F, CRT_D);   
  632.     }
  633.   
  634.     /* write CRT registers */
  635.     for (i = 0; i < CRT_C; i++) {       
  636.     port_out(i, CRT_I); 
  637.     port_out(regs[CRT+i], CRT_D); 
  638.     }
  639.  
  640.     /* write graphics controller registers */
  641.     for (i = 0; i < GRA_C; i++) {       
  642.     port_out(i, GRA_I); 
  643.     port_out(regs[GRA+i], GRA_D); 
  644.     }
  645.      
  646.     /* write attribute controller registers */
  647.     for (i = 0; i < ATT_C; i++) {       
  648.     port_in(IS1_R);   /* reset flip-flop */
  649.     __vga_delay();
  650.     port_out(i, ATT_IW);
  651.     __vga_delay();
  652.     port_out(regs[ATT+i], ATT_IW);
  653.     __vga_delay();
  654.     }
  655.  
  656.     return 0;
  657. }
  658.  
  659. /* We invoke the old interrupt handler after setting text mode */
  660.  
  661. static struct sigaction old_SIGINT_handler;
  662. static struct sigaction old_SIGFPE_handler;
  663. static struct sigaction old_SIGSEGV_handler;
  664. static struct sigaction old_SIGILL_handler;
  665.  
  666. static void restoretextmode(void) {
  667.     /* handle unexpected interrupts - restore text mode and exit */
  668.     if (CM != TEXT) 
  669.         vga_setmode(TEXT);
  670.     if (!__svgalib_screenon) 
  671.         vga_screenon();
  672.     if (__svgalib_tty_fd >= 0)
  673.         ioctl(__svgalib_tty_fd, KDSETMODE, KD_TEXT);
  674. }
  675.  
  676.  
  677. static void SIGINT_handler( int v ) {
  678.     restoretextmode();
  679.     printf("svgalib: Interrupted (ctrl-c pressed)\n");
  680.     sigaction(SIGINT, &old_SIGINT_handler, NULL);
  681.     raise(SIGINT);
  682. }
  683.  
  684. static void SIGFPE_handler( int v ) {
  685.     restoretextmode();
  686.     printf("svgalib: Floating point exception or division by zero\n");
  687.     sigaction(SIGFPE, &old_SIGFPE_handler, NULL);
  688.     raise(SIGFPE);
  689. }
  690.  
  691. static void SIGSEGV_handler( int v ) {
  692.     restoretextmode();
  693.     printf("svgalib: Segment violation\n");
  694.     sigaction(SIGSEGV, &old_SIGSEGV_handler, NULL);
  695.     raise(SIGSEGV);
  696. }
  697.  
  698. static void SIGILL_handler( int v ) {
  699.     restoretextmode();
  700.     printf("svgalib: Illegal instruction\n");
  701.     sigaction(SIGILL, &old_SIGILL_handler, NULL);
  702.     raise(SIGILL);
  703. }
  704.  
  705. int __vga_getchipset(void) {
  706.     readconfigfile();    /* Make sure the config file is read. */
  707.  
  708.     __vga_get_perm();
  709.     if (CHIPSET == UNDEFINED) {
  710.         CHIPSET = VGA; /* Protect against recursion */
  711.         #ifdef INCLUDE_MACH32_DRIVER_TEST
  712.         if (mach32_driverspecs.test())
  713.             CHIPSET = MACH32;
  714.         else
  715.         #endif
  716.         #ifdef INCLUDE_EGA_DRIVER_TEST
  717.         if (ega_driverspecs.test())
  718.             CHIPSET = EGA;
  719.         else
  720.         #endif
  721.         #ifdef INCLUDE_ET4000_DRIVER_TEST
  722.         if (et4000_driverspecs.test())
  723.             CHIPSET = ET4000;
  724.         else
  725.         #endif
  726.         #ifdef INCLUDE_TVGA_DRIVER_TEST
  727.         if (tvga8900_driverspecs.test())
  728.             CHIPSET = TVGA8900;
  729.         else
  730.         #endif
  731.         #ifdef INCLUDE_CIRRUS_DRIVER_TEST
  732.         /* The Cirrus detection is not very clean. */
  733.         if (cirrus_driverspecs.test())
  734.             CHIPSET = CIRRUS;
  735.         else
  736.         #endif
  737.         #ifdef INCLUDE_OAK_DRIVER_TEST
  738.         if (oak_driverspecs.test())
  739.             CHIPSET = OAK;
  740.         else
  741.         #endif
  742.         #ifdef INCLUDE_S3_DRIVER_TEST
  743.         if (s3_driverspecs.test())
  744.             CHIPSET = S3;
  745.         else
  746.         #endif
  747.         #ifdef INCLUDE_ET3000_DRIVER_TEST
  748.         if (et3000_driverspecs.test())
  749.             CHIPSET = ET3000;
  750.         else
  751.         #endif
  752.         #ifdef INCLUDE_ARK_DRIVER_TEST
  753.         if (ark_driverspecs.test())
  754.             CHIPSET = ARK;
  755.         else
  756.         #endif
  757.         #ifdef INCLUDE_GVGA6400_DRIVER_TEST
  758.         if (gvga6400_driverspecs.test())
  759.             CHIPSET = GVGA6400;
  760.         else
  761.         #endif
  762.         #ifdef INCLUDE_ATI_DRIVER_TEST
  763.         if (ati_driverspecs.test())
  764.             CHIPSET = ATI;
  765.         else
  766.         #endif
  767.         
  768.         if (vga_driverspecs.test())
  769.             CHIPSET = VGA;
  770.         else
  771.         /* else */
  772.         {
  773.             fprintf(stderr, "svgalib: Cannot find EGA or VGA graphics device.\n");
  774.             exit(1);
  775.         }
  776.         setpage = driverspecs->setpage;
  777.         setrdpage = driverspecs->setrdpage;
  778.         setwrpage = driverspecs->setwrpage;
  779.     }
  780.     return CHIPSET;
  781. }
  782.  
  783. void vga_setchipset( int c ) {
  784.     CHIPSET = c;
  785.     #ifdef DEBUG
  786.     printf("Setting chipset\n");
  787.     #endif
  788.     if (c == UNDEFINED)
  789.         return;
  790.     if (driverspecslist[c] == NULL) {
  791.         printf("svgalib: Invalid chipset. The driver may not be compiled in.\n");
  792.         CHIPSET = UNDEFINED;
  793.         return;
  794.     }
  795.     __vga_get_perm();
  796.     driverspecslist[c]->init(0, 0, 0);
  797.     setpage = driverspecs->setpage;
  798.     setrdpage = driverspecs->setrdpage;
  799.     setwrpage = driverspecs->setwrpage;
  800. }
  801.  
  802. void vga_setchipsetandfeatures( int c, int par1, int par2 ) {
  803.     CHIPSET = c;
  804.     #ifdef DEBUG
  805.     printf("Forcing chipset and features\n");
  806.     #endif
  807.     __vga_get_perm();
  808.     driverspecslist[c]->init(1, par1, par2);
  809.     #ifdef DEBUG
  810.     printf("Finished forcing chipset and features\n");
  811.     #endif
  812.     setpage = driverspecs->setpage;
  813.     setrdpage = driverspecs->setrdpage;
  814.     setwrpage = driverspecs->setwrpage;
  815. }
  816.  
  817.  
  818. static void savepalette(unsigned char *red, unsigned char *green, 
  819. unsigned char *blue) {
  820.     int i;
  821.  
  822.     if (CHIPSET == EGA)
  823.         return;
  824.  
  825.     if ((__svgalib_chipset == MACH32) && SVGAMODE(CM))
  826.            {
  827.            /* Actually the same but we are in 8514 mode and the dac
  828.            does not respond to the VGA circuitry anymore... */
  829.  
  830.            port_out(0, PEL8514_IR); 
  831.            for (i = 0; i < 256; i++) {
  832.                __vga_delay();
  833.                *(red++)   = port_in(PEL8514_D);
  834.                __vga_delay();
  835.                *(green++) = port_in(PEL8514_D);
  836.                __vga_delay();
  837.                *(blue++)  = port_in(PEL8514_D);
  838.            }
  839.        return;
  840.        }
  841.  
  842.         /* save graphics mode palette - first select palette index 0 */
  843.         port_out(0, PEL_IR); 
  844.  
  845.         /* read RGB components - index is autoincremented */
  846.         for (i = 0; i < 256; i++) {
  847.             __vga_delay();
  848.             *(red++)   = port_in(PEL_D);
  849.             __vga_delay();
  850.             *(green++) = port_in(PEL_D);
  851.             __vga_delay();
  852.             *(blue++)  = port_in(PEL_D);
  853.         }
  854. }
  855.  
  856. static void restorepalette( const unsigned char *red,
  857. const unsigned char *green, const unsigned char *blue ) {
  858.     int i;
  859.  
  860.     if (CHIPSET == EGA)
  861.         return;
  862.  
  863.     if ((__svgalib_chipset == MACH32) && SVGAMODE(CM))
  864.            {
  865.            /* Actually the same but we are in 8514 mode and the dac
  866.            does not respond to the VGA circuitry anymore... */
  867.  
  868.            port_out(0, PEL8514_IW); 
  869.            for (i = 0; i < 256; i++) {
  870.                __vga_delay();
  871.                port_out(*(red++), PEL8514_D);
  872.                __vga_delay();
  873.                port_out(*(green++), PEL8514_D);
  874.                __vga_delay();
  875.                port_out(*(blue++), PEL8514_D);
  876.            }
  877.        return;
  878.        }
  879.  
  880.         /* restore saved palette */
  881.         port_out(0, PEL_IW); 
  882.  
  883.         /* read RGB components - index is autoincremented */
  884.         for (i = 0; i < 256; i++) {
  885.             __vga_delay();
  886.             port_out(*(red++), PEL_D);
  887.             __vga_delay();
  888.             port_out(*(green++), PEL_D);
  889.             __vga_delay();
  890.             port_out(*(blue++), PEL_D);
  891.         }
  892. }
  893.  
  894.  
  895. /* Virtual console switching */
  896.  
  897. static int forbidvtrelease = 0;
  898. static int forbidvtacquire = 0;
  899. static int lock_count = 0;
  900. static int release_flag = 0;
  901.  
  902. static void takevtcontrol();
  903.  
  904. void __vga_flipaway();
  905. static void vga_flipback();
  906.  
  907. static void releasevt_signal( int n ) {
  908.     struct sigaction siga;
  909.     if (lock_count) {
  910.         release_flag = 1;
  911.         return;
  912.     }
  913.     #ifdef DEBUG
  914.     printf("Release request.\n");
  915.     #endif
  916.     forbidvtacquire = 1;
  917.     SETSIG(siga, SIGUSR1, releasevt_signal);
  918.     if (forbidvtrelease) {
  919.         forbidvtacquire = 0;
  920.         ioctl(__svgalib_tty_fd, VT_RELDISP, 0);
  921.         return;
  922.     }
  923.     __vga_flipaway();
  924.     ioctl(__svgalib_tty_fd, VT_RELDISP, 1);
  925.     #ifdef DEBUG
  926.     printf("Finished release.\n");
  927.     #endif
  928.     forbidvtacquire = 0;
  929.  
  930.     /* Suspend program until switched to again. */
  931.     #ifdef DEBUG
  932.     printf("Suspended.\n");
  933.     #endif
  934.     oktowrite = 0;
  935.     if (!runinbackground)
  936.         __svgalib_waitvtactive();
  937.     #ifdef DEBUG
  938.     printf("Waked.\n");
  939.     #endif
  940. } 
  941.  
  942. static void acquirevt_signal( int n ) {
  943.     struct sigaction siga;
  944.     #ifdef DEBUG
  945.     printf("Acquisition request.\n");
  946.     #endif
  947.     forbidvtrelease = 1;
  948.     SETSIG(siga, SIGUSR2, acquirevt_signal);
  949.     if (forbidvtacquire) {
  950.         forbidvtrelease = 0;
  951.         return;
  952.     }
  953.     vga_flipback();
  954.     ioctl(__svgalib_tty_fd, VT_RELDISP, VT_ACKACQ);
  955.     #ifdef DEBUG
  956.     printf("Finished acquisition.\n");
  957.     #endif
  958.     forbidvtrelease = 0;
  959.     oktowrite = 1;
  960. }
  961.  
  962. static struct vt_mode oldvtmode;
  963. static struct vt_mode newvtmode;
  964.  
  965. void takevtcontrol() {
  966.         struct sigaction siga;
  967.  
  968.         ioctl(__svgalib_tty_fd, VT_GETMODE, &oldvtmode);
  969.         newvtmode = oldvtmode;
  970.         newvtmode.mode = VT_PROCESS;    /* handle VT changes */
  971.         newvtmode.relsig = SIGUSR1;    /* I didn't find SIGUSR1/2 anywhere */
  972.         newvtmode.acqsig = SIGUSR2;    /* in the kernel sources, so I guess */
  973.                         /* they are free */
  974.     SETSIG(siga, SIGUSR1, releasevt_signal);
  975.         SETSIG(siga, SIGUSR2, acquirevt_signal);
  976.         ioctl(__svgalib_tty_fd, VT_SETMODE, &newvtmode);
  977. }
  978.  
  979. static void __vga_mmap()
  980. {
  981.     #if 1
  982.     /* This may waste 64K; mmap can probably do better by now. */
  983.     /* valloc allocates aligned on page boundary */
  984.     if ((__svgalib_graph_mem = valloc(GRAPH_SIZE)) == NULL) {
  985.     printf("svgalib: allocation error \n");
  986.     exit (-1);
  987.     }
  988.     __svgalib_graph_mem = (unsigned char *)mmap(
  989.     (caddr_t)GM,
  990.     GRAPH_SIZE,
  991.     PROT_READ|PROT_WRITE,
  992.     MAP_SHARED|MAP_FIXED,
  993.     __svgalib_mem_fd,
  994.     GRAPH_BASE
  995.     );
  996.     #endif
  997.     #if 0
  998.     /* This assumes pl10+. */
  999.     /* Still seems to waste 64K, so don't bother. */
  1000.     GM = (unsigned char *)mmap(
  1001.     (caddr_t) 0,
  1002.     GRAPH_SIZE,
  1003.     PROT_READ|PROT_WRITE,
  1004.     MAP_SHARED,
  1005.     __svgalib_mem_fd,
  1006.     GRAPH_BASE
  1007.     );
  1008.     #endif
  1009.     graph_mem = __svgalib_graph_mem;    /* Exported variable. */
  1010. }
  1011.  
  1012. static void __vga_atexit(void) {
  1013.     if (getpid() == my_pid) /* protect against forked processes */
  1014.     restoretextmode(); 
  1015. }
  1016.  
  1017. static void setcoloremulation() {
  1018.     /* shift to color emulation */
  1019.     CRT_I = CRT_IC;
  1020.     CRT_D = CRT_DC;
  1021.     IS1_R = IS1_RC;
  1022.     if (CHIPSET != EGA)
  1023.     port_out(port_in(MIS_R)|0x01, MIS_W); 
  1024. }
  1025.  
  1026. static void initialize()
  1027. {
  1028.     int i;
  1029.     struct sigaction siga;
  1030.  
  1031.     doconsolecheck();
  1032.  
  1033.     /* Make sure that textmode is restored at exit(). */
  1034.     if (my_pid == 0)
  1035.     my_pid = getpid();
  1036.     atexit(__vga_atexit);
  1037.  
  1038. #ifndef DONT_WAIT_VC_ACTIVE
  1039.     __svgalib_waitvtactive();
  1040. #endif
  1041.  
  1042.     /* save text mode termio parameters */
  1043.     ioctl(0, TCGETS, &text_termio);
  1044.  
  1045.     graph_termio = text_termio;
  1046.  
  1047.     /* change termio parameters to allow our own I/O processing */
  1048.     graph_termio.c_iflag &= ~(BRKINT|PARMRK|INPCK|IUCLC|IXON|IXOFF);
  1049.     graph_termio.c_iflag |=  (IGNBRK|IGNPAR);
  1050.  
  1051.     graph_termio.c_oflag &= ~(ONOCR);
  1052.  
  1053.     graph_termio.c_lflag &= ~(ICANON|ECHO|ECHOE|ECHOK|ECHONL|NOFLSH);
  1054.     graph_termio.c_lflag |= (ISIG);   /* enable interrupt */
  1055.  
  1056.     graph_termio.c_cc[VMIN] = 1;
  1057.     graph_termio.c_cc[VTIME] = 0;
  1058.     graph_termio.c_cc[VSUSP] = 0;   /* disable suspend */
  1059.  
  1060.     disable_interrupt();
  1061.  
  1062.     __vga_getchipset();    /* make sure a chipset has been selected */
  1063.     chipset_unlock();
  1064.     
  1065. #ifdef USE_DEVTTY
  1066.     if ((__svgalib_tty_fd = open("/dev/tty", O_RDONLY)) < 0) {
  1067.     printf("svgalib: can't open /dev/tty \n");
  1068.     exit(-1);
  1069.     }
  1070. #else
  1071.     /* open /dev/tty0 - current virtual console */
  1072.     if ((__svgalib_tty_fd = open("/dev/tty0", O_RDONLY) ) < 0) {
  1073.     printf("svgalib: can't open /dev/tty0 \n");
  1074.     exit (-1);
  1075.     }
  1076. #endif
  1077. /*    console = fdopen(devtty_fd, "r"); */
  1078.  
  1079. #if 0     
  1080.     /* Check for EGA/VGA display */
  1081. /*   linux/kd.h defines this function but doesn't work (or am I wrong) ? */
  1082.     if (ioctl(__svgalib_tty_fd, KDDISPTYPE, &display_type)){
  1083.     printf("VGAlib: can't get display type\n");
  1084.     exit (-1);
  1085.     }
  1086.     if (display_type != KD_EGA) {
  1087.     printf("VGAlib: EGA/VGA display required\n");
  1088.     exit(-1);
  1089.     }
  1090. #endif
  1091.  
  1092.     /* disable text output to console */
  1093.     ioctl(__svgalib_tty_fd, KDSETMODE, KD_GRAPHICS);
  1094.  
  1095. /* What the hell is this?!?? Why should using a mouse prevent  */
  1096. /* you from switching vt's ??                                  */
  1097. /*  if (!mouse_support)       */
  1098.     if (1)
  1099.         takevtcontrol();    /* HH: Take control over VT */
  1100.     
  1101. /*    vga_lockvc(); */
  1102.  
  1103.     /* open /dev/mem */
  1104.     open_mem();
  1105.  
  1106.     /* mmap graphics memory */
  1107.  
  1108.     __vga_mmap();
  1109.  
  1110.     if ((long)GM < 0) {
  1111.     printf("svgalib: mmap error \n");
  1112.     exit (-1);
  1113.     }
  1114.  
  1115.     /* disable video */
  1116.     vga_screenoff();
  1117.  
  1118.     /* Sanity check: (from painful experience) */
  1119.  
  1120.     i = __vga_saveregs(text_regs);
  1121.     if(i > MAX_REGS)
  1122.     {
  1123.     puts("svgalib: FATAL internal error:");
  1124.     printf("Set MAX_REGS at least to %d in src/driver.h and recompile everything.\n",
  1125.         i);
  1126.     exit(1);
  1127.     }
  1128.  
  1129.     /* This appears to fix the Trident 8900 rebooting problem. */
  1130.     if (__svgalib_chipset == TVGA8900) {
  1131.         port_out(0x0c, SEQ_I);              /* reg 12 */
  1132.         text_regs[EXT + 11] = port_in(SEQ_D);
  1133.         port_out(0x1f, CRT_I);
  1134.         text_regs[EXT + 12] = port_in(CRT_D);
  1135.     }
  1136.  
  1137.     /* save text mode palette - first select palette index 0 */
  1138.     port_out(0, PEL_IR);
  1139.  
  1140.     /* read RGB components - index is autoincremented */
  1141.     savepalette(text_red, text_green, text_blue);
  1142.  
  1143.     /* shift to color emulation */
  1144.     setcoloremulation();
  1145.  
  1146.     /* save font data - first select a 16 color graphics mode */
  1147.     driverspecs->setmode(GPLANE16);
  1148.  
  1149.     /* Allocate space for textmode font. */
  1150.     font_buf1 = malloc(FONT_SIZE * 2);
  1151.     font_buf2 = font_buf1 + FONT_SIZE;
  1152.  
  1153.     /* save font data in plane 2 */
  1154.     port_out(0x04, GRA_I); 
  1155.     port_out(0x02, GRA_D); 
  1156.     slowcpy(font_buf1, GM, FONT_SIZE);
  1157.  
  1158.     /* save font data in plane 3 */
  1159.     port_out(0x04, GRA_I); 
  1160.     port_out(0x03, GRA_D);
  1161.     slowcpy(font_buf2, GM, FONT_SIZE);
  1162.  
  1163.     initialized = 1;
  1164.     /* do our own interrupt handling */
  1165.     SETSIG2(siga, SIGINT, SIGINT_handler, old_SIGINT_handler);
  1166.  
  1167.     /* Restore textmode after segment violation and math exception */
  1168.     /* I wonder why vgalib didn't do this */
  1169.         SETSIG2(siga, SIGSEGV, SIGSEGV_handler, old_SIGSEGV_handler);
  1170.         SETSIG2(siga, SIGFPE, SIGFPE_handler, old_SIGFPE_handler);
  1171.         SETSIG2(siga, SIGILL, SIGILL_handler, old_SIGILL_handler);
  1172.  
  1173.     /* VMEM setting moved into setmode - Michael. */
  1174.  
  1175. /*    vga_unlockvc(); */
  1176. }
  1177.  
  1178.  
  1179. inline void vga_setpage( int p ) {
  1180.     if (p == currentpage)
  1181.         return;
  1182.     setpage(p);
  1183.     currentpage = p;
  1184. }
  1185.  
  1186.  
  1187. void vga_setreadpage( int p ) {
  1188.     if ( p == currentpage)
  1189.         return;
  1190.     setrdpage( p);
  1191.     currentpage = -1;
  1192. }
  1193.  
  1194.  
  1195. void vga_setwritepage( int p ) {
  1196.     if ( p == currentpage)
  1197.         return;
  1198.     setwrpage( p);
  1199.     currentpage = -1;
  1200. }
  1201.  
  1202.  
  1203. void vga_safety_fork(void (*shutdown_routine)())
  1204. {
  1205.     int childpid;
  1206.  
  1207.     if (initialized)
  1208.     {    
  1209.         printf("svgalib: warning: vga_safety_fork() called when already initialized\n");
  1210.         return;
  1211.     }
  1212.  
  1213.     initialize();
  1214.  
  1215.     childpid = fork();
  1216.     if (childpid < 0)
  1217.     {
  1218.         printf("VGAlib: warning: can't fork to enhance reliability; proceeding anyway\n");
  1219.         return;
  1220.     }
  1221.     if (childpid)
  1222.     {
  1223.         while (waitpid(childpid, 0, WUNTRACED) != childpid);
  1224.         if (shutdown_routine)
  1225.             shutdown_routine();
  1226.         vga_setmode(TEXT);
  1227.         exit(0); /* XXX pass back true exit status */
  1228.     }
  1229.  
  1230.     /* These need to be done again because the child doesn't inherit them.  */
  1231.     __vga_get_perm();
  1232.     __vga_mmap();
  1233. }
  1234.  
  1235.  
  1236. static void prepareforfontloading() {
  1237.     if (__svgalib_chipset == CIRRUS) {
  1238.         outb(0x3c4, 0x0f);
  1239.         /* Disable CRT FIFO Fast-Page mode. */
  1240.         outb(0x3c5, inb(0x3c5) | 0x40);
  1241.     }
  1242. }
  1243.  
  1244. static void fontloadingcomplete() {
  1245.     if (__svgalib_chipset == CIRRUS) {
  1246.         outb(0x3c4, 0x0f);
  1247.         /* Re-enable CRT FIFO Fast-Page mode. */
  1248.         outb(0x3c5, inb(0x3c5) & 0xbf);
  1249.     }
  1250. }
  1251.  
  1252.  
  1253. int vga_setmode(int mode) 
  1254. {
  1255.     if (!initialized)
  1256.         initialize();
  1257.  
  1258.     if (mode != TEXT && !chipset_modeavailable(mode))
  1259.         return -1;
  1260.  
  1261. /*    if (!flip)
  1262.     vga_lockvc(); */
  1263.     disable_interrupt();
  1264.  
  1265.     prv_mode = CM;
  1266.     CM       = mode;
  1267.  
  1268.     /* disable video */
  1269.     vga_screenoff();
  1270.  
  1271.     /* Should be more robust (eg. grabbed X modes) */
  1272.     if (   __vga_getchipset() == ET4000
  1273.     && prv_mode != G640x480x256
  1274.     && SVGAMODE(prv_mode)           )
  1275.         chipset_setmode(G640x480x256, prv_mode);
  1276.  
  1277.     if (mode == TEXT) {
  1278.         /* Returning to textmode. */
  1279.  
  1280.         if (prv_mode != TEXT && mouse_mode == prv_mode) {
  1281.             #ifdef DEBUG
  1282.             printf("svgalib: Closing mouse.\n");
  1283.             #endif
  1284.             mouse_close();
  1285.             mouse_mode = 0;
  1286.             /* vga_unlockvc(); */
  1287.         }
  1288.     
  1289.     if (SVGAMODE(prv_mode))
  1290.         vga_setpage(0);
  1291.  
  1292.  
  1293.     /* The extended registers are restored either by the */
  1294.     /* chipset setregs function, or the chipset setmode function. */
  1295.  
  1296.         /* restore font data - first select a 16 color graphics mode */
  1297.         /* Note: this should restore the old extended registers if */
  1298.         /* setregs is not defined for the chipset. */
  1299.         driverspecs->setmode(GPLANE16, prv_mode);
  1300.  
  1301.     if (CHIPSET != EGA)
  1302.         /* restore old extended regs */
  1303.         chipset_setregs(text_regs, mode);
  1304.  
  1305.     /* disable Set/Reset Register */
  1306.         port_out(0x01, GRA_I ); 
  1307.         port_out(0x00, GRA_D );   
  1308.  
  1309.     prepareforfontloading();
  1310.  
  1311.         /* restore font data in plane 2 - necessary for all VGA's */
  1312.         port_out(0x02, SEQ_I ); 
  1313.         port_out(0x04, SEQ_D );
  1314.     slowcpy(GM, font_buf1, FONT_SIZE);
  1315.  
  1316.         /* restore font data in plane 3 - necessary for Trident VGA's */
  1317.         port_out(0x02, SEQ_I ); 
  1318.         port_out(0x08, SEQ_D );   
  1319.     slowcpy(GM, font_buf2, FONT_SIZE);
  1320.  
  1321.     fontloadingcomplete();
  1322.  
  1323.         /* change register adresses if monochrome text mode */
  1324.         /* EGA is assumed to use color emulation. */
  1325.         if (!color_text) {
  1326.             CRT_I = CRT_IM;
  1327.             CRT_D = CRT_DM;
  1328.             IS1_R = IS1_RM;
  1329.             port_out(port_in(MIS_R)&0xFE, MIS_W); 
  1330.         }
  1331.  
  1332.         /* restore saved palette */
  1333.         restorepalette(text_red, text_green, text_blue);
  1334.  
  1335.     /* restore text mode VGA registers */
  1336.         __vga_setregs(text_regs);
  1337.  
  1338.     /* Set VMEM to some minimum value .. probably pointless.. */
  1339.         {
  1340.         vga_claimvideomemory(12);
  1341.         }
  1342.  
  1343. /*        if (!flip) */
  1344.         /* enable text output - restores the screen contents */ 
  1345.               ioctl(__svgalib_tty_fd, KDSETMODE, KD_TEXT);
  1346.  
  1347.     usleep(MODESWITCHDELAY);    /* wait for signal to stabilize */
  1348.  
  1349.         /* enable video */
  1350.     vga_screenon();
  1351.  
  1352.       if (!flip)
  1353.             /* restore text mode termio */
  1354.             set_texttermio();
  1355.     } else {
  1356.         /* Setting a graphics mode. */
  1357.  
  1358.     /* disable text output */
  1359.     ioctl(__svgalib_tty_fd, KDSETMODE, KD_GRAPHICS);
  1360.     
  1361.     if (SVGAMODE(prv_mode)) {
  1362.         /* The current mode is an SVGA mode, and we now want to */
  1363.         /* set a standard VGA mode. Make sure the extended regs */
  1364.         /* are restored. */
  1365.         /* Also used when setting another SVGA mode to hopefully */
  1366.         /* eliminate lock-ups. */
  1367.         vga_setpage(0);
  1368.         chipset_setregs(text_regs, mode);
  1369.             /* restore old extended regs */
  1370.     }
  1371.  
  1372.         /* shift to color emulation */
  1373.         setcoloremulation();
  1374.  
  1375.         CI.xdim = infotable[mode].xdim;
  1376.         CI.ydim = infotable[mode].ydim;
  1377.         CI.colors = infotable[mode].colors;
  1378.         CI.xbytes = infotable[mode].xbytes;
  1379.         CI.bytesperpixel = infotable[mode].bytesperpixel;
  1380.  
  1381.     chipset_setmode(mode, prv_mode);
  1382.  
  1383.         MODEX = 0;
  1384.  
  1385.     /* Set default claimed memory (moved here from initialize - Michael.) */
  1386.     if (mode == G320x200x256)
  1387.         VMEM = 65536;
  1388.     else
  1389.     if (STDVGAMODE(mode))
  1390.         VMEM = 256 * 1024; /* Why always 256K ??? - Michael */
  1391.     else {
  1392.         vga_modeinfo *modeinfo;
  1393.  
  1394.         modeinfo = vga_getmodeinfo(mode);
  1395.         VMEM = modeinfo->linewidth * modeinfo->height;
  1396.     }
  1397.  
  1398.         if (!flip) {
  1399.                 /* set default palette */
  1400.                 if (CI.colors <= 256) 
  1401.           restorepalette(default_red, default_green, default_blue);
  1402.  
  1403.                 /* clear screen (sets current color to 15) */
  1404.                 currentpage = -1;
  1405.                 vga_clear();
  1406.  
  1407.                 if (SVGAMODE(__svgalib_cur_mode))
  1408.                     vga_setpage(0);
  1409.         }
  1410.  
  1411.         currentpage = -1;
  1412.         currentlogicalwidth = CI.xbytes;
  1413.         currentdisplaystart = 0;
  1414.  
  1415.     usleep(MODESWITCHDELAY);    /* wait for signal to stabilize */
  1416.  
  1417.         /* enable video */
  1418.     if (!flip)
  1419.       vga_screenon();
  1420.  
  1421.     if (mouse_support) {
  1422.         #ifdef DEBUG
  1423.         printf("svgalib: Opening mouse (type = %x).\n", mouse_type|mouse_modem_ctl);
  1424.         #endif
  1425.         if (mouse_init("/dev/mouse", mouse_type|mouse_modem_ctl, MOUSE_DEFAULTSAMPLERATE))
  1426.             printf("svgalib: Failed to initialize mouse.\n");
  1427.         else {
  1428.             /* vga_lockvc(); */
  1429.             mouse_setxrange(0, CI.xdim - 1);
  1430.             mouse_setyrange(0, CI.ydim - 1);
  1431.             mouse_setwrap(MOUSE_NOWRAP);
  1432.             mouse_mode = mode;
  1433.         }
  1434.     }
  1435.  
  1436.       if (!flip)
  1437.             /* set graphics mode termio */
  1438.             set_graphtermio();
  1439.         else
  1440.             enable_interrupt();
  1441.             
  1442.     {
  1443.         vga_modeinfo *modeinfo;
  1444.         modeinfo = vga_getmodeinfo(mode);
  1445.         MODEX = ((MODEFLAGS=modeinfo->flags) & IS_MODEX);
  1446.     }
  1447.  
  1448.     }
  1449.  
  1450. /*    if (!flip)
  1451.     vga_unlockvc(); */
  1452.  
  1453.     return 0;  
  1454. }
  1455.  
  1456. void vga_gettextfont( void *font ) {
  1457.     memcpy(font, font_buf1, FONT_SIZE);
  1458. }
  1459.  
  1460. void vga_puttextfont( void *font ) {
  1461.     memcpy(font_buf1, font, FONT_SIZE);
  1462.     memcpy(font_buf2, font, FONT_SIZE);
  1463. }
  1464.  
  1465. void vga_gettextmoderegs( void *regs ) {
  1466.     memcpy(regs, text_regs, MAX_REGS);
  1467. }
  1468.  
  1469. void vga_settextmoderegs( void *regs ) {
  1470.     memcpy(text_regs, regs, MAX_REGS);
  1471. }
  1472.  
  1473. int vga_getcurrentmode() {
  1474.     return CM;
  1475. }
  1476.  
  1477. int vga_getcurrentchipset() {
  1478.     return __vga_getchipset();
  1479. }
  1480.  
  1481. void vga_disabledriverreport() {
  1482.     DREP = 0;
  1483. }
  1484.  
  1485. vga_modeinfo *vga_getmodeinfo( int mode ) {
  1486.     static vga_modeinfo modeinfo;
  1487.     int is_modeX = (CM == mode) && MODEX;
  1488.  
  1489.     if (mode > vga_lastmodenumber())
  1490.         return NULL;
  1491.     __vga_getchipset();
  1492.     modeinfo.width = infotable[mode].xdim;
  1493.     modeinfo.height = infotable[mode].ydim;
  1494.     modeinfo.bytesperpixel = infotable[mode].bytesperpixel;
  1495.     modeinfo.colors = infotable[mode].colors;
  1496.     if (is_modeX) {
  1497.         modeinfo.linewidth = modeinfo.width / 4;
  1498.         modeinfo.bytesperpixel = 0;
  1499.     }
  1500.     else
  1501.         modeinfo.linewidth = infotable[mode].xbytes;
  1502.     modeinfo.flags = 0;
  1503.     if (mode == TEXT)
  1504.         return &modeinfo;
  1505.     if ((STDVGAMODE(mode) && mode != G320x200x256) || is_modeX)
  1506.         vga_driverspecs.getmodeinfo(mode, &modeinfo);
  1507.     else
  1508.         /* Get chipset specific info for SVGA modes and */
  1509.         /* 320x200x256 (chipsets may support more pages) */
  1510.         chipset_getmodeinfo(mode, &modeinfo);
  1511.  
  1512.     if (modeinfo.colors == 256 && modeinfo.bytesperpixel == 0)
  1513.       modeinfo.flags |= IS_MODEX;
  1514.     if (mode > __GLASTMODE)
  1515.       modeinfo.flags |= IS_DYNAMICMODE;
  1516.  
  1517.     /* Maskout CAPABLE_LINEAR if requested by config file */
  1518.     modeinfo.flags&=modeinfo_mask;
  1519.  
  1520.     /* If all needed info is here, signal if linear support has been enabled */
  1521.     if( (modeinfo.flags&(CAPABLE_LINEAR|EXT_INFO_AVAILABLE)) ==
  1522.                 (CAPABLE_LINEAR|EXT_INFO_AVAILABLE) ) {
  1523.         modeinfo.flags |= __svgalib_modeinfo_linearset;
  1524.     }
  1525.  
  1526.     return &modeinfo;
  1527. }
  1528.  
  1529. int vga_hasmode(int mode)
  1530. {
  1531.     readconfigfile();    /* Make sure the config file is read. */
  1532.     __vga_getchipset();    /* Make sure the chipset is known. */
  1533.     if (mode == TEXT)
  1534.         return 1;
  1535.     return (chipset_modeavailable(mode) != 0);
  1536. }
  1537.  
  1538.  
  1539. int vga_lastmodenumber(void)
  1540. {
  1541.     __vga_getchipset();
  1542.     return lastmodenumber;
  1543. }
  1544.  
  1545.  
  1546. int __vga_addmode(int xdim, int ydim, int cols, int xbytes, int bytespp)
  1547. {
  1548.     int i;
  1549.  
  1550.     for (i=0; i <= lastmodenumber; ++i)
  1551.        if ( infotable[i].xdim   == xdim &&
  1552.         infotable[i].ydim   == ydim &&
  1553.         infotable[i].colors == cols &&
  1554.         infotable[i].bytesperpixel == bytespp &&
  1555.         infotable[i].xbytes == xbytes  )
  1556.           return i;
  1557.     if (lastmodenumber >= MAX_MODES-1)
  1558.       return -1; /* no more space available */
  1559.     ++lastmodenumber;
  1560.     infotable[lastmodenumber].xdim   = xdim;
  1561.     infotable[lastmodenumber].ydim   = ydim;
  1562.     infotable[lastmodenumber].colors = cols;
  1563.     infotable[lastmodenumber].xbytes = xbytes;
  1564.     infotable[lastmodenumber].bytesperpixel = bytespp;
  1565.     return lastmodenumber;
  1566. }
  1567.  
  1568.  
  1569. int vga_setcolor(int color)
  1570. {
  1571.     switch (CI.colors) {
  1572.     case  2: if (color != 0)
  1573.            color = 15;
  1574.     case 16: /* update set/reset register */
  1575.              port_out(0x00, GRA_I ); 
  1576.              port_out((color&15), GRA_D );
  1577.          break;
  1578.     default: COL = color;
  1579.                  break;
  1580.     }
  1581.  
  1582.     return 0;
  1583. }
  1584.  
  1585.  
  1586. int vga_screenoff()
  1587. {
  1588.     /* Dunno how to support that in MACH32 modes...*/
  1589.     /* But it is used to switch the VGA off for better
  1590.        mem access performance...*/
  1591.     /* turn off screen for faster VGA memory acces */
  1592.     if (CHIPSET != EGA) {
  1593.         port_out(0x01, SEQ_I);           
  1594.         port_out(port_in(SEQ_D)|0x20, SEQ_D);
  1595.     }
  1596.     /* Disable video output */
  1597. #ifdef DISABLE_VIDEO_OUTPUT
  1598.     port_in(IS1_R);
  1599.     __vga_delay();
  1600.     port_out(0x00, ATT_IW);
  1601. #endif
  1602.  
  1603.     SCREENON = 0;
  1604.     return 0;
  1605. }
  1606.  
  1607.  
  1608. int vga_screenon()
  1609. {
  1610.     /* Dunno how to support that in MACH32 modes...*/
  1611.     if ((__svgalib_chipset == MACH32) && SVGAMODE(CM))
  1612.     {
  1613.     /* Warning! This is also used for faking of vgapal.c!*/
  1614.     /* Not needed anymore... had to hack vgapal.c anyway..*/
  1615.     /* Let it in anyway to show that std-vga is disabled */
  1616.  
  1617.     /* Anyway force Mach32 to ATI mode (used by setmode)*/
  1618.     outw(0x4AEE,inw(0x4AEE)|1);
  1619.     SCREENON = 0;
  1620.     return 0;
  1621.     }
  1622.     /* turn screen back on */
  1623.     if (CHIPSET != EGA) {
  1624.         port_out(0x01, SEQ_I);           
  1625.         port_out(port_in(SEQ_D)&0xDF, SEQ_D);
  1626.     }
  1627.  
  1628. /* #ifdef DISABLE_VIDEO_OUTPUT */
  1629.     /* enable video output */
  1630.     port_in(IS1_R);
  1631.     __vga_delay();
  1632.     port_out(0x20, ATT_IW);
  1633. /* #endif */
  1634.  
  1635.     SCREENON = 1;
  1636.     return 0;
  1637. }
  1638.  
  1639.  
  1640. int vga_getxdim()
  1641. {
  1642.     return CI.xdim;
  1643. }
  1644.  
  1645.  
  1646. int vga_getydim()
  1647. {
  1648.     return CI.ydim;
  1649. }
  1650.  
  1651.  
  1652. int vga_getcolors()
  1653. {
  1654.     return CI.colors;
  1655. }
  1656.  
  1657. int vga_white(void)
  1658. {
  1659.     switch (CI.colors) {
  1660.       case     2:
  1661.       case    16:
  1662.       case   256: return 15;
  1663.       case 1<<15: return 32767;
  1664.       case 1<<16: return 65535;
  1665.       case 1<<24: return (1<<24)-1;
  1666.     }
  1667.     return CI.colors-1;
  1668. }
  1669.   
  1670. int vga_claimvideomemory( int m ) {
  1671.     vga_modeinfo *modeinfo;
  1672.     int cardmemory;
  1673.  
  1674.     modeinfo = vga_getmodeinfo(CM);
  1675.     if (m < VMEM)
  1676.         return 0;
  1677.     if (modeinfo->colors == 16)
  1678.         cardmemory = modeinfo->maxpixels / 2;
  1679.     else
  1680.         cardmemory = (modeinfo->maxpixels * modeinfo->bytesperpixel
  1681.             + 2) & 0xffff0000;
  1682.     /* maxpixels * bytesperpixel can be 2 less than video memory in */
  1683.     /* 3 byte-per-pixel modes; assume memory is multiple of 64K */
  1684.     if (m > cardmemory)
  1685.         return -1;
  1686.     VMEM = m;
  1687.     return 0;
  1688. }
  1689.  
  1690. int vga_setmodeX(void)
  1691. {
  1692.   switch (CM) {
  1693.     case TEXT : 
  1694. /*    case G320x200x256: */
  1695.     case G320x240x256:
  1696.     case G320x400x256:
  1697.     case G360x480x256: return 0;
  1698.   }
  1699.   if (CI.colors == 256 && VMEM < 256*1024) {
  1700.     port_out( 4, SEQ_I);                              /* switch from linear to plane memory */
  1701.     port_out( (port_in(SEQ_D) & 0xF7) | 0x04, SEQ_D);
  1702.     port_out( 0x14, CRT_I);                           /* switch double word mode off */
  1703.     port_out( (port_in(CRT_D) & 0xBF), CRT_D);
  1704.     port_out( 0x17, CRT_I); 
  1705.     port_out( (port_in(CRT_D) | 0x40), CRT_D);
  1706.     CI.xbytes = CI.xdim / 4;
  1707.     vga_setpage(0);
  1708.     MODEX = 1;
  1709.     return 1;
  1710.   }
  1711.   return 0;
  1712. }
  1713.  
  1714.  
  1715. static int saved_page;
  1716. static int saved_logicalwidth;
  1717. static int saved_displaystart;
  1718. static int saved_modeX;
  1719.  
  1720. static void savestate() {
  1721.     int i;
  1722.  
  1723.     vga_screenoff();
  1724.  
  1725.     savepalette(graph_red, graph_green, graph_blue);
  1726.  
  1727.     saved_page = currentpage;
  1728.     saved_logicalwidth = currentlogicalwidth;
  1729.     saved_displaystart = currentdisplaystart;
  1730.     saved_modeX = MODEX;
  1731.  
  1732.     if (CM == G320x200x256 && VMEM <= 65536) {
  1733.         /* 320x200x256 is a special case; only 64K is addressable */
  1734.         /* (unless more has been claimed, in which case we assume */
  1735.         /* SVGA bank-switching) */
  1736.             if ((graph_buf = malloc(GRAPH_SIZE)) == NULL) {
  1737.                 printf("Cannot allocate memory for VGA state\n");
  1738.                 vga_setmode(TEXT);
  1739.             exit (-1);
  1740.             }
  1741.             memcpy(graph_buf, GM, GRAPH_SIZE);
  1742.     }
  1743.     else
  1744.     if (MODEX || CM==G800x600x16 || (STDVGAMODE(CM) && CM != G320x200x256)) {
  1745.         /* for planar VGA modes, save the full 256K */
  1746.         vga_driverspecs.setmode(GPLANE16);
  1747.             if ((graph_buf = malloc(4*GRAPH_SIZE)) == NULL) {
  1748.                 printf("Cannot allocate memory for VGA state\n");
  1749.                 vga_setmode(TEXT);
  1750.             exit (-1);
  1751.             }
  1752.  
  1753.             for (i = 0; i < 4; i++) {
  1754.                 /* save plane i */
  1755.                     port_out(0x04, GRA_I); 
  1756.                    port_out(i, GRA_D); 
  1757.                     memcpy(graph_buf + i*GRAPH_SIZE, GM, GRAPH_SIZE);
  1758.         }
  1759.     }
  1760.     else
  1761.     if (CI.colors == 16) {
  1762.         int page, size, sbytes;
  1763.         unsigned char *sp;
  1764.  
  1765.         size = VMEM;
  1766.         if ((graph_buf = malloc(4*size)) == NULL) {
  1767.                 printf("Cannot allocate memory for VGA state\n");
  1768.                 vga_setmode(TEXT);
  1769.             exit(-1);
  1770.             }
  1771.  
  1772.         sp = graph_buf;
  1773.         for (page = 0; size > 0; ++page) {
  1774.             vga_setpage(page);
  1775.             sbytes = (size>GRAPH_SIZE) ? GRAPH_SIZE : size;
  1776.             for (i = 0; i < 4; i++) {
  1777.                 /* save plane i */
  1778.             port_out(0x04, GRA_I); 
  1779.             port_out(i, GRA_D);
  1780.                     memcpy(sp, GM, sbytes);
  1781.             sp += sbytes;
  1782.             }
  1783.             size -= sbytes;
  1784.         }
  1785.     }
  1786.     else {    /* SVGA, and SVGA 320x200x256 if videomemoryused > 65536 */
  1787.             int size;
  1788.             int page;
  1789.  
  1790.         size = VMEM;
  1791.  
  1792.         #ifdef DEBUG
  1793.         printf("Saving %dK of video memory.\n", (size + 2) / 1024);
  1794.         #endif
  1795.             if ((graph_buf = malloc(size)) == NULL) {
  1796.                 printf("Cannot allocate memory for SVGA state.\n");
  1797.                 vga_setmode(TEXT);
  1798.             exit(-1);
  1799.             }
  1800.             page = 0;
  1801.             while (size >= 65536) {
  1802.                 vga_setpage(page);
  1803.                 memcpy(graph_buf + page * 65536, GM, 65536);
  1804.                 page++;
  1805.                 size -= 65536;
  1806.             }
  1807.             if (size > 0) {
  1808.                 vga_setpage(page);
  1809.                 memcpy(graph_buf + page * 65536, GM, size);
  1810.             }
  1811.     }
  1812. }
  1813.  
  1814. static void restorestate() {
  1815.     int i;
  1816.  
  1817.     vga_screenoff();
  1818.  
  1819.     if (saved_modeX)
  1820.         vga_setmodeX();
  1821.  
  1822.     restorepalette(graph_red, graph_green, graph_blue);
  1823.  
  1824.     if (CM == G320x200x256 && VMEM <= 65536) {
  1825.         memcpy(GM, graph_buf, 65536);
  1826.     }
  1827.     else
  1828.     if (MODEX || CM==G800x600x16 || (STDVGAMODE(CM) && CM != G320x200x256)) {
  1829.         int setresetreg, planereg;
  1830.         /* disable Set/Reset Register */
  1831.             port_out(0x01, GRA_I); 
  1832.             setresetreg = inb(GRA_D);
  1833.             port_out(0x00, GRA_D);   
  1834.             outb(SEQ_I, 0x02);
  1835.             planereg = inb(SEQ_D);
  1836.  
  1837.             for (i = 0; i < 4; i++) {
  1838.                 /* restore plane i */
  1839.                 port_out(0x02, SEQ_I ); 
  1840.                 port_out(1<<i, SEQ_D );
  1841.                     memcpy(GM, graph_buf + i*GRAPH_SIZE,GRAPH_SIZE);
  1842.         }
  1843.         outb(GRA_I, 0x01);
  1844.         outb(GRA_D, setresetreg);
  1845.         outb(SEQ_I, 0x02);
  1846.         outb(SEQ_D, planereg);
  1847.     } else
  1848.     if (CI.colors == 16) {
  1849.         int page, size, rbytes;
  1850.         unsigned char *rp;
  1851.         int setresetreg, planereg;
  1852.  
  1853.         /* disable Set/Reset Register */
  1854.             port_out(0x01, GRA_I); 
  1855.             if (CHIPSET == EGA)
  1856.                 setresetreg = 0;
  1857.             else
  1858.                 setresetreg = inb(GRA_D);
  1859.             port_out(0x00, GRA_D);
  1860.         port_out(0x02, SEQ_I);
  1861.         if (CHIPSET == EGA)
  1862.             planereg = 0;
  1863.         else
  1864.                 planereg = inb(SEQ_D);
  1865.  
  1866.         size = VMEM;
  1867.         rp = graph_buf;
  1868.         for (page=0; size > 0; ++page) {
  1869.             vga_setpage(page);
  1870.             rbytes = (size>GRAPH_SIZE) ? GRAPH_SIZE : size;
  1871.             for (i = 0; i < 4; i++) {
  1872.                 /* save plane i */
  1873.             port_out(0x02, SEQ_I); 
  1874.             port_out(1<<i, SEQ_D);
  1875.                     memcpy(GM, rp, rbytes);
  1876.             rp += rbytes;
  1877.             }
  1878.             size -= rbytes;
  1879.         }
  1880.  
  1881.         outb(GRA_I, 0x01);
  1882.         outb(GRA_D, setresetreg);
  1883.         outb(SEQ_I, 0x02);
  1884.         outb(SEQ_D, planereg);
  1885.     }
  1886.     else {
  1887. /*            vga_modeinfo *modeinfo; */
  1888.             int size;
  1889.             int page;
  1890.         size = VMEM;
  1891.  
  1892.         #ifdef DEBUG
  1893.         printf("Restoring %dK of video memory.\n", (size + 2) / 1024);
  1894.         #endif
  1895.             page = 0;
  1896.             while (size >= 65536) {
  1897.                 vga_setpage(page);
  1898.                 memcpy(GM, graph_buf + page * 65536, 65536);
  1899.                 size -= 65536;
  1900.                 page++;
  1901.             }
  1902.             if (size > 0) {
  1903.                 vga_setpage(page);
  1904.                 memcpy(GM, graph_buf + page * 65536, size);
  1905.             }
  1906.     }
  1907.     
  1908.     if (saved_logicalwidth != CI.xbytes)
  1909.         vga_setlogicalwidth(saved_logicalwidth);
  1910.     if (saved_page != 0)
  1911.         vga_setpage(saved_page);
  1912.     if (saved_displaystart != 0)
  1913.         vga_setdisplaystart(saved_displaystart);
  1914.  
  1915.     vga_screenon();
  1916.  
  1917.     free(graph_buf);
  1918. }
  1919.  
  1920.  
  1921. int vga_getch()
  1922. {
  1923.     char c;
  1924.  
  1925.     if (CM == TEXT)
  1926.         return -1;
  1927.  
  1928.     while ((read(__svgalib_tty_fd, &c, 1) < 0) && (errno == EINTR));
  1929.  
  1930.     return c;
  1931. }
  1932.  
  1933. /* I have kept the slightly funny 'flip' terminology. */
  1934.  
  1935. void __vga_flipaway() {
  1936.     /* Leaving console. */
  1937.     flip_mode = CM;
  1938.     if (CM != TEXT) {
  1939.         /* wait for any blitter operation to finish */
  1940.         if (vga_getmodeinfo(CM)->haveblit & HAVE_BLITWAIT)
  1941.             vga_blitwait();
  1942.         /* Save state and go to textmode. */
  1943.         savestate();
  1944.         flip = 1;
  1945.         vga_setmode(TEXT);
  1946.         flip = 0;
  1947.     }
  1948. }
  1949.  
  1950. static void vga_flipback() {
  1951.     /* Entering console. */
  1952.         /* Hmmm... and how about unlocking anything someone else locked? */
  1953.     chipset_unlock();
  1954.     if (flip_mode != TEXT) {
  1955.         /* Restore graphics mode and state. */
  1956.         flip = 1;
  1957.         vga_setmode(flip_mode);
  1958.         flip = 0;
  1959.         restorestate();
  1960.     }
  1961. }
  1962.  
  1963. int vga_flip() {
  1964.     if (CM != TEXT) {        /* save state and go to textmode */
  1965.         savestate();
  1966.         flip_mode = CM;
  1967.         flip = 1;
  1968.         vga_setmode(TEXT);
  1969.         flip = 0;
  1970.     }
  1971.     else {                /* restore graphics mode and state */
  1972.         flip = 1;
  1973.         vga_setmode(flip_mode);
  1974.         flip = 0;
  1975.         restorestate();
  1976.     }
  1977.     return 0;
  1978. }
  1979.  
  1980.  
  1981. int vga_setflipchar(int c)
  1982. /* This function is obsolete. Retained for VGAlib compatibility. */
  1983. {
  1984.     flipchar = c;
  1985.  
  1986.     return 0;
  1987. }
  1988.  
  1989. void vga_setlogicalwidth( int w ) {
  1990.     driverspecs->setlogicalwidth(w);
  1991.     currentlogicalwidth = w;
  1992. }
  1993.  
  1994. void vga_setdisplaystart( int a ) {
  1995.     currentdisplaystart = a;
  1996.     if (CHIPSET != VGA && CHIPSET != EGA)
  1997.         if (MODEX || CI.colors == 16) {
  1998.             /* We are currently using a Mode X-like mode on a */
  1999.             /* SVGA card, use the standard VGA function */
  2000.             /* that works properly for Mode X. */
  2001.             /* Same goes for 16 color modes. */
  2002.             vga_driverspecs.setdisplaystart(a);
  2003.             return;
  2004.         }
  2005.  
  2006.     /* Call the regular display start function for the chipset */
  2007.     driverspecs->setdisplaystart(a);
  2008. }
  2009.  
  2010. void vga_bitblt( int srcaddr, int destaddr, int w, int h, int pitch ) {
  2011.     driverspecs->bitblt(srcaddr, destaddr, w, h, pitch);
  2012. }
  2013.  
  2014. void vga_imageblt( void *srcaddr, int destaddr, int w, int h, int pitch ) {
  2015.     driverspecs->imageblt(srcaddr, destaddr, w, h, pitch);
  2016. }
  2017.  
  2018. void vga_fillblt( int destaddr, int w, int h, int pitch, int c ) {
  2019.     driverspecs->fillblt(destaddr, w, h, pitch, c);
  2020. }
  2021.  
  2022. void vga_hlinelistblt( int ymin, int n, int *xmin, int *xmax, int pitch,
  2023. int c ) {
  2024.     driverspecs->hlinelistblt(ymin, n, xmin, xmax, pitch, c);
  2025. }
  2026.  
  2027. void vga_blitwait(void) {
  2028.     driverspecs->bltwait();
  2029. }
  2030.  
  2031. int vga_ext_set(unsigned what, ...) {
  2032.     va_list params;
  2033.     register int retval;
  2034.  
  2035.     /* Does this use of the arglist corrupt non-AVAIL_ACCEL ext_set? */
  2036.     va_start(params, what);
  2037.     if (what == VGA_EXT_AVAILABLE
  2038.     && va_arg(params, int) == VGA_AVAIL_ACCEL) {
  2039.         if (driverspecs->accelspecs == NULL)
  2040.             return 0;
  2041.         else
  2042.             return driverspecs->accelspecs->operations;
  2043.     }
  2044.     va_end(params);
  2045.  
  2046.     if(MODEFLAGS&HAVE_EXT_SET) {
  2047.         va_start(params,what);
  2048.         retval=driverspecs->ext_set(what, params);
  2049.         va_end(params);
  2050.         return retval;
  2051.         }
  2052.     else    return 0;
  2053. }
  2054.  
  2055.  
  2056.  
  2057. /* Parse a string for options.. str is \0-terminated source,
  2058.    commands is an array of char ptrs (last one is NULL) containing commands
  2059.    to parse for. (if first char is ! case sensitive),
  2060.    func is called with ind the index of the detected command.
  2061.    func has to return the ptr to the next unhandled token returned by strtok(NULL," ").
  2062.    Use strtok(NULL," ") to get the next token from the file..
  2063.    mode is 1 when reading from conffile and 0 when parsing the env-vars. This is to
  2064.    allow disabling of dangerous (hardware damaging) options when reading the ENV-Vars
  2065.    of Joe user.
  2066.    Note: We use strtok, that is str is destroyed!*/
  2067. static void parse_string(char *str, char **commands, char *(*func)(int ind,int mode),int mode) {
  2068.     int index;
  2069.     register char *ptr,**curr;
  2070.  
  2071.     /*Pass one, delete comments,ensure only whitespace is ' '*/
  2072.     for(ptr=str;*ptr;ptr++) {
  2073.         if(*ptr=='#') {
  2074.             while(*ptr && (*ptr!='\n')) {
  2075.                 *ptr++ =' ';
  2076.             }
  2077.             if(*ptr)
  2078.                 *ptr=' ';
  2079.         }
  2080.         else if(isspace(*ptr)) {
  2081.             *ptr=' ';
  2082.         }
  2083.     }
  2084.     /*Pass two, parse commands*/
  2085.     ptr=strtok(str," ");
  2086.     while(ptr) {
  2087.         #ifdef DEBUG_CONF
  2088.         printf("Parsing: %s\n",ptr);
  2089.         #endif
  2090.         for(curr=commands, index=0; *curr; curr++,index++) {
  2091.             #ifdef DEBUG_CONF
  2092.             printf("Checking: %s\n",*curr);
  2093.             #endif
  2094.             if(**curr=='!') {
  2095.                 if(!strcmp(*curr+1,ptr)) {
  2096.                     ptr=(*func)(index,mode);
  2097.                     break;
  2098.                 }
  2099.             }
  2100.             else {
  2101.                 if(!strcasecmp(*curr,ptr)) {
  2102.                     ptr=(*func)(index,mode);
  2103.                     break;
  2104.                 }
  2105.             }
  2106.         }
  2107.         if(!*curr) /*unknow command*/
  2108.             ptr=strtok(NULL," ");    /* skip silently til' next command */
  2109.     }
  2110. }
  2111.  
  2112. static int allowoverride = 0;    /* Allow dangerous options in ENV-Var */
  2113.  
  2114. /* This is a service function for drivers. commands and func are as above,
  2115.    the config file and (afterwards) the contents of the environment variable
  2116.    SVGALIB_CONFIG are parsed..*/
  2117. void __svgalib_read_options(char **commands, char *(*func)(int ind,int mode)) {
  2118. /* Parse configuration file. */
  2119.     FILE *f;
  2120.     char *buf=NULL,*ptr;
  2121.     struct stat st;
  2122.     int i;
  2123.  
  2124.     st.st_size=0; /*safety for readenv*/
  2125.  
  2126.     f = fopen(SVGALIB_CONFIG_FILE, "r");
  2127.     if (f == NULL) {
  2128.         printf("svgalib: Configuration file %s not found.\n",
  2129.             SVGALIB_CONFIG_FILE);
  2130.         goto readenv;
  2131.     }
  2132.     fstat(fileno(f), &st);    /* Some error analysis may be fine here..*/
  2133.     buf = alloca(st.st_size+1); /* + a final \0 */
  2134.     fread(buf, 1, st.st_size, f);
  2135.     fclose(f);
  2136.     /*Erase any maybe embedded \0 */
  2137.     for(i=0,ptr=buf;i<st.st_size;i++,ptr++)    {
  2138.         if(!*ptr)
  2139.             *ptr=' ';
  2140.     }
  2141.     /*Trailing \0*/
  2142.     *ptr=0;
  2143.     /*parse config file*/
  2144.     parse_string(buf,commands,func,1);
  2145.     readenv:
  2146.     if(!(ptr=getenv("SVGALIB_CONFIG")))
  2147.         return;
  2148.     if(!(i=strlen(ptr)))
  2149.         return;
  2150.     if(i>st.st_size) /* Note that we allocated one more char...*/
  2151.         buf = alloca(i+1);
  2152.     strcpy(buf,ptr); /* Copy for safety and strtok!! */
  2153.     /*parse environment variable*/
  2154.     parse_string(buf,commands,func,allowoverride);
  2155. }
  2156.     
  2157. /* Configuration file, mouse interface, initialization. */
  2158.  
  2159. static int configfileread = 0;    /* Boolean. */
  2160.  
  2161. static char *vga_conf_commands[]={
  2162.     "mouse","monitor","!m","!M","chipset","overrideenable","!m0","!m1","!m2","!m3",
  2163.     "!m4","!m9", "!M0","!M1","!M2","!M3","!M4","!M5","!M6","nolinear",
  2164.     "linear","!C0","!C1","!C2","!C3","!C4","!C5","!C6","!C7","!C8","!C9",
  2165.     "!c0","!c1","monotext","colortext","!m5",
  2166.     "leavedtr","cleardtr","setdtr","leaverts","clearrts",
  2167.     "setrts",
  2168.     NULL};
  2169.  
  2170. static char *conf_mousenames[]={
  2171.     "Microsoft","MouseSystems","MMSeries","Logitech","Busmouse","PS2",NULL};
  2172.  
  2173. static int check_digit(char *ptr, char *digits) {
  2174.     if(ptr==NULL)
  2175.         return 0;
  2176.     return strlen(ptr)==strspn(ptr,digits);
  2177. }
  2178.  
  2179. static char *process_option(int command,int mode) {
  2180.     static char digits[]=".0123456789";
  2181.     char *ptr,**tabptr,*ptb;
  2182.     int i,j;
  2183.     float f;
  2184.  
  2185. #ifdef DEBUG_CONF
  2186.     printf("command %d detected.\n",command);
  2187. #endif
  2188.     switch(command) {
  2189.         case 5:
  2190.             #ifdef DEBUG_CONF
  2191.             puts("Allow override");
  2192.             #endif
  2193.             if(mode)
  2194.                 allowoverride=1;
  2195.             else    puts("Overrideenable denied. (Gee.. Do you think I'm that silly?)");
  2196.             break;
  2197.         case 0: /* mouse */
  2198.         case 2: /* m */
  2199.             ptr=strtok(NULL," ");
  2200.             if(ptr==NULL)
  2201.                 goto inv_mouse;
  2202.             if(check_digit(ptr,digits+1)) { /* It is a number.. */
  2203.                 i=atoi(ptr);
  2204.                 if((i!=9)&&(i>5))
  2205.                     goto inv_mouse;
  2206.                 mouse_type=i;
  2207.             }
  2208.             else { /* parse for symbolic name.. */
  2209.                 if(!strcasecmp(ptr,"none")) {
  2210.                     mouse_type=9;
  2211.                     break;
  2212.                 }
  2213.                 for(i=0,tabptr=conf_mousenames;*tabptr;tabptr++,i++) {
  2214.                     if(!strcasecmp(ptr,*tabptr)) {
  2215.                         mouse_type=i;
  2216.                         goto leave;
  2217.                     }
  2218.                 }
  2219.                 inv_mouse:
  2220.                 printf("svgalib: Illegal mouse setting: {mouse|m} %s\n"
  2221.                     "Correct usage: {mouse|m} mousetype\n"
  2222.                     "where mousetype is one of 0, 1, 2, 3, 4, 5, 9,\n",
  2223.                     (ptr!=NULL)?ptr:"");
  2224.                 for(tabptr=conf_mousenames;*tabptr;tabptr++) {
  2225.                     printf("%s, ",*tabptr);
  2226.                 }
  2227.                 puts("or none.");
  2228.                 return ptr;    /* Allow a second parse of str */
  2229.             }
  2230.             break;
  2231.         case 1: /* monitor */
  2232.         case 3: /* M */
  2233.             ptr=strtok(NULL," ");
  2234.             if( check_digit(ptr,digits+1) ) { /* It is an int.. */
  2235.                 i=atoi(ptr);
  2236.                 if(i<7) {
  2237.                     if(!mode)
  2238.                         goto mon_deny;
  2239.                     __svgalib_monitortype = i;
  2240.                 }
  2241.                 else {
  2242.                     f=i;
  2243.                     goto monkhz;
  2244.                 }
  2245.             }
  2246.             else if( check_digit(ptr,digits) ) { /* It is a float.. */
  2247.                 f=atof(ptr);
  2248.                 monkhz:
  2249.                 if(!mode)
  2250.                     goto mon_deny;
  2251.                 if(f>=59.0)
  2252.                     __svgalib_monitortype = 6;
  2253.                 else if(f>=56.0)
  2254.                     __svgalib_monitortype = 5;
  2255.                 else if(f>=48.3)
  2256.                     __svgalib_monitortype = 4;
  2257.                 else if(f>=37.9)
  2258.                     __svgalib_monitortype = 3;
  2259.                 else if(f>=35.5)
  2260.                     __svgalib_monitortype = 2;
  2261.                 else if(f>=35.1)
  2262.                     __svgalib_monitortype = 1;
  2263.                 else
  2264.                     __svgalib_monitortype = 0;
  2265.             }
  2266.             else {
  2267.                 printf("svgalib: Illegal monitor setting: {monitor|M} %s\n"
  2268.                     "Correct usage: {monitor|M} monitortype\n"
  2269.                     "where monitortype is one of 0, 1, 2, 3, 4, 5, 6, or\n"
  2270.                     "maximal horz. scan frequency in khz.\n"
  2271.                     "Example: monitor 36.5\n",
  2272.                     (ptr!=NULL)?ptr:"");
  2273.                 return ptr;    /* Allow a second parse of str */
  2274.             }
  2275.             break;
  2276.         case 4: /* chipset */
  2277.             ptr=strtok(NULL," ");
  2278.             if(ptr==NULL) {
  2279.                 puts("svgalib: Illegal chipset setting: no chipset given");
  2280.                 goto chip_us;
  2281.             }
  2282.             /*First param is chipset*/
  2283.             for(i=0,tabptr=driver_names;*tabptr;tabptr++,i++) {
  2284.                 if( (!strcasecmp(ptr,*tabptr)) && (driverspecslist[i]!=NULL) ) {
  2285.                     ptr=strtok(NULL," ");
  2286.                     if( check_digit(ptr,digits+1) ) {
  2287.                         j=atoi(ptr);
  2288.                         ptr=strtok(NULL," ");
  2289.                         if( check_digit(ptr,digits+1) ) {
  2290.                             if(mode)
  2291.                                 vga_setchipsetandfeatures(i,j,atoi(ptr));
  2292.                             else
  2293.                                 {
  2294.                                 chipdeny:
  2295.                             puts("chipset override from environment denied.");
  2296.                                 }
  2297.                             return strtok(NULL," ");
  2298.                         }
  2299.                         else {
  2300.                 puts("svgalib: Illegal chipset setting: memory is not a number");
  2301.                             goto chip_us;
  2302.                         }
  2303.                     }
  2304.                     if(mode)
  2305.                         vga_setchipset(i);
  2306.                     else puts("chipset override from environment denied.");
  2307.                     return ptr;
  2308.                 }
  2309.             }
  2310.             printf("svgalib: Illegal chipset setting: chipset %s\n",ptr);
  2311.             chip_us:
  2312.             puts("Correct usage: chipset driver [par1 par2]\n"
  2313.                 "where driver is one of:");
  2314.             ptb="%s";
  2315.             for(i=0,tabptr=driver_names;*tabptr;tabptr++,i++) {
  2316.                 if(driverspecslist[i]!=NULL) {
  2317.                     printf(ptb,*tabptr);
  2318.                     ptb=", %s";
  2319.                 }
  2320.             }
  2321.             puts("\npar1 and par2 are river dependant integers.\n"
  2322.                 "Example: Chipset VGA    or\n"
  2323.                 "Chipset VGA 0 512");
  2324.             return ptr;
  2325.         case 6: /* oldstyle config: m0-m4 */
  2326.         case 7:
  2327.         case 8:
  2328.         case 9:
  2329.         case 10:
  2330.             mouse_type = command - 6;
  2331.             break;
  2332.         case 11: /* m9 */
  2333.             mouse_type = 9;
  2334.             break;
  2335.         case 12: /* oldstyle config: M0-M6 */
  2336.         case 13:
  2337.         case 14:
  2338.         case 15:
  2339.         case 16:
  2340.         case 17:
  2341.         case 18:
  2342.             if(!mode) {
  2343.                 mon_deny:
  2344.                 puts("Monitor setting from environment denied.");
  2345.                 break;
  2346.             }
  2347.             __svgalib_monitortype = command - 12;
  2348.             break;
  2349.         case 19: /*nolinear*/
  2350.             modeinfo_mask&= ~CAPABLE_LINEAR;
  2351.             break;
  2352.         case 20: /*linear*/
  2353.             modeinfo_mask|= CAPABLE_LINEAR;
  2354.             break;
  2355.         case 21: /* oldstyle chipset C0 - C9 */
  2356.         case 22:
  2357.         case 23:
  2358.         case 24:
  2359.         case 25:
  2360.         case 26:
  2361.         case 27:
  2362.         case 28:
  2363.         case 29:
  2364.         case 30:
  2365.             if(!mode)
  2366.                 goto chipdeny;
  2367.             vga_setchipset(command-21);
  2368.             break;
  2369.         case 31: /* c0-c1 color-text selection */
  2370.             if(!mode)
  2371.                 {
  2372.                 coltexdeny:
  2373.                 puts("Color/mono text selection from environment denied.");
  2374.                 break;
  2375.                 }
  2376.             color_text = 0;
  2377.             break;
  2378.         case 32:
  2379.             if(!mode)
  2380.                 {
  2381.                 puts("Color/mono text selection from environment denied.");
  2382.                 break;
  2383.                 }
  2384.             color_text = 1;
  2385.             break;
  2386.         case 33:
  2387.         case 34:
  2388.             if(!mode)
  2389.                 goto coltexdeny;
  2390.             color_text=command-32;
  2391.             break;
  2392.         case 35: /* Mouse type 5 - "PS2". */
  2393.             mouse_type = 5;
  2394.             break;
  2395.         case 36:
  2396.             mouse_modem_ctl&= ~(MOUSE_CHG_DTR|MOUSE_DTR_HIGH);
  2397.             break;
  2398.         case 37:
  2399.             mouse_modem_ctl&= ~MOUSE_DTR_HIGH;
  2400.             mouse_modem_ctl|= MOUSE_CHG_DTR;
  2401.             break;
  2402.         case 38:
  2403.             mouse_modem_ctl|= (MOUSE_CHG_RTS|MOUSE_RTS_HIGH);
  2404.             break;
  2405.         case 39:
  2406.             mouse_modem_ctl&= ~(MOUSE_CHG_RTS|MOUSE_RTS_HIGH);
  2407.             break;
  2408.         case 40:
  2409.             mouse_modem_ctl&= ~MOUSE_RTS_HIGH;
  2410.             mouse_modem_ctl|= MOUSE_CHG_RTS;
  2411.             break;
  2412.         case 41:
  2413.             mouse_modem_ctl|= (MOUSE_CHG_RTS|MOUSE_RTS_HIGH);
  2414.             break;
  2415.     }
  2416. leave:
  2417. return strtok(NULL," ");
  2418. }
  2419.  
  2420. static void readconfigfile() {
  2421.     if (configfileread)
  2422.         return;
  2423.     configfileread = 1;
  2424.     mouse_type = -1;
  2425.     __svgalib_monitortype = -1;
  2426.     __svgalib_read_options(vga_conf_commands,process_option);
  2427.     if (mouse_type == -1) {
  2428.         mouse_type = MOUSE_MICROSOFT;    /* Default. */
  2429.         puts("svgalib: Assuming Microsoft mouse.");
  2430.     }
  2431.     if (__svgalib_monitortype == -1)
  2432.         {
  2433.         /* Default monitor is low end SVGA/8514. */
  2434.         __svgalib_monitortype = MON1024_43I;
  2435.         puts("svgalib: Assuming low end SVGA/8514 monitor (35.5 KHz).");
  2436.     }
  2437.     #ifdef DEBUG_CONF
  2438.     printf("Mouse is: %d Monitor is: %d\n",mouse_type,__svgalib_monitortype);
  2439.     #endif
  2440. }
  2441.  
  2442. int vga_getmousetype() {
  2443.     readconfigfile();
  2444.     return mouse_type|mouse_modem_ctl;
  2445. }
  2446.  
  2447. int vga_getmonitortype() {
  2448.     readconfigfile();
  2449.     return __svgalib_monitortype;
  2450. }
  2451.  
  2452. void vga_setmousesupport( int s ) {
  2453.     mouse_support = s;
  2454. }
  2455.  
  2456. void vga_lockvc() {
  2457.     lock_count++;
  2458.     if (flip)
  2459.         __svgalib_waitvtactive();
  2460. }
  2461.  
  2462. void vga_unlockvc() {
  2463.     if (--lock_count <= 0)
  2464.     {
  2465.         lock_count = 0;
  2466.         if (release_flag)
  2467.         {
  2468.             release_flag = 0;
  2469.             releasevt_signal(SIGUSR1);
  2470.         }
  2471.     }
  2472. }
  2473.  
  2474. void vga_runinbackground( int stat ) {
  2475.     runinbackground = stat;
  2476. }
  2477.  
  2478. int vga_oktowrite() {
  2479.     return oktowrite;
  2480. }
  2481.  
  2482. int vga_init() {
  2483.     open_devconsole();
  2484.     if (!checkconsole()) {
  2485.         /* Return with error code. */
  2486.         seteuid(getuid());
  2487.         setegid(getgid());
  2488.         return -1;
  2489.     }
  2490.     readconfigfile();
  2491.     vga_hasmode(TEXT);    /* Force driver message and initialization. */
  2492.     seteuid(getuid());    /* Don't need supervisor rights anymore. */
  2493.     setegid(getgid());
  2494.     return 0;
  2495. }
  2496.