vga.c

linux 下svgalib编的一个界面程序示例

#ifdef INCLUDE_ET4000_DRIVER_TEST
	if (__svgalib_et4000_driverspecs.test())
	    CHIPSET = ET4000;
	else
#endif
#ifdef INCLUDE_TVGA_DRIVER_TEST
	if (__svgalib_tvga8900_driverspecs.test())
	    CHIPSET = TVGA8900;
	else
#endif
#ifdef INCLUDE_CIRRUS_DRIVER_TEST
	    /* The Cirrus detection is not very clean. */
	if (__svgalib_cirrus_driverspecs.test())
	    CHIPSET = CIRRUS;
	else
#endif
#ifdef INCLUDE_OAK_DRIVER_TEST
	if (__svgalib_oak_driverspecs.test())
	    CHIPSET = OAK;
	else
#endif
#ifdef INCLUDE_PARADISE_DRIVER_TEST
	if (__svgalib_paradise_driverspecs.test())
	    CHIPSET = PARADISE;
	else
#endif
#ifdef INCLUDE_S3_DRIVER_TEST
	if (__svgalib_s3_driverspecs.test())
	    CHIPSET = S3;
	else
#endif
#ifdef INCLUDE_ET3000_DRIVER_TEST
	if (__svgalib_et3000_driverspecs.test())
	    CHIPSET = ET3000;
	else
#endif
#ifdef INCLUDE_ARK_DRIVER_TEST
	if (__svgalib_ark_driverspecs.test())
	    CHIPSET = ARK;
	else
#endif
#ifdef INCLUDE_GVGA6400_DRIVER_TEST
	if (__svgalib_gvga6400_driverspecs.test())
	    CHIPSET = GVGA6400;
	else
#endif
#ifdef INCLUDE_ATI_DRIVER_TEST
	if (__svgalib_ati_driverspecs.test())
	    CHIPSET = ATI;
	else
#endif
#ifdef INCLUDE_ALI_DRIVER_TEST
	if (__svgalib_ali_driverspecs.test())
	    CHIPSET = ALI;
	else
#endif
#ifdef INCLUDE_APM_DRIVER_TEST
/* Note: On certain cards this may toggle the video signal on/off which
   is ugly. Hence we test this last. */
	if (__svgalib_apm_driverspecs.test())
	    CHIPSET = APM;
	else
#endif
#ifdef INCLUDE_VESA_DRIVER_TEST
	if (__svgalib_vesa_driverspecs.test())
	    CHIPSET = VESA;
	else
#endif

	if (__svgalib_vga_driverspecs.test())
	    CHIPSET = VGA;
	else
	    /* else */
	{
	    fprintf(stderr, "svgalib: Cannot find EGA or VGA graphics device.\n");
	    exit(1);
	}
	__svgalib_setpage = __svgalib_driverspecs->__svgalib_setpage;
	__svgalib_setrdpage = __svgalib_driverspecs->__svgalib_setrdpage;
	__svgalib_setwrpage = __svgalib_driverspecs->__svgalib_setwrpage;
    }
    return CHIPSET;
}

void vga_setchipset(int c)
{
    CHIPSET = c;
#ifdef DEBUG
    printf("Setting chipset\n");
#endif
    if (c == UNDEFINED)
	return;
    if (__svgalib_driverspecslist[c] == NULL) {
	printf("svgalib: Invalid chipset. The driver may not be compiled in.\n");
	CHIPSET = UNDEFINED;
	return;
    }
    __svgalib_get_perm();
    __svgalib_driverspecslist[c]->init(0, 0, 0);
    __svgalib_setpage = __svgalib_driverspecs->__svgalib_setpage;
    __svgalib_setrdpage = __svgalib_driverspecs->__svgalib_setrdpage;
    __svgalib_setwrpage = __svgalib_driverspecs->__svgalib_setwrpage;
}

void vga_setchipsetandfeatures(int c, int par1, int par2)
{
    CHIPSET = c;
#ifdef DEBUG
    printf("Forcing chipset and features\n");
#endif
    __svgalib_get_perm();
    __svgalib_driverspecslist[c]->init(1, par1, par2);
#ifdef DEBUG
    printf("Finished forcing chipset and features\n");
#endif
    __svgalib_setpage = __svgalib_driverspecs->__svgalib_setpage;
    __svgalib_setrdpage = __svgalib_driverspecs->__svgalib_setrdpage;
    __svgalib_setwrpage = __svgalib_driverspecs->__svgalib_setwrpage;
}


