event.svga

BIOS emulator and interface to Realmode X86 Emulator Library Can emulate a PCI Graphic Controller V

/****************************************************************************
*
*           The SuperVGA Kit - UniVBE Software Development Kit
*
*  ========================================================================
*
*    The contents of this file are subject to the SciTech MGL Public
*    License Version 1.0 (the "License"); you may not use this file
*    except in compliance with the License. You may obtain a copy of
*    the License at http://www.scitechsoft.com/mgl-license.txt
*
*    Software distributed under the License is distributed on an
*    "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
*    implied. See the License for the specific language governing
*    rights and limitations under the License.
*
*    The Original Code is Copyright (C) 1991-1998 SciTech Software, Inc.
*
*    The Initial Developer of the Original Code is SciTech Software, Inc.
*    All Rights Reserved.
*
*  ========================================================================
*
* Language:     ANSI C
* Environment:  IBM PC (MS DOS)
*
* Description:  Routines to provide a Linux event queue, which automatically
*               handles keyboard and mouse events for the Linux compatability
*               libraries. Based on the event handling code in the MGL.
*
****************************************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <termios.h>
#include <signal.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <linux/keyboard.h>
#include <linux/kd.h>
#include <linux/vt.h>
#include <gpm.h>
#include "pm.h"
#include "vesavbe.h"
#include "wdirect.h"

/*--------------------------- Global variables ----------------------------*/

#define EVENTQSIZE  100        		/* Number of events in event queue  */

static int     	head = -1;      	/* Head of event queue              */
static int     	tail = -1;      	/* Tail of event queue              */
static int     	freeHead = -1;  	/* Head of free list                */
static int     	count = 0;      	/* No. of items currently in queue  */
static WD_event evtq[EVENTQSIZE];	/* The queue structure itself      */
static int		oldMove = -1;		/* Previous movement event			*/
static int		oldKey = -1;		/* Previous key repeat event		*/
static int		mx,my;				/* Current mouse position			*/
static int		xRes,yRes;			/* Screen resolution coordinates	*/
static void		*stateBuf;			/* Pointer to console state buffer	*/
static int      conn;         	    /* GPM file descriptor for mouse handling */
static int      tty_fd;             /* File descriptor for /dev/console */
extern int		tty_vc;				/* Virtual console ID, from the PM/Pro library */
static ibool    key_down[128];		/* State of all keyboard keys		*/
static struct termios old_conf;     /* Saved terminal configuration 	*/
static int      oldkbmode;          /* and previous keyboard mode 		*/
struct vt_mode 	oldvtmode;			/* Old virtual terminal mode		*/
static int 		old_flags;			/* Old flags for fcntl				*/
static ulong	key_modifiers;		/* Keyboard modifiers				*/
static int 		forbid_vt_release=0;/* Flag to forbid release of VT		*/
static int 		forbid_vt_acquire=0;/* Flag to forbid cature of VT		*/
static int      oldmode;            /* Old SVGA mode saved for VT switch*/
static int      initmode;           /* Initial text mode                */
static ibool	installed = false;	/* True if we are installed			*/
static void 	(_ASMAPI *moveCursor)(int x,int y) = NULL;
static int      (_ASMAPI *suspendAppCallback)(int flags) = NULL;

#if 0
/* Keyboard Translation table from scancodes to ASCII */

static uchar keyTable[128] =
"\0\0331234567890-=\010"
"\011qwertyuiop[]\015"
"\0asdfghjkl;'`\0\\"
"zxcvbnm,./\0*\0 \0"
"\0\0\0\0\0\0\0\0\0\0\0\0"		/* Function keys */
"789-456+1230.\0\0\0\0\0"		/* Keypad keys */
"\0\0\0\0\0\0\0\015\0/";

static uchar keyTableShifted[128] =
"\0\033!@#$%^&*()_+\010"
"\011QWERTYUIOP{}\015"
"\0ASDFGHJKL:\"~\0|"
"ZXCVBNM<>?\0*\0 \0"
"\0\0\0\0\0\0\0\0\0\0\0\0"		/* Function keys */
"789-456+1230.\0\0\0\0\0"		/* Keypad keys */
"\0\0\0\0\0\0\0\015\0/";
#endif

/* Macros to keep track of the CAPS and NUM lock states */

#define	EVT_CAPSSTATE	0x0100
#define	EVT_NUMSTATE	0x0200

/* Helper macros for dealing with timers */

#define TICKS_TO_USEC(t) ((t)*65536.0/1.193180)
#define USEC_TO_TICKS(u) ((u)*1.193180/65536.0)

/* Number of keycodes to read at a time from the console */

#define KBDREADBUFFERSIZE 32

/*---------------------------- Implementation -----------------------------*/

/****************************************************************************
REMARKS:
Returns the current time stamp in units of 18.2 ticks per second.
****************************************************************************/
static ulong getTimeStamp(void)
{
    return (ulong)(clock() / (CLOCKS_PER_SEC / 18.2));
}

/****************************************************************************
PARAMETERS:
evt - Event to place onto event queue

REMARKS:
Adds an event to the event queue by tacking it onto the tail of the event
queue. This routine assumes that at least one spot is available on the
freeList for the event to be inserted.
****************************************************************************/
static void addEvent(
	WD_event *evt)
{
    int         evtID;

    /* Get spot to place the event from the free list */
	evtID = freeHead;
	freeHead = evtq[freeHead].next;

    /* Add to the tail of the event queue   */
    evt->next = -1;
    evt->prev = tail;
    if (tail != -1)
        evtq[tail].next = evtID;
    else
        head = evtID;
    tail = evtID;
    evtq[evtID] = *evt;
    count++;
}

