[mirror_ubuntu-artful-kernel.git] / drivers / hid / hid-elo.c

/*
 * HID driver for ELO usb touchscreen 4000/4500
 *
 * Copyright (c) 2013 Jiri Slaby
 *
 * Data parsing taken from elousb driver by Vojtech Pavlik.
 *
 * This driver is licensed under the terms of GPLv2.
 */

#include <linux/hid.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/workqueue.h>

#include "hid-ids.h"

#define ELO_PERIODIC_READ_INTERVAL	HZ
#define ELO_SMARTSET_CMD_TIMEOUT	2000 /* msec */

/* Elo SmartSet commands */
#define ELO_FLUSH_SMARTSET_RESPONSES	0x02 /* Flush all pending smartset responses */
#define ELO_SEND_SMARTSET_COMMAND	0x05 /* Send a smartset command */
#define ELO_GET_SMARTSET_RESPONSE	0x06 /* Get a smartset response */
#define ELO_DIAG			0x64 /* Diagnostics command */
#define ELO_SMARTSET_PACKET_SIZE	8

struct elo_priv {
	struct usb_device *usbdev;
	struct delayed_work work;
	unsigned char buffer[ELO_SMARTSET_PACKET_SIZE];
};

static struct workqueue_struct *wq;
static bool use_fw_quirk = true;
module_param(use_fw_quirk, bool, S_IRUGO);
MODULE_PARM_DESC(use_fw_quirk, "Do periodic pokes for broken M firmwares (default = true)");

static void elo_input_configured(struct hid_device *hdev,
		struct hid_input *hidinput)
{
	struct input_dev *input = hidinput->input;

	set_bit(BTN_TOUCH, input->keybit);
	set_bit(ABS_PRESSURE, input->absbit);
	input_set_abs_params(input, ABS_PRESSURE, 0, 256, 0, 0);
}

static void elo_process_data(struct input_dev *input, const u8 *data, int size)
{
	int press;

	input_report_abs(input, ABS_X, (data[3] << 8) | data[2]);
	input_report_abs(input, ABS_Y, (data[5] << 8) | data[4]);

	press = 0;
	if (data[1] & 0x80)
		press = (data[7] << 8) | data[6];
	input_report_abs(input, ABS_PRESSURE, press);

	if (data[1] & 0x03) {
		input_report_key(input, BTN_TOUCH, 1);
		input_sync(input);
	}

	if (data[1] & 0x04)
		input_report_key(input, BTN_TOUCH, 0);

	input_sync(input);
}

static int elo_raw_event(struct hid_device *hdev, struct hid_report *report,
	 u8 *data, int size)
{
	struct hid_input *hidinput;

	if (!(hdev->claimed & HID_CLAIMED_INPUT) || list_empty(&hdev->inputs))
		return 0;

	hidinput = list_first_entry(&hdev->inputs, struct hid_input, list);

	switch (report->id) {
	case 0:
		if (data[0] == 'T') {	/* Mandatory ELO packet marker */
			elo_process_data(hidinput->input, data, size);
			return 1;
		}
		break;
	default:	/* unknown report */
		/* Unknown report type; pass upstream */
		hid_info(hdev, "unknown report type %d\n", report->id);
		break;
	}

	return 0;
}

static int elo_smartset_send_get(struct usb_device *dev, u8 command,
		void *data)
{
	unsigned int pipe;
	u8 dir;

	if (command == ELO_SEND_SMARTSET_COMMAND) {
		pipe = usb_sndctrlpipe(dev, 0);
		dir = USB_DIR_OUT;
	} else if (command == ELO_GET_SMARTSET_RESPONSE) {
		pipe = usb_rcvctrlpipe(dev, 0);
		dir = USB_DIR_IN;
	} else
		return -EINVAL;

	return usb_control_msg(dev, pipe, command,
			dir | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			0, 0, data, ELO_SMARTSET_PACKET_SIZE,
			ELO_SMARTSET_CMD_TIMEOUT);
}

static int elo_flush_smartset_responses(struct usb_device *dev)
{
	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
			ELO_FLUSH_SMARTSET_RESPONSES,
			USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
			0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
}

