usbtouchscreen.c 25.7 KB
Newer Older
1 2 3 4
/******************************************************************************
 * usbtouchscreen.c
 * Driver for USB Touchscreens, supporting those devices:
 *  - eGalax Touchkit
D
Daniel Ritz 已提交
5 6
 *    includes eTurboTouch CT-410/510/700
 *  - 3M/Microtouch  EX II series
7 8
 *  - ITM
 *  - PanJit TouchSet
D
Daniel Ritz 已提交
9 10
 *  - eTurboTouch
 *  - Gunze AHL61
11
 *  - DMC TSC-10/25
12
 *  - IRTOUCHSYSTEMS/UNITOP
13
 *  - IdealTEK URTC1000
14
 *  - General Touch
15
 *  - GoTop Super_Q2/GogoPen/PenPower tablets
16
 *
17
 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
 * Copyright (C) by Todd E. Johnson (mtouchusb.c)
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 * Driver is based on touchkitusb.c
 * - ITM parts are from itmtouch.c
 * - 3M parts are from mtouchusb.c
 * - PanJit parts are from an unmerged driver by Lanslott Gish
38 39
 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged
 *   driver from Marius Vollmer
40 41 42 43 44 45 46 47 48 49 50
 *
 *****************************************************************************/

//#define DEBUG

#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/usb.h>
51
#include <linux/usb/input.h>
52
#include <linux/hid.h>
53 54


55
#define DRIVER_VERSION		"v0.6"
56 57 58 59 60 61 62
#define DRIVER_AUTHOR		"Daniel Ritz <daniel.ritz@gmx.ch>"
#define DRIVER_DESC		"USB Touchscreen Driver"

static int swap_xy;
module_param(swap_xy, bool, 0644);
MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");

63 64 65 66
static int hwcalib_xy;
module_param(hwcalib_xy, bool, 0644);
MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");

67 68 69 70 71 72 73 74
/* device specifc data/functions */
struct usbtouch_usb;
struct usbtouch_device_info {
	int min_xc, max_xc;
	int min_yc, max_yc;
	int min_press, max_press;
	int rept_size;

75
	void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
76 77 78 79 80 81 82

	/*
	 * used to get the packet len. possible return values:
	 * > 0: packet len
	 * = 0: skip one byte
	 * < 0: -return value more bytes needed
	 */
D
Daniel Ritz 已提交
83
	int  (*get_pkt_len) (unsigned char *pkt, int len);
84

85
	int  (*read_data)   (struct usbtouch_usb *usbtouch, unsigned char *pkt);
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
	int  (*init)        (struct usbtouch_usb *usbtouch);
};

/* a usbtouch device */
struct usbtouch_usb {
	unsigned char *data;
	dma_addr_t data_dma;
	unsigned char *buffer;
	int buf_len;
	struct urb *irq;
	struct usb_device *udev;
	struct input_dev *input;
	struct usbtouch_device_info *type;
	char name[128];
	char phys[64];
101 102 103

	int x, y;
	int touch, press;
104 105
};

D
Daniel Ritz 已提交
106

107 108
/* device types */
enum {
109
	DEVTYPE_IGNORE = -1,
110 111 112 113
	DEVTYPE_EGALAX,
	DEVTYPE_PANJIT,
	DEVTYPE_3M,
	DEVTYPE_ITM,
D
Daniel Ritz 已提交
114 115
	DEVTYPE_ETURBO,
	DEVTYPE_GUNZE,
116
	DEVTYPE_DMC_TSC10,
117
	DEVTYPE_IRTOUCH,
118
	DEVTYPE_IDEALTEK,
119
	DEVTYPE_GENERAL_TOUCH,
120
	DEVTYPE_GOTOP,
121 122
};

123 124
#define USB_DEVICE_HID_CLASS(vend, prod) \
	.match_flags = USB_DEVICE_ID_MATCH_INT_CLASS \
125
		| USB_DEVICE_ID_MATCH_INT_PROTOCOL \
126 127 128 129 130 131
		| USB_DEVICE_ID_MATCH_DEVICE, \
	.idVendor = (vend), \
	.idProduct = (prod), \
	.bInterfaceClass = USB_INTERFACE_CLASS_HID, \
	.bInterfaceProtocol = USB_INTERFACE_PROTOCOL_MOUSE

