power.c

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

            OUTREG32(&pPwrRst_reg->pkwr, 0x000FC000); // any keyboard; 
            pkwrVal = INREG32(&pPwrRst_reg->pkwr);  //read to make sure values are latched
        }
        else
        {
            if (!OALIntrTranslateSysIntr(sysIntr, &count, &pIrqs))
                continue;                                                // Get IRQs
                
            for (i = 0; i < count; i++) {                              // Hardware supports only restricted number of sources
                BSPSetWakeSrc(pwerBits, pIrqs[i]);
            }
        }
    }

    // Enable Wifi Wakeup Interrupt
    OEMInterruptEnable(SYSINTR_WIFIWAKEUP, NULL, 0);

    // set wake up sources register (PWER)
    OUTREG32(&pPwrRst_reg->pwer, pwerVal);
    dummyRead = INREG32(&pPwrRst_reg->pwer);

    // determine whether we are just suspending or pwering off!
    if (pwerVal != 0x80004001 || 
        (pkwrVal & ~PKSR_REG_RSVD_BITS) != 0)
    {
        // we have a wake source other than RTC and PMIC set. Go to sleep
        g_fPlatformPowerOff = FALSE;

        // set up the PCFR
        OUTREG32(&pPwrRst_reg->pcfr, 0x00008081); 
        dummyRead = INREG32(&pPwrRst_reg->pcfr);
        OALMSGS(OAL_POWER, (TEXT("BSPPowerOff: pPwrRst_reg->pcfr = 0x%x\r\n"), dummyRead));
    }
    else
    {
        // No wake sources set other than the default ones. We should power off the system
        g_fPlatformPowerOff = TRUE;
    }
}    

//------------------------------------------------------------------------------

VOID BSPPowerOn()
{
    UINT32 wakesrc, srcIrq;
    PBULVERDE_PWRRST_REG  pPwrRst_reg = (PBULVERDE_PWRRST_REG) OALPAtoUA(BULVERDE_BASE_REG_PA_PWR);

    // find wake up source
    //
    wakesrc = INREG32(&pPwrRst_reg->pedr);
    wakesrc &= ~PEDR_REG_RSVD_BITS;

    if (BSPGetWakeSrc((PBULVERDE_PEDR_REGBITS)&wakesrc, &srcIrq))
    {
        g_oalWakeSource = OALIntrTranslateIrq(srcIrq);
        OALMSGS(1,(TEXT("Non Keybd wakesrc = %d\r\n"), g_oalWakeSource));
    }
    else
    {
        // check for keyboard wakeup
        wakesrc = INREG32(&pPwrRst_reg->pksr);
        wakesrc &= ~PKSR_REG_RSVD_BITS;
        if (wakesrc != 0)
        {
            g_oalWakeSource = SYSINTR_KEYPAD;
            OALMSGS(1,(TEXT("Keybd wakesrc!\r\n")));
        }
    }

    // clear wake up source status register (PEDR)
    OUTREG32(&pPwrRst_reg->pedr, wakesrc );    

    // Ack and Disable Wifi Wakeup Interrupt
    if (g_oalWakeSource == SYSINTR_WIFIWAKEUP)
        OEMInterruptDone(SYSINTR_WIFIWAKEUP);

    OEMInterruptDisable(SYSINTR_WIFIWAKEUP);
}       

//------------------------------------------------------------------------------
//
// Function:     BSPSetWakeSrc
//
// Description:  called to set wake-up sources. 
//
void BSPSetWakeSrc(PBULVERDE_PWER_REGBITS pPwer, int irq)
{
    //ignore undefined IRQ
    if (irq == OAL_INTR_IRQ_UNDEFINED)
        return;
    
    switch(irq) {
        case IRQ_RTCALARM:
            pPwer->rtc_alarm = 1;
            break;

        case IRQ_GPIO0:
            pPwer->gpio0 = 1;
            break;

        case IRQ_GPIOXX_2_GPIO14:
            pPwer->gpio14 = 1;
            break;

        default:
            OALMSG(OAL_WARN, (
                L"BSPSetWakeSrc: IRQ %d not supported as wake up source\r\n", irq
            ));
    }
}


//------------------------------------------------------------------------------
//
// Function:     BSPGetWakeSrc
//
// Description:  called to get the wake-up source.
//
BOOL BSPGetWakeSrc(PBULVERDE_PEDR_REGBITS pPedr, UINT32* pSrcIrq)
{
    if (pPedr->rtc_alarm) 
        *pSrcIrq = IRQ_RTCALARM;
    else if (pPedr->gpio0)
        *pSrcIrq = IRQ_GPIO0;
    else if (pPedr->gpio14)
        *pSrcIrq = IRQ_GPIOXX_2_GPIO14;
    else
        return 0;           //no match found

    return 1;                // match found
}



