drivers/hid/hid-google-hammer.c

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