vga.c

基于组件方式开发操作系统的OSKIT源代码

    if(__svgalib_novga) return 1;

    if (__svgalib_chipset == EGA) {
	/* Enable graphics register modification */
	port_out(0x00, GRA_E0);
	port_out(0x01, GRA_E1);
    }
    /* update misc output register */
    port_out(regs[MIS], MIS_W);

    /* synchronous reset on */
    port_out(0x00, SEQ_I);
    port_out(0x01, SEQ_D);

    /* write sequencer registers */
    port_out(1, SEQ_I);
    port_out(regs[SEQ + 1] | 0x20, SEQ_D);
    for (i = 2; i < SEQ_C; i++) {
	port_out(i, SEQ_I);
	port_out(regs[SEQ + i], SEQ_D);
    }

    /* synchronous reset off */
    port_out(0x00, SEQ_I);
    port_out(0x03, SEQ_D);

    if (__svgalib_chipset != EGA) {
	/* deprotect CRT registers 0-7 */
	port_out(0x11, __svgalib_CRT_I);
	port_out(port_in(__svgalib_CRT_D) & 0x7F, __svgalib_CRT_D);
    }
    /* write CRT registers */
    for (i = 0; i < CRT_C; i++) {
	port_out(i, __svgalib_CRT_I);
	port_out(regs[CRT + i], __svgalib_CRT_D);
    }

    /* write graphics controller registers */
    for (i = 0; i < GRA_C; i++) {
	port_out(i, GRA_I);
	port_out(regs[GRA + i], GRA_D);
    }

    /* write attribute controller registers */
    for (i = 0; i < ATT_C; i++) {
	port_in(__svgalib_IS1_R);		/* reset flip-flop */
	__svgalib_delay();
	port_out(i, ATT_IW);
	__svgalib_delay();
	port_out(regs[ATT + i], ATT_IW);
	__svgalib_delay();
    }

    return 0;
}

#ifndef OSKIT
static void idle_accel(void) {
    /* wait for the accel to finish, we assume one of the both interfaces suffices */
    if (vga_ext_set(VGA_EXT_AVAILABLE, VGA_AVAIL_ACCEL) & ACCELFLAG_SYNC)
        vga_accel(ACCEL_SYNC);
    else if (vga_getmodeinfo(CM)->haveblit & HAVE_BLITWAIT)
	vga_blitwait();
}
#endif

int __svgalib_getchipset(void)
{
    readconfigfile();		/* Make sure the config file is read. */

#ifndef OSKIT
    __svgalib_get_perm();
#endif /* !OSKIT */
    if (CHIPSET == UNDEFINED) {
	CHIPSET = VGA;		/* Protect against recursion */
#ifdef INCLUDE_CHIPS_DRIVER_TEST
	if (__svgalib_chips_driverspecs.test())
	    CHIPSET = CHIPS;
	else
#endif
#ifdef INCLUDE_MACH64_DRIVER_TEST
	if (__svgalib_mach64_driverspecs.test())
	    CHIPSET = MACH64;
	else
#endif
#ifdef INCLUDE_MACH32_DRIVER_TEST
	if (__svgalib_mach32_driverspecs.test())
	    CHIPSET = MACH32;
	else
#endif
#ifdef INCLUDE_EGA_DRIVER_TEST
	if (__svgalib_ega_driverspecs.test())
	    CHIPSET = EGA;
	else
#endif
#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_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_NV3_DRIVER_TEST
	if (__svgalib_nv3_driverspecs.test())
	    CHIPSET = NV3;
	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

	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;
    }
#ifndef OSKIT
    __svgalib_get_perm();
#endif /* !OSKIT */
    __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
#ifndef OSKIT
    __svgalib_get_perm();
#endif /* !OSKIT */
    __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;
}


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

#ifndef OSKIT
/* 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);
#endif /* !OSKIT */

#endif

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);
}

#ifndef BACKGROUND

inline void vga_setpage(int p)
{
    p += vga_page_offset;
    if (p == __svgalib_currentpage)
	return;
    (*__svgalib_setpage) (p);
    __svgalib_currentpage = p;
}