static void savepalette(unsigned char *red, unsigned char *green,
			unsigned char *blue)
{
    int i;

    if (__svgalib_driverspecs->emul && __svgalib_driverspecs->emul->savepalette) 
        return (__svgalib_driverspecs->emul->savepalette(red, green, blue));

    if (CHIPSET == EGA || __svgalib_novga) 
	return;

    /* save graphics mode palette - first select palette index 0 */
    port_out(0, PEL_IR);

    /* read RGB components - index is autoincremented */
    for (i = 0; i < 256; i++) {
	__svgalib_delay();
	*(red++) = port_in(PEL_D);
	__svgalib_delay();
	*(green++) = port_in(PEL_D);
	__svgalib_delay();
	*(blue++) = port_in(PEL_D);
    }
}

static void restorepalette(const unsigned char *red,
		   const unsigned char *green, const unsigned char *blue)
{
    int i;

    if (__svgalib_driverspecs->emul && __svgalib_driverspecs->emul->restorepalette) 
        return (__svgalib_driverspecs->emul->restorepalette(red, green, blue));

    if (CHIPSET == EGA || __svgalib_novga)
	return;

    /* restore saved palette */
    port_out(0, PEL_IW);

    /* read RGB components - index is autoincremented */
    for (i = 0; i < 256; i++) {
	__svgalib_delay();
	port_out(*(red++), PEL_D);
	__svgalib_delay();
	port_out(*(green++), PEL_D);
	__svgalib_delay();
	port_out(*(blue++), PEL_D);
    }
}

#ifndef BACKGROUND

/* Virtual console switching */

static int forbidvtrelease = 0;
static int forbidvtacquire = 0;
static int lock_count = 0;
static int release_flag = 0;

static void __svgalib_takevtcontrol(void);

void __svgalib_flipaway(void);
static void __svgalib_flipback(void);

static void __svgalib_releasevt_signal(int n)
{
    if (lock_count) {
	release_flag = 1;
	return;
    }
#ifdef DEBUG
    printf("Release request.\n");
#endif
    forbidvtacquire = 1;
    if (forbidvtrelease) {
	forbidvtacquire = 0;
	ioctl(__svgalib_tty_fd, VT_RELDISP, 0);
	return;
    }
    if (__svgalib_go_to_background)
	(__svgalib_go_to_background) ();
    __svgalib_flipaway();
        if((__svgalib_textprog&3)==3){
           pid_t child;
           if((child=fork())==0){
           execv(__svgalib_TextProg,__svgalib_TextProg_argv);
           } else {
           waitpid(child,NULL,0);
           };  
        };
    ioctl(__svgalib_tty_fd, VT_RELDISP, 1);
#ifdef DEBUG
    printf("Finished release.\n");
#endif
    forbidvtacquire = 0;

    /* Suspend program until switched to again. */
#ifdef DEBUG
    printf("Suspended.\n");
#endif

    __svgalib_oktowrite = 0;
    if (!__svgalib_runinbackground)
	__svgalib_waitvtactive();
#ifdef DEBUG
    printf("Waked.\n");
#endif
}

static void __svgalib_acquirevt_signal(int n)
{
#ifdef DEBUG
    printf("Acquisition request.\n");
#endif
    forbidvtrelease = 1;
    if (forbidvtacquire) {
	forbidvtrelease = 0;
	return;
    }
    __svgalib_flipback();
    ioctl(__svgalib_tty_fd, VT_RELDISP, VT_ACKACQ);
#ifdef DEBUG
    printf("Finished acquisition.\n");
#endif
    forbidvtrelease = 0;
    if (__svgalib_come_from_background)
	(__svgalib_come_from_background) ();
    __svgalib_oktowrite = 1;
}

#endif

#ifndef BACKGROUND

