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