keypad.cpp

Windows CE 6.0 BSP for VOIPAC Board (PXA270) Version 2b.

void FreeKeyPadRegs(void)
{   
    if (g_pKeyPadRegs != NULL)
    {
        VirtualFree((void *)g_pKeyPadRegs, 0, MEM_RELEASE);
        g_pKeyPadRegs = NULL;
    }

    if (g_pGPIORegs != NULL)
    {
        VirtualFree((void *)g_pGPIORegs, 0, MEM_RELEASE);
        g_pGPIORegs = NULL;
    }

    if (g_pClockRegs != NULL)
    {
        VirtualFree((void *)g_pClockRegs, 0, MEM_RELEASE);
        g_pClockRegs = NULL;
    }

    if (g_pOSTRegs != NULL)
    {
        VirtualFree((void *)g_pOSTRegs, 0, MEM_RELEASE);
        g_pOSTRegs = NULL;
    }
}


BOOL AllocKeyPadRegs(void)
{   
    PHYSICAL_ADDRESS PA;

    if (g_pKeyPadRegs == NULL)
    {
        PA.QuadPart = BULVERDE_BASE_REG_PA_KEYPAD;
        g_pKeyPadRegs = (volatile BULVERDE_KEYPAD_REG *) MmMapIoSpace(PA, sizeof(XLLP_KEYPAD_REGS), FALSE);
    }

    if (g_pGPIORegs == NULL)
    {
        PA.QuadPart = BULVERDE_BASE_REG_PA_GPIO;
        g_pGPIORegs = (volatile BULVERDE_GPIO_REG *) MmMapIoSpace(PA, sizeof(XLLP_GPIO_T), FALSE);
    }

    if (g_pClockRegs == NULL)
    {
        PA.QuadPart = BULVERDE_BASE_REG_PA_CLKMGR;
        g_pClockRegs = (volatile BULVERDE_CLKMGR_REG *) MmMapIoSpace(PA, sizeof(XLLP_CLKMGR_T), FALSE);
    }

    if (g_pOSTRegs == NULL)
    {
        PA.QuadPart = BULVERDE_BASE_REG_PA_OST;
        g_pOSTRegs = (volatile BULVERDE_OST_REG *) MmMapIoSpace(PA, sizeof(XLLP_OST_T), FALSE);
    }

    if (!g_pKeyPadRegs || !g_pGPIORegs || !g_pClockRegs || !g_pOSTRegs)
    {
        FreeKeyPadRegs();
        return(FALSE);
    }

#ifndef BSP_NOIPM
    IPM_KeyPadInit();
#endif // ndef BSP_NOIPM
    return(TRUE);

}


BOOL KeyPad::Initialize()
{
    BOOL bRet = FALSE;
    DEBUGMSG(ZONE_INIT, (TEXT("\r\n+KeyPad::Initialize\r\n")));

    // Allocate and map keypad registers.
    if (AllocKeyPadRegs())
    {
        // Power-on the keypad controller.
        bRet = KeyPadPowerOn();
    }

    DEBUGMSG(ZONE_INIT, (TEXT("-KeyPad::Initialize\r\n")));
    return(bRet);
}


BOOL KeyPad::KeyPadPowerOff()
{
    if (!g_pClockRegs) return(FALSE);

    g_pClockRegs->cken &= ~(0x1 << 19);

    return(TRUE);
}


BOOL KeyPad::KeyPadPowerOn()
{   
    BOOL bRet = FALSE;

    if (g_pClockRegs && g_pKeyPadRegs && g_pGPIORegs)
    {
        g_pClockRegs->cken |= 0x1 << 19;

        if (g_pOSTRegs) XllpOstDelayMilliSeconds((P_XLLP_OST_T) g_pOSTRegs, 50);

        if (XllpKeyPadConfigure((XLLP_KEYPAD_REGS *)g_pKeyPadRegs, (XLLP_GPIO_T *)g_pGPIORegs))
        {
            if (XllpSetUpKeyPadInterrupts((XLLP_KEYPAD_REGS *)g_pKeyPadRegs,(XLLP_BOOL_T ) XLLP_KPD_INT_ENABLE))
            {
                bRet = TRUE;
            }
        }
    }

    return(bRet);
}


void KeypadPdd_PowerHandler(BOOL bOff)
{
    // Note no return value permitted.
    if (bOff)
    {
        (void) v_pKpd->KeyPadPowerOff();
    }
    else
    {
        (void) v_pKpd->KeyPadPowerOn();
    }
}

