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