pmgr.c

Xcale270Bsp包,wince平台

            // Don't enable GPIO reset on GPIO 1  (enable = 1u << 4)

            // Don't control DVM aspects (bits 6, 10) (PCFR_msk)

        //    pPwrMgrRegs->PCFR  = (pPwrMgrRegs->PCFR & (0x00001CF7 &~(0x00000886))) | 0x020;

            pSlpParams->PCFR_msk    =  ((~0x00001CF7u) 
                                            | 0x00000886u | 0x00000020u) | 0x01u;
            pSlpParams->PCFR_vals   =  ( 0x0u                       | 0x00000020u);

            pSlpParams->PSLR_msk    =  (0xFFFFFFFFu); // Control them all for now.
                // Power ramp delays at max: 0xFF << 28 and 24
                // Don't shorten wakeup delay (b23 = 0)
                // Enter deep sleep from sleep for VCC fault (b22=0)
                // SRAM banks 3..0 powered off for sleep modes (b11..8 = 0)
                // Keep PI domain powered during sleep (2 << 2)
                // All others reserved = 0

        //  Don't assert nRESET_OUT for sleep: SL_ROD, bit 20 ; resets FPGA and other
        //  peripherals on Mainstone.
            pSlpParams->PSLR_vals   =  ((0xFFu<< 28) | (0xFFu<< 24) | (1u << 20) | (2u << 2));
        // OK, but leaves LEDs on

        // Now try this: resets FPGA and more.  OK for switch-based wakeup, may need
        //  to leave deasserted for other wakeup reasons.  nRESET_OUT is used on 
        //  Mainstone II to reset many devices.
            // Do assert nRESET_OUT for sleep: (SL_ROD, bit 20)
        // would assert:   pSlpParams->PSLR_vals   =  ((0xFFu<< 28) | (0xFFu<< 24) | (2u << 2));


                // Don't save internal memory until used by an entity that doesn't save it by itself
            pSlpParams->StoreAddrForIntlMem_0 = 0;//(P_XLLP_UINT32_T) (IM_SAVE_U_VIRTUAL+(0*XLLP_IM_BANK_SIZE));
            pSlpParams->StoreAddrForIntlMem_1 = 0;//(P_XLLP_UINT32_T) (IM_SAVE_U_VIRTUAL+(1*XLLP_IM_BANK_SIZE));
            pSlpParams->StoreAddrForIntlMem_2 = 0;//(P_XLLP_UINT32_T) (IM_SAVE_U_VIRTUAL+(2*XLLP_IM_BANK_SIZE));
            pSlpParams->StoreAddrForIntlMem_3 = 0;//(P_XLLP_UINT32_T) (IM_SAVE_U_VIRTUAL+(3*XLLP_IM_BANK_SIZE));
            pSlpParams->IntlMemVA_0 = (P_XLLP_UINT32_T) (IM_STORAGE_BASE_U_VIRTUAL+(0*XLLP_IM_BANK_SIZE));
            pSlpParams->IntlMemVA_1 = (P_XLLP_UINT32_T) (IM_STORAGE_BASE_U_VIRTUAL+(1*XLLP_IM_BANK_SIZE));
            pSlpParams->IntlMemVA_2 = (P_XLLP_UINT32_T) (IM_STORAGE_BASE_U_VIRTUAL+(2*XLLP_IM_BANK_SIZE));
            pSlpParams->IntlMemVA_3 = (P_XLLP_UINT32_T) (IM_STORAGE_BASE_U_VIRTUAL+(3*XLLP_IM_BANK_SIZE));

            // Extended checksum and optional reglist capability
            // Note: Total checksummed space limited by XLLI_MAX_SLEEP_DATA_COUNT
            #ifdef  BUILDING_SAMPLE_OPT_REGLIST
                pSlpParams->pOptionalRegList = PmRegList;
                pSlpParams->privateRegListCount =  sizeof(regListTestJunkArray) / sizeof (XLLP_VUINT32_T);
                pSlpParams->pPrivateRegListStorage = pPmSleepData->sleepExtraChecksummedData.PmRegListStorage;
            #endif // def  BUILDING_SAMPLE_OPT_REGLIST
            #ifdef  USING_EXTENDED_CHECKSUM_AREA
                pSlpParams->extendedChecksumWordCount = sizeof (Pm_SLEEP_SAVE_DATA_EXTENSIONS_T) / 4;
            #endif // def  USING_EXTENDED_CHECKSUM_AREA

        } // if ((!pPmSleepData)||forceReset)
    }
//NKDbgPrintfW(TEXT("-PmgrInitSleepParam\r\n"));

    return(status);
} // PmgrInitSleepParam()

void PmgrProcessorFlushAll (void)
{
    // Use OS-specific flushing calls
    FlushDCache();
    FlushICache();
    TLBClear();

}  // PmgrProcessorFlushAll()


