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