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

/*
 *  HID driver for multitouch panels
 *
 *  Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
 *  Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
 *
 *  This code is partly based on hid-egalax.c:
 *
 *  Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
 *  Copyright (c) 2010 Canonical, Ltd.
 *
 *  This code is partly based on hid-3m-pct.c:
 *
 *  Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
 *  Copyright (c) 2010      Henrik Rydberg <rydberg@euromail.se>
 *  Copyright (c) 2010      Canonical, Ltd.
 *
 */

/*
 * 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 <linux/input/mt.h>
#include "usbhid/usbhid.h"


MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
MODULE_DESCRIPTION("HID multitouch panels");
MODULE_LICENSE("GPL");

#include "hid-ids.h"

/* quirks to control the device */
#define MT_QUIRK_NOT_SEEN_MEANS_UP	(1 << 0)
#define MT_QUIRK_SLOT_IS_CONTACTID	(1 << 1)
#define MT_QUIRK_CYPRESS		(1 << 2)
#define MT_QUIRK_SLOT_IS_CONTACTNUMBER	(1 << 3)
#define MT_QUIRK_VALID_IS_INRANGE	(1 << 4)
#define MT_QUIRK_VALID_IS_CONFIDENCE	(1 << 5)
#define MT_QUIRK_EGALAX_XYZ_FIXUP	(1 << 6)

struct mt_slot {
	__s32 x, y, p, w, h;
	__s32 contactid;	/* the device ContactID assigned to this slot */
	bool touch_state;	/* is the touch valid? */
	bool seen_in_this_frame;/* has this slot been updated */
};

struct mt_device {
	struct mt_slot curdata;	/* placeholder of incoming data */
	struct mt_class *mtclass;	/* our mt device class */
	unsigned last_field_index;	/* last field index of the report */
	unsigned last_slot_field;	/* the last field of a slot */
	__s8 inputmode;		/* InputMode HID feature, -1 if non-existent */
	__u8 num_received;	/* how many contacts we received */
	__u8 num_expected;	/* expected last contact index */
	__u8 maxcontacts;
	bool curvalid;		/* is the current contact valid? */
	struct mt_slot *slots;
};

struct mt_class {
	__s32 name;	/* MT_CLS */
	__s32 quirks;
	__s32 sn_move;	/* Signal/noise ratio for move events */
	__s32 sn_width;	/* Signal/noise ratio for width events */
	__s32 sn_height;	/* Signal/noise ratio for height events */
	__s32 sn_pressure;	/* Signal/noise ratio for pressure events */
	__u8 maxcontacts;
};

/* classes of device behavior */
#define MT_CLS_DEFAULT				1
#define MT_CLS_DUAL_INRANGE_CONTACTID		2
#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER	3
#define MT_CLS_CYPRESS				4
#define MT_CLS_EGALAX				5
#define MT_CLS_STANTUM				6
#define MT_CLS_3M				7

#define MT_DEFAULT_MAXCONTACT	10

/*
 * these device-dependent functions determine what slot corresponds
 * to a valid contact that was just read.
 */

static int cypress_compute_slot(struct mt_device *td)
{
	if (td->curdata.contactid != 0 || td->num_received == 0)
		return td->curdata.contactid;
	else
		return -1;
}

static int find_slot_from_contactid(struct mt_device *td)
{
	int i;
	for (i = 0; i < td->maxcontacts; ++i) {
		if (td->slots[i].contactid == td->curdata.contactid &&
			td->slots[i].touch_state)
			return i;
	}
	for (i = 0; i < td->maxcontacts; ++i) {
		if (!td->slots[i].seen_in_this_frame &&
			!td->slots[i].touch_state)
			return i;
	}
	/* should not occurs. If this happens that means
	 * that the device sent more touches that it says
	 * in the report descriptor. It is ignored then. */
	return -1;
}

struct mt_class mt_classes[] = {
	{ .name = MT_CLS_DEFAULT,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.maxcontacts = 2 },
	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		.quirks = MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_SLOT_IS_CONTACTNUMBER,
		.maxcontacts = 2 },
	{ .name = MT_CLS_CYPRESS,
		.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
			MT_QUIRK_CYPRESS,
		.maxcontacts = 10 },

	{ .name = MT_CLS_EGALAX,
		.quirks =  MT_QUIRK_SLOT_IS_CONTACTID |
			MT_QUIRK_VALID_IS_INRANGE |
			MT_QUIRK_EGALAX_XYZ_FIXUP,
		.maxcontacts = 2,
		.sn_move = 4096,
		.sn_pressure = 32,
	},
	{ .name = MT_CLS_STANTUM,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
	{ .name = MT_CLS_3M,
		.quirks = MT_QUIRK_VALID_IS_CONFIDENCE |
			MT_QUIRK_SLOT_IS_CONTACTID,
		.sn_move = 2048,
		.sn_width = 128,
		.sn_height = 128 },

	{ }
};

static void mt_feature_mapping(struct hid_device *hdev,
		struct hid_field *field, struct hid_usage *usage)
{
	struct mt_device *td = hid_get_drvdata(hdev);

	switch (usage->hid) {
	case HID_DG_INPUTMODE:
		td->inputmode = field->report->id;
		break;
	case HID_DG_CONTACTMAX:
		td->maxcontacts = field->value[0];
		if (td->mtclass->maxcontacts)
			/* check if the maxcontacts is given by the class */
			td->maxcontacts = td->mtclass->maxcontacts;

		break;
	}
}

