1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * Driver for the Surface ACPI Notify (SAN) interface/shim.
4  *
5  * Translates communication from ACPI to Surface System Aggregator Module
6  * (SSAM/SAM) requests and back, specifically SAM-over-SSH. Translates SSAM
7  * events back to ACPI notifications. Allows handling of discrete GPU
8  * notifications sent from ACPI via the SAN interface by providing them to any
9  * registered external driver.
10  *
11  * Copyright (C) 2019-2022 Maximilian Luz <luzmaximilian@gmail.com>
12  */
13 
14 #include <asm/unaligned.h>
15 #include <linux/acpi.h>
16 #include <linux/delay.h>
17 #include <linux/jiffies.h>
18 #include <linux/kernel.h>
19 #include <linux/module.h>
20 #include <linux/notifier.h>
21 #include <linux/platform_device.h>
22 #include <linux/rwsem.h>
23 
24 #include <linux/surface_aggregator/controller.h>
25 #include <linux/surface_acpi_notify.h>
26 
27 struct san_data {
28 	struct device *dev;
29 	struct ssam_controller *ctrl;
30 
31 	struct acpi_connection_info info;
32 
33 	struct ssam_event_notifier nf_bat;
34 	struct ssam_event_notifier nf_tmp;
35 };
36 
37 #define to_san_data(ptr, member) \
38 	container_of(ptr, struct san_data, member)
39 
40 static struct workqueue_struct *san_wq;
41 
42 /* -- dGPU notifier interface. ---------------------------------------------- */
43 
44 struct san_rqsg_if {
45 	struct rw_semaphore lock;
46 	struct device *dev;
47 	struct blocking_notifier_head nh;
48 };
49 
50 static struct san_rqsg_if san_rqsg_if = {
51 	.lock = __RWSEM_INITIALIZER(san_rqsg_if.lock),
52 	.dev = NULL,
53 	.nh = BLOCKING_NOTIFIER_INIT(san_rqsg_if.nh),
54 };
55 
56 static int san_set_rqsg_interface_device(struct device *dev)
57 {
58 	int status = 0;
59 
60 	down_write(&san_rqsg_if.lock);
61 	if (!san_rqsg_if.dev && dev)
62 		san_rqsg_if.dev = dev;
63 	else
64 		status = -EBUSY;
65 	up_write(&san_rqsg_if.lock);
66 
67 	return status;
68 }
69 
70 /**
71  * san_client_link() - Link client as consumer to SAN device.
72  * @client: The client to link.
73  *
74  * Sets up a device link between the provided client device as consumer and
75  * the SAN device as provider. This function can be used to ensure that the
76  * SAN interface has been set up and will be set up for as long as the driver
77  * of the client device is bound. This guarantees that, during that time, all
78  * dGPU events will be received by any registered notifier.
79  *
80  * The link will be automatically removed once the client device's driver is
81  * unbound.
82  *
83  * Return: Returns zero on success, %-ENXIO if the SAN interface has not been
84  * set up yet, and %-ENOMEM if device link creation failed.
85  */
86 int san_client_link(struct device *client)
87 {
88 	const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER;
89 	struct device_link *link;
90 
91 	down_read(&san_rqsg_if.lock);
92 
93 	if (!san_rqsg_if.dev) {
94 		up_read(&san_rqsg_if.lock);
95 		return -ENXIO;
96 	}
97 
98 	link = device_link_add(client, san_rqsg_if.dev, flags);
99 	if (!link) {
100 		up_read(&san_rqsg_if.lock);
101 		return -ENOMEM;
102 	}
103 
104 	if (READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) {
105 		up_read(&san_rqsg_if.lock);
106 		return -ENXIO;
107 	}
108 
109 	up_read(&san_rqsg_if.lock);
110 	return 0;
111 }
112 EXPORT_SYMBOL_GPL(san_client_link);
113 
114 /**
115  * san_dgpu_notifier_register() - Register a SAN dGPU notifier.
116  * @nb: The notifier-block to register.
117  *
118  * Registers a SAN dGPU notifier, receiving any new SAN dGPU events sent from
119  * ACPI. The registered notifier will be called with &struct san_dgpu_event
120  * as notifier data and the command ID of that event as notifier action.
121  */
122 int san_dgpu_notifier_register(struct notifier_block *nb)
123 {
124 	return blocking_notifier_chain_register(&san_rqsg_if.nh, nb);
125 }
126 EXPORT_SYMBOL_GPL(san_dgpu_notifier_register);
127 
128 /**
129  * san_dgpu_notifier_unregister() - Unregister a SAN dGPU notifier.
130  * @nb: The notifier-block to unregister.
131  */
132 int san_dgpu_notifier_unregister(struct notifier_block *nb)
133 {
134 	return blocking_notifier_chain_unregister(&san_rqsg_if.nh, nb);
135 }
136 EXPORT_SYMBOL_GPL(san_dgpu_notifier_unregister);
137 
138 static int san_dgpu_notifier_call(struct san_dgpu_event *evt)
139 {
140 	int ret;
141 
142 	ret = blocking_notifier_call_chain(&san_rqsg_if.nh, evt->command, evt);
143 	return notifier_to_errno(ret);
144 }
145 
146 
147 /* -- ACPI _DSM event relay. ------------------------------------------------ */
148 
149 #define SAN_DSM_REVISION	0
150 
151 /* 93b666c5-70c6-469f-a215-3d487c91ab3c */
152 static const guid_t SAN_DSM_UUID =
153 	GUID_INIT(0x93b666c5, 0x70c6, 0x469f, 0xa2, 0x15, 0x3d,
154 		  0x48, 0x7c, 0x91, 0xab, 0x3c);
155 
156 enum san_dsm_event_fn {
157 	SAN_DSM_EVENT_FN_BAT1_STAT = 0x03,
158 	SAN_DSM_EVENT_FN_BAT1_INFO = 0x04,
159 	SAN_DSM_EVENT_FN_ADP1_STAT = 0x05,
160 	SAN_DSM_EVENT_FN_ADP1_INFO = 0x06,
161 	SAN_DSM_EVENT_FN_BAT2_STAT = 0x07,
162 	SAN_DSM_EVENT_FN_BAT2_INFO = 0x08,
163 	SAN_DSM_EVENT_FN_THERMAL   = 0x09,
164 	SAN_DSM_EVENT_FN_DPTF      = 0x0a,
165 };
166 
167 enum sam_event_cid_bat {
168 	SAM_EVENT_CID_BAT_BIX  = 0x15,
169 	SAM_EVENT_CID_BAT_BST  = 0x16,
170 	SAM_EVENT_CID_BAT_ADP  = 0x17,
171 	SAM_EVENT_CID_BAT_PROT = 0x18,
172 	SAM_EVENT_CID_BAT_DPTF = 0x4f,
173 };
174 
175 enum sam_event_cid_tmp {
176 	SAM_EVENT_CID_TMP_TRIP = 0x0b,
177 };
178 
179 struct san_event_work {
180 	struct delayed_work work;
181 	struct device *dev;
182 	struct ssam_event event;	/* must be last */
183 };
184 
185 static int san_acpi_notify_event(struct device *dev, u64 func,
186 				 union acpi_object *param)
187 {
188 	acpi_handle san = ACPI_HANDLE(dev);
189 	union acpi_object *obj;
190 	int status = 0;
191 
192 	if (!acpi_check_dsm(san, &SAN_DSM_UUID, SAN_DSM_REVISION, BIT_ULL(func)))
193 		return 0;
194 
195 	dev_dbg(dev, "notify event %#04llx\n", func);
196 
197 	obj = acpi_evaluate_dsm_typed(san, &SAN_DSM_UUID, SAN_DSM_REVISION,
198 				      func, param, ACPI_TYPE_BUFFER);
199 	if (!obj)
200 		return -EFAULT;
201 
202 	if (obj->buffer.length != 1 || obj->buffer.pointer[0] != 0) {
203 		dev_err(dev, "got unexpected result from _DSM\n");
204 		status = -EPROTO;
205 	}
206 
207 	ACPI_FREE(obj);
208 	return status;
209 }
210 
211 static int san_evt_bat_adp(struct device *dev, const struct ssam_event *event)
212 {
213 	int status;
214 
215 	status = san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_ADP1_STAT, NULL);
216 	if (status)
217 		return status;
218 
219 	/*
220 	 * Ensure that the battery states get updated correctly. When the
221 	 * battery is fully charged and an adapter is plugged in, it sometimes
222 	 * is not updated correctly, instead showing it as charging.
223 	 * Explicitly trigger battery updates to fix this.
224 	 */
225 
226 	status = san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_BAT1_STAT, NULL);
227 	if (status)
228 		return status;
229 
230 	return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_BAT2_STAT, NULL);
231 }
232 
233 static int san_evt_bat_bix(struct device *dev, const struct ssam_event *event)
234 {
235 	enum san_dsm_event_fn fn;
236 
237 	if (event->instance_id == 0x02)
238 		fn = SAN_DSM_EVENT_FN_BAT2_INFO;
239 	else
240 		fn = SAN_DSM_EVENT_FN_BAT1_INFO;
241 
242 	return san_acpi_notify_event(dev, fn, NULL);
243 }
244 
245 static int san_evt_bat_bst(struct device *dev, const struct ssam_event *event)
246 {
247 	enum san_dsm_event_fn fn;
248 
249 	if (event->instance_id == 0x02)
250 		fn = SAN_DSM_EVENT_FN_BAT2_STAT;
251 	else
252 		fn = SAN_DSM_EVENT_FN_BAT1_STAT;
253 
254 	return san_acpi_notify_event(dev, fn, NULL);
255 }
256 
257 static int san_evt_bat_dptf(struct device *dev, const struct ssam_event *event)
258 {
259 	union acpi_object payload;
260 
261 	/*
262 	 * The Surface ACPI expects a buffer and not a package. It specifically
263 	 * checks for ObjectType (Arg3) == 0x03. This will cause a warning in
264 	 * acpica/nsarguments.c, but that warning can be safely ignored.
265 	 */
266 	payload.type = ACPI_TYPE_BUFFER;
267 	payload.buffer.length = event->length;
268 	payload.buffer.pointer = (u8 *)&event->data[0];
269 
270 	return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_DPTF, &payload);
271 }
272 
273 static unsigned long san_evt_bat_delay(u8 cid)
274 {
275 	switch (cid) {
276 	case SAM_EVENT_CID_BAT_ADP:
277 		/*
278 		 * Wait for battery state to update before signaling adapter
279 		 * change.
280 		 */
281 		return msecs_to_jiffies(5000);
282 
283 	case SAM_EVENT_CID_BAT_BST:
284 		/* Ensure we do not miss anything important due to caching. */
285 		return msecs_to_jiffies(2000);
286 
287 	default:
288 		return 0;
289 	}
290 }
291 
292 static bool san_evt_bat(const struct ssam_event *event, struct device *dev)
293 {
294 	int status;
295 
296 	switch (event->command_id) {
297 	case SAM_EVENT_CID_BAT_BIX:
298 		status = san_evt_bat_bix(dev, event);
299 		break;
300 
301 	case SAM_EVENT_CID_BAT_BST:
302 		status = san_evt_bat_bst(dev, event);
303 		break;
304 
305 	case SAM_EVENT_CID_BAT_ADP:
306 		status = san_evt_bat_adp(dev, event);
307 		break;
308 
309 	case SAM_EVENT_CID_BAT_PROT:
310 		/*
311 		 * TODO: Implement support for battery protection status change
312 		 *       event.
313 		 */
314 		return true;
315 
316 	case SAM_EVENT_CID_BAT_DPTF:
317 		status = san_evt_bat_dptf(dev, event);
318 		break;
319 
320 	default:
321 		return false;
322 	}
323 
324 	if (status) {
325 		dev_err(dev, "error handling power event (cid = %#04x)\n",
326 			event->command_id);
327 	}
328 
329 	return true;
330 }
331 
332 static void san_evt_bat_workfn(struct work_struct *work)
333 {
334 	struct san_event_work *ev;
335 
336 	ev = container_of(work, struct san_event_work, work.work);
337 	san_evt_bat(&ev->event, ev->dev);
338 	kfree(ev);
339 }
340 
341 static u32 san_evt_bat_nf(struct ssam_event_notifier *nf,
342 			  const struct ssam_event *event)
343 {
344 	struct san_data *d = to_san_data(nf, nf_bat);
345 	struct san_event_work *work;
346 	unsigned long delay = san_evt_bat_delay(event->command_id);
347 
348 	if (delay == 0)
349 		return san_evt_bat(event, d->dev) ? SSAM_NOTIF_HANDLED : 0;
350 
351 	work = kzalloc(sizeof(*work) + event->length, GFP_KERNEL);
352 	if (!work)
353 		return ssam_notifier_from_errno(-ENOMEM);
354 
355 	INIT_DELAYED_WORK(&work->work, san_evt_bat_workfn);
356 	work->dev = d->dev;
357 
358 	memcpy(&work->event, event, sizeof(struct ssam_event) + event->length);
359 
360 	queue_delayed_work(san_wq, &work->work, delay);
361 	return SSAM_NOTIF_HANDLED;
362 }
363 
364 static int san_evt_tmp_trip(struct device *dev, const struct ssam_event *event)
365 {
366 	union acpi_object param;
367 
368 	/*
369 	 * The Surface ACPI expects an integer and not a package. This will
370 	 * cause a warning in acpica/nsarguments.c, but that warning can be
371 	 * safely ignored.
372 	 */
373 	param.type = ACPI_TYPE_INTEGER;
374 	param.integer.value = event->instance_id;
375 
376 	return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_THERMAL, &param);
377 }
378 
379 static bool san_evt_tmp(const struct ssam_event *event, struct device *dev)
380 {
381 	int status;
382 
383 	switch (event->command_id) {
384 	case SAM_EVENT_CID_TMP_TRIP:
385 		status = san_evt_tmp_trip(dev, event);
386 		break;
387 
388 	default:
389 		return false;
390 	}
391 
392 	if (status) {
393 		dev_err(dev, "error handling thermal event (cid = %#04x)\n",
394 			event->command_id);
395 	}
396 
397 	return true;
398 }
399 
400 static u32 san_evt_tmp_nf(struct ssam_event_notifier *nf,
401 			  const struct ssam_event *event)
402 {
403 	struct san_data *d = to_san_data(nf, nf_tmp);
404 
405 	return san_evt_tmp(event, d->dev) ? SSAM_NOTIF_HANDLED : 0;
406 }
407 
408 
409 /* -- ACPI GSB OperationRegion handler -------------------------------------- */
410 
411 struct gsb_data_in {
412 	u8 cv;
413 } __packed;
414 
415 struct gsb_data_rqsx {
416 	u8 cv;				/* Command value (san_gsb_request_cv). */
417 	u8 tc;				/* Target category. */
418 	u8 tid;				/* Target ID. */
419 	u8 iid;				/* Instance ID. */
420 	u8 snc;				/* Expect-response-flag. */
421 	u8 cid;				/* Command ID. */
422 	u16 cdl;			/* Payload length. */
423 	u8 pld[];			/* Payload. */
424 } __packed;
425 
426 struct gsb_data_etwl {
427 	u8 cv;				/* Command value (should be 0x02). */
428 	u8 etw3;			/* Unknown. */
429 	u8 etw4;			/* Unknown. */
430 	u8 msg[];			/* Error message (ASCIIZ). */
431 } __packed;
432 
433 struct gsb_data_out {
434 	u8 status;			/* _SSH communication status. */
435 	u8 len;				/* _SSH payload length. */
436 	u8 pld[];			/* _SSH payload. */
437 } __packed;
438 
439 union gsb_buffer_data {
440 	struct gsb_data_in   in;	/* Common input. */
441 	struct gsb_data_rqsx rqsx;	/* RQSX input. */
442 	struct gsb_data_etwl etwl;	/* ETWL input. */
443 	struct gsb_data_out  out;	/* Output. */
444 };
445 
446 struct gsb_buffer {
447 	u8 status;			/* GSB AttribRawProcess status. */
448 	u8 len;				/* GSB AttribRawProcess length. */
449 	union gsb_buffer_data data;
450 } __packed;
451 
452 #define SAN_GSB_MAX_RQSX_PAYLOAD  (U8_MAX - 2 - sizeof(struct gsb_data_rqsx))
453 #define SAN_GSB_MAX_RESPONSE	  (U8_MAX - 2 - sizeof(struct gsb_data_out))
454 
455 #define SAN_GSB_COMMAND		0
456 
457 enum san_gsb_request_cv {
458 	SAN_GSB_REQUEST_CV_RQST = 0x01,
459 	SAN_GSB_REQUEST_CV_ETWL = 0x02,
460 	SAN_GSB_REQUEST_CV_RQSG = 0x03,
461 };
462 
463 #define SAN_REQUEST_NUM_TRIES	5
464 
465 static acpi_status san_etwl(struct san_data *d, struct gsb_buffer *b)
466 {
467 	struct gsb_data_etwl *etwl = &b->data.etwl;
468 
469 	if (b->len < sizeof(struct gsb_data_etwl)) {
470 		dev_err(d->dev, "invalid ETWL package (len = %d)\n", b->len);
471 		return AE_OK;
472 	}
473 
474 	dev_err(d->dev, "ETWL(%#04x, %#04x): %.*s\n", etwl->etw3, etwl->etw4,
475 		(unsigned int)(b->len - sizeof(struct gsb_data_etwl)),
476 		(char *)etwl->msg);
477 
478 	/* Indicate success. */
479 	b->status = 0x00;
480 	b->len = 0x00;
481 
482 	return AE_OK;
483 }
484 
485 static
486 struct gsb_data_rqsx *san_validate_rqsx(struct device *dev, const char *type,
487 					struct gsb_buffer *b)
488 {
489 	struct gsb_data_rqsx *rqsx = &b->data.rqsx;
490 
491 	if (b->len < sizeof(struct gsb_data_rqsx)) {
492 		dev_err(dev, "invalid %s package (len = %d)\n", type, b->len);
493 		return NULL;
494 	}
495 
496 	if (get_unaligned(&rqsx->cdl) != b->len - sizeof(struct gsb_data_rqsx)) {
497 		dev_err(dev, "bogus %s package (len = %d, cdl = %d)\n",
498 			type, b->len, get_unaligned(&rqsx->cdl));
499 		return NULL;
500 	}
501 
502 	if (get_unaligned(&rqsx->cdl) > SAN_GSB_MAX_RQSX_PAYLOAD) {
503 		dev_err(dev, "payload for %s package too large (cdl = %d)\n",
504 			type, get_unaligned(&rqsx->cdl));
505 		return NULL;
506 	}
507 
508 	return rqsx;
509 }
510 
511 static void gsb_rqsx_response_error(struct gsb_buffer *gsb, int status)
512 {
513 	gsb->status = 0x00;
514 	gsb->len = 0x02;
515 	gsb->data.out.status = (u8)(-status);
516 	gsb->data.out.len = 0x00;
517 }
518 
519 static void gsb_rqsx_response_success(struct gsb_buffer *gsb, u8 *ptr, size_t len)
520 {
521 	gsb->status = 0x00;
522 	gsb->len = len + 2;
523 	gsb->data.out.status = 0x00;
524 	gsb->data.out.len = len;
525 
526 	if (len)
527 		memcpy(&gsb->data.out.pld[0], ptr, len);
528 }
529 
530 static acpi_status san_rqst_fixup_suspended(struct san_data *d,
531 					    struct ssam_request *rqst,
532 					    struct gsb_buffer *gsb)
533 {
534 	if (rqst->target_category == SSAM_SSH_TC_BAS && rqst->command_id == 0x0D) {
535 		u8 base_state = 1;
536 
537 		/* Base state quirk:
538 		 * The base state may be queried from ACPI when the EC is still
539 		 * suspended. In this case it will return '-EPERM'. This query
540 		 * will only be triggered from the ACPI lid GPE interrupt, thus
541 		 * we are either in laptop or studio mode (base status 0x01 or
542 		 * 0x02). Furthermore, we will only get here if the device (and
543 		 * EC) have been suspended.
544 		 *
545 		 * We now assume that the device is in laptop mode (0x01). This
546 		 * has the drawback that it will wake the device when unfolding
547 		 * it in studio mode, but it also allows us to avoid actively
548 		 * waiting for the EC to wake up, which may incur a notable
549 		 * delay.
550 		 */
551 
552 		dev_dbg(d->dev, "rqst: fixup: base-state quirk\n");
553 
554 		gsb_rqsx_response_success(gsb, &base_state, sizeof(base_state));
555 		return AE_OK;
556 	}
557 
558 	gsb_rqsx_response_error(gsb, -ENXIO);
559 	return AE_OK;
560 }
561 
562 static acpi_status san_rqst(struct san_data *d, struct gsb_buffer *buffer)
563 {
564 	u8 rspbuf[SAN_GSB_MAX_RESPONSE];
565 	struct gsb_data_rqsx *gsb_rqst;
566 	struct ssam_request rqst;
567 	struct ssam_response rsp;
568 	int status = 0;
569 
570 	gsb_rqst = san_validate_rqsx(d->dev, "RQST", buffer);
571 	if (!gsb_rqst)
572 		return AE_OK;
573 
574 	rqst.target_category = gsb_rqst->tc;
575 	rqst.target_id = gsb_rqst->tid;
576 	rqst.command_id = gsb_rqst->cid;
577 	rqst.instance_id = gsb_rqst->iid;
578 	rqst.flags = gsb_rqst->snc ? SSAM_REQUEST_HAS_RESPONSE : 0;
579 	rqst.length = get_unaligned(&gsb_rqst->cdl);
580 	rqst.payload = &gsb_rqst->pld[0];
581 
582 	rsp.capacity = ARRAY_SIZE(rspbuf);
583 	rsp.length = 0;
584 	rsp.pointer = &rspbuf[0];
585 
586 	/* Handle suspended device. */
587 	if (d->dev->power.is_suspended) {
588 		dev_warn(d->dev, "rqst: device is suspended, not executing\n");
589 		return san_rqst_fixup_suspended(d, &rqst, buffer);
590 	}
591 
592 	status = __ssam_retry(ssam_request_sync_onstack, SAN_REQUEST_NUM_TRIES,
593 			      d->ctrl, &rqst, &rsp, SAN_GSB_MAX_RQSX_PAYLOAD);
594 
595 	if (!status) {
596 		gsb_rqsx_response_success(buffer, rsp.pointer, rsp.length);
597 	} else {
598 		dev_err(d->dev, "rqst: failed with error %d\n", status);
599 		gsb_rqsx_response_error(buffer, status);
600 	}
601 
602 	return AE_OK;
603 }
604 
605 static acpi_status san_rqsg(struct san_data *d, struct gsb_buffer *buffer)
606 {
607 	struct gsb_data_rqsx *gsb_rqsg;
608 	struct san_dgpu_event evt;
609 	int status;
610 
611 	gsb_rqsg = san_validate_rqsx(d->dev, "RQSG", buffer);
612 	if (!gsb_rqsg)
613 		return AE_OK;
614 
615 	evt.category = gsb_rqsg->tc;
616 	evt.target = gsb_rqsg->tid;
617 	evt.command = gsb_rqsg->cid;
618 	evt.instance = gsb_rqsg->iid;
619 	evt.length = get_unaligned(&gsb_rqsg->cdl);
620 	evt.payload = &gsb_rqsg->pld[0];
621 
622 	status = san_dgpu_notifier_call(&evt);
623 	if (!status) {
624 		gsb_rqsx_response_success(buffer, NULL, 0);
625 	} else {
626 		dev_err(d->dev, "rqsg: failed with error %d\n", status);
627 		gsb_rqsx_response_error(buffer, status);
628 	}
629 
630 	return AE_OK;
631 }
632 
633 static acpi_status san_opreg_handler(u32 function, acpi_physical_address command,
634 				     u32 bits, u64 *value64, void *opreg_context,
635 				     void *region_context)
636 {
637 	struct san_data *d = to_san_data(opreg_context, info);
638 	struct gsb_buffer *buffer = (struct gsb_buffer *)value64;
639 	int accessor_type = (function & 0xFFFF0000) >> 16;
640 
641 	if (command != SAN_GSB_COMMAND) {
642 		dev_warn(d->dev, "unsupported command: %#04llx\n", command);
643 		return AE_OK;
644 	}
645 
646 	if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) {
647 		dev_err(d->dev, "invalid access type: %#04x\n", accessor_type);
648 		return AE_OK;
649 	}
650 
651 	/* Buffer must have at least contain the command-value. */
652 	if (buffer->len == 0) {
653 		dev_err(d->dev, "request-package too small\n");
654 		return AE_OK;
655 	}
656 
657 	switch (buffer->data.in.cv) {
658 	case SAN_GSB_REQUEST_CV_RQST:
659 		return san_rqst(d, buffer);
660 
661 	case SAN_GSB_REQUEST_CV_ETWL:
662 		return san_etwl(d, buffer);
663 
664 	case SAN_GSB_REQUEST_CV_RQSG:
665 		return san_rqsg(d, buffer);
666 
667 	default:
668 		dev_warn(d->dev, "unsupported SAN0 request (cv: %#04x)\n",
669 			 buffer->data.in.cv);
670 		return AE_OK;
671 	}
672 }
673 
674 
675 /* -- Driver setup. --------------------------------------------------------- */
676 
677 static int san_events_register(struct platform_device *pdev)
678 {
679 	struct san_data *d = platform_get_drvdata(pdev);
680 	int status;
681 
682 	d->nf_bat.base.priority = 1;
683 	d->nf_bat.base.fn = san_evt_bat_nf;
684 	d->nf_bat.event.reg = SSAM_EVENT_REGISTRY_SAM;
685 	d->nf_bat.event.id.target_category = SSAM_SSH_TC_BAT;
686 	d->nf_bat.event.id.instance = 0;
687 	d->nf_bat.event.mask = SSAM_EVENT_MASK_TARGET;
688 	d->nf_bat.event.flags = SSAM_EVENT_SEQUENCED;
689 
690 	d->nf_tmp.base.priority = 1;
691 	d->nf_tmp.base.fn = san_evt_tmp_nf;
692 	d->nf_tmp.event.reg = SSAM_EVENT_REGISTRY_SAM;
693 	d->nf_tmp.event.id.target_category = SSAM_SSH_TC_TMP;
694 	d->nf_tmp.event.id.instance = 0;
695 	d->nf_tmp.event.mask = SSAM_EVENT_MASK_TARGET;
696 	d->nf_tmp.event.flags = SSAM_EVENT_SEQUENCED;
697 
698 	status = ssam_notifier_register(d->ctrl, &d->nf_bat);
699 	if (status)
700 		return status;
701 
702 	status = ssam_notifier_register(d->ctrl, &d->nf_tmp);
703 	if (status)
704 		ssam_notifier_unregister(d->ctrl, &d->nf_bat);
705 
706 	return status;
707 }
708 
709 static void san_events_unregister(struct platform_device *pdev)
710 {
711 	struct san_data *d = platform_get_drvdata(pdev);
712 
713 	ssam_notifier_unregister(d->ctrl, &d->nf_bat);
714 	ssam_notifier_unregister(d->ctrl, &d->nf_tmp);
715 }
716 
717 #define san_consumer_printk(level, dev, handle, fmt, ...)			\
718 do {										\
719 	char *path = "<error getting consumer path>";				\
720 	struct acpi_buffer buffer = {						\
721 		.length = ACPI_ALLOCATE_BUFFER,					\
722 		.pointer = NULL,						\
723 	};									\
724 										\
725 	if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))	\
726 		path = buffer.pointer;						\
727 										\
728 	dev_##level(dev, "[%s]: " fmt, path, ##__VA_ARGS__);			\
729 	kfree(buffer.pointer);							\
730 } while (0)
731 
732 #define san_consumer_dbg(dev, handle, fmt, ...) \
733 	san_consumer_printk(dbg, dev, handle, fmt, ##__VA_ARGS__)
734 
735 #define san_consumer_warn(dev, handle, fmt, ...) \
736 	san_consumer_printk(warn, dev, handle, fmt, ##__VA_ARGS__)
737 
738 static bool is_san_consumer(struct platform_device *pdev, acpi_handle handle)
739 {
740 	struct acpi_handle_list dep_devices;
741 	acpi_handle supplier = ACPI_HANDLE(&pdev->dev);
742 	acpi_status status;
743 	int i;
744 
745 	if (!acpi_has_method(handle, "_DEP"))
746 		return false;
747 
748 	status = acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices);
749 	if (ACPI_FAILURE(status)) {
750 		san_consumer_dbg(&pdev->dev, handle, "failed to evaluate _DEP\n");
751 		return false;
752 	}
753 
754 	for (i = 0; i < dep_devices.count; i++) {
755 		if (dep_devices.handles[i] == supplier)
756 			return true;
757 	}
758 
759 	return false;
760 }
761 
762 static acpi_status san_consumer_setup(acpi_handle handle, u32 lvl,
763 				      void *context, void **rv)
764 {
765 	const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER;
766 	struct platform_device *pdev = context;
767 	struct acpi_device *adev;
768 	struct device_link *link;
769 
770 	if (!is_san_consumer(pdev, handle))
771 		return AE_OK;
772 
773 	/* Ignore ACPI devices that are not present. */
774 	adev = acpi_fetch_acpi_dev(handle);
775 	if (!adev)
776 		return AE_OK;
777 
778 	san_consumer_dbg(&pdev->dev, handle, "creating device link\n");
779 
780 	/* Try to set up device links, ignore but log errors. */
781 	link = device_link_add(&adev->dev, &pdev->dev, flags);
782 	if (!link) {
783 		san_consumer_warn(&pdev->dev, handle, "failed to create device link\n");
784 		return AE_OK;
785 	}
786 
787 	return AE_OK;
788 }
789 
790 static int san_consumer_links_setup(struct platform_device *pdev)
791 {
792 	acpi_status status;
793 
794 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
795 				     ACPI_UINT32_MAX, san_consumer_setup, NULL,
796 				     pdev, NULL);
797 
798 	return status ? -EFAULT : 0;
799 }
800 
801 static int san_probe(struct platform_device *pdev)
802 {
803 	struct acpi_device *san = ACPI_COMPANION(&pdev->dev);
804 	struct ssam_controller *ctrl;
805 	struct san_data *data;
806 	acpi_status astatus;
807 	int status;
808 
809 	ctrl = ssam_client_bind(&pdev->dev);
810 	if (IS_ERR(ctrl))
811 		return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
812 
813 	status = san_consumer_links_setup(pdev);
814 	if (status)
815 		return status;
816 
817 	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
818 	if (!data)
819 		return -ENOMEM;
820 
821 	data->dev = &pdev->dev;
822 	data->ctrl = ctrl;
823 
824 	platform_set_drvdata(pdev, data);
825 
826 	astatus = acpi_install_address_space_handler(san->handle,
827 						     ACPI_ADR_SPACE_GSBUS,
828 						     &san_opreg_handler, NULL,
829 						     &data->info);
830 	if (ACPI_FAILURE(astatus))
831 		return -ENXIO;
832 
833 	status = san_events_register(pdev);
834 	if (status)
835 		goto err_enable_events;
836 
837 	status = san_set_rqsg_interface_device(&pdev->dev);
838 	if (status)
839 		goto err_install_dev;
840 
841 	acpi_dev_clear_dependencies(san);
842 	return 0;
843 
844 err_install_dev:
845 	san_events_unregister(pdev);
846 err_enable_events:
847 	acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
848 					  &san_opreg_handler);
849 	return status;
850 }
851 
852 static int san_remove(struct platform_device *pdev)
853 {
854 	acpi_handle san = ACPI_HANDLE(&pdev->dev);
855 
856 	san_set_rqsg_interface_device(NULL);
857 	acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
858 					  &san_opreg_handler);
859 	san_events_unregister(pdev);
860 
861 	/*
862 	 * We have unregistered our event sources. Now we need to ensure that
863 	 * all delayed works they may have spawned are run to completion.
864 	 */
865 	flush_workqueue(san_wq);
866 
867 	return 0;
868 }
869 
870 static const struct acpi_device_id san_match[] = {
871 	{ "MSHW0091" },
872 	{ },
873 };
874 MODULE_DEVICE_TABLE(acpi, san_match);
875 
876 static struct platform_driver surface_acpi_notify = {
877 	.probe = san_probe,
878 	.remove = san_remove,
879 	.driver = {
880 		.name = "surface_acpi_notify",
881 		.acpi_match_table = san_match,
882 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
883 	},
884 };
885 
886 static int __init san_init(void)
887 {
888 	int ret;
889 
890 	san_wq = alloc_workqueue("san_wq", 0, 0);
891 	if (!san_wq)
892 		return -ENOMEM;
893 	ret = platform_driver_register(&surface_acpi_notify);
894 	if (ret)
895 		destroy_workqueue(san_wq);
896 	return ret;
897 }
898 module_init(san_init);
899 
900 static void __exit san_exit(void)
901 {
902 	platform_driver_unregister(&surface_acpi_notify);
903 	destroy_workqueue(san_wq);
904 }
905 module_exit(san_exit);
906 
907 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
908 MODULE_DESCRIPTION("Surface ACPI Notify driver for Surface System Aggregator Module");
909 MODULE_LICENSE("GPL");
910