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
46
47
48
49
50
51
52
53#include <linux/kernel.h>
54#include <linux/module.h>
55#include <linux/errno.h>
56#include <linux/slab.h>
57#include <linux/input.h>
58#include <linux/usb.h>
59#include <linux/uaccess.h>
60#include <asm/unaligned.h>
61#include <asm/byteorder.h>
62#include <linux/bitops.h>
63
64#include <linux/usb/input.h>
65
66
67#define GTCO_VERSION "2.00.0006"
68
69
70
71
72#define VENDOR_ID_GTCO 0x078C
73#define PID_400 0x400
74#define PID_401 0x401
75#define PID_1000 0x1000
76#define PID_1001 0x1001
77#define PID_1002 0x1002
78
79
80#define REPORT_MAX_SIZE 10
81
82
83
84#define MASK_INRANGE 0x20
85#define MASK_BUTTON 0x01F
86
87#define PATHLENGTH 64
88
89
90
91
92static const struct usb_device_id gtco_usbid_table[] = {
93 { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
94 { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
95 { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
96 { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
97 { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
98 { }
99};
100MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
101
102
103
104struct gtco {
105
106 struct input_dev *inputdevice;
107 struct usb_interface *intf;
108 struct urb *urbinfo;
109 dma_addr_t buf_dma;
110 unsigned char * buffer;
111
112 char usbpath[PATHLENGTH];
113 int openCount;
114
115
116 u32 usage;
117 u32 min_X;
118 u32 max_X;
119 u32 min_Y;
120 u32 max_Y;
121 s8 mintilt_X;
122 s8 maxtilt_X;
123 s8 mintilt_Y;
124 s8 maxtilt_Y;
125 u32 maxpressure;
126 u32 minpressure;
127};
128
129
130
131
132
133
134struct hid_descriptor
135{
136 struct usb_descriptor_header header;
137 __le16 bcdHID;
138 u8 bCountryCode;
139 u8 bNumDescriptors;
140 u8 bDescriptorType;
141 __le16 wDescriptorLength;
142} __attribute__ ((packed));
143
144
145#define HID_DESCRIPTOR_SIZE 9
146#define HID_DEVICE_TYPE 33
147#define REPORT_DEVICE_TYPE 34
148
149
150#define PREF_TAG(x) ((x)>>4)
151#define PREF_TYPE(x) ((x>>2)&0x03)
152#define PREF_SIZE(x) ((x)&0x03)
153
154#define TYPE_MAIN 0
155#define TYPE_GLOBAL 1
156#define TYPE_LOCAL 2
157#define TYPE_RESERVED 3
158
159#define TAG_MAIN_INPUT 0x8
160#define TAG_MAIN_OUTPUT 0x9
161#define TAG_MAIN_FEATURE 0xB
162#define TAG_MAIN_COL_START 0xA
163#define TAG_MAIN_COL_END 0xC
164
165#define TAG_GLOB_USAGE 0
166#define TAG_GLOB_LOG_MIN 1
167#define TAG_GLOB_LOG_MAX 2
168#define TAG_GLOB_PHYS_MIN 3
169#define TAG_GLOB_PHYS_MAX 4
170#define TAG_GLOB_UNIT_EXP 5
171#define TAG_GLOB_UNIT 6
172#define TAG_GLOB_REPORT_SZ 7
173#define TAG_GLOB_REPORT_ID 8
174#define TAG_GLOB_REPORT_CNT 9
175#define TAG_GLOB_PUSH 10
176#define TAG_GLOB_POP 11
177
178#define TAG_GLOB_MAX 12
179
180#define DIGITIZER_USAGE_TIP_PRESSURE 0x30
181#define DIGITIZER_USAGE_TILT_X 0x3D
182#define DIGITIZER_USAGE_TILT_Y 0x3E
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199static void parse_hid_report_descriptor(struct gtco *device, char * report,
200 int length)
201{
202 struct device *ddev = &device->intf->dev;
203 int x, i = 0;
204
205
206 __u8 prefix;
207 __u8 size;
208 __u8 tag;
209 __u8 type;
210 __u8 data = 0;
211 __u16 data16 = 0;
212 __u32 data32 = 0;
213
214
215 int inputnum = 0;
216 __u32 usage = 0;
217
218
219 __u32 globalval[TAG_GLOB_MAX];
220 __u32 oldval[TAG_GLOB_MAX];
221
222
223 char maintype = 'x';
224 char globtype[12];
225 int indent = 0;
226 char indentstr[10] = "";
227
228
229 dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
230
231
232 while (i < length) {
233 prefix = report[i];
234
235
236 i++;
237
238
239 size = PREF_SIZE(prefix);
240 switch (size) {
241 case 1:
242 data = report[i];
243 break;
244 case 2:
245 data16 = get_unaligned_le16(&report[i]);
246 break;
247 case 3:
248 size = 4;
249 data32 = get_unaligned_le32(&report[i]);
250 break;
251 }
252
253
254 i += size;
255
256
257 tag = PREF_TAG(prefix);
258 type = PREF_TYPE(prefix);
259 switch (type) {
260 case TYPE_MAIN:
261 strcpy(globtype, "");
262 switch (tag) {
263
264 case TAG_MAIN_INPUT:
265
266
267
268
269
270
271
272 maintype = 'I';
273 if (data == 2)
274 strcpy(globtype, "Variable");
275 else if (data == 3)
276 strcpy(globtype, "Var|Const");
277
278 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
279 globalval[TAG_GLOB_REPORT_ID], inputnum,
280 globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
281 globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
282 globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
283
284
285
286
287
288
289
290
291 switch (inputnum) {
292 case 0:
293 dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
294 if (device->max_X == 0) {
295 device->max_X = globalval[TAG_GLOB_LOG_MAX];
296 device->min_X = globalval[TAG_GLOB_LOG_MIN];
297 }
298 break;
299
300 case 1:
301 dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
302 if (device->max_Y == 0) {
303 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
304 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
305 }
306 break;
307
308 default:
309
310 if (usage == DIGITIZER_USAGE_TILT_X) {
311 if (device->maxtilt_X == 0) {
312 device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
313 device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
314 }
315 }
316
317
318 if (usage == DIGITIZER_USAGE_TILT_Y) {
319 if (device->maxtilt_Y == 0) {
320 device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
321 device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
322 }
323 }
324
325
326 if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
327 if (device->maxpressure == 0) {
328 device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
329 device->minpressure = globalval[TAG_GLOB_LOG_MIN];
330 }
331 }
332
333 break;
334 }
335
336 inputnum++;
337 break;
338
339 case TAG_MAIN_OUTPUT:
340 maintype = 'O';
341 break;
342
343 case TAG_MAIN_FEATURE:
344 maintype = 'F';
345 break;
346
347 case TAG_MAIN_COL_START:
348 maintype = 'S';
349
350 if (data == 0) {
351 dev_dbg(ddev, "======>>>>>> Physical\n");
352 strcpy(globtype, "Physical");
353 } else
354 dev_dbg(ddev, "======>>>>>>\n");
355
356
357 indent++;
358 for (x = 0; x < indent; x++)
359 indentstr[x] = '-';
360 indentstr[x] = 0;
361
362
363 for (x = 0; x < TAG_GLOB_MAX; x++)
364 oldval[x] = globalval[x];
365
366 break;
367
368 case TAG_MAIN_COL_END:
369 dev_dbg(ddev, "<<<<<<======\n");
370 maintype = 'E';
371 indent--;
372 for (x = 0; x < indent; x++)
373 indentstr[x] = '-';
374 indentstr[x] = 0;
375
376
377 for (x = 0; x < TAG_GLOB_MAX; x++)
378 globalval[x] = oldval[x];
379
380 break;
381 }
382
383 switch (size) {
384 case 1:
385 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
386 indentstr, tag, maintype, size, globtype, data);
387 break;
388
389 case 2:
390 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
391 indentstr, tag, maintype, size, globtype, data16);
392 break;
393
394 case 4:
395 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
396 indentstr, tag, maintype, size, globtype, data32);
397 break;
398 }
399 break;
400
401 case TYPE_GLOBAL:
402 switch (tag) {
403 case TAG_GLOB_USAGE:
404
405
406
407
408 if (device->usage == 0)
409 device->usage = data;
410
411 strcpy(globtype, "USAGE");
412 break;
413
414 case TAG_GLOB_LOG_MIN:
415 strcpy(globtype, "LOG_MIN");
416 break;
417
418 case TAG_GLOB_LOG_MAX:
419 strcpy(globtype, "LOG_MAX");
420 break;
421
422 case TAG_GLOB_PHYS_MIN:
423 strcpy(globtype, "PHYS_MIN");
424 break;
425
426 case TAG_GLOB_PHYS_MAX:
427 strcpy(globtype, "PHYS_MAX");
428 break;
429
430 case TAG_GLOB_UNIT_EXP:
431 strcpy(globtype, "EXP");
432 break;
433
434 case TAG_GLOB_UNIT:
435 strcpy(globtype, "UNIT");
436 break;
437
438 case TAG_GLOB_REPORT_SZ:
439 strcpy(globtype, "REPORT_SZ");
440 break;
441
442 case TAG_GLOB_REPORT_ID:
443 strcpy(globtype, "REPORT_ID");
444
445 inputnum = 0;
446 break;
447
448 case TAG_GLOB_REPORT_CNT:
449 strcpy(globtype, "REPORT_CNT");
450 break;
451
452 case TAG_GLOB_PUSH:
453 strcpy(globtype, "PUSH");
454 break;
455
456 case TAG_GLOB_POP:
457 strcpy(globtype, "POP");
458 break;
459 }
460
461
462
463 if (tag < TAG_GLOB_MAX) {
464 switch (size) {
465 case 1:
466 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
467 indentstr, globtype, tag, size, data);
468 globalval[tag] = data;
469 break;
470
471 case 2:
472 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
473 indentstr, globtype, tag, size, data16);
474 globalval[tag] = data16;
475 break;
476
477 case 4:
478 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
479 indentstr, globtype, tag, size, data32);
480 globalval[tag] = data32;
481 break;
482 }
483 } else {
484 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
485 indentstr, tag, size);
486 }
487 break;
488
489 case TYPE_LOCAL:
490 switch (tag) {
491 case TAG_GLOB_USAGE:
492 strcpy(globtype, "USAGE");
493
494 usage = data;
495 break;
496
497 case TAG_GLOB_LOG_MIN:
498 strcpy(globtype, "MIN");
499 break;
500
501 case TAG_GLOB_LOG_MAX:
502 strcpy(globtype, "MAX");
503 break;
504
505 default:
506 strcpy(globtype, "UNKNOWN");
507 break;
508 }
509
510 switch (size) {
511 case 1:
512 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
513 indentstr, tag, globtype, size, data);
514 break;
515
516 case 2:
517 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
518 indentstr, tag, globtype, size, data16);
519 break;
520
521 case 4:
522 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
523 indentstr, tag, globtype, size, data32);
524 break;
525 }
526
527 break;
528 }
529 }
530}
531
532
533
534
535
536
537
538static int gtco_input_open(struct input_dev *inputdev)
539{
540 struct gtco *device = input_get_drvdata(inputdev);
541
542 device->urbinfo->dev = interface_to_usbdev(device->intf);
543 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
544 return -EIO;
545
546 return 0;
547}
548
549
550
551
552static void gtco_input_close(struct input_dev *inputdev)
553{
554 struct gtco *device = input_get_drvdata(inputdev);
555
556 usb_kill_urb(device->urbinfo);
557}
558
559
560
561
562
563
564
565
566
567
568static void gtco_setup_caps(struct input_dev *inputdev)
569{
570 struct gtco *device = input_get_drvdata(inputdev);
571
572
573 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
574 BIT_MASK(EV_MSC);
575
576
577 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
578 BIT_MASK(MSC_RAW);
579
580
581 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
582 0, 0);
583 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
584 0, 0);
585
586
587 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
588
589
590 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
591 device->maxtilt_X, 0, 0);
592 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
593 device->maxtilt_Y, 0, 0);
594 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
595 device->maxpressure, 0, 0);
596
597
598 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
599}
600
601
602
603
604
605
606
607
608
609
610static void gtco_urb_callback(struct urb *urbinfo)
611{
612 struct gtco *device = urbinfo->context;
613 struct input_dev *inputdev;
614 int rc;
615 u32 val = 0;
616 char le_buffer[2];
617
618 inputdev = device->inputdevice;
619
620
621 if (urbinfo->status == -ECONNRESET ||
622 urbinfo->status == -ENOENT ||
623 urbinfo->status == -ESHUTDOWN) {
624
625
626 return;
627 }
628
629 if (urbinfo->status != 0) {
630
631
632
633
634 goto resubmit;
635 }
636
637
638
639
640
641
642 if (inputdev->id.product == PID_1000 ||
643 inputdev->id.product == PID_1001 ||
644 inputdev->id.product == PID_1002) {
645
646
647
648
649
650
651
652 switch (device->buffer[0]) {
653 case 5:
654
655 val = ((u16)(device->buffer[8]) << 1);
656 val |= (u16)(device->buffer[7] >> 7);
657 input_report_abs(inputdev, ABS_PRESSURE,
658 device->buffer[8]);
659
660
661 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
662
663
664 case 4:
665
666 input_report_abs(inputdev, ABS_TILT_X,
667 sign_extend32(device->buffer[6], 6));
668
669 input_report_abs(inputdev, ABS_TILT_Y,
670 sign_extend32(device->buffer[7], 6));
671
672
673 case 2:
674 case 3:
675
676 val = (device->buffer[5]) & MASK_BUTTON;
677
678
679
680 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
681
682
683 case 1:
684
685 val = get_unaligned_le16(&device->buffer[1]);
686 input_report_abs(inputdev, ABS_X, val);
687
688 val = get_unaligned_le16(&device->buffer[3]);
689 input_report_abs(inputdev, ABS_Y, val);
690
691
692 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
693 input_report_abs(inputdev, ABS_DISTANCE, val);
694
695
696
697 if (device->buffer[0] == 1) {
698
699
700
701
702
703
704 val = device->buffer[5] & MASK_BUTTON;
705 dev_dbg(&device->intf->dev,
706 "======>>>>>>REPORT 1: val 0x%X(%d)\n",
707 val, val);
708
709
710
711
712
713 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
714 }
715 break;
716
717 case 7:
718
719 input_event(inputdev, EV_MSC, MSC_SCAN,
720 device->buffer[1]);
721 break;
722 }
723 }
724
725
726 if (inputdev->id.product == PID_400 ||
727 inputdev->id.product == PID_401) {
728
729
730 if (device->buffer[0] == 2) {
731
732 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
733 }
734
735
736 if (device->buffer[0] == 1) {
737 char buttonbyte;
738
739
740 if (device->max_X > 0x10000) {
741
742 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
743 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
744
745 input_report_abs(inputdev, ABS_X, val);
746
747 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
748 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
749
750 le_buffer[1] = (u8)(device->buffer[4] >> 1);
751 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
752
753 val = get_unaligned_le16(le_buffer);
754 input_report_abs(inputdev, ABS_Y, val);
755
756
757
758
759
760 buttonbyte = device->buffer[5] >> 1;
761 } else {
762
763 val = get_unaligned_le16(&device->buffer[1]);
764 input_report_abs(inputdev, ABS_X, val);
765
766 val = get_unaligned_le16(&device->buffer[3]);
767 input_report_abs(inputdev, ABS_Y, val);
768
769 buttonbyte = device->buffer[5];
770 }
771
772
773 val = buttonbyte & MASK_INRANGE ? 1 : 0;
774 input_report_abs(inputdev, ABS_DISTANCE, val);
775
776
777 val = buttonbyte & 0x0F;
778#ifdef USE_BUTTONS
779 for (i = 0; i < 5; i++)
780 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
781#else
782
783 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
784#endif
785
786
787 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
788 }
789 }
790
791
792 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
793
794
795 input_sync(inputdev);
796
797 resubmit:
798 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
799 if (rc != 0)
800 dev_err(&device->intf->dev,
801 "usb_submit_urb failed rc=0x%x\n", rc);
802}
803
804
805
806
807
808
809
810
811
812
813
814
815static int gtco_probe(struct usb_interface *usbinterface,
816 const struct usb_device_id *id)
817{
818
819 struct gtco *gtco;
820 struct input_dev *input_dev;
821 struct hid_descriptor *hid_desc;
822 char *report;
823 int result = 0, retry;
824 int error;
825 struct usb_endpoint_descriptor *endpoint;
826 struct usb_device *udev = interface_to_usbdev(usbinterface);
827
828
829 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
830 input_dev = input_allocate_device();
831 if (!gtco || !input_dev) {
832 dev_err(&usbinterface->dev, "No more memory\n");
833 error = -ENOMEM;
834 goto err_free_devs;
835 }
836
837
838 gtco->inputdevice = input_dev;
839
840
841 gtco->intf = usbinterface;
842
843
844 gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
845 GFP_KERNEL, >co->buf_dma);
846 if (!gtco->buffer) {
847 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
848 error = -ENOMEM;
849 goto err_free_devs;
850 }
851
852
853 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
854 if (!gtco->urbinfo) {
855 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
856 error = -ENOMEM;
857 goto err_free_buf;
858 }
859
860
861 if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
862 dev_err(&usbinterface->dev,
863 "Invalid number of endpoints\n");
864 error = -EINVAL;
865 goto err_free_urb;
866 }
867
868
869
870
871
872 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
873
874
875 dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
876 dev_dbg(&usbinterface->dev, "num endpoints: %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
877 dev_dbg(&usbinterface->dev, "interface class: %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
878 dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
879 if (usb_endpoint_xfer_int(endpoint))
880 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
881
882 dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
883
884
885
886
887
888 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
889 HID_DEVICE_TYPE, &hid_desc) != 0) {
890 dev_err(&usbinterface->dev,
891 "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
892 error = -EIO;
893 goto err_free_urb;
894 }
895
896 dev_dbg(&usbinterface->dev,
897 "Extra descriptor success: type:%d len:%d\n",
898 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
899
900 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
901 if (!report) {
902 dev_err(&usbinterface->dev, "No more memory for report\n");
903 error = -ENOMEM;
904 goto err_free_urb;
905 }
906
907
908 for (retry = 0; retry < 3; retry++) {
909 result = usb_control_msg(udev,
910 usb_rcvctrlpipe(udev, 0),
911 USB_REQ_GET_DESCRIPTOR,
912 USB_RECIP_INTERFACE | USB_DIR_IN,
913 REPORT_DEVICE_TYPE << 8,
914 0,
915 report,
916 le16_to_cpu(hid_desc->wDescriptorLength),
917 5000);
918
919 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
920 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
921 parse_hid_report_descriptor(gtco, report, result);
922 break;
923 }
924 }
925
926 kfree(report);
927
928
929 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
930 dev_err(&usbinterface->dev,
931 "Failed to get HID Report Descriptor of size: %d\n",
932 hid_desc->wDescriptorLength);
933 error = -EIO;
934 goto err_free_urb;
935 }
936
937
938 usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
939 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
940
941
942 input_dev->open = gtco_input_open;
943 input_dev->close = gtco_input_close;
944
945
946 input_dev->name = "GTCO_CalComp";
947 input_dev->phys = gtco->usbpath;
948
949 input_set_drvdata(input_dev, gtco);
950
951
952 gtco_setup_caps(input_dev);
953
954
955 usb_to_input_id(udev, &input_dev->id);
956 input_dev->dev.parent = &usbinterface->dev;
957
958
959 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
960
961 usb_fill_int_urb(gtco->urbinfo,
962 udev,
963 usb_rcvintpipe(udev,
964 endpoint->bEndpointAddress),
965 gtco->buffer,
966 REPORT_MAX_SIZE,
967 gtco_urb_callback,
968 gtco,
969 endpoint->bInterval);
970
971 gtco->urbinfo->transfer_dma = gtco->buf_dma;
972 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
973
974
975 usb_set_intfdata(usbinterface, gtco);
976
977
978 error = input_register_device(input_dev);
979 if (error)
980 goto err_free_urb;
981
982 return 0;
983
984 err_free_urb:
985 usb_free_urb(gtco->urbinfo);
986 err_free_buf:
987 usb_free_coherent(udev, REPORT_MAX_SIZE,
988 gtco->buffer, gtco->buf_dma);
989 err_free_devs:
990 input_free_device(input_dev);
991 kfree(gtco);
992 return error;
993}
994
995
996
997
998
999
1000static void gtco_disconnect(struct usb_interface *interface)
1001{
1002
1003 struct gtco *gtco = usb_get_intfdata(interface);
1004 struct usb_device *udev = interface_to_usbdev(interface);
1005
1006
1007 if (gtco) {
1008 input_unregister_device(gtco->inputdevice);
1009 usb_kill_urb(gtco->urbinfo);
1010 usb_free_urb(gtco->urbinfo);
1011 usb_free_coherent(udev, REPORT_MAX_SIZE,
1012 gtco->buffer, gtco->buf_dma);
1013 kfree(gtco);
1014 }
1015
1016 dev_info(&interface->dev, "gtco driver disconnected\n");
1017}
1018
1019
1020
1021static struct usb_driver gtco_driverinfo_table = {
1022 .name = "gtco",
1023 .id_table = gtco_usbid_table,
1024 .probe = gtco_probe,
1025 .disconnect = gtco_disconnect,
1026};
1027
1028module_usb_driver(gtco_driverinfo_table);
1029
1030MODULE_DESCRIPTION("GTCO digitizer USB driver");
1031MODULE_LICENSE("GPL");
1032