132
static struct usb_device_id usbtouch_devices[] = {
133
#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
134 135 136 137 138
	/* ignore the HID capable devices, handled by usbhid */
	{USB_DEVICE_HID_CLASS(0x0eef, 0x0001), .driver_info = DEVTYPE_IGNORE},
	{USB_DEVICE_HID_CLASS(0x0eef, 0x0002), .driver_info = DEVTYPE_IGNORE},

	/* normal device IDs */
139
	{USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
D
Daniel Ritz 已提交
140
	{USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
141 142 143
	{USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
	{USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
	{USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
D
Daniel Ritz 已提交
144 145
	{USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
	{USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
146 147
#endif

148
#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
149 150 151 152 153 154
	{USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
	{USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
	{USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
	{USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
#endif

155
#ifdef CONFIG_TOUCHSCREEN_USB_3M
156 157 158
	{USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
#endif

159
#ifdef CONFIG_TOUCHSCREEN_USB_ITM
160 161 162
	{USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
#endif

163
#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
D
Daniel Ritz 已提交
164 165 166
	{USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
#endif

167
#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
D
Daniel Ritz 已提交
168 169 170
	{USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
#endif

171
#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
172 173 174
	{USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
#endif

175 176 177 178 179
#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
	{USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
	{USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
#endif

180 181 182 183
#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
	{USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
#endif

184 185 186 187
#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
	{USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
#endif

188 189 190 191 192 193
#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
	{USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
	{USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
	{USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
#endif

194 195 196 197 198 199 200 201
	{}
};


/*****************************************************************************
 * eGalax part
 */

202
#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
203

204 205 206 207
#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif

208 209 210 211
#define EGALAX_PKT_TYPE_MASK		0xFE
#define EGALAX_PKT_TYPE_REPT		0x80
#define EGALAX_PKT_TYPE_DIAG		0x0A

212
static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
213 214 215 216
{
	if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
		return 0;

217 218 219
	dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
	dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
	dev->touch = pkt[0] & 0x01;
220 221 222 223

	return 1;
}

D
Daniel Ritz 已提交
224
static int egalax_get_pkt_len(unsigned char *buf, int len)
225 226 227 228 229 230
{
	switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
	case EGALAX_PKT_TYPE_REPT:
		return 5;

	case EGALAX_PKT_TYPE_DIAG:
D
Daniel Ritz 已提交
231 232 233
		if (len < 2)
			return -1;

234 235 236 237 238 239 240 241 242 243 244
		return buf[1] + 2;
	}

	return 0;
}
#endif


/*****************************************************************************
 * PanJit Part
 */
245
#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
246
static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
247
{
248 249 250
	dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
	dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
	dev->touch = pkt[0] & 0x01;
251 252 253 254 255 256 257 258 259

	return 1;
}
#endif


/*****************************************************************************
 * 3M/Microtouch Part
 */
260
#ifdef CONFIG_TOUCHSCREEN_USB_3M
261 262 263 264 265

#define MTOUCHUSB_ASYNC_REPORT          1
#define MTOUCHUSB_RESET                 7
#define MTOUCHUSB_REQ_CTRLLR_ID         10

266
static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
267
{
268 269 270 271 272 273 274
	if (hwcalib_xy) {
		dev->x = (pkt[4] << 8) | pkt[3];
		dev->y = 0xffff - ((pkt[6] << 8) | pkt[5]);
	} else {
		dev->x = (pkt[8] << 8) | pkt[7];
		dev->y = (pkt[10] << 8) | pkt[9];
	}
275
	dev->touch = (pkt[2] & 0x40) ? 1 : 0;
276 277 278 279 280 281

	return 1;
}

static int mtouch_init(struct usbtouch_usb *usbtouch)
{
D
Daniel Ritz 已提交
282
	int ret, i;
283 284 285 286 287 288

	ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
	                      MTOUCHUSB_RESET,
	                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
	                      1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
	dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
289
	    __func__, ret);
290 291
	if (ret < 0)
		return ret;
D
Daniel Ritz 已提交
292 293 294 295 296 297 298 299
	msleep(150);

	for (i = 0; i < 3; i++) {
		ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
				      MTOUCHUSB_ASYNC_REPORT,
				      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
				      1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
		dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
300
		    __func__, ret);
D
Daniel Ritz 已提交
301 302 303 304 305
		if (ret >= 0)
			break;
		if (ret != -EPIPE)
			return ret;
	}
306

307 308 309 310 311 312
	/* Default min/max xy are the raw values, override if using hw-calib */
	if (hwcalib_xy) {
		input_set_abs_params(usbtouch->input, ABS_X, 0, 0xffff, 0, 0);
		input_set_abs_params(usbtouch->input, ABS_Y, 0, 0xffff, 0, 0);
	}

313 314 315 316 317 318 319 320
	return 0;
}
#endif


/*****************************************************************************
 * ITM Part
 */
321
#ifdef CONFIG_TOUCHSCREEN_USB_ITM
322
static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
323
{
324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345
	int touch;
	/*
	 * ITM devices report invalid x/y data if not touched.
	 * if the screen was touched before but is not touched any more
	 * report touch as 0 with the last valid x/y data once. then stop
	 * reporting data until touched again.
	 */
	dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);

	touch = ~pkt[7] & 0x20;
	if (!touch) {
		if (dev->touch) {
			dev->touch = 0;
			return 1;
		}

		return 0;
	}

	dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
	dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
	dev->touch = touch;
346

347
	return 1;
348 349 350 351
}
#endif


D
Daniel Ritz 已提交
352 353 354
/*****************************************************************************
 * eTurboTouch part
 */
355
#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
356 357 358
#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif
359
static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
D
Daniel Ritz 已提交
360 361 362 363 364 365 366 367
{
	unsigned int shift;

	/* packets should start with sync */
	if (!(pkt[0] & 0x80))
		return 0;

	shift = (6 - (pkt[0] & 0x03));
368 369 370
	dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
	dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
	dev->touch = (pkt[0] & 0x10) ? 1 : 0;
D
Daniel Ritz 已提交
371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

	return 1;
}

static int eturbo_get_pkt_len(unsigned char *buf, int len)
{
	if (buf[0] & 0x80)
		return 5;
	if (buf[0] == 0x01)
		return 3;
	return 0;
}
#endif


/*****************************************************************************
 * Gunze part
 */
389
#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
390
static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
D
Daniel Ritz 已提交
391 392 393 394
{
	if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
		return 0;

395 396 397
	dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
	dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
	dev->touch = pkt[0] & 0x20;
D
Daniel Ritz 已提交
398 399 400 401 402

	return 1;
}
#endif

403 404 405 406 407 408 409
/*****************************************************************************
 * DMC TSC-10/25 Part
 *
 * Documentation about the controller and it's protocol can be found at
 *   http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
 *   http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
 */
410
#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428

/* supported data rates. currently using 130 */
#define TSC10_RATE_POINT	0x50
#define TSC10_RATE_30		0x40
#define TSC10_RATE_50		0x41
#define TSC10_RATE_80		0x42
#define TSC10_RATE_100		0x43
#define TSC10_RATE_130		0x44
#define TSC10_RATE_150		0x45

/* commands */
#define TSC10_CMD_RESET		0x55
#define TSC10_CMD_RATE		0x05
#define TSC10_CMD_DATA1		0x01

static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
{
	struct usb_device *dev = usbtouch->udev;
429 430
	int ret = -ENOMEM;
	unsigned char *buf;
431

432 433 434
	buf = kmalloc(2, GFP_KERNEL);
	if (!buf)
		goto err_nobuf;
435 436 437 438 439 440 441
	/* reset */
	buf[0] = buf[1] = 0xFF;
	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
	                      TSC10_CMD_RESET,
	                      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
	                      0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
	if (ret < 0)
442
		goto err_out;
443
	if (buf[0] != 0x06) {
444 445 446
		ret = -ENODEV;
		goto err_out;
	}
447 448 449 450 451 452 453 454

	/* set coordinate output rate */
	buf[0] = buf[1] = 0xFF;
	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
	                      TSC10_CMD_RATE,
	                      USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
	                      TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
	if (ret < 0)
455
		goto err_out;
456
	if ((buf[0] != 0x06) && (buf[0] != 0x15 || buf[1] != 0x01)) {
457 458 459
		ret = -ENODEV;
		goto err_out;
	}
460 461 462 463 464 465

	/* start sending data */
	ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
	                      TSC10_CMD_DATA1,
	                      USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
	                      0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
466 467 468 469
err_out:
	kfree(buf);
err_nobuf:
	return ret;
470 471 472
}


473
static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
474
{
475 476 477
	dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
	dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
	dev->touch = pkt[0] & 0x01;
478 479 480 481 482 483

	return 1;
}
#endif


484 485 486 487 488 489 490 491 492 493 494 495 496 497 498
/*****************************************************************************
 * IRTOUCH Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
	dev->x = (pkt[3] << 8) | pkt[2];
	dev->y = (pkt[5] << 8) | pkt[4];
	dev->touch = (pkt[1] & 0x03) ? 1 : 0;

	return 1;
}
#endif


499 500 501 502
/*****************************************************************************
 * IdealTEK URTC1000 Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
503 504 505
#ifndef MULTI_PACKET
#define MULTI_PACKET
#endif
506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537
static int idealtek_get_pkt_len(unsigned char *buf, int len)
{
	if (buf[0] & 0x80)
		return 5;
	if (buf[0] == 0x01)
		return len;
	return 0;
}

static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
	switch (pkt[0] & 0x98) {
	case 0x88:
		/* touch data in IdealTEK mode */
		dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
		dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
		dev->touch = (pkt[0] & 0x40) ? 1 : 0;
		return 1;

	case 0x98:
		/* touch data in MT emulation mode */
		dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
		dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
		dev->touch = (pkt[0] & 0x40) ? 1 : 0;
		return 1;

	default:
		return 0;
	}
}
#endif

538 539 540 541 542 543 544 545 546 547 548 549 550 551
/*****************************************************************************
 * General Touch Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
	dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
	dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
	dev->press = pkt[5] & 0xff;
	dev->touch = pkt[0] & 0x01;

	return 1;
}
#endif
552

553 554 555 556 557 558 559 560 561 562 563 564 565 566
/*****************************************************************************
 * GoTop Part
 */
#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
{
	dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
	dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
	dev->touch = pkt[0] & 0x01;
	return 1;
}
#endif


567 568 569
/*****************************************************************************
 * the different device descriptors
 */
570 571 572 573 574
#ifdef MULTI_PACKET
static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
				   unsigned char *pkt, int len);
#endif

575
static struct usbtouch_device_info usbtouch_dev_info[] = {
576
#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
577 578 579 580 581 582
	[DEVTYPE_EGALAX] = {
		.min_xc		= 0x0,
		.max_xc		= 0x07ff,
		.min_yc		= 0x0,
		.max_yc		= 0x07ff,
		.rept_size	= 16,
D
Daniel Ritz 已提交
583 584
		.process_pkt	= usbtouch_process_multi,
		.get_pkt_len	= egalax_get_pkt_len,
585 586 587 588
		.read_data	= egalax_read_data,
	},
#endif

589
#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
590 591 592 593 594 595 596 597 598 599
	[DEVTYPE_PANJIT] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0fff,
		.min_yc		= 0x0,
		.max_yc		= 0x0fff,
		.rept_size	= 8,
		.read_data	= panjit_read_data,
	},
#endif

600
#ifdef CONFIG_TOUCHSCREEN_USB_3M
601 602 603 604 605 606 607 608 609 610 611
	[DEVTYPE_3M] = {
		.min_xc		= 0x0,
		.max_xc		= 0x4000,
		.min_yc		= 0x0,
		.max_yc		= 0x4000,
		.rept_size	= 11,
		.read_data	= mtouch_read_data,
		.init		= mtouch_init,
	},
#endif

612
#ifdef CONFIG_TOUCHSCREEN_USB_ITM
613 614 615 616 617 618 619 620 621 622
	[DEVTYPE_ITM] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0fff,
		.min_yc		= 0x0,
		.max_yc		= 0x0fff,
		.max_press	= 0xff,
		.rept_size	= 8,
		.read_data	= itm_read_data,
	},
#endif
D
Daniel Ritz 已提交
623

624
#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
D
Daniel Ritz 已提交
625 626 627 628 629 630 631 632 633 634 635 636
	[DEVTYPE_ETURBO] = {
		.min_xc		= 0x0,
		.max_xc		= 0x07ff,
		.min_yc		= 0x0,
		.max_yc		= 0x07ff,
		.rept_size	= 8,
		.process_pkt	= usbtouch_process_multi,
		.get_pkt_len	= eturbo_get_pkt_len,
		.read_data	= eturbo_read_data,
	},
#endif

637
#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
D
Daniel Ritz 已提交
638 639 640 641 642 643 644 645 646
	[DEVTYPE_GUNZE] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0fff,
		.min_yc		= 0x0,
		.max_yc		= 0x0fff,
		.rept_size	= 4,
		.read_data	= gunze_read_data,
	},
#endif
647

648
#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
649 650 651 652 653 654 655 656 657 658
	[DEVTYPE_DMC_TSC10] = {
		.min_xc		= 0x0,
		.max_xc		= 0x03ff,
		.min_yc		= 0x0,
		.max_yc		= 0x03ff,
		.rept_size	= 5,
		.init		= dmc_tsc10_init,
		.read_data	= dmc_tsc10_read_data,
	},
#endif
659 660 661 662 663 664 665 666 667 668 669

#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
	[DEVTYPE_IRTOUCH] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0fff,
		.min_yc		= 0x0,
		.max_yc		= 0x0fff,
		.rept_size	= 8,
		.read_data	= irtouch_read_data,
	},
#endif
670 671 672 673 674 675 676 677 678 679 680 681 682

#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
	[DEVTYPE_IDEALTEK] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0fff,
		.min_yc		= 0x0,
		.max_yc		= 0x0fff,
		.rept_size	= 8,
		.process_pkt	= usbtouch_process_multi,
		.get_pkt_len	= idealtek_get_pkt_len,
		.read_data	= idealtek_read_data,
	},
#endif
683 684 685 686 687 688 689 690 691

#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
	[DEVTYPE_GENERAL_TOUCH] = {
		.min_xc		= 0x0,
		.max_xc		= 0x0500,
		.min_yc		= 0x0,
		.max_yc		= 0x0500,
		.rept_size	= 7,
		.read_data	= general_touch_read_data,
692
	},
693 694
#endif

695 696 697 698 699 700 701 702 703 704
#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
	[DEVTYPE_GOTOP] = {
		.min_xc		= 0x0,
		.max_xc		= 0x03ff,
		.min_yc		= 0x0,
		.max_yc		= 0x03ff,
		.rept_size	= 4,
		.read_data	= gotop_read_data,
	},
#endif
705 706 707 708 709 710 711
};


/*****************************************************************************
 * Generic Part
 */
static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
712
                                 unsigned char *pkt, int len)
713 714 715
{
	struct usbtouch_device_info *type = usbtouch->type;

716
	if (!type->read_data(usbtouch, pkt))
717 718
			return;

719
	input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
720 721

	if (swap_xy) {
722 723
		input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
		input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
724
	} else {
725 726
		input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
		input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
727 728
	}
	if (type->max_press)
729
		input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
730 731 732 733
	input_sync(usbtouch->input);
}


D
Daniel Ritz 已提交
734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771
#ifdef MULTI_PACKET
static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
                                   unsigned char *pkt, int len)
{
	unsigned char *buffer;
	int pkt_len, pos, buf_len, tmp;

	/* process buffer */
	if (unlikely(usbtouch->buf_len)) {
		/* try to get size */
		pkt_len = usbtouch->type->get_pkt_len(
				usbtouch->buffer, usbtouch->buf_len);

		/* drop? */
		if (unlikely(!pkt_len))
			goto out_flush_buf;

		/* need to append -pkt_len bytes before able to get size */
		if (unlikely(pkt_len < 0)) {
			int append = -pkt_len;
			if (unlikely(append > len))
			       append = len;
			if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
				goto out_flush_buf;
			memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
			usbtouch->buf_len += append;

			pkt_len = usbtouch->type->get_pkt_len(
					usbtouch->buffer, usbtouch->buf_len);
			if (pkt_len < 0)
				return;
		}

		/* append */
		tmp = pkt_len - usbtouch->buf_len;
		if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
			goto out_flush_buf;
		memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
772
		usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);
D
Daniel Ritz 已提交
773 774 775 776 777 778 779 780 781 782 783 784

		buffer = pkt + tmp;
		buf_len = len - tmp;
	} else {
		buffer = pkt;
		buf_len = len;
	}

	/* loop over the received packet, process */
	pos = 0;
	while (pos < buf_len) {
		/* get packet len */
785 786
		pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
							buf_len - pos);
D
Daniel Ritz 已提交
787

788 789 790 791 792
		/* unknown packet: skip one byte */
		if (unlikely(!pkt_len)) {
			pos++;
			continue;
		}
D
Daniel Ritz 已提交
793 794 795

		/* full packet: process */
		if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
796
			usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
D
Daniel Ritz 已提交
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812
		} else {
			/* incomplete packet: save in buffer */
			memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
			usbtouch->buf_len = buf_len - pos;
			return;
		}
		pos += pkt_len;
	}

out_flush_buf:
	usbtouch->buf_len = 0;
	return;
}
#endif


813
static void usbtouch_irq(struct urb *urb)
814 815 816 817 818 819 820 821
{
	struct usbtouch_usb *usbtouch = urb->context;
	int retval;

	switch (urb->status) {
	case 0:
		/* success */
		break;
822
	case -ETIME:
823 824
		/* this urb is timing out */
		dbg("%s - urb timed out - was the device unplugged?",
825
		    __func__);
826 827 828 829 830 831
		return;
	case -ECONNRESET:
	case -ENOENT:
	case -ESHUTDOWN:
		/* this urb is terminated, clean up */
		dbg("%s - urb shutting down with status: %d",
832
		    __func__, urb->status);
833 834 835
		return;
	default:
		dbg("%s - nonzero urb status received: %d",
836
		    __func__, urb->status);
837 838 839
		goto exit;
	}

840
	usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
841 842 843 844 845

exit:
	retval = usb_submit_urb(urb, GFP_ATOMIC);
	if (retval)
		err("%s - usb_submit_urb failed with result: %d",
846
		    __func__, retval);
847 848 849 850
}

static int usbtouch_open(struct input_dev *input)
{
851
	struct usbtouch_usb *usbtouch = input_get_drvdata(input);
852 853 854 855 856 857 858 859 860 861 862

	usbtouch->irq->dev = usbtouch->udev;

	if (usb_submit_urb(usbtouch->irq, GFP_KERNEL))
		return -EIO;

	return 0;
}

static void usbtouch_close(struct input_dev *input)
{
863
	struct usbtouch_usb *usbtouch = input_get_drvdata(input);
864 865 866 867 868 869 870 871

	usb_kill_urb(usbtouch->irq);
}


static void usbtouch_free_buffers(struct usb_device *udev,
				  struct usbtouch_usb *usbtouch)
{
872 873
	usb_buffer_free(udev, usbtouch->type->rept_size,
	                usbtouch->data, usbtouch->data_dma);
874 875 876 877 878 879 880 881 882 883 884 885 886
	kfree(usbtouch->buffer);
}


static int usbtouch_probe(struct usb_interface *intf,
			  const struct usb_device_id *id)
{
	struct usbtouch_usb *usbtouch;
	struct input_dev *input_dev;
	struct usb_host_interface *interface;
	struct usb_endpoint_descriptor *endpoint;
	struct usb_device *udev = interface_to_usbdev(intf);
	struct usbtouch_device_info *type;
D
Daniel Ritz 已提交
887
	int err = -ENOMEM;
888 889 890 891

	/* some devices are ignored */
	if (id->driver_info == DEVTYPE_IGNORE)
		return -ENODEV;
892 893 894 895 896 897 898 899 900 901 902 903 904 905 906

	interface = intf->cur_altsetting;
	endpoint = &interface->endpoint[0].desc;

	usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!usbtouch || !input_dev)
		goto out_free;

	type = &usbtouch_dev_info[id->driver_info];
	usbtouch->type = type;
	if (!type->process_pkt)
		type->process_pkt = usbtouch_process_pkt;

	usbtouch->data = usb_buffer_alloc(udev, type->rept_size,
907
	                                  GFP_KERNEL, &usbtouch->data_dma);
908 909 910
	if (!usbtouch->data)
		goto out_free;

911
	if (type->get_pkt_len) {
912 913 914 915 916 917 918
		usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
		if (!usbtouch->buffer)
			goto out_free_buffers;
	}

	usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
	if (!usbtouch->irq) {
919
		dbg("%s - usb_alloc_urb failed: usbtouch->irq", __func__);
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
		goto out_free_buffers;
	}

	usbtouch->udev = udev;
	usbtouch->input = input_dev;

	if (udev->manufacturer)
		strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));

	if (udev->product) {
		if (udev->manufacturer)
			strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
		strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
	}

	if (!strlen(usbtouch->name))
		snprintf(usbtouch->name, sizeof(usbtouch->name),
			"USB Touchscreen %04x:%04x",
			 le16_to_cpu(udev->descriptor.idVendor),
			 le16_to_cpu(udev->descriptor.idProduct));

	usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
942
	strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));
943 944 945 946

	input_dev->name = usbtouch->name;
	input_dev->phys = usbtouch->phys;
	usb_to_input_id(udev, &input_dev->id);
947
	input_dev->dev.parent = &intf->dev;
948 949 950

	input_set_drvdata(input_dev, usbtouch);

951 952 953
	input_dev->open = usbtouch_open;
	input_dev->close = usbtouch_close;

954 955
	input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
	input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
956 957 958 959 960 961 962
	input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
	if (type->max_press)
		input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
		                     type->max_press, 0, 0);

