i8042kbd.c

cpc-1631的BSP包for VxWorks操作系统

LOCAL void	kbdEs (unsigned char scanCode);
LOCAL void 	(*keyHandler[]) (unsigned char scanCode)  =
    {
    kbdNormal,   kbdShift,   kbdCtrl,   kbdNum,   kbdCaps,
    kbdStp,      kbdExt,     kbdEs
    };
LOCAL void	kbdHook (int opCode);
LOCAL void	kbdWdog (void);
LOCAL STATUS	kbdWrite (char data);
LOCAL STATUS	kbdRead (char *data);
LOCAL STATUS	kbdCommand (char data);
      void	kbdReset (void);		/* for debugging */

/*******************************************************************************
*
* kbdHrdInit - initialize the Keyboard
* 
* This routine is called to do the key board initialization from an external
* routine
*
* RETURNS: N/A
*
* NOMANUAL
*/

void kbdHrdInit (void)
    {
    char	temp;

    kbdWdid = wdCreate ();

    do {
	if (kbdTimeoutCnt > 3)		/* try 3 times then give up */	
	    break;

	if (kbdTimeout)			/* reset if we got timeout */
	    kbdReset ();

        if (kbdCommand (0x60) == ERROR)
	    continue;
        if (kbdWrite (0x44) == ERROR)
	    continue;

        while (sysInByte (STATUS_8042) & 0x01)
	    if (kbdRead (&temp) == ERROR)
		break;
    
        if (kbdCommand (0x60) == ERROR)
	    continue;
        if (kbdWrite (0x45) == ERROR)
	    continue;

        if (kbdCommand (0xae) == ERROR)
	    continue;
	} while (kbdTimeout);

    kbdStatInit ();
    } 

/*******************************************************************************
*
* kbdStatInit - initialize the Keyboard state
*
* This routine initializes the keyboard descriptor in the virtual consoles.
* The same keybaord descriptor is used for all the virtual consoles.
*
* RETURNS: N/A
*/

LOCAL void kbdStatInit (void)
    {
    int		ix;		/* to hold temp variable */
    UCHAR	stat;

    /* initialize all the key board descriptors in the virtual consoles */

    for ( ix = 0; ix < N_VIRTUAL_CONSOLES; ix++)
	{
	pcConDv [ix].ks = &kbdConDv;		/* kbd device descriptor */
	}

    kbdConDv.curMode = TRUE;	/* default mode is normal */
    kbdConDv.convertChar = TRUE;	/* default to convert to ASCII */
    
    /* default keyboard is English Enhanced key */
    
    kbdConDv.kbdMode  = ENGLISH_KBD; 
    kbdConDv.kbdFlags = NORMAL|NUM;		/* Numeric mode on */
    kbdConDv.kbdState = 0; 			/* unshift state */
    kbdConDv.kbdHook  = (FUNCPTR) kbdHook;	/* hook routine */
    kbdConDv.currCon  = PC_CONSOLE;     	/* console tty */
    

    stat = (UCHAR) (kbdConDv.kbdFlags & 0x07);

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

    do {
	if (kbdTimeoutCnt > 3)		/* try 3 times then give up */	
	    break;

	if (kbdTimeout)			/* reset if we got timeout */
	    kbdReset ();

        if (kbdWrite (0xed) == ERROR)
	    continue;

        if (kbdWrite (stat) == ERROR)
	    continue;
	} while (kbdTimeout);
    }

/*******************************************************************************
*
* kbdIntr - interrupt level processing
*
* This routine handles the keyboard interrupts
*
* RETURNS: N/A
*
* NOMANUAL
*/

void kbdIntr (void)
    {
    FAST UCHAR	scanCode;	/* to hold the scanCode */

    kbdIntCnt++;

    if (sysInByte (STATUS_8042) & 0x01)
        {
	scanCode = sysInByte (DATA_8042);

	/* keyboard acknowledge to any valid input, so just return */

	if (scanCode == 0xfa) 
	    {
	    kbdAcknowledge = TRUE;
	    return;
	    }
	if (kbdConDv.convertChar) 
	    kbdConvChar (scanCode);
	else
	    tyIRd (&(pcConDv[kbdConDv.currCon].tyDev), scanCode);
        }
    }

/*******************************************************************************
*
* kbdConvChar - Convert scan code to character
*
* This routine convert scanCode to ASCII character
*
* RETURNS: N/A
*/

LOCAL void kbdConvChar 
    (
    UCHAR	scanCode	/* scan Code from the keyboard */
    )
    {
    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 */
	}
    }

/******************************************************************************