xllp_keypad.c

Windows CE 6.0 BSP for VOIP sample phone. Intel PXA270 platform.

        gplr0_InPinMask = gplr0_OutPinMask = gplr0_AllPinsMask =
        gplr1_InPinMask = gplr1_OutPinMask = gplr1_AllPinsMask =
        gplr2_InPinMask = gplr2_OutPinMask = gplr2_AllPinsMask =
        gplr3_InPinMask = gplr3_OutPinMask = gplr3_AllPinsMask = 0;

        for (i=1 ;i<(XllpKpdGpioDirNonScrollWheelInList[0]+1) ;i++ )
        {
            switch (XllpKpdGpioDirNonScrollWheelInList[i] / 32) // 32 pins per level register
            {
                case 0:
                    gplr0_InPinMask |= (1u << (XllpKpdGpioDirNonScrollWheelInList[i] &31));
                    break;
                case 1:
                    gplr1_InPinMask |= (1u << (XllpKpdGpioDirNonScrollWheelInList[i] &31));
                    break;
                case 2:
                    gplr2_InPinMask |= (1u << (XllpKpdGpioDirNonScrollWheelInList[i] &31));
                    break;
                case 3:
                    gplr3_InPinMask |= (1u << (XllpKpdGpioDirNonScrollWheelInList[i] &31));
                    break;
            }
        }  // Input pin masks

        for (i=1 ;i<XllpKpdGpioDirOutList[0]+1 ;i++ )
        {
            switch (XllpKpdGpioDirOutList[i] / 32) // 32 pins per level register
            {
                case 0:
                    gplr0_OutPinMask |= (1u << (XllpKpdGpioDirOutList[i] &31));
                    break;
                case 1:
                    gplr1_OutPinMask |= (1u << (XllpKpdGpioDirOutList[i] &31));
                    break;
                case 2:
                    gplr2_OutPinMask |= (1u << (XllpKpdGpioDirOutList[i] &31));
                    break;
                case 3:
                    gplr3_OutPinMask |= (1u << (XllpKpdGpioDirOutList[i] &31));
                    break;
            }
        }  // Output pin masks

        gplr0_AllPinsMask = gplr0_InPinMask | gplr0_OutPinMask;
        gplr1_AllPinsMask = gplr1_InPinMask | gplr1_OutPinMask;
        gplr2_AllPinsMask = gplr2_InPinMask | gplr2_OutPinMask;
        gplr3_AllPinsMask = gplr3_InPinMask | gplr3_OutPinMask;

        xllpKpKIP_Initialized = XLLP_TRUE;
    }

    // Main calculation
    // Platform-specific optimization: For Mainstone, no keypad pins in GPLR[1:0].

    gpioRegTmp = v_pGPIOReg->GPLR2 ;
    activity =  (gpioRegTmp ^ gplr2_OutPinMask) & gplr2_AllPinsMask;

    gpioRegTmp = v_pGPIOReg->GPLR3 ;
    activity |= (gpioRegTmp ^ gplr3_OutPinMask) & gplr3_AllPinsMask;

    return(activity);

} // XllpKpKeypressIsInProgress()

//---------------------------------------------------------------------------------------------------------------
// Function: ReadDirectKeys
// Purpose:  This function looks for any Thumbwheel movement or button press and returns a scan code.
// Returns:  success/failure.
//---------------------------------------------------------------------------------------------------------------

XLLP_BOOL_T ReadDirectKeys(XLLP_KEYPAD_REGS *v_pKeyPadRegs,XLLP_UINT8_T *key)
{
    XLLP_UINT32_T CurrCount,SaveKpRotaryEncoderCountReg;
    static XLLP_UINT32_T PrevCount=START_VALUE;
    XLLP_BOOL_T retval;
    if(KP_Status & DIRECT_INTR_BIT)
    {
        SaveKpRotaryEncoderCountReg = v_pKeyPadRegs->kpRotaryEncoderCountReg;
        CurrCount = SaveKpRotaryEncoderCountReg & COUNT_MASK;
        if(SaveKpRotaryEncoderCountReg & OVERFLOW_ROTARY_ENC_0)
        {
            v_pKeyPadRegs->kpRotaryEncoderCountReg = START_VALUE;
            PrevCount   = START_VALUE;
            *key    = SCAN_CODE_SCROLL_UP;                  // Scroll Up
        }
        else if(SaveKpRotaryEncoderCountReg & UNDERFLOW_ROTARY_ENC_0)
        {
            v_pKeyPadRegs->kpRotaryEncoderCountReg = START_VALUE;
            PrevCount   = START_VALUE;
            *key    = SCAN_CODE_SCROLL_DOWN;                // Scroll Down
        }
        else if(CurrCount > PrevCount)
        {
            *key    = SCAN_CODE_SCROLL_UP;
            PrevCount   = CurrCount;                        // Scroll Up
        }
        else if(CurrCount < PrevCount)
        {
            *key    = SCAN_CODE_SCROLL_DOWN;
            PrevCount   = CurrCount;                        // Scroll Down
        }
        else if(v_pKeyPadRegs->kpDirectKeyReg & DIRECT_KEY_IN_2)
        {
            *key    = SCAN_CODE_ACTION;                     // Action Key       
        }

        retval = XLLP_TRUE;                                 // Signal availability
    }
    else
    {
        retval = XLLP_FALSE;
    }

    return(retval);
}

