event.svga

uboot在arm处理器s3c2410的移植代码

/****************************************************************************
*
*           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