// 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) "SCMI Notifications - " fmt #define pr_fmt(fmt) "SCMI Notifications - " fmt #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "common.h" #include "notify.h" #define SCMI_MAX_PROTO 256 #define PROTO_ID_MASK GENMASK(31, 24) #define EVT_ID_MASK GENMASK(23, 16) #define SRC_ID_MASK GENMASK(15, 0) /* * 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) \ (FIELD_PREP(PROTO_ID_MASK, (p)) | \ FIELD_PREP(EVT_ID_MASK, (e)) | \ FIELD_PREP(SRC_ID_MASK, (s))) #define MAKE_ALL_SRCS_KEY(p, e) MAKE_HASH_KEY((p), (e), SRC_ID_MASK) /* * 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) \ ({ \ typeof(__k) k_ = __k; \ typeof(__obj) obj_; \ \ hash_for_each_possible((__ht), obj_, hash, k_) \ if (obj_->key == k_) \ break; \ __obj = obj_; \ }) #define KEY_XTRACT_PROTO_ID(key) FIELD_GET(PROTO_ID_MASK, (key)) #define KEY_XTRACT_EVT_ID(key) FIELD_GET(EVT_ID_MASK, (key)) #define KEY_XTRACT_SRC_ID(key) FIELD_GET(SRC_ID_MASK, (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) \ ({ \ typeof(__ni) ni_ = __ni; \ struct scmi_registered_events_desc *__pd = NULL; \ \ if (ni_) \ __pd = READ_ONCE(ni_->registered_protocols[(__pid)]); \ __pd; \ }) #define SCMI_GET_REVT_FROM_PD(__pd, __eid) \ ({ \ typeof(__pd) pd_ = __pd; \ typeof(__eid) eid_ = __eid; \ struct scmi_registered_event *__revt = NULL; \ \ if (pd_ && eid_ < pd_->num_events) \ __revt = READ_ONCE(pd_->registered_events[eid_]); \ __revt; \ }) #define SCMI_GET_REVT(__ni, __pid, __eid) \ ({ \ struct scmi_registered_event *__revt; \ struct scmi_registered_events_desc *__pd; \ \ __pd = SCMI_GET_PROTO((__ni), (__pid)); \ __revt = SCMI_GET_REVT_FROM_PD(__pd, (__eid)); \ __revt; \ }) /* A couple of utility macros to limit cruft when calling protocols' helpers */ #define REVT_NOTIFY_SET_STATUS(revt, eid, sid, state) \ ({ \ typeof(revt) r = revt; \ r->proto->ops->set_notify_enabled(r->proto->ph, \ (eid), (sid), (state)); \ }) #define REVT_NOTIFY_ENABLE(revt, eid, sid) \ REVT_NOTIFY_SET_STATUS((revt), (eid), (sid), true) #define REVT_NOTIFY_DISABLE(revt, eid, sid) \ REVT_NOTIFY_SET_STATUS((revt), (eid), (sid), false) #define REVT_FILL_REPORT(revt, ...) \ ({ \ typeof(revt) r = revt; \ r->proto->ops->fill_custom_report(r->proto->ph, \ __VA_ARGS__); \ }) #define SCMI_PENDING_HASH_SZ 4 #define SCMI_REGISTERED_HASH_SZ 6 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 { void *gid; struct scmi_handle *handle; struct work_struct init_work; struct workqueue_struct *notify_wq; /* lock to protect pending_events_handlers */ struct mutex pending_mtx; struct scmi_registered_events_desc **registered_protocols; DECLARE_HASHTABLE(pending_events_handlers, SCMI_PENDING_HASH_SZ); }; /** * 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 { size_t sz; struct kfifo kfifo; struct work_struct notify_work; struct workqueue_struct *wq; }; /** * 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 { ktime_t timestamp; size_t payld_sz; unsigned char evt_id; unsigned char payld[]; }; 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 { u8 id; const struct scmi_event_ops *ops; struct events_queue equeue; struct scmi_notify_instance *ni; struct scmi_event_header *eh; size_t eh_sz; void *in_flight; int num_events; struct scmi_registered_event **registered_events; /* mutex to protect registered_events_handlers */ struct mutex registered_mtx; const struct scmi_protocol_handle *ph; DECLARE_HASHTABLE(registered_events_handlers, SCMI_REGISTERED_HASH_SZ); }; /** * 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_registered_events_desc *proto; const struct scmi_event *evt; void *report; u32 num_sources; refcount_t *sources; /* locking to serialize the access to sources */ struct mutex sources_mtx; }; /** * 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 { u32 key; refcount_t users; struct scmi_registered_event *r_evt; struct blocking_notifier_head chain; struct hlist_node hash; bool enabled; }; #define IS_HNDL_PENDING(hndl) (!(hndl)->r_evt) 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) { int ret; struct scmi_event_handler *hndl; /* * Here ensure the event handler cannot vanish while using it. * It is legitimate, though, for an handler not to be found at all here, * e.g. when it has been unregistered by the user after some events had * already been queued. */ hndl = scmi_get_active_handler(ni, evt_key); if (!hndl) return; ret = blocking_notifier_call_chain(&hndl->chain, KEY_XTRACT_EVT_ID(evt_key), report); /* Notifiers are NOT supposed to cut the chain ... */ WARN_ON_ONCE(ret & NOTIFY_STOP_MASK); scmi_put_active_handler(ni, hndl); } /** * 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) { unsigned int outs; struct scmi_registered_event *r_evt; outs = kfifo_out(&eq->kfifo, pd->eh, sizeof(struct scmi_event_header)); if (!outs) return NULL; if (outs != sizeof(struct scmi_event_header)) { dev_err(pd->ni->handle->dev, "corrupted EVT header. Flush.\n"); kfifo_reset_out(&eq->kfifo); return NULL; } r_evt = SCMI_GET_REVT_FROM_PD(pd, pd->eh->evt_id); if (!r_evt) r_evt = ERR_PTR(-EINVAL); return r_evt; } /** * 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) { u32 src_id, key; unsigned int outs; void *report = NULL; outs = kfifo_out(&eq->kfifo, pd->eh->payld, pd->eh->payld_sz); if (!outs) return false; /* Any in-flight event has now been officially processed */ pd->in_flight = NULL; if (outs != pd->eh->payld_sz) { dev_err(pd->ni->handle->dev, "corrupted EVT Payload. Flush.\n"); kfifo_reset_out(&eq->kfifo); return false; } if (IS_ERR(r_evt)) { dev_warn(pd->ni->handle->dev, "SKIP UNKNOWN EVT - proto:%X evt:%d\n", pd->id, pd->eh->evt_id); return true; } report = REVT_FILL_REPORT(r_evt, pd->eh->evt_id, pd->eh->timestamp, pd->eh->payld, pd->eh->payld_sz, r_evt->report, &src_id); if (!report) { dev_err(pd->ni->handle->dev, "report not available - proto:%X evt:%d\n", pd->id, pd->eh->evt_id); return true; } /* At first search for a generic ALL src_ids handler... */ key = MAKE_ALL_SRCS_KEY(pd->id, pd->eh->evt_id); scmi_lookup_and_call_event_chain(pd->ni, key, report); /* ...then search for any specific src_id */ key = MAKE_HASH_KEY(pd->id, pd->eh->evt_id, src_id); scmi_lookup_and_call_event_chain(pd->ni, key, report); return true; } /** * 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) { struct events_queue *eq; struct scmi_registered_events_desc *pd; struct scmi_registered_event *r_evt; eq = container_of(work, struct events_queue, notify_work); pd = container_of(eq, struct scmi_registered_events_desc, equeue); /* * In order to keep the queue lock-less and the number of memcopies * to the bare minimum needed, the dispatcher accounts for the * possibility of per-protocol in-flight events: i.e. an event whose * reception could end up being split across two subsequent runs of this * worker, first the header, then the payload. */ do { if (!pd->in_flight) { r_evt = scmi_process_event_header(eq, pd); if (!r_evt) break; pd->in_flight = r_evt; } else { r_evt = pd->in_flight; } } while (scmi_process_event_payload(eq, pd, r_evt)); } /** * 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) { struct scmi_registered_event *r_evt; struct scmi_event_header eh; struct scmi_notify_instance *ni; ni = scmi_notification_instance_data_get(handle); if (!ni) return 0; r_evt = SCMI_GET_REVT(ni, proto_id, evt_id); if (!r_evt) return -EINVAL; if (len > r_evt->evt->max_payld_sz) { dev_err(handle->dev, "discard badly sized message\n"); return -EINVAL; } if (kfifo_avail(&r_evt->proto->equeue.kfifo) < sizeof(eh) + len) { dev_warn(handle->dev, "queue full, dropping proto_id:%d evt_id:%d ts:%lld\n", proto_id, evt_id, ktime_to_ns(ts)); return -ENOMEM; } eh.timestamp = ts; eh.evt_id = evt_id; eh.payld_sz = len; /* * Header and payload are enqueued with two distinct kfifo_in() (so non * atomic), but this situation is handled properly on the consumer side * with in-flight events tracking. */ kfifo_in(&r_evt->proto->equeue.kfifo, &eh, sizeof(eh)); kfifo_in(&r_evt->proto->equeue.kfifo, buf, len); /* * Don't care about return value here since we just want to ensure that * a work is queued all the times whenever some items have been pushed * on the kfifo: * - if work was already queued it will simply fail to queue a new one * since it is not needed * - if work was not queued already it will be now, even in case work * was in fact already running: this behavior avoids any possible race * when this function pushes new items onto the kfifos after the * related executing worker had already determined the kfifo to be * empty and it was terminating. */ queue_work(r_evt->proto->equeue.wq, &r_evt->proto->equeue.notify_work); return 0; } /** * scmi_kfifo_free() - Devres action helper to free the kfifo * @kfifo: The kfifo to free */ static void scmi_kfifo_free(void *kfifo) { kfifo_free((struct kfifo *)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) { int ret; if (kfifo_alloc(&equeue->kfifo, sz, GFP_KERNEL)) return -ENOMEM; /* Size could have been roundup to power-of-two */ equeue->sz = kfifo_size(&equeue->kfifo); ret = devm_add_action_or_reset(ni->handle->dev, scmi_kfifo_free, &equeue->kfifo); if (ret) return ret; INIT_WORK(&equeue->notify_work, scmi_events_dispatcher); equeue->wq = ni->notify_wq; return ret; } /** * 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) { int ret; struct scmi_registered_events_desc *pd; /* Ensure protocols are up to date */ smp_rmb(); if (WARN_ON(ni->registered_protocols[proto_id])) return ERR_PTR(-EINVAL); pd = devm_kzalloc(ni->handle->dev, sizeof(*pd), GFP_KERNEL); if (!pd) return ERR_PTR(-ENOMEM); pd->id = proto_id; pd->ops = ops; pd->ni = ni; ret = scmi_initialize_events_queue(ni, &pd->equeue, queue_sz); if (ret) return ERR_PTR(ret); pd->eh = devm_kzalloc(ni->handle->dev, eh_sz, GFP_KERNEL); if (!pd->eh) return ERR_PTR(-ENOMEM); pd->eh_sz = eh_sz; pd->registered_events = devm_kcalloc(ni->handle->dev, num_events, sizeof(char *), GFP_KERNEL); if (!pd->registered_events) return ERR_PTR(-ENOMEM); pd->num_events = num_events; /* Initialize per protocol handlers table */ mutex_init(&pd->registered_mtx); hash_init(pd->registered_events_handlers); return pd; } /** * 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) { int i; unsigned int num_sources; size_t payld_sz = 0; struct scmi_registered_events_desc *pd; struct scmi_notify_instance *ni; const struct scmi_event *evt; if (!ee || !ee->ops || !ee->evts || !ph || (!ee->num_sources && !ee->ops->get_num_sources)) return -EINVAL; ni = scmi_notification_instance_data_get(handle); if (!ni) return -ENOMEM; /* num_sources cannot be <= 0 */ if (ee->num_sources) { num_sources = ee->num_sources; } else { int nsrc = ee->ops->get_num_sources(ph); if (nsrc <= 0) return -EINVAL; num_sources = nsrc; } evt = ee->evts; for (i = 0; i < ee->num_events; i++) payld_sz = max_t(size_t, payld_sz, evt[i].max_payld_sz); payld_sz += sizeof(struct scmi_event_header); pd = scmi_allocate_registered_events_desc(ni, proto_id, ee->queue_sz, payld_sz, ee->num_events, ee->ops); if (IS_ERR(pd)) return PTR_ERR(pd); pd->ph = ph; for (i = 0; i < ee->num_events; i++, evt++) { struct scmi_registered_event *r_evt; r_evt = devm_kzalloc(ni->handle->dev, sizeof(*r_evt), GFP_KERNEL); if (!r_evt) return -ENOMEM; r_evt->proto = pd; r_evt->evt = evt; r_evt->sources = devm_kcalloc(ni->handle->dev, num_sources, sizeof(refcount_t), GFP_KERNEL); if (!r_evt->sources) return -ENOMEM; r_evt->num_sources = num_sources; mutex_init(&r_evt->sources_mtx); r_evt->report = devm_kzalloc(ni->handle->dev, evt->max_report_sz, GFP_KERNEL); if (!r_evt->report) return -ENOMEM; pd->registered_events[i] = r_evt; /* Ensure events are updated */ smp_wmb(); dev_dbg(handle->dev, "registered event - %lX\n", MAKE_ALL_SRCS_KEY(r_evt->proto->id, r_evt->evt->id)); } /* Register protocol and events...it will never be removed */ ni->registered_protocols[proto_id] = pd; /* Ensure protocols are updated */ smp_wmb(); /* * Finalize any pending events' handler which could have been waiting * for this protocol's events registration. */ schedule_work(&ni->init_work); return 0; } /** * 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) { struct scmi_notify_instance *ni; struct scmi_registered_events_desc *pd; ni = scmi_notification_instance_data_get(handle); if (!ni) return; pd = ni->registered_protocols[proto_id]; if (!pd) return; ni->registered_protocols[proto_id] = NULL; /* Ensure protocols are updated */ smp_wmb(); cancel_work_sync(&pd->equeue.notify_work); } /** * 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) { struct scmi_event_handler *hndl; hndl = kzalloc(sizeof(*hndl), GFP_KERNEL); if (!hndl) return NULL; hndl->key = evt_key; BLOCKING_INIT_NOTIFIER_HEAD(&hndl->chain); refcount_set(&hndl->users, 1); /* New handlers are created pending */ hash_add(ni->pending_events_handlers, &hndl->hash, hndl->key); return hndl; } /** * 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) { hash_del(&hndl->hash); kfree(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) { struct scmi_registered_event *r_evt; r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(hndl->key), KEY_XTRACT_EVT_ID(hndl->key)); if (!r_evt) return -EINVAL; /* * Remove from pending and insert into registered while getting hold * of protocol instance. */ hash_del(&hndl->hash); /* * Acquire protocols only for NON pending handlers, so as NOT to trigger * protocol initialization when a notifier is registered against a still * not registered protocol, since it would make little sense to force init * protocols for which still no SCMI driver user exists: they wouldn't * emit any event anyway till some SCMI driver starts using it. */ scmi_protocol_acquire(ni->handle, KEY_XTRACT_PROTO_ID(hndl->key)); hndl->r_evt = r_evt; mutex_lock(&r_evt->proto->registered_mtx); hash_add(r_evt->proto->registered_events_handlers, &hndl->hash, hndl->key); mutex_unlock(&r_evt->proto->registered_mtx); return 0; } /** * 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) { struct scmi_registered_events_desc *pd; if (!IS_HNDL_PENDING(hndl)) return -EINVAL; pd = SCMI_GET_PROTO(ni, KEY_XTRACT_PROTO_ID(hndl->key)); if (pd) return -EINVAL; return 0; } /** * 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) { int ret; ret = scmi_bind_event_handler(ni, hndl); if (!ret) { dev_dbg(ni->handle->dev, "registered NEW handler - key:%X\n", hndl->key); } else { ret = scmi_valid_pending_handler(ni, hndl); if (!ret) dev_dbg(ni->handle->dev, "registered PENDING handler - key:%X\n", hndl->key); } return ret; } /** * __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) { struct scmi_registered_event *r_evt; struct scmi_event_handler *hndl = NULL; r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(evt_key), KEY_XTRACT_EVT_ID(evt_key)); mutex_lock(&ni->pending_mtx); /* Search registered events at first ... if possible at all */ if (r_evt) { mutex_lock(&r_evt->proto->registered_mtx); hndl = KEY_FIND(r_evt->proto->registered_events_handlers, hndl, evt_key); if (hndl) refcount_inc(&hndl->users); mutex_unlock(&r_evt->proto->registered_mtx); } /* ...then amongst pending. */ if (!hndl) { hndl = KEY_FIND(ni->pending_events_handlers, hndl, evt_key); if (hndl) refcount_inc(&hndl->users); } /* Create if still not found and required */ if (!hndl && create) { hndl = scmi_allocate_event_handler(ni, evt_key); if (hndl && scmi_register_event_handler(ni, hndl)) { dev_dbg(ni->handle->dev, "purging UNKNOWN handler - key:%X\n", hndl->key); /* this hndl can be only a pending one */ scmi_put_handler_unlocked(ni, hndl); hndl = NULL; } } mutex_unlock(&ni->pending_mtx); return hndl; } static struct scmi_event_handler * scmi_get_handler(struct scmi_notify_instance *ni, u32 evt_key) { return __scmi_event_handler_get_ops(ni, evt_key, false); } static struct scmi_event_handler * scmi_get_or_create_handler(struct scmi_notify_instance *ni, u32 evt_key) { return __scmi_event_handler_get_ops(ni, evt_key, true); } /** * 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) { struct scmi_registered_event *r_evt; struct scmi_event_handler *hndl = NULL; r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(evt_key), KEY_XTRACT_EVT_ID(evt_key)); if (r_evt) { mutex_lock(&r_evt->proto->registered_mtx); hndl = KEY_FIND(r_evt->proto->registered_events_handlers, hndl, evt_key); if (hndl) refcount_inc(&hndl->users); mutex_unlock(&r_evt->proto->registered_mtx); } return hndl; } /** * __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) { int retvals = 0; u32 num_sources; refcount_t *sid; if (src_id == SRC_ID_MASK) { src_id = 0; num_sources = r_evt->num_sources; } else if (src_id < r_evt->num_sources) { num_sources = 1; } else { return -EINVAL; } mutex_lock(&r_evt->sources_mtx); if (enable) { for (; num_sources; src_id++, num_sources--) { int ret = 0; sid = &r_evt->sources[src_id]; if (refcount_read(sid) == 0) { ret = REVT_NOTIFY_ENABLE(r_evt, r_evt->evt->id, src_id); if (!ret) refcount_set(sid, 1); } else { refcount_inc(sid); } retvals += !ret; } } else { for (; num_sources; src_id++, num_sources--) { sid = &r_evt->sources[src_id]; if (refcount_dec_and_test(sid)) REVT_NOTIFY_DISABLE(r_evt, r_evt->evt->id, src_id); } retvals = 1; } mutex_unlock(&r_evt->sources_mtx); return retvals ? 0 : -EINVAL; } static int scmi_enable_events(struct scmi_event_handler *hndl) { int ret = 0; if (!hndl->enabled) { ret = __scmi_enable_evt(hndl->r_evt, KEY_XTRACT_SRC_ID(hndl->key), true); if (!ret) hndl->enabled = true; } return ret; } static int scmi_disable_events(struct scmi_event_handler *hndl) { int ret = 0; if (hndl->enabled) { ret = __scmi_enable_evt(hndl->r_evt, KEY_XTRACT_SRC_ID(hndl->key), false); if (!ret) hndl->enabled = false; } return ret; } /** * 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) { bool freed = false; if (refcount_dec_and_test(&hndl->users)) { if (!IS_HNDL_PENDING(hndl)) scmi_disable_events(hndl); scmi_free_event_handler(hndl); freed = true; } return freed; } static void scmi_put_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { bool freed; u8 protocol_id; struct scmi_registered_event *r_evt = hndl->r_evt; mutex_lock(&ni->pending_mtx); if (r_evt) { protocol_id = r_evt->proto->id; mutex_lock(&r_evt->proto->registered_mtx); } freed = scmi_put_handler_unlocked(ni, hndl); if (r_evt) { mutex_unlock(&r_evt->proto->registered_mtx); /* * Only registered handler acquired protocol; must be here * released only AFTER unlocking registered_mtx, since * releasing a protocol can trigger its de-initialization * (ie. including r_evt and registered_mtx) */ if (freed) scmi_protocol_release(ni->handle, protocol_id); } mutex_unlock(&ni->pending_mtx); } static void scmi_put_active_handler(struct scmi_notify_instance *ni, struct scmi_event_handler *hndl) { bool freed; struct scmi_registered_event *r_evt = hndl->r_evt; u8 protocol_id = r_evt->proto->id; mutex_lock(&r_evt->proto->registered_mtx); freed = scmi_put_handler_unlocked(ni, hndl); mutex_unlock(&r_evt->proto->registered_mtx); if (freed) scmi_protocol_release(ni->handle, protocol_id); } /** * 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) { if (scmi_enable_events(hndl)) { pr_err("Failed to ENABLE events for key:%X !\n", hndl->key); return -EINVAL; } return 0; } /** * 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) { int ret = 0; u32 evt_key; struct scmi_event_handler *hndl; struct scmi_notify_instance *ni; ni = scmi_notification_instance_data_get(handle); if (!ni) return -ENODEV; evt_key = MAKE_HASH_KEY(proto_id, evt_id, src_id ? *src_id : SRC_ID_MASK); hndl = scmi_get_or_create_handler(ni, evt_key); if (!hndl) return -EINVAL; blocking_notifier_chain_register(&hndl->chain, nb); /* Enable events for not pending handlers */ if (!IS_HNDL_PENDING(hndl)) { ret = scmi_event_handler_enable_events(hndl); if (ret) scmi_put_handler(ni, hndl); } return ret; } /** * 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) { u32 evt_key; struct scmi_event_handler *hndl; struct scmi_notify_instance *ni; ni = scmi_notification_instance_data_get(handle); if (!ni) return -ENODEV; evt_key = MAKE_HASH_KEY(proto_id, evt_id, src_id ? *src_id : SRC_ID_MASK); hndl = scmi_get_handler(ni, evt_key); if (!hndl) return -EINVAL; /* * Note that this chain unregistration call is safe on its own * being internally protected by an rwsem. */ blocking_notifier_chain_unregister(&hndl->chain, nb); scmi_put_handler(ni, hndl); /* * This balances the initial get issued in @scmi_notifier_register. * If this notifier_block happened to be the last known user callback * for this event, the handler is here freed and the event's generation * stopped. * * Note that, an ongoing concurrent lookup on the delivery workqueue * path could still hold the refcount to 1 even after this routine * completes: in such a case it will be the final put on the delivery * path which will finally free this unused handler. */ scmi_put_handler(ni, hndl); return 0; } struct scmi_notifier_devres { const struct scmi_handle *handle; u8 proto_id; u8 evt_id; u32 __src_id; u32 *src_id; struct notifier_block *nb; }; static void scmi_devm_release_notifier(struct device *dev, void *res) { struct scmi_notifier_devres *dres = res; scmi_notifier_unregister(dres->handle, dres->proto_id, dres->evt_id, dres->src_id, dres->nb); } /** * 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. */ static int scmi_devm_notifier_register(struct scmi_device *sdev, u8 proto_id, u8 evt_id, const u32 *src_id, struct notifier_block *nb) { int ret; struct scmi_notifier_devres *dres; dres = devres_alloc(scmi_devm_release_notifier, sizeof(*dres), GFP_KERNEL); if (!dres) return -ENOMEM; ret = scmi_notifier_register(sdev->handle, proto_id, evt_id, src_id, nb); if (ret) { devres_free(dres); return ret; } dres->handle = sdev->handle; dres->proto_id = proto_id; dres->evt_id = evt_id; dres->nb = nb; if (src_id) { dres->__src_id = *src_id; dres->src_id = &dres->__src_id; } else { dres->src_id = NULL; } devres_add(&sdev->dev, dres); return ret; } static int scmi_devm_notifier_match(struct device *dev, void *res, void *data) { struct scmi_notifier_devres *dres = res; struct scmi_notifier_devres *xres = data; if (WARN_ON(!dres || !xres)) return 0; return dres->proto_id == xres->proto_id && dres->evt_id == xres->evt_id && dres->nb == xres->nb && ((!dres->src_id && !xres->src_id) || (dres->src_id && xres->src_id && dres->__src_id == xres->__src_id)); } /** * 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. * @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 explicitly un-register a notifier_block * against a protocol event, which was previously registered using the above * @scmi_devm_notifier_register. */ static int scmi_devm_notifier_unregister(struct scmi_device *sdev, u8 proto_id, u8 evt_id, const u32 *src_id, struct notifier_block *nb) { int ret; struct scmi_notifier_devres dres; dres.handle = sdev->handle; dres.proto_id = proto_id; dres.evt_id = evt_id; if (src_id) { dres.__src_id = *src_id; dres.src_id = &dres.__src_id; } else { dres.src_id = NULL; } ret = devres_release(&sdev->dev, scmi_devm_release_notifier, scmi_devm_notifier_match, &dres); WARN_ON(ret); return ret; } /** * 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) { int bkt; struct scmi_event_handler *hndl; struct scmi_notify_instance *ni; struct hlist_node *tmp; ni = container_of(work, struct scmi_notify_instance, init_work); /* Ensure protocols and events are up to date */ smp_rmb(); mutex_lock(&ni->pending_mtx); hash_for_each_safe(ni->pending_events_handlers, bkt, tmp, hndl, hash) { int ret; ret = scmi_bind_event_handler(ni, hndl); if (!ret) { dev_dbg(ni->handle->dev, "finalized PENDING handler - key:%X\n", hndl->key); ret = scmi_event_handler_enable_events(hndl); if (ret) { dev_dbg(ni->handle->dev, "purging INVALID handler - key:%X\n", hndl->key); scmi_put_active_handler(ni, hndl); } } else { ret = scmi_valid_pending_handler(ni, hndl); if (ret) { dev_dbg(ni->handle->dev, "purging PENDING handler - key:%X\n", hndl->key); /* this hndl can be only a pending one */ scmi_put_handler_unlocked(ni, hndl); } } } mutex_unlock(&ni->pending_mtx); } /* * 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 = { .devm_event_notifier_register = scmi_devm_notifier_register, .devm_event_notifier_unregister = scmi_devm_notifier_unregister, .event_notifier_register = scmi_notifier_register, .event_notifier_unregister = scmi_notifier_unregister, }; /** * 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) { void *gid; struct scmi_notify_instance *ni; gid = devres_open_group(handle->dev, NULL, GFP_KERNEL); if (!gid) return -ENOMEM; ni = devm_kzalloc(handle->dev, sizeof(*ni), GFP_KERNEL); if (!ni) goto err; ni->gid = gid; ni->handle = handle; ni->registered_protocols = devm_kcalloc(handle->dev, SCMI_MAX_PROTO, sizeof(char *), GFP_KERNEL); if (!ni->registered_protocols) goto err; ni->notify_wq = alloc_workqueue(dev_name(handle->dev), WQ_UNBOUND | WQ_FREEZABLE | WQ_SYSFS, 0); if (!ni->notify_wq) goto err; mutex_init(&ni->pending_mtx); hash_init(ni->pending_events_handlers); INIT_WORK(&ni->init_work, scmi_protocols_late_init); scmi_notification_instance_data_set(handle, ni); handle->notify_ops = ¬ify_ops; /* Ensure handle is up to date */ smp_wmb(); dev_info(handle->dev, "Core Enabled.\n"); devres_close_group(handle->dev, ni->gid); return 0; err: dev_warn(handle->dev, "Initialization Failed.\n"); devres_release_group(handle->dev, gid); return -ENOMEM; } /** * 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) { struct scmi_notify_instance *ni; ni = scmi_notification_instance_data_get(handle); if (!ni) return; scmi_notification_instance_data_set(handle, NULL); /* Destroy while letting pending work complete */ destroy_workqueue(ni->notify_wq); devres_release_group(ni->handle->dev, ni->gid); }