static void set_abs(struct input_dev *input, unsigned int code,
		struct hid_field *field, int snratio)
{
	int fmin = field->logical_minimum;
	int fmax = field->logical_maximum;
	int fuzz = snratio ? (fmax - fmin) / snratio : 0;
	input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
}

static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct mt_device *td = hid_get_drvdata(hdev);
	struct mt_class *cls = td->mtclass;
	__s32 quirks = cls->quirks;

	switch (usage->hid & HID_USAGE_PAGE) {

	case HID_UP_GENDESK:
		switch (usage->hid) {
		case HID_GD_X:
			if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
				field->logical_maximum = 32760;
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_X);
			set_abs(hi->input, ABS_MT_POSITION_X, field,
				cls->sn_move);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_X, field, cls->sn_move);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_GD_Y:
			if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
				field->logical_maximum = 32760;
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_POSITION_Y);
			set_abs(hi->input, ABS_MT_POSITION_Y, field,
				cls->sn_move);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_Y, field, cls->sn_move);
			td->last_slot_field = usage->hid;
			return 1;
		}
		return 0;

	case HID_UP_DIGITIZER:
		switch (usage->hid) {
		case HID_DG_INRANGE:
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_CONFIDENCE:
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_TIPSWITCH:
			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
			input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_CONTACTID:
			input_mt_init_slots(hi->input, td->maxcontacts);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_WIDTH:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MAJOR);
			set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
				cls->sn_width);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_HEIGHT:
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_TOUCH_MINOR);
			set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
				cls->sn_height);
			input_set_abs_params(hi->input,
					ABS_MT_ORIENTATION, 0, 1, 0, 0);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_TIPPRESSURE:
			if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
				field->logical_minimum = 0;
			hid_map_usage(hi, usage, bit, max,
					EV_ABS, ABS_MT_PRESSURE);
			set_abs(hi->input, ABS_MT_PRESSURE, field,
				cls->sn_pressure);
			/* touchscreen emulation */
			set_abs(hi->input, ABS_PRESSURE, field,
				cls->sn_pressure);
			td->last_slot_field = usage->hid;
			return 1;
		case HID_DG_CONTACTCOUNT:
			td->last_field_index = field->report->maxfield - 1;
			return 1;
		case HID_DG_CONTACTMAX:
			/* we don't set td->last_slot_field as contactcount and
			 * contact max are global to the report */
			return -1;
		}
		/* let hid-input decide for the others */
		return 0;

	case 0xff000000:
		/* we do not want to map these: no input-oriented meaning */
		return -1;
	}

	return 0;
}

static int mt_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)
		set_bit(usage->type, hi->input->evbit);

	return -1;
}

static int mt_compute_slot(struct mt_device *td)
{
	__s32 quirks = td->mtclass->quirks;

	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
		return td->curdata.contactid;

	if (quirks & MT_QUIRK_CYPRESS)
		return cypress_compute_slot(td);

	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
		return td->num_received;

	return find_slot_from_contactid(td);
}

/*
 * this function is called when a whole contact has been processed,
 * so that it can assign it to a slot and store the data there
 */
static void mt_complete_slot(struct mt_device *td)
{
	td->curdata.seen_in_this_frame = true;
	if (td->curvalid) {
		int slotnum = mt_compute_slot(td);

		if (slotnum >= 0 && slotnum < td->maxcontacts)
			td->slots[slotnum] = td->curdata;
	}
	td->num_received++;
}


/*
 * this function is called when a whole packet has been received and processed,
 * so that it can decide what to send to the input layer.
 */
static void mt_emit_event(struct mt_device *td, struct input_dev *input)
{
	int i;

	for (i = 0; i < td->maxcontacts; ++i) {
		struct mt_slot *s = &(td->slots[i]);
		if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
			!s->seen_in_this_frame) {
			s->touch_state = false;
		}

		input_mt_slot(input, i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER,
			s->touch_state);
		if (s->touch_state) {
			/* this finger is on the screen */
			int wide = (s->w > s->h);
			/* divided by two to match visual scale of touch */
			int major = max(s->w, s->h) >> 1;
			int minor = min(s->w, s->h) >> 1;

			input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
			input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
			input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
			input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
			input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
			input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
		}
		s->seen_in_this_frame = false;

	}

	input_mt_report_pointer_emulation(input, true);
	input_sync(input);
	td->num_received = 0;
}


static int mt_event(struct hid_device *hid, struct hid_field *field,
				struct hid_usage *usage, __s32 value)
{
	struct mt_device *td = hid_get_drvdata(hid);
	__s32 quirks = td->mtclass->quirks;

	if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
		switch (usage->hid) {
		case HID_DG_INRANGE:
			if (quirks & MT_QUIRK_VALID_IS_INRANGE)
				td->curvalid = value;
			break;
		case HID_DG_TIPSWITCH:
			if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
				td->curvalid = value;
			td->curdata.touch_state = value;
			break;
		case HID_DG_CONFIDENCE:
			if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
				td->curvalid = value;
			break;
		case HID_DG_CONTACTID:
			td->curdata.contactid = value;
			break;
		case HID_DG_TIPPRESSURE:
			td->curdata.p = value;
			break;
		case HID_GD_X:
			td->curdata.x = value;
			break;
		case HID_GD_Y:
			td->curdata.y = value;
			break;
		case HID_DG_WIDTH:
			td->curdata.w = value;
			break;
		case HID_DG_HEIGHT:
			td->curdata.h = value;
			break;
		case HID_DG_CONTACTCOUNT:
			/*
			 * Includes multi-packet support where subsequent
			 * packets are sent with zero contactcount.
			 */
			if (value)
				td->num_expected = value;
			break;

		default:
			if (td->last_field_index
				&& field->index == td->last_field_index)
				/* we reach here when the last field in the
				 * report is not related to multitouch.
				 * This is not good. As a temporary solution,
				 * we trigger our mt event completion and
				 * ignore the field.
				 */
				break;
			/* fallback to the generic hidinput handling */
			return 0;
		}

