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(sem: &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(sem: &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(sem: &san_rqsg_if.lock); |
92 | |
93 | if (!san_rqsg_if.dev) { |
94 | up_read(sem: &san_rqsg_if.lock); |
95 | return -ENXIO; |
96 | } |
97 | |
98 | link = device_link_add(consumer: client, supplier: san_rqsg_if.dev, flags); |
99 | if (!link) { |
100 | up_read(sem: &san_rqsg_if.lock); |
101 | return -ENOMEM; |
102 | } |
103 | |
104 | if (READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) { |
105 | up_read(sem: &san_rqsg_if.lock); |
106 | return -ENXIO; |
107 | } |
108 | |
109 | up_read(sem: &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(nh: &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(nh: &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(nh: &san_rqsg_if.nh, val: evt->command, v: 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(handle: san, guid: &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(handle: san, guid: &SAN_DSM_UUID, SAN_DSM_REVISION, |
198 | func, argv4: 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, func: 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, func: SAN_DSM_EVENT_FN_BAT1_STAT, NULL); |
227 | if (status) |
228 | return status; |
229 | |
230 | return san_acpi_notify_event(dev, func: 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, func: 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, func: 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, func: SAN_DSM_EVENT_FN_DPTF, param: &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(m: 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(m: 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(event: &ev->event, dev: ev->dev); |
338 | kfree(objp: 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(cid: event->command_id); |
347 | |
348 | if (delay == 0) |
349 | return san_evt_bat(event, dev: d->dev) ? SSAM_NOTIF_HANDLED : 0; |
350 | |
351 | work = kzalloc(size: sizeof(*work) + event->length, GFP_KERNEL); |
352 | if (!work) |
353 | return ssam_notifier_from_errno(err: -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(wq: san_wq, dwork: &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, func: SAN_DSM_EVENT_FN_THERMAL, param: ¶m); |
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, dev: 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, ptr: &base_state, len: sizeof(base_state)); |
556 | return AE_OK; |
557 | } |
558 | |
559 | gsb_rqsx_response_error(gsb, status: -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(dev: d->dev, type: "RQST" , b: 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: &rqst, gsb: buffer); |
591 | } |
592 | |
593 | status = __ssam_retry(ssam_request_do_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(gsb: buffer, ptr: rsp.pointer, len: rsp.length); |
598 | } else { |
599 | dev_err(d->dev, "rqst: failed with error %d\n" , status); |
600 | gsb_rqsx_response_error(gsb: 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(dev: d->dev, type: "RQSG" , b: 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: &evt); |
624 | if (!status) { |
625 | gsb_rqsx_response_success(gsb: buffer, NULL, len: 0); |
626 | } else { |
627 | dev_err(d->dev, "rqsg: failed with error %d\n" , status); |
628 | gsb_rqsx_response_error(gsb: 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, b: 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(ctrl: d->ctrl, n: &d->nf_bat); |
700 | if (status) |
701 | return status; |
702 | |
703 | status = ssam_notifier_register(ctrl: d->ctrl, n: &d->nf_tmp); |
704 | if (status) |
705 | ssam_notifier_unregister(ctrl: d->ctrl, n: &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(ctrl: d->ctrl, n: &d->nf_bat); |
715 | ssam_notifier_unregister(ctrl: d->ctrl, n: &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 acpi_status san_consumer_setup(acpi_handle handle, u32 lvl, |
740 | void *context, void **rv) |
741 | { |
742 | const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_SUPPLIER; |
743 | struct platform_device *pdev = context; |
744 | struct acpi_device *adev; |
745 | struct device_link *link; |
746 | |
747 | if (!acpi_device_dep(target: handle, ACPI_HANDLE(&pdev->dev))) |
748 | return AE_OK; |
749 | |
750 | /* Ignore ACPI devices that are not present. */ |
751 | adev = acpi_fetch_acpi_dev(handle); |
752 | if (!adev) |
753 | return AE_OK; |
754 | |
755 | san_consumer_dbg(&pdev->dev, handle, "creating device link\n" ); |
756 | |
757 | /* Try to set up device links, ignore but log errors. */ |
758 | link = device_link_add(consumer: &adev->dev, supplier: &pdev->dev, flags); |
759 | if (!link) { |
760 | san_consumer_warn(&pdev->dev, handle, "failed to create device link\n" ); |
761 | return AE_OK; |
762 | } |
763 | |
764 | return AE_OK; |
765 | } |
766 | |
767 | static int san_consumer_links_setup(struct platform_device *pdev) |
768 | { |
769 | acpi_status status; |
770 | |
771 | status = acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, |
772 | ACPI_UINT32_MAX, descending_callback: san_consumer_setup, NULL, |
773 | context: pdev, NULL); |
774 | |
775 | return status ? -EFAULT : 0; |
776 | } |
777 | |
778 | static int san_probe(struct platform_device *pdev) |
779 | { |
780 | struct acpi_device *san = ACPI_COMPANION(&pdev->dev); |
781 | struct ssam_controller *ctrl; |
782 | struct san_data *data; |
783 | acpi_status astatus; |
784 | int status; |
785 | |
786 | ctrl = ssam_client_bind(client: &pdev->dev); |
787 | if (IS_ERR(ptr: ctrl)) |
788 | return PTR_ERR(ptr: ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ptr: ctrl); |
789 | |
790 | status = san_consumer_links_setup(pdev); |
791 | if (status) |
792 | return status; |
793 | |
794 | data = devm_kzalloc(dev: &pdev->dev, size: sizeof(*data), GFP_KERNEL); |
795 | if (!data) |
796 | return -ENOMEM; |
797 | |
798 | data->dev = &pdev->dev; |
799 | data->ctrl = ctrl; |
800 | |
801 | platform_set_drvdata(pdev, data); |
802 | |
803 | astatus = acpi_install_address_space_handler(device: san->handle, |
804 | ACPI_ADR_SPACE_GSBUS, |
805 | handler: &san_opreg_handler, NULL, |
806 | context: &data->info); |
807 | if (ACPI_FAILURE(astatus)) |
808 | return -ENXIO; |
809 | |
810 | status = san_events_register(pdev); |
811 | if (status) |
812 | goto err_enable_events; |
813 | |
814 | status = san_set_rqsg_interface_device(dev: &pdev->dev); |
815 | if (status) |
816 | goto err_install_dev; |
817 | |
818 | acpi_dev_clear_dependencies(supplier: san); |
819 | return 0; |
820 | |
821 | err_install_dev: |
822 | san_events_unregister(pdev); |
823 | err_enable_events: |
824 | acpi_remove_address_space_handler(device: san, ACPI_ADR_SPACE_GSBUS, |
825 | handler: &san_opreg_handler); |
826 | return status; |
827 | } |
828 | |
829 | static void san_remove(struct platform_device *pdev) |
830 | { |
831 | acpi_handle san = ACPI_HANDLE(&pdev->dev); |
832 | |
833 | san_set_rqsg_interface_device(NULL); |
834 | acpi_remove_address_space_handler(device: san, ACPI_ADR_SPACE_GSBUS, |
835 | handler: &san_opreg_handler); |
836 | san_events_unregister(pdev); |
837 | |
838 | /* |
839 | * We have unregistered our event sources. Now we need to ensure that |
840 | * all delayed works they may have spawned are run to completion. |
841 | */ |
842 | flush_workqueue(san_wq); |
843 | } |
844 | |
845 | static const struct acpi_device_id san_match[] = { |
846 | { "MSHW0091" }, |
847 | { }, |
848 | }; |
849 | MODULE_DEVICE_TABLE(acpi, san_match); |
850 | |
851 | static struct platform_driver surface_acpi_notify = { |
852 | .probe = san_probe, |
853 | .remove_new = san_remove, |
854 | .driver = { |
855 | .name = "surface_acpi_notify" , |
856 | .acpi_match_table = san_match, |
857 | .probe_type = PROBE_PREFER_ASYNCHRONOUS, |
858 | }, |
859 | }; |
860 | |
861 | static int __init san_init(void) |
862 | { |
863 | int ret; |
864 | |
865 | san_wq = alloc_workqueue(fmt: "san_wq" , flags: 0, max_active: 0); |
866 | if (!san_wq) |
867 | return -ENOMEM; |
868 | ret = platform_driver_register(&surface_acpi_notify); |
869 | if (ret) |
870 | destroy_workqueue(wq: san_wq); |
871 | return ret; |
872 | } |
873 | module_init(san_init); |
874 | |
875 | static void __exit san_exit(void) |
876 | { |
877 | platform_driver_unregister(&surface_acpi_notify); |
878 | destroy_workqueue(wq: san_wq); |
879 | } |
880 | module_exit(san_exit); |
881 | |
882 | MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>" ); |
883 | MODULE_DESCRIPTION("Surface ACPI Notify driver for Surface System Aggregator Module" ); |
884 | MODULE_LICENSE("GPL" ); |
885 | |