// SPDX-License-Identifier: GPL-2.0 /* * System Control and Management Interface (SCMI) Notification support * * Copyright (C) 2020-2021 ARM Ltd. */ /** * DOC: Theory of operation * * SCMI Protocol specification allows the platform to signal events to * interested agents via notification messages: this is an implementation * of the dispatch and delivery of such notifications to the interested users * inside the Linux kernel. * * An SCMI Notification core instance is initialized for each active platform * instance identified by the means of the usual &struct scmi_handle. * * Each SCMI Protocol implementation, during its initialization, registers with * this core its set of supported events using scmi_register_protocol_events(): * all the needed descriptors are stored in the &struct registered_protocols and * &struct registered_events arrays. * * Kernel users interested in some specific event can register their callbacks * providing the usual notifier_block descriptor, since this core implements * events' delivery using the standard Kernel notification chains machinery. * * Given the number of possible events defined by SCMI and the extensibility * of the SCMI Protocol itself, the underlying notification chains are created * and destroyed dynamically on demand depending on the number of users * effectively registered for an event, so that no support structures or chains * are allocated until at least one user has registered a notifier_block for * such event. Similarly, events' generation itself is enabled at the platform * level only after at least one user has registered, and it is shutdown after * the last user for that event has gone. * * All users provided callbacks and allocated notification-chains are stored in * the @registered_events_handlers hashtable. Callbacks' registration requests * for still to be registered events are instead kept in the dedicated common * hashtable @pending_events_handlers. * * An event is identified univocally by the tuple (proto_id, evt_id, src_id) * and is served by its own dedicated notification chain; information contained * in such tuples is used, in a few different ways, to generate the needed * hash-keys. * * Here proto_id and evt_id are simply the protocol_id and message_id numbers * as described in the SCMI Protocol specification, while src_id represents an * optional, protocol dependent, source identifier (like domain_id, perf_id * or sensor_id and so forth). * * Upon reception of a notification message from the platform the SCMI RX ISR * passes the received message payload and some ancillary information (including * an arrival timestamp in nanoseconds) to the core via @scmi_notify() which * pushes the event-data itself on a protocol-dedicated kfifo queue for further * deferred processing as specified in @scmi_events_dispatcher(). * * Each protocol has it own dedicated work_struct and worker which, once kicked * by the ISR, takes care to empty its own dedicated queue, deliverying the * queued items into the proper notification-chain: notifications processing can * proceed concurrently on distinct workers only between events belonging to * different protocols while delivery of events within the same protocol is * still strictly sequentially ordered by time of arrival. * * Events' information is then extracted from the SCMI Notification messages and * conveyed, converted into a custom per-event report struct, as the void *data * param to the user callback provided by the registered notifier_block, so that * from the user perspective his callback will look invoked like: * * int user_cb(struct notifier_block *nb, unsigned long event_id, void *report) * */ #define dev_fmt(fmt) … #define pr_fmt(fmt) … #include <linux/bitfield.h> #include <linux/bug.h> #include <linux/compiler.h> #include <linux/device.h> #include <linux/err.h> #include <linux/hashtable.h> #include <linux/kernel.h> #include <linux/ktime.h> #include <linux/kfifo.h> #include <linux/list.h> #include <linux/mutex.h> #include <linux/notifier.h> #include <linux/refcount.h> #include <linux/scmi_protocol.h> #include <linux/slab.h> #include <linux/types.h> #include <linux/workqueue.h> #include "common.h" #include "notify.h" #define SCMI_MAX_PROTO … #define PROTO_ID_MASK … #define EVT_ID_MASK … #define SRC_ID_MASK … #define NOTIF_UNSUPP … /* * Builds an unsigned 32bit key from the given input tuple to be used * as a key in hashtables. */ #define MAKE_HASH_KEY(p, e, s) … #define MAKE_ALL_SRCS_KEY(p, e) … /* * Assumes that the stored obj includes its own hash-key in a field named 'key': * with this simplification this macro can be equally used for all the objects' * types hashed by this implementation. * * @__ht: The hashtable name * @__obj: A pointer to the object type to be retrieved from the hashtable; * it will be used as a cursor while scanning the hastable and it will * be possibly left as NULL when @__k is not found * @__k: The key to search for */ #define KEY_FIND(__ht, __obj, __k) … #define KEY_XTRACT_PROTO_ID(key) … #define KEY_XTRACT_EVT_ID(key) … #define KEY_XTRACT_SRC_ID(key) … /* * A set of macros used to access safely @registered_protocols and * @registered_events arrays; these are fixed in size and each entry is possibly * populated at protocols' registration time and then only read but NEVER * modified or removed. */ #define SCMI_GET_PROTO(__ni, __pid) … #define SCMI_GET_REVT_FROM_PD(__pd, __eid) … #define SCMI_GET_REVT(__ni, __pid, __eid) … /* A couple of utility macros to limit cruft when calling protocols' helpers */ #define REVT_NOTIFY_SET_STATUS(revt, eid, sid, state) … #define REVT_NOTIFY_ENABLE(revt, eid, sid) … #define REVT_NOTIFY_DISABLE(revt, eid, sid) … #define REVT_FILL_REPORT(revt, ...) … #define SCMI_PENDING_HASH_SZ … #define SCMI_REGISTERED_HASH_SZ … struct scmi_registered_events_desc; /** * struct scmi_notify_instance - Represents an instance of the notification * core * @gid: GroupID used for devres * @handle: A reference to the platform instance * @init_work: A work item to perform final initializations of pending handlers * @notify_wq: A reference to the allocated Kernel cmwq * @pending_mtx: A mutex to protect @pending_events_handlers * @registered_protocols: A statically allocated array containing pointers to * all the registered protocol-level specific information * related to events' handling * @pending_events_handlers: An hashtable containing all pending events' * handlers descriptors * * Each platform instance, represented by a handle, has its own instance of * the notification subsystem represented by this structure. */ struct scmi_notify_instance { … }; /** * struct events_queue - Describes a queue and its associated worker * @sz: Size in bytes of the related kfifo * @kfifo: A dedicated Kernel kfifo descriptor * @notify_work: A custom work item bound to this queue * @wq: A reference to the associated workqueue * * Each protocol has its own dedicated events_queue descriptor. */ struct events_queue { … }; /** * struct scmi_event_header - A utility header * @timestamp: The timestamp, in nanoseconds (boottime), which was associated * to this event as soon as it entered the SCMI RX ISR * @payld_sz: Effective size of the embedded message payload which follows * @evt_id: Event ID (corresponds to the Event MsgID for this Protocol) * @payld: A reference to the embedded event payload * * This header is prepended to each received event message payload before * queueing it on the related &struct events_queue. */ struct scmi_event_header { … }; struct scmi_registered_event; /** * struct scmi_registered_events_desc - Protocol Specific information * @id: Protocol ID * @ops: Protocol specific and event-related operations * @equeue: The embedded per-protocol events_queue * @ni: A reference to the initialized instance descriptor * @eh: A reference to pre-allocated buffer to be used as a scratch area by the * deferred worker when fetching data from the kfifo * @eh_sz: Size of the pre-allocated buffer @eh * @in_flight: A reference to an in flight &struct scmi_registered_event * @num_events: Number of events in @registered_events * @registered_events: A dynamically allocated array holding all the registered * events' descriptors, whose fixed-size is determined at * compile time. * @registered_mtx: A mutex to protect @registered_events_handlers * @ph: SCMI protocol handle reference * @registered_events_handlers: An hashtable containing all events' handlers * descriptors registered for this protocol * * All protocols that register at least one event have their protocol-specific * information stored here, together with the embedded allocated events_queue. * These descriptors are stored in the @registered_protocols array at protocol * registration time. * * Once these descriptors are successfully registered, they are NEVER again * removed or modified since protocols do not unregister ever, so that, once * we safely grab a NON-NULL reference from the array we can keep it and use it. */ struct scmi_registered_events_desc { … }; /** * struct scmi_registered_event - Event Specific Information * @proto: A reference to the associated protocol descriptor * @evt: A reference to the associated event descriptor (as provided at * registration time) * @report: A pre-allocated buffer used by the deferred worker to fill a * customized event report * @num_sources: The number of possible sources for this event as stated at * events' registration time * @sources: A reference to a dynamically allocated array used to refcount the * events' enable requests for all the existing sources * @sources_mtx: A mutex to serialize the access to @sources * * All registered events are represented by one of these structures that are * stored in the @registered_events array at protocol registration time. * * Once these descriptors are successfully registered, they are NEVER again * removed or modified since protocols do not unregister ever, so that once we * safely grab a NON-NULL reference from the table we can keep it and use it. */ struct scmi_registered_event { … }; /** * struct scmi_event_handler - Event handler information * @key: The used hashkey * @users: A reference count for number of active users for this handler * @r_evt: A reference to the associated registered event; when this is NULL * this handler is pending, which means that identifies a set of * callbacks intended to be attached to an event which is still not * known nor registered by any protocol at that point in time * @chain: The notification chain dedicated to this specific event tuple * @hash: The hlist_node used for collision handling * @enabled: A boolean which records if event's generation has been already * enabled for this handler as a whole * * This structure collects all the information needed to process a received * event identified by the tuple (proto_id, evt_id, src_id). * These descriptors are stored in a per-protocol @registered_events_handlers * table using as a key a value derived from that tuple. */ struct scmi_event_handler { … }; #define IS_HNDL_PENDING(hndl) … static struct scmi_event_handler * scmi_get_active_handler(struct scmi_notify_instance *ni, u32 evt_key); static void scmi_put_active_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl); static bool scmi_put_handler_unlocked(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl); /** * scmi_lookup_and_call_event_chain() - Lookup the proper chain and call it * @ni: A reference to the notification instance to use * @evt_key: The key to use to lookup the related notification chain * @report: The customized event-specific report to pass down to the callbacks * as their *data parameter. */ static inline void scmi_lookup_and_call_event_chain(struct scmi_notify_instance *ni, u32 evt_key, void *report) { … } /** * scmi_process_event_header() - Dequeue and process an event header * @eq: The queue to use * @pd: The protocol descriptor to use * * Read an event header from the protocol queue into the dedicated scratch * buffer and looks for a matching registered event; in case an anomalously * sized read is detected just flush the queue. * * Return: * * a reference to the matching registered event when found * * ERR_PTR(-EINVAL) when NO registered event could be found * * NULL when the queue is empty */ static inline struct scmi_registered_event * scmi_process_event_header(struct events_queue *eq, struct scmi_registered_events_desc *pd) { … } /** * scmi_process_event_payload() - Dequeue and process an event payload * @eq: The queue to use * @pd: The protocol descriptor to use * @r_evt: The registered event descriptor to use * * Read an event payload from the protocol queue into the dedicated scratch * buffer, fills a custom report and then look for matching event handlers and * call them; skip any unknown event (as marked by scmi_process_event_header()) * and in case an anomalously sized read is detected just flush the queue. * * Return: False when the queue is empty */ static inline bool scmi_process_event_payload(struct events_queue *eq, struct scmi_registered_events_desc *pd, struct scmi_registered_event *r_evt) { … } /** * scmi_events_dispatcher() - Common worker logic for all work items. * @work: The work item to use, which is associated to a dedicated events_queue * * Logic: * 1. dequeue one pending RX notification (queued in SCMI RX ISR context) * 2. generate a custom event report from the received event message * 3. lookup for any registered ALL_SRC_IDs handler: * - > call the related notification chain passing in the report * 4. lookup for any registered specific SRC_ID handler: * - > call the related notification chain passing in the report * * Note that: * * a dedicated per-protocol kfifo queue is used: in this way an anomalous * flood of events cannot saturate other protocols' queues. * * each per-protocol queue is associated to a distinct work_item, which * means, in turn, that: * + all protocols can process their dedicated queues concurrently * (since notify_wq:max_active != 1) * + anyway at most one worker instance is allowed to run on the same queue * concurrently: this ensures that we can have only one concurrent * reader/writer on the associated kfifo, so that we can use it lock-less * * Context: Process context. */ static void scmi_events_dispatcher(struct work_struct *work) { … } /** * scmi_notify() - Queues a notification for further deferred processing * @handle: The handle identifying the platform instance from which the * dispatched event is generated * @proto_id: Protocol ID * @evt_id: Event ID (msgID) * @buf: Event Message Payload (without the header) * @len: Event Message Payload size * @ts: RX Timestamp in nanoseconds (boottime) * * Context: Called in interrupt context to queue a received event for * deferred processing. * * Return: 0 on Success */ int scmi_notify(const struct scmi_handle *handle, u8 proto_id, u8 evt_id, const void *buf, size_t len, ktime_t ts) { … } /** * scmi_kfifo_free() - Devres action helper to free the kfifo * @kfifo: The kfifo to free */ static void scmi_kfifo_free(void *kfifo) { … } /** * scmi_initialize_events_queue() - Allocate/Initialize a kfifo buffer * @ni: A reference to the notification instance to use * @equeue: The events_queue to initialize * @sz: Size of the kfifo buffer to allocate * * Allocate a buffer for the kfifo and initialize it. * * Return: 0 on Success */ static int scmi_initialize_events_queue(struct scmi_notify_instance *ni, struct events_queue *equeue, size_t sz) { … } /** * scmi_allocate_registered_events_desc() - Allocate a registered events' * descriptor * @ni: A reference to the &struct scmi_notify_instance notification instance * to use * @proto_id: Protocol ID * @queue_sz: Size of the associated queue to allocate * @eh_sz: Size of the event header scratch area to pre-allocate * @num_events: Number of events to support (size of @registered_events) * @ops: Pointer to a struct holding references to protocol specific helpers * needed during events handling * * It is supposed to be called only once for each protocol at protocol * initialization time, so it warns if the requested protocol is found already * registered. * * Return: The allocated and registered descriptor on Success */ static struct scmi_registered_events_desc * scmi_allocate_registered_events_desc(struct scmi_notify_instance *ni, u8 proto_id, size_t queue_sz, size_t eh_sz, int num_events, const struct scmi_event_ops *ops) { … } /** * scmi_register_protocol_events() - Register Protocol Events with the core * @handle: The handle identifying the platform instance against which the * protocol's events are registered * @proto_id: Protocol ID * @ph: SCMI protocol handle. * @ee: A structure describing the events supported by this protocol. * * Used by SCMI Protocols initialization code to register with the notification * core the list of supported events and their descriptors: takes care to * pre-allocate and store all needed descriptors, scratch buffers and event * queues. * * Return: 0 on Success */ int scmi_register_protocol_events(const struct scmi_handle *handle, u8 proto_id, const struct scmi_protocol_handle *ph, const struct scmi_protocol_events *ee) { … } /** * scmi_deregister_protocol_events - Deregister protocol events with the core * @handle: The handle identifying the platform instance against which the * protocol's events are registered * @proto_id: Protocol ID */ void scmi_deregister_protocol_events(const struct scmi_handle *handle, u8 proto_id) { … } /** * scmi_allocate_event_handler() - Allocate Event handler * @ni: A reference to the notification instance to use * @evt_key: 32bit key uniquely bind to the event identified by the tuple * (proto_id, evt_id, src_id) * * Allocate an event handler and related notification chain associated with * the provided event handler key. * Note that, at this point, a related registered_event is still to be * associated to this handler descriptor (hndl->r_evt == NULL), so the handler * is initialized as pending. * * Context: Assumes to be called with @pending_mtx already acquired. * Return: the freshly allocated structure on Success */ static struct scmi_event_handler * scmi_allocate_event_handler(struct scmi_notify_instance *ni, u32 evt_key) { … } /** * scmi_free_event_handler() - Free the provided Event handler * @hndl: The event handler structure to free * * Context: Assumes to be called with proper locking acquired depending * on the situation. */ static void scmi_free_event_handler(struct scmi_event_handler *hndl) { … } /** * scmi_bind_event_handler() - Helper to attempt binding an handler to an event * @ni: A reference to the notification instance to use * @hndl: The event handler to bind * * If an associated registered event is found, move the handler from the pending * into the registered table. * * Context: Assumes to be called with @pending_mtx already acquired. * * Return: 0 on Success */ static inline int scmi_bind_event_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } /** * scmi_valid_pending_handler() - Helper to check pending status of handlers * @ni: A reference to the notification instance to use * @hndl: The event handler to check * * An handler is considered pending when its r_evt == NULL, because the related * event was still unknown at handler's registration time; anyway, since all * protocols register their supported events once for all at protocols' * initialization time, a pending handler cannot be considered valid anymore if * the underlying event (which it is waiting for), belongs to an already * initialized and registered protocol. * * Return: 0 on Success */ static inline int scmi_valid_pending_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } /** * scmi_register_event_handler() - Register whenever possible an Event handler * @ni: A reference to the notification instance to use * @hndl: The event handler to register * * At first try to bind an event handler to its associated event, then check if * it was at least a valid pending handler: if it was not bound nor valid return * false. * * Valid pending incomplete bindings will be periodically retried by a dedicated * worker which is kicked each time a new protocol completes its own * registration phase. * * Context: Assumes to be called with @pending_mtx acquired. * * Return: 0 on Success */ static int scmi_register_event_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } /** * __scmi_event_handler_get_ops() - Utility to get or create an event handler * @ni: A reference to the notification instance to use * @evt_key: The event key to use * @create: A boolean flag to specify if a handler must be created when * not already existent * * Search for the desired handler matching the key in both the per-protocol * registered table and the common pending table: * * if found adjust users refcount * * if not found and @create is true, create and register the new handler: * handler could end up being registered as pending if no matching event * could be found. * * An handler is guaranteed to reside in one and only one of the tables at * any one time; to ensure this the whole search and create is performed * holding the @pending_mtx lock, with @registered_mtx additionally acquired * if needed. * * Note that when a nested acquisition of these mutexes is needed the locking * order is always (same as in @init_work): * 1. pending_mtx * 2. registered_mtx * * Events generation is NOT enabled right after creation within this routine * since at creation time we usually want to have all setup and ready before * events really start flowing. * * Return: A properly refcounted handler on Success, NULL on Failure */ static inline struct scmi_event_handler * __scmi_event_handler_get_ops(struct scmi_notify_instance *ni, u32 evt_key, bool create) { … } static struct scmi_event_handler * scmi_get_handler(struct scmi_notify_instance *ni, u32 evt_key) { … } static struct scmi_event_handler * scmi_get_or_create_handler(struct scmi_notify_instance *ni, u32 evt_key) { … } /** * scmi_get_active_handler() - Helper to get active handlers only * @ni: A reference to the notification instance to use * @evt_key: The event key to use * * Search for the desired handler matching the key only in the per-protocol * table of registered handlers: this is called only from the dispatching path * so want to be as quick as possible and do not care about pending. * * Return: A properly refcounted active handler */ static struct scmi_event_handler * scmi_get_active_handler(struct scmi_notify_instance *ni, u32 evt_key) { … } /** * __scmi_enable_evt() - Enable/disable events generation * @r_evt: The registered event to act upon * @src_id: The src_id to act upon * @enable: The action to perform: true->Enable, false->Disable * * Takes care of proper refcounting while performing enable/disable: handles * the special case of ALL sources requests by itself. * Returns successfully if at least one of the required src_id has been * successfully enabled/disabled. * * Return: 0 on Success */ static inline int __scmi_enable_evt(struct scmi_registered_event *r_evt, u32 src_id, bool enable) { … } static int scmi_enable_events(struct scmi_event_handler *hndl) { … } static int scmi_disable_events(struct scmi_event_handler *hndl) { … } /** * scmi_put_handler_unlocked() - Put an event handler * @ni: A reference to the notification instance to use * @hndl: The event handler to act upon * * After having got exclusive access to the registered handlers hashtable, * update the refcount and if @hndl is no more in use by anyone: * * ask for events' generation disabling * * unregister and free the handler itself * * Context: Assumes all the proper locking has been managed by the caller. * * Return: True if handler was freed (users dropped to zero) */ static bool scmi_put_handler_unlocked(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } static void scmi_put_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } static void scmi_put_active_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { … } /** * scmi_event_handler_enable_events() - Enable events associated to an handler * @hndl: The Event handler to act upon * * Return: 0 on Success */ static int scmi_event_handler_enable_events(struct scmi_event_handler *hndl) { … } /** * scmi_notifier_register() - Register a notifier_block for an event * @handle: The handle identifying the platform instance against which the * callback is registered * @proto_id: Protocol ID * @evt_id: Event ID * @src_id: Source ID, when NULL register for events coming form ALL possible * sources * @nb: A standard notifier block to register for the specified event * * Generic helper to register a notifier_block against a protocol event. * * A notifier_block @nb will be registered for each distinct event identified * by the tuple (proto_id, evt_id, src_id) on a dedicated notification chain * so that: * * (proto_X, evt_Y, src_Z) --> chain_X_Y_Z * * @src_id meaning is protocol specific and identifies the origin of the event * (like domain_id, sensor_id and so forth). * * @src_id can be NULL to signify that the caller is interested in receiving * notifications from ALL the available sources for that protocol OR simply that * the protocol does not support distinct sources. * * As soon as one user for the specified tuple appears, an handler is created, * and that specific event's generation is enabled at the platform level, unless * an associated registered event is found missing, meaning that the needed * protocol is still to be initialized and the handler has just been registered * as still pending. * * Return: 0 on Success */ static int scmi_notifier_register(const struct scmi_handle *handle, u8 proto_id, u8 evt_id, const u32 *src_id, struct notifier_block *nb) { … } /** * scmi_notifier_unregister() - Unregister a notifier_block for an event * @handle: The handle identifying the platform instance against which the * callback is unregistered * @proto_id: Protocol ID * @evt_id: Event ID * @src_id: Source ID * @nb: The notifier_block to unregister * * Takes care to unregister the provided @nb from the notification chain * associated to the specified event and, if there are no more users for the * event handler, frees also the associated event handler structures. * (this could possibly cause disabling of event's generation at platform level) * * Return: 0 on Success */ static int scmi_notifier_unregister(const struct scmi_handle *handle, u8 proto_id, u8 evt_id, const u32 *src_id, struct notifier_block *nb) { … } struct scmi_notifier_devres { … }; static void scmi_devm_release_notifier(struct device *dev, void *res) { … } /** * scmi_devm_notifier_register() - Managed registration of a notifier_block * for an event * @sdev: A reference to an scmi_device whose embedded struct device is to * be used for devres accounting. * @proto_id: Protocol ID * @evt_id: Event ID * @src_id: Source ID, when NULL register for events coming form ALL possible * sources * @nb: A standard notifier block to register for the specified event * * Generic devres managed helper to register a notifier_block against a * protocol event. * * Return: 0 on Success */ static int scmi_devm_notifier_register(struct scmi_device *sdev, u8 proto_id, u8 evt_id, const u32 *src_id, struct notifier_block *nb) { … } static int scmi_devm_notifier_match(struct device *dev, void *res, void *data) { … } /** * scmi_devm_notifier_unregister() - Managed un-registration of a * notifier_block for an event * @sdev: A reference to an scmi_device whose embedded struct device is to * be used for devres accounting. * @nb: A standard notifier block to register for the specified event * * Generic devres managed helper to explicitly un-register a notifier_block * against a protocol event, which was previously registered using the above * @scmi_devm_notifier_register. * * Return: 0 on Success */ static int scmi_devm_notifier_unregister(struct scmi_device *sdev, struct notifier_block *nb) { … } /** * scmi_protocols_late_init() - Worker for late initialization * @work: The work item to use associated to the proper SCMI instance * * This kicks in whenever a new protocol has completed its own registration via * scmi_register_protocol_events(): it is in charge of scanning the table of * pending handlers (registered by users while the related protocol was still * not initialized) and finalizing their initialization whenever possible; * invalid pending handlers are purged at this point in time. */ static void scmi_protocols_late_init(struct work_struct *work) { … } /* * notify_ops are attached to the handle so that can be accessed * directly from an scmi_driver to register its own notifiers. */ static const struct scmi_notify_ops notify_ops = …; /** * scmi_notification_init() - Initializes Notification Core Support * @handle: The handle identifying the platform instance to initialize * * This function lays out all the basic resources needed by the notification * core instance identified by the provided handle: once done, all of the * SCMI Protocols can register their events with the core during their own * initializations. * * Note that failing to initialize the core notifications support does not * cause the whole SCMI Protocols stack to fail its initialization. * * SCMI Notification Initialization happens in 2 steps: * * initialization: basic common allocations (this function) * * registration: protocols asynchronously come into life and registers their * own supported list of events with the core; this causes * further per-protocol allocations * * Any user's callback registration attempt, referring a still not registered * event, will be registered as pending and finalized later (if possible) * by scmi_protocols_late_init() work. * This allows for lazy initialization of SCMI Protocols due to late (or * missing) SCMI drivers' modules loading. * * Return: 0 on Success */ int scmi_notification_init(struct scmi_handle *handle) { … } /** * scmi_notification_exit() - Shutdown and clean Notification core * @handle: The handle identifying the platform instance to shutdown */ void scmi_notification_exit(struct scmi_handle *handle) { … }
Codebase Browser
linux