// General usage OK.  Serialization assumed.
XLLP_STATUS_T PmgrSetValue(PVOID pvu_SleepAreaBase,
                           PMGR_DATUM_SELECTOR_T selector,
                           XLLP_UINT32_T value)
{
    volatile P_PM_SLEEP_DATA_T pPmSleepData =
                                (volatile P_PM_SLEEP_DATA_T) pvu_SleepAreaBase;
// Not needed yet.    volatile P_XLLP_PM_ENTER_SLEEP_PARAMS_T  pSlpParams;
    XLLP_STATUS_T status = XLLP_STATUS_SUCCESS;

//NKDbgPrintfW(TEXT("+PmgrSetValue\r\n"));
//NKDbgPrintfW(TEXT("  pvu_SleepAreaBase: 0x%X\r\n"),pvu_SleepAreaBase);
//NKDbgPrintfW(TEXT("  selector: 0x%X\r\n"),selector);
///NKDbgPrintfW(TEXT("  value: 0x%X\r\n"),value);
    if (!pvu_SleepAreaBase)
    {
        status = XLLP_STATUS_WRONG_PARAMETER;
    }
    else 
    {
// Not needed yet.        pSlpParams =  &((P_PM_SLEEP_DATA_T)pPmSleepData)->sleepParameters;
        switch (selector)
        {
            case PMDS_SLEEP_TYPE:
                pPmSleepData->sleepTM.sleepType = value;
//NKDbgPrintfW(TEXT("  pPmSleepData->sleepTM.sleepType = value: 0x%X;0x%X \r\n"),
//                    &pPmSleepData->sleepTM.sleepType,value);
                break;
            default:
                status = XLLP_STATUS_WRONG_PARAMETER;

        }   // switch (selector)
    } // else of if (!pvu_SleepAreaBase)

//NKDbgPrintfW(TEXT("-PmgrSetValue, status = 0x%X\r\n"),status);
    return(status);

} // PmgrSetValue()


// General usage OK.  Serialization assumed.
XLLP_STATUS_T PmgrGetValue(PVOID pvu_SleepAreaBase,
                           PMGR_DATUM_SELECTOR_T selector,
                           P_XLLP_UINT32_T pu32_Value)
{
    volatile P_PM_SLEEP_DATA_T pPmSleepData =
                                (volatile P_PM_SLEEP_DATA_T) pvu_SleepAreaBase;
// Not needed yet.    volatile P_XLLP_PM_ENTER_SLEEP_PARAMS_T  pSlpParams;
    XLLP_STATUS_T status = XLLP_STATUS_SUCCESS;

    if (!pvu_SleepAreaBase)
    {
        status = XLLP_STATUS_WRONG_PARAMETER;
    }
    else 
    {
// Not needed yet.        pSlpParams =  &((P_PM_SLEEP_DATA_T)pPmSleepData)->sleepParameters;
        switch (selector)
        {
            case PMDS_SLEEP_TYPE:
                *pu32_Value = pPmSleepData->sleepTM.sleepType;
                break;
            default:
                status = XLLP_STATUS_WRONG_PARAMETER;
        }   // switch (selector)
    } // else of if (!pvu_SleepAreaBase)

    return(status);

} // PmgrGetValue()

static void PmgrOsSuspendOptionalFn(void)
{
    #ifdef BSP_MAINSTONE
        PmgrBlankLeds();   //Save power, maintain old behavior now that nReset_Out not asserted.        
    #endif //def BSP_MAINSTONE
    PmgrCheckForForcedWakeup();

} // PmgrOsSuspendOptionalFn()


#ifdef BSP_MAINSTONE

// Save power, maintain old behavior now that nReset_Out not asserted.        
// Ideally, there would be an LED driver.
static void PmgrBlankLeds(void)
{
    P_XLLP_BCR_T pBLR = (P_XLLP_BCR_T) FPGA_REGS_BASE_U_VIRTUAL; 
    pBLR->LCR = 0x0FFFF; // Set all bits in 16-bit reg to blank hex + discrete LEDs.
    
} // PmgrBlankLeds()

#endif //def BSP_MAINSTONE


// If Soft Reset is selected, force RTC wakeup in one-two seconds.
// Note this is sub-optimal for restart latency; use of OSMR4 or higher
//  should be investigated.
static void PmgrCheckForForcedWakeup(void)
{
    P_PM_SLEEP_DATA_T pPmSleepData = (P_PM_SLEEP_DATA_T) SLEEP_SAVE_U_VIRTUAL;
    volatile XLLP_RTC_T *v_pRTCReg = (volatile XLLP_RTC_T *)RTC_BASE_U_VIRTUAL;

    if (SLEEP_TYPE_SOFT_RESET == pPmSleepData->sleepTM.sleepType)
    {
        // Enable RTC wakeup
            // Assumed as standard for now.
        // Set RTC match register to wake up in 1-2 seconds.
        v_pRTCReg->rtar  =  v_pRTCReg->rcnr +2 ;
    }

} // PmgrCheckForForcedWakeup()


static void PmgrOsResumeOptionalFn(void)
{
    OsSpecificDebugCommsResume();
#ifndef BSP_NOIPM
	IPM_RegisterWakeUpReasons();
#endif

} // PmgrOsResumeOptionalFn()



#if 0

void PmgrDumpOSCRs(void)
{
    NKDbgPrintfW(TEXT("\r\nOSCRs from Suspend-Resume Statistics:\r\n"));
    NKDbgPrintfW(TEXT("     BeginSleepTime = 0x%X\r\n"), pPmgrSleepParams->BeginSleepTime);
    NKDbgPrintfW(TEXT("     EndSleepTime   = 0x%X\r\n"), pPmgrSleepParams->EndSleepTime);
    NKDbgPrintfW(TEXT("     BeginWakeTime  = 0x%X\r\n"), pPmgrSleepParams->BeginWakeTime);
    NKDbgPrintfW(TEXT("     ChangeOfTime   = 0x%X\r\n"), pPmgrSleepParams->ChangeOfTime);
    NKDbgPrintfW(TEXT("     EndWakeTime    = 0x%X\r\n"), pPmgrSleepParams->EndWakeTime);

} // PmgrDumpOSCRs()

#endif 0