static void elo_work(struct work_struct *work)
{
	struct elo_priv *priv = container_of(work, struct elo_priv, work.work);
	struct usb_device *dev = priv->usbdev;
	unsigned char *buffer = priv->buffer;
	int ret;

	ret = elo_flush_smartset_responses(dev);
	if (ret < 0) {
		dev_err(&dev->dev, "initial FLUSH_SMARTSET_RESPONSES failed, error %d\n",
				ret);
		goto fail;
	}

	/* send Diagnostics command */
	*buffer = ELO_DIAG;
	ret = elo_smartset_send_get(dev, ELO_SEND_SMARTSET_COMMAND, buffer);
	if (ret < 0) {
		dev_err(&dev->dev, "send Diagnostics Command failed, error %d\n",
				ret);
		goto fail;
	}

	/* get the result */
	ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE, buffer);
	if (ret < 0) {
		dev_err(&dev->dev, "get Diagnostics Command response failed, error %d\n",
				ret);
		goto fail;
	}

	/* read the ack */
	if (*buffer != 'A') {
		ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE,
				buffer);
		if (ret < 0) {
			dev_err(&dev->dev, "get acknowledge response failed, error %d\n",
					ret);
			goto fail;
		}
	}

fail:
	ret = elo_flush_smartset_responses(dev);
	if (ret < 0)
		dev_err(&dev->dev, "final FLUSH_SMARTSET_RESPONSES failed, error %d\n",
				ret);
	queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
}

/*
 * Not all Elo devices need the periodic HID descriptor reads.
 * Only firmware version M needs this.
 */
static bool elo_broken_firmware(struct usb_device *dev)
{
	return use_fw_quirk && le16_to_cpu(dev->descriptor.bcdDevice) == 0x10d;
}

static int elo_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	struct elo_priv *priv;
	int ret;

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

	INIT_DELAYED_WORK(&priv->work, elo_work);
	priv->usbdev = interface_to_usbdev(to_usb_interface(hdev->dev.parent));

	hid_set_drvdata(hdev, priv);

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "parse failed\n");
		goto err_free;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret) {
		hid_err(hdev, "hw start failed\n");
		goto err_free;
	}

	if (elo_broken_firmware(priv->usbdev)) {
		hid_info(hdev, "broken firmware found, installing workaround\n");
		queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
	}

	return 0;
err_free:
	kfree(priv);
	return ret;
}

static void elo_remove(struct hid_device *hdev)
{
	struct elo_priv *priv = hid_get_drvdata(hdev);

	hid_hw_stop(hdev);
	flush_workqueue(wq);
	kfree(priv);
}

static const struct hid_device_id elo_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009), },
	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030), },
	{ }
};
MODULE_DEVICE_TABLE(hid, elo_devices);

static struct hid_driver elo_driver = {
	.name = "elo",
	.id_table = elo_devices,
	.probe = elo_probe,
	.remove = elo_remove,
	.raw_event = elo_raw_event,
	.input_configured = elo_input_configured,
};

static int __init elo_driver_init(void)
{
	int ret;

	wq = create_singlethread_workqueue("elousb");
	if (!wq)
		return -ENOMEM;

	ret = hid_register_driver(&elo_driver);
	if (ret)
		destroy_workqueue(wq);

	return ret;
}
module_init(elo_driver_init);

static void __exit elo_driver_exit(void)
{
	hid_unregister_driver(&elo_driver);
	destroy_workqueue(wq);
}
module_exit(elo_driver_exit);

MODULE_AUTHOR("Jiri Slaby <jslaby@suse.cz>");
MODULE_LICENSE("GPL");
Commit	Line	Data
d23efc19 JS	1	/*
	2	* HID driver for ELO usb touchscreen 4000/4500
	3	*
	4	* Copyright (c) 2013 Jiri Slaby
	5	*
	6	* Data parsing taken from elousb driver by Vojtech Pavlik.
	7	*
	8	* This driver is licensed under the terms of GPLv2.
	9	*/
	10
	11	#include <linux/hid.h>
	12	#include <linux/input.h>
	13	#include <linux/module.h>
d8e5aec8 JS	14	#include <linux/usb.h>
d8e5aec8 JS	15	#include <linux/workqueue.h>
d23efc19 JS	16
	17	#include "hid-ids.h"
	18
d8e5aec8 JS	19	#define ELO_PERIODIC_READ_INTERVAL HZ
	20	#define ELO_SMARTSET_CMD_TIMEOUT 2000 /* msec */
	21
	22	/* Elo SmartSet commands */
	23	#define ELO_FLUSH_SMARTSET_RESPONSES 0x02 /* Flush all pending smartset responses */
	24	#define ELO_SEND_SMARTSET_COMMAND 0x05 /* Send a smartset command */
	25	#define ELO_GET_SMARTSET_RESPONSE 0x06 /* Get a smartset response */
	26	#define ELO_DIAG 0x64 /* Diagnostics command */
	27	#define ELO_SMARTSET_PACKET_SIZE 8
	28
	29	struct elo_priv {
	30	struct usb_device *usbdev;
	31	struct delayed_work work;
	32	unsigned char buffer[ELO_SMARTSET_PACKET_SIZE];
	33	};
	34
	35	static struct workqueue_struct *wq;
	36	static bool use_fw_quirk = true;
	37	module_param(use_fw_quirk, bool, S_IRUGO);
	38	MODULE_PARM_DESC(use_fw_quirk, "Do periodic pokes for broken M firmwares (default = true)");
	39
