Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

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

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