		if (usage->hid == td->last_slot_field) {
			mt_complete_slot(td);
			if (!td->last_field_index)
				mt_emit_event(td, field->hidinput->input);
		}

		if (field->index == td->last_field_index
			&& td->num_received >= td->num_expected)
			mt_emit_event(td, field->hidinput->input);

	}

	/* 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 void mt_set_input_mode(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
	struct hid_report *r;
	struct hid_report_enum *re;

	if (td->inputmode < 0)
		return;

	re = &(hdev->report_enum[HID_FEATURE_REPORT]);
	r = re->report_id_hash[td->inputmode];
	if (r) {
		r->field[0]->value[0] = 0x02;
		usbhid_submit_report(hdev, r, USB_DIR_OUT);
	}
}

static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	int ret, i;
	struct mt_device *td;
	struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */

	for (i = 0; mt_classes[i].name ; i++) {
		if (id->driver_data == mt_classes[i].name) {
			mtclass = &(mt_classes[i]);
			break;
		}
	}

	/* This allows the driver to correctly support devices
	 * that emit events over several HID messages.
	 */
	hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;

	td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
	if (!td) {
		dev_err(&hdev->dev, "cannot allocate multitouch data\n");
		return -ENOMEM;
	}
	td->mtclass = mtclass;
	td->inputmode = -1;
	hid_set_drvdata(hdev, td);

	ret = hid_parse(hdev);
	if (ret != 0)
		goto fail;

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
	if (ret)
		goto fail;

	if (!td->maxcontacts)
		td->maxcontacts = MT_DEFAULT_MAXCONTACT;

	td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
				GFP_KERNEL);
	if (!td->slots) {
		dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
		hid_hw_stop(hdev);
		ret = -ENOMEM;
		goto fail;
	}

	mt_set_input_mode(hdev);

	return 0;

fail:
	kfree(td);
	return ret;
}

#ifdef CONFIG_PM
static int mt_reset_resume(struct hid_device *hdev)
{
	mt_set_input_mode(hdev);
	return 0;
}
#endif

static void mt_remove(struct hid_device *hdev)
{
	struct mt_device *td = hid_get_drvdata(hdev);
	hid_hw_stop(hdev);
	kfree(td->slots);
	kfree(td);
	hid_set_drvdata(hdev, NULL);
}

static const struct hid_device_id mt_devices[] = {

	/* 3M panels */
	{ .driver_data = MT_CLS_3M,
		HID_USB_DEVICE(USB_VENDOR_ID_3M,
			USB_DEVICE_ID_3M1968) },
	{ .driver_data = MT_CLS_3M,
		HID_USB_DEVICE(USB_VENDOR_ID_3M,
			USB_DEVICE_ID_3M2256) },

	/* Cando panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
			USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
			USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },

	/* Cypress panel */
	{ .driver_data = MT_CLS_CYPRESS,
		HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
			USB_DEVICE_ID_CYPRESS_TRUETOUCH) },

	/* GeneralTouch panel */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
		HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
			USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },

	/* IRTOUCH panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
		HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
			USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },

	/* PixCir-based panels */
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
		HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
			USB_DEVICE_ID_HANVON_MULTITOUCH) },
	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
		HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
			USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },

	/* Resistive eGalax devices */
	{  .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
	{  .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },

	/* Capacitive eGalax devices */
	{  .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
	{  .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
	{  .driver_data = MT_CLS_EGALAX,
		HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
			USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },

	/* Stantum panels */
	{ .driver_data = MT_CLS_STANTUM,
		HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
			USB_DEVICE_ID_MTP)},
	{ .driver_data = MT_CLS_STANTUM,
		HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
			USB_DEVICE_ID_MTP_STM)},
	{ .driver_data = MT_CLS_STANTUM,
		HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
			USB_DEVICE_ID_MTP_SITRONIX)},

	{ }
};
MODULE_DEVICE_TABLE(hid, mt_devices);

static const struct hid_usage_id mt_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 mt_driver = {
	.name = "hid-multitouch",
	.id_table = mt_devices,
	.probe = mt_probe,
	.remove = mt_remove,
	.input_mapping = mt_input_mapping,
	.input_mapped = mt_input_mapped,
	.feature_mapping = mt_feature_mapping,
	.usage_table = mt_grabbed_usages,
	.event = mt_event,
#ifdef CONFIG_PM
	.reset_resume = mt_reset_resume,
#endif
};

static int __init mt_init(void)
{
	return hid_register_driver(&mt_driver);
}

static void __exit mt_exit(void)
{
	hid_unregister_driver(&mt_driver);
}

