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/platform_device.h>
  17 #include <linux/property.h>
  18 #include <linux/types.h>
  19 #include <linux/workqueue.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 (TID1). */
  81 static const struct software_node ssam_node_hid_tid1_keyboard = {
  82         .name = "ssam:01:15:01:01:00",
  83         .parent = &ssam_node_root,
  84 };
  85
  86 /* HID pen stash (TID1; pen taken / stashed away evens). */
  87 static const struct software_node ssam_node_hid_tid1_penstash = {
  88         .name = "ssam:01:15:01:02:00",
  89         .parent = &ssam_node_root,
  90 };
  91
  92 /* HID touchpad (TID1). */
  93 static const struct software_node ssam_node_hid_tid1_touchpad = {
  94         .name = "ssam:01:15:01:03:00",
  95         .parent = &ssam_node_root,
  96 };
  97
  98 /* HID device instance 6 (TID1, unknown HID device). */
  99 static const struct software_node ssam_node_hid_tid1_iid6 = {
 100         .name = "ssam:01:15:01:06:00",
 101         .parent = &ssam_node_root,
 102 };
 103
 104 /* HID device instance 7 (TID1, unknown HID device). */
 105 static const struct software_node ssam_node_hid_tid1_iid7 = {
 106         .name = "ssam:01:15:01:07:00",
 107         .parent = &ssam_node_root,
 108 };
 109
 110 /* HID system controls (TID1). */
 111 static const struct software_node ssam_node_hid_tid1_sysctrl = {
 112         .name = "ssam:01:15:01:08:00",
 113         .parent = &ssam_node_root,
 114 };
 115
 116 /* HID keyboard. */
 117 static const struct software_node ssam_node_hid_main_keyboard = {
 118         .name = "ssam:01:15:02:01:00",
 119         .parent = &ssam_node_root,
 120 };
 121
 122 /* HID touchpad. */
 123 static const struct software_node ssam_node_hid_main_touchpad = {
 124         .name = "ssam:01:15:02:03:00",
 125         .parent = &ssam_node_root,
 126 };
 127
 128 /* HID device instance 5 (unknown HID device). */
 129 static const struct software_node ssam_node_hid_main_iid5 = {
 130         .name = "ssam:01:15:02:05:00",
 131         .parent = &ssam_node_root,
 132 };
 133
 134 /* HID keyboard (base hub). */
 135 static const struct software_node ssam_node_hid_base_keyboard = {
 136         .name = "ssam:01:15:02:01:00",
 137         .parent = &ssam_node_hub_base,
 138 };
 139
 140 /* HID touchpad (base hub). */
 141 static const struct software_node ssam_node_hid_base_touchpad = {
 142         .name = "ssam:01:15:02:03:00",
 143         .parent = &ssam_node_hub_base,
 144 };
 145
 146 /* HID device instance 5 (unknown HID device, base hub). */
 147 static const struct software_node ssam_node_hid_base_iid5 = {
 148         .name = "ssam:01:15:02:05:00",
 149         .parent = &ssam_node_hub_base,
 150 };
 151
 152 /* HID device instance 6 (unknown HID device, base hub). */
 153 static const struct software_node ssam_node_hid_base_iid6 = {
 154         .name = "ssam:01:15:02:06:00",
 155         .parent = &ssam_node_hub_base,
 156 };
 157
 158 /*
 159  * Devices for 5th- and 6th-generations models:
 160  * - Surface Book 2,
 161  * - Surface Laptop 1 and 2,
 162  * - Surface Pro 5 and 6.
 163  */
 164 static const struct software_node *ssam_node_group_gen5[] = {
 165         &ssam_node_root,
 166         &ssam_node_tmp_pprof,
 167         NULL,
 168 };
 169
 170 /* Devices for Surface Book 3. */
 171 static const struct software_node *ssam_node_group_sb3[] = {
 172         &ssam_node_root,
 173         &ssam_node_hub_base,
 174         &ssam_node_bat_ac,
 175         &ssam_node_bat_main,
 176         &ssam_node_bat_sb3base,
 177         &ssam_node_tmp_pprof,
 178         &ssam_node_bas_dtx,
 179         &ssam_node_hid_base_keyboard,
 180         &ssam_node_hid_base_touchpad,
 181         &ssam_node_hid_base_iid5,
 182         &ssam_node_hid_base_iid6,
 183         NULL,
 184 };
 185
 186 /* Devices for Surface Laptop 3 and 4. */
 187 static const struct software_node *ssam_node_group_sl3[] = {
 188         &ssam_node_root,
 189         &ssam_node_bat_ac,
 190         &ssam_node_bat_main,
 191         &ssam_node_tmp_pprof,
 192         &ssam_node_hid_main_keyboard,
 193         &ssam_node_hid_main_touchpad,
 194         &ssam_node_hid_main_iid5,
 195         NULL,
 196 };
 197
 198 /* Devices for Surface Laptop Studio. */
 199 static const struct software_node *ssam_node_group_sls[] = {
 200         &ssam_node_root,
 201         &ssam_node_bat_ac,
 202         &ssam_node_bat_main,
 203         &ssam_node_tmp_pprof,
 204         &ssam_node_hid_tid1_keyboard,
 205         &ssam_node_hid_tid1_penstash,
 206         &ssam_node_hid_tid1_touchpad,
 207         &ssam_node_hid_tid1_iid6,
 208         &ssam_node_hid_tid1_iid7,
 209         &ssam_node_hid_tid1_sysctrl,
 210         NULL,
 211 };
 212
 213 /* Devices for Surface Laptop Go. */
 214 static const struct software_node *ssam_node_group_slg1[] = {
 215         &ssam_node_root,
 216         &ssam_node_bat_ac,
 217         &ssam_node_bat_main,
 218         &ssam_node_tmp_pprof,
 219         NULL,
 220 };
 221
 222 /* Devices for Surface Pro 7 and Surface Pro 7+. */
 223 static const struct software_node *ssam_node_group_sp7[] = {
 224         &ssam_node_root,
 225         &ssam_node_bat_ac,
 226         &ssam_node_bat_main,
 227         &ssam_node_tmp_pprof,
 228         NULL,
 229 };
 230
 231 static const struct software_node *ssam_node_group_sp8[] = {
 232         &ssam_node_root,
 233         &ssam_node_bat_ac,
 234         &ssam_node_bat_main,
 235         &ssam_node_tmp_pprof,
 236         /* TODO: Add support for keyboard cover. */
 237         NULL,
 238 };
 239
 240
 241 /* -- Device registry helper functions. ------------------------------------- */
 242
 243 static int ssam_uid_from_string(const char *str, struct ssam_device_uid *uid)
 244 {
 245         u8 d, tc, tid, iid, fn;
 246         int n;
 247
 248         n = sscanf(str, "ssam:%hhx:%hhx:%hhx:%hhx:%hhx", &d, &tc, &tid, &iid, &fn);
 249         if (n != 5)
 250                 return -EINVAL;
 251
 252         uid->domain = d;
 253         uid->category = tc;
 254         uid->target = tid;
 255         uid->instance = iid;
 256         uid->function = fn;
 257
 258         return 0;
 259 }
 260
 261 static int ssam_hub_add_device(struct device *parent, struct ssam_controller *ctrl,
 262                                struct fwnode_handle *node)
 263 {
 264         struct ssam_device_uid uid;
 265         struct ssam_device *sdev;
 266         int status;
 267
 268         status = ssam_uid_from_string(fwnode_get_name(node), &uid);
 269         if (status)
 270                 return status;
 271
 272         sdev = ssam_device_alloc(ctrl, uid);
 273         if (!sdev)
 274                 return -ENOMEM;
 275
 276         sdev->dev.parent = parent;
 277         sdev->dev.fwnode = node;
 278
 279         status = ssam_device_add(sdev);
 280         if (status)
 281                 ssam_device_put(sdev);
 282
 283         return status;
 284 }
 285
 286 static int ssam_hub_register_clients(struct device *parent, struct ssam_controller *ctrl,
 287                                      struct fwnode_handle *node)
 288 {
 289         struct fwnode_handle *child;
 290         int status;
 291
 292         fwnode_for_each_child_node(node, child) {
 293                 /*
 294                  * Try to add the device specified in the firmware node. If
 295                  * this fails with -EINVAL, the node does not specify any SSAM
 296                  * device, so ignore it and continue with the next one.
 297                  */
 298
 299                 status = ssam_hub_add_device(parent, ctrl, child);
 300                 if (status && status != -EINVAL)
 301                         goto err;
 302         }
 303
 304         return 0;
 305 err:
 306         ssam_remove_clients(parent);
 307         return status;
 308 }
 309
 310
 311 /* -- SSAM base-hub driver. ------------------------------------------------- */
 312
 313 /*
 314  * Some devices (especially battery) may need a bit of time to be fully usable
 315  * after being (re-)connected. This delay has been determined via
 316  * experimentation.
 317  */
 318 #define SSAM_BASE_UPDATE_CONNECT_DELAY          msecs_to_jiffies(2500)
 319
 320 enum ssam_base_hub_state {
 321         SSAM_BASE_HUB_UNINITIALIZED,
 322         SSAM_BASE_HUB_CONNECTED,
 323         SSAM_BASE_HUB_DISCONNECTED,
 324 };
 325
 326 struct ssam_base_hub {
 327         struct ssam_device *sdev;
 328
 329         enum ssam_base_hub_state state;
 330         struct delayed_work update_work;
 331
 332         struct ssam_event_notifier notif;
 333 };
 334
 335 SSAM_DEFINE_SYNC_REQUEST_R(ssam_bas_query_opmode, u8, {
 336         .target_category = SSAM_SSH_TC_BAS,
 337         .target_id       = 0x01,
 338         .command_id      = 0x0d,
 339         .instance_id     = 0x00,
 340 });
 341
 342 #define SSAM_BAS_OPMODE_TABLET          0x00
 343 #define SSAM_EVENT_BAS_CID_CONNECTION   0x0c
 344
 345 static int ssam_base_hub_query_state(struct ssam_base_hub *hub, enum ssam_base_hub_state *state)
 346 {
 347         u8 opmode;
 348         int status;
 349
 350         status = ssam_retry(ssam_bas_query_opmode, hub->sdev->ctrl, &opmode);
 351         if (status < 0) {
 352                 dev_err(&hub->sdev->dev, "failed to query base state: %d\n", status);
 353                 return status;
 354         }
 355
 356         if (opmode != SSAM_BAS_OPMODE_TABLET)
 357                 *state = SSAM_BASE_HUB_CONNECTED;
 358         else
 359                 *state = SSAM_BASE_HUB_DISCONNECTED;
 360
 361         return 0;
 362 }
 363
 364 static ssize_t ssam_base_hub_state_show(struct device *dev, struct device_attribute *attr,
 365                                         char *buf)
 366 {
 367         struct ssam_base_hub *hub = dev_get_drvdata(dev);
 368         bool connected = hub->state == SSAM_BASE_HUB_CONNECTED;
 369
 370         return sysfs_emit(buf, "%d\n", connected);
 371 }
 372
 373 static struct device_attribute ssam_base_hub_attr_state =
 374         __ATTR(state, 0444, ssam_base_hub_state_show, NULL);
 375
 376 static struct attribute *ssam_base_hub_attrs[] = {
 377         &ssam_base_hub_attr_state.attr,
 378         NULL,
 379 };
 380
 381 static const struct attribute_group ssam_base_hub_group = {
 382         .attrs = ssam_base_hub_attrs,
 383 };
 384
 385 static void ssam_base_hub_update_workfn(struct work_struct *work)
 386 {
 387         struct ssam_base_hub *hub = container_of(work, struct ssam_base_hub, update_work.work);
 388         struct fwnode_handle *node = dev_fwnode(&hub->sdev->dev);
 389         enum ssam_base_hub_state state;
 390         int status = 0;
 391
 392         status = ssam_base_hub_query_state(hub, &state);
 393         if (status)
 394                 return;
 395
 396         if (hub->state == state)
 397                 return;
 398         hub->state = state;
 399
 400         if (hub->state == SSAM_BASE_HUB_CONNECTED)
 401                 status = ssam_hub_register_clients(&hub->sdev->dev, hub->sdev->ctrl, node);
 402         else
 403                 ssam_remove_clients(&hub->sdev->dev);
 404
 405         if (status)
 406                 dev_err(&hub->sdev->dev, "failed to update base-hub devices: %d\n", status);
 407 }
 408
 409 static u32 ssam_base_hub_notif(struct ssam_event_notifier *nf, const struct ssam_event *event)
 410 {
 411         struct ssam_base_hub *hub = container_of(nf, struct ssam_base_hub, notif);
 412         unsigned long delay;
 413
 414         if (event->command_id != SSAM_EVENT_BAS_CID_CONNECTION)
 415                 return 0;
 416
 417         if (event->length < 1) {
 418                 dev_err(&hub->sdev->dev, "unexpected payload size: %u\n", event->length);
 419                 return 0;
 420         }
 421
 422         /*
 423          * Delay update when the base is being connected to give devices/EC
 424          * some time to set up.
 425          */
 426         delay = event->data[0] ? SSAM_BASE_UPDATE_CONNECT_DELAY : 0;
 427
 428         schedule_delayed_work(&hub->update_work, delay);
 429
 430         /*
 431          * Do not return SSAM_NOTIF_HANDLED: The event should be picked up and
 432          * consumed by the detachment system driver. We're just a (more or less)
 433          * silent observer.
 434          */
 435         return 0;
 436 }
 437
 438 static int __maybe_unused ssam_base_hub_resume(struct device *dev)
 439 {
 440         struct ssam_base_hub *hub = dev_get_drvdata(dev);
 441
 442         schedule_delayed_work(&hub->update_work, 0);
 443         return 0;
 444 }
 445 static SIMPLE_DEV_PM_OPS(ssam_base_hub_pm_ops, NULL, ssam_base_hub_resume);
 446
 447 static int ssam_base_hub_probe(struct ssam_device *sdev)
 448 {
 449         struct ssam_base_hub *hub;
 450         int status;
 451
 452         hub = devm_kzalloc(&sdev->dev, sizeof(*hub), GFP_KERNEL);
 453         if (!hub)
 454                 return -ENOMEM;
 455
 456         hub->sdev = sdev;
 457         hub->state = SSAM_BASE_HUB_UNINITIALIZED;
 458
 459         hub->notif.base.priority = INT_MAX;  /* This notifier should run first. */
 460         hub->notif.base.fn = ssam_base_hub_notif;
 461         hub->notif.event.reg = SSAM_EVENT_REGISTRY_SAM;
 462         hub->notif.event.id.target_category = SSAM_SSH_TC_BAS,
 463         hub->notif.event.id.instance = 0,
 464         hub->notif.event.mask = SSAM_EVENT_MASK_NONE;
 465         hub->notif.event.flags = SSAM_EVENT_SEQUENCED;
 466
 467         INIT_DELAYED_WORK(&hub->update_work, ssam_base_hub_update_workfn);
 468
 469         ssam_device_set_drvdata(sdev, hub);
 470
 471         status = ssam_notifier_register(sdev->ctrl, &hub->notif);
 472         if (status)
 473                 return status;
 474
 475         status = sysfs_create_group(&sdev->dev.kobj, &ssam_base_hub_group);
 476         if (status)
 477                 goto err;
 478
 479         schedule_delayed_work(&hub->update_work, 0);
 480         return 0;
 481
 482 err:
 483         ssam_notifier_unregister(sdev->ctrl, &hub->notif);
 484         cancel_delayed_work_sync(&hub->update_work);
 485         ssam_remove_clients(&sdev->dev);
 486         return status;
 487 }
 488
 489 static void ssam_base_hub_remove(struct ssam_device *sdev)
 490 {
 491         struct ssam_base_hub *hub = ssam_device_get_drvdata(sdev);
 492
 493         sysfs_remove_group(&sdev->dev.kobj, &ssam_base_hub_group);
 494
 495         ssam_notifier_unregister(sdev->ctrl, &hub->notif);
 496         cancel_delayed_work_sync(&hub->update_work);
 497         ssam_remove_clients(&sdev->dev);
 498 }
 499
 500 static const struct ssam_device_id ssam_base_hub_match[] = {
 501         { SSAM_VDEV(HUB, 0x02, SSAM_ANY_IID, 0x00) },
 502         { },
 503 };
 504
 505 static struct ssam_device_driver ssam_base_hub_driver = {
 506         .probe = ssam_base_hub_probe,
 507         .remove = ssam_base_hub_remove,
 508         .match_table = ssam_base_hub_match,
 509         .driver = {
 510                 .name = "surface_aggregator_base_hub",
 511                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 512                 .pm = &ssam_base_hub_pm_ops,
 513         },
 514 };
 515
 516
 517 /* -- SSAM platform/meta-hub driver. ---------------------------------------- */
 518
 519 static const struct acpi_device_id ssam_platform_hub_match[] = {
 520         /* Surface Pro 4, 5, and 6 (OMBR < 0x10) */
 521         { "MSHW0081", (unsigned long)ssam_node_group_gen5 },
 522
 523         /* Surface Pro 6 (OMBR >= 0x10) */
 524         { "MSHW0111", (unsigned long)ssam_node_group_gen5 },
 525
 526         /* Surface Pro 7 */
 527         { "MSHW0116", (unsigned long)ssam_node_group_sp7 },
 528
 529         /* Surface Pro 7+ */
 530         { "MSHW0119", (unsigned long)ssam_node_group_sp7 },
 531
 532         /* Surface Pro 8 */
 533         { "MSHW0263", (unsigned long)ssam_node_group_sp8 },
 534
 535         /* Surface Book 2 */
 536         { "MSHW0107", (unsigned long)ssam_node_group_gen5 },
 537
 538         /* Surface Book 3 */
 539         { "MSHW0117", (unsigned long)ssam_node_group_sb3 },
 540
 541         /* Surface Laptop 1 */
 542         { "MSHW0086", (unsigned long)ssam_node_group_gen5 },
 543
 544         /* Surface Laptop 2 */
 545         { "MSHW0112", (unsigned long)ssam_node_group_gen5 },
 546
 547         /* Surface Laptop 3 (13", Intel) */
 548         { "MSHW0114", (unsigned long)ssam_node_group_sl3 },
 549
 550         /* Surface Laptop 3 (15", AMD) and 4 (15", AMD) */
 551         { "MSHW0110", (unsigned long)ssam_node_group_sl3 },
 552
 553         /* Surface Laptop 4 (13", Intel) */
 554         { "MSHW0250", (unsigned long)ssam_node_group_sl3 },
 555
 556         /* Surface Laptop Go 1 */
 557         { "MSHW0118", (unsigned long)ssam_node_group_slg1 },
 558
 559         /* Surface Laptop Studio */
 560         { "MSHW0123", (unsigned long)ssam_node_group_sls },
 561
 562         { },
 563 };
 564 MODULE_DEVICE_TABLE(acpi, ssam_platform_hub_match);
 565
 566 static int ssam_platform_hub_probe(struct platform_device *pdev)
 567 {
 568         const struct software_node **nodes;
 569         struct ssam_controller *ctrl;
 570         struct fwnode_handle *root;
 571         int status;
 572
 573         nodes = (const struct software_node **)acpi_device_get_match_data(&pdev->dev);
 574         if (!nodes)
 575                 return -ENODEV;
 576
 577         /*
 578          * As we're adding the SSAM client devices as children under this device
 579          * and not the SSAM controller, we need to add a device link to the
 580          * controller to ensure that we remove all of our devices before the
 581          * controller is removed. This also guarantees proper ordering for
 582          * suspend/resume of the devices on this hub.
 583          */
 584         ctrl = ssam_client_bind(&pdev->dev);
 585         if (IS_ERR(ctrl))
 586                 return PTR_ERR(ctrl) == -ENODEV ? -EPROBE_DEFER : PTR_ERR(ctrl);
 587
 588         status = software_node_register_node_group(nodes);
 589         if (status)
 590                 return status;
 591
 592         root = software_node_fwnode(&ssam_node_root);
 593         if (!root) {
 594                 software_node_unregister_node_group(nodes);
 595                 return -ENOENT;
 596         }
 597
 598         set_secondary_fwnode(&pdev->dev, root);
 599
 600         status = ssam_hub_register_clients(&pdev->dev, ctrl, root);
 601         if (status) {
 602                 set_secondary_fwnode(&pdev->dev, NULL);
 603                 software_node_unregister_node_group(nodes);
 604         }
 605
 606         platform_set_drvdata(pdev, nodes);
 607         return status;
 608 }
 609
 610 static int ssam_platform_hub_remove(struct platform_device *pdev)
 611 {
 612         const struct software_node **nodes = platform_get_drvdata(pdev);
 613
 614         ssam_remove_clients(&pdev->dev);
 615         set_secondary_fwnode(&pdev->dev, NULL);
 616         software_node_unregister_node_group(nodes);
 617         return 0;
 618 }
 619
 620 static struct platform_driver ssam_platform_hub_driver = {
 621         .probe = ssam_platform_hub_probe,
 622         .remove = ssam_platform_hub_remove,
 623         .driver = {
 624                 .name = "surface_aggregator_platform_hub",
 625                 .acpi_match_table = ssam_platform_hub_match,
 626                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 627         },
 628 };
 629
 630
 631 /* -- Module initialization. ------------------------------------------------ */
 632
 633 static int __init ssam_device_hub_init(void)
 634 {
 635         int status;
 636
 637         status = platform_driver_register(&ssam_platform_hub_driver);
 638         if (status)
 639                 return status;
 640
 641         status = ssam_device_driver_register(&ssam_base_hub_driver);
 642         if (status)
 643                 platform_driver_unregister(&ssam_platform_hub_driver);
 644
 645         return status;
 646 }
 647 module_init(ssam_device_hub_init);
 648
 649 static void __exit ssam_device_hub_exit(void)
 650 {
 651         ssam_device_driver_unregister(&ssam_base_hub_driver);
 652         platform_driver_unregister(&ssam_platform_hub_driver);
 653 }
 654 module_exit(ssam_device_hub_exit);
 655
 656 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
 657 MODULE_DESCRIPTION("Device-registry for Surface System Aggregator Module");
 658 MODULE_LICENSE("GPL");