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