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         int error;
 344
 345         kbd_backlight = kzalloc(sizeof(*kbd_backlight), 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         error = led_classdev_register(&hdev->dev, &kbd_backlight->cdev);
 360         if (error)
 361                 goto err_free_mem;
 362
 363         hid_set_drvdata(hdev, kbd_backlight);
 364         return 0;
 365
 366 err_free_mem:
 367         kfree(kbd_backlight);
 368         return error;
 369 }
 370
 371 static void hammer_unregister_leds(struct hid_device *hdev)
 372 {
 373         struct hammer_kbd_leds *kbd_backlight = hid_get_drvdata(hdev);
 374
 375         if (kbd_backlight) {
 376                 led_classdev_unregister(&kbd_backlight->cdev);
 377                 kfree(kbd_backlight);
 378         }
 379 }
 380
 381 #define HID_UP_GOOGLEVENDOR     0xffd10000
 382 #define HID_VD_KBD_FOLDED       0x00000019
 383 #define HID_USAGE_KBD_FOLDED    (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED)
 384
 385 /* HID usage for keyboard backlight (Alphanumeric display brightness) */
 386 #define HID_AD_BRIGHTNESS       0x00140046
 387
 388 static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi,
 389                                 struct hid_field *field,
 390                                 struct hid_usage *usage,
 391                                 unsigned long **bit, int *max)
 392 {
 393         if (usage->hid == HID_USAGE_KBD_FOLDED) {
 394                 /*
 395                  * We do not want to have this usage mapped as it will get
 396                  * mixed in with "base attached" signal and delivered over
 397                  * separate input device for tablet switch mode.
 398                  */
 399                 return -1;
 400         }
 401
 402         return 0;
 403 }
 404
 405 static void hammer_folded_event(struct hid_device *hdev, bool folded)
 406 {
 407         unsigned long flags;
 408
 409         spin_lock_irqsave(&cbas_ec_lock, flags);
 410
 411         /*
 412          * If we are getting events from Whiskers that means that it
 413          * is attached to the lid.
 414          */
 415         cbas_ec.base_present = true;
 416         cbas_ec.base_folded = folded;
 417         hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__,
 418                 cbas_ec.base_present, cbas_ec.base_folded);
 419
 420         if (cbas_ec.input) {
 421                 input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded);
 422                 input_sync(cbas_ec.input);
 423         }
 424
 425         spin_unlock_irqrestore(&cbas_ec_lock, flags);
 426 }
 427
 428 static int hammer_event(struct hid_device *hid, struct hid_field *field,
 429                         struct hid_usage *usage, __s32 value)
 430 {
 431         if (usage->hid == HID_USAGE_KBD_FOLDED) {
 432                 hammer_folded_event(hid, value);
 433                 return 1; /* We handled this event */
 434         }
 435
 436         return 0;
 437 }
 438
 439 static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type,
 440                         unsigned application, unsigned usage)
 441 {
 442         struct hid_report_enum *re = &hdev->report_enum[report_type];
 443         struct hid_report *report;
 444         int i, j;
 445
 446         list_for_each_entry(report, &re->report_list, list) {
 447                 if (report->application != application)
 448                         continue;
 449
 450                 for (i = 0; i < report->maxfield; i++) {
 451                         struct hid_field *field = report->field[i];
 452
 453                         for (j = 0; j < field->maxusage; j++)
 454                                 if (field->usage[j].hid == usage)
 455                                         return true;
 456                 }
 457         }
 458
 459         return false;
 460 }
 461
 462 static bool hammer_has_folded_event(struct hid_device *hdev)
 463 {
 464         return hammer_has_usage(hdev, HID_INPUT_REPORT,
 465                                 HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED);
 466 }
 467
 468 static bool hammer_has_backlight_control(struct hid_device *hdev)
 469 {
 470         return hammer_has_usage(hdev, HID_OUTPUT_REPORT,
 471                                 HID_GD_KEYBOARD, HID_AD_BRIGHTNESS);
 472 }
 473
 474 static void hammer_get_folded_state(struct hid_device *hdev)
 475 {
 476         struct hid_report *report;
 477         char *buf;
 478         int len, rlen;
 479         int a;
 480
 481         report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];
 482
 483         if (!report || report->maxfield < 1)
 484                 return;
 485
 486         len = hid_report_len(report) + 1;
 487
 488         buf = kmalloc(len, GFP_KERNEL);
 489         if (!buf)
 490                 return;
 491
 492         rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);
 493
 494         if (rlen != len) {
 495                 hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len);
 496                 goto out;
 497         }
 498
 499         for (a = 0; a < report->maxfield; a++) {
 500                 struct hid_field *field = report->field[a];
 501
 502                 if (field->usage->hid == HID_USAGE_KBD_FOLDED) {
 503                         u32 value = hid_field_extract(hdev, buf+1,
 504                                         field->report_offset, field->report_size);
 505
 506                         hammer_folded_event(hdev, value);
 507                         break;
 508                 }
 509         }
 510
 511 out:
 512         kfree(buf);
 513 }
 514
 515 static int hammer_probe(struct hid_device *hdev,
 516                         const struct hid_device_id *id)
 517 {
 518         int error;
 519
 520         error = hid_parse(hdev);
 521         if (error)
 522                 return error;
 523
 524         error = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 525         if (error)
 526                 return error;
 527
 528         /*
 529          * We always want to poll for, and handle tablet mode events from
 530          * devices that have folded usage, even when nobody has opened the input
 531          * device. This also prevents the hid core from dropping early tablet
 532          * mode events from the device.
 533          */
 534         if (hammer_has_folded_event(hdev)) {
 535                 hdev->quirks |= HID_QUIRK_ALWAYS_POLL;
 536                 error = hid_hw_open(hdev);
 537                 if (error)
 538                         return error;
 539
 540                 hammer_get_folded_state(hdev);
 541         }
 542
 543         if (hammer_has_backlight_control(hdev)) {
 544                 error = hammer_register_leds(hdev);
 545                 if (error)
 546                         hid_warn(hdev,
 547                                 "Failed to register keyboard backlight: %d\n",
 548                                 error);
 549         }
 550
 551         return 0;
 552 }
 553
 554 static void hammer_remove(struct hid_device *hdev)
 555 {
 556         unsigned long flags;
 557
 558         if (hammer_has_folded_event(hdev)) {
 559                 hid_hw_close(hdev);
 560
 561                 /*
 562                  * If we are disconnecting then most likely Whiskers is
 563                  * being removed. Even if it is not removed, without proper
 564                  * keyboard we should not stay in clamshell mode.
 565                  *
 566                  * The reason for doing it here and not waiting for signal
 567                  * from EC, is that on some devices there are high leakage
 568                  * on Whiskers pins and we do not detect disconnect reliably,
 569                  * resulting in devices being stuck in clamshell mode.
 570                  */
 571                 spin_lock_irqsave(&cbas_ec_lock, flags);
 572                 if (cbas_ec.input && cbas_ec.base_present) {
 573                         input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
 574                         input_sync(cbas_ec.input);
 575                 }
 576                 cbas_ec.base_present = false;
 577                 spin_unlock_irqrestore(&cbas_ec_lock, flags);
 578         }
 579
 580         hammer_unregister_leds(hdev);
 581
 582         hid_hw_stop(hdev);
 583 }
 584
 585 static const struct hid_device_id hammer_devices[] = {
 586         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 587                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },
 588         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 589                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
 590         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 591                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },
 592         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 593                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
 594         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 595                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
 596         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 597                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
 598         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 599                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) },
 600         { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 601                      USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },
 602         { }
 603 };
 604 MODULE_DEVICE_TABLE(hid, hammer_devices);
 605
 606 static struct hid_driver hammer_driver = {
 607         .name = "hammer",
 608         .id_table = hammer_devices,
 609         .probe = hammer_probe,
 610         .remove = hammer_remove,
 611         .input_mapping = hammer_input_mapping,
 612         .event = hammer_event,
 613 };
 614
 615 static int __init hammer_init(void)
 616 {
 617         int error;
 618
 619         error = platform_driver_register(&cbas_ec_driver);
 620         if (error)
 621                 return error;
 622
 623         error = hid_register_driver(&hammer_driver);
 624         if (error) {
 625                 platform_driver_unregister(&cbas_ec_driver);
 626                 return error;
 627         }
 628
 629         return 0;
 630 }
 631 module_init(hammer_init);
 632
 633 static void __exit hammer_exit(void)
 634 {
 635         hid_unregister_driver(&hammer_driver);
 636         platform_driver_unregister(&cbas_ec_driver);
 637 }
 638 module_exit(hammer_exit);
 639
 640 MODULE_LICENSE("GPL");