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_MAGNEMITE) },
474 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
475 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
476 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
477 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
478 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
479 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) },
480 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
481 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },
482 	{ }
483 };
484 MODULE_DEVICE_TABLE(hid, hammer_devices);
485 
486 static struct hid_driver hammer_driver = {
487 	.name = "hammer",
488 	.id_table = hammer_devices,
489 	.probe = hammer_probe,
490 	.input_mapping = hammer_input_mapping,
491 	.event = hammer_event,
492 };
493 
494 static int __init hammer_init(void)
495 {
496 	int error;
497 
498 	error = platform_driver_register(&cbas_ec_driver);
499 	if (error)
500 		return error;
501 
502 	error = hid_register_driver(&hammer_driver);
503 	if (error) {
504 		platform_driver_unregister(&cbas_ec_driver);
505 		return error;
506 	}
507 
508 	return 0;
509 }
510 module_init(hammer_init);
511 
512 static void __exit hammer_exit(void)
513 {
514 	hid_unregister_driver(&hammer_driver);
515 	platform_driver_unregister(&cbas_ec_driver);
516 }
517 module_exit(hammer_exit);
518 
519 MODULE_LICENSE("GPL");
520