tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/* -*- linux-c -*-
2
3GTCO digitizer USB driver
4
5TO CHECK: Is pressure done right on report 5?
6
7Copyright (C) 2006 GTCO CalComp
8
9This program is free software; you can redistribute it and/or
10modify it under the terms of the GNU General Public License
11as published by the Free Software Foundation; version 2
12of the License.
13
14This program is distributed in the hope that it will be useful,
15but WITHOUT ANY WARRANTY; without even the implied warranty of
16MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17GNU General Public License for more details.
18
19You should have received a copy of the GNU General Public License
20along with this program; if not, write to the Free Software
21Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22
23Permission to use, copy, modify, distribute, and sell this software and its
24documentation for any purpose is hereby granted without fee, provided that
25the above copyright notice appear in all copies and that both that
26copyright notice and this permission notice appear in supporting
27documentation, and that the name of GTCO-CalComp not be used in advertising
28or publicity pertaining to distribution of the software without specific,
29written prior permission. GTCO-CalComp makes no representations about the
30suitability of this software for any purpose. It is provided "as is"
31without express or implied warranty.
32
33GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
34INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
35EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
36CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
37DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
38TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
39PERFORMANCE OF THIS SOFTWARE.
40
41GTCO CalComp, Inc.
427125 Riverwood Drive
43Columbia, MD 21046
44
45Jeremy Roberson jroberson@gtcocalcomp.com
46Scott 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 <asm/uaccess.h>
60#include <asm/unaligned.h>
61#include <asm/byteorder.h>
62
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 */
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/* Structure to hold all of our device specific stuff */
104struct gtco {
105
106 struct input_dev *inputdevice; /* input device struct pointer */
107 struct usb_device *usbdev; /* the usb device for this device */
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 */
135struct 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 */
200static 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[10] = "";
228
229
230 dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
231
232 /* Walk this report and pull out the info we need */
233 while (i < length) {
234 prefix = report[i];
235
236 /* Skip over prefix */
237 i++;
238
239 /* Determine data size and save the data in the proper variable */
240 size = PREF_SIZE(prefix);
241 switch (size) {
242 case 1:
243 data = report[i];
244 break;
245 case 2:
246 data16 = get_unaligned_le16(&report[i]);
247 break;
248 case 3:
249 size = 4;
250 data32 = get_unaligned_le32(&report[i]);
251 break;
252 }
253
254 /* Skip size of data */
255 i += size;
256
257 /* What we do depends on the tag type */
258 tag = PREF_TAG(prefix);
259 type = PREF_TYPE(prefix);
260 switch (type) {
261 case TYPE_MAIN:
262 strcpy(globtype, "");
263 switch (tag) {
264
265 case TAG_MAIN_INPUT:
266 /*
267 * The INPUT MAIN tag signifies this is
268 * information from a report. We need to
269 * figure out what it is and store the
270 * min/max values
271 */
272
273 maintype = 'I';
274 if (data == 2)
275 strcpy(globtype, "Variable");
276 else if (data == 3)
277 strcpy(globtype, "Var|Const");
278
279 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
280 globalval[TAG_GLOB_REPORT_ID], inputnum,
281 globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
282 globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
283 globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
284
285
286 /*
287 We can assume that the first two input items
288 are always the X and Y coordinates. After
289 that, we look for everything else by
290 local usage value
291 */
292 switch (inputnum) {
293 case 0: /* X coord */
294 dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
295 if (device->max_X == 0) {
296 device->max_X = globalval[TAG_GLOB_LOG_MAX];
297 device->min_X = globalval[TAG_GLOB_LOG_MIN];
298 }
299 break;
300
301 case 1: /* Y coord */
302 dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
303 if (device->max_Y == 0) {
304 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
305 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
306 }
307 break;
308
309 default:
310 /* Tilt X */
311 if (usage == DIGITIZER_USAGE_TILT_X) {
312 if (device->maxtilt_X == 0) {
313 device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
314 device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
315 }
316 }
317
318 /* Tilt Y */
319 if (usage == DIGITIZER_USAGE_TILT_Y) {
320 if (device->maxtilt_Y == 0) {
321 device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
322 device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
323 }
324 }
325
326 /* Pressure */
327 if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
328 if (device->maxpressure == 0) {
329 device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
330 device->minpressure = globalval[TAG_GLOB_LOG_MIN];
331 }
332 }
333
334 break;
335 }
336
337 inputnum++;
338 break;
339
340 case TAG_MAIN_OUTPUT:
341 maintype = 'O';
342 break;
343
344 case TAG_MAIN_FEATURE:
345 maintype = 'F';
346 break;
347
348 case TAG_MAIN_COL_START:
349 maintype = 'S';
350
351 if (data == 0) {
352 dev_dbg(ddev, "======>>>>>> Physical\n");
353 strcpy(globtype, "Physical");
354 } else
355 dev_dbg(ddev, "======>>>>>>\n");
356
357 /* Indent the debug output */
358 indent++;
359 for (x = 0; x < indent; x++)
360 indentstr[x] = '-';
361 indentstr[x] = 0;
362
363 /* Save global tags */
364 for (x = 0; x < TAG_GLOB_MAX; x++)
365 oldval[x] = globalval[x];
366
367 break;
368
369 case TAG_MAIN_COL_END:
370 dev_dbg(ddev, "<<<<<<======\n");
371 maintype = 'E';
372 indent--;
373 for (x = 0; x < indent; x++)
374 indentstr[x] = '-';
375 indentstr[x] = 0;
376
377 /* Copy global tags back */
378 for (x = 0; x < TAG_GLOB_MAX; x++)
379 globalval[x] = oldval[x];
380
381 break;
382 }
383
384 switch (size) {
385 case 1:
386 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
387 indentstr, tag, maintype, size, globtype, data);
388 break;
389
390 case 2:
391 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
392 indentstr, tag, maintype, size, globtype, data16);
393 break;
394
395 case 4:
396 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
397 indentstr, tag, maintype, size, globtype, data32);
398 break;
399 }
400 break;
401
402 case TYPE_GLOBAL:
403 switch (tag) {
404 case TAG_GLOB_USAGE:
405 /*
406 * First time we hit the global usage tag,
407 * it should tell us the type of device
408 */
409 if (device->usage == 0)
410 device->usage = data;
411
412 strcpy(globtype, "USAGE");
413 break;
414
415 case TAG_GLOB_LOG_MIN:
416 strcpy(globtype, "LOG_MIN");
417 break;
418
419 case TAG_GLOB_LOG_MAX:
420 strcpy(globtype, "LOG_MAX");
421 break;
422
423 case TAG_GLOB_PHYS_MIN:
424 strcpy(globtype, "PHYS_MIN");
425 break;
426
427 case TAG_GLOB_PHYS_MAX:
428 strcpy(globtype, "PHYS_MAX");
429 break;
430
431 case TAG_GLOB_UNIT_EXP:
432 strcpy(globtype, "EXP");
433 break;
434
435 case TAG_GLOB_UNIT:
436 strcpy(globtype, "UNIT");
437 break;
438
439 case TAG_GLOB_REPORT_SZ:
440 strcpy(globtype, "REPORT_SZ");
441 break;
442
443 case TAG_GLOB_REPORT_ID:
444 strcpy(globtype, "REPORT_ID");
445 /* New report, restart numbering */
446 inputnum = 0;
447 break;
448
449 case TAG_GLOB_REPORT_CNT:
450 strcpy(globtype, "REPORT_CNT");
451 break;
452
453 case TAG_GLOB_PUSH:
454 strcpy(globtype, "PUSH");
455 break;
456
457 case TAG_GLOB_POP:
458 strcpy(globtype, "POP");
459 break;
460 }
461
462 /* Check to make sure we have a good tag number
463 so we don't overflow array */
464 if (tag < TAG_GLOB_MAX) {
465 switch (size) {
466 case 1:
467 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
468 indentstr, globtype, tag, size, data);
469 globalval[tag] = data;
470 break;
471
472 case 2:
473 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
474 indentstr, globtype, tag, size, data16);
475 globalval[tag] = data16;
476 break;
477
478 case 4:
479 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
480 indentstr, globtype, tag, size, data32);
481 globalval[tag] = data32;
482 break;
483 }
484 } else {
485 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
486 indentstr, tag, size);
487 }
488 break;
489
490 case TYPE_LOCAL:
491 switch (tag) {
492 case TAG_GLOB_USAGE:
493 strcpy(globtype, "USAGE");
494 /* Always 1 byte */
495 usage = data;
496 break;
497
498 case TAG_GLOB_LOG_MIN:
499 strcpy(globtype, "MIN");
500 break;
501
502 case TAG_GLOB_LOG_MAX:
503 strcpy(globtype, "MAX");
504 break;
505
506 default:
507 strcpy(globtype, "UNKNOWN");
508 break;
509 }
510
511 switch (size) {
512 case 1:
513 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
514 indentstr, tag, globtype, size, data);
515 break;
516
517 case 2:
518 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
519 indentstr, tag, globtype, size, data16);
520 break;
521
522 case 4:
523 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
524 indentstr, tag, globtype, size, data32);
525 break;
526 }
527
528 break;
529 }
530 }
531}
532
533/* INPUT DRIVER Routines */
534
535/*
536 * Called when opening the input device. This will submit the URB to
537 * the usb system so we start getting reports
538 */
539static int gtco_input_open(struct input_dev *inputdev)
540{
541 struct gtco *device = input_get_drvdata(inputdev);
542
543 device->urbinfo->dev = device->usbdev;
544 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
545 return -EIO;
546
547 return 0;
548}
549
550/*
551 * Called when closing the input device. This will unlink the URB
552 */
553static void gtco_input_close(struct input_dev *inputdev)
554{
555 struct gtco *device = input_get_drvdata(inputdev);
556
557 usb_kill_urb(device->urbinfo);
558}
559
560
561/*
562 * Setup input device capabilities. Tell the input system what this
563 * device is capable of generating.
564 *
565 * This information is based on what is read from the HID report and
566 * placed in the struct gtco structure
567 *
568 */
569static void gtco_setup_caps(struct input_dev *inputdev)
570{
571 struct gtco *device = input_get_drvdata(inputdev);
572
573 /* Which events */
574 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
575 BIT_MASK(EV_MSC);
576
577 /* Misc event menu block */
578 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
579 BIT_MASK(MSC_RAW);
580
581 /* Absolute values based on HID report info */
582 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
583 0, 0);
584 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
585 0, 0);
586
587 /* Proximity */
588 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
589
590 /* Tilt & pressure */
591 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
592 device->maxtilt_X, 0, 0);
593 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
594 device->maxtilt_Y, 0, 0);
595 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
596 device->maxpressure, 0, 0);
597
598 /* Transducer */
599 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
600}
601
602/* USB Routines */
603
604/*
605 * URB callback routine. Called when we get IRQ reports from the
606 * digitizer.
607 *
608 * This bridges the USB and input device worlds. It generates events
609 * on the input device based on the USB reports.
610 */
611static void gtco_urb_callback(struct urb *urbinfo)
612{
613 struct gtco *device = urbinfo->context;
614 struct input_dev *inputdev;
615 int rc;
616 u32 val = 0;
617 s8 valsigned = 0;
618 char le_buffer[2];
619
620 inputdev = device->inputdevice;
621
622 /* Was callback OK? */
623 if (urbinfo->status == -ECONNRESET ||
624 urbinfo->status == -ENOENT ||
625 urbinfo->status == -ESHUTDOWN) {
626
627 /* Shutdown is occurring. Return and don't queue up any more */
628 return;
629 }
630
631 if (urbinfo->status != 0) {
632 /*
633 * Some unknown error. Hopefully temporary. Just go and
634 * requeue an URB
635 */
636 goto resubmit;
637 }
638
639 /*
640 * Good URB, now process
641 */
642
643 /* PID dependent when we interpret the report */
644 if (inputdev->id.product == PID_1000 ||
645 inputdev->id.product == PID_1001 ||
646 inputdev->id.product == PID_1002) {
647
648 /*
649 * Switch on the report ID
650 * Conveniently, the reports have more information, the higher
651 * the report number. We can just fall through the case
652 * statements if we start with the highest number report
653 */
654 switch (device->buffer[0]) {
655 case 5:
656 /* Pressure is 9 bits */
657 val = ((u16)(device->buffer[8]) << 1);
658 val |= (u16)(device->buffer[7] >> 7);
659 input_report_abs(inputdev, ABS_PRESSURE,
660 device->buffer[8]);
661
662 /* Mask out the Y tilt value used for pressure */
663 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
664
665 /* Fall thru */
666 case 4:
667 /* Tilt */
668
669 /* Sign extend these 7 bit numbers. */
670 if (device->buffer[6] & 0x40)
671 device->buffer[6] |= 0x80;
672
673 if (device->buffer[7] & 0x40)
674 device->buffer[7] |= 0x80;
675
676
677 valsigned = (device->buffer[6]);
678 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
679
680 valsigned = (device->buffer[7]);
681 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
682
683 /* Fall thru */
684 case 2:
685 case 3:
686 /* Convert buttons, only 5 bits possible */
687 val = (device->buffer[5]) & MASK_BUTTON;
688
689 /* We don't apply any meaning to the bitmask,
690 just report */
691 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
692
693 /* Fall thru */
694 case 1:
695 /* All reports have X and Y coords in the same place */
696 val = get_unaligned_le16(&device->buffer[1]);
697 input_report_abs(inputdev, ABS_X, val);
698
699 val = get_unaligned_le16(&device->buffer[3]);
700 input_report_abs(inputdev, ABS_Y, val);
701
702 /* Ditto for proximity bit */
703 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
704 input_report_abs(inputdev, ABS_DISTANCE, val);
705
706 /* Report 1 is an exception to how we handle buttons */
707 /* Buttons are an index, not a bitmask */
708 if (device->buffer[0] == 1) {
709
710 /*
711 * Convert buttons, 5 bit index
712 * Report value of index set as one,
713 * the rest as 0
714 */
715 val = device->buffer[5] & MASK_BUTTON;
716 dev_dbg(&device->intf->dev,
717 "======>>>>>>REPORT 1: val 0x%X(%d)\n",
718 val, val);
719
720 /*
721 * We don't apply any meaning to the button
722 * index, just report it
723 */
724 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
725 }
726 break;
727
728 case 7:
729 /* Menu blocks */
730 input_event(inputdev, EV_MSC, MSC_SCAN,
731 device->buffer[1]);
732 break;
733 }
734 }
735
736 /* Other pid class */
737 if (inputdev->id.product == PID_400 ||
738 inputdev->id.product == PID_401) {
739
740 /* Report 2 */
741 if (device->buffer[0] == 2) {
742 /* Menu blocks */
743 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
744 }
745
746 /* Report 1 */
747 if (device->buffer[0] == 1) {
748 char buttonbyte;
749
750 /* IF X max > 64K, we still a bit from the y report */
751 if (device->max_X > 0x10000) {
752
753 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
754 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
755
756 input_report_abs(inputdev, ABS_X, val);
757
758 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
759 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
760
761 le_buffer[1] = (u8)(device->buffer[4] >> 1);
762 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
763
764 val = get_unaligned_le16(le_buffer);
765 input_report_abs(inputdev, ABS_Y, val);
766
767 /*
768 * Shift the button byte right by one to
769 * make it look like the standard report
770 */
771 buttonbyte = device->buffer[5] >> 1;
772 } else {
773
774 val = get_unaligned_le16(&device->buffer[1]);
775 input_report_abs(inputdev, ABS_X, val);
776
777 val = get_unaligned_le16(&device->buffer[3]);
778 input_report_abs(inputdev, ABS_Y, val);
779
780 buttonbyte = device->buffer[5];
781 }
782
783 /* BUTTONS and PROXIMITY */
784 val = buttonbyte & MASK_INRANGE ? 1 : 0;
785 input_report_abs(inputdev, ABS_DISTANCE, val);
786
787 /* Convert buttons, only 4 bits possible */
788 val = buttonbyte & 0x0F;
789#ifdef USE_BUTTONS
790 for (i = 0; i < 5; i++)
791 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
792#else
793 /* We don't apply any meaning to the bitmask, just report */
794 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
795#endif
796
797 /* TRANSDUCER */
798 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
799 }
800 }
801
802 /* Everybody gets report ID's */
803 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
804
805 /* Sync it up */
806 input_sync(inputdev);
807
808 resubmit:
809 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
810 if (rc != 0)
811 dev_err(&device->intf->dev,
812 "usb_submit_urb failed rc=0x%x\n", rc);
813}
814
815/*
816 * The probe routine. This is called when the kernel find the matching USB
817 * vendor/product. We do the following:
818 *
819 * - Allocate mem for a local structure to manage the device
820 * - Request a HID Report Descriptor from the device and parse it to
821 * find out the device parameters
822 * - Create an input device and assign it attributes
823 * - Allocate an URB so the device can talk to us when the input
824 * queue is open
825 */
826static int gtco_probe(struct usb_interface *usbinterface,
827 const struct usb_device_id *id)
828{
829
830 struct gtco *gtco;
831 struct input_dev *input_dev;
832 struct hid_descriptor *hid_desc;
833 char *report;
834 int result = 0, retry;
835 int error;
836 struct usb_endpoint_descriptor *endpoint;
837
838 /* Allocate memory for device structure */
839 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
840 input_dev = input_allocate_device();
841 if (!gtco || !input_dev) {
842 dev_err(&usbinterface->dev, "No more memory\n");
843 error = -ENOMEM;
844 goto err_free_devs;
845 }
846
847 /* Set pointer to the input device */
848 gtco->inputdevice = input_dev;
849
850 /* Save interface information */
851 gtco->usbdev = interface_to_usbdev(usbinterface);
852 gtco->intf = usbinterface;
853
854 /* Allocate some data for incoming reports */
855 gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
856 GFP_KERNEL, >co->buf_dma);
857 if (!gtco->buffer) {
858 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
859 error = -ENOMEM;
860 goto err_free_devs;
861 }
862
863 /* Allocate URB for reports */
864 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
865 if (!gtco->urbinfo) {
866 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
867 error = -ENOMEM;
868 goto err_free_buf;
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(gtco->usbdev,
913 usb_rcvctrlpipe(gtco->usbdev, 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(gtco->usbdev, 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(gtco->usbdev, &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 gtco->usbdev,
966 usb_rcvintpipe(gtco->usbdev,
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(gtco->usbdev, 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 */
1003static void gtco_disconnect(struct usb_interface *interface)
1004{
1005 /* Grab private device ptr */
1006 struct gtco *gtco = usb_get_intfdata(interface);
1007
1008 /* Now reverse all the registration stuff */
1009 if (gtco) {
1010 input_unregister_device(gtco->inputdevice);
1011 usb_kill_urb(gtco->urbinfo);
1012 usb_free_urb(gtco->urbinfo);
1013 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
1014 gtco->buffer, gtco->buf_dma);
1015 kfree(gtco);
1016 }
1017
1018 dev_info(&interface->dev, "gtco driver disconnected\n");
1019}
1020
1021/* STANDARD MODULE LOAD ROUTINES */
1022
1023static struct usb_driver gtco_driverinfo_table = {
1024 .name = "gtco",
1025 .id_table = gtco_usbid_table,
1026 .probe = gtco_probe,
1027 .disconnect = gtco_disconnect,
1028};
1029
1030module_usb_driver(gtco_driverinfo_table);
1031
1032MODULE_DESCRIPTION("GTCO digitizer USB driver");
1033MODULE_LICENSE("GPL");