623 lines · 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 it11 * under the terms of the GNU General Public License as published by the Free12 * 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 reporting33 * state of the "Whiskers" base - attached or detached. Whiskers USB device also34 * reports position of the keyboard - folded or not. Combining base state and35 * position allows us to generate proper "Tablet mode" events.36 */37struct 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 45static struct cbas_ec cbas_ec;46static DEFINE_SPINLOCK(cbas_ec_lock);47static DEFINE_MUTEX(cbas_ec_reglock);48 49static 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 56static 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 94static 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 want117 * to disrupt the state reported by the base by118 * overriding it with state reported by the LID. Only119 * report changes, as we assume that on attach the base120 * 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 137static __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 it155 * 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 168static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume);169 170static 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 178static 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 240static 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 253out:254 mutex_unlock(&cbas_ec_reglock);255 return retval;256}257 258static 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 271static const struct acpi_device_id cbas_ec_acpi_ids[] = {272 { "GOOG000B", 0 },273 { }274};275MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids);276 277#ifdef CONFIG_OF278static const struct of_device_id cbas_ec_of_match[] = {279 { .compatible = "google,cros-cbas" },280 { },281};282MODULE_DEVICE_TABLE(of, cbas_ec_of_match);283#endif284 285static struct platform_driver cbas_ec_driver = {286 .probe = cbas_ec_probe,287 .remove_new = cbas_ec_remove,288 .driver = {289 .name = "cbas_ec",290 .acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids),291 .of_match_table = of_match_ptr(cbas_ec_of_match),292 .pm = &cbas_ec_pm_ops,293 },294};295 296#define MAX_BRIGHTNESS 100297 298struct hammer_kbd_leds {299 struct led_classdev cdev;300 struct hid_device *hdev;301 u8 buf[2] ____cacheline_aligned;302};303 304static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev,305 enum led_brightness br)306{307 struct hammer_kbd_leds *led = container_of(cdev,308 struct hammer_kbd_leds,309 cdev);310 int ret;311 312 led->buf[0] = 0;313 led->buf[1] = br;314 315 /*316 * Request USB HID device to be in Full On mode, so that sending317 * hardware output report and hardware raw request won't fail.318 */319 ret = hid_hw_power(led->hdev, PM_HINT_FULLON);320 if (ret < 0) {321 hid_err(led->hdev, "failed: device not resumed %d\n", ret);322 return ret;323 }324 325 ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf));326 if (ret == -ENOSYS)327 ret = hid_hw_raw_request(led->hdev, 0, led->buf,328 sizeof(led->buf),329 HID_OUTPUT_REPORT,330 HID_REQ_SET_REPORT);331 if (ret < 0)332 hid_err(led->hdev, "failed to set keyboard backlight: %d\n",333 ret);334 335 /* Request USB HID device back to Normal Mode. */336 hid_hw_power(led->hdev, PM_HINT_NORMAL);337 338 return ret;339}340 341static int hammer_register_leds(struct hid_device *hdev)342{343 struct hammer_kbd_leds *kbd_backlight;344 345 kbd_backlight = devm_kzalloc(&hdev->dev, sizeof(*kbd_backlight),346 GFP_KERNEL);347 if (!kbd_backlight)348 return -ENOMEM;349 350 kbd_backlight->hdev = hdev;351 kbd_backlight->cdev.name = "hammer::kbd_backlight";352 kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS;353 kbd_backlight->cdev.brightness_set_blocking =354 hammer_kbd_brightness_set_blocking;355 kbd_backlight->cdev.flags = LED_HW_PLUGGABLE;356 357 /* Set backlight to 0% initially. */358 hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0);359 360 return devm_led_classdev_register(&hdev->dev, &kbd_backlight->cdev);361}362 363#define HID_UP_GOOGLEVENDOR 0xffd10000364#define HID_VD_KBD_FOLDED 0x00000019365#define HID_USAGE_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED)366 367/* HID usage for keyboard backlight (Alphanumeric display brightness) */368#define HID_AD_BRIGHTNESS 0x00140046369 370static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi,371 struct hid_field *field,372 struct hid_usage *usage,373 unsigned long **bit, int *max)374{375 if (usage->hid == HID_USAGE_KBD_FOLDED) {376 /*377 * We do not want to have this usage mapped as it will get378 * mixed in with "base attached" signal and delivered over379 * separate input device for tablet switch mode.380 */381 return -1;382 }383 384 return 0;385}386 387static void hammer_folded_event(struct hid_device *hdev, bool folded)388{389 unsigned long flags;390 391 spin_lock_irqsave(&cbas_ec_lock, flags);392 393 /*394 * If we are getting events from Whiskers that means that it395 * is attached to the lid.396 */397 cbas_ec.base_present = true;398 cbas_ec.base_folded = folded;399 hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__,400 cbas_ec.base_present, cbas_ec.base_folded);401 402 if (cbas_ec.input) {403 input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded);404 input_sync(cbas_ec.input);405 }406 407 spin_unlock_irqrestore(&cbas_ec_lock, flags);408}409 410static int hammer_event(struct hid_device *hid, struct hid_field *field,411 struct hid_usage *usage, __s32 value)412{413 if (usage->hid == HID_USAGE_KBD_FOLDED) {414 hammer_folded_event(hid, value);415 return 1; /* We handled this event */416 }417 418 return 0;419}420 421static bool hammer_has_folded_event(struct hid_device *hdev)422{423 return !!hid_find_field(hdev, HID_INPUT_REPORT,424 HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED);425}426 427static bool hammer_has_backlight_control(struct hid_device *hdev)428{429 return !!hid_find_field(hdev, HID_OUTPUT_REPORT,430 HID_GD_KEYBOARD, HID_AD_BRIGHTNESS);431}432 433static void hammer_get_folded_state(struct hid_device *hdev)434{435 struct hid_report *report;436 char *buf;437 int len, rlen;438 int a;439 440 report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];441 442 if (!report || report->maxfield < 1)443 return;444 445 len = hid_report_len(report) + 1;446 447 buf = kmalloc(len, GFP_KERNEL);448 if (!buf)449 return;450 451 rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);452 453 if (rlen != len) {454 hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len);455 goto out;456 }457 458 for (a = 0; a < report->maxfield; a++) {459 struct hid_field *field = report->field[a];460 461 if (field->usage->hid == HID_USAGE_KBD_FOLDED) {462 u32 value = hid_field_extract(hdev, buf+1,463 field->report_offset, field->report_size);464 465 hammer_folded_event(hdev, value);466 break;467 }468 }469 470out:471 kfree(buf);472}473 474static void hammer_stop(void *hdev)475{476 hid_hw_stop(hdev);477}478 479static int hammer_probe(struct hid_device *hdev,480 const struct hid_device_id *id)481{482 struct vivaldi_data *vdata;483 int error;484 485 vdata = devm_kzalloc(&hdev->dev, sizeof(*vdata), GFP_KERNEL);486 if (!vdata)487 return -ENOMEM;488 489 hid_set_drvdata(hdev, vdata);490 491 error = hid_parse(hdev);492 if (error)493 return error;494 495 error = hid_hw_start(hdev, HID_CONNECT_DEFAULT);496 if (error)497 return error;498 499 error = devm_add_action(&hdev->dev, hammer_stop, hdev);500 if (error)501 return error;502 503 /*504 * We always want to poll for, and handle tablet mode events from505 * devices that have folded usage, even when nobody has opened the input506 * device. This also prevents the hid core from dropping early tablet507 * mode events from the device.508 */509 if (hammer_has_folded_event(hdev)) {510 hdev->quirks |= HID_QUIRK_ALWAYS_POLL;511 error = hid_hw_open(hdev);512 if (error)513 return error;514 515 hammer_get_folded_state(hdev);516 }517 518 if (hammer_has_backlight_control(hdev)) {519 error = hammer_register_leds(hdev);520 if (error)521 hid_warn(hdev,522 "Failed to register keyboard backlight: %d\n",523 error);524 }525 526 return 0;527}528 529static void hammer_remove(struct hid_device *hdev)530{531 unsigned long flags;532 533 if (hammer_has_folded_event(hdev)) {534 hid_hw_close(hdev);535 536 /*537 * If we are disconnecting then most likely Whiskers is538 * being removed. Even if it is not removed, without proper539 * keyboard we should not stay in clamshell mode.540 *541 * The reason for doing it here and not waiting for signal542 * from EC, is that on some devices there are high leakage543 * on Whiskers pins and we do not detect disconnect reliably,544 * resulting in devices being stuck in clamshell mode.545 */546 spin_lock_irqsave(&cbas_ec_lock, flags);547 if (cbas_ec.input && cbas_ec.base_present) {548 input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);549 input_sync(cbas_ec.input);550 }551 cbas_ec.base_present = false;552 spin_unlock_irqrestore(&cbas_ec_lock, flags);553 }554 555 /* Unregistering LEDs and stopping the hardware is done via devm */556}557 558static const struct hid_device_id hammer_devices[] = {559 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,560 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },561 { HID_DEVICE(BUS_USB, HID_GROUP_VIVALDI,562 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_EEL) },563 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,564 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },565 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,566 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_JEWEL) },567 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,568 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },569 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,570 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },571 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,572 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },573 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,574 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },575 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,576 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) },577 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,578 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },579 { }580};581MODULE_DEVICE_TABLE(hid, hammer_devices);582 583static struct hid_driver hammer_driver = {584 .name = "hammer",585 .id_table = hammer_devices,586 .probe = hammer_probe,587 .remove = hammer_remove,588 .feature_mapping = vivaldi_feature_mapping,589 .input_mapping = hammer_input_mapping,590 .event = hammer_event,591 .driver = {592 .dev_groups = vivaldi_attribute_groups,593 },594};595 596static int __init hammer_init(void)597{598 int error;599 600 error = platform_driver_register(&cbas_ec_driver);601 if (error)602 return error;603 604 error = hid_register_driver(&hammer_driver);605 if (error) {606 platform_driver_unregister(&cbas_ec_driver);607 return error;608 }609 610 return 0;611}612module_init(hammer_init);613 614static void __exit hammer_exit(void)615{616 hid_unregister_driver(&hammer_driver);617 platform_driver_unregister(&cbas_ec_driver);618}619module_exit(hammer_exit);620 621MODULE_DESCRIPTION("HID driver for Google Hammer device.");622MODULE_LICENSE("GPL");623