//---------------------------------------------------------------------------------------------------------------
// Function: XllpReadScanCode
// Purpose:
// Returns:
//---------------------------------------------------------------------------------------------------------------

XLLP_BOOL_T XllpReadScanCode(XLLP_KEYPAD_REGS *v_pKeyPadRegs,XLLP_UINT8_T *pui8Data)
{
    // Initialise to NO Key scan code, same as key UP
    XLLP_UINT8_T key = NO_KEY;

    if(!ReadDirectKeys(v_pKeyPadRegs,&key))
        ReadScanCodeAutomatically(v_pKeyPadRegs,&key);

    // Assign the Key Here
    *pui8Data = key;

    if(*pui8Data == NO_KEY)
        return(XLLP_FALSE);
    else
        return(XLLP_TRUE);      // Enjoy
}

//---------------------------------------------------------------------------------------------------------------
// Function: XllpSetUpKeyPadInterrupts
// Purpose:  This function will Enable/Disable the Interrupts.
// Returns:  success/failure.
//---------------------------------------------------------------------------------------------------------------
XLLP_BOOL_T XllpSetUpKeyPadInterrupts(XLLP_KEYPAD_REGS *v_pKeyPadRegs,XLLP_BOOL_T fEnDis)
{
    KP_Status = v_pKeyPadRegs->kpControlReg;

    if(fEnDis)
    {
        EN_DIRECT_KEYS_INTR();
        EN_MAT_KEYS_INTR();
    }
    else
    {
        DISABLE_DIRECT_KEYS_INTR();
        DISABLE_MAT_KEYS_INTR();
    }
    return(XLLP_TRUE);
}

//-----------------------------------------------------------------------------------------
// Function: XllpKeyPadConfigure
// Purpose:  This function configures the KeyPad Controller on Bulverde-Mainstone with the
//           appropriate settings.
// Returns:  success/failure.
//------------------------------------------------------------------------------------------
//  PIN#      GPIO PIN NAME           DIRECTION         ALTERNATE FUNCTION
//
//   95         KP_DKIN[2]              Input                   3
//   97         KP_DKIN[4]              Input                   3
//   98         KP_DKIN[5]              Input                   3
//   99         KP_DKIN[6]              Input                   3
//  100         KP_MKIN[0]              Input                   1
//  101         KP_MKIN[1]              Input                   1
//  102         KP_MKIN[2]              Input                   1
//  
//   96         KP_DKIN[3]              Output                  3
//  103         KP_MKOUT[0]             Output                  2
//  104         KP_MKOUT[1]             Output                  2
//  105         KP_MKOUT[2]             Output                  2
//  106         KP_MKOUT[3]             Output                  2
//  107         KP_MKOUT[4]             Output                  2
//  108         KP_MKOUT[5]             Output                  2
//
//  93          KP_DKIN[0]              Input                   1
//  94          KP_DKIN[1]              Input                   1
//--------------------------------------------------------------------------------------------

XLLP_BOOL_T XllpKeyPadConfigure(XLLP_KEYPAD_REGS *v_pKeyPadRegs,XLLP_GPIO_T *v_pGPIOReg)
{
    XLLP_BOOL_T retval=XLLP_FALSE;
    XLLP_UINT32_T GpioDirOutList[]={7,96,103,104,105,106,107,108};
    XLLP_UINT32_T GpioDirInList[]={9,93,94,95,97,98,99,100,101,102};
    XLLP_UINT32_T GpioAltFnPinList[]={16,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108};
    XLLP_UINT32_T GpioAltFnValList[]={16,1,1,3,3,3,3,3,1,1,1,2,2,2,2,2,2};
    if(v_pGPIOReg != 0)
    {
        XllpGpioSetDirectionIn(v_pGPIOReg, GpioDirInList);
        XllpGpioSetDirectionOut(v_pGPIOReg, GpioDirOutList);
        XllpGpioSetOutput0(v_pGPIOReg, GpioDirOutList);
        XllpGpioSetAlternateFn(v_pGPIOReg, GpioAltFnPinList, GpioAltFnValList);
    }


    if(v_pKeyPadRegs != 0)
    {
        // Init the control regs for direct keys
        v_pKeyPadRegs->kpControlReg = (MATRIX_KP_NUMBER_OF_ROWS |  MATRIX_KP_NUMBER_OF_COLUMNS |
                                        MAT_SCAN_LINE0 | MAT_SCAN_LINE1 | MAT_SCAN_LINE2 |
                                        MAT_SCAN_LINE3 | MAT_SCAN_LINE4 | MAT_SCAN_LINE5 |
                                        MAT_SCAN_LINE6 | MAT_SCAN_LINE7 | IGNORE_MULTIPLE_KEY_PRESS |
                                        AUTO_SCAN_ON_ACTIVITY | MATRIX_INTR_ENABLE |
                                        MATRIX_KP_ENABLE | ROTARY_ENCODER_ZERO_DEB |
                                        DIRECT_KP_INTR_ENABLE | DIRECT_KEY_NUMS |
                                        DIRECT_KP_ENABLE | ROTARY_ENCODER_0_ENABLE) ;    //NMD

        v_pKeyPadRegs->kpRotaryEncoderCountReg = START_VALUE;

        retval = XLLP_TRUE;     
    }
    return(retval);
}