Subversion Repositories or1k

#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <linux/vt.h>
#include "device.h"
#include "fb.h"
/*
 * VT switch handling code for Linux
 */
 
/* signal to use when VT swithing*/
#ifndef SIGUNUSED
#define SIGUNUSED	SIGUSR1		/* some systems lack SIGUNUSED*/
#endif
 
#define SIGVTSWITCH	SIGUNUSED	/* SIGUSR2 is used by pthreads...*/
 
int	mwvterm;		/* the VT we were started on */
volatile int mwdrawing;		/* nonzero when drawing is happening*/
static int mwcvt, mwocvt;
static int ttyfd = -1;		/* /dev/tty0*/
static int visible = 1;		/* VT visible flag*/
static struct vt_mode mode;	/* terminal mode*/
static SUBDRIVER save;		/* saved subdriver when VT switched*/
 
extern SCREENDEVICE	scrdev;	/* FIXME */
 
/* entry points*/
int 	MwInitVt(void);
int  	MwCurrentVt(void);
int  	MwCheckVtChange(void);
void 	MwRedrawVt(int t);
 
/* local routines*/
static void  	draw_enable(void);
static void 	draw_disable(void);
static void	vt_switch(int sig);
 
/* null subdriver for drawing when switched out*/
static void 	null_drawpixel(PSD psd,MWCOORD x, MWCOORD y, MWPIXELVAL c) {}
static MWPIXELVAL null_readpixel(PSD psd,MWCOORD x, MWCOORD y) { return 0;}
static void	null_drawhorzline(PSD psd,MWCOORD x1,MWCOORD x2,MWCOORD y,
			MWPIXELVAL c) {}
static void	null_drawvertline(PSD psd,MWCOORD x,MWCOORD y1,MWCOORD y2,
			MWPIXELVAL c) {}
static void	null_fillrect(PSD psd,MWCOORD x1,MWCOORD y1,MWCOORD x2,
			MWCOORD y2,MWPIXELVAL c) {}
static void	null_blit(PSD dstpsd,MWCOORD destx,MWCOORD desty,MWCOORD w,
			MWCOORD h,PSD srcpsd,MWCOORD srcx,MWCOORD srcy,
			long op) {}
static void 	null_drawarea(PSD psd, driver_gc_t *gc, int op) {}
static SUBDRIVER nulldriver = {
	NULL,
	null_drawpixel,
	null_readpixel,
	null_drawhorzline,
	null_drawvertline,
	null_fillrect,
	null_blit,
	null_drawarea
};
 
static void
draw_enable(void)
{
	if(visible)
		return;
	visible = 1;
 
	/* restore screen drawing functions*/
	set_subdriver(&scrdev, &save, FALSE);
}
 
static void
draw_disable(void)
{
	if(!visible)
		return;
	visible = 0;
 
	/* save screen drawing functions and reroute drawing*/
	get_subdriver(&scrdev, &save);
 
	/* set null driver*/
	set_subdriver(&scrdev, &nulldriver, FALSE);
}
 
/* Timer handler used to do the VT switch at a time when not drawing */
static void
vt_do_switch(void *arg)
{
    static unsigned short r[16], g[16], b[16];
 
    /*
     * If a drawing function is in progress then we cannot mode
     * switch right now because the drawing function would continue to
     * scribble on the screen after the switch.  So disable further
     * drawing and schedule an alarm to try again in .1 second.
     */
    if(mwdrawing) {
    	draw_disable ();
	GdAddTimer(100, vt_do_switch, NULL);
    	return;
    }
 
    if(visible) {
    	draw_disable ();
	ioctl_getpalette(0, 16, r, g, b);
 
	if(ioctl (ttyfd, VT_RELDISP, 1) == -1)
	    EPRINTF("Error can't switch away from VT: %m\n");
    } else {
	ioctl_setpalette(0, 16, r, g, b);
    	draw_enable ();
 
	if(ioctl (ttyfd, VT_RELDISP, VT_ACKACQ) == -1)
		EPRINTF("Error can't acknowledge VT switch: %m\n");
    }
}
 
/* Signal handler called when kernel switches to or from our tty*/
static void
vt_switch(int sig)
{
	signal(SIGVTSWITCH, vt_switch);
	vt_do_switch(NULL);
}
 
/*
 * Init VT switch catching code
 * 	return 0 on success, -1 on error
 */
int
MwInitVt(void)
{
	ttyfd = open("/dev/tty0", O_RDONLY);
	if(ttyfd == -1)
		return EPRINTF("Error can't open tty0: %m\n");
 
	/* setup new tty mode*/
	if(ioctl (ttyfd, VT_GETMODE, &mode) == -1)
		return EPRINTF("Error can't get VT mode: %m\n");
 
	mode.mode = VT_PROCESS;
	mode.relsig = SIGVTSWITCH;
	mode.acqsig = SIGVTSWITCH;
	signal (SIGVTSWITCH, vt_switch);
	if(ioctl (ttyfd, VT_SETMODE, &mode) == -1)
		return EPRINTF("Error can't set VT mode: %m\n");
 
	mwcvt = mwocvt = mwvterm = MwCurrentVt();
	/*
	 * Note: this hack is required to get Linux
	 * to orient virtual 0,0 with physical 0,0
	 * I have no idea why this kluge is required...
	 */
	MwRedrawVt(mwvterm);
 
	return 0;
}
 
/*
 * This function is used to find out what the current active VT is.
 */
int
MwCurrentVt(void)
{
	struct vt_stat stat;
 
	ioctl(ttyfd, VT_GETSTATE, &stat);
	return stat.v_active;
}
 
/*
 * Check if our VT has changed.  Return 1 if so.
 */
int
MwCheckVtChange(void)
{
	mwcvt = MwCurrentVt();
	if(mwcvt != mwocvt && mwcvt == mwvterm) {
		mwocvt = mwcvt;
		return 1;
	}
	mwocvt = mwcvt;
	return 0;
}
 
/*
 * This function is used to cause a redraw of the text console.
 * FIXME: Switching to another console and
 * back works, but that's a really dirty hack
 */
void
MwRedrawVt(int t)
{
	if(MwCurrentVt() == mwvterm) {
		ioctl(ttyfd, VT_ACTIVATE, t == 1 ? 2 : 1); /* Awful hack!!*/
		ioctl(ttyfd, VT_ACTIVATE, t);
	}
}
 
void
MwExitVt(void)
{
	signal(SIGVTSWITCH, SIG_DFL);
	mode.mode = VT_AUTO;
	mode.relsig = 0;
	mode.acqsig = 0;
	ioctl(ttyfd, VT_SETMODE, &mode);
 
	if(ttyfd != -1)
		close(ttyfd);
}