void vga_setreadpage(int p)
{
    p += vga_page_offset;
    if (p == __svgalib_currentpage)
	return;
    (*__svgalib_setrdpage) (p);
    __svgalib_currentpage = -1;
}


void vga_setwritepage(int p)
{
    p += vga_page_offset;
    if (p == __svgalib_currentpage)
	return;
    (*__svgalib_setwrpage) (p);
    __svgalib_currentpage = -1;
}

#endif


static void prepareforfontloading(void)
{
    if (__svgalib_chipset == CIRRUS) {
	outb(0x3c4, 0x0f);
	/* Disable CRT FIFO Fast-Page mode. */
	outb(0x3c5, inb(0x3c5) | 0x40);
    }
}

static void fontloadingcomplete(void)
{
    if (__svgalib_chipset == CIRRUS) {
	outb(0x3c4, 0x0f);
	/* Re-enable CRT FIFO Fast-Page mode. */
	outb(0x3c5, inb(0x3c5) & 0xbf);
    }
}


int vga_setmode(int mode)
{
#ifdef BACKGROUND
    __svgalib_dont_switch_vt_yet();
    /* Can't initialize if screen is flipped. */
    if (__svgalib_oktowrite)
#endif
    if (!initialized)
	initialize();

    if (mode != TEXT && !chipset_modeavailable(mode))
       {
#ifdef BACKGROUND
         __svgalib_is_vt_switching_needed();
#endif
	return -1;
       }
       
#ifdef BACKGROUND
    if (!__svgalib_oktowrite)
        {
	 prv_mode=CM;
	 CM=mode;
	 vga_setpage(0);
	 __svgalib_is_vt_switching_needed();
	 return(0);
	 /* propably this was enough. */
	 /* hmm.. there... virtual screen... */
	}
#endif
       
/*    if (!flip)
   vga_lockvc(); */
#ifndef OSKIT
    disable_interrupt();
#endif /* !OSKIT */

    prv_mode = CM;
    CM = mode;

    /* disable video */
    vga_screenoff();

    if(!__svgalib_novga) {
    /* Should be more robust (eg. grabbed X modes) */
	if (__svgalib_getchipset() == ET4000
	     && prv_mode != G640x480x256
	     && SVGAMODE(prv_mode))
	    chipset_setmode(G640x480x256, prv_mode);

	/* This is a hack to get around the fact that some C&T chips
	 * are programmed to ignore syncronous resets. So if we are
	 * a C&T wait for retrace start
	 */
	if (__svgalib_getchipset() == CHIPS) {
	   while (((port_in(__svgalib_IS1_R)) & 0x08) == 0x08 );/* wait VSync off */
	   while (((port_in(__svgalib_IS1_R)) & 0x08) == 0 );   /* wait VSync on  */
	   port_outw(0x3C4,0x07);         /* reset hsync - just in case...  */
	}
    }

    if (mode == TEXT) {
	/* Returning to textmode. */

#ifndef OSKIT
	if (prv_mode != TEXT && mouse_mode == prv_mode) {
#ifdef DEBUG
	    printf("svgalib: Closing mouse.\n");
#endif
	    mouse_close();
	    mouse_mode = 0;
	    /* vga_unlockvc(); */
	}
#endif /* !OSKIT */
	if (SVGAMODE(prv_mode))
	    vga_setpage(0);


	/* The extended registers are restored either by the */
	/* chipset setregs function, or the chipset setmode function. */

	/* restore font data - first select a 16 color graphics mode */
	/* Note: this should restore the old extended registers if */
	/* setregs is not defined for the chipset. */
        if(__svgalib_novga) __svgalib_driverspecs->setmode(TEXT, prv_mode);
        if (__svgalib_driverspecs->emul && __svgalib_driverspecs->emul->restorefont) {
           __svgalib_driverspecs->emul->restorefont(); 
	   chipset_setregs(text_regs, mode);
        } else if(!__svgalib_novga) {
	  __svgalib_driverspecs->setmode(GPLANE16, prv_mode);

	  if (CHIPSET != EGA)
	      /* restore old extended regs */
	      chipset_setregs(text_regs, mode);

	  /* disable Set/Reset Register */
	  port_out(0x01, GRA_I);
	  port_out(0x00, GRA_D);

	  prepareforfontloading();

	  /* restore font data in plane 2 - necessary for all VGA's */
	  port_out(0x02, SEQ_I);
	  port_out(0x04, SEQ_D);
#ifdef __alpha__
	  port_out(0x06, GRA_I);
	  port_out(0x00, GRA_D);
#endif

#ifdef BACKGROUND
          if (-1 == mprotect(font_buf1,FONT_SIZE*2,PROT_READ|PROT_WRITE))
          {
	   printf("svgalib: Memory protect error\n");
	   exit(-1);
	  }
#endif

#if defined(CONFIG_ALPHA_JENSEN)
	  slowcpy_to_sm(SM, font_buf1, FONT_SIZE);
#else
	  slowcpy(GM, font_buf1, FONT_SIZE);
#endif

	  /* restore font data in plane 3 - necessary for Trident VGA's */
	  port_out(0x02, SEQ_I);
	  port_out(0x08, SEQ_D);
#if defined(CONFIG_ALPHA_JENSEN)
	  slowcpy_to_sm(SM, font_buf2, FONT_SIZE);
#else
	  slowcpy(GM, font_buf2, FONT_SIZE);
#endif
#ifdef BACKGROUND
          if (-1 == mprotect(font_buf1,FONT_SIZE*2,PROT_READ))
          {
	   printf("svgalib: Memory protect error\n");
	   exit(1);
	  }
#endif
	  fontloadingcomplete();

	  /* change register adresses if monochrome text mode */
	  /* EGA is assumed to use color emulation. */
	  if (!color_text) {
	      __svgalib_CRT_I = CRT_IM;
	      __svgalib_CRT_D = CRT_DM;
	      __svgalib_IS1_R = IS1_RM;
	      port_out(port_in(MIS_R) & 0xFE, MIS_W);
	  }
        } else chipset_setregs(text_regs, mode);
	/* restore saved palette */
	restorepalette(text_red, text_green, text_blue);

	/* restore text mode VGA registers */
	__svgalib_setregs(text_regs);

	/* Set VMEM to some minimum value .. probably pointless.. */
	{
	    vga_claimvideomemory(12);
	}

#ifndef OSKIT
/*      if (!flip) */
	/* enable text output - restores the screen contents */
	ioctl(__svgalib_tty_fd, KDSETMODE, KD_TEXT);
#endif /* !OSKIT */

	usleep(MODESWITCHDELAY);	/* wait for signal to stabilize */

	/* enable video */
	vga_screenon();

#ifndef OSKIT
	if (!flip)
	    /* restore text mode termio */
	    set_texttermio();
#endif /* !OSKIT */
    } else {
	/* Setting a graphics mode. */

#ifndef OSKIT
	/* disable text output */
	ioctl(__svgalib_tty_fd, KDSETMODE, KD_GRAPHICS);
#endif

	if (SVGAMODE(prv_mode)) {
	    /* The current mode is an SVGA mode, and we now want to */
	    /* set a standard VGA mode. Make sure the extended regs */
	    /* are restored. */
	    /* Also used when setting another SVGA mode to hopefully */
	    /* eliminate lock-ups. */
	    vga_setpage(0);
	    chipset_setregs(text_regs, mode);
	    /* restore old extended regs */
	}
	/* shift to color emulation */
	setcoloremulation();

	CI.xdim = infotable[mode].xdim;
	CI.ydim = infotable[mode].ydim;
	CI.colors = infotable[mode].colors;
	CI.xbytes = infotable[mode].xbytes;
	CI.bytesperpixel = infotable[mode].bytesperpixel;

	chipset_setmode(mode, prv_mode);

	MODEX = 0;

	/* Set default claimed memory (moved here from initialize - Michael.) */
	if (mode == G320x200x256)
	    VMEM = 65536;
	else if (STDVGAMODE(mode))
	    VMEM = 256 * 1024;	/* Why always 256K ??? - Michael */
	else {
	    vga_modeinfo *modeinfo;

	    modeinfo = vga_getmodeinfo(mode);
	    VMEM = modeinfo->linewidth * modeinfo->height;
            CI.xbytes = modeinfo->linewidth;
	}

	if (!flip) {