void __svgalib_takevtcontrol(void)
{
    struct sigaction siga;
    struct vt_mode newvtmode;

    ioctl(__svgalib_tty_fd, VT_GETMODE, &__svgalib_oldvtmode);
    newvtmode = __svgalib_oldvtmode;
    newvtmode.mode = VT_PROCESS;	/* handle VT changes */
    newvtmode.relsig = SVGALIB_RELEASE_SIG;	/* I didn't find SIGUSR1/2 anywhere */
    newvtmode.acqsig = SVGALIB_ACQUIRE_SIG;	/* in the kernel sources, so I guess */
    /* they are free */
    SETSIG(siga, SVGALIB_RELEASE_SIG, __svgalib_releasevt_signal);
    SETSIG(siga, SVGALIB_ACQUIRE_SIG, __svgalib_acquirevt_signal); 
    ioctl(__svgalib_tty_fd, VT_SETMODE, &newvtmode);
}

#endif

#ifdef LINEAR_DEBUG
void dump_mem(unsigned char *name)
{
  unsigned char bu[128];
  sprintf(bu,"cat /proc/%d/maps > /tmp/%s",getpid(),name);
  system(bu);
}
#endif

#ifdef BACKGROUND
#if BACKGROUND == 1
void __svgalib_map_virtual_screen(int page)
{
 if (page==1000000)
     {
      __svgalib_graph_mem = 
          (unsigned char *) mmap((caddr_t) GM, GRAPH_SIZE,
				 PROT_READ | PROT_WRITE,
				 MAP_SHARED | MAP_FIXED,
				 __svgalib_virtual_mem_fd,
				 (int)__svgalib_graph_mem_orginal);
      if (__svgalib_graph_mem!=__svgalib_graph_mem_check)
          {
	   printf("svgalib: mmap error in paged screen memory.\n");
	   exit(-1);
	  }
      if (__svgalib_modeinfo_linearset&IS_LINEAR)
          {
           __svgalib_linearframebuffer = 
           (unsigned char *) mmap((caddr_t) __svgalib_linearframebuffer, 
	                         __svgalib_linear_memory_size,
				 PROT_READ | PROT_WRITE,
				 MAP_SHARED | MAP_FIXED,
				 __svgalib_virtual_mem_fd,
				 (int)__svgalib_graph_mem_linear_orginal);
           if (__svgalib_linearframebuffer!=__svgalib_graph_mem_linear_check)
              {
	       printf("svgalib: mmap error in linear screen memory.\n");
	       exit(-1);
	      }
	   __svgalib_linear_is_background=0;
	  }
     }
   else
     {
      /*  Program is now in the background. */
      __svgalib_graph_mem = 
          (unsigned char *) mmap((caddr_t) GM, GRAPH_SIZE,
				 PROT_READ | PROT_WRITE,
				 MAP_SHARED | MAP_FIXED,
				 __svgalib_virtual_mem_fd,
				 (int)(graph_buf+(GRAPH_SIZE*page)));
      if (__svgalib_graph_mem!=__svgalib_graph_mem_check)
          {
	   printf("svgalib: mmap error in paged background memory.\n");
	   exit(-1);
	  }
      if (!__svgalib_linear_is_background && 
          __svgalib_modeinfo_linearset&IS_LINEAR)
          {
#ifdef LINEAR_DEBUG
           dump_mem("testmaps-before");
           printf("svgalib: trying to map regular mem at %p, size=0x%08x from %p\n",
                  __svgalib_linearframebuffer,__svgalib_linear_memory_size,graph_buf2);
#endif
           munmap(__svgalib_linearframebuffer,__svgalib_linear_memory_size);
#ifdef LINEAR_DEBUG
           dump_mem("testmaps-after");
#endif
    __svgalib_linearframebuffer = 
           (unsigned char *) mmap((caddr_t) __svgalib_linearframebuffer, 
	                         __svgalib_linear_memory_size,
				 PROT_READ | PROT_WRITE,
				 MAP_SHARED | MAP_FIXED,
				 __svgalib_virtual_mem_fd,
				 (int)(graph_buf2));
           if (__svgalib_linearframebuffer!=__svgalib_graph_mem_linear_check)
              {
	       printf("svgalib: mmap error in linear background memory.\n");
	       exit(-1);
	      }
	   __svgalib_linear_is_background=1;
          }
     }
 return;
}

