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