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