tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/******************************************************************************
2 * usbtouchscreen.c
3 * Driver for USB Touchscreens, supporting those devices:
4 * - eGalax Touchkit
5 * includes eTurboTouch CT-410/510/700
6 * - 3M/Microtouch EX II series
7 * - ITM
8 * - PanJit TouchSet
9 * - eTurboTouch
10 * - Gunze AHL61
11 * - DMC TSC-10/25
12 * - IRTOUCHSYSTEMS/UNITOP
13 * - IdealTEK URTC1000
14 * - General Touch
15 * - GoTop Super_Q2/GogoPen/PenPower tablets
16 *
17 * Copyright (C) 2004-2007 by Daniel Ritz <daniel.ritz@gmx.ch>
18 * Copyright (C) by Todd E. Johnson (mtouchusb.c)
19 *
20 * This program is free software; you can redistribute it and/or
21 * modify it under the terms of the GNU General Public License as
22 * published by the Free Software Foundation; either version 2 of the
23 * License, or (at your option) any later version.
24 *
25 * This program is distributed in the hope that it will be useful, but
26 * WITHOUT ANY WARRANTY; without even the implied warranty of
27 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
28 * General Public License for more details.
29 *
30 * You should have received a copy of the GNU General Public License
31 * along with this program; if not, write to the Free Software
32 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
33 *
34 * Driver is based on touchkitusb.c
35 * - ITM parts are from itmtouch.c
36 * - 3M parts are from mtouchusb.c
37 * - PanJit parts are from an unmerged driver by Lanslott Gish
38 * - DMC TSC 10/25 are from Holger Schurig, with ideas from an unmerged
39 * driver from Marius Vollmer
40 *
41 *****************************************************************************/
42
43//#define DEBUG
44
45#include <linux/kernel.h>
46#include <linux/slab.h>
47#include <linux/input.h>
48#include <linux/module.h>
49#include <linux/init.h>
50#include <linux/usb.h>
51#include <linux/usb/input.h>
52
53
54#define DRIVER_VERSION "v0.6"
55#define DRIVER_AUTHOR "Daniel Ritz <daniel.ritz@gmx.ch>"
56#define DRIVER_DESC "USB Touchscreen Driver"
57
58static int swap_xy;
59module_param(swap_xy, bool, 0644);
60MODULE_PARM_DESC(swap_xy, "If set X and Y axes are swapped.");
61
62/* device specifc data/functions */
63struct usbtouch_usb;
64struct usbtouch_device_info {
65 int min_xc, max_xc;
66 int min_yc, max_yc;
67 int min_press, max_press;
68 int rept_size;
69
70 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
71
72 /*
73 * used to get the packet len. possible return values:
74 * > 0: packet len
75 * = 0: skip one byte
76 * < 0: -return value more bytes needed
77 */
78 int (*get_pkt_len) (unsigned char *pkt, int len);
79
80 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt);
81 int (*init) (struct usbtouch_usb *usbtouch);
82};
83
84/* a usbtouch device */
85struct usbtouch_usb {
86 unsigned char *data;
87 dma_addr_t data_dma;
88 unsigned char *buffer;
89 int buf_len;
90 struct urb *irq;
91 struct usb_device *udev;
92 struct input_dev *input;
93 struct usbtouch_device_info *type;
94 char name[128];
95 char phys[64];
96
97 int x, y;
98 int touch, press;
99};
100
101
102/* device types */
103enum {
104 DEVTPYE_DUMMY = -1,
105 DEVTYPE_EGALAX,
106 DEVTYPE_PANJIT,
107 DEVTYPE_3M,
108 DEVTYPE_ITM,
109 DEVTYPE_ETURBO,
110 DEVTYPE_GUNZE,
111 DEVTYPE_DMC_TSC10,
112 DEVTYPE_IRTOUCH,
113 DEVTYPE_IDEALTEK,
114 DEVTYPE_GENERAL_TOUCH,
115 DEVTYPE_GOTOP,
116};
117
118static struct usb_device_id usbtouch_devices[] = {
119#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
120 {USB_DEVICE(0x3823, 0x0001), .driver_info = DEVTYPE_EGALAX},
121 {USB_DEVICE(0x3823, 0x0002), .driver_info = DEVTYPE_EGALAX},
122 {USB_DEVICE(0x0123, 0x0001), .driver_info = DEVTYPE_EGALAX},
123 {USB_DEVICE(0x0eef, 0x0001), .driver_info = DEVTYPE_EGALAX},
124 {USB_DEVICE(0x0eef, 0x0002), .driver_info = DEVTYPE_EGALAX},
125 {USB_DEVICE(0x1234, 0x0001), .driver_info = DEVTYPE_EGALAX},
126 {USB_DEVICE(0x1234, 0x0002), .driver_info = DEVTYPE_EGALAX},
127#endif
128
129#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
130 {USB_DEVICE(0x134c, 0x0001), .driver_info = DEVTYPE_PANJIT},
131 {USB_DEVICE(0x134c, 0x0002), .driver_info = DEVTYPE_PANJIT},
132 {USB_DEVICE(0x134c, 0x0003), .driver_info = DEVTYPE_PANJIT},
133 {USB_DEVICE(0x134c, 0x0004), .driver_info = DEVTYPE_PANJIT},
134#endif
135
136#ifdef CONFIG_TOUCHSCREEN_USB_3M
137 {USB_DEVICE(0x0596, 0x0001), .driver_info = DEVTYPE_3M},
138#endif
139
140#ifdef CONFIG_TOUCHSCREEN_USB_ITM
141 {USB_DEVICE(0x0403, 0xf9e9), .driver_info = DEVTYPE_ITM},
142#endif
143
144#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
145 {USB_DEVICE(0x1234, 0x5678), .driver_info = DEVTYPE_ETURBO},
146#endif
147
148#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
149 {USB_DEVICE(0x0637, 0x0001), .driver_info = DEVTYPE_GUNZE},
150#endif
151
152#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
153 {USB_DEVICE(0x0afa, 0x03e8), .driver_info = DEVTYPE_DMC_TSC10},
154#endif
155
156#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
157 {USB_DEVICE(0x595a, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
158 {USB_DEVICE(0x6615, 0x0001), .driver_info = DEVTYPE_IRTOUCH},
159#endif
160
161#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
162 {USB_DEVICE(0x1391, 0x1000), .driver_info = DEVTYPE_IDEALTEK},
163#endif
164
165#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
166 {USB_DEVICE(0x0dfc, 0x0001), .driver_info = DEVTYPE_GENERAL_TOUCH},
167#endif
168
169#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
170 {USB_DEVICE(0x08f2, 0x007f), .driver_info = DEVTYPE_GOTOP},
171 {USB_DEVICE(0x08f2, 0x00ce), .driver_info = DEVTYPE_GOTOP},
172 {USB_DEVICE(0x08f2, 0x00f4), .driver_info = DEVTYPE_GOTOP},
173#endif
174
175 {}
176};
177
178
179/*****************************************************************************
180 * eGalax part
181 */
182
183#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
184
185#ifndef MULTI_PACKET
186#define MULTI_PACKET
187#endif
188
189#define EGALAX_PKT_TYPE_MASK 0xFE
190#define EGALAX_PKT_TYPE_REPT 0x80
191#define EGALAX_PKT_TYPE_DIAG 0x0A
192
193static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
194{
195 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
196 return 0;
197
198 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
199 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
200 dev->touch = pkt[0] & 0x01;
201
202 return 1;
203}
204
205static int egalax_get_pkt_len(unsigned char *buf, int len)
206{
207 switch (buf[0] & EGALAX_PKT_TYPE_MASK) {
208 case EGALAX_PKT_TYPE_REPT:
209 return 5;
210
211 case EGALAX_PKT_TYPE_DIAG:
212 if (len < 2)
213 return -1;
214
215 return buf[1] + 2;
216 }
217
218 return 0;
219}
220#endif
221
222
223/*****************************************************************************
224 * PanJit Part
225 */
226#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
227static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
228{
229 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
230 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
231 dev->touch = pkt[0] & 0x01;
232
233 return 1;
234}
235#endif
236
237
238/*****************************************************************************
239 * 3M/Microtouch Part
240 */
241#ifdef CONFIG_TOUCHSCREEN_USB_3M
242
243#define MTOUCHUSB_ASYNC_REPORT 1
244#define MTOUCHUSB_RESET 7
245#define MTOUCHUSB_REQ_CTRLLR_ID 10
246
247static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
248{
249 dev->x = (pkt[8] << 8) | pkt[7];
250 dev->y = (pkt[10] << 8) | pkt[9];
251 dev->touch = (pkt[2] & 0x40) ? 1 : 0;
252
253 return 1;
254}
255
256static int mtouch_init(struct usbtouch_usb *usbtouch)
257{
258 int ret, i;
259
260 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
261 MTOUCHUSB_RESET,
262 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
263 1, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
264 dbg("%s - usb_control_msg - MTOUCHUSB_RESET - bytes|err: %d",
265 __FUNCTION__, ret);
266 if (ret < 0)
267 return ret;
268 msleep(150);
269
270 for (i = 0; i < 3; i++) {
271 ret = usb_control_msg(usbtouch->udev, usb_rcvctrlpipe(usbtouch->udev, 0),
272 MTOUCHUSB_ASYNC_REPORT,
273 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
274 1, 1, NULL, 0, USB_CTRL_SET_TIMEOUT);
275 dbg("%s - usb_control_msg - MTOUCHUSB_ASYNC_REPORT - bytes|err: %d",
276 __FUNCTION__, ret);
277 if (ret >= 0)
278 break;
279 if (ret != -EPIPE)
280 return ret;
281 }
282
283 return 0;
284}
285#endif
286
287
288/*****************************************************************************
289 * ITM Part
290 */
291#ifdef CONFIG_TOUCHSCREEN_USB_ITM
292static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
293{
294 int touch;
295 /*
296 * ITM devices report invalid x/y data if not touched.
297 * if the screen was touched before but is not touched any more
298 * report touch as 0 with the last valid x/y data once. then stop
299 * reporting data until touched again.
300 */
301 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);
302
303 touch = ~pkt[7] & 0x20;
304 if (!touch) {
305 if (dev->touch) {
306 dev->touch = 0;
307 return 1;
308 }
309
310 return 0;
311 }
312
313 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
314 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
315 dev->touch = touch;
316
317 return 1;
318}
319#endif
320
321
322/*****************************************************************************
323 * eTurboTouch part
324 */
325#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
326#ifndef MULTI_PACKET
327#define MULTI_PACKET
328#endif
329static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
330{
331 unsigned int shift;
332
333 /* packets should start with sync */
334 if (!(pkt[0] & 0x80))
335 return 0;
336
337 shift = (6 - (pkt[0] & 0x03));
338 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
339 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
340 dev->touch = (pkt[0] & 0x10) ? 1 : 0;
341
342 return 1;
343}
344
345static int eturbo_get_pkt_len(unsigned char *buf, int len)
346{
347 if (buf[0] & 0x80)
348 return 5;
349 if (buf[0] == 0x01)
350 return 3;
351 return 0;
352}
353#endif
354
355
356/*****************************************************************************
357 * Gunze part
358 */
359#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
360static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
361{
362 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
363 return 0;
364
365 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
366 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
367 dev->touch = pkt[0] & 0x20;
368
369 return 1;
370}
371#endif
372
373/*****************************************************************************
374 * DMC TSC-10/25 Part
375 *
376 * Documentation about the controller and it's protocol can be found at
377 * http://www.dmccoltd.com/files/controler/tsc10usb_pi_e.pdf
378 * http://www.dmccoltd.com/files/controler/tsc25_usb_e.pdf
379 */
380#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
381
382/* supported data rates. currently using 130 */
383#define TSC10_RATE_POINT 0x50
384#define TSC10_RATE_30 0x40
385#define TSC10_RATE_50 0x41
386#define TSC10_RATE_80 0x42
387#define TSC10_RATE_100 0x43
388#define TSC10_RATE_130 0x44
389#define TSC10_RATE_150 0x45
390
391/* commands */
392#define TSC10_CMD_RESET 0x55
393#define TSC10_CMD_RATE 0x05
394#define TSC10_CMD_DATA1 0x01
395
396static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
397{
398 struct usb_device *dev = usbtouch->udev;
399 int ret;
400 unsigned char buf[2];
401
402 /* reset */
403 buf[0] = buf[1] = 0xFF;
404 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
405 TSC10_CMD_RESET,
406 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
407 0, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
408 if (ret < 0)
409 return ret;
410 if (buf[0] != 0x06 || buf[1] != 0x00)
411 return -ENODEV;
412
413 /* set coordinate output rate */
414 buf[0] = buf[1] = 0xFF;
415 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
416 TSC10_CMD_RATE,
417 USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
418 TSC10_RATE_150, 0, buf, 2, USB_CTRL_SET_TIMEOUT);
419 if (ret < 0)
420 return ret;
421 if ((buf[0] != 0x06 || buf[1] != 0x00) &&
422 (buf[0] != 0x15 || buf[1] != 0x01))
423 return -ENODEV;
424
425 /* start sending data */
426 ret = usb_control_msg(dev, usb_rcvctrlpipe (dev, 0),
427 TSC10_CMD_DATA1,
428 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
429 0, 0, NULL, 0, USB_CTRL_SET_TIMEOUT);
430 if (ret < 0)
431 return ret;
432
433 return 0;
434}
435
436
437static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
438{
439 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
440 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
441 dev->touch = pkt[0] & 0x01;
442
443 return 1;
444}
445#endif
446
447
448/*****************************************************************************
449 * IRTOUCH Part
450 */
451#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
452static int irtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
453{
454 dev->x = (pkt[3] << 8) | pkt[2];
455 dev->y = (pkt[5] << 8) | pkt[4];
456 dev->touch = (pkt[1] & 0x03) ? 1 : 0;
457
458 return 1;
459}
460#endif
461
462
463/*****************************************************************************
464 * IdealTEK URTC1000 Part
465 */
466#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
467#ifndef MULTI_PACKET
468#define MULTI_PACKET
469#endif
470static int idealtek_get_pkt_len(unsigned char *buf, int len)
471{
472 if (buf[0] & 0x80)
473 return 5;
474 if (buf[0] == 0x01)
475 return len;
476 return 0;
477}
478
479static int idealtek_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
480{
481 switch (pkt[0] & 0x98) {
482 case 0x88:
483 /* touch data in IdealTEK mode */
484 dev->x = (pkt[1] << 5) | (pkt[2] >> 2);
485 dev->y = (pkt[3] << 5) | (pkt[4] >> 2);
486 dev->touch = (pkt[0] & 0x40) ? 1 : 0;
487 return 1;
488
489 case 0x98:
490 /* touch data in MT emulation mode */
491 dev->x = (pkt[2] << 5) | (pkt[1] >> 2);
492 dev->y = (pkt[4] << 5) | (pkt[3] >> 2);
493 dev->touch = (pkt[0] & 0x40) ? 1 : 0;
494 return 1;
495
496 default:
497 return 0;
498 }
499}
500#endif
501
502/*****************************************************************************
503 * General Touch Part
504 */
505#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
506static int general_touch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
507{
508 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1] ;
509 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3] ;
510 dev->press = pkt[5] & 0xff;
511 dev->touch = pkt[0] & 0x01;
512
513 return 1;
514}
515#endif
516
517/*****************************************************************************
518 * GoTop Part
519 */
520#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
521static int gotop_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
522{
523 dev->x = ((pkt[1] & 0x38) << 4) | pkt[2];
524 dev->y = ((pkt[1] & 0x07) << 7) | pkt[3];
525 dev->touch = pkt[0] & 0x01;
526 return 1;
527}
528#endif
529
530
531/*****************************************************************************
532 * the different device descriptors
533 */
534#ifdef MULTI_PACKET
535static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
536 unsigned char *pkt, int len);
537#endif
538
539static struct usbtouch_device_info usbtouch_dev_info[] = {
540#ifdef CONFIG_TOUCHSCREEN_USB_EGALAX
541 [DEVTYPE_EGALAX] = {
542 .min_xc = 0x0,
543 .max_xc = 0x07ff,
544 .min_yc = 0x0,
545 .max_yc = 0x07ff,
546 .rept_size = 16,
547 .process_pkt = usbtouch_process_multi,
548 .get_pkt_len = egalax_get_pkt_len,
549 .read_data = egalax_read_data,
550 },
551#endif
552
553#ifdef CONFIG_TOUCHSCREEN_USB_PANJIT
554 [DEVTYPE_PANJIT] = {
555 .min_xc = 0x0,
556 .max_xc = 0x0fff,
557 .min_yc = 0x0,
558 .max_yc = 0x0fff,
559 .rept_size = 8,
560 .read_data = panjit_read_data,
561 },
562#endif
563
564#ifdef CONFIG_TOUCHSCREEN_USB_3M
565 [DEVTYPE_3M] = {
566 .min_xc = 0x0,
567 .max_xc = 0x4000,
568 .min_yc = 0x0,
569 .max_yc = 0x4000,
570 .rept_size = 11,
571 .read_data = mtouch_read_data,
572 .init = mtouch_init,
573 },
574#endif
575
576#ifdef CONFIG_TOUCHSCREEN_USB_ITM
577 [DEVTYPE_ITM] = {
578 .min_xc = 0x0,
579 .max_xc = 0x0fff,
580 .min_yc = 0x0,
581 .max_yc = 0x0fff,
582 .max_press = 0xff,
583 .rept_size = 8,
584 .read_data = itm_read_data,
585 },
586#endif
587
588#ifdef CONFIG_TOUCHSCREEN_USB_ETURBO
589 [DEVTYPE_ETURBO] = {
590 .min_xc = 0x0,
591 .max_xc = 0x07ff,
592 .min_yc = 0x0,
593 .max_yc = 0x07ff,
594 .rept_size = 8,
595 .process_pkt = usbtouch_process_multi,
596 .get_pkt_len = eturbo_get_pkt_len,
597 .read_data = eturbo_read_data,
598 },
599#endif
600
601#ifdef CONFIG_TOUCHSCREEN_USB_GUNZE
602 [DEVTYPE_GUNZE] = {
603 .min_xc = 0x0,
604 .max_xc = 0x0fff,
605 .min_yc = 0x0,
606 .max_yc = 0x0fff,
607 .rept_size = 4,
608 .read_data = gunze_read_data,
609 },
610#endif
611
612#ifdef CONFIG_TOUCHSCREEN_USB_DMC_TSC10
613 [DEVTYPE_DMC_TSC10] = {
614 .min_xc = 0x0,
615 .max_xc = 0x03ff,
616 .min_yc = 0x0,
617 .max_yc = 0x03ff,
618 .rept_size = 5,
619 .init = dmc_tsc10_init,
620 .read_data = dmc_tsc10_read_data,
621 },
622#endif
623
624#ifdef CONFIG_TOUCHSCREEN_USB_IRTOUCH
625 [DEVTYPE_IRTOUCH] = {
626 .min_xc = 0x0,
627 .max_xc = 0x0fff,
628 .min_yc = 0x0,
629 .max_yc = 0x0fff,
630 .rept_size = 8,
631 .read_data = irtouch_read_data,
632 },
633#endif
634
635#ifdef CONFIG_TOUCHSCREEN_USB_IDEALTEK
636 [DEVTYPE_IDEALTEK] = {
637 .min_xc = 0x0,
638 .max_xc = 0x0fff,
639 .min_yc = 0x0,
640 .max_yc = 0x0fff,
641 .rept_size = 8,
642 .process_pkt = usbtouch_process_multi,
643 .get_pkt_len = idealtek_get_pkt_len,
644 .read_data = idealtek_read_data,
645 },
646#endif
647
648#ifdef CONFIG_TOUCHSCREEN_USB_GENERAL_TOUCH
649 [DEVTYPE_GENERAL_TOUCH] = {
650 .min_xc = 0x0,
651 .max_xc = 0x0500,
652 .min_yc = 0x0,
653 .max_yc = 0x0500,
654 .rept_size = 7,
655 .read_data = general_touch_read_data,
656 },
657#endif
658
659#ifdef CONFIG_TOUCHSCREEN_USB_GOTOP
660 [DEVTYPE_GOTOP] = {
661 .min_xc = 0x0,
662 .max_xc = 0x03ff,
663 .min_yc = 0x0,
664 .max_yc = 0x03ff,
665 .rept_size = 4,
666 .read_data = gotop_read_data,
667 },
668#endif
669};
670
671
672/*****************************************************************************
673 * Generic Part
674 */
675static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
676 unsigned char *pkt, int len)
677{
678 struct usbtouch_device_info *type = usbtouch->type;
679
680 if (!type->read_data(usbtouch, pkt))
681 return;
682
683 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
684
685 if (swap_xy) {
686 input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
687 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
688 } else {
689 input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
690 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
691 }
692 if (type->max_press)
693 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
694 input_sync(usbtouch->input);
695}
696
697
698#ifdef MULTI_PACKET
699static void usbtouch_process_multi(struct usbtouch_usb *usbtouch,
700 unsigned char *pkt, int len)
701{
702 unsigned char *buffer;
703 int pkt_len, pos, buf_len, tmp;
704
705 /* process buffer */
706 if (unlikely(usbtouch->buf_len)) {
707 /* try to get size */
708 pkt_len = usbtouch->type->get_pkt_len(
709 usbtouch->buffer, usbtouch->buf_len);
710
711 /* drop? */
712 if (unlikely(!pkt_len))
713 goto out_flush_buf;
714
715 /* need to append -pkt_len bytes before able to get size */
716 if (unlikely(pkt_len < 0)) {
717 int append = -pkt_len;
718 if (unlikely(append > len))
719 append = len;
720 if (usbtouch->buf_len + append >= usbtouch->type->rept_size)
721 goto out_flush_buf;
722 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, append);
723 usbtouch->buf_len += append;
724
725 pkt_len = usbtouch->type->get_pkt_len(
726 usbtouch->buffer, usbtouch->buf_len);
727 if (pkt_len < 0)
728 return;
729 }
730
731 /* append */
732 tmp = pkt_len - usbtouch->buf_len;
733 if (usbtouch->buf_len + tmp >= usbtouch->type->rept_size)
734 goto out_flush_buf;
735 memcpy(usbtouch->buffer + usbtouch->buf_len, pkt, tmp);
736 usbtouch_process_pkt(usbtouch, usbtouch->buffer, pkt_len);
737
738 buffer = pkt + tmp;
739 buf_len = len - tmp;
740 } else {
741 buffer = pkt;
742 buf_len = len;
743 }
744
745 /* loop over the received packet, process */
746 pos = 0;
747 while (pos < buf_len) {
748 /* get packet len */
749 pkt_len = usbtouch->type->get_pkt_len(buffer + pos,
750 buf_len - pos);
751
752 /* unknown packet: skip one byte */
753 if (unlikely(!pkt_len)) {
754 pos++;
755 continue;
756 }
757
758 /* full packet: process */
759 if (likely((pkt_len > 0) && (pkt_len <= buf_len - pos))) {
760 usbtouch_process_pkt(usbtouch, buffer + pos, pkt_len);
761 } else {
762 /* incomplete packet: save in buffer */
763 memcpy(usbtouch->buffer, buffer + pos, buf_len - pos);
764 usbtouch->buf_len = buf_len - pos;
765 return;
766 }
767 pos += pkt_len;
768 }
769
770out_flush_buf:
771 usbtouch->buf_len = 0;
772 return;
773}
774#endif
775
776
777static void usbtouch_irq(struct urb *urb)
778{
779 struct usbtouch_usb *usbtouch = urb->context;
780 int retval;
781
782 switch (urb->status) {
783 case 0:
784 /* success */
785 break;
786 case -ETIME:
787 /* this urb is timing out */
788 dbg("%s - urb timed out - was the device unplugged?",
789 __FUNCTION__);
790 return;
791 case -ECONNRESET:
792 case -ENOENT:
793 case -ESHUTDOWN:
794 /* this urb is terminated, clean up */
795 dbg("%s - urb shutting down with status: %d",
796 __FUNCTION__, urb->status);
797 return;
798 default:
799 dbg("%s - nonzero urb status received: %d",
800 __FUNCTION__, urb->status);
801 goto exit;
802 }
803
804 usbtouch->type->process_pkt(usbtouch, usbtouch->data, urb->actual_length);
805
806exit:
807 retval = usb_submit_urb(urb, GFP_ATOMIC);
808 if (retval)
809 err("%s - usb_submit_urb failed with result: %d",
810 __FUNCTION__, retval);
811}
812
813static int usbtouch_open(struct input_dev *input)
814{
815 struct usbtouch_usb *usbtouch = input_get_drvdata(input);
816
817 usbtouch->irq->dev = usbtouch->udev;
818
819 if (usb_submit_urb(usbtouch->irq, GFP_KERNEL))
820 return -EIO;
821
822 return 0;
823}
824
825static void usbtouch_close(struct input_dev *input)
826{
827 struct usbtouch_usb *usbtouch = input_get_drvdata(input);
828
829 usb_kill_urb(usbtouch->irq);
830}
831
832
833static void usbtouch_free_buffers(struct usb_device *udev,
834 struct usbtouch_usb *usbtouch)
835{
836 usb_buffer_free(udev, usbtouch->type->rept_size,
837 usbtouch->data, usbtouch->data_dma);
838 kfree(usbtouch->buffer);
839}
840
841
842static int usbtouch_probe(struct usb_interface *intf,
843 const struct usb_device_id *id)
844{
845 struct usbtouch_usb *usbtouch;
846 struct input_dev *input_dev;
847 struct usb_host_interface *interface;
848 struct usb_endpoint_descriptor *endpoint;
849 struct usb_device *udev = interface_to_usbdev(intf);
850 struct usbtouch_device_info *type;
851 int err = -ENOMEM;
852
853 interface = intf->cur_altsetting;
854 endpoint = &interface->endpoint[0].desc;
855
856 usbtouch = kzalloc(sizeof(struct usbtouch_usb), GFP_KERNEL);
857 input_dev = input_allocate_device();
858 if (!usbtouch || !input_dev)
859 goto out_free;
860
861 type = &usbtouch_dev_info[id->driver_info];
862 usbtouch->type = type;
863 if (!type->process_pkt)
864 type->process_pkt = usbtouch_process_pkt;
865
866 usbtouch->data = usb_buffer_alloc(udev, type->rept_size,
867 GFP_KERNEL, &usbtouch->data_dma);
868 if (!usbtouch->data)
869 goto out_free;
870
871 if (type->get_pkt_len) {
872 usbtouch->buffer = kmalloc(type->rept_size, GFP_KERNEL);
873 if (!usbtouch->buffer)
874 goto out_free_buffers;
875 }
876
877 usbtouch->irq = usb_alloc_urb(0, GFP_KERNEL);
878 if (!usbtouch->irq) {
879 dbg("%s - usb_alloc_urb failed: usbtouch->irq", __FUNCTION__);
880 goto out_free_buffers;
881 }
882
883 usbtouch->udev = udev;
884 usbtouch->input = input_dev;
885
886 if (udev->manufacturer)
887 strlcpy(usbtouch->name, udev->manufacturer, sizeof(usbtouch->name));
888
889 if (udev->product) {
890 if (udev->manufacturer)
891 strlcat(usbtouch->name, " ", sizeof(usbtouch->name));
892 strlcat(usbtouch->name, udev->product, sizeof(usbtouch->name));
893 }
894
895 if (!strlen(usbtouch->name))
896 snprintf(usbtouch->name, sizeof(usbtouch->name),
897 "USB Touchscreen %04x:%04x",
898 le16_to_cpu(udev->descriptor.idVendor),
899 le16_to_cpu(udev->descriptor.idProduct));
900
901 usb_make_path(udev, usbtouch->phys, sizeof(usbtouch->phys));
902 strlcat(usbtouch->phys, "/input0", sizeof(usbtouch->phys));
903
904 input_dev->name = usbtouch->name;
905 input_dev->phys = usbtouch->phys;
906 usb_to_input_id(udev, &input_dev->id);
907 input_dev->dev.parent = &intf->dev;
908
909 input_set_drvdata(input_dev, usbtouch);
910
911 input_dev->open = usbtouch_open;
912 input_dev->close = usbtouch_close;
913
914 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
915 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
916 input_set_abs_params(input_dev, ABS_X, type->min_xc, type->max_xc, 0, 0);
917 input_set_abs_params(input_dev, ABS_Y, type->min_yc, type->max_yc, 0, 0);
918 if (type->max_press)
919 input_set_abs_params(input_dev, ABS_PRESSURE, type->min_press,
920 type->max_press, 0, 0);
921
922 usb_fill_int_urb(usbtouch->irq, usbtouch->udev,
923 usb_rcvintpipe(usbtouch->udev, endpoint->bEndpointAddress),
924 usbtouch->data, type->rept_size,
925 usbtouch_irq, usbtouch, endpoint->bInterval);
926
927 usbtouch->irq->dev = usbtouch->udev;
928 usbtouch->irq->transfer_dma = usbtouch->data_dma;
929 usbtouch->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
930
931 /* device specific init */
932 if (type->init) {
933 err = type->init(usbtouch);
934 if (err) {
935 dbg("%s - type->init() failed, err: %d", __FUNCTION__, err);
936 goto out_free_buffers;
937 }
938 }
939
940 err = input_register_device(usbtouch->input);
941 if (err) {
942 dbg("%s - input_register_device failed, err: %d", __FUNCTION__, err);
943 goto out_free_buffers;
944 }
945
946 usb_set_intfdata(intf, usbtouch);
947
948 return 0;
949
950out_free_buffers:
951 usbtouch_free_buffers(udev, usbtouch);
952out_free:
953 input_free_device(input_dev);
954 kfree(usbtouch);
955 return err;
956}
957
958static void usbtouch_disconnect(struct usb_interface *intf)
959{
960 struct usbtouch_usb *usbtouch = usb_get_intfdata(intf);
961
962 dbg("%s - called", __FUNCTION__);
963
964 if (!usbtouch)
965 return;
966
967 dbg("%s - usbtouch is initialized, cleaning up", __FUNCTION__);
968 usb_set_intfdata(intf, NULL);
969 usb_kill_urb(usbtouch->irq);
970 input_unregister_device(usbtouch->input);
971 usb_free_urb(usbtouch->irq);
972 usbtouch_free_buffers(interface_to_usbdev(intf), usbtouch);
973 kfree(usbtouch);
974}
975
976MODULE_DEVICE_TABLE(usb, usbtouch_devices);
977
978static struct usb_driver usbtouch_driver = {
979 .name = "usbtouchscreen",
980 .probe = usbtouch_probe,
981 .disconnect = usbtouch_disconnect,
982 .id_table = usbtouch_devices,
983};
984
985static int __init usbtouch_init(void)
986{
987 return usb_register(&usbtouch_driver);
988}
989
990static void __exit usbtouch_cleanup(void)
991{
992 usb_deregister(&usbtouch_driver);
993}
994
995module_init(usbtouch_init);
996module_exit(usbtouch_cleanup);
997
998MODULE_AUTHOR(DRIVER_AUTHOR);
999MODULE_DESCRIPTION(DRIVER_DESC);
1000MODULE_LICENSE("GPL");
1001
1002MODULE_ALIAS("touchkitusb");
1003MODULE_ALIAS("itmtouch");
1004MODULE_ALIAS("mtouchusb");