[PATCH v4 2/9] cyclic: Add basic support for cyclic function execution infrastruture
Stefan Roese
sr at denx.de
Tue Aug 16 12:28:09 CEST 2022
Add the basic infrastructure to periodically execute code, e.g. all
100ms. Examples for such functions might be LED blinking etc. The
functions that are hooked into this cyclic list should be small timewise
as otherwise the execution of the other code that relies on a high
frequent polling (e.g. UART rx char ready check) might be delayed too
much. This patch also adds the Kconfig option
CONFIG_CYCLIC_MAX_CPU_TIME_US, which configures the max allowed time
for such a cyclic function. If it's execution time exceeds this time,
this cyclic function will get removed from the cyclic list.
How is this cyclic functionality executed?
The following patch integrates the main function responsible for
calling all registered cyclic functions cyclic_run() into the
common WATCHDOG_RESET macro. This guarantees that cyclic_run() is
executed very often, which is necessary for the cyclic functions to
get scheduled and executed at their configured periods.
This cyclic infrastructure will be used by a board specific function on
the NIC23 MIPS Octeon board, which needs to check periodically, if a
PCIe FLR has occurred.
Signed-off-by: Stefan Roese <sr at denx.de>
Reviewed-by: Simon Glass <sjg at chromium.org>
---
v4:
- Rename cyclic_struct to cyclic_info and document it
- Set 'cyclic_ready' to false in cyclic_uninit()
- Added Simon's RB tag
v3:
- No change
v2:
- Also add cyclic_register() and cyclic_unregister() as empty functions
when CONFIG_CYCLIC is not defined
- Misc minor changes
MAINTAINERS | 6 +++
common/Kconfig | 20 +++++++++
common/Makefile | 1 +
common/cyclic.c | 113 +++++++++++++++++++++++++++++++++++++++++++++++
include/cyclic.h | 110 +++++++++++++++++++++++++++++++++++++++++++++
5 files changed, 250 insertions(+)
create mode 100644 common/cyclic.c
create mode 100644 include/cyclic.h
diff --git a/MAINTAINERS b/MAINTAINERS
index fa8c13fc7dfb..61395a85a83e 100644
--- a/MAINTAINERS
+++ b/MAINTAINERS
@@ -788,6 +788,12 @@ T: git https://source.denx.de/u-boot/custodians/u-boot-coldfire.git
F: arch/m68k/
F: doc/arch/m68k.rst
+CYCLIC
+M: Stefan Roese <sr at denx.de>
+S: Maintained
+F: common/cyclic.c
+F: include/cyclic.h
+
DFU
M: Lukasz Majewski <lukma at denx.de>
S: Maintained
diff --git a/common/Kconfig b/common/Kconfig
index e7914ca750a3..a6a94ab8dfbf 100644
--- a/common/Kconfig
+++ b/common/Kconfig
@@ -545,6 +545,26 @@ config DISPLAY_BOARDINFO_LATE
menu "Start-up hooks"
+config CYCLIC
+ bool "General-purpose cyclic execution mechanism"
+ help
+ This enables 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.
+
+if CYCLIC
+
+config CYCLIC_MAX_CPU_TIME_US
+ int "Sets the max allowed time for a cyclic function in us"
+ default 1000
+ help
+ The max allowed time for a cyclic function in us. If a functions
+ takes longer than this duration this function will get unregistered
+ automatically.
+
+endif # CYCLIC
+
config EVENT
bool "General-purpose event-handling mechanism"
default y if SANDBOX
diff --git a/common/Makefile b/common/Makefile
index 2ed8672c3ac1..1d56c9f2895a 100644
--- a/common/Makefile
+++ b/common/Makefile
@@ -84,6 +84,7 @@ obj-y += malloc_simple.o
endif
endif
+obj-$(CONFIG_CYCLIC) += cyclic.o
obj-$(CONFIG_$(SPL_TPL_)EVENT) += event.o
obj-$(CONFIG_$(SPL_TPL_)HASH) += hash.o
diff --git a/common/cyclic.c b/common/cyclic.c
new file mode 100644
index 000000000000..766a98382596
--- /dev/null
+++ b/common/cyclic.c
@@ -0,0 +1,113 @@
+// 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 at denx.de>
+ */
+
+#include <cyclic.h>
+#include <log.h>
+#include <linker_lists.h>
+#include <malloc.h>
+#include <time.h>
+#include <linux/errno.h>
+#include <linux/list.h>
+
+struct list_head cyclic_list;
+static bool cyclic_ready;
+static bool cyclic_running;
+
+struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us,
+ const char *name, void *ctx)
+{
+ struct cyclic_info *cyclic;
+
+ if (!cyclic_ready) {
+ pr_debug("Cyclic IF not ready yet\n");
+ return NULL;
+ }
+
+ cyclic = calloc(1, sizeof(struct cyclic_info));
+ if (!cyclic) {
+ pr_debug("Memory allocation error\n");
+ return NULL;
+ }
+
+ /* Store values in struct */
+ cyclic->func = func;
+ cyclic->ctx = ctx;
+ cyclic->name = strdup(name);
+ cyclic->delay_us = delay_us;
+ cyclic->start_time_us = timer_get_us();
+ list_add_tail(&cyclic->list, &cyclic_list);
+
+ return cyclic;
+}
+
+int cyclic_unregister(struct cyclic_info *cyclic)
+{
+ list_del(&cyclic->list);
+ free(cyclic);
+
+ return 0;
+}
+
+void cyclic_run(void)
+{
+ struct cyclic_info *cyclic, *tmp;
+ uint64_t now, cpu_time;
+
+ /* Prevent recursion */
+ if (cyclic_running)
+ return;
+
+ cyclic_running = true;
+ list_for_each_entry_safe(cyclic, tmp, &cyclic_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->ctx);
+ 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) {
+ pr_err("cyclic function %s took too long: %lldus vs %dus max, disabling\n",
+ cyclic->name, cpu_time,
+ CONFIG_CYCLIC_MAX_CPU_TIME_US);
+
+ /* Unregister this cyclic function */
+ cyclic_unregister(cyclic);
+ }
+ }
+ }
+ cyclic_running = false;
+}
+
+int cyclic_uninit(void)
+{
+ struct cyclic_info *cyclic, *tmp;
+
+ list_for_each_entry_safe(cyclic, tmp, &cyclic_list, list)
+ cyclic_unregister(cyclic);
+ cyclic_ready = false;
+
+ return 0;
+}
+
+int cyclic_init(void)
+{
+ INIT_LIST_HEAD(&cyclic_list);
+ cyclic_ready = true;
+
+ return 0;
+}
diff --git a/include/cyclic.h b/include/cyclic.h
new file mode 100644
index 000000000000..2ae1cba32f20
--- /dev/null
+++ b/include/cyclic.h
@@ -0,0 +1,110 @@
+/* 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 at denx.de>
+ */
+
+#ifndef __cyclic_h
+#define __cyclic_h
+
+#include <linux/list.h>
+#include <asm/types.h>
+
+/**
+ * struct cyclic_info - Information about cyclic execution function
+ *
+ * @func: Function to call periodically
+ * @ctx: Context pointer to get passed to this function
+ * @name: Name of the cyclic function, e.g. shown in the commands
+ * @delay_ns: Delay is ns after which this function shall get executed
+ * @start_time_us: Start time in us, when this function started its execution
+ * @cpu_time_us: Total CPU time of this function
+ * @run_cnt: Counter of executions occurances
+ * @next_call: Next time in us, when the function shall be executed again
+ * @list: List node
+ */
+struct cyclic_info {
+ void (*func)(void *ctx);
+ void *ctx;
+ char *name;
+ uint64_t delay_us;
+ uint64_t start_time_us;
+ uint64_t cpu_time_us;
+ uint64_t run_cnt;
+ uint64_t next_call;
+ struct list_head list;
+};
+
+/** Function type for cyclic functions */
+typedef void (*cyclic_func_t)(void *ctx);
+
+#if defined(CONFIG_CYCLIC)
+/**
+ * cyclic_register - Register a new cyclic function
+ *
+ * @func: Function to call periodically
+ * @delay_us: Delay is us after which this function shall get executed
+ * @name: Cyclic function name/id
+ * @ctx: Context to pass to the function
+ * @return: pointer to cyclic_struct if OK, NULL on error
+ */
+struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us,
+ const char *name, void *ctx);
+
+/**
+ * cyclic_unregister - Unregister a cyclic function
+ *
+ * @cyclic: Pointer to cyclic_struct of the function that shall be removed
+ * @return: 0 if OK, -ve on error
+ */
+int cyclic_unregister(struct cyclic_info *cyclic);
+
+/**
+ * cyclic_init() - Set up cyclic functions
+ *
+ * Init a list of cyclic functions, so that these can be added as needed
+ */
+int cyclic_init(void);
+
+/**
+ * cyclic_uninit() - Clean up cyclic functions
+ *
+ * This removes all cyclic functions
+ */
+int cyclic_uninit(void);
+
+void cyclic_run(void);
+#else
+static inline struct cyclic_info *cyclic_register(cyclic_func_t func,
+ uint64_t delay_us,
+ const char *name,
+ void *ctx)
+{
+ return NULL;
+}
+
+static inline int cyclic_unregister(struct cyclic_info *cyclic)
+{
+ return 0;
+}
+
+static inline void cyclic_run(void)
+{
+}
+
+static inline int cyclic_init(void)
+{
+ return 0;
+}
+
+static inline int cyclic_uninit(void)
+{
+ return 0;
+}
+#endif
+
+#endif
--
2.37.2
More information about the U-Boot
mailing list