keymatrix.cpp

6410BSP3

        goto error_return;
    }
    DEBUGMSG(ZONE_INIT, (TEXT("[KBD] pGPIOReg mapped at %x\r\n"), pGPIOReg));

    // Keypad Virtual alloc
    ioPhysicalBase.LowPart = dwIOCTRLBase;    
    pKeyPadReg = (S3C6410_KEYPAD_REG *)MmMapIoSpace(ioPhysicalBase, sizeof(S3C6410_KEYPAD_REG), FALSE);
    if (pKeyPadReg == NULL)
    {
        DEBUGMSG(ZONE_ERROR,(TEXT("[KBD] pKeyPadReg : MmMapIoSpace failed!\r\n")));
        goto error_return;
    }
    DEBUGMSG(ZONE_INIT, (TEXT("[KBD] pKeyPadReg mapped at %x\r\n"), pKeyPadReg));

    DEBUGMSG(ZONE_INIT,(TEXT("--KeybdDriverInitializeAddresses\r\n")));

    return TRUE;

error_return:

    if ( pSysConReg )
    {
        MmUnmapIoSpace((PVOID)pSysConReg, sizeof(S3C6410_SYSCON_REG));
        pSysConReg = NULL;
    }

    if ( pGPIOReg )
    {
        MmUnmapIoSpace((PVOID)pGPIOReg, sizeof(S3C6410_GPIO_REG));
        pGPIOReg = NULL;
    }

    if ( pKeyPadReg )
    {
        MmUnmapIoSpace((PVOID)pKeyPadReg, sizeof(S3C6410_KEYPAD_REG));
        pKeyPadReg = NULL;
    }

    DEBUGMSG(ZONE_INIT,(TEXT("--KeybdDriverInitializeAddresses[FAILED!!!]\r\n")));
    return FALSE;
}
/****************************************************************************/


/*****************************************************************************
*    Function Name : VarInit
*    Function Desc  : Initialization for variables about Key Change. 
*
*/
void VarInit(void)
{
    int i;

    for( i=0; i<SIZE_KEY; i++)
    {
        KeyChange[i].Mask = 0;
        KeyChange[i].Cnt  = 0;
    }
}
/****************************************************************************/


/*****************************************************************************
*    Function Name : AreAllKeysUp
*    Function Desc  : Check that all keys are released. 
*
*/
BOOL AreAllKeysUp(void)
{
    DWORD tmp = 0, tmp1 = 0, i;

    for(i=0;i<SIZE_COLS;i++)
    {
        tmp |= KeyState[i];
        tmp1 |= ChangeState[i];
    }

    return (tmp || tmp1)? FALSE:TRUE;
}
/****************************************************************************/

/*****************************************************************************
*    Function Name : KScan_ProcState
*    Function Desc  : Handle KeyMatrix State. Check which keys are changed.
*
*/
DWORD KScan_ProcState(int kidx, int idx, PDWORD key, PBOOL press)
{
    int val, i;
    DWORD count = 0;
    int mask;

    val = ChangeState[kidx];
    for(i=0;i<SIZE_BITS;i++)
    {
        mask = 1<<i;

        if( (KeyState[kidx] & mask) && (KeyCode[idx].Type == KCODE_TYPE_SL) && (KeyCode[idx].Fin == 0) )
        {
            if( (KeyCode[idx].TimeoutCnt == CNT_LONGKEY) )
            {
                // key down
                *key++ = KeyCode[idx].Scan | SCAN_EXT;
                *press++ = FALSE;
                // key up
                *key++ = KeyCode[idx].Scan | SCAN_EXT;
                *press++ = TRUE;
                count+=2;

                KeyCode[idx].TimeoutCnt = 0;
                KeyCode[idx].Fin = TRUE;
                RETAILMSG(FALSE, (TEXT(">>> KSCAN:LONG[%d] - %d, key - 0x%x\r\n"), idx, KeyCode[idx].Scan,*key));
            }
            else
            {
                KeyCode[idx].TimeoutCnt++;
            }
        }

        // state changed
        if( val & mask )
        {
            // Need to check whether the key changed really
            if( KeyChange[idx].Cnt == 0 ) // in counting
            {
                KeyChange[idx].Cnt = CNT_VALIDKEY;
                KeyChange[idx].Mask = ( KeyState[kidx] & mask )? 0: mask;
            }
            else
            {
            // checked key state
                if( KeyChange[idx].Mask != (KeyState[kidx] & mask) )
                {
                    if( --KeyChange[idx].Cnt == 0 )
                    {
                        if( KeyChange[idx].Mask == 0 )  // Key UP
                        {
                            if( KeyCode[idx].Type == KCODE_TYPE_NORMAL )
                            {
                                *key++ = KeyCode[idx].Scan;
                                *press++ = TRUE;
                                count++;

                                RETAILMSG(FALSE, (TEXT(">>> KSCAN:UP  [%d] - %d\r\n"), idx, KeyCode[idx].Scan));
                            }
                            else    // KCODE_TYPE_SL
                            {
                                if( KeyCode[idx].Fin == FALSE )
                                {
                                    // key down
                                    *key++ = KeyCode[idx].Scan;
                                    *press++ = FALSE;
                                    // key up
                                    *key++ = KeyCode[idx].Scan;
                                    *press++ = TRUE;
                                    count+=2;

                                    KeyCode[idx].Fin = TRUE;

                                    RETAILMSG(FALSE, (TEXT(">>> KSCAN:SHORT[%d] - %d\r\n"), idx, KeyCode[idx].Scan));
                                }
                            }

                            KeyState[kidx] &= ~mask;
                        }
                        else    // Key Down
                        {
                            if( KeyCode[idx].Type == KCODE_TYPE_NORMAL )
                            {
                                *key++ = KeyCode[idx].Scan;
                                *press++ = FALSE;
                                count++;

                                RETAILMSG(FALSE, (TEXT(">>> KSCAN:DOWN[%d] - %d\r\n"), idx, KeyCode[idx].Scan));
                            }
                            else    // KCODE_TYPE_SL
                            {
                                KeyCode[idx].TimeoutCnt = 0;
                                KeyCode[idx].Fin = FALSE;
                            }

                            KeyState[kidx] |= mask;
                        }
                    }
                }
                else
                {
                    KeyChange[idx].Cnt = 0;
                    RETAILMSG(0, (TEXT(">>> KSCAN:Must be not occurred[%d] %x, %llx, %llx\r\n"), idx,KeyChange[idx].Mask,KeyState,mask));
                }
            }
        }
        else
        {
            if( KeyChange[idx].Cnt ) // in counting
            {
                KeyChange[idx].Cnt = 0;
                RETAILMSG(0, (TEXT(">>> KSCAN:Canceled [%d]\r\n"), idx));
            }
        }
        idx++;
    }

    return count;
}
/****************************************************************************/

