F: arch/m68k/
F: doc/arch/m68k.rst
+CYCLIC
+M: Stefan Roese <sr@denx.de>
+S: Maintained
+F: common/cyclic.c
+F: include/cyclic.h
+
DFU
M: Lukasz Majewski <lukma@denx.de>
S: Maintained
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
endif
endif
+obj-$(CONFIG_CYCLIC) += cyclic.o
obj-$(CONFIG_$(SPL_TPL_)EVENT) += event.o
obj-$(CONFIG_$(SPL_TPL_)HASH) += hash.o
--- /dev/null
+// 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;
+
+struct list_head *cyclic_get_list(void)
+{
+ return &gd->cyclic->cyclic_list;
+}
+
+struct cyclic_info *cyclic_register(cyclic_func_t func, uint64_t delay_us,
+ const char *name, void *ctx)
+{
+ struct cyclic_info *cyclic;
+
+ if (!gd->cyclic->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, &gd->cyclic->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 (gd->cyclic->cyclic_running)
+ return;
+
+ gd->cyclic->cyclic_running = true;
+ list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->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);
+ }
+ }
+ }
+ gd->cyclic->cyclic_running = false;
+}
+
+int cyclic_uninit(void)
+{
+ struct cyclic_info *cyclic, *tmp;
+
+ list_for_each_entry_safe(cyclic, tmp, &gd->cyclic->cyclic_list, list)
+ cyclic_unregister(cyclic);
+ gd->cyclic->cyclic_ready = false;
+
+ return 0;
+}
+
+int cyclic_init(void)
+{
+ int size = sizeof(struct cyclic_drv);
+
+ gd->cyclic = (struct cyclic_drv *)malloc(size);
+ if (!gd->cyclic)
+ return -ENOMEM;
+
+ memset(gd->cyclic, '\0', size);
+ INIT_LIST_HEAD(&gd->cyclic->cyclic_list);
+ gd->cyclic->cyclic_ready = true;
+
+ return 0;
+}
*/
#ifndef __ASSEMBLY__
+#include <cyclic.h>
#include <event_internal.h>
#include <fdtdec.h>
#include <membuff.h>
* @event_state: Points to the current state of events
*/
struct event_state event_state;
+#endif
+#ifdef CONFIG_CYCLIC
+ /**
+ * @cyclic: cyclic driver data
+ */
+ struct cyclic_drv *cyclic;
#endif
/**
* @dmtag_list: List of DM tags
--- /dev/null
+/* 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>
+ */
+
+#ifndef __cyclic_h
+#define __cyclic_h
+
+#include <linux/list.h>
+#include <asm/types.h>
+
+/**
+ * struct cyclic_drv - Cyclic driver internal data
+ *
+ * @cyclic_list: Cylic list node
+ * @cyclic_ready: Flag if cyclic infrastructure is ready
+ * @cyclic_running: Flag if cyclic infrastructure is running
+ */
+struct cyclic_drv {
+ struct list_head cyclic_list;
+ bool cyclic_ready;
+ bool cyclic_running;
+};
+
+/**
+ * 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);
+
+/**
+ * cyclic_get_list() - Get cyclic list pointer
+ *
+ * Return the cyclic list pointer
+ *
+ * @return: pointer to cyclic_list
+ */
+struct list_head *cyclic_get_list(void);
+
+/**
+ * cyclic_run() - Interate over all registered cyclic functions
+ *
+ * Interate over all registered cyclic functions and if the it's function
+ * needs to be executed, then call into these registered functions.
+ */
+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
projects / u-boot.git / commitdiff
