[linux-2.6-block.git] / drivers / hid / hid-google-hammer.c

// SPDX-License-Identifier: GPL-2.0+
/*
 *  HID driver for Google Hammer device.
 *
 *  Copyright (c) 2017 Google Inc.
 *  Author: Wei-Ning Huang <wnhuang@google.com>
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/acpi.h>
#include <linux/hid.h>
#include <linux/leds.h>
#include <linux/module.h>
#include <linux/platform_data/cros_ec_commands.h>
#include <linux/platform_data/cros_ec_proto.h>
#include <linux/platform_device.h>
#include <linux/pm_wakeup.h>
#include <asm/unaligned.h>

#include "hid-ids.h"

/*
 * C(hrome)B(ase)A(ttached)S(witch) - switch exported by Chrome EC and reporting
 * state of the "Whiskers" base - attached or detached. Whiskers USB device also
 * reports position of the keyboard - folded or not. Combining base state and
 * position allows us to generate proper "Tablet mode" events.
 */
struct cbas_ec {
	struct device *dev;	/* The platform device (EC) */
	struct input_dev *input;
	bool base_present;
	bool base_folded;
	struct notifier_block notifier;
};

static struct cbas_ec cbas_ec;
static DEFINE_SPINLOCK(cbas_ec_lock);
static DEFINE_MUTEX(cbas_ec_reglock);

static bool cbas_parse_base_state(const void *data)
{
	u32 switches = get_unaligned_le32(data);

	return !!(switches & BIT(EC_MKBP_BASE_ATTACHED));
}

static int cbas_ec_query_base(struct cros_ec_device *ec_dev, bool get_state,
				  bool *state)
{
	struct ec_params_mkbp_info *params;
	struct cros_ec_command *msg;
	int ret;

	msg = kzalloc(sizeof(*msg) + max(sizeof(u32), sizeof(*params)),
		      GFP_KERNEL);
	if (!msg)
		return -ENOMEM;

	msg->command = EC_CMD_MKBP_INFO;
	msg->version = 1;
	msg->outsize = sizeof(*params);
	msg->insize = sizeof(u32);
	params = (struct ec_params_mkbp_info *)msg->data;
	params->info_type = get_state ?
		EC_MKBP_INFO_CURRENT : EC_MKBP_INFO_SUPPORTED;
	params->event_type = EC_MKBP_EVENT_SWITCH;

	ret = cros_ec_cmd_xfer_status(ec_dev, msg);
	if (ret >= 0) {
		if (ret != sizeof(u32)) {
			dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n",
				 ret, sizeof(u32));
			ret = -EPROTO;
		} else {
			*state = cbas_parse_base_state(msg->data);
			ret = 0;
		}
	}

	kfree(msg);

	return ret;
}

static int cbas_ec_notify(struct notifier_block *nb,
			      unsigned long queued_during_suspend,
			      void *_notify)
{
	struct cros_ec_device *ec = _notify;
	unsigned long flags;
	bool base_present;

	if (ec->event_data.event_type == EC_MKBP_EVENT_SWITCH) {
		base_present = cbas_parse_base_state(
					&ec->event_data.data.switches);
		dev_dbg(cbas_ec.dev,
			"%s: base: %d\n", __func__, base_present);

		if (device_may_wakeup(cbas_ec.dev) ||
		    !queued_during_suspend) {

			pm_wakeup_event(cbas_ec.dev, 0);

			spin_lock_irqsave(&cbas_ec_lock, flags);

			/*
			 * While input layer dedupes the events, we do not want
			 * to disrupt the state reported by the base by
			 * overriding it with state reported by the LID. Only
			 * report changes, as we assume that on attach the base
			 * is not folded.
			 */
			if (base_present != cbas_ec.base_present) {
				input_report_switch(cbas_ec.input,
						    SW_TABLET_MODE,
						    !base_present);
				input_sync(cbas_ec.input);
				cbas_ec.base_present = base_present;
			}

			spin_unlock_irqrestore(&cbas_ec_lock, flags);
		}
	}

	return NOTIFY_OK;
}