#endif
#if BACKGROUND == 2

#endif
#endif


static void __vga_mmap(void)
{
#ifdef LINEAR_DEBUG
    printf("__vga_mmap() called, __svgalib_graph_base=0x%08lx\n",__svgalib_graph_base);
#endif
    /* This assumes pl10+. */
    /* Still seems to waste 64K, so don't bother. */
#ifndef BACKGROUND
    GM = (unsigned char *) BANKED_MEM_POINTER;
#endif
#ifdef BACKGROUND
#if BACKGROUND == 1
    if ((__svgalib_graph_mem = valloc(GRAPH_SIZE)) == NULL) {
	printf("svgalib: allocation error \n");
	exit(-1);
    }
    __svgalib_graph_mem_check=__svgalib_graph_mem;
    __svgalib_graph_mem_orginal = (unsigned char *) BANKED_MEM_POINTER;
    __svgalib_map_virtual_screen(1000000); /* Video page */
#endif	
#if BACKGROUND == 2
    GM = (unsigned char *) BANKED_MEM_POINTER;
    __svgalib_graph_mem_orginal=GM;
#endif
#endif

#ifdef __alpha__
    SM = (unsigned char *) mmap(
				   (caddr_t) 0,
				   GRAPH_SIZE << MEM_SHIFT,
				   PROT_READ | PROT_WRITE,
				   MAP_SHARED,
				   __svgalib_mem_fd,
				   SPARSE_GRAPH_BASE
	);
#endif
    graph_mem = __svgalib_graph_mem;	/* Exported variable. */
}

static void __vga_atexit(void)
{
    if (getpid() == my_pid)	/* protect against forked processes */
	restoretextmode();
    if (__svgalib_tty_fd >= 0 && startup_vc > 0)
	    ioctl(__svgalib_tty_fd, VT_ACTIVATE, startup_vc);
}

static void setcoloremulation(void)
{
    /* shift to color emulation */
    __svgalib_CRT_I = CRT_IC;
    __svgalib_CRT_D = CRT_DC;
    __svgalib_IS1_R = IS1_RC;
    if (CHIPSET != EGA && !__svgalib_novga)  
	port_out(port_in(MIS_R) | 0x01, MIS_W);
}

static void initialize(void)
{
    int i;
    struct sigaction siga;

    __svgalib_open_devconsole();
    if (__svgalib_tty_fd < 0) {
	exit(1);
    }

    /* Make sure that textmode is restored at exit(). */
    if (my_pid == 0)
	my_pid = getpid();
    atexit(__vga_atexit);

#ifndef DONT_WAIT_VC_ACTIVE
    __svgalib_waitvtactive();
#endif

    /* save text mode termio parameters */
    ioctl(0, TCGETS, &text_termio);

    graph_termio = text_termio;

    /* change termio parameters to allow our own I/O processing */
    graph_termio.c_iflag &= ~(BRKINT | PARMRK | INPCK | IUCLC | IXON | IXOFF);
    graph_termio.c_iflag |= (IGNBRK | IGNPAR);

    graph_termio.c_oflag &= ~(ONOCR);

    graph_termio.c_lflag &= ~(ICANON | ECHO | ECHOE | ECHOK | ECHONL | NOFLSH);
    if (__svgalib_nosigint)
	graph_termio.c_lflag &= ~ISIG;	/* disable interrupt */
    else
	graph_termio.c_lflag |=  ISIG;	/* enable interrupt */

    graph_termio.c_cc[VMIN] = 1;
    graph_termio.c_cc[VTIME] = 0;
    graph_termio.c_cc[VSUSP] = 0;	/* disable suspend */

    disable_interrupt();	/* Is reenabled later by set_texttermio */

    __svgalib_getchipset();		/* make sure a chipset has been selected */
    chipset_unlock();

    /* disable text output to console */
    if (!__svgalib_secondary)
	ioctl(__svgalib_tty_fd, KDSETMODE, KD_GRAPHICS);

    __svgalib_takevtcontrol();	/* HH: Take control over VT */

    /* open /dev/mem */
    open_mem();

    /* mmap graphics memory */