pcvt_sup.c

freebsd v4.4内核源码

	vgapage(current_video_screen);
#else
	switch_screen(current_video_screen, 0, 0);
#endif /* !PCVT_USL_VT_COMPAT */

}

/*---------------------------------------------------------------------------*
 *	ega/vga ioctl - get font attributes
 *---------------------------------------------------------------------------*/
static void
vgagetfontattr(struct vgafontattr *data)
{
	int vga_character_set;

	vga_character_set = data->character_set;
	vga_character_set = (vga_character_set < 0) ? 0 :
		((vga_character_set < (int)totalfonts) ?
		 vga_character_set :
		 (int)(totalfonts-1));

	data->character_set = (int)vga_character_set;

	data->font_loaded = (int)vgacs[vga_character_set].loaded;

	data->character_scanlines =
		(int)vgacs[vga_character_set].char_scanlines
		& 0x1f;		/* do not display the overflow bits */

	data->screen_scanlines = (int)vgacs[vga_character_set].scr_scanlines;

	data->screen_size = (int)vgacs[vga_character_set].screen_size;
}

/*---------------------------------------------------------------------------*
 *	ega/vga ioctl - load a character shape into character set
 *---------------------------------------------------------------------------*/
static void
vgaloadchar(struct vgaloadchar *data)
{
	int vga_character_set;
	int character;
	int lines_per_character;

	vga_character_set = data->character_set;
	vga_character_set = (vga_character_set < 0) ? 0 :
		((vga_character_set < (int)totalfonts) ?
		 vga_character_set : (int)(totalfonts-1));

	character = (data->character < 0) ? 0 :
		((data->character > 255) ? 255 : data->character);

	lines_per_character = (int)data->character_scanlines;
	lines_per_character = (lines_per_character < 0) ? 0 :
	        ((lines_per_character > 32) ? 32 : lines_per_character);

	loadchar(vga_character_set,character,lines_per_character,
		 data->char_table);
}

/*---------------------------------------------------------------------------*
 *	video ioctl - get screen information
 *---------------------------------------------------------------------------*/
static void
vid_getscreen(struct screeninfo *data, Dev_t dev)
{
	int device = minor(dev);
	data->adaptor_type = adaptor_type;	/* video adapter installed */
	data->monitor_type = color;		/* monitor type installed */
	data->totalfonts = totalfonts;		/* no of downloadble fonts */
	data->totalscreens = totalscreens;	/* no of virtual screens */
	data->screen_no = device;		/* this screen number */
	data->current_screen = current_video_screen; /* displayed screen no */
	/* screen size */
	data->screen_size = vgacs[(vs[device].vga_charset)].screen_size;
	/* pure VT mode or HP/VT mode */
	data->pure_vt_mode = vs[device].vt_pure_mode;
	data->vga_family = vga_family;		/* manufacturer, family */
	data->vga_type = vga_type;		/* detected chipset type */
	data->vga_132 = can_do_132col;		/* 132 column support */
	data->force_24lines = vs[device].force24; /* force 24 lines */
}

/*---------------------------------------------------------------------------*
 *	video ioctl - set screen information
 *---------------------------------------------------------------------------*/
static void
vid_setscreen(struct screeninfo *data, Dev_t dev)
{
	int screen;

	if(data->current_screen == -1)
	{
		screen = minor(dev);
	}
	else
	{
		if(data->current_screen >= PCVT_NSCREENS)
			return;					/* XXXXXX */
		screen = data->current_screen;
	}

	vgapage(screen);

#if defined XSERVER && PCVT_USL_VT_COMPAT
	{
		int x = spltty(), waitfor = screen + 1;
		/* if the vt is yet to be released by a process, wait here */
		if(vs[screen].vt_status & VT_WAIT_REL)
			(void)usl_vt_ioctl(dev, VT_WAITACTIVE,
					   (caddr_t)&waitfor, 0, 0);
		splx(x);
	}
	/* make sure the switch really happened */
	if(screen != current_video_screen)
		return;		/* XXX should say "EAGAIN" here */
#endif /* defined XSERVER && PCVT_USL_VT_COMPAT */

	if((data->screen_size != -1) || (data->force_24lines != -1))
	{
		if(data->screen_size == -1)
			data->screen_size =
				vgacs[(vs[screen].vga_charset)].screen_size;

		if(data->force_24lines != -1)
		{
			vs[screen].force24 = data->force_24lines;

			if(vs[screen].force24)
			{
				swritefkl(2,(u_char *)"FORCE24 ENABLE *",
					  &vs[screen]);
			}
			else
			{
				swritefkl(2,(u_char *)"FORCE24 ENABLE  ",
					  &vs[screen]);
			}
		}

		if((data->screen_size == SIZ_25ROWS) ||
		   (data->screen_size == SIZ_28ROWS) ||
		   (data->screen_size == SIZ_35ROWS) ||
		   (data->screen_size == SIZ_40ROWS) ||
		   (data->screen_size == SIZ_43ROWS) ||
		   (data->screen_size == SIZ_50ROWS))
		{
			if(data->screen_no == -1)
				set_screen_size(vsp, data->screen_size);
			else
				set_screen_size(&vs[minor(dev)],
						data->screen_size);
		}
	}

	if(data->pure_vt_mode != -1)
	{
		if((data->pure_vt_mode == M_HPVT) ||
		   (data->pure_vt_mode == M_PUREVT))
		{
			if(data->screen_no == -1)
				set_emulation_mode(vsp, data->pure_vt_mode);
			else
				set_emulation_mode(&vs[minor(dev)],
						   data->pure_vt_mode);
		}
	}
}