static __maybe_unused int cbas_ec_resume(struct device *dev)
{
	struct cros_ec_device *ec = dev_get_drvdata(dev->parent);
	bool base_present;
	int error;

	error = cbas_ec_query_base(ec, true, &base_present);
	if (error) {
		dev_warn(dev, "failed to fetch base state on resume: %d\n",
			 error);
	} else {
		spin_lock_irq(&cbas_ec_lock);

		cbas_ec.base_present = base_present;

		/*
		 * Only report if base is disconnected. If base is connected,
		 * it will resend its state on resume, and we'll update it
		 * in hammer_event().
		 */
		if (!cbas_ec.base_present) {
			input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
			input_sync(cbas_ec.input);
		}

		spin_unlock_irq(&cbas_ec_lock);
	}

	return 0;
}

static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume);

static void cbas_ec_set_input(struct input_dev *input)
{
	/* Take the lock so hammer_event() does not race with us here */
	spin_lock_irq(&cbas_ec_lock);
	cbas_ec.input = input;
	spin_unlock_irq(&cbas_ec_lock);
}

static int __cbas_ec_probe(struct platform_device *pdev)
{
	struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
	struct input_dev *input;
	bool base_supported;
	int error;

	error = cbas_ec_query_base(ec, false, &base_supported);
	if (error)
		return error;

	if (!base_supported)
		return -ENXIO;

	input = devm_input_allocate_device(&pdev->dev);
	if (!input)
		return -ENOMEM;

	input->name = "Whiskers Tablet Mode Switch";
	input->id.bustype = BUS_HOST;

	input_set_capability(input, EV_SW, SW_TABLET_MODE);

	error = input_register_device(input);
	if (error) {
		dev_err(&pdev->dev, "cannot register input device: %d\n",
			error);
		return error;
	}

	/* Seed the state */
	error = cbas_ec_query_base(ec, true, &cbas_ec.base_present);
	if (error) {
		dev_err(&pdev->dev, "cannot query base state: %d\n", error);
		return error;
	}

	if (!cbas_ec.base_present)
		cbas_ec.base_folded = false;

	dev_dbg(&pdev->dev, "%s: base: %d, folded: %d\n", __func__,
		cbas_ec.base_present, cbas_ec.base_folded);

	input_report_switch(input, SW_TABLET_MODE,
			    !cbas_ec.base_present || cbas_ec.base_folded);

	cbas_ec_set_input(input);

	cbas_ec.dev = &pdev->dev;
	cbas_ec.notifier.notifier_call = cbas_ec_notify;
	error = blocking_notifier_chain_register(&ec->event_notifier,
						 &cbas_ec.notifier);
	if (error) {
		dev_err(&pdev->dev, "cannot register notifier: %d\n", error);
		cbas_ec_set_input(NULL);
		return error;
	}

	device_init_wakeup(&pdev->dev, true);
	return 0;
}

static int cbas_ec_probe(struct platform_device *pdev)
{
	int retval;

	mutex_lock(&cbas_ec_reglock);

	if (cbas_ec.input) {
		retval = -EBUSY;
		goto out;
	}

	retval = __cbas_ec_probe(pdev);

out:
	mutex_unlock(&cbas_ec_reglock);
	return retval;
}

static int cbas_ec_remove(struct platform_device *pdev)
{
	struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);

	mutex_lock(&cbas_ec_reglock);

	blocking_notifier_chain_unregister(&ec->event_notifier,
					   &cbas_ec.notifier);
	cbas_ec_set_input(NULL);

	mutex_unlock(&cbas_ec_reglock);
	return 0;
}

static const struct acpi_device_id cbas_ec_acpi_ids[] = {
	{ "GOOG000B", 0 },
	{ }
};
MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids);

static struct platform_driver cbas_ec_driver = {
	.probe = cbas_ec_probe,
	.remove = cbas_ec_remove,
	.driver = {
		.name = "cbas_ec",
		.acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids),
		.pm = &cbas_ec_pm_ops,
	},
};

#define MAX_BRIGHTNESS 100

struct hammer_kbd_leds {
	struct led_classdev cdev;
	struct hid_device *hdev;
	u8 buf[2] ____cacheline_aligned;
};

static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev,
		enum led_brightness br)
{
	struct hammer_kbd_leds *led = container_of(cdev,
						   struct hammer_kbd_leds,
						   cdev);
	int ret;

