michaelh/zephyr
1
0
Fork 0
Code Releases Activity
zephyr/drivers/timer/legacy_api.h

75 lines
1.8 KiB
C
Raw Permalink Normal View History

license: cleanup: add SPDX Apache-2.0 license identifier Update the files which contain no license information with the 'Apache-2.0' SPDX license identifier. Many source files in the tree are missing licensing information, which makes it harder for compliance tools to determine the correct license. By default all files without license information are under the default license of Zephyr, which is Apache version 2. Signed-off-by: Anas Nashif <anas.nashif@intel.com>
2019-04-06 09:08:09 -04:00
/*
* Copyright (c) 2018 Intel Corporation
*
* SPDX-License-Identifier: Apache-2.0
*/
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
#ifndef ZEPHYR_LEGACY_SET_TIME_H__
#define ZEPHYR_LEGACY_SET_TIME_H__
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
/* Stub implementation of z_clock_set_timeout() and z_clock_elapsed()
* in terms of the original APIs. Used by older timer drivers.
* Should be replaced.
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
*
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
* Yes, this "header" includes function definitions and must be
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
* included only once in a single compilation.
*/
#ifdef CONFIG_TICKLESS_IDLE
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
void z_timer_idle_enter(int32_t ticks);
include/system_timer.h: Timer API cleanup Rename timer driver API functions to be consistent. ADD DOCS TO THE HEADER so implementations understand what the requirements are. Remove some unused functions that don't need declarations here. Also removes the per-platform #if's around the power control callback in favor of a weak-linked noop function in the driver initialization (adds a few bytes of code to default platforms -- we'll live, I think). Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-21 09:33:36 -07:00
void z_clock_idle_exit(void);
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
#endif
timer: Clean up hairy tickless APIs The tickless driver had a bunch of "hairy" APIs which forced the timer drivers to do needless low-level accounting for the benefit of the kernel, all of which then proceeded to implement them via cut and paste. Specifically the "program_time" calls forced the driver to expose to the kernel exactly when the next interrupt was due and how much time had elapsed, in a parallel API to the existing "what time is it" and "announce a tick" interrupts that carry the same information. Remove these from the kernel, replacing them with synthesized logic written in terms of the simpler APIs. In some cases there will be a performance impact due to the use of the 64 bit uptime call, but that will go away soon. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-21 11:54:57 -07:00
#ifdef CONFIG_TICKLESS_KERNEL
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
void z_set_time(uint32_t time);
extern uint32_t z_get_program_time(void);
extern uint32_t z_get_remaining_program_time(void);
extern uint32_t z_get_elapsed_program_time(void);
timer: Clean up hairy tickless APIs The tickless driver had a bunch of "hairy" APIs which forced the timer drivers to do needless low-level accounting for the benefit of the kernel, all of which then proceeded to implement them via cut and paste. Specifically the "program_time" calls forced the driver to expose to the kernel exactly when the next interrupt was due and how much time had elapsed, in a parallel API to the existing "what time is it" and "announce a tick" interrupts that carry the same information. Remove these from the kernel, replacing them with synthesized logic written in terms of the simpler APIs. In some cases there will be a performance impact due to the use of the 64 bit uptime call, but that will go away soon. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-21 11:54:57 -07:00
#endif
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
extern uint64_t z_clock_uptime(void);
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
void z_clock_set_timeout(int32_t ticks, bool idle)
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
{
#ifdef CONFIG_TICKLESS_KERNEL
if (idle) {
drivers: Rename reserved function names Rename reserved function names in drivers/ subdirectory. Update function macros concatenatenating function names with '##'. As there is a conflict between the existing gpio_sch_manage_callback() and _gpio_sch_manage_callback() names, leave the latter unmodified. Signed-off-by: Patrik Flykt <patrik.flykt@intel.com>
2019-03-12 15:15:42 -06:00
z_timer_idle_enter(ticks);
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
} else {
kernel/timeout: Make timeout arguments an opaque type Add a k_timeout_t type, and use it everywhere that kernel API functions were accepting a millisecond timeout argument. Instead of forcing milliseconds everywhere (which are often not integrally representable as system ticks), do the conversion to ticks at the point where the timeout is created. This avoids an extra unit conversion in some application code, and allows us to express the timeout in units other than milliseconds to achieve greater precision. The existing K_MSEC() et. al. macros now return initializers for a k_timeout_t. The K_NO_WAIT and K_FOREVER constants have now become k_timeout_t values, which means they cannot be operated on as integers. Applications which have their own APIs that need to inspect these vs. user-provided timeouts can now use a K_TIMEOUT_EQ() predicate to test for equality. Timer drivers, which receive an integer tick count in ther z_clock_set_timeout() functions, now use the integer-valued K_TICKS_FOREVER constant instead of K_FOREVER. For the initial release, to preserve source compatibility, a CONFIG_LEGACY_TIMEOUT_API kconfig is provided. When true, the k_timeout_t will remain a compatible 32 bit value that will work with any legacy Zephyr application. Some subsystems present timeout (or timeout-like) values to their own users as APIs that would re-use the kernel's own constants and conventions. These will require some minor design work to adapt to the new scheme (in most cases just using k_timeout_t directly in their own API), and they have not been changed in this patch, instead selecting CONFIG_LEGACY_TIMEOUT_API via kconfig. These subsystems include: CAN Bus, the Microbit display driver, I2S, LoRa modem drivers, the UART Async API, Video hardware drivers, the console subsystem, and the network buffer abstraction. k_sleep() now takes a k_timeout_t argument, with a k_msleep() variant provided that works identically to the original API. Most of the changes here are just type/configuration management and documentation, but there are logic changes in mempool, where a loop that used a timeout numerically has been reworked using a new z_timeout_end_calc() predicate. Also in queue.c, a (when POLL was enabled) a similar loop was needlessly used to try to retry the k_poll() call after a spurious failure. But k_poll() does not fail spuriously, so the loop was removed. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2020-03-05 15:18:14 -08:00
z_set_time(ticks == K_TICKS_FOREVER ? 0 : ticks);
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
}
#endif
}
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
/* The old driver "now" API would return a full uptime value. The new
* one only requires the driver to track ticks since the last announce
* call. Implement the new call in terms of the old one on legacy
* drivers by keeping (yet another) uptime value locally.
*/
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
static uint32_t driver_uptime;
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
uint32_t z_clock_elapsed(void)
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
{
kernel: kconfig: Fix broken references to TICKLESS_KERNEL The CONFIG_ prefixes were missing on these. Found with a work-in-progress scripts/kconfig/lint.py check. This symbol is defined in kernel/Kconfig. Signed-off-by: Ulf Magnusson <Ulf.Magnusson@nordicsemi.no>
2020-01-25 05:16:31 +01:00
#ifdef CONFIG_TICKLESS_KERNEL
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
return (uint32_t)(z_clock_uptime() - driver_uptime);
kernel: New timeout implementation Now that the API has been fixed up, replace the existing timeout queue with a much smaller version. The basic algorithm is unchanged: timeouts are stored in a sorted dlist with each node nolding a delta time from the previous node in the list; the announce call just walks this list pulling off the heads as needed. Advantages: * Properly spinlocked and SMP-aware. The earlier timer implementation relied on only CPU 0 doing timeout work, and on an irq_lock() being taken before entry (something that was violated in a few spots). Now any CPU can wake up for an event (or all of them) and everything works correctly. * The *_thread_timeout() API is now expressible as a clean wrapping (just one liners) around the lower-level interface based on function pointer callbacks. As a result the timeout objects no longer need to store backpointers to the thread and wait_q and have shrunk by 33%. * MUCH smaller, to the tune of hundreds of lines of code removed. * Future proof, in that all operations on the queue are now fronted by just two entry points (_add_timeout() and z_clock_announce()) which can easily be augmented with fancier data structures. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 16:50:00 -07:00
#else
return 0;
#endif
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
}
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
static void wrapped_announce(int32_t ticks)
system_timer.h: Change "now" uptime API to be simpler for drivers The current z_clock_uptime() call (recently renamed from _get_elapsed_program_time) requires the driver to track a full 64 bit uptime value in ticks, which is entirely separate from the one the kernel is already keeping. Don't do that. Just ask the drivers to track uptime since the last call to z_clock_announce(), since that is going to map better to built-in hardware capability. Obviously existing drivers already have this feature, so they're actually getting slightly larger in order to implement the new API in terms of the old one. But future drivers will thank us. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 14:08:46 -07:00
{
driver_uptime += ticks;
z_clock_announce(ticks);
}
#define z_clock_announce(t) wrapped_announce(t)
kernel: New timeout implementation Now that the API has been fixed up, replace the existing timeout queue with a much smaller version. The basic algorithm is unchanged: timeouts are stored in a sorted dlist with each node nolding a delta time from the previous node in the list; the announce call just walks this list pulling off the heads as needed. Advantages: * Properly spinlocked and SMP-aware. The earlier timer implementation relied on only CPU 0 doing timeout work, and on an irq_lock() being taken before entry (something that was violated in a few spots). Now any CPU can wake up for an event (or all of them) and everything works correctly. * The *_thread_timeout() API is now expressible as a clean wrapping (just one liners) around the lower-level interface based on function pointer callbacks. As a result the timeout objects no longer need to store backpointers to the thread and wait_q and have shrunk by 33%. * MUCH smaller, to the tune of hundreds of lines of code removed. * Future proof, in that all operations on the queue are now fronted by just two entry points (_add_timeout() and z_clock_announce()) which can easily be augmented with fancier data structures. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 16:50:00 -07:00
#define _sys_clock_always_on (0)
zephyr: replace zephyr integer types with C99 types git grep -l 'u\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/u\(8\|16\|32\|64\)_t/uint\1_t/g" git grep -l 's\(8\|16\|32\|64\)_t' | \ xargs sed -i "s/s\(8\|16\|32\|64\)_t/int\1_t/g" Signed-off-by: Kumar Gala <kumar.gala@linaro.org>
2020-05-27 11:26:57 -05:00
static inline void z_tick_set(int64_t val)
kernel: New timeout implementation Now that the API has been fixed up, replace the existing timeout queue with a much smaller version. The basic algorithm is unchanged: timeouts are stored in a sorted dlist with each node nolding a delta time from the previous node in the list; the announce call just walks this list pulling off the heads as needed. Advantages: * Properly spinlocked and SMP-aware. The earlier timer implementation relied on only CPU 0 doing timeout work, and on an irq_lock() being taken before entry (something that was violated in a few spots). Now any CPU can wake up for an event (or all of them) and everything works correctly. * The *_thread_timeout() API is now expressible as a clean wrapping (just one liners) around the lower-level interface based on function pointer callbacks. As a result the timeout objects no longer need to store backpointers to the thread and wait_q and have shrunk by 33%. * MUCH smaller, to the tune of hundreds of lines of code removed. * Future proof, in that all operations on the queue are now fronted by just two entry points (_add_timeout() and z_clock_announce()) which can easily be augmented with fancier data structures. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-27 16:50:00 -07:00
{
/* noop with current kernel code, use z_clock_announce() */
ARG_UNUSED(val);
}
drivers/timer: Unify timeout setting APIs The existing API had two almost identical functions: _set_time() and _timer_idle_enter(). Both simply instruct the timer driver to set the next timer interrupt expiration appropriately so that the call to z_clock_announce() will be made at the requested number of ticks. On most/all hardware, these should be implementable identically. Unfortunately because they are specified differently, existing drivers have implemented them in parallel. Specify a new, unified, z_clock_set_timeout(). Document it clearly for implementors. And provide a shim layer for legacy drivers that will continue to use the old functions. Note that this patch fixes an existing bug found by inspection: the old call to _set_time() out of z_clock_announce() failed to test for the "wait forever" case in the situation where clock_always_on is true, meaning that a system that reached this point and then never set another timeout would freeze its uptime clock incorrectly. Signed-off-by: Andy Ross <andrew.j.ross@intel.com>
2018-09-20 13:56:45 -07:00
#endif /* ZEPHYR_LEGACY_SET_TIME_H__ */
Copy permalink