i8048kbd.c

IXP425的BSP代码

    int		ix;		/* to hold temp variable */

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

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

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

    scanCode = sysInByte (DATA_8048);		/* get the scan code */
    status = sysInByte (STATUS_8048);		/* get the status    */
    sysOutByte (COMMAND_8048, (status | 0x80));	/* send acknowledgment    */
    sysOutByte (STATUS_8048, status);		/* restore previous status */

    if (scanCode == 0xfa)
	{
	return;
	}
    kbdConvChar (scanCode);	/* convert scancode to ASCII character and */
				/* announce it to tyIRd    		   */
    }

/*******************************************************************************
*
* kbdConvChar - Convert scan code to character
*
* This routine convert scanCode to ASCII character
*/

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

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

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

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

LOCAL void kbdCaps
    (
    UCHAR	scanCode	/* scan code recieved */
    )
    {
    if ((kbdConDv.kbdFlags & BRK) == NORMAL) 
	{
	kbdConDv.kbdFlags ^= CAPS;
	}
    }

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

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

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

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);
	}
    }

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

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

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);
	}
    }

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

LOCAL void kbdHook
    (
    int opCode		/* operation to perform */
    )
    {
    switch (opCode)
	{
	case 0:		/* reinitialize the keyboard state */
	      kbdStatInit ();
	      break;
	case 1:
	      break;
	default:
	      break;
	}
    }