i8042kbd.c

8042驱动代码

    if (scanCode == 0xe0)
	{
	kbdConDv.kbdFlags |= EXT;
	return;
	}

    /* if high bit of scanCode,set break flag */

    if (((scanCode & 0x80) << 2) == BRK)  
       kbdConDv.kbdFlags |=  BRK;
    else
       kbdConDv.kbdFlags &= ~BRK;

    if ((scanCode == 0xe1) || (kbdConDv.kbdFlags & E1))
	{
	if (scanCode == 0xe1)
	    {
	    kbdConDv.kbdFlags ^= BRK; 	/* reset the break flag */
	    kbdConDv.kbdFlags ^= E1;  	/* bitwise EXOR with E1 flag */
	    }
	return;
	}
    scanCode &= 0x7f;
    if ((kbdConDv.kbdFlags & EXT) == EXT)
	{
	int 	ix;		

	for (ix = 0; ix < EXTND_SIZE; ix++)
	    {
	    if (scanCode == enhancedKeys [ix])
		{
		scanCode = E0_BASE + ix;
		ix = -1;
		break;
		}
	    }
	kbdConDv.kbdFlags ^= EXT; 	/* reset the extended flag */
	if (ix != -1)
	    {
	    return ; 			/* unknown scancode */
	    }
	}

    /* invoke the respective handler */

    (*keyHandler [action [scanCode]]) (scanCode);
    }

/******************************************************************************
*
* kbdNormal - Normal key
*
* This routine does the normal key processing
*
* RETURNS: N/A
*/

LOCAL void kbdNormal
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    FAST UCHAR	chr;
    FAST int	ix = kbdConDv.currCon;	/* to hold the console no. */

    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	chr = keyMap [kbdConDv.kbdMode][kbdConDv.kbdState][scanCode];
	if ((chr == 0xff) || (chr == 0x00))
	    {
	    return;
	    }

	/* if caps lock convert upper to lower */

	if (((kbdConDv.kbdFlags & CAPS) == CAPS) && 
	    (chr >= 'a' && chr <= 'z'))
	    { 
	    chr -= 'a' - 'A';
	    } 
	tyIRd (&(pcConDv [ix].tyDev), chr);	/* give input to buffer */
	}
    }

/******************************************************************************
*
* kbdShift - Shift key operation
*
* This routine sets the shift state of the key board
*
* RETURNS: N/A
*/

LOCAL void kbdShift
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    if ((kbdConDv.kbdFlags & BRK) == BRK) 
	{
	kbdConDv.kbdState = AS;
	kbdConDv.kbdFlags &= (~SHIFT);
	}
    else
	{
	kbdConDv.kbdState = SH;
	kbdConDv.kbdFlags |= SHIFT;
	}
    }

/******************************************************************************
*
* kbdCtrl - Control key operation
*
* This routine sets the shift state of key board to control state
*
* RETURNS: N/A
*/

LOCAL void kbdCtrl
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    if ((kbdConDv.kbdFlags & BRK) == BRK) 
	{
	kbdConDv.kbdState = AS;
	kbdConDv.kbdFlags &= (~CTRL);
	}
    else
	{
	kbdConDv.kbdState = CN;
	kbdConDv.kbdFlags |= CTRL;
	}
    }

/******************************************************************************
*
* kbdCaps - Capslock key operation
*
* This routine sets the capslock state and the key board flags. 
*
* RETURNS: N/A
*/

LOCAL void kbdCaps
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	kbdConDv.kbdFlags ^= CAPS;
	kbdLedSet (); 		/* Set the relevant LED on the Key board */
	}
    }

/******************************************************************************
*
* kbdNum - Numerlock set key operation
*
* This routine sets the numeric lock state of the key board.
* The keyboard state is numeric by default. If the numeric lock is off
* then this routine initializes the keyboard state to non numeric state.
*
* RETURNS: N/A
*/

LOCAL void kbdNum
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	kbdConDv.kbdFlags ^= NUM;
	kbdConDv.kbdState = (kbdConDv.kbdFlags & NUM) ? AS : NM;
	kbdLedSet (); 		/* set the relevant key board led */
	}
    }

/******************************************************************************
*
* kbdStp - Scroll lock set key operation
* 
* This routine sets the scroll lock state of the key board. 
* This routine outputs 0x13 if ^S is pressed or 0x11 if ^Q is pressed.
*
* RETURNS: N/A
*/

LOCAL void kbdStp
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    FAST int	ix = kbdConDv.currCon;	/* to hold the console no. */

    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	kbdConDv.kbdFlags ^= STP;
	(kbdConDv.kbdFlags & STP) ? tyIRd (&(pcConDv [ix].tyDev),0x13) : 
	                              tyIRd (&(pcConDv [ix].tyDev),0x11);
	kbdLedSet (); 		/* set the relevant key board led */
	}
    }

/******************************************************************************
*
* kbdExt - Extended key board operation
*
* This routine processes the extended scan code operations
* and ouputs an escape sequence. ESC [ <chr> . The character is for example
* one of the following. (A, B, C, D, F, L, P)
*
* RETURNS: N/A
*/

