blob: 3d32d3f4e486629d653330b38aafc59fb44d1af7 [file] [log] [blame]
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001/* -*- linux-c -*-
2
3GTCO digitizer USB driver
4
Greg Kroah-Hartman899ef6e2008-08-18 13:21:04 -07005Use the err() and dbg() macros from usb.h for system logging
Jeremy Robersona19ceb52007-01-18 08:10:25 -07006
7TO CHECK: Is pressure done right on report 5?
8
9Copyright (C) 2006 GTCO CalComp
10
11This program is free software; you can redistribute it and/or
12modify it under the terms of the GNU General Public License
13as published by the Free Software Foundation; version 2
14of the License.
15
16This program is distributed in the hope that it will be useful,
17but WITHOUT ANY WARRANTY; without even the implied warranty of
18MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19GNU General Public License for more details.
20
21You should have received a copy of the GNU General Public License
22along with this program; if not, write to the Free Software
23Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24
25Permission to use, copy, modify, distribute, and sell this software and its
26documentation for any purpose is hereby granted without fee, provided that
27the above copyright notice appear in all copies and that both that
28copyright notice and this permission notice appear in supporting
29documentation, and that the name of GTCO-CalComp not be used in advertising
30or publicity pertaining to distribution of the software without specific,
31written prior permission. GTCO-CalComp makes no representations about the
32suitability of this software for any purpose. It is provided "as is"
33without express or implied warranty.
34
35GTCO-CALCOMP DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
36INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
37EVENT SHALL GTCO-CALCOMP BE LIABLE FOR ANY SPECIAL, INDIRECT OR
38CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
39DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
40TORTIOUS ACTIONS, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
41PERFORMANCE OF THIS SOFTWARE.
42
43GTCO CalComp, Inc.
447125 Riverwood Drive
45Columbia, MD 21046
46
47Jeremy Roberson jroberson@gtcocalcomp.com
48Scott Hill shill@gtcocalcomp.com
49*/
50
51
52
53/*#define DEBUG*/
54
55#include <linux/kernel.h>
56#include <linux/module.h>
57#include <linux/errno.h>
58#include <linux/init.h>
59#include <linux/slab.h>
60#include <linux/input.h>
61#include <linux/usb.h>
62#include <asm/uaccess.h>
63#include <asm/unaligned.h>
64#include <asm/byteorder.h>
65
66
Jeremy Robersona19ceb52007-01-18 08:10:25 -070067#include <linux/usb/input.h>
68
69/* Version with a Major number of 2 is for kernel inclusion only. */
70#define GTCO_VERSION "2.00.0006"
71
72
73/* MACROS */
74
75#define VENDOR_ID_GTCO 0x078C
76#define PID_400 0x400
77#define PID_401 0x401
78#define PID_1000 0x1000
79#define PID_1001 0x1001
80#define PID_1002 0x1002
81
82/* Max size of a single report */
83#define REPORT_MAX_SIZE 10
84
85
86/* Bitmask whether pen is in range */
87#define MASK_INRANGE 0x20
88#define MASK_BUTTON 0x01F
89
90#define PATHLENGTH 64
91
92/* DATA STRUCTURES */
93
94/* Device table */
95static struct usb_device_id gtco_usbid_table [] = {
96 { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
97 { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
98 { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
99 { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
100 { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
101 { }
102};
103MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
104
105
106/* Structure to hold all of our device specific stuff */
107struct gtco {
108
109 struct input_dev *inputdevice; /* input device struct pointer */
110 struct usb_device *usbdev; /* the usb device for this device */
111 struct urb *urbinfo; /* urb for incoming reports */
112 dma_addr_t buf_dma; /* dma addr of the data buffer*/
113 unsigned char * buffer; /* databuffer for reports */
114
115 char usbpath[PATHLENGTH];
116 int openCount;
117
118 /* Information pulled from Report Descriptor */
119 u32 usage;
120 u32 min_X;
121 u32 max_X;
122 u32 min_Y;
123 u32 max_Y;
124 s8 mintilt_X;
125 s8 maxtilt_X;
126 s8 mintilt_Y;
127 s8 maxtilt_Y;
128 u32 maxpressure;
129 u32 minpressure;
130};
131
132
133
134/* Code for parsing the HID REPORT DESCRIPTOR */
135
136/* From HID1.11 spec */
137struct hid_descriptor
138{
139 struct usb_descriptor_header header;
140 __le16 bcdHID;
141 u8 bCountryCode;
142 u8 bNumDescriptors;
143 u8 bDescriptorType;
144 __le16 wDescriptorLength;
145} __attribute__ ((packed));
146
147
148#define HID_DESCRIPTOR_SIZE 9
149#define HID_DEVICE_TYPE 33
150#define REPORT_DEVICE_TYPE 34
151
152
153#define PREF_TAG(x) ((x)>>4)
154#define PREF_TYPE(x) ((x>>2)&0x03)
155#define PREF_SIZE(x) ((x)&0x03)
156
157#define TYPE_MAIN 0
158#define TYPE_GLOBAL 1
159#define TYPE_LOCAL 2
160#define TYPE_RESERVED 3
161
162#define TAG_MAIN_INPUT 0x8
163#define TAG_MAIN_OUTPUT 0x9
164#define TAG_MAIN_FEATURE 0xB
165#define TAG_MAIN_COL_START 0xA
166#define TAG_MAIN_COL_END 0xC
167
168#define TAG_GLOB_USAGE 0
169#define TAG_GLOB_LOG_MIN 1
170#define TAG_GLOB_LOG_MAX 2
171#define TAG_GLOB_PHYS_MIN 3
172#define TAG_GLOB_PHYS_MAX 4
173#define TAG_GLOB_UNIT_EXP 5
174#define TAG_GLOB_UNIT 6
175#define TAG_GLOB_REPORT_SZ 7
176#define TAG_GLOB_REPORT_ID 8
177#define TAG_GLOB_REPORT_CNT 9
178#define TAG_GLOB_PUSH 10
179#define TAG_GLOB_POP 11
180
181#define TAG_GLOB_MAX 12
182
183#define DIGITIZER_USAGE_TIP_PRESSURE 0x30
184#define DIGITIZER_USAGE_TILT_X 0x3D
185#define DIGITIZER_USAGE_TILT_Y 0x3E
186
187
188/*
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700189 * This is an abbreviated parser for the HID Report Descriptor. We
190 * know what devices we are talking to, so this is by no means meant
191 * to be generic. We can make some safe assumptions:
192 *
193 * - We know there are no LONG tags, all short
194 * - We know that we have no MAIN Feature and MAIN Output items
195 * - We know what the IRQ reports are supposed to look like.
196 *
197 * The main purpose of this is to use the HID report desc to figure
198 * out the mins and maxs of the fields in the IRQ reports. The IRQ
199 * reports for 400/401 change slightly if the max X is bigger than 64K.
200 *
201 */
202static void parse_hid_report_descriptor(struct gtco *device, char * report,
203 int length)
204{
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400205 int x, i = 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700206
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
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700216 /* 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 */
Dmitry Torokhovbc95f362007-05-01 00:24:54 -0400225 char maintype = 'x';
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700226 char globtype[12];
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400227 int indent = 0;
228 char indentstr[10] = "";
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700229
230
231 dbg("======>>>>>>PARSE<<<<<<======");
232
233 /* Walk this report and pull out the info we need */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400234 while (i < length) {
235 prefix = report[i];
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700236
237 /* Skip over prefix */
238 i++;
239
240 /* Determine data size and save the data in the proper variable */
241 size = PREF_SIZE(prefix);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400242 switch (size) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700243 case 1:
244 data = report[i];
245 break;
246 case 2:
Harvey Harrison858ad082008-04-29 01:03:34 -0700247 data16 = get_unaligned_le16(&report[i]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700248 break;
249 case 3:
250 size = 4;
Harvey Harrison858ad082008-04-29 01:03:34 -0700251 data32 = get_unaligned_le32(&report[i]);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400252 break;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700253 }
254
255 /* Skip size of data */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400256 i += size;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700257
258 /* What we do depends on the tag type */
259 tag = PREF_TAG(prefix);
260 type = PREF_TYPE(prefix);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400261 switch (type) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700262 case TYPE_MAIN:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400263 strcpy(globtype, "");
264 switch (tag) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700265
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
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400274 maintype = 'I';
275 if (data == 2)
276 strcpy(globtype, "Variable");
277 else if (data == 3)
278 strcpy(globtype, "Var|Const");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700279
280 dbg("::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400281 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]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700285
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 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400293 switch (inputnum) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700294 case 0: /* X coord */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400295 dbg("GER: X Usage: 0x%x", usage);
296 if (device->max_X == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700297 device->max_X = globalval[TAG_GLOB_LOG_MAX];
298 device->min_X = globalval[TAG_GLOB_LOG_MIN];
299 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700300 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400301
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700302 case 1: /* Y coord */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400303 dbg("GER: Y Usage: 0x%x", usage);
304 if (device->max_Y == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700305 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
306 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
307 }
308 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400309
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700310 default:
311 /* Tilt X */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400312 if (usage == DIGITIZER_USAGE_TILT_X) {
313 if (device->maxtilt_X == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700314 device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
315 device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
316 }
317 }
318
319 /* Tilt Y */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400320 if (usage == DIGITIZER_USAGE_TILT_Y) {
321 if (device->maxtilt_Y == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700322 device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
323 device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
324 }
325 }
326
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700327 /* Pressure */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400328 if (usage == DIGITIZER_USAGE_TIP_PRESSURE) {
329 if (device->maxpressure == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700330 device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
331 device->minpressure = globalval[TAG_GLOB_LOG_MIN];
332 }
333 }
334
335 break;
336 }
337
338 inputnum++;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700339 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400340
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700341 case TAG_MAIN_OUTPUT:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400342 maintype = 'O';
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700343 break;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700344
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400345 case TAG_MAIN_FEATURE:
346 maintype = 'F';
347 break;
348
349 case TAG_MAIN_COL_START:
350 maintype = 'S';
351
352 if (data == 0) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700353 dbg("======>>>>>> Physical");
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400354 strcpy(globtype, "Physical");
355 } else
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700356 dbg("======>>>>>>");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700357
358 /* Indent the debug output */
359 indent++;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400360 for (x = 0; x < indent; x++)
361 indentstr[x] = '-';
362 indentstr[x] = 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700363
364 /* Save global tags */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400365 for (x = 0; x < TAG_GLOB_MAX; x++)
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700366 oldval[x] = globalval[x];
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700367
368 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400369
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700370 case TAG_MAIN_COL_END:
371 dbg("<<<<<<======");
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400372 maintype = 'E';
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700373 indent--;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400374 for (x = 0; x < indent; x++)
375 indentstr[x] = '-';
376 indentstr[x] = 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700377
378 /* Copy global tags back */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400379 for (x = 0; x < TAG_GLOB_MAX; x++)
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700380 globalval[x] = oldval[x];
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700381
382 break;
383 }
384
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400385 switch (size) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700386 case 1:
387 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400388 indentstr, tag, maintype, size, globtype, data);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700389 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400390
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700391 case 2:
392 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400393 indentstr, tag, maintype, size, globtype, data16);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700394 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400395
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700396 case 4:
397 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400398 indentstr, tag, maintype, size, globtype, data32);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700399 break;
400 }
401 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400402
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700403 case TYPE_GLOBAL:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400404 switch (tag) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700405 case TAG_GLOB_USAGE:
406 /*
407 * First time we hit the global usage tag,
408 * it should tell us the type of device
409 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400410 if (device->usage == 0)
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700411 device->usage = data;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400412
413 strcpy(globtype, "USAGE");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700414 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400415
416 case TAG_GLOB_LOG_MIN:
417 strcpy(globtype, "LOG_MIN");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700418 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400419
420 case TAG_GLOB_LOG_MAX:
421 strcpy(globtype, "LOG_MAX");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700422 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400423
424 case TAG_GLOB_PHYS_MIN:
425 strcpy(globtype, "PHYS_MIN");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700426 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400427
428 case TAG_GLOB_PHYS_MAX:
429 strcpy(globtype, "PHYS_MAX");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700430 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400431
432 case TAG_GLOB_UNIT_EXP:
433 strcpy(globtype, "EXP");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700434 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400435
436 case TAG_GLOB_UNIT:
437 strcpy(globtype, "UNIT");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700438 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400439
440 case TAG_GLOB_REPORT_SZ:
441 strcpy(globtype, "REPORT_SZ");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700442 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400443
444 case TAG_GLOB_REPORT_ID:
445 strcpy(globtype, "REPORT_ID");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700446 /* New report, restart numbering */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400447 inputnum = 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700448 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400449
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700450 case TAG_GLOB_REPORT_CNT:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400451 strcpy(globtype, "REPORT_CNT");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700452 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400453
454 case TAG_GLOB_PUSH:
455 strcpy(globtype, "PUSH");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700456 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400457
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700458 case TAG_GLOB_POP:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400459 strcpy(globtype, "POP");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700460 break;
461 }
462
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700463 /* Check to make sure we have a good tag number
464 so we don't overflow array */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400465 if (tag < TAG_GLOB_MAX) {
466 switch (size) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700467 case 1:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400468 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
469 indentstr, globtype, tag, size, data);
470 globalval[tag] = data;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700471 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400472
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700473 case 2:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400474 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
475 indentstr, globtype, tag, size, data16);
476 globalval[tag] = data16;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700477 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400478
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700479 case 4:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400480 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",
481 indentstr, globtype, tag, size, data32);
482 globalval[tag] = data32;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700483 break;
484 }
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400485 } else {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700486 dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400487 indentstr, tag, size);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700488 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700489 break;
490
491 case TYPE_LOCAL:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400492 switch (tag) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700493 case TAG_GLOB_USAGE:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400494 strcpy(globtype, "USAGE");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700495 /* Always 1 byte */
496 usage = data;
497 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400498
499 case TAG_GLOB_LOG_MIN:
500 strcpy(globtype, "MIN");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700501 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400502
503 case TAG_GLOB_LOG_MAX:
504 strcpy(globtype, "MAX");
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700505 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400506
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700507 default:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400508 strcpy(globtype, "UNKNOWN");
509 break;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700510 }
511
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400512 switch (size) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700513 case 1:
514 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400515 indentstr, tag, globtype, size, data);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700516 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400517
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700518 case 2:
519 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400520 indentstr, tag, globtype, size, data16);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700521 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400522
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700523 case 4:
524 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400525 indentstr, tag, globtype, size, data32);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700526 break;
527 }
528
529 break;
530 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700531 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700532}
533
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700534/* INPUT DRIVER Routines */
535
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700536/*
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400537 * Called when opening the input device. This will submit the URB to
538 * the usb system so we start getting reports
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700539 */
540static int gtco_input_open(struct input_dev *inputdev)
541{
Dmitry Torokhov7791bda2007-04-12 01:34:39 -0400542 struct gtco *device = input_get_drvdata(inputdev);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700543
544 device->urbinfo->dev = device->usbdev;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400545 if (usb_submit_urb(device->urbinfo, GFP_KERNEL))
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700546 return -EIO;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400547
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700548 return 0;
549}
550
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400551/*
552 * Called when closing the input device. This will unlink the URB
553 */
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700554static void gtco_input_close(struct input_dev *inputdev)
555{
Dmitry Torokhov7791bda2007-04-12 01:34:39 -0400556 struct gtco *device = input_get_drvdata(inputdev);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700557
558 usb_kill_urb(device->urbinfo);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700559}
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 */
Dmitry Torokhov7791bda2007-04-12 01:34:39 -0400570static void gtco_setup_caps(struct input_dev *inputdev)
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700571{
Dmitry Torokhov7791bda2007-04-12 01:34:39 -0400572 struct gtco *device = input_get_drvdata(inputdev);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700573
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700574 /* Which events */
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700575 inputdev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
576 BIT_MASK(EV_MSC);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700577
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700578 /* Misc event menu block */
Jiri Slaby7b19ada2007-10-18 23:40:32 -0700579 inputdev->mscbit[0] = BIT_MASK(MSC_SCAN) | BIT_MASK(MSC_SERIAL) |
580 BIT_MASK(MSC_RAW);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700581
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700582 /* 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
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700599 /* Transducer */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400600 input_set_abs_params(inputdev, ABS_MISC, 0, 0xFF, 0, 0);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700601}
602
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700603/* USB Routines */
604
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700605/*
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 */
612static void gtco_urb_callback(struct urb *urbinfo)
613{
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400614 struct gtco *device = urbinfo->context;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700615 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
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700623 /* Was callback OK? */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400624 if (urbinfo->status == -ECONNRESET ||
625 urbinfo->status == -ENOENT ||
626 urbinfo->status == -ESHUTDOWN) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700627
628 /* Shutdown is occurring. Return and don't queue up any more */
629 return;
630 }
631
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400632 if (urbinfo->status != 0) {
633 /*
634 * Some unknown error. Hopefully temporary. Just go and
635 * requeue an URB
636 */
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700637 goto resubmit;
638 }
639
640 /*
641 * Good URB, now process
642 */
643
644 /* PID dependent when we interpret the report */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400645 if (inputdev->id.product == PID_1000 ||
646 inputdev->id.product == PID_1001 ||
647 inputdev->id.product == PID_1002) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700648
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 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400655 switch (device->buffer[0]) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700656 case 5:
657 /* Pressure is 9 bits */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400658 val = ((u16)(device->buffer[8]) << 1);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700659 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
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700666 /* 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 */
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700685 case 2:
686 case 3:
687 /* Convert buttons, only 5 bits possible */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400688 val = (device->buffer[5]) & MASK_BUTTON;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700689
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:
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700696 /* All reports have X and Y coords in the same place */
Harvey Harrison858ad082008-04-29 01:03:34 -0700697 val = get_unaligned_le16(&device->buffer[1]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700698 input_report_abs(inputdev, ABS_X, val);
699
Harvey Harrison858ad082008-04-29 01:03:34 -0700700 val = get_unaligned_le16(&device->buffer[3]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700701 input_report_abs(inputdev, ABS_Y, val);
702
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700703 /* Ditto for proximity bit */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400704 val = device->buffer[5] & MASK_INRANGE ? 1 : 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700705 input_report_abs(inputdev, ABS_DISTANCE, val);
706
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700707 /* Report 1 is an exception to how we handle buttons */
708 /* Buttons are an index, not a bitmask */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400709 if (device->buffer[0] == 1) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700710
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400711 /*
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;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700717 dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400718 val, val);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700719
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);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700725 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700726 break;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400727
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700728 case 7:
729 /* Menu blocks */
730 input_event(inputdev, EV_MSC, MSC_SCAN,
731 device->buffer[1]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700732 break;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700733 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700734 }
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400735
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700736 /* Other pid class */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400737 if (inputdev->id.product == PID_400 ||
738 inputdev->id.product == PID_401) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700739
740 /* Report 2 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400741 if (device->buffer[0] == 2) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700742 /* Menu blocks */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400743 input_event(inputdev, EV_MSC, MSC_SCAN, device->buffer[1]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700744 }
745
746 /* Report 1 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400747 if (device->buffer[0] == 1) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700748 char buttonbyte;
749
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700750 /* IF X max > 64K, we still a bit from the y report */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400751 if (device->max_X > 0x10000) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700752
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400753 val = (u16)(((u16)(device->buffer[2] << 8)) | (u8)device->buffer[1]);
754 val |= (u32)(((u8)device->buffer[3] & 0x1) << 16);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700755
756 input_report_abs(inputdev, ABS_X, val);
757
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400758 le_buffer[0] = (u8)((u8)(device->buffer[3]) >> 1);
759 le_buffer[0] |= (u8)((device->buffer[3] & 0x1) << 7);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700760
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400761 le_buffer[1] = (u8)(device->buffer[4] >> 1);
762 le_buffer[1] |= (u8)((device->buffer[5] & 0x1) << 7);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700763
Harvey Harrison858ad082008-04-29 01:03:34 -0700764 val = get_unaligned_le16(le_buffer);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700765 input_report_abs(inputdev, ABS_Y, val);
766
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700767 /*
768 * Shift the button byte right by one to
769 * make it look like the standard report
770 */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400771 buttonbyte = device->buffer[5] >> 1;
772 } else {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700773
Harvey Harrison858ad082008-04-29 01:03:34 -0700774 val = get_unaligned_le16(&device->buffer[1]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700775 input_report_abs(inputdev, ABS_X, val);
776
Harvey Harrison858ad082008-04-29 01:03:34 -0700777 val = get_unaligned_le16(&device->buffer[3]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700778 input_report_abs(inputdev, ABS_Y, val);
779
780 buttonbyte = device->buffer[5];
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700781 }
782
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700783 /* BUTTONS and PROXIMITY */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400784 val = buttonbyte & MASK_INRANGE ? 1 : 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700785 input_report_abs(inputdev, ABS_DISTANCE, val);
786
787 /* Convert buttons, only 4 bits possible */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400788 val = buttonbyte & 0x0F;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700789#ifdef USE_BUTTONS
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400790 for (i = 0; i < 5; i++)
791 input_report_key(inputdev, BTN_DIGI + i, val & (1 << i));
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700792#else
793 /* We don't apply any meaning to the bitmask, just report */
794 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
795#endif
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400796
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700797 /* TRANSDUCER */
798 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700799 }
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);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400810 if (rc != 0)
811 err("usb_submit_urb failed rc=0x%x", rc);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700812}
813
814/*
815 * The probe routine. This is called when the kernel find the matching USB
816 * vendor/product. We do the following:
817 *
818 * - Allocate mem for a local structure to manage the device
819 * - Request a HID Report Descriptor from the device and parse it to
820 * find out the device parameters
821 * - Create an input device and assign it attributes
822 * - Allocate an URB so the device can talk to us when the input
823 * queue is open
824 */
825static int gtco_probe(struct usb_interface *usbinterface,
826 const struct usb_device_id *id)
827{
828
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400829 struct gtco *gtco;
830 struct input_dev *input_dev;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700831 struct hid_descriptor *hid_desc;
Dmitry Torokhov501a5252008-05-30 10:40:28 -0400832 char *report;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400833 int result = 0, retry;
834 int error;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700835 struct usb_endpoint_descriptor *endpoint;
836
837 /* Allocate memory for device structure */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400838 gtco = kzalloc(sizeof(struct gtco), GFP_KERNEL);
839 input_dev = input_allocate_device();
840 if (!gtco || !input_dev) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700841 err("No more memory");
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400842 error = -ENOMEM;
843 goto err_free_devs;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700844 }
845
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400846 /* Set pointer to the input device */
847 gtco->inputdevice = input_dev;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700848
849 /* Save interface information */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400850 gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700851
852 /* Allocate some data for incoming reports */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400853 gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE,
854 GFP_KERNEL, &gtco->buf_dma);
855 if (!gtco->buffer) {
856 err("No more memory for us buffers");
857 error = -ENOMEM;
858 goto err_free_devs;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700859 }
860
861 /* Allocate URB for reports */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400862 gtco->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
863 if (!gtco->urbinfo) {
864 err("Failed to allocate URB");
Julia Lawallf4bc95d2008-07-03 12:10:58 -0400865 error = -ENOMEM;
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400866 goto err_free_buf;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700867 }
868
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700869 /*
870 * The endpoint is always altsetting 0, we know this since we know
871 * this device only has one interrupt endpoint
872 */
873 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
874
875 /* Some debug */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400876 dbg("gtco # interfaces: %d", usbinterface->num_altsetting);
877 dbg("num endpoints: %d", usbinterface->cur_altsetting->desc.bNumEndpoints);
878 dbg("interface class: %d", usbinterface->cur_altsetting->desc.bInterfaceClass);
879 dbg("endpoint: attribute:0x%x type:0x%x", endpoint->bmAttributes, endpoint->bDescriptorType);
Julia Lawalle941da32008-12-30 01:09:02 -0800880 if (usb_endpoint_xfer_int(endpoint))
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700881 dbg("endpoint: we have interrupt endpoint\n");
882
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400883 dbg("endpoint extra len:%d ", usbinterface->altsetting[0].extralen);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700884
885 /*
886 * Find the HID descriptor so we can find out the size of the
887 * HID report descriptor
888 */
889 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400890 HID_DEVICE_TYPE, &hid_desc) != 0){
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700891 err("Can't retrieve exta USB descriptor to get hid report descriptor length");
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400892 error = -EIO;
893 goto err_free_urb;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700894 }
895
896 dbg("Extra descriptor success: type:%d len:%d",
897 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
898
Al Viro6b8588f2008-04-28 07:00:26 +0100899 report = kzalloc(le16_to_cpu(hid_desc->wDescriptorLength), GFP_KERNEL);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400900 if (!report) {
901 err("No more memory for report");
902 error = -ENOMEM;
903 goto err_free_urb;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700904 }
905
906 /* Couple of tries to get reply */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400907 for (retry = 0; retry < 3; retry++) {
908 result = usb_control_msg(gtco->usbdev,
909 usb_rcvctrlpipe(gtco->usbdev, 0),
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700910 USB_REQ_GET_DESCRIPTOR,
911 USB_RECIP_INTERFACE | USB_DIR_IN,
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400912 REPORT_DEVICE_TYPE << 8,
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700913 0, /* interface */
914 report,
Al Viro6b8588f2008-04-28 07:00:26 +0100915 le16_to_cpu(hid_desc->wDescriptorLength),
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700916 5000); /* 5 secs */
917
Dmitry Torokhov501a5252008-05-30 10:40:28 -0400918 dbg("usb_control_msg result: %d", result);
919 if (result == le16_to_cpu(hid_desc->wDescriptorLength)) {
920 parse_hid_report_descriptor(gtco, report, result);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700921 break;
Dmitry Torokhov501a5252008-05-30 10:40:28 -0400922 }
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700923 }
924
Dmitry Torokhov501a5252008-05-30 10:40:28 -0400925 kfree(report);
926
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700927 /* If we didn't get the report, fail */
Al Viro6b8588f2008-04-28 07:00:26 +0100928 if (result != le16_to_cpu(hid_desc->wDescriptorLength)) {
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700929 err("Failed to get HID Report Descriptor of size: %d",
930 hid_desc->wDescriptorLength);
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400931 error = -EIO;
932 goto err_free_urb;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700933 }
934
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700935 /* Create a device file node */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400936 usb_make_path(gtco->usbdev, gtco->usbpath, sizeof(gtco->usbpath));
937 strlcat(gtco->usbpath, "/input0", sizeof(gtco->usbpath));
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700938
939 /* Set Input device functions */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400940 input_dev->open = gtco_input_open;
941 input_dev->close = gtco_input_close;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700942
943 /* Set input device information */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400944 input_dev->name = "GTCO_CalComp";
945 input_dev->phys = gtco->usbpath;
Dmitry Torokhov7791bda2007-04-12 01:34:39 -0400946
947 input_set_drvdata(input_dev, gtco);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700948
949 /* Now set up all the input device capabilities */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400950 gtco_setup_caps(input_dev);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700951
952 /* Set input device required ID information */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400953 usb_to_input_id(gtco->usbdev, &input_dev->id);
Dmitry Torokhovc0f82d52007-04-12 01:35:03 -0400954 input_dev->dev.parent = &usbinterface->dev;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700955
956 /* Setup the URB, it will be posted later on open of input device */
957 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
958
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400959 usb_fill_int_urb(gtco->urbinfo,
960 gtco->usbdev,
961 usb_rcvintpipe(gtco->usbdev,
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700962 endpoint->bEndpointAddress),
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400963 gtco->buffer,
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700964 REPORT_MAX_SIZE,
965 gtco_urb_callback,
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400966 gtco,
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700967 endpoint->bInterval);
968
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400969 gtco->urbinfo->transfer_dma = gtco->buf_dma;
970 gtco->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700971
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400972 /* Save gtco pointer in USB interface gtco */
973 usb_set_intfdata(usbinterface, gtco);
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700974
975 /* All done, now register the input device */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400976 error = input_register_device(input_dev);
977 if (error)
978 goto err_free_urb;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700979
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700980 return 0;
981
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400982 err_free_urb:
983 usb_free_urb(gtco->urbinfo);
984 err_free_buf:
985 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
986 gtco->buffer, gtco->buf_dma);
987 err_free_devs:
Dmitry Torokhov1b726a02007-04-12 01:33:00 -0400988 input_free_device(input_dev);
989 kfree(gtco);
990 return error;
Jeremy Robersona19ceb52007-01-18 08:10:25 -0700991}
992
993/*
994 * This function is a standard USB function called when the USB device
995 * is disconnected. We will get rid of the URV, de-register the input
996 * device, and free up allocated memory
997 */
998static void gtco_disconnect(struct usb_interface *interface)
999{
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001000 /* Grab private device ptr */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001001 struct gtco *gtco = usb_get_intfdata(interface);
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001002
1003 /* Now reverse all the registration stuff */
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001004 if (gtco) {
1005 input_unregister_device(gtco->inputdevice);
1006 usb_kill_urb(gtco->urbinfo);
1007 usb_free_urb(gtco->urbinfo);
1008 usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE,
1009 gtco->buffer, gtco->buf_dma);
1010 kfree(gtco);
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001011 }
1012
Greg Kroah-Hartman899ef6e2008-08-18 13:21:04 -07001013 dev_info(&interface->dev, "gtco driver disconnected\n");
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001014}
1015
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001016/* STANDARD MODULE LOAD ROUTINES */
1017
1018static struct usb_driver gtco_driverinfo_table = {
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001019 .name = "gtco",
1020 .id_table = gtco_usbid_table,
1021 .probe = gtco_probe,
1022 .disconnect = gtco_disconnect,
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001023};
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001024
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001025/*
1026 * Register this module with the USB subsystem
1027 */
1028static int __init gtco_init(void)
1029{
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001030 int error;
1031
1032 error = usb_register(&gtco_driverinfo_table);
1033 if (error) {
1034 err("usb_register() failed rc=0x%x", error);
1035 return error;
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001036 }
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001037
1038 printk("GTCO usb driver version: %s", GTCO_VERSION);
1039 return 0;
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001040}
1041
1042/*
1043 * Deregister this module with the USB subsystem
1044 */
1045static void __exit gtco_exit(void)
1046{
1047 usb_deregister(&gtco_driverinfo_table);
1048}
1049
Dmitry Torokhov1b726a02007-04-12 01:33:00 -04001050module_init(gtco_init);
1051module_exit(gtco_exit);
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001052
Dmitry Torokhov32a676f2009-04-17 20:12:35 -07001053MODULE_DESCRIPTION("GTCO digitizer USB driver");
Jeremy Robersona19ceb52007-01-18 08:10:25 -07001054MODULE_LICENSE("GPL");