drivers/platform/surface/surface_aggregator_tabletsw.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * Surface System Aggregator Module (SSAM) tablet mode switch driver.
   4  *
   5  * Copyright (C) 2022 Maximilian Luz <luzmaximilian@gmail.com>
   6  */
   7
   8 #include <linux/unaligned.h>
   9 #include <linux/input.h>
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/types.h>
  13 #include <linux/workqueue.h>
  14
  15 #include <linux/surface_aggregator/controller.h>
  16 #include <linux/surface_aggregator/device.h>
  17
  18
  19 /* -- SSAM generic tablet switch driver framework. -------------------------- */
  20
  21 struct ssam_tablet_sw;
  22
  23 struct ssam_tablet_sw_state {
  24         u32 source;
  25         u32 state;
  26 };
  27
  28 struct ssam_tablet_sw_ops {
  29         int (*get_state)(struct ssam_tablet_sw *sw, struct ssam_tablet_sw_state *state);
  30         const char *(*state_name)(struct ssam_tablet_sw *sw,
  31                                   const struct ssam_tablet_sw_state *state);
  32         bool (*state_is_tablet_mode)(struct ssam_tablet_sw *sw,
  33                                      const struct ssam_tablet_sw_state *state);
  34 };
  35
  36 struct ssam_tablet_sw {
  37         struct ssam_device *sdev;
  38
  39         struct ssam_tablet_sw_state state;
  40         struct work_struct update_work;
  41         struct input_dev *mode_switch;
  42
  43         struct ssam_tablet_sw_ops ops;
  44         struct ssam_event_notifier notif;
  45 };
  46
  47 struct ssam_tablet_sw_desc {
  48         struct {
  49                 const char *name;
  50                 const char *phys;
  51         } dev;
  52
  53         struct {
  54                 u32 (*notify)(struct ssam_event_notifier *nf, const struct ssam_event *event);
  55                 int (*get_state)(struct ssam_tablet_sw *sw, struct ssam_tablet_sw_state *state);
  56                 const char *(*state_name)(struct ssam_tablet_sw *sw,
  57                                           const struct ssam_tablet_sw_state *state);
  58                 bool (*state_is_tablet_mode)(struct ssam_tablet_sw *sw,
  59                                              const struct ssam_tablet_sw_state *state);
  60         } ops;
  61
  62         struct {
  63                 struct ssam_event_registry reg;
  64                 struct ssam_event_id id;
  65                 enum ssam_event_mask mask;
  66                 u8 flags;
  67         } event;
  68 };
  69
  70 static ssize_t state_show(struct device *dev, struct device_attribute *attr, char *buf)
  71 {
  72         struct ssam_tablet_sw *sw = dev_get_drvdata(dev);
  73         const char *state = sw->ops.state_name(sw, &sw->state);
  74
  75         return sysfs_emit(buf, "%s\n", state);
  76 }
  77 static DEVICE_ATTR_RO(state);
  78
  79 static struct attribute *ssam_tablet_sw_attrs[] = {
  80         &dev_attr_state.attr,
  81         NULL,
  82 };
  83
  84 static const struct attribute_group ssam_tablet_sw_group = {
  85         .attrs = ssam_tablet_sw_attrs,
  86 };
  87
  88 static void ssam_tablet_sw_update_workfn(struct work_struct *work)
  89 {
  90         struct ssam_tablet_sw *sw = container_of(work, struct ssam_tablet_sw, update_work);
  91         struct ssam_tablet_sw_state state;
  92         int tablet, status;
  93
  94         status = sw->ops.get_state(sw, &state);
  95         if (status)
  96                 return;
  97
  98         if (sw->state.source == state.source && sw->state.state == state.state)
  99                 return;
 100         sw->state = state;
 101
 102         /* Send SW_TABLET_MODE event. */
 103         tablet = sw->ops.state_is_tablet_mode(sw, &state);
 104         input_report_switch(sw->mode_switch, SW_TABLET_MODE, tablet);
 105         input_sync(sw->mode_switch);
 106 }
 107
 108 static int __maybe_unused ssam_tablet_sw_resume(struct device *dev)
 109 {
 110         struct ssam_tablet_sw *sw = dev_get_drvdata(dev);
 111
 112         schedule_work(&sw->update_work);
 113         return 0;
 114 }
 115 static SIMPLE_DEV_PM_OPS(ssam_tablet_sw_pm_ops, NULL, ssam_tablet_sw_resume);
 116
 117 static int ssam_tablet_sw_probe(struct ssam_device *sdev)
 118 {
 119         const struct ssam_tablet_sw_desc *desc;
 120         struct ssam_tablet_sw *sw;
 121         int tablet, status;
 122
 123         desc = ssam_device_get_match_data(sdev);
 124         if (!desc) {
 125                 WARN(1, "no driver match data specified");
 126                 return -EINVAL;
 127         }
 128
 129         sw = devm_kzalloc(&sdev->dev, sizeof(*sw), GFP_KERNEL);
 130         if (!sw)
 131                 return -ENOMEM;
 132
 133         sw->sdev = sdev;
 134
 135         sw->ops.get_state = desc->ops.get_state;
 136         sw->ops.state_name = desc->ops.state_name;
 137         sw->ops.state_is_tablet_mode = desc->ops.state_is_tablet_mode;
 138
 139         INIT_WORK(&sw->update_work, ssam_tablet_sw_update_workfn);
 140
 141         ssam_device_set_drvdata(sdev, sw);
 142
 143         /* Get initial state. */
 144         status = sw->ops.get_state(sw, &sw->state);
 145         if (status)
 146                 return status;
 147
 148         /* Set up tablet mode switch. */
 149         sw->mode_switch = devm_input_allocate_device(&sdev->dev);
 150         if (!sw->mode_switch)
 151                 return -ENOMEM;
 152
 153         sw->mode_switch->name = desc->dev.name;
 154         sw->mode_switch->phys = desc->dev.phys;
 155         sw->mode_switch->id.bustype = BUS_HOST;
 156         sw->mode_switch->dev.parent = &sdev->dev;
 157
 158         tablet = sw->ops.state_is_tablet_mode(sw, &sw->state);
 159         input_set_capability(sw->mode_switch, EV_SW, SW_TABLET_MODE);
 160         input_report_switch(sw->mode_switch, SW_TABLET_MODE, tablet);
 161
 162         status = input_register_device(sw->mode_switch);
 163         if (status)
 164                 return status;
 165
 166         /* Set up notifier. */
 167         sw->notif.base.priority = 0;
 168         sw->notif.base.fn = desc->ops.notify;
 169         sw->notif.event.reg = desc->event.reg;
 170         sw->notif.event.id = desc->event.id;
 171         sw->notif.event.mask = desc->event.mask;
 172         sw->notif.event.flags = SSAM_EVENT_SEQUENCED;
 173
 174         status = ssam_device_notifier_register(sdev, &sw->notif);
 175         if (status)
 176                 return status;
 177
 178         status = sysfs_create_group(&sdev->dev.kobj, &ssam_tablet_sw_group);
 179         if (status)
 180                 goto err;
 181
 182         /* We might have missed events during setup, so check again. */
 183         schedule_work(&sw->update_work);
 184         return 0;
 185
 186 err:
 187         ssam_device_notifier_unregister(sdev, &sw->notif);
 188         cancel_work_sync(&sw->update_work);
 189         return status;
 190 }
 191
 192 static void ssam_tablet_sw_remove(struct ssam_device *sdev)
 193 {
 194         struct ssam_tablet_sw *sw = ssam_device_get_drvdata(sdev);
 195
 196         sysfs_remove_group(&sdev->dev.kobj, &ssam_tablet_sw_group);
 197
 198         ssam_device_notifier_unregister(sdev, &sw->notif);
 199         cancel_work_sync(&sw->update_work);
 200 }
 201
 202
 203 /* -- SSAM KIP tablet switch implementation. -------------------------------- */
 204
 205 #define SSAM_EVENT_KIP_CID_COVER_STATE_CHANGED  0x1d
 206
 207 enum ssam_kip_cover_state {
 208         SSAM_KIP_COVER_STATE_DISCONNECTED  = 0x01,
 209         SSAM_KIP_COVER_STATE_CLOSED        = 0x02,
 210         SSAM_KIP_COVER_STATE_LAPTOP        = 0x03,
 211         SSAM_KIP_COVER_STATE_FOLDED_CANVAS = 0x04,
 212         SSAM_KIP_COVER_STATE_FOLDED_BACK   = 0x05,
 213         SSAM_KIP_COVER_STATE_BOOK          = 0x06,
 214 };
 215
 216 static const char *ssam_kip_cover_state_name(struct ssam_tablet_sw *sw,
 217                                              const struct ssam_tablet_sw_state *state)
 218 {
 219         switch (state->state) {
 220         case SSAM_KIP_COVER_STATE_DISCONNECTED:
 221                 return "disconnected";
 222
 223         case SSAM_KIP_COVER_STATE_CLOSED:
 224                 return "closed";
 225
 226         case SSAM_KIP_COVER_STATE_LAPTOP:
 227                 return "laptop";
 228
 229         case SSAM_KIP_COVER_STATE_FOLDED_CANVAS:
 230                 return "folded-canvas";
 231
 232         case SSAM_KIP_COVER_STATE_FOLDED_BACK:
 233                 return "folded-back";
 234
 235         case SSAM_KIP_COVER_STATE_BOOK:
 236                 return "book";
 237
 238         default:
 239                 dev_warn(&sw->sdev->dev, "unknown KIP cover state: %u\n", state->state);
 240                 return "<unknown>";
 241         }
 242 }
 243
 244 static bool ssam_kip_cover_state_is_tablet_mode(struct ssam_tablet_sw *sw,
 245                                                 const struct ssam_tablet_sw_state *state)
 246 {
 247         switch (state->state) {
 248         case SSAM_KIP_COVER_STATE_DISCONNECTED:
 249         case SSAM_KIP_COVER_STATE_FOLDED_CANVAS:
 250         case SSAM_KIP_COVER_STATE_FOLDED_BACK:
 251         case SSAM_KIP_COVER_STATE_BOOK:
 252                 return true;
 253
 254         case SSAM_KIP_COVER_STATE_CLOSED:
 255         case SSAM_KIP_COVER_STATE_LAPTOP:
 256                 return false;
 257
 258         default:
 259                 dev_warn(&sw->sdev->dev, "unknown KIP cover state: %d\n", state->state);
 260                 return true;
 261         }
 262 }
 263
 264 SSAM_DEFINE_SYNC_REQUEST_R(__ssam_kip_get_cover_state, u8, {
 265         .target_category = SSAM_SSH_TC_KIP,
 266         .target_id       = SSAM_SSH_TID_SAM,
 267         .command_id      = 0x1d,
 268         .instance_id     = 0x00,
 269 });
 270
 271 static int ssam_kip_get_cover_state(struct ssam_tablet_sw *sw, struct ssam_tablet_sw_state *state)
 272 {
 273         int status;
 274         u8 raw;
 275
 276         status = ssam_retry(__ssam_kip_get_cover_state, sw->sdev->ctrl, &raw);
 277         if (status < 0) {
 278                 dev_err(&sw->sdev->dev, "failed to query KIP lid state: %d\n", status);
 279                 return status;
 280         }
 281
 282         state->source = 0;      /* Unused for KIP switch. */
 283         state->state = raw;
 284         return 0;
 285 }
 286
 287 static u32 ssam_kip_sw_notif(struct ssam_event_notifier *nf, const struct ssam_event *event)
 288 {
 289         struct ssam_tablet_sw *sw = container_of(nf, struct ssam_tablet_sw, notif);
 290
 291         if (event->command_id != SSAM_EVENT_KIP_CID_COVER_STATE_CHANGED)
 292                 return 0;       /* Return "unhandled". */
 293
 294         if (event->length < 1)
 295                 dev_warn(&sw->sdev->dev, "unexpected payload size: %u\n", event->length);
 296
 297         schedule_work(&sw->update_work);
 298         return SSAM_NOTIF_HANDLED;
 299 }
 300
 301 static const struct ssam_tablet_sw_desc ssam_kip_sw_desc = {
 302         .dev = {
 303                 .name = "Microsoft Surface KIP Tablet Mode Switch",
 304                 .phys = "ssam/01:0e:01:00:01/input0",
 305         },
 306         .ops = {
 307                 .notify = ssam_kip_sw_notif,
 308                 .get_state = ssam_kip_get_cover_state,
 309                 .state_name = ssam_kip_cover_state_name,
 310                 .state_is_tablet_mode = ssam_kip_cover_state_is_tablet_mode,
 311         },
 312         .event = {
 313                 .reg = SSAM_EVENT_REGISTRY_SAM,
 314                 .id = {
 315                         .target_category = SSAM_SSH_TC_KIP,
 316                         .instance = 0,
 317                 },
 318                 .mask = SSAM_EVENT_MASK_TARGET,
 319         },
 320 };
 321
 322
 323 /* -- SSAM POS tablet switch implementation. -------------------------------- */
 324
 325 static bool tablet_mode_in_slate_state = true;
 326 module_param(tablet_mode_in_slate_state, bool, 0644);
 327 MODULE_PARM_DESC(tablet_mode_in_slate_state, "Enable tablet mode in slate device posture, default is 'true'");
 328
 329 #define SSAM_EVENT_POS_CID_POSTURE_CHANGED      0x03
 330 #define SSAM_POS_MAX_SOURCES                    4
 331
 332 enum ssam_pos_source_id {
 333         SSAM_POS_SOURCE_COVER = 0x00,
 334         SSAM_POS_SOURCE_SLS   = 0x03,
 335 };
 336
 337 enum ssam_pos_state_cover {
 338         SSAM_POS_COVER_DISCONNECTED  = 0x01,
 339         SSAM_POS_COVER_CLOSED        = 0x02,
 340         SSAM_POS_COVER_LAPTOP        = 0x03,
 341         SSAM_POS_COVER_FOLDED_CANVAS = 0x04,
 342         SSAM_POS_COVER_FOLDED_BACK   = 0x05,
 343         SSAM_POS_COVER_BOOK          = 0x06,
 344 };
 345
 346 enum ssam_pos_state_sls {
 347         SSAM_POS_SLS_LID_CLOSED = 0x00,
 348         SSAM_POS_SLS_LAPTOP     = 0x01,
 349         SSAM_POS_SLS_SLATE      = 0x02,
 350         SSAM_POS_SLS_TABLET     = 0x03,
 351 };
 352
 353 struct ssam_sources_list {
 354         __le32 count;
 355         __le32 id[SSAM_POS_MAX_SOURCES];
 356 } __packed;
 357
 358 static const char *ssam_pos_state_name_cover(struct ssam_tablet_sw *sw, u32 state)
 359 {
 360         switch (state) {
 361         case SSAM_POS_COVER_DISCONNECTED:
 362                 return "disconnected";
 363
 364         case SSAM_POS_COVER_CLOSED:
 365                 return "closed";
 366
 367         case SSAM_POS_COVER_LAPTOP:
 368                 return "laptop";
 369
 370         case SSAM_POS_COVER_FOLDED_CANVAS:
 371                 return "folded-canvas";
 372
 373         case SSAM_POS_COVER_FOLDED_BACK:
 374                 return "folded-back";
 375
 376         case SSAM_POS_COVER_BOOK:
 377                 return "book";
 378
 379         default:
 380                 dev_warn(&sw->sdev->dev, "unknown device posture for type-cover: %u\n", state);
 381                 return "<unknown>";
 382         }
 383 }
 384
 385 static const char *ssam_pos_state_name_sls(struct ssam_tablet_sw *sw, u32 state)
 386 {
 387         switch (state) {
 388         case SSAM_POS_SLS_LID_CLOSED:
 389                 return "closed";
 390
 391         case SSAM_POS_SLS_LAPTOP:
 392                 return "laptop";
 393
 394         case SSAM_POS_SLS_SLATE:
 395                 return "slate";
 396
 397         case SSAM_POS_SLS_TABLET:
 398                 return "tablet";
 399
 400         default:
 401                 dev_warn(&sw->sdev->dev, "unknown device posture for SLS: %u\n", state);
 402                 return "<unknown>";
 403         }
 404 }
 405
 406 static const char *ssam_pos_state_name(struct ssam_tablet_sw *sw,
 407                                        const struct ssam_tablet_sw_state *state)
 408 {
 409         switch (state->source) {
 410         case SSAM_POS_SOURCE_COVER:
 411                 return ssam_pos_state_name_cover(sw, state->state);
 412
 413         case SSAM_POS_SOURCE_SLS:
 414                 return ssam_pos_state_name_sls(sw, state->state);
 415
 416         default:
 417                 dev_warn(&sw->sdev->dev, "unknown device posture source: %u\n", state->source);
 418                 return "<unknown>";
 419         }
 420 }
 421
 422 static bool ssam_pos_state_is_tablet_mode_cover(struct ssam_tablet_sw *sw, u32 state)
 423 {
 424         switch (state) {
 425         case SSAM_POS_COVER_DISCONNECTED:
 426         case SSAM_POS_COVER_FOLDED_CANVAS:
 427         case SSAM_POS_COVER_FOLDED_BACK:
 428         case SSAM_POS_COVER_BOOK:
 429                 return true;
 430
 431         case SSAM_POS_COVER_CLOSED:
 432         case SSAM_POS_COVER_LAPTOP:
 433                 return false;
 434
 435         default:
 436                 dev_warn(&sw->sdev->dev, "unknown device posture for type-cover: %u\n", state);
 437                 return true;
 438         }
 439 }
 440
 441 static bool ssam_pos_state_is_tablet_mode_sls(struct ssam_tablet_sw *sw, u32 state)
 442 {
 443         switch (state) {
 444         case SSAM_POS_SLS_LAPTOP:
 445         case SSAM_POS_SLS_LID_CLOSED:
 446                 return false;
 447
 448         case SSAM_POS_SLS_SLATE:
 449                 return tablet_mode_in_slate_state;
 450
 451         case SSAM_POS_SLS_TABLET:
 452                 return true;
 453
 454         default:
 455                 dev_warn(&sw->sdev->dev, "unknown device posture for SLS: %u\n", state);
 456                 return true;
 457         }
 458 }
 459
 460 static bool ssam_pos_state_is_tablet_mode(struct ssam_tablet_sw *sw,
 461                                           const struct ssam_tablet_sw_state *state)
 462 {
 463         switch (state->source) {
 464         case SSAM_POS_SOURCE_COVER:
 465                 return ssam_pos_state_is_tablet_mode_cover(sw, state->state);
 466
 467         case SSAM_POS_SOURCE_SLS:
 468                 return ssam_pos_state_is_tablet_mode_sls(sw, state->state);
 469
 470         default:
 471                 dev_warn(&sw->sdev->dev, "unknown device posture source: %u\n", state->source);
 472                 return true;
 473         }
 474 }
 475
 476 static int ssam_pos_get_sources_list(struct ssam_tablet_sw *sw, struct ssam_sources_list *sources)
 477 {
 478         struct ssam_request rqst;
 479         struct ssam_response rsp;
 480         int status;
 481
 482         rqst.target_category = SSAM_SSH_TC_POS;
 483         rqst.target_id = SSAM_SSH_TID_SAM;
 484         rqst.command_id = 0x01;
 485         rqst.instance_id = 0x00;
 486         rqst.flags = SSAM_REQUEST_HAS_RESPONSE;
 487         rqst.length = 0;
 488         rqst.payload = NULL;
 489
 490         rsp.capacity = sizeof(*sources);
 491         rsp.length = 0;
 492         rsp.pointer = (u8 *)sources;
 493
 494         status = ssam_retry(ssam_request_do_sync_onstack, sw->sdev->ctrl, &rqst, &rsp, 0);
 495         if (status)
 496                 return status;
 497
 498         /* We need at least the 'sources->count' field. */
 499         if (rsp.length < sizeof(__le32)) {
 500                 dev_err(&sw->sdev->dev, "received source list response is too small\n");
 501                 return -EPROTO;
 502         }
 503
 504         /* Make sure 'sources->count' matches with the response length. */
 505         if (get_unaligned_le32(&sources->count) * sizeof(__le32) + sizeof(__le32) != rsp.length) {
 506                 dev_err(&sw->sdev->dev, "mismatch between number of sources and response size\n");
 507                 return -EPROTO;
 508         }
 509
 510         return 0;
 511 }
 512
 513 static int ssam_pos_get_source(struct ssam_tablet_sw *sw, u32 *source_id)
 514 {
 515         struct ssam_sources_list sources = {};
 516         int status;
 517
 518         status = ssam_pos_get_sources_list(sw, &sources);
 519         if (status)
 520                 return status;
 521
 522         if (get_unaligned_le32(&sources.count) == 0) {
 523                 dev_err(&sw->sdev->dev, "no posture sources found\n");
 524                 return -ENODEV;
 525         }
 526
 527         /*
 528          * We currently don't know what to do with more than one posture
 529          * source. At the moment, only one source seems to be used/provided.
 530          * The WARN_ON() here should hopefully let us know quickly once there
 531          * is a device that provides multiple sources, at which point we can
 532          * then try to figure out how to handle them.
 533          */
 534         WARN_ON(get_unaligned_le32(&sources.count) > 1);
 535
 536         *source_id = get_unaligned_le32(&sources.id[0]);
 537         return 0;
 538 }
 539
 540 SSAM_DEFINE_SYNC_REQUEST_WR(__ssam_pos_get_posture_for_source, __le32, __le32, {
 541         .target_category = SSAM_SSH_TC_POS,
 542         .target_id       = SSAM_SSH_TID_SAM,
 543         .command_id      = 0x02,
 544         .instance_id     = 0x00,
 545 });
 546
 547 static int ssam_pos_get_posture_for_source(struct ssam_tablet_sw *sw, u32 source_id, u32 *posture)
 548 {
 549         __le32 source_le = cpu_to_le32(source_id);
 550         __le32 rspval_le = 0;
 551         int status;
 552
 553         status = ssam_retry(__ssam_pos_get_posture_for_source, sw->sdev->ctrl,
 554                             &source_le, &rspval_le);
 555         if (status)
 556                 return status;
 557
 558         *posture = le32_to_cpu(rspval_le);
 559         return 0;
 560 }
 561
 562 static int ssam_pos_get_posture(struct ssam_tablet_sw *sw, struct ssam_tablet_sw_state *state)
 563 {
 564         u32 source_id;
 565         u32 source_state;
 566         int status;
 567
 568         status = ssam_pos_get_source(sw, &source_id);
 569         if (status) {
 570                 dev_err(&sw->sdev->dev, "failed to get posture source ID: %d\n", status);
 571                 return status;
 572         }
 573
 574         status = ssam_pos_get_posture_for_source(sw, source_id, &source_state);
 575         if (status) {
 576                 dev_err(&sw->sdev->dev, "failed to get posture value for source %u: %d\n",
 577                         source_id, status);
 578                 return status;
 579         }
 580
 581         state->source = source_id;
 582         state->state = source_state;
 583         return 0;
 584 }
 585
 586 static u32 ssam_pos_sw_notif(struct ssam_event_notifier *nf, const struct ssam_event *event)
 587 {
 588         struct ssam_tablet_sw *sw = container_of(nf, struct ssam_tablet_sw, notif);
 589
 590         if (event->command_id != SSAM_EVENT_POS_CID_POSTURE_CHANGED)
 591                 return 0;       /* Return "unhandled". */
 592
 593         if (event->length != sizeof(__le32) * 3)
 594                 dev_warn(&sw->sdev->dev, "unexpected payload size: %u\n", event->length);
 595
 596         schedule_work(&sw->update_work);
 597         return SSAM_NOTIF_HANDLED;
 598 }
 599
 600 static const struct ssam_tablet_sw_desc ssam_pos_sw_desc = {
 601         .dev = {
 602                 .name = "Microsoft Surface POS Tablet Mode Switch",
 603                 .phys = "ssam/01:26:01:00:01/input0",
 604         },
 605         .ops = {
 606                 .notify = ssam_pos_sw_notif,
 607                 .get_state = ssam_pos_get_posture,
 608                 .state_name = ssam_pos_state_name,
 609                 .state_is_tablet_mode = ssam_pos_state_is_tablet_mode,
 610         },
 611         .event = {
 612                 .reg = SSAM_EVENT_REGISTRY_SAM,
 613                 .id = {
 614                         .target_category = SSAM_SSH_TC_POS,
 615                         .instance = 0,
 616                 },
 617                 .mask = SSAM_EVENT_MASK_TARGET,
 618         },
 619 };
 620
 621
 622 /* -- Driver registration. -------------------------------------------------- */
 623
 624 static const struct ssam_device_id ssam_tablet_sw_match[] = {
 625         { SSAM_SDEV(KIP, SAM, 0x00, 0x01), (unsigned long)&ssam_kip_sw_desc },
 626         { SSAM_SDEV(POS, SAM, 0x00, 0x01), (unsigned long)&ssam_pos_sw_desc },
 627         { },
 628 };
 629 MODULE_DEVICE_TABLE(ssam, ssam_tablet_sw_match);
 630
 631 static struct ssam_device_driver ssam_tablet_sw_driver = {
 632         .probe = ssam_tablet_sw_probe,
 633         .remove = ssam_tablet_sw_remove,
 634         .match_table = ssam_tablet_sw_match,
 635         .driver = {
 636                 .name = "surface_aggregator_tablet_mode_switch",
 637                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 638                 .pm = &ssam_tablet_sw_pm_ops,
 639         },
 640 };
 641 module_ssam_device_driver(ssam_tablet_sw_driver);
 642
 643 MODULE_AUTHOR("Maximilian Luz <luzmaximilian@gmail.com>");
 644 MODULE_DESCRIPTION("Tablet mode switch driver for Surface devices using the Surface Aggregator Module");
 645 MODULE_LICENSE("GPL");