module_init(mt_init);
module_exit(mt_exit);
Commit	Line	Data
5519cab4 BT	1	/*
	2	* HID driver for multitouch panels
	3	*
	4	* Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
	5	* Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
	6	* Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
	7	*
4875ac11 RN	8	* This code is partly based on hid-egalax.c:
	9	*
	10	* Copyright (c) 2010 Stephane Chatty <chatty@enac.fr>
	11	* Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
	12	* Copyright (c) 2010 Canonical, Ltd.
	13	*
f786bba4 BT	14	* This code is partly based on hid-3m-pct.c:
	15	*
	16	* Copyright (c) 2009-2010 Stephane Chatty <chatty@enac.fr>
	17	* Copyright (c) 2010 Henrik Rydberg <rydberg@euromail.se>
	18	* Copyright (c) 2010 Canonical, Ltd.
	19	*
5519cab4 BT	20	*/
	21
	22	/*
	23	* This program is free software; you can redistribute it and/or modify it
	24	* under the terms of the GNU General Public License as published by the Free
	25	* Software Foundation; either version 2 of the License, or (at your option)
	26	* any later version.
	27	*/
	28
	29	#include <linux/device.h>
	30	#include <linux/hid.h>
	31	#include <linux/module.h>
	32	#include <linux/slab.h>
	33	#include <linux/usb.h>
	34	#include <linux/input/mt.h>
	35	#include "usbhid/usbhid.h"
	36
	37
	38	MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
ef2fafb3	39	MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
5519cab4 BT	40	MODULE_DESCRIPTION("HID multitouch panels");
	41	MODULE_LICENSE("GPL");
	42
	43	#include "hid-ids.h"
	44
	45	/* quirks to control the device */
	46	#define MT_QUIRK_NOT_SEEN_MEANS_UP (1 << 0)
	47	#define MT_QUIRK_SLOT_IS_CONTACTID (1 << 1)
2d93666e	48	#define MT_QUIRK_CYPRESS (1 << 2)
5572da08	49	#define MT_QUIRK_SLOT_IS_CONTACTNUMBER (1 << 3)
2d93666e BT	50	#define MT_QUIRK_VALID_IS_INRANGE (1 << 4)
2d93666e BT	51	#define MT_QUIRK_VALID_IS_CONFIDENCE (1 << 5)
4875ac11	52	#define MT_QUIRK_EGALAX_XYZ_FIXUP (1 << 6)
5519cab4 BT	53
	54	struct mt_slot {
	55	__s32 x, y, p, w, h;
	56	__s32 contactid; /* the device ContactID assigned to this slot */
	57	bool touch_state; /* is the touch valid? */
	58	bool seen_in_this_frame;/* has this slot been updated */
	59	};
	60
	61	struct mt_device {
	62	struct mt_slot curdata; /* placeholder of incoming data */
	63	struct mt_class mtclass; / our mt device class */
	64	unsigned last_field_index; /* last field index of the report */
	65	unsigned last_slot_field; /* the last field of a slot */
	66	__s8 inputmode; /* InputMode HID feature, -1 if non-existent */
	67	__u8 num_received; /* how many contacts we received */
	68	__u8 num_expected; /* expected last contact index */
9498f954	69	__u8 maxcontacts;
5519cab4	70	bool curvalid; /* is the current contact valid? */
9498f954	71	struct mt_slot *slots;
5519cab4 BT	72	};
	73
	74	struct mt_class {
2d93666e	75	__s32 name; /* MT_CLS */
5519cab4 BT	76	__s32 quirks;
5519cab4 BT	77	__s32 sn_move; /* Signal/noise ratio for move events */
f786bba4 BT	78	__s32 sn_width; /* Signal/noise ratio for width events */
f786bba4 BT	79	__s32 sn_height; /* Signal/noise ratio for height events */
5519cab4 BT	80	__s32 sn_pressure; /* Signal/noise ratio for pressure events */
	81	__u8 maxcontacts;
	82	};
	83
	84	/* classes of device behavior */
1e9cf35b BT	85	#define MT_CLS_DEFAULT 1
	86	#define MT_CLS_DUAL_INRANGE_CONTACTID 2
	87	#define MT_CLS_DUAL_INRANGE_CONTACTNUMBER 3
	88	#define MT_CLS_CYPRESS 4
4875ac11	89	#define MT_CLS_EGALAX 5
043b403a	90	#define MT_CLS_STANTUM 6
f786bba4	91	#define MT_CLS_3M 7
5519cab4	92
9498f954 BT	93	#define MT_DEFAULT_MAXCONTACT 10
9498f954 BT	94
5519cab4 BT	95	/*
	96	* these device-dependent functions determine what slot corresponds
	97	* to a valid contact that was just read.
	98	*/
	99
a3b5e577 BT	100	static int cypress_compute_slot(struct mt_device *td)
	101	{
	102	if (td->curdata.contactid != 0 \|\| td->num_received == 0)
	103	return td->curdata.contactid;
	104	else
	105	return -1;
	106	}
	107
