1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Surface Serial Hub (SSH) driver for communication with the Surface/System 4 * Aggregator Module (SSAM/SAM). 5 * 6 * Provides access to a SAM-over-SSH connected EC via a controller device. 7 * Handles communication via requests as well as enabling, disabling, and 8 * relaying of events. 9 * 10 * Copyright (C) 2019-2022 Maximilian Luz <luzmaximilian@gmail.com> 11 */ 12 13 #include <linux/acpi.h> 14 #include <linux/atomic.h> 15 #include <linux/completion.h> 16 #include <linux/gpio/consumer.h> 17 #include <linux/kernel.h> 18 #include <linux/kref.h> 19 #include <linux/module.h> 20 #include <linux/pm.h> 21 #include <linux/serdev.h> 22 #include <linux/sysfs.h> 23 24 #include <linux/surface_aggregator/controller.h> 25 #include <linux/surface_aggregator/device.h> 26 27 #include "bus.h" 28 #include "controller.h" 29 30 #define CREATE_TRACE_POINTS 31 #include "trace.h" 32 33 34 /* -- Static controller reference. ------------------------------------------ */ 35 36 /* 37 * Main controller reference. The corresponding lock must be held while 38 * accessing (reading/writing) the reference. 39 */ 40 static struct ssam_controller *__ssam_controller; 41 static DEFINE_SPINLOCK(__ssam_controller_lock); 42 43 /** 44 * ssam_get_controller() - Get reference to SSAM controller. 45 * 46 * Returns a reference to the SSAM controller of the system or %NULL if there 47 * is none, it hasn't been set up yet, or it has already been unregistered. 48 * This function automatically increments the reference count of the 49 * controller, thus the calling party must ensure that ssam_controller_put() 50 * is called when it doesn't need the controller any more. 51 */ 52 struct ssam_controller *ssam_get_controller(void) 53 { 54 struct ssam_controller *ctrl; 55 56 spin_lock(&__ssam_controller_lock); 57 58 ctrl = __ssam_controller; 59 if (!ctrl) 60 goto out; 61 62 if (WARN_ON(!kref_get_unless_zero(&ctrl->kref))) 63 ctrl = NULL; 64 65 out: 66 spin_unlock(&__ssam_controller_lock); 67 return ctrl; 68 } 69 EXPORT_SYMBOL_GPL(ssam_get_controller); 70 71 /** 72 * ssam_try_set_controller() - Try to set the main controller reference. 73 * @ctrl: The controller to which the reference should point. 74 * 75 * Set the main controller reference to the given pointer if the reference 76 * hasn't been set already. 77 * 78 * Return: Returns zero on success or %-EEXIST if the reference has already 79 * been set. 80 */ 81 static int ssam_try_set_controller(struct ssam_controller *ctrl) 82 { 83 int status = 0; 84 85 spin_lock(&__ssam_controller_lock); 86 if (!__ssam_controller) 87 __ssam_controller = ctrl; 88 else 89 status = -EEXIST; 90 spin_unlock(&__ssam_controller_lock); 91 92 return status; 93 } 94 95 /** 96 * ssam_clear_controller() - Remove/clear the main controller reference. 97 * 98 * Clears the main controller reference, i.e. sets it to %NULL. This function 99 * should be called before the controller is shut down. 100 */ 101 static void ssam_clear_controller(void) 102 { 103 spin_lock(&__ssam_controller_lock); 104 __ssam_controller = NULL; 105 spin_unlock(&__ssam_controller_lock); 106 } 107 108 /** 109 * ssam_client_link() - Link an arbitrary client device to the controller. 110 * @c: The controller to link to. 111 * @client: The client device. 112 * 113 * Link an arbitrary client device to the controller by creating a device link 114 * between it as consumer and the controller device as provider. This function 115 * can be used for non-SSAM devices (or SSAM devices not registered as child 116 * under the controller) to guarantee that the controller is valid for as long 117 * as the driver of the client device is bound, and that proper suspend and 118 * resume ordering is guaranteed. 119 * 120 * The device link does not have to be destructed manually. It is removed 121 * automatically once the driver of the client device unbinds. 122 * 123 * Return: Returns zero on success, %-ENODEV if the controller is not ready or 124 * going to be removed soon, or %-ENOMEM if the device link could not be 125 * created for other reasons. 126 */ 127 int ssam_client_link(struct ssam_controller *c, struct device *client) 128 { 129 const u32 flags = DL_FLAG_PM_RUNTIME | DL_FLAG_AUTOREMOVE_CONSUMER; 130 struct device_link *link; 131 struct device *ctrldev; 132 133 ssam_controller_statelock(c); 134 135 if (c->state != SSAM_CONTROLLER_STARTED) { 136 ssam_controller_stateunlock(c); 137 return -ENODEV; 138 } 139 140 ctrldev = ssam_controller_device(c); 141 if (!ctrldev) { 142 ssam_controller_stateunlock(c); 143 return -ENODEV; 144 } 145 146 link = device_link_add(client, ctrldev, flags); 147 if (!link) { 148 ssam_controller_stateunlock(c); 149 return -ENOMEM; 150 } 151 152 /* 153 * Return -ENODEV if supplier driver is on its way to be removed. In 154 * this case, the controller won't be around for much longer and the 155 * device link is not going to save us any more, as unbinding is 156 * already in progress. 157 */ 158 if (READ_ONCE(link->status) == DL_STATE_SUPPLIER_UNBIND) { 159 ssam_controller_stateunlock(c); 160 return -ENODEV; 161 } 162 163 ssam_controller_stateunlock(c); 164 return 0; 165 } 166 EXPORT_SYMBOL_GPL(ssam_client_link); 167 168 /** 169 * ssam_client_bind() - Bind an arbitrary client device to the controller. 170 * @client: The client device. 171 * 172 * Link an arbitrary client device to the controller by creating a device link 173 * between it as consumer and the main controller device as provider. This 174 * function can be used for non-SSAM devices to guarantee that the controller 175 * returned by this function is valid for as long as the driver of the client 176 * device is bound, and that proper suspend and resume ordering is guaranteed. 177 * 178 * This function does essentially the same as ssam_client_link(), except that 179 * it first fetches the main controller reference, then creates the link, and 180 * finally returns this reference. Note that this function does not increment 181 * the reference counter of the controller, as, due to the link, the 182 * controller lifetime is assured as long as the driver of the client device 183 * is bound. 184 * 185 * It is not valid to use the controller reference obtained by this method 186 * outside of the driver bound to the client device at the time of calling 187 * this function, without first incrementing the reference count of the 188 * controller via ssam_controller_get(). Even after doing this, care must be 189 * taken that requests are only submitted and notifiers are only 190 * (un-)registered when the controller is active and not suspended. In other 191 * words: The device link only lives as long as the client driver is bound and 192 * any guarantees enforced by this link (e.g. active controller state) can 193 * only be relied upon as long as this link exists and may need to be enforced 194 * in other ways afterwards. 195 * 196 * The created device link does not have to be destructed manually. It is 197 * removed automatically once the driver of the client device unbinds. 198 * 199 * Return: Returns the controller on success, an error pointer with %-ENODEV 200 * if the controller is not present, not ready or going to be removed soon, or 201 * %-ENOMEM if the device link could not be created for other reasons. 202 */ 203 struct ssam_controller *ssam_client_bind(struct device *client) 204 { 205 struct ssam_controller *c; 206 int status; 207 208 c = ssam_get_controller(); 209 if (!c) 210 return ERR_PTR(-ENODEV); 211 212 status = ssam_client_link(c, client); 213 214 /* 215 * Note that we can drop our controller reference in both success and 216 * failure cases: On success, we have bound the controller lifetime 217 * inherently to the client driver lifetime, i.e. it the controller is 218 * now guaranteed to outlive the client driver. On failure, we're not 219 * going to use the controller any more. 220 */ 221 ssam_controller_put(c); 222 223 return status >= 0 ? c : ERR_PTR(status); 224 } 225 EXPORT_SYMBOL_GPL(ssam_client_bind); 226 227 228 /* -- Glue layer (serdev_device -> ssam_controller). ------------------------ */ 229 230 static ssize_t ssam_receive_buf(struct serdev_device *dev, const u8 *buf, 231 size_t n) 232 { 233 struct ssam_controller *ctrl; 234 int ret; 235 236 ctrl = serdev_device_get_drvdata(dev); 237 ret = ssam_controller_receive_buf(ctrl, buf, n); 238 239 return ret < 0 ? 0 : ret; 240 } 241 242 static void ssam_write_wakeup(struct serdev_device *dev) 243 { 244 ssam_controller_write_wakeup(serdev_device_get_drvdata(dev)); 245 } 246 247 static const struct serdev_device_ops ssam_serdev_ops = { 248 .receive_buf = ssam_receive_buf, 249 .write_wakeup = ssam_write_wakeup, 250 }; 251 252 253 /* -- SysFS and misc. ------------------------------------------------------- */ 254 255 static int ssam_log_firmware_version(struct ssam_controller *ctrl) 256 { 257 u32 version, a, b, c; 258 int status; 259 260 status = ssam_get_firmware_version(ctrl, &version); 261 if (status) 262 return status; 263 264 a = (version >> 24) & 0xff; 265 b = ((version >> 8) & 0xffff); 266 c = version & 0xff; 267 268 ssam_info(ctrl, "SAM firmware version: %u.%u.%u\n", a, b, c); 269 return 0; 270 } 271 272 static ssize_t firmware_version_show(struct device *dev, 273 struct device_attribute *attr, char *buf) 274 { 275 struct ssam_controller *ctrl = dev_get_drvdata(dev); 276 u32 version, a, b, c; 277 int status; 278 279 status = ssam_get_firmware_version(ctrl, &version); 280 if (status < 0) 281 return status; 282 283 a = (version >> 24) & 0xff; 284 b = ((version >> 8) & 0xffff); 285 c = version & 0xff; 286 287 return sysfs_emit(buf, "%u.%u.%u\n", a, b, c); 288 } 289 static DEVICE_ATTR_RO(firmware_version); 290 291 static struct attribute *ssam_sam_attrs[] = { 292 &dev_attr_firmware_version.attr, 293 NULL 294 }; 295 296 static const struct attribute_group ssam_sam_group = { 297 .name = "sam", 298 .attrs = ssam_sam_attrs, 299 }; 300 301 302 /* -- ACPI based device setup. ---------------------------------------------- */ 303 304 static acpi_status ssam_serdev_setup_via_acpi_crs(struct acpi_resource *rsc, 305 void *ctx) 306 { 307 struct serdev_device *serdev = ctx; 308 struct acpi_resource_uart_serialbus *uart; 309 bool flow_control; 310 int status = 0; 311 312 if (!serdev_acpi_get_uart_resource(rsc, &uart)) 313 return AE_OK; 314 315 /* Set up serdev device. */ 316 serdev_device_set_baudrate(serdev, uart->default_baud_rate); 317 318 /* serdev currently only supports RTSCTS flow control. */ 319 if (uart->flow_control & (~((u8)ACPI_UART_FLOW_CONTROL_HW))) { 320 dev_warn(&serdev->dev, "setup: unsupported flow control (value: %#04x)\n", 321 uart->flow_control); 322 } 323 324 /* Set RTSCTS flow control. */ 325 flow_control = uart->flow_control & ACPI_UART_FLOW_CONTROL_HW; 326 serdev_device_set_flow_control(serdev, flow_control); 327 328 /* serdev currently only supports EVEN/ODD parity. */ 329 switch (uart->parity) { 330 case ACPI_UART_PARITY_NONE: 331 status = serdev_device_set_parity(serdev, SERDEV_PARITY_NONE); 332 break; 333 case ACPI_UART_PARITY_EVEN: 334 status = serdev_device_set_parity(serdev, SERDEV_PARITY_EVEN); 335 break; 336 case ACPI_UART_PARITY_ODD: 337 status = serdev_device_set_parity(serdev, SERDEV_PARITY_ODD); 338 break; 339 default: 340 dev_warn(&serdev->dev, "setup: unsupported parity (value: %#04x)\n", 341 uart->parity); 342 break; 343 } 344 345 if (status) { 346 dev_err(&serdev->dev, "setup: failed to set parity (value: %#04x, error: %d)\n", 347 uart->parity, status); 348 return AE_ERROR; 349 } 350 351 /* We've found the resource and are done. */ 352 return AE_CTRL_TERMINATE; 353 } 354 355 static acpi_status ssam_serdev_setup_via_acpi(acpi_handle handle, 356 struct serdev_device *serdev) 357 { 358 return acpi_walk_resources(handle, METHOD_NAME__CRS, 359 ssam_serdev_setup_via_acpi_crs, serdev); 360 } 361 362 363 /* -- Power management. ----------------------------------------------------- */ 364 365 static void ssam_serial_hub_shutdown(struct device *dev) 366 { 367 struct ssam_controller *c = dev_get_drvdata(dev); 368 int status; 369 370 /* 371 * Try to disable notifiers, signal display-off and D0-exit, ignore any 372 * errors. 373 * 374 * Note: It has not been established yet if this is actually 375 * necessary/useful for shutdown. 376 */ 377 378 status = ssam_notifier_disable_registered(c); 379 if (status) { 380 ssam_err(c, "pm: failed to disable notifiers for shutdown: %d\n", 381 status); 382 } 383 384 status = ssam_ctrl_notif_display_off(c); 385 if (status) 386 ssam_err(c, "pm: display-off notification failed: %d\n", status); 387 388 status = ssam_ctrl_notif_d0_exit(c); 389 if (status) 390 ssam_err(c, "pm: D0-exit notification failed: %d\n", status); 391 } 392 393 #ifdef CONFIG_PM_SLEEP 394 395 static int ssam_serial_hub_pm_prepare(struct device *dev) 396 { 397 struct ssam_controller *c = dev_get_drvdata(dev); 398 int status; 399 400 /* 401 * Try to signal display-off, This will quiesce events. 402 * 403 * Note: Signaling display-off/display-on should normally be done from 404 * some sort of display state notifier. As that is not available, 405 * signal it here. 406 */ 407 408 status = ssam_ctrl_notif_display_off(c); 409 if (status) 410 ssam_err(c, "pm: display-off notification failed: %d\n", status); 411 412 return status; 413 } 414 415 static void ssam_serial_hub_pm_complete(struct device *dev) 416 { 417 struct ssam_controller *c = dev_get_drvdata(dev); 418 int status; 419 420 /* 421 * Try to signal display-on. This will restore events. 422 * 423 * Note: Signaling display-off/display-on should normally be done from 424 * some sort of display state notifier. As that is not available, 425 * signal it here. 426 */ 427 428 status = ssam_ctrl_notif_display_on(c); 429 if (status) 430 ssam_err(c, "pm: display-on notification failed: %d\n", status); 431 } 432 433 static int ssam_serial_hub_pm_suspend(struct device *dev) 434 { 435 struct ssam_controller *c = dev_get_drvdata(dev); 436 int status; 437 438 /* 439 * Try to signal D0-exit, enable IRQ wakeup if specified. Abort on 440 * error. 441 */ 442 443 status = ssam_ctrl_notif_d0_exit(c); 444 if (status) { 445 ssam_err(c, "pm: D0-exit notification failed: %d\n", status); 446 goto err_notif; 447 } 448 449 status = ssam_irq_arm_for_wakeup(c); 450 if (status) 451 goto err_irq; 452 453 WARN_ON(ssam_controller_suspend(c)); 454 return 0; 455 456 err_irq: 457 ssam_ctrl_notif_d0_entry(c); 458 err_notif: 459 ssam_ctrl_notif_display_on(c); 460 return status; 461 } 462 463 static int ssam_serial_hub_pm_resume(struct device *dev) 464 { 465 struct ssam_controller *c = dev_get_drvdata(dev); 466 int status; 467 468 WARN_ON(ssam_controller_resume(c)); 469 470 /* 471 * Try to disable IRQ wakeup (if specified) and signal D0-entry. In 472 * case of errors, log them and try to restore normal operation state 473 * as far as possible. 474 * 475 * Note: Signaling display-off/display-on should normally be done from 476 * some sort of display state notifier. As that is not available, 477 * signal it here. 478 */ 479 480 ssam_irq_disarm_wakeup(c); 481 482 status = ssam_ctrl_notif_d0_entry(c); 483 if (status) 484 ssam_err(c, "pm: D0-entry notification failed: %d\n", status); 485 486 return 0; 487 } 488 489 static int ssam_serial_hub_pm_freeze(struct device *dev) 490 { 491 struct ssam_controller *c = dev_get_drvdata(dev); 492 int status; 493 494 /* 495 * During hibernation image creation, we only have to ensure that the 496 * EC doesn't send us any events. This is done via the display-off 497 * and D0-exit notifications. Note that this sets up the wakeup IRQ 498 * on the EC side, however, we have disabled it by default on our side 499 * and won't enable it here. 500 * 501 * See ssam_serial_hub_poweroff() for more details on the hibernation 502 * process. 503 */ 504 505 status = ssam_ctrl_notif_d0_exit(c); 506 if (status) { 507 ssam_err(c, "pm: D0-exit notification failed: %d\n", status); 508 ssam_ctrl_notif_display_on(c); 509 return status; 510 } 511 512 WARN_ON(ssam_controller_suspend(c)); 513 return 0; 514 } 515 516 static int ssam_serial_hub_pm_thaw(struct device *dev) 517 { 518 struct ssam_controller *c = dev_get_drvdata(dev); 519 int status; 520 521 WARN_ON(ssam_controller_resume(c)); 522 523 status = ssam_ctrl_notif_d0_entry(c); 524 if (status) 525 ssam_err(c, "pm: D0-exit notification failed: %d\n", status); 526 527 return status; 528 } 529 530 static int ssam_serial_hub_pm_poweroff(struct device *dev) 531 { 532 struct ssam_controller *c = dev_get_drvdata(dev); 533 int status; 534 535 /* 536 * When entering hibernation and powering off the system, the EC, at 537 * least on some models, may disable events. Without us taking care of 538 * that, this leads to events not being enabled/restored when the 539 * system resumes from hibernation, resulting SAM-HID subsystem devices 540 * (i.e. keyboard, touchpad) not working, AC-plug/AC-unplug events being 541 * gone, etc. 542 * 543 * To avoid these issues, we disable all registered events here (this is 544 * likely not actually required) and restore them during the drivers PM 545 * restore callback. 546 * 547 * Wakeup from the EC interrupt is not supported during hibernation, 548 * so don't arm the IRQ here. 549 */ 550 551 status = ssam_notifier_disable_registered(c); 552 if (status) { 553 ssam_err(c, "pm: failed to disable notifiers for hibernation: %d\n", 554 status); 555 return status; 556 } 557 558 status = ssam_ctrl_notif_d0_exit(c); 559 if (status) { 560 ssam_err(c, "pm: D0-exit notification failed: %d\n", status); 561 ssam_notifier_restore_registered(c); 562 return status; 563 } 564 565 WARN_ON(ssam_controller_suspend(c)); 566 return 0; 567 } 568 569 static int ssam_serial_hub_pm_restore(struct device *dev) 570 { 571 struct ssam_controller *c = dev_get_drvdata(dev); 572 int status; 573 574 /* 575 * Ignore but log errors, try to restore state as much as possible in 576 * case of failures. See ssam_serial_hub_poweroff() for more details on 577 * the hibernation process. 578 */ 579 580 WARN_ON(ssam_controller_resume(c)); 581 582 status = ssam_ctrl_notif_d0_entry(c); 583 if (status) 584 ssam_err(c, "pm: D0-entry notification failed: %d\n", status); 585 586 ssam_notifier_restore_registered(c); 587 return 0; 588 } 589 590 static const struct dev_pm_ops ssam_serial_hub_pm_ops = { 591 .prepare = ssam_serial_hub_pm_prepare, 592 .complete = ssam_serial_hub_pm_complete, 593 .suspend = ssam_serial_hub_pm_suspend, 594 .resume = ssam_serial_hub_pm_resume, 595 .freeze = ssam_serial_hub_pm_freeze, 596 .thaw = ssam_serial_hub_pm_thaw, 597 .poweroff = ssam_serial_hub_pm_poweroff, 598 .restore = ssam_serial_hub_pm_restore, 599 }; 600 601 #else /* CONFIG_PM_SLEEP */ 602 603 static const struct dev_pm_ops ssam_serial_hub_pm_ops = { }; 604 605 #endif /* CONFIG_PM_SLEEP */ 606 607 608 /* -- Device/driver setup. -------------------------------------------------- */ 609 610 static const struct acpi_gpio_params gpio_ssam_wakeup_int = { 0, 0, false }; 611 static const struct acpi_gpio_params gpio_ssam_wakeup = { 1, 0, false }; 612 613 static const struct acpi_gpio_mapping ssam_acpi_gpios[] = { 614 { "ssam_wakeup-int-gpio", &gpio_ssam_wakeup_int, 1 }, 615 { "ssam_wakeup-gpio", &gpio_ssam_wakeup, 1 }, 616 { }, 617 }; 618 619 static int ssam_serial_hub_probe(struct serdev_device *serdev) 620 { 621 struct acpi_device *ssh = ACPI_COMPANION(&serdev->dev); 622 struct ssam_controller *ctrl; 623 acpi_status astatus; 624 int status; 625 626 if (gpiod_count(&serdev->dev, NULL) < 0) 627 return -ENODEV; 628 629 status = devm_acpi_dev_add_driver_gpios(&serdev->dev, ssam_acpi_gpios); 630 if (status) 631 return status; 632 633 /* Allocate controller. */ 634 ctrl = kzalloc(sizeof(*ctrl), GFP_KERNEL); 635 if (!ctrl) 636 return -ENOMEM; 637 638 /* Initialize controller. */ 639 status = ssam_controller_init(ctrl, serdev); 640 if (status) 641 goto err_ctrl_init; 642 643 ssam_controller_lock(ctrl); 644 645 /* Set up serdev device. */ 646 serdev_device_set_drvdata(serdev, ctrl); 647 serdev_device_set_client_ops(serdev, &ssam_serdev_ops); 648 status = serdev_device_open(serdev); 649 if (status) 650 goto err_devopen; 651 652 astatus = ssam_serdev_setup_via_acpi(ssh->handle, serdev); 653 if (ACPI_FAILURE(astatus)) { 654 status = -ENXIO; 655 goto err_devinit; 656 } 657 658 /* Start controller. */ 659 status = ssam_controller_start(ctrl); 660 if (status) 661 goto err_devinit; 662 663 ssam_controller_unlock(ctrl); 664 665 /* 666 * Initial SAM requests: Log version and notify default/init power 667 * states. 668 */ 669 status = ssam_log_firmware_version(ctrl); 670 if (status) 671 goto err_initrq; 672 673 status = ssam_ctrl_notif_d0_entry(ctrl); 674 if (status) 675 goto err_initrq; 676 677 status = ssam_ctrl_notif_display_on(ctrl); 678 if (status) 679 goto err_initrq; 680 681 status = sysfs_create_group(&serdev->dev.kobj, &ssam_sam_group); 682 if (status) 683 goto err_initrq; 684 685 /* Set up IRQ. */ 686 status = ssam_irq_setup(ctrl); 687 if (status) 688 goto err_irq; 689 690 /* Finally, set main controller reference. */ 691 status = ssam_try_set_controller(ctrl); 692 if (WARN_ON(status)) /* Currently, we're the only provider. */ 693 goto err_mainref; 694 695 /* 696 * TODO: The EC can wake up the system via the associated GPIO interrupt 697 * in multiple situations. One of which is the remaining battery 698 * capacity falling below a certain threshold. Normally, we should 699 * use the device_init_wakeup function, however, the EC also seems 700 * to have other reasons for waking up the system and it seems 701 * that Windows has additional checks whether the system should be 702 * resumed. In short, this causes some spurious unwanted wake-ups. 703 * For now let's thus default power/wakeup to false. 704 */ 705 device_set_wakeup_capable(&serdev->dev, true); 706 acpi_dev_clear_dependencies(ssh); 707 708 return 0; 709 710 err_mainref: 711 ssam_irq_free(ctrl); 712 err_irq: 713 sysfs_remove_group(&serdev->dev.kobj, &ssam_sam_group); 714 err_initrq: 715 ssam_controller_lock(ctrl); 716 ssam_controller_shutdown(ctrl); 717 err_devinit: 718 serdev_device_close(serdev); 719 err_devopen: 720 ssam_controller_destroy(ctrl); 721 ssam_controller_unlock(ctrl); 722 err_ctrl_init: 723 kfree(ctrl); 724 return status; 725 } 726 727 static void ssam_serial_hub_remove(struct serdev_device *serdev) 728 { 729 struct ssam_controller *ctrl = serdev_device_get_drvdata(serdev); 730 int status; 731 732 /* Clear static reference so that no one else can get a new one. */ 733 ssam_clear_controller(); 734 735 /* Disable and free IRQ. */ 736 ssam_irq_free(ctrl); 737 738 sysfs_remove_group(&serdev->dev.kobj, &ssam_sam_group); 739 ssam_controller_lock(ctrl); 740 741 /* Remove all client devices. */ 742 ssam_remove_clients(&serdev->dev); 743 744 /* Act as if suspending to silence events. */ 745 status = ssam_ctrl_notif_display_off(ctrl); 746 if (status) { 747 dev_err(&serdev->dev, "display-off notification failed: %d\n", 748 status); 749 } 750 751 status = ssam_ctrl_notif_d0_exit(ctrl); 752 if (status) { 753 dev_err(&serdev->dev, "D0-exit notification failed: %d\n", 754 status); 755 } 756 757 /* Shut down controller and remove serdev device reference from it. */ 758 ssam_controller_shutdown(ctrl); 759 760 /* Shut down actual transport. */ 761 serdev_device_wait_until_sent(serdev, 0); 762 serdev_device_close(serdev); 763 764 /* Drop our controller reference. */ 765 ssam_controller_unlock(ctrl); 766 ssam_controller_put(ctrl); 767 768 device_set_wakeup_capable(&serdev->dev, false); 769 } 770 771 static const struct acpi_device_id ssam_serial_hub_match[] = { 772 { "MSHW0084", 0 }, 773 { }, 774 }; 775 MODULE_DEVICE_TABLE(acpi, ssam_serial_hub_match); 776 777 static struct serdev_device_driver ssam_serial_hub = { 778 .probe = ssam_serial_hub_probe, 779 .remove = ssam_serial_hub_remove, 780 .driver = { 781 .name = "surface_serial_hub", 782 .acpi_match_table = ssam_serial_hub_match, 783 .pm = &ssam_serial_hub_pm_ops, 784 .shutdown = ssam_serial_hub_shutdown, 785 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 786 }, 787 }; 788 789 790 /* -- Module setup. --------------------------------------------------------- */ 791 792 static int __init ssam_core_init(void) 793 { 794 int status; 795 796 status = ssam_bus_register(); 797 if (status) 798 goto err_bus; 799 800 status = ssh_ctrl_packet_cache_init(); 801 if (status) 802 goto err_cpkg; 803 804 status = ssam_event_item_cache_init(); 805 if (status) 806 goto err_evitem; 807 808 status = serdev_device_driver_register(&ssam_serial_hub); 809 if (status) 810 goto err_register; 811 812 return 0; 813 814 err_register: 815 ssam_event_item_cache_destroy(); 816 err_evitem: 817 ssh_ctrl_packet_cache_destroy(); 818 err_cpkg: 819 ssam_bus_unregister(); 820 err_bus: 821 return status; 822 } 823 subsys_initcall(ssam_core_init); 824 825 static void __exit ssam_core_exit(void) 826 { 827 serdev_device_driver_unregister(&ssam_serial_hub); 828 ssam_event_item_cache_destroy(); 829 ssh_ctrl_packet_cache_destroy(); 830 ssam_bus_unregister(); 831 } 832 module_exit(ssam_core_exit); 833 834 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>"); 835 MODULE_DESCRIPTION("Subsystem and Surface Serial Hub driver for Surface System Aggregator Module"); 836 MODULE_LICENSE("GPL"); 837