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
82
83 /* Bitmask whether pen is in range */
84 #define MASK_INRANGE 0x20
85 #define MASK_BUTTON 0x01F
86
87 #define PATHLENGTH 64
88
89 /* DATA STRUCTURES */
90
91 /* Device table */
92 static 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 };
100 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
101
102
103 /* Structure to hold all of our device specific stuff */
104 struct gtco {
105
106 struct input_dev *inputdevice; /* input device struct pointer */
107 struct usb_interface *intf; /* the usb interface for this device */
108 struct urb *urbinfo; /* urb for incoming reports */
109 dma_addr_t buf_dma; /* dma addr of the data buffer*/
110 unsigned char * buffer; /* databuffer for reports */
111
112 char usbpath[PATHLENGTH];
113 int openCount;
114
115 /* Information pulled from Report Descriptor */
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 /* Code for parsing the HID REPORT DESCRIPTOR */
132
133 /* From HID1.11 spec */
134 struct 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 * This is an abbreviated parser for the HID Report Descriptor. We
187 * know what devices we are talking to, so this is by no means meant
188 * to be generic. We can make some safe assumptions:
189 *
190 * - We know there are no LONG tags, all short
191 * - We know that we have no MAIN Feature and MAIN Output items
192 * - We know what the IRQ reports are supposed to look like.
193 *
194 * The main purpose of this is to use the HID report desc to figure
195 * out the mins and maxs of the fields in the IRQ reports. The IRQ
196 * reports for 400/401 change slightly if the max X is bigger than 64K.
197 *
198 */
parse_hid_report_descriptor(struct gtco * device,char * report,int length)199 static 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 /* Tag primitive vars */
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 /* For parsing logic */
215 int inputnum = 0;
216 __u32 usage = 0;
217
218 /* Global Values, indexed by TAG */
219 __u32 globalval[TAG_GLOB_MAX];
220 __u32 oldval[TAG_GLOB_MAX];
221
222 /* Debug stuff */
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 /* 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 (data == 0) {
354 dev_dbg(ddev, "======>>>>>> Physical\n");
355 strcpy(globtype, "Physical");
356 } else
357 dev_dbg(ddev, "======>>>>>>\n");
358
359 /* Indent the debug output */
360 indent++;
361 for (x = 0; x < indent; x++)
362 indentstr[x] = '-';
363 indentstr[x] = 0;
364
365 /* Save global tags */
366 for (x = 0; x < TAG_GLOB_MAX; x++)
367 oldval[x] = globalval[x];
368
369 break;
370
371 case TAG_MAIN_COL_END:
372 dev_dbg(ddev, "<<<<<<======\n");
373 maintype = 'E';
374 indent--;
375 for (x = 0; x < indent; x++)
376 indentstr[x] = '-';
377 indentstr[x] = 0;
378
379 /* Copy global tags back */
380 for (x = 0; x < TAG_GLOB_MAX; x++)
381 globalval[x] = oldval[x];
382
383 break;
384 }
385
386 switch (size) {
387 case 1:
388 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
389 indentstr, tag, maintype, size, globtype, data);
390 break;
391
392 case 2:
393 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
394 indentstr, tag, maintype, size, globtype, data16);
395 break;
396
397 case 4:
398 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
399 indentstr, tag, maintype, size, globtype, data32);
400 break;
401 }
402 break;
403
404 case TYPE_GLOBAL:
405 switch (tag) {
406 case TAG_GLOB_USAGE:
407 /*
408 * First time we hit the global usage tag,
409 * it should tell us the type of device
410 */
411 if (device->usage == 0)
412 device->usage = data;
413
414 strcpy(globtype, "USAGE");
415 break;
416
417 case TAG_GLOB_LOG_MIN:
418 strcpy(globtype, "LOG_MIN");
419 break;
420
421 case TAG_GLOB_LOG_MAX:
422 strcpy(globtype, "LOG_MAX");
423 break;
424
425 case TAG_GLOB_PHYS_MIN:
426 strcpy(globtype, "PHYS_MIN");
427 break;
428
429 case TAG_GLOB_PHYS_MAX:
430 strcpy(globtype, "PHYS_MAX");
431 break;
432
433 case TAG_GLOB_UNIT_EXP:
434 strcpy(globtype, "EXP");
435 break;
436
437 case TAG_GLOB_UNIT:
438 strcpy(globtype, "UNIT");
439 break;
440
441 case TAG_GLOB_REPORT_SZ:
442 strcpy(globtype, "REPORT_SZ");
443 break;
444
445 case TAG_GLOB_REPORT_ID:
446 strcpy(globtype, "REPORT_ID");
447 /* New report, restart numbering */
448 inputnum = 0;
449 break;
450
451 case TAG_GLOB_REPORT_CNT:
452 strcpy(globtype, "REPORT_CNT");
453 break;
454
455 case TAG_GLOB_PUSH:
456 strcpy(globtype, "PUSH");
457 break;
458
459 case TAG_GLOB_POP:
460 strcpy(globtype, "POP");
461 break;
462 }
463
464 /* Check to make sure we have a good tag number
465 so we don't overflow array */
466 if (tag < TAG_GLOB_MAX) {
467 switch (size) {
468 case 1:
469 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
470 indentstr, globtype, tag, size, data);
471 globalval[tag] = data;
472 break;
473
474 case 2:
475 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
476 indentstr, globtype, tag, size, data16);
477 globalval[tag] = data16;
478 break;
479
480 case 4:
481 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
482 indentstr, globtype, tag, size, data32);
483 globalval[tag] = data32;
484 break;
485 }
486 } else {
487 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
488 indentstr, tag, size);
489 }
490 break;
491
492 case TYPE_LOCAL:
493 switch (tag) {
494 case TAG_GLOB_USAGE:
495 strcpy(globtype, "USAGE");
496 /* Always 1 byte */
497 usage = data;
498 break;
499
500 case TAG_GLOB_LOG_MIN:
501 strcpy(globtype, "MIN");
502 break;
503
504 case TAG_GLOB_LOG_MAX:
505 strcpy(globtype, "MAX");
506 break;
507
508 default:
509 strcpy(globtype, "UNKNOWN");
510 break;
511 }
512
513 switch (size) {
514 case 1:
515 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
516 indentstr, tag, globtype, size, data);
517 break;
518
519 case 2:
520 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
521 indentstr, tag, globtype, size, data16);
522 break;
523
524 case 4:
525 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
526 indentstr, tag, globtype, size, data32);
527 break;
528 }
529
530 break;
531 }
532 }
533 }
534
535 /* INPUT DRIVER Routines */
536
537 /*
538 * Called when opening the input device. This will submit the URB to
539 * the usb system so we start getting reports
540 */
gtco_input_open(struct input_dev * inputdev)541 static int gtco_input_open(struct input_dev *inputdev)
542 {
543 struct gtco *device = input_get_drvdata(inputdev);
544
545 device->urbinfo->dev = interface_to_usbdev(device->intf);
546 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
547 return -EIO;
548
549 return 0;
550 }
551
552 /*
553 * Called when closing the input device. This will unlink the URB
554 */
gtco_input_close(struct input_dev * inputdev)555 static void gtco_input_close(struct input_dev *inputdev)
556 {
557 struct gtco *device = input_get_drvdata(inputdev);
558
559 usb_kill_urb(device->urbinfo);
560 }
561
562
563 /*
564 * Setup input device capabilities. Tell the input system what this
565 * device is capable of generating.
566 *
567 * This information is based on what is read from the HID report and
568 * placed in the struct gtco structure
569 *
570 */
gtco_setup_caps(struct input_dev * inputdev)571 static void gtco_setup_caps(struct input_dev *inputdev)
572 {
573 struct gtco *device = input_get_drvdata(inputdev);
574
575 /* Which events */
576 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
577 BIT_MASK(EV_MSC);
578
579 /* Misc event menu block */
580 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
581 BIT_MASK(MSC_RAW);
582
583 /* Absolute values based on HID report info */
584 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
585 0, 0);
586 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
587 0, 0);
588
589 /* Proximity */
590 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
591
592 /* Tilt & pressure */
593 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
594 device->maxtilt_X, 0, 0);
595 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
596 device->maxtilt_Y, 0, 0);
597 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
598 device->maxpressure, 0, 0);
599
600 /* Transducer */
601 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
602 }
603
604 /* USB Routines */
605
606 /*
607 * URB callback routine. Called when we get IRQ reports from the
608 * digitizer.
609 *
610 * This bridges the USB and input device worlds. It generates events
611 * on the input device based on the USB reports.
612 */
gtco_urb_callback(struct urb * urbinfo)613 static void gtco_urb_callback(struct urb *urbinfo)
614 {
615 struct gtco *device = urbinfo->context;
616 struct input_dev *inputdev;
617 int rc;
618 u32 val = 0;
619 char le_buffer[2];
620
621 inputdev = device->inputdevice;
622
623 /* Was callback OK? */
624 if (urbinfo->status == -ECONNRESET ||
625 urbinfo->status == -ENOENT ||
626 urbinfo->status == -ESHUTDOWN) {
627
628 /* Shutdown is occurring. Return and don't queue up any more */
629 return;
630 }
631
632 if (urbinfo->status != 0) {
633 /*
634 * Some unknown error. Hopefully temporary. Just go and
635 * requeue an URB
636 */
637 goto resubmit;
638 }
639
640 /*
641 * Good URB, now process
642 */
643
644 /* PID dependent when we interpret the report */
645 if (inputdev->id.product == PID_1000 ||
646 inputdev->id.product == PID_1001 ||
647 inputdev->id.product == PID_1002) {
648
649 /*
650 * Switch on the report ID
651 * Conveniently, the reports have more information, the higher
652 * the report number. We can just fall through the case
653 * statements if we start with the highest number report
654 */
655 switch (device->buffer[0]) {
656 case 5:
657 /* Pressure is 9 bits */
658 val = ((u16)(device->buffer[8]) << 1);
659 val |= (u16)(device->buffer[7] >> 7);
660 input_report_abs(inputdev, ABS_PRESSURE,
661 device->buffer[8]);
662
663 /* Mask out the Y tilt value used for pressure */
664 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
665
666 /* Fall thru */
667 case 4:
668 /* Tilt */
669 input_report_abs(inputdev, ABS_TILT_X,
670 sign_extend32(device->buffer[6], 6));
671
672 input_report_abs(inputdev, ABS_TILT_Y,
673 sign_extend32(device->buffer[7], 6));
674
675 /* Fall thru */
676 case 2:
677 case 3:
678 /* Convert buttons, only 5 bits possible */
679 val = (device->buffer[5]) & MASK_BUTTON;
680
681 /* We don't apply any meaning to the bitmask,
682 just report */
683 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
684
685 /* Fall thru */
686 case 1:
687 /* All reports have X and Y coords in the same place */
688 val = get_unaligned_le16(&device->buffer[1]);
689 input_report_abs(inputdev, ABS_X, val);
690
691 val = get_unaligned_le16(&device->buffer[3]);
692 input_report_abs(inputdev, ABS_Y, val);
693
694 /* Ditto for proximity bit */
695 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
696 input_report_abs(inputdev, ABS_DISTANCE, val);
697
698 /* Report 1 is an exception to how we handle buttons */
699 /* Buttons are an index, not a bitmask */
700 if (device->buffer[0] == 1) {
701
702 /*
703 * Convert buttons, 5 bit index
704 * Report value of index set as one,
705 * the rest as 0
706 */
707 val = device->buffer[5] & MASK_BUTTON;
708 dev_dbg(&device->intf->dev,
709 "======>>>>>>REPORT 1: val 0x%X(%d)\n",
710 val, val);
711
712 /*
713 * We don't apply any meaning to the button
714 * index, just report it
715 */
716 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
717 }
718 break;
719
720 case 7:
721 /* Menu blocks */
722 input_event(inputdev, EV_MSC, MSC_SCAN,
723 device->buffer[1]);
724 break;
725 }
726 }
727
728 /* Other pid class */
729 if (inputdev->id.product == PID_400 ||
730 inputdev->id.product == PID_401) {
731
732 /* Report 2 */
733 if (device->buffer[0] == 2) {
734 /* Menu blocks */
735 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
736 }
737
738 /* Report 1 */
739 if (device->buffer[0] == 1) {
740 char buttonbyte;
741
742 /* IF X max > 64K, we still a bit from the y report */
743 if (device->max_X > 0x10000) {
744
745 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
746 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
747
748 input_report_abs(inputdev, ABS_X, val);
749
750 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
751 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
752
753 le_buffer[1] = (u8)(device->buffer[4] >> 1);
754 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
755
756 val = get_unaligned_le16(le_buffer);
757 input_report_abs(inputdev, ABS_Y, val);
758
759 /*
760 * Shift the button byte right by one to
761 * make it look like the standard report
762 */
763 buttonbyte = device->buffer[5] >> 1;
764 } else {
765
766 val = get_unaligned_le16(&device->buffer[1]);
767 input_report_abs(inputdev, ABS_X, val);
768
769 val = get_unaligned_le16(&device->buffer[3]);
770 input_report_abs(inputdev, ABS_Y, val);
771
772 buttonbyte = device->buffer[5];
773 }
774
775 /* BUTTONS and PROXIMITY */
776 val = buttonbyte & MASK_INRANGE ? 1 : 0;
777 input_report_abs(inputdev, ABS_DISTANCE, val);
778
779 /* Convert buttons, only 4 bits possible */
780 val = buttonbyte & 0x0F;
781 #ifdef USE_BUTTONS
782 for (i = 0; i < 5; i++)
783 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
784 #else
785 /* We don't apply any meaning to the bitmask, just report */
786 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
787 #endif
788
789 /* TRANSDUCER */
790 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
791 }
792 }
793
794 /* Everybody gets report ID's */
795 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
796
797 /* Sync it up */
798 input_sync(inputdev);
799
800 resubmit:
801 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
802 if (rc != 0)
803 dev_err(&device->intf->dev,
804 "usb_submit_urb failed rc=0x%x\n", rc);
805 }
806
807 /*
808 * The probe routine. This is called when the kernel find the matching USB
809 * vendor/product. We do the following:
810 *
811 * - Allocate mem for a local structure to manage the device
812 * - Request a HID Report Descriptor from the device and parse it to
813 * find out the device parameters
814 * - Create an input device and assign it attributes
815 * - Allocate an URB so the device can talk to us when the input
816 * queue is open
817 */
gtco_probe(struct usb_interface * usbinterface,const struct usb_device_id * id)818 static int gtco_probe(struct usb_interface *usbinterface,
819 const struct usb_device_id *id)
820 {
821
822 struct gtco *gtco;
823 struct input_dev *input_dev;
824 struct hid_descriptor *hid_desc;
825 char *report;
826 int result = 0, retry;
827 int error;
828 struct usb_endpoint_descriptor *endpoint;
829 struct usb_device *udev = interface_to_usbdev(usbinterface);
830
831 /* Allocate memory for device structure */
832 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
833 input_dev = input_allocate_device();
834 if (!gtco || !input_dev) {
835 dev_err(&usbinterface->dev, "No more memory\n");
836 error = -ENOMEM;
837 goto err_free_devs;
838 }
839
840 /* Set pointer to the input device */
841 gtco->inputdevice = input_dev;
842
843 /* Save interface information */
844 gtco->intf = usbinterface;
845
846 /* Allocate some data for incoming reports */
847 gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
848 GFP_KERNEL, >co->buf_dma);
849 if (!gtco->buffer) {
850 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
851 error = -ENOMEM;
852 goto err_free_devs;
853 }
854
855 /* Allocate URB for reports */
856 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
857 if (!gtco->urbinfo) {
858 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
859 error = -ENOMEM;
860 goto err_free_buf;
861 }
862
863 /* Sanity check that a device has an endpoint */
864 if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
865 dev_err(&usbinterface->dev,
866 "Invalid number of endpoints\n");
867 error = -EINVAL;
868 goto err_free_urb;
869 }
870
871 /*
872 * The endpoint is always altsetting 0, we know this since we know
873 * this device only has one interrupt endpoint
874 */
875 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
876
877 /* Some debug */
878 dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
879 dev_dbg(&usbinterface->dev, "num endpoints: %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
880 dev_dbg(&usbinterface->dev, "interface class: %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
881 dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
882 if (usb_endpoint_xfer_int(endpoint))
883 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
884
885 dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
886
887 /*
888 * Find the HID descriptor so we can find out the size of the
889 * HID report descriptor
890 */
891 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
892 HID_DEVICE_TYPE, &hid_desc) != 0) {
893 dev_err(&usbinterface->dev,
894 "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
895 error = -EIO;
896 goto err_free_urb;
897 }
898
899 dev_dbg(&usbinterface->dev,
900 "Extra descriptor success: type:%d len:%d\n",
901 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
902
903 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
904 if (!report) {
905 dev_err(&usbinterface->dev, "No more memory for report\n");
906 error = -ENOMEM;
907 goto err_free_urb;
908 }
909
910 /* Couple of tries to get reply */
911 for (retry = 0; retry < 3; retry++) {
912 result = usb_control_msg(udev,
913 usb_rcvctrlpipe(udev, 0),
914 USB_REQ_GET_DESCRIPTOR,
915 USB_RECIP_INTERFACE | USB_DIR_IN,
916 REPORT_DEVICE_TYPE << 8,
917 0, /* interface */
918 report,
919 le16_to_cpu(hid_desc->wDescriptorLength),
920 5000); /* 5 secs */
921
922 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
923 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
924 parse_hid_report_descriptor(gtco, report, result);
925 break;
926 }
927 }
928
929 kfree(report);
930
931 /* If we didn't get the report, fail */
932 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
933 dev_err(&usbinterface->dev,
934 "Failed to get HID Report Descriptor of size: %d\n",
935 hid_desc->wDescriptorLength);
936 error = -EIO;
937 goto err_free_urb;
938 }
939
940 /* Create a device file node */
941 usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
942 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
943
944 /* Set Input device functions */
945 input_dev->open = gtco_input_open;
946 input_dev->close = gtco_input_close;
947
948 /* Set input device information */
949 input_dev->name = "GTCO_CalComp";
950 input_dev->phys = gtco->usbpath;
951
952 input_set_drvdata(input_dev, gtco);
953
954 /* Now set up all the input device capabilities */
955 gtco_setup_caps(input_dev);
956
957 /* Set input device required ID information */
958 usb_to_input_id(udev, &input_dev->id);
959 input_dev->dev.parent = &usbinterface->dev;
960
961 /* Setup the URB, it will be posted later on open of input device */
962 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
963
964 usb_fill_int_urb(gtco->urbinfo,
965 udev,
966 usb_rcvintpipe(udev,
967 endpoint->bEndpointAddress),
968 gtco->buffer,
969 REPORT_MAX_SIZE,
970 gtco_urb_callback,
971 gtco,
972 endpoint->bInterval);
973
974 gtco->urbinfo->transfer_dma = gtco->buf_dma;
975 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
976
977 /* Save gtco pointer in USB interface gtco */
978 usb_set_intfdata(usbinterface, gtco);
979
980 /* All done, now register the input device */
981 error = input_register_device(input_dev);
982 if (error)
983 goto err_free_urb;
984
985 return 0;
986
987 err_free_urb:
988 usb_free_urb(gtco->urbinfo);
989 err_free_buf:
990 usb_free_coherent(udev, REPORT_MAX_SIZE,
991 gtco->buffer, gtco->buf_dma);
992 err_free_devs:
993 input_free_device(input_dev);
994 kfree(gtco);
995 return error;
996 }
997
998 /*
999 * This function is a standard USB function called when the USB device
1000 * is disconnected. We will get rid of the URV, de-register the input
1001 * device, and free up allocated memory
1002 */
gtco_disconnect(struct usb_interface * interface)1003 static void gtco_disconnect(struct usb_interface *interface)
1004 {
1005 /* Grab private device ptr */
1006 struct gtco *gtco = usb_get_intfdata(interface);
1007 struct usb_device *udev = interface_to_usbdev(interface);
1008
1009 /* Now reverse all the registration stuff */
1010 if (gtco) {
1011 input_unregister_device(gtco->inputdevice);
1012 usb_kill_urb(gtco->urbinfo);
1013 usb_free_urb(gtco->urbinfo);
1014 usb_free_coherent(udev, REPORT_MAX_SIZE,
1015 gtco->buffer, gtco->buf_dma);
1016 kfree(gtco);
1017 }
1018
1019 dev_info(&interface->dev, "gtco driver disconnected\n");
1020 }
1021
1022 /* STANDARD MODULE LOAD ROUTINES */
1023
1024 static struct usb_driver gtco_driverinfo_table = {
1025 .name = "gtco",
1026 .id_table = gtco_usbid_table,
1027 .probe = gtco_probe,
1028 .disconnect = gtco_disconnect,
1029 };
1030
1031 module_usb_driver(gtco_driverinfo_table);
1032
1033 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1034 MODULE_LICENSE("GPL");
1035