5519cab4 BT	108	static int find_slot_from_contactid(struct mt_device *td)
	109	{
	110	int i;
9498f954	111	for (i = 0; i < td->maxcontacts; ++i) {
5519cab4 BT	112	if (td->slots[i].contactid == td->curdata.contactid &&
	113	td->slots[i].touch_state)
	114	return i;
	115	}
9498f954	116	for (i = 0; i < td->maxcontacts; ++i) {
5519cab4 BT	117	if (!td->slots[i].seen_in_this_frame &&
	118	!td->slots[i].touch_state)
	119	return i;
	120	}
5519cab4 BT	121	/* should not occurs. If this happens that means
	122	* that the device sent more touches that it says
	123	* in the report descriptor. It is ignored then. */
2d93666e	124	return -1;
5519cab4 BT	125	}
	126
	127	struct mt_class mt_classes[] = {
2d93666e	128	{ .name = MT_CLS_DEFAULT,
9498f954	129	.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP },
1e9cf35b	130	{ .name = MT_CLS_DUAL_INRANGE_CONTACTID,
2d93666e BT	131	.quirks = MT_QUIRK_VALID_IS_INRANGE \|
	132	MT_QUIRK_SLOT_IS_CONTACTID,
	133	.maxcontacts = 2 },
1e9cf35b	134	{ .name = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
2d93666e BT	135	.quirks = MT_QUIRK_VALID_IS_INRANGE \|
	136	MT_QUIRK_SLOT_IS_CONTACTNUMBER,
	137	.maxcontacts = 2 },
	138	{ .name = MT_CLS_CYPRESS,
	139	.quirks = MT_QUIRK_NOT_SEEN_MEANS_UP \|
	140	MT_QUIRK_CYPRESS,
	141	.maxcontacts = 10 },
	142
4875ac11 RN	143	{ .name = MT_CLS_EGALAX,
	144	.quirks = MT_QUIRK_SLOT_IS_CONTACTID \|
	145	MT_QUIRK_VALID_IS_INRANGE \|
	146	MT_QUIRK_EGALAX_XYZ_FIXUP,
	147	.maxcontacts = 2,
	148	.sn_move = 4096,
	149	.sn_pressure = 32,
	150	},
043b403a BT	151	{ .name = MT_CLS_STANTUM,
043b403a BT	152	.quirks = MT_QUIRK_VALID_IS_CONFIDENCE },
f786bba4 BT	153	{ .name = MT_CLS_3M,
	154	.quirks = MT_QUIRK_VALID_IS_CONFIDENCE \|
	155	MT_QUIRK_SLOT_IS_CONTACTID,
	156	.sn_move = 2048,
	157	.sn_width = 128,
	158	.sn_height = 128 },
043b403a	159
2d93666e	160	{ }
5519cab4 BT	161	};
5519cab4 BT	162
f635bd11	163	static void mt_feature_mapping(struct hid_device *hdev,
5519cab4 BT	164	struct hid_field field, struct hid_usage usage)
5519cab4 BT	165	{
9498f954 BT	166	struct mt_device *td = hid_get_drvdata(hdev);
	167
	168	switch (usage->hid) {
	169	case HID_DG_INPUTMODE:
5519cab4	170	td->inputmode = field->report->id;
9498f954 BT	171	break;
	172	case HID_DG_CONTACTMAX:
	173	td->maxcontacts = field->value[0];
	174	if (td->mtclass->maxcontacts)
	175	/* check if the maxcontacts is given by the class */
	176	td->maxcontacts = td->mtclass->maxcontacts;
	177
	178	break;
5519cab4 BT	179	}
	180	}
	181
	182	static void set_abs(struct input_dev *input, unsigned int code,
	183	struct hid_field *field, int snratio)
	184	{
	185	int fmin = field->logical_minimum;
	186	int fmax = field->logical_maximum;
	187	int fuzz = snratio ? (fmax - fmin) / snratio : 0;
	188	input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
	189	}
	190
	191	static int mt_input_mapping(struct hid_device hdev, struct hid_input hi,
	192	struct hid_field field, struct hid_usage usage,
	193	unsigned long *bit, int max)
	194	{
	195	struct mt_device *td = hid_get_drvdata(hdev);
	196	struct mt_class *cls = td->mtclass;
4875ac11 RN	197	__s32 quirks = cls->quirks;
4875ac11 RN	198
5519cab4 BT	199	switch (usage->hid & HID_USAGE_PAGE) {
	200
	201	case HID_UP_GENDESK:
	202	switch (usage->hid) {
	203	case HID_GD_X:
4875ac11 RN	204	if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
4875ac11 RN	205	field->logical_maximum = 32760;
5519cab4 BT	206	hid_map_usage(hi, usage, bit, max,
	207	EV_ABS, ABS_MT_POSITION_X);
	208	set_abs(hi->input, ABS_MT_POSITION_X, field,
	209	cls->sn_move);
	210	/* touchscreen emulation */
	211	set_abs(hi->input, ABS_X, field, cls->sn_move);
	212	td->last_slot_field = usage->hid;
	213	return 1;
	214	case HID_GD_Y:
4875ac11 RN	215	if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
4875ac11 RN	216	field->logical_maximum = 32760;
5519cab4 BT	217	hid_map_usage(hi, usage, bit, max,
	218	EV_ABS, ABS_MT_POSITION_Y);
	219	set_abs(hi->input, ABS_MT_POSITION_Y, field,
	220	cls->sn_move);
	221	/* touchscreen emulation */
	222	set_abs(hi->input, ABS_Y, field, cls->sn_move);
	223	td->last_slot_field = usage->hid;
	224	return 1;
	225	}
	226	return 0;
	227
	228	case HID_UP_DIGITIZER:
	229	switch (usage->hid) {
	230	case HID_DG_INRANGE:
	231	td->last_slot_field = usage->hid;
	232	return 1;
	233	case HID_DG_CONFIDENCE:
	234	td->last_slot_field = usage->hid;
	235	return 1;
	236	case HID_DG_TIPSWITCH:
	237	hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
	238	input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
	239	td->last_slot_field = usage->hid;
	240	return 1;
	241	case HID_DG_CONTACTID:
9498f954	242	input_mt_init_slots(hi->input, td->maxcontacts);
5519cab4 BT	243	td->last_slot_field = usage->hid;
	244	return 1;
	245	case HID_DG_WIDTH:
	246	hid_map_usage(hi, usage, bit, max,
	247	EV_ABS, ABS_MT_TOUCH_MAJOR);
f786bba4 BT	248	set_abs(hi->input, ABS_MT_TOUCH_MAJOR, field,
f786bba4 BT	249	cls->sn_width);
5519cab4 BT	250	td->last_slot_field = usage->hid;
	251	return 1;
	252	case HID_DG_HEIGHT:
	253	hid_map_usage(hi, usage, bit, max,
	254	EV_ABS, ABS_MT_TOUCH_MINOR);
f786bba4 BT	255	set_abs(hi->input, ABS_MT_TOUCH_MINOR, field,
f786bba4 BT	256	cls->sn_height);
1e648a13 BT	257	input_set_abs_params(hi->input,
1e648a13 BT	258	ABS_MT_ORIENTATION, 0, 1, 0, 0);
5519cab4 BT	259	td->last_slot_field = usage->hid;
	260	return 1;
	261	case HID_DG_TIPPRESSURE:
4875ac11 RN	262	if (quirks & MT_QUIRK_EGALAX_XYZ_FIXUP)
4875ac11 RN	263	field->logical_minimum = 0;
5519cab4 BT	264	hid_map_usage(hi, usage, bit, max,
	265	EV_ABS, ABS_MT_PRESSURE);
	266	set_abs(hi->input, ABS_MT_PRESSURE, field,
	267	cls->sn_pressure);
	268	/* touchscreen emulation */
	269	set_abs(hi->input, ABS_PRESSURE, field,
	270	cls->sn_pressure);
	271	td->last_slot_field = usage->hid;
	272	return 1;
	273	case HID_DG_CONTACTCOUNT:
	274	td->last_field_index = field->report->maxfield - 1;
	275	return 1;
	276	case HID_DG_CONTACTMAX:
	277	/* we don't set td->last_slot_field as contactcount and
	278	* contact max are global to the report */
	279	return -1;
	280	}
	281	/* let hid-input decide for the others */
	282	return 0;
	283
	284	case 0xff000000:
	285	/* we do not want to map these: no input-oriented meaning */
	286	return -1;
	287	}
	288
	289	return 0;
	290	}
	291
	292	static int mt_input_mapped(struct hid_device hdev, struct hid_input hi,
	293	struct hid_field field, struct hid_usage usage,
	294	unsigned long *bit, int max)
	295	{
	296	if (usage->type == EV_KEY \|\| usage->type == EV_ABS)
	297	set_bit(usage->type, hi->input->evbit);
	298
	299	return -1;
	300	}
	301
	302	static int mt_compute_slot(struct mt_device *td)
	303	{
2d93666e	304	__s32 quirks = td->mtclass->quirks;
5519cab4	305
2d93666e BT	306	if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
2d93666e BT	307	return td->curdata.contactid;
5519cab4	308
2d93666e	309	if (quirks & MT_QUIRK_CYPRESS)
a3b5e577 BT	310	return cypress_compute_slot(td);
a3b5e577 BT	311
2d93666e BT	312	if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
2d93666e BT	313	return td->num_received;
5572da08	314
5519cab4 BT	315	return find_slot_from_contactid(td);
	316	}
	317
	318	/*
	319	* this function is called when a whole contact has been processed,
	320	* so that it can assign it to a slot and store the data there
	321	*/
	322	static void mt_complete_slot(struct mt_device *td)
	323	{
2d93666e	324	td->curdata.seen_in_this_frame = true;
5519cab4	325	if (td->curvalid) {
5519cab4 BT	326	int slotnum = mt_compute_slot(td);
5519cab4 BT	327
9498f954	328	if (slotnum >= 0 && slotnum < td->maxcontacts)
2d93666e	329	td->slots[slotnum] = td->curdata;
5519cab4 BT	330	}
	331	td->num_received++;
	332	}
	333
	334
	335	/*
	336	* this function is called when a whole packet has been received and processed,
	337	* so that it can decide what to send to the input layer.
	338	*/
	339	static void mt_emit_event(struct mt_device td, struct input_dev input)
	340	{
	341	int i;
	342
9498f954	343	for (i = 0; i < td->maxcontacts; ++i) {
5519cab4 BT	344	struct mt_slot *s = &(td->slots[i]);
	345	if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
	346	!s->seen_in_this_frame) {
5519cab4 BT	347	s->touch_state = false;
	348	}
	349
	350	input_mt_slot(input, i);
	351	input_mt_report_slot_state(input, MT_TOOL_FINGER,
	352	s->touch_state);
2d93666e	353	if (s->touch_state) {
f786bba4 BT	354	/* this finger is on the screen */
	355	int wide = (s->w > s->h);
	356	/* divided by two to match visual scale of touch */
	357	int major = max(s->w, s->h) >> 1;
	358	int minor = min(s->w, s->h) >> 1;
	359
2d93666e BT	360	input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
2d93666e BT	361	input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
f786bba4	362	input_event(input, EV_ABS, ABS_MT_ORIENTATION, wide);
2d93666e	363	input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
f786bba4 BT	364	input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, major);
f786bba4 BT	365	input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, minor);
2d93666e	366	}
5519cab4 BT	367	s->seen_in_this_frame = false;
	368
	369	}
	370
	371	input_mt_report_pointer_emulation(input, true);
	372	input_sync(input);
	373	td->num_received = 0;
	374	}
	375
	376
	377
	378	static int mt_event(struct hid_device hid, struct hid_field field,
	379	struct hid_usage *usage, __s32 value)
	380	{
	381	struct mt_device *td = hid_get_drvdata(hid);
2d93666e	382	__s32 quirks = td->mtclass->quirks;
5519cab4	383
9498f954	384	if (hid->claimed & HID_CLAIMED_INPUT && td->slots) {
5519cab4 BT	385	switch (usage->hid) {
5519cab4 BT	386	case HID_DG_INRANGE:
2d93666e BT	387	if (quirks & MT_QUIRK_VALID_IS_INRANGE)
2d93666e BT	388	td->curvalid = value;
5519cab4 BT	389	break;
5519cab4 BT	390	case HID_DG_TIPSWITCH:
2d93666e BT	391	if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
2d93666e BT	392	td->curvalid = value;
5519cab4 BT	393	td->curdata.touch_state = value;
	394	break;
	395	case HID_DG_CONFIDENCE:
2d93666e BT	396	if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
2d93666e BT	397	td->curvalid = value;
5519cab4 BT	398	break;
	399	case HID_DG_CONTACTID:
	400	td->curdata.contactid = value;
	401	break;
	402	case HID_DG_TIPPRESSURE:
	403	td->curdata.p = value;
	404	break;
	405	case HID_GD_X:
	406	td->curdata.x = value;
	407	break;
	408	case HID_GD_Y:
	409	td->curdata.y = value;
	410	break;
	411	case HID_DG_WIDTH:
	412	td->curdata.w = value;
	413	break;
	414	case HID_DG_HEIGHT:
	415	td->curdata.h = value;
	416	break;
	417	case HID_DG_CONTACTCOUNT:
	418	/*
2d93666e BT	419	* Includes multi-packet support where subsequent
2d93666e BT	420	* packets are sent with zero contactcount.
5519cab4 BT	421	*/
5519cab4 BT	422	if (value)
2d93666e	423	td->num_expected = value;
5519cab4 BT	424	break;
	425
	426	default:
f786bba4 BT	427	if (td->last_field_index
	428	&& field->index == td->last_field_index)
	429	/* we reach here when the last field in the
	430	* report is not related to multitouch.
	431	* This is not good. As a temporary solution,
	432	* we trigger our mt event completion and
	433	* ignore the field.
	434	*/
	435	break;
5519cab4 BT	436	/* fallback to the generic hidinput handling */
	437	return 0;
	438	}
5519cab4	439
f153fc39	440	if (usage->hid == td->last_slot_field) {
2d93666e	441	mt_complete_slot(td);
f153fc39 HR	442	if (!td->last_field_index)
	443	mt_emit_event(td, field->hidinput->input);
	444	}
2d93666e BT	445
	446	if (field->index == td->last_field_index
	447	&& td->num_received >= td->num_expected)
	448	mt_emit_event(td, field->hidinput->input);
5519cab4	449
2d93666e	450	}
5519cab4 BT	451
	452	/* we have handled the hidinput part, now remains hiddev */
	453	if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
	454	hid->hiddev_hid_event(hid, field, usage, value);
	455
	456	return 1;
	457	}
	458
	459	static void mt_set_input_mode(struct hid_device *hdev)
	460	{
	461	struct mt_device *td = hid_get_drvdata(hdev);
	462	struct hid_report *r;
	463	struct hid_report_enum *re;
	464
	465	if (td->inputmode < 0)
	466	return;
	467
	468	re = &(hdev->report_enum[HID_FEATURE_REPORT]);
	469	r = re->report_id_hash[td->inputmode];
	470	if (r) {
	471	r->field[0]->value[0] = 0x02;
	472	usbhid_submit_report(hdev, r, USB_DIR_OUT);
	473	}
	474	}
	475
	476	static int mt_probe(struct hid_device hdev, const struct hid_device_id id)
	477	{
2d93666e	478	int ret, i;
5519cab4	479	struct mt_device *td;
2d93666e BT	480	struct mt_class mtclass = mt_classes; / MT_CLS_DEFAULT */
	481
	482	for (i = 0; mt_classes[i].name ; i++) {
	483	if (id->driver_data == mt_classes[i].name) {
	484	mtclass = &(mt_classes[i]);
	485	break;
	486	}
	487	}
5519cab4 BT	488
	489	/* This allows the driver to correctly support devices
	490	* that emit events over several HID messages.
	491	*/
	492	hdev->quirks \|= HID_QUIRK_NO_INPUT_SYNC;
	493
9498f954	494	td = kzalloc(sizeof(struct mt_device), GFP_KERNEL);
5519cab4 BT	495	if (!td) {
	496	dev_err(&hdev->dev, "cannot allocate multitouch data\n");
	497	return -ENOMEM;
	498	}
	499	td->mtclass = mtclass;
	500	td->inputmode = -1;
	501	hid_set_drvdata(hdev, td);
	502
	503	ret = hid_parse(hdev);
	504	if (ret != 0)
	505	goto fail;
	506
	507	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
2d93666e	508	if (ret)
5519cab4 BT	509	goto fail;
5519cab4 BT	510
9498f954 BT	511	if (!td->maxcontacts)
	512	td->maxcontacts = MT_DEFAULT_MAXCONTACT;
	513
	514	td->slots = kzalloc(td->maxcontacts * sizeof(struct mt_slot),
	515	GFP_KERNEL);
	516	if (!td->slots) {
	517	dev_err(&hdev->dev, "cannot allocate multitouch slots\n");
	518	hid_hw_stop(hdev);
	519	ret = -ENOMEM;
	520	goto fail;
	521	}
	522
5519cab4 BT	523	mt_set_input_mode(hdev);
	524
	525	return 0;
	526
	527	fail:
	528	kfree(td);
	529	return ret;
	530	}
	531
	532	#ifdef CONFIG_PM
	533	static int mt_reset_resume(struct hid_device *hdev)
	534	{
	535	mt_set_input_mode(hdev);
	536	return 0;
	537	}
	538	#endif
	539
	540	static void mt_remove(struct hid_device *hdev)
	541	{
	542	struct mt_device *td = hid_get_drvdata(hdev);
	543	hid_hw_stop(hdev);
9498f954	544	kfree(td->slots);
5519cab4 BT	545	kfree(td);
	546	hid_set_drvdata(hdev, NULL);
	547	}
	548
	549	static const struct hid_device_id mt_devices[] = {
	550
f786bba4 BT	551	/* 3M panels */
	552	{ .driver_data = MT_CLS_3M,
	553	HID_USB_DEVICE(USB_VENDOR_ID_3M,
	554	USB_DEVICE_ID_3M1968) },
	555	{ .driver_data = MT_CLS_3M,
	556	HID_USB_DEVICE(USB_VENDOR_ID_3M,
	557	USB_DEVICE_ID_3M2256) },
	558
a841b62c BT	559	/* Cando panels */
	560	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
	561	HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
	562	USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
	563	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
	564	HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
	565	USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1) },
	566	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
	567	HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
	568	USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
	569	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
	570	HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
	571	USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
	572