d23efc19 JS	40	static void elo_input_configured(struct hid_device *hdev,
	41	struct hid_input *hidinput)
	42	{
	43	struct input_dev *input = hidinput->input;
	44
	45	set_bit(BTN_TOUCH, input->keybit);
	46	set_bit(ABS_PRESSURE, input->absbit);
	47	input_set_abs_params(input, ABS_PRESSURE, 0, 256, 0, 0);
	48	}
	49
	50	static void elo_process_data(struct input_dev input, const u8 data, int size)
	51	{
	52	int press;
	53
	54	input_report_abs(input, ABS_X, (data[3] << 8) \| data[2]);
	55	input_report_abs(input, ABS_Y, (data[5] << 8) \| data[4]);
	56
	57	press = 0;
	58	if (data[1] & 0x80)
	59	press = (data[7] << 8) \| data[6];
	60	input_report_abs(input, ABS_PRESSURE, press);
	61
	62	if (data[1] & 0x03) {
	63	input_report_key(input, BTN_TOUCH, 1);
	64	input_sync(input);
	65	}
	66
	67	if (data[1] & 0x04)
	68	input_report_key(input, BTN_TOUCH, 0);
	69
	70	input_sync(input);
	71	}
	72
	73	static int elo_raw_event(struct hid_device hdev, struct hid_report report,
	74	u8 *data, int size)
	75	{
	76	struct hid_input *hidinput;
	77
	78	if (!(hdev->claimed & HID_CLAIMED_INPUT) \|\| list_empty(&hdev->inputs))
	79	return 0;
	80
	81	hidinput = list_first_entry(&hdev->inputs, struct hid_input, list);
	82
	83	switch (report->id) {
	84	case 0:
	85	if (data[0] == 'T') { /* Mandatory ELO packet marker */
	86	elo_process_data(hidinput->input, data, size);
	87	return 1;
	88	}
	89	break;
	90	default: /* unknown report */
	91	/* Unknown report type; pass upstream */
	92	hid_info(hdev, "unknown report type %d\n", report->id);
	93	break;
	94	}
	95
	96	return 0;
	97	}
	98
d8e5aec8 JS	99	static int elo_smartset_send_get(struct usb_device *dev, u8 command,
	100	void *data)
	101	{
	102	unsigned int pipe;
	103	u8 dir;
	104
	105	if (command == ELO_SEND_SMARTSET_COMMAND) {
	106	pipe = usb_sndctrlpipe(dev, 0);
	107	dir = USB_DIR_OUT;
	108	} else if (command == ELO_GET_SMARTSET_RESPONSE) {
	109	pipe = usb_rcvctrlpipe(dev, 0);
	110	dir = USB_DIR_IN;
	111	} else
	112	return -EINVAL;
	113
	114	return usb_control_msg(dev, pipe, command,
	115	dir \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	116	0, 0, data, ELO_SMARTSET_PACKET_SIZE,
	117	ELO_SMARTSET_CMD_TIMEOUT);
	118	}
	119
	120	static int elo_flush_smartset_responses(struct usb_device *dev)
	121	{
	122	return usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
	123	ELO_FLUSH_SMARTSET_RESPONSES,
	124	USB_DIR_OUT \| USB_TYPE_VENDOR \| USB_RECIP_DEVICE,
	125	0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
	126	}
	127
	128	static void elo_work(struct work_struct *work)
	129	{
	130	struct elo_priv *priv = container_of(work, struct elo_priv, work.work);
	131	struct usb_device *dev = priv->usbdev;
	132	unsigned char *buffer = priv->buffer;
	133	int ret;
	134
	135	ret = elo_flush_smartset_responses(dev);
	136	if (ret < 0) {
	137	dev_err(&dev->dev, "initial FLUSH_SMARTSET_RESPONSES failed, error %d\n",
	138	ret);
	139	goto fail;
	140	}
	141
	142	/* send Diagnostics command */
	143	*buffer = ELO_DIAG;
	144	ret = elo_smartset_send_get(dev, ELO_SEND_SMARTSET_COMMAND, buffer);
	145	if (ret < 0) {
	146	dev_err(&dev->dev, "send Diagnostics Command failed, error %d\n",
	147	ret);
	148	goto fail;
	149	}
	150
	151	/* get the result */
	152	ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE, buffer);
	153	if (ret < 0) {
	154	dev_err(&dev->dev, "get Diagnostics Command response failed, error %d\n",
	155	ret);
	156	goto fail;
	157	}
	158
	159	/* read the ack */
	160	if (*buffer != 'A') {
	161	ret = elo_smartset_send_get(dev, ELO_GET_SMARTSET_RESPONSE,
	162	buffer);
163	if (ret < 0) {
164	dev_err(&dev->dev, "get acknowledge response failed, error %d\n",
165	ret);
166	goto fail;
167	}
168	}
169
170	fail:
171	ret = elo_flush_smartset_responses(dev);
172	if (ret < 0)
173	dev_err(&dev->dev, "final FLUSH_SMARTSET_RESPONSES failed, error %d\n",
174	ret);
175	queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
176	}
177
178	/*
179	* Not all Elo devices need the periodic HID descriptor reads.
180	* Only firmware version M needs this.
181	*/
182	static bool elo_broken_firmware(struct usb_device *dev)
183	{
184	return use_fw_quirk && le16_to_cpu(dev->descriptor.bcdDevice) == 0x10d;
185	}
186
d23efc19 JS	187	static int elo_probe(struct hid_device hdev, const struct hid_device_id id)
d23efc19 JS	188	{
d8e5aec8	189	struct elo_priv *priv;
d23efc19 JS	190	int ret;
d23efc19 JS	191
d8e5aec8 JS	192	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	193	if (!priv)
	194	return -ENOMEM;
	195
	196	INIT_DELAYED_WORK(&priv->work, elo_work);
	197	priv->usbdev = interface_to_usbdev(to_usb_interface(hdev->dev.parent));
	198
	199	hid_set_drvdata(hdev, priv);
	200
d23efc19 JS	201	ret = hid_parse(hdev);
	202	if (ret) {
	203	hid_err(hdev, "parse failed\n");
	204	goto err_free;
	205	}
	206
	207	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	208	if (ret) {
	209	hid_err(hdev, "hw start failed\n");
	210	goto err_free;
	211	}
	212
d8e5aec8 JS	213	if (elo_broken_firmware(priv->usbdev)) {
	214	hid_info(hdev, "broken firmware found, installing workaround\n");
	215	queue_delayed_work(wq, &priv->work, ELO_PERIODIC_READ_INTERVAL);
	216	}
	217
d23efc19 JS	218	return 0;
d23efc19 JS	219	err_free:
d8e5aec8	220	kfree(priv);
d23efc19 JS	221	return ret;
	222	}
	223
	224	static void elo_remove(struct hid_device *hdev)
	225	{
d8e5aec8 JS	226	struct elo_priv *priv = hid_get_drvdata(hdev);
d8e5aec8 JS	227
d23efc19	228	hid_hw_stop(hdev);
d8e5aec8 JS	229	flush_workqueue(wq);
d8e5aec8 JS	230	kfree(priv);
d23efc19 JS	231	}
	232
	233	static const struct hid_device_id elo_devices[] = {
	234	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0009), },
	235	{ HID_USB_DEVICE(USB_VENDOR_ID_ELO, 0x0030), },
	236	{ }
	237	};
	238	MODULE_DEVICE_TABLE(hid, elo_devices);
	239
	240	static struct hid_driver elo_driver = {
	241	.name = "elo",
	242	.id_table = elo_devices,
	243	.probe = elo_probe,
	244	.remove = elo_remove,
	245	.raw_event = elo_raw_event,
	246	.input_configured = elo_input_configured,
	247	};
	248
	249	static int __init elo_driver_init(void)
	250	{
d8e5aec8 JS	251	int ret;
	252
	253	wq = create_singlethread_workqueue("elousb");
	254	if (!wq)
	255	return -ENOMEM;
	256
	257	ret = hid_register_driver(&elo_driver);
	258	if (ret)
	259	destroy_workqueue(wq);
	260
	261	return ret;
d23efc19 JS	262	}
	263	module_init(elo_driver_init);
	264
	265	static void __exit elo_driver_exit(void)
	266	{
	267	hid_unregister_driver(&elo_driver);
d8e5aec8	268	destroy_workqueue(wq);
d23efc19 JS	269	}
	270	module_exit(elo_driver_exit);
	271
	272	MODULE_AUTHOR("Jiri Slaby <jslaby@suse.cz>");
	273	MODULE_LICENSE("GPL");