Input: drivers/usb/input - don't access dev->private directly
[linux-2.6.git] / drivers / usb / input / gtco.c
1 /*    -*- linux-c -*-
2
3 GTCO digitizer USB driver
4
5 Use the err(), dbg() and info() macros from usb.h for system logging
6
7 TO CHECK:  Is pressure done right on report 5?
8
9 Copyright (C) 2006  GTCO CalComp
10
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.
15
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.
20
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.
24
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.
34
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.
42
43 GTCO CalComp, Inc.
44 7125 Riverwood Drive
45 Columbia, MD 21046
46
47 Jeremy Roberson jroberson@gtcocalcomp.com
48 Scott Hill shill@gtcocalcomp.com
49 */
50
51
52
53 /*#define DEBUG*/
54
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>
65
66
67 #include <linux/version.h>
68 #include <linux/usb/input.h>
69
70 /* Version with a Major number of 2 is for kernel inclusion only. */
71 #define  GTCO_VERSION   "2.00.0006"
72
73
74 /*   MACROS  */
75
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
82
83 /* Max size of a single report */
84 #define REPORT_MAX_SIZE       10
85
86
87 /* Bitmask whether pen is in range */
88 #define MASK_INRANGE 0x20
89 #define MASK_BUTTON  0x01F
90
91 #define  PATHLENGTH     64
92
93 /* DATA STRUCTURES */
94
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) },
102         { }
103 };
104 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
105
106
107 /* Structure to hold all of our device specific stuff */
108 struct gtco {
109
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 */
115
116         char  usbpath[PATHLENGTH];
117         int   openCount;
118
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;
131 };
132
133
134
135 /*   Code for parsing the HID REPORT DESCRIPTOR          */
136
137 /* From HID1.11 spec */
138 struct hid_descriptor
139 {
140         struct usb_descriptor_header header;
141         __le16   bcdHID;
142         u8       bCountryCode;
143         u8       bNumDescriptors;
144         u8       bDescriptorType;
145         __le16   wDescriptorLength;
146 } __attribute__ ((packed));
147
148
149 #define HID_DESCRIPTOR_SIZE   9
150 #define HID_DEVICE_TYPE       33
151 #define REPORT_DEVICE_TYPE    34
152
153
154 #define PREF_TAG(x)     ((x)>>4)
155 #define PREF_TYPE(x)    ((x>>2)&0x03)
156 #define PREF_SIZE(x)    ((x)&0x03)
157
158 #define TYPE_MAIN       0
159 #define TYPE_GLOBAL     1
160 #define TYPE_LOCAL      2
161 #define TYPE_RESERVED   3
162
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
168
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
181
182 #define TAG_GLOB_MAX          12
183
184 #define DIGITIZER_USAGE_TIP_PRESSURE   0x30
185 #define DIGITIZER_USAGE_TILT_X         0x3D
186 #define DIGITIZER_USAGE_TILT_Y         0x3E
187
188
189 /*
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:
193  *
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.
197  *
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.
201  *
202  */
203 static void parse_hid_report_descriptor(struct gtco *device, char * report,
204                                         int length)
205 {
206         int   x, i = 0;
207
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;
216
217         /* For parsing logic */
218         int   inputnum = 0;
219         __u32 usage = 0;
220
221         /* Global Values, indexed by TAG */
222         __u32 globalval[TAG_GLOB_MAX];
223         __u32 oldval[TAG_GLOB_MAX];
224
225         /* Debug stuff */
226         char  maintype='x';
227         char  globtype[12];
228         int   indent = 0;
229         char  indentstr[10] = "";
230
231
232         dbg("======>>>>>>PARSE<<<<<<======");
233
234         /* Walk  this report and pull out the info we need */
235         while (i < length) {
236                 prefix = report[i];
237
238                 /* Skip over prefix */
239                 i++;
240
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 = le16_to_cpu(get_unaligned((__le16 *)&report[i]));
249                         break;
250                 case 3:
251                         size = 4;
252                         data32 = le32_to_cpu(get_unaligned((__le32 *)&report[i]));
253                         break;
254                 }
255
256                 /* Skip size of data */
257                 i += size;
258
259                 /* What we do depends on the tag type */
260                 tag  = PREF_TAG(prefix);
261                 type = PREF_TYPE(prefix);
262                 switch (type) {
263                 case TYPE_MAIN:
264                         strcpy(globtype, "");
265                         switch (tag) {
266
267                         case TAG_MAIN_INPUT:
268                                 /*
269                                  * The INPUT MAIN tag signifies this is
270                                  * information from a report.  We need to
271                                  * figure out what it is and store the
272                                  * min/max values
273                                  */
274
275                                 maintype = 'I';
276                                 if (data == 2)
277                                         strcpy(globtype, "Variable");
278                                 else if (data == 3)
279                                         strcpy(globtype, "Var|Const");
280
281                                 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]);
286
287
288                                 /*
289                                   We can assume that the first two input items
290                                   are always the X and Y coordinates.  After
291                                   that, we look for everything else by
292                                   local usage value
293                                  */
294                                 switch (inputnum) {
295                                 case 0:  /* X coord */
296                                         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];
300                                         }
301                                         break;
302
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];
308                                         }
309                                         break;
310
311                                 default:
312                                         /* Tilt X */
313                                         if (usage == DIGITIZER_USAGE_TILT_X) {
314                                                 if (device->maxtilt_X == 0) {
315                                                         device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
316                                                         device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
317                                                 }
318                                         }
319
320                                         /* Tilt Y */
321                                         if (usage == DIGITIZER_USAGE_TILT_Y) {
322                                                 if (device->maxtilt_Y == 0) {
323                                                         device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
324                                                         device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
325                                                 }
326                                         }
327
328                                         /* Pressure */
329                                         if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
330                                                 if (device->maxpressure == 0) {
331                                                         device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
332                                                         device->minpressure = globalval[TAG_GLOB_LOG_MIN];
333                                                 }
334                                         }
335
336                                         break;
337                                 }
338
339                                 inputnum++;
340                                 break;
341
342                         case TAG_MAIN_OUTPUT:
343                                 maintype = 'O';
344                                 break;
345
346                         case TAG_MAIN_FEATURE:
347                                 maintype = 'F';
348                                 break;
349
350                         case TAG_MAIN_COL_START:
351                                 maintype = 'S';
352
353                                 if (data == 0) {
354                                         dbg("======>>>>>> Physical");
355                                         strcpy(globtype, "Physical");
356                                 } else
357                                         dbg("======>>>>>>");
358
359                                 /* Indent the debug output */
360                                 indent++;
361                                 for (x = 0; x < indent; x++)
362                                         indentstr[x] = '-';
363                                 indentstr[x] = 0;
364
365                                 /* Save global tags */
366                                 for (x = 0; x < TAG_GLOB_MAX; x++)
367                                         oldval[x] = globalval[x];
368
369                                 break;
370
371                         case TAG_MAIN_COL_END:
372                                 dbg("<<<<<<======");
373                                 maintype = 'E';
374                                 indent--;
375                                 for (x = 0; x < indent; x++)
376                                         indentstr[x] = '-';
377                                 indentstr[x] = 0;
378
379                                 /* Copy global tags back */
380                                 for (x = 0; x < TAG_GLOB_MAX; x++)
381                                         globalval[x] = oldval[x];
382
383                                 break;
384                         }
385
386                         switch (size) {
387                         case 1:
388                                 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
389                                     indentstr, tag, maintype, size, globtype, data);
390                                 break;
391
392                         case 2:
393                                 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
394                                     indentstr, tag, maintype, size, globtype, data16);
395                                 break;
396
397                         case 4:
398                                 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
399                                     indentstr, tag, maintype, size, globtype, data32);
400                                 break;
401                         }
402                         break;
403
404                 case TYPE_GLOBAL:
405                         switch (tag) {
406                         case TAG_GLOB_USAGE:
407                                 /*
408                                  * First time we hit the global usage tag,
409                                  * it should tell us the type of device
410                                  */
411                                 if (device->usage == 0)
412                                         device->usage = data;
413
414                                 strcpy(globtype, "USAGE");
415                                 break;
416
417                         case TAG_GLOB_LOG_MIN:
418                                 strcpy(globtype, "LOG_MIN");
419                                 break;
420
421                         case TAG_GLOB_LOG_MAX:
422                                 strcpy(globtype, "LOG_MAX");
423                                 break;
424
425                         case TAG_GLOB_PHYS_MIN:
426                                 strcpy(globtype, "PHYS_MIN");
427                                 break;
428
429                         case TAG_GLOB_PHYS_MAX:
430                                 strcpy(globtype, "PHYS_MAX");
431                                 break;
432
433                         case TAG_GLOB_UNIT_EXP:
434                                 strcpy(globtype, "EXP");
435                                 break;
436
437                         case TAG_GLOB_UNIT:
438                                 strcpy(globtype, "UNIT");
439                                 break;
440
441                         case TAG_GLOB_REPORT_SZ:
442                                 strcpy(globtype, "REPORT_SZ");
443                                 break;
444
445                         case TAG_GLOB_REPORT_ID:
446                                 strcpy(globtype, "REPORT_ID");
447                                 /* New report, restart numbering */
448                                 inputnum = 0;
449                                 break;
450
451                         case TAG_GLOB_REPORT_CNT:
452                                 strcpy(globtype, "REPORT_CNT");
453                                 break;
454
455                         case TAG_GLOB_PUSH:
456                                 strcpy(globtype, "PUSH");
457                                 break;
458
459                         case TAG_GLOB_POP:
460                                 strcpy(globtype, "POP");
461                                 break;
462                         }
463
464                         /* Check to make sure we have a good tag number
465                            so we don't overflow array */
466                         if (tag < TAG_GLOB_MAX) {
467                                 switch (size) {
468                                 case 1:
469                                         dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
470                                             indentstr, globtype, tag, size, data);
471                                         globalval[tag] = data;
472                                         break;
473
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;
479
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;
485                                 }
486                         } else {
487                                 dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
488                                     indentstr, tag, size);
489                         }
490                         break;
491
492                 case TYPE_LOCAL:
493                         switch (tag) {
494                         case TAG_GLOB_USAGE:
495                                 strcpy(globtype, "USAGE");
496                                 /* Always 1 byte */
497                                 usage = data;
498                                 break;
499
500                         case TAG_GLOB_LOG_MIN:
501                                 strcpy(globtype, "MIN");
502                                 break;
503
504                         case TAG_GLOB_LOG_MAX:
505                                 strcpy(globtype, "MAX");
506                                 break;
507
508                         default:
509                                 strcpy(globtype, "UNKNOWN");
510                                 break;
511                         }
512
513                         switch (size) {
514                         case 1:
515                                 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
516                                     indentstr, tag, globtype, size, data);
517                                 break;
518
519                         case 2:
520                                 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
521                                     indentstr, tag, globtype, size, data16);
522                                 break;
523
524                         case 4:
525                                 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
526                                     indentstr, tag, globtype, size, data32);
527                                 break;
528                         }
529
530                         break;
531                 }
532         }
533 }
534
535 /*   INPUT DRIVER Routines                               */
536
537 /*
538  * Called when opening the input device.  This will submit the URB to
539  * the usb system so we start getting reports
540  */
541 static int gtco_input_open(struct input_dev *inputdev)
542 {
543         struct gtco *device = input_get_drvdata(inputdev);
544
545         device->urbinfo->dev = device->usbdev;
546         if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
547                 return -EIO;
548
549         return 0;
550 }
551
552 /*
553  * Called when closing the input device.  This will unlink the URB
554  */
555 static void gtco_input_close(struct input_dev *inputdev)
556 {
557         struct gtco *device = input_get_drvdata(inputdev);
558
559         usb_kill_urb(device->urbinfo);
560 }
561
562
563 /*
564  *  Setup input device capabilities.  Tell the input system what this
565  *  device is capable of generating.
566  *
567  *  This information is based on what is read from the HID report and
568  *  placed in the struct gtco structure
569  *
570  */
571 static void gtco_setup_caps(struct input_dev *inputdev)
572 {
573         struct gtco *device = input_get_drvdata(inputdev);
574
575         /* Which events */
576         inputdev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC);
577
578         /* Misc event menu block */
579         inputdev->mscbit[0] = BIT(MSC_SCAN)|BIT(MSC_SERIAL)|BIT(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  */
611 static 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 = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
697                         input_report_abs(inputdev, ABS_X, val);
698
699                         val = le16_to_cpu(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                                 dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
717                                     val, val);
718
719                                 /*
720                                  * We don't apply any meaning to the button
721                                  * index, just report it
722                                  */
723                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
724                         }
725                         break;
726
727                 case 7:
728                         /* Menu blocks */
729                         input_event(inputdev, EV_MSC, MSC_SCAN,
730                                     device->buffer[1]);
731                         break;
732                 }
733         }
734
735         /* Other pid class */
736         if (inputdev->id.product == PID_400 ||
737             inputdev->id.product == PID_401) {
738
739                 /* Report 2 */
740                 if (device->buffer[0] == 2) {
741                         /* Menu blocks */
742                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
743                 }
744
745                 /*  Report 1 */
746                 if (device->buffer[0] == 1) {
747                         char buttonbyte;
748
749                         /*  IF X max > 64K, we still a bit from the y report */
750                         if (device->max_X > 0x10000) {
751
752                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
753                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
754
755                                 input_report_abs(inputdev, ABS_X, val);
756
757                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
758                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
759
760                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
761                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
762
763                                 val = le16_to_cpu(get_unaligned((__le16 *)le_buffer));
764                                 input_report_abs(inputdev, ABS_Y, val);
765
766                                 /*
767                                  * Shift the button byte right by one to
768                                  * make it look like the standard report
769                                  */
770                                 buttonbyte = device->buffer[5] >> 1;
771                         } else {
772
773                                 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[1]));
774                                 input_report_abs(inputdev, ABS_X, val);
775
776                                 val = le16_to_cpu(get_unaligned((__le16 *)&device->buffer[3]));
777                                 input_report_abs(inputdev, ABS_Y, val);
778
779                                 buttonbyte = device->buffer[5];
780                         }
781
782                         /* BUTTONS and PROXIMITY */
783                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
784                         input_report_abs(inputdev, ABS_DISTANCE, val);
785
786                         /* Convert buttons, only 4 bits possible */
787                         val = buttonbyte & 0x0F;
788 #ifdef USE_BUTTONS
789                         for (i = 0; i < 5; i++)
790                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
791 #else
792                         /* We don't apply any meaning to the bitmask, just report */
793                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
794 #endif
795
796                         /* TRANSDUCER */
797                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
798                 }
799         }
800
801         /* Everybody gets report ID's */
802         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
803
804         /* Sync it up */
805         input_sync(inputdev);
806
807  resubmit:
808         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
809         if (rc != 0)
810                 err("usb_submit_urb failed rc=0x%x", rc);
811 }
812
813 /*
814  *  The probe routine.  This is called when the kernel find the matching USB
815  *   vendor/product.  We do the following:
816  *
817  *    - Allocate mem for a local structure to manage the device
818  *    - Request a HID Report Descriptor from the device and parse it to
819  *      find out the device parameters
820  *    - Create an input device and assign it attributes
821  *   - Allocate an URB so the device can talk to us when the input
822  *      queue is open
823  */
824 static int gtco_probe(struct usb_interface *usbinterface,
825                       const struct usb_device_id *id)
826 {
827
828         struct gtco             *gtco;
829         struct input_dev        *input_dev;
830         struct hid_descriptor   *hid_desc;
831         char                    *report = NULL;
832         int                     result = 0, retry;
833         int                     error;
834         struct usb_endpoint_descriptor *endpoint;
835
836         /* Allocate memory for device structure */
837         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
838         input_dev = input_allocate_device();
839         if (!gtco || !input_dev) {
840                 err("No more memory");
841                 error = -ENOMEM;
842                 goto err_free_devs;
843         }
844
845         /* Set pointer to the input device */
846         gtco->inputdevice = input_dev;
847
848         /* Save interface information */
849         gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
850
851         /* Allocate some data for incoming reports */
852         gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
853                                         GFP_KERNEL, &gtco->buf_dma);
854         if (!gtco->buffer) {
855                 err("No more memory for us buffers");
856                 error = -ENOMEM;
857                 goto err_free_devs;
858         }
859
860         /* Allocate URB for reports */
861         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
862         if (!gtco->urbinfo) {
863                 err("Failed to allocate URB");
864                 return -ENOMEM;
865                 goto err_free_buf;
866         }
867
868         /*
869          * The endpoint is always altsetting 0, we know this since we know
870          * this device only has one interrupt endpoint
871          */
872         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
873
874         /* Some debug */
875         dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
876         dbg("num endpoints:     %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
877         dbg("interface class:   %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
878         dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
879         if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
880                 dbg("endpoint: we have interrupt endpoint\n");
881
882         dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
883
884         /*
885          * Find the HID descriptor so we can find out the size of the
886          * HID report descriptor
887          */
888         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
889                                      HID_DEVICE_TYPE, &hid_desc) != 0){
890                 err("Can't retrieve exta USB descriptor to get hid report descriptor length");
891                 error = -EIO;
892                 goto err_free_urb;
893         }
894
895         dbg("Extra descriptor success: type:%d  len:%d",
896             hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
897
898         report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
899         if (!report) {
900                 err("No more memory for report");
901                 error = -ENOMEM;
902                 goto err_free_urb;
903         }
904
905         /* Couple of tries to get reply */
906         for (retry = 0; retry < 3; retry++) {
907                 result = usb_control_msg(gtco->usbdev,
908                                          usb_rcvctrlpipe(gtco->usbdev, 0),
909                                          USB_REQ_GET_DESCRIPTOR,
910                                          USB_RECIP_INTERFACE | USB_DIR_IN,
911                                          REPORT_DEVICE_TYPE << 8,
912                                          0, /* interface */
913                                          report,
914                                          hid_desc->wDescriptorLength,
915                                          5000); /* 5 secs */
916
917                 if (result == hid_desc->wDescriptorLength)
918                         break;
919         }
920
921         /* If we didn't get the report, fail */
922         dbg("usb_control_msg result: :%d", result);
923         if (result != hid_desc->wDescriptorLength) {
924                 err("Failed to get HID Report Descriptor of size: %d",
925                     hid_desc->wDescriptorLength);
926                 error = -EIO;
927                 goto err_free_urb;
928         }
929
930         /* Now we parse the report */
931         parse_hid_report_descriptor(gtco, report, result);
932
933         /* Now we delete it */
934         kfree(report);
935
936         /* Create a device file node */
937         usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
938         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
939
940         /* Set Input device functions */
941         input_dev->open = gtco_input_open;
942         input_dev->close = gtco_input_close;
943
944         /* Set input device information */
945         input_dev->name = "GTCO_CalComp";
946         input_dev->phys = gtco->usbpath;
947
948         input_set_drvdata(input_dev, gtco);
949
950         /* Now set up all the input device capabilities */
951         gtco_setup_caps(input_dev);
952
953         /* Set input device required ID information */
954         usb_to_input_id(gtco->usbdev, &input_dev->id);
955         input_dev->cdev.dev = &usbinterface->dev;
956
957         /* Setup the URB, it will be posted later on open of input device */
958         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
959
960         usb_fill_int_urb(gtco->urbinfo,
961                          gtco->usbdev,
962                          usb_rcvintpipe(gtco->usbdev,
963                                         endpoint->bEndpointAddress),
964                          gtco->buffer,
965                          REPORT_MAX_SIZE,
966                          gtco_urb_callback,
967                          gtco,
968                          endpoint->bInterval);
969
970         gtco->urbinfo->transfer_dma = gtco->buf_dma;
971         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
972
973         /* Save gtco pointer in USB interface gtco */
974         usb_set_intfdata(usbinterface, gtco);
975
976         /* All done, now register the input device */
977         error = input_register_device(input_dev);
978         if (error)
979                 goto err_free_urb;
980
981         return 0;
982
983  err_free_urb:
984         usb_free_urb(gtco->urbinfo);
985  err_free_buf:
986         usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
987                         gtco->buffer, gtco->buf_dma);
988  err_free_devs:
989         kfree(report);
990         input_free_device(input_dev);
991         kfree(gtco);
992         return error;
993 }
994
995 /*
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
999  */
1000 static void gtco_disconnect(struct usb_interface *interface)
1001 {
1002         /* Grab private device ptr */
1003         struct gtco *gtco = usb_get_intfdata(interface);
1004
1005         /* Now reverse all the registration stuff */
1006         if (gtco) {
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);
1012                 kfree(gtco);
1013         }
1014
1015         info("gtco driver disconnected");
1016 }
1017
1018 /*   STANDARD MODULE LOAD ROUTINES  */
1019
1020 static struct usb_driver gtco_driverinfo_table = {
1021         .name           = "gtco",
1022         .id_table       = gtco_usbid_table,
1023         .probe          = gtco_probe,
1024         .disconnect     = gtco_disconnect,
1025 };
1026
1027 /*
1028  *  Register this module with the USB subsystem
1029  */
1030 static int __init gtco_init(void)
1031 {
1032         int error;
1033
1034         error = usb_register(&gtco_driverinfo_table);
1035         if (error) {
1036                 err("usb_register() failed rc=0x%x", error);
1037                 return error;
1038         }
1039
1040         printk("GTCO usb driver version: %s", GTCO_VERSION);
1041         return 0;
1042 }
1043
1044 /*
1045  *   Deregister this module with the USB subsystem
1046  */
1047 static void __exit gtco_exit(void)
1048 {
1049         usb_deregister(&gtco_driverinfo_table);
1050 }
1051
1052 module_init(gtco_init);
1053 module_exit(gtco_exit);
1054
1055 MODULE_LICENSE("GPL");