a3b5e577 BT	573	/* Cypress panel */
	574	{ .driver_data = MT_CLS_CYPRESS,
	575	HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
	576	USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
	577
5572da08	578	/* GeneralTouch panel */
1e9cf35b	579	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTNUMBER,
5572da08 BT	580	HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
	581	USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
	582
4dfcced8 BT	583	/* IRTOUCH panels */
	584	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
	585	HID_USB_DEVICE(USB_VENDOR_ID_IRTOUCHSYSTEMS,
	586	USB_DEVICE_ID_IRTOUCH_INFRARED_USB) },
	587
5519cab4	588	/* PixCir-based panels */
1e9cf35b	589	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
5519cab4 BT	590	HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
5519cab4 BT	591	USB_DEVICE_ID_HANVON_MULTITOUCH) },
1e9cf35b	592	{ .driver_data = MT_CLS_DUAL_INRANGE_CONTACTID,
5519cab4 BT	593	HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
	594	USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
	595
4875ac11 RN	596	/* Resistive eGalax devices */
	597	{ .driver_data = MT_CLS_EGALAX,
	598	HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
	599	USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
	600	{ .driver_data = MT_CLS_EGALAX,
	601	HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
	602	USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH3) },
	603
	604	/* Capacitive eGalax devices */
	605	{ .driver_data = MT_CLS_EGALAX,
	606	HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
	607	USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
	608	{ .driver_data = MT_CLS_EGALAX,
	609	HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
	610	USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH2) },
	611	{ .driver_data = MT_CLS_EGALAX,
	612	HID_USB_DEVICE(USB_VENDOR_ID_DWAV,
	613	USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH4) },
	614
043b403a BT	615	/* Stantum panels */
	616	{ .driver_data = MT_CLS_STANTUM,
	617	HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
	618	USB_DEVICE_ID_MTP)},
	619	{ .driver_data = MT_CLS_STANTUM,
	620	HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
	621	USB_DEVICE_ID_MTP_STM)},
	622	{ .driver_data = MT_CLS_STANTUM,
	623	HID_USB_DEVICE(USB_VENDOR_ID_STANTUM,
	624	USB_DEVICE_ID_MTP_SITRONIX)},
	625
5519cab4 BT	626	{ }
	627	};
	628	MODULE_DEVICE_TABLE(hid, mt_devices);
	629
	630	static const struct hid_usage_id mt_grabbed_usages[] = {
	631	{ HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
	632	{ HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
	633	};
	634
	635	static struct hid_driver mt_driver = {
	636	.name = "hid-multitouch",
	637	.id_table = mt_devices,
	638	.probe = mt_probe,
	639	.remove = mt_remove,
	640	.input_mapping = mt_input_mapping,
	641	.input_mapped = mt_input_mapped,
	642	.feature_mapping = mt_feature_mapping,
	643	.usage_table = mt_grabbed_usages,
	644	.event = mt_event,
	645	#ifdef CONFIG_PM
	646	.reset_resume = mt_reset_resume,
	647	#endif
	648	};
	649
	650	static int __init mt_init(void)
	651	{
	652	return hid_register_driver(&mt_driver);
	653	}
	654
	655	static void __exit mt_exit(void)
	656	{
	657	hid_unregister_driver(&mt_driver);
	658	}
	659
	660	module_init(mt_init);
	661	module_exit(mt_exit);