3 GTCO digitizer USB driver
5 TO CHECK: Is pressure done right on report 5?
7 Copyright (C) 2006 GTCO CalComp
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
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.
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.
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.
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.
45 Jeremy Roberson jroberson@gtcocalcomp.com
46 Scott Hill shill@gtcocalcomp.com
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>
64 #include <linux/usb/input.h>
66 /* Version with a Major number of 2 is for kernel inclusion only. */
67 #define GTCO_VERSION "2.00.0006"
72 #define VENDOR_ID_GTCO 0x078C
75 #define PID_1000 0x1000
76 #define PID_1001 0x1001
77 #define PID_1002 0x1002
79 /* Max size of a single report */
80 #define REPORT_MAX_SIZE 10
83 /* Bitmask whether pen is in range */
84 #define MASK_INRANGE 0x20
85 #define MASK_BUTTON 0x01F
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) },
100 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
103 /* Structure to hold all of our device specific stuff */
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 */
113 char usbpath[PATHLENGTH];
116 /* Information pulled from Report Descriptor */
132 /* Code for parsing the HID REPORT DESCRIPTOR */
134 /* From HID1.11 spec */
135 struct hid_descriptor
137 struct usb_descriptor_header header;
142 __le16 wDescriptorLength;
143 } __attribute__ ((packed));
146 #define HID_DESCRIPTOR_SIZE 9
147 #define HID_DEVICE_TYPE 33
148 #define REPORT_DEVICE_TYPE 34
151 #define PREF_TAG(x) ((x)>>4)
152 #define PREF_TYPE(x) ((x>>2)&0x03)
153 #define PREF_SIZE(x) ((x)&0x03)
156 #define TYPE_GLOBAL 1
158 #define TYPE_RESERVED 3
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
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
179 #define TAG_GLOB_MAX 12
181 #define DIGITIZER_USAGE_TIP_PRESSURE 0x30
182 #define DIGITIZER_USAGE_TILT_X 0x3D
183 #define DIGITIZER_USAGE_TILT_Y 0x3E
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:
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.
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.
200 static void parse_hid_report_descriptor(struct gtco *device, char * report,
203 struct device *ddev = &device->intf->dev;
206 /* Tag primitive vars */
215 /* For parsing logic */
219 /* Global Values, indexed by TAG */
220 __u32 globalval[TAG_GLOB_MAX];
221 __u32 oldval[TAG_GLOB_MAX];
227 char indentstr[10] = "";
230 dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
232 /* Walk this report and pull out the info we need */
236 /* Skip over prefix */
239 /* Determine data size and save the data in the proper variable */
240 size = PREF_SIZE(prefix);
246 data16 = get_unaligned_le16(&report[i]);
250 data32 = get_unaligned_le32(&report[i]);
254 /* Skip size of data */
257 /* What we do depends on the tag type */
258 tag = PREF_TAG(prefix);
259 type = PREF_TYPE(prefix);
262 strcpy(globtype, "");
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
275 strcpy(globtype, "Variable");
277 strcpy(globtype, "Var|Const");
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]);
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
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];
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];
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];
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];
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];
340 case TAG_MAIN_OUTPUT:
344 case TAG_MAIN_FEATURE:
348 case TAG_MAIN_COL_START:
352 dev_dbg(ddev, "======>>>>>> Physical\n");
353 strcpy(globtype, "Physical");
355 dev_dbg(ddev, "======>>>>>>\n");
357 /* Indent the debug output */
359 for (x = 0; x < indent; x++)
363 /* Save global tags */
364 for (x = 0; x < TAG_GLOB_MAX; x++)
365 oldval[x] = globalval[x];
369 case TAG_MAIN_COL_END:
370 dev_dbg(ddev, "<<<<<<======\n");
373 for (x = 0; x < indent; x++)
377 /* Copy global tags back */
378 for (x = 0; x < TAG_GLOB_MAX; x++)
379 globalval[x] = oldval[x];
386 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
387 indentstr, tag, maintype, size, globtype, data);
391 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
392 indentstr, tag, maintype, size, globtype, data16);
396 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
397 indentstr, tag, maintype, size, globtype, data32);
406 * First time we hit the global usage tag,
407 * it should tell us the type of device
409 if (device->usage == 0)
410 device->usage = data;
412 strcpy(globtype, "USAGE");
415 case TAG_GLOB_LOG_MIN:
416 strcpy(globtype, "LOG_MIN");
419 case TAG_GLOB_LOG_MAX:
420 strcpy(globtype, "LOG_MAX");
423 case TAG_GLOB_PHYS_MIN:
424 strcpy(globtype, "PHYS_MIN");
427 case TAG_GLOB_PHYS_MAX:
428 strcpy(globtype, "PHYS_MAX");
431 case TAG_GLOB_UNIT_EXP:
432 strcpy(globtype, "EXP");
436 strcpy(globtype, "UNIT");
439 case TAG_GLOB_REPORT_SZ:
440 strcpy(globtype, "REPORT_SZ");
443 case TAG_GLOB_REPORT_ID:
444 strcpy(globtype, "REPORT_ID");
445 /* New report, restart numbering */
449 case TAG_GLOB_REPORT_CNT:
450 strcpy(globtype, "REPORT_CNT");
454 strcpy(globtype, "PUSH");
458 strcpy(globtype, "POP");
462 /* Check to make sure we have a good tag number
463 so we don't overflow array */
464 if (tag < TAG_GLOB_MAX) {
467 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
468 indentstr, globtype, tag, size, data);
469 globalval[tag] = data;
473 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
474 indentstr, globtype, tag, size, data16);
475 globalval[tag] = data16;
479 dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
480 indentstr, globtype, tag, size, data32);
481 globalval[tag] = data32;
485 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
486 indentstr, tag, size);
493 strcpy(globtype, "USAGE");
498 case TAG_GLOB_LOG_MIN:
499 strcpy(globtype, "MIN");
502 case TAG_GLOB_LOG_MAX:
503 strcpy(globtype, "MAX");
507 strcpy(globtype, "UNKNOWN");
513 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
514 indentstr, tag, globtype, size, data);
518 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
519 indentstr, tag, globtype, size, data16);
523 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
524 indentstr, tag, globtype, size, data32);
533 /* INPUT DRIVER Routines */
536 * Called when opening the input device. This will submit the URB to
537 * the usb system so we start getting reports
539 static int gtco_input_open(struct input_dev *inputdev)
541 struct gtco *device = input_get_drvdata(inputdev);
543 device->urbinfo->dev = device->usbdev;
544 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
551 * Called when closing the input device. This will unlink the URB
553 static void gtco_input_close(struct input_dev *inputdev)
555 struct gtco *device = input_get_drvdata(inputdev);
557 usb_kill_urb(device->urbinfo);
562 * Setup input device capabilities. Tell the input system what this
563 * device is capable of generating.
565 * This information is based on what is read from the HID report and
566 * placed in the struct gtco structure
569 static void gtco_setup_caps(struct input_dev *inputdev)
571 struct gtco *device = input_get_drvdata(inputdev);
574 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
577 /* Misc event menu block */
578 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
581 /* Absolute values based on HID report info */
582 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
584 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
588 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
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);
599 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
605 * URB callback routine. Called when we get IRQ reports from the
608 * This bridges the USB and input device worlds. It generates events
609 * on the input device based on the USB reports.
611 static void gtco_urb_callback(struct urb *urbinfo)
613 struct gtco *device = urbinfo->context;
614 struct input_dev *inputdev;
620 inputdev = device->inputdevice;
622 /* Was callback OK? */
623 if (urbinfo->status == -ECONNRESET ||
624 urbinfo->status == -ENOENT ||
625 urbinfo->status == -ESHUTDOWN) {
627 /* Shutdown is occurring. Return and don't queue up any more */
631 if (urbinfo->status != 0) {
633 * Some unknown error. Hopefully temporary. Just go and
640 * Good URB, now process
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) {
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
654 switch (device->buffer[0]) {
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,
662 /* Mask out the Y tilt value used for pressure */
663 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
669 /* Sign extend these 7 bit numbers. */
670 if (device->buffer[6] & 0x40)
671 device->buffer[6] |= 0x80;
673 if (device->buffer[7] & 0x40)
674 device->buffer[7] |= 0x80;
677 valsigned = (device->buffer[6]);
678 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
680 valsigned = (device->buffer[7]);
681 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
686 /* Convert buttons, only 5 bits possible */
687 val = (device->buffer[5]) & MASK_BUTTON;
689 /* We don't apply any meaning to the bitmask,
691 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
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);
699 val = get_unaligned_le16(&device->buffer[3]);
700 input_report_abs(inputdev, ABS_Y, val);
702 /* Ditto for proximity bit */
703 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
704 input_report_abs(inputdev, ABS_DISTANCE, val);
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) {
711 * Convert buttons, 5 bit index
712 * Report value of index set as one,
715 val = device->buffer[5] & MASK_BUTTON;
716 dev_dbg(&device->intf->dev,
717 "======>>>>>>REPORT 1: val 0x%X(%d)\n",
721 * We don't apply any meaning to the button
722 * index, just report it
724 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
730 input_event(inputdev, EV_MSC, MSC_SCAN,
736 /* Other pid class */
737 if (inputdev->id.product == PID_400 ||
738 inputdev->id.product == PID_401) {
741 if (device->buffer[0] == 2) {
743 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
747 if (device->buffer[0] == 1) {
750 /* IF X max > 64K, we still a bit from the y report */
751 if (device->max_X > 0x10000) {
753 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
754 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
756 input_report_abs(inputdev, ABS_X, val);
758 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
759 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
761 le_buffer[1] = (u8)(device->buffer[4] >> 1);
762 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
764 val = get_unaligned_le16(le_buffer);
765 input_report_abs(inputdev, ABS_Y, val);
768 * Shift the button byte right by one to
769 * make it look like the standard report
771 buttonbyte = device->buffer[5] >> 1;
774 val = get_unaligned_le16(&device->buffer[1]);
775 input_report_abs(inputdev, ABS_X, val);
777 val = get_unaligned_le16(&device->buffer[3]);
778 input_report_abs(inputdev, ABS_Y, val);
780 buttonbyte = device->buffer[5];
783 /* BUTTONS and PROXIMITY */
784 val = buttonbyte & MASK_INRANGE ? 1 : 0;
785 input_report_abs(inputdev, ABS_DISTANCE, val);
787 /* Convert buttons, only 4 bits possible */
788 val = buttonbyte & 0x0F;
790 for (i = 0; i < 5; i++)
791 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
793 /* We don't apply any meaning to the bitmask, just report */
794 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
798 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
802 /* Everybody gets report ID's */
803 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
806 input_sync(inputdev);
809 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
811 dev_err(&device->intf->dev,
812 "usb_submit_urb failed rc=0x%x\n", 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
826 static int gtco_probe(struct usb_interface *usbinterface,
827 const struct usb_device_id *id)
831 struct input_dev *input_dev;
832 struct hid_descriptor *hid_desc;
834 int result = 0, retry;
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 dev_err(&usbinterface->dev, "No more memory\n");
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));
852 gtco->intf = usbinterface;
854 /* Allocate some data for incoming reports */
855 gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
856 GFP_KERNEL, >co->buf_dma);
858 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
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");
872 * The endpoint is always altsetting 0, we know this since we know
873 * this device only has one interrupt endpoint
875 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
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");
885 dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
888 * Find the HID descriptor so we can find out the size of the
889 * HID report descriptor
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");
899 dev_dbg(&usbinterface->dev,
900 "Extra descriptor success: type:%d len:%d\n",
901 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
903 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
905 dev_err(&usbinterface->dev, "No more memory for report\n");
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,
919 le16_to_cpu(hid_desc->wDescriptorLength),
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);
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);
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));
944 /* Set Input device functions */
945 input_dev->open = gtco_input_open;
946 input_dev->close = gtco_input_close;
948 /* Set input device information */
949 input_dev->name = "GTCO_CalComp";
950 input_dev->phys = gtco->usbpath;
952 input_set_drvdata(input_dev, gtco);
954 /* Now set up all the input device capabilities */
955 gtco_setup_caps(input_dev);
957 /* Set input device required ID information */
958 usb_to_input_id(gtco->usbdev, &input_dev->id);
959 input_dev->dev.parent = &usbinterface->dev;
961 /* Setup the URB, it will be posted later on open of input device */
962 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
964 usb_fill_int_urb(gtco->urbinfo,
966 usb_rcvintpipe(gtco->usbdev,
967 endpoint->bEndpointAddress),
972 endpoint->bInterval);
974 gtco->urbinfo->transfer_dma = gtco->buf_dma;
975 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
977 /* Save gtco pointer in USB interface gtco */
978 usb_set_intfdata(usbinterface, gtco);
980 /* All done, now register the input device */
981 error = input_register_device(input_dev);
988 usb_free_urb(gtco->urbinfo);
990 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
991 gtco->buffer, gtco->buf_dma);
993 input_free_device(input_dev);
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
1003 static void gtco_disconnect(struct usb_interface *interface)
1005 /* Grab private device ptr */
1006 struct gtco *gtco = usb_get_intfdata(interface);
1008 /* Now reverse all the registration stuff */
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);
1018 dev_info(&interface->dev, "gtco driver disconnected\n");
1021 /* STANDARD MODULE LOAD ROUTINES */
1023 static struct usb_driver gtco_driverinfo_table = {
1025 .id_table = gtco_usbid_table,
1026 .probe = gtco_probe,
1027 .disconnect = gtco_disconnect,
1030 module_usb_driver(gtco_driverinfo_table);
1032 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1033 MODULE_LICENSE("GPL");