	usb_fill_int_urb(usbtouch->irq, usbtouch->udev,
963
			 usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress),
964 965 966
			 usbtouch->data, type->rept_size,
			 usbtouch_irq, usbtouch, endpoint->bInterval);

D
Daniel Ritz 已提交
967
	usbtouch->irq->dev = usbtouch->udev;
968 969 970 971 972 973 974
	usbtouch->irq->transfer_dma = usbtouch->data_dma;
	usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;

	/* device specific init */
	if (type->init) {
		err = type->init(usbtouch);
		if (err) {
975
			dbg("%s - type->init() failed, err: %d", __func__, err);
976 977 978 979 980 981
			goto out_free_buffers;
		}
	}

	err = input_register_device(usbtouch->input);
	if (err) {
982
		dbg("%s - input_register_device failed, err: %d", __func__, err);
983 984 985 986 987 988 989 990 991 992 993 994
		goto out_free_buffers;
	}

	usb_set_intfdata(intf, usbtouch);

	return 0;

out_free_buffers:
	usbtouch_free_buffers(udev, usbtouch);
out_free:
	input_free_device(input_dev);
	kfree(usbtouch);
D
Daniel Ritz 已提交
995
	return err;
996 997 998 999 1000 1001
}

static void usbtouch_disconnect(struct usb_interface *intf)
{
	struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);

