xllp_keypad.c

PXA270硬件测试源代码

            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;
    if(v_pGPIOReg != 0)
    {
        XllpGpioSetDirectionIn(v_pGPIOReg, XllpKpdGpioDirInList);
        XllpGpioSetDirectionOut(v_pGPIOReg, XllpKpdGpioDirOutList);
        XllpGpioSetOutput0(v_pGPIOReg, XllpKpdGpioDirOutList);
        XllpGpioSetAlternateFn(v_pGPIOReg, XllpKpdGpioAltFnPinList, XllpKpdGpioAltFnValList);
    }


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


//---------------------------------------------------------------------------------------------------------------
// Function: XllpKpKeypressIsInProgress
// Purpose:  This function reports nonzero if the keypad is currently active during a keypress.
//           (Keypress active as indicated by non-rotary DKIN levels high, any MKIN levels high
//              or any MKOUT levels low (indicates scan is active))
//
// Note:     It cannot detect the debouncing of a complete key up event.  Therefore, full 
//           protection from performing conflicting actions during keypad activity must include
//           support from higher level software.  (One example is avoiding entering Standby while
//           a key release is being debounced because the key release detection could be lost.)
//
// Returns:  nonzero ("true") / zero ("false")
// Limitations:  Platform-specific because it requires complete knowledge of keypad configuration
//---------------------------------------------------------------------------------------------------------------
XLLP_UINT32_T XllpKpKeypressIsInProgress (XLLP_GPIO_T *v_pGPIOReg)
{
    // Note that GPIOs used here only include MKOUTs, MKINs and non-rotary DKINs.

    static XLLP_BOOL_T xllpKpKIP_Initialized = XLLP_FALSE;
    static XLLP_UINT32_T gplr0_InPinMask, gplr0_OutPinMask, gplr0_AllPinsMask,
                         gplr1_InPinMask, gplr1_OutPinMask, gplr1_AllPinsMask,
                         gplr2_InPinMask, gplr2_OutPinMask, gplr2_AllPinsMask,
                         gplr3_InPinMask, gplr3_OutPinMask, gplr3_AllPinsMask;

    XLLP_UINT32_T i;
    XLLP_UINT32_T gpioRegTmp;
    XLLP_UINT32_T activity  = 0;

    // Set up masks only once.  Do this in code rather than precalculation to expose
    //  the algorithm and make it easily re-usable.  Perform full init because fairly
    //  fast and only done once.

    if (!xllpKpKIP_Initialized)
    {
        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()