[deliverable/linux.git] / drivers / hid / hid-mosart.c

/*
 *  HID driver for the multitouch panel on the ASUS EeePC T91MT
 *
 *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010 Teemu Tuominen <teemu.tuominen@cybercom.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/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/usb.h>
#include "usbhid/usbhid.h"

MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
MODULE_DESCRIPTION("MosArt dual-touch panel");
MODULE_LICENSE("GPL");

#include "hid-ids.h"

struct mosart_data {
	__u16 x, y;
	__u8 id;
	bool valid;		/* valid finger data, or just placeholder? */
	bool first;		/* is this the first finger in this frame? */
	bool activity_now;	/* at least one active finger in this frame? */
	bool activity;		/* at least one active finger previously? */
};

static int mosart_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	switch (usage->hid & HID_USAGE_PAGE) {

	case HID_UP_GENDESK:
		switch (usage->hid) {
		case HID_GD_X:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_X);
			/* touchscreen emulation */
			input_set_abs_params(hi->input, ABS_X,
						field->logical_minimum,
						field->logical_maximum, 0, 0);
			return 1;
		case HID_GD_Y:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_Y);
			/* touchscreen emulation */
			input_set_abs_params(hi->input, ABS_Y,
						field->logical_minimum,
						field->logical_maximum, 0, 0);
			return 1;
		}
		return 0;

	case HID_UP_DIGITIZER:
		switch (usage->hid) {
		case HID_DG_CONFIDENCE:
		case HID_DG_TIPSWITCH:
		case HID_DG_INPUTMODE:
		case HID_DG_DEVICEINDEX:
		case HID_DG_CONTACTCOUNT:
		case HID_DG_CONTACTMAX:
		case HID_DG_TIPPRESSURE:
		case HID_DG_WIDTH:
		case HID_DG_HEIGHT:
			return -1;
		case HID_DG_INRANGE:
			/* touchscreen emulation */
			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
			return 1;

		case HID_DG_CONTACTID:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TRACKING_ID);
			return 1;

		}
		return 0;

	case 0xff000000:
		/* ignore HID features */
		return -1;

	case HID_UP_BUTTON:
		/* ignore buttons */
		return -1;
	}

	return 0;
}

static int mosart_input_mapped(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	if (usage->type == EV_KEY || usage->type == EV_ABS)
		clear_bit(usage->code, *bit);

	return 0;
}

/*
 * this function is called when a whole finger has been parsed,
 * so that it can decide what to send to the input layer.
 */
static void mosart_filter_event(struct mosart_data *td, struct input_dev *input)
{
	td->first = !td->first; /* touchscreen emulation */

	if (!td->valid) {
		/*
		 * touchscreen emulation: if no finger in this frame is valid
		 * and there previously was finger activity, this is a release
		 */ 
		if (!td->first && !td->activity_now && td->activity) {
			input_event(input, EV_KEY, BTN_TOUCH, 0);
			td->activity = false;
		}
		return;
	}

	input_event(input, EV_ABS, ABS_MT_TRACKING_ID, td->id);
	input_event(input, EV_ABS, ABS_MT_POSITION_X, td->x);
	input_event(input, EV_ABS, ABS_MT_POSITION_Y, td->y);

	input_mt_sync(input);
	td->valid = false;

	/* touchscreen emulation: if first active finger in this frame... */
	if (!td->activity_now) {
		/* if there was no previous activity, emit touch event */
		if (!td->activity) {
			input_event(input, EV_KEY, BTN_TOUCH, 1);
			td->activity = true;
		}
		td->activity_now = true;
		/* and in any case this is our preferred finger */
		input_event(input, EV_ABS, ABS_X, td->x);
		input_event(input, EV_ABS, ABS_Y, td->y);
	}
}


static int mosart_event(struct hid_device *hid, struct hid_field *field,
				struct hid_usage *usage, __s32 value)
{
	struct mosart_data *td = hid_get_drvdata(hid);

	if (hid->claimed & HID_CLAIMED_INPUT) {
		struct input_dev *input = field->hidinput->input;
		switch (usage->hid) {
		case HID_DG_INRANGE:
			td->valid = !!value;
			break;
		case HID_GD_X:
			td->x = value;
			break;
		case HID_GD_Y:
			td->y = value;
			mosart_filter_event(td, input);
			break;
		case HID_DG_CONTACTID:
			td->id = value;
			break;
		case HID_DG_CONTACTCOUNT:
			/* touch emulation: this is the last field in a frame */
			td->first = false;
			td->activity_now = false;
			break;
		case HID_DG_CONFIDENCE:
		case HID_DG_TIPSWITCH:
			/* avoid interference from generic hidinput handling */
			break;

		default:
			/* fallback to the generic hidinput handling */
			return 0;
		}
	}

