1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * System Control and Management Interface (SCMI) Notification support
   4 *
   5 * Copyright (C) 2020 ARM Ltd.
   6 */
   7/**
   8 * DOC: Theory of operation
   9 *
  10 * SCMI Protocol specification allows the platform to signal events to
  11 * interested agents via notification messages: this is an implementation
  12 * of the dispatch and delivery of such notifications to the interested users
  13 * inside the Linux kernel.
  14 *
  15 * An SCMI Notification core instance is initialized for each active platform
  16 * instance identified by the means of the usual &struct scmi_handle.
  17 *
  18 * Each SCMI Protocol implementation, during its initialization, registers with
  19 * this core its set of supported events using scmi_register_protocol_events():
  20 * all the needed descriptors are stored in the &struct registered_protocols and
  21 * &struct registered_events arrays.
  22 *
  23 * Kernel users interested in some specific event can register their callbacks
  24 * providing the usual notifier_block descriptor, since this core implements
  25 * events' delivery using the standard Kernel notification chains machinery.
  26 *
  27 * Given the number of possible events defined by SCMI and the extensibility
  28 * of the SCMI Protocol itself, the underlying notification chains are created
  29 * and destroyed dynamically on demand depending on the number of users
  30 * effectively registered for an event, so that no support structures or chains
  31 * are allocated until at least one user has registered a notifier_block for
  32 * such event. Similarly, events' generation itself is enabled at the platform
  33 * level only after at least one user has registered, and it is shutdown after
  34 * the last user for that event has gone.
  35 *
  36 * All users provided callbacks and allocated notification-chains are stored in
  37 * the @registered_events_handlers hashtable. Callbacks' registration requests
  38 * for still to be registered events are instead kept in the dedicated common
  39 * hashtable @pending_events_handlers.
  40 *
  41 * An event is identified univocally by the tuple (proto_id, evt_id, src_id)
  42 * and is served by its own dedicated notification chain; information contained
  43 * in such tuples is used, in a few different ways, to generate the needed
  44 * hash-keys.
  45 *
  46 * Here proto_id and evt_id are simply the protocol_id and message_id numbers
  47 * as described in the SCMI Protocol specification, while src_id represents an
  48 * optional, protocol dependent, source identifier (like domain_id, perf_id
  49 * or sensor_id and so forth).
  50 *
  51 * Upon reception of a notification message from the platform the SCMI RX ISR
  52 * passes the received message payload and some ancillary information (including
  53 * an arrival timestamp in nanoseconds) to the core via @scmi_notify() which
  54 * pushes the event-data itself on a protocol-dedicated kfifo queue for further
  55 * deferred processing as specified in @scmi_events_dispatcher().
  56 *
  57 * Each protocol has it own dedicated work_struct and worker which, once kicked
  58 * by the ISR, takes care to empty its own dedicated queue, deliverying the
  59 * queued items into the proper notification-chain: notifications processing can
  60 * proceed concurrently on distinct workers only between events belonging to
  61 * different protocols while delivery of events within the same protocol is
  62 * still strictly sequentially ordered by time of arrival.
  63 *
  64 * Events' information is then extracted from the SCMI Notification messages and
  65 * conveyed, converted into a custom per-event report struct, as the void *data
  66 * param to the user callback provided by the registered notifier_block, so that
  67 * from the user perspective his callback will look invoked like:
  68 *
  69 * int user_cb(struct notifier_block *nb, unsigned long event_id, void *report)
  70 *
  71 */
  72
  73#define dev_fmt(fmt) "SCMI Notifications - " fmt
  74#define pr_fmt(fmt) "SCMI Notifications - " fmt
  75
  76#include <linux/bitfield.h>
  77#include <linux/bug.h>
  78#include <linux/compiler.h>
  79#include <linux/device.h>
  80#include <linux/err.h>
  81#include <linux/hashtable.h>
  82#include <linux/kernel.h>
  83#include <linux/ktime.h>
  84#include <linux/kfifo.h>
  85#include <linux/list.h>
  86#include <linux/mutex.h>
  87#include <linux/notifier.h>
  88#include <linux/refcount.h>
  89#include <linux/scmi_protocol.h>
  90#include <linux/slab.h>
  91#include <linux/types.h>
  92#include <linux/workqueue.h>
  93
 
  94#include "notify.h"
  95
  96#define SCMI_MAX_PROTO		256
  97
  98#define PROTO_ID_MASK		GENMASK(31, 24)
  99#define EVT_ID_MASK		GENMASK(23, 16)
 100#define SRC_ID_MASK		GENMASK(15, 0)
 101
 102/*
 103 * Builds an unsigned 32bit key from the given input tuple to be used
 104 * as a key in hashtables.
 105 */
 106#define MAKE_HASH_KEY(p, e, s)			\
 107	(FIELD_PREP(PROTO_ID_MASK, (p)) |	\
 108	   FIELD_PREP(EVT_ID_MASK, (e)) |	\
 109	   FIELD_PREP(SRC_ID_MASK, (s)))
 110
 111#define MAKE_ALL_SRCS_KEY(p, e)		MAKE_HASH_KEY((p), (e), SRC_ID_MASK)
 112
 113/*
 114 * Assumes that the stored obj includes its own hash-key in a field named 'key':
 115 * with this simplification this macro can be equally used for all the objects'
 116 * types hashed by this implementation.
 117 *
 118 * @__ht: The hashtable name
 119 * @__obj: A pointer to the object type to be retrieved from the hashtable;
 120 *	   it will be used as a cursor while scanning the hastable and it will
 121 *	   be possibly left as NULL when @__k is not found
 122 * @__k: The key to search for
 123 */
 124#define KEY_FIND(__ht, __obj, __k)				\
 125({								\
 126	typeof(__k) k_ = __k;					\
 127	typeof(__obj) obj_;					\
 128								\
 129	hash_for_each_possible((__ht), obj_, hash, k_)		\
 130		if (obj_->key == k_)				\
 131			break;					\
 132	__obj = obj_;						\
 133})
 134
 135#define KEY_XTRACT_PROTO_ID(key)	FIELD_GET(PROTO_ID_MASK, (key))
 136#define KEY_XTRACT_EVT_ID(key)		FIELD_GET(EVT_ID_MASK, (key))
 137#define KEY_XTRACT_SRC_ID(key)		FIELD_GET(SRC_ID_MASK, (key))
 138
 139/*
 140 * A set of macros used to access safely @registered_protocols and
 141 * @registered_events arrays; these are fixed in size and each entry is possibly
 142 * populated at protocols' registration time and then only read but NEVER
 143 * modified or removed.
 144 */
 145#define SCMI_GET_PROTO(__ni, __pid)					\
 146({									\
 147	typeof(__ni) ni_ = __ni;					\
 148	struct scmi_registered_events_desc *__pd = NULL;		\
 149									\
 150	if (ni_)							\
 151		__pd = READ_ONCE(ni_->registered_protocols[(__pid)]);	\
 152	__pd;								\
 153})
 154
 155#define SCMI_GET_REVT_FROM_PD(__pd, __eid)				\
 156({									\
 157	typeof(__pd) pd_ = __pd;					\
 158	typeof(__eid) eid_ = __eid;					\
 159	struct scmi_registered_event *__revt = NULL;			\
 160									\
 161	if (pd_ && eid_ < pd_->num_events)				\
 162		__revt = READ_ONCE(pd_->registered_events[eid_]);	\
 163	__revt;								\
 164})
 165
 166#define SCMI_GET_REVT(__ni, __pid, __eid)				\
 167({									\
 168	struct scmi_registered_event *__revt;				\
 169	struct scmi_registered_events_desc *__pd;			\
 170									\
 171	__pd = SCMI_GET_PROTO((__ni), (__pid));				\
 172	__revt = SCMI_GET_REVT_FROM_PD(__pd, (__eid));			\
 173	__revt;								\
 174})
 175
 176/* A couple of utility macros to limit cruft when calling protocols' helpers */
 177#define REVT_NOTIFY_SET_STATUS(revt, eid, sid, state)		\
 178({								\
 179	typeof(revt) r = revt;					\
 180	r->proto->ops->set_notify_enabled(r->proto->ni->handle,	\
 181					(eid), (sid), (state));	\
 182})
 183
 184#define REVT_NOTIFY_ENABLE(revt, eid, sid)			\
 185	REVT_NOTIFY_SET_STATUS((revt), (eid), (sid), true)
 186
 187#define REVT_NOTIFY_DISABLE(revt, eid, sid)			\
 188	REVT_NOTIFY_SET_STATUS((revt), (eid), (sid), false)
 189
 190#define REVT_FILL_REPORT(revt, ...)				\
 191({								\
 192	typeof(revt) r = revt;					\
 193	r->proto->ops->fill_custom_report(r->proto->ni->handle,	\
 194					  __VA_ARGS__);		\
 195})
 196
 197#define SCMI_PENDING_HASH_SZ		4
 198#define SCMI_REGISTERED_HASH_SZ		6
 199
 200struct scmi_registered_events_desc;
 201
 202/**
 203 * struct scmi_notify_instance  - Represents an instance of the notification
 204 * core
 205 * @gid: GroupID used for devres
 206 * @handle: A reference to the platform instance
 207 * @init_work: A work item to perform final initializations of pending handlers
 208 * @notify_wq: A reference to the allocated Kernel cmwq
 209 * @pending_mtx: A mutex to protect @pending_events_handlers
 210 * @registered_protocols: A statically allocated array containing pointers to
 211 *			  all the registered protocol-level specific information
 212 *			  related to events' handling
 213 * @pending_events_handlers: An hashtable containing all pending events'
 214 *			     handlers descriptors
 215 *
 216 * Each platform instance, represented by a handle, has its own instance of
 217 * the notification subsystem represented by this structure.
 218 */
 219struct scmi_notify_instance {
 220	void			*gid;
 221	struct scmi_handle	*handle;
 222	struct work_struct	init_work;
 223	struct workqueue_struct	*notify_wq;
 224	/* lock to protect pending_events_handlers */
 225	struct mutex		pending_mtx;
 226	struct scmi_registered_events_desc	**registered_protocols;
 227	DECLARE_HASHTABLE(pending_events_handlers, SCMI_PENDING_HASH_SZ);
 228};
 229
 230/**
 231 * struct events_queue  - Describes a queue and its associated worker
 232 * @sz: Size in bytes of the related kfifo
 233 * @kfifo: A dedicated Kernel kfifo descriptor
 234 * @notify_work: A custom work item bound to this queue
 235 * @wq: A reference to the associated workqueue
 236 *
 237 * Each protocol has its own dedicated events_queue descriptor.
 238 */
 239struct events_queue {
 240	size_t			sz;
 241	struct kfifo		kfifo;
 242	struct work_struct	notify_work;
 243	struct workqueue_struct	*wq;
 244};
 245
 246/**
 247 * struct scmi_event_header  - A utility header
 248 * @timestamp: The timestamp, in nanoseconds (boottime), which was associated
 249 *	       to this event as soon as it entered the SCMI RX ISR
 250 * @payld_sz: Effective size of the embedded message payload which follows
 251 * @evt_id: Event ID (corresponds to the Event MsgID for this Protocol)
 252 * @payld: A reference to the embedded event payload
 253 *
 254 * This header is prepended to each received event message payload before
 255 * queueing it on the related &struct events_queue.
 256 */
 257struct scmi_event_header {
 258	ktime_t timestamp;
 259	size_t payld_sz;
 260	unsigned char evt_id;
 261	unsigned char payld[];
 262};
 263
 264struct scmi_registered_event;
 265
 266/**
 267 * struct scmi_registered_events_desc  - Protocol Specific information
 268 * @id: Protocol ID
 269 * @ops: Protocol specific and event-related operations
 270 * @equeue: The embedded per-protocol events_queue
 271 * @ni: A reference to the initialized instance descriptor
 272 * @eh: A reference to pre-allocated buffer to be used as a scratch area by the
 273 *	deferred worker when fetching data from the kfifo
 274 * @eh_sz: Size of the pre-allocated buffer @eh
 275 * @in_flight: A reference to an in flight &struct scmi_registered_event
 276 * @num_events: Number of events in @registered_events
 277 * @registered_events: A dynamically allocated array holding all the registered
 278 *		       events' descriptors, whose fixed-size is determined at
 279 *		       compile time.
 280 * @registered_mtx: A mutex to protect @registered_events_handlers
 
 281 * @registered_events_handlers: An hashtable containing all events' handlers
 282 *				descriptors registered for this protocol
 283 *
 284 * All protocols that register at least one event have their protocol-specific
 285 * information stored here, together with the embedded allocated events_queue.
 286 * These descriptors are stored in the @registered_protocols array at protocol
 287 * registration time.
 288 *
 289 * Once these descriptors are successfully registered, they are NEVER again
 290 * removed or modified since protocols do not unregister ever, so that, once
 291 * we safely grab a NON-NULL reference from the array we can keep it and use it.
 292 */
 293struct scmi_registered_events_desc {
 294	u8				id;
 295	const struct scmi_event_ops	*ops;
 296	struct events_queue		equeue;
 297	struct scmi_notify_instance	*ni;
 298	struct scmi_event_header	*eh;
 299	size_t				eh_sz;
 300	void				*in_flight;
 301	int				num_events;
 302	struct scmi_registered_event	**registered_events;
 303	/* mutex to protect registered_events_handlers */
 304	struct mutex			registered_mtx;
 
 305	DECLARE_HASHTABLE(registered_events_handlers, SCMI_REGISTERED_HASH_SZ);
 306};
 307
 308/**
 309 * struct scmi_registered_event  - Event Specific Information
 310 * @proto: A reference to the associated protocol descriptor
 311 * @evt: A reference to the associated event descriptor (as provided at
 312 *       registration time)
 313 * @report: A pre-allocated buffer used by the deferred worker to fill a
 314 *	    customized event report
 315 * @num_sources: The number of possible sources for this event as stated at
 316 *		 events' registration time
 317 * @sources: A reference to a dynamically allocated array used to refcount the
 318 *	     events' enable requests for all the existing sources
 319 * @sources_mtx: A mutex to serialize the access to @sources
 320 *
 321 * All registered events are represented by one of these structures that are
 322 * stored in the @registered_events array at protocol registration time.
 323 *
 324 * Once these descriptors are successfully registered, they are NEVER again
 325 * removed or modified since protocols do not unregister ever, so that once we
 326 * safely grab a NON-NULL reference from the table we can keep it and use it.
 327 */
 328struct scmi_registered_event {
 329	struct scmi_registered_events_desc *proto;
 330	const struct scmi_event	*evt;
 331	void		*report;
 332	u32		num_sources;
 333	refcount_t	*sources;
 334	/* locking to serialize the access to sources */
 335	struct mutex	sources_mtx;
 336};
 337
 338/**
 339 * struct scmi_event_handler  - Event handler information
 340 * @key: The used hashkey
 341 * @users: A reference count for number of active users for this handler
 342 * @r_evt: A reference to the associated registered event; when this is NULL
 343 *	   this handler is pending, which means that identifies a set of
 344 *	   callbacks intended to be attached to an event which is still not
 345 *	   known nor registered by any protocol at that point in time
 346 * @chain: The notification chain dedicated to this specific event tuple
 347 * @hash: The hlist_node used for collision handling
 348 * @enabled: A boolean which records if event's generation has been already
 349 *	     enabled for this handler as a whole
 350 *
 351 * This structure collects all the information needed to process a received
 352 * event identified by the tuple (proto_id, evt_id, src_id).
 353 * These descriptors are stored in a per-protocol @registered_events_handlers
 354 * table using as a key a value derived from that tuple.
 355 */
 356struct scmi_event_handler {
 357	u32				key;
 358	refcount_t			users;
 359	struct scmi_registered_event	*r_evt;
 360	struct blocking_notifier_head	chain;
 361	struct hlist_node		hash;
 362	bool				enabled;
 363};
 364
 365#define IS_HNDL_PENDING(hndl)	(!(hndl)->r_evt)
 366
 367static struct scmi_event_handler *
 368scmi_get_active_handler(struct scmi_notify_instance *ni, u32 evt_key);
 369static void scmi_put_active_handler(struct scmi_notify_instance *ni,
 370				    struct scmi_event_handler *hndl);
 371static void scmi_put_handler_unlocked(struct scmi_notify_instance *ni,
 372				      struct scmi_event_handler *hndl);
 373
 374/**
 375 * scmi_lookup_and_call_event_chain()  - Lookup the proper chain and call it
 376 * @ni: A reference to the notification instance to use
 377 * @evt_key: The key to use to lookup the related notification chain
 378 * @report: The customized event-specific report to pass down to the callbacks
 379 *	    as their *data parameter.
 380 */
 381static inline void
 382scmi_lookup_and_call_event_chain(struct scmi_notify_instance *ni,
 383				 u32 evt_key, void *report)
 384{
 385	int ret;
 386	struct scmi_event_handler *hndl;
 387
 388	/*
 389	 * Here ensure the event handler cannot vanish while using it.
 390	 * It is legitimate, though, for an handler not to be found at all here,
 391	 * e.g. when it has been unregistered by the user after some events had
 392	 * already been queued.
 393	 */
 394	hndl = scmi_get_active_handler(ni, evt_key);
 395	if (!hndl)
 396		return;
 397
 398	ret = blocking_notifier_call_chain(&hndl->chain,
 399					   KEY_XTRACT_EVT_ID(evt_key),
 400					   report);
 401	/* Notifiers are NOT supposed to cut the chain ... */
 402	WARN_ON_ONCE(ret & NOTIFY_STOP_MASK);
 403
 404	scmi_put_active_handler(ni, hndl);
 405}
 406
 407/**
 408 * scmi_process_event_header()  - Dequeue and process an event header
 409 * @eq: The queue to use
 410 * @pd: The protocol descriptor to use
 411 *
 412 * Read an event header from the protocol queue into the dedicated scratch
 413 * buffer and looks for a matching registered event; in case an anomalously
 414 * sized read is detected just flush the queue.
 415 *
 416 * Return:
 417 * * a reference to the matching registered event when found
 418 * * ERR_PTR(-EINVAL) when NO registered event could be found
 419 * * NULL when the queue is empty
 420 */
 421static inline struct scmi_registered_event *
 422scmi_process_event_header(struct events_queue *eq,
 423			  struct scmi_registered_events_desc *pd)
 424{
 425	unsigned int outs;
 426	struct scmi_registered_event *r_evt;
 427
 428	outs = kfifo_out(&eq->kfifo, pd->eh,
 429			 sizeof(struct scmi_event_header));
 430	if (!outs)
 431		return NULL;
 432	if (outs != sizeof(struct scmi_event_header)) {
 433		dev_err(pd->ni->handle->dev, "corrupted EVT header. Flush.\n");
 434		kfifo_reset_out(&eq->kfifo);
 435		return NULL;
 436	}
 437
 438	r_evt = SCMI_GET_REVT_FROM_PD(pd, pd->eh->evt_id);
 439	if (!r_evt)
 440		r_evt = ERR_PTR(-EINVAL);
 441
 442	return r_evt;
 443}
 444
 445/**
 446 * scmi_process_event_payload()  - Dequeue and process an event payload
 447 * @eq: The queue to use
 448 * @pd: The protocol descriptor to use
 449 * @r_evt: The registered event descriptor to use
 450 *
 451 * Read an event payload from the protocol queue into the dedicated scratch
 452 * buffer, fills a custom report and then look for matching event handlers and
 453 * call them; skip any unknown event (as marked by scmi_process_event_header())
 454 * and in case an anomalously sized read is detected just flush the queue.
 455 *
 456 * Return: False when the queue is empty
 457 */
 458static inline bool
 459scmi_process_event_payload(struct events_queue *eq,
 460			   struct scmi_registered_events_desc *pd,
 461			   struct scmi_registered_event *r_evt)
 462{
 463	u32 src_id, key;
 464	unsigned int outs;
 465	void *report = NULL;
 466
 467	outs = kfifo_out(&eq->kfifo, pd->eh->payld, pd->eh->payld_sz);
 468	if (!outs)
 469		return false;
 470
 471	/* Any in-flight event has now been officially processed */
 472	pd->in_flight = NULL;
 473
 474	if (outs != pd->eh->payld_sz) {
 475		dev_err(pd->ni->handle->dev, "corrupted EVT Payload. Flush.\n");
 476		kfifo_reset_out(&eq->kfifo);
 477		return false;
 478	}
 479
 480	if (IS_ERR(r_evt)) {
 481		dev_warn(pd->ni->handle->dev,
 482			 "SKIP UNKNOWN EVT - proto:%X  evt:%d\n",
 483			 pd->id, pd->eh->evt_id);
 484		return true;
 485	}
 486
 487	report = REVT_FILL_REPORT(r_evt, pd->eh->evt_id, pd->eh->timestamp,
 488				  pd->eh->payld, pd->eh->payld_sz,
 489				  r_evt->report, &src_id);
 490	if (!report) {
 491		dev_err(pd->ni->handle->dev,
 492			"report not available - proto:%X  evt:%d\n",
 493			pd->id, pd->eh->evt_id);
 494		return true;
 495	}
 496
 497	/* At first search for a generic ALL src_ids handler... */
 498	key = MAKE_ALL_SRCS_KEY(pd->id, pd->eh->evt_id);
 499	scmi_lookup_and_call_event_chain(pd->ni, key, report);
 500
 501	/* ...then search for any specific src_id */
 502	key = MAKE_HASH_KEY(pd->id, pd->eh->evt_id, src_id);
 503	scmi_lookup_and_call_event_chain(pd->ni, key, report);
 504
 505	return true;
 506}
 507
 508/**
 509 * scmi_events_dispatcher()  - Common worker logic for all work items.
 510 * @work: The work item to use, which is associated to a dedicated events_queue
 511 *
 512 * Logic:
 513 *  1. dequeue one pending RX notification (queued in SCMI RX ISR context)
 514 *  2. generate a custom event report from the received event message
 515 *  3. lookup for any registered ALL_SRC_IDs handler:
 516 *    - > call the related notification chain passing in the report
 517 *  4. lookup for any registered specific SRC_ID handler:
 518 *    - > call the related notification chain passing in the report
 519 *
 520 * Note that:
 521 * * a dedicated per-protocol kfifo queue is used: in this way an anomalous
 522 *   flood of events cannot saturate other protocols' queues.
 523 * * each per-protocol queue is associated to a distinct work_item, which
 524 *   means, in turn, that:
 525 *   + all protocols can process their dedicated queues concurrently
 526 *     (since notify_wq:max_active != 1)
 527 *   + anyway at most one worker instance is allowed to run on the same queue
 528 *     concurrently: this ensures that we can have only one concurrent
 529 *     reader/writer on the associated kfifo, so that we can use it lock-less
 530 *
 531 * Context: Process context.
 532 */
 533static void scmi_events_dispatcher(struct work_struct *work)
 534{
 535	struct events_queue *eq;
 536	struct scmi_registered_events_desc *pd;
 537	struct scmi_registered_event *r_evt;
 538
 539	eq = container_of(work, struct events_queue, notify_work);
 540	pd = container_of(eq, struct scmi_registered_events_desc, equeue);
 541	/*
 542	 * In order to keep the queue lock-less and the number of memcopies
 543	 * to the bare minimum needed, the dispatcher accounts for the
 544	 * possibility of per-protocol in-flight events: i.e. an event whose
 545	 * reception could end up being split across two subsequent runs of this
 546	 * worker, first the header, then the payload.
 547	 */
 548	do {
 549		if (!pd->in_flight) {
 550			r_evt = scmi_process_event_header(eq, pd);
 551			if (!r_evt)
 552				break;
 553			pd->in_flight = r_evt;
 554		} else {
 555			r_evt = pd->in_flight;
 556		}
 557	} while (scmi_process_event_payload(eq, pd, r_evt));
 558}
 559
 560/**
 561 * scmi_notify()  - Queues a notification for further deferred processing
 562 * @handle: The handle identifying the platform instance from which the
 563 *	    dispatched event is generated
 564 * @proto_id: Protocol ID
 565 * @evt_id: Event ID (msgID)
 566 * @buf: Event Message Payload (without the header)
 567 * @len: Event Message Payload size
 568 * @ts: RX Timestamp in nanoseconds (boottime)
 569 *
 570 * Context: Called in interrupt context to queue a received event for
 571 * deferred processing.
 572 *
 573 * Return: 0 on Success
 574 */
 575int scmi_notify(const struct scmi_handle *handle, u8 proto_id, u8 evt_id,
 576		const void *buf, size_t len, ktime_t ts)
 577{
 578	struct scmi_registered_event *r_evt;
 579	struct scmi_event_header eh;
 580	struct scmi_notify_instance *ni;
 581
 582	/* Ensure notify_priv is updated */
 583	smp_rmb();
 584	if (!handle->notify_priv)
 585		return 0;
 586	ni = handle->notify_priv;
 587
 588	r_evt = SCMI_GET_REVT(ni, proto_id, evt_id);
 589	if (!r_evt)
 590		return -EINVAL;
 591
 592	if (len > r_evt->evt->max_payld_sz) {
 593		dev_err(handle->dev, "discard badly sized message\n");
 594		return -EINVAL;
 595	}
 596	if (kfifo_avail(&r_evt->proto->equeue.kfifo) < sizeof(eh) + len) {
 597		dev_warn(handle->dev,
 598			 "queue full, dropping proto_id:%d  evt_id:%d  ts:%lld\n",
 599			 proto_id, evt_id, ktime_to_ns(ts));
 600		return -ENOMEM;
 601	}
 602
 603	eh.timestamp = ts;
 604	eh.evt_id = evt_id;
 605	eh.payld_sz = len;
 606	/*
 607	 * Header and payload are enqueued with two distinct kfifo_in() (so non
 608	 * atomic), but this situation is handled properly on the consumer side
 609	 * with in-flight events tracking.
 610	 */
 611	kfifo_in(&r_evt->proto->equeue.kfifo, &eh, sizeof(eh));
 612	kfifo_in(&r_evt->proto->equeue.kfifo, buf, len);
 613	/*
 614	 * Don't care about return value here since we just want to ensure that
 615	 * a work is queued all the times whenever some items have been pushed
 616	 * on the kfifo:
 617	 * - if work was already queued it will simply fail to queue a new one
 618	 *   since it is not needed
 619	 * - if work was not queued already it will be now, even in case work
 620	 *   was in fact already running: this behavior avoids any possible race
 621	 *   when this function pushes new items onto the kfifos after the
 622	 *   related executing worker had already determined the kfifo to be
 623	 *   empty and it was terminating.
 624	 */
 625	queue_work(r_evt->proto->equeue.wq,
 626		   &r_evt->proto->equeue.notify_work);
 627
 628	return 0;
 629}
 630
 631/**
 632 * scmi_kfifo_free()  - Devres action helper to free the kfifo
 633 * @kfifo: The kfifo to free
 634 */
 635static void scmi_kfifo_free(void *kfifo)
 636{
 637	kfifo_free((struct kfifo *)kfifo);
 638}
 639
 640/**
 641 * scmi_initialize_events_queue()  - Allocate/Initialize a kfifo buffer
 642 * @ni: A reference to the notification instance to use
 643 * @equeue: The events_queue to initialize
 644 * @sz: Size of the kfifo buffer to allocate
 645 *
 646 * Allocate a buffer for the kfifo and initialize it.
 647 *
 648 * Return: 0 on Success
 649 */
 650static int scmi_initialize_events_queue(struct scmi_notify_instance *ni,
 651					struct events_queue *equeue, size_t sz)
 652{
 653	int ret;
 654
 655	if (kfifo_alloc(&equeue->kfifo, sz, GFP_KERNEL))
 656		return -ENOMEM;
 657	/* Size could have been roundup to power-of-two */
 658	equeue->sz = kfifo_size(&equeue->kfifo);
 659
 660	ret = devm_add_action_or_reset(ni->handle->dev, scmi_kfifo_free,
 661				       &equeue->kfifo);
 662	if (ret)
 663		return ret;
 664
 665	INIT_WORK(&equeue->notify_work, scmi_events_dispatcher);
 666	equeue->wq = ni->notify_wq;
 667
 668	return ret;
 669}
 670
 671/**
 672 * scmi_allocate_registered_events_desc()  - Allocate a registered events'
 673 * descriptor
 674 * @ni: A reference to the &struct scmi_notify_instance notification instance
 675 *	to use
 676 * @proto_id: Protocol ID
 677 * @queue_sz: Size of the associated queue to allocate
 678 * @eh_sz: Size of the event header scratch area to pre-allocate
 679 * @num_events: Number of events to support (size of @registered_events)
 680 * @ops: Pointer to a struct holding references to protocol specific helpers
 681 *	 needed during events handling
 682 *
 683 * It is supposed to be called only once for each protocol at protocol
 684 * initialization time, so it warns if the requested protocol is found already
 685 * registered.
 686 *
 687 * Return: The allocated and registered descriptor on Success
 688 */
 689static struct scmi_registered_events_desc *
 690scmi_allocate_registered_events_desc(struct scmi_notify_instance *ni,
 691				     u8 proto_id, size_t queue_sz, size_t eh_sz,
 692				     int num_events,
 693				     const struct scmi_event_ops *ops)
 694{
 695	int ret;
 696	struct scmi_registered_events_desc *pd;
 697
 698	/* Ensure protocols are up to date */
 699	smp_rmb();
 700	if (WARN_ON(ni->registered_protocols[proto_id]))
 701		return ERR_PTR(-EINVAL);
 702
 703	pd = devm_kzalloc(ni->handle->dev, sizeof(*pd), GFP_KERNEL);
 704	if (!pd)
 705		return ERR_PTR(-ENOMEM);
 706	pd->id = proto_id;
 707	pd->ops = ops;
 708	pd->ni = ni;
 709
 710	ret = scmi_initialize_events_queue(ni, &pd->equeue, queue_sz);
 711	if (ret)
 712		return ERR_PTR(ret);
 713
 714	pd->eh = devm_kzalloc(ni->handle->dev, eh_sz, GFP_KERNEL);
 715	if (!pd->eh)
 716		return ERR_PTR(-ENOMEM);
 717	pd->eh_sz = eh_sz;
 718
 719	pd->registered_events = devm_kcalloc(ni->handle->dev, num_events,
 720					     sizeof(char *), GFP_KERNEL);
 721	if (!pd->registered_events)
 722		return ERR_PTR(-ENOMEM);
 723	pd->num_events = num_events;
 724
 725	/* Initialize per protocol handlers table */
 726	mutex_init(&pd->registered_mtx);
 727	hash_init(pd->registered_events_handlers);
 728
 729	return pd;
 730}
 731
 732/**
 733 * scmi_register_protocol_events()  - Register Protocol Events with the core
 734 * @handle: The handle identifying the platform instance against which the
 735 *	    the protocol's events are registered
 736 * @proto_id: Protocol ID
 737 * @queue_sz: Size in bytes of the associated queue to be allocated
 738 * @ops: Protocol specific event-related operations
 739 * @evt: Event descriptor array
 740 * @num_events: Number of events in @evt array
 741 * @num_sources: Number of possible sources for this protocol on this
 742 *		 platform.
 743 *
 744 * Used by SCMI Protocols initialization code to register with the notification
 745 * core the list of supported events and their descriptors: takes care to
 746 * pre-allocate and store all needed descriptors, scratch buffers and event
 747 * queues.
 748 *
 749 * Return: 0 on Success
 750 */
 751int scmi_register_protocol_events(const struct scmi_handle *handle,
 752				  u8 proto_id, size_t queue_sz,
 753				  const struct scmi_event_ops *ops,
 754				  const struct scmi_event *evt, int num_events,
 755				  int num_sources)
 756{
 757	int i;
 
 758	size_t payld_sz = 0;
 759	struct scmi_registered_events_desc *pd;
 760	struct scmi_notify_instance *ni;
 
 761
 762	if (!ops || !evt)
 
 763		return -EINVAL;
 764
 765	/* Ensure notify_priv is updated */
 766	smp_rmb();
 767	if (!handle->notify_priv)
 768		return -ENOMEM;
 769	ni = handle->notify_priv;
 770
 771	/* Attach to the notification main devres group */
 772	if (!devres_open_group(ni->handle->dev, ni->gid, GFP_KERNEL))
 773		return -ENOMEM;
 
 
 
 
 
 
 
 774
 775	for (i = 0; i < num_events; i++)
 
 776		payld_sz = max_t(size_t, payld_sz, evt[i].max_payld_sz);
 777	payld_sz += sizeof(struct scmi_event_header);
 778
 779	pd = scmi_allocate_registered_events_desc(ni, proto_id, queue_sz,
 780						  payld_sz, num_events, ops);
 
 781	if (IS_ERR(pd))
 782		goto err;
 783
 784	for (i = 0; i < num_events; i++, evt++) {
 
 785		struct scmi_registered_event *r_evt;
 786
 787		r_evt = devm_kzalloc(ni->handle->dev, sizeof(*r_evt),
 788				     GFP_KERNEL);
 789		if (!r_evt)
 790			goto err;
 791		r_evt->proto = pd;
 792		r_evt->evt = evt;
 793
 794		r_evt->sources = devm_kcalloc(ni->handle->dev, num_sources,
 795					      sizeof(refcount_t), GFP_KERNEL);
 796		if (!r_evt->sources)
 797			goto err;
 798		r_evt->num_sources = num_sources;
 799		mutex_init(&r_evt->sources_mtx);
 800
 801		r_evt->report = devm_kzalloc(ni->handle->dev,
 802					     evt->max_report_sz, GFP_KERNEL);
 803		if (!r_evt->report)
 804			goto err;
 805
 806		pd->registered_events[i] = r_evt;
 807		/* Ensure events are updated */
 808		smp_wmb();
 809		dev_dbg(handle->dev, "registered event - %lX\n",
 810			MAKE_ALL_SRCS_KEY(r_evt->proto->id, r_evt->evt->id));
 811	}
 812
 813	/* Register protocol and events...it will never be removed */
 814	ni->registered_protocols[proto_id] = pd;
 815	/* Ensure protocols are updated */
 816	smp_wmb();
 817
 818	devres_close_group(ni->handle->dev, ni->gid);
 819
 820	/*
 821	 * Finalize any pending events' handler which could have been waiting
 822	 * for this protocol's events registration.
 823	 */
 824	schedule_work(&ni->init_work);
 825
 826	return 0;
 
 827
 828err:
 829	dev_warn(handle->dev, "Proto:%X - Registration Failed !\n", proto_id);
 830	/* A failing protocol registration does not trigger full failure */
 831	devres_close_group(ni->handle->dev, ni->gid);
 
 
 
 
 
 
 
 832
 833	return -ENOMEM;
 
 
 
 
 
 
 
 
 
 
 
 
 834}
 835
 836/**
 837 * scmi_allocate_event_handler()  - Allocate Event handler
 838 * @ni: A reference to the notification instance to use
 839 * @evt_key: 32bit key uniquely bind to the event identified by the tuple
 840 *	     (proto_id, evt_id, src_id)
 841 *
 842 * Allocate an event handler and related notification chain associated with
 843 * the provided event handler key.
 844 * Note that, at this point, a related registered_event is still to be
 845 * associated to this handler descriptor (hndl->r_evt == NULL), so the handler
 846 * is initialized as pending.
 847 *
 848 * Context: Assumes to be called with @pending_mtx already acquired.
 849 * Return: the freshly allocated structure on Success
 850 */
 851static struct scmi_event_handler *
 852scmi_allocate_event_handler(struct scmi_notify_instance *ni, u32 evt_key)
 853{
 854	struct scmi_event_handler *hndl;
 855
 856	hndl = kzalloc(sizeof(*hndl), GFP_KERNEL);
 857	if (!hndl)
 858		return NULL;
 859	hndl->key = evt_key;
 860	BLOCKING_INIT_NOTIFIER_HEAD(&hndl->chain);
 861	refcount_set(&hndl->users, 1);
 862	/* New handlers are created pending */
 863	hash_add(ni->pending_events_handlers, &hndl->hash, hndl->key);
 864
 865	return hndl;
 866}
 867
 868/**
 869 * scmi_free_event_handler()  - Free the provided Event handler
 870 * @hndl: The event handler structure to free
 871 *
 872 * Context: Assumes to be called with proper locking acquired depending
 873 *	    on the situation.
 874 */
 875static void scmi_free_event_handler(struct scmi_event_handler *hndl)
 876{
 877	hash_del(&hndl->hash);
 878	kfree(hndl);
 879}
 880
 881/**
 882 * scmi_bind_event_handler()  - Helper to attempt binding an handler to an event
 883 * @ni: A reference to the notification instance to use
 884 * @hndl: The event handler to bind
 885 *
 886 * If an associated registered event is found, move the handler from the pending
 887 * into the registered table.
 888 *
 889 * Context: Assumes to be called with @pending_mtx already acquired.
 890 *
 891 * Return: 0 on Success
 892 */
 893static inline int scmi_bind_event_handler(struct scmi_notify_instance *ni,
 894					  struct scmi_event_handler *hndl)
 895{
 896	struct scmi_registered_event *r_evt;
 897
 898	r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(hndl->key),
 899			      KEY_XTRACT_EVT_ID(hndl->key));
 900	if (!r_evt)
 901		return -EINVAL;
 902
 903	/* Remove from pending and insert into registered */
 
 
 
 904	hash_del(&hndl->hash);
 
 
 
 
 
 
 
 
 905	hndl->r_evt = r_evt;
 
 906	mutex_lock(&r_evt->proto->registered_mtx);
 907	hash_add(r_evt->proto->registered_events_handlers,
 908		 &hndl->hash, hndl->key);
 909	mutex_unlock(&r_evt->proto->registered_mtx);
 910
 911	return 0;
 912}
 913
 914/**
 915 * scmi_valid_pending_handler()  - Helper to check pending status of handlers
 916 * @ni: A reference to the notification instance to use
 917 * @hndl: The event handler to check
 918 *
 919 * An handler is considered pending when its r_evt == NULL, because the related
 920 * event was still unknown at handler's registration time; anyway, since all
 921 * protocols register their supported events once for all at protocols'
 922 * initialization time, a pending handler cannot be considered valid anymore if
 923 * the underlying event (which it is waiting for), belongs to an already
 924 * initialized and registered protocol.
 925 *
 926 * Return: 0 on Success
 927 */
 928static inline int scmi_valid_pending_handler(struct scmi_notify_instance *ni,
 929					     struct scmi_event_handler *hndl)
 930{
 931	struct scmi_registered_events_desc *pd;
 932
 933	if (!IS_HNDL_PENDING(hndl))
 934		return -EINVAL;
 935
 936	pd = SCMI_GET_PROTO(ni, KEY_XTRACT_PROTO_ID(hndl->key));
 937	if (pd)
 938		return -EINVAL;
 939
 940	return 0;
 941}
 942
 943/**
 944 * scmi_register_event_handler()  - Register whenever possible an Event handler
 945 * @ni: A reference to the notification instance to use
 946 * @hndl: The event handler to register
 947 *
 948 * At first try to bind an event handler to its associated event, then check if
 949 * it was at least a valid pending handler: if it was not bound nor valid return
 950 * false.
 951 *
 952 * Valid pending incomplete bindings will be periodically retried by a dedicated
 953 * worker which is kicked each time a new protocol completes its own
 954 * registration phase.
 955 *
 956 * Context: Assumes to be called with @pending_mtx acquired.
 957 *
 958 * Return: 0 on Success
 959 */
 960static int scmi_register_event_handler(struct scmi_notify_instance *ni,
 961				       struct scmi_event_handler *hndl)
 962{
 963	int ret;
 964
 965	ret = scmi_bind_event_handler(ni, hndl);
 966	if (!ret) {
 967		dev_dbg(ni->handle->dev, "registered NEW handler - key:%X\n",
 968			hndl->key);
 969	} else {
 970		ret = scmi_valid_pending_handler(ni, hndl);
 971		if (!ret)
 972			dev_dbg(ni->handle->dev,
 973				"registered PENDING handler - key:%X\n",
 974				hndl->key);
 975	}
 976
 977	return ret;
 978}
 979
 980/**
 981 * __scmi_event_handler_get_ops()  - Utility to get or create an event handler
 982 * @ni: A reference to the notification instance to use
 983 * @evt_key: The event key to use
 984 * @create: A boolean flag to specify if a handler must be created when
 985 *	    not already existent
 986 *
 987 * Search for the desired handler matching the key in both the per-protocol
 988 * registered table and the common pending table:
 989 * * if found adjust users refcount
 990 * * if not found and @create is true, create and register the new handler:
 991 *   handler could end up being registered as pending if no matching event
 992 *   could be found.
 993 *
 994 * An handler is guaranteed to reside in one and only one of the tables at
 995 * any one time; to ensure this the whole search and create is performed
 996 * holding the @pending_mtx lock, with @registered_mtx additionally acquired
 997 * if needed.
 998 *
 999 * Note that when a nested acquisition of these mutexes is needed the locking
1000 * order is always (same as in @init_work):
1001 * 1. pending_mtx
1002 * 2. registered_mtx
1003 *
1004 * Events generation is NOT enabled right after creation within this routine
1005 * since at creation time we usually want to have all setup and ready before
1006 * events really start flowing.
1007 *
1008 * Return: A properly refcounted handler on Success, NULL on Failure
1009 */
1010static inline struct scmi_event_handler *
1011__scmi_event_handler_get_ops(struct scmi_notify_instance *ni,
1012			     u32 evt_key, bool create)
1013{
1014	struct scmi_registered_event *r_evt;
1015	struct scmi_event_handler *hndl = NULL;
1016
1017	r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(evt_key),
1018			      KEY_XTRACT_EVT_ID(evt_key));
1019
1020	mutex_lock(&ni->pending_mtx);
1021	/* Search registered events at first ... if possible at all */
1022	if (r_evt) {
1023		mutex_lock(&r_evt->proto->registered_mtx);
1024		hndl = KEY_FIND(r_evt->proto->registered_events_handlers,
1025				hndl, evt_key);
1026		if (hndl)
1027			refcount_inc(&hndl->users);
1028		mutex_unlock(&r_evt->proto->registered_mtx);
1029	}
1030
1031	/* ...then amongst pending. */
1032	if (!hndl) {
1033		hndl = KEY_FIND(ni->pending_events_handlers, hndl, evt_key);
1034		if (hndl)
1035			refcount_inc(&hndl->users);
1036	}
1037
1038	/* Create if still not found and required */
1039	if (!hndl && create) {
1040		hndl = scmi_allocate_event_handler(ni, evt_key);
1041		if (hndl && scmi_register_event_handler(ni, hndl)) {
1042			dev_dbg(ni->handle->dev,
1043				"purging UNKNOWN handler - key:%X\n",
1044				hndl->key);
1045			/* this hndl can be only a pending one */
1046			scmi_put_handler_unlocked(ni, hndl);
1047			hndl = NULL;
1048		}
1049	}
1050	mutex_unlock(&ni->pending_mtx);
1051
1052	return hndl;
1053}
1054
1055static struct scmi_event_handler *
1056scmi_get_handler(struct scmi_notify_instance *ni, u32 evt_key)
1057{
1058	return __scmi_event_handler_get_ops(ni, evt_key, false);
1059}
1060
1061static struct scmi_event_handler *
1062scmi_get_or_create_handler(struct scmi_notify_instance *ni, u32 evt_key)
1063{
1064	return __scmi_event_handler_get_ops(ni, evt_key, true);
1065}
1066
1067/**
1068 * scmi_get_active_handler()  - Helper to get active handlers only
1069 * @ni: A reference to the notification instance to use
1070 * @evt_key: The event key to use
1071 *
1072 * Search for the desired handler matching the key only in the per-protocol
1073 * table of registered handlers: this is called only from the dispatching path
1074 * so want to be as quick as possible and do not care about pending.
1075 *
1076 * Return: A properly refcounted active handler
1077 */
1078static struct scmi_event_handler *
1079scmi_get_active_handler(struct scmi_notify_instance *ni, u32 evt_key)
1080{
1081	struct scmi_registered_event *r_evt;
1082	struct scmi_event_handler *hndl = NULL;
1083
1084	r_evt = SCMI_GET_REVT(ni, KEY_XTRACT_PROTO_ID(evt_key),
1085			      KEY_XTRACT_EVT_ID(evt_key));
1086	if (r_evt) {
1087		mutex_lock(&r_evt->proto->registered_mtx);
1088		hndl = KEY_FIND(r_evt->proto->registered_events_handlers,
1089				hndl, evt_key);
1090		if (hndl)
1091			refcount_inc(&hndl->users);
1092		mutex_unlock(&r_evt->proto->registered_mtx);
1093	}
1094
1095	return hndl;
1096}
1097
1098/**
1099 * __scmi_enable_evt()  - Enable/disable events generation
1100 * @r_evt: The registered event to act upon
1101 * @src_id: The src_id to act upon
1102 * @enable: The action to perform: true->Enable, false->Disable
1103 *
1104 * Takes care of proper refcounting while performing enable/disable: handles
1105 * the special case of ALL sources requests by itself.
1106 * Returns successfully if at least one of the required src_id has been
1107 * successfully enabled/disabled.
1108 *
1109 * Return: 0 on Success
1110 */
1111static inline int __scmi_enable_evt(struct scmi_registered_event *r_evt,
1112				    u32 src_id, bool enable)
1113{
1114	int retvals = 0;
1115	u32 num_sources;
1116	refcount_t *sid;
1117
1118	if (src_id == SRC_ID_MASK) {
1119		src_id = 0;
1120		num_sources = r_evt->num_sources;
1121	} else if (src_id < r_evt->num_sources) {
1122		num_sources = 1;
1123	} else {
1124		return -EINVAL;
1125	}
1126
1127	mutex_lock(&r_evt->sources_mtx);
1128	if (enable) {
1129		for (; num_sources; src_id++, num_sources--) {
1130			int ret = 0;
1131
1132			sid = &r_evt->sources[src_id];
1133			if (refcount_read(sid) == 0) {
1134				ret = REVT_NOTIFY_ENABLE(r_evt, r_evt->evt->id,
1135							 src_id);
1136				if (!ret)
1137					refcount_set(sid, 1);
1138			} else {
1139				refcount_inc(sid);
1140			}
1141			retvals += !ret;
1142		}
1143	} else {
1144		for (; num_sources; src_id++, num_sources--) {
1145			sid = &r_evt->sources[src_id];
1146			if (refcount_dec_and_test(sid))
1147				REVT_NOTIFY_DISABLE(r_evt,
1148						    r_evt->evt->id, src_id);
1149		}
1150		retvals = 1;
1151	}
1152	mutex_unlock(&r_evt->sources_mtx);
1153
1154	return retvals ? 0 : -EINVAL;
1155}
1156
1157static int scmi_enable_events(struct scmi_event_handler *hndl)
1158{
1159	int ret = 0;
1160
1161	if (!hndl->enabled) {
1162		ret = __scmi_enable_evt(hndl->r_evt,
1163					KEY_XTRACT_SRC_ID(hndl->key), true);
1164		if (!ret)
1165			hndl->enabled = true;
1166	}
1167
1168	return ret;
1169}
1170
1171static int scmi_disable_events(struct scmi_event_handler *hndl)
1172{
1173	int ret = 0;
1174
1175	if (hndl->enabled) {
1176		ret = __scmi_enable_evt(hndl->r_evt,
1177					KEY_XTRACT_SRC_ID(hndl->key), false);
1178		if (!ret)
1179			hndl->enabled = false;
1180	}
1181
1182	return ret;
1183}
1184
1185/**
1186 * scmi_put_handler_unlocked()  - Put an event handler
1187 * @ni: A reference to the notification instance to use
1188 * @hndl: The event handler to act upon
1189 *
1190 * After having got exclusive access to the registered handlers hashtable,
1191 * update the refcount and if @hndl is no more in use by anyone:
1192 * * ask for events' generation disabling
1193 * * unregister and free the handler itself
1194 *
1195 * Context: Assumes all the proper locking has been managed by the caller.
 
 
1196 */
1197static void scmi_put_handler_unlocked(struct scmi_notify_instance *ni,
1198				      struct scmi_event_handler *hndl)
1199{
 
 
1200	if (refcount_dec_and_test(&hndl->users)) {
1201		if (!IS_HNDL_PENDING(hndl))
1202			scmi_disable_events(hndl);
1203		scmi_free_event_handler(hndl);
 
1204	}
 
 
1205}
1206
1207static void scmi_put_handler(struct scmi_notify_instance *ni,
1208			     struct scmi_event_handler *hndl)
1209{
 
 
1210	struct scmi_registered_event *r_evt = hndl->r_evt;
1211
1212	mutex_lock(&ni->pending_mtx);
1213	if (r_evt)
 
1214		mutex_lock(&r_evt->proto->registered_mtx);
 
1215
1216	scmi_put_handler_unlocked(ni, hndl);
1217
1218	if (r_evt)
1219		mutex_unlock(&r_evt->proto->registered_mtx);
 
 
 
 
 
 
 
 
 
1220	mutex_unlock(&ni->pending_mtx);
1221}
1222
1223static void scmi_put_active_handler(struct scmi_notify_instance *ni,
1224				    struct scmi_event_handler *hndl)
1225{
 
1226	struct scmi_registered_event *r_evt = hndl->r_evt;
 
1227
1228	mutex_lock(&r_evt->proto->registered_mtx);
1229	scmi_put_handler_unlocked(ni, hndl);
1230	mutex_unlock(&r_evt->proto->registered_mtx);
 
 
1231}
1232
1233/**
1234 * scmi_event_handler_enable_events()  - Enable events associated to an handler
1235 * @hndl: The Event handler to act upon
1236 *
1237 * Return: 0 on Success
1238 */
1239static int scmi_event_handler_enable_events(struct scmi_event_handler *hndl)
1240{
1241	if (scmi_enable_events(hndl)) {
1242		pr_err("Failed to ENABLE events for key:%X !\n", hndl->key);
1243		return -EINVAL;
1244	}
1245
1246	return 0;
1247}
1248
1249/**
1250 * scmi_register_notifier()  - Register a notifier_block for an event
1251 * @handle: The handle identifying the platform instance against which the
1252 *	    callback is registered
1253 * @proto_id: Protocol ID
1254 * @evt_id: Event ID
1255 * @src_id: Source ID, when NULL register for events coming form ALL possible
1256 *	    sources
1257 * @nb: A standard notifier block to register for the specified event
1258 *
1259 * Generic helper to register a notifier_block against a protocol event.
1260 *
1261 * A notifier_block @nb will be registered for each distinct event identified
1262 * by the tuple (proto_id, evt_id, src_id) on a dedicated notification chain
1263 * so that:
1264 *
1265 *	(proto_X, evt_Y, src_Z) --> chain_X_Y_Z
1266 *
1267 * @src_id meaning is protocol specific and identifies the origin of the event
1268 * (like domain_id, sensor_id and so forth).
1269 *
1270 * @src_id can be NULL to signify that the caller is interested in receiving
1271 * notifications from ALL the available sources for that protocol OR simply that
1272 * the protocol does not support distinct sources.
1273 *
1274 * As soon as one user for the specified tuple appears, an handler is created,
1275 * and that specific event's generation is enabled at the platform level, unless
1276 * an associated registered event is found missing, meaning that the needed
1277 * protocol is still to be initialized and the handler has just been registered
1278 * as still pending.
1279 *
1280 * Return: 0 on Success
1281 */
1282static int scmi_register_notifier(const struct scmi_handle *handle,
1283				  u8 proto_id, u8 evt_id, u32 *src_id,
1284				  struct notifier_block *nb)
1285{
1286	int ret = 0;
1287	u32 evt_key;
1288	struct scmi_event_handler *hndl;
1289	struct scmi_notify_instance *ni;
1290
1291	/* Ensure notify_priv is updated */
1292	smp_rmb();
1293	if (!handle->notify_priv)
1294		return -ENODEV;
1295	ni = handle->notify_priv;
1296
1297	evt_key = MAKE_HASH_KEY(proto_id, evt_id,
1298				src_id ? *src_id : SRC_ID_MASK);
1299	hndl = scmi_get_or_create_handler(ni, evt_key);
1300	if (!hndl)
1301		return -EINVAL;
1302
1303	blocking_notifier_chain_register(&hndl->chain, nb);
1304
1305	/* Enable events for not pending handlers */
1306	if (!IS_HNDL_PENDING(hndl)) {
1307		ret = scmi_event_handler_enable_events(hndl);
1308		if (ret)
1309			scmi_put_handler(ni, hndl);
1310	}
1311
1312	return ret;
1313}
1314
1315/**
1316 * scmi_unregister_notifier()  - Unregister a notifier_block for an event
1317 * @handle: The handle identifying the platform instance against which the
1318 *	    callback is unregistered
1319 * @proto_id: Protocol ID
1320 * @evt_id: Event ID
1321 * @src_id: Source ID
1322 * @nb: The notifier_block to unregister
1323 *
1324 * Takes care to unregister the provided @nb from the notification chain
1325 * associated to the specified event and, if there are no more users for the
1326 * event handler, frees also the associated event handler structures.
1327 * (this could possibly cause disabling of event's generation at platform level)
1328 *
1329 * Return: 0 on Success
1330 */
1331static int scmi_unregister_notifier(const struct scmi_handle *handle,
1332				    u8 proto_id, u8 evt_id, u32 *src_id,
1333				    struct notifier_block *nb)
1334{
1335	u32 evt_key;
1336	struct scmi_event_handler *hndl;
1337	struct scmi_notify_instance *ni;
1338
1339	/* Ensure notify_priv is updated */
1340	smp_rmb();
1341	if (!handle->notify_priv)
1342		return -ENODEV;
1343	ni = handle->notify_priv;
1344
1345	evt_key = MAKE_HASH_KEY(proto_id, evt_id,
1346				src_id ? *src_id : SRC_ID_MASK);
1347	hndl = scmi_get_handler(ni, evt_key);
1348	if (!hndl)
1349		return -EINVAL;
1350
1351	/*
1352	 * Note that this chain unregistration call is safe on its own
1353	 * being internally protected by an rwsem.
1354	 */
1355	blocking_notifier_chain_unregister(&hndl->chain, nb);
1356	scmi_put_handler(ni, hndl);
1357
1358	/*
1359	 * This balances the initial get issued in @scmi_register_notifier.
1360	 * If this notifier_block happened to be the last known user callback
1361	 * for this event, the handler is here freed and the event's generation
1362	 * stopped.
1363	 *
1364	 * Note that, an ongoing concurrent lookup on the delivery workqueue
1365	 * path could still hold the refcount to 1 even after this routine
1366	 * completes: in such a case it will be the final put on the delivery
1367	 * path which will finally free this unused handler.
1368	 */
1369	scmi_put_handler(ni, hndl);
1370
1371	return 0;
1372}
1373
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1374/**
1375 * scmi_protocols_late_init()  - Worker for late initialization
1376 * @work: The work item to use associated to the proper SCMI instance
1377 *
1378 * This kicks in whenever a new protocol has completed its own registration via
1379 * scmi_register_protocol_events(): it is in charge of scanning the table of
1380 * pending handlers (registered by users while the related protocol was still
1381 * not initialized) and finalizing their initialization whenever possible;
1382 * invalid pending handlers are purged at this point in time.
1383 */
1384static void scmi_protocols_late_init(struct work_struct *work)
1385{
1386	int bkt;
1387	struct scmi_event_handler *hndl;
1388	struct scmi_notify_instance *ni;
1389	struct hlist_node *tmp;
1390
1391	ni = container_of(work, struct scmi_notify_instance, init_work);
1392
1393	/* Ensure protocols and events are up to date */
1394	smp_rmb();
1395
1396	mutex_lock(&ni->pending_mtx);
1397	hash_for_each_safe(ni->pending_events_handlers, bkt, tmp, hndl, hash) {
1398		int ret;
1399
1400		ret = scmi_bind_event_handler(ni, hndl);
1401		if (!ret) {
1402			dev_dbg(ni->handle->dev,
1403				"finalized PENDING handler - key:%X\n",
1404				hndl->key);
1405			ret = scmi_event_handler_enable_events(hndl);
 
 
 
 
 
 
1406		} else {
1407			ret = scmi_valid_pending_handler(ni, hndl);
1408		}
1409		if (ret) {
1410			dev_dbg(ni->handle->dev,
1411				"purging PENDING handler - key:%X\n",
1412				hndl->key);
1413			/* this hndl can be only a pending one */
1414			scmi_put_handler_unlocked(ni, hndl);
1415		}
1416	}
1417	mutex_unlock(&ni->pending_mtx);
1418}
1419
1420/*
1421 * notify_ops are attached to the handle so that can be accessed
1422 * directly from an scmi_driver to register its own notifiers.
1423 */
1424static struct scmi_notify_ops notify_ops = {
1425	.register_event_notifier = scmi_register_notifier,
1426	.unregister_event_notifier = scmi_unregister_notifier,
 
 
1427};
1428
1429/**
1430 * scmi_notification_init()  - Initializes Notification Core Support
1431 * @handle: The handle identifying the platform instance to initialize
1432 *
1433 * This function lays out all the basic resources needed by the notification
1434 * core instance identified by the provided handle: once done, all of the
1435 * SCMI Protocols can register their events with the core during their own
1436 * initializations.
1437 *
1438 * Note that failing to initialize the core notifications support does not
1439 * cause the whole SCMI Protocols stack to fail its initialization.
1440 *
1441 * SCMI Notification Initialization happens in 2 steps:
1442 * * initialization: basic common allocations (this function)
1443 * * registration: protocols asynchronously come into life and registers their
1444 *		   own supported list of events with the core; this causes
1445 *		   further per-protocol allocations
1446 *
1447 * Any user's callback registration attempt, referring a still not registered
1448 * event, will be registered as pending and finalized later (if possible)
1449 * by scmi_protocols_late_init() work.
1450 * This allows for lazy initialization of SCMI Protocols due to late (or
1451 * missing) SCMI drivers' modules loading.
1452 *
1453 * Return: 0 on Success
1454 */
1455int scmi_notification_init(struct scmi_handle *handle)
1456{
1457	void *gid;
1458	struct scmi_notify_instance *ni;
1459
1460	gid = devres_open_group(handle->dev, NULL, GFP_KERNEL);
1461	if (!gid)
1462		return -ENOMEM;
1463
1464	ni = devm_kzalloc(handle->dev, sizeof(*ni), GFP_KERNEL);
1465	if (!ni)
1466		goto err;
1467
1468	ni->gid = gid;
1469	ni->handle = handle;
1470
1471	ni->notify_wq = alloc_workqueue("scmi_notify",
1472					WQ_UNBOUND | WQ_FREEZABLE | WQ_SYSFS,
1473					0);
1474	if (!ni->notify_wq)
1475		goto err;
1476
1477	ni->registered_protocols = devm_kcalloc(handle->dev, SCMI_MAX_PROTO,
1478						sizeof(char *), GFP_KERNEL);
1479	if (!ni->registered_protocols)
1480		goto err;
1481
 
 
 
 
 
 
1482	mutex_init(&ni->pending_mtx);
1483	hash_init(ni->pending_events_handlers);
1484
1485	INIT_WORK(&ni->init_work, scmi_protocols_late_init);
1486
 
1487	handle->notify_ops = &notify_ops;
1488	handle->notify_priv = ni;
1489	/* Ensure handle is up to date */
1490	smp_wmb();
1491
1492	dev_info(handle->dev, "Core Enabled.\n");
1493
1494	devres_close_group(handle->dev, ni->gid);
1495
1496	return 0;
1497
1498err:
1499	dev_warn(handle->dev, "Initialization Failed.\n");
1500	devres_release_group(handle->dev, NULL);
1501	return -ENOMEM;
1502}
1503
1504/**
1505 * scmi_notification_exit()  - Shutdown and clean Notification core
1506 * @handle: The handle identifying the platform instance to shutdown
1507 */
1508void scmi_notification_exit(struct scmi_handle *handle)
1509{
1510	struct scmi_notify_instance *ni;
1511
1512	/* Ensure notify_priv is updated */
1513	smp_rmb();
1514	if (!handle->notify_priv)
1515		return;
1516	ni = handle->notify_priv;
1517
1518	handle->notify_priv = NULL;
1519	/* Ensure handle is up to date */
1520	smp_wmb();
1521
1522	/* Destroy while letting pending work complete */
1523	destroy_workqueue(ni->notify_wq);
1524
1525	devres_release_group(ni->handle->dev, ni->gid);
1526}