	led->buf[0] = 0;
	led->buf[1] = br;

	/*
	 * Request USB HID device to be in Full On mode, so that sending
	 * hardware output report and hardware raw request won't fail.
	 */
	ret = hid_hw_power(led->hdev, PM_HINT_FULLON);
	if (ret < 0) {
		hid_err(led->hdev, "failed: device not resumed %d\n", ret);
		return ret;
	}

	ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf));
	if (ret == -ENOSYS)
		ret = hid_hw_raw_request(led->hdev, 0, led->buf,
					 sizeof(led->buf),
					 HID_OUTPUT_REPORT,
					 HID_REQ_SET_REPORT);
	if (ret < 0)
		hid_err(led->hdev, "failed to set keyboard backlight: %d\n",
			ret);

	/* Request USB HID device back to Normal Mode. */
	hid_hw_power(led->hdev, PM_HINT_NORMAL);

	return ret;
}

static int hammer_register_leds(struct hid_device *hdev)
{
	struct hammer_kbd_leds *kbd_backlight;
	int error;

	kbd_backlight = kzalloc(sizeof(*kbd_backlight), GFP_KERNEL);
	if (!kbd_backlight)
		return -ENOMEM;

	kbd_backlight->hdev = hdev;
	kbd_backlight->cdev.name = "hammer::kbd_backlight";
	kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS;
	kbd_backlight->cdev.brightness_set_blocking =
		hammer_kbd_brightness_set_blocking;
	kbd_backlight->cdev.flags = LED_HW_PLUGGABLE;

	/* Set backlight to 0% initially. */
	hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0);

	error = led_classdev_register(&hdev->dev, &kbd_backlight->cdev);
	if (error)
		goto err_free_mem;

	hid_set_drvdata(hdev, kbd_backlight);
	return 0;

err_free_mem:
	kfree(kbd_backlight);
	return error;
}

static void hammer_unregister_leds(struct hid_device *hdev)
{
	struct hammer_kbd_leds *kbd_backlight = hid_get_drvdata(hdev);

	if (kbd_backlight) {
		led_classdev_unregister(&kbd_backlight->cdev);
		kfree(kbd_backlight);
	}
}

#define HID_UP_GOOGLEVENDOR	0xffd10000
#define HID_VD_KBD_FOLDED	0x00000019
#define HID_USAGE_KBD_FOLDED	(HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED)

/* HID usage for keyboard backlight (Alphanumeric display brightness) */
#define HID_AD_BRIGHTNESS	0x00140046

static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi,
				struct hid_field *field,
				struct hid_usage *usage,
				unsigned long **bit, int *max)
{
	if (usage->hid == HID_USAGE_KBD_FOLDED) {
		/*
		 * We do not want to have this usage mapped as it will get
		 * mixed in with "base attached" signal and delivered over
		 * separate input device for tablet switch mode.
		 */
		return -1;
	}

	return 0;
}

static void hammer_folded_event(struct hid_device *hdev, bool folded)
{
	unsigned long flags;

	spin_lock_irqsave(&cbas_ec_lock, flags);

	/*
	 * If we are getting events from Whiskers that means that it
	 * is attached to the lid.
	 */
	cbas_ec.base_present = true;
	cbas_ec.base_folded = folded;
	hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__,
		cbas_ec.base_present, cbas_ec.base_folded);

	if (cbas_ec.input) {
		input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded);
		input_sync(cbas_ec.input);
	}

	spin_unlock_irqrestore(&cbas_ec_lock, flags);
}

static int hammer_event(struct hid_device *hid, struct hid_field *field,
			struct hid_usage *usage, __s32 value)
{
	if (usage->hid == HID_USAGE_KBD_FOLDED) {
		hammer_folded_event(hid, value);
		return 1; /* We handled this event */
	}

	return 0;
}

static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type,
			unsigned application, unsigned usage)
{
	struct hid_report_enum *re = &hdev->report_enum[report_type];
	struct hid_report *report;
	int i, j;

	list_for_each_entry(report, &re->report_list, list) {
		if (report->application != application)
			continue;

		for (i = 0; i < report->maxfield; i++) {
			struct hid_field *field = report->field[i];

			for (j = 0; j < field->maxusage; j++)
				if (field->usage[j].hid == usage)
					return true;
		}
	}

	return false;
}

