1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * HID driver for Google Hammer device. 4 * 5 * Copyright (c) 2017 Google Inc. 6 * Author: Wei-Ning Huang <wnhuang@google.com> 7 */ 8 9 /* 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; either version 2 of the License, or (at your option) 13 * any later version. 14 */ 15 16 #include <linux/acpi.h> 17 #include <linux/hid.h> 18 #include <linux/input/vivaldi-fmap.h> 19 #include <linux/leds.h> 20 #include <linux/module.h> 21 #include <linux/of.h> 22 #include <linux/platform_data/cros_ec_commands.h> 23 #include <linux/platform_data/cros_ec_proto.h> 24 #include <linux/platform_device.h> 25 #include <linux/pm_wakeup.h> 26 #include <linux/unaligned.h> 27 28 #include "hid-ids.h" 29 #include "hid-vivaldi-common.h" 30 31 /* 32 * C(hrome)B(ase)A(ttached)S(witch) - switch exported by Chrome EC and reporting 33 * state of the "Whiskers" base - attached or detached. Whiskers USB device also 34 * reports position of the keyboard - folded or not. Combining base state and 35 * position allows us to generate proper "Tablet mode" events. 36 */ 37 struct cbas_ec { 38 struct device *dev; /* The platform device (EC) */ 39 struct input_dev *input; 40 bool base_present; 41 bool base_folded; 42 struct notifier_block notifier; 43 }; 44 45 static struct cbas_ec cbas_ec; 46 static DEFINE_SPINLOCK(cbas_ec_lock); 47 static DEFINE_MUTEX(cbas_ec_reglock); 48 49 static bool cbas_parse_base_state(const void *data) 50 { 51 u32 switches = get_unaligned_le32(data); 52 53 return !!(switches & BIT(EC_MKBP_BASE_ATTACHED)); 54 } 55 56 static int cbas_ec_query_base(struct cros_ec_device *ec_dev, bool get_state, 57 bool *state) 58 { 59 struct ec_params_mkbp_info *params; 60 struct cros_ec_command *msg; 61 int ret; 62 63 msg = kzalloc(struct_size(msg, data, max(sizeof(u32), sizeof(*params))), 64 GFP_KERNEL); 65 if (!msg) 66 return -ENOMEM; 67 68 msg->command = EC_CMD_MKBP_INFO; 69 msg->version = 1; 70 msg->outsize = sizeof(*params); 71 msg->insize = sizeof(u32); 72 params = (struct ec_params_mkbp_info *)msg->data; 73 params->info_type = get_state ? 74 EC_MKBP_INFO_CURRENT : EC_MKBP_INFO_SUPPORTED; 75 params->event_type = EC_MKBP_EVENT_SWITCH; 76 77 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 78 if (ret >= 0) { 79 if (ret != sizeof(u32)) { 80 dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n", 81 ret, sizeof(u32)); 82 ret = -EPROTO; 83 } else { 84 *state = cbas_parse_base_state(msg->data); 85 ret = 0; 86 } 87 } 88 89 kfree(msg); 90 91 return ret; 92 } 93 94 static int cbas_ec_notify(struct notifier_block *nb, 95 unsigned long queued_during_suspend, 96 void *_notify) 97 { 98 struct cros_ec_device *ec = _notify; 99 unsigned long flags; 100 bool base_present; 101 102 if (ec->event_data.event_type == EC_MKBP_EVENT_SWITCH) { 103 base_present = cbas_parse_base_state( 104 &ec->event_data.data.switches); 105 dev_dbg(cbas_ec.dev, 106 "%s: base: %d\n", __func__, base_present); 107 108 if (device_may_wakeup(cbas_ec.dev) || 109 !queued_during_suspend) { 110 111 pm_wakeup_event(cbas_ec.dev, 0); 112 113 spin_lock_irqsave(&cbas_ec_lock, flags); 114 115 /* 116 * While input layer dedupes the events, we do not want 117 * to disrupt the state reported by the base by 118 * overriding it with state reported by the LID. Only 119 * report changes, as we assume that on attach the base 120 * is not folded. 121 */ 122 if (base_present != cbas_ec.base_present) { 123 input_report_switch(cbas_ec.input, 124 SW_TABLET_MODE, 125 !base_present); 126 input_sync(cbas_ec.input); 127 cbas_ec.base_present = base_present; 128 } 129 130 spin_unlock_irqrestore(&cbas_ec_lock, flags); 131 } 132 } 133 134 return NOTIFY_OK; 135 } 136 137 static __maybe_unused int cbas_ec_resume(struct device *dev) 138 { 139 struct cros_ec_device *ec = dev_get_drvdata(dev->parent); 140 bool base_present; 141 int error; 142 143 error = cbas_ec_query_base(ec, true, &base_present); 144 if (error) { 145 dev_warn(dev, "failed to fetch base state on resume: %d\n", 146 error); 147 } else { 148 spin_lock_irq(&cbas_ec_lock); 149 150 cbas_ec.base_present = base_present; 151 152 /* 153 * Only report if base is disconnected. If base is connected, 154 * it will resend its state on resume, and we'll update it 155 * in hammer_event(). 156 */ 157 if (!cbas_ec.base_present) { 158 input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1); 159 input_sync(cbas_ec.input); 160 } 161 162 spin_unlock_irq(&cbas_ec_lock); 163 } 164 165 return 0; 166 } 167 168 static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume); 169 170 static void cbas_ec_set_input(struct input_dev *input) 171 { 172 /* Take the lock so hammer_event() does not race with us here */ 173 spin_lock_irq(&cbas_ec_lock); 174 cbas_ec.input = input; 175 spin_unlock_irq(&cbas_ec_lock); 176 } 177 178 static int __cbas_ec_probe(struct platform_device *pdev) 179 { 180 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); 181 struct input_dev *input; 182 bool base_supported; 183 int error; 184 185 error = cbas_ec_query_base(ec, false, &base_supported); 186 if (error) 187 return error; 188 189 if (!base_supported) 190 return -ENXIO; 191 192 input = devm_input_allocate_device(&pdev->dev); 193 if (!input) 194 return -ENOMEM; 195 196 input->name = "Whiskers Tablet Mode Switch"; 197 input->id.bustype = BUS_HOST; 198 199 input_set_capability(input, EV_SW, SW_TABLET_MODE); 200 201 error = input_register_device(input); 202 if (error) { 203 dev_err(&pdev->dev, "cannot register input device: %d\n", 204 error); 205 return error; 206 } 207 208 /* Seed the state */ 209 error = cbas_ec_query_base(ec, true, &cbas_ec.base_present); 210 if (error) { 211 dev_err(&pdev->dev, "cannot query base state: %d\n", error); 212 return error; 213 } 214 215 if (!cbas_ec.base_present) 216 cbas_ec.base_folded = false; 217 218 dev_dbg(&pdev->dev, "%s: base: %d, folded: %d\n", __func__, 219 cbas_ec.base_present, cbas_ec.base_folded); 220 221 input_report_switch(input, SW_TABLET_MODE, 222 !cbas_ec.base_present || cbas_ec.base_folded); 223 224 cbas_ec_set_input(input); 225 226 cbas_ec.dev = &pdev->dev; 227 cbas_ec.notifier.notifier_call = cbas_ec_notify; 228 error = blocking_notifier_chain_register(&ec->event_notifier, 229 &cbas_ec.notifier); 230 if (error) { 231 dev_err(&pdev->dev, "cannot register notifier: %d\n", error); 232 cbas_ec_set_input(NULL); 233 return error; 234 } 235 236 device_init_wakeup(&pdev->dev, true); 237 return 0; 238 } 239 240 static int cbas_ec_probe(struct platform_device *pdev) 241 { 242 int retval; 243 244 mutex_lock(&cbas_ec_reglock); 245 246 if (cbas_ec.input) { 247 retval = -EBUSY; 248 goto out; 249 } 250 251 retval = __cbas_ec_probe(pdev); 252 253 out: 254 mutex_unlock(&cbas_ec_reglock); 255 return retval; 256 } 257 258 static void cbas_ec_remove(struct platform_device *pdev) 259 { 260 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); 261 262 mutex_lock(&cbas_ec_reglock); 263 264 blocking_notifier_chain_unregister(&ec->event_notifier, 265 &cbas_ec.notifier); 266 cbas_ec_set_input(NULL); 267 268 mutex_unlock(&cbas_ec_reglock); 269 } 270 271 #ifdef CONFIG_ACPI 272 static const struct acpi_device_id cbas_ec_acpi_ids[] = { 273 { "GOOG000B", 0 }, 274 { } 275 }; 276 MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids); 277 #endif 278 279 #ifdef CONFIG_OF 280 static const struct of_device_id cbas_ec_of_match[] = { 281 { .compatible = "google,cros-cbas" }, 282 { }, 283 }; 284 MODULE_DEVICE_TABLE(of, cbas_ec_of_match); 285 #endif 286 287 static struct platform_driver cbas_ec_driver = { 288 .probe = cbas_ec_probe, 289 .remove = cbas_ec_remove, 290 .driver = { 291 .name = "cbas_ec", 292 .acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids), 293 .of_match_table = of_match_ptr(cbas_ec_of_match), 294 .pm = &cbas_ec_pm_ops, 295 }, 296 }; 297 298 #define MAX_BRIGHTNESS 100 299 300 struct hammer_kbd_leds { 301 struct led_classdev cdev; 302 struct hid_device *hdev; 303 u8 buf[2] ____cacheline_aligned; 304 }; 305 306 static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev, 307 enum led_brightness br) 308 { 309 struct hammer_kbd_leds *led = container_of(cdev, 310 struct hammer_kbd_leds, 311 cdev); 312 int ret; 313 314 led->buf[0] = 0; 315 led->buf[1] = br; 316 317 /* 318 * Request USB HID device to be in Full On mode, so that sending 319 * hardware output report and hardware raw request won't fail. 320 */ 321 ret = hid_hw_power(led->hdev, PM_HINT_FULLON); 322 if (ret < 0) { 323 hid_err(led->hdev, "failed: device not resumed %d\n", ret); 324 return ret; 325 } 326 327 ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf)); 328 if (ret == -ENOSYS) 329 ret = hid_hw_raw_request(led->hdev, 0, led->buf, 330 sizeof(led->buf), 331 HID_OUTPUT_REPORT, 332 HID_REQ_SET_REPORT); 333 if (ret < 0) 334 hid_err(led->hdev, "failed to set keyboard backlight: %d\n", 335 ret); 336 337 /* Request USB HID device back to Normal Mode. */ 338 hid_hw_power(led->hdev, PM_HINT_NORMAL); 339 340 return ret; 341 } 342 343 static int hammer_register_leds(struct hid_device *hdev) 344 { 345 struct hammer_kbd_leds *kbd_backlight; 346 347 kbd_backlight = devm_kzalloc(&hdev->dev, sizeof(*kbd_backlight), 348 GFP_KERNEL); 349 if (!kbd_backlight) 350 return -ENOMEM; 351 352 kbd_backlight->hdev = hdev; 353 kbd_backlight->cdev.name = "hammer::kbd_backlight"; 354 kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS; 355 kbd_backlight->cdev.brightness_set_blocking = 356 hammer_kbd_brightness_set_blocking; 357 kbd_backlight->cdev.flags = LED_HW_PLUGGABLE; 358 359 /* Set backlight to 0% initially. */ 360 hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0); 361 362 return devm_led_classdev_register(&hdev->dev, &kbd_backlight->cdev); 363 } 364 365 #define HID_UP_GOOGLEVENDOR 0xffd10000 366 #define HID_VD_KBD_FOLDED 0x00000019 367 #define HID_USAGE_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED) 368 369 /* HID usage for keyboard backlight (Alphanumeric display brightness) */ 370 #define HID_AD_BRIGHTNESS 0x00140046 371 372 static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi, 373 struct hid_field *field, 374 struct hid_usage *usage, 375 unsigned long **bit, int *max) 376 { 377 if (usage->hid == HID_USAGE_KBD_FOLDED) { 378 /* 379 * We do not want to have this usage mapped as it will get 380 * mixed in with "base attached" signal and delivered over 381 * separate input device for tablet switch mode. 382 */ 383 return -1; 384 } 385 386 return 0; 387 } 388 389 static void hammer_folded_event(struct hid_device *hdev, bool folded) 390 { 391 unsigned long flags; 392 393 spin_lock_irqsave(&cbas_ec_lock, flags); 394 395 /* 396 * If we are getting events from Whiskers that means that it 397 * is attached to the lid. 398 */ 399 cbas_ec.base_present = true; 400 cbas_ec.base_folded = folded; 401 hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__, 402 cbas_ec.base_present, cbas_ec.base_folded); 403 404 if (cbas_ec.input) { 405 input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded); 406 input_sync(cbas_ec.input); 407 } 408 409 spin_unlock_irqrestore(&cbas_ec_lock, flags); 410 } 411 412 static int hammer_event(struct hid_device *hid, struct hid_field *field, 413 struct hid_usage *usage, __s32 value) 414 { 415 if (usage->hid == HID_USAGE_KBD_FOLDED) { 416 hammer_folded_event(hid, value); 417 return 1; /* We handled this event */ 418 } 419 420 return 0; 421 } 422 423 static bool hammer_has_folded_event(struct hid_device *hdev) 424 { 425 return !!hid_find_field(hdev, HID_INPUT_REPORT, 426 HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED); 427 } 428 429 static bool hammer_has_backlight_control(struct hid_device *hdev) 430 { 431 return !!hid_find_field(hdev, HID_OUTPUT_REPORT, 432 HID_GD_KEYBOARD, HID_AD_BRIGHTNESS); 433 } 434 435 static void hammer_get_folded_state(struct hid_device *hdev) 436 { 437 struct hid_report *report; 438 char *buf; 439 int len, rlen; 440 int a; 441 442 report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0]; 443 444 if (!report || report->maxfield < 1) 445 return; 446 447 len = hid_report_len(report) + 1; 448 449 buf = kmalloc(len, GFP_KERNEL); 450 if (!buf) 451 return; 452 453 rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT); 454 455 if (rlen != len) { 456 hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len); 457 goto out; 458 } 459 460 for (a = 0; a < report->maxfield; a++) { 461 struct hid_field *field = report->field[a]; 462 463 if (field->usage->hid == HID_USAGE_KBD_FOLDED) { 464 u32 value = hid_field_extract(hdev, buf+1, 465 field->report_offset, field->report_size); 466 467 hammer_folded_event(hdev, value); 468 break; 469 } 470 } 471 472 out: 473 kfree(buf); 474 } 475 476 static void hammer_stop(void *hdev) 477 { 478 hid_hw_stop(hdev); 479 } 480 481 static int hammer_probe(struct hid_device *hdev, 482 const struct hid_device_id *id) 483 { 484 struct vivaldi_data *vdata; 485 int error; 486 487 vdata = devm_kzalloc(&hdev->dev, sizeof(*vdata), GFP_KERNEL); 488 if (!vdata) 489 return -ENOMEM; 490 491 hid_set_drvdata(hdev, vdata); 492 493 error = hid_parse(hdev); 494 if (error) 495 return error; 496 497 error = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 498 if (error) 499 return error; 500 501 error = devm_add_action(&hdev->dev, hammer_stop, hdev); 502 if (error) 503 return error; 504 505 /* 506 * We always want to poll for, and handle tablet mode events from 507 * devices that have folded usage, even when nobody has opened the input 508 * device. This also prevents the hid core from dropping early tablet 509 * mode events from the device. 510 */ 511 if (hammer_has_folded_event(hdev)) { 512 hdev->quirks |= HID_QUIRK_ALWAYS_POLL; 513 error = hid_hw_open(hdev); 514 if (error) 515 return error; 516 517 hammer_get_folded_state(hdev); 518 } 519 520 if (hammer_has_backlight_control(hdev)) { 521 error = hammer_register_leds(hdev); 522 if (error) 523 hid_warn(hdev, 524 "Failed to register keyboard backlight: %d\n", 525 error); 526 } 527 528 return 0; 529 } 530 531 static void hammer_remove(struct hid_device *hdev) 532 { 533 unsigned long flags; 534 535 if (hammer_has_folded_event(hdev)) { 536 hid_hw_close(hdev); 537 538 /* 539 * If we are disconnecting then most likely Whiskers is 540 * being removed. Even if it is not removed, without proper 541 * keyboard we should not stay in clamshell mode. 542 * 543 * The reason for doing it here and not waiting for signal 544 * from EC, is that on some devices there are high leakage 545 * on Whiskers pins and we do not detect disconnect reliably, 546 * resulting in devices being stuck in clamshell mode. 547 */ 548 spin_lock_irqsave(&cbas_ec_lock, flags); 549 if (cbas_ec.input && cbas_ec.base_present) { 550 input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1); 551 input_sync(cbas_ec.input); 552 } 553 cbas_ec.base_present = false; 554 spin_unlock_irqrestore(&cbas_ec_lock, flags); 555 } 556 557 /* Unregistering LEDs and stopping the hardware is done via devm */ 558 } 559 560 static const struct hid_device_id hammer_devices[] = { 561 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 562 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) }, 563 { HID_DEVICE(BUS_USB, HID_GROUP_VIVALDI, 564 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_EEL) }, 565 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 566 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) }, 567 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 568 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_JEWEL) }, 569 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 570 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) }, 571 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 572 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) }, 573 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 574 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) }, 575 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 576 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) }, 577 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 578 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) }, 579 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 580 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) }, 581 { } 582 }; 583 MODULE_DEVICE_TABLE(hid, hammer_devices); 584 585 static struct hid_driver hammer_driver = { 586 .name = "hammer", 587 .id_table = hammer_devices, 588 .probe = hammer_probe, 589 .remove = hammer_remove, 590 .feature_mapping = vivaldi_feature_mapping, 591 .input_mapping = hammer_input_mapping, 592 .event = hammer_event, 593 .driver = { 594 .dev_groups = vivaldi_attribute_groups, 595 }, 596 }; 597 598 static int __init hammer_init(void) 599 { 600 int error; 601 602 error = platform_driver_register(&cbas_ec_driver); 603 if (error) 604 return error; 605 606 error = hid_register_driver(&hammer_driver); 607 if (error) { 608 platform_driver_unregister(&cbas_ec_driver); 609 return error; 610 } 611 612 return 0; 613 } 614 module_init(hammer_init); 615 616 static void __exit hammer_exit(void) 617 { 618 hid_unregister_driver(&hammer_driver); 619 platform_driver_unregister(&cbas_ec_driver); 620 } 621 module_exit(hammer_exit); 622 623 MODULE_DESCRIPTION("HID driver for Google Hammer device."); 624 MODULE_LICENSE("GPL"); 625