LOCAL void kbdExt
    (
    UCHAR 	scanCode	/* scan code recieved */
    )
    {
    FAST UCHAR	chr;
    FAST int	ix = kbdConDv.currCon;	/* to hold the console no. */

    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	chr = keyMap [kbdConDv.kbdMode][kbdConDv.kbdState][scanCode];
	tyIRd (&pcConDv [ix].tyDev, 0x1b); 	/* escape character */
	kbdConDv.curMode ? tyIRd (&pcConDv [ix].tyDev, '[') : 
	                     tyIRd (&pcConDv [ix].tyDev, 'O');
	tyIRd (&pcConDv [ix].tyDev, chr);	
	}
    }

/******************************************************************************
*
* kbdEs - Non Numeric key board operation
*
* This routine processes the non numeric scan code operations
*
* RETURNS: N/A
*/

LOCAL void kbdEs
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    FAST UCHAR	chr;
    FAST int	ix = kbdConDv.currCon;	/* to hold the console no. */

    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	chr = keyMap [kbdConDv.kbdMode][kbdConDv.kbdState][scanCode];
	if ((kbdConDv.kbdFlags & NUM) == NORMAL)
	    {
	    tyIRd (&pcConDv [ix].tyDev, 0x1b);  /* escape character */
	    tyIRd (&pcConDv [ix].tyDev, 'O');
	    }
	tyIRd (&pcConDv [ix].tyDev, chr);
	}
    }

/******************************************************************************
*
* kbdLedSet - Keybord LED Set
*
* This routine Keyboad LED control on kbdConDv.kbdFlags numeric, caps and
* stps
*
* RETURNS: N/A
*/

LOCAL void kbdLedSet (void)
    {
    int		ix;
    UCHAR 	stat = 0;

    /* bits 0 1 2 for scroll numlock & capslock */
    stat = (UCHAR) (kbdConDv.kbdFlags & 0x07);

    if (oldLedStat == stat)
	return;
    oldLedStat = stat;

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (DATA_8042, 0xed);		/* SET LEDS command */


    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (DATA_8042, stat);		/* set LEDs */
    }

/******************************************************************************
*
* kbdHook - key board function called from an external routine
*
* This function does the respective key board operation according to the
* opCode. The user can extend this function to perform any key board 
* operation called as a hook from any external function for eg
* from the vga driver. 
*
* RETURNS: N/A
*/

LOCAL void kbdHook
    (
    int opCode		/* operation to perform */
    )
    {
    switch (opCode)
	{
	case 0:
	      kbdStatInit ();
	      break;
        case 1:
	      kbdLedSet ();
	      break;
	default:
	      break;
	}
    }
/******************************************************************************
*
* kbdRead - read data from the key board.
*
* Read data from the key board.
*
* RETURNS: OK or ERROR if timed out
*/

LOCAL STATUS kbdRead
    (
    char *pData
    )
    {

    kbdTimeout = FALSE;
    wdStart (kbdWdid, (sysClkRateGet() * kbdWdsec), (FUNCPTR)kbdWdog, 0);

    while (((sysInByte (STATUS_8042) & 0x01) == 0) && !kbdTimeout)
	;

    wdCancel (kbdWdid);

    taskDelay (sysClkRateGet () >> 4);

    *pData = sysInByte (DATA_8042);

    return (kbdTimeout ? ERROR : OK);
    }
/******************************************************************************
*
* kbdWrite - write data to the key board.
*
* Write data to the key board.
*
* RETURNS: OK or ERROR if timed out
*/

LOCAL STATUS kbdWrite
    (
    char data
    )
    {

    kbdTimeout = FALSE;
    wdStart (kbdWdid, (sysClkRateGet() * kbdWdsec), (FUNCPTR)kbdWdog, 0);

    while ((sysInByte (STATUS_8042) & 0x02) && !kbdTimeout)
	;

    wdCancel (kbdWdid);

    sysOutByte (DATA_8042, data);

    return (kbdTimeout ? ERROR : OK);
    }
/******************************************************************************
*
* kbdCommand - write command to the key board.
*
* Write command to the key board.
*
* RETURNS: OK or ERROR if timed out
*/

LOCAL STATUS kbdCommand
    (
    char command
    )
    {

    kbdTimeout = FALSE;
    wdStart (kbdWdid, (sysClkRateGet() * kbdWdsec), (FUNCPTR)kbdWdog, 0);

    while ((sysInByte (STATUS_8042) & 0x02) && !kbdTimeout)
	;

    sysOutByte (COMMAND_8042, command);

    while ((sysInByte (STATUS_8042) & 0x02) && !kbdTimeout)
	;

    wdCancel (kbdWdid);

    return (kbdTimeout ? ERROR : OK);
    }
/******************************************************************************
*
* kbdReset - reset a keyboard
*
* This routine resets the keyboard.
*
* RETURNS: N/A
*/

void kbdReset (void)
    {
    int		ix;

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (DATA_8042, 0xff);

    taskDelay (sysClkRateGet () >> 4);

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (DATA_8042, 0x60);

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (DATA_8042, 0x45);

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;

    sysOutByte (COMMAND_8042, 0xae);

    for (ix=0; ix<WAIT_MAX; ix++)		/* wait for input buf empty */
	if ((sysInByte (STATUS_8042) & 0x02) == 0)
	    break;
    }
/******************************************************************************
*
* kbdWdog - KBD driver watchdog handler.
*
* KBD driver watchdog handler.
*
* RETURNS: N/A
*/

LOCAL void kbdWdog
    (
    void
    )
    {
    kbdTimeout = TRUE;
    kbdTimeoutCnt++;
    }