static bool hammer_has_folded_event(struct hid_device *hdev)
{
	return hammer_has_usage(hdev, HID_INPUT_REPORT,
				HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED);
}

static bool hammer_has_backlight_control(struct hid_device *hdev)
{
	return hammer_has_usage(hdev, HID_OUTPUT_REPORT,
				HID_GD_KEYBOARD, HID_AD_BRIGHTNESS);
}

static void hammer_get_folded_state(struct hid_device *hdev)
{
	struct hid_report *report;
	char *buf;
	int len, rlen;
	int a;

	report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];

	if (!report || report->maxfield < 1)
		return;

	len = hid_report_len(report) + 1;

	buf = kmalloc(len, GFP_KERNEL);
	if (!buf)
		return;

	rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);

	if (rlen != len) {
		hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len);
		goto out;
	}

	for (a = 0; a < report->maxfield; a++) {
		struct hid_field *field = report->field[a];

		if (field->usage->hid == HID_USAGE_KBD_FOLDED) {
			u32 value = hid_field_extract(hdev, buf+1,
					field->report_offset, field->report_size);

			hammer_folded_event(hdev, value);
			break;
		}
	}

out:
	kfree(buf);
}

static int hammer_probe(struct hid_device *hdev,
			const struct hid_device_id *id)
{
	int error;

	error = hid_parse(hdev);
	if (error)
		return error;

	error = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (error)
		return error;

	/*
	 * We always want to poll for, and handle tablet mode events from
	 * devices that have folded usage, even when nobody has opened the input
	 * device. This also prevents the hid core from dropping early tablet
	 * mode events from the device.
	 */
	if (hammer_has_folded_event(hdev)) {
		hdev->quirks |= HID_QUIRK_ALWAYS_POLL;
		error = hid_hw_open(hdev);
		if (error)
			return error;

		hammer_get_folded_state(hdev);
	}

	if (hammer_has_backlight_control(hdev)) {
		error = hammer_register_leds(hdev);
		if (error)
			hid_warn(hdev,
				"Failed to register keyboard backlight: %d\n",
				error);
	}

	return 0;
}

static void hammer_remove(struct hid_device *hdev)
{
	unsigned long flags;

	if (hammer_has_folded_event(hdev)) {
		hid_hw_close(hdev);

		/*
		 * If we are disconnecting then most likely Whiskers is
		 * being removed. Even if it is not removed, without proper
		 * keyboard we should not stay in clamshell mode.
		 *
		 * The reason for doing it here and not waiting for signal
		 * from EC, is that on some devices there are high leakage
		 * on Whiskers pins and we do not detect disconnect reliably,
		 * resulting in devices being stuck in clamshell mode.
		 */
		spin_lock_irqsave(&cbas_ec_lock, flags);
		if (cbas_ec.input && cbas_ec.base_present) {
			input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
			input_sync(cbas_ec.input);
		}
		cbas_ec.base_present = false;
		spin_unlock_irqrestore(&cbas_ec_lock, flags);
	}

	hammer_unregister_leds(hdev);

	hid_hw_stop(hdev);
}

static const struct hid_device_id hammer_devices[] = {
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) },
	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },
	{ }
};
MODULE_DEVICE_TABLE(hid, hammer_devices);

static struct hid_driver hammer_driver = {
	.name = "hammer",
	.id_table = hammer_devices,
	.probe = hammer_probe,
	.remove = hammer_remove,
	.input_mapping = hammer_input_mapping,
	.event = hammer_event,
};

static int __init hammer_init(void)
{
	int error;

	error = platform_driver_register(&cbas_ec_driver);
	if (error)
		return error;

	error = hid_register_driver(&hammer_driver);
	if (error) {
		platform_driver_unregister(&cbas_ec_driver);
		return error;
	}

	return 0;
}
module_init(hammer_init);

static void __exit hammer_exit(void)
{
	hid_unregister_driver(&hammer_driver);
	platform_driver_unregister(&cbas_ec_driver);
}
module_exit(hammer_exit);

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