/*---------------------------------------------------------------------------*
 *	set screen size/resolution for a virtual screen
 *---------------------------------------------------------------------------*/
void
set_screen_size(struct video_state *svsp, int size)
{
	int i;

	for(i = 0; i < totalfonts; i++)
	{
		if(vgacs[i].screen_size == size)
		{
			set_charset(svsp, i);
			clr_parms(svsp); 	/* escape parameter init */
			svsp->state = STATE_INIT; /* initial state */
			svsp->scrr_beg = 0;	/* start of scrolling region */
			svsp->sc_flag = 0;	/* invalidate saved cursor
						 * position */
			svsp->transparent = 0;	/* disable control code
						 * processing */

			/* Update tty to reflect screen size */

			if (svsp->vs_tty)
			{
				svsp->vs_tty->t_winsize.ws_col = svsp->maxcol;
				svsp->vs_tty->t_winsize.ws_xpixel =
					(svsp->maxcol == 80)? 720: 1056;
				svsp->vs_tty->t_winsize.ws_ypixel = 400;
				svsp->vs_tty->t_winsize.ws_row =
					svsp->screen_rows;
			}
			/* screen_rows already calculated in set_charset() */
			if(svsp->vt_pure_mode == M_HPVT && svsp->labels_on)
			{
				if(svsp->which_fkl == SYS_FKL)
					sw_sfkl(svsp);
				else if(svsp->which_fkl == USR_FKL)
					sw_ufkl(svsp);
			}


			svsp->scrr_len = svsp->screen_rows;
			svsp->scrr_end = svsp->scrr_len - 1;

#if PCVT_SIGWINCH
			if (svsp->vs_tty && svsp->vs_tty->t_pgrp)
				pgsignal(svsp->vs_tty->t_pgrp, SIGWINCH, 1);
#endif /* PCVT_SIGWINCH */

			break;
		}
 	}
}

/*---------------------------------------------------------------------------*
 *	VGA ioctl - read DAC palette entry
 *---------------------------------------------------------------------------*/
static void
vgareadpel(struct vgapel *data, Dev_t dev)
{
	register unsigned vpage = minor(dev);
	register unsigned idx = data->idx;

	if(idx >= NVGAPEL)
		return;		/* no such entry */

	/* do not read VGA palette directly, use saved values */
	data->r = vs[vpage].palette[idx].r;
	data->g = vs[vpage].palette[idx].g;
	data->b = vs[vpage].palette[idx].b;
}

/*---------------------------------------------------------------------------*
 *	VGA ioctl - write DAC palette entry
 *---------------------------------------------------------------------------*/
static void
vgawritepel(struct vgapel *data, Dev_t dev)
{
	register unsigned vpage = minor(dev);
	register unsigned idx = data->idx;

	if(idx >= NVGAPEL)
		return;		/* no such entry */

	/* first, update saved values for this video screen */
	vs[vpage].palette[idx].r = data->r;
	vs[vpage].palette[idx].g = data->g;
	vs[vpage].palette[idx].b = data->b;

	/* if this happens on active screen, update VGA DAC, too */
	if(vpage == current_video_screen)
		vgapaletteio(idx, &vs[vpage].palette[idx], 1);
}

