Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

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 
 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         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 = get_unaligned_le16(&device->buffer[1]);
697                         input_report_abs(inputdev, ABS_X, val);
698 
699                         val = 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                                 dev_dbg(&device->intf->dev,
717                                         "======>>>>>>REPORT 1: val 0x%X(%d)\n",
718                                         val, val);
719 
720                                 /*
721                                  * We don't apply any meaning to the button
722                                  * index, just report it
723                                  */
724                                 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
725                         }
726                         break;
727 
728                 case 7:
729                         /* Menu blocks */
730                         input_event(inputdev, EV_MSC, MSC_SCAN,
731                                     device->buffer[1]);
732                         break;
733                 }
734         }
735 
736         /* Other pid class */
737         if (inputdev->id.product == PID_400 ||
738             inputdev->id.product == PID_401) {
739 
740                 /* Report 2 */
741                 if (device->buffer[0] == 2) {
742                         /* Menu blocks */
743                         input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
744                 }
745 
746                 /*  Report 1 */
747                 if (device->buffer[0] == 1) {
748                         char buttonbyte;
749 
750                         /*  IF X max > 64K, we still a bit from the y report */
751                         if (device->max_X > 0x10000) {
752 
753                                 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
754                                 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
755 
756                                 input_report_abs(inputdev, ABS_X, val);
757 
758                                 le_buffer[0]  = (u8)((u8)(device->buffer[3]) >> 1);
759                                 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
760 
761                                 le_buffer[1]  = (u8)(device->buffer[4] >> 1);
762                                 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
763 
764                                 val = get_unaligned_le16(le_buffer);
765                                 input_report_abs(inputdev, ABS_Y, val);
766 
767                                 /*
768                                  * Shift the button byte right by one to
769                                  * make it look like the standard report
770                                  */
771                                 buttonbyte = device->buffer[5] >> 1;
772                         } else {
773 
774                                 val = get_unaligned_le16(&device->buffer[1]);
775                                 input_report_abs(inputdev, ABS_X, val);
776 
777                                 val = get_unaligned_le16(&device->buffer[3]);
778                                 input_report_abs(inputdev, ABS_Y, val);
779 
780                                 buttonbyte = device->buffer[5];
781                         }
782 
783                         /* BUTTONS and PROXIMITY */
784                         val = buttonbyte & MASK_INRANGE ? 1 : 0;
785                         input_report_abs(inputdev, ABS_DISTANCE, val);
786 
787                         /* Convert buttons, only 4 bits possible */
788                         val = buttonbyte & 0x0F;
789 #ifdef USE_BUTTONS
790                         for (i = 0; i < 5; i++)
791                                 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
792 #else
793                         /* We don't apply any meaning to the bitmask, just report */
794                         input_event(inputdev, EV_MSC, MSC_SERIAL, val);
795 #endif
796 
797                         /* TRANSDUCER */
798                         input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
799                 }
800         }
801 
802         /* Everybody gets report ID's */
803         input_event(inputdev, EV_MSC, MSC_RAW,  device->buffer[0]);
804 
805         /* Sync it up */
806         input_sync(inputdev);
807 
808  resubmit:
809         rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
810         if (rc != 0)
811                 dev_err(&device->intf->dev,
812                         "usb_submit_urb failed rc=0x%x\n", rc);
813 }
814 
815 /*
816  *  The probe routine.  This is called when the kernel find the matching USB
817  *   vendor/product.  We do the following:
818  *
819  *    - Allocate mem for a local structure to manage the device
820  *    - Request a HID Report Descriptor from the device and parse it to
821  *      find out the device parameters
822  *    - Create an input device and assign it attributes
823  *   - Allocate an URB so the device can talk to us when the input
824  *      queue is open
825  */
826 static int gtco_probe(struct usb_interface *usbinterface,
827                       const struct usb_device_id *id)
828 {
829 
830         struct gtco             *gtco;
831         struct input_dev        *input_dev;
832         struct hid_descriptor   *hid_desc;
833         char                    *report;
834         int                     result = 0, retry;
835         int                     error;
836         struct usb_endpoint_descriptor *endpoint;
837 
838         /* Allocate memory for device structure */
839         gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
840         input_dev = input_allocate_device();
841         if (!gtco || !input_dev) {
842                 dev_err(&usbinterface->dev, "No more memory\n");
843                 error = -ENOMEM;
844                 goto err_free_devs;
845         }
846 
847         /* Set pointer to the input device */
848         gtco->inputdevice = input_dev;
849 
850         /* Save interface information */
851         gtco->usbdev = interface_to_usbdev(usbinterface);
852         gtco->intf = usbinterface;
853 
854         /* Allocate some data for incoming reports */
855         gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE,
856                                           GFP_KERNEL, &gtco->buf_dma);
857         if (!gtco->buffer) {
858                 dev_err(&usbinterface->dev, "No more memory for us buffers\n");
859                 error = -ENOMEM;
860                 goto err_free_devs;
861         }
862 
863         /* Allocate URB for reports */
864         gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
865         if (!gtco->urbinfo) {
866                 dev_err(&usbinterface->dev, "Failed to allocate URB\n");
867                 error = -ENOMEM;
868                 goto err_free_buf;
869         }
870 
871         /*
872          * The endpoint is always altsetting 0, we know this since we know
873          * this device only has one interrupt endpoint
874          */
875         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
876 
877         /* Some debug */
878         dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
879         dev_dbg(&usbinterface->dev, "num endpoints:     %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
880         dev_dbg(&usbinterface->dev, "interface class:   %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
881         dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
882         if (usb_endpoint_xfer_int(endpoint))
883                 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
884 
885         dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
886 
887         /*
888          * Find the HID descriptor so we can find out the size of the
889          * HID report descriptor
890          */
891         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
892                                      HID_DEVICE_TYPE, &hid_desc) != 0){
893                 dev_err(&usbinterface->dev,
894                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
895                 error = -EIO;
896                 goto err_free_urb;
897         }
898 
899         dev_dbg(&usbinterface->dev,
900                 "Extra descriptor success: type:%d  len:%d\n",
901                 hid_desc->bDescriptorType,  hid_desc->wDescriptorLength);
902 
903         report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
904         if (!report) {
905                 dev_err(&usbinterface->dev, "No more memory for report\n");
906                 error = -ENOMEM;
907                 goto err_free_urb;
908         }
909 
910         /* Couple of tries to get reply */
911         for (retry = 0; retry < 3; retry++) {
912                 result = usb_control_msg(gtco->usbdev,
913                                          usb_rcvctrlpipe(gtco->usbdev, 0),
914                                          USB_REQ_GET_DESCRIPTOR,
915                                          USB_RECIP_INTERFACE | USB_DIR_IN,
916                                          REPORT_DEVICE_TYPE << 8,
917                                          0, /* interface */
918                                          report,
919                                          le16_to_cpu(hid_desc->wDescriptorLength),
920                                          5000); /* 5 secs */
921 
922                 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
923                 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
924                         parse_hid_report_descriptor(gtco, report, result);
925                         break;
926                 }
927         }
928 
929         kfree(report);
930 
931         /* If we didn't get the report, fail */
932         if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
933                 dev_err(&usbinterface->dev,
934                         "Failed to get HID Report Descriptor of size: %d\n",
935                         hid_desc->wDescriptorLength);
936                 error = -EIO;
937                 goto err_free_urb;
938         }
939 
940         /* Create a device file node */
941         usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
942         strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
943 
944         /* Set Input device functions */
945         input_dev->open = gtco_input_open;
946         input_dev->close = gtco_input_close;
947 
948         /* Set input device information */
949         input_dev->name = "GTCO_CalComp";
950         input_dev->phys = gtco->usbpath;
951 
952         input_set_drvdata(input_dev, gtco);
953 
954         /* Now set up all the input device capabilities */
955         gtco_setup_caps(input_dev);
956 
957         /* Set input device required ID information */
958         usb_to_input_id(gtco->usbdev, &input_dev->id);
959         input_dev->dev.parent = &usbinterface->dev;
960 
961         /* Setup the URB, it will be posted later on open of input device */
962         endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
963 
964         usb_fill_int_urb(gtco->urbinfo,
965                          gtco->usbdev,
966                          usb_rcvintpipe(gtco->usbdev,
967                                         endpoint->bEndpointAddress),
968                          gtco->buffer,
969                          REPORT_MAX_SIZE,
970                          gtco_urb_callback,
971                          gtco,
972                          endpoint->bInterval);
973 
974         gtco->urbinfo->transfer_dma = gtco->buf_dma;
975         gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
976 
977         /* Save gtco pointer in USB interface gtco */
978         usb_set_intfdata(usbinterface, gtco);
979 
980         /* All done, now register the input device */
981         error = input_register_device(input_dev);
982         if (error)
983                 goto err_free_urb;
984 
985         return 0;
986 
987  err_free_urb:
988         usb_free_urb(gtco->urbinfo);
989  err_free_buf:
990         usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
991                           gtco->buffer, gtco->buf_dma);
992  err_free_devs:
993         input_free_device(input_dev);
994         kfree(gtco);
995         return error;
996 }
997 
998 /*
999  *  This function is a standard USB function called when the USB device
1000  *  is disconnected.  We will get rid of the URV, de-register the input
1001  *  device, and free up allocated memory
1002  */
1003 static void gtco_disconnect(struct usb_interface *interface)
1004 {
1005         /* Grab private device ptr */
1006         struct gtco *gtco = usb_get_intfdata(interface);
1007 
1008         /* Now reverse all the registration stuff */
1009         if (gtco) {
1010                 input_unregister_device(gtco->inputdevice);
1011                 usb_kill_urb(gtco->urbinfo);
1012                 usb_free_urb(gtco->urbinfo);
1013                 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
1014                                   gtco->buffer, gtco->buf_dma);
1015                 kfree(gtco);
1016         }
1017 
1018         dev_info(&interface->dev, "gtco driver disconnected\n");
1019 }
1020 
1021 /*   STANDARD MODULE LOAD ROUTINES  */
1022 
1023 static struct usb_driver gtco_driverinfo_table = {
1024         .name           = "gtco",
1025         .id_table       = gtco_usbid_table,
1026         .probe          = gtco_probe,
1027         .disconnect     = gtco_disconnect,
1028 };
1029 
1030 module_usb_driver(gtco_driverinfo_table);
1031 
1032 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1033 MODULE_LICENSE("GPL");
1034 

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