/****************************************************************************
PARAMETERS:
what        - Event code
message     - Event message
modifiers	- keyboard modifiers
x           - Mouse X position at time of event
y         	- Mouse Y position at time of event
but_stat    - Mouse button status at time of event

REMARKS:
Adds a new mouse event to the event queue. This routine is called from
within the mouse interrupt subroutine, so it must be efficient.
****************************************************************************/
static void addMouseEvent(
	uint what,
	uint message,
	int x,
	int y,
	uint but_stat)
{
	WD_event	evt;

	if (count < EVENTQSIZE) {
		evt.what = what;
		evt.when = getTimeStamp();
		evt.message = message;
		evt.modifiers = but_stat | key_modifiers;
		evt.where_x = x;
		evt.where_y = y;
		fprintf(stderr, "(%d,%d), buttons %ld\n", x,y, evt.modifiers);
		addEvent(&evt);            		/* Add to tail of event queue   */
		}
}

/****************************************************************************
PARAMETERS:
scancode	- Raw keyboard scan code
modifiers	- Keyboard modifiers flags

REMARKS:
Converts the raw scan code into the appropriate ASCII code using the scan
code and the keyboard modifier flags.
****************************************************************************/
static ulong getKeyMessage(
	uint scancode,
	ulong modifiers)
{
	ushort	code = scancode << 8;
	ushort	ascii;
	struct kbentry ke;

	ke.kb_index = scancode;

	/* Find the basic ASCII code for the scan code */
	if (modifiers & EVT_CAPSSTATE) {
		if (modifiers & EVT_SHIFTKEY)
		  ke.kb_table = K_NORMTAB;
		//			ascii = tolower(keyTableShifted[scancode]);
		else
		  ke.kb_table = K_SHIFTTAB;
		//			ascii = toupper(keyTable[scancode]);
		}
	else {
		if (modifiers & EVT_SHIFTKEY)
		  ke.kb_table = K_SHIFTTAB;
		  // ascii = keyTableShifted[scancode];
		else
		  ke.kb_table = K_NORMTAB;
		  // ascii = keyTable[scancode];
		}
	if(modifiers & EVT_ALTSTATE)
	  ke.kb_table |= K_ALTTAB;

	if (ioctl(tty_fd, KDGKBENT, (unsigned long)&ke)) {
		fprintf(stderr, "KDGKBENT at index %d in table %d: ",
			scancode, ke.kb_table);
		return 0;
	}
	ascii = ke.kb_value;

	/* Add ASCII code if key is not alt'ed or ctrl'ed */
	if (!(modifiers & (EVT_ALTSTATE | EVT_CTRLSTATE)))
		code |= ascii;

	return code;
}

/****************************************************************************
PARAMETERS:
what        - Event code
scancode    - Raw scancode of keyboard event to add

REMARKS:
Adds a new keyboard event to the event queue. We only take KEYUP and
KEYDOWN event codes, however if a key is already down we convert the KEYDOWN
to a KEYREPEAT.
****************************************************************************/
static void addKeyEvent(
	uint what,
	uint scancode)
{
	WD_event	evt;

	if (count < EVENTQSIZE) {
	    evt.what = what;
	    evt.when = getTimeStamp();
	    evt.message = getKeyMessage(scancode,key_modifiers) | 0x10000UL;
	    evt.where_x = evt.where_y = 0;
	    evt.modifiers = key_modifiers;
        if (evt.what == EVT_KEYUP)
        	key_down[scancode] = false;
      	else if (evt.what == EVT_KEYDOWN) {
        	if (key_down[scancode]) {
				if (oldKey != -1) {
				    evtq[oldKey].message += 0x10000UL;
            	    }
				else {
        	       	evt.what = EVT_KEYREPEAT;
				    oldKey = freeHead;
			    	addEvent(&evt);
				    oldMove = -1;
        	      	}
                return;
              	}
        	key_down[scancode] = true;
	    	}

		addEvent(&evt);
		oldMove = -1;
        }
}

/****************************************************************************
PARAMETERS:
sig	- Signal being sent to this signal handler

REMARKS:
Signal handler for the timer. This routine takes care of periodically
posting timer events to the event queue.
****************************************************************************/
void timerHandler(
	int sig)
{
    WD_event	evt;

	if (sig == SIGALRM) {
	    if (count < EVENTQSIZE) {
			evt.when = getTimeStamp();
			evt.what = EVT_TIMERTICK;
			evt.message = 0;
			evt.where_x = evt.where_y = 0;
			evt.modifiers = 0;
			addEvent(&evt);
			oldMove = -1;
			oldKey = -1;
			}
		signal(SIGALRM, timerHandler);
		}
}

/****************************************************************************
REMARKS:
Restore the terminal to normal operation on exit
****************************************************************************/
static void restore_term(void)
{
	RMREGS	regs;

	if (installed) {
		/* Restore text mode and the state of the console */
        regs.x.ax = 0x3;
        PM_int86(0x10,&regs,&regs);
		PM_restoreConsoleState(stateBuf,tty_fd);

		/* Restore console to normal operation */
	    ioctl(tty_fd, VT_SETMODE, &oldvtmode);
		ioctl(tty_fd, KDSKBMODE, oldkbmode);
		tcsetattr(tty_fd, TCSAFLUSH, &old_conf);
		fcntl(tty_fd,F_SETFL,old_flags &= ~O_NONBLOCK);
		PM_closeConsole(tty_fd);

		/* Close the mouse driver */
		close(conn);

		/* Flag that we are not no longer installed */
		installed = false;
		}
}

/****************************************************************************
REMARKS:
Signal handler to capture forced program termination conditions so that