void WINAPI KeyPadPddPowerHandler(
    UINT uiPddId,
    BOOL bOff
    )
{
    KeypadPdd_PowerHandler(bOff);
}

static KEYBD_PDD KeyPadPdd = {
    KEYPAD_PDD_ID,
    _T("Keypad"),
    KeyPadPddPowerHandler,
    NULL   // no toggle-lights function
};

BOOL KeypadDriverInitializeAddresses(void);

BOOL
WINAPI
KeyPad_Entry(
    UINT uiPddId,
    PFN_KEYBD_EVENT pfnKeyPadEvent,
    PKEYBD_PDD *ppKeybdPdd
    )
{
    SETFNAME(_T("KeyPad_Entry"));
    BOOL fRet = FALSE;

    DEBUGMSG(ZONE_FUNCTION, (TEXT("+KeyPad_Entry\r\n")));
    DEBUGMSG(ZONE_INIT, (TEXT("Received 0x%X as uiPddId\r\n"),uiPddId));

    v_uiPddId = uiPddId;
    v_pfnKeyPadEvent = pfnKeyPadEvent;

    DEBUGMSG(ZONE_INIT, (_T("%s: Initialize Keypad_Entry ID %u\r\n"), pszFname, uiPddId));
    DEBUGCHK(ppKeybdPdd != NULL);

    *ppKeybdPdd = &KeyPadPdd;
    
    if (v_pKpd) {
        fRet = TRUE;
        goto leave;
    }
    //  We always assume that there is a keypad.

    v_pKpd = new KeyPad;
    if (v_pKpd && v_pKpd->Initialize()) {
        v_pKpd ->IsrThreadStart();
    } 
    else {
        ERRORMSG(1, (TEXT("Could not initialize Matrix keypad.\r\n")));
        if (v_pKpd)
            delete v_pKpd;
        v_pKpd = NULL;
        goto leave;
    }

#if 0
// obsolete?
    if (!KeybdDriverInitializeAddresses()) {
        goto leave;
    }
#endif // 0

    if (v_pKpd)
    {
        v_pKpd->KeyPadPowerOn();
    }

    fRet = TRUE;
        
leave:
    DEBUGMSG(ZONE_INIT, (_T("%s: Initialization complete\r\n"), pszFname));

    return fRet;
}

#ifdef DEBUG
// Verify function declaration against the typedef.
static PFN_KEYBD_PDD_ENTRY v_pfnKeybdEntry = KeyPad_Entry;
#endif


BOOL KeyPad::IsrThreadProc()
{

    //DEBUGMSG(1, (TEXT("KeyPad IsrThreadProc:\r\n")));
    m_hevInterrupt = CreateEvent(NULL,FALSE,FALSE,NULL);
    if (m_hevInterrupt == NULL) {
        RETAILMSG(1, (TEXT("IsrThreadProc: InterruptInitialize Failed\r\n")));
    }
    else 
    {
        if (InterruptInitialize(SYSINTR_KEYPAD, m_hevInterrupt, NULL, 0)) 
        {
            KEYBD_IST keyPadIst;
            keyPadIst.hevInterrupt = m_hevInterrupt;
            keyPadIst.dwSysIntr_Keybd = SYSINTR_KEYPAD;
            keyPadIst.uiPddId = v_uiPddId;
            keyPadIst.pfnGetKeybdEvent = KeyPadPdd_GetEventEx2;
            keyPadIst.pfnKeybdEvent = v_pfnKeyPadEvent;

            // Note: no point in trying to set the thread priority here, because KeybdIstLoop()
            //  forces it after we give up control: 
            KeybdIstLoop(&keyPadIst);
        }
        else
        {
            DEBUGMSG(ZONE_ERROR, (TEXT("KeyPad::IsrThreadProc: InterruptInitialize Failure\r\n")));
        }

    }

    return(0);

} // KeyPad::IsrThreadProc()

DWORD KeyPadIsrThread(KeyPad *v_pKpd)
{
    DEBUGMSG(ZONE_INIT, (TEXT("KeypadIsrThread:\r\n")));
    v_pKpd->IsrThreadProc();
    return 0;
}

BOOL KeyPad::IsrThreadStart()
{
    HANDLE  hthrd;

    DEBUGMSG(ZONE_INIT, (TEXT("IsrThreadStart:\r\n")));
    hthrd = CreateThread(NULL,0,(LPTHREAD_START_ROUTINE)KeyPadIsrThread,this,0,NULL);
    //  Since we don't need the handle, close it now.
    CloseHandle(hthrd);
    return TRUE;
}