/*****************************************************************************
*    Function Name : KScan_ProcIO
*    Function Desc  : Scan code
*                     Read KEYIF
*
*/
void KScan_ProcIO(void)
{
    int i;

    for(i = 0 ; i < SIZE_COLS; i++)
    {
        KEYIF_Column_Set(0x0);
        // select a column
        KEYIF_Column_Bitset(false,i);
        Sleep(1);
        ChangeState[i] = KeyState[i]^((~ KEYIF_Row_Read())&0xff);
        RETAILMSG(FALSE, (TEXT("[KSCAN](%d)-%x\r\n"), i, ChangeState[i]));
        Sleep(1);
    }
    KEYIF_Column_Set(0x0);
}
/****************************************************************************/

/*****************************************************************************
*    Function Name : KScan_SetINTMode
*    Function Desc  : Initialize the H/W
*
*/
void KScan_SetINTMode(void)
{
    RETAILMSG(FALSE,(TEXT("+Select all column\r\n")));
    // select all column - Set Keypad column GPIO to [Key PAD COL]
    GPIO_CtrlHandler(ENUM_COL, ENUM_AUXFUNC);

    KEYIF_Column_Set(0x0);

    // configure - Set Keypad row GPIO to [Key PAD ROW]
    GPIO_CtrlHandler(ENUM_ROW, ENUM_AUXFUNC);

    // unmask the key interrupt
    KEYIF_Status_Clear();
}
/****************************************************************************/

/*****************************************************************************
*    Function Name : KeybdPdd_ToggleKeyNotification
*    Function Desc  : Toggle Key
*
*/
void WINAPI KeybdPdd_ToggleKeyNotification(KEY_STATE_FLAGS  KeyStateFlags)
{
    unsigned int fLights;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("KeybdPdd_ToggleKeyNotification\r\n")));

    fLights = 0;
    if (KeyStateFlags & KeyShiftCapitalFlag)
    {
        fLights |= 0x04;
    }

    if (KeyStateFlags & KeyShiftNumLockFlag)
    {
        fLights |= 0x2;
    }
    /*
    Keyboard lights is disabled once driver is installed because the
    PS2 controller sends back a response which goes to the IST and corrupts
    the interface.  When we figure out how to disable the PS2 response we
    can re-enable the lights routine below
    */

    return;
}
/****************************************************************************/

/*****************************************************************************
*    Function Name : IsrThreadProc
*    Function Desc  : IST of KeyBD D/D
*        Create IST
*        Wait for Event according to the KEYPAD INT
*        KScan_SetIOMode() : Handle H/W
*        KScan_ProcIO() :
*        KScan_ProcState() :
*
*/
extern UINT v_uiPddId;
extern PFN_KEYBD_EVENT v_pfnKeybdEvent;

BOOL KeyMatrix::IsrThreadProc()
{
    DWORD dwPriority;
    DWORD i, step;

    DWORD   rguiScanCode[SIZE_KEY];
    BOOL    rgfKeyUp[SIZE_KEY];
    UINT    cEvents;
    DWORD ret;
    DWORD timeout;
    HANDLE gEventIntr;
    DWORD irq, sysintr;

    ReadRegDWORD( TEXT("HARDWARE\\DEVICEMAP\\KEYBD"), _T("Priority256"), &dwPriority );
    if(dwPriority == 0)
    {
        dwPriority = DEFAULT_PRIORITY;
    }

    DEBUGMSG(ZONE_INIT, (TEXT("+[KEYBD]IsrThreadProc\r\n")));
    // update the IST priority
    CeSetThreadPriority(GetCurrentThread(), (int)dwPriority);

    irq = IRQ_KEYPAD;
    if (!KernelIoControl(IOCTL_HAL_REQUEST_SYSINTR, &irq, sizeof(UINT32), &sysintr, sizeof(UINT32), NULL))
    {
        ERRORMSG( 1, (TEXT("ERROR: Failed to request the IRQ_KEY sysintr.\r\n")));
        sysintr = SYSINTR_UNDEFINED;
        return(FALSE);
    }

    gEventIntr = CreateEvent(NULL, FALSE, FALSE, NULL);
    if( NULL == gEventIntr )
    {
        ERRORMSG( 1, (TEXT("Event is not created\r\n")));
        return(FALSE);
    }

    if( InterruptInitialize(sysintr, gEventIntr, NULL, 0) == FALSE )
    {
        ERRORMSG( 1, (TEXT("interrupt is not initialized\n\r")));
        return(FALSE);
    }


    timeout = INFINITE;
    DEBUGMSG(ZONE_INIT, (TEXT("+[KEYBD]Enter Infinite Loop\r\n")));