1// SPDX-License-Identifier: GPL-2.0-or-later
   2/******************************************************************************
   3 * usbtouchscreen.c
   4 * Driver for USB Touchscreens, supporting those devices:
   5 *  - eGalax Touchkit
   6 *    includes eTurboTouch CT-410/510/700
   7 *  - 3M/Microtouch  EX II series
   8 *  - ITM
   9 *  - PanJit TouchSet
  10 *  - eTurboTouch
  11 *  - Gunze AHL61
  12 *  - DMC TSC-10/25
  13 *  - IRTOUCHSYSTEMS/UNITOP
  14 *  - IdealTEK URTC1000
  15 *  - General Touch
  16 *  - GoTop Super_Q2/GogoPen/PenPower tablets
  17 *  - JASTEC USB touch controller/DigiTech DTR-02U
  18 *  - Zytronic capacitive touchscreen
  19 *  - NEXIO/iNexio
  20 *  - Elo TouchSystems 2700 IntelliTouch
  21 *  - EasyTouch USB Dual/Multi touch controller from Data Modul
  22 *
  23 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
  24 * Copyright (C) by Todd E. Johnson (mtouchusb.c)
  25 *
  26 * Driver is based on touchkitusb.c
  27 * - ITM parts are from itmtouch.c
  28 * - 3M parts are from mtouchusb.c
  29 * - PanJit parts are from an unmerged driver by Lanslott Gish
  30 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged
  31 *   driver from Marius Vollmer
  32 *
  33 *****************************************************************************/
  34
  35//#define DEBUG
  36
  37#include <linux/kernel.h>
  38#include <linux/slab.h>
  39#include <linux/input.h>
  40#include <linux/module.h>
  41#include <linux/usb.h>
  42#include <linux/usb/input.h>
  43#include <linux/hid.h>
  44#include <linux/mutex.h>
  45
  46static bool swap_xy;
  47module_param(swap_xy, bool, 0644);
  48MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
  49
  50static bool hwcalib_xy;
  51module_param(hwcalib_xy, bool, 0644);
  52MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");
  53
  54/* device specifc data/functions */
  55struct usbtouch_usb;
  56struct usbtouch_device_info {
  57	int min_xc, max_xc;
  58	int min_yc, max_yc;
  59	int min_press, max_press;
  60	int rept_size;
  61
  62	/*
  63	 * Always service the USB devices irq not just when the input device is
  64	 * open. This is useful when devices have a watchdog which prevents us
  65	 * from periodically polling the device. Leave this unset unless your
  66	 * touchscreen device requires it, as it does consume more of the USB
  67	 * bandwidth.
  68	 */
  69	bool irq_always;
  70
  71	void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
  72
  73	/*
  74	 * used to get the packet len. possible return values:
  75	 * > 0: packet len
  76	 * = 0: skip one byte
  77	 * < 0: -return value more bytes needed
  78	 */
  79	int  (*get_pkt_len) (unsigned char *pkt, int len);
  80
  81	int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
  82	int  (*alloc)       (struct usbtouch_usb *usbtouch);
  83	int  (*init)        (struct usbtouch_usb *usbtouch);
  84	void (*exit)	    (struct usbtouch_usb *usbtouch);
  85};
  86
  87/* a usbtouch device */
  88struct usbtouch_usb {
  89	unsigned char *data;
  90	dma_addr_t data_dma;
  91	int data_size;
  92	unsigned char *buffer;
  93	int buf_len;
  94	struct urb *irq;
  95	struct usb_interface *interface;
  96	struct input_dev *input;
  97	struct usbtouch_device_info *type;
  98	struct mutex pm_mutex;  /* serialize access to open/suspend */
  99	bool is_open;
 100	char name[128];
 101	char phys[64];
 102	void *priv;
 103
 104	int x, y;
 105	int touch, press;
 106};
 107
 108
 109/* device types */
 110enum {
 111	DEVTYPE_IGNORE = -1,
 112	DEVTYPE_EGALAX,
 113	DEVTYPE_PANJIT,
 114	DEVTYPE_3M,
 115	DEVTYPE_ITM,
 116	DEVTYPE_ETURBO,
 117	DEVTYPE_GUNZE,
 118	DEVTYPE_DMC_TSC10,
 119	DEVTYPE_IRTOUCH,
 120	DEVTYPE_IRTOUCH_HIRES,
 121	DEVTYPE_IDEALTEK,
 122	DEVTYPE_GENERAL_TOUCH,
 123	DEVTYPE_GOTOP,
 124	DEVTYPE_JASTEC,
 125	DEVTYPE_E2I,
 126	DEVTYPE_ZYTRONIC,
 127	DEVTYPE_TC45USB,
 128	DEVTYPE_NEXIO,
 129	DEVTYPE_ELO,
 130	DEVTYPE_ETOUCH,
 131};
 132
 133#define USB_DEVICE_HID_CLASS(vend, prod) \
 134	.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
 135		| USB_DEVICE_ID_MATCH_DEVICE, \
 136	.idVendor = (vend), \
 137	.idProduct = (prod), \
 138	.bInterfaceClass = USB_INTERFACE_CLASS_HID
 139
 140static const struct usb_device_id usbtouch_devices[] = {
 141#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 142	/* ignore the HID capable devices, handled by usbhid */
 143	{USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
 144	{USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},
 145
 146	/* normal device IDs */
 147	{USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
 148	{USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
 149	{USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
 150	{USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
 151	{USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
 152	{USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
 153	{USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
 154#endif
 155
 156#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 157	{USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
 158	{USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
 159	{USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
 160	{USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
 161#endif
 162
 163#ifdef CONFIG_TOUCHSCREEN_USB_3M
 164	{USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
 165#endif
 166
 167#ifdef CONFIG_TOUCHSCREEN_USB_ITM
 168	{USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
 169	{USB_DEVICE(0x16e3, 0xf9e9), .driver_info = DEVTYPE_ITM},
 170#endif
 171
 172#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 173	{USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
 174#endif
 175
 176#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 177	{USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
 178#endif
 179
 180#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 181	{USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
 182#endif
 183
 184#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 185	{USB_DEVICE(0x255e, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 186	{USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 187	{USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
 188	{USB_DEVICE(0x6615, 0x0012), .driver_info = DEVTYPE_IRTOUCH_HIRES},
 189#endif
 190
 191#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 192	{USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
 193#endif
 194
 195#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 196	{USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
 197#endif
 198
 199#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 200	{USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
 201	{USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
 202	{USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
 203#endif
 204
 205#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
 206	{USB_DEVICE(0x0f92, 0x0001), .driver_info = DEVTYPE_JASTEC},
 207#endif
 208
 209#ifdef CONFIG_TOUCHSCREEN_USB_E2I
 210	{USB_DEVICE(0x1ac7, 0x0001), .driver_info = DEVTYPE_E2I},
 211#endif
 212
 213#ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 214	{USB_DEVICE(0x14c8, 0x0003), .driver_info = DEVTYPE_ZYTRONIC},
 215#endif
 216
 217#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
 218	/* TC5UH */
 219	{USB_DEVICE(0x0664, 0x0309), .driver_info = DEVTYPE_TC45USB},
 220	/* TC4UM */
 221	{USB_DEVICE(0x0664, 0x0306), .driver_info = DEVTYPE_TC45USB},
 222#endif
 223
 224#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
 225	/* data interface only */
 226	{USB_DEVICE_AND_INTERFACE_INFO(0x10f0, 0x2002, 0x0a, 0x00, 0x00),
 227		.driver_info = DEVTYPE_NEXIO},
 228	{USB_DEVICE_AND_INTERFACE_INFO(0x1870, 0x0001, 0x0a, 0x00, 0x00),
 229		.driver_info = DEVTYPE_NEXIO},
 230#endif
 231
 232#ifdef CONFIG_TOUCHSCREEN_USB_ELO
 233	{USB_DEVICE(0x04e7, 0x0020), .driver_info = DEVTYPE_ELO},
 234#endif
 235
 236#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
 237	{USB_DEVICE(0x7374, 0x0001), .driver_info = DEVTYPE_ETOUCH},
 238#endif
 239
 240	{}
 241};
 242
 243
 244/*****************************************************************************
 245 * e2i Part
 246 */
 247
 248#ifdef CONFIG_TOUCHSCREEN_USB_E2I
 249static int e2i_init(struct usbtouch_usb *usbtouch)
 250{
 251	int ret;
 252	struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 253
 254	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 255	                      0x01, 0x02, 0x0000, 0x0081,
 256	                      NULL, 0, USB_CTRL_SET_TIMEOUT);
 257
 258	dev_dbg(&usbtouch->interface->dev,
 259		"%s - usb_control_msg - E2I_RESET - bytes|err: %d\n",
 260		__func__, ret);
 261	return ret;
 262}
 263
 264static int e2i_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 265{
 266	int tmp = (pkt[0] << 8) | pkt[1];
 267	dev->x  = (pkt[2] << 8) | pkt[3];
 268	dev->y  = (pkt[4] << 8) | pkt[5];
 269
 270	tmp = tmp - 0xA000;
 271	dev->touch = (tmp > 0);
 272	dev->press = (tmp > 0 ? tmp : 0);
 273
 274	return 1;
 275}
 276#endif
 277
 278
 279/*****************************************************************************
 280 * eGalax part
 281 */
 282
 283#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
 284
 285#ifndef MULTI_PACKET
 286#define MULTI_PACKET
 287#endif
 288
 289#define EGALAX_PKT_TYPE_MASK		0xFE
 290#define EGALAX_PKT_TYPE_REPT		0x80
 291#define EGALAX_PKT_TYPE_DIAG		0x0A
 292
 293static int egalax_init(struct usbtouch_usb *usbtouch)
 294{
 295	int ret, i;
 296	unsigned char *buf;
 297	struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 298
 299	/*
 300	 * An eGalax diagnostic packet kicks the device into using the right
 301	 * protocol.  We send a "check active" packet.  The response will be
 302	 * read later and ignored.
 303	 */
 304
 305	buf = kmalloc(3, GFP_KERNEL);
 306	if (!buf)
 307		return -ENOMEM;
 308
 309	buf[0] = EGALAX_PKT_TYPE_DIAG;
 310	buf[1] = 1;	/* length */
 311	buf[2] = 'A';	/* command - check active */
 312
 313	for (i = 0; i < 3; i++) {
 314		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 315				      0,
 316				      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 317				      0, 0, buf, 3,
 318				      USB_CTRL_SET_TIMEOUT);
 319		if (ret >= 0) {
 320			ret = 0;
 321			break;
 322		}
 323		if (ret != -EPIPE)
 324			break;
 325	}
 326
 327	kfree(buf);
 328
 329	return ret;
 330}
 331
 332static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 333{
 334	if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
 335		return 0;
 336
 337	dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
 338	dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
 339	dev->touch = pkt[0] & 0x01;
 340
 341	return 1;
 342}
 343
 344static int egalax_get_pkt_len(unsigned char *buf, int len)
 345{
 346	switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
 347	case EGALAX_PKT_TYPE_REPT:
 348		return 5;
 349
 350	case EGALAX_PKT_TYPE_DIAG:
 351		if (len < 2)
 352			return -1;
 353
 354		return buf[1] + 2;
 355	}
 356
 357	return 0;
 358}
 359#endif
 360
 361/*****************************************************************************
 362 * EasyTouch part
 363 */
 364
 365#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
 366
 367#ifndef MULTI_PACKET
 368#define MULTI_PACKET
 369#endif
 370
 371#define ETOUCH_PKT_TYPE_MASK		0xFE
 372#define ETOUCH_PKT_TYPE_REPT		0x80
 373#define ETOUCH_PKT_TYPE_REPT2		0xB0
 374#define ETOUCH_PKT_TYPE_DIAG		0x0A
 375
 376static int etouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 377{
 378	if ((pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT &&
 379		(pkt[0] & ETOUCH_PKT_TYPE_MASK) != ETOUCH_PKT_TYPE_REPT2)
 380		return 0;
 381
 382	dev->x = ((pkt[1] & 0x1F) << 7) | (pkt[2] & 0x7F);
 383	dev->y = ((pkt[3] & 0x1F) << 7) | (pkt[4] & 0x7F);
 384	dev->touch = pkt[0] & 0x01;
 385
 386	return 1;
 387}
 388
 389static int etouch_get_pkt_len(unsigned char *buf, int len)
 390{
 391	switch (buf[0] & ETOUCH_PKT_TYPE_MASK) {
 392	case ETOUCH_PKT_TYPE_REPT:
 393	case ETOUCH_PKT_TYPE_REPT2:
 394		return 5;
 395
 396	case ETOUCH_PKT_TYPE_DIAG:
 397		if (len < 2)
 398			return -1;
 399
 400		return buf[1] + 2;
 401	}
 402
 403	return 0;
 404}
 405#endif
 406
 407/*****************************************************************************
 408 * PanJit Part
 409 */
 410#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
 411static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 412{
 413	dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
 414	dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
 415	dev->touch = pkt[0] & 0x01;
 416
 417	return 1;
 418}
 419#endif
 420
 421
 422/*****************************************************************************
 423 * 3M/Microtouch Part
 424 */
 425#ifdef CONFIG_TOUCHSCREEN_USB_3M
 426
 427#define MTOUCHUSB_ASYNC_REPORT          1
 428#define MTOUCHUSB_RESET                 7
 429#define MTOUCHUSB_REQ_CTRLLR_ID         10
 430
 431#define MTOUCHUSB_REQ_CTRLLR_ID_LEN	16
 432
 433static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 434{
 435	if (hwcalib_xy) {
 436		dev->x = (pkt[4] << 8) | pkt[3];
 437		dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]);
 438	} else {
 439		dev->x = (pkt[8] << 8) | pkt[7];
 440		dev->y = (pkt[10] << 8) | pkt[9];
 441	}
 442	dev->touch = (pkt[2] & 0x40) ? 1 : 0;
 443
 444	return 1;
 445}
 446
 447struct mtouch_priv {
 448	u8 fw_rev_major;
 449	u8 fw_rev_minor;
 450};
 451
 452static ssize_t mtouch_firmware_rev_show(struct device *dev,
 453				struct device_attribute *attr, char *output)
 454{
 455	struct usb_interface *intf = to_usb_interface(dev);
 456	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
 457	struct mtouch_priv *priv = usbtouch->priv;
 458
 459	return scnprintf(output, PAGE_SIZE, "%1x.%1x\n",
 460			 priv->fw_rev_major, priv->fw_rev_minor);
 461}
 462static DEVICE_ATTR(firmware_rev, 0444, mtouch_firmware_rev_show, NULL);
 463
 464static struct attribute *mtouch_attrs[] = {
 465	&dev_attr_firmware_rev.attr,
 466	NULL
 467};
 468
 469static const struct attribute_group mtouch_attr_group = {
 470	.attrs = mtouch_attrs,
 471};
 472
 473static int mtouch_get_fw_revision(struct usbtouch_usb *usbtouch)
 474{
 475	struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 476	struct mtouch_priv *priv = usbtouch->priv;
 477	u8 *buf;
 478	int ret;
 479
 480	buf = kzalloc(MTOUCHUSB_REQ_CTRLLR_ID_LEN, GFP_NOIO);
 481	if (!buf)
 482		return -ENOMEM;
 483
 484	ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
 485			      MTOUCHUSB_REQ_CTRLLR_ID,
 486			      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 487			      0, 0, buf, MTOUCHUSB_REQ_CTRLLR_ID_LEN,
 488			      USB_CTRL_SET_TIMEOUT);
 489	if (ret != MTOUCHUSB_REQ_CTRLLR_ID_LEN) {
 490		dev_warn(&usbtouch->interface->dev,
 491			 "Failed to read FW rev: %d\n", ret);
 492		ret = ret < 0 ? ret : -EIO;
 493		goto free;
 494	}
 495
 496	priv->fw_rev_major = buf[3];
 497	priv->fw_rev_minor = buf[4];
 498
 499	ret = 0;
 500
 501free:
 502	kfree(buf);
 503	return ret;
 504}
 505
 506static int mtouch_alloc(struct usbtouch_usb *usbtouch)
 507{
 508	int ret;
 509
 510	usbtouch->priv = kmalloc(sizeof(struct mtouch_priv), GFP_KERNEL);
 511	if (!usbtouch->priv)
 512		return -ENOMEM;
 513
 514	ret = sysfs_create_group(&usbtouch->interface->dev.kobj,
 515				 &mtouch_attr_group);
 516	if (ret) {
 517		kfree(usbtouch->priv);
 518		usbtouch->priv = NULL;
 519		return ret;
 520	}
 521
 522	return 0;
 523}
 524
 525static int mtouch_init(struct usbtouch_usb *usbtouch)
 526{
 527	int ret, i;
 528	struct usb_device *udev = interface_to_usbdev(usbtouch->interface);
 529
 530	ret = mtouch_get_fw_revision(usbtouch);
 531	if (ret)
 532		return ret;
 533
 534	ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 535	                      MTOUCHUSB_RESET,
 536	                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 537	                      1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 538	dev_dbg(&usbtouch->interface->dev,
 539		"%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d\n",
 540		__func__, ret);
 541	if (ret < 0)
 542		return ret;
 543	msleep(150);
 544
 545	for (i = 0; i < 3; i++) {
 546		ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
 547				      MTOUCHUSB_ASYNC_REPORT,
 548				      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 549				      1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
 550		dev_dbg(&usbtouch->interface->dev,
 551			"%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d\n",
 552			__func__, ret);
 553		if (ret >= 0)
 554			break;
 555		if (ret != -EPIPE)
 556			return ret;
 557	}
 558
 559	/* Default min/max xy are the raw values, override if using hw-calib */
 560	if (hwcalib_xy) {
 561		input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0);
 562		input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0);
 563	}
 564
 565	return 0;
 566}
 567
 568static void mtouch_exit(struct usbtouch_usb *usbtouch)
 569{
 570	struct mtouch_priv *priv = usbtouch->priv;
 571
 572	sysfs_remove_group(&usbtouch->interface->dev.kobj, &mtouch_attr_group);
 573	kfree(priv);
 574}
 575#endif
 576
 577
 578/*****************************************************************************
 579 * ITM Part
 580 */
 581#ifdef CONFIG_TOUCHSCREEN_USB_ITM
 582static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 583{
 584	int touch;
 585	/*
 586	 * ITM devices report invalid x/y data if not touched.
 587	 * if the screen was touched before but is not touched any more
 588	 * report touch as 0 with the last valid x/y data once. then stop
 589	 * reporting data until touched again.
 590	 */
 591	dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);
 592
 593	touch = ~pkt[7] & 0x20;
 594	if (!touch) {
 595		if (dev->touch) {
 596			dev->touch = 0;
 597			return 1;
 598		}
 599
 600		return 0;
 601	}
 602
 603	dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
 604	dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
 605	dev->touch = touch;
 606
 607	return 1;
 608}
 609#endif
 610
 611
 612/*****************************************************************************
 613 * eTurboTouch part
 614 */
 615#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
 616#ifndef MULTI_PACKET
 617#define MULTI_PACKET
 618#endif
 619static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 620{
 621	unsigned int shift;
 622
 623	/* packets should start with sync */
 624	if (!(pkt[0] & 0x80))
 625		return 0;
 626
 627	shift = (6 - (pkt[0] & 0x03));
 628	dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
 629	dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
 630	dev->touch = (pkt[0] & 0x10) ? 1 : 0;
 631
 632	return 1;
 633}
 634
 635static int eturbo_get_pkt_len(unsigned char *buf, int len)
 636{
 637	if (buf[0] & 0x80)
 638		return 5;
 639	if (buf[0] == 0x01)
 640		return 3;
 641	return 0;
 642}
 643#endif
 644
 645
 646/*****************************************************************************
 647 * Gunze part
 648 */
 649#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
 650static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 651{
 652	if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
 653		return 0;
 654
 655	dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
 656	dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
 657	dev->touch = pkt[0] & 0x20;
 658
 659	return 1;
 660}
 661#endif
 662
 663/*****************************************************************************
 664 * DMC TSC-10/25 Part
 665 *
 666 * Documentation about the controller and it's protocol can be found at
 667 *   http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
 668 *   http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
 669 */
 670#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
 671
 672/* supported data rates. currently using 130 */
 673#define TSC10_RATE_POINT	0x50
 674#define TSC10_RATE_30		0x40
 675#define TSC10_RATE_50		0x41
 676#define TSC10_RATE_80		0x42
 677#define TSC10_RATE_100		0x43
 678#define TSC10_RATE_130		0x44
 679#define TSC10_RATE_150		0x45
 680
 681/* commands */
 682#define TSC10_CMD_RESET		0x55
 683#define TSC10_CMD_RATE		0x05
 684#define TSC10_CMD_DATA1		0x01
 685
 686static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
 687{
 688	struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
 689	int ret = -ENOMEM;
 690	unsigned char *buf;
 691
 692	buf = kmalloc(2, GFP_NOIO);
 693	if (!buf)
 694		goto err_nobuf;
 695	/* reset */
 696	buf[0] = buf[1] = 0xFF;
 697	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
 698	                      TSC10_CMD_RESET,
 699	                      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 700	                      0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 701	if (ret < 0)
 702		goto err_out;
 703	if (buf[0] != 0x06) {
 704		ret = -ENODEV;
 705		goto err_out;
 706	}
 707
 708	/* TSC-25 data sheet specifies a delay after the RESET command */
 709	msleep(150);
 710
 711	/* set coordinate output rate */
 712	buf[0] = buf[1] = 0xFF;
 713	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
 714	                      TSC10_CMD_RATE,
 715	                      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 716	                      TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
 717	if (ret < 0)
 718		goto err_out;
 719	if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) {
 720		ret = -ENODEV;
 721		goto err_out;
 722	}
 723
 724	/* start sending data */
 725	ret = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 726	                      TSC10_CMD_DATA1,
 727	                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
 728	                      0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
 729err_out:
 730	kfree(buf);
 731err_nobuf:
 732	return ret;
 733}
 734
 735
 736static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 737{
 738	dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
 739	dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
 740	dev->touch = pkt[0] & 0x01;
 741
 742	return 1;
 743}
 744#endif
 745
 746
 747/*****************************************************************************
 748 * IRTOUCH Part
 749 */
 750#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
 751static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 752{
 753	dev->x = (pkt[3] << 8) | pkt[2];
 754	dev->y = (pkt[5] << 8) | pkt[4];
 755	dev->touch = (pkt[1] & 0x03) ? 1 : 0;
 756
 757	return 1;
 758}
 759#endif
 760
 761/*****************************************************************************
 762 * ET&T TC5UH/TC4UM part
 763 */
 764#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
 765static int tc45usb_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 766{
 767	dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
 768	dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
 769	dev->touch = pkt[0] & 0x01;
 770
 771	return 1;
 772}
 773#endif
 774
 775/*****************************************************************************
 776 * IdealTEK URTC1000 Part
 777 */
 778#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
 779#ifndef MULTI_PACKET
 780#define MULTI_PACKET
 781#endif
 782static int idealtek_get_pkt_len(unsigned char *buf, int len)
 783{
 784	if (buf[0] & 0x80)
 785		return 5;
 786	if (buf[0] == 0x01)
 787		return len;
 788	return 0;
 789}
 790
 791static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 792{
 793	switch (pkt[0] & 0x98) {
 794	case 0x88:
 795		/* touch data in IdealTEK mode */
 796		dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
 797		dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
 798		dev->touch = (pkt[0] & 0x40) ? 1 : 0;
 799		return 1;
 800
 801	case 0x98:
 802		/* touch data in MT emulation mode */
 803		dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
 804		dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
 805		dev->touch = (pkt[0] & 0x40) ? 1 : 0;
 806		return 1;
 807
 808	default:
 809		return 0;
 810	}
 811}
 812#endif
 813
 814/*****************************************************************************
 815 * General Touch Part
 816 */
 817#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
 818static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 819{
 820	dev->x = (pkt[2] << 8) | pkt[1];
 821	dev->y = (pkt[4] << 8) | pkt[3];
 822	dev->press = pkt[5] & 0xff;
 823	dev->touch = pkt[0] & 0x01;
 824
 825	return 1;
 826}
 827#endif
 828
 829/*****************************************************************************
 830 * GoTop Part
 831 */
 832#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
 833static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 834{
 835	dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
 836	dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
 837	dev->touch = pkt[0] & 0x01;
 838
 839	return 1;
 840}
 841#endif
 842
 843/*****************************************************************************
 844 * JASTEC Part
 845 */
 846#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
 847static int jastec_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 848{
 849	dev->x = ((pkt[0] & 0x3f) << 6) | (pkt[2] & 0x3f);
 850	dev->y = ((pkt[1] & 0x3f) << 6) | (pkt[3] & 0x3f);
 851	dev->touch = (pkt[0] & 0x40) >> 6;
 852
 853	return 1;
 854}
 855#endif
 856
 857/*****************************************************************************
 858 * Zytronic Part
 859 */
 860#ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
 861static int zytronic_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
 862{
 863	struct usb_interface *intf = dev->interface;
 864
 865	switch (pkt[0]) {
 866	case 0x3A: /* command response */
 867		dev_dbg(&intf->dev, "%s: Command response %d\n", __func__, pkt[1]);
 868		break;
 869
 870	case 0xC0: /* down */
 871		dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
 872		dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
 873		dev->touch = 1;
 874		dev_dbg(&intf->dev, "%s: down %d,%d\n", __func__, dev->x, dev->y);
 875		return 1;
 876
 877	case 0x80: /* up */
 878		dev->x = (pkt[1] & 0x7f) | ((pkt[2] & 0x07) << 7);
 879		dev->y = (pkt[3] & 0x7f) | ((pkt[4] & 0x07) << 7);
 880		dev->touch = 0;
 881		dev_dbg(&intf->dev, "%s: up %d,%d\n", __func__, dev->x, dev->y);
 882		return 1;
 883
 884	default:
 885		dev_dbg(&intf->dev, "%s: Unknown return %d\n", __func__, pkt[0]);
 886		break;
 887	}
 888
 889	return 0;
 890}
 891#endif
 892
 893/*****************************************************************************
 894 * NEXIO Part
 895 */
 896#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
 897
 898#define NEXIO_TIMEOUT	5000
 899#define NEXIO_BUFSIZE	1024
 900#define NEXIO_THRESHOLD	50
 901
 902struct nexio_priv {
 903	struct urb *ack;
 904	unsigned char *ack_buf;
 905};
 906
 907struct nexio_touch_packet {
 908	u8	flags;		/* 0xe1 = touch, 0xe1 = release */
 909	__be16	data_len;	/* total bytes of touch data */
 910	__be16	x_len;		/* bytes for X axis */
 911	__be16	y_len;		/* bytes for Y axis */
 912	u8	data[];
 913} __attribute__ ((packed));
 914
 915static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 };
 916static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f };
 917
 918static void nexio_ack_complete(struct urb *urb)
 919{
 920}
 921
 922static int nexio_alloc(struct usbtouch_usb *usbtouch)
 923{
 924	struct nexio_priv *priv;
 925	int ret = -ENOMEM;
 926
 927	usbtouch->priv = kmalloc(sizeof(struct nexio_priv), GFP_KERNEL);
 928	if (!usbtouch->priv)
 929		goto out_buf;
 930
 931	priv = usbtouch->priv;
 932
 933	priv->ack_buf = kmemdup(nexio_ack_pkt, sizeof(nexio_ack_pkt),
 934				GFP_KERNEL);
 935	if (!priv->ack_buf)
 936		goto err_priv;
 937
 938	priv->ack = usb_alloc_urb(0, GFP_KERNEL);
 939	if (!priv->ack) {
 940		dev_dbg(&usbtouch->interface->dev,
 941			"%s - usb_alloc_urb failed: usbtouch->ack\n", __func__);
 942		goto err_ack_buf;
 943	}
 944
 945	return 0;
 946
 947err_ack_buf:
 948	kfree(priv->ack_buf);
 949err_priv:
 950	kfree(priv);
 951out_buf:
 952	return ret;
 953}
 954
 955static int nexio_init(struct usbtouch_usb *usbtouch)
 956{
 957	struct usb_device *dev = interface_to_usbdev(usbtouch->interface);
 958	struct usb_host_interface *interface = usbtouch->interface->cur_altsetting;
 959	struct nexio_priv *priv = usbtouch->priv;
 960	int ret = -ENOMEM;
 961	int actual_len, i;
 962	unsigned char *buf;
 963	char *firmware_ver = NULL, *device_name = NULL;
 964	int input_ep = 0, output_ep = 0;
 965
 966	/* find first input and output endpoint */
 967	for (i = 0; i < interface->desc.bNumEndpoints; i++) {
 968		if (!input_ep &&
 969		    usb_endpoint_dir_in(&interface->endpoint[i].desc))
 970			input_ep = interface->endpoint[i].desc.bEndpointAddress;
 971		if (!output_ep &&
 972		    usb_endpoint_dir_out(&interface->endpoint[i].desc))
 973			output_ep = interface->endpoint[i].desc.bEndpointAddress;
 974	}
 975	if (!input_ep || !output_ep)
 976		return -ENXIO;
 977
 978	buf = kmalloc(NEXIO_BUFSIZE, GFP_NOIO);
 979	if (!buf)
 980		goto out_buf;
 981
 982	/* two empty reads */
 983	for (i = 0; i < 2; i++) {
 984		ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
 985				   buf, NEXIO_BUFSIZE, &actual_len,
 986				   NEXIO_TIMEOUT);
 987		if (ret < 0)
 988			goto out_buf;
 989	}
 990
 991	/* send init command */
 992	memcpy(buf, nexio_init_pkt, sizeof(nexio_init_pkt));
 993	ret = usb_bulk_msg(dev, usb_sndbulkpipe(dev, output_ep),
 994			   buf, sizeof(nexio_init_pkt), &actual_len,
 995			   NEXIO_TIMEOUT);
 996	if (ret < 0)
 997		goto out_buf;
 998
 999	/* read replies */
1000	for (i = 0; i < 3; i++) {
1001		memset(buf, 0, NEXIO_BUFSIZE);
1002		ret = usb_bulk_msg(dev, usb_rcvbulkpipe(dev, input_ep),
1003				   buf, NEXIO_BUFSIZE, &actual_len,
1004				   NEXIO_TIMEOUT);
1005		if (ret < 0 || actual_len < 1 || buf[1] != actual_len)
1006			continue;
1007		switch (buf[0]) {
1008		case 0x83:	/* firmware version */
1009			if (!firmware_ver)
1010				firmware_ver = kstrdup(&buf[2], GFP_NOIO);
1011			break;
1012		case 0x84:	/* device name */
1013			if (!device_name)
1014				device_name = kstrdup(&buf[2], GFP_NOIO);
1015			break;
1016		}
1017	}
1018
1019	printk(KERN_INFO "Nexio device: %s, firmware version: %s\n",
1020	       device_name, firmware_ver);
1021
1022	kfree(firmware_ver);
1023	kfree(device_name);
1024
1025	usb_fill_bulk_urb(priv->ack, dev, usb_sndbulkpipe(dev, output_ep),
1026			  priv->ack_buf, sizeof(nexio_ack_pkt),
1027			  nexio_ack_complete, usbtouch);
1028	ret = 0;
1029
1030out_buf:
1031	kfree(buf);
1032	return ret;
1033}
1034
1035static void nexio_exit(struct usbtouch_usb *usbtouch)
1036{
1037	struct nexio_priv *priv = usbtouch->priv;
1038
1039	usb_kill_urb(priv->ack);
1040	usb_free_urb(priv->ack);
1041	kfree(priv->ack_buf);
1042	kfree(priv);
1043}
1044
1045static int nexio_read_data(struct usbtouch_usb *usbtouch, unsigned char *pkt)
1046{
1047	struct device *dev = &usbtouch->interface->dev;
1048	struct nexio_touch_packet *packet = (void *) pkt;
1049	struct nexio_priv *priv = usbtouch->priv;
1050	unsigned int data_len = be16_to_cpu(packet->data_len);
1051	unsigned int x_len = be16_to_cpu(packet->x_len);
1052	unsigned int y_len = be16_to_cpu(packet->y_len);
1053	int x, y, begin_x, begin_y, end_x, end_y, w, h, ret;
1054
1055	/* got touch data? */
1056	if ((pkt[0] & 0xe0) != 0xe0)
1057		return 0;
1058
1059	if (data_len > 0xff)
1060		data_len -= 0x100;
1061	if (x_len > 0xff)
1062		x_len -= 0x80;
1063
1064	/* send ACK */
1065	ret = usb_submit_urb(priv->ack, GFP_ATOMIC);
1066	if (ret)
1067		dev_warn(dev, "Failed to submit ACK URB: %d\n", ret);
1068
1069	if (!usbtouch->type->max_xc) {
1070		usbtouch->type->max_xc = 2 * x_len;
1071		input_set_abs_params(usbtouch->input, ABS_X,
1072				     0, usbtouch->type->max_xc, 0, 0);
1073		usbtouch->type->max_yc = 2 * y_len;
1074		input_set_abs_params(usbtouch->input, ABS_Y,
1075				     0, usbtouch->type->max_yc, 0, 0);
1076	}
1077	/*
1078	 * The device reports state of IR sensors on X and Y axes.
1079	 * Each byte represents "darkness" percentage (0-100) of one element.
1080	 * 17" touchscreen reports only 64 x 52 bytes so the resolution is low.
1081	 * This also means that there's a limited multi-touch capability but
1082	 * it's disabled (and untested) here as there's no X driver for that.
1083	 */
1084	begin_x = end_x = begin_y = end_y = -1;
1085	for (x = 0; x < x_len; x++) {
1086		if (begin_x == -1 && packet->data[x] > NEXIO_THRESHOLD) {
1087			begin_x = x;
1088			continue;
1089		}
1090		if (end_x == -1 && begin_x != -1 && packet->data[x] < NEXIO_THRESHOLD) {
1091			end_x = x - 1;
1092			for (y = x_len; y < data_len; y++) {
1093				if (begin_y == -1 && packet->data[y] > NEXIO_THRESHOLD) {
1094					begin_y = y - x_len;
1095					continue;
1096				}
1097				if (end_y == -1 &&
1098				    begin_y != -1 && packet->data[y] < NEXIO_THRESHOLD) {
1099					end_y = y - 1 - x_len;
1100					w = end_x - begin_x;
1101					h = end_y - begin_y;
1102#if 0
1103					/* multi-touch */
1104					input_report_abs(usbtouch->input,
1105						    ABS_MT_TOUCH_MAJOR, max(w,h));
1106					input_report_abs(usbtouch->input,
1107						    ABS_MT_TOUCH_MINOR, min(x,h));
1108					input_report_abs(usbtouch->input,
1109						    ABS_MT_POSITION_X, 2*begin_x+w);
1110					input_report_abs(usbtouch->input,
1111						    ABS_MT_POSITION_Y, 2*begin_y+h);
1112					input_report_abs(usbtouch->input,
1113						    ABS_MT_ORIENTATION, w > h);
1114					input_mt_sync(usbtouch->input);
1115#endif
1116					/* single touch */
1117					usbtouch->x = 2 * begin_x + w;
1118					usbtouch->y = 2 * begin_y + h;
1119					usbtouch->touch = packet->flags & 0x01;
1120					begin_y = end_y = -1;
1121					return 1;
1122				}
1123			}
1124			begin_x = end_x = -1;
1125		}
1126
1127	}
1128	return 0;
1129}
1130#endif
1131
1132
1133/*****************************************************************************
1134 * ELO part
1135 */
1136
1137#ifdef CONFIG_TOUCHSCREEN_USB_ELO
1138
1139static int elo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
1140{
1141	dev->x = (pkt[3] << 8) | pkt[2];
1142	dev->y = (pkt[5] << 8) | pkt[4];
1143	dev->touch = pkt[6] > 0;
1144	dev->press = pkt[6];
1145
1146	return 1;
1147}
1148#endif
1149
1150
1151/*****************************************************************************
1152 * the different device descriptors
1153 */
1154#ifdef MULTI_PACKET
1155static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
1156				   unsigned char *pkt, int len);
1157#endif
1158
1159static struct usbtouch_device_info usbtouch_dev_info[] = {
1160#ifdef CONFIG_TOUCHSCREEN_USB_ELO
1161	[DEVTYPE_ELO] = {
1162		.min_xc		= 0x0,
1163		.max_xc		= 0x0fff,
1164		.min_yc		= 0x0,
1165		.max_yc		= 0x0fff,
1166		.max_press	= 0xff,
1167		.rept_size	= 8,
1168		.read_data	= elo_read_data,
1169	},
1170#endif
1171
1172#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
1173	[DEVTYPE_EGALAX] = {
1174		.min_xc		= 0x0,
1175		.max_xc		= 0x07ff,
1176		.min_yc		= 0x0,
1177		.max_yc		= 0x07ff,
1178		.rept_size	= 16,
1179		.process_pkt	= usbtouch_process_multi,
1180		.get_pkt_len	= egalax_get_pkt_len,
1181		.read_data	= egalax_read_data,
1182		.init		= egalax_init,
1183	},
1184#endif
1185
1186#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
1187	[DEVTYPE_PANJIT] = {
1188		.min_xc		= 0x0,
1189		.max_xc		= 0x0fff,
1190		.min_yc		= 0x0,
1191		.max_yc		= 0x0fff,
1192		.rept_size	= 8,
1193		.read_data	= panjit_read_data,
1194	},
1195#endif
1196
1197#ifdef CONFIG_TOUCHSCREEN_USB_3M
1198	[DEVTYPE_3M] = {
1199		.min_xc		= 0x0,
1200		.max_xc		= 0x4000,
1201		.min_yc		= 0x0,
1202		.max_yc		= 0x4000,
1203		.rept_size	= 11,
1204		.read_data	= mtouch_read_data,
1205		.alloc		= mtouch_alloc,
1206		.init		= mtouch_init,
1207		.exit		= mtouch_exit,
1208	},
1209#endif
1210
1211#ifdef CONFIG_TOUCHSCREEN_USB_ITM
1212	[DEVTYPE_ITM] = {
1213		.min_xc		= 0x0,
1214		.max_xc		= 0x0fff,
1215		.min_yc		= 0x0,
1216		.max_yc		= 0x0fff,
1217		.max_press	= 0xff,
1218		.rept_size	= 8,
1219		.read_data	= itm_read_data,
1220	},
1221#endif
1222
1223#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
1224	[DEVTYPE_ETURBO] = {
1225		.min_xc		= 0x0,
1226		.max_xc		= 0x07ff,
1227		.min_yc		= 0x0,
1228		.max_yc		= 0x07ff,
1229		.rept_size	= 8,
1230		.process_pkt	= usbtouch_process_multi,
1231		.get_pkt_len	= eturbo_get_pkt_len,
1232		.read_data	= eturbo_read_data,
1233	},
1234#endif
1235
1236#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
1237	[DEVTYPE_GUNZE] = {
1238		.min_xc		= 0x0,
1239		.max_xc		= 0x0fff,
1240		.min_yc		= 0x0,
1241		.max_yc		= 0x0fff,
1242		.rept_size	= 4,
1243		.read_data	= gunze_read_data,
1244	},
1245#endif
1246
1247#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
1248	[DEVTYPE_DMC_TSC10] = {
1249		.min_xc		= 0x0,
1250		.max_xc		= 0x03ff,
1251		.min_yc		= 0x0,
1252		.max_yc		= 0x03ff,
1253		.rept_size	= 5,
1254		.init		= dmc_tsc10_init,
1255		.read_data	= dmc_tsc10_read_data,
1256	},
1257#endif
1258
1259#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
1260	[DEVTYPE_IRTOUCH] = {
1261		.min_xc		= 0x0,
1262		.max_xc		= 0x0fff,
1263		.min_yc		= 0x0,
1264		.max_yc		= 0x0fff,
1265		.rept_size	= 8,
1266		.read_data	= irtouch_read_data,
1267	},
1268
1269	[DEVTYPE_IRTOUCH_HIRES] = {
1270		.min_xc		= 0x0,
1271		.max_xc		= 0x7fff,
1272		.min_yc		= 0x0,
1273		.max_yc		= 0x7fff,
1274		.rept_size	= 8,
1275		.read_data	= irtouch_read_data,
1276	},
1277#endif
1278
1279#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
1280	[DEVTYPE_IDEALTEK] = {
1281		.min_xc		= 0x0,
1282		.max_xc		= 0x0fff,
1283		.min_yc		= 0x0,
1284		.max_yc		= 0x0fff,
1285		.rept_size	= 8,
1286		.process_pkt	= usbtouch_process_multi,
1287		.get_pkt_len	= idealtek_get_pkt_len,
1288		.read_data	= idealtek_read_data,
1289	},
1290#endif
1291
1292#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
1293	[DEVTYPE_GENERAL_TOUCH] = {
1294		.min_xc		= 0x0,
1295		.max_xc		= 0x7fff,
1296		.min_yc		= 0x0,
1297		.max_yc		= 0x7fff,
1298		.rept_size	= 7,
1299		.read_data	= general_touch_read_data,
1300	},
1301#endif
1302
1303#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
1304	[DEVTYPE_GOTOP] = {
1305		.min_xc		= 0x0,
1306		.max_xc		= 0x03ff,
1307		.min_yc		= 0x0,
1308		.max_yc		= 0x03ff,
1309		.rept_size	= 4,
1310		.read_data	= gotop_read_data,
1311	},
1312#endif
1313
1314#ifdef CONFIG_TOUCHSCREEN_USB_JASTEC
1315	[DEVTYPE_JASTEC] = {
1316		.min_xc		= 0x0,
1317		.max_xc		= 0x0fff,
1318		.min_yc		= 0x0,
1319		.max_yc		= 0x0fff,
1320		.rept_size	= 4,
1321		.read_data	= jastec_read_data,
1322	},
1323#endif
1324
1325#ifdef CONFIG_TOUCHSCREEN_USB_E2I
1326	[DEVTYPE_E2I] = {
1327		.min_xc		= 0x0,
1328		.max_xc		= 0x7fff,
1329		.min_yc		= 0x0,
1330		.max_yc		= 0x7fff,
1331		.rept_size	= 6,
1332		.init		= e2i_init,
1333		.read_data	= e2i_read_data,
1334	},
1335#endif
1336
1337#ifdef CONFIG_TOUCHSCREEN_USB_ZYTRONIC
1338	[DEVTYPE_ZYTRONIC] = {
1339		.min_xc		= 0x0,
1340		.max_xc		= 0x03ff,
1341		.min_yc		= 0x0,
1342		.max_yc		= 0x03ff,
1343		.rept_size	= 5,
1344		.read_data	= zytronic_read_data,
1345		.irq_always     = true,
1346	},
1347#endif
1348
1349#ifdef CONFIG_TOUCHSCREEN_USB_ETT_TC45USB
1350	[DEVTYPE_TC45USB] = {
1351		.min_xc		= 0x0,
1352		.max_xc		= 0x0fff,
1353		.min_yc		= 0x0,
1354		.max_yc		= 0x0fff,
1355		.rept_size	= 5,
1356		.read_data	= tc45usb_read_data,
1357	},
1358#endif
1359
1360#ifdef CONFIG_TOUCHSCREEN_USB_NEXIO
1361	[DEVTYPE_NEXIO] = {
1362		.rept_size	= 1024,
1363		.irq_always	= true,
1364		.read_data	= nexio_read_data,
1365		.alloc		= nexio_alloc,
1366		.init		= nexio_init,
1367		.exit		= nexio_exit,
1368	},
1369#endif
1370#ifdef CONFIG_TOUCHSCREEN_USB_EASYTOUCH
1371	[DEVTYPE_ETOUCH] = {
1372		.min_xc		= 0x0,
1373		.max_xc		= 0x07ff,
1374		.min_yc		= 0x0,
1375		.max_yc		= 0x07ff,
1376		.rept_size	= 16,
1377		.process_pkt	= usbtouch_process_multi,
1378		.get_pkt_len	= etouch_get_pkt_len,
1379		.read_data	= etouch_read_data,
1380	},
1381#endif
1382};
1383
1384
1385/*****************************************************************************
1386 * Generic Part
1387 */
1388static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
1389                                 unsigned char *pkt, int len)
1390{
1391	struct usbtouch_device_info *type = usbtouch->type;
1392
1393	if (!type->read_data(usbtouch, pkt))
1394			return;
1395
1396	input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
1397
1398	if (swap_xy) {
1399		input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
1400		input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
1401	} else {
1402		input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
1403		input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
1404	}
1405	if (type->max_press)
1406		input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
1407	input_sync(usbtouch->input);
1408}
1409
1410
1411#ifdef MULTI_PACKET
1412static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
1413                                   unsigned char *pkt, int len)
1414{
1415	unsigned char *buffer;
1416	int pkt_len, pos, buf_len, tmp;
1417
1418	/* process buffer */
1419	if (unlikely(usbtouch->buf_len)) {
1420		/* try to get size */
1421		pkt_len = usbtouch->type->get_pkt_len(
1422				usbtouch->buffer, usbtouch->buf_len);
1423
1424		/* drop? */
1425		if (unlikely(!pkt_len))
1426			goto out_flush_buf;
1427
1428		/* need to append -pkt_len bytes before able to get size */
1429		if (unlikely(pkt_len < 0)) {
1430			int append = -pkt_len;
1431			if (unlikely(append > len))
1432			       append = len;
1433			if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
1434				goto out_flush_buf;
1435			memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
1436			usbtouch->buf_len += append;
1437
1438			pkt_len = usbtouch->type->get_pkt_len(
1439					usbtouch->buffer, usbtouch->buf_len);
1440			if (pkt_len < 0)
1441				return;
1442		}
1443
1444		/* append */
1445		tmp = pkt_len - usbtouch->buf_len;
1446		if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
1447			goto out_flush_buf;
1448		memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
1449		usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);
1450
1451		buffer = pkt + tmp;
1452		buf_len = len - tmp;
1453	} else {
1454		buffer = pkt;
1455		buf_len = len;
1456	}
1457
1458	/* loop over the received packet, process */
1459	pos = 0;
1460	while (pos < buf_len) {
1461		/* get packet len */
1462		pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
1463							buf_len - pos);
1464
1465		/* unknown packet: skip one byte */
1466		if (unlikely(!pkt_len)) {
1467			pos++;
1468			continue;
1469		}
1470
1471		/* full packet: process */
1472		if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
1473			usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
1474		} else {
1475			/* incomplete packet: save in buffer */
1476			memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
1477			usbtouch->buf_len = buf_len - pos;
1478			return;
1479		}
1480		pos += pkt_len;
1481	}
1482
1483out_flush_buf:
1484	usbtouch->buf_len = 0;
1485	return;
1486}
1487#endif
1488
1489
1490static void usbtouch_irq(struct urb *urb)
1491{
1492	struct usbtouch_usb *usbtouch = urb->context;
1493	struct device *dev = &usbtouch->interface->dev;
1494	int retval;
1495
1496	switch (urb->status) {
1497	case 0:
1498		/* success */
1499		break;
1500	case -ETIME:
1501		/* this urb is timing out */
1502		dev_dbg(dev,
1503			"%s - urb timed out - was the device unplugged?\n",
1504			__func__);
1505		return;
1506	case -ECONNRESET:
1507	case -ENOENT:
1508	case -ESHUTDOWN:
1509	case -EPIPE:
1510		/* this urb is terminated, clean up */
1511		dev_dbg(dev, "%s - urb shutting down with status: %d\n",
1512			__func__, urb->status);
1513		return;
1514	default:
1515		dev_dbg(dev, "%s - nonzero urb status received: %d\n",
1516			__func__, urb->status);
1517		goto exit;
1518	}
1519
1520	usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
1521
1522exit:
1523	usb_mark_last_busy(interface_to_usbdev(usbtouch->interface));
1524	retval = usb_submit_urb(urb, GFP_ATOMIC);
1525	if (retval)
1526		dev_err(dev, "%s - usb_submit_urb failed with result: %d\n",
1527			__func__, retval);
1528}
1529
1530static int usbtouch_open(struct input_dev *input)
1531{
1532	struct usbtouch_usb *usbtouch = input_get_drvdata(input);
1533	int r;
1534
1535	usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface);
1536
1537	r = usb_autopm_get_interface(usbtouch->interface) ? -EIO : 0;
1538	if (r < 0)
1539		goto out;
1540
1541	mutex_lock(&usbtouch->pm_mutex);
1542	if (!usbtouch->type->irq_always) {
1543		if (usb_submit_urb(usbtouch->irq, GFP_KERNEL)) {
1544			r = -EIO;
1545			goto out_put;
1546		}
1547	}
1548
1549	usbtouch->interface->needs_remote_wakeup = 1;
1550	usbtouch->is_open = true;
1551out_put:
1552	mutex_unlock(&usbtouch->pm_mutex);
1553	usb_autopm_put_interface(usbtouch->interface);
1554out:
1555	return r;
1556}
1557
1558static void usbtouch_close(struct input_dev *input)
1559{
1560	struct usbtouch_usb *usbtouch = input_get_drvdata(input);
1561	int r;
1562
1563	mutex_lock(&usbtouch->pm_mutex);
1564	if (!usbtouch->type->irq_always)
1565		usb_kill_urb(usbtouch->irq);
1566	usbtouch->is_open = false;
1567	mutex_unlock(&usbtouch->pm_mutex);
1568
1569	r = usb_autopm_get_interface(usbtouch->interface);
1570	usbtouch->interface->needs_remote_wakeup = 0;
1571	if (!r)
1572		usb_autopm_put_interface(usbtouch->interface);
1573}
1574
1575static int usbtouch_suspend
1576(struct usb_interface *intf, pm_message_t message)
1577{
1578	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1579
1580	usb_kill_urb(usbtouch->irq);
1581
1582	return 0;
1583}
1584
1585static int usbtouch_resume(struct usb_interface *intf)
1586{
1587	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1588	int result = 0;
1589
1590	mutex_lock(&usbtouch->pm_mutex);
1591	if (usbtouch->is_open || usbtouch->type->irq_always)
1592		result = usb_submit_urb(usbtouch->irq, GFP_NOIO);
1593	mutex_unlock(&usbtouch->pm_mutex);
1594
1595	return result;
1596}
1597
1598static int usbtouch_reset_resume(struct usb_interface *intf)
1599{
1600	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1601	int err = 0;
1602
1603	/* reinit the device */
1604	if (usbtouch->type->init) {
1605		err = usbtouch->type->init(usbtouch);
1606		if (err) {
1607			dev_dbg(&intf->dev,
1608				"%s - type->init() failed, err: %d\n",
1609				__func__, err);
1610			return err;
1611		}
1612	}
1613
1614	/* restart IO if needed */
1615	mutex_lock(&usbtouch->pm_mutex);
1616	if (usbtouch->is_open)
1617		err = usb_submit_urb(usbtouch->irq, GFP_NOIO);
1618	mutex_unlock(&usbtouch->pm_mutex);
1619
1620	return err;
1621}
1622
1623static void usbtouch_free_buffers(struct usb_device *udev,
1624				  struct usbtouch_usb *usbtouch)
1625{
1626	usb_free_coherent(udev, usbtouch->data_size,
1627			  usbtouch->data, usbtouch->data_dma);
1628	kfree(usbtouch->buffer);
1629}
1630
1631static struct usb_endpoint_descriptor *
1632usbtouch_get_input_endpoint(struct usb_host_interface *interface)
1633{
1634	int i;
1635
1636	for (i = 0; i < interface->desc.bNumEndpoints; i++)
1637		if (usb_endpoint_dir_in(&interface->endpoint[i].desc))
1638			return &interface->endpoint[i].desc;
1639
1640	return NULL;
1641}
1642
1643static int usbtouch_probe(struct usb_interface *intf,
1644			  const struct usb_device_id *id)
1645{
1646	struct usbtouch_usb *usbtouch;
1647	struct input_dev *input_dev;
1648	struct usb_endpoint_descriptor *endpoint;
1649	struct usb_device *udev = interface_to_usbdev(intf);
1650	struct usbtouch_device_info *type;
1651	int err = -ENOMEM;
1652
1653	/* some devices are ignored */
1654	if (id->driver_info == DEVTYPE_IGNORE)
1655		return -ENODEV;
1656
1657	if (id->driver_info >= ARRAY_SIZE(usbtouch_dev_info))
1658		return -ENODEV;
1659
1660	endpoint = usbtouch_get_input_endpoint(intf->cur_altsetting);
1661	if (!endpoint)
1662		return -ENXIO;
1663
1664	usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
1665	input_dev = input_allocate_device();
1666	if (!usbtouch || !input_dev)
1667		goto out_free;
1668
1669	mutex_init(&usbtouch->pm_mutex);
1670
1671	type = &usbtouch_dev_info[id->driver_info];
1672	usbtouch->type = type;
1673	if (!type->process_pkt)
1674		type->process_pkt = usbtouch_process_pkt;
1675
1676	usbtouch->data_size = type->rept_size;
1677	if (type->get_pkt_len) {
1678		/*
1679		 * When dealing with variable-length packets we should
1680		 * not request more than wMaxPacketSize bytes at once
1681		 * as we do not know if there is more data coming or
1682		 * we filled exactly wMaxPacketSize bytes and there is
1683		 * nothing else.
1684		 */
1685		usbtouch->data_size = min(usbtouch->data_size,
1686					  usb_endpoint_maxp(endpoint));
1687	}
1688
1689	usbtouch->data = usb_alloc_coherent(udev, usbtouch->data_size,
1690					    GFP_KERNEL, &usbtouch->data_dma);
1691	if (!usbtouch->data)
1692		goto out_free;
1693
1694	if (type->get_pkt_len) {
1695		usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
1696		if (!usbtouch->buffer)
1697			goto out_free_buffers;
1698	}
1699
1700	usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
1701	if (!usbtouch->irq) {
1702		dev_dbg(&intf->dev,
1703			"%s - usb_alloc_urb failed: usbtouch->irq\n", __func__);
1704		goto out_free_buffers;
1705	}
1706
1707	usbtouch->interface = intf;
1708	usbtouch->input = input_dev;
1709
1710	if (udev->manufacturer)
1711		strscpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));
1712
1713	if (udev->product) {
1714		if (udev->manufacturer)
1715			strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
1716		strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
1717	}
1718
1719	if (!strlen(usbtouch->name))
1720		snprintf(usbtouch->name, sizeof(usbtouch->name),
1721			"USB Touchscreen %04x:%04x",
1722			 le16_to_cpu(udev->descriptor.idVendor),
1723			 le16_to_cpu(udev->descriptor.idProduct));
1724
1725	usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
1726	strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));
1727
1728	input_dev->name = usbtouch->name;
1729	input_dev->phys = usbtouch->phys;
1730	usb_to_input_id(udev, &input_dev->id);
1731	input_dev->dev.parent = &intf->dev;
1732
1733	input_set_drvdata(input_dev, usbtouch);
1734
1735	input_dev->open = usbtouch_open;
1736	input_dev->close = usbtouch_close;
1737
1738	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
1739	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
1740	input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
1741	input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
1742	if (type->max_press)
1743		input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
1744		                     type->max_press, 0, 0);
1745
1746	if (usb_endpoint_type(endpoint) == USB_ENDPOINT_XFER_INT)
1747		usb_fill_int_urb(usbtouch->irq, udev,
1748			 usb_rcvintpipe(udev, endpoint->bEndpointAddress),
1749			 usbtouch->data, usbtouch->data_size,
1750			 usbtouch_irq, usbtouch, endpoint->bInterval);
1751	else
1752		usb_fill_bulk_urb(usbtouch->irq, udev,
1753			 usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
1754			 usbtouch->data, usbtouch->data_size,
1755			 usbtouch_irq, usbtouch);
1756
1757	usbtouch->irq->dev = udev;
1758	usbtouch->irq->transfer_dma = usbtouch->data_dma;
1759	usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1760
1761	/* device specific allocations */
1762	if (type->alloc) {
1763		err = type->alloc(usbtouch);
1764		if (err) {
1765			dev_dbg(&intf->dev,
1766				"%s - type->alloc() failed, err: %d\n",
1767				__func__, err);
1768			goto out_free_urb;
1769		}
1770	}
1771
1772	/* device specific initialisation*/
1773	if (type->init) {
1774		err = type->init(usbtouch);
1775		if (err) {
1776			dev_dbg(&intf->dev,
1777				"%s - type->init() failed, err: %d\n",
1778				__func__, err);
1779			goto out_do_exit;
1780		}
1781	}
1782
1783	err = input_register_device(usbtouch->input);
1784	if (err) {
1785		dev_dbg(&intf->dev,
1786			"%s - input_register_device failed, err: %d\n",
1787			__func__, err);
1788		goto out_do_exit;
1789	}
1790
1791	usb_set_intfdata(intf, usbtouch);
1792
1793	if (usbtouch->type->irq_always) {
1794		/* this can't fail */
1795		usb_autopm_get_interface(intf);
1796		err = usb_submit_urb(usbtouch->irq, GFP_KERNEL);
1797		if (err) {
1798			usb_autopm_put_interface(intf);
1799			dev_err(&intf->dev,
1800				"%s - usb_submit_urb failed with result: %d\n",
1801				__func__, err);
1802			goto out_unregister_input;
1803		}
1804	}
1805
1806	return 0;
1807
1808out_unregister_input:
1809	input_unregister_device(input_dev);
1810	input_dev = NULL;
1811out_do_exit:
1812	if (type->exit)
1813		type->exit(usbtouch);
1814out_free_urb:
1815	usb_free_urb(usbtouch->irq);
1816out_free_buffers:
1817	usbtouch_free_buffers(udev, usbtouch);
1818out_free:
1819	input_free_device(input_dev);
1820	kfree(usbtouch);
1821	return err;
1822}
1823
1824static void usbtouch_disconnect(struct usb_interface *intf)
1825{
1826	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
1827
1828	if (!usbtouch)
1829		return;
1830
1831	dev_dbg(&intf->dev,
1832		"%s - usbtouch is initialized, cleaning up\n", __func__);
1833
1834	usb_set_intfdata(intf, NULL);
1835	/* this will stop IO via close */
1836	input_unregister_device(usbtouch->input);
1837	usb_free_urb(usbtouch->irq);
1838	if (usbtouch->type->exit)
1839		usbtouch->type->exit(usbtouch);
1840	usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
1841	kfree(usbtouch);
1842}
1843
1844MODULE_DEVICE_TABLE(usb, usbtouch_devices);
1845
1846static struct usb_driver usbtouch_driver = {
1847	.name		= "usbtouchscreen",
1848	.probe		= usbtouch_probe,
1849	.disconnect	= usbtouch_disconnect,
1850	.suspend	= usbtouch_suspend,
1851	.resume		= usbtouch_resume,
1852	.reset_resume	= usbtouch_reset_resume,
1853	.id_table	= usbtouch_devices,
1854	.supports_autosuspend = 1,
1855};
1856
1857module_usb_driver(usbtouch_driver);
1858
1859MODULE_AUTHOR("Daniel Ritz <daniel.ritz@gmx.ch>");
1860MODULE_DESCRIPTION("USB Touchscreen Driver");
1861MODULE_LICENSE("GPL");
1862
1863MODULE_ALIAS("touchkitusb");
1864MODULE_ALIAS("itmtouch");
1865MODULE_ALIAS("mtouchusb");