1 /* -*- linux-c -*-
2
3 GTCO digitizer USB driver
4
5 TO CHECK: Is pressure done right on report 5?
6
7 Copyright (C) 2006 GTCO CalComp
8
9 This program is free software; you can redistribute it and/or
10 modify it under the terms of the GNU General Public License
11 as published by the Free Software Foundation; version 2
12 of the License.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
23 Permission to use, copy, modify, distribute, and sell this software and its
24 documentation for any purpose is hereby granted without fee, provided that
25 the above copyright notice appear in all copies and that both that
26 copyright notice and this permission notice appear in supporting
27 documentation, and that the name of GTCO-CalComp not be used in advertising
28 or publicity pertaining to distribution of the software without specific,
29 written prior permission. GTCO-CalComp makes no representations about the
30 suitability of this software for any purpose. It is provided "as is"
31 without express or implied warranty.
32
33 GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
34 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
35 EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
36 CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
37 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
38 TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
39 PERFORMANCE OF THIS SOFTWARE.
40
41 GTCO CalComp, Inc.
42 7125 Riverwood Drive
43 Columbia, MD 21046
44
45 Jeremy Roberson jroberson@gtcocalcomp.com
46 Scott Hill shill@gtcocalcomp.com
47 */
48
49
50
51 /*#define DEBUG*/
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 /* Version with a Major number of 2 is for kernel inclusion only. */
67 #define GTCO_VERSION "2.00.0006"
68
69
70 /* MACROS */
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 /* Max size of a single report */
80 #define REPORT_MAX_SIZE 10
81 #define MAX_COLLECTION_LEVELS 10
82
83
84 /* Bitmask whether pen is in range */
85 #define MASK_INRANGE 0x20
86 #define MASK_BUTTON 0x01F
87
88 #define PATHLENGTH 64
89
90 /* DATA STRUCTURES */
91
92 /* Device table */
93 static const struct usb_device_id gtco_usbid_table[] = {
94 { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
95 { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
96 { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
97 { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
98 { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
99 { }
100 };
101 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
102
103
104 /* Structure to hold all of our device specific stuff */
105 struct gtco {
106
107 struct input_dev *inputdevice; /* input device struct pointer */
108 struct usb_interface *intf; /* the usb interface for this device */
109 struct urb *urbinfo; /* urb for incoming reports */
110 dma_addr_t buf_dma; /* dma addr of the data buffer*/
111 unsigned char * buffer; /* databuffer for reports */
112
113 char usbpath[PATHLENGTH];
114 int openCount;
115
116 /* Information pulled from Report Descriptor */
117 u32 usage;
118 u32 min_X;
119 u32 max_X;
120 u32 min_Y;
121 u32 max_Y;
122 s8 mintilt_X;
123 s8 maxtilt_X;
124 s8 mintilt_Y;
125 s8 maxtilt_Y;
126 u32 maxpressure;
127 u32 minpressure;
128 };
129
130
131
132 /* Code for parsing the HID REPORT DESCRIPTOR */
133
134 /* From HID1.11 spec */
135 struct hid_descriptor
136 {
137 struct usb_descriptor_header header;
138 __le16 bcdHID;
139 u8 bCountryCode;
140 u8 bNumDescriptors;
141 u8 bDescriptorType;
142 __le16 wDescriptorLength;
143 } __attribute__ ((packed));
144
145
146 #define HID_DESCRIPTOR_SIZE 9
147 #define HID_DEVICE_TYPE 33
148 #define REPORT_DEVICE_TYPE 34
149
150
151 #define PREF_TAG(x) ((x)>>4)
152 #define PREF_TYPE(x) ((x>>2)&0x03)
153 #define PREF_SIZE(x) ((x)&0x03)
154
155 #define TYPE_MAIN 0
156 #define TYPE_GLOBAL 1
157 #define TYPE_LOCAL 2
158 #define TYPE_RESERVED 3
159
160 #define TAG_MAIN_INPUT 0x8
161 #define TAG_MAIN_OUTPUT 0x9
162 #define TAG_MAIN_FEATURE 0xB
163 #define TAG_MAIN_COL_START 0xA
164 #define TAG_MAIN_COL_END 0xC
165
166 #define TAG_GLOB_USAGE 0
167 #define TAG_GLOB_LOG_MIN 1
168 #define TAG_GLOB_LOG_MAX 2
169 #define TAG_GLOB_PHYS_MIN 3
170 #define TAG_GLOB_PHYS_MAX 4
171 #define TAG_GLOB_UNIT_EXP 5
172 #define TAG_GLOB_UNIT 6
173 #define TAG_GLOB_REPORT_SZ 7
174 #define TAG_GLOB_REPORT_ID 8
175 #define TAG_GLOB_REPORT_CNT 9
176 #define TAG_GLOB_PUSH 10
177 #define TAG_GLOB_POP 11
178
179 #define TAG_GLOB_MAX 12
180
181 #define DIGITIZER_USAGE_TIP_PRESSURE 0x30
182 #define DIGITIZER_USAGE_TILT_X 0x3D
183 #define DIGITIZER_USAGE_TILT_Y 0x3E
184
185
186 /*
187 * This is an abbreviated parser for the HID Report Descriptor. We
188 * know what devices we are talking to, so this is by no means meant
189 * to be generic. We can make some safe assumptions:
190 *
191 * - We know there are no LONG tags, all short
192 * - We know that we have no MAIN Feature and MAIN Output items
193 * - We know what the IRQ reports are supposed to look like.
194 *
195 * The main purpose of this is to use the HID report desc to figure
196 * out the mins and maxs of the fields in the IRQ reports. The IRQ
197 * reports for 400/401 change slightly if the max X is bigger than 64K.
198 *
199 */
200 static void parse_hid_report_descriptor(struct gtco *device, char * report,
201 int length)
202 {
203 struct device *ddev = &device->intf->dev;
204 int x, i = 0;
205
206 /* Tag primitive vars */
207 __u8 prefix;
208 __u8 size;
209 __u8 tag;
210 __u8 type;
211 __u8 data = 0;
212 __u16 data16 = 0;
213 __u32 data32 = 0;
214
215 /* For parsing logic */
216 int inputnum = 0;
217 __u32 usage = 0;
218
219 /* Global Values, indexed by TAG */
220 __u32 globalval[TAG_GLOB_MAX];
221 __u32 oldval[TAG_GLOB_MAX];
222
223 /* Debug stuff */
224 char maintype = 'x';
225 char globtype[12];
226 int indent = 0;
227 char indentstr[MAX_COLLECTION_LEVELS + 1] = { 0 };
228
229 dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
230
231 /* Walk this report and pull out the info we need */
232 while (i < length) {
233 prefix = report[i++];
234
235 /* Determine data size and save the data in the proper variable */
236 size = (1U << PREF_SIZE(prefix)) >> 1;
237 if (i + size > length) {
238 dev_err(ddev,
239 "Not enough data (need %d, have %d)\n",
240 i + size, length);
241 break;
242 }
243
244 switch (size) {
245 case 1:
246 data = report[i];
247 break;
248 case 2:
249 data16 = get_unaligned_le16(&report[i]);
250 break;
251 case 4:
252 data32 = get_unaligned_le32(&report[i]);
253 break;
254 }
255
256 /* Skip size of data */
257 i += size;
258
259 /* What we do depends on the tag type */
260 tag = PREF_TAG(prefix);
261 type = PREF_TYPE(prefix);
262 switch (type) {
263 case TYPE_MAIN:
264 strcpy(globtype, "");
265 switch (tag) {
266
267 case TAG_MAIN_INPUT:
268 /*
269 * The INPUT MAIN tag signifies this is
270 * information from a report. We need to
271 * figure out what it is and store the
272 * min/max values
273 */
274
275 maintype = 'I';
276 if (data == 2)
277 strcpy(globtype, "Variable");
278 else if (data == 3)
279 strcpy(globtype, "Var|Const");
280
281 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
282 globalval[TAG_GLOB_REPORT_ID], inputnum,
283 globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
284 globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
285 globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
286
287
288 /*
289 We can assume that the first two input items
290 are always the X and Y coordinates. After
291 that, we look for everything else by
292 local usage value
293 */
294 switch (inputnum) {
295 case 0: /* X coord */
296 dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
297 if (device->max_X == 0) {
298 device->max_X = globalval[TAG_GLOB_LOG_MAX];
299 device->min_X = globalval[TAG_GLOB_LOG_MIN];
300 }
301 break;
302
303 case 1: /* Y coord */
304 dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
305 if (device->max_Y == 0) {
306 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
307 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
308 }
309 break;
310
311 default:
312 /* Tilt X */
313 if (usage == DIGITIZER_USAGE_TILT_X) {
314 if (device->maxtilt_X == 0) {
315 device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
316 device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
317 }
318 }
319
320 /* Tilt Y */
321 if (usage == DIGITIZER_USAGE_TILT_Y) {
322 if (device->maxtilt_Y == 0) {
323 device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
324 device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
325 }
326 }
327
328 /* Pressure */
329 if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
330 if (device->maxpressure == 0) {
331 device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
332 device->minpressure = globalval[TAG_GLOB_LOG_MIN];
333 }
334 }
335
336 break;
337 }
338
339 inputnum++;
340 break;
341
342 case TAG_MAIN_OUTPUT:
343 maintype = 'O';
344 break;
345
346 case TAG_MAIN_FEATURE:
347 maintype = 'F';
348 break;
349
350 case TAG_MAIN_COL_START:
351 maintype = 'S';
352
353 if (indent == MAX_COLLECTION_LEVELS) {
354 dev_err(ddev, "Collection level %d would exceed limit of %d\n",
355 indent + 1,
356 MAX_COLLECTION_LEVELS);
357 break;
358 }
359
360 if (data == 0) {
361 dev_dbg(ddev, "======>>>>>> Physical\n");
362 strcpy(globtype, "Physical");
363 } else
364 dev_dbg(ddev, "======>>>>>>\n");
365
366 /* Indent the debug output */
367 indent++;
368 for (x = 0; x < indent; x++)
369 indentstr[x] = '-';
370 indentstr[x] = 0;
371
372 /* Save global tags */
373 for (x = 0; x < TAG_GLOB_MAX; x++)
374 oldval[x] = globalval[x];
375
376 break;
377
378 case TAG_MAIN_COL_END:
379 maintype = 'E';
380
381 if (indent == 0) {
382 dev_err(ddev, "Collection level already at zero\n");
383 break;
384 }
385
386 dev_dbg(ddev, "<<<<<<======\n");
387
388 indent--;
389 for (x = 0; x < indent; x++)
390 indentstr[x] = '-';
391 indentstr[x] = 0;
392
393 /* Copy global tags back */
394 for (x = 0; x < TAG_GLOB_MAX; x++)
395 globalval[x] = oldval[x];
396
397 break;
398 }
399
400 switch (size) {
401 case 1:
402 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
403 indentstr, tag, maintype, size, globtype, data);
404 break;
405
406 case 2:
407 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
408 indentstr, tag, maintype, size, globtype, data16);
409 break;
410
411 case 4:
412 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
413 indentstr, tag, maintype, size, globtype, data32);
414 break;
415 }
416 break;
417
418 case TYPE_GLOBAL:
419 switch (tag) {
420 case TAG_GLOB_USAGE:
421 /*
422 * First time we hit the global usage tag,
423 * it should tell us the type of device
424 */
425 if (device->usage == 0)
426 device->usage = data;
427
428 strcpy(globtype, "USAGE");
429 break;
430
431 case TAG_GLOB_LOG_MIN:
432 strcpy(globtype, "LOG_MIN");
433 break;
434
435 case TAG_GLOB_LOG_MAX:
436 strcpy(globtype, "LOG_MAX");
437 break;
438
439 case TAG_GLOB_PHYS_MIN:
440 strcpy(globtype, "PHYS_MIN");
441 break;
442
443 case TAG_GLOB_PHYS_MAX:
444 strcpy(globtype, "PHYS_MAX");
445 break;
446
447 case TAG_GLOB_UNIT_EXP:
448 strcpy(globtype, "EXP");
449 break;
450
451 case TAG_GLOB_UNIT:
452 strcpy(globtype, "UNIT");
453 break;
454
455 case TAG_GLOB_REPORT_SZ:
456 strcpy(globtype, "REPORT_SZ");
457 break;
458
459 case TAG_GLOB_REPORT_ID:
460 strcpy(globtype, "REPORT_ID");
461 /* New report, restart numbering */
462 inputnum = 0;
463 break;
464
465 case TAG_GLOB_REPORT_CNT:
466 strcpy(globtype, "REPORT_CNT");
467 break;
468
469 case TAG_GLOB_PUSH:
470 strcpy(globtype, "PUSH");
471 break;
472
473 case TAG_GLOB_POP:
474 strcpy(globtype, "POP");
475 break;
476 }
477
478 /* Check to make sure we have a good tag number
479 so we don't overflow array */
480 if (tag < TAG_GLOB_MAX) {
481 switch (size) {
482 case 1:
483 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
484 indentstr, globtype, tag, size, data);
485 globalval[tag] = data;
486 break;
487
488 case 2:
489 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
490 indentstr, globtype, tag, size, data16);
491 globalval[tag] = data16;
492 break;
493
494 case 4:
495 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
496 indentstr, globtype, tag, size, data32);
497 globalval[tag] = data32;
498 break;
499 }
500 } else {
501 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
502 indentstr, tag, size);
503 }
504 break;
505
506 case TYPE_LOCAL:
507 switch (tag) {
508 case TAG_GLOB_USAGE:
509 strcpy(globtype, "USAGE");
510 /* Always 1 byte */
511 usage = data;
512 break;
513
514 case TAG_GLOB_LOG_MIN:
515 strcpy(globtype, "MIN");
516 break;
517
518 case TAG_GLOB_LOG_MAX:
519 strcpy(globtype, "MAX");
520 break;
521
522 default:
523 strcpy(globtype, "UNKNOWN");
524 break;
525 }
526
527 switch (size) {
528 case 1:
529 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
530 indentstr, tag, globtype, size, data);
531 break;
532
533 case 2:
534 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
535 indentstr, tag, globtype, size, data16);
536 break;
537
538 case 4:
539 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
540 indentstr, tag, globtype, size, data32);
541 break;
542 }
543
544 break;
545 }
546 }
547 }
548
549 /* INPUT DRIVER Routines */
550
551 /*
552 * Called when opening the input device. This will submit the URB to
553 * the usb system so we start getting reports
554 */
555 static int gtco_input_open(struct input_dev *inputdev)
556 {
557 struct gtco *device = input_get_drvdata(inputdev);
558
559 device->urbinfo->dev = interface_to_usbdev(device->intf);
560 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
561 return -EIO;
562
563 return 0;
564 }
565
566 /*
567 * Called when closing the input device. This will unlink the URB
568 */
569 static void gtco_input_close(struct input_dev *inputdev)
570 {
571 struct gtco *device = input_get_drvdata(inputdev);
572
573 usb_kill_urb(device->urbinfo);
574 }
575
576
577 /*
578 * Setup input device capabilities. Tell the input system what this
579 * device is capable of generating.
580 *
581 * This information is based on what is read from the HID report and
582 * placed in the struct gtco structure
583 *
584 */
585 static void gtco_setup_caps(struct input_dev *inputdev)
586 {
587 struct gtco *device = input_get_drvdata(inputdev);
588
589 /* Which events */
590 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
591 BIT_MASK(EV_MSC);
592
593 /* Misc event menu block */
594 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
595 BIT_MASK(MSC_RAW);
596
597 /* Absolute values based on HID report info */
598 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
599 0, 0);
600 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
601 0, 0);
602
603 /* Proximity */
604 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
605
606 /* Tilt & pressure */
607 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
608 device->maxtilt_X, 0, 0);
609 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
610 device->maxtilt_Y, 0, 0);
611 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
612 device->maxpressure, 0, 0);
613
614 /* Transducer */
615 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
616 }
617
618 /* USB Routines */
619
620 /*
621 * URB callback routine. Called when we get IRQ reports from the
622 * digitizer.
623 *
624 * This bridges the USB and input device worlds. It generates events
625 * on the input device based on the USB reports.
626 */
627 static void gtco_urb_callback(struct urb *urbinfo)
628 {
629 struct gtco *device = urbinfo->context;
630 struct input_dev *inputdev;
631 int rc;
632 u32 val = 0;
633 char le_buffer[2];
634
635 inputdev = device->inputdevice;
636
637 /* Was callback OK? */
638 if (urbinfo->status == -ECONNRESET ||
639 urbinfo->status == -ENOENT ||
640 urbinfo->status == -ESHUTDOWN) {
641
642 /* Shutdown is occurring. Return and don't queue up any more */
643 return;
644 }
645
646 if (urbinfo->status != 0) {
647 /*
648 * Some unknown error. Hopefully temporary. Just go and
649 * requeue an URB
650 */
651 goto resubmit;
652 }
653
654 /*
655 * Good URB, now process
656 */
657
658 /* PID dependent when we interpret the report */
659 if (inputdev->id.product == PID_1000 ||
660 inputdev->id.product == PID_1001 ||
661 inputdev->id.product == PID_1002) {
662
663 /*
664 * Switch on the report ID
665 * Conveniently, the reports have more information, the higher
666 * the report number. We can just fall through the case
667 * statements if we start with the highest number report
668 */
669 switch (device->buffer[0]) {
670 case 5:
671 /* Pressure is 9 bits */
672 val = ((u16)(device->buffer[8]) << 1);
673 val |= (u16)(device->buffer[7] >> 7);
674 input_report_abs(inputdev, ABS_PRESSURE,
675 device->buffer[8]);
676
677 /* Mask out the Y tilt value used for pressure */
678 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
679
680 /* Fall thru */
681 case 4:
682 /* Tilt */
683 input_report_abs(inputdev, ABS_TILT_X,
684 sign_extend32(device->buffer[6], 6));
685
686 input_report_abs(inputdev, ABS_TILT_Y,
687 sign_extend32(device->buffer[7], 6));
688
689 /* Fall thru */
690 case 2:
691 case 3:
692 /* Convert buttons, only 5 bits possible */
693 val = (device->buffer[5]) & MASK_BUTTON;
694
695 /* We don't apply any meaning to the bitmask,
696 just report */
697 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
698
699 /* Fall thru */
700 case 1:
701 /* All reports have X and Y coords in the same place */
702 val = get_unaligned_le16(&device->buffer[1]);
703 input_report_abs(inputdev, ABS_X, val);
704
705 val = get_unaligned_le16(&device->buffer[3]);
706 input_report_abs(inputdev, ABS_Y, val);
707
708 /* Ditto for proximity bit */
709 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
710 input_report_abs(inputdev, ABS_DISTANCE, val);
711
712 /* Report 1 is an exception to how we handle buttons */
713 /* Buttons are an index, not a bitmask */
714 if (device->buffer[0] == 1) {
715
716 /*
717 * Convert buttons, 5 bit index
718 * Report value of index set as one,
719 * the rest as 0
720 */
721 val = device->buffer[5] & MASK_BUTTON;
722 dev_dbg(&device->intf->dev,
723 "======>>>>>>REPORT 1: val 0x%X(%d)\n",
724 val, val);
725
726 /*
727 * We don't apply any meaning to the button
728 * index, just report it
729 */
730 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
731 }
732 break;
733
734 case 7:
735 /* Menu blocks */
736 input_event(inputdev, EV_MSC, MSC_SCAN,
737 device->buffer[1]);
738 break;
739 }
740 }
741
742 /* Other pid class */
743 if (inputdev->id.product == PID_400 ||
744 inputdev->id.product == PID_401) {
745
746 /* Report 2 */
747 if (device->buffer[0] == 2) {
748 /* Menu blocks */
749 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
750 }
751
752 /* Report 1 */
753 if (device->buffer[0] == 1) {
754 char buttonbyte;
755
756 /* IF X max > 64K, we still a bit from the y report */
757 if (device->max_X > 0x10000) {
758
759 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
760 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
761
762 input_report_abs(inputdev, ABS_X, val);
763
764 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
765 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
766
767 le_buffer[1] = (u8)(device->buffer[4] >> 1);
768 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
769
770 val = get_unaligned_le16(le_buffer);
771 input_report_abs(inputdev, ABS_Y, val);
772
773 /*
774 * Shift the button byte right by one to
775 * make it look like the standard report
776 */
777 buttonbyte = device->buffer[5] >> 1;
778 } else {
779
780 val = get_unaligned_le16(&device->buffer[1]);
781 input_report_abs(inputdev, ABS_X, val);
782
783 val = get_unaligned_le16(&device->buffer[3]);
784 input_report_abs(inputdev, ABS_Y, val);
785
786 buttonbyte = device->buffer[5];
787 }
788
789 /* BUTTONS and PROXIMITY */
790 val = buttonbyte & MASK_INRANGE ? 1 : 0;
791 input_report_abs(inputdev, ABS_DISTANCE, val);
792
793 /* Convert buttons, only 4 bits possible */
794 val = buttonbyte & 0x0F;
795 #ifdef USE_BUTTONS
796 for (i = 0; i < 5; i++)
797 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
798 #else
799 /* We don't apply any meaning to the bitmask, just report */
800 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
801 #endif
802
803 /* TRANSDUCER */
804 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
805 }
806 }
807
808 /* Everybody gets report ID's */
809 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
810
811 /* Sync it up */
812 input_sync(inputdev);
813
814 resubmit:
815 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
816 if (rc != 0)
817 dev_err(&device->intf->dev,
818 "usb_submit_urb failed rc=0x%x\n", rc);
819 }
820
821 /*
822 * The probe routine. This is called when the kernel find the matching USB
823 * vendor/product. We do the following:
824 *
825 * - Allocate mem for a local structure to manage the device
826 * - Request a HID Report Descriptor from the device and parse it to
827 * find out the device parameters
828 * - Create an input device and assign it attributes
829 * - Allocate an URB so the device can talk to us when the input
830 * queue is open
831 */
832 static int gtco_probe(struct usb_interface *usbinterface,
833 const struct usb_device_id *id)
834 {
835
836 struct gtco *gtco;
837 struct input_dev *input_dev;
838 struct hid_descriptor *hid_desc;
839 char *report;
840 int result = 0, retry;
841 int error;
842 struct usb_endpoint_descriptor *endpoint;
843 struct usb_device *udev = interface_to_usbdev(usbinterface);
844
845 /* Allocate memory for device structure */
846 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
847 input_dev = input_allocate_device();
848 if (!gtco || !input_dev) {
849 dev_err(&usbinterface->dev, "No more memory\n");
850 error = -ENOMEM;
851 goto err_free_devs;
852 }
853
854 /* Set pointer to the input device */
855 gtco->inputdevice = input_dev;
856
857 /* Save interface information */
858 gtco->intf = usbinterface;
859
860 /* Allocate some data for incoming reports */
861 gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
862 GFP_KERNEL, >co->buf_dma);
863 if (!gtco->buffer) {
864 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
865 error = -ENOMEM;
866 goto err_free_devs;
867 }
868
869 /* Allocate URB for reports */
870 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
871 if (!gtco->urbinfo) {
872 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
873 error = -ENOMEM;
874 goto err_free_buf;
875 }
876
877 /* Sanity check that a device has an endpoint */
878 if (usbinterface->cur_altsetting->desc.bNumEndpoints < 1) {
879 dev_err(&usbinterface->dev,
880 "Invalid number of endpoints\n");
881 error = -EINVAL;
882 goto err_free_urb;
883 }
884
885 endpoint = &usbinterface->cur_altsetting->endpoint[0].desc;
886
887 /* Some debug */
888 dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
889 dev_dbg(&usbinterface->dev, "num endpoints: %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
890 dev_dbg(&usbinterface->dev, "interface class: %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
891 dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
892 if (usb_endpoint_xfer_int(endpoint))
893 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
894
895 dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
896
897 /*
898 * Find the HID descriptor so we can find out the size of the
899 * HID report descriptor
900 */
901 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
902 HID_DEVICE_TYPE, &hid_desc) != 0) {
903 dev_err(&usbinterface->dev,
904 "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
905 error = -EIO;
906 goto err_free_urb;
907 }
908
909 dev_dbg(&usbinterface->dev,
910 "Extra descriptor success: type:%d len:%d\n",
911 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
912
913 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
914 if (!report) {
915 dev_err(&usbinterface->dev, "No more memory for report\n");
916 error = -ENOMEM;
917 goto err_free_urb;
918 }
919
920 /* Couple of tries to get reply */
921 for (retry = 0; retry < 3; retry++) {
922 result = usb_control_msg(udev,
923 usb_rcvctrlpipe(udev, 0),
924 USB_REQ_GET_DESCRIPTOR,
925 USB_RECIP_INTERFACE | USB_DIR_IN,
926 REPORT_DEVICE_TYPE << 8,
927 0, /* interface */
928 report,
929 le16_to_cpu(hid_desc->wDescriptorLength),
930 5000); /* 5 secs */
931
932 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
933 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
934 parse_hid_report_descriptor(gtco, report, result);
935 break;
936 }
937 }
938
939 kfree(report);
940
941 /* If we didn't get the report, fail */
942 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
943 dev_err(&usbinterface->dev,
944 "Failed to get HID Report Descriptor of size: %d\n",
945 hid_desc->wDescriptorLength);
946 error = -EIO;
947 goto err_free_urb;
948 }
949
950 /* Create a device file node */
951 usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
952 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
953
954 /* Set Input device functions */
955 input_dev->open = gtco_input_open;
956 input_dev->close = gtco_input_close;
957
958 /* Set input device information */
959 input_dev->name = "GTCO_CalComp";
960 input_dev->phys = gtco->usbpath;
961
962 input_set_drvdata(input_dev, gtco);
963
964 /* Now set up all the input device capabilities */
965 gtco_setup_caps(input_dev);
966
967 /* Set input device required ID information */
968 usb_to_input_id(udev, &input_dev->id);
969 input_dev->dev.parent = &usbinterface->dev;
970
971 /* Setup the URB, it will be posted later on open of input device */
972 endpoint = &usbinterface->cur_altsetting->endpoint[0].desc;
973
974 usb_fill_int_urb(gtco->urbinfo,
975 udev,
976 usb_rcvintpipe(udev,
977 endpoint->bEndpointAddress),
978 gtco->buffer,
979 REPORT_MAX_SIZE,
980 gtco_urb_callback,
981 gtco,
982 endpoint->bInterval);
983
984 gtco->urbinfo->transfer_dma = gtco->buf_dma;
985 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
986
987 /* Save gtco pointer in USB interface gtco */
988 usb_set_intfdata(usbinterface, gtco);
989
990 /* All done, now register the input device */
991 error = input_register_device(input_dev);
992 if (error)
993 goto err_free_urb;
994
995 return 0;
996
997 err_free_urb:
998 usb_free_urb(gtco->urbinfo);
999 err_free_buf:
1000 usb_free_coherent(udev, REPORT_MAX_SIZE,
1001 gtco->buffer, gtco->buf_dma);
1002 err_free_devs:
1003 input_free_device(input_dev);
1004 kfree(gtco);
1005 return error;
1006 }
1007
1008 /*
1009 * This function is a standard USB function called when the USB device
1010 * is disconnected. We will get rid of the URV, de-register the input
1011 * device, and free up allocated memory
1012 */
1013 static void gtco_disconnect(struct usb_interface *interface)
1014 {
1015 /* Grab private device ptr */
1016 struct gtco *gtco = usb_get_intfdata(interface);
1017 struct usb_device *udev = interface_to_usbdev(interface);
1018
1019 /* Now reverse all the registration stuff */
1020 if (gtco) {
1021 input_unregister_device(gtco->inputdevice);
1022 usb_kill_urb(gtco->urbinfo);
1023 usb_free_urb(gtco->urbinfo);
1024 usb_free_coherent(udev, REPORT_MAX_SIZE,
1025 gtco->buffer, gtco->buf_dma);
1026 kfree(gtco);
1027 }
1028
1029 dev_info(&interface->dev, "gtco driver disconnected\n");
1030 }
1031
1032 /* STANDARD MODULE LOAD ROUTINES */
1033
1034 static struct usb_driver gtco_driverinfo_table = {
1035 .name = "gtco",
1036 .id_table = gtco_usbid_table,
1037 .probe = gtco_probe,
1038 .disconnect = gtco_disconnect,
1039 };
1040
1041 module_usb_driver(gtco_driverinfo_table);
1042
1043 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1044 MODULE_LICENSE("GPL");