?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
mfd: wm8350-i2c: Make sure the i2c regmap functions are compiled
[linux/fpc-iii.git] / drivers / input / tablet / gtco.c
bloba9f8f925ba2b22c32c146226745d3e2acca894b1
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/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 /* Sanity check that a device has an endpoint */
873 if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
874 dev_err(&usbinterface->dev,
875 "Invalid number of endpoints\n");
876 error = -EINVAL;
877 goto err_free_urb;
878 }
879
880 /*
881 * The endpoint is always altsetting 0, we know this since we know
882 * this device only has one interrupt endpoint
883 */
884 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
885
886 /* Some debug */
887 dev_dbg(&usbinterface->dev, "gtco # interfaces: %d\n", usbinterface->num_altsetting);
888 dev_dbg(&usbinterface->dev, "num endpoints: %d\n", usbinterface->cur_altsetting->desc.bNumEndpoints);
889 dev_dbg(&usbinterface->dev, "interface class: %d\n", usbinterface->cur_altsetting->desc.bInterfaceClass);
890 dev_dbg(&usbinterface->dev, "endpoint: attribute:0x%x type:0x%x\n", endpoint->bmAttributes, endpoint->bDescriptorType);
891 if (usb_endpoint_xfer_int(endpoint))
892 dev_dbg(&usbinterface->dev, "endpoint: we have interrupt endpoint\n");
893
894 dev_dbg(&usbinterface->dev, "endpoint extra len:%d\n", usbinterface->altsetting[0].extralen);
895
896 /*
897 * Find the HID descriptor so we can find out the size of the
898 * HID report descriptor
899 */
900 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
901 HID_DEVICE_TYPE, &hid_desc) != 0) {
902 dev_err(&usbinterface->dev,
903 "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
904 error = -EIO;
905 goto err_free_urb;
906 }
907
908 dev_dbg(&usbinterface->dev,
909 "Extra descriptor success: type:%d len:%d\n",
910 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
911
912 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
913 if (!report) {
914 dev_err(&usbinterface->dev, "No more memory for report\n");
915 error = -ENOMEM;
916 goto err_free_urb;
917 }
918
919 /* Couple of tries to get reply */
920 for (retry = 0; retry < 3; retry++) {
921 result = usb_control_msg(gtco->usbdev,
922 usb_rcvctrlpipe(gtco->usbdev, 0),
923 USB_REQ_GET_DESCRIPTOR,
924 USB_RECIP_INTERFACE | USB_DIR_IN,
925 REPORT_DEVICE_TYPE << 8,
926 0, /* interface */
927 report,
928 le16_to_cpu(hid_desc->wDescriptorLength),
929 5000); /* 5 secs */
930
931 dev_dbg(&usbinterface->dev, "usb_control_msg result: %d\n", result);
932 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
933 parse_hid_report_descriptor(gtco, report, result);
934 break;
935 }
936 }
937
938 kfree(report);
939
940 /* If we didn't get the report, fail */
941 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
942 dev_err(&usbinterface->dev,
943 "Failed to get HID Report Descriptor of size: %d\n",
944 hid_desc->wDescriptorLength);
945 error = -EIO;
946 goto err_free_urb;
947 }
948
949 /* Create a device file node */
950 usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
951 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
952
953 /* Set Input device functions */
954 input_dev->open = gtco_input_open;
955 input_dev->close = gtco_input_close;
956
957 /* Set input device information */
958 input_dev->name = "GTCO_CalComp";
959 input_dev->phys = gtco->usbpath;
960
961 input_set_drvdata(input_dev, gtco);
962
963 /* Now set up all the input device capabilities */
964 gtco_setup_caps(input_dev);
965
966 /* Set input device required ID information */
967 usb_to_input_id(gtco->usbdev, &input_dev->id);
968 input_dev->dev.parent = &usbinterface->dev;
969
970 /* Setup the URB, it will be posted later on open of input device */
971 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
972
973 usb_fill_int_urb(gtco->urbinfo,
974 gtco->usbdev,
975 usb_rcvintpipe(gtco->usbdev,
976 endpoint->bEndpointAddress),
977 gtco->buffer,
978 REPORT_MAX_SIZE,
979 gtco_urb_callback,
980 gtco,
981 endpoint->bInterval);
982
983 gtco->urbinfo->transfer_dma = gtco->buf_dma;
984 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
985
986 /* Save gtco pointer in USB interface gtco */
987 usb_set_intfdata(usbinterface, gtco);
988
989 /* All done, now register the input device */
990 error = input_register_device(input_dev);
991 if (error)
992 goto err_free_urb;
993
994 return 0;
995
996 err_free_urb:
997 usb_free_urb(gtco->urbinfo);
998 err_free_buf:
999 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
1000 gtco->buffer, gtco->buf_dma);
1001 err_free_devs:
1002 input_free_device(input_dev);
1003 kfree(gtco);
1004 return error;
1005 }
1006
1007 /*
1008 * This function is a standard USB function called when the USB device
1009 * is disconnected. We will get rid of the URV, de-register the input
1010 * device, and free up allocated memory
1011 */
1012 static void gtco_disconnect(struct usb_interface *interface)
1013 {
1014 /* Grab private device ptr */
1015 struct gtco *gtco = usb_get_intfdata(interface);
1016
1017 /* Now reverse all the registration stuff */
1018 if (gtco) {
1019 input_unregister_device(gtco->inputdevice);
1020 usb_kill_urb(gtco->urbinfo);
1021 usb_free_urb(gtco->urbinfo);
1022 usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE,
1023 gtco->buffer, gtco->buf_dma);
1024 kfree(gtco);
1025 }
1026
1027 dev_info(&interface->dev, "gtco driver disconnected\n");
1028 }
1029
1030 /* STANDARD MODULE LOAD ROUTINES */
1031
1032 static struct usb_driver gtco_driverinfo_table = {
1033 .name = "gtco",
1034 .id_table = gtco_usbid_table,
1035 .probe = gtco_probe,
1036 .disconnect = gtco_disconnect,
1037 };
1038
1039 module_usb_driver(gtco_driverinfo_table);
1040
1041 MODULE_DESCRIPTION("GTCO digitizer USB driver");
1042 MODULE_LICENSE("GPL");
Linux with added FPC-III support