ia64/kvm: compilation fix. export account_system_vtime.
[pv_ops_mirror.git] / drivers / input / tablet / gtco.c
blobc5a8661a1baae242720bdd2c9f0eee248019c1d3
1 /* -*- linux-c -*-
3 GTCO digitizer USB driver
5 Use the err(), dbg() and info() macros from usb.h for system logging
7 TO CHECK: Is pressure done right on report 5?
9 Copyright (C) 2006 GTCO CalComp
11 This program is free software; you can redistribute it and/or
12 modify it under the terms of the GNU General Public License
13 as published by the Free Software Foundation; version 2
14 of the License.
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
21 You should have received a copy of the GNU General Public License
22 along with this program; if not, write to the Free Software
23 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
25 Permission to use, copy, modify, distribute, and sell this software and its
26 documentation for any purpose is hereby granted without fee, provided that
27 the above copyright notice appear in all copies and that both that
28 copyright notice and this permission notice appear in supporting
29 documentation, and that the name of GTCO-CalComp not be used in advertising
30 or publicity pertaining to distribution of the software without specific,
31 written prior permission. GTCO-CalComp makes no representations about the
32 suitability of this software for any purpose. It is provided "as is"
33 without express or implied warranty.
35 GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
36 INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
37 EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
38 CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
39 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
40 TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
41 PERFORMANCE OF THIS SOFTWARE.
43 GTCO CalComp, Inc.
44 7125 Riverwood Drive
45 Columbia, MD 21046
47 Jeremy Roberson jroberson@gtcocalcomp.com
48 Scott Hill shill@gtcocalcomp.com
53 /*#define DEBUG*/
55 #include <linux/kernel.h>
56 #include <linux/module.h>
57 #include <linux/errno.h>
58 #include <linux/init.h>
59 #include <linux/slab.h>
60 #include <linux/input.h>
61 #include <linux/usb.h>
62 #include <asm/uaccess.h>
63 #include <asm/unaligned.h>
64 #include <asm/byteorder.h>
67 #include <linux/version.h>
68 #include <linux/usb/input.h>
70 /* Version with a Major number of 2 is for kernel inclusion only. */
71 #define GTCO_VERSION "2.00.0006"
74 /* MACROS */
76 #define VENDOR_ID_GTCO 0x078C
77 #define PID_400 0x400
78 #define PID_401 0x401
79 #define PID_1000 0x1000
80 #define PID_1001 0x1001
81 #define PID_1002 0x1002
83 /* Max size of a single report */
84 #define REPORT_MAX_SIZE 10
87 /* Bitmask whether pen is in range */
88 #define MASK_INRANGE 0x20
89 #define MASK_BUTTON 0x01F
91 #define PATHLENGTH 64
93 /* DATA STRUCTURES */
95 /* Device table */
96 static struct usb_device_id gtco_usbid_table [] = {
97 { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
98 { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
99 { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
100 { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
101 { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
104 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
107 /* Structure to hold all of our device specific stuff */
108 struct gtco {
110 struct input_dev *inputdevice; /* input device struct pointer */
111 struct usb_device *usbdev; /* the usb device for this device */
112 struct urb *urbinfo; /* urb for incoming reports */
113 dma_addr_t buf_dma; /* dma addr of the data buffer*/
114 unsigned char * buffer; /* databuffer for reports */
116 char usbpath[PATHLENGTH];
117 int openCount;
119 /* Information pulled from Report Descriptor */
120 u32 usage;
121 u32 min_X;
122 u32 max_X;
123 u32 min_Y;
124 u32 max_Y;
125 s8 mintilt_X;
126 s8 maxtilt_X;
127 s8 mintilt_Y;
128 s8 maxtilt_Y;
129 u32 maxpressure;
130 u32 minpressure;
135 /* Code for parsing the HID REPORT DESCRIPTOR */
137 /* From HID1.11 spec */
138 struct hid_descriptor
140 struct usb_descriptor_header header;
141 __le16 bcdHID;
142 u8 bCountryCode;
143 u8 bNumDescriptors;
144 u8 bDescriptorType;
145 __le16 wDescriptorLength;
146 } __attribute__ ((packed));
149 #define HID_DESCRIPTOR_SIZE 9
150 #define HID_DEVICE_TYPE 33
151 #define REPORT_DEVICE_TYPE 34
154 #define PREF_TAG(x) ((x)>>4)
155 #define PREF_TYPE(x) ((x>>2)&0x03)
156 #define PREF_SIZE(x) ((x)&0x03)
158 #define TYPE_MAIN 0
159 #define TYPE_GLOBAL 1
160 #define TYPE_LOCAL 2
161 #define TYPE_RESERVED 3
163 #define TAG_MAIN_INPUT 0x8
164 #define TAG_MAIN_OUTPUT 0x9
165 #define TAG_MAIN_FEATURE 0xB
166 #define TAG_MAIN_COL_START 0xA
167 #define TAG_MAIN_COL_END 0xC
169 #define TAG_GLOB_USAGE 0
170 #define TAG_GLOB_LOG_MIN 1
171 #define TAG_GLOB_LOG_MAX 2
172 #define TAG_GLOB_PHYS_MIN 3
173 #define TAG_GLOB_PHYS_MAX 4
174 #define TAG_GLOB_UNIT_EXP 5
175 #define TAG_GLOB_UNIT 6
176 #define TAG_GLOB_REPORT_SZ 7
177 #define TAG_GLOB_REPORT_ID 8
178 #define TAG_GLOB_REPORT_CNT 9
179 #define TAG_GLOB_PUSH 10
180 #define TAG_GLOB_POP 11
182 #define TAG_GLOB_MAX 12
184 #define DIGITIZER_USAGE_TIP_PRESSURE 0x30
185 #define DIGITIZER_USAGE_TILT_X 0x3D
186 #define DIGITIZER_USAGE_TILT_Y 0x3E
190 * This is an abbreviated parser for the HID Report Descriptor. We
191 * know what devices we are talking to, so this is by no means meant
192 * to be generic. We can make some safe assumptions:
194 * - We know there are no LONG tags, all short
195 * - We know that we have no MAIN Feature and MAIN Output items
196 * - We know what the IRQ reports are supposed to look like.
198 * The main purpose of this is to use the HID report desc to figure
199 * out the mins and maxs of the fields in the IRQ reports. The IRQ
200 * reports for 400/401 change slightly if the max X is bigger than 64K.
203 static void parse_hid_report_descriptor(struct gtco *device, char * report,
204 int length)
206 int x, i = 0;
208 /* Tag primitive vars */
209 __u8 prefix;
210 __u8 size;
211 __u8 tag;
212 __u8 type;
213 __u8 data = 0;
214 __u16 data16 = 0;
215 __u32 data32 = 0;
217 /* For parsing logic */
218 int inputnum = 0;
219 __u32 usage = 0;
221 /* Global Values, indexed by TAG */
222 __u32 globalval[TAG_GLOB_MAX];
223 __u32 oldval[TAG_GLOB_MAX];
225 /* Debug stuff */
226 char maintype = 'x';
227 char globtype[12];
228 int indent = 0;
229 char indentstr[10] = "";
232 dbg("======>>>>>>PARSE<<<<<<======");
234 /* Walk this report and pull out the info we need */
235 while (i < length) {
236 prefix = report[i];
238 /* Skip over prefix */
239 i++;
241 /* Determine data size and save the data in the proper variable */
242 size = PREF_SIZE(prefix);
243 switch (size) {
244 case 1:
245 data = report[i];
246 break;
247 case 2:
248 data16 = get_unaligned_le16(&report[i]);
249 break;
250 case 3:
251 size = 4;
252 data32 = get_unaligned_le32(&report[i]);
253 break;
256 /* Skip size of data */
257 i += size;
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) {
267 case TAG_MAIN_INPUT:
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
275 maintype = 'I';
276 if (data == 2)
277 strcpy(globtype, "Variable");
278 else if (data == 3)
279 strcpy(globtype, "Var|Const");
281 dbg("::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits",
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]);
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
294 switch (inputnum) {
295 case 0: /* X coord */
296 dbg("GER: X Usage: 0x%x", 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];
301 break;
303 case 1: /* Y coord */
304 dbg("GER: Y Usage: 0x%x", 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];
309 break;
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];
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];
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];
336 break;
339 inputnum++;
340 break;
342 case TAG_MAIN_OUTPUT:
343 maintype = 'O';
344 break;
346 case TAG_MAIN_FEATURE:
347 maintype = 'F';
348 break;
350 case TAG_MAIN_COL_START:
351 maintype = 'S';
353 if (data == 0) {
354 dbg("======>>>>>> Physical");
355 strcpy(globtype, "Physical");
356 } else
357 dbg("======>>>>>>");
359 /* Indent the debug output */
360 indent++;
361 for (x = 0; x < indent; x++)
362 indentstr[x] = '-';
363 indentstr[x] = 0;
365 /* Save global tags */
366 for (x = 0; x < TAG_GLOB_MAX; x++)
367 oldval[x] = globalval[x];
369 break;
371 case TAG_MAIN_COL_END:
372 dbg("<<<<<<======");
373 maintype = 'E';
374 indent--;
375 for (x = 0; x < indent; x++)
376 indentstr[x] = '-';
377 indentstr[x] = 0;
379 /* Copy global tags back */
380 for (x = 0; x < TAG_GLOB_MAX; x++)
381 globalval[x] = oldval[x];
383 break;
386 switch (size) {
387 case 1:
388 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
389 indentstr, tag, maintype, size, globtype, data);
390 break;
392 case 2:
393 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
394 indentstr, tag, maintype, size, globtype, data16);
395 break;
397 case 4:
398 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
399 indentstr, tag, maintype, size, globtype, data32);
400 break;
402 break;
404 case TYPE_GLOBAL:
405 switch (tag) {
406 case TAG_GLOB_USAGE:
408 * First time we hit the global usage tag,
409 * it should tell us the type of device
411 if (device->usage == 0)
412 device->usage = data;
414 strcpy(globtype, "USAGE");
415 break;
417 case TAG_GLOB_LOG_MIN:
418 strcpy(globtype, "LOG_MIN");
419 break;
421 case TAG_GLOB_LOG_MAX:
422 strcpy(globtype, "LOG_MAX");
423 break;
425 case TAG_GLOB_PHYS_MIN:
426 strcpy(globtype, "PHYS_MIN");
427 break;
429 case TAG_GLOB_PHYS_MAX:
430 strcpy(globtype, "PHYS_MAX");
431 break;
433 case TAG_GLOB_UNIT_EXP:
434 strcpy(globtype, "EXP");
435 break;
437 case TAG_GLOB_UNIT:
438 strcpy(globtype, "UNIT");
439 break;
441 case TAG_GLOB_REPORT_SZ:
442 strcpy(globtype, "REPORT_SZ");
443 break;
445 case TAG_GLOB_REPORT_ID:
446 strcpy(globtype, "REPORT_ID");
447 /* New report, restart numbering */
448 inputnum = 0;
449 break;
451 case TAG_GLOB_REPORT_CNT:
452 strcpy(globtype, "REPORT_CNT");
453 break;
455 case TAG_GLOB_PUSH:
456 strcpy(globtype, "PUSH");
457 break;
459 case TAG_GLOB_POP:
460 strcpy(globtype, "POP");
461 break;
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 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
470 indentstr, globtype, tag, size, data);
471 globalval[tag] = data;
472 break;
474 case 2:
475 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
476 indentstr, globtype, tag, size, data16);
477 globalval[tag] = data16;
478 break;
480 case 4:
481 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
482 indentstr, globtype, tag, size, data32);
483 globalval[tag] = data32;
484 break;
486 } else {
487 dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
488 indentstr, tag, size);
490 break;
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;
500 case TAG_GLOB_LOG_MIN:
501 strcpy(globtype, "MIN");
502 break;
504 case TAG_GLOB_LOG_MAX:
505 strcpy(globtype, "MAX");
506 break;
508 default:
509 strcpy(globtype, "UNKNOWN");
510 break;
513 switch (size) {
514 case 1:
515 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
516 indentstr, tag, globtype, size, data);
517 break;
519 case 2:
520 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
521 indentstr, tag, globtype, size, data16);
522 break;
524 case 4:
525 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
526 indentstr, tag, globtype, size, data32);
527 break;
530 break;
535 /* INPUT DRIVER Routines */
538 * Called when opening the input device. This will submit the URB to
539 * the usb system so we start getting reports
541 static int gtco_input_open(struct input_dev *inputdev)
543 struct gtco *device = input_get_drvdata(inputdev);
545 device->urbinfo->dev = device->usbdev;
546 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
547 return -EIO;
549 return 0;
553 * Called when closing the input device. This will unlink the URB
555 static void gtco_input_close(struct input_dev *inputdev)
557 struct gtco *device = input_get_drvdata(inputdev);
559 usb_kill_urb(device->urbinfo);
564 * Setup input device capabilities. Tell the input system what this
565 * device is capable of generating.
567 * This information is based on what is read from the HID report and
568 * placed in the struct gtco structure
571 static void gtco_setup_caps(struct input_dev *inputdev)
573 struct gtco *device = input_get_drvdata(inputdev);
575 /* Which events */
576 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
577 BIT_MASK(EV_MSC);
579 /* Misc event menu block */
580 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
581 BIT_MASK(MSC_RAW);
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);
589 /* Proximity */
590 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
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);
600 /* Transducer */
601 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
604 /* USB Routines */
607 * URB callback routine. Called when we get IRQ reports from the
608 * digitizer.
610 * This bridges the USB and input device worlds. It generates events
611 * on the input device based on the USB reports.
613 static void gtco_urb_callback(struct urb *urbinfo)
615 struct gtco *device = urbinfo->context;
616 struct input_dev *inputdev;
617 int rc;
618 u32 val = 0;
619 s8 valsigned = 0;
620 char le_buffer[2];
622 inputdev = device->inputdevice;
624 /* Was callback OK? */
625 if (urbinfo->status == -ECONNRESET ||
626 urbinfo->status == -ENOENT ||
627 urbinfo->status == -ESHUTDOWN) {
629 /* Shutdown is occurring. Return and don't queue up any more */
630 return;
633 if (urbinfo->status != 0) {
635 * Some unknown error. Hopefully temporary. Just go and
636 * requeue an URB
638 goto resubmit;
642 * Good URB, now process
645 /* PID dependent when we interpret the report */
646 if (inputdev->id.product == PID_1000 ||
647 inputdev->id.product == PID_1001 ||
648 inputdev->id.product == PID_1002) {
651 * Switch on the report ID
652 * Conveniently, the reports have more information, the higher
653 * the report number. We can just fall through the case
654 * statements if we start with the highest number report
656 switch (device->buffer[0]) {
657 case 5:
658 /* Pressure is 9 bits */
659 val = ((u16)(device->buffer[8]) << 1);
660 val |= (u16)(device->buffer[7] >> 7);
661 input_report_abs(inputdev, ABS_PRESSURE,
662 device->buffer[8]);
664 /* Mask out the Y tilt value used for pressure */
665 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
667 /* Fall thru */
668 case 4:
669 /* Tilt */
671 /* Sign extend these 7 bit numbers. */
672 if (device->buffer[6] & 0x40)
673 device->buffer[6] |= 0x80;
675 if (device->buffer[7] & 0x40)
676 device->buffer[7] |= 0x80;
679 valsigned = (device->buffer[6]);
680 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
682 valsigned = (device->buffer[7]);
683 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
685 /* Fall thru */
686 case 2:
687 case 3:
688 /* Convert buttons, only 5 bits possible */
689 val = (device->buffer[5]) & MASK_BUTTON;
691 /* We don't apply any meaning to the bitmask,
692 just report */
693 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
695 /* Fall thru */
696 case 1:
697 /* All reports have X and Y coords in the same place */
698 val = get_unaligned_le16(&device->buffer[1]);
699 input_report_abs(inputdev, ABS_X, val);
701 val = get_unaligned_le16(&device->buffer[3]);
702 input_report_abs(inputdev, ABS_Y, val);
704 /* Ditto for proximity bit */
705 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
706 input_report_abs(inputdev, ABS_DISTANCE, val);
708 /* Report 1 is an exception to how we handle buttons */
709 /* Buttons are an index, not a bitmask */
710 if (device->buffer[0] == 1) {
713 * Convert buttons, 5 bit index
714 * Report value of index set as one,
715 * the rest as 0
717 val = device->buffer[5] & MASK_BUTTON;
718 dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
719 val, val);
722 * We don't apply any meaning to the button
723 * index, just report it
725 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
727 break;
729 case 7:
730 /* Menu blocks */
731 input_event(inputdev, EV_MSC, MSC_SCAN,
732 device->buffer[1]);
733 break;
737 /* Other pid class */
738 if (inputdev->id.product == PID_400 ||
739 inputdev->id.product == PID_401) {
741 /* Report 2 */
742 if (device->buffer[0] == 2) {
743 /* Menu blocks */
744 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
747 /* Report 1 */
748 if (device->buffer[0] == 1) {
749 char buttonbyte;
751 /* IF X max > 64K, we still a bit from the y report */
752 if (device->max_X > 0x10000) {
754 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
755 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
757 input_report_abs(inputdev, ABS_X, val);
759 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
760 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
762 le_buffer[1] = (u8)(device->buffer[4] >> 1);
763 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
765 val = get_unaligned_le16(le_buffer);
766 input_report_abs(inputdev, ABS_Y, val);
769 * Shift the button byte right by one to
770 * make it look like the standard report
772 buttonbyte = device->buffer[5] >> 1;
773 } else {
775 val = get_unaligned_le16(&device->buffer[1]);
776 input_report_abs(inputdev, ABS_X, val);
778 val = get_unaligned_le16(&device->buffer[3]);
779 input_report_abs(inputdev, ABS_Y, val);
781 buttonbyte = device->buffer[5];
784 /* BUTTONS and PROXIMITY */
785 val = buttonbyte & MASK_INRANGE ? 1 : 0;
786 input_report_abs(inputdev, ABS_DISTANCE, val);
788 /* Convert buttons, only 4 bits possible */
789 val = buttonbyte & 0x0F;
790 #ifdef USE_BUTTONS
791 for (i = 0; i < 5; i++)
792 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
793 #else
794 /* We don't apply any meaning to the bitmask, just report */
795 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
796 #endif
798 /* TRANSDUCER */
799 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
803 /* Everybody gets report ID's */
804 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
806 /* Sync it up */
807 input_sync(inputdev);
809 resubmit:
810 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
811 if (rc != 0)
812 err("usb_submit_urb failed rc=0x%x", rc);
816 * The probe routine. This is called when the kernel find the matching USB
817 * vendor/product. We do the following:
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
826 static int gtco_probe(struct usb_interface *usbinterface,
827 const struct usb_device_id *id)
830 struct gtco *gtco;
831 struct input_dev *input_dev;
832 struct hid_descriptor *hid_desc;
833 char *report = NULL;
834 int result = 0, retry;
835 int error;
836 struct usb_endpoint_descriptor *endpoint;
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 err("No more memory");
843 error = -ENOMEM;
844 goto err_free_devs;
847 /* Set pointer to the input device */
848 gtco->inputdevice = input_dev;
850 /* Save interface information */
851 gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
853 /* Allocate some data for incoming reports */
854 gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
855 GFP_KERNEL, &gtco->buf_dma);
856 if (!gtco->buffer) {
857 err("No more memory for us buffers");
858 error = -ENOMEM;
859 goto err_free_devs;
862 /* Allocate URB for reports */
863 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
864 if (!gtco->urbinfo) {
865 err("Failed to allocate URB");
866 return -ENOMEM;
867 goto err_free_buf;
871 * The endpoint is always altsetting 0, we know this since we know
872 * this device only has one interrupt endpoint
874 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
876 /* Some debug */
877 dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
878 dbg("num endpoints: %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
879 dbg("interface class: %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
880 dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
881 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
882 dbg("endpoint: we have interrupt endpoint\n");
884 dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
887 * Find the HID descriptor so we can find out the size of the
888 * HID report descriptor
890 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
891 HID_DEVICE_TYPE, &hid_desc) != 0){
892 err("Can't retrieve exta USB descriptor to get hid report descriptor length");
893 error = -EIO;
894 goto err_free_urb;
897 dbg("Extra descriptor success: type:%d len:%d",
898 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
900 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
901 if (!report) {
902 err("No more memory for report");
903 error = -ENOMEM;
904 goto err_free_urb;
907 /* Couple of tries to get reply */
908 for (retry = 0; retry < 3; retry++) {
909 result = usb_control_msg(gtco->usbdev,
910 usb_rcvctrlpipe(gtco->usbdev, 0),
911 USB_REQ_GET_DESCRIPTOR,
912 USB_RECIP_INTERFACE | USB_DIR_IN,
913 REPORT_DEVICE_TYPE << 8,
914 0, /* interface */
915 report,
916 le16_to_cpu(hid_desc->wDescriptorLength),
917 5000); /* 5 secs */
919 if (result == le16_to_cpu(hid_desc->wDescriptorLength))
920 break;
923 /* If we didn't get the report, fail */
924 dbg("usb_control_msg result: :%d", result);
925 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
926 err("Failed to get HID Report Descriptor of size: %d",
927 hid_desc->wDescriptorLength);
928 error = -EIO;
929 goto err_free_urb;
932 /* Now we parse the report */
933 parse_hid_report_descriptor(gtco, report, result);
935 /* Now we delete it */
936 kfree(report);
938 /* Create a device file node */
939 usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
940 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
942 /* Set Input device functions */
943 input_dev->open = gtco_input_open;
944 input_dev->close = gtco_input_close;
946 /* Set input device information */
947 input_dev->name = "GTCO_CalComp";
948 input_dev->phys = gtco->usbpath;
950 input_set_drvdata(input_dev, gtco);
952 /* Now set up all the input device capabilities */
953 gtco_setup_caps(input_dev);
955 /* Set input device required ID information */
956 usb_to_input_id(gtco->usbdev, &input_dev->id);
957 input_dev->dev.parent = &usbinterface->dev;
959 /* Setup the URB, it will be posted later on open of input device */
960 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
962 usb_fill_int_urb(gtco->urbinfo,
963 gtco->usbdev,
964 usb_rcvintpipe(gtco->usbdev,
965 endpoint->bEndpointAddress),
966 gtco->buffer,
967 REPORT_MAX_SIZE,
968 gtco_urb_callback,
969 gtco,
970 endpoint->bInterval);
972 gtco->urbinfo->transfer_dma = gtco->buf_dma;
973 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
975 /* Save gtco pointer in USB interface gtco */
976 usb_set_intfdata(usbinterface, gtco);
978 /* All done, now register the input device */
979 error = input_register_device(input_dev);
980 if (error)
981 goto err_free_urb;
983 return 0;
985 err_free_urb:
986 usb_free_urb(gtco->urbinfo);
987 err_free_buf:
988 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
989 gtco->buffer, gtco->buf_dma);
990 err_free_devs:
991 kfree(report);
992 input_free_device(input_dev);
993 kfree(gtco);
994 return error;
998 * This function is a standard USB function called when the USB device
999 * is disconnected. We will get rid of the URV, de-register the input
1000 * device, and free up allocated memory
1002 static void gtco_disconnect(struct usb_interface *interface)
1004 /* Grab private device ptr */
1005 struct gtco *gtco = usb_get_intfdata(interface);
1007 /* Now reverse all the registration stuff */
1008 if (gtco) {
1009 input_unregister_device(gtco->inputdevice);
1010 usb_kill_urb(gtco->urbinfo);
1011 usb_free_urb(gtco->urbinfo);
1012 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
1013 gtco->buffer, gtco->buf_dma);
1014 kfree(gtco);
1017 info("gtco driver disconnected");
1020 /* STANDARD MODULE LOAD ROUTINES */
1022 static struct usb_driver gtco_driverinfo_table = {
1023 .name = "gtco",
1024 .id_table = gtco_usbid_table,
1025 .probe = gtco_probe,
1026 .disconnect = gtco_disconnect,
1030 * Register this module with the USB subsystem
1032 static int __init gtco_init(void)
1034 int error;
1036 error = usb_register(&gtco_driverinfo_table);
1037 if (error) {
1038 err("usb_register() failed rc=0x%x", error);
1039 return error;
1042 printk("GTCO usb driver version: %s", GTCO_VERSION);
1043 return 0;
1047 * Deregister this module with the USB subsystem
1049 static void __exit gtco_exit(void)
1051 usb_deregister(&gtco_driverinfo_table);
1054 module_init(gtco_init);
1055 module_exit(gtco_exit);
1057 MODULE_LICENSE("GPL");