mirror of
https://github.com/u-boot/u-boot.git
synced 2025-04-25 06:46:00 +00:00
008c4b3c31
There are of course not a whole lot of examples in-tree yet, but
before they appear, let's make this API change: Instead of separately
allocating a 'struct cyclic_info', make the users embed such an
instance in their own structure, and make the convention that the
callback simply receives the 'struct cyclic_info *', from which the
clients can get their own data using the container_of() macro.
This has a number of advantages.
First, it means cyclic_register() simply cannot fail, simplifying the
code. The necessary storage will simply be allocated automatically
when the client's own structure is allocated (often via
uclass_priv_auto or similar).
Second, code for which CONFIG_CYCLIC is just an option can more easily
be written without #ifdefs, if we just provide an empty struct
cyclic_info {}. For example, the nested CONFIG_IS_ENABLED()s in
https://lore.kernel.org/u-boot/20240316201416.211480-1-marek.vasut+renesas@mailbox.org/
are mostly due to the existence of the 'struct cyclic_info *' member
being guarded by #ifdef CONFIG_CYCLIC.
And we do probably want to avoid the extra memory overhead of that
member when !CONFIG_CYCLIC. But that is automatic if, instead of a
'struct cyclic_info *', one simply embeds a 'struct cyclic_info',
which will have size 0 when !CONFIG_CYCLIC. Also, the no-op
cyclic_register() function can just unconditionally be called, and the
compiler will see that (1) the callback is referenced, so not emit a
warning for a maybe-unused function and (2) see that it can actually
never be reached, so not emit any code for it.
Reviewed-by: Stefan Roese <sr@denx.de>
Signed-off-by: Rasmus Villemoes <rasmus.villemoes@prevas.dk>
113 lines
2.7 KiB
C
113 lines
2.7 KiB
C
// SPDX-License-Identifier: GPL-2.0+
|
|
/*
|
|
* A general-purpose cyclic execution infrastructure, to allow "small"
|
|
* (run-time wise) functions to be executed at a specified frequency.
|
|
* Things like LED blinking or watchdog triggering are examples for such
|
|
* tasks.
|
|
*
|
|
* Copyright (C) 2022 Stefan Roese <sr@denx.de>
|
|
*/
|
|
|
|
#include <cyclic.h>
|
|
#include <log.h>
|
|
#include <malloc.h>
|
|
#include <time.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/list.h>
|
|
#include <asm/global_data.h>
|
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
void hw_watchdog_reset(void);
|
|
|
|
struct hlist_head *cyclic_get_list(void)
|
|
{
|
|
/* Silence "discards 'volatile' qualifier" warning. */
|
|
return (struct hlist_head *)&gd->cyclic_list;
|
|
}
|
|
|
|
void cyclic_register(struct cyclic_info *cyclic, cyclic_func_t func,
|
|
uint64_t delay_us, const char *name)
|
|
{
|
|
memset(cyclic, 0, sizeof(*cyclic));
|
|
|
|
/* Store values in struct */
|
|
cyclic->func = func;
|
|
cyclic->name = name;
|
|
cyclic->delay_us = delay_us;
|
|
cyclic->start_time_us = timer_get_us();
|
|
hlist_add_head(&cyclic->list, cyclic_get_list());
|
|
}
|
|
|
|
void cyclic_unregister(struct cyclic_info *cyclic)
|
|
{
|
|
hlist_del(&cyclic->list);
|
|
}
|
|
|
|
void cyclic_run(void)
|
|
{
|
|
struct cyclic_info *cyclic;
|
|
struct hlist_node *tmp;
|
|
uint64_t now, cpu_time;
|
|
|
|
/* Prevent recursion */
|
|
if (gd->flags & GD_FLG_CYCLIC_RUNNING)
|
|
return;
|
|
|
|
gd->flags |= GD_FLG_CYCLIC_RUNNING;
|
|
hlist_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list) {
|
|
/*
|
|
* Check if this cyclic function needs to get called, e.g.
|
|
* do not call the cyclic func too often
|
|
*/
|
|
now = timer_get_us();
|
|
if (time_after_eq64(now, cyclic->next_call)) {
|
|
/* Call cyclic function and account it's cpu-time */
|
|
cyclic->next_call = now + cyclic->delay_us;
|
|
cyclic->func(cyclic);
|
|
cyclic->run_cnt++;
|
|
cpu_time = timer_get_us() - now;
|
|
cyclic->cpu_time_us += cpu_time;
|
|
|
|
/* Check if cpu-time exceeds max allowed time */
|
|
if ((cpu_time > CONFIG_CYCLIC_MAX_CPU_TIME_US) &&
|
|
(!cyclic->already_warned)) {
|
|
pr_err("cyclic function %s took too long: %lldus vs %dus max\n",
|
|
cyclic->name, cpu_time,
|
|
CONFIG_CYCLIC_MAX_CPU_TIME_US);
|
|
|
|
/*
|
|
* Don't disable this function, just warn once
|
|
* about this exceeding CPU time usage
|
|
*/
|
|
cyclic->already_warned = true;
|
|
}
|
|
}
|
|
}
|
|
gd->flags &= ~GD_FLG_CYCLIC_RUNNING;
|
|
}
|
|
|
|
void schedule(void)
|
|
{
|
|
/* The HW watchdog is not integrated into the cyclic IF (yet) */
|
|
if (IS_ENABLED(CONFIG_HW_WATCHDOG))
|
|
hw_watchdog_reset();
|
|
|
|
/*
|
|
* schedule() might get called very early before the cyclic IF is
|
|
* ready. Make sure to only call cyclic_run() when it's initalized.
|
|
*/
|
|
if (gd)
|
|
cyclic_run();
|
|
}
|
|
|
|
int cyclic_unregister_all(void)
|
|
{
|
|
struct cyclic_info *cyclic;
|
|
struct hlist_node *tmp;
|
|
|
|
hlist_for_each_entry_safe(cyclic, tmp, cyclic_get_list(), list)
|
|
cyclic_unregister(cyclic);
|
|
|
|
return 0;
|
|
}
|