X-Git-Url: https://repo.jachan.dev/J-u-boot.git/blobdiff_plain/af7d151b8eaa56aaf61beb38248ce45b7ca017a8..ddec4cae624e48c3678ea856fa7d6292a7104238:/include/event.h diff --git a/include/event.h b/include/event.h index c00c4fb68dc..c37deae9452 100644 --- a/include/event.h +++ b/include/event.h @@ -10,25 +10,144 @@ #ifndef __event_h #define __event_h +#include <dm/ofnode_decl.h> +#include <linux/types.h> + /** * enum event_t - Types of events supported by U-Boot * * @EVT_DM_PRE_PROBE: Device is about to be probed */ enum event_t { - EVT_NONE, + /** + * @EVT_NONE: This zero value is not used for events. + */ + EVT_NONE = 0, + + /** + * @EVT_TEST: This event is used in unit tests. + */ EVT_TEST, - /* Events related to driver model */ - EVT_DM_POST_INIT, + /** + * @EVT_DM_POST_INIT_F: + * This event is triggered after pre-relocation initialization of the + * driver model. Its parameter is NULL. + * A non-zero return code from the event handler let's the boot process + * fail. + */ + EVT_DM_POST_INIT_F, + + /** + * @EVT_DM_POST_INIT_R: + * This event is triggered after post-relocation initialization of the + * driver model. Its parameter is NULL. + * A non-zero return code from the event handler let's the boot process + * fail. + */ + EVT_DM_POST_INIT_R, + + /** + * @EVT_DM_PRE_PROBE: + * This event is triggered before probing a device. Its parameter is the + * device to be probed. + * A non-zero return code from the event handler lets the device not + * being probed. + */ EVT_DM_PRE_PROBE, + + /** + * @EVT_DM_POST_PROBE: + * This event is triggered after probing a device. Its parameter is the + * device that was probed. + * A non-zero return code from the event handler leaves the device in + * the unprobed state and therefore not usable. + */ EVT_DM_POST_PROBE, + + /** + * @EVT_DM_PRE_REMOVE: + * This event is triggered after removing a device. Its parameter is + * the device to be removed. + * A non-zero return code from the event handler stops the removal of + * the device before any changes. + */ EVT_DM_PRE_REMOVE, + + /** + * @EVT_DM_POST_REMOVE: + * This event is triggered before removing a device. Its parameter is + * the device that was removed. + * A non-zero return code stops from the event handler the removal of + * the device after all removal changes. The previous state is not + * restored. All children will be gone and the device may not be + * functional. + */ EVT_DM_POST_REMOVE, - /* Init hooks */ + /** + * @EVT_MISC_INIT_F: + * This event is triggered during the initialization sequence before + * relocation. Its parameter is NULL. + * A non-zero return code from the event handler let's the boot process + * fail. + */ EVT_MISC_INIT_F, + /* + * Emitted before relocation to set up Firmware Support Package + * + * Where U-Boot relies on binary blobs to handle part of the system + * init, this event can be used to set up the blobs. This is used on + * some Intel platforms + */ + EVT_FSP_INIT_F, + + /* + * Emitted just before jumping to the main loop + * + * Some boards need to perform initialisation immediately before control + * is passed to the command-line interpreter (e.g. for init that depend + * on later phases in the init sequence). + * + * Some parts can be only initialized if all others (like Interrupts) + * are up and running (e.g. the PC-style ISA keyboard). + */ + EVT_LAST_STAGE_INIT, + + /** + * @EVT_FPGA_LOAD: + * The FPGA load hook is called after loading an FPGA with a new binary. + * Its parameter is of type struct event_fpga_load and contains + * information about the loaded image. + */ + EVT_FPGA_LOAD, + + /** + * @EVT_FT_FIXUP: + * This event is triggered during device-tree fix up after all + * other device-tree fixups have been executed. + * Its parameter is of type struct event_ft_fixup which contains + * the address of the device-tree to fix up and the list of images to be + * booted. + * A non-zero return code from the event handler let's booting the + * images fail. + */ + EVT_FT_FIXUP, + + /** + * @EVT_MAIN_LOOP: + * This event is triggered immediately before calling main_loop() which + * is the entry point of the command line. Its parameter is NULL. + * A non-zero return value causes the boot to fail. + */ + EVT_MAIN_LOOP, + + /** + * @EVT_COUNT: + * This constants holds the maximum event number + 1 and is used when + * looping over all event classes. + */ EVT_COUNT }; @@ -50,6 +169,30 @@ union event_data { struct event_dm { struct udevice *dev; } dm; + + /** + * struct event_fpga_load - fpga load event + * + * @buf: The buffer that was loaded into the fpga + * @bsize: The size of the buffer that was loaded into the fpga + * @result: Result of the load operation + */ + struct event_fpga_load { + const void *buf; + size_t bsize; + int result; + } fpga_load; + + /** + * struct event_ft_fixup - FDT fixup before booting + * + * @tree: tree to update + * @images: images which are being booted + */ + struct event_ft_fixup { + oftree tree; + struct bootm_headers *images; + } ft_fixup; }; /** @@ -63,19 +206,48 @@ struct event { union event_data data; }; +/* Flags for event spy */ +enum evspy_flags { + EVSPYF_SIMPLE = 1 << 0, +}; + /** Function type for event handlers */ typedef int (*event_handler_t)(void *ctx, struct event *event); +/** Function type for simple event handlers */ +typedef int (*event_handler_simple_t)(void); + /** * struct evspy_info - information about an event spy * * @func: Function to call when the event is activated (must be first) * @type: Event type + * @flag: Flags for this spy * @id: Event id string */ struct evspy_info { event_handler_t func; - enum event_t type; + u8 type; + u8 flags; +#if CONFIG_IS_ENABLED(EVENT_DEBUG) + const char *id; +#endif +}; + +/** + * struct evspy_info_simple - information about an event spy + * + * THis is the 'simple' record, the only difference being the handler function + * + * @func: Function to call when the event is activated (must be first) + * @type: Event type + * @flag: Flags for this spy + * @id: Event id string + */ +struct evspy_info_simple { + event_handler_simple_t func; + u8 type; + u8 flags; #if CONFIG_IS_ENABLED(EVENT_DEBUG) const char *id; #endif @@ -83,9 +255,11 @@ struct evspy_info { /* Declare a new event spy */ #if CONFIG_IS_ENABLED(EVENT_DEBUG) -#define _ESPY_REC(_type, _func) { _func, _type, #_func, } +#define _ESPY_REC(_type, _func) { _func, _type, 0, #_func, } +#define _ESPY_REC_SIMPLE(_type, _func) { _func, _type, EVSPYF_SIMPLE, #_func, } #else #define _ESPY_REC(_type, _func) { _func, _type, } +#define _ESPY_REC_SIMPLE(_type, _func) { _func, _type, EVSPYF_SIMPLE } #endif static inline const char *event_spy_id(struct evspy_info *spy) @@ -123,11 +297,20 @@ static inline const char *event_spy_id(struct evspy_info *spy) * The only solution I can think of is to mark linker-list entries as 'used' * using an attribute. This should be safe, since we don't actually want to drop * any of these. However this does slightly limit LTO's optimisation choices. + * + * Another issue has come up, only with clang: using 'static' makes it throw + * away the linker-list entry sometimes, e.g. with the EVT_FT_FIXUP entry in + * vbe_simple.c - so for now, make it global. */ -#define EVENT_SPY(_type, _func) \ - static __attribute__((used)) ll_entry_declare(struct evspy_info, \ - _type, evspy_info) = \ - _ESPY_REC(_type, _func) +#define EVENT_SPY_FULL(_type, _func) \ + __used ll_entry_declare(struct evspy_info, _type ## _3_ ## _func, \ + evspy_info) = _ESPY_REC(_type, _func) + +/* Simple spy with no function arguemnts */ +#define EVENT_SPY_SIMPLE(_type, _func) \ + __used ll_entry_declare(struct evspy_info_simple, \ + _type ## _3_ ## _func, \ + evspy_info) = _ESPY_REC_SIMPLE(_type, _func) /** * event_register - register a new spy @@ -154,6 +337,14 @@ void event_show_spy_list(void); */ int event_manual_reloc(void); +/** + * event_type_name() - Get the name of an event type + * + * @type: Type to check + * Return: Name of event, or "(unknown)" if not known + */ +const char *event_type_name(enum event_t type); + /** * event_notify() - notify spies about an event *