/*---------------------------------------------------------------------------*
 *	VGA physical IO - read/write one palette entry
 *---------------------------------------------------------------------------*/
void
vgapaletteio(unsigned idx, struct rgb *val, int writeit)
{

#if PCVT_PALFLICKER
	vga_screen_off();
#endif /* PCVT_PALFLICKER */

	if(writeit)
	{
		outb(VGA_DAC + 2, idx);

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		outb(VGA_DAC + 3, val->r & VGA_PMSK);

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		outb(VGA_DAC + 3, val->g & VGA_PMSK);

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		outb(VGA_DAC + 3, val->b & VGA_PMSK);
	}
	else	/* read it */
	{
		outb(VGA_DAC + 1, idx);

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		val->r = inb(VGA_DAC + 3) & VGA_PMSK;

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		val->g = inb(VGA_DAC + 3) & VGA_PMSK;

#if PCVT_WAITRETRACE
		wait_retrace();
#endif /* PCVT_WAITRETRACE */

		val->b = inb(VGA_DAC + 3) & VGA_PMSK;
	}

#if PCVT_PALFLICKER
	vga_screen_on();
#endif /* PCVT_PALFLICKER */

}

/*---------------------------------------------------------------------------*
 *
 *	update asynchronous: cursor, cursor pos displ, sys load, keyb scan
 *
 *	arg is:
 *		UPDATE_START = do update; requeue
 *		UPDATE_STOP  = suspend updates
 *		UPDATE_KERN  = do update for kernel printfs
 *
 *---------------------------------------------------------------------------*/
