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