drivers/platform/surface/surface_aggregator_registry.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Surface System Aggregator Module (SSAM) client device registry.
   4  *
   5  * Registry for non-platform/non-ACPI SSAM client devices, i.e. devices that
   6  * cannot be auto-detected. Provides device-hubs and performs instantiation
   7  * for these devices.
   8  *
   9  * Copyright (C) 2020-2021 Maximilian Luz <luzmaximilian@gmail.com>
  10  */
  11
  12 #include <linux/acpi.h>
  13 #include <linux/kernel.h>
  14 #include <linux/limits.h>
  15 #include <linux/module.h>
  16 #include <linux/mutex.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/property.h>
  19 #include <linux/types.h>
  20
  21 #include <linux/surface_aggregator/controller.h>
  22 #include <linux/surface_aggregator/device.h>
  23
  24
  25 /* -- Device registry. ------------------------------------------------------ */
  26
  27 /*
  28  * SSAM device names follow the SSAM module alias, meaning they are prefixed
  29  * with 'ssam:', followed by domain, category, target ID, instance ID, and
  30  * function, each encoded as two-digit hexadecimal, separated by ':'. In other
  31  * words, it follows the scheme
  32  *
  33  *      ssam:dd:cc:tt:ii:ff
  34  *
  35  * Where, 'dd', 'cc', 'tt', 'ii', and 'ff' are the two-digit hexadecimal
  36  * values mentioned above, respectively.
  37  */
  38
  39 /* Root node. */
  40 static const struct software_node ssam_node_root = {
  41         .name = "ssam_platform_hub",
  42 };
  43
  44 /* Base device hub (devices attached to Surface Book 3 base). */
  45 static const struct software_node ssam_node_hub_base = {
  46         .name = "ssam:00:00:02:00:00",
  47         .parent = &ssam_node_root,
  48 };
  49
  50 /* AC adapter. */
  51 static const struct software_node ssam_node_bat_ac = {
  52         .name = "ssam:01:02:01:01:01",
  53         .parent = &ssam_node_root,
  54 };
  55
  56 /* Primary battery. */
  57 static const struct software_node ssam_node_bat_main = {
  58         .name = "ssam:01:02:01:01:00",
  59         .parent = &ssam_node_root,
  60 };
  61
  62 /* Secondary battery (Surface Book 3). */
  63 static const struct software_node ssam_node_bat_sb3base = {
  64         .name = "ssam:01:02:02:01:00",
  65         .parent = &ssam_node_hub_base,
  66 };
  67
  68 /* Platform profile / performance-mode device. */
  69 static const struct software_node ssam_node_tmp_pprof = {
  70         .name = "ssam:01:03:01:00:01",
  71         .parent = &ssam_node_root,
  72 };
  73
  74 /* DTX / detachment-system device (Surface Book 3). */
  75 static const struct software_node ssam_node_bas_dtx = {
  76         .name = "ssam:01:11:01:00:00",
  77         .parent = &ssam_node_root,
  78 };
  79
  80 /* HID keyboard. */
  81 static const struct software_node ssam_node_hid_main_keyboard = {
  82         .name = "ssam:01:15:02:01:00",
  83         .parent = &ssam_node_root,
  84 };
  85
  86 /* HID touchpad. */
  87 static const struct software_node ssam_node_hid_main_touchpad = {
  88         .name = "ssam:01:15:02:03:00",
  89         .parent = &ssam_node_root,
  90 };
  91
  92 /* HID device instance 5 (unknown HID device). */
  93 static const struct software_node ssam_node_hid_main_iid5 = {
  94         .name = "ssam:01:15:02:05:00",
  95         .parent = &ssam_node_root,
  96 };
  97
  98 /* HID keyboard (base hub). */
  99 static const struct software_node ssam_node_hid_base_keyboard = {
 100         .name = "ssam:01:15:02:01:00",
 101         .parent = &ssam_node_hub_base,
 102 };
 103
 104 /* HID touchpad (base hub). */
 105 static const struct software_node ssam_node_hid_base_touchpad = {
 106         .name = "ssam:01:15:02:03:00",
 107         .parent = &ssam_node_hub_base,
 108 };
 109
 110 /* HID device instance 5 (unknown HID device, base hub). */
 111 static const struct software_node ssam_node_hid_base_iid5 = {
 112         .name = "ssam:01:15:02:05:00",
 113         .parent = &ssam_node_hub_base,
 114 };
 115
 116 /* HID device instance 6 (unknown HID device, base hub). */
 117 static const struct software_node ssam_node_hid_base_iid6 = {
 118         .name = "ssam:01:15:02:06:00",
 119         .parent = &ssam_node_hub_base,
 120 };
 121
 122 /* Devices for Surface Book 2. */
 123 static const struct software_node *ssam_node_group_sb2[] = {
 124         &ssam_node_root,
 125         &ssam_node_tmp_pprof,
 126         NULL,
 127 };
 128
 129 /* Devices for Surface Book 3. */
 130 static const struct software_node *ssam_node_group_sb3[] = {
 131         &ssam_node_root,
 132         &ssam_node_hub_base,
 133         &ssam_node_bat_ac,
 134         &ssam_node_bat_main,
 135         &ssam_node_bat_sb3base,
 136         &ssam_node_tmp_pprof,
 137         &ssam_node_bas_dtx,
 138         &ssam_node_hid_base_keyboard,
 139         &ssam_node_hid_base_touchpad,
 140         &ssam_node_hid_base_iid5,
 141         &ssam_node_hid_base_iid6,
 142         NULL,
 143 };
 144
 145 /* Devices for Surface Laptop 1. */
 146 static const struct software_node *ssam_node_group_sl1[] = {
 147         &ssam_node_root,
 148         &ssam_node_tmp_pprof,
 149         NULL,
 150 };
 151
 152 /* Devices for Surface Laptop 2. */
 153 static const struct software_node *ssam_node_group_sl2[] = {
 154         &ssam_node_root,
 155         &ssam_node_tmp_pprof,
 156         NULL,
 157 };
 158
 159 /* Devices for Surface Laptop 3. */
 160 static const struct software_node *ssam_node_group_sl3[] = {
 161         &ssam_node_root,
 162         &ssam_node_bat_ac,
 163         &ssam_node_bat_main,
 164         &ssam_node_tmp_pprof,
 165         &ssam_node_hid_main_keyboard,
 166         &ssam_node_hid_main_touchpad,
 167         &ssam_node_hid_main_iid5,
 168         NULL,
 169 };
 170
 171 /* Devices for Surface Laptop Go. */
 172 static const struct software_node *ssam_node_group_slg1[] = {
 173         &ssam_node_root,
 174         &ssam_node_bat_ac,
 175         &ssam_node_bat_main,
 176         &ssam_node_tmp_pprof,
 177         NULL,
 178 };
 179
 180 /* Devices for Surface Pro 5. */
 181 static const struct software_node *ssam_node_group_sp5[] = {
 182         &ssam_node_root,
 183         &ssam_node_tmp_pprof,
 184         NULL,
 185 };
 186
 187 /* Devices for Surface Pro 6. */
 188 static const struct software_node *ssam_node_group_sp6[] = {
 189         &ssam_node_root,
 190         &ssam_node_tmp_pprof,
 191         NULL,
 192 };
 193
 194 /* Devices for Surface Pro 7. */
 195 static const struct software_node *ssam_node_group_sp7[] = {
 196         &ssam_node_root,
 197         &ssam_node_bat_ac,
 198         &ssam_node_bat_main,
 199         &ssam_node_tmp_pprof,
 200         NULL,
 201 };
 202
 203
 204 /* -- Device registry helper functions. ------------------------------------- */
 205
 206 static int ssam_uid_from_string(const char *str, struct ssam_device_uid *uid)
 207 {
 208         u8 d, tc, tid, iid, fn;
 209         int n;
 210
 211         n = sscanf(str, "ssam:%hhx:%hhx:%hhx:%hhx:%hhx", &d, &tc, &tid, &iid, &fn);
 212         if (n != 5)
 213                 return -EINVAL;
 214
 215         uid->domain = d;
 216         uid->category = tc;
 217         uid->target = tid;
 218         uid->instance = iid;
 219         uid->function = fn;
 220
 221         return 0;
 222 }
 223
 224 static int ssam_hub_remove_devices_fn(struct device *dev, void *data)
 225 {
 226         if (!is_ssam_device(dev))
 227                 return 0;
 228
 229         ssam_device_remove(to_ssam_device(dev));
 230         return 0;
 231 }
 232
 233 static void ssam_hub_remove_devices(struct device *parent)
 234 {
 235         device_for_each_child_reverse(parent, NULL, ssam_hub_remove_devices_fn);
 236 }
 237
 238 static int ssam_hub_add_device(struct device *parent, struct ssam_controller *ctrl,
 239                                struct fwnode_handle *node)
 240 {
 241         struct ssam_device_uid uid;
 242         struct ssam_device *sdev;
 243         int status;
 244
 245         status = ssam_uid_from_string(fwnode_get_name(node), &uid);
 246         if (status)
 247                 return status;
 248
 249         sdev = ssam_device_alloc(ctrl, uid);
 250         if (!sdev)
 251                 return -ENOMEM;
 252
 253         sdev->dev.parent = parent;
 254         sdev->dev.fwnode = node;
 255
 256         status = ssam_device_add(sdev);
 257         if (status)
 258                 ssam_device_put(sdev);
 259
 260         return status;
 261 }
 262
 263 static int ssam_hub_add_devices(struct device *parent, struct ssam_controller *ctrl,
 264                                 struct fwnode_handle *node)
 265 {
 266         struct fwnode_handle *child;
 267         int status;
 268
 269         fwnode_for_each_child_node(node, child) {
 270                 /*
 271                  * Try to add the device specified in the firmware node. If
 272                  * this fails with -EINVAL, the node does not specify any SSAM
 273                  * device, so ignore it and continue with the next one.
 274                  */
 275
 276                 status = ssam_hub_add_device(parent, ctrl, child);
 277                 if (status && status != -EINVAL)
 278                         goto err;
 279         }
 280
 281         return 0;
 282 err:
 283         ssam_hub_remove_devices(parent);
 284         return status;
 285 }
 286
 287
 288 /* -- SSAM base-hub driver. ------------------------------------------------- */
 289
 290 enum ssam_base_hub_state {
 291         SSAM_BASE_HUB_UNINITIALIZED,
 292         SSAM_BASE_HUB_CONNECTED,
 293         SSAM_BASE_HUB_DISCONNECTED,
 294 };
 295
 296 struct ssam_base_hub {
 297         struct ssam_device *sdev;
 298
 299         struct mutex lock;  /* Guards state update checks and transitions. */
 300         enum ssam_base_hub_state state;
 301
 302         struct ssam_event_notifier notif;
 303 };
 304
 305 SSAM_DEFINE_SYNC_REQUEST_R(ssam_bas_query_opmode, u8, {
 306         .target_category = SSAM_SSH_TC_BAS,
 307         .target_id       = 0x01,
 308         .command_id      = 0x0d,
 309         .instance_id     = 0x00,
 310 });
 311
 312 #define SSAM_BAS_OPMODE_TABLET          0x00
 313 #define SSAM_EVENT_BAS_CID_CONNECTION   0x0c
 314
 315 static int ssam_base_hub_query_state(struct ssam_base_hub *hub, enum ssam_base_hub_state *state)
 316 {
 317         u8 opmode;
 318         int status;
 319
 320         status = ssam_retry(ssam_bas_query_opmode, hub->sdev->ctrl, &opmode);
 321         if (status < 0) {
 322                 dev_err(&hub->sdev->dev, "failed to query base state: %d\n", status);
 323                 return status;
 324         }
 325
 326         if (opmode != SSAM_BAS_OPMODE_TABLET)
 327                 *state = SSAM_BASE_HUB_CONNECTED;
 328         else
 329                 *state = SSAM_BASE_HUB_DISCONNECTED;
 330
 331         return 0;
 332 }
 333
 334 static ssize_t ssam_base_hub_state_show(struct device *dev, struct device_attribute *attr,
 335                                         char *buf)
 336 {
 337         struct ssam_base_hub *hub = dev_get_drvdata(dev);
 338         bool connected;
 339
 340         mutex_lock(&hub->lock);
 341         connected = hub->state == SSAM_BASE_HUB_CONNECTED;
 342         mutex_unlock(&hub->lock);
 343
 344         return sysfs_emit(buf, "%d\n", connected);
 345 }
 346
 347 static struct device_attribute ssam_base_hub_attr_state =
 348         __ATTR(state, 0444, ssam_base_hub_state_show, NULL);
 349
 350 static struct attribute *ssam_base_hub_attrs[] = {
 351         &ssam_base_hub_attr_state.attr,
 352         NULL,
 353 };
 354
 355 const struct attribute_group ssam_base_hub_group = {
 356         .attrs = ssam_base_hub_attrs,
 357 };
 358
 359 static int __ssam_base_hub_update(struct ssam_base_hub *hub, enum ssam_base_hub_state new)
 360 {
 361         struct fwnode_handle *node = dev_fwnode(&hub->sdev->dev);
 362         int status = 0;
 363
 364         lockdep_assert_held(&hub->lock);
 365
 366         if (hub->state == new)
 367                 return 0;
 368         hub->state = new;
 369
 370         if (hub->state == SSAM_BASE_HUB_CONNECTED)
 371                 status = ssam_hub_add_devices(&hub->sdev->dev, hub->sdev->ctrl, node);
 372         else
 373                 ssam_hub_remove_devices(&hub->sdev->dev);
 374
 375         if (status)
 376                 dev_err(&hub->sdev->dev, "failed to update base-hub devices: %d\n", status);
 377
 378         return status;
 379 }
 380
 381 static int ssam_base_hub_update(struct ssam_base_hub *hub)
 382 {
 383         enum ssam_base_hub_state state;
 384         int status;
 385
 386         mutex_lock(&hub->lock);
 387
 388         status = ssam_base_hub_query_state(hub, &state);
 389         if (!status)
 390                 status = __ssam_base_hub_update(hub, state);
 391
 392         mutex_unlock(&hub->lock);
 393         return status;
 394 }
 395
 396 static u32 ssam_base_hub_notif(struct ssam_event_notifier *nf, const struct ssam_event *event)
 397 {
 398         struct ssam_base_hub *hub;
 399         struct ssam_device *sdev;
 400         enum ssam_base_hub_state new;
 401
 402         hub = container_of(nf, struct ssam_base_hub, notif);
 403         sdev = hub->sdev;
 404
 405         if (event->command_id != SSAM_EVENT_BAS_CID_CONNECTION)
 406                 return 0;
 407
 408         if (event->length < 1) {
 409                 dev_err(&sdev->dev, "unexpected payload size: %u\n",
 410                         event->length);
 411                 return 0;
 412         }
 413
 414         if (event->data[0])
 415                 new = SSAM_BASE_HUB_CONNECTED;
 416         else
 417                 new = SSAM_BASE_HUB_DISCONNECTED;
 418
 419         mutex_lock(&hub->lock);
 420         __ssam_base_hub_update(hub, new);
 421         mutex_unlock(&hub->lock);
 422
 423         /*
 424          * Do not return SSAM_NOTIF_HANDLED: The event should be picked up and
 425          * consumed by the detachment system driver. We're just a (more or less)
 426          * silent observer.
 427          */
 428         return 0;
 429 }
 430
 431 static int __maybe_unused ssam_base_hub_resume(struct device *dev)
 432 {
 433         return ssam_base_hub_update(dev_get_drvdata(dev));
 434 }
 435 static SIMPLE_DEV_PM_OPS(ssam_base_hub_pm_ops, NULL, ssam_base_hub_resume);
 436
 437 static int ssam_base_hub_probe(struct ssam_device *sdev)
 438 {
 439         struct ssam_base_hub *hub;
 440         int status;
 441
 442         hub = devm_kzalloc(&sdev->dev, sizeof(*hub), GFP_KERNEL);
 443         if (!hub)
 444                 return -ENOMEM;
 445
 446         mutex_init(&hub->lock);
 447
 448         hub->sdev = sdev;
 449         hub->state = SSAM_BASE_HUB_UNINITIALIZED;
 450
 451         hub->notif.base.priority = INT_MAX;  /* This notifier should run first. */
 452         hub->notif.base.fn = ssam_base_hub_notif;
 453         hub->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
 454         hub->notif.event.id.target_category = SSAM_SSH_TC_BAS,
 455         hub->notif.event.id.instance = 0,
 456         hub->notif.event.mask = SSAM_EVENT_MASK_NONE;
 457         hub->notif.event.flags = SSAM_EVENT_SEQUENCED;
 458
 459         ssam_device_set_drvdata(sdev, hub);
 460
 461         status = ssam_notifier_register(sdev->ctrl, &hub->notif);
 462         if (status)
 463                 goto err_register;
 464
 465         status = ssam_base_hub_update(hub);
 466         if (status)
 467                 goto err_update;
 468
 469         status = sysfs_create_group(&sdev->dev.kobj, &ssam_base_hub_group);
 470         if (status)
 471                 goto err_update;
 472
 473         return 0;
 474
 475 err_update:
 476         ssam_notifier_unregister(sdev->ctrl, &hub->notif);
 477         ssam_hub_remove_devices(&sdev->dev);
 478 err_register:
 479         mutex_destroy(&hub->lock);
 480         return status;
 481 }
 482
 483 static void ssam_base_hub_remove(struct ssam_device *sdev)
 484 {
 485         struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev);
 486
 487         sysfs_remove_group(&sdev->dev.kobj, &ssam_base_hub_group);
 488
 489         ssam_notifier_unregister(sdev->ctrl, &hub->notif);
 490         ssam_hub_remove_devices(&sdev->dev);
 491
 492         mutex_destroy(&hub->lock);
 493 }
 494
 495 static const struct ssam_device_id ssam_base_hub_match[] = {
 496         { SSAM_VDEV(HUB, 0x02, SSAM_ANY_IID, 0x00) },
 497         { },
 498 };
 499
 500 static struct ssam_device_driver ssam_base_hub_driver = {
 501         .probe = ssam_base_hub_probe,
 502         .remove = ssam_base_hub_remove,
 503         .match_table = ssam_base_hub_match,
 504         .driver = {
 505                 .name = "surface_aggregator_base_hub",
 506                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 507                 .pm = &ssam_base_hub_pm_ops,
 508         },
 509 };
 510
 511
 512 /* -- SSAM platform/meta-hub driver. ---------------------------------------- */
 513
 514 static const struct acpi_device_id ssam_platform_hub_match[] = {
 515         /* Surface Pro 4, 5, and 6 (OMBR < 0x10) */
 516         { "MSHW0081", (unsigned long)ssam_node_group_sp5 },
 517
 518         /* Surface Pro 6 (OMBR >= 0x10) */
 519         { "MSHW0111", (unsigned long)ssam_node_group_sp6 },
 520
 521         /* Surface Pro 7 */
 522         { "MSHW0116", (unsigned long)ssam_node_group_sp7 },
 523
 524         /* Surface Book 2 */
 525         { "MSHW0107", (unsigned long)ssam_node_group_sb2 },
 526
 527         /* Surface Book 3 */
 528         { "MSHW0117", (unsigned long)ssam_node_group_sb3 },
 529
 530         /* Surface Laptop 1 */
 531         { "MSHW0086", (unsigned long)ssam_node_group_sl1 },
 532
 533         /* Surface Laptop 2 */
 534         { "MSHW0112", (unsigned long)ssam_node_group_sl2 },
 535
 536         /* Surface Laptop 3 (13", Intel) */
 537         { "MSHW0114", (unsigned long)ssam_node_group_sl3 },
 538
 539         /* Surface Laptop 3 (15", AMD) */
 540         { "MSHW0110", (unsigned long)ssam_node_group_sl3 },
 541
 542         /* Surface Laptop Go 1 */
 543         { "MSHW0118", (unsigned long)ssam_node_group_slg1 },
 544
 545         { },
 546 };
 547 MODULE_DEVICE_TABLE(acpi, ssam_platform_hub_match);
 548
 549 static int ssam_platform_hub_probe(struct platform_device *pdev)
 550 {
 551         const struct software_node **nodes;
 552         struct ssam_controller *ctrl;
 553         struct fwnode_handle *root;
 554         int status;
 555
 556         nodes = (const struct software_node **)acpi_device_get_match_data(&pdev->dev);
 557         if (!nodes)
 558                 return -ENODEV;
 559
 560         /*
 561          * As we're adding the SSAM client devices as children under this device
 562          * and not the SSAM controller, we need to add a device link to the
 563          * controller to ensure that we remove all of our devices before the
 564          * controller is removed. This also guarantees proper ordering for
 565          * suspend/resume of the devices on this hub.
 566          */
 567         ctrl = ssam_client_bind(&pdev->dev);
 568         if (IS_ERR(ctrl))
 569                 return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
 570
 571         status = software_node_register_node_group(nodes);
 572         if (status)
 573                 return status;
 574
 575         root = software_node_fwnode(&ssam_node_root);
 576         if (!root) {
 577                 software_node_unregister_node_group(nodes);
 578                 return -ENOENT;
 579         }
 580
 581         set_secondary_fwnode(&pdev->dev, root);
 582
 583         status = ssam_hub_add_devices(&pdev->dev, ctrl, root);
 584         if (status) {
 585                 set_secondary_fwnode(&pdev->dev, NULL);
 586                 software_node_unregister_node_group(nodes);
 587         }
 588
 589         platform_set_drvdata(pdev, nodes);
 590         return status;
 591 }
 592
 593 static int ssam_platform_hub_remove(struct platform_device *pdev)
 594 {
 595         const struct software_node **nodes = platform_get_drvdata(pdev);
 596
 597         ssam_hub_remove_devices(&pdev->dev);
 598         set_secondary_fwnode(&pdev->dev, NULL);
 599         software_node_unregister_node_group(nodes);
 600         return 0;
 601 }
 602
 603 static struct platform_driver ssam_platform_hub_driver = {
 604         .probe = ssam_platform_hub_probe,
 605         .remove = ssam_platform_hub_remove,
 606         .driver = {
 607                 .name = "surface_aggregator_platform_hub",
 608                 .acpi_match_table = ssam_platform_hub_match,
 609                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 610         },
 611 };
 612
 613
 614 /* -- Module initialization. ------------------------------------------------ */
 615
 616 static int __init ssam_device_hub_init(void)
 617 {
 618         int status;
 619
 620         status = platform_driver_register(&ssam_platform_hub_driver);
 621         if (status)
 622                 return status;
 623
 624         status = ssam_device_driver_register(&ssam_base_hub_driver);
 625         if (status)
 626                 platform_driver_unregister(&ssam_platform_hub_driver);
 627
 628         return status;
 629 }
 630 module_init(ssam_device_hub_init);
 631
 632 static void __exit ssam_device_hub_exit(void)
 633 {
 634         ssam_device_driver_unregister(&ssam_base_hub_driver);
 635         platform_driver_unregister(&ssam_platform_hub_driver);
 636 }
 637 module_exit(ssam_device_hub_exit);
 638
 639 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
 640 MODULE_DESCRIPTION("Device-registry for Surface System Aggregator Module");
 641 MODULE_LICENSE("GPL");