xref: /linux/drivers/hid/hid-google-hammer.c (revision d5859510d35d8e7d63fed5169f1775317f40fb03)
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 <asm/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 static const struct acpi_device_id cbas_ec_acpi_ids[] = {
272 	{ "GOOG000B", 0 },
273 	{ }
274 };
275 MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids);
276 
277 #ifdef CONFIG_OF
278 static const struct of_device_id cbas_ec_of_match[] = {
279 	{ .compatible = "google,cros-cbas" },
280 	{ },
281 };
282 MODULE_DEVICE_TABLE(of, cbas_ec_of_match);
283 #endif
284 
285 static 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 100
297 
298 struct hammer_kbd_leds {
299 	struct led_classdev cdev;
300 	struct hid_device *hdev;
301 	u8 buf[2] ____cacheline_aligned;
302 };
303 
304 static 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 sending
317 	 * 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 
341 static 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	0xffd10000
364 #define HID_VD_KBD_FOLDED	0x00000019
365 #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	0x00140046
369 
370 static 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 get
378 		 * mixed in with "base attached" signal and delivered over
379 		 * separate input device for tablet switch mode.
380 		 */
381 		return -1;
382 	}
383 
384 	return 0;
385 }
386 
387 static 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 it
395 	 * 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 
410 static 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 
421 static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type,
422 			unsigned application, unsigned usage)
423 {
424 	struct hid_report_enum *re = &hdev->report_enum[report_type];
425 	struct hid_report *report;
426 	int i, j;
427 
428 	list_for_each_entry(report, &re->report_list, list) {
429 		if (report->application != application)
430 			continue;
431 
432 		for (i = 0; i < report->maxfield; i++) {
433 			struct hid_field *field = report->field[i];
434 
435 			for (j = 0; j < field->maxusage; j++)
436 				if (field->usage[j].hid == usage)
437 					return true;
438 		}
439 	}
440 
441 	return false;
442 }
443 
444 static bool hammer_has_folded_event(struct hid_device *hdev)
445 {
446 	return hammer_has_usage(hdev, HID_INPUT_REPORT,
447 				HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED);
448 }
449 
450 static bool hammer_has_backlight_control(struct hid_device *hdev)
451 {
452 	return hammer_has_usage(hdev, HID_OUTPUT_REPORT,
453 				HID_GD_KEYBOARD, HID_AD_BRIGHTNESS);
454 }
455 
456 static void hammer_get_folded_state(struct hid_device *hdev)
457 {
458 	struct hid_report *report;
459 	char *buf;
460 	int len, rlen;
461 	int a;
462 
463 	report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];
464 
465 	if (!report || report->maxfield < 1)
466 		return;
467 
468 	len = hid_report_len(report) + 1;
469 
470 	buf = kmalloc(len, GFP_KERNEL);
471 	if (!buf)
472 		return;
473 
474 	rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);
475 
476 	if (rlen != len) {
477 		hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len);
478 		goto out;
479 	}
480 
481 	for (a = 0; a < report->maxfield; a++) {
482 		struct hid_field *field = report->field[a];
483 
484 		if (field->usage->hid == HID_USAGE_KBD_FOLDED) {
485 			u32 value = hid_field_extract(hdev, buf+1,
486 					field->report_offset, field->report_size);
487 
488 			hammer_folded_event(hdev, value);
489 			break;
490 		}
491 	}
492 
493 out:
494 	kfree(buf);
495 }
496 
497 static void hammer_stop(void *hdev)
498 {
499 	hid_hw_stop(hdev);
500 }
501 
502 static int hammer_probe(struct hid_device *hdev,
503 			const struct hid_device_id *id)
504 {
505 	struct vivaldi_data *vdata;
506 	int error;
507 
508 	vdata = devm_kzalloc(&hdev->dev, sizeof(*vdata), GFP_KERNEL);
509 	if (!vdata)
510 		return -ENOMEM;
511 
512 	hid_set_drvdata(hdev, vdata);
513 
514 	error = hid_parse(hdev);
515 	if (error)
516 		return error;
517 
518 	error = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
519 	if (error)
520 		return error;
521 
522 	error = devm_add_action(&hdev->dev, hammer_stop, hdev);
523 	if (error)
524 		return error;
525 
526 	/*
527 	 * We always want to poll for, and handle tablet mode events from
528 	 * devices that have folded usage, even when nobody has opened the input
529 	 * device. This also prevents the hid core from dropping early tablet
530 	 * mode events from the device.
531 	 */
532 	if (hammer_has_folded_event(hdev)) {
533 		hdev->quirks |= HID_QUIRK_ALWAYS_POLL;
534 		error = hid_hw_open(hdev);
535 		if (error)
536 			return error;
537 
538 		hammer_get_folded_state(hdev);
539 	}
540 
541 	if (hammer_has_backlight_control(hdev)) {
542 		error = hammer_register_leds(hdev);
543 		if (error)
544 			hid_warn(hdev,
545 				"Failed to register keyboard backlight: %d\n",
546 				error);
547 	}
548 
549 	return 0;
550 }
551 
552 static void hammer_remove(struct hid_device *hdev)
553 {
554 	unsigned long flags;
555 
556 	if (hammer_has_folded_event(hdev)) {
557 		hid_hw_close(hdev);
558 
559 		/*
560 		 * If we are disconnecting then most likely Whiskers is
561 		 * being removed. Even if it is not removed, without proper
562 		 * keyboard we should not stay in clamshell mode.
563 		 *
564 		 * The reason for doing it here and not waiting for signal
565 		 * from EC, is that on some devices there are high leakage
566 		 * on Whiskers pins and we do not detect disconnect reliably,
567 		 * resulting in devices being stuck in clamshell mode.
568 		 */
569 		spin_lock_irqsave(&cbas_ec_lock, flags);
570 		if (cbas_ec.input && cbas_ec.base_present) {
571 			input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
572 			input_sync(cbas_ec.input);
573 		}
574 		cbas_ec.base_present = false;
575 		spin_unlock_irqrestore(&cbas_ec_lock, flags);
576 	}
577 
578 	/* Unregistering LEDs and stopping the hardware is done via devm */
579 }
580 
581 static const struct hid_device_id hammer_devices[] = {
582 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
583 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },
584 	{ HID_DEVICE(BUS_USB, HID_GROUP_VIVALDI,
585 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_EEL) },
586 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
587 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
588 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
589 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_JEWEL) },
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 	.feature_mapping = vivaldi_feature_mapping,
612 	.input_mapping = hammer_input_mapping,
613 	.event = hammer_event,
614 	.driver = {
615 		.dev_groups = vivaldi_attribute_groups,
616 	},
617 };
618 
619 static int __init hammer_init(void)
620 {
621 	int error;
622 
623 	error = platform_driver_register(&cbas_ec_driver);
624 	if (error)
625 		return error;
626 
627 	error = hid_register_driver(&hammer_driver);
628 	if (error) {
629 		platform_driver_unregister(&cbas_ec_driver);
630 		return error;
631 	}
632 
633 	return 0;
634 }
635 module_init(hammer_init);
636 
637 static void __exit hammer_exit(void)
638 {
639 	hid_unregister_driver(&hammer_driver);
640 	platform_driver_unregister(&cbas_ec_driver);
641 }
642 module_exit(hammer_exit);
643 
644 MODULE_LICENSE("GPL");
645