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 	work->event = *event;
359 	memcpy(work->event.data, event->data, event->length);
360 
361 	queue_delayed_work(san_wq, &work->work, delay);
362 	return SSAM_NOTIF_HANDLED;
363 }
364 
365 static int san_evt_tmp_trip(struct device *dev, const struct ssam_event *event)
366 {
367 	union acpi_object param;
368 
369 	/*
370 	 * The Surface ACPI expects an integer and not a package. This will
371 	 * cause a warning in acpica/nsarguments.c, but that warning can be
372 	 * safely ignored.
373 	 */
374 	param.type = ACPI_TYPE_INTEGER;
375 	param.integer.value = event->instance_id;
376 
377 	return san_acpi_notify_event(dev, SAN_DSM_EVENT_FN_THERMAL, &param);
378 }
379 
380 static bool san_evt_tmp(const struct ssam_event *event, struct device *dev)
381 {
382 	int status;
383 
384 	switch (event->command_id) {
385 	case SAM_EVENT_CID_TMP_TRIP:
386 		status = san_evt_tmp_trip(dev, event);
387 		break;
388 
389 	default:
390 		return false;
391 	}
392 
393 	if (status) {
394 		dev_err(dev, "error handling thermal event (cid = %#04x)\n",
395 			event->command_id);
396 	}
397 
398 	return true;
399 }
400 
401 static u32 san_evt_tmp_nf(struct ssam_event_notifier *nf,
402 			  const struct ssam_event *event)
403 {
404 	struct san_data *d = to_san_data(nf, nf_tmp);
405 
406 	return san_evt_tmp(event, d->dev) ? SSAM_NOTIF_HANDLED : 0;
407 }
408 
409 
410 /* -- ACPI GSB OperationRegion handler -------------------------------------- */
411 
412 struct gsb_data_in {
413 	u8 cv;
414 } __packed;
415 
416 struct gsb_data_rqsx {
417 	u8 cv;				/* Command value (san_gsb_request_cv). */
418 	u8 tc;				/* Target category. */
419 	u8 tid;				/* Target ID. */
420 	u8 iid;				/* Instance ID. */
421 	u8 snc;				/* Expect-response-flag. */
422 	u8 cid;				/* Command ID. */
423 	u16 cdl;			/* Payload length. */
424 	u8 pld[];			/* Payload. */
425 } __packed;
426 
427 struct gsb_data_etwl {
428 	u8 cv;				/* Command value (should be 0x02). */
429 	u8 etw3;			/* Unknown. */
430 	u8 etw4;			/* Unknown. */
431 	u8 msg[];			/* Error message (ASCIIZ). */
432 } __packed;
433 
434 struct gsb_data_out {
435 	u8 status;			/* _SSH communication status. */
436 	u8 len;				/* _SSH payload length. */
437 	u8 pld[];			/* _SSH payload. */
438 } __packed;
439 
440 union gsb_buffer_data {
441 	struct gsb_data_in   in;	/* Common input. */
442 	struct gsb_data_rqsx rqsx;	/* RQSX input. */
443 	struct gsb_data_etwl etwl;	/* ETWL input. */
444 	struct gsb_data_out  out;	/* Output. */
445 };
446 
447 struct gsb_buffer {
448 	u8 status;			/* GSB AttribRawProcess status. */
449 	u8 len;				/* GSB AttribRawProcess length. */
450 	union gsb_buffer_data data;
451 } __packed;
452 
453 #define SAN_GSB_MAX_RQSX_PAYLOAD  (U8_MAX - 2 - sizeof(struct gsb_data_rqsx))
454 #define SAN_GSB_MAX_RESPONSE	  (U8_MAX - 2 - sizeof(struct gsb_data_out))
455 
456 #define SAN_GSB_COMMAND		0
457 
458 enum san_gsb_request_cv {
459 	SAN_GSB_REQUEST_CV_RQST = 0x01,
460 	SAN_GSB_REQUEST_CV_ETWL = 0x02,
461 	SAN_GSB_REQUEST_CV_RQSG = 0x03,
462 };
463 
464 #define SAN_REQUEST_NUM_TRIES	5
465 
466 static acpi_status san_etwl(struct san_data *d, struct gsb_buffer *b)
467 {
468 	struct gsb_data_etwl *etwl = &b->data.etwl;
469 
470 	if (b->len < sizeof(struct gsb_data_etwl)) {
471 		dev_err(d->dev, "invalid ETWL package (len = %d)\n", b->len);
472 		return AE_OK;
473 	}
474 
475 	dev_err(d->dev, "ETWL(%#04x, %#04x): %.*s\n", etwl->etw3, etwl->etw4,
476 		(unsigned int)(b->len - sizeof(struct gsb_data_etwl)),
477 		(char *)etwl->msg);
478 
479 	/* Indicate success. */
480 	b->status = 0x00;
481 	b->len = 0x00;
482 
483 	return AE_OK;
484 }
485 
486 static
487 struct gsb_data_rqsx *san_validate_rqsx(struct device *dev, const char *type,
488 					struct gsb_buffer *b)
489 {
490 	struct gsb_data_rqsx *rqsx = &b->data.rqsx;
491 
492 	if (b->len < sizeof(struct gsb_data_rqsx)) {
493 		dev_err(dev, "invalid %s package (len = %d)\n", type, b->len);
494 		return NULL;
495 	}
496 
497 	if (get_unaligned(&rqsx->cdl) != b->len - sizeof(struct gsb_data_rqsx)) {
498 		dev_err(dev, "bogus %s package (len = %d, cdl = %d)\n",
499 			type, b->len, get_unaligned(&rqsx->cdl));
500 		return NULL;
501 	}
502 
503 	if (get_unaligned(&rqsx->cdl) > SAN_GSB_MAX_RQSX_PAYLOAD) {
504 		dev_err(dev, "payload for %s package too large (cdl = %d)\n",
505 			type, get_unaligned(&rqsx->cdl));
506 		return NULL;
507 	}
508 
509 	return rqsx;
510 }
511 
512 static void gsb_rqsx_response_error(struct gsb_buffer *gsb, int status)
513 {
514 	gsb->status = 0x00;
515 	gsb->len = 0x02;
516 	gsb->data.out.status = (u8)(-status);
517 	gsb->data.out.len = 0x00;
518 }
519 
520 static void gsb_rqsx_response_success(struct gsb_buffer *gsb, u8 *ptr, size_t len)
521 {
522 	gsb->status = 0x00;
523 	gsb->len = len + 2;
524 	gsb->data.out.status = 0x00;
525 	gsb->data.out.len = len;
526 
527 	if (len)
528 		memcpy(&gsb->data.out.pld[0], ptr, len);
529 }
530 
531 static acpi_status san_rqst_fixup_suspended(struct san_data *d,
532 					    struct ssam_request *rqst,
533 					    struct gsb_buffer *gsb)
534 {
535 	if (rqst->target_category == SSAM_SSH_TC_BAS && rqst->command_id == 0x0D) {
536 		u8 base_state = 1;
537 
538 		/* Base state quirk:
539 		 * The base state may be queried from ACPI when the EC is still
540 		 * suspended. In this case it will return '-EPERM'. This query
541 		 * will only be triggered from the ACPI lid GPE interrupt, thus
542 		 * we are either in laptop or studio mode (base status 0x01 or
543 		 * 0x02). Furthermore, we will only get here if the device (and
544 		 * EC) have been suspended.
545 		 *
546 		 * We now assume that the device is in laptop mode (0x01). This
547 		 * has the drawback that it will wake the device when unfolding
548 		 * it in studio mode, but it also allows us to avoid actively
549 		 * waiting for the EC to wake up, which may incur a notable
550 		 * delay.
551 		 */
552 
553 		dev_dbg(d->dev, "rqst: fixup: base-state quirk\n");
554 
555 		gsb_rqsx_response_success(gsb, &base_state, sizeof(base_state));
556 		return AE_OK;
557 	}
558 
559 	gsb_rqsx_response_error(gsb, -ENXIO);
560 	return AE_OK;
561 }
562 
563 static acpi_status san_rqst(struct san_data *d, struct gsb_buffer *buffer)
564 {
565 	u8 rspbuf[SAN_GSB_MAX_RESPONSE];
566 	struct gsb_data_rqsx *gsb_rqst;
567 	struct ssam_request rqst;
568 	struct ssam_response rsp;
569 	int status = 0;
570 
571 	gsb_rqst = san_validate_rqsx(d->dev, "RQST", buffer);
572 	if (!gsb_rqst)
573 		return AE_OK;
574 
575 	rqst.target_category = gsb_rqst->tc;
576 	rqst.target_id = gsb_rqst->tid;
577 	rqst.command_id = gsb_rqst->cid;
578 	rqst.instance_id = gsb_rqst->iid;
579 	rqst.flags = gsb_rqst->snc ? SSAM_REQUEST_HAS_RESPONSE : 0;
580 	rqst.length = get_unaligned(&gsb_rqst->cdl);
581 	rqst.payload = &gsb_rqst->pld[0];
582 
583 	rsp.capacity = ARRAY_SIZE(rspbuf);
584 	rsp.length = 0;
585 	rsp.pointer = &rspbuf[0];
586 
587 	/* Handle suspended device. */
588 	if (d->dev->power.is_suspended) {
589 		dev_warn(d->dev, "rqst: device is suspended, not executing\n");
590 		return san_rqst_fixup_suspended(d, &rqst, buffer);
591 	}
592 
593 	status = __ssam_retry(ssam_request_sync_onstack, SAN_REQUEST_NUM_TRIES,
594 			      d->ctrl, &rqst, &rsp, SAN_GSB_MAX_RQSX_PAYLOAD);
595 
596 	if (!status) {
597 		gsb_rqsx_response_success(buffer, rsp.pointer, rsp.length);
598 	} else {
599 		dev_err(d->dev, "rqst: failed with error %d\n", status);
600 		gsb_rqsx_response_error(buffer, status);
601 	}
602 
603 	return AE_OK;
604 }
605 
606 static acpi_status san_rqsg(struct san_data *d, struct gsb_buffer *buffer)
607 {
608 	struct gsb_data_rqsx *gsb_rqsg;
609 	struct san_dgpu_event evt;
610 	int status;
611 
612 	gsb_rqsg = san_validate_rqsx(d->dev, "RQSG", buffer);
613 	if (!gsb_rqsg)
614 		return AE_OK;
615 
616 	evt.category = gsb_rqsg->tc;
617 	evt.target = gsb_rqsg->tid;
618 	evt.command = gsb_rqsg->cid;
619 	evt.instance = gsb_rqsg->iid;
620 	evt.length = get_unaligned(&gsb_rqsg->cdl);
621 	evt.payload = &gsb_rqsg->pld[0];
622 
623 	status = san_dgpu_notifier_call(&evt);
624 	if (!status) {
625 		gsb_rqsx_response_success(buffer, NULL, 0);
626 	} else {
627 		dev_err(d->dev, "rqsg: failed with error %d\n", status);
628 		gsb_rqsx_response_error(buffer, status);
629 	}
630 
631 	return AE_OK;
632 }
633 
634 static acpi_status san_opreg_handler(u32 function, acpi_physical_address command,
635 				     u32 bits, u64 *value64, void *opreg_context,
636 				     void *region_context)
637 {
638 	struct san_data *d = to_san_data(opreg_context, info);
639 	struct gsb_buffer *buffer = (struct gsb_buffer *)value64;
640 	int accessor_type = (function & 0xFFFF0000) >> 16;
641 
642 	if (command != SAN_GSB_COMMAND) {
643 		dev_warn(d->dev, "unsupported command: %#04llx\n", command);
644 		return AE_OK;
645 	}
646 
647 	if (accessor_type != ACPI_GSB_ACCESS_ATTRIB_RAW_PROCESS) {
648 		dev_err(d->dev, "invalid access type: %#04x\n", accessor_type);
649 		return AE_OK;
650 	}
651 
652 	/* Buffer must have at least contain the command-value. */
653 	if (buffer->len == 0) {
654 		dev_err(d->dev, "request-package too small\n");
655 		return AE_OK;
656 	}
657 
658 	switch (buffer->data.in.cv) {
659 	case SAN_GSB_REQUEST_CV_RQST:
660 		return san_rqst(d, buffer);
661 
662 	case SAN_GSB_REQUEST_CV_ETWL:
663 		return san_etwl(d, buffer);
664 
665 	case SAN_GSB_REQUEST_CV_RQSG:
666 		return san_rqsg(d, buffer);
667 
668 	default:
669 		dev_warn(d->dev, "unsupported SAN0 request (cv: %#04x)\n",
670 			 buffer->data.in.cv);
671 		return AE_OK;
672 	}
673 }
674 
675 
676 /* -- Driver setup. --------------------------------------------------------- */
677 
678 static int san_events_register(struct platform_device *pdev)
679 {
680 	struct san_data *d = platform_get_drvdata(pdev);
681 	int status;
682 
683 	d->nf_bat.base.priority = 1;
684 	d->nf_bat.base.fn = san_evt_bat_nf;
685 	d->nf_bat.event.reg = SSAM_EVENT_REGISTRY_SAM;
686 	d->nf_bat.event.id.target_category = SSAM_SSH_TC_BAT;
687 	d->nf_bat.event.id.instance = 0;
688 	d->nf_bat.event.mask = SSAM_EVENT_MASK_TARGET;
689 	d->nf_bat.event.flags = SSAM_EVENT_SEQUENCED;
690 
691 	d->nf_tmp.base.priority = 1;
692 	d->nf_tmp.base.fn = san_evt_tmp_nf;
693 	d->nf_tmp.event.reg = SSAM_EVENT_REGISTRY_SAM;
694 	d->nf_tmp.event.id.target_category = SSAM_SSH_TC_TMP;
695 	d->nf_tmp.event.id.instance = 0;
696 	d->nf_tmp.event.mask = SSAM_EVENT_MASK_TARGET;
697 	d->nf_tmp.event.flags = SSAM_EVENT_SEQUENCED;
698 
699 	status = ssam_notifier_register(d->ctrl, &d->nf_bat);
700 	if (status)
701 		return status;
702 
703 	status = ssam_notifier_register(d->ctrl, &d->nf_tmp);
704 	if (status)
705 		ssam_notifier_unregister(d->ctrl, &d->nf_bat);
706 
707 	return status;
708 }
709 
710 static void san_events_unregister(struct platform_device *pdev)
711 {
712 	struct san_data *d = platform_get_drvdata(pdev);
713 
714 	ssam_notifier_unregister(d->ctrl, &d->nf_bat);
715 	ssam_notifier_unregister(d->ctrl, &d->nf_tmp);
716 }
717 
718 #define san_consumer_printk(level, dev, handle, fmt, ...)			\
719 do {										\
720 	char *path = "<error getting consumer path>";				\
721 	struct acpi_buffer buffer = {						\
722 		.length = ACPI_ALLOCATE_BUFFER,					\
723 		.pointer = NULL,						\
724 	};									\
725 										\
726 	if (ACPI_SUCCESS(acpi_get_name(handle, ACPI_FULL_PATHNAME, &buffer)))	\
727 		path = buffer.pointer;						\
728 										\
729 	dev_##level(dev, "[%s]: " fmt, path, ##__VA_ARGS__);			\
730 	kfree(buffer.pointer);							\
731 } while (0)
732 
733 #define san_consumer_dbg(dev, handle, fmt, ...) \
734 	san_consumer_printk(dbg, dev, handle, fmt, ##__VA_ARGS__)
735 
736 #define san_consumer_warn(dev, handle, fmt, ...) \
737 	san_consumer_printk(warn, dev, handle, fmt, ##__VA_ARGS__)
738 
739 static bool is_san_consumer(struct platform_device *pdev, acpi_handle handle)
740 {
741 	struct acpi_handle_list dep_devices;
742 	acpi_handle supplier = ACPI_HANDLE(&pdev->dev);
743 	acpi_status status;
744 	int i;
745 
746 	if (!acpi_has_method(handle, "_DEP"))
747 		return false;
748 
749 	status = acpi_evaluate_reference(handle, "_DEP", NULL, &dep_devices);
750 	if (ACPI_FAILURE(status)) {
751 		san_consumer_dbg(&pdev->dev, handle, "failed to evaluate _DEP\n");
752 		return false;
753 	}
754 
755 	for (i = 0; i < dep_devices.count; i++) {
756 		if (dep_devices.handles[i] == supplier)
757 			return true;
758 	}
759 
760 	return false;
761 }
762 
763 static acpi_status san_consumer_setup(acpi_handle handle, u32 lvl,
764 				      void *context, void **rv)
765 {
766 	const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER;
767 	struct platform_device *pdev = context;
768 	struct acpi_device *adev;
769 	struct device_link *link;
770 
771 	if (!is_san_consumer(pdev, handle))
772 		return AE_OK;
773 
774 	/* Ignore ACPI devices that are not present. */
775 	adev = acpi_fetch_acpi_dev(handle);
776 	if (!adev)
777 		return AE_OK;
778 
779 	san_consumer_dbg(&pdev->dev, handle, "creating device link\n");
780 
781 	/* Try to set up device links, ignore but log errors. */
782 	link = device_link_add(&adev->dev, &pdev->dev, flags);
783 	if (!link) {
784 		san_consumer_warn(&pdev->dev, handle, "failed to create device link\n");
785 		return AE_OK;
786 	}
787 
788 	return AE_OK;
789 }
790 
791 static int san_consumer_links_setup(struct platform_device *pdev)
792 {
793 	acpi_status status;
794 
795 	status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT,
796 				     ACPI_UINT32_MAX, san_consumer_setup, NULL,
797 				     pdev, NULL);
798 
799 	return status ? -EFAULT : 0;
800 }
801 
802 static int san_probe(struct platform_device *pdev)
803 {
804 	struct acpi_device *san = ACPI_COMPANION(&pdev->dev);
805 	struct ssam_controller *ctrl;
806 	struct san_data *data;
807 	acpi_status astatus;
808 	int status;
809 
810 	ctrl = ssam_client_bind(&pdev->dev);
811 	if (IS_ERR(ctrl))
812 		return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
813 
814 	status = san_consumer_links_setup(pdev);
815 	if (status)
816 		return status;
817 
818 	data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
819 	if (!data)
820 		return -ENOMEM;
821 
822 	data->dev = &pdev->dev;
823 	data->ctrl = ctrl;
824 
825 	platform_set_drvdata(pdev, data);
826 
827 	astatus = acpi_install_address_space_handler(san->handle,
828 						     ACPI_ADR_SPACE_GSBUS,
829 						     &san_opreg_handler, NULL,
830 						     &data->info);
831 	if (ACPI_FAILURE(astatus))
832 		return -ENXIO;
833 
834 	status = san_events_register(pdev);
835 	if (status)
836 		goto err_enable_events;
837 
838 	status = san_set_rqsg_interface_device(&pdev->dev);
839 	if (status)
840 		goto err_install_dev;
841 
842 	acpi_dev_clear_dependencies(san);
843 	return 0;
844 
845 err_install_dev:
846 	san_events_unregister(pdev);
847 err_enable_events:
848 	acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
849 					  &san_opreg_handler);
850 	return status;
851 }
852 
853 static int san_remove(struct platform_device *pdev)
854 {
855 	acpi_handle san = ACPI_HANDLE(&pdev->dev);
856 
857 	san_set_rqsg_interface_device(NULL);
858 	acpi_remove_address_space_handler(san, ACPI_ADR_SPACE_GSBUS,
859 					  &san_opreg_handler);
860 	san_events_unregister(pdev);
861 
862 	/*
863 	 * We have unregistered our event sources. Now we need to ensure that
864 	 * all delayed works they may have spawned are run to completion.
865 	 */
866 	flush_workqueue(san_wq);
867 
868 	return 0;
869 }
870 
871 static const struct acpi_device_id san_match[] = {
872 	{ "MSHW0091" },
873 	{ },
874 };
875 MODULE_DEVICE_TABLE(acpi, san_match);
876 
877 static struct platform_driver surface_acpi_notify = {
878 	.probe = san_probe,
879 	.remove = san_remove,
880 	.driver = {
881 		.name = "surface_acpi_notify",
882 		.acpi_match_table = san_match,
883 		.probe_type = PROBE_PREFER_ASYNCHRONOUS,
884 	},
885 };
886 
887 static int __init san_init(void)
888 {
889 	int ret;
890 
891 	san_wq = alloc_workqueue("san_wq", 0, 0);
892 	if (!san_wq)
893 		return -ENOMEM;
894 	ret = platform_driver_register(&surface_acpi_notify);
895 	if (ret)
896 		destroy_workqueue(san_wq);
897 	return ret;
898 }
899 module_init(san_init);
900 
901 static void __exit san_exit(void)
902 {
903 	platform_driver_unregister(&surface_acpi_notify);
904 	destroy_workqueue(san_wq);
905 }
906 module_exit(san_exit);
907 
908 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
909 MODULE_DESCRIPTION("Surface ACPI Notify driver for Surface System Aggregator Module");
910 MODULE_LICENSE("GPL");
911