//------------------------------------------------------------------------------
//
// Function:     InitSleepParams
//
// Description:  Initialize sleep params (need to do only once).
//                   Sets up the sleep parameters that are used by the
//                   xllp suspend/resume layer to put the system to sleep/deep-sleep
//
void InitSleepParams(struct OFF_SLEEP_DATA_S* pSleepData)
{

    struct XLLP_PM_ENTER_SLEEP_PARAMS_S*  pSlpParams = &pSleepData->sleepParameters;
         
    // Force any unsupported options to not-selected
    //
    memset (pSlpParams, 0, sizeof (struct XLLP_PM_ENTER_SLEEP_PARAMS_S));

    //Set regs Uncached addresses. Required by the xllp layer to access, save and restore regs
    //
    pSlpParams->ProcRegs.UAPwrMgrRegs      = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_PWR);
    pSlpParams->ProcRegs.UAGPIORegs        = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_GPIO);
    pSlpParams->ProcRegs.UAIntcRegs        = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_INTC);
    pSlpParams->ProcRegs.UAIMControlReg    = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_IMCONTROL);
    pSlpParams->ProcRegs.UAOSTRegs         = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_OST);
    pSlpParams->ProcRegs.UAMEMCRegs        = (XLLP_UINT32_T) OALPAtoUA(BULVERDE_BASE_REG_PA_MEMC);
    
    //Set other values
    //
    pSlpParams->SleepDataAreaPA             = (XLLP_UINT32_T) OALVAtoPA(pSleepData);
    pSlpParams->SleepDataAreaVA             = (P_XLLP_PM_SLEEP_SAVE_DATA_T) pSleepData;
    pSlpParams->PWRMODE                     = XLLP_PM_PWRMODE_SLEEP;

}



//------------------------------------------------------------------------------
//
// Function:     OEMPowerOff
//
// Description:  Called when the system is to transition to it's lowest power mode (off)
//
//               The device is switched off by issuing the GOSTDBY command to the 
//               PCF50606 PMIC over the I2C bus
//
void OEMPowerOff()
{
    BOOL PowerState;
    static BOOL sleepParamsInit = FALSE;
    
    // init sleep params variable
    //
    if (!sleepParamsInit) {
        InitSleepParams(&m_SleepData);
        sleepParamsInit = TRUE;
    }

    // reset global wake-up source variable, just in case
    // we return from this function from a failure
    //
    g_oalWakeSource = SYSWAKE_UNKNOWN;

    OALMSGS(1, (TEXT("OEMPowerOff.\r\n")));

    // Initialize Power I2C registers;
    //
    if (!PI2CInit())
    {
        OALMSGS(1, (TEXT("OEMPowerOff: Failed to initialize Pi2c communication. Returning.\r\n")));
        return;
    }

    // power off KITL
    // 
    PowerState = 0;
    KITLIoctl (IOCTL_KITL_POWER_CALL, &PowerState, sizeof(PowerState), NULL, 0, NULL);

    // Give chance to do board specific stuff
    // Note: this sets wake-up source register
    //
    BSPPowerOff();

    if (g_fPlatformPowerOff)
    {
        // Power off Device
        //
        OALMSGS(1, (TEXT("OEMPowerOff: Issuing GOSTANDBY command to PMIC\r\n")));
        OALStall(20000);
        
        // Issue the standby command
        WritePI2CRegister(OOCC1, OOCC1_GOSTDBY | OOCC1_CHGWAK);

        // Wait for the command to take effect
        //
        OALStall(10000);
    }
    else
    {
        OALMSGS(1, (TEXT("OEMPowerOff: Issuing sleep command to proc\r\n")));
        OALStall(20000);
        
        // Sleep
        //
        XllpPmEnterSleep(&m_SleepData.sleepParameters);
    }

    //At this point device returned from sleep or failed to power off

    // turn on the serial port
    //
    OEMInitDebugSerial ();

    OALMSGS(1, (TEXT("\r\n\r\nOEMPowerOff: Back from Sleep.\r\n")));

    if (g_fPlatformPowerOff)
    {
        //We should not get here normally. 
        //
        // If we do, print error and return back. Returning from this function would be
        // analogous to resuming from a suspend.
        OALMSGS(1, (TEXT("OEMPowerOff failed. Returning back to full power.\r\n")));
    }
    
    // Do board specific stuff
    // Note: this sets g_oalWakeSource
    //
    BSPPowerOn();

    // Reinitialize KITL
    //
    PowerState = 1;
    KITLIoctl (IOCTL_KITL_POWER_CALL, &PowerState, sizeof(PowerState), NULL, 0, NULL);    
    
}