void
async_update(void *arg)
{
	static int lastpos = 0;
	static int counter = PCVT_UPDATESLOW;

#ifdef XSERVER
	/* need a method to suspend the updates */

	if(arg == UPDATE_STOP)
	{
		untimeout(async_update, UPDATE_START);
		return;
	}
#endif /* XSERVER */

	/* first check if update is possible */

	if(chargen_access		/* does no-one load characters? */
#ifdef XSERVER				/* is vt0 not in graphics mode? */
#if !PCVT_USL_VT_COMPAT
	   || pcvt_xmode		/* XXX necessary ????? */
#endif /* PCVT_USL_VT_COMPAT */
#endif /* XSERVER */
	   )
	{
		goto async_update_exit;	/* do not update anything */
	}

#if PCVT_SCREENSAVER
	if(reset_screen_saver && (counter == PCVT_UPDATESLOW))
	{
		pcvt_scrnsv_reset();	/* yes, do it */
		reset_screen_saver = 0;	/* re-init */
	}
	else if(scrnsv_active)		/* is the screen not blanked? */
	{
		goto async_update_exit;	/* do not update anything */
	}
#endif /* PCVT_SCREENSAVER */

	/*-------------------------------------------------------------------*/
	/* this takes place on EVERY virtual screen (if not in X mode etc...)*/
	/*-------------------------------------------------------------------*/

	if ( cursor_pos_valid &&
	    (lastpos != (vsp->Crtat + vsp->cur_offset - Crtat)))
	{
		lastpos = vsp->Crtat + vsp->cur_offset - Crtat;
	 	outb(addr_6845, CRTC_CURSORH);	/* high register */
		outb(addr_6845+1, ((lastpos) >> 8));
		outb(addr_6845, CRTC_CURSORL);	/* low register */
		outb(addr_6845+1, (lastpos));
	}

	if (arg == UPDATE_KERN)		/* Magic arg: for kernel printfs */
		return;

	if(--counter)			/* below is possible update */
		goto async_update_exit;	/*  just now and then ..... */
	counter = PCVT_UPDATESLOW;	/* caution, see screensaver above !! */

	/*-------------------------------------------------------------------*/
	/* this takes place ONLY on screen 0 if in HP mode, labels on, !X    */
	/*-------------------------------------------------------------------*/

	/* additional processing for HP necessary ? */

	if((vs[0].vt_pure_mode == M_HPVT) && (vs[0].labels_on))
	{
		static volatile u_char buffer[] =
		       "System Load: 1min: 0.00 5min: 0.00 15min: 0.00";
		register int tmp, i;
#if PCVT_SHOWKEYS
		extern u_char rawkeybuf[80];

		if(keyboard_show)
		{
			for(i = 0; i < 80; i++)
			{
				*((vs[0].Crtat+((vs[0].screen_rows+2)
					* vs[0].maxcol))+i) =
				 user_attr | rawkeybuf[i];
			}
		}
		else
		{
#endif	/* PCVT_SHOWKEYS */

		/* display load averages in last line (taken from tty.c) */
			i = 18;
#ifdef NEW_AVERUNNABLE
	 		tmp = (averunnable.ldavg[0] * 100 + FSCALE / 2)
				>> FSHIFT;
#else
			tmp = (averunnable[0] * 100 + FSCALE / 2) >> FSHIFT;
#endif

			buffer[i++] =
				((((tmp/100)/10) == 0) ?
				 ' ' :
				 ((tmp/100)/10) + '0');
			buffer[i++] = ((tmp/100)%10) + '0';
			buffer[i++] = '.';
			buffer[i++] = ((tmp%100)/10) + '0';
			buffer[i++] = ((tmp%100)%10) + '0';
			i += 6;
#ifdef NEW_AVERUNNABLE
	 		tmp = (averunnable.ldavg[1] * 100 + FSCALE / 2)
				>> FSHIFT;
#else
			tmp = (averunnable[1] * 100 + FSCALE / 2) >> FSHIFT;
#endif
			buffer[i++] = ((((tmp/100)/10) == 0) ?
				       ' ' :
				       ((tmp/100)/10) + '0');
			buffer[i++] = ((tmp/100)%10) + '0';
			buffer[i++] = '.';
			buffer[i++] = ((tmp%100)/10) + '0';
			buffer[i++] = ((tmp%100)%10) + '0';
			i += 7;
#ifdef NEW_AVERUNNABLE
	 		tmp = (averunnable.ldavg[2] * 100 + FSCALE / 2)
				>> FSHIFT;
#else
			tmp = (averunnable[2] * 100 + FSCALE / 2) >> FSHIFT;
#endif
			buffer[i++] = ((((tmp/100)/10) == 0) ?
				       ' ' :
				       ((tmp/100)/10) + '0');
			buffer[i++] = ((tmp/100)%10) + '0';
			buffer[i++] = '.';
			buffer[i++] = ((tmp%100)/10) + '0';
			buffer[i++] = ((tmp%100)%10) + '0';
			buffer[i] = '\0';

			for(i = 0; buffer[i]; i++)
			{
				*((vs[0].Crtat +
				   ((vs[0].screen_rows + 2) * vs[0].maxcol)
				   ) + i
				  ) = user_attr | buffer[i];
			}

#if PCVT_SHOWKEYS
			for(; i < 77; i++)
			{
				*((vs[0].Crtat +
				   ((vs[0].screen_rows + 2) * vs[0].maxcol)
				   ) + i
				  ) = user_attr | ' ';
			}

		}
#endif	/* PCVT_SHOWKEYS */
	}

	/*-------------------------------------------------------------------*/
	/* this takes place on EVERY screen which is in HP mode, labels on,!X*/
	/*-------------------------------------------------------------------*/

	if((vsp->vt_pure_mode == M_HPVT) && (vsp->labels_on))
	{
		register int col = vsp->col+1;
		register u_short *p = vsp->Crtat +
				(vsp->screen_rows * vsp->maxcol);

		/* update column display between labels */

		if(vsp->maxcol == SCR_COL132)
		{
			p += (SCR_COL132 - SCR_COL80)/2;

			if(col >= 100)
			{
				*(p + LABEL_COLU) = user_attr | '1';
				col -= 100;
			}
			else
			{
				*(p + LABEL_COLU) = user_attr | '0';
			}
		}
		*(p + LABEL_COLH) = user_attr | ((col/10) + '0');
		*(p + LABEL_COLL) = user_attr | ((col%10) + '0');

		/* update row display between labels */

		*(p + LABEL_ROWH) = (user_attr | (((vsp->row+1)/10) + '0'));
		*(p + LABEL_ROWL) = (user_attr | (((vsp->row+1)%10) + '0'));
	}

async_update_exit:

 	if(arg == UPDATE_START)
	{
	   timeout(async_update, UPDATE_START, PCVT_UPDATEFAST);
	}
}

/*---------------------------------------------------------------------------*
 *	set character set for virtual screen
 *---------------------------------------------------------------------------*/
void
set_charset(struct video_state *svsp, int curvgacs)
{
	static int sizetab[] = { 25, 28, 35, 40, 43, 50 };
	int oldsize, oldrows, newsize, newrows;

	if((curvgacs < 0) || (curvgacs > (NVGAFONTS-1)))
		return;

	svsp->vga_charset = curvgacs;

	select_vga_charset(curvgacs);