Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

Linux/drivers/input/tablet/gtco.c

  1 /*    -*- linux-c -*-
  2 
  3 GTCO digitizer USB driver
  4 
  5 TO CHECK:  Is pressure done right on report 5?
  6 
  7 Copyright (C) 2006  GTCO CalComp
  8 
  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
 12 of the License.
 13 
 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.
 18 
 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.
 22 
 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.
 32 
 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.
 40 
 41 GTCO CalComp, Inc.
 42 7125 Riverwood Drive
 43 Columbia, MD 21046
 44 
 45 Jeremy Roberson jroberson@gtcocalcomp.com
 46 Scott Hill shill@gtcocalcomp.com
 47 */
 48 
 49 
 50 
 51 /*#define DEBUG*/
 52 
 53 #include <linux/kernel.h>
 54 #include <linux/module.h>
 55 #include <linux/errno.h>
 56 #include <linux/slab.h>
 57 #include <linux/input.h>
 58 #include <linux/usb.h>
 59 #include <asm/uaccess.h>
 60 #include <asm/unaligned.h>
 61 #include <asm/byteorder.h>
 62 #include <linux/bitops.h>
 63 
 64 #include <linux/usb/input.h>
 65 
 66 /* Version with a Major number of 2 is for kernel inclusion only. */
 67 #define  GTCO_VERSION   "2.00.0006"
 68 
 69 
 70 /*   MACROS  */
 71 
 72 #define VENDOR_ID_GTCO        0x078C
 73 #define PID_400               0x400
 74 #define PID_401               0x401
 75 #define PID_1000              0x1000
 76 #define PID_1001              0x1001
 77 #define PID_1002              0x1002
 78 
 79 /* Max size of a single report */
 80 #define REPORT_MAX_SIZE       10
 81 
 82 
 83 /* Bitmask whether pen is in range */
 84 #define MASK_INRANGE 0x20
 85 #define MASK_BUTTON  0x01F
 86 
 87 #define  PATHLENGTH     64
 88 
 89 /* DATA STRUCTURES */
 90 
 91 /* Device table */
 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) },
 98         { }
 99 };