	/* we have handled the hidinput part, now remains hiddev */
	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
		hid->hiddev_hid_event(hid, field, usage, value);

	return 1;
}

static int mosart_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	int ret;
	struct mosart_data *td;


	td = kmalloc(sizeof(struct mosart_data), GFP_KERNEL);
	if (!td) {
		hid_err(hdev, "cannot allocate MosArt data\n");
		return -ENOMEM;
	}
	td->valid = false;
	td->activity = false;
	td->activity_now = false;
	td->first = false;
	hid_set_drvdata(hdev, td);

	/* currently, it's better to have one evdev device only */
#if 0
	hdev->quirks |= HID_QUIRK_MULTI_INPUT;
#endif

	ret = hid_parse(hdev);
	if (ret == 0)
		ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);

	if (ret == 0) {
		struct hid_report_enum *re = hdev->report_enum
						+ HID_FEATURE_REPORT;
		struct hid_report *r = re->report_id_hash[7];

		r->field[0]->value[0] = 0x02;
		usbhid_submit_report(hdev, r, USB_DIR_OUT);
	} else 
		kfree(td);

	return ret;
}

#ifdef CONFIG_PM
static int mosart_reset_resume(struct hid_device *hdev)
{
	struct hid_report_enum *re = hdev->report_enum
						+ HID_FEATURE_REPORT;
	struct hid_report *r = re->report_id_hash[7];

	r->field[0]->value[0] = 0x02;
	usbhid_submit_report(hdev, r, USB_DIR_OUT);
	return 0;
}
#endif

static void mosart_remove(struct hid_device *hdev)
{
	hid_hw_stop(hdev);
	kfree(hid_get_drvdata(hdev));
	hid_set_drvdata(hdev, NULL);
}

static const struct hid_device_id mosart_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
	{ }
};
MODULE_DEVICE_TABLE(hid, mosart_devices);

static const struct hid_usage_id mosart_grabbed_usages[] = {
	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
};

static struct hid_driver mosart_driver = {
	.name = "mosart",
	.id_table = mosart_devices,
	.probe = mosart_probe,
	.remove = mosart_remove,
	.input_mapping = mosart_input_mapping,
	.input_mapped = mosart_input_mapped,
	.usage_table = mosart_grabbed_usages,
	.event = mosart_event,
#ifdef CONFIG_PM
	.reset_resume = mosart_reset_resume,
#endif
};

static int __init mosart_init(void)
{
	return hid_register_driver(&mosart_driver);
}

static void __exit mosart_exit(void)
{
	hid_unregister_driver(&mosart_driver);
}

