brintos / linux-shallow public Read only

1// SPDX-License-Identifier: GPL-2.0+2/*3 * Main SSAM/SSH controller structure and functionality.4 *5 * Copyright (C) 2019-2022 Maximilian Luz <luzmaximilian@gmail.com>6 */7 8#include <linux/acpi.h>9#include <linux/atomic.h>10#include <linux/completion.h>11#include <linux/gpio/consumer.h>12#include <linux/interrupt.h>13#include <linux/kref.h>14#include <linux/limits.h>15#include <linux/list.h>16#include <linux/lockdep.h>17#include <linux/mutex.h>18#include <linux/rculist.h>19#include <linux/rbtree.h>20#include <linux/rwsem.h>21#include <linux/serdev.h>22#include <linux/slab.h>23#include <linux/spinlock.h>24#include <linux/srcu.h>25#include <linux/types.h>26#include <linux/workqueue.h>27 28#include <linux/surface_aggregator/controller.h>29#include <linux/surface_aggregator/serial_hub.h>30 31#include "controller.h"32#include "ssh_msgb.h"33#include "ssh_request_layer.h"34 35#include "trace.h"36 37 38/* -- Safe counters. -------------------------------------------------------- */39 40/**41 * ssh_seq_reset() - Reset/initialize sequence ID counter.42 * @c: The counter to reset.43 */44static void ssh_seq_reset(struct ssh_seq_counter *c)45{46	WRITE_ONCE(c->value, 0);47}48 49/**50 * ssh_seq_next() - Get next sequence ID.51 * @c: The counter providing the sequence IDs.52 *53 * Return: Returns the next sequence ID of the counter.54 */55static u8 ssh_seq_next(struct ssh_seq_counter *c)56{57	u8 old = READ_ONCE(c->value);58	u8 new = old + 1;59	u8 ret;60 61	while (unlikely((ret = cmpxchg(&c->value, old, new)) != old)) {62		old = ret;63		new = old + 1;64	}65 66	return old;67}68 69/**70 * ssh_rqid_reset() - Reset/initialize request ID counter.71 * @c: The counter to reset.72 */73static void ssh_rqid_reset(struct ssh_rqid_counter *c)74{75	WRITE_ONCE(c->value, 0);76}77 78/**79 * ssh_rqid_next() - Get next request ID.80 * @c: The counter providing the request IDs.81 *82 * Return: Returns the next request ID of the counter, skipping any reserved83 * request IDs.84 */85static u16 ssh_rqid_next(struct ssh_rqid_counter *c)86{87	u16 old = READ_ONCE(c->value);88	u16 new = ssh_rqid_next_valid(old);89	u16 ret;90 91	while (unlikely((ret = cmpxchg(&c->value, old, new)) != old)) {92		old = ret;93		new = ssh_rqid_next_valid(old);94	}95 96	return old;97}98 99 100/* -- Event notifier/callbacks. --------------------------------------------- */101/*102 * The notifier system is based on linux/notifier.h, specifically the SRCU103 * implementation. The difference to that is, that some bits of the notifier104 * call return value can be tracked across multiple calls. This is done so105 * that handling of events can be tracked and a warning can be issued in case106 * an event goes unhandled. The idea of that warning is that it should help107 * discover and identify new/currently unimplemented features.108 */109 110/**111 * ssam_event_matches_notifier() - Test if an event matches a notifier.112 * @n: The event notifier to test against.113 * @event: The event to test.114 *115 * Return: Returns %true if the given event matches the given notifier116 * according to the rules set in the notifier's event mask, %false otherwise.117 */118static bool ssam_event_matches_notifier(const struct ssam_event_notifier *n,119					const struct ssam_event *event)120{121	bool match = n->event.id.target_category == event->target_category;122 123	if (n->event.mask & SSAM_EVENT_MASK_TARGET)124		match &= n->event.reg.target_id == event->target_id;125 126	if (n->event.mask & SSAM_EVENT_MASK_INSTANCE)127		match &= n->event.id.instance == event->instance_id;128 129	return match;130}131 132/**133 * ssam_nfblk_call_chain() - Call event notifier callbacks of the given chain.134 * @nh:    The notifier head for which the notifier callbacks should be called.135 * @event: The event data provided to the callbacks.136 *137 * Call all registered notifier callbacks in order of their priority until138 * either no notifier is left or a notifier returns a value with the139 * %SSAM_NOTIF_STOP bit set. Note that this bit is automatically set via140 * ssam_notifier_from_errno() on any non-zero error value.141 *142 * Return: Returns the notifier status value, which contains the notifier143 * status bits (%SSAM_NOTIF_HANDLED and %SSAM_NOTIF_STOP) as well as a144 * potential error value returned from the last executed notifier callback.145 * Use ssam_notifier_to_errno() to convert this value to the original error146 * value.147 */148static int ssam_nfblk_call_chain(struct ssam_nf_head *nh, struct ssam_event *event)149{150	struct ssam_event_notifier *nf;151	int ret = 0, idx;152 153	idx = srcu_read_lock(&nh->srcu);154 155	list_for_each_entry_rcu(nf, &nh->head, base.node,156				srcu_read_lock_held(&nh->srcu)) {157		if (ssam_event_matches_notifier(nf, event)) {158			ret = (ret & SSAM_NOTIF_STATE_MASK) | nf->base.fn(nf, event);159			if (ret & SSAM_NOTIF_STOP)160				break;161		}162	}163 164	srcu_read_unlock(&nh->srcu, idx);165	return ret;166}167 168/**169 * ssam_nfblk_insert() - Insert a new notifier block into the given notifier170 * list.171 * @nh: The notifier head into which the block should be inserted.172 * @nb: The notifier block to add.173 *174 * Note: This function must be synchronized by the caller with respect to other175 * insert, find, and/or remove calls by holding ``struct ssam_nf.lock``.176 *177 * Return: Returns zero on success, %-EEXIST if the notifier block has already178 * been registered.179 */180static int ssam_nfblk_insert(struct ssam_nf_head *nh, struct ssam_notifier_block *nb)181{182	struct ssam_notifier_block *p;183	struct list_head *h;184 185	/* Runs under lock, no need for RCU variant. */186	list_for_each(h, &nh->head) {187		p = list_entry(h, struct ssam_notifier_block, node);188 189		if (unlikely(p == nb)) {190			WARN(1, "double register detected");191			return -EEXIST;192		}193 194		if (nb->priority > p->priority)195			break;196	}197 198	list_add_tail_rcu(&nb->node, h);199	return 0;200}201 202/**203 * ssam_nfblk_find() - Check if a notifier block is registered on the given204 * notifier head.205 * list.206 * @nh: The notifier head on which to search.207 * @nb: The notifier block to search for.208 *209 * Note: This function must be synchronized by the caller with respect to other210 * insert, find, and/or remove calls by holding ``struct ssam_nf.lock``.211 *212 * Return: Returns true if the given notifier block is registered on the given213 * notifier head, false otherwise.214 */215static bool ssam_nfblk_find(struct ssam_nf_head *nh, struct ssam_notifier_block *nb)216{217	struct ssam_notifier_block *p;218 219	/* Runs under lock, no need for RCU variant. */220	list_for_each_entry(p, &nh->head, node) {221		if (p == nb)222			return true;223	}224 225	return false;226}227 228/**229 * ssam_nfblk_remove() - Remove a notifier block from its notifier list.230 * @nb: The notifier block to be removed.231 *232 * Note: This function must be synchronized by the caller with respect to233 * other insert, find, and/or remove calls by holding ``struct ssam_nf.lock``.234 * Furthermore, the caller _must_ ensure SRCU synchronization by calling235 * synchronize_srcu() with ``nh->srcu`` after leaving the critical section, to236 * ensure that the removed notifier block is not in use any more.237 */238static void ssam_nfblk_remove(struct ssam_notifier_block *nb)239{240	list_del_rcu(&nb->node);241}242 243/**244 * ssam_nf_head_init() - Initialize the given notifier head.245 * @nh: The notifier head to initialize.246 */247static int ssam_nf_head_init(struct ssam_nf_head *nh)248{249	int status;250 251	status = init_srcu_struct(&nh->srcu);252	if (status)253		return status;254 255	INIT_LIST_HEAD(&nh->head);256	return 0;257}258 259/**260 * ssam_nf_head_destroy() - Deinitialize the given notifier head.261 * @nh: The notifier head to deinitialize.262 */263static void ssam_nf_head_destroy(struct ssam_nf_head *nh)264{265	cleanup_srcu_struct(&nh->srcu);266}267 268 269/* -- Event/notification registry. ------------------------------------------ */270 271/**272 * struct ssam_nf_refcount_key - Key used for event activation reference273 * counting.274 * @reg: The registry via which the event is enabled/disabled.275 * @id:  The ID uniquely describing the event.276 */277struct ssam_nf_refcount_key {278	struct ssam_event_registry reg;279	struct ssam_event_id id;280};281 282/**283 * struct ssam_nf_refcount_entry - RB-tree entry for reference counting event284 * activations.285 * @node:     The node of this entry in the rb-tree.286 * @key:      The key of the event.287 * @refcount: The reference-count of the event.288 * @flags:    The flags used when enabling the event.289 */290struct ssam_nf_refcount_entry {291	struct rb_node node;292	struct ssam_nf_refcount_key key;293	int refcount;294	u8 flags;295};296 297/**298 * ssam_nf_refcount_inc() - Increment reference-/activation-count of the given299 * event.300 * @nf:  The notifier system reference.301 * @reg: The registry used to enable/disable the event.302 * @id:  The event ID.303 *304 * Increments the reference-/activation-count associated with the specified305 * event type/ID, allocating a new entry for this event ID if necessary. A306 * newly allocated entry will have a refcount of one.307 *308 * Note: ``nf->lock`` must be held when calling this function.309 *310 * Return: Returns the refcount entry on success. Returns an error pointer311 * with %-ENOSPC if there have already been %INT_MAX events of the specified312 * ID and type registered, or %-ENOMEM if the entry could not be allocated.313 */314static struct ssam_nf_refcount_entry *315ssam_nf_refcount_inc(struct ssam_nf *nf, struct ssam_event_registry reg,316		     struct ssam_event_id id)317{318	struct ssam_nf_refcount_entry *entry;319	struct ssam_nf_refcount_key key;320	struct rb_node **link = &nf->refcount.rb_node;321	struct rb_node *parent = NULL;322	int cmp;323 324	lockdep_assert_held(&nf->lock);325 326	key.reg = reg;327	key.id = id;328 329	while (*link) {330		entry = rb_entry(*link, struct ssam_nf_refcount_entry, node);331		parent = *link;332 333		cmp = memcmp(&key, &entry->key, sizeof(key));334		if (cmp < 0) {335			link = &(*link)->rb_left;336		} else if (cmp > 0) {337			link = &(*link)->rb_right;338		} else if (entry->refcount < INT_MAX) {339			entry->refcount++;340			return entry;341		} else {342			WARN_ON(1);343			return ERR_PTR(-ENOSPC);344		}345	}346 347	entry = kzalloc(sizeof(*entry), GFP_KERNEL);348	if (!entry)349		return ERR_PTR(-ENOMEM);350 351	entry->key = key;352	entry->refcount = 1;353 354	rb_link_node(&entry->node, parent, link);355	rb_insert_color(&entry->node, &nf->refcount);356 357	return entry;358}359 360/**361 * ssam_nf_refcount_dec() - Decrement reference-/activation-count of the given362 * event.363 * @nf:  The notifier system reference.364 * @reg: The registry used to enable/disable the event.365 * @id:  The event ID.366 *367 * Decrements the reference-/activation-count of the specified event,368 * returning its entry. If the returned entry has a refcount of zero, the369 * caller is responsible for freeing it using kfree().370 *371 * Note: ``nf->lock`` must be held when calling this function.372 *373 * Return: Returns the refcount entry on success or %NULL if the entry has not374 * been found.375 */376static struct ssam_nf_refcount_entry *377ssam_nf_refcount_dec(struct ssam_nf *nf, struct ssam_event_registry reg,378		     struct ssam_event_id id)379{380	struct ssam_nf_refcount_entry *entry;381	struct ssam_nf_refcount_key key;382	struct rb_node *node = nf->refcount.rb_node;383	int cmp;384 385	lockdep_assert_held(&nf->lock);386 387	key.reg = reg;388	key.id = id;389 390	while (node) {391		entry = rb_entry(node, struct ssam_nf_refcount_entry, node);392 393		cmp = memcmp(&key, &entry->key, sizeof(key));394		if (cmp < 0) {395			node = node->rb_left;396		} else if (cmp > 0) {397			node = node->rb_right;398		} else {399			entry->refcount--;400			if (entry->refcount == 0)401				rb_erase(&entry->node, &nf->refcount);402 403			return entry;404		}405	}406 407	return NULL;408}409 410/**411 * ssam_nf_refcount_dec_free() - Decrement reference-/activation-count of the412 * given event and free its entry if the reference count reaches zero.413 * @nf:  The notifier system reference.414 * @reg: The registry used to enable/disable the event.415 * @id:  The event ID.416 *417 * Decrements the reference-/activation-count of the specified event, freeing418 * its entry if it reaches zero.419 *420 * Note: ``nf->lock`` must be held when calling this function.421 */422static void ssam_nf_refcount_dec_free(struct ssam_nf *nf,423				      struct ssam_event_registry reg,424				      struct ssam_event_id id)425{426	struct ssam_nf_refcount_entry *entry;427 428	lockdep_assert_held(&nf->lock);429 430	entry = ssam_nf_refcount_dec(nf, reg, id);431	if (entry && entry->refcount == 0)432		kfree(entry);433}434 435/**436 * ssam_nf_refcount_empty() - Test if the notification system has any437 * enabled/active events.438 * @nf: The notification system.439 */440static bool ssam_nf_refcount_empty(struct ssam_nf *nf)441{442	return RB_EMPTY_ROOT(&nf->refcount);443}444 445/**446 * ssam_nf_call() - Call notification callbacks for the provided event.447 * @nf:    The notifier system448 * @dev:   The associated device, only used for logging.449 * @rqid:  The request ID of the event.450 * @event: The event provided to the callbacks.451 *452 * Execute registered callbacks in order of their priority until either no453 * callback is left or a callback returns a value with the %SSAM_NOTIF_STOP454 * bit set. Note that this bit is set automatically when converting non-zero455 * error values via ssam_notifier_from_errno() to notifier values.456 *457 * Also note that any callback that could handle an event should return a value458 * with bit %SSAM_NOTIF_HANDLED set, indicating that the event does not go459 * unhandled/ignored. In case no registered callback could handle an event,460 * this function will emit a warning.461 *462 * In case a callback failed, this function will emit an error message.463 */464static void ssam_nf_call(struct ssam_nf *nf, struct device *dev, u16 rqid,465			 struct ssam_event *event)466{467	struct ssam_nf_head *nf_head;468	int status, nf_ret;469 470	if (!ssh_rqid_is_event(rqid)) {471		dev_warn(dev, "event: unsupported rqid: %#06x\n", rqid);472		return;473	}474 475	nf_head = &nf->head[ssh_rqid_to_event(rqid)];476	nf_ret = ssam_nfblk_call_chain(nf_head, event);477	status = ssam_notifier_to_errno(nf_ret);478 479	if (status < 0) {480		dev_err(dev,481			"event: error handling event: %d (tc: %#04x, tid: %#04x, cid: %#04x, iid: %#04x)\n",482			status, event->target_category, event->target_id,483			event->command_id, event->instance_id);484	} else if (!(nf_ret & SSAM_NOTIF_HANDLED)) {485		dev_warn(dev,486			 "event: unhandled event (rqid: %#04x, tc: %#04x, tid: %#04x, cid: %#04x, iid: %#04x)\n",487			 rqid, event->target_category, event->target_id,488			 event->command_id, event->instance_id);489	}490}491 492/**493 * ssam_nf_init() - Initialize the notifier system.494 * @nf: The notifier system to initialize.495 */496static int ssam_nf_init(struct ssam_nf *nf)497{498	int i, status;499 500	for (i = 0; i < SSH_NUM_EVENTS; i++) {501		status = ssam_nf_head_init(&nf->head[i]);502		if (status)503			break;504	}505 506	if (status) {507		while (i--)508			ssam_nf_head_destroy(&nf->head[i]);509 510		return status;511	}512 513	mutex_init(&nf->lock);514	return 0;515}516 517/**518 * ssam_nf_destroy() - Deinitialize the notifier system.519 * @nf: The notifier system to deinitialize.520 */521static void ssam_nf_destroy(struct ssam_nf *nf)522{523	int i;524 525	for (i = 0; i < SSH_NUM_EVENTS; i++)526		ssam_nf_head_destroy(&nf->head[i]);527 528	mutex_destroy(&nf->lock);529}530 531 532/* -- Event/async request completion system. -------------------------------- */533 534#define SSAM_CPLT_WQ_NAME	"ssam_cpltq"535 536/*537 * SSAM_CPLT_WQ_BATCH - Maximum number of event item completions executed per538 * work execution. Used to prevent livelocking of the workqueue. Value chosen539 * via educated guess, may be adjusted.540 */541#define SSAM_CPLT_WQ_BATCH	10542 543/*544 * SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN - Maximum payload length for a cached545 * &struct ssam_event_item.546 *547 * This length has been chosen to be accommodate standard touchpad and548 * keyboard input events. Events with larger payloads will be allocated549 * separately.550 */551#define SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN	32552 553static struct kmem_cache *ssam_event_item_cache;554 555/**556 * ssam_event_item_cache_init() - Initialize the event item cache.557 */558int ssam_event_item_cache_init(void)559{560	const unsigned int size = sizeof(struct ssam_event_item)561				  + SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN;562	const unsigned int align = __alignof__(struct ssam_event_item);563	struct kmem_cache *cache;564 565	cache = kmem_cache_create("ssam_event_item", size, align, 0, NULL);566	if (!cache)567		return -ENOMEM;568 569	ssam_event_item_cache = cache;570	return 0;571}572 573/**574 * ssam_event_item_cache_destroy() - Deinitialize the event item cache.575 */576void ssam_event_item_cache_destroy(void)577{578	kmem_cache_destroy(ssam_event_item_cache);579	ssam_event_item_cache = NULL;580}581 582static void __ssam_event_item_free_cached(struct ssam_event_item *item)583{584	kmem_cache_free(ssam_event_item_cache, item);585}586 587static void __ssam_event_item_free_generic(struct ssam_event_item *item)588{589	kfree(item);590}591 592/**593 * ssam_event_item_free() - Free the provided event item.594 * @item: The event item to free.595 */596static void ssam_event_item_free(struct ssam_event_item *item)597{598	trace_ssam_event_item_free(item);599	item->ops.free(item);600}601 602/**603 * ssam_event_item_alloc() - Allocate an event item with the given payload size.604 * @len:   The event payload length.605 * @flags: The flags used for allocation.606 *607 * Allocate an event item with the given payload size, preferring allocation608 * from the event item cache if the payload is small enough (i.e. smaller than609 * %SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN). Sets the item operations and payload610 * length values. The item free callback (``ops.free``) should not be611 * overwritten after this call.612 *613 * Return: Returns the newly allocated event item.614 */615static struct ssam_event_item *ssam_event_item_alloc(size_t len, gfp_t flags)616{617	struct ssam_event_item *item;618 619	if (len <= SSAM_EVENT_ITEM_CACHE_PAYLOAD_LEN) {620		item = kmem_cache_alloc(ssam_event_item_cache, flags);621		if (!item)622			return NULL;623 624		item->ops.free = __ssam_event_item_free_cached;625	} else {626		item = kzalloc(struct_size(item, event.data, len), flags);627		if (!item)628			return NULL;629 630		item->ops.free = __ssam_event_item_free_generic;631	}632 633	item->event.length = len;634 635	trace_ssam_event_item_alloc(item, len);636	return item;637}638 639/**640 * ssam_event_queue_push() - Push an event item to the event queue.641 * @q:    The event queue.642 * @item: The item to add.643 */644static void ssam_event_queue_push(struct ssam_event_queue *q,645				  struct ssam_event_item *item)646{647	spin_lock(&q->lock);648	list_add_tail(&item->node, &q->head);649	spin_unlock(&q->lock);650}651 652/**653 * ssam_event_queue_pop() - Pop the next event item from the event queue.654 * @q: The event queue.655 *656 * Returns and removes the next event item from the queue. Returns %NULL If657 * there is no event item left.658 */659static struct ssam_event_item *ssam_event_queue_pop(struct ssam_event_queue *q)660{661	struct ssam_event_item *item;662 663	spin_lock(&q->lock);664	item = list_first_entry_or_null(&q->head, struct ssam_event_item, node);665	if (item)666		list_del(&item->node);667	spin_unlock(&q->lock);668 669	return item;670}671 672/**673 * ssam_event_queue_is_empty() - Check if the event queue is empty.674 * @q: The event queue.675 */676static bool ssam_event_queue_is_empty(struct ssam_event_queue *q)677{678	bool empty;679 680	spin_lock(&q->lock);681	empty = list_empty(&q->head);682	spin_unlock(&q->lock);683 684	return empty;685}686 687/**688 * ssam_cplt_get_event_queue() - Get the event queue for the given parameters.689 * @cplt: The completion system on which to look for the queue.690 * @tid:  The target ID of the queue.691 * @rqid: The request ID representing the event ID for which to get the queue.692 *693 * Return: Returns the event queue corresponding to the event type described694 * by the given parameters. If the request ID does not represent an event,695 * this function returns %NULL. If the target ID is not supported, this696 * function will fall back to the default target ID (``tid = 1``).697 */698static699struct ssam_event_queue *ssam_cplt_get_event_queue(struct ssam_cplt *cplt,700						   u8 tid, u16 rqid)701{702	u16 event = ssh_rqid_to_event(rqid);703	u16 tidx = ssh_tid_to_index(tid);704 705	if (!ssh_rqid_is_event(rqid)) {706		dev_err(cplt->dev, "event: unsupported request ID: %#06x\n", rqid);707		return NULL;708	}709 710	if (!ssh_tid_is_valid(tid)) {711		dev_warn(cplt->dev, "event: unsupported target ID: %u\n", tid);712		tidx = 0;713	}714 715	return &cplt->event.target[tidx].queue[event];716}717 718/**719 * ssam_cplt_submit() - Submit a work item to the completion system workqueue.720 * @cplt: The completion system.721 * @work: The work item to submit.722 */723static bool ssam_cplt_submit(struct ssam_cplt *cplt, struct work_struct *work)724{725	return queue_work(cplt->wq, work);726}727 728/**729 * ssam_cplt_submit_event() - Submit an event to the completion system.730 * @cplt: The completion system.731 * @item: The event item to submit.732 *733 * Submits the event to the completion system by queuing it on the event item734 * queue and queuing the respective event queue work item on the completion735 * workqueue, which will eventually complete the event.736 *737 * Return: Returns zero on success, %-EINVAL if there is no event queue that738 * can handle the given event item.739 */740static int ssam_cplt_submit_event(struct ssam_cplt *cplt,741				  struct ssam_event_item *item)742{743	struct ssam_event_queue *evq;744 745	evq = ssam_cplt_get_event_queue(cplt, item->event.target_id, item->rqid);746	if (!evq)747		return -EINVAL;748 749	ssam_event_queue_push(evq, item);750	ssam_cplt_submit(cplt, &evq->work);751	return 0;752}753 754/**755 * ssam_cplt_flush() - Flush the completion system.756 * @cplt: The completion system.757 *758 * Flush the completion system by waiting until all currently submitted work759 * items have been completed.760 *761 * Note: This function does not guarantee that all events will have been762 * handled once this call terminates. In case of a larger number of763 * to-be-completed events, the event queue work function may re-schedule its764 * work item, which this flush operation will ignore.765 *766 * This operation is only intended to, during normal operation prior to767 * shutdown, try to complete most events and requests to get them out of the768 * system while the system is still fully operational. It does not aim to769 * provide any guarantee that all of them have been handled.770 */771static void ssam_cplt_flush(struct ssam_cplt *cplt)772{773	flush_workqueue(cplt->wq);774}775 776static void ssam_event_queue_work_fn(struct work_struct *work)777{778	struct ssam_event_queue *queue;779	struct ssam_event_item *item;780	struct ssam_nf *nf;781	struct device *dev;782	unsigned int iterations = SSAM_CPLT_WQ_BATCH;783 784	queue = container_of(work, struct ssam_event_queue, work);785	nf = &queue->cplt->event.notif;786	dev = queue->cplt->dev;787 788	/* Limit number of processed events to avoid livelocking. */789	do {790		item = ssam_event_queue_pop(queue);791		if (!item)792			return;793 794		ssam_nf_call(nf, dev, item->rqid, &item->event);795		ssam_event_item_free(item);796	} while (--iterations);797 798	if (!ssam_event_queue_is_empty(queue))799		ssam_cplt_submit(queue->cplt, &queue->work);800}801 802/**803 * ssam_event_queue_init() - Initialize an event queue.804 * @cplt: The completion system on which the queue resides.805 * @evq:  The event queue to initialize.806 */807static void ssam_event_queue_init(struct ssam_cplt *cplt,808				  struct ssam_event_queue *evq)809{810	evq->cplt = cplt;811	spin_lock_init(&evq->lock);812	INIT_LIST_HEAD(&evq->head);813	INIT_WORK(&evq->work, ssam_event_queue_work_fn);814}815 816/**817 * ssam_cplt_init() - Initialize completion system.818 * @cplt: The completion system to initialize.819 * @dev:  The device used for logging.820 */821static int ssam_cplt_init(struct ssam_cplt *cplt, struct device *dev)822{823	struct ssam_event_target *target;824	int status, c, i;825 826	cplt->dev = dev;827 828	cplt->wq = alloc_workqueue(SSAM_CPLT_WQ_NAME, WQ_UNBOUND | WQ_MEM_RECLAIM, 0);829	if (!cplt->wq)830		return -ENOMEM;831 832	for (c = 0; c < ARRAY_SIZE(cplt->event.target); c++) {833		target = &cplt->event.target[c];834 835		for (i = 0; i < ARRAY_SIZE(target->queue); i++)836			ssam_event_queue_init(cplt, &target->queue[i]);837	}838 839	status = ssam_nf_init(&cplt->event.notif);840	if (status)841		destroy_workqueue(cplt->wq);842 843	return status;844}845 846/**847 * ssam_cplt_destroy() - Deinitialize the completion system.848 * @cplt: The completion system to deinitialize.849 *850 * Deinitialize the given completion system and ensure that all pending, i.e.851 * yet-to-be-completed, event items and requests have been handled.852 */853static void ssam_cplt_destroy(struct ssam_cplt *cplt)854{855	/*856	 * Note: destroy_workqueue ensures that all currently queued work will857	 * be fully completed and the workqueue drained. This means that this858	 * call will inherently also free any queued ssam_event_items, thus we859	 * don't have to take care of that here explicitly.860	 */861	destroy_workqueue(cplt->wq);862	ssam_nf_destroy(&cplt->event.notif);863}864 865 866/* -- Main SSAM device structures. ------------------------------------------ */867 868/**869 * ssam_controller_device() - Get the &struct device associated with this870 * controller.871 * @c: The controller for which to get the device.872 *873 * Return: Returns the &struct device associated with this controller,874 * providing its lower-level transport.875 */876struct device *ssam_controller_device(struct ssam_controller *c)877{878	return ssh_rtl_get_device(&c->rtl);879}880EXPORT_SYMBOL_GPL(ssam_controller_device);881 882static void __ssam_controller_release(struct kref *kref)883{884	struct ssam_controller *ctrl = to_ssam_controller(kref, kref);885 886	/*887	 * The lock-call here is to satisfy lockdep. At this point we really888	 * expect this to be the last remaining reference to the controller.889	 * Anything else is a bug.890	 */891	ssam_controller_lock(ctrl);892	ssam_controller_destroy(ctrl);893	ssam_controller_unlock(ctrl);894 895	kfree(ctrl);896}897 898/**899 * ssam_controller_get() - Increment reference count of controller.900 * @c: The controller.901 *902 * Return: Returns the controller provided as input.903 */904struct ssam_controller *ssam_controller_get(struct ssam_controller *c)905{906	if (c)907		kref_get(&c->kref);908	return c;909}910EXPORT_SYMBOL_GPL(ssam_controller_get);911 912/**913 * ssam_controller_put() - Decrement reference count of controller.914 * @c: The controller.915 */916void ssam_controller_put(struct ssam_controller *c)917{918	if (c)919		kref_put(&c->kref, __ssam_controller_release);920}921EXPORT_SYMBOL_GPL(ssam_controller_put);922 923/**924 * ssam_controller_statelock() - Lock the controller against state transitions.925 * @c: The controller to lock.926 *927 * Lock the controller against state transitions. Holding this lock guarantees928 * that the controller will not transition between states, i.e. if the929 * controller is in state "started", when this lock has been acquired, it will930 * remain in this state at least until the lock has been released.931 *932 * Multiple clients may concurrently hold this lock. In other words: The933 * ``statelock`` functions represent the read-lock part of a r/w-semaphore.934 * Actions causing state transitions of the controller must be executed while935 * holding the write-part of this r/w-semaphore (see ssam_controller_lock()936 * and ssam_controller_unlock() for that).937 *938 * See ssam_controller_stateunlock() for the corresponding unlock function.939 */940void ssam_controller_statelock(struct ssam_controller *c)941{942	down_read(&c->lock);943}944EXPORT_SYMBOL_GPL(ssam_controller_statelock);945 946/**947 * ssam_controller_stateunlock() - Unlock controller state transitions.948 * @c: The controller to unlock.949 *950 * See ssam_controller_statelock() for the corresponding lock function.951 */952void ssam_controller_stateunlock(struct ssam_controller *c)953{954	up_read(&c->lock);955}956EXPORT_SYMBOL_GPL(ssam_controller_stateunlock);957 958/**959 * ssam_controller_lock() - Acquire the main controller lock.960 * @c: The controller to lock.961 *962 * This lock must be held for any state transitions, including transition to963 * suspend/resumed states and during shutdown. See ssam_controller_statelock()964 * for more details on controller locking.965 *966 * See ssam_controller_unlock() for the corresponding unlock function.967 */968void ssam_controller_lock(struct ssam_controller *c)969{970	down_write(&c->lock);971}972 973/*974 * ssam_controller_unlock() - Release the main controller lock.975 * @c: The controller to unlock.976 *977 * See ssam_controller_lock() for the corresponding lock function.978 */979void ssam_controller_unlock(struct ssam_controller *c)980{981	up_write(&c->lock);982}983 984static void ssam_handle_event(struct ssh_rtl *rtl,985			      const struct ssh_command *cmd,986			      const struct ssam_span *data)987{988	struct ssam_controller *ctrl = to_ssam_controller(rtl, rtl);989	struct ssam_event_item *item;990 991	item = ssam_event_item_alloc(data->len, GFP_KERNEL);992	if (!item)993		return;994 995	item->rqid = get_unaligned_le16(&cmd->rqid);996	item->event.target_category = cmd->tc;997	item->event.target_id = cmd->sid;998	item->event.command_id = cmd->cid;999	item->event.instance_id = cmd->iid;1000	memcpy(&item->event.data[0], data->ptr, data->len);1001 1002	if (WARN_ON(ssam_cplt_submit_event(&ctrl->cplt, item)))1003		ssam_event_item_free(item);1004}1005 1006static const struct ssh_rtl_ops ssam_rtl_ops = {1007	.handle_event = ssam_handle_event,1008};1009 1010static bool ssam_notifier_is_empty(struct ssam_controller *ctrl);1011static void ssam_notifier_unregister_all(struct ssam_controller *ctrl);1012 1013#define SSAM_SSH_DSM_REVISION	01014 1015/* d5e383e1-d892-4a76-89fc-f6aaae7ed5b5 */1016static const guid_t SSAM_SSH_DSM_GUID =1017	GUID_INIT(0xd5e383e1, 0xd892, 0x4a76,1018		  0x89, 0xfc, 0xf6, 0xaa, 0xae, 0x7e, 0xd5, 0xb5);1019 1020enum ssh_dsm_fn {1021	SSH_DSM_FN_SSH_POWER_PROFILE             = 0x05,1022	SSH_DSM_FN_SCREEN_ON_SLEEP_IDLE_TIMEOUT  = 0x06,1023	SSH_DSM_FN_SCREEN_OFF_SLEEP_IDLE_TIMEOUT = 0x07,1024	SSH_DSM_FN_D3_CLOSES_HANDLE              = 0x08,1025	SSH_DSM_FN_SSH_BUFFER_SIZE               = 0x09,1026};1027 1028static int ssam_dsm_get_functions(acpi_handle handle, u64 *funcs)1029{1030	union acpi_object *obj;1031	u64 mask = 0;1032	int i;1033 1034	*funcs = 0;1035 1036	/*1037	 * The _DSM function is only present on newer models. It is not1038	 * present on 5th and 6th generation devices (i.e. up to and including1039	 * Surface Pro 6, Surface Laptop 2, Surface Book 2).1040	 *1041	 * If the _DSM is not present, indicate that no function is supported.1042	 * This will result in default values being set.1043	 */1044	if (!acpi_has_method(handle, "_DSM"))1045		return 0;1046 1047	obj = acpi_evaluate_dsm_typed(handle, &SSAM_SSH_DSM_GUID,1048				      SSAM_SSH_DSM_REVISION, 0, NULL,1049				      ACPI_TYPE_BUFFER);1050	if (!obj)1051		return -EIO;1052 1053	for (i = 0; i < obj->buffer.length && i < 8; i++)1054		mask |= (((u64)obj->buffer.pointer[i]) << (i * 8));1055 1056	if (mask & BIT(0))1057		*funcs = mask;1058 1059	ACPI_FREE(obj);1060	return 0;1061}1062 1063static int ssam_dsm_load_u32(acpi_handle handle, u64 funcs, u64 func, u32 *ret)1064{1065	union acpi_object *obj;1066	u64 val;1067 1068	if (!(funcs & BIT_ULL(func)))1069		return 0; /* Not supported, leave *ret at its default value */1070 1071	obj = acpi_evaluate_dsm_typed(handle, &SSAM_SSH_DSM_GUID,1072				      SSAM_SSH_DSM_REVISION, func, NULL,1073				      ACPI_TYPE_INTEGER);1074	if (!obj)1075		return -EIO;1076 1077	val = obj->integer.value;1078	ACPI_FREE(obj);1079 1080	if (val > U32_MAX)1081		return -ERANGE;1082 1083	*ret = val;1084	return 0;1085}1086 1087/**1088 * ssam_controller_caps_load_from_acpi() - Load controller capabilities from1089 * ACPI _DSM.1090 * @handle: The handle of the ACPI controller/SSH device.1091 * @caps:   Where to store the capabilities in.1092 *1093 * Initializes the given controller capabilities with default values, then1094 * checks and, if the respective _DSM functions are available, loads the1095 * actual capabilities from the _DSM.1096 *1097 * Return: Returns zero on success, a negative error code on failure.1098 */1099static1100int ssam_controller_caps_load_from_acpi(acpi_handle handle,1101					struct ssam_controller_caps *caps)1102{1103	u32 d3_closes_handle = false;1104	u64 funcs;1105	int status;1106 1107	/* Pre-load supported DSM functions. */1108	status = ssam_dsm_get_functions(handle, &funcs);1109	if (status)1110		return status;1111 1112	/* Load actual values from ACPI, if present. */1113	status = ssam_dsm_load_u32(handle, funcs, SSH_DSM_FN_SSH_POWER_PROFILE,1114				   &caps->ssh_power_profile);1115	if (status)1116		return status;1117 1118	status = ssam_dsm_load_u32(handle, funcs,1119				   SSH_DSM_FN_SCREEN_ON_SLEEP_IDLE_TIMEOUT,1120				   &caps->screen_on_sleep_idle_timeout);1121	if (status)1122		return status;1123 1124	status = ssam_dsm_load_u32(handle, funcs,1125				   SSH_DSM_FN_SCREEN_OFF_SLEEP_IDLE_TIMEOUT,1126				   &caps->screen_off_sleep_idle_timeout);1127	if (status)1128		return status;1129 1130	status = ssam_dsm_load_u32(handle, funcs, SSH_DSM_FN_D3_CLOSES_HANDLE,1131				   &d3_closes_handle);1132	if (status)1133		return status;1134 1135	caps->d3_closes_handle = !!d3_closes_handle;1136 1137	status = ssam_dsm_load_u32(handle, funcs, SSH_DSM_FN_SSH_BUFFER_SIZE,1138				   &caps->ssh_buffer_size);1139	if (status)1140		return status;1141 1142	return 0;1143}1144 1145/**1146 * ssam_controller_caps_load_from_of() - Load controller capabilities from OF/DT.1147 * @dev:  A pointer to the controller device1148 * @caps: Where to store the capabilities in.1149 *1150 * Return: Returns zero on success, a negative error code on failure.1151 */1152static int ssam_controller_caps_load_from_of(struct device *dev, struct ssam_controller_caps *caps)1153{1154	/*1155	 * Every device starting with Surface Pro X through Laptop 7 uses these1156	 * identical values, which makes them good defaults.1157	 */1158	caps->d3_closes_handle = true;1159	caps->screen_on_sleep_idle_timeout = 5000;1160	caps->screen_off_sleep_idle_timeout = 30;1161	caps->ssh_buffer_size = 48;1162	/* TODO: figure out power profile */1163 1164	return 0;1165}1166 1167/**1168 * ssam_controller_caps_load() - Load controller capabilities1169 * @dev:  A pointer to the controller device1170 * @caps: Where to store the capabilities in.1171 *1172 * Return: Returns zero on success, a negative error code on failure.1173 */1174static int ssam_controller_caps_load(struct device *dev, struct ssam_controller_caps *caps)1175{1176	acpi_handle handle = ACPI_HANDLE(dev);1177 1178	/* Set defaults. */1179	caps->ssh_power_profile = U32_MAX;1180	caps->screen_on_sleep_idle_timeout = U32_MAX;1181	caps->screen_off_sleep_idle_timeout = U32_MAX;1182	caps->d3_closes_handle = false;1183	caps->ssh_buffer_size = U32_MAX;1184 1185	if (handle)1186		return ssam_controller_caps_load_from_acpi(handle, caps);1187	else1188		return ssam_controller_caps_load_from_of(dev, caps);1189}1190 1191/**1192 * ssam_controller_init() - Initialize SSAM controller.1193 * @ctrl:   The controller to initialize.1194 * @serdev: The serial device representing the underlying data transport.1195 *1196 * Initializes the given controller. Does neither start receiver nor1197 * transmitter threads. After this call, the controller has to be hooked up to1198 * the serdev core separately via &struct serdev_device_ops, relaying calls to1199 * ssam_controller_receive_buf() and ssam_controller_write_wakeup(). Once the1200 * controller has been hooked up, transmitter and receiver threads may be1201 * started via ssam_controller_start(). These setup steps need to be completed1202 * before controller can be used for requests.1203 */1204int ssam_controller_init(struct ssam_controller *ctrl,1205			 struct serdev_device *serdev)1206{1207	int status;1208 1209	init_rwsem(&ctrl->lock);1210	kref_init(&ctrl->kref);1211 1212	status = ssam_controller_caps_load(&serdev->dev, &ctrl->caps);1213	if (status)1214		return status;1215 1216	dev_dbg(&serdev->dev,1217		"device capabilities:\n"1218		"  ssh_power_profile:             %u\n"1219		"  ssh_buffer_size:               %u\n"1220		"  screen_on_sleep_idle_timeout:  %u\n"1221		"  screen_off_sleep_idle_timeout: %u\n"1222		"  d3_closes_handle:              %u\n",1223		ctrl->caps.ssh_power_profile,1224		ctrl->caps.ssh_buffer_size,1225		ctrl->caps.screen_on_sleep_idle_timeout,1226		ctrl->caps.screen_off_sleep_idle_timeout,1227		ctrl->caps.d3_closes_handle);1228 1229	ssh_seq_reset(&ctrl->counter.seq);1230	ssh_rqid_reset(&ctrl->counter.rqid);1231 1232	/* Initialize event/request completion system. */1233	status = ssam_cplt_init(&ctrl->cplt, &serdev->dev);1234	if (status)1235		return status;1236 1237	/* Initialize request and packet transport layers. */1238	status = ssh_rtl_init(&ctrl->rtl, serdev, &ssam_rtl_ops);1239	if (status) {1240		ssam_cplt_destroy(&ctrl->cplt);1241		return status;1242	}1243 1244	/*1245	 * Set state via write_once even though we expect to be in an1246	 * exclusive context, due to smoke-testing in1247	 * ssam_request_sync_submit().1248	 */1249	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_INITIALIZED);1250	return 0;1251}1252 1253/**1254 * ssam_controller_start() - Start the receiver and transmitter threads of the1255 * controller.1256 * @ctrl: The controller.1257 *1258 * Note: When this function is called, the controller should be properly1259 * hooked up to the serdev core via &struct serdev_device_ops. Please refer1260 * to ssam_controller_init() for more details on controller initialization.1261 *1262 * This function must be called with the main controller lock held (i.e. by1263 * calling ssam_controller_lock()).1264 */1265int ssam_controller_start(struct ssam_controller *ctrl)1266{1267	int status;1268 1269	lockdep_assert_held_write(&ctrl->lock);1270 1271	if (ctrl->state != SSAM_CONTROLLER_INITIALIZED)1272		return -EINVAL;1273 1274	status = ssh_rtl_start(&ctrl->rtl);1275	if (status)1276		return status;1277 1278	/*1279	 * Set state via write_once even though we expect to be locked/in an1280	 * exclusive context, due to smoke-testing in1281	 * ssam_request_sync_submit().1282	 */1283	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STARTED);1284	return 0;1285}1286 1287/*1288 * SSAM_CTRL_SHUTDOWN_FLUSH_TIMEOUT - Timeout for flushing requests during1289 * shutdown.1290 *1291 * Chosen to be larger than one full request timeout, including packets timing1292 * out. This value should give ample time to complete any outstanding requests1293 * during normal operation and account for the odd package timeout.1294 */1295#define SSAM_CTRL_SHUTDOWN_FLUSH_TIMEOUT	msecs_to_jiffies(5000)1296 1297/**1298 * ssam_controller_shutdown() - Shut down the controller.1299 * @ctrl: The controller.1300 *1301 * Shuts down the controller by flushing all pending requests and stopping the1302 * transmitter and receiver threads. All requests submitted after this call1303 * will fail with %-ESHUTDOWN. While it is discouraged to do so, this function1304 * is safe to use in parallel with ongoing request submission.1305 *1306 * In the course of this shutdown procedure, all currently registered1307 * notifiers will be unregistered. It is, however, strongly recommended to not1308 * rely on this behavior, and instead the party registering the notifier1309 * should unregister it before the controller gets shut down, e.g. via the1310 * SSAM bus which guarantees client devices to be removed before a shutdown.1311 *1312 * Note that events may still be pending after this call, but, due to the1313 * notifiers being unregistered, these events will be dropped when the1314 * controller is subsequently destroyed via ssam_controller_destroy().1315 *1316 * This function must be called with the main controller lock held (i.e. by1317 * calling ssam_controller_lock()).1318 */1319void ssam_controller_shutdown(struct ssam_controller *ctrl)1320{1321	enum ssam_controller_state s = ctrl->state;1322	int status;1323 1324	lockdep_assert_held_write(&ctrl->lock);1325 1326	if (s == SSAM_CONTROLLER_UNINITIALIZED || s == SSAM_CONTROLLER_STOPPED)1327		return;1328 1329	/*1330	 * Try to flush pending events and requests while everything still1331	 * works. Note: There may still be packets and/or requests in the1332	 * system after this call (e.g. via control packets submitted by the1333	 * packet transport layer or flush timeout / failure, ...). Those will1334	 * be handled with the ssh_rtl_shutdown() call below.1335	 */1336	status = ssh_rtl_flush(&ctrl->rtl, SSAM_CTRL_SHUTDOWN_FLUSH_TIMEOUT);1337	if (status) {1338		ssam_err(ctrl, "failed to flush request transport layer: %d\n",1339			 status);1340	}1341 1342	/* Try to flush all currently completing requests and events. */1343	ssam_cplt_flush(&ctrl->cplt);1344 1345	/*1346	 * We expect all notifiers to have been removed by the respective client1347	 * driver that set them up at this point. If this warning occurs, some1348	 * client driver has not done that...1349	 */1350	WARN_ON(!ssam_notifier_is_empty(ctrl));1351 1352	/*1353	 * Nevertheless, we should still take care of drivers that don't behave1354	 * well. Thus disable all enabled events, unregister all notifiers.1355	 */1356	ssam_notifier_unregister_all(ctrl);1357 1358	/*1359	 * Cancel remaining requests. Ensure no new ones can be queued and stop1360	 * threads.1361	 */1362	ssh_rtl_shutdown(&ctrl->rtl);1363 1364	/*1365	 * Set state via write_once even though we expect to be locked/in an1366	 * exclusive context, due to smoke-testing in1367	 * ssam_request_sync_submit().1368	 */1369	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STOPPED);1370	ctrl->rtl.ptl.serdev = NULL;1371}1372 1373/**1374 * ssam_controller_destroy() - Destroy the controller and free its resources.1375 * @ctrl: The controller.1376 *1377 * Ensures that all resources associated with the controller get freed. This1378 * function should only be called after the controller has been stopped via1379 * ssam_controller_shutdown(). In general, this function should not be called1380 * directly. The only valid place to call this function directly is during1381 * initialization, before the controller has been fully initialized and passed1382 * to other processes. This function is called automatically when the1383 * reference count of the controller reaches zero.1384 *1385 * This function must be called with the main controller lock held (i.e. by1386 * calling ssam_controller_lock()).1387 */1388void ssam_controller_destroy(struct ssam_controller *ctrl)1389{1390	lockdep_assert_held_write(&ctrl->lock);1391 1392	if (ctrl->state == SSAM_CONTROLLER_UNINITIALIZED)1393		return;1394 1395	WARN_ON(ctrl->state != SSAM_CONTROLLER_STOPPED &&1396		ctrl->state != SSAM_CONTROLLER_INITIALIZED);1397 1398	/*1399	 * Note: New events could still have been received after the previous1400	 * flush in ssam_controller_shutdown, before the request transport layer1401	 * has been shut down. At this point, after the shutdown, we can be sure1402	 * that no new events will be queued. The call to ssam_cplt_destroy will1403	 * ensure that those remaining are being completed and freed.1404	 */1405 1406	/* Actually free resources. */1407	ssam_cplt_destroy(&ctrl->cplt);1408	ssh_rtl_destroy(&ctrl->rtl);1409 1410	/*1411	 * Set state via write_once even though we expect to be locked/in an1412	 * exclusive context, due to smoke-testing in1413	 * ssam_request_sync_submit().1414	 */1415	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_UNINITIALIZED);1416}1417 1418/**1419 * ssam_controller_suspend() - Suspend the controller.1420 * @ctrl: The controller to suspend.1421 *1422 * Marks the controller as suspended. Note that display-off and D0-exit1423 * notifications have to be sent manually before transitioning the controller1424 * into the suspended state via this function.1425 *1426 * See ssam_controller_resume() for the corresponding resume function.1427 *1428 * Return: Returns %-EINVAL if the controller is currently not in the1429 * "started" state.1430 */1431int ssam_controller_suspend(struct ssam_controller *ctrl)1432{1433	ssam_controller_lock(ctrl);1434 1435	if (ctrl->state != SSAM_CONTROLLER_STARTED) {1436		ssam_controller_unlock(ctrl);1437		return -EINVAL;1438	}1439 1440	ssam_dbg(ctrl, "pm: suspending controller\n");1441 1442	/*1443	 * Set state via write_once even though we're locked, due to1444	 * smoke-testing in ssam_request_sync_submit().1445	 */1446	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_SUSPENDED);1447 1448	ssam_controller_unlock(ctrl);1449	return 0;1450}1451 1452/**1453 * ssam_controller_resume() - Resume the controller from suspend.1454 * @ctrl: The controller to resume.1455 *1456 * Resume the controller from the suspended state it was put into via1457 * ssam_controller_suspend(). This function does not issue display-on and1458 * D0-entry notifications. If required, those have to be sent manually after1459 * this call.1460 *1461 * Return: Returns %-EINVAL if the controller is currently not suspended.1462 */1463int ssam_controller_resume(struct ssam_controller *ctrl)1464{1465	ssam_controller_lock(ctrl);1466 1467	if (ctrl->state != SSAM_CONTROLLER_SUSPENDED) {1468		ssam_controller_unlock(ctrl);1469		return -EINVAL;1470	}1471 1472	ssam_dbg(ctrl, "pm: resuming controller\n");1473 1474	/*1475	 * Set state via write_once even though we're locked, due to1476	 * smoke-testing in ssam_request_sync_submit().1477	 */1478	WRITE_ONCE(ctrl->state, SSAM_CONTROLLER_STARTED);1479 1480	ssam_controller_unlock(ctrl);1481	return 0;1482}1483 1484 1485/* -- Top-level request interface ------------------------------------------- */1486 1487/**1488 * ssam_request_write_data() - Construct and write SAM request message to1489 * buffer.1490 * @buf:  The buffer to write the data to.1491 * @ctrl: The controller via which the request will be sent.1492 * @spec: The request data and specification.1493 *1494 * Constructs a SAM/SSH request message and writes it to the provided buffer.1495 * The request and transport counters, specifically RQID and SEQ, will be set1496 * in this call. These counters are obtained from the controller. It is thus1497 * only valid to send the resulting message via the controller specified here.1498 *1499 * For calculation of the required buffer size, refer to the1500 * SSH_COMMAND_MESSAGE_LENGTH() macro.1501 *1502 * Return: Returns the number of bytes used in the buffer on success. Returns1503 * %-EINVAL if the payload length provided in the request specification is too1504 * large (larger than %SSH_COMMAND_MAX_PAYLOAD_SIZE) or if the provided buffer1505 * is too small.1506 */1507ssize_t ssam_request_write_data(struct ssam_span *buf,1508				struct ssam_controller *ctrl,1509				const struct ssam_request *spec)1510{1511	struct msgbuf msgb;1512	u16 rqid;1513	u8 seq;1514 1515	if (spec->length > SSH_COMMAND_MAX_PAYLOAD_SIZE)1516		return -EINVAL;1517 1518	if (SSH_COMMAND_MESSAGE_LENGTH(spec->length) > buf->len)1519		return -EINVAL;1520 1521	msgb_init(&msgb, buf->ptr, buf->len);1522	seq = ssh_seq_next(&ctrl->counter.seq);1523	rqid = ssh_rqid_next(&ctrl->counter.rqid);1524	msgb_push_cmd(&msgb, seq, rqid, spec);1525 1526	return msgb_bytes_used(&msgb);1527}1528EXPORT_SYMBOL_GPL(ssam_request_write_data);1529 1530static void ssam_request_sync_complete(struct ssh_request *rqst,1531				       const struct ssh_command *cmd,1532				       const struct ssam_span *data, int status)1533{1534	struct ssh_rtl *rtl = ssh_request_rtl(rqst);1535	struct ssam_request_sync *r;1536 1537	r = container_of(rqst, struct ssam_request_sync, base);1538	r->status = status;1539 1540	if (r->resp)1541		r->resp->length = 0;1542 1543	if (status) {1544		rtl_dbg_cond(rtl, "rsp: request failed: %d\n", status);1545		return;1546	}1547 1548	if (!data)	/* Handle requests without a response. */1549		return;1550 1551	if (!r->resp || !r->resp->pointer) {1552		if (data->len)1553			rtl_warn(rtl, "rsp: no response buffer provided, dropping data\n");1554		return;1555	}1556 1557	if (data->len > r->resp->capacity) {1558		rtl_err(rtl,1559			"rsp: response buffer too small, capacity: %zu bytes, got: %zu bytes\n",1560			r->resp->capacity, data->len);1561		r->status = -ENOSPC;1562		return;1563	}1564 1565	r->resp->length = data->len;1566	memcpy(r->resp->pointer, data->ptr, data->len);1567}1568 1569static void ssam_request_sync_release(struct ssh_request *rqst)1570{1571	complete_all(&container_of(rqst, struct ssam_request_sync, base)->comp);1572}1573 1574static const struct ssh_request_ops ssam_request_sync_ops = {1575	.release = ssam_request_sync_release,1576	.complete = ssam_request_sync_complete,1577};1578 1579/**1580 * ssam_request_sync_alloc() - Allocate a synchronous request.1581 * @payload_len: The length of the request payload.1582 * @flags:       Flags used for allocation.1583 * @rqst:        Where to store the pointer to the allocated request.1584 * @buffer:      Where to store the buffer descriptor for the message buffer of1585 *               the request.1586 *1587 * Allocates a synchronous request with corresponding message buffer. The1588 * request still needs to be initialized ssam_request_sync_init() before1589 * it can be submitted, and the message buffer data must still be set to the1590 * returned buffer via ssam_request_sync_set_data() after it has been filled,1591 * if need be with adjusted message length.1592 *1593 * After use, the request and its corresponding message buffer should be freed1594 * via ssam_request_sync_free(). The buffer must not be freed separately.1595 *1596 * Return: Returns zero on success, %-ENOMEM if the request could not be1597 * allocated.1598 */1599int ssam_request_sync_alloc(size_t payload_len, gfp_t flags,1600			    struct ssam_request_sync **rqst,1601			    struct ssam_span *buffer)1602{1603	size_t msglen = SSH_COMMAND_MESSAGE_LENGTH(payload_len);1604 1605	*rqst = kzalloc(sizeof(**rqst) + msglen, flags);1606	if (!*rqst)1607		return -ENOMEM;1608 1609	buffer->ptr = (u8 *)(*rqst + 1);1610	buffer->len = msglen;1611 1612	return 0;1613}1614EXPORT_SYMBOL_GPL(ssam_request_sync_alloc);1615 1616/**1617 * ssam_request_sync_free() - Free a synchronous request.1618 * @rqst: The request to be freed.1619 *1620 * Free a synchronous request and its corresponding buffer allocated with1621 * ssam_request_sync_alloc(). Do not use for requests allocated on the stack1622 * or via any other function.1623 *1624 * Warning: The caller must ensure that the request is not in use any more.1625 * I.e. the caller must ensure that it has the only reference to the request1626 * and the request is not currently pending. This means that the caller has1627 * either never submitted the request, request submission has failed, or the1628 * caller has waited until the submitted request has been completed via1629 * ssam_request_sync_wait().1630 */1631void ssam_request_sync_free(struct ssam_request_sync *rqst)1632{1633	kfree(rqst);1634}1635EXPORT_SYMBOL_GPL(ssam_request_sync_free);1636 1637/**1638 * ssam_request_sync_init() - Initialize a synchronous request struct.1639 * @rqst:  The request to initialize.1640 * @flags: The request flags.1641 *1642 * Initializes the given request struct. Does not initialize the request1643 * message data. This has to be done explicitly after this call via1644 * ssam_request_sync_set_data() and the actual message data has to be written1645 * via ssam_request_write_data().1646 *1647 * Return: Returns zero on success or %-EINVAL if the given flags are invalid.1648 */1649int ssam_request_sync_init(struct ssam_request_sync *rqst,1650			   enum ssam_request_flags flags)1651{1652	int status;1653 1654	status = ssh_request_init(&rqst->base, flags, &ssam_request_sync_ops);1655	if (status)1656		return status;1657 1658	init_completion(&rqst->comp);1659	rqst->resp = NULL;1660	rqst->status = 0;1661 1662	return 0;1663}1664EXPORT_SYMBOL_GPL(ssam_request_sync_init);1665 1666/**1667 * ssam_request_sync_submit() - Submit a synchronous request.1668 * @ctrl: The controller with which to submit the request.1669 * @rqst: The request to submit.1670 *1671 * Submit a synchronous request. The request has to be initialized and1672 * properly set up, including response buffer (may be %NULL if no response is1673 * expected) and command message data. This function does not wait for the1674 * request to be completed.1675 *1676 * If this function succeeds, ssam_request_sync_wait() must be used to ensure1677 * that the request has been completed before the response data can be1678 * accessed and/or the request can be freed. On failure, the request may1679 * immediately be freed.1680 *1681 * This function may only be used if the controller is active, i.e. has been1682 * initialized and not suspended.1683 */1684int ssam_request_sync_submit(struct ssam_controller *ctrl,1685			     struct ssam_request_sync *rqst)1686{1687	int status;1688 1689	/*1690	 * This is only a superficial check. In general, the caller needs to1691	 * ensure that the controller is initialized and is not (and does not1692	 * get) suspended during use, i.e. until the request has been completed1693	 * (if _absolutely_ necessary, by use of ssam_controller_statelock/1694	 * ssam_controller_stateunlock, but something like ssam_client_link1695	 * should be preferred as this needs to last until the request has been1696	 * completed).1697	 *1698	 * Note that it is actually safe to use this function while the1699	 * controller is in the process of being shut down (as ssh_rtl_submit1700	 * is safe with regards to this), but it is generally discouraged to do1701	 * so.1702	 */1703	if (WARN_ON(READ_ONCE(ctrl->state) != SSAM_CONTROLLER_STARTED)) {1704		ssh_request_put(&rqst->base);1705		return -ENODEV;1706	}1707 1708	status = ssh_rtl_submit(&ctrl->rtl, &rqst->base);1709	ssh_request_put(&rqst->base);1710 1711	return status;1712}1713EXPORT_SYMBOL_GPL(ssam_request_sync_submit);1714 1715/**1716 * ssam_request_do_sync() - Execute a synchronous request.1717 * @ctrl: The controller via which the request will be submitted.1718 * @spec: The request specification and payload.1719 * @rsp:  The response buffer.1720 *1721 * Allocates a synchronous request with its message data buffer on the heap1722 * via ssam_request_sync_alloc(), fully initializes it via the provided1723 * request specification, submits it, and finally waits for its completion1724 * before freeing it and returning its status.1725 *1726 * Return: Returns the status of the request or any failure during setup.1727 */1728int ssam_request_do_sync(struct ssam_controller *ctrl,1729			 const struct ssam_request *spec,1730			 struct ssam_response *rsp)1731{1732	struct ssam_request_sync *rqst;1733	struct ssam_span buf;1734	ssize_t len;1735	int status;1736 1737	status = ssam_request_sync_alloc(spec->length, GFP_KERNEL, &rqst, &buf);1738	if (status)1739		return status;1740 1741	status = ssam_request_sync_init(rqst, spec->flags);1742	if (status) {1743		ssam_request_sync_free(rqst);1744		return status;1745	}1746 1747	ssam_request_sync_set_resp(rqst, rsp);1748 1749	len = ssam_request_write_data(&buf, ctrl, spec);1750	if (len < 0) {1751		ssam_request_sync_free(rqst);1752		return len;1753	}1754 1755	ssam_request_sync_set_data(rqst, buf.ptr, len);1756 1757	status = ssam_request_sync_submit(ctrl, rqst);1758	if (!status)1759		status = ssam_request_sync_wait(rqst);1760 1761	ssam_request_sync_free(rqst);1762	return status;1763}1764EXPORT_SYMBOL_GPL(ssam_request_do_sync);1765 1766/**1767 * ssam_request_do_sync_with_buffer() - Execute a synchronous request with the1768 * provided buffer as back-end for the message buffer.1769 * @ctrl: The controller via which the request will be submitted.1770 * @spec: The request specification and payload.1771 * @rsp:  The response buffer.1772 * @buf:  The buffer for the request message data.1773 *1774 * Allocates a synchronous request struct on the stack, fully initializes it1775 * using the provided buffer as message data buffer, submits it, and then1776 * waits for its completion before returning its status. The1777 * SSH_COMMAND_MESSAGE_LENGTH() macro can be used to compute the required1778 * message buffer size.1779 *1780 * This function does essentially the same as ssam_request_do_sync(), but1781 * instead of dynamically allocating the request and message data buffer, it1782 * uses the provided message data buffer and stores the (small) request struct1783 * on the heap.1784 *1785 * Return: Returns the status of the request or any failure during setup.1786 */1787int ssam_request_do_sync_with_buffer(struct ssam_controller *ctrl,1788				     const struct ssam_request *spec,1789				     struct ssam_response *rsp,1790				     struct ssam_span *buf)1791{1792	struct ssam_request_sync rqst;1793	ssize_t len;1794	int status;1795 1796	status = ssam_request_sync_init(&rqst, spec->flags);1797	if (status)1798		return status;1799 1800	ssam_request_sync_set_resp(&rqst, rsp);1801 1802	len = ssam_request_write_data(buf, ctrl, spec);1803	if (len < 0)1804		return len;1805 1806	ssam_request_sync_set_data(&rqst, buf->ptr, len);1807 1808	status = ssam_request_sync_submit(ctrl, &rqst);1809	if (!status)1810		status = ssam_request_sync_wait(&rqst);1811 1812	return status;1813}1814EXPORT_SYMBOL_GPL(ssam_request_do_sync_with_buffer);1815 1816 1817/* -- Internal SAM requests. ------------------------------------------------ */1818 1819SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_get_firmware_version, __le32, {1820	.target_category = SSAM_SSH_TC_SAM,1821	.target_id       = SSAM_SSH_TID_SAM,1822	.command_id      = 0x13,1823	.instance_id     = 0x00,1824});1825 1826SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_display_off, u8, {1827	.target_category = SSAM_SSH_TC_SAM,1828	.target_id       = SSAM_SSH_TID_SAM,1829	.command_id      = 0x15,1830	.instance_id     = 0x00,1831});1832 1833SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_display_on, u8, {1834	.target_category = SSAM_SSH_TC_SAM,1835	.target_id       = SSAM_SSH_TID_SAM,1836	.command_id      = 0x16,1837	.instance_id     = 0x00,1838});1839 1840SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_d0_exit, u8, {1841	.target_category = SSAM_SSH_TC_SAM,1842	.target_id       = SSAM_SSH_TID_SAM,1843	.command_id      = 0x33,1844	.instance_id     = 0x00,1845});1846 1847SSAM_DEFINE_SYNC_REQUEST_R(ssam_ssh_notif_d0_entry, u8, {1848	.target_category = SSAM_SSH_TC_SAM,1849	.target_id       = SSAM_SSH_TID_SAM,1850	.command_id      = 0x34,1851	.instance_id     = 0x00,1852});1853 1854/**1855 * struct ssh_notification_params - Command payload to enable/disable SSH1856 * notifications.1857 * @target_category: The target category for which notifications should be1858 *                   enabled/disabled.1859 * @flags:           Flags determining how notifications are being sent.1860 * @request_id:      The request ID that is used to send these notifications.1861 * @instance_id:     The specific instance in the given target category for1862 *                   which notifications should be enabled.1863 */1864struct ssh_notification_params {1865	u8 target_category;1866	u8 flags;1867	__le16 request_id;1868	u8 instance_id;1869} __packed;1870 1871static_assert(sizeof(struct ssh_notification_params) == 5);1872 1873static int __ssam_ssh_event_request(struct ssam_controller *ctrl,1874				    struct ssam_event_registry reg, u8 cid,1875				    struct ssam_event_id id, u8 flags)1876{1877	struct ssh_notification_params params;1878	struct ssam_request rqst;1879	struct ssam_response result;1880	int status;1881 1882	u16 rqid = ssh_tc_to_rqid(id.target_category);1883	u8 buf = 0;1884 1885	/* Only allow RQIDs that lie within the event spectrum. */1886	if (!ssh_rqid_is_event(rqid))1887		return -EINVAL;1888 1889	params.target_category = id.target_category;1890	params.instance_id = id.instance;1891	params.flags = flags;1892	put_unaligned_le16(rqid, &params.request_id);1893 1894	rqst.target_category = reg.target_category;1895	rqst.target_id = reg.target_id;1896	rqst.command_id = cid;1897	rqst.instance_id = 0x00;1898	rqst.flags = SSAM_REQUEST_HAS_RESPONSE;1899	rqst.length = sizeof(params);1900	rqst.payload = (u8 *)&params;1901 1902	result.capacity = sizeof(buf);1903	result.length = 0;1904	result.pointer = &buf;1905 1906	status = ssam_retry(ssam_request_do_sync_onstack, ctrl, &rqst, &result,1907			    sizeof(params));1908 1909	return status < 0 ? status : buf;1910}1911 1912/**1913 * ssam_ssh_event_enable() - Enable SSH event.1914 * @ctrl:  The controller for which to enable the event.1915 * @reg:   The event registry describing what request to use for enabling and1916 *         disabling the event.1917 * @id:    The event identifier.1918 * @flags: The event flags.1919 *1920 * Enables the specified event on the EC. This function does not manage1921 * reference counting of enabled events and is basically only a wrapper for1922 * the raw EC request. If the specified event is already enabled, the EC will1923 * ignore this request.1924 *1925 * Return: Returns the status of the executed SAM request (zero on success and1926 * negative on direct failure) or %-EPROTO if the request response indicates a1927 * failure.1928 */1929static int ssam_ssh_event_enable(struct ssam_controller *ctrl,1930				 struct ssam_event_registry reg,1931				 struct ssam_event_id id, u8 flags)1932{1933	int status;1934 1935	status = __ssam_ssh_event_request(ctrl, reg, reg.cid_enable, id, flags);1936 1937	if (status < 0 && status != -EINVAL) {1938		ssam_err(ctrl,1939			 "failed to enable event source (tc: %#04x, iid: %#04x, reg: %#04x)\n",1940			 id.target_category, id.instance, reg.target_category);1941	}1942 1943	if (status > 0) {1944		ssam_err(ctrl,1945			 "unexpected result while enabling event source: %#04x (tc: %#04x, iid: %#04x, reg: %#04x)\n",1946			 status, id.target_category, id.instance, reg.target_category);1947		return -EPROTO;1948	}1949 1950	return status;1951}1952 1953/**1954 * ssam_ssh_event_disable() - Disable SSH event.1955 * @ctrl:  The controller for which to disable the event.1956 * @reg:   The event registry describing what request to use for enabling and1957 *         disabling the event (must be same as used when enabling the event).1958 * @id:    The event identifier.1959 * @flags: The event flags (likely ignored for disabling of events).1960 *1961 * Disables the specified event on the EC. This function does not manage1962 * reference counting of enabled events and is basically only a wrapper for1963 * the raw EC request. If the specified event is already disabled, the EC will1964 * ignore this request.1965 *1966 * Return: Returns the status of the executed SAM request (zero on success and1967 * negative on direct failure) or %-EPROTO if the request response indicates a1968 * failure.1969 */1970static int ssam_ssh_event_disable(struct ssam_controller *ctrl,1971				  struct ssam_event_registry reg,1972				  struct ssam_event_id id, u8 flags)1973{1974	int status;1975 1976	status = __ssam_ssh_event_request(ctrl, reg, reg.cid_disable, id, flags);1977 1978	if (status < 0 && status != -EINVAL) {1979		ssam_err(ctrl,1980			 "failed to disable event source (tc: %#04x, iid: %#04x, reg: %#04x)\n",1981			 id.target_category, id.instance, reg.target_category);1982	}1983 1984	if (status > 0) {1985		ssam_err(ctrl,1986			 "unexpected result while disabling event source: %#04x (tc: %#04x, iid: %#04x, reg: %#04x)\n",1987			 status, id.target_category, id.instance, reg.target_category);1988		return -EPROTO;1989	}1990 1991	return status;1992}1993 1994 1995/* -- Wrappers for internal SAM requests. ----------------------------------- */1996 1997/**1998 * ssam_get_firmware_version() - Get the SAM/EC firmware version.1999 * @ctrl:    The controller.2000 * @version: Where to store the version number.2001 *2002 * Return: Returns zero on success or the status of the executed SAM request2003 * if that request failed.2004 */2005int ssam_get_firmware_version(struct ssam_controller *ctrl, u32 *version)2006{2007	__le32 __version;2008	int status;2009 2010	status = ssam_retry(ssam_ssh_get_firmware_version, ctrl, &__version);2011	if (status)2012		return status;2013 2014	*version = le32_to_cpu(__version);2015	return 0;2016}2017 2018/**2019 * ssam_ctrl_notif_display_off() - Notify EC that the display has been turned2020 * off.2021 * @ctrl: The controller.2022 *2023 * Notify the EC that the display has been turned off and the driver may enter2024 * a lower-power state. This will prevent events from being sent directly.2025 * Rather, the EC signals an event by pulling the wakeup GPIO high for as long2026 * as there are pending events. The events then need to be manually released,2027 * one by one, via the GPIO callback request. All pending events accumulated2028 * during this state can also be released by issuing the display-on2029 * notification, e.g. via ssam_ctrl_notif_display_on(), which will also reset2030 * the GPIO.2031 *2032 * On some devices, specifically ones with an integrated keyboard, the keyboard2033 * backlight will be turned off by this call.2034 *2035 * This function will only send the display-off notification command if2036 * display notifications are supported by the EC. Currently all known devices2037 * support these notifications.2038 *2039 * Use ssam_ctrl_notif_display_on() to reverse the effects of this function.2040 *2041 * Return: Returns zero on success or if no request has been executed, the2042 * status of the executed SAM request if that request failed, or %-EPROTO if2043 * an unexpected response has been received.2044 */2045int ssam_ctrl_notif_display_off(struct ssam_controller *ctrl)2046{2047	int status;2048	u8 response;2049 2050	ssam_dbg(ctrl, "pm: notifying display off\n");2051 2052	status = ssam_retry(ssam_ssh_notif_display_off, ctrl, &response);2053	if (status)2054		return status;2055 2056	if (response != 0) {2057		ssam_err(ctrl, "unexpected response from display-off notification: %#04x\n",2058			 response);2059		return -EPROTO;2060	}2061 2062	return 0;2063}2064 2065/**2066 * ssam_ctrl_notif_display_on() - Notify EC that the display has been turned on.2067 * @ctrl: The controller.2068 *2069 * Notify the EC that the display has been turned back on and the driver has2070 * exited its lower-power state. This notification is the counterpart to the2071 * display-off notification sent via ssam_ctrl_notif_display_off() and will2072 * reverse its effects, including resetting events to their default behavior.2073 *2074 * This function will only send the display-on notification command if display2075 * notifications are supported by the EC. Currently all known devices support2076 * these notifications.2077 *2078 * See ssam_ctrl_notif_display_off() for more details.2079 *2080 * Return: Returns zero on success or if no request has been executed, the2081 * status of the executed SAM request if that request failed, or %-EPROTO if2082 * an unexpected response has been received.2083 */2084int ssam_ctrl_notif_display_on(struct ssam_controller *ctrl)2085{2086	int status;2087	u8 response;2088 2089	ssam_dbg(ctrl, "pm: notifying display on\n");2090 2091	status = ssam_retry(ssam_ssh_notif_display_on, ctrl, &response);2092	if (status)2093		return status;2094 2095	if (response != 0) {2096		ssam_err(ctrl, "unexpected response from display-on notification: %#04x\n",2097			 response);2098		return -EPROTO;2099	}2100 2101	return 0;2102}2103 2104/**2105 * ssam_ctrl_notif_d0_exit() - Notify EC that the driver/device exits the D02106 * power state.2107 * @ctrl: The controller2108 *2109 * Notifies the EC that the driver prepares to exit the D0 power state in2110 * favor of a lower-power state. Exact effects of this function related to the2111 * EC are currently unknown.2112 *2113 * This function will only send the D0-exit notification command if D0-state2114 * notifications are supported by the EC. Only newer Surface generations2115 * support these notifications.2116 *2117 * Use ssam_ctrl_notif_d0_entry() to reverse the effects of this function.2118 *2119 * Return: Returns zero on success or if no request has been executed, the2120 * status of the executed SAM request if that request failed, or %-EPROTO if2121 * an unexpected response has been received.2122 */2123int ssam_ctrl_notif_d0_exit(struct ssam_controller *ctrl)2124{2125	int status;2126	u8 response;2127 2128	if (!ctrl->caps.d3_closes_handle)2129		return 0;2130 2131	ssam_dbg(ctrl, "pm: notifying D0 exit\n");2132 2133	status = ssam_retry(ssam_ssh_notif_d0_exit, ctrl, &response);2134	if (status)2135		return status;2136 2137	if (response != 0) {2138		ssam_err(ctrl, "unexpected response from D0-exit notification: %#04x\n",2139			 response);2140		return -EPROTO;2141	}2142 2143	return 0;2144}2145 2146/**2147 * ssam_ctrl_notif_d0_entry() - Notify EC that the driver/device enters the D02148 * power state.2149 * @ctrl: The controller2150 *2151 * Notifies the EC that the driver has exited a lower-power state and entered2152 * the D0 power state. Exact effects of this function related to the EC are2153 * currently unknown.2154 *2155 * This function will only send the D0-entry notification command if D0-state2156 * notifications are supported by the EC. Only newer Surface generations2157 * support these notifications.2158 *2159 * See ssam_ctrl_notif_d0_exit() for more details.2160 *2161 * Return: Returns zero on success or if no request has been executed, the2162 * status of the executed SAM request if that request failed, or %-EPROTO if2163 * an unexpected response has been received.2164 */2165int ssam_ctrl_notif_d0_entry(struct ssam_controller *ctrl)2166{2167	int status;2168	u8 response;2169 2170	if (!ctrl->caps.d3_closes_handle)2171		return 0;2172 2173	ssam_dbg(ctrl, "pm: notifying D0 entry\n");2174 2175	status = ssam_retry(ssam_ssh_notif_d0_entry, ctrl, &response);2176	if (status)2177		return status;2178 2179	if (response != 0) {2180		ssam_err(ctrl, "unexpected response from D0-entry notification: %#04x\n",2181			 response);2182		return -EPROTO;2183	}2184 2185	return 0;2186}2187 2188 2189/* -- Top-level event registry interface. ----------------------------------- */2190 2191/**2192 * ssam_nf_refcount_enable() - Enable event for reference count entry if it has2193 * not already been enabled.2194 * @ctrl:  The controller to enable the event on.2195 * @entry: The reference count entry for the event to be enabled.2196 * @flags: The flags used for enabling the event on the EC.2197 *2198 * Enable the event associated with the given reference count entry if the2199 * reference count equals one, i.e. the event has not previously been enabled.2200 * If the event has already been enabled (i.e. reference count not equal to2201 * one), check that the flags used for enabling match and warn about this if2202 * they do not.2203 *2204 * This does not modify the reference count itself, which is done with2205 * ssam_nf_refcount_inc() / ssam_nf_refcount_dec().2206 *2207 * Note: ``nf->lock`` must be held when calling this function.2208 *2209 * Return: Returns zero on success. If the event is enabled by this call,2210 * returns the status of the event-enable EC command.2211 */2212static int ssam_nf_refcount_enable(struct ssam_controller *ctrl,2213				   struct ssam_nf_refcount_entry *entry, u8 flags)2214{2215	const struct ssam_event_registry reg = entry->key.reg;2216	const struct ssam_event_id id = entry->key.id;2217	struct ssam_nf *nf = &ctrl->cplt.event.notif;2218	int status;2219 2220	lockdep_assert_held(&nf->lock);2221 2222	ssam_dbg(ctrl, "enabling event (reg: %#04x, tc: %#04x, iid: %#04x, rc: %d)\n",2223		 reg.target_category, id.target_category, id.instance, entry->refcount);2224 2225	if (entry->refcount == 1) {2226		status = ssam_ssh_event_enable(ctrl, reg, id, flags);2227		if (status)2228			return status;2229 2230		entry->flags = flags;2231 2232	} else if (entry->flags != flags) {2233		ssam_warn(ctrl,2234			  "inconsistent flags when enabling event: got %#04x, expected %#04x (reg: %#04x, tc: %#04x, iid: %#04x)\n",2235			  flags, entry->flags, reg.target_category, id.target_category,2236			  id.instance);2237	}2238 2239	return 0;2240}2241 2242/**2243 * ssam_nf_refcount_disable_free() - Disable event for reference count entry if2244 * it is no longer in use and free the corresponding entry.2245 * @ctrl:  The controller to disable the event on.2246 * @entry: The reference count entry for the event to be disabled.2247 * @flags: The flags used for enabling the event on the EC.2248 * @ec:    Flag specifying if the event should actually be disabled on the EC.2249 *2250 * If ``ec`` equals ``true`` and the reference count equals zero (i.e. the2251 * event is no longer requested by any client), the specified event will be2252 * disabled on the EC via the corresponding request.2253 *2254 * If ``ec`` equals ``false``, no request will be sent to the EC and the event2255 * can be considered in a detached state (i.e. no longer used but still2256 * enabled). Disabling an event via this method may be required for2257 * hot-removable devices, where event disable requests may time out after the2258 * device has been physically removed.2259 *2260 * In both cases, if the reference count equals zero, the corresponding2261 * reference count entry will be freed. The reference count entry must not be2262 * used any more after a call to this function.2263 *2264 * Also checks if the flags used for disabling the event match the flags used2265 * for enabling the event and warns if they do not (regardless of reference2266 * count).2267 *2268 * This does not modify the reference count itself, which is done with2269 * ssam_nf_refcount_inc() / ssam_nf_refcount_dec().2270 *2271 * Note: ``nf->lock`` must be held when calling this function.2272 *2273 * Return: Returns zero on success. If the event is disabled by this call,2274 * returns the status of the event-enable EC command.2275 */2276static int ssam_nf_refcount_disable_free(struct ssam_controller *ctrl,2277					 struct ssam_nf_refcount_entry *entry, u8 flags, bool ec)2278{2279	const struct ssam_event_registry reg = entry->key.reg;2280	const struct ssam_event_id id = entry->key.id;2281	struct ssam_nf *nf = &ctrl->cplt.event.notif;2282	int status = 0;2283 2284	lockdep_assert_held(&nf->lock);2285 2286	ssam_dbg(ctrl, "%s event (reg: %#04x, tc: %#04x, iid: %#04x, rc: %d)\n",2287		 ec ? "disabling" : "detaching", reg.target_category, id.target_category,2288		 id.instance, entry->refcount);2289 2290	if (entry->flags != flags) {2291		ssam_warn(ctrl,2292			  "inconsistent flags when disabling event: got %#04x, expected %#04x (reg: %#04x, tc: %#04x, iid: %#04x)\n",2293			  flags, entry->flags, reg.target_category, id.target_category,2294			  id.instance);2295	}2296 2297	if (ec && entry->refcount == 0) {2298		status = ssam_ssh_event_disable(ctrl, reg, id, flags);2299		kfree(entry);2300	}2301 2302	return status;2303}2304 2305/**2306 * ssam_notifier_register() - Register an event notifier.2307 * @ctrl: The controller to register the notifier on.2308 * @n:    The event notifier to register.2309 *2310 * Register an event notifier. Increment the usage counter of the associated2311 * SAM event if the notifier is not marked as an observer. If the event is not2312 * marked as an observer and is currently not enabled, it will be enabled2313 * during this call. If the notifier is marked as an observer, no attempt will2314 * be made at enabling any event and no reference count will be modified.2315 *2316 * Notifiers marked as observers do not need to be associated with one specific2317 * event, i.e. as long as no event matching is performed, only the event target2318 * category needs to be set.2319 *2320 * Return: Returns zero on success, %-ENOSPC if there have already been2321 * %INT_MAX notifiers for the event ID/type associated with the notifier block2322 * registered, %-ENOMEM if the corresponding event entry could not be2323 * allocated. If this is the first time that a notifier block is registered2324 * for the specific associated event, returns the status of the event-enable2325 * EC-command.2326 */2327int ssam_notifier_register(struct ssam_controller *ctrl, struct ssam_event_notifier *n)2328{2329	u16 rqid = ssh_tc_to_rqid(n->event.id.target_category);2330	struct ssam_nf_refcount_entry *entry = NULL;2331	struct ssam_nf_head *nf_head;2332	struct ssam_nf *nf;2333	int status;2334 2335	if (!ssh_rqid_is_event(rqid))2336		return -EINVAL;2337 2338	nf = &ctrl->cplt.event.notif;2339	nf_head = &nf->head[ssh_rqid_to_event(rqid)];2340 2341	mutex_lock(&nf->lock);2342 2343	if (!(n->flags & SSAM_EVENT_NOTIFIER_OBSERVER)) {2344		entry = ssam_nf_refcount_inc(nf, n->event.reg, n->event.id);2345		if (IS_ERR(entry)) {2346			mutex_unlock(&nf->lock);2347			return PTR_ERR(entry);2348		}2349	}2350 2351	status = ssam_nfblk_insert(nf_head, &n->base);2352	if (status) {2353		if (entry)2354			ssam_nf_refcount_dec_free(nf, n->event.reg, n->event.id);2355 2356		mutex_unlock(&nf->lock);2357		return status;2358	}2359 2360	if (entry) {2361		status = ssam_nf_refcount_enable(ctrl, entry, n->event.flags);2362		if (status) {2363			ssam_nfblk_remove(&n->base);2364			ssam_nf_refcount_dec_free(nf, n->event.reg, n->event.id);2365			mutex_unlock(&nf->lock);2366			synchronize_srcu(&nf_head->srcu);2367			return status;2368		}2369	}2370 2371	mutex_unlock(&nf->lock);2372	return 0;2373}2374EXPORT_SYMBOL_GPL(ssam_notifier_register);2375 2376/**2377 * __ssam_notifier_unregister() - Unregister an event notifier.2378 * @ctrl:    The controller the notifier has been registered on.2379 * @n:       The event notifier to unregister.2380 * @disable: Whether to disable the corresponding event on the EC.2381 *2382 * Unregister an event notifier. Decrement the usage counter of the associated2383 * SAM event if the notifier is not marked as an observer. If the usage counter2384 * reaches zero and ``disable`` equals ``true``, the event will be disabled.2385 *2386 * Useful for hot-removable devices, where communication may fail once the2387 * device has been physically removed. In that case, specifying ``disable`` as2388 * ``false`` avoids communication with the EC.2389 *2390 * Return: Returns zero on success, %-ENOENT if the given notifier block has2391 * not been registered on the controller. If the given notifier block was the2392 * last one associated with its specific event, returns the status of the2393 * event-disable EC-command.2394 */2395int __ssam_notifier_unregister(struct ssam_controller *ctrl, struct ssam_event_notifier *n,2396			       bool disable)2397{2398	u16 rqid = ssh_tc_to_rqid(n->event.id.target_category);2399	struct ssam_nf_refcount_entry *entry;2400	struct ssam_nf_head *nf_head;2401	struct ssam_nf *nf;2402	int status = 0;2403 2404	if (!ssh_rqid_is_event(rqid))2405		return -EINVAL;2406 2407	nf = &ctrl->cplt.event.notif;2408	nf_head = &nf->head[ssh_rqid_to_event(rqid)];2409 2410	mutex_lock(&nf->lock);2411 2412	if (!ssam_nfblk_find(nf_head, &n->base)) {2413		mutex_unlock(&nf->lock);2414		return -ENOENT;2415	}2416 2417	/*2418	 * If this is an observer notifier, do not attempt to disable the2419	 * event, just remove it.2420	 */2421	if (!(n->flags & SSAM_EVENT_NOTIFIER_OBSERVER)) {2422		entry = ssam_nf_refcount_dec(nf, n->event.reg, n->event.id);2423		if (WARN_ON(!entry)) {2424			/*2425			 * If this does not return an entry, there's a logic2426			 * error somewhere: The notifier block is registered,2427			 * but the event refcount entry is not there. Remove2428			 * the notifier block anyways.2429			 */2430			status = -ENOENT;2431			goto remove;2432		}2433 2434		status = ssam_nf_refcount_disable_free(ctrl, entry, n->event.flags, disable);2435	}2436 2437remove:2438	ssam_nfblk_remove(&n->base);2439	mutex_unlock(&nf->lock);2440	synchronize_srcu(&nf_head->srcu);2441 2442	return status;2443}2444EXPORT_SYMBOL_GPL(__ssam_notifier_unregister);2445 2446/**2447 * ssam_controller_event_enable() - Enable the specified event.2448 * @ctrl:  The controller to enable the event for.2449 * @reg:   The event registry to use for enabling the event.2450 * @id:    The event ID specifying the event to be enabled.2451 * @flags: The SAM event flags used for enabling the event.2452 *2453 * Increment the event reference count of the specified event. If the event has2454 * not been enabled previously, it will be enabled by this call.2455 *2456 * Note: In general, ssam_notifier_register() with a non-observer notifier2457 * should be preferred for enabling/disabling events, as this will guarantee2458 * proper ordering and event forwarding in case of errors during event2459 * enabling/disabling.2460 *2461 * Return: Returns zero on success, %-ENOSPC if the reference count for the2462 * specified event has reached its maximum, %-ENOMEM if the corresponding event2463 * entry could not be allocated. If this is the first time that this event has2464 * been enabled (i.e. the reference count was incremented from zero to one by2465 * this call), returns the status of the event-enable EC-command.2466 */2467int ssam_controller_event_enable(struct ssam_controller *ctrl,2468				 struct ssam_event_registry reg,2469				 struct ssam_event_id id, u8 flags)2470{2471	u16 rqid = ssh_tc_to_rqid(id.target_category);2472	struct ssam_nf *nf = &ctrl->cplt.event.notif;2473	struct ssam_nf_refcount_entry *entry;2474	int status;2475 2476	if (!ssh_rqid_is_event(rqid))2477		return -EINVAL;2478 2479	mutex_lock(&nf->lock);2480 2481	entry = ssam_nf_refcount_inc(nf, reg, id);2482	if (IS_ERR(entry)) {2483		mutex_unlock(&nf->lock);2484		return PTR_ERR(entry);2485	}2486 2487	status = ssam_nf_refcount_enable(ctrl, entry, flags);2488	if (status) {2489		ssam_nf_refcount_dec_free(nf, reg, id);2490		mutex_unlock(&nf->lock);2491		return status;2492	}2493 2494	mutex_unlock(&nf->lock);2495	return 0;2496}2497EXPORT_SYMBOL_GPL(ssam_controller_event_enable);2498 2499/**2500 * ssam_controller_event_disable() - Disable the specified event.2501 * @ctrl:  The controller to disable the event for.2502 * @reg:   The event registry to use for disabling the event.2503 * @id:    The event ID specifying the event to be disabled.2504 * @flags: The flags used when enabling the event.2505 *2506 * Decrement the reference count of the specified event. If the reference count2507 * reaches zero, the event will be disabled.2508 *2509 * Note: In general, ssam_notifier_register()/ssam_notifier_unregister() with a2510 * non-observer notifier should be preferred for enabling/disabling events, as2511 * this will guarantee proper ordering and event forwarding in case of errors2512 * during event enabling/disabling.2513 *2514 * Return: Returns zero on success, %-ENOENT if the given event has not been2515 * enabled on the controller. If the reference count of the event reaches zero2516 * during this call, returns the status of the event-disable EC-command.2517 */2518int ssam_controller_event_disable(struct ssam_controller *ctrl,2519				  struct ssam_event_registry reg,2520				  struct ssam_event_id id, u8 flags)2521{2522	u16 rqid = ssh_tc_to_rqid(id.target_category);2523	struct ssam_nf *nf = &ctrl->cplt.event.notif;2524	struct ssam_nf_refcount_entry *entry;2525	int status;2526 2527	if (!ssh_rqid_is_event(rqid))2528		return -EINVAL;2529 2530	mutex_lock(&nf->lock);2531 2532	entry = ssam_nf_refcount_dec(nf, reg, id);2533	if (!entry) {2534		mutex_unlock(&nf->lock);2535		return -ENOENT;2536	}2537 2538	status = ssam_nf_refcount_disable_free(ctrl, entry, flags, true);2539 2540	mutex_unlock(&nf->lock);2541	return status;2542}2543EXPORT_SYMBOL_GPL(ssam_controller_event_disable);2544 2545/**2546 * ssam_notifier_disable_registered() - Disable events for all registered2547 * notifiers.2548 * @ctrl: The controller for which to disable the notifiers/events.2549 *2550 * Disables events for all currently registered notifiers. In case of an error2551 * (EC command failing), all previously disabled events will be restored and2552 * the error code returned.2553 *2554 * This function is intended to disable all events prior to hibernation entry.2555 * See ssam_notifier_restore_registered() to restore/re-enable all events2556 * disabled with this function.2557 *2558 * Note that this function will not disable events for notifiers registered2559 * after calling this function. It should thus be made sure that no new2560 * notifiers are going to be added after this call and before the corresponding2561 * call to ssam_notifier_restore_registered().2562 *2563 * Return: Returns zero on success. In case of failure returns the error code2564 * returned by the failed EC command to disable an event.2565 */2566int ssam_notifier_disable_registered(struct ssam_controller *ctrl)2567{2568	struct ssam_nf *nf = &ctrl->cplt.event.notif;2569	struct rb_node *n;2570	int status;2571 2572	mutex_lock(&nf->lock);2573	for (n = rb_first(&nf->refcount); n; n = rb_next(n)) {2574		struct ssam_nf_refcount_entry *e;2575 2576		e = rb_entry(n, struct ssam_nf_refcount_entry, node);2577		status = ssam_ssh_event_disable(ctrl, e->key.reg,2578						e->key.id, e->flags);2579		if (status)2580			goto err;2581	}2582	mutex_unlock(&nf->lock);2583 2584	return 0;2585 2586err:2587	for (n = rb_prev(n); n; n = rb_prev(n)) {2588		struct ssam_nf_refcount_entry *e;2589 2590		e = rb_entry(n, struct ssam_nf_refcount_entry, node);2591		ssam_ssh_event_enable(ctrl, e->key.reg, e->key.id, e->flags);2592	}2593	mutex_unlock(&nf->lock);2594 2595	return status;2596}2597 2598/**2599 * ssam_notifier_restore_registered() - Restore/re-enable events for all2600 * registered notifiers.2601 * @ctrl: The controller for which to restore the notifiers/events.2602 *2603 * Restores/re-enables all events for which notifiers have been registered on2604 * the given controller. In case of a failure, the error is logged and the2605 * function continues to try and enable the remaining events.2606 *2607 * This function is intended to restore/re-enable all registered events after2608 * hibernation. See ssam_notifier_disable_registered() for the counter part2609 * disabling the events and more details.2610 */2611void ssam_notifier_restore_registered(struct ssam_controller *ctrl)2612{2613	struct ssam_nf *nf = &ctrl->cplt.event.notif;2614	struct rb_node *n;2615 2616	mutex_lock(&nf->lock);2617	for (n = rb_first(&nf->refcount); n; n = rb_next(n)) {2618		struct ssam_nf_refcount_entry *e;2619 2620		e = rb_entry(n, struct ssam_nf_refcount_entry, node);2621 2622		/* Ignore errors, will get logged in call. */2623		ssam_ssh_event_enable(ctrl, e->key.reg, e->key.id, e->flags);2624	}2625	mutex_unlock(&nf->lock);2626}2627 2628/**2629 * ssam_notifier_is_empty() - Check if there are any registered notifiers.2630 * @ctrl: The controller to check on.2631 *2632 * Return: Returns %true if there are currently no notifiers registered on the2633 * controller, %false otherwise.2634 */2635static bool ssam_notifier_is_empty(struct ssam_controller *ctrl)2636{2637	struct ssam_nf *nf = &ctrl->cplt.event.notif;2638	bool result;2639 2640	mutex_lock(&nf->lock);2641	result = ssam_nf_refcount_empty(nf);2642	mutex_unlock(&nf->lock);2643 2644	return result;2645}2646 2647/**2648 * ssam_notifier_unregister_all() - Unregister all currently registered2649 * notifiers.2650 * @ctrl: The controller to unregister the notifiers on.2651 *2652 * Unregisters all currently registered notifiers. This function is used to2653 * ensure that all notifiers will be unregistered and associated2654 * entries/resources freed when the controller is being shut down.2655 */2656static void ssam_notifier_unregister_all(struct ssam_controller *ctrl)2657{2658	struct ssam_nf *nf = &ctrl->cplt.event.notif;2659	struct ssam_nf_refcount_entry *e, *n;2660 2661	mutex_lock(&nf->lock);2662	rbtree_postorder_for_each_entry_safe(e, n, &nf->refcount, node) {2663		/* Ignore errors, will get logged in call. */2664		ssam_ssh_event_disable(ctrl, e->key.reg, e->key.id, e->flags);2665		kfree(e);2666	}2667	nf->refcount = RB_ROOT;2668	mutex_unlock(&nf->lock);2669}2670 2671 2672/* -- Wakeup IRQ. ----------------------------------------------------------- */2673 2674static irqreturn_t ssam_irq_handle(int irq, void *dev_id)2675{2676	struct ssam_controller *ctrl = dev_id;2677 2678	ssam_dbg(ctrl, "pm: wake irq triggered\n");2679 2680	/*2681	 * Note: Proper wakeup detection is currently unimplemented.2682	 *       When the EC is in display-off or any other non-D0 state, it2683	 *       does not send events/notifications to the host. Instead it2684	 *       signals that there are events available via the wakeup IRQ.2685	 *       This driver is responsible for calling back to the EC to2686	 *       release these events one-by-one.2687	 *2688	 *       This IRQ should not cause a full system resume by its own.2689	 *       Instead, events should be handled by their respective subsystem2690	 *       drivers, which in turn should signal whether a full system2691	 *       resume should be performed.2692	 *2693	 * TODO: Send GPIO callback command repeatedly to EC until callback2694	 *       returns 0x00. Return flag of callback is "has more events".2695	 *       Each time the command is sent, one event is "released". Once2696	 *       all events have been released (return = 0x00), the GPIO is2697	 *       re-armed. Detect wakeup events during this process, go back to2698	 *       sleep if no wakeup event has been received.2699	 */2700 2701	return IRQ_HANDLED;2702}2703 2704/**2705 * ssam_irq_setup() - Set up SAM EC wakeup-GPIO interrupt.2706 * @ctrl: The controller for which the IRQ should be set up.2707 *2708 * Set up an IRQ for the wakeup-GPIO pin of the SAM EC. This IRQ can be used2709 * to wake the device from a low power state.2710 *2711 * Note that this IRQ can only be triggered while the EC is in the display-off2712 * state. In this state, events are not sent to the host in the usual way.2713 * Instead the wakeup-GPIO gets pulled to "high" as long as there are pending2714 * events and these events need to be released one-by-one via the GPIO2715 * callback request, either until there are no events left and the GPIO is2716 * reset, or all at once by transitioning the EC out of the display-off state,2717 * which will also clear the GPIO.2718 *2719 * Not all events, however, should trigger a full system wakeup. Instead the2720 * driver should, if necessary, inspect and forward each event to the2721 * corresponding subsystem, which in turn should decide if the system needs to2722 * be woken up. This logic has not been implemented yet, thus wakeup by this2723 * IRQ should be disabled by default to avoid spurious wake-ups, caused, for2724 * example, by the remaining battery percentage changing. Refer to comments in2725 * this function and comments in the corresponding IRQ handler for more2726 * details on how this should be implemented.2727 *2728 * See also ssam_ctrl_notif_display_off() and ssam_ctrl_notif_display_off()2729 * for functions to transition the EC into and out of the display-off state as2730 * well as more details on it.2731 *2732 * The IRQ is disabled by default and has to be enabled before it can wake up2733 * the device from suspend via ssam_irq_arm_for_wakeup(). On teardown, the IRQ2734 * should be freed via ssam_irq_free().2735 */2736int ssam_irq_setup(struct ssam_controller *ctrl)2737{2738	struct device *dev = ssam_controller_device(ctrl);2739	struct gpio_desc *gpiod;2740	int irq;2741	int status;2742 2743	/*2744	 * The actual GPIO interrupt is declared in ACPI as TRIGGER_HIGH.2745	 * However, the GPIO line only gets reset by sending the GPIO callback2746	 * command to SAM (or alternatively the display-on notification). As2747	 * proper handling for this interrupt is not implemented yet, leaving2748	 * the IRQ at TRIGGER_HIGH would cause an IRQ storm (as the callback2749	 * never gets sent and thus the line never gets reset). To avoid this,2750	 * mark the IRQ as TRIGGER_RISING for now, only creating a single2751	 * interrupt, and let the SAM resume callback during the controller2752	 * resume process clear it.2753	 */2754	const int irqf = IRQF_ONESHOT | IRQF_TRIGGER_RISING | IRQF_NO_AUTOEN;2755 2756	gpiod = gpiod_get(dev, "ssam_wakeup-int", GPIOD_ASIS);2757	if (IS_ERR(gpiod)) {2758		irq = fwnode_irq_get(dev_fwnode(dev), 0);2759	} else {2760		irq = gpiod_to_irq(gpiod);2761		gpiod_put(gpiod);2762	}2763 2764	if (irq < 0)2765		return irq;2766 2767	status = request_threaded_irq(irq, NULL, ssam_irq_handle, irqf,2768				      "ssam_wakeup", ctrl);2769	if (status)2770		return status;2771 2772	ctrl->irq.num = irq;2773	return 0;2774}2775 2776/**2777 * ssam_irq_free() - Free SAM EC wakeup-GPIO interrupt.2778 * @ctrl: The controller for which the IRQ should be freed.2779 *2780 * Free the wakeup-GPIO IRQ previously set-up via ssam_irq_setup().2781 */2782void ssam_irq_free(struct ssam_controller *ctrl)2783{2784	free_irq(ctrl->irq.num, ctrl);2785	ctrl->irq.num = -1;2786}2787 2788/**2789 * ssam_irq_arm_for_wakeup() - Arm the EC IRQ for wakeup, if enabled.2790 * @ctrl: The controller for which the IRQ should be armed.2791 *2792 * Sets up the IRQ so that it can be used to wake the device. Specifically,2793 * this function enables the irq and then, if the device is allowed to wake up2794 * the system, calls enable_irq_wake(). See ssam_irq_disarm_wakeup() for the2795 * corresponding function to disable the IRQ.2796 *2797 * This function is intended to arm the IRQ before entering S2idle suspend.2798 *2799 * Note: calls to ssam_irq_arm_for_wakeup() and ssam_irq_disarm_wakeup() must2800 * be balanced.2801 */2802int ssam_irq_arm_for_wakeup(struct ssam_controller *ctrl)2803{2804	struct device *dev = ssam_controller_device(ctrl);2805	int status;2806 2807	enable_irq(ctrl->irq.num);2808	if (device_may_wakeup(dev)) {2809		status = enable_irq_wake(ctrl->irq.num);2810		if (status) {2811			ssam_err(ctrl, "failed to enable wake IRQ: %d\n", status);2812			disable_irq(ctrl->irq.num);2813			return status;2814		}2815 2816		ctrl->irq.wakeup_enabled = true;2817	} else {2818		ctrl->irq.wakeup_enabled = false;2819	}2820 2821	return 0;2822}2823 2824/**2825 * ssam_irq_disarm_wakeup() - Disarm the wakeup IRQ.2826 * @ctrl: The controller for which the IRQ should be disarmed.2827 *2828 * Disarm the IRQ previously set up for wake via ssam_irq_arm_for_wakeup().2829 *2830 * This function is intended to disarm the IRQ after exiting S2idle suspend.2831 *2832 * Note: calls to ssam_irq_arm_for_wakeup() and ssam_irq_disarm_wakeup() must2833 * be balanced.2834 */2835void ssam_irq_disarm_wakeup(struct ssam_controller *ctrl)2836{2837	int status;2838 2839	if (ctrl->irq.wakeup_enabled) {2840		status = disable_irq_wake(ctrl->irq.num);2841		if (status)2842			ssam_err(ctrl, "failed to disable wake IRQ: %d\n", status);2843 2844		ctrl->irq.wakeup_enabled = false;2845	}2846	disable_irq(ctrl->irq.num);2847}2848