/** * \brief Test different parameters of the Sleep Manager module * * This function locks & unlocks the different sleep modes, and verifies that * the correct values are being set. * * \param test Current test case. */ static void run_set_functions_test(const struct test_case *test) { volatile enum sleepmgr_mode sleep_mode; /* Initialize the lock counts */ sleepmgr_init(); /* Lock Power Down mode */ sleepmgr_lock_mode(SLEEPMGR_PDOWN); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == SLEEPMGR_PDOWN, "Trying to lock Power Down mode failed."); /* Lock Power Save mode */ sleepmgr_lock_mode(SLEEPMGR_PSAVE); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == SLEEPMGR_PSAVE, "Trying to lock Power Save mode failed."); /* Lock Idle Sleep mode */ sleepmgr_lock_mode(SLEEPMGR_IDLE); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == SLEEPMGR_IDLE, "Trying to lock Idle Sleep mode failed."); /* Unlock Idle Sleep mode */ sleepmgr_unlock_mode(SLEEPMGR_IDLE); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == SLEEPMGR_PSAVE, "Trying to unlock Idle Sleep mode failed."); /* Unlock Power Save mode */ sleepmgr_unlock_mode(SLEEPMGR_PSAVE); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == SLEEPMGR_PDOWN, "Trying to unlock Power Save Sleep mode failed."); /* Unlock Power Down mode */ sleepmgr_unlock_mode(SLEEPMGR_PDOWN); /* get the deepest allowable sleep mode */ sleep_mode = sleepmgr_get_sleep_mode(); test_assert_true(test, sleep_mode == (SLEEPMGR_NR_OF_MODES - 1), "Trying to unlock Power Down mode failed."); }
/* Override the default definition of vPortSuppressTicksAndSleep() that is weakly defined in the FreeRTOS Cortex-M3 port layer with a version that manages the asynchronous timer (AST), as the tick is generated from the low power AST and not the SysTick as would normally be the case on a Cortex-M. */ void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime ) { uint32_t ulAlarmValue, ulCompleteTickPeriods, ulInterruptStatus; eSleepModeStatus eSleepAction; TickType_t xModifiableIdleTime; enum sleepmgr_mode xSleepMode; /* THIS FUNCTION IS CALLED WITH THE SCHEDULER SUSPENDED. */ /* Make sure the AST reload value does not overflow the counter. */ if( xExpectedIdleTime > xMaximumPossibleSuppressedTicks ) { xExpectedIdleTime = xMaximumPossibleSuppressedTicks; } /* Calculate the reload value required to wait xExpectedIdleTime tick periods. */ ulAlarmValue = ulAlarmValueForOneTick * xExpectedIdleTime; if( ulAlarmValue > ulStoppedTimerCompensation ) { /* Compensate for the fact that the AST is going to be stopped momentarily. */ ulAlarmValue -= ulStoppedTimerCompensation; } /* Stop the AST momentarily. The time the AST is stopped for is accounted for as best it can be, but using the tickless mode will inevitably result in some tiny drift of the time maintained by the kernel with respect to calendar time. */ prvDisableAST(); /* Enter a critical section but don't use the taskENTER_CRITICAL() method as that will mask interrupts that should exit sleep mode. */ ulInterruptStatus = cpu_irq_save(); /* The tick flag is set to false before sleeping. If it is true when sleep mode is exited then sleep mode was probably exited because the tick was suppressed for the entire xExpectedIdleTime period. */ ulTickFlag = pdFALSE; /* If a context switch is pending then abandon the low power entry as the context switch might have been pended by an external interrupt that requires processing. */ eSleepAction = eTaskConfirmSleepModeStatus(); if( eSleepAction == eAbortSleep ) { /* Restart tick. */ prvEnableAST(); /* Re-enable interrupts - see comments above the cpsid instruction() above. */ cpu_irq_restore( ulInterruptStatus ); } else { /* Adjust the alarm value to take into account that the current time slice is already partially complete. */ ulAlarmValue -= ast_read_counter_value( AST ); ast_write_alarm0_value( AST, ulAlarmValue ); /* Restart the AST. */ prvEnableAST(); /* Allow the application to define some pre-sleep processing. */ xModifiableIdleTime = xExpectedIdleTime; configPRE_SLEEP_PROCESSING( xModifiableIdleTime ); /* xExpectedIdleTime being set to 0 by configPRE_SLEEP_PROCESSING() means the application defined code has already executed the WAIT instruction. */ if( xModifiableIdleTime > 0 ) { /* Find the deepest allowable sleep mode. */ xSleepMode = sleepmgr_get_sleep_mode(); if( xSleepMode != SLEEPMGR_ACTIVE ) { /* Sleep until something happens. */ bpm_sleep( BPM, xSleepMode ); } } /* Allow the application to define some post sleep processing. */ configPOST_SLEEP_PROCESSING( xModifiableIdleTime ); /* Stop AST. Again, the time the SysTick is stopped for is accounted for as best it can be, but using the tickless mode will inevitably result in some tiny drift of the time maintained by the kernel with respect to calendar time. */ prvDisableAST(); /* Re-enable interrupts - see comments above the cpsid instruction() above. */ cpu_irq_restore( ulInterruptStatus ); if( ulTickFlag != pdFALSE ) { /* The tick interrupt has already executed, although because this function is called with the scheduler suspended the actual tick processing will not occur until after this function has exited. Reset the alarm value with whatever remains of this tick period. */ ulAlarmValue = ulAlarmValueForOneTick - ast_read_counter_value( AST ); ast_write_alarm0_value( AST, ulAlarmValue ); /* The tick interrupt handler will already have pended the tick processing in the kernel. As the pending tick will be processed as soon as this function exits, the tick value maintained by the tick is stepped forward by one less than the time spent sleeping. The actual stepping of the tick appears later in this function. */ ulCompleteTickPeriods = xExpectedIdleTime - 1UL; } else { /* Something other than the tick interrupt ended the sleep. How many complete tick periods passed while the processor was sleeping? */ ulCompleteTickPeriods = ast_read_counter_value( AST ) / ulAlarmValueForOneTick; /* The alarm value is set to whatever fraction of a single tick period remains. */ ulAlarmValue = ast_read_counter_value( AST ) - ( ulCompleteTickPeriods * ulAlarmValueForOneTick ); if( ulAlarmValue == 0 ) { /* There is no fraction remaining. */ ulAlarmValue = ulAlarmValueForOneTick; ulCompleteTickPeriods++; } ast_write_counter_value( AST, 0 ); ast_write_alarm0_value( AST, ulAlarmValue ); } /* Restart the AST so it runs up to the alarm value. The alarm value will get set to the value required to generate exactly one tick period the next time the AST interrupt executes. */ prvEnableAST(); /* Wind the tick forward by the number of tick periods that the CPU remained in a low power state. */ vTaskStepTick( ulCompleteTickPeriods ); } }