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 <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 <luzmaximilian@gmail.com>"); 532 MODULE_DESCRIPTION("Tablet mode switch driver for Surface devices using the Surface Aggregator Module"); 533 MODULE_LICENSE("GPL"); 534