module_init(mosart_init);
module_exit(mosart_exit);
Commit	Line	Data
77f720b7 SC	1	/*
	2	* HID driver for the multitouch panel on the ASUS EeePC T91MT
	3	*
	4	* Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
	5	* Copyright (c) 2010 Teemu Tuominen <teemu.tuominen@cybercom.com>
	6	*
	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/device.h>
	17	#include <linux/hid.h>
	18	#include <linux/module.h>
5a0e3ad6	19	#include <linux/slab.h>
77f720b7 SC	20	#include <linux/usb.h>
	21	#include "usbhid/usbhid.h"
	22
77f720b7 SC	23	MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
	24	MODULE_DESCRIPTION("MosArt dual-touch panel");
	25	MODULE_LICENSE("GPL");
	26
	27	#include "hid-ids.h"
	28
	29	struct mosart_data {
	30	__u16 x, y;
	31	__u8 id;
	32	bool valid; /* valid finger data, or just placeholder? */
	33	bool first; /* is this the first finger in this frame? */
	34	bool activity_now; /* at least one active finger in this frame? */
	35	bool activity; /* at least one active finger previously? */
	36	};
	37
	38	static int mosart_input_mapping(struct hid_device hdev, struct hid_input hi,
	39	struct hid_field field, struct hid_usage usage,
	40	unsigned long *bit, int max)
	41	{
	42	switch (usage->hid & HID_USAGE_PAGE) {
	43
	44	case HID_UP_GENDESK:
	45	switch (usage->hid) {
	46	case HID_GD_X:
	47	hid_map_usage(hi, usage, bit, max,
	48	EV_ABS, ABS_MT_POSITION_X);
	49	/* touchscreen emulation */
	50	input_set_abs_params(hi->input, ABS_X,
	51	field->logical_minimum,
	52	field->logical_maximum, 0, 0);
	53	return 1;
	54	case HID_GD_Y:
	55	hid_map_usage(hi, usage, bit, max,
	56	EV_ABS, ABS_MT_POSITION_Y);
	57	/* touchscreen emulation */
	58	input_set_abs_params(hi->input, ABS_Y,
	59	field->logical_minimum,
	60	field->logical_maximum, 0, 0);
	61	return 1;
	62	}
	63	return 0;
	64
	65	case HID_UP_DIGITIZER:
	66	switch (usage->hid) {
	67	case HID_DG_CONFIDENCE:
	68	case HID_DG_TIPSWITCH:
	69	case HID_DG_INPUTMODE:
	70	case HID_DG_DEVICEINDEX:
	71	case HID_DG_CONTACTCOUNT:
	72	case HID_DG_CONTACTMAX:
	73	case HID_DG_TIPPRESSURE:
	74	case HID_DG_WIDTH:
	75	case HID_DG_HEIGHT:
	76	return -1;
	77	case HID_DG_INRANGE:
	78	/* touchscreen emulation */
	79	hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
	80	return 1;
	81
	82	case HID_DG_CONTACTID:
	83	hid_map_usage(hi, usage, bit, max,
	84	EV_ABS, ABS_MT_TRACKING_ID);
	85	return 1;
	86
87	}
88	return 0;
89
90	case 0xff000000:
91	/* ignore HID features */
92	return -1;
ad6d4267 BT	93
	94	case HID_UP_BUTTON:
	95	/* ignore buttons */
	96	return -1;
77f720b7 SC	97	}
	98
	99	return 0;
	100	}
	101
	102	static int mosart_input_mapped(struct hid_device hdev, struct hid_input hi,
	103	struct hid_field field, struct hid_usage usage,
	104	unsigned long *bit, int max)
	105	{
	106	if (usage->type == EV_KEY \|\| usage->type == EV_ABS)
	107	clear_bit(usage->code, *bit);
	108
	109	return 0;
	110	}
	111
	112	/*
	113	* this function is called when a whole finger has been parsed,
	114	* so that it can decide what to send to the input layer.
	115	*/
	116	static void mosart_filter_event(struct mosart_data td, struct input_dev input)
	117	{
	118	td->first = !td->first; /* touchscreen emulation */
	119
	120	if (!td->valid) {
	121	/*
	122	* touchscreen emulation: if no finger in this frame is valid
	123	* and there previously was finger activity, this is a release
	124	*/
	125	if (!td->first && !td->activity_now && td->activity) {
	126	input_event(input, EV_KEY, BTN_TOUCH, 0);
	127	td->activity = false;
	128	}
	129	return;
	130	}
	131
	132	input_event(input, EV_ABS, ABS_MT_TRACKING_ID, td->id);
	133	input_event(input, EV_ABS, ABS_MT_POSITION_X, td->x);
	134	input_event(input, EV_ABS, ABS_MT_POSITION_Y, td->y);
	135
	136	input_mt_sync(input);
	137	td->valid = false;
	138
	139	/* touchscreen emulation: if first active finger in this frame... */
	140	if (!td->activity_now) {
	141	/* if there was no previous activity, emit touch event */
	142	if (!td->activity) {
	143	input_event(input, EV_KEY, BTN_TOUCH, 1);
	144	td->activity = true;
	145	}
	146	td->activity_now = true;
	147	/* and in any case this is our preferred finger */
	148	input_event(input, EV_ABS, ABS_X, td->x);
	149	input_event(input, EV_ABS, ABS_Y, td->y);
	150	}
	151	}
	152
	153
	154	static int mosart_event(struct hid_device hid, struct hid_field field,
	155	struct hid_usage *usage, __s32 value)
	156	{
	157	struct mosart_data *td = hid_get_drvdata(hid);
	158
	159	if (hid->claimed & HID_CLAIMED_INPUT) {
	160	struct input_dev *input = field->hidinput->input;
161	switch (usage->hid) {
162	case HID_DG_INRANGE:
163	td->valid = !!value;
164	break;
165	case HID_GD_X:
166	td->x = value;
167	break;
168	case HID_GD_Y:
169	td->y = value;
170	mosart_filter_event(td, input);
171	break;
172	case HID_DG_CONTACTID:
173	td->id = value;
174	break;
175	case HID_DG_CONTACTCOUNT:
176	/* touch emulation: this is the last field in a frame */
177	td->first = false;
178	td->activity_now = false;
179	break;
180	case HID_DG_CONFIDENCE:
181	case HID_DG_TIPSWITCH:
182	/* avoid interference from generic hidinput handling */
183	break;
184
185	default:
186	/* fallback to the generic hidinput handling */
187	return 0;
188	}
189	}
190
191	/* we have handled the hidinput part, now remains hiddev */
192	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
193	hid->hiddev_hid_event(hid, field, usage, value);
194
195	return 1;
196	}
197
198	static int mosart_probe(struct hid_device hdev, const struct hid_device_id id)
199	{
200	int ret;
201	struct mosart_data *td;
202
203
204	td = kmalloc(sizeof(struct mosart_data), GFP_KERNEL);
205	if (!td) {
4291ee30	206	hid_err(hdev, "cannot allocate MosArt data\n");
77f720b7 SC	207	return -ENOMEM;
	208	}
	209	td->valid = false;
	210	td->activity = false;
	211	td->activity_now = false;
	212	td->first = false;
	213	hid_set_drvdata(hdev, td);
	214
	215	/* currently, it's better to have one evdev device only */
	216	#if 0
	217	hdev->quirks \|= HID_QUIRK_MULTI_INPUT;
	218	#endif
	219
	220	ret = hid_parse(hdev);
	221	if (ret == 0)
	222	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	223
	224	if (ret == 0) {
	225	struct hid_report_enum *re = hdev->report_enum
	226	+ HID_FEATURE_REPORT;
	227	struct hid_report *r = re->report_id_hash[7];
	228
	229	r->field[0]->value[0] = 0x02;
	230	usbhid_submit_report(hdev, r, USB_DIR_OUT);
	231	} else
	232	kfree(td);
	233
	234	return ret;
	235	}
	236
