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
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.
47 Jeremy Roberson jroberson@gtcocalcomp.com
48 Scott Hill shill@gtcocalcomp.com
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"
76 #define VENDOR_ID_GTCO 0x078C
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
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 */
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];
119 /* Information pulled from Report Descriptor */
135 /* Code for parsing the HID REPORT DESCRIPTOR */
137 /* From HID1.11 spec */
138 struct hid_descriptor
140 struct usb_descriptor_header header;
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)
159 #define TYPE_GLOBAL 1
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,
208 /* Tag primitive vars */
217 /* For parsing logic */
221 /* Global Values, indexed by TAG */
222 __u32 globalval[TAG_GLOB_MAX];
223 __u32 oldval[TAG_GLOB_MAX];
229 char indentstr[10] = "";
232 dbg("======>>>>>>PARSE<<<<<<======");
234 /* Walk this report and pull out the info we need */
238 /* Skip over prefix */
241 /* Determine data size and save the data in the proper variable */
242 size = PREF_SIZE(prefix);
248 data16 = le16_to_cpu(get_unaligned((__le16 *)&report[i]));
252 data32 = le32_to_cpu(get_unaligned((__le32 *)&report[i]));
256 /* Skip size of data */
259 /* What we do depends on the tag type */
260 tag = PREF_TAG(prefix);
261 type = PREF_TYPE(prefix);
264 strcpy(globtype, "");
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
277 strcpy(globtype, "Variable");
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
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];
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];
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];
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];
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];
342 case TAG_MAIN_OUTPUT:
346 case TAG_MAIN_FEATURE:
350 case TAG_MAIN_COL_START:
354 dbg("======>>>>>> Physical");
355 strcpy(globtype, "Physical");
359 /* Indent the debug output */
361 for (x = 0; x < indent; x++)
365 /* Save global tags */
366 for (x = 0; x < TAG_GLOB_MAX; x++)
367 oldval[x] = globalval[x];
371 case TAG_MAIN_COL_END:
375 for (x = 0; x < indent; x++)
379 /* Copy global tags back */
380 for (x = 0; x < TAG_GLOB_MAX; x++)
381 globalval[x] = oldval[x];
388 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
389 indentstr, tag, maintype, size, globtype, data);
393 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
394 indentstr, tag, maintype, size, globtype, data16);
398 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
399 indentstr, tag, maintype, size, globtype, data32);
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");
417 case TAG_GLOB_LOG_MIN:
418 strcpy(globtype, "LOG_MIN");
421 case TAG_GLOB_LOG_MAX:
422 strcpy(globtype, "LOG_MAX");
425 case TAG_GLOB_PHYS_MIN:
426 strcpy(globtype, "PHYS_MIN");
429 case TAG_GLOB_PHYS_MAX:
430 strcpy(globtype, "PHYS_MAX");
433 case TAG_GLOB_UNIT_EXP:
434 strcpy(globtype, "EXP");
438 strcpy(globtype, "UNIT");
441 case TAG_GLOB_REPORT_SZ:
442 strcpy(globtype, "REPORT_SZ");
445 case TAG_GLOB_REPORT_ID:
446 strcpy(globtype, "REPORT_ID");
447 /* New report, restart numbering */
451 case TAG_GLOB_REPORT_CNT:
452 strcpy(globtype, "REPORT_CNT");
456 strcpy(globtype, "PUSH");
460 strcpy(globtype, "POP");
464 /* Check to make sure we have a good tag number
465 so we don't overflow array */
466 if (tag < TAG_GLOB_MAX) {
469 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
470 indentstr, globtype, tag, size, data);
471 globalval[tag] = data;
475 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
476 indentstr, globtype, tag, size, data16);
477 globalval[tag] = data16;
481 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
482 indentstr, globtype, tag, size, data32);
483 globalval[tag] = data32;
487 dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
488 indentstr, tag, size);
495 strcpy(globtype, "USAGE");
500 case TAG_GLOB_LOG_MIN:
501 strcpy(globtype, "MIN");
504 case TAG_GLOB_LOG_MAX:
505 strcpy(globtype, "MAX");
509 strcpy(globtype, "UNKNOWN");
515 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
516 indentstr, tag, globtype, size, data);
520 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
521 indentstr, tag, globtype, size, data16);
525 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
526 indentstr, tag, globtype, size, data32);
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)
544 device = inputdev->private;
546 device->urbinfo->dev = device->usbdev;
547 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
554 * Called when closing the input device. This will unlink the URB
556 static void gtco_input_close(struct input_dev *inputdev)
558 struct gtco *device = inputdev->private;
560 usb_kill_urb(device->urbinfo);
565 * Setup input device capabilities. Tell the input system what this
566 * device is capable of generating.
568 * This information is based on what is read from the HID report and
569 * placed in the struct gtco structure
572 static void gtco_setup_caps(struct input_dev *inputdev)
574 struct gtco *device = inputdev->private;
577 inputdev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC);
579 /* Misc event menu block */
580 inputdev->mscbit[0] = BIT(MSC_SCAN)|BIT(MSC_SERIAL)|BIT(MSC_RAW) ;
582 /* Absolute values based on HID report info */
583 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
585 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
589 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
591 /* Tilt & pressure */
592 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
593 device->maxtilt_X, 0, 0);
594 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
595 device->maxtilt_Y, 0, 0);
596 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
597 device->maxpressure, 0, 0);
600 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
606 * URB callback routine. Called when we get IRQ reports from the
609 * This bridges the USB and input device worlds. It generates events
610 * on the input device based on the USB reports.
612 static void gtco_urb_callback(struct urb *urbinfo)
614 struct gtco *device = urbinfo->context;
615 struct input_dev *inputdev;
621 inputdev = device->inputdevice;
623 /* Was callback OK? */
624 if (urbinfo->status == -ECONNRESET ||
625 urbinfo->status == -ENOENT ||
626 urbinfo->status == -ESHUTDOWN) {
628 /* Shutdown is occurring. Return and don't queue up any more */
632 if (urbinfo->status != 0) {
634 * Some unknown error. Hopefully temporary. Just go and
641 * Good URB, now process
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) {
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
655 switch (device->buffer[0]) {
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,
663 /* Mask out the Y tilt value used for pressure */
664 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
670 /* Sign extend these 7 bit numbers. */
671 if (device->buffer[6] & 0x40)
672 device->buffer[6] |= 0x80;
674 if (device->buffer[7] & 0x40)
675 device->buffer[7] |= 0x80;
678 valsigned = (device->buffer[6]);
679 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
681 valsigned = (device->buffer[7]);
682 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
687 /* Convert buttons, only 5 bits possible */
688 val = (device->buffer[5]) & MASK_BUTTON;
690 /* We don't apply any meaning to the bitmask,
692 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
696 /* All reports have X and Y coords in the same place */
697 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
698 input_report_abs(inputdev, ABS_X, val);
700 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
701 input_report_abs(inputdev, ABS_Y, val);
703 /* Ditto for proximity bit */
704 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
705 input_report_abs(inputdev, ABS_DISTANCE, val);
707 /* Report 1 is an exception to how we handle buttons */
708 /* Buttons are an index, not a bitmask */
709 if (device->buffer[0] == 1) {
712 * Convert buttons, 5 bit index
713 * Report value of index set as one,
716 val = device->buffer[5] & MASK_BUTTON;
717 dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
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 = le16_to_cpu(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 = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
775 input_report_abs(inputdev, ABS_X, val);
777 val = le16_to_cpu(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 err("usb_submit_urb failed rc=0x%x", rc);
815 * The probe routine. This is called when the kernel find the matching USB
816 * vendor/product. We do the following:
818 * - Allocate mem for a local structure to manage the device
819 * - Request a HID Report Descriptor from the device and parse it to
820 * find out the device parameters
821 * - Create an input device and assign it attributes
822 * - Allocate an URB so the device can talk to us when the input
825 static int gtco_probe(struct usb_interface *usbinterface,
826 const struct usb_device_id *id)
830 struct input_dev *input_dev;
831 struct hid_descriptor *hid_desc;
833 int result = 0, retry;
835 struct usb_endpoint_descriptor *endpoint;
837 /* Allocate memory for device structure */
838 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
839 input_dev = input_allocate_device();
840 if (!gtco || !input_dev) {
841 err("No more memory");
846 /* Set pointer to the input device */
847 gtco->inputdevice = input_dev;
849 /* Save interface information */
850 gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
852 /* Allocate some data for incoming reports */
853 gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
854 GFP_KERNEL, >co->buf_dma);
856 err("No more memory for us buffers");
861 /* Allocate URB for reports */
862 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
863 if (!gtco->urbinfo) {
864 err("Failed to allocate URB");
870 * The endpoint is always altsetting 0, we know this since we know
871 * this device only has one interrupt endpoint
873 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
876 dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
877 dbg("num endpoints: %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
878 dbg("interface class: %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
879 dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
880 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
881 dbg("endpoint: we have interrupt endpoint\n");
883 dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
886 * Find the HID descriptor so we can find out the size of the
887 * HID report descriptor
889 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
890 HID_DEVICE_TYPE, &hid_desc) != 0){
891 err("Can't retrieve exta USB descriptor to get hid report descriptor length");
896 dbg("Extra descriptor success: type:%d len:%d",
897 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
899 report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
901 err("No more memory for report");
906 /* Couple of tries to get reply */
907 for (retry = 0; retry < 3; retry++) {
908 result = usb_control_msg(gtco->usbdev,
909 usb_rcvctrlpipe(gtco->usbdev, 0),
910 USB_REQ_GET_DESCRIPTOR,
911 USB_RECIP_INTERFACE | USB_DIR_IN,
912 REPORT_DEVICE_TYPE << 8,
915 hid_desc->wDescriptorLength,
918 if (result == hid_desc->wDescriptorLength)
922 /* If we didn't get the report, fail */
923 dbg("usb_control_msg result: :%d", result);
924 if (result != hid_desc->wDescriptorLength) {
925 err("Failed to get HID Report Descriptor of size: %d",
926 hid_desc->wDescriptorLength);
931 /* Now we parse the report */
932 parse_hid_report_descriptor(gtco, report, result);
934 /* Now we delete it */
937 /* Create a device file node */
938 usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
939 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
941 /* Set Input device functions */
942 input_dev->open = gtco_input_open;
943 input_dev->close = gtco_input_close;
945 /* Set input device information */
946 input_dev->name = "GTCO_CalComp";
947 input_dev->phys = gtco->usbpath;
948 input_dev->private = gtco;
950 /* Now set up all the input device capabilities */
951 gtco_setup_caps(input_dev);
953 /* Set input device required ID information */
954 usb_to_input_id(gtco->usbdev, &input_dev->id);
955 input_dev->cdev.dev = &usbinterface->dev;
957 /* Setup the URB, it will be posted later on open of input device */
958 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
960 usb_fill_int_urb(gtco->urbinfo,
962 usb_rcvintpipe(gtco->usbdev,
963 endpoint->bEndpointAddress),
968 endpoint->bInterval);
970 gtco->urbinfo->transfer_dma = gtco->buf_dma;
971 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
973 /* Save gtco pointer in USB interface gtco */
974 usb_set_intfdata(usbinterface, gtco);
976 /* All done, now register the input device */
977 error = input_register_device(input_dev);
984 usb_free_urb(gtco->urbinfo);
986 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
987 gtco->buffer, gtco->buf_dma);
990 input_free_device(input_dev);
996 * This function is a standard USB function called when the USB device
997 * is disconnected. We will get rid of the URV, de-register the input
998 * device, and free up allocated memory
1000 static void gtco_disconnect(struct usb_interface *interface)
1002 /* Grab private device ptr */
1003 struct gtco *gtco = usb_get_intfdata(interface);
1005 /* Now reverse all the registration stuff */
1007 input_unregister_device(gtco->inputdevice);
1008 usb_kill_urb(gtco->urbinfo);
1009 usb_free_urb(gtco->urbinfo);
1010 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
1011 gtco->buffer, gtco->buf_dma);
1015 info("gtco driver disconnected");
1018 /* STANDARD MODULE LOAD ROUTINES */
1020 static struct usb_driver gtco_driverinfo_table = {
1022 .id_table = gtco_usbid_table,
1023 .probe = gtco_probe,
1024 .disconnect = gtco_disconnect,
1028 * Register this module with the USB subsystem
1030 static int __init gtco_init(void)
1034 error = usb_register(>co_driverinfo_table);
1036 err("usb_register() failed rc=0x%x", error);
1040 printk("GTCO usb driver version: %s", GTCO_VERSION);
1045 * Deregister this module with the USB subsystem
1047 static void __exit gtco_exit(void)
1049 usb_deregister(>co_driverinfo_table);
1052 module_init(gtco_init);
1053 module_exit(gtco_exit);
1055 MODULE_LICENSE("GPL");