100 MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
101 
102 
103 /* Structure to hold all of our device specific stuff */
104 struct gtco {
105 
106         struct input_dev  *inputdevice; /* input device struct pointer  */
107         struct usb_interface *intf;     /* the usb interface for this device */
108         struct urb        *urbinfo;      /* urb for incoming reports      */
109         dma_addr_t        buf_dma;  /* dma addr of the data buffer*/
110         unsigned char *   buffer;   /* databuffer for reports */
111 
112         char  usbpath[PATHLENGTH];
113         int   openCount;
114 
115         /* Information pulled from Report Descriptor */
116         u32  usage;
117         u32  min_X;
118         u32  max_X;
119         u32  min_Y;
120         u32  max_Y;
121         s8   mintilt_X;
122         s8   maxtilt_X;
123         s8   mintilt_Y;
124         s8   maxtilt_Y;
125         u32  maxpressure;
126         u32  minpressure;
127 };
128 
129 
130 
131 /*   Code for parsing the HID REPORT DESCRIPTOR          */
132 
133 /* From HID1.11 spec */
134 struct hid_descriptor
135 {
136         struct usb_descriptor_header header;
137         __le16   bcdHID;
138         u8       bCountryCode;
139         u8       bNumDescriptors;
140         u8       bDescriptorType;
141         __le16   wDescriptorLength;
142 } __attribute__ ((packed));
143 
144 
145 #define HID_DESCRIPTOR_SIZE   9
146 #define HID_DEVICE_TYPE       33
147 #define REPORT_DEVICE_TYPE    34
148 
149 
150 #define PREF_TAG(x)     ((x)>>4)
151 #define PREF_TYPE(x)    ((x>>2)&0x03)
152 #define PREF_SIZE(x)    ((x)&0x03)
153 
154 #define TYPE_MAIN       0
155 #define TYPE_GLOBAL     1
156 #define TYPE_LOCAL      2
157 #define TYPE_RESERVED   3
158 
159 #define TAG_MAIN_INPUT        0x8
160 #define TAG_MAIN_OUTPUT       0x9
161 #define TAG_MAIN_FEATURE      0xB
162 #define TAG_MAIN_COL_START    0xA
163 #define TAG_MAIN_COL_END      0xC
164 
165 #define TAG_GLOB_USAGE        0
166 #define TAG_GLOB_LOG_MIN      1
167 #define TAG_GLOB_LOG_MAX      2
168 #define TAG_GLOB_PHYS_MIN     3
169 #define TAG_GLOB_PHYS_MAX     4
170 #define TAG_GLOB_UNIT_EXP     5
171 #define TAG_GLOB_UNIT         6
172 #define TAG_GLOB_REPORT_SZ    7
173 #define TAG_GLOB_REPORT_ID    8
174 #define TAG_GLOB_REPORT_CNT   9
175 #define TAG_GLOB_PUSH         10
176 #define TAG_GLOB_POP          11
177 
178 #define TAG_GLOB_MAX          12
179 
180 #define DIGITIZER_USAGE_TIP_PRESSURE   0x30
181 #define DIGITIZER_USAGE_TILT_X         0x3D
182 #define DIGITIZER_USAGE_TILT_Y         0x3E
183 
184 
185 /*
186  *   This is an abbreviated parser for the HID Report Descriptor.  We
187  *   know what devices we are talking to, so this is by no means meant
188  *   to be generic.  We can make some safe assumptions:
189  *
190  *   - We know there are no LONG tags, all short
191  *   - We know that we have no MAIN Feature and MAIN Output items
192  *   - We know what the IRQ reports are supposed to look like.
193  *
194  *   The main purpose of this is to use the HID report desc to figure
195  *   out the mins and maxs of the fields in the IRQ reports.  The IRQ
196  *   reports for 400/401 change slightly if the max X is bigger than 64K.
197  *
198  */
199 static void parse_hid_report_descriptor(struct gtco *device, char * report,
200                                         int length)
201 {
202         struct device *ddev = &device->intf->dev;
203         int   x, i = 0;
204 
205         /* Tag primitive vars */
206         __u8   prefix;
207         __u8   size;
208         __u8   tag;
209         __u8   type;
210         __u8   data   = 0;
211         __u16  data16 = 0;
212         __u32  data32 = 0;
213 
214         /* For parsing logic */
215         int   inputnum = 0;
216         __u32 usage = 0;
217 
218         /* Global Values, indexed by TAG */
219         __u32 globalval[TAG_GLOB_MAX];
220         __u32 oldval[TAG_GLOB_MAX];
221 
222         /* Debug stuff */
223         char  maintype = 'x';
224         char  globtype[12];
225         int   indent = 0;
226         char  indentstr[10] = "";
227 
228 
229         dev_dbg(ddev, "======>>>>>>PARSE<<<<<<======\n");
230 
231         /* Walk  this report and pull out the info we need */
232         while (i < length) {
233                 prefix = report[i];
234 
235                 /* Skip over prefix */
236                 i++;
237 
238                 /* Determine data size and save the data in the proper variable */
239                 size = PREF_SIZE(prefix);
240                 switch (size) {
241                 case 1:
242                         data = report[i];
243                         break;
244                 case 2:
245                         data16 = get_unaligned_le16(&report[i]);
246                         break;
247                 case 3:
248                         size = 4;
249                         data32 = get_unaligned_le32(&report[i]);
250                         break;
251                 }
252 
253                 /* Skip size of data */
254                 i += size;
255 
256                 /* What we do depends on the tag type */
257                 tag  = PREF_TAG(prefix);
258                 type = PREF_TYPE(prefix);
259                 switch (type) {
260                 case TYPE_MAIN:
261                         strcpy(globtype, "");
262                         switch (tag) {
263 
264                         case TAG_MAIN_INPUT:
265                                 /*
266                                  * The INPUT MAIN tag signifies this is
267                                  * information from a report.  We need to
268                                  * figure out what it is and store the
269                                  * min/max values
270                                  */
271 
272                                 maintype = 'I';
273                                 if (data == 2)
274                                         strcpy(globtype, "Variable");
275                                 else if (data == 3)
276                                         strcpy(globtype, "Var|Const");
277 
278                                 dev_dbg(ddev, "::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits\n",
279                                         globalval[TAG_GLOB_REPORT_ID], inputnum,
280                                         globalval[TAG_GLOB_LOG_MAX], globalval[TAG_GLOB_LOG_MAX],
281                                         globalval[TAG_GLOB_LOG_MIN], globalval[TAG_GLOB_LOG_MIN],
282                                         globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]);
283 
284 
285                                 /*
286                                   We can assume that the first two input items
287                                   are always the X and Y coordinates.  After
288                                   that, we look for everything else by
289                                   local usage value
290                                  */
291                                 switch (inputnum) {
292                                 case 0:  /* X coord */
293                                         dev_dbg(ddev, "GER: X Usage: 0x%x\n", usage);
294                                         if (device->max_X == 0) {
295                                                 device->max_X = globalval[TAG_GLOB_LOG_MAX];
296                                                 device->min_X = globalval[TAG_GLOB_LOG_MIN];
297                                         }
298                                         break;
299 
300                                 case 1:  /* Y coord */
301                                         dev_dbg(ddev, "GER: Y Usage: 0x%x\n", usage);
302                                         if (device->max_Y == 0) {
303                                                 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
304                                                 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
305                                         }
306                                         break;
307 
308                                 default:
309                                         /* Tilt X */
310                                         if (usage == DIGITIZER_USAGE_TILT_X) {
311                                                 if (device->maxtilt_X == 0) {
312                                                         device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
313                                                         device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
314                                                 }
315                                         }
316 
317                                         /* Tilt Y */
318                                         if (usage == DIGITIZER_USAGE_TILT_Y) {
319                                                 if (device->maxtilt_Y == 0) {
320                                                         device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
321                                                         device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
322                                                 }
323                                         }
324 
325                                         /* Pressure */
326                                         if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
327                                                 if (device->maxpressure == 0) {
328                                                         device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
329                                                         device->minpressure = globalval[TAG_GLOB_LOG_MIN];
330                                                 }
331                                         }
332 
333                                         break;
334                                 }
335 
336                                 inputnum++;
337                                 break;
338 
339                         case TAG_MAIN_OUTPUT:
340                                 maintype = 'O';
341                                 break;
342 
343                         case TAG_MAIN_FEATURE:
344                                 maintype = 'F';
345                                 break;
346 
347                         case TAG_MAIN_COL_START:
348                                 maintype = 'S';
349 
350                                 if (data == 0) {
351                                         dev_dbg(ddev, "======>>>>>> Physical\n");
352                                         strcpy(globtype, "Physical");
353                                 } else
354                                         dev_dbg(ddev, "======>>>>>>\n");
355 
356                                 /* Indent the debug output */
357                                 indent++;
358                                 for (x = 0; x < indent; x++)
359                                         indentstr[x] = '-';
360                                 indentstr[x] = 0;
361 
362                                 /* Save global tags */
363                                 for (x = 0; x < TAG_GLOB_MAX; x++)
364                                         oldval[x] = globalval[x];
365 
366                                 break;
367 
368                         case TAG_MAIN_COL_END:
369                                 dev_dbg(ddev, "<<<<<<======\n");
370                                 maintype = 'E';
371                                 indent--;
372                                 for (x = 0; x < indent; x++)
373                                         indentstr[x] = '-';
374                                 indentstr[x] = 0;
375 
376                                 /* Copy global tags back */
377                                 for (x = 0; x < TAG_GLOB_MAX; x++)
378                                         globalval[x] = oldval[x];
379 
380                                 break;
381                         }
382 
383                         switch (size) {
384                         case 1:
385                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
386                                         indentstr, tag, maintype, size, globtype, data);
387                                 break;
388 
389                         case 2:
390                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
391                                         indentstr, tag, maintype, size, globtype, data16);
392                                 break;
393 
394                         case 4:
395                                 dev_dbg(ddev, "%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x\n",
396                                         indentstr, tag, maintype, size, globtype, data32);
397                                 break;
398                         }
399                         break;
400 
401                 case TYPE_GLOBAL:
402                         switch (tag) {
403                         case TAG_GLOB_USAGE:
404                                 /*
405                                  * First time we hit the global usage tag,
406                                  * it should tell us the type of device
407                                  */
408                                 if (device->usage == 0)
409                                         device->usage = data;
410 
411                                 strcpy(globtype, "USAGE");
412                                 break;
413 
414                         case TAG_GLOB_LOG_MIN:
415                                 strcpy(globtype, "LOG_MIN");
416                                 break;
417 
418                         case TAG_GLOB_LOG_MAX:
419                                 strcpy(globtype, "LOG_MAX");
420                                 break;
421 
422                         case TAG_GLOB_PHYS_MIN:
423                                 strcpy(globtype, "PHYS_MIN");
424                                 break;
425 
426                         case TAG_GLOB_PHYS_MAX:
427                                 strcpy(globtype, "PHYS_MAX");
428                                 break;
429 
430                         case TAG_GLOB_UNIT_EXP:
431                                 strcpy(globtype, "EXP");
432                                 break;
433 
434                         case TAG_GLOB_UNIT:
435                                 strcpy(globtype, "UNIT");
436                                 break;
437 
438                         case TAG_GLOB_REPORT_SZ:
439                                 strcpy(globtype, "REPORT_SZ");
440                                 break;
441 
442                         case TAG_GLOB_REPORT_ID:
443                                 strcpy(globtype, "REPORT_ID");
444                                 /* New report, restart numbering */
445                                 inputnum = 0;
446                                 break;
447 
448                         case TAG_GLOB_REPORT_CNT:
449                                 strcpy(globtype, "REPORT_CNT");
450                                 break;
451 
452                         case TAG_GLOB_PUSH:
453                                 strcpy(globtype, "PUSH");
454                                 break;
455 
456                         case TAG_GLOB_POP:
457                                 strcpy(globtype, "POP");
458                                 break;
459                         }
460 
461                         /* Check to make sure we have a good tag number
462                            so we don't overflow array */
463                         if (tag < TAG_GLOB_MAX) {
464                                 switch (size) {
465                                 case 1:
466                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
467                                                 indentstr, globtype, tag, size, data);
468                                         globalval[tag] = data;
469                                         break;
470 
471                                 case 2:
472                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
473                                                 indentstr, globtype, tag, size, data16);
474                                         globalval[tag] = data16;
475                                         break;
476 
477                                 case 4:
478                                         dev_dbg(ddev, "%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x\n",
479                                                 indentstr, globtype, tag, size, data32);
480                                         globalval[tag] = data32;
481                                         break;
482                                 }
483                         } else {
484                                 dev_dbg(ddev, "%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d\n",
485                                         indentstr, tag, size);
486                         }
487                         break;
488 
489                 case TYPE_LOCAL:
490                         switch (tag) {
491                         case TAG_GLOB_USAGE:
492                                 strcpy(globtype, "USAGE");
493                                 /* Always 1 byte */
494                                 usage = data;
495                                 break;
496 
497                         case TAG_GLOB_LOG_MIN:
498                                 strcpy(globtype, "MIN");
499                                 break;
500 
501                         case TAG_GLOB_LOG_MAX:
502                                 strcpy(globtype, "MAX");
503                                 break;
504 
505                         default:
506                                 strcpy(globtype, "UNKNOWN");
507                                 break;
508                         }
509 
510                         switch (size) {
511                         case 1:
512                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
513                                         indentstr, tag, globtype, size, data);
514                                 break;
515 
516                         case 2:
517                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
518                                         indentstr, tag, globtype, size, data16);
519                                 break;
520 
521                         case 4:
522                                 dev_dbg(ddev, "%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x\n",
523                                         indentstr, tag, globtype, size, data32);
524                                 break;
525                         }
526 
527                         break;
528                 }
529         }
530 }
531 
532 /*   INPUT DRIVER Routines                               */
533 
534 /*
535  * Called when opening the input device.  This will submit the URB to
536  * the usb system so we start getting reports
537  */
538 static int gtco_input_open(struct input_dev *inputdev)
539 {
540         struct gtco *device = input_get_drvdata(inputdev);
541 
542         device->urbinfo->dev = interface_to_usbdev(device->intf);
543         if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
544                 return -EIO;
545 
546         return 0;
547 }
548 
549 /*
550  * Called when closing the input device.  This will unlink the URB
551  */
552 static void gtco_input_close(struct input_dev *inputdev)
553 {
554         struct gtco *device = input_get_drvdata(inputdev);
555 
556         usb_kill_urb(device->urbinfo);
557 }
558 
559 
560 /*
561  *  Setup input device capabilities.  Tell the input system what this
562  *  device is capable of generating.
563  *
564  *  This information is based on what is read from the HID report and
565  *  placed in the struct gtco structure
566  *
567  */
568 static void gtco_setup_caps(struct input_dev *inputdev)
569 {
570         struct gtco *device = input_get_drvdata(inputdev);
571 
572         /* Which events */
573         inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
574                 BIT_MASK(EV_MSC);
575 
576         /* Misc event menu block */
577         inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
578                 BIT_MASK(MSC_RAW);
579 
580         /* Absolute values based on HID report info */
581         input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
582                              0, 0);
583         input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
584                              0, 0);
585 
586         /* Proximity */
587         input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
588 
589         /* Tilt & pressure */
590         input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
591                              device->maxtilt_X, 0, 0);
592         input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
593                              device->maxtilt_Y, 0, 0);
594         input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
595                              device->maxpressure, 0, 0);
596 
597         /* Transducer */
598         input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
599 }
600 
601 /*   USB Routines  */
602 
603 /*
604  * URB callback routine.  Called when we get IRQ reports from the
605  *  digitizer.
606  *
607  *  This bridges the USB and input device worlds.  It generates events
608  *  on the input device based on the USB reports.
609  */
610 static void gtco_urb_callback(struct urb *urbinfo)
611 {
612         struct gtco *device = urbinfo->context;
613         struct input_dev  *inputdev;
614         int               rc;
615         u32               val = 0;
616         char              le_buffer[2];
617 
618         inputdev = device->inputdevice;
619 
620         /* Was callback OK? */
621         if (urbinfo->status == -ECONNRESET ||
622             urbinfo->status == -ENOENT ||
623             urbinfo->status == -ESHUTDOWN) {
624 
625                 /* Shutdown is occurring. Return and don't queue up any more */
626                 return;
627         }
628 
629         if (urbinfo->status != 0) {
630                 /*
631                  * Some unknown error.  Hopefully temporary. Just go and
632                  * requeue an URB
633                  */
634                 goto resubmit;
635         }
636 
637         /*
638          * Good URB, now process
639          */
640 
641         /* PID dependent when we interpret the report */
642         if (inputdev->id.product == PID_1000 ||
643             inputdev->id.product == PID_1001 ||
644             inputdev->id.product == PID_1002) {
645 
646                 /*
647                  * Switch on the report ID
648                  * Conveniently, the reports have more information, the higher
649                  * the report number.  We can just fall through the case
650                  * statements if we start with the highest number report
651                  */
652                 switch (device->buffer[0]) {
653                 case 5:
654                         /* Pressure is 9 bits */
655                         val = ((u16)(device->buffer[8]) << 1);
656                         val |= (u16)(device->buffer[7] >> 7);
657                         input_report_abs(inputdev, ABS_PRESSURE,
658                                          device->buffer[8]);
659 
660                         /* Mask out the Y tilt value used for pressure */
661                         device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
662 
663                         /* Fall thru */
664                 case 4:
665                         /* Tilt */
666                         input_report_abs(inputdev, ABS_TILT_X,
667                                          sign_extend32(device->buffer[6], 6));
668 
669                         input_report_abs(inputdev, ABS_TILT_Y,
670                                          sign_extend32(device->buffer[7], 6));
671 
672                         /* Fall thru */
673                 case 2:
674                 case 3:
675                         /* Convert buttons, only 5 bits possible */
676                         val = (device->buffer[5]) & MASK_BUTTON;
677 
678                         /* We don't apply any meaning to the bitmask,
679                            just report */
680                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
681 
682                         /*  Fall thru */
683                 case 1:
684                         /* All reports have X and Y coords in the same place */
685                         val = get_unaligned_le16(&device->buffer[1]);
686                         input_report_abs(inputdev, ABS_X, val);
687 
688                         val = get_unaligned_le16(&device->buffer[3]);
689                         input_report_abs(inputdev, ABS_Y, val);
690 
691                         /* Ditto for proximity bit */
692                         val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
693                         input_report_abs(inputdev, ABS_DISTANCE, val);
694 
695                         /* Report 1 is an exception to how we handle buttons */
696                         /* Buttons are an index, not a bitmask */
697                         if (device->buffer[0] == 1) {
698 
699                                 /*
700                                  * Convert buttons, 5 bit index
701                                  * Report value of index set as one,
702                                  * the rest as 0
703                                  */
704                                 val = device->buffer[5] & MASK_BUTTON;
705                                 dev_dbg(&device->intf->dev,
706                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
707                                         val, val);
708 
709                                 /*
710                                  * We don't apply any meaning to the button
711                                  * index, just report it
712                                  */
713                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
714                         }
715                         break;
716 
717                 case 7:
718                         /* Menu blocks */
719                         input_event(inputdev, EV_MSC, MSC_SCAN,
720                                     device->buffer[1]);
721                         break;
722                 }
723         }
724 
725         /* Other pid class */
726         if (inputdev->id.product == PID_400 ||
727             inputdev->id.product == PID_401) {
728 
729                 /* Report 2 */
730                 if (device->buffer[0] == 2) {
731                         /* Menu blocks */
732                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
733                 }
734 
735                 /*  Report 1 */
736                 if (device->buffer[0] == 1) {
737                         char buttonbyte;
738 
739                         /*  IF X max > 64K, we still a bit from the y report */
740                         if (device->max_X > 0x10000) {
741 
742                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
743                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
744 
745                                 input_report_abs(inputdev, ABS_X, val);
746 
747                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
748                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
749 
750                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
751                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
752 
753                                 val = get_unaligned_le16(le_buffer);
754                                 input_report_abs(inputdev, ABS_Y, val);
755 
756                                 /*
757                                  * Shift the button byte right by one to
758                                  * make it look like the standard report
759                                  */
760                                 buttonbyte = device->buffer[5] >> 1;
761                         } else {
762 
763                                 val = get_unaligned_le16(&device->buffer[1]);
764                                 input_report_abs(inputdev, ABS_X, val);
765 
766                                 val = get_unaligned_le16(&device->buffer[3]);
767                                 input_report_abs(inputdev, ABS_Y, val);
768 
769                                 buttonbyte = device->buffer[5];
770                         }
771 
772                         /* BUTTONS and PROXIMITY */
773                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
774                         input_report_abs(inputdev, ABS_DISTANCE, val);
775 
776                         /* Convert buttons, only 4 bits possible */
777                         val = buttonbyte & 0x0F;
778 #ifdef USE_BUTTONS
779                         for (i = 0; i < 5; i++)
780                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
781 #else
782                         /* We don't apply any meaning to the bitmask, just report */
783                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
784 #endif
785 
786                         /* TRANSDUCER */
787                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
788                 }
789         }
790 
791         /* Everybody gets report ID's */
792         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
793 
794         /* Sync it up */
795         input_sync(inputdev);
796 
797  resubmit:
798         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
799         if (rc != 0)
800                 dev_err(&device->intf->dev,
801                         "usb_submit_urb failed rc=0x%x\n", rc);
802 }
803 
804 /*
805  *  The probe routine.  This is called when the kernel find the matching USB
806  *   vendor/product.  We do the following:
807  *
808  *    - Allocate mem for a local structure to manage the device
809  *    - Request a HID Report Descriptor from the device and parse it to
810  *      find out the device parameters
811  *    - Create an input device and assign it attributes
812  *   - Allocate an URB so the device can talk to us when the input
813  *      queue is open
814  */
815 static int gtco_probe(struct usb_interface *usbinterface,
816                       const struct usb_device_id *id)
817 {
818 
819         struct gtco             *gtco;
820         struct input_dev        *input_dev;
821         struct hid_descriptor   *hid_desc;
822         char                    *report;
823         int                     result = 0, retry;
824         int                     error;
825         struct usb_endpoint_descriptor *endpoint;
826         struct usb_device       *udev = interface_to_usbdev(usbinterface);
827 
828         /* Allocate memory for device structure */
829         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
830         input_dev = input_allocate_device();
831         if (!gtco || !input_dev) {
832                 dev_err(&usbinterface->dev, "No more memory\n");
833                 error = -ENOMEM;
834                 goto err_free_devs;
835         }
836 
837         /* Set pointer to the input device */
838         gtco->inputdevice = input_dev;
839 
840         /* Save interface information */
841         gtco->intf = usbinterface;
842 
843         /* Allocate some data for incoming reports */
844         gtco->buffer = usb_alloc_coherent(udev, REPORT_MAX_SIZE,
845                                           GFP_KERNEL, &gtco->buf_dma);
846         if (!gtco->buffer) {
847                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
848                 error = -ENOMEM;
849                 goto err_free_devs;
850         }
851 
852         /* Allocate URB for reports */
853         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
854         if (!gtco->urbinfo) {
855                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
856                 error = -ENOMEM;
857                 goto err_free_buf;
858         }
859 
860         /* Sanity check that a device has an endpoint */
861         if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
862                 dev_err(&usbinterface->dev,
863                         "Invalid number of endpoints\n");
864                 error = -EINVAL;
865                 goto err_free_urb;
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         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
876         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
877         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
878         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
879         if (usb_endpoint_xfer_int(endpoint))
880                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
881 
882         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", 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                 dev_err(&usbinterface->dev,
891                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
892                 error = -EIO;
893                 goto err_free_urb;
894         }
895 
896         dev_dbg(&usbinterface->dev,
897                 "Extra descriptor success: type:%d  len:%d\n",
898                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
899 
900         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
901         if (!report) {
902                 dev_err(&usbinterface->dev, "No more memory for report\n");
903                 error = -ENOMEM;
904                 goto err_free_urb;
905         }
906 
907         /* Couple of tries to get reply */
908         for (retry = 0; retry < 3; retry++) {
909                 result = usb_control_msg(udev,
910                                          usb_rcvctrlpipe(udev, 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 */
918 
919                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
920                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
921                         parse_hid_report_descriptor(gtco, report, result);
922                         break;
923                 }
924         }
925 
926         kfree(report);
927 
928         /* If we didn't get the report, fail */
929         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
930                 dev_err(&usbinterface->dev,
931                         "Failed to get HID Report Descriptor of size: %d\n",
932                         hid_desc->wDescriptorLength);
933                 error = -EIO;
934                 goto err_free_urb;
935         }
936 
937         /* Create a device file node */
938         usb_make_path(udev, gtco->usbpath, sizeof(gtco->usbpath));
939         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
940 
941         /* Set Input device functions */
942         input_dev->open = gtco_input_open;
943         input_dev->close = gtco_input_close;
944 
945         /* Set input device information */
946         input_dev->name = "GTCO_CalComp";
947         input_dev->phys = gtco->usbpath;
948 
949         input_set_drvdata(input_dev, gtco);
950 
951         /* Now set up all the input device capabilities */
952         gtco_setup_caps(input_dev);
953 
954         /* Set input device required ID information */
955         usb_to_input_id(udev, &input_dev->id);
956         input_dev->dev.parent = &usbinterface->dev;
957 
958         /* Setup the URB, it will be posted later on open of input device */
959         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
960 
961         usb_fill_int_urb(gtco->urbinfo,
962                          udev,
963                          usb_rcvintpipe(udev,
964                                         endpoint->bEndpointAddress),
965                          gtco->buffer,
966                          REPORT_MAX_SIZE,
967                          gtco_urb_callback,
968                          gtco,
969                          endpoint->bInterval);
970 
971         gtco->urbinfo->transfer_dma = gtco->buf_dma;
972         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
973 
974         /* Save gtco pointer in USB interface gtco */
975         usb_set_intfdata(usbinterface, gtco);
976 
977         /* All done, now register the input device */
978         error = input_register_device(input_dev);
979         if (error)
980                 goto err_free_urb;
981 
982         return 0;
983 
984  err_free_urb:
985         usb_free_urb(gtco->urbinfo);
986  err_free_buf:
987         usb_free_coherent(udev, REPORT_MAX_SIZE,
988                           gtco->buffer, gtco->buf_dma);
989  err_free_devs:
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         struct usb_device *udev = interface_to_usbdev(interface);
1005 
1006         /* Now reverse all the registration stuff */
1007         if (gtco) {
1008                 input_unregister_device(gtco->inputdevice);
1009                 usb_kill_urb(gtco->urbinfo);
1010                 usb_free_urb(gtco->urbinfo);
1011                 usb_free_coherent(udev, REPORT_MAX_SIZE,
1012                                   gtco->buffer, gtco->buf_dma);
1013                 kfree(gtco);
1014         }
1015 
1016         dev_info(&interface->dev, "gtco driver disconnected\n");
1017 }
1018 
1019 /*   STANDARD MODULE LOAD ROUTINES  */
1020 
1021 static struct usb_driver gtco_driverinfo_table = {
1022         .name           = "gtco",
1023         .id_table       = gtco_usbid_table,
1024         .probe          = gtco_probe,
1025         .disconnect     = gtco_disconnect,
1026 };
1027 
1028 module_usb_driver(gtco_driverinfo_table);
1029 
1030 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1031 MODULE_LICENSE("GPL");
1032 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us