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