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
46	static bool swap_xy;
47	module_param(swap_xy, bool, 0644);
48	MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
49
50	static bool hwcalib_xy;
51	module_param(hwcalib_xy, bool, 0644);
52	MODULE_PARM_DESC(hwcalib_xy, "If set hw-calibrated X/Y are used if available");
53
54	/* device specifc data/functions */
55	struct usbtouch_usb;
56	struct 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 */
88	struct 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 */
110	enum {
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
140	static 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
249	static 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(dev: udev, usb_sndctrlpipe(udev, 0),
255	request: 0x01, requesttype: 0x02, value: 0x0000, index: 0x0081,
256	NULL, size: 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
264	static 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
293	static 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(size: 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(dev: udev, usb_sndctrlpipe(udev, 0),
315	request: 0,
316	USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
317	value: 0, index: 0, data: buf, size: 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(objp: buf);
328
329	return ret;
330	}
331
332	static 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
344	static 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
376	static 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
389	static 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
411	static 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
433	static 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
447	struct mtouch_priv {
448	u8 fw_rev_major;
449	u8 fw_rev_minor;
450	};
451
452	static 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(buf: output, PAGE_SIZE, fmt: "%1x.%1x\n",
460	priv->fw_rev_major, priv->fw_rev_minor);
461	}
462	static DEVICE_ATTR(firmware_rev, 0444, mtouch_firmware_rev_show, NULL);
463
464	static struct attribute *mtouch_attrs[] = {
465	&dev_attr_firmware_rev.attr,
466	NULL
467	};
468
469	static const struct attribute_group mtouch_attr_group = {
470	.attrs = mtouch_attrs,
471	};
472
473	static 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(dev: udev, usb_rcvctrlpipe(udev, 0),
485	MTOUCHUSB_REQ_CTRLLR_ID,
486	USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
487	value: 0, index: 0, data: 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
501	free:
502	kfree(objp: buf);
503	return ret;
504	}
505
506	static int mtouch_alloc(struct usbtouch_usb *usbtouch)
507	{
508	int ret;
509
510	usbtouch->priv = kmalloc(size: sizeof(struct mtouch_priv), GFP_KERNEL);
511	if (!usbtouch->priv)
512	return -ENOMEM;
513
514	ret = sysfs_create_group(kobj: &usbtouch->interface->dev.kobj,
515	grp: &mtouch_attr_group);
516	if (ret) {
517	kfree(objp: usbtouch->priv);
518	usbtouch->priv = NULL;
519	return ret;
520	}
521
522	return 0;
523	}
524
525	static 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(dev: udev, usb_sndctrlpipe(udev, 0),
535	MTOUCHUSB_RESET,
536	USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
537	value: 1, index: 0, NULL, size: 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(msecs: 150);
544
545	for (i = 0; i < 3; i++) {
546	ret = usb_control_msg(dev: udev, usb_sndctrlpipe(udev, 0),
547	MTOUCHUSB_ASYNC_REPORT,
548	USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
549	value: 1, index: 1, NULL, size: 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(dev: usbtouch->input, ABS_X, min: 0, max: 0xffff, fuzz: 0, flat: 0);
562	input_set_abs_params(dev: usbtouch->input, ABS_Y, min: 0, max: 0xffff, fuzz: 0, flat: 0);
563	}
564
565	return 0;
566	}
567
568	static void mtouch_exit(struct usbtouch_usb *usbtouch)
569	{
570	struct mtouch_priv *priv = usbtouch->priv;
571
572	sysfs_remove_group(kobj: &usbtouch->interface->dev.kobj, grp: &mtouch_attr_group);
573	kfree(objp: priv);
574	}
575	#endif
576
577
578	/*****************************************************************************
579	* ITM Part
580	*/
581	#ifdef CONFIG_TOUCHSCREEN_USB_ITM
582	static 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
619	static 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
635	static 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
650	static 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
686	static 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(size: 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	value: 0, index: 0, data: buf, size: 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(msecs: 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, index: 0, data: buf, size: 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	value: 0, index: 0, NULL, size: 0, USB_CTRL_SET_TIMEOUT);
729	err_out:
730	kfree(objp: buf);
731	err_nobuf:
732	return ret;
733	}
734
735
736	static 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
751	static 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
765	static 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
782	static 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
791	static 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
818	static 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
833	static 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
847	static 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
861	static 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
902	struct nexio_priv {
903	struct urb *ack;
904	unsigned char *ack_buf;
905	};
906
907	struct 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
915	static unsigned char nexio_ack_pkt[2] = { 0xaa, 0x02 };
916	static unsigned char nexio_init_pkt[4] = { 0x82, 0x04, 0x0a, 0x0f };
917
918	static void nexio_ack_complete(struct urb *urb)
919	{
920	}
921
922	static int nexio_alloc(struct usbtouch_usb *usbtouch)
923	{
924	struct nexio_priv *priv;
925	int ret = -ENOMEM;
926
927	usbtouch->priv = kmalloc(size: 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(p: nexio_ack_pkt, size: sizeof(nexio_ack_pkt),
934	GFP_KERNEL);
935	if (!priv->ack_buf)
936	goto err_priv;
937
938	priv->ack = usb_alloc_urb(iso_packets: 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
947	err_ack_buf:
948	kfree(objp: priv->ack_buf);
949	err_priv:
950	kfree(objp: priv);
951	out_buf:
952	return ret;
953	}
954
955	static 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(epd: &interface->endpoint[i].desc))
970	input_ep = interface->endpoint[i].desc.bEndpointAddress;
971	if (!output_ep &&
972	usb_endpoint_dir_out(epd: &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(usb_dev: dev, usb_rcvbulkpipe(dev, input_ep),
985	data: buf, NEXIO_BUFSIZE, actual_length: &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(usb_dev: dev, usb_sndbulkpipe(dev, output_ep),
994	data: buf, len: sizeof(nexio_init_pkt), actual_length: &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(usb_dev: dev, usb_rcvbulkpipe(dev, input_ep),
1003	data: buf, NEXIO_BUFSIZE, actual_length: &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(s: &buf[2], GFP_NOIO);
1011	break;
1012	case 0x84: /* device name */
1013	if (!device_name)
1014	device_name = kstrdup(s: &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(objp: firmware_ver);
1023	kfree(objp: device_name);
1024
1025	usb_fill_bulk_urb(urb: priv->ack, dev, usb_sndbulkpipe(dev, output_ep),
1026	transfer_buffer: priv->ack_buf, buffer_length: sizeof(nexio_ack_pkt),
1027	complete_fn: nexio_ack_complete, context: usbtouch);
1028	ret = 0;
1029
1030	out_buf:
1031	kfree(objp: buf);
1032	return ret;
1033	}
1034
1035	static void nexio_exit(struct usbtouch_usb *usbtouch)
1036	{
1037	struct nexio_priv *priv = usbtouch->priv;
1038
1039	usb_kill_urb(urb: priv->ack);
1040	usb_free_urb(urb: priv->ack);
1041	kfree(objp: priv->ack_buf);
1042	kfree(objp: priv);
1043	}
1044
1045	static 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(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(dev: usbtouch->input, ABS_X,
1072	min: 0, max: usbtouch->type->max_xc, fuzz: 0, flat: 0);
1073	usbtouch->type->max_yc = 2 * y_len;
1074	input_set_abs_params(dev: usbtouch->input, ABS_Y,
1075	min: 0, max: usbtouch->type->max_yc, fuzz: 0, flat: 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
1139	static 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
1155	static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
1156	unsigned char *pkt, int len);
1157	#endif
1158
1159	static 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	*/
1388	static 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(dev: usbtouch->input, BTN_TOUCH, value: usbtouch->touch);
1397
1398	if (swap_xy) {
1399	input_report_abs(dev: usbtouch->input, ABS_X, value: usbtouch->y);
1400	input_report_abs(dev: usbtouch->input, ABS_Y, value: usbtouch->x);
1401	} else {
1402	input_report_abs(dev: usbtouch->input, ABS_X, value: usbtouch->x);
1403	input_report_abs(dev: usbtouch->input, ABS_Y, value: usbtouch->y);
1404	}
1405	if (type->max_press)
1406	input_report_abs(dev: usbtouch->input, ABS_PRESSURE, value: usbtouch->press);
1407	input_sync(dev: usbtouch->input);
1408	}
1409
1410
1411	#ifdef MULTI_PACKET
1412	static 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, pkt: usbtouch->buffer, len: 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, pkt: buffer + pos, len: 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
1483	out_flush_buf:
1484	usbtouch->buf_len = 0;
1485	return;
1486	}
1487	#endif
1488
1489
1490	static 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
1522	exit:
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
1530	static int usbtouch_open(struct input_dev *input)
1531	{
1532	struct usbtouch_usb *usbtouch = input_get_drvdata(dev: input);
1533	int r;
1534
1535	usbtouch->irq->dev = interface_to_usbdev(usbtouch->interface);
1536
1537	r = usb_autopm_get_interface(intf: 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(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;
1551	out_put:
1552	mutex_unlock(lock: &usbtouch->pm_mutex);
1553	usb_autopm_put_interface(intf: usbtouch->interface);
1554	out:
1555	return r;
1556	}
1557
1558	static void usbtouch_close(struct input_dev *input)
1559	{
1560	struct usbtouch_usb *usbtouch = input_get_drvdata(dev: input);
1561	int r;
1562
1563	mutex_lock(&usbtouch->pm_mutex);
1564	if (!usbtouch->type->irq_always)
1565	usb_kill_urb(urb: usbtouch->irq);
1566	usbtouch->is_open = false;
1567	mutex_unlock(lock: &usbtouch->pm_mutex);
1568
1569	r = usb_autopm_get_interface(intf: usbtouch->interface);
1570	usbtouch->interface->needs_remote_wakeup = 0;
1571	if (!r)
1572	usb_autopm_put_interface(intf: usbtouch->interface);
1573	}
1574
1575	static 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(urb: usbtouch->irq);
1581
1582	return 0;
1583	}
1584
1585	static 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(urb: usbtouch->irq, GFP_NOIO);
1593	mutex_unlock(lock: &usbtouch->pm_mutex);
1594
1595	return result;
1596	}
1597
1598	static 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(urb: usbtouch->irq, GFP_NOIO);
1618	mutex_unlock(lock: &usbtouch->pm_mutex);
1619
1620	return err;
1621	}
1622
1623	static void usbtouch_free_buffers(struct usb_device *udev,
1624	struct usbtouch_usb *usbtouch)
1625	{
1626	usb_free_coherent(dev: udev, size: usbtouch->data_size,
1627	addr: usbtouch->data, dma: usbtouch->data_dma);
1628	kfree(objp: usbtouch->buffer);
1629	}
1630
1631	static struct usb_endpoint_descriptor *
1632	usbtouch_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(epd: &interface->endpoint[i].desc))
1638	return &interface->endpoint[i].desc;
1639
1640	return NULL;
1641	}
1642
1643	static 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(interface: intf->cur_altsetting);
1661	if (!endpoint)
1662	return -ENXIO;
1663
1664	usbtouch = kzalloc(size: 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(dev: udev, size: usbtouch->data_size,
1690	GFP_KERNEL, dma: &usbtouch->data_dma);
1691	if (!usbtouch->data)
1692	goto out_free;
1693
1694	if (type->get_pkt_len) {
1695	usbtouch->buffer = kmalloc(size: type->rept_size, GFP_KERNEL);
1696	if (!usbtouch->buffer)
1697	goto out_free_buffers;
1698	}
1699
1700	usbtouch->irq = usb_alloc_urb(iso_packets: 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(p: usbtouch->name, q: udev->manufacturer, size: sizeof(usbtouch->name));
1712
1713	if (udev->product) {
1714	if (udev->manufacturer)
1715	strlcat(p: usbtouch->name, q: " ", avail: sizeof(usbtouch->name));
1716	strlcat(p: usbtouch->name, q: udev->product, avail: sizeof(usbtouch->name));
1717	}
1718
1719	if (!strlen(usbtouch->name))
1720	snprintf(buf: usbtouch->name, size: sizeof(usbtouch->name),
1721	fmt: "USB Touchscreen %04x:%04x",
1722	le16_to_cpu(udev->descriptor.idVendor),
1723	le16_to_cpu(udev->descriptor.idProduct));
1724
1725	usb_make_path(dev: udev, buf: usbtouch->phys, size: sizeof(usbtouch->phys));
1726	strlcat(p: usbtouch->phys, q: "/input0", avail: sizeof(usbtouch->phys));
1727
1728	input_dev->name = usbtouch->name;
1729	input_dev->phys = usbtouch->phys;
1730	usb_to_input_id(dev: udev, id: &input_dev->id);
1731	input_dev->dev.parent = &intf->dev;
1732
1733	input_set_drvdata(dev: input_dev, data: 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(dev: input_dev, ABS_X, min: type->min_xc, max: type->max_xc, fuzz: 0, flat: 0);
1741	input_set_abs_params(dev: input_dev, ABS_Y, min: type->min_yc, max: type->max_yc, fuzz: 0, flat: 0);
1742	if (type->max_press)
1743	input_set_abs_params(dev: input_dev, ABS_PRESSURE, min: type->min_press,
1744	max: type->max_press, fuzz: 0, flat: 0);
1745
1746	if (usb_endpoint_type(epd: endpoint) == USB_ENDPOINT_XFER_INT)
1747	usb_fill_int_urb(urb: usbtouch->irq, dev: udev,
1748	usb_rcvintpipe(udev, endpoint->bEndpointAddress),
1749	transfer_buffer: usbtouch->data, buffer_length: usbtouch->data_size,
1750	complete_fn: usbtouch_irq, context: usbtouch, interval: endpoint->bInterval);
1751	else
1752	usb_fill_bulk_urb(urb: usbtouch->irq, dev: udev,
1753	usb_rcvbulkpipe(udev, endpoint->bEndpointAddress),
1754	transfer_buffer: usbtouch->data, buffer_length: usbtouch->data_size,
1755	complete_fn: usbtouch_irq, context: 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, data: usbtouch);
1792
1793	if (usbtouch->type->irq_always) {
1794	/* this can't fail */
1795	usb_autopm_get_interface(intf);
1796	err = usb_submit_urb(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
1808	out_unregister_input:
1809	input_unregister_device(input_dev);
1810	input_dev = NULL;
1811	out_do_exit:
1812	if (type->exit)
1813	type->exit(usbtouch);
1814	out_free_urb:
1815	usb_free_urb(urb: usbtouch->irq);
1816	out_free_buffers:
1817	usbtouch_free_buffers(udev, usbtouch);
1818	out_free:
1819	input_free_device(dev: input_dev);
1820	kfree(objp: usbtouch);
1821	return err;
1822	}
1823
1824	static 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(urb: usbtouch->irq);
1838	if (usbtouch->type->exit)
1839	usbtouch->type->exit(usbtouch);
1840	usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
1841	kfree(objp: usbtouch);
1842	}
1843
1844	MODULE_DEVICE_TABLE(usb, usbtouch_devices);
1845
1846	static 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
1857	module_usb_driver(usbtouch_driver);
1858
1859	MODULE_AUTHOR("Daniel Ritz <daniel.ritz@gmx.ch>");
1860	MODULE_DESCRIPTION("USB Touchscreen Driver");
1861	MODULE_LICENSE("GPL");
1862
1863	MODULE_ALIAS("touchkitusb");
1864	MODULE_ALIAS("itmtouch");
1865	MODULE_ALIAS("mtouchusb");
1866