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