c25bcd34 BT	237	#ifdef CONFIG_PM
	238	static int mosart_reset_resume(struct hid_device *hdev)
	239	{
	240	struct hid_report_enum *re = hdev->report_enum
	241	+ HID_FEATURE_REPORT;
	242	struct hid_report *r = re->report_id_hash[7];
	243
	244	r->field[0]->value[0] = 0x02;
	245	usbhid_submit_report(hdev, r, USB_DIR_OUT);
	246	return 0;
	247	}
	248	#endif
	249
77f720b7 SC	250	static void mosart_remove(struct hid_device *hdev)
	251	{
	252	hid_hw_stop(hdev);
	253	kfree(hid_get_drvdata(hdev));
	254	hid_set_drvdata(hdev, NULL);
	255	}
	256
	257	static const struct hid_device_id mosart_devices[] = {
	258	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
cec15a0e	259	{ HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
77f720b7 SC	260	{ }
	261	};
	262	MODULE_DEVICE_TABLE(hid, mosart_devices);
	263
	264	static const struct hid_usage_id mosart_grabbed_usages[] = {
	265	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
	266	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
	267	};
	268
	269	static struct hid_driver mosart_driver = {
	270	.name = "mosart",
	271	.id_table = mosart_devices,
	272	.probe = mosart_probe,
	273	.remove = mosart_remove,
	274	.input_mapping = mosart_input_mapping,
	275	.input_mapped = mosart_input_mapped,
	276	.usage_table = mosart_grabbed_usages,
	277	.event = mosart_event,
c25bcd34 BT	278	#ifdef CONFIG_PM
	279	.reset_resume = mosart_reset_resume,
	280	#endif
77f720b7 SC	281	};
	282
	283	static int __init mosart_init(void)
	284	{
	285	return hid_register_driver(&mosart_driver);
	286	}
	287
	288	static void __exit mosart_exit(void)
	289	{
	290	hid_unregister_driver(&mosart_driver);
	291	}
	292
	293	module_init(mosart_init);
	294	module_exit(mosart_exit);
	295