1002
	dbg("%s - called", __func__);
1003 1004 1005 1006

	if (!usbtouch)
		return;

1007
	dbg("%s - usbtouch is initialized, cleaning up", __func__);
1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044
	usb_set_intfdata(intf, NULL);
	usb_kill_urb(usbtouch->irq);
	input_unregister_device(usbtouch->input);
	usb_free_urb(usbtouch->irq);
	usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
	kfree(usbtouch);
}

MODULE_DEVICE_TABLE(usb, usbtouch_devices);

static struct usb_driver usbtouch_driver = {
	.name		= "usbtouchscreen",
	.probe		= usbtouch_probe,
	.disconnect	= usbtouch_disconnect,
	.id_table	= usbtouch_devices,
};

static int __init usbtouch_init(void)
{
	return usb_register(&usbtouch_driver);
}

static void __exit usbtouch_cleanup(void)
{
	usb_deregister(&usbtouch_driver);
}

module_init(usbtouch_init);
module_exit(usbtouch_cleanup);

MODULE_AUTHOR(DRIVER_AUTHOR);
MODULE_DESCRIPTION(DRIVER_DESC);
MODULE_LICENSE("GPL");

MODULE_ALIAS("touchkitusb");
MODULE_ALIAS("itmtouch");
MODULE_ALIAS("mtouchusb");