blob: 99bf482097e2a733f27560b772e63980745cdcc3 [file] [log] [blame]
/*
* Copyright (c) 1997-2010, 2012-2014 Wind River Systems, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @file
* @brief Microkernel idle logic
*
* Microkernel idle logic. Different forms of idling are performed by the idle
* task, depending on how the kernel is configured.
*/
#include <micro_private.h>
#include <nano_private.h>
#include <arch/cpu.h>
#include <toolchain.h>
#include <sections.h>
#include <microkernel.h>
#include <misc/util.h>
#include <drivers/system_timer.h>
#if defined(CONFIG_WORKLOAD_MONITOR)
static unsigned int _k_workload_slice = 0x0;
static unsigned int _k_workload_ticks = 0x0;
static unsigned int _k_workload_ref_time = 0x0;
static unsigned int _k_workload_t0 = 0x0;
static unsigned int _k_workload_t1 = 0x0;
static volatile unsigned int _k_workload_n0 = 0x0;
static volatile unsigned int _k_workload_n1 = 0x0;
static volatile unsigned int _k_workload_i = 0x0;
static volatile unsigned int _k_workload_i0 = 0x0;
static volatile unsigned int _k_workload_delta = 0x0;
static volatile unsigned int _k_workload_start_time = 0x0;
static volatile unsigned int _k_workload_end_time = 0x0;
#ifdef WL_SCALE
static extern uint32_t _k_workload_scale;
#endif
/**
*
* @brief Shared code between workload calibration and monitoring
*
* Perform idle task "dummy work".
*
* This routine increments _k_workload_i and checks it against _k_workload_n1.
* _k_workload_n1 is updated by the system tick handler, and both are kept
* in close synchronization.
*
* @return N/A
*
*/
static void workload_loop(void)
{
volatile int x = 87654321;
volatile int y = 4;
/* loop never terminates, except during calibration phase */
while (++_k_workload_i != _k_workload_n1) {
unsigned int s_iCountDummyProc = 0;
while (64 != s_iCountDummyProc++) { /* 64 == 2^6 */
x >>= y;
x <<= y;
y++;
x >>= y;
x <<= y;
y--;
}
}
}
/**
*
* @brief Calibrate the workload monitoring subsystem
*
* Measures the time required to do a fixed amount of "dummy work", and
* sets default values for the workload measuring period.
*
* @return N/A
*
*/
void _k_workload_monitor_calibrate(void)
{
_k_workload_n0 = _k_workload_i = 0;
_k_workload_n1 = 1000;
_k_workload_t0 = sys_cycle_get_32();
workload_loop();
_k_workload_t1 = sys_cycle_get_32();
_k_workload_delta = _k_workload_t1 - _k_workload_t0;
_k_workload_i0 = _k_workload_i;
#ifdef WL_SCALE
_k_workload_ref_time =
(_k_workload_t1 - _k_workload_t0) >> (_k_workload_scale);
#else
_k_workload_ref_time = (_k_workload_t1 - _k_workload_t0) >> (4 + 6);
#endif
_k_workload_slice = 100;
_k_workload_ticks = 100;
}
/**
*
* @brief Workload monitor tick handler
*
* If workload monitor is configured this routine updates the global variables
* it uses to record the passage of time.
*
* @return N/A
*
*/
void _k_workload_monitor_update(void)
{
if (--_k_workload_ticks == 0) {
_k_workload_t0 = _k_workload_t1;
_k_workload_t1 = sys_cycle_get_32();
_k_workload_n0 = _k_workload_n1;
_k_workload_n1 = _k_workload_i - 1;
_k_workload_ticks = _k_workload_slice;
}
}
/**
*
* @brief Workload monitor "start idling" handler
*
* Records time when idle task was selected for execution by the microkernel.
*
* @return N/A
*/
void _k_workload_monitor_idle_start(void)
{
_k_workload_start_time = sys_cycle_get_32();
}
/**
*
* @brief Workload monitor "end idling" handler
*
* Records time when idle task was no longer selected for execution by the
* microkernel, and updates amount of time spent idling.
*
* @return N/A
*/
void _k_workload_monitor_idle_end(void)
{
_k_workload_end_time = sys_cycle_get_32();
_k_workload_i += (_k_workload_i0 *
(_k_workload_end_time - _k_workload_start_time)) / _k_workload_delta;
}
/**
*
* @brief Process request to read the processor workload
*
* Computes workload, or uses 0 if workload monitoring is not configured.
*
* @return N/A
*/
void _k_workload_get(struct k_args *P)
{
unsigned int k, t;
signed int iret;
k = (_k_workload_i - _k_workload_n0) * _k_workload_ref_time;
#ifdef WL_SCALE
t = (sys_cycle_get_32() - _k_workload_t0) >> (_k_workload_scale);
#else
t = (sys_cycle_get_32() - _k_workload_t0) >> (4 + 6);
#endif
iret = MSEC_PER_SEC - k / t;
/*
* Due to calibration at startup, <iret> could be slightly negative.
* Ensure a negative value is never returned.
*/
if (iret < 0) {
iret = 0;
}
P->args.u1.rval = iret;
}
#else
void _k_workload_get(struct k_args *P)
{
P->args.u1.rval = 0;
}
#endif /* CONFIG_WORKLOAD_MONITOR */
int task_workload_get(void)
{
struct k_args A;
A.Comm = _K_SVC_WORKLOAD_GET;
KERNEL_ENTRY(&A);
return A.args.u1.rval;
}
void sys_workload_time_slice_set(int32_t t)
{
#ifdef CONFIG_WORKLOAD_MONITOR
if (t < 10) {
t = 10;
}
if (t > 1000) {
t = 1000;
}
_k_workload_slice = t;
#else
ARG_UNUSED(t);
#endif
}
unsigned char _sys_power_save_flag = 1;
#if defined(CONFIG_SYS_POWER_MANAGEMENT)
#include <nanokernel.h>
#include <microkernel/base_api.h>
#if (defined(CONFIG_SYS_POWER_LOW_POWER_STATE) || \
defined(CONFIG_SYS_POWER_DEEP_SLEEP) || \
defined(CONFIG_DEVICE_POWER_MANAGEMENT))
#include <power.h>
#endif
#if defined(CONFIG_TICKLESS_IDLE)
#include <drivers/system_timer.h>
#endif
extern void nano_cpu_set_idle(int32_t ticks);
#if defined(CONFIG_TICKLESS_IDLE)
/*
* Idle time must be this value or higher for timer to go into tickless idle
* state.
*/
int32_t _sys_idle_threshold_ticks = CONFIG_TICKLESS_IDLE_THRESH;
#endif /* CONFIG_TICKLESS_IDLE */
/**
*
* @brief Power management policy when kernel begins idling
*
* This routine implements the power management policy based on the time
* until the timer expires, in system ticks.
* Routine is invoked from the idle task with interrupts disabled
*
* @return N/A
*/
void _sys_power_save_idle(int32_t ticks)
{
#if defined(CONFIG_TICKLESS_IDLE)
if ((ticks == TICKS_UNLIMITED) || ticks >= _sys_idle_threshold_ticks) {
/*
* Stop generating system timer interrupts until it's time for
* the next scheduled microkernel timer to expire.
*/
_timer_idle_enter(ticks);
}
#endif /* CONFIG_TICKLESS_IDLE */
nano_cpu_set_idle(ticks);
#if (defined(CONFIG_SYS_POWER_LOW_POWER_STATE) || \
defined(CONFIG_SYS_POWER_DEEP_SLEEP) || \
defined(CONFIG_DEVICE_POWER_MANAGEMENT))
/*
* Call the suspend hook function, which checks if the system should
* enter deep sleep, low power state or only suspend devices.
* If the time available is too short for any PM operation then
* the function returns SYS_PM_NOT_HANDLED immediately and kernel
* does normal idle processing. Otherwise it will return the code
* corresponding to the action taken.
*
* This function can just suspend devices without entering
* deep sleep or cpu low power state. In this case it should return
* SYS_PM_DEVICE_SUSPEND_ONLY and kernel would do normal idle
* processing.
*
* This function is entered with interrupts disabled. If the function
* returns either SYS_PM_LOW_POWER_STATE or SYS_PM_DEEP_SLEEP then
* it should ensure interrupts are re-enabled before returning.
* This is because the kernel does not do its own idle processing in
* these cases i.e. skips nano_cpu_idle(). The kernel's idle
* processing re-enables interrupts which is essential for kernel's
* scheduling logic.
*/
if (!(_sys_soc_suspend(ticks) &
(SYS_PM_DEEP_SLEEP | SYS_PM_LOW_POWER_STATE))) {
nano_cpu_idle();
}
#else
nano_cpu_idle();
#endif
}
/**
*
* @brief Power management policy when kernel stops idling
*
* This routine is invoked when the kernel leaves the idle state.
* Routine can be modified to wake up other devices.
* The routine is invoked from interrupt thread, with interrupts disabled.
*
* @return N/A
*/
void _sys_power_save_idle_exit(int32_t ticks)
{
#if (defined(CONFIG_SYS_POWER_LOW_POWER_STATE) || \
defined(CONFIG_SYS_POWER_DEEP_SLEEP) || \
defined(CONFIG_DEVICE_POWER_MANAGEMENT))
/* Any idle wait based on CPU low power state will be exited by
* interrupt. This function is called within that interrupt's
* ISR context. _sys_soc_resume() needs to be called here
* to handle exit from CPU low power states. This gives an
* opportunity for device states altered in _sys_soc_suspend()
* to be restored before the kernel schedules another thread.
* _sys_soc_resume() is not called from here for deep sleep
* exit. Deep sleep recovery happens at cold boot path.
*/
_sys_soc_resume();
#endif
#ifdef CONFIG_TICKLESS_IDLE
if ((ticks == TICKS_UNLIMITED) || ticks >= _sys_idle_threshold_ticks) {
/* Resume normal periodic system timer interrupts */
_timer_idle_exit();
}
#else
ARG_UNUSED(ticks);
#endif /* CONFIG_TICKLESS_IDLE */
}
/**
*
* @brief Obtain number of ticks until next timer expires
*
* Must be called with interrupts locked to prevent the timer queues from
* changing.
*
* @return Number of ticks until next timer expires.
*
*/
static inline int32_t _get_next_timer_expiry(void)
{
uint32_t closest_deadline = (uint32_t)TICKS_UNLIMITED;
if (_k_timer_list_head) {
closest_deadline = _k_timer_list_head->duration;
}
return (int32_t)min(closest_deadline, _nano_get_earliest_deadline());
}
#endif
/**
*
* @brief Power saving when idle
*
* If _sys_power_save_flag is non-zero, this routine keeps the system in a low
* power state whenever the kernel is idle. If it is zero, this routine will
* fall through and _k_kernel_idle() will try the next idling mechanism.
*
* @return N/A
*
*/
static void _power_save(void)
{
if (_sys_power_save_flag) {
for (;;) {
irq_lock();
#ifdef CONFIG_SYS_POWER_MANAGEMENT
_sys_power_save_idle(_get_next_timer_expiry());
#else
/*
* nano_cpu_idle() is invoked here directly only if APM
* is disabled. Otherwise the microkernel decides
* either to invoke it or to implement advanced idle
* functionality
*/
nano_cpu_idle();
#endif
}
/*
* Code analyzers may complain that _power_save() uses an
* infinite loop unless we indicate that this is intentional
*/
CODE_UNREACHABLE;
}
}
/* Specify what work to do when idle task is "busy waiting" */
#ifdef CONFIG_WORKLOAD_MONITOR
#define DO_IDLE_WORK() workload_loop()
#else
#define DO_IDLE_WORK() do { /* do nothing */ } while (0)
#endif
/**
*
* @brief Microkernel idle task
*
* If power save is on, we sleep; if power save is off, we "busy wait".
*
* @return N/A
*
*/
int _k_kernel_idle(void)
{
_power_save(); /* never returns if power saving is enabled */
#ifdef CONFIG_BOOT_TIME_MEASUREMENT
/* record timestamp when idling begins */
extern uint64_t __idle_tsc;
__idle_tsc = _NanoTscRead();
#endif
for (;;) {
DO_IDLE_WORK();
}
/*
* Code analyzers may complain that _k_kernel_idle() uses an infinite
* loop unless we indicate that this is intentional
*/
CODE_UNREACHABLE;
}