aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/usb/input
diff options
context:
space:
mode:
authorDmitry Torokhov <dtor@insightbb.com>2007-02-10 01:26:32 -0500
committerDmitry Torokhov <dtor@insightbb.com>2007-02-10 01:26:32 -0500
commitb22364c8eec89e6b0c081a237f3b6348df87796f (patch)
tree233a923281fb640106465d076997ff511efb6edf /drivers/usb/input
parent2c8dc071517ec2843869024dc82be2e246f41064 (diff)
parent66efc5a7e3061c3597ac43a8bb1026488d57e66b (diff)
Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
Diffstat (limited to 'drivers/usb/input')
-rw-r--r--drivers/usb/input/Kconfig46
-rw-r--r--drivers/usb/input/Makefile7
-rw-r--r--drivers/usb/input/gtco.c1104
-rw-r--r--drivers/usb/input/hid-core.c1497
-rw-r--r--drivers/usb/input/hid-debug.h757
-rw-r--r--drivers/usb/input/hid-ff.c12
-rw-r--r--drivers/usb/input/hid-input.c872
-rw-r--r--drivers/usb/input/hid-lgff.c11
-rw-r--r--drivers/usb/input/hid-pidff.c58
-rw-r--r--drivers/usb/input/hid-plff.c129
-rw-r--r--drivers/usb/input/hid-tmff.c5
-rw-r--r--drivers/usb/input/hid-zpff.c7
-rw-r--r--drivers/usb/input/hid.h540
-rw-r--r--drivers/usb/input/hiddev.c37
-rw-r--r--drivers/usb/input/usbhid.h87
-rw-r--r--drivers/usb/input/usbtouchscreen.c98
-rw-r--r--drivers/usb/input/wacom_sys.c4
-rw-r--r--drivers/usb/input/wacom_wac.c26
18 files changed, 1834 insertions, 3463 deletions
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index 661af7aa6236..2e71d3cca198 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -6,14 +6,14 @@ comment "USB Input Devices"
6 6
7config USB_HID 7config USB_HID
8 tristate "USB Human Interface Device (full HID) support" 8 tristate "USB Human Interface Device (full HID) support"
9 depends on USB 9 default y
10 depends on USB && INPUT
11 select HID
10 ---help--- 12 ---help---
11 Say Y here if you want full HID support to connect keyboards, 13 Say Y here if you want full HID support to connect USB keyboards,
12 mice, joysticks, graphic tablets, or any other HID based devices 14 mice, joysticks, graphic tablets, or any other HID based devices
13 to your computer via USB. You also need to select HID Input layer 15 to your computer via USB, as well as Uninterruptible Power Supply
14 support (below) if you want to use keyboards, mice, joysticks and 16 (UPS) and monitor control devices.
15 the like ... as well as Uninterruptible Power Supply (UPS) and
16 monitor control devices.
17 17
18 You can't use this driver and the HIDBP (Boot Protocol) keyboard 18 You can't use this driver and the HIDBP (Boot Protocol) keyboard
19 and mouse drivers at the same time. More information is available: 19 and mouse drivers at the same time. More information is available:
@@ -27,20 +27,10 @@ config USB_HID
27comment "Input core support is needed for USB HID input layer or HIDBP support" 27comment "Input core support is needed for USB HID input layer or HIDBP support"
28 depends on USB_HID && INPUT=n 28 depends on USB_HID && INPUT=n
29 29
30config USB_HIDINPUT
31 bool "HID input layer support"
32 default y
33 depends on INPUT && USB_HID
34 help
35 Say Y here if you want to use a USB keyboard, mouse or joystick,
36 or any other HID input device.
37
38 If unsure, say Y.
39
40config USB_HIDINPUT_POWERBOOK 30config USB_HIDINPUT_POWERBOOK
41 bool "Enable support for iBook/PowerBook special keys" 31 bool "Enable support for iBook/PowerBook special keys"
42 default n 32 default n
43 depends on USB_HIDINPUT 33 depends on USB_HID
44 help 34 help
45 Say Y here if you want support for the special keys (Fn, Numlock) on 35 Say Y here if you want support for the special keys (Fn, Numlock) on
46 Apple iBooks and PowerBooks. 36 Apple iBooks and PowerBooks.
@@ -49,7 +39,7 @@ config USB_HIDINPUT_POWERBOOK
49 39
50config HID_FF 40config HID_FF
51 bool "Force feedback support (EXPERIMENTAL)" 41 bool "Force feedback support (EXPERIMENTAL)"
52 depends on USB_HIDINPUT && EXPERIMENTAL 42 depends on USB_HID && EXPERIMENTAL
53 help 43 help
54 Say Y here is you want force feedback support for a few HID devices. 44 Say Y here is you want force feedback support for a few HID devices.
55 See below for a list of supported devices. 45 See below for a list of supported devices.
@@ -79,6 +69,14 @@ config LOGITECH_FF
79 Note: if you say N here, this device will still be supported, but without 69 Note: if you say N here, this device will still be supported, but without
80 force feedback. 70 force feedback.
81 71
72config PANTHERLORD_FF
73 bool "PantherLord USB/PS2 2in1 Adapter support"
74 depends on HID_FF
75 select INPUT_FF_MEMLESS if USB_HID
76 help
77 Say Y here if you have a PantherLord USB/PS2 2in1 Adapter and want
78 to enable force feedback support for it.
79
82config THRUSTMASTER_FF 80config THRUSTMASTER_FF
83 bool "ThrustMaster FireStorm Dual Power 2 support (EXPERIMENTAL)" 81 bool "ThrustMaster FireStorm Dual Power 2 support (EXPERIMENTAL)"
84 depends on HID_FF && EXPERIMENTAL 82 depends on HID_FF && EXPERIMENTAL
@@ -354,3 +352,15 @@ config USB_APPLETOUCH
354 352
355 To compile this driver as a module, choose M here: the 353 To compile this driver as a module, choose M here: the
356 module will be called appletouch. 354 module will be called appletouch.
355
356config USB_GTCO
357 tristate "GTCO CalComp/InterWrite USB Support"
358 depends on USB && INPUT
359 ---help---
360 Say Y here if you want to use the USB version of the GTCO
361 CalComp/InterWrite Tablet. Make sure to say Y to "Mouse support"
362 (CONFIG_INPUT_MOUSEDEV) and/or "Event interface support"
363 (CONFIG_INPUT_EVDEV) as well.
364
365 To compile this driver as a module, choose M here: the
366 module will be called gtco.
diff --git a/drivers/usb/input/Makefile b/drivers/usb/input/Makefile
index d946d5213b30..a9d206c945e9 100644
--- a/drivers/usb/input/Makefile
+++ b/drivers/usb/input/Makefile
@@ -11,15 +11,15 @@ usbhid-objs := hid-core.o
11ifeq ($(CONFIG_USB_HIDDEV),y) 11ifeq ($(CONFIG_USB_HIDDEV),y)
12 usbhid-objs += hiddev.o 12 usbhid-objs += hiddev.o
13endif 13endif
14ifeq ($(CONFIG_USB_HIDINPUT),y)
15 usbhid-objs += hid-input.o
16endif
17ifeq ($(CONFIG_HID_PID),y) 14ifeq ($(CONFIG_HID_PID),y)
18 usbhid-objs += hid-pidff.o 15 usbhid-objs += hid-pidff.o
19endif 16endif
20ifeq ($(CONFIG_LOGITECH_FF),y) 17ifeq ($(CONFIG_LOGITECH_FF),y)
21 usbhid-objs += hid-lgff.o 18 usbhid-objs += hid-lgff.o
22endif 19endif
20ifeq ($(CONFIG_PANTHERLORD_FF),y)
21 usbhid-objs += hid-plff.o
22endif
23ifeq ($(CONFIG_THRUSTMASTER_FF),y) 23ifeq ($(CONFIG_THRUSTMASTER_FF),y)
24 usbhid-objs += hid-tmff.o 24 usbhid-objs += hid-tmff.o
25endif 25endif
@@ -48,6 +48,7 @@ obj-$(CONFIG_USB_ACECAD) += acecad.o
48obj-$(CONFIG_USB_YEALINK) += yealink.o 48obj-$(CONFIG_USB_YEALINK) += yealink.o
49obj-$(CONFIG_USB_XPAD) += xpad.o 49obj-$(CONFIG_USB_XPAD) += xpad.o
50obj-$(CONFIG_USB_APPLETOUCH) += appletouch.o 50obj-$(CONFIG_USB_APPLETOUCH) += appletouch.o
51obj-$(CONFIG_USB_GTCO) += gtco.o
51 52
52ifeq ($(CONFIG_USB_DEBUG),y) 53ifeq ($(CONFIG_USB_DEBUG),y)
53EXTRA_CFLAGS += -DDEBUG 54EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/usb/input/gtco.c b/drivers/usb/input/gtco.c
new file mode 100644
index 000000000000..203cdc1bbba4
--- /dev/null
+++ b/drivers/usb/input/gtco.c
@@ -0,0 +1,1104 @@
1/* -*- linux-c -*-
2
3GTCO digitizer USB driver
4
5Use the err(), dbg() and info() macros from usb.h for system logging
6
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
67#include <linux/version.h>
68#include <linux/usb/input.h>
69
70/* Version with a Major number of 2 is for kernel inclusion only. */
71#define GTCO_VERSION "2.00.0006"
72
73
74/* MACROS */
75
76#define VENDOR_ID_GTCO 0x078C
77#define PID_400 0x400
78#define PID_401 0x401
79#define PID_1000 0x1000
80#define PID_1001 0x1001
81#define PID_1002 0x1002
82
83/* Max size of a single report */
84#define REPORT_MAX_SIZE 10
85
86
87/* Bitmask whether pen is in range */
88#define MASK_INRANGE 0x20
89#define MASK_BUTTON 0x01F
90
91#define PATHLENGTH 64
92
93/* DATA STRUCTURES */
94
95/* Device table */
96static struct usb_device_id gtco_usbid_table [] = {
97 { USB_DEVICE(VENDOR_ID_GTCO, PID_400) },
98 { USB_DEVICE(VENDOR_ID_GTCO, PID_401) },
99 { USB_DEVICE(VENDOR_ID_GTCO, PID_1000) },
100 { USB_DEVICE(VENDOR_ID_GTCO, PID_1001) },
101 { USB_DEVICE(VENDOR_ID_GTCO, PID_1002) },
102 { }
103};
104MODULE_DEVICE_TABLE (usb, gtco_usbid_table);
105
106
107/* Structure to hold all of our device specific stuff */
108struct gtco {
109
110 struct input_dev *inputdevice; /* input device struct pointer */
111 struct usb_device *usbdev; /* the usb device for this device */
112 struct urb *urbinfo; /* urb for incoming reports */
113 dma_addr_t buf_dma; /* dma addr of the data buffer*/
114 unsigned char * buffer; /* databuffer for reports */
115
116 char usbpath[PATHLENGTH];
117 int openCount;
118
119 /* Information pulled from Report Descriptor */
120 u32 usage;
121 u32 min_X;
122 u32 max_X;
123 u32 min_Y;
124 u32 max_Y;
125 s8 mintilt_X;
126 s8 maxtilt_X;
127 s8 mintilt_Y;
128 s8 maxtilt_Y;
129 u32 maxpressure;
130 u32 minpressure;
131};
132
133
134
135/* Code for parsing the HID REPORT DESCRIPTOR */
136
137/* From HID1.11 spec */
138struct hid_descriptor
139{
140 struct usb_descriptor_header header;
141 __le16 bcdHID;
142 u8 bCountryCode;
143 u8 bNumDescriptors;
144 u8 bDescriptorType;
145 __le16 wDescriptorLength;
146} __attribute__ ((packed));
147
148
149#define HID_DESCRIPTOR_SIZE 9
150#define HID_DEVICE_TYPE 33
151#define REPORT_DEVICE_TYPE 34
152
153
154#define PREF_TAG(x) ((x)>>4)
155#define PREF_TYPE(x) ((x>>2)&0x03)
156#define PREF_SIZE(x) ((x)&0x03)
157
158#define TYPE_MAIN 0
159#define TYPE_GLOBAL 1
160#define TYPE_LOCAL 2
161#define TYPE_RESERVED 3
162
163#define TAG_MAIN_INPUT 0x8
164#define TAG_MAIN_OUTPUT 0x9
165#define TAG_MAIN_FEATURE 0xB
166#define TAG_MAIN_COL_START 0xA
167#define TAG_MAIN_COL_END 0xC
168
169#define TAG_GLOB_USAGE 0
170#define TAG_GLOB_LOG_MIN 1
171#define TAG_GLOB_LOG_MAX 2
172#define TAG_GLOB_PHYS_MIN 3
173#define TAG_GLOB_PHYS_MAX 4
174#define TAG_GLOB_UNIT_EXP 5
175#define TAG_GLOB_UNIT 6
176#define TAG_GLOB_REPORT_SZ 7
177#define TAG_GLOB_REPORT_ID 8
178#define TAG_GLOB_REPORT_CNT 9
179#define TAG_GLOB_PUSH 10
180#define TAG_GLOB_POP 11
181
182#define TAG_GLOB_MAX 12
183
184#define DIGITIZER_USAGE_TIP_PRESSURE 0x30
185#define DIGITIZER_USAGE_TILT_X 0x3D
186#define DIGITIZER_USAGE_TILT_Y 0x3E
187
188
189/*
190 *
191 * This is an abbreviated parser for the HID Report Descriptor. We
192 * know what devices we are talking to, so this is by no means meant
193 * to be generic. We can make some safe assumptions:
194 *
195 * - We know there are no LONG tags, all short
196 * - We know that we have no MAIN Feature and MAIN Output items
197 * - We know what the IRQ reports are supposed to look like.
198 *
199 * The main purpose of this is to use the HID report desc to figure
200 * out the mins and maxs of the fields in the IRQ reports. The IRQ
201 * reports for 400/401 change slightly if the max X is bigger than 64K.
202 *
203 */
204static void parse_hid_report_descriptor(struct gtco *device, char * report,
205 int length)
206{
207 int x,i=0;
208
209 /* Tag primitive vars */
210 __u8 prefix;
211 __u8 size;
212 __u8 tag;
213 __u8 type;
214 __u8 data = 0;
215 __u16 data16 = 0;
216 __u32 data32 = 0;
217
218
219 /* For parsing logic */
220 int inputnum = 0;
221 __u32 usage = 0;
222
223 /* Global Values, indexed by TAG */
224 __u32 globalval[TAG_GLOB_MAX];
225 __u32 oldval[TAG_GLOB_MAX];
226
227 /* Debug stuff */
228 char maintype='x';
229 char globtype[12];
230 int indent=0;
231 char indentstr[10]="";
232
233
234
235 dbg("======>>>>>>PARSE<<<<<<======");
236
237 /* Walk this report and pull out the info we need */
238 while (i<length){
239 prefix=report[i];
240
241 /* Skip over prefix */
242 i++;
243
244 /* Determine data size and save the data in the proper variable */
245 size = PREF_SIZE(prefix);
246 switch(size){
247 case 1:
248 data = report[i];
249 break;
250 case 2:
251 data16 = le16_to_cpu(get_unaligned((__le16*)(&(report[i]))));
252 break;
253 case 3:
254 size = 4;
255 data32 = le32_to_cpu(get_unaligned((__le32*)(&(report[i]))));
256 }
257
258 /* Skip size of data */
259 i+=size;
260
261 /* What we do depends on the tag type */
262 tag = PREF_TAG(prefix);
263 type = PREF_TYPE(prefix);
264 switch(type){
265 case TYPE_MAIN:
266 strcpy(globtype,"");
267 switch(tag){
268
269 case TAG_MAIN_INPUT:
270 /*
271 * The INPUT MAIN tag signifies this is
272 * information from a report. We need to
273 * figure out what it is and store the
274 * min/max values
275 */
276
277 maintype='I';
278 if (data==2){
279 strcpy(globtype,"Variable");
280 }
281 if (data==3){
282 strcpy(globtype,"Var|Const");
283 }
284
285 dbg("::::: Saving Report: %d input #%d Max: 0x%X(%d) Min:0x%X(%d) of %d bits",
286 globalval[TAG_GLOB_REPORT_ID],inputnum,
287 globalval[TAG_GLOB_LOG_MAX],globalval[TAG_GLOB_LOG_MAX],
288 globalval[TAG_GLOB_LOG_MIN],globalval[TAG_GLOB_LOG_MIN],
289 (globalval[TAG_GLOB_REPORT_SZ] * globalval[TAG_GLOB_REPORT_CNT]));
290
291
292 /*
293 We can assume that the first two input items
294 are always the X and Y coordinates. After
295 that, we look for everything else by
296 local usage value
297 */
298 switch (inputnum){
299 case 0: /* X coord */
300 dbg("GER: X Usage: 0x%x",usage);
301 if (device->max_X == 0){
302 device->max_X = globalval[TAG_GLOB_LOG_MAX];
303 device->min_X = globalval[TAG_GLOB_LOG_MIN];
304 }
305
306 break;
307 case 1: /* Y coord */
308 dbg("GER: Y Usage: 0x%x",usage);
309 if (device->max_Y == 0){
310 device->max_Y = globalval[TAG_GLOB_LOG_MAX];
311 device->min_Y = globalval[TAG_GLOB_LOG_MIN];
312 }
313 break;
314 default:
315 /* Tilt X */
316 if (usage == DIGITIZER_USAGE_TILT_X){
317 if (device->maxtilt_X == 0){
318 device->maxtilt_X = globalval[TAG_GLOB_LOG_MAX];
319 device->mintilt_X = globalval[TAG_GLOB_LOG_MIN];
320 }
321 }
322
323 /* Tilt Y */
324 if (usage == DIGITIZER_USAGE_TILT_Y){
325 if (device->maxtilt_Y == 0){
326 device->maxtilt_Y = globalval[TAG_GLOB_LOG_MAX];
327 device->mintilt_Y = globalval[TAG_GLOB_LOG_MIN];
328 }
329 }
330
331
332 /* Pressure */
333 if (usage == DIGITIZER_USAGE_TIP_PRESSURE){
334 if (device->maxpressure == 0){
335 device->maxpressure = globalval[TAG_GLOB_LOG_MAX];
336 device->minpressure = globalval[TAG_GLOB_LOG_MIN];
337 }
338 }
339
340 break;
341 }
342
343 inputnum++;
344
345
346 break;
347 case TAG_MAIN_OUTPUT:
348 maintype='O';
349 break;
350 case TAG_MAIN_FEATURE:
351 maintype='F';
352 break;
353 case TAG_MAIN_COL_START:
354 maintype='S';
355
356 if (data==0){
357 dbg("======>>>>>> Physical");
358 strcpy(globtype,"Physical");
359 }else{
360 dbg("======>>>>>>");
361 }
362
363 /* Indent the debug output */
364 indent++;
365 for (x=0;x<indent;x++){
366 indentstr[x]='-';
367 }
368 indentstr[x]=0;
369
370 /* Save global tags */
371 for (x=0;x<TAG_GLOB_MAX;x++){
372 oldval[x] = globalval[x];
373 }
374
375 break;
376 case TAG_MAIN_COL_END:
377 dbg("<<<<<<======");
378 maintype='E';
379 indent--;
380 for (x=0;x<indent;x++){
381 indentstr[x]='-';
382 }
383 indentstr[x]=0;
384
385 /* Copy global tags back */
386 for (x=0;x<TAG_GLOB_MAX;x++){
387 globalval[x] = oldval[x];
388 }
389
390 break;
391 }
392
393 switch (size){
394 case 1:
395 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
396 indentstr,tag,maintype,size,globtype,data);
397 break;
398 case 2:
399 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
400 indentstr,tag,maintype,size,globtype, data16);
401 break;
402 case 4:
403 dbg("%sMAINTAG:(%d) %c SIZE: %d Data: %s 0x%x",
404 indentstr,tag,maintype,size,globtype,data32);
405 break;
406 }
407 break;
408 case TYPE_GLOBAL:
409 switch(tag){
410 case TAG_GLOB_USAGE:
411 /*
412 * First time we hit the global usage tag,
413 * it should tell us the type of device
414 */
415 if (device->usage == 0){
416 device->usage = data;
417 }
418 strcpy(globtype,"USAGE");
419 break;
420 case TAG_GLOB_LOG_MIN :
421 strcpy(globtype,"LOG_MIN");
422 break;
423 case TAG_GLOB_LOG_MAX :
424 strcpy(globtype,"LOG_MAX");
425 break;
426 case TAG_GLOB_PHYS_MIN :
427 strcpy(globtype,"PHYS_MIN");
428 break;
429 case TAG_GLOB_PHYS_MAX :
430 strcpy(globtype,"PHYS_MAX");
431 break;
432 case TAG_GLOB_UNIT_EXP :
433 strcpy(globtype,"EXP");
434 break;
435 case TAG_GLOB_UNIT :
436 strcpy(globtype,"UNIT");
437 break;
438 case TAG_GLOB_REPORT_SZ :
439 strcpy(globtype,"REPORT_SZ");
440 break;
441 case TAG_GLOB_REPORT_ID :
442 strcpy(globtype,"REPORT_ID");
443 /* New report, restart numbering */
444 inputnum=0;
445 break;
446 case TAG_GLOB_REPORT_CNT:
447 strcpy(globtype,"REPORT_CNT");
448 break;
449 case TAG_GLOB_PUSH :
450 strcpy(globtype,"PUSH");
451 break;
452 case TAG_GLOB_POP:
453 strcpy(globtype,"POP");
454 break;
455 }
456
457
458 /* Check to make sure we have a good tag number
459 so we don't overflow array */
460 if (tag < TAG_GLOB_MAX){
461 switch (size){
462 case 1:
463 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",indentstr,globtype,tag,size,data);
464 globalval[tag]=data;
465 break;
466 case 2:
467 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",indentstr,globtype,tag,size,data16);
468 globalval[tag]=data16;
469 break;
470 case 4:
471 dbg("%sGLOBALTAG:%s(%d) SIZE: %d Data: 0x%x",indentstr,globtype,tag,size,data32);
472 globalval[tag]=data32;
473 break;
474 }
475 }else{
476 dbg("%sGLOBALTAG: ILLEGAL TAG:%d SIZE: %d ",
477 indentstr,tag,size);
478 }
479
480
481 break;
482
483 case TYPE_LOCAL:
484 switch(tag){
485 case TAG_GLOB_USAGE:
486 strcpy(globtype,"USAGE");
487 /* Always 1 byte */
488 usage = data;
489 break;
490 case TAG_GLOB_LOG_MIN :
491 strcpy(globtype,"MIN");
492 break;
493 case TAG_GLOB_LOG_MAX :
494 strcpy(globtype,"MAX");
495 break;
496 default:
497 strcpy(globtype,"UNKNOWN");
498 }
499
500 switch (size){
501 case 1:
502 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
503 indentstr,tag,globtype,size,data);
504 break;
505 case 2:
506 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
507 indentstr,tag,globtype,size,data16);
508 break;
509 case 4:
510 dbg("%sLOCALTAG:(%d) %s SIZE: %d Data: 0x%x",
511 indentstr,tag,globtype,size,data32);
512 break;
513 }
514
515 break;
516 }
517
518 }
519
520}
521
522
523
524/* INPUT DRIVER Routines */
525
526
527/*
528 * Called when opening the input device. This will submit the URB to
529 * the usb system so we start getting reports
530 */
531static int gtco_input_open(struct input_dev *inputdev)
532{
533 struct gtco *device;
534 device = inputdev->private;
535
536 device->urbinfo->dev = device->usbdev;
537 if (usb_submit_urb(device->urbinfo, GFP_KERNEL)) {
538 return -EIO;
539 }
540 return 0;
541}
542
543/**
544 Called when closing the input device. This will unlink the URB
545*/
546static void gtco_input_close(struct input_dev *inputdev)
547{
548 struct gtco *device = inputdev->private;
549
550 usb_kill_urb(device->urbinfo);
551
552}
553
554
555/*
556 * Setup input device capabilities. Tell the input system what this
557 * device is capable of generating.
558 *
559 * This information is based on what is read from the HID report and
560 * placed in the struct gtco structure
561 *
562 */
563static void gtco_setup_caps(struct input_dev *inputdev)
564{
565 struct gtco *device = inputdev->private;
566
567
568 /* Which events */
569 inputdev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_MSC);
570
571
572 /* Misc event menu block */
573 inputdev->mscbit[0] = BIT(MSC_SCAN)|BIT(MSC_SERIAL)|BIT(MSC_RAW) ;
574
575
576 /* Absolute values based on HID report info */
577 input_set_abs_params(inputdev, ABS_X, device->min_X, device->max_X,
578 0, 0);
579 input_set_abs_params(inputdev, ABS_Y, device->min_Y, device->max_Y,
580 0, 0);
581
582 /* Proximity */
583 input_set_abs_params(inputdev, ABS_DISTANCE, 0, 1, 0, 0);
584
585 /* Tilt & pressure */
586 input_set_abs_params(inputdev, ABS_TILT_X, device->mintilt_X,
587 device->maxtilt_X, 0, 0);
588 input_set_abs_params(inputdev, ABS_TILT_Y, device->mintilt_Y,
589 device->maxtilt_Y, 0, 0);
590 input_set_abs_params(inputdev, ABS_PRESSURE, device->minpressure,
591 device->maxpressure, 0, 0);
592
593
594 /* Transducer */
595 input_set_abs_params(inputdev, ABS_MISC, 0,0xFF, 0, 0);
596
597}
598
599
600
601/* USB Routines */
602
603
604/*
605 * URB callback routine. Called when we get IRQ reports from the
606 * digitizer.
607 *
608 * This bridges the USB and input device worlds. It generates events
609 * on the input device based on the USB reports.
610 */
611static void gtco_urb_callback(struct urb *urbinfo)
612{
613
614
615 struct gtco *device = urbinfo->context;
616 struct input_dev *inputdev;
617 int rc;
618 u32 val = 0;
619 s8 valsigned = 0;
620 char le_buffer[2];
621
622 inputdev = device->inputdevice;
623
624
625 /* Was callback OK? */
626 if ((urbinfo->status == -ECONNRESET ) ||
627 (urbinfo->status == -ENOENT ) ||
628 (urbinfo->status == -ESHUTDOWN )){
629
630 /* Shutdown is occurring. Return and don't queue up any more */
631 return;
632 }
633
634 if (urbinfo->status != 0 ) {
635 /* Some unknown error. Hopefully temporary. Just go and */
636 /* requeue an URB */
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 /*
651 * Switch on the report ID
652 * Conveniently, the reports have more information, the higher
653 * the report number. We can just fall through the case
654 * statements if we start with the highest number report
655 */
656 switch(device->buffer[0]){
657 case 5:
658 /* Pressure is 9 bits */
659 val = ((u16)(device->buffer[8]) << 1);
660 val |= (u16)(device->buffer[7] >> 7);
661 input_report_abs(inputdev, ABS_PRESSURE,
662 device->buffer[8]);
663
664 /* Mask out the Y tilt value used for pressure */
665 device->buffer[7] = (u8)((device->buffer[7]) & 0x7F);
666
667
668 /* Fall thru */
669 case 4:
670 /* Tilt */
671
672 /* Sign extend these 7 bit numbers. */
673 if (device->buffer[6] & 0x40)
674 device->buffer[6] |= 0x80;
675
676 if (device->buffer[7] & 0x40)
677 device->buffer[7] |= 0x80;
678
679
680 valsigned = (device->buffer[6]);
681 input_report_abs(inputdev, ABS_TILT_X, (s32)valsigned);
682
683 valsigned = (device->buffer[7]);
684 input_report_abs(inputdev, ABS_TILT_Y, (s32)valsigned);
685
686 /* Fall thru */
687
688 case 2:
689 case 3:
690 /* Convert buttons, only 5 bits possible */
691 val = (device->buffer[5])&MASK_BUTTON;
692
693 /* We don't apply any meaning to the bitmask,
694 just report */
695 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
696
697 /* Fall thru */
698 case 1:
699
700 /* All reports have X and Y coords in the same place */
701 val = le16_to_cpu(get_unaligned((__le16 *) &(device->buffer[1])));
702 input_report_abs(inputdev, ABS_X, val);
703
704 val = le16_to_cpu(get_unaligned((__le16 *) &(device->buffer[3])));
705 input_report_abs(inputdev, ABS_Y, val);
706
707
708 /* Ditto for proximity bit */
709 if (device->buffer[5]& MASK_INRANGE){
710 val = 1;
711 }else{
712 val=0;
713 }
714 input_report_abs(inputdev, ABS_DISTANCE, val);
715
716
717 /* Report 1 is an exception to how we handle buttons */
718 /* Buttons are an index, not a bitmask */
719 if (device->buffer[0] == 1){
720
721 /* Convert buttons, 5 bit index */
722 /* Report value of index set as one,
723 the rest as 0 */
724 val = device->buffer[5]& MASK_BUTTON;
725 dbg("======>>>>>>REPORT 1: val 0x%X(%d)",
726 val,val);
727
728 /*
729 * We don't apply any meaning to the button
730 * index, just report it
731 */
732 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
733
734
735 }
736
737 break;
738 case 7:
739 /* Menu blocks */
740 input_event(inputdev, EV_MSC, MSC_SCAN,
741 device->buffer[1]);
742
743
744 break;
745
746 }
747
748
749 }
750 /* Other pid class */
751 if ((inputdev->id.product == PID_400 )||
752 (inputdev->id.product == PID_401 ))
753 {
754
755 /* Report 2 */
756 if (device->buffer[0] == 2){
757 /* Menu blocks */
758 input_event(inputdev, EV_MSC, MSC_SCAN,
759 device->buffer[1]);
760 }
761
762 /* Report 1 */
763 if (device->buffer[0] == 1){
764 char buttonbyte;
765
766
767 /* IF X max > 64K, we still a bit from the y report */
768 if (device->max_X > 0x10000){
769
770 val = (u16)(((u16)(device->buffer[2]<<8))|((u8)(device->buffer[1])));
771 val |= (u32)(((u8)device->buffer[3]&0x1)<< 16);
772
773 input_report_abs(inputdev, ABS_X, val);
774
775 le_buffer[0] = (u8)((u8)(device->buffer[3])>>1);
776 le_buffer[0] |= (u8)((device->buffer[3]&0x1)<<7);
777
778 le_buffer[1] = (u8)(device->buffer[4]>>1);
779 le_buffer[1] |= (u8)((device->buffer[5]&0x1)<<7);
780
781 val = le16_to_cpu(get_unaligned((__le16 *)(le_buffer)));
782
783 input_report_abs(inputdev, ABS_Y, val);
784
785
786 /*
787 * Shift the button byte right by one to
788 * make it look like the standard report
789 */
790 buttonbyte = (device->buffer[5])>>1;
791 }else{
792
793 val = le16_to_cpu(get_unaligned((__le16 *) (&(device->buffer[1]))));
794 input_report_abs(inputdev, ABS_X, val);
795
796 val = le16_to_cpu(get_unaligned((__le16 *) (&(device->buffer[3]))));
797 input_report_abs(inputdev, ABS_Y, val);
798
799 buttonbyte = device->buffer[5];
800
801 }
802
803
804 /* BUTTONS and PROXIMITY */
805 if (buttonbyte& MASK_INRANGE){
806 val = 1;
807 }else{
808 val=0;
809 }
810 input_report_abs(inputdev, ABS_DISTANCE, val);
811
812 /* Convert buttons, only 4 bits possible */
813 val = buttonbyte&0x0F;
814#ifdef USE_BUTTONS
815 for ( i=0;i<5;i++){
816 input_report_key(inputdev, BTN_DIGI+i,val&(1<<i));
817 }
818#else
819 /* We don't apply any meaning to the bitmask, just report */
820 input_event(inputdev, EV_MSC, MSC_SERIAL, val);
821#endif
822 /* TRANSDUCER */
823 input_report_abs(inputdev, ABS_MISC, device->buffer[6]);
824
825 }
826 }
827
828 /* Everybody gets report ID's */
829 input_event(inputdev, EV_MSC, MSC_RAW, device->buffer[0]);
830
831 /* Sync it up */
832 input_sync(inputdev);
833
834 resubmit:
835 rc = usb_submit_urb(urbinfo, GFP_ATOMIC);
836 if (rc != 0) {
837 err("usb_submit_urb failed rc=0x%x",rc);
838 }
839
840}
841
842/*
843 * The probe routine. This is called when the kernel find the matching USB
844 * vendor/product. We do the following:
845 *
846 * - Allocate mem for a local structure to manage the device
847 * - Request a HID Report Descriptor from the device and parse it to
848 * find out the device parameters
849 * - Create an input device and assign it attributes
850 * - Allocate an URB so the device can talk to us when the input
851 * queue is open
852 */
853static int gtco_probe(struct usb_interface *usbinterface,
854 const struct usb_device_id *id)
855{
856
857 struct gtco *device = NULL;
858 char path[PATHLENGTH];
859 struct input_dev *inputdev;
860 struct hid_descriptor *hid_desc;
861 char *report;
862 int result=0, retry;
863 struct usb_endpoint_descriptor *endpoint;
864
865 /* Allocate memory for device structure */
866 device = kzalloc(sizeof(struct gtco), GFP_KERNEL);
867 if (device == NULL) {
868 err("No more memory");
869 return -ENOMEM;
870 }
871
872
873 device->inputdevice = input_allocate_device();
874 if (!device->inputdevice){
875 kfree(device);
876 err("No more memory");
877 return -ENOMEM;
878 }
879
880 /* Get pointer to the input device */
881 inputdev = device->inputdevice;
882
883 /* Save interface information */
884 device->usbdev = usb_get_dev(interface_to_usbdev(usbinterface));
885
886
887 /* Allocate some data for incoming reports */
888 device->buffer = usb_buffer_alloc(device->usbdev, REPORT_MAX_SIZE,
889 GFP_KERNEL, &(device->buf_dma));
890 if (!device->buffer){
891 input_free_device(device->inputdevice);
892 kfree(device);
893 err("No more memory");
894 return -ENOMEM;
895 }
896
897 /* Allocate URB for reports */
898 device->urbinfo = usb_alloc_urb(0, GFP_KERNEL);
899 if (!device->urbinfo) {
900 usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
901 device->buffer, device->buf_dma);
902 input_free_device(device->inputdevice);
903 kfree(device);
904 err("No more memory");
905 return -ENOMEM;
906 }
907
908
909 /*
910 * The endpoint is always altsetting 0, we know this since we know
911 * this device only has one interrupt endpoint
912 */
913 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
914
915 /* Some debug */
916 dbg("gtco # interfaces: %d",usbinterface->num_altsetting);
917 dbg("num endpoints: %d",usbinterface->cur_altsetting->desc.bNumEndpoints);
918 dbg("interface class: %d",usbinterface->cur_altsetting->desc.bInterfaceClass);
919 dbg("endpoint: attribute:0x%x type:0x%x",endpoint->bmAttributes,endpoint->bDescriptorType);
920 if ((endpoint->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) == USB_ENDPOINT_XFER_INT)
921 dbg("endpoint: we have interrupt endpoint\n");
922
923 dbg("endpoint extra len:%d ",usbinterface->altsetting[0].extralen);
924
925
926
927 /*
928 * Find the HID descriptor so we can find out the size of the
929 * HID report descriptor
930 */
931 if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
932 HID_DEVICE_TYPE,&hid_desc) != 0){
933 err("Can't retrieve exta USB descriptor to get hid report descriptor length");
934 usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
935 device->buffer, device->buf_dma);
936 input_free_device(device->inputdevice);
937 kfree(device);
938 return -EIO;
939 }
940
941 dbg("Extra descriptor success: type:%d len:%d",
942 hid_desc->bDescriptorType, hid_desc->wDescriptorLength);
943
944 if (!(report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL))) {
945 usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
946 device->buffer, device->buf_dma);
947
948 input_free_device(device->inputdevice);
949 kfree(device);
950 err("No more memory");
951 return -ENOMEM;
952 }
953
954 /* Couple of tries to get reply */
955 for (retry=0;retry<3;retry++) {
956 result = usb_control_msg(device->usbdev,
957 usb_rcvctrlpipe(device->usbdev, 0),
958 USB_REQ_GET_DESCRIPTOR,
959 USB_RECIP_INTERFACE | USB_DIR_IN,
960 (REPORT_DEVICE_TYPE << 8),
961 0, /* interface */
962 report,
963 hid_desc->wDescriptorLength,
964 5000); /* 5 secs */
965
966 if (result == hid_desc->wDescriptorLength)
967 break;
968 }
969
970 /* If we didn't get the report, fail */
971 dbg("usb_control_msg result: :%d", result);
972 if (result != hid_desc->wDescriptorLength){
973 kfree(report);
974 usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
975 device->buffer, device->buf_dma);
976 input_free_device(device->inputdevice);
977 kfree(device);
978 err("Failed to get HID Report Descriptor of size: %d",
979 hid_desc->wDescriptorLength);
980 return -EIO;
981 }
982
983
984 /* Now we parse the report */
985 parse_hid_report_descriptor(device,report,result);
986
987 /* Now we delete it */
988 kfree(report);
989
990 /* Create a device file node */
991 usb_make_path(device->usbdev, path, PATHLENGTH);
992 sprintf(device->usbpath, "%s/input0", path);
993
994
995 /* Set Input device functions */
996 inputdev->open = gtco_input_open;
997 inputdev->close = gtco_input_close;
998
999 /* Set input device information */
1000 inputdev->name = "GTCO_CalComp";
1001 inputdev->phys = device->usbpath;
1002 inputdev->private = device;
1003
1004
1005 /* Now set up all the input device capabilities */
1006 gtco_setup_caps(inputdev);
1007
1008 /* Set input device required ID information */
1009 usb_to_input_id(device->usbdev, &device->inputdevice->id);
1010 inputdev->cdev.dev = &usbinterface->dev;
1011
1012 /* Setup the URB, it will be posted later on open of input device */
1013 endpoint = &usbinterface->altsetting[0].endpoint[0].desc;
1014
1015 usb_fill_int_urb(device->urbinfo,
1016 device->usbdev,
1017 usb_rcvintpipe(device->usbdev,
1018 endpoint->bEndpointAddress),
1019 device->buffer,
1020 REPORT_MAX_SIZE,
1021 gtco_urb_callback,
1022 device,
1023 endpoint->bInterval);
1024
1025 device->urbinfo->transfer_dma = device->buf_dma;
1026 device->urbinfo->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
1027
1028
1029 /* Save device pointer in USB interface device */
1030 usb_set_intfdata(usbinterface, device);
1031
1032 /* All done, now register the input device */
1033 input_register_device(inputdev);
1034
1035 info( "gtco driver created usb: %s\n", path);
1036 return 0;
1037
1038}
1039
1040/*
1041 * This function is a standard USB function called when the USB device
1042 * is disconnected. We will get rid of the URV, de-register the input
1043 * device, and free up allocated memory
1044 */
1045static void gtco_disconnect(struct usb_interface *interface)
1046{
1047
1048 /* Grab private device ptr */
1049 struct gtco *device = usb_get_intfdata (interface);
1050 struct input_dev *inputdev;
1051
1052 inputdev = device->inputdevice;
1053
1054 /* Now reverse all the registration stuff */
1055 if (device) {
1056 input_unregister_device(inputdev);
1057 usb_kill_urb(device->urbinfo);
1058 usb_free_urb(device->urbinfo);
1059 usb_buffer_free(device->usbdev, REPORT_MAX_SIZE,
1060 device->buffer, device->buf_dma);
1061 kfree(device);
1062 }
1063
1064 info("gtco driver disconnected");
1065}
1066
1067
1068/* STANDARD MODULE LOAD ROUTINES */
1069
1070static struct usb_driver gtco_driverinfo_table = {
1071#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,16))
1072 .owner = THIS_MODULE,
1073#endif
1074 .name = "gtco",
1075 .id_table = gtco_usbid_table,
1076 .probe = gtco_probe,
1077 .disconnect = gtco_disconnect,
1078};
1079/*
1080 * Register this module with the USB subsystem
1081 */
1082static int __init gtco_init(void)
1083{
1084 int rc;
1085 rc = usb_register(&gtco_driverinfo_table);
1086 if (rc) {
1087 err("usb_register() failed rc=0x%x", rc);
1088 }
1089 printk("GTCO usb driver version: %s",GTCO_VERSION);
1090 return rc;
1091}
1092
1093/*
1094 * Deregister this module with the USB subsystem
1095 */
1096static void __exit gtco_exit(void)
1097{
1098 usb_deregister(&gtco_driverinfo_table);
1099}
1100
1101module_init (gtco_init);
1102module_exit (gtco_exit);
1103
1104MODULE_LICENSE("GPL");
diff --git a/drivers/usb/input/hid-core.c b/drivers/usb/input/hid-core.c
index 0811c39bd14f..84983d1b7164 100644
--- a/drivers/usb/input/hid-core.c
+++ b/drivers/usb/input/hid-core.c
@@ -4,6 +4,7 @@
4 * Copyright (c) 1999 Andreas Gal 4 * Copyright (c) 1999 Andreas Gal
5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz> 5 * Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc 6 * Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
7 * Copyright (c) 2006 Jiri Kosina
7 */ 8 */
8 9
9/* 10/*
@@ -32,8 +33,10 @@
32 33
33#include <linux/usb.h> 34#include <linux/usb.h>
34 35
35#include "hid.h" 36#include <linux/hid.h>
36#include <linux/hiddev.h> 37#include <linux/hiddev.h>
38#include <linux/hid-debug.h>
39#include "usbhid.h"
37 40
38/* 41/*
39 * Version Information 42 * Version Information
@@ -55,887 +58,6 @@ module_param_named(mousepoll, hid_mousepoll_interval, uint, 0644);
55MODULE_PARM_DESC(mousepoll, "Polling interval of mice"); 58MODULE_PARM_DESC(mousepoll, "Polling interval of mice");
56 59
57/* 60/*
58 * Register a new report for a device.
59 */
60
61static struct hid_report *hid_register_report(struct hid_device *device, unsigned type, unsigned id)
62{
63 struct hid_report_enum *report_enum = device->report_enum + type;
64 struct hid_report *report;
65
66 if (report_enum->report_id_hash[id])
67 return report_enum->report_id_hash[id];
68
69 if (!(report = kzalloc(sizeof(struct hid_report), GFP_KERNEL)))
70 return NULL;
71
72 if (id != 0)
73 report_enum->numbered = 1;
74
75 report->id = id;
76 report->type = type;
77 report->size = 0;
78 report->device = device;
79 report_enum->report_id_hash[id] = report;
80
81 list_add_tail(&report->list, &report_enum->report_list);
82
83 return report;
84}
85
86/*
87 * Register a new field for this report.
88 */
89
90static struct hid_field *hid_register_field(struct hid_report *report, unsigned usages, unsigned values)
91{
92 struct hid_field *field;
93
94 if (report->maxfield == HID_MAX_FIELDS) {
95 dbg("too many fields in report");
96 return NULL;
97 }
98
99 if (!(field = kzalloc(sizeof(struct hid_field) + usages * sizeof(struct hid_usage)
100 + values * sizeof(unsigned), GFP_KERNEL))) return NULL;
101
102 field->index = report->maxfield++;
103 report->field[field->index] = field;
104 field->usage = (struct hid_usage *)(field + 1);
105 field->value = (unsigned *)(field->usage + usages);
106 field->report = report;
107
108 return field;
109}
110
111/*
112 * Open a collection. The type/usage is pushed on the stack.
113 */
114
115static int open_collection(struct hid_parser *parser, unsigned type)
116{
117 struct hid_collection *collection;
118 unsigned usage;
119
120 usage = parser->local.usage[0];
121
122 if (parser->collection_stack_ptr == HID_COLLECTION_STACK_SIZE) {
123 dbg("collection stack overflow");
124 return -1;
125 }
126
127 if (parser->device->maxcollection == parser->device->collection_size) {
128 collection = kmalloc(sizeof(struct hid_collection) *
129 parser->device->collection_size * 2, GFP_KERNEL);
130 if (collection == NULL) {
131 dbg("failed to reallocate collection array");
132 return -1;
133 }
134 memcpy(collection, parser->device->collection,
135 sizeof(struct hid_collection) *
136 parser->device->collection_size);
137 memset(collection + parser->device->collection_size, 0,
138 sizeof(struct hid_collection) *
139 parser->device->collection_size);
140 kfree(parser->device->collection);
141 parser->device->collection = collection;
142 parser->device->collection_size *= 2;
143 }
144
145 parser->collection_stack[parser->collection_stack_ptr++] =
146 parser->device->maxcollection;
147
148 collection = parser->device->collection +
149 parser->device->maxcollection++;
150 collection->type = type;
151 collection->usage = usage;
152 collection->level = parser->collection_stack_ptr - 1;
153
154 if (type == HID_COLLECTION_APPLICATION)
155 parser->device->maxapplication++;
156
157 return 0;
158}
159
160/*
161 * Close a collection.
162 */
163
164static int close_collection(struct hid_parser *parser)
165{
166 if (!parser->collection_stack_ptr) {
167 dbg("collection stack underflow");
168 return -1;
169 }
170 parser->collection_stack_ptr--;
171 return 0;
172}
173
174/*
175 * Climb up the stack, search for the specified collection type
176 * and return the usage.
177 */
178
179static unsigned hid_lookup_collection(struct hid_parser *parser, unsigned type)
180{
181 int n;
182 for (n = parser->collection_stack_ptr - 1; n >= 0; n--)
183 if (parser->device->collection[parser->collection_stack[n]].type == type)
184 return parser->device->collection[parser->collection_stack[n]].usage;
185 return 0; /* we know nothing about this usage type */
186}
187
188/*
189 * Add a usage to the temporary parser table.
190 */
191
192static int hid_add_usage(struct hid_parser *parser, unsigned usage)
193{
194 if (parser->local.usage_index >= HID_MAX_USAGES) {
195 dbg("usage index exceeded");
196 return -1;
197 }
198 parser->local.usage[parser->local.usage_index] = usage;
199 parser->local.collection_index[parser->local.usage_index] =
200 parser->collection_stack_ptr ?
201 parser->collection_stack[parser->collection_stack_ptr - 1] : 0;
202 parser->local.usage_index++;
203 return 0;
204}
205
206/*
207 * Register a new field for this report.
208 */
209
210static int hid_add_field(struct hid_parser *parser, unsigned report_type, unsigned flags)
211{
212 struct hid_report *report;
213 struct hid_field *field;
214 int usages;
215 unsigned offset;
216 int i;
217
218 if (!(report = hid_register_report(parser->device, report_type, parser->global.report_id))) {
219 dbg("hid_register_report failed");
220 return -1;
221 }
222
223 if (parser->global.logical_maximum < parser->global.logical_minimum) {
224 dbg("logical range invalid %d %d", parser->global.logical_minimum, parser->global.logical_maximum);
225 return -1;
226 }
227
228 offset = report->size;
229 report->size += parser->global.report_size * parser->global.report_count;
230
231 if (!parser->local.usage_index) /* Ignore padding fields */
232 return 0;
233
234 usages = max_t(int, parser->local.usage_index, parser->global.report_count);
235
236 if ((field = hid_register_field(report, usages, parser->global.report_count)) == NULL)
237 return 0;
238
239 field->physical = hid_lookup_collection(parser, HID_COLLECTION_PHYSICAL);
240 field->logical = hid_lookup_collection(parser, HID_COLLECTION_LOGICAL);
241 field->application = hid_lookup_collection(parser, HID_COLLECTION_APPLICATION);
242
243 for (i = 0; i < usages; i++) {
244 int j = i;
245 /* Duplicate the last usage we parsed if we have excess values */
246 if (i >= parser->local.usage_index)
247 j = parser->local.usage_index - 1;
248 field->usage[i].hid = parser->local.usage[j];
249 field->usage[i].collection_index =
250 parser->local.collection_index[j];
251 }
252
253 field->maxusage = usages;
254 field->flags = flags;
255 field->report_offset = offset;
256 field->report_type = report_type;
257 field->report_size = parser->global.report_size;
258 field->report_count = parser->global.report_count;
259 field->logical_minimum = parser->global.logical_minimum;
260 field->logical_maximum = parser->global.logical_maximum;
261 field->physical_minimum = parser->global.physical_minimum;
262 field->physical_maximum = parser->global.physical_maximum;
263 field->unit_exponent = parser->global.unit_exponent;
264 field->unit = parser->global.unit;
265
266 return 0;
267}
268
269/*
270 * Read data value from item.
271 */
272
273static u32 item_udata(struct hid_item *item)
274{
275 switch (item->size) {
276 case 1: return item->data.u8;
277 case 2: return item->data.u16;
278 case 4: return item->data.u32;
279 }
280 return 0;
281}
282
283static s32 item_sdata(struct hid_item *item)
284{
285 switch (item->size) {
286 case 1: return item->data.s8;
287 case 2: return item->data.s16;
288 case 4: return item->data.s32;
289 }
290 return 0;
291}
292
293/*
294 * Process a global item.
295 */
296
297static int hid_parser_global(struct hid_parser *parser, struct hid_item *item)
298{
299 switch (item->tag) {
300
301 case HID_GLOBAL_ITEM_TAG_PUSH:
302
303 if (parser->global_stack_ptr == HID_GLOBAL_STACK_SIZE) {
304 dbg("global enviroment stack overflow");
305 return -1;
306 }
307
308 memcpy(parser->global_stack + parser->global_stack_ptr++,
309 &parser->global, sizeof(struct hid_global));
310 return 0;
311
312 case HID_GLOBAL_ITEM_TAG_POP:
313
314 if (!parser->global_stack_ptr) {
315 dbg("global enviroment stack underflow");
316 return -1;
317 }
318
319 memcpy(&parser->global, parser->global_stack + --parser->global_stack_ptr,
320 sizeof(struct hid_global));
321 return 0;
322
323 case HID_GLOBAL_ITEM_TAG_USAGE_PAGE:
324 parser->global.usage_page = item_udata(item);
325 return 0;
326
327 case HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM:
328 parser->global.logical_minimum = item_sdata(item);
329 return 0;
330
331 case HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM:
332 if (parser->global.logical_minimum < 0)
333 parser->global.logical_maximum = item_sdata(item);
334 else
335 parser->global.logical_maximum = item_udata(item);
336 return 0;
337
338 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM:
339 parser->global.physical_minimum = item_sdata(item);
340 return 0;
341
342 case HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM:
343 if (parser->global.physical_minimum < 0)
344 parser->global.physical_maximum = item_sdata(item);
345 else
346 parser->global.physical_maximum = item_udata(item);
347 return 0;
348
349 case HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT:
350 parser->global.unit_exponent = item_sdata(item);
351 return 0;
352
353 case HID_GLOBAL_ITEM_TAG_UNIT:
354 parser->global.unit = item_udata(item);
355 return 0;
356
357 case HID_GLOBAL_ITEM_TAG_REPORT_SIZE:
358 if ((parser->global.report_size = item_udata(item)) > 32) {
359 dbg("invalid report_size %d", parser->global.report_size);
360 return -1;
361 }
362 return 0;
363
364 case HID_GLOBAL_ITEM_TAG_REPORT_COUNT:
365 if ((parser->global.report_count = item_udata(item)) > HID_MAX_USAGES) {
366 dbg("invalid report_count %d", parser->global.report_count);
367 return -1;
368 }
369 return 0;
370
371 case HID_GLOBAL_ITEM_TAG_REPORT_ID:
372 if ((parser->global.report_id = item_udata(item)) == 0) {
373 dbg("report_id 0 is invalid");
374 return -1;
375 }
376 return 0;
377
378 default:
379 dbg("unknown global tag 0x%x", item->tag);
380 return -1;
381 }
382}
383
384/*
385 * Process a local item.
386 */
387
388static int hid_parser_local(struct hid_parser *parser, struct hid_item *item)
389{
390 __u32 data;
391 unsigned n;
392
393 if (item->size == 0) {
394 dbg("item data expected for local item");
395 return -1;
396 }
397
398 data = item_udata(item);
399
400 switch (item->tag) {
401
402 case HID_LOCAL_ITEM_TAG_DELIMITER:
403
404 if (data) {
405 /*
406 * We treat items before the first delimiter
407 * as global to all usage sets (branch 0).
408 * In the moment we process only these global
409 * items and the first delimiter set.
410 */
411 if (parser->local.delimiter_depth != 0) {
412 dbg("nested delimiters");
413 return -1;
414 }
415 parser->local.delimiter_depth++;
416 parser->local.delimiter_branch++;
417 } else {
418 if (parser->local.delimiter_depth < 1) {
419 dbg("bogus close delimiter");
420 return -1;
421 }
422 parser->local.delimiter_depth--;
423 }
424 return 1;
425
426 case HID_LOCAL_ITEM_TAG_USAGE:
427
428 if (parser->local.delimiter_branch > 1) {
429 dbg("alternative usage ignored");
430 return 0;
431 }
432
433 if (item->size <= 2)
434 data = (parser->global.usage_page << 16) + data;
435
436 return hid_add_usage(parser, data);
437
438 case HID_LOCAL_ITEM_TAG_USAGE_MINIMUM:
439
440 if (parser->local.delimiter_branch > 1) {
441 dbg("alternative usage ignored");
442 return 0;
443 }
444
445 if (item->size <= 2)
446 data = (parser->global.usage_page << 16) + data;
447
448 parser->local.usage_minimum = data;
449 return 0;
450
451 case HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM:
452
453 if (parser->local.delimiter_branch > 1) {
454 dbg("alternative usage ignored");
455 return 0;
456 }
457
458 if (item->size <= 2)
459 data = (parser->global.usage_page << 16) + data;
460
461 for (n = parser->local.usage_minimum; n <= data; n++)
462 if (hid_add_usage(parser, n)) {
463 dbg("hid_add_usage failed\n");
464 return -1;
465 }
466 return 0;
467
468 default:
469
470 dbg("unknown local item tag 0x%x", item->tag);
471 return 0;
472 }
473 return 0;
474}
475
476/*
477 * Process a main item.
478 */
479
480static int hid_parser_main(struct hid_parser *parser, struct hid_item *item)
481{
482 __u32 data;
483 int ret;
484
485 data = item_udata(item);
486
487 switch (item->tag) {
488 case HID_MAIN_ITEM_TAG_BEGIN_COLLECTION:
489 ret = open_collection(parser, data & 0xff);
490 break;
491 case HID_MAIN_ITEM_TAG_END_COLLECTION:
492 ret = close_collection(parser);
493 break;
494 case HID_MAIN_ITEM_TAG_INPUT:
495 ret = hid_add_field(parser, HID_INPUT_REPORT, data);
496 break;
497 case HID_MAIN_ITEM_TAG_OUTPUT:
498 ret = hid_add_field(parser, HID_OUTPUT_REPORT, data);
499 break;
500 case HID_MAIN_ITEM_TAG_FEATURE:
501 ret = hid_add_field(parser, HID_FEATURE_REPORT, data);
502 break;
503 default:
504 dbg("unknown main item tag 0x%x", item->tag);
505 ret = 0;
506 }
507
508 memset(&parser->local, 0, sizeof(parser->local)); /* Reset the local parser environment */
509
510 return ret;
511}
512
513/*
514 * Process a reserved item.
515 */
516
517static int hid_parser_reserved(struct hid_parser *parser, struct hid_item *item)
518{
519 dbg("reserved item type, tag 0x%x", item->tag);
520 return 0;
521}
522
523/*
524 * Free a report and all registered fields. The field->usage and
525 * field->value table's are allocated behind the field, so we need
526 * only to free(field) itself.
527 */
528
529static void hid_free_report(struct hid_report *report)
530{
531 unsigned n;
532
533 for (n = 0; n < report->maxfield; n++)
534 kfree(report->field[n]);
535 kfree(report);
536}
537
538/*
539 * Free a device structure, all reports, and all fields.
540 */
541
542static void hid_free_device(struct hid_device *device)
543{
544 unsigned i,j;
545
546 for (i = 0; i < HID_REPORT_TYPES; i++) {
547 struct hid_report_enum *report_enum = device->report_enum + i;
548
549 for (j = 0; j < 256; j++) {
550 struct hid_report *report = report_enum->report_id_hash[j];
551 if (report)
552 hid_free_report(report);
553 }
554 }
555
556 kfree(device->rdesc);
557 kfree(device);
558}
559
560/*
561 * Fetch a report description item from the data stream. We support long
562 * items, though they are not used yet.
563 */
564
565static u8 *fetch_item(__u8 *start, __u8 *end, struct hid_item *item)
566{
567 u8 b;
568
569 if ((end - start) <= 0)
570 return NULL;
571
572 b = *start++;
573
574 item->type = (b >> 2) & 3;
575 item->tag = (b >> 4) & 15;
576
577 if (item->tag == HID_ITEM_TAG_LONG) {
578
579 item->format = HID_ITEM_FORMAT_LONG;
580
581 if ((end - start) < 2)
582 return NULL;
583
584 item->size = *start++;
585 item->tag = *start++;
586
587 if ((end - start) < item->size)
588 return NULL;
589
590 item->data.longdata = start;
591 start += item->size;
592 return start;
593 }
594
595 item->format = HID_ITEM_FORMAT_SHORT;
596 item->size = b & 3;
597
598 switch (item->size) {
599
600 case 0:
601 return start;
602
603 case 1:
604 if ((end - start) < 1)
605 return NULL;
606 item->data.u8 = *start++;
607 return start;
608
609 case 2:
610 if ((end - start) < 2)
611 return NULL;
612 item->data.u16 = le16_to_cpu(get_unaligned((__le16*)start));
613 start = (__u8 *)((__le16 *)start + 1);
614 return start;
615
616 case 3:
617 item->size++;
618 if ((end - start) < 4)
619 return NULL;
620 item->data.u32 = le32_to_cpu(get_unaligned((__le32*)start));
621 start = (__u8 *)((__le32 *)start + 1);
622 return start;
623 }
624
625 return NULL;
626}
627
628/*
629 * Parse a report description into a hid_device structure. Reports are
630 * enumerated, fields are attached to these reports.
631 */
632
633static struct hid_device *hid_parse_report(__u8 *start, unsigned size)
634{
635 struct hid_device *device;
636 struct hid_parser *parser;
637 struct hid_item item;
638 __u8 *end;
639 unsigned i;
640 static int (*dispatch_type[])(struct hid_parser *parser,
641 struct hid_item *item) = {
642 hid_parser_main,
643 hid_parser_global,
644 hid_parser_local,
645 hid_parser_reserved
646 };
647
648 if (!(device = kzalloc(sizeof(struct hid_device), GFP_KERNEL)))
649 return NULL;
650
651 if (!(device->collection = kzalloc(sizeof(struct hid_collection) *
652 HID_DEFAULT_NUM_COLLECTIONS, GFP_KERNEL))) {
653 kfree(device);
654 return NULL;
655 }
656 device->collection_size = HID_DEFAULT_NUM_COLLECTIONS;
657
658 for (i = 0; i < HID_REPORT_TYPES; i++)
659 INIT_LIST_HEAD(&device->report_enum[i].report_list);
660
661 if (!(device->rdesc = (__u8 *)kmalloc(size, GFP_KERNEL))) {
662 kfree(device->collection);
663 kfree(device);
664 return NULL;
665 }
666 memcpy(device->rdesc, start, size);
667 device->rsize = size;
668
669 if (!(parser = kzalloc(sizeof(struct hid_parser), GFP_KERNEL))) {
670 kfree(device->rdesc);
671 kfree(device->collection);
672 kfree(device);
673 return NULL;
674 }
675 parser->device = device;
676
677 end = start + size;
678 while ((start = fetch_item(start, end, &item)) != NULL) {
679
680 if (item.format != HID_ITEM_FORMAT_SHORT) {
681 dbg("unexpected long global item");
682 kfree(device->collection);
683 hid_free_device(device);
684 kfree(parser);
685 return NULL;
686 }
687
688 if (dispatch_type[item.type](parser, &item)) {
689 dbg("item %u %u %u %u parsing failed\n",
690 item.format, (unsigned)item.size, (unsigned)item.type, (unsigned)item.tag);
691 kfree(device->collection);
692 hid_free_device(device);
693 kfree(parser);
694 return NULL;
695 }
696
697 if (start == end) {
698 if (parser->collection_stack_ptr) {
699 dbg("unbalanced collection at end of report description");
700 kfree(device->collection);
701 hid_free_device(device);
702 kfree(parser);
703 return NULL;
704 }
705 if (parser->local.delimiter_depth) {
706 dbg("unbalanced delimiter at end of report description");
707 kfree(device->collection);
708 hid_free_device(device);
709 kfree(parser);
710 return NULL;
711 }
712 kfree(parser);
713 return device;
714 }
715 }
716
717 dbg("item fetching failed at offset %d\n", (int)(end - start));
718 kfree(device->collection);
719 hid_free_device(device);
720 kfree(parser);
721 return NULL;
722}
723
724/*
725 * Convert a signed n-bit integer to signed 32-bit integer. Common
726 * cases are done through the compiler, the screwed things has to be
727 * done by hand.
728 */
729
730static s32 snto32(__u32 value, unsigned n)
731{
732 switch (n) {
733 case 8: return ((__s8)value);
734 case 16: return ((__s16)value);
735 case 32: return ((__s32)value);
736 }
737 return value & (1 << (n - 1)) ? value | (-1 << n) : value;
738}
739
740/*
741 * Convert a signed 32-bit integer to a signed n-bit integer.
742 */
743
744static u32 s32ton(__s32 value, unsigned n)
745{
746 s32 a = value >> (n - 1);
747 if (a && a != -1)
748 return value < 0 ? 1 << (n - 1) : (1 << (n - 1)) - 1;
749 return value & ((1 << n) - 1);
750}
751
752/*
753 * Extract/implement a data field from/to a little endian report (bit array).
754 *
755 * Code sort-of follows HID spec:
756 * http://www.usb.org/developers/devclass_docs/HID1_11.pdf
757 *
758 * While the USB HID spec allows unlimited length bit fields in "report
759 * descriptors", most devices never use more than 16 bits.
760 * One model of UPS is claimed to report "LINEV" as a 32-bit field.
761 * Search linux-kernel and linux-usb-devel archives for "hid-core extract".
762 */
763
764static __inline__ __u32 extract(__u8 *report, unsigned offset, unsigned n)
765{
766 u64 x;
767
768 WARN_ON(n > 32);
769
770 report += offset >> 3; /* adjust byte index */
771 offset &= 7; /* now only need bit offset into one byte */
772 x = get_unaligned((u64 *) report);
773 x = le64_to_cpu(x);
774 x = (x >> offset) & ((1ULL << n) - 1); /* extract bit field */
775 return (u32) x;
776}
777
778/*
779 * "implement" : set bits in a little endian bit stream.
780 * Same concepts as "extract" (see comments above).
781 * The data mangled in the bit stream remains in little endian
782 * order the whole time. It make more sense to talk about
783 * endianness of register values by considering a register
784 * a "cached" copy of the little endiad bit stream.
785 */
786static __inline__ void implement(__u8 *report, unsigned offset, unsigned n, __u32 value)
787{
788 u64 x;
789 u64 m = (1ULL << n) - 1;
790
791 WARN_ON(n > 32);
792
793 WARN_ON(value > m);
794 value &= m;
795
796 report += offset >> 3;
797 offset &= 7;
798
799 x = get_unaligned((u64 *)report);
800 x &= cpu_to_le64(~(m << offset));
801 x |= cpu_to_le64(((u64) value) << offset);
802 put_unaligned(x, (u64 *) report);
803}
804
805/*
806 * Search an array for a value.
807 */
808
809static __inline__ int search(__s32 *array, __s32 value, unsigned n)
810{
811 while (n--) {
812 if (*array++ == value)
813 return 0;
814 }
815 return -1;
816}
817
818static void hid_process_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value, int interrupt)
819{
820 hid_dump_input(usage, value);
821 if (hid->claimed & HID_CLAIMED_INPUT)
822 hidinput_hid_event(hid, field, usage, value);
823 if (hid->claimed & HID_CLAIMED_HIDDEV && interrupt)
824 hiddev_hid_event(hid, field, usage, value);
825}
826
827/*
828 * Analyse a received field, and fetch the data from it. The field
829 * content is stored for next report processing (we do differential
830 * reporting to the layer).
831 */
832
833static void hid_input_field(struct hid_device *hid, struct hid_field *field, __u8 *data, int interrupt)
834{
835 unsigned n;
836 unsigned count = field->report_count;
837 unsigned offset = field->report_offset;
838 unsigned size = field->report_size;
839 __s32 min = field->logical_minimum;
840 __s32 max = field->logical_maximum;
841 __s32 *value;
842
843 if (!(value = kmalloc(sizeof(__s32) * count, GFP_ATOMIC)))
844 return;
845
846 for (n = 0; n < count; n++) {
847
848 value[n] = min < 0 ? snto32(extract(data, offset + n * size, size), size) :
849 extract(data, offset + n * size, size);
850
851 if (!(field->flags & HID_MAIN_ITEM_VARIABLE) /* Ignore report if ErrorRollOver */
852 && value[n] >= min && value[n] <= max
853 && field->usage[value[n] - min].hid == HID_UP_KEYBOARD + 1)
854 goto exit;
855 }
856
857 for (n = 0; n < count; n++) {
858
859 if (HID_MAIN_ITEM_VARIABLE & field->flags) {
860 hid_process_event(hid, field, &field->usage[n], value[n], interrupt);
861 continue;
862 }
863
864 if (field->value[n] >= min && field->value[n] <= max
865 && field->usage[field->value[n] - min].hid
866 && search(value, field->value[n], count))
867 hid_process_event(hid, field, &field->usage[field->value[n] - min], 0, interrupt);
868
869 if (value[n] >= min && value[n] <= max
870 && field->usage[value[n] - min].hid
871 && search(field->value, value[n], count))
872 hid_process_event(hid, field, &field->usage[value[n] - min], 1, interrupt);
873 }
874
875 memcpy(field->value, value, count * sizeof(__s32));
876exit:
877 kfree(value);
878}
879
880static int hid_input_report(int type, struct urb *urb, int interrupt)
881{
882 struct hid_device *hid = urb->context;
883 struct hid_report_enum *report_enum = hid->report_enum + type;
884 u8 *data = urb->transfer_buffer;
885 int len = urb->actual_length;
886 struct hid_report *report;
887 int n, size;
888
889 if (!len) {
890 dbg("empty report");
891 return -1;
892 }
893
894#ifdef DEBUG_DATA
895 printk(KERN_DEBUG __FILE__ ": report (size %u) (%snumbered)\n", len, report_enum->numbered ? "" : "un");
896#endif
897
898 n = 0; /* Normally report number is 0 */
899 if (report_enum->numbered) { /* Device uses numbered reports, data[0] is report number */
900 n = *data++;
901 len--;
902 }
903
904#ifdef DEBUG_DATA
905 {
906 int i;
907 printk(KERN_DEBUG __FILE__ ": report %d (size %u) = ", n, len);
908 for (i = 0; i < len; i++)
909 printk(" %02x", data[i]);
910 printk("\n");
911 }
912#endif
913
914 if (!(report = report_enum->report_id_hash[n])) {
915 dbg("undefined report_id %d received", n);
916 return -1;
917 }
918
919 size = ((report->size - 1) >> 3) + 1;
920
921 if (len < size) {
922 dbg("report %d is too short, (%d < %d)", report->id, len, size);
923 memset(data + len, 0, size - len);
924 }
925
926 if (hid->claimed & HID_CLAIMED_HIDDEV)
927 hiddev_report_event(hid, report);
928
929 for (n = 0; n < report->maxfield; n++)
930 hid_input_field(hid, report->field[n], data, interrupt);
931
932 if (hid->claimed & HID_CLAIMED_INPUT)
933 hidinput_report_event(hid, report);
934
935 return 0;
936}
937
938/*
939 * Input submission and I/O error handler. 61 * Input submission and I/O error handler.
940 */ 62 */
941 63
@@ -946,15 +68,16 @@ static int hid_start_in(struct hid_device *hid)
946{ 68{
947 unsigned long flags; 69 unsigned long flags;
948 int rc = 0; 70 int rc = 0;
71 struct usbhid_device *usbhid = hid->driver_data;
949 72
950 spin_lock_irqsave(&hid->inlock, flags); 73 spin_lock_irqsave(&usbhid->inlock, flags);
951 if (hid->open > 0 && !test_bit(HID_SUSPENDED, &hid->iofl) && 74 if (hid->open > 0 && !test_bit(HID_SUSPENDED, &usbhid->iofl) &&
952 !test_and_set_bit(HID_IN_RUNNING, &hid->iofl)) { 75 !test_and_set_bit(HID_IN_RUNNING, &usbhid->iofl)) {
953 rc = usb_submit_urb(hid->urbin, GFP_ATOMIC); 76 rc = usb_submit_urb(usbhid->urbin, GFP_ATOMIC);
954 if (rc != 0) 77 if (rc != 0)
955 clear_bit(HID_IN_RUNNING, &hid->iofl); 78 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
956 } 79 }
957 spin_unlock_irqrestore(&hid->inlock, flags); 80 spin_unlock_irqrestore(&usbhid->inlock, flags);
958 return rc; 81 return rc;
959} 82}
960 83
@@ -962,8 +85,9 @@ static int hid_start_in(struct hid_device *hid)
962static void hid_retry_timeout(unsigned long _hid) 85static void hid_retry_timeout(unsigned long _hid)
963{ 86{
964 struct hid_device *hid = (struct hid_device *) _hid; 87 struct hid_device *hid = (struct hid_device *) _hid;
88 struct usbhid_device *usbhid = hid->driver_data;
965 89
966 dev_dbg(&hid->intf->dev, "retrying intr urb\n"); 90 dev_dbg(&usbhid->intf->dev, "retrying intr urb\n");
967 if (hid_start_in(hid)) 91 if (hid_start_in(hid))
968 hid_io_error(hid); 92 hid_io_error(hid);
969} 93}
@@ -971,38 +95,39 @@ static void hid_retry_timeout(unsigned long _hid)
971/* Workqueue routine to reset the device or clear a halt */ 95/* Workqueue routine to reset the device or clear a halt */
972static void hid_reset(struct work_struct *work) 96static void hid_reset(struct work_struct *work)
973{ 97{
974 struct hid_device *hid = 98 struct usbhid_device *usbhid =
975 container_of(work, struct hid_device, reset_work); 99 container_of(work, struct usbhid_device, reset_work);
100 struct hid_device *hid = usbhid->hid;
976 int rc_lock, rc = 0; 101 int rc_lock, rc = 0;
977 102
978 if (test_bit(HID_CLEAR_HALT, &hid->iofl)) { 103 if (test_bit(HID_CLEAR_HALT, &usbhid->iofl)) {
979 dev_dbg(&hid->intf->dev, "clear halt\n"); 104 dev_dbg(&usbhid->intf->dev, "clear halt\n");
980 rc = usb_clear_halt(hid->dev, hid->urbin->pipe); 105 rc = usb_clear_halt(hid_to_usb_dev(hid), usbhid->urbin->pipe);
981 clear_bit(HID_CLEAR_HALT, &hid->iofl); 106 clear_bit(HID_CLEAR_HALT, &usbhid->iofl);
982 hid_start_in(hid); 107 hid_start_in(hid);
983 } 108 }
984 109
985 else if (test_bit(HID_RESET_PENDING, &hid->iofl)) { 110 else if (test_bit(HID_RESET_PENDING, &usbhid->iofl)) {
986 dev_dbg(&hid->intf->dev, "resetting device\n"); 111 dev_dbg(&usbhid->intf->dev, "resetting device\n");
987 rc = rc_lock = usb_lock_device_for_reset(hid->dev, hid->intf); 112 rc = rc_lock = usb_lock_device_for_reset(hid_to_usb_dev(hid), usbhid->intf);
988 if (rc_lock >= 0) { 113 if (rc_lock >= 0) {
989 rc = usb_reset_composite_device(hid->dev, hid->intf); 114 rc = usb_reset_composite_device(hid_to_usb_dev(hid), usbhid->intf);
990 if (rc_lock) 115 if (rc_lock)
991 usb_unlock_device(hid->dev); 116 usb_unlock_device(hid_to_usb_dev(hid));
992 } 117 }
993 clear_bit(HID_RESET_PENDING, &hid->iofl); 118 clear_bit(HID_RESET_PENDING, &usbhid->iofl);
994 } 119 }
995 120
996 switch (rc) { 121 switch (rc) {
997 case 0: 122 case 0:
998 if (!test_bit(HID_IN_RUNNING, &hid->iofl)) 123 if (!test_bit(HID_IN_RUNNING, &usbhid->iofl))
999 hid_io_error(hid); 124 hid_io_error(hid);
1000 break; 125 break;
1001 default: 126 default:
1002 err("can't reset device, %s-%s/input%d, status %d", 127 err("can't reset device, %s-%s/input%d, status %d",
1003 hid->dev->bus->bus_name, 128 hid_to_usb_dev(hid)->bus->bus_name,
1004 hid->dev->devpath, 129 hid_to_usb_dev(hid)->devpath,
1005 hid->ifnum, rc); 130 usbhid->ifnum, rc);
1006 /* FALLTHROUGH */ 131 /* FALLTHROUGH */
1007 case -EHOSTUNREACH: 132 case -EHOSTUNREACH:
1008 case -ENODEV: 133 case -ENODEV:
@@ -1015,33 +140,34 @@ static void hid_reset(struct work_struct *work)
1015static void hid_io_error(struct hid_device *hid) 140static void hid_io_error(struct hid_device *hid)
1016{ 141{
1017 unsigned long flags; 142 unsigned long flags;
143 struct usbhid_device *usbhid = hid->driver_data;
1018 144
1019 spin_lock_irqsave(&hid->inlock, flags); 145 spin_lock_irqsave(&usbhid->inlock, flags);
1020 146
1021 /* Stop when disconnected */ 147 /* Stop when disconnected */
1022 if (usb_get_intfdata(hid->intf) == NULL) 148 if (usb_get_intfdata(usbhid->intf) == NULL)
1023 goto done; 149 goto done;
1024 150
1025 /* When an error occurs, retry at increasing intervals */ 151 /* When an error occurs, retry at increasing intervals */
1026 if (hid->retry_delay == 0) { 152 if (usbhid->retry_delay == 0) {
1027 hid->retry_delay = 13; /* Then 26, 52, 104, 104, ... */ 153 usbhid->retry_delay = 13; /* Then 26, 52, 104, 104, ... */
1028 hid->stop_retry = jiffies + msecs_to_jiffies(1000); 154 usbhid->stop_retry = jiffies + msecs_to_jiffies(1000);
1029 } else if (hid->retry_delay < 100) 155 } else if (usbhid->retry_delay < 100)
1030 hid->retry_delay *= 2; 156 usbhid->retry_delay *= 2;
1031 157
1032 if (time_after(jiffies, hid->stop_retry)) { 158 if (time_after(jiffies, usbhid->stop_retry)) {
1033 159
1034 /* Retries failed, so do a port reset */ 160 /* Retries failed, so do a port reset */
1035 if (!test_and_set_bit(HID_RESET_PENDING, &hid->iofl)) { 161 if (!test_and_set_bit(HID_RESET_PENDING, &usbhid->iofl)) {
1036 schedule_work(&hid->reset_work); 162 schedule_work(&usbhid->reset_work);
1037 goto done; 163 goto done;
1038 } 164 }
1039 } 165 }
1040 166
1041 mod_timer(&hid->io_retry, 167 mod_timer(&usbhid->io_retry,
1042 jiffies + msecs_to_jiffies(hid->retry_delay)); 168 jiffies + msecs_to_jiffies(usbhid->retry_delay));
1043done: 169done:
1044 spin_unlock_irqrestore(&hid->inlock, flags); 170 spin_unlock_irqrestore(&usbhid->inlock, flags);
1045} 171}
1046 172
1047/* 173/*
@@ -1051,28 +177,31 @@ done:
1051static void hid_irq_in(struct urb *urb) 177static void hid_irq_in(struct urb *urb)
1052{ 178{
1053 struct hid_device *hid = urb->context; 179 struct hid_device *hid = urb->context;
180 struct usbhid_device *usbhid = hid->driver_data;
1054 int status; 181 int status;
1055 182
1056 switch (urb->status) { 183 switch (urb->status) {
1057 case 0: /* success */ 184 case 0: /* success */
1058 hid->retry_delay = 0; 185 usbhid->retry_delay = 0;
1059 hid_input_report(HID_INPUT_REPORT, urb, 1); 186 hid_input_report(urb->context, HID_INPUT_REPORT,
187 urb->transfer_buffer,
188 urb->actual_length, 1);
1060 break; 189 break;
1061 case -EPIPE: /* stall */ 190 case -EPIPE: /* stall */
1062 clear_bit(HID_IN_RUNNING, &hid->iofl); 191 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
1063 set_bit(HID_CLEAR_HALT, &hid->iofl); 192 set_bit(HID_CLEAR_HALT, &usbhid->iofl);
1064 schedule_work(&hid->reset_work); 193 schedule_work(&usbhid->reset_work);
1065 return; 194 return;
1066 case -ECONNRESET: /* unlink */ 195 case -ECONNRESET: /* unlink */
1067 case -ENOENT: 196 case -ENOENT:
1068 case -ESHUTDOWN: /* unplug */ 197 case -ESHUTDOWN: /* unplug */
1069 clear_bit(HID_IN_RUNNING, &hid->iofl); 198 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
1070 return; 199 return;
1071 case -EILSEQ: /* protocol error or unplug */ 200 case -EILSEQ: /* protocol error or unplug */
1072 case -EPROTO: /* protocol error or unplug */ 201 case -EPROTO: /* protocol error or unplug */
1073 case -ETIME: /* protocol error or unplug */ 202 case -ETIME: /* protocol error or unplug */
1074 case -ETIMEDOUT: /* Should never happen, but... */ 203 case -ETIMEDOUT: /* Should never happen, but... */
1075 clear_bit(HID_IN_RUNNING, &hid->iofl); 204 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
1076 hid_io_error(hid); 205 hid_io_error(hid);
1077 return; 206 return;
1078 default: /* error */ 207 default: /* error */
@@ -1081,108 +210,31 @@ static void hid_irq_in(struct urb *urb)
1081 210
1082 status = usb_submit_urb(urb, GFP_ATOMIC); 211 status = usb_submit_urb(urb, GFP_ATOMIC);
1083 if (status) { 212 if (status) {
1084 clear_bit(HID_IN_RUNNING, &hid->iofl); 213 clear_bit(HID_IN_RUNNING, &usbhid->iofl);
1085 if (status != -EPERM) { 214 if (status != -EPERM) {
1086 err("can't resubmit intr, %s-%s/input%d, status %d", 215 err("can't resubmit intr, %s-%s/input%d, status %d",
1087 hid->dev->bus->bus_name, 216 hid_to_usb_dev(hid)->bus->bus_name,
1088 hid->dev->devpath, 217 hid_to_usb_dev(hid)->devpath,
1089 hid->ifnum, status); 218 usbhid->ifnum, status);
1090 hid_io_error(hid); 219 hid_io_error(hid);
1091 } 220 }
1092 } 221 }
1093} 222}
1094 223
1095/*
1096 * Output the field into the report.
1097 */
1098
1099static void hid_output_field(struct hid_field *field, __u8 *data)
1100{
1101 unsigned count = field->report_count;
1102 unsigned offset = field->report_offset;
1103 unsigned size = field->report_size;
1104 unsigned n;
1105
1106 for (n = 0; n < count; n++) {
1107 if (field->logical_minimum < 0) /* signed values */
1108 implement(data, offset + n * size, size, s32ton(field->value[n], size));
1109 else /* unsigned values */
1110 implement(data, offset + n * size, size, field->value[n]);
1111 }
1112}
1113
1114/*
1115 * Create a report.
1116 */
1117
1118static void hid_output_report(struct hid_report *report, __u8 *data)
1119{
1120 unsigned n;
1121
1122 if (report->id > 0)
1123 *data++ = report->id;
1124
1125 for (n = 0; n < report->maxfield; n++)
1126 hid_output_field(report->field[n], data);
1127}
1128
1129/*
1130 * Set a field value. The report this field belongs to has to be
1131 * created and transferred to the device, to set this value in the
1132 * device.
1133 */
1134
1135int hid_set_field(struct hid_field *field, unsigned offset, __s32 value)
1136{
1137 unsigned size = field->report_size;
1138
1139 hid_dump_input(field->usage + offset, value);
1140
1141 if (offset >= field->report_count) {
1142 dbg("offset (%d) exceeds report_count (%d)", offset, field->report_count);
1143 hid_dump_field(field, 8);
1144 return -1;
1145 }
1146 if (field->logical_minimum < 0) {
1147 if (value != snto32(s32ton(value, size), size)) {
1148 dbg("value %d is out of range", value);
1149 return -1;
1150 }
1151 }
1152 field->value[offset] = value;
1153 return 0;
1154}
1155
1156/*
1157 * Find a report field with a specified HID usage.
1158 */
1159#if 0
1160struct hid_field *hid_find_field_by_usage(struct hid_device *hid, __u32 wanted_usage, int type)
1161{
1162 struct hid_report *report;
1163 int i;
1164
1165 list_for_each_entry(report, &hid->report_enum[type].report_list, list)
1166 for (i = 0; i < report->maxfield; i++)
1167 if (report->field[i]->logical == wanted_usage)
1168 return report->field[i];
1169 return NULL;
1170}
1171#endif /* 0 */
1172
1173static int hid_submit_out(struct hid_device *hid) 224static int hid_submit_out(struct hid_device *hid)
1174{ 225{
1175 struct hid_report *report; 226 struct hid_report *report;
227 struct usbhid_device *usbhid = hid->driver_data;
1176 228
1177 report = hid->out[hid->outtail]; 229 report = usbhid->out[usbhid->outtail];
1178 230
1179 hid_output_report(report, hid->outbuf); 231 hid_output_report(report, usbhid->outbuf);
1180 hid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0); 232 usbhid->urbout->transfer_buffer_length = ((report->size - 1) >> 3) + 1 + (report->id > 0);
1181 hid->urbout->dev = hid->dev; 233 usbhid->urbout->dev = hid_to_usb_dev(hid);
1182 234
1183 dbg("submitting out urb"); 235 dbg("submitting out urb");
1184 236
1185 if (usb_submit_urb(hid->urbout, GFP_ATOMIC)) { 237 if (usb_submit_urb(usbhid->urbout, GFP_ATOMIC)) {
1186 err("usb_submit_urb(out) failed"); 238 err("usb_submit_urb(out) failed");
1187 return -1; 239 return -1;
1188 } 240 }
@@ -1195,42 +247,43 @@ static int hid_submit_ctrl(struct hid_device *hid)
1195 struct hid_report *report; 247 struct hid_report *report;
1196 unsigned char dir; 248 unsigned char dir;
1197 int len; 249 int len;
250 struct usbhid_device *usbhid = hid->driver_data;
1198 251
1199 report = hid->ctrl[hid->ctrltail].report; 252 report = usbhid->ctrl[usbhid->ctrltail].report;
1200 dir = hid->ctrl[hid->ctrltail].dir; 253 dir = usbhid->ctrl[usbhid->ctrltail].dir;
1201 254
1202 len = ((report->size - 1) >> 3) + 1 + (report->id > 0); 255 len = ((report->size - 1) >> 3) + 1 + (report->id > 0);
1203 if (dir == USB_DIR_OUT) { 256 if (dir == USB_DIR_OUT) {
1204 hid_output_report(report, hid->ctrlbuf); 257 hid_output_report(report, usbhid->ctrlbuf);
1205 hid->urbctrl->pipe = usb_sndctrlpipe(hid->dev, 0); 258 usbhid->urbctrl->pipe = usb_sndctrlpipe(hid_to_usb_dev(hid), 0);
1206 hid->urbctrl->transfer_buffer_length = len; 259 usbhid->urbctrl->transfer_buffer_length = len;
1207 } else { 260 } else {
1208 int maxpacket, padlen; 261 int maxpacket, padlen;
1209 262
1210 hid->urbctrl->pipe = usb_rcvctrlpipe(hid->dev, 0); 263 usbhid->urbctrl->pipe = usb_rcvctrlpipe(hid_to_usb_dev(hid), 0);
1211 maxpacket = usb_maxpacket(hid->dev, hid->urbctrl->pipe, 0); 264 maxpacket = usb_maxpacket(hid_to_usb_dev(hid), usbhid->urbctrl->pipe, 0);
1212 if (maxpacket > 0) { 265 if (maxpacket > 0) {
1213 padlen = (len + maxpacket - 1) / maxpacket; 266 padlen = (len + maxpacket - 1) / maxpacket;
1214 padlen *= maxpacket; 267 padlen *= maxpacket;
1215 if (padlen > hid->bufsize) 268 if (padlen > usbhid->bufsize)
1216 padlen = hid->bufsize; 269 padlen = usbhid->bufsize;
1217 } else 270 } else
1218 padlen = 0; 271 padlen = 0;
1219 hid->urbctrl->transfer_buffer_length = padlen; 272 usbhid->urbctrl->transfer_buffer_length = padlen;
1220 } 273 }
1221 hid->urbctrl->dev = hid->dev; 274 usbhid->urbctrl->dev = hid_to_usb_dev(hid);
1222 275
1223 hid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir; 276 usbhid->cr->bRequestType = USB_TYPE_CLASS | USB_RECIP_INTERFACE | dir;
1224 hid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : HID_REQ_GET_REPORT; 277 usbhid->cr->bRequest = (dir == USB_DIR_OUT) ? HID_REQ_SET_REPORT : HID_REQ_GET_REPORT;
1225 hid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | report->id); 278 usbhid->cr->wValue = cpu_to_le16(((report->type + 1) << 8) | report->id);
1226 hid->cr->wIndex = cpu_to_le16(hid->ifnum); 279 usbhid->cr->wIndex = cpu_to_le16(usbhid->ifnum);
1227 hid->cr->wLength = cpu_to_le16(len); 280 usbhid->cr->wLength = cpu_to_le16(len);
1228 281
1229 dbg("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u", 282 dbg("submitting ctrl urb: %s wValue=0x%04x wIndex=0x%04x wLength=%u",
1230 hid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report", 283 usbhid->cr->bRequest == HID_REQ_SET_REPORT ? "Set_Report" : "Get_Report",
1231 hid->cr->wValue, hid->cr->wIndex, hid->cr->wLength); 284 usbhid->cr->wValue, usbhid->cr->wIndex, usbhid->cr->wLength);
1232 285
1233 if (usb_submit_urb(hid->urbctrl, GFP_ATOMIC)) { 286 if (usb_submit_urb(usbhid->urbctrl, GFP_ATOMIC)) {
1234 err("usb_submit_urb(ctrl) failed"); 287 err("usb_submit_urb(ctrl) failed");
1235 return -1; 288 return -1;
1236 } 289 }
@@ -1245,6 +298,7 @@ static int hid_submit_ctrl(struct hid_device *hid)
1245static void hid_irq_out(struct urb *urb) 298static void hid_irq_out(struct urb *urb)
1246{ 299{
1247 struct hid_device *hid = urb->context; 300 struct hid_device *hid = urb->context;
301 struct usbhid_device *usbhid = hid->driver_data;
1248 unsigned long flags; 302 unsigned long flags;
1249 int unplug = 0; 303 int unplug = 0;
1250 304
@@ -1262,24 +316,24 @@ static void hid_irq_out(struct urb *urb)
1262 warn("output irq status %d received", urb->status); 316 warn("output irq status %d received", urb->status);
1263 } 317 }
1264 318
1265 spin_lock_irqsave(&hid->outlock, flags); 319 spin_lock_irqsave(&usbhid->outlock, flags);
1266 320
1267 if (unplug) 321 if (unplug)
1268 hid->outtail = hid->outhead; 322 usbhid->outtail = usbhid->outhead;
1269 else 323 else
1270 hid->outtail = (hid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1); 324 usbhid->outtail = (usbhid->outtail + 1) & (HID_OUTPUT_FIFO_SIZE - 1);
1271 325
1272 if (hid->outhead != hid->outtail) { 326 if (usbhid->outhead != usbhid->outtail) {
1273 if (hid_submit_out(hid)) { 327 if (hid_submit_out(hid)) {
1274 clear_bit(HID_OUT_RUNNING, &hid->iofl); 328 clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
1275 wake_up(&hid->wait); 329 wake_up(&hid->wait);
1276 } 330 }
1277 spin_unlock_irqrestore(&hid->outlock, flags); 331 spin_unlock_irqrestore(&usbhid->outlock, flags);
1278 return; 332 return;
1279 } 333 }
1280 334
1281 clear_bit(HID_OUT_RUNNING, &hid->iofl); 335 clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
1282 spin_unlock_irqrestore(&hid->outlock, flags); 336 spin_unlock_irqrestore(&usbhid->outlock, flags);
1283 wake_up(&hid->wait); 337 wake_up(&hid->wait);
1284} 338}
1285 339
@@ -1290,15 +344,17 @@ static void hid_irq_out(struct urb *urb)
1290static void hid_ctrl(struct urb *urb) 344static void hid_ctrl(struct urb *urb)
1291{ 345{
1292 struct hid_device *hid = urb->context; 346 struct hid_device *hid = urb->context;
347 struct usbhid_device *usbhid = hid->driver_data;
1293 unsigned long flags; 348 unsigned long flags;
1294 int unplug = 0; 349 int unplug = 0;
1295 350
1296 spin_lock_irqsave(&hid->ctrllock, flags); 351 spin_lock_irqsave(&usbhid->ctrllock, flags);
1297 352
1298 switch (urb->status) { 353 switch (urb->status) {
1299 case 0: /* success */ 354 case 0: /* success */
1300 if (hid->ctrl[hid->ctrltail].dir == USB_DIR_IN) 355 if (usbhid->ctrl[usbhid->ctrltail].dir == USB_DIR_IN)
1301 hid_input_report(hid->ctrl[hid->ctrltail].report->type, urb, 0); 356 hid_input_report(urb->context, usbhid->ctrl[usbhid->ctrltail].report->type,
357 urb->transfer_buffer, urb->actual_length, 0);
1302 break; 358 break;
1303 case -ESHUTDOWN: /* unplug */ 359 case -ESHUTDOWN: /* unplug */
1304 unplug = 1; 360 unplug = 1;
@@ -1313,76 +369,102 @@ static void hid_ctrl(struct urb *urb)
1313 } 369 }
1314 370
1315 if (unplug) 371 if (unplug)
1316 hid->ctrltail = hid->ctrlhead; 372 usbhid->ctrltail = usbhid->ctrlhead;
1317 else 373 else
1318 hid->ctrltail = (hid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1); 374 usbhid->ctrltail = (usbhid->ctrltail + 1) & (HID_CONTROL_FIFO_SIZE - 1);
1319 375
1320 if (hid->ctrlhead != hid->ctrltail) { 376 if (usbhid->ctrlhead != usbhid->ctrltail) {
1321 if (hid_submit_ctrl(hid)) { 377 if (hid_submit_ctrl(hid)) {
1322 clear_bit(HID_CTRL_RUNNING, &hid->iofl); 378 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
1323 wake_up(&hid->wait); 379 wake_up(&hid->wait);
1324 } 380 }
1325 spin_unlock_irqrestore(&hid->ctrllock, flags); 381 spin_unlock_irqrestore(&usbhid->ctrllock, flags);
1326 return; 382 return;
1327 } 383 }
1328 384
1329 clear_bit(HID_CTRL_RUNNING, &hid->iofl); 385 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
1330 spin_unlock_irqrestore(&hid->ctrllock, flags); 386 spin_unlock_irqrestore(&usbhid->ctrllock, flags);
1331 wake_up(&hid->wait); 387 wake_up(&hid->wait);
1332} 388}
1333 389
1334void hid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir) 390void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir)
1335{ 391{
1336 int head; 392 int head;
1337 unsigned long flags; 393 unsigned long flags;
394 struct usbhid_device *usbhid = hid->driver_data;
1338 395
1339 if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN) 396 if ((hid->quirks & HID_QUIRK_NOGET) && dir == USB_DIR_IN)
1340 return; 397 return;
1341 398
1342 if (hid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) { 399 if (usbhid->urbout && dir == USB_DIR_OUT && report->type == HID_OUTPUT_REPORT) {
1343 400
1344 spin_lock_irqsave(&hid->outlock, flags); 401 spin_lock_irqsave(&usbhid->outlock, flags);
1345 402
1346 if ((head = (hid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == hid->outtail) { 403 if ((head = (usbhid->outhead + 1) & (HID_OUTPUT_FIFO_SIZE - 1)) == usbhid->outtail) {
1347 spin_unlock_irqrestore(&hid->outlock, flags); 404 spin_unlock_irqrestore(&usbhid->outlock, flags);
1348 warn("output queue full"); 405 warn("output queue full");
1349 return; 406 return;
1350 } 407 }
1351 408
1352 hid->out[hid->outhead] = report; 409 usbhid->out[usbhid->outhead] = report;
1353 hid->outhead = head; 410 usbhid->outhead = head;
1354 411
1355 if (!test_and_set_bit(HID_OUT_RUNNING, &hid->iofl)) 412 if (!test_and_set_bit(HID_OUT_RUNNING, &usbhid->iofl))
1356 if (hid_submit_out(hid)) 413 if (hid_submit_out(hid))
1357 clear_bit(HID_OUT_RUNNING, &hid->iofl); 414 clear_bit(HID_OUT_RUNNING, &usbhid->iofl);
1358 415
1359 spin_unlock_irqrestore(&hid->outlock, flags); 416 spin_unlock_irqrestore(&usbhid->outlock, flags);
1360 return; 417 return;
1361 } 418 }
1362 419
1363 spin_lock_irqsave(&hid->ctrllock, flags); 420 spin_lock_irqsave(&usbhid->ctrllock, flags);
1364 421
1365 if ((head = (hid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == hid->ctrltail) { 422 if ((head = (usbhid->ctrlhead + 1) & (HID_CONTROL_FIFO_SIZE - 1)) == usbhid->ctrltail) {
1366 spin_unlock_irqrestore(&hid->ctrllock, flags); 423 spin_unlock_irqrestore(&usbhid->ctrllock, flags);
1367 warn("control queue full"); 424 warn("control queue full");
1368 return; 425 return;
1369 } 426 }
1370 427
1371 hid->ctrl[hid->ctrlhead].report = report; 428 usbhid->ctrl[usbhid->ctrlhead].report = report;
1372 hid->ctrl[hid->ctrlhead].dir = dir; 429 usbhid->ctrl[usbhid->ctrlhead].dir = dir;
1373 hid->ctrlhead = head; 430 usbhid->ctrlhead = head;
1374 431
1375 if (!test_and_set_bit(HID_CTRL_RUNNING, &hid->iofl)) 432 if (!test_and_set_bit(HID_CTRL_RUNNING, &usbhid->iofl))
1376 if (hid_submit_ctrl(hid)) 433 if (hid_submit_ctrl(hid))
1377 clear_bit(HID_CTRL_RUNNING, &hid->iofl); 434 clear_bit(HID_CTRL_RUNNING, &usbhid->iofl);
435
436 spin_unlock_irqrestore(&usbhid->ctrllock, flags);
437}
438
439static int usb_hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
440{
441 struct hid_device *hid = dev->private;
442 struct hid_field *field;
443 int offset;
1378 444
1379 spin_unlock_irqrestore(&hid->ctrllock, flags); 445 if (type == EV_FF)
446 return input_ff_event(dev, type, code, value);
447
448 if (type != EV_LED)
449 return -1;
450
451 if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
452 warn("event field not found");
453 return -1;
454 }
455
456 hid_set_field(field, offset, value);
457 usbhid_submit_report(hid, field->report, USB_DIR_OUT);
458
459 return 0;
1380} 460}
1381 461
1382int hid_wait_io(struct hid_device *hid) 462int usbhid_wait_io(struct hid_device *hid)
1383{ 463{
1384 if (!wait_event_timeout(hid->wait, (!test_bit(HID_CTRL_RUNNING, &hid->iofl) && 464 struct usbhid_device *usbhid = hid->driver_data;
1385 !test_bit(HID_OUT_RUNNING, &hid->iofl)), 465
466 if (!wait_event_timeout(hid->wait, (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl) &&
467 !test_bit(HID_OUT_RUNNING, &usbhid->iofl)),
1386 10*HZ)) { 468 10*HZ)) {
1387 dbg("timeout waiting for ctrl or out queue to clear"); 469 dbg("timeout waiting for ctrl or out queue to clear");
1388 return -1; 470 return -1;
@@ -1403,7 +485,7 @@ static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
1403{ 485{
1404 int result, retries = 4; 486 int result, retries = 4;
1405 487
1406 memset(buf,0,size); // Make sure we parse really received data 488 memset(buf, 0, size);
1407 489
1408 do { 490 do {
1409 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), 491 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
@@ -1414,7 +496,7 @@ static int hid_get_class_descriptor(struct usb_device *dev, int ifnum,
1414 return result; 496 return result;
1415} 497}
1416 498
1417int hid_open(struct hid_device *hid) 499int usbhid_open(struct hid_device *hid)
1418{ 500{
1419 ++hid->open; 501 ++hid->open;
1420 if (hid_start_in(hid)) 502 if (hid_start_in(hid))
@@ -1422,10 +504,12 @@ int hid_open(struct hid_device *hid)
1422 return 0; 504 return 0;
1423} 505}
1424 506
1425void hid_close(struct hid_device *hid) 507void usbhid_close(struct hid_device *hid)
1426{ 508{
509 struct usbhid_device *usbhid = hid->driver_data;
510
1427 if (!--hid->open) 511 if (!--hid->open)
1428 usb_kill_urb(hid->urbin); 512 usb_kill_urb(usbhid->urbin);
1429} 513}
1430 514
1431#define USB_VENDOR_ID_PANJIT 0x134c 515#define USB_VENDOR_ID_PANJIT 0x134c
@@ -1437,26 +521,27 @@ void hid_close(struct hid_device *hid)
1437 * Initialize all reports 521 * Initialize all reports
1438 */ 522 */
1439 523
1440void hid_init_reports(struct hid_device *hid) 524void usbhid_init_reports(struct hid_device *hid)
1441{ 525{
1442 struct hid_report *report; 526 struct hid_report *report;
527 struct usbhid_device *usbhid = hid->driver_data;
1443 int err, ret; 528 int err, ret;
1444 529
1445 list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list) 530 list_for_each_entry(report, &hid->report_enum[HID_INPUT_REPORT].report_list, list)
1446 hid_submit_report(hid, report, USB_DIR_IN); 531 usbhid_submit_report(hid, report, USB_DIR_IN);
1447 532
1448 list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list) 533 list_for_each_entry(report, &hid->report_enum[HID_FEATURE_REPORT].report_list, list)
1449 hid_submit_report(hid, report, USB_DIR_IN); 534 usbhid_submit_report(hid, report, USB_DIR_IN);
1450 535
1451 err = 0; 536 err = 0;
1452 ret = hid_wait_io(hid); 537 ret = usbhid_wait_io(hid);
1453 while (ret) { 538 while (ret) {
1454 err |= ret; 539 err |= ret;
1455 if (test_bit(HID_CTRL_RUNNING, &hid->iofl)) 540 if (test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
1456 usb_kill_urb(hid->urbctrl); 541 usb_kill_urb(usbhid->urbctrl);
1457 if (test_bit(HID_OUT_RUNNING, &hid->iofl)) 542 if (test_bit(HID_OUT_RUNNING, &usbhid->iofl))
1458 usb_kill_urb(hid->urbout); 543 usb_kill_urb(usbhid->urbout);
1459 ret = hid_wait_io(hid); 544 ret = usbhid_wait_io(hid);
1460 } 545 }
1461 546
1462 if (err) 547 if (err)
@@ -1464,6 +549,7 @@ void hid_init_reports(struct hid_device *hid)
1464} 549}
1465 550
1466#define USB_VENDOR_ID_GTCO 0x078c 551#define USB_VENDOR_ID_GTCO 0x078c
552#define USB_VENDOR_ID_GTCO_IPANEL_2 0x5543
1467#define USB_DEVICE_ID_GTCO_90 0x0090 553#define USB_DEVICE_ID_GTCO_90 0x0090
1468#define USB_DEVICE_ID_GTCO_100 0x0100 554#define USB_DEVICE_ID_GTCO_100 0x0100
1469#define USB_DEVICE_ID_GTCO_101 0x0101 555#define USB_DEVICE_ID_GTCO_101 0x0101
@@ -1509,6 +595,8 @@ void hid_init_reports(struct hid_device *hid)
1509#define USB_DEVICE_ID_GTCO_1004 0x1004 595#define USB_DEVICE_ID_GTCO_1004 0x1004
1510#define USB_DEVICE_ID_GTCO_1005 0x1005 596#define USB_DEVICE_ID_GTCO_1005 0x1005
1511#define USB_DEVICE_ID_GTCO_1006 0x1006 597#define USB_DEVICE_ID_GTCO_1006 0x1006
598#define USB_DEVICE_ID_GTCO_8 0x0008
599#define USB_DEVICE_ID_GTCO_d 0x000d
1512 600
1513#define USB_VENDOR_ID_WACOM 0x056a 601#define USB_VENDOR_ID_WACOM 0x056a
1514 602
@@ -1654,6 +742,7 @@ void hid_init_reports(struct hid_device *hid)
1654#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c 742#define USB_DEVICE_ID_APPLE_GEYSER4_JIS 0x021c
1655#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY 0x030a 743#define USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY 0x030a
1656#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY 0x030b 744#define USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY 0x030b
745#define USB_DEVICE_ID_APPLE_IR 0x8240
1657 746
1658#define USB_VENDOR_ID_CHERRY 0x046a 747#define USB_VENDOR_ID_CHERRY 0x046a
1659#define USB_DEVICE_ID_CHERRY_CYMOTION 0x0023 748#define USB_DEVICE_ID_CHERRY_CYMOTION 0x0023
@@ -1673,6 +762,15 @@ void hid_init_reports(struct hid_device *hid)
1673#define USB_VENDOR_ID_LOGITECH 0x046d 762#define USB_VENDOR_ID_LOGITECH 0x046d
1674#define USB_DEVICE_ID_LOGITECH_USB_RECEIVER 0xc101 763#define USB_DEVICE_ID_LOGITECH_USB_RECEIVER 0xc101
1675 764
765#define USB_VENDOR_ID_IMATION 0x0718
766#define USB_DEVICE_ID_DISC_STAKKA 0xd000
767
768#define USB_VENDOR_ID_PANTHERLORD 0x0810
769#define USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK 0x0001
770
771#define USB_VENDOR_ID_SONY 0x054c
772#define USB_DEVICE_ID_SONY_PS3_CONTROLLER 0x0268
773
1676/* 774/*
1677 * Alphabetically sorted blacklist by quirk type. 775 * Alphabetically sorted blacklist by quirk type.
1678 */ 776 */
@@ -1757,6 +855,9 @@ static const struct hid_blacklist {
1757 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE }, 855 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1004, HID_QUIRK_IGNORE },
1758 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE }, 856 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1005, HID_QUIRK_IGNORE },
1759 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE }, 857 { USB_VENDOR_ID_GTCO, USB_DEVICE_ID_GTCO_1006, HID_QUIRK_IGNORE },
858 { USB_VENDOR_ID_GTCO_IPANEL_2, USB_DEVICE_ID_GTCO_8, HID_QUIRK_IGNORE },
859 { USB_VENDOR_ID_GTCO_IPANEL_2, USB_DEVICE_ID_GTCO_d, HID_QUIRK_IGNORE },
860 { USB_VENDOR_ID_IMATION, USB_DEVICE_ID_DISC_STAKKA, HID_QUIRK_IGNORE },
1760 { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE }, 861 { USB_VENDOR_ID_KBGEAR, USB_DEVICE_ID_KBGEAR_JAMSTUDIO, HID_QUIRK_IGNORE },
1761 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE }, 862 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_CASSY, HID_QUIRK_IGNORE },
1762 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE }, 863 { USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_POCKETCASSY, HID_QUIRK_IGNORE },
@@ -1824,19 +925,21 @@ static const struct hid_blacklist {
1824 925
1825 { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_CYMOTION }, 926 { USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION, HID_QUIRK_CYMOTION },
1826 927
1827 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_POWERBOOK_HAS_FN }, 928 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1828 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_POWERBOOK_HAS_FN }, 929 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1829 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_POWERBOOK_HAS_FN }, 930 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1830 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_POWERBOOK_ISO_KEYBOARD}, 931 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
1831 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_POWERBOOK_HAS_FN }, 932 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1832 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_POWERBOOK_HAS_FN }, 933 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1833 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_POWERBOOK_ISO_KEYBOARD}, 934 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
1834 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_POWERBOOK_HAS_FN }, 935 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1835 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN }, 936 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1836 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN }, 937 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE | HID_QUIRK_POWERBOOK_ISO_KEYBOARD},
1837 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN }, 938 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1838 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN }, 939 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
1839 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN }, 940 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY, HID_QUIRK_POWERBOOK_HAS_FN | HID_QUIRK_IGNORE_MOUSE },
941
942 { USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IR, HID_QUIRK_IGNORE },
1840 943
1841 { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE }, 944 { USB_VENDOR_ID_PANJIT, 0x0001, HID_QUIRK_IGNORE },
1842 { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE }, 945 { USB_VENDOR_ID_PANJIT, 0x0002, HID_QUIRK_IGNORE },
@@ -1847,6 +950,10 @@ static const struct hid_blacklist {
1847 950
1848 { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_USB_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS }, 951 { USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_USB_RECEIVER, HID_QUIRK_BAD_RELATIVE_KEYS },
1849 952
953 { USB_VENDOR_ID_PANTHERLORD, USB_DEVICE_ID_PANTHERLORD_TWIN_USB_JOYSTICK, HID_QUIRK_MULTI_INPUT | HID_QUIRK_SKIP_OUTPUT_REPORTS },
954
955 { USB_VENDOR_ID_SONY, USB_DEVICE_ID_SONY_PS3_CONTROLLER, HID_QUIRK_SONY_PS3_CONTROLLER },
956
1850 { 0, 0 } 957 { 0, 0 }
1851}; 958};
1852 959
@@ -1869,13 +976,15 @@ static void hid_find_max_report(struct hid_device *hid, unsigned int type, int *
1869 976
1870static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid) 977static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
1871{ 978{
1872 if (!(hid->inbuf = usb_buffer_alloc(dev, hid->bufsize, GFP_ATOMIC, &hid->inbuf_dma))) 979 struct usbhid_device *usbhid = hid->driver_data;
980
981 if (!(usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->inbuf_dma)))
1873 return -1; 982 return -1;
1874 if (!(hid->outbuf = usb_buffer_alloc(dev, hid->bufsize, GFP_ATOMIC, &hid->outbuf_dma))) 983 if (!(usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->outbuf_dma)))
1875 return -1; 984 return -1;
1876 if (!(hid->cr = usb_buffer_alloc(dev, sizeof(*(hid->cr)), GFP_ATOMIC, &hid->cr_dma))) 985 if (!(usbhid->cr = usb_buffer_alloc(dev, sizeof(*(usbhid->cr)), GFP_ATOMIC, &usbhid->cr_dma)))
1877 return -1; 986 return -1;
1878 if (!(hid->ctrlbuf = usb_buffer_alloc(dev, hid->bufsize, GFP_ATOMIC, &hid->ctrlbuf_dma))) 987 if (!(usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_ATOMIC, &usbhid->ctrlbuf_dma)))
1879 return -1; 988 return -1;
1880 989
1881 return 0; 990 return 0;
@@ -1883,14 +992,16 @@ static int hid_alloc_buffers(struct usb_device *dev, struct hid_device *hid)
1883 992
1884static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid) 993static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
1885{ 994{
1886 if (hid->inbuf) 995 struct usbhid_device *usbhid = hid->driver_data;
1887 usb_buffer_free(dev, hid->bufsize, hid->inbuf, hid->inbuf_dma); 996
1888 if (hid->outbuf) 997 if (usbhid->inbuf)
1889 usb_buffer_free(dev, hid->bufsize, hid->outbuf, hid->outbuf_dma); 998 usb_buffer_free(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma);
1890 if (hid->cr) 999 if (usbhid->outbuf)
1891 usb_buffer_free(dev, sizeof(*(hid->cr)), hid->cr, hid->cr_dma); 1000 usb_buffer_free(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma);
1892 if (hid->ctrlbuf) 1001 if (usbhid->cr)
1893 usb_buffer_free(dev, hid->bufsize, hid->ctrlbuf, hid->ctrlbuf_dma); 1002 usb_buffer_free(dev, sizeof(*(usbhid->cr)), usbhid->cr, usbhid->cr_dma);
1003 if (usbhid->ctrlbuf)
1004 usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma);
1894} 1005}
1895 1006
1896/* 1007/*
@@ -1907,6 +1018,32 @@ static void hid_fixup_cymotion_descriptor(char *rdesc, int rsize)
1907 } 1018 }
1908} 1019}
1909 1020
1021/*
1022 * Sending HID_REQ_GET_REPORT changes the operation mode of the ps3 controller
1023 * to "operational". Without this, the ps3 controller will not report any
1024 * events.
1025 */
1026static void hid_fixup_sony_ps3_controller(struct usb_device *dev, int ifnum)
1027{
1028 int result;
1029 char *buf = kmalloc(18, GFP_KERNEL);
1030
1031 if (!buf)
1032 return;
1033
1034 result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
1035 HID_REQ_GET_REPORT,
1036 USB_DIR_IN | USB_TYPE_CLASS |
1037 USB_RECIP_INTERFACE,
1038 (3 << 8) | 0xf2, ifnum, buf, 17,
1039 USB_CTRL_GET_TIMEOUT);
1040
1041 if (result < 0)
1042 err("%s failed: %d\n", __func__, result);
1043
1044 kfree(buf);
1045}
1046
1910static struct hid_device *usb_hid_configure(struct usb_interface *intf) 1047static struct hid_device *usb_hid_configure(struct usb_interface *intf)
1911{ 1048{
1912 struct usb_host_interface *interface = intf->cur_altsetting; 1049 struct usb_host_interface *interface = intf->cur_altsetting;
@@ -1916,6 +1053,7 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
1916 unsigned quirks = 0, rsize = 0; 1053 unsigned quirks = 0, rsize = 0;
1917 char *rdesc; 1054 char *rdesc;
1918 int n, len, insize = 0; 1055 int n, len, insize = 0;
1056 struct usbhid_device *usbhid;
1919 1057
1920 /* Ignore all Wacom devices */ 1058 /* Ignore all Wacom devices */
1921 if (le16_to_cpu(dev->descriptor.idVendor) == USB_VENDOR_ID_WACOM) 1059 if (le16_to_cpu(dev->descriptor.idVendor) == USB_VENDOR_ID_WACOM)
@@ -1937,6 +1075,11 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
1937 if (quirks & HID_QUIRK_IGNORE) 1075 if (quirks & HID_QUIRK_IGNORE)
1938 return NULL; 1076 return NULL;
1939 1077
1078 if ((quirks & HID_QUIRK_IGNORE_MOUSE) &&
1079 (interface->desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE))
1080 return NULL;
1081
1082
1940 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) && 1083 if (usb_get_extra_descriptor(interface, HID_DT_HID, &hdesc) &&
1941 (!interface->desc.bNumEndpoints || 1084 (!interface->desc.bNumEndpoints ||
1942 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) { 1085 usb_get_extra_descriptor(&interface->endpoint[0], HID_DT_HID, &hdesc))) {
@@ -1985,13 +1128,19 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
1985 kfree(rdesc); 1128 kfree(rdesc);
1986 hid->quirks = quirks; 1129 hid->quirks = quirks;
1987 1130
1988 hid->bufsize = HID_MIN_BUFFER_SIZE; 1131 if (!(usbhid = kzalloc(sizeof(struct usbhid_device), GFP_KERNEL)))
1989 hid_find_max_report(hid, HID_INPUT_REPORT, &hid->bufsize); 1132 goto fail;
1990 hid_find_max_report(hid, HID_OUTPUT_REPORT, &hid->bufsize); 1133
1991 hid_find_max_report(hid, HID_FEATURE_REPORT, &hid->bufsize); 1134 hid->driver_data = usbhid;
1135 usbhid->hid = hid;
1136
1137 usbhid->bufsize = HID_MIN_BUFFER_SIZE;
1138 hid_find_max_report(hid, HID_INPUT_REPORT, &usbhid->bufsize);
1139 hid_find_max_report(hid, HID_OUTPUT_REPORT, &usbhid->bufsize);
1140 hid_find_max_report(hid, HID_FEATURE_REPORT, &usbhid->bufsize);
1992 1141
1993 if (hid->bufsize > HID_MAX_BUFFER_SIZE) 1142 if (usbhid->bufsize > HID_MAX_BUFFER_SIZE)
1994 hid->bufsize = HID_MAX_BUFFER_SIZE; 1143 usbhid->bufsize = HID_MAX_BUFFER_SIZE;
1995 1144
1996 hid_find_max_report(hid, HID_INPUT_REPORT, &insize); 1145 hid_find_max_report(hid, HID_INPUT_REPORT, &insize);
1997 1146
@@ -2020,47 +1169,47 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
2020 interval = hid_mousepoll_interval; 1169 interval = hid_mousepoll_interval;
2021 1170
2022 if (usb_endpoint_dir_in(endpoint)) { 1171 if (usb_endpoint_dir_in(endpoint)) {
2023 if (hid->urbin) 1172 if (usbhid->urbin)
2024 continue; 1173 continue;
2025 if (!(hid->urbin = usb_alloc_urb(0, GFP_KERNEL))) 1174 if (!(usbhid->urbin = usb_alloc_urb(0, GFP_KERNEL)))
2026 goto fail; 1175 goto fail;
2027 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress); 1176 pipe = usb_rcvintpipe(dev, endpoint->bEndpointAddress);
2028 usb_fill_int_urb(hid->urbin, dev, pipe, hid->inbuf, insize, 1177 usb_fill_int_urb(usbhid->urbin, dev, pipe, usbhid->inbuf, insize,
2029 hid_irq_in, hid, interval); 1178 hid_irq_in, hid, interval);
2030 hid->urbin->transfer_dma = hid->inbuf_dma; 1179 usbhid->urbin->transfer_dma = usbhid->inbuf_dma;
2031 hid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1180 usbhid->urbin->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
2032 } else { 1181 } else {
2033 if (hid->urbout) 1182 if (usbhid->urbout)
2034 continue; 1183 continue;
2035 if (!(hid->urbout = usb_alloc_urb(0, GFP_KERNEL))) 1184 if (!(usbhid->urbout = usb_alloc_urb(0, GFP_KERNEL)))
2036 goto fail; 1185 goto fail;
2037 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress); 1186 pipe = usb_sndintpipe(dev, endpoint->bEndpointAddress);
2038 usb_fill_int_urb(hid->urbout, dev, pipe, hid->outbuf, 0, 1187 usb_fill_int_urb(usbhid->urbout, dev, pipe, usbhid->outbuf, 0,
2039 hid_irq_out, hid, interval); 1188 hid_irq_out, hid, interval);
2040 hid->urbout->transfer_dma = hid->outbuf_dma; 1189 usbhid->urbout->transfer_dma = usbhid->outbuf_dma;
2041 hid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 1190 usbhid->urbout->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
2042 } 1191 }
2043 } 1192 }
2044 1193
2045 if (!hid->urbin) { 1194 if (!usbhid->urbin) {
2046 err("couldn't find an input interrupt endpoint"); 1195 err("couldn't find an input interrupt endpoint");
2047 goto fail; 1196 goto fail;
2048 } 1197 }
2049 1198
2050 init_waitqueue_head(&hid->wait); 1199 init_waitqueue_head(&hid->wait);
2051 1200
2052 INIT_WORK(&hid->reset_work, hid_reset); 1201 INIT_WORK(&usbhid->reset_work, hid_reset);
2053 setup_timer(&hid->io_retry, hid_retry_timeout, (unsigned long) hid); 1202 setup_timer(&usbhid->io_retry, hid_retry_timeout, (unsigned long) hid);
2054 1203
2055 spin_lock_init(&hid->inlock); 1204 spin_lock_init(&usbhid->inlock);
2056 spin_lock_init(&hid->outlock); 1205 spin_lock_init(&usbhid->outlock);
2057 spin_lock_init(&hid->ctrllock); 1206 spin_lock_init(&usbhid->ctrllock);
2058 1207
2059 hid->version = le16_to_cpu(hdesc->bcdHID); 1208 hid->version = le16_to_cpu(hdesc->bcdHID);
2060 hid->country = hdesc->bCountryCode; 1209 hid->country = hdesc->bCountryCode;
2061 hid->dev = dev; 1210 hid->dev = &intf->dev;
2062 hid->intf = intf; 1211 usbhid->intf = intf;
2063 hid->ifnum = interface->desc.bInterfaceNumber; 1212 usbhid->ifnum = interface->desc.bInterfaceNumber;
2064 1213
2065 hid->name[0] = 0; 1214 hid->name[0] = 0;
2066 1215
@@ -2078,6 +1227,10 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
2078 le16_to_cpu(dev->descriptor.idVendor), 1227 le16_to_cpu(dev->descriptor.idVendor),
2079 le16_to_cpu(dev->descriptor.idProduct)); 1228 le16_to_cpu(dev->descriptor.idProduct));
2080 1229
1230 hid->bus = BUS_USB;
1231 hid->vendor = dev->descriptor.idVendor;
1232 hid->product = dev->descriptor.idProduct;
1233
2081 usb_make_path(dev, hid->phys, sizeof(hid->phys)); 1234 usb_make_path(dev, hid->phys, sizeof(hid->phys));
2082 strlcat(hid->phys, "/input", sizeof(hid->phys)); 1235 strlcat(hid->phys, "/input", sizeof(hid->phys));
2083 len = strlen(hid->phys); 1236 len = strlen(hid->phys);
@@ -2088,22 +1241,28 @@ static struct hid_device *usb_hid_configure(struct usb_interface *intf)
2088 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0) 1241 if (usb_string(dev, dev->descriptor.iSerialNumber, hid->uniq, 64) <= 0)
2089 hid->uniq[0] = 0; 1242 hid->uniq[0] = 0;
2090 1243
2091 hid->urbctrl = usb_alloc_urb(0, GFP_KERNEL); 1244 usbhid->urbctrl = usb_alloc_urb(0, GFP_KERNEL);
2092 if (!hid->urbctrl) 1245 if (!usbhid->urbctrl)
2093 goto fail; 1246 goto fail;
2094 1247
2095 usb_fill_control_urb(hid->urbctrl, dev, 0, (void *) hid->cr, 1248 usb_fill_control_urb(usbhid->urbctrl, dev, 0, (void *) usbhid->cr,
2096 hid->ctrlbuf, 1, hid_ctrl, hid); 1249 usbhid->ctrlbuf, 1, hid_ctrl, hid);
2097 hid->urbctrl->setup_dma = hid->cr_dma; 1250 usbhid->urbctrl->setup_dma = usbhid->cr_dma;
2098 hid->urbctrl->transfer_dma = hid->ctrlbuf_dma; 1251 usbhid->urbctrl->transfer_dma = usbhid->ctrlbuf_dma;
2099 hid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP); 1252 usbhid->urbctrl->transfer_flags |= (URB_NO_TRANSFER_DMA_MAP | URB_NO_SETUP_DMA_MAP);
2100 1253 hid->hidinput_input_event = usb_hidinput_input_event;
1254 hid->hid_open = usbhid_open;
1255 hid->hid_close = usbhid_close;
1256#ifdef CONFIG_USB_HIDDEV
1257 hid->hiddev_hid_event = hiddev_hid_event;
1258 hid->hiddev_report_event = hiddev_report_event;
1259#endif
2101 return hid; 1260 return hid;
2102 1261
2103fail: 1262fail:
2104 usb_free_urb(hid->urbin); 1263 usb_free_urb(usbhid->urbin);
2105 usb_free_urb(hid->urbout); 1264 usb_free_urb(usbhid->urbout);
2106 usb_free_urb(hid->urbctrl); 1265 usb_free_urb(usbhid->urbctrl);
2107 hid_free_buffers(dev, hid); 1266 hid_free_buffers(dev, hid);
2108 hid_free_device(hid); 1267 hid_free_device(hid);
2109 1268
@@ -2113,18 +1272,21 @@ fail:
2113static void hid_disconnect(struct usb_interface *intf) 1272static void hid_disconnect(struct usb_interface *intf)
2114{ 1273{
2115 struct hid_device *hid = usb_get_intfdata (intf); 1274 struct hid_device *hid = usb_get_intfdata (intf);
1275 struct usbhid_device *usbhid;
2116 1276
2117 if (!hid) 1277 if (!hid)
2118 return; 1278 return;
2119 1279
2120 spin_lock_irq(&hid->inlock); /* Sync with error handler */ 1280 usbhid = hid->driver_data;
1281
1282 spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
2121 usb_set_intfdata(intf, NULL); 1283 usb_set_intfdata(intf, NULL);
2122 spin_unlock_irq(&hid->inlock); 1284 spin_unlock_irq(&usbhid->inlock);
2123 usb_kill_urb(hid->urbin); 1285 usb_kill_urb(usbhid->urbin);
2124 usb_kill_urb(hid->urbout); 1286 usb_kill_urb(usbhid->urbout);
2125 usb_kill_urb(hid->urbctrl); 1287 usb_kill_urb(usbhid->urbctrl);
2126 1288
2127 del_timer_sync(&hid->io_retry); 1289 del_timer_sync(&usbhid->io_retry);
2128 flush_scheduled_work(); 1290 flush_scheduled_work();
2129 1291
2130 if (hid->claimed & HID_CLAIMED_INPUT) 1292 if (hid->claimed & HID_CLAIMED_INPUT)
@@ -2132,11 +1294,11 @@ static void hid_disconnect(struct usb_interface *intf)
2132 if (hid->claimed & HID_CLAIMED_HIDDEV) 1294 if (hid->claimed & HID_CLAIMED_HIDDEV)
2133 hiddev_disconnect(hid); 1295 hiddev_disconnect(hid);
2134 1296
2135 usb_free_urb(hid->urbin); 1297 usb_free_urb(usbhid->urbin);
2136 usb_free_urb(hid->urbctrl); 1298 usb_free_urb(usbhid->urbctrl);
2137 usb_free_urb(hid->urbout); 1299 usb_free_urb(usbhid->urbout);
2138 1300
2139 hid_free_buffers(hid->dev, hid); 1301 hid_free_buffers(hid_to_usb_dev(hid), hid);
2140 hid_free_device(hid); 1302 hid_free_device(hid);
2141} 1303}
2142 1304
@@ -2153,7 +1315,7 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
2153 if (!(hid = usb_hid_configure(intf))) 1315 if (!(hid = usb_hid_configure(intf)))
2154 return -ENODEV; 1316 return -ENODEV;
2155 1317
2156 hid_init_reports(hid); 1318 usbhid_init_reports(hid);
2157 hid_dump_device(hid); 1319 hid_dump_device(hid);
2158 1320
2159 if (!hidinput_connect(hid)) 1321 if (!hidinput_connect(hid))
@@ -2169,6 +1331,13 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
2169 return -ENODEV; 1331 return -ENODEV;
2170 } 1332 }
2171 1333
1334 if ((hid->claimed & HID_CLAIMED_INPUT))
1335 hid_ff_init(hid);
1336
1337 if (hid->quirks & HID_QUIRK_SONY_PS3_CONTROLLER)
1338 hid_fixup_sony_ps3_controller(interface_to_usbdev(intf),
1339 intf->cur_altsetting->desc.bInterfaceNumber);
1340
2172 printk(KERN_INFO); 1341 printk(KERN_INFO);
2173 1342
2174 if (hid->claimed & HID_CLAIMED_INPUT) 1343 if (hid->claimed & HID_CLAIMED_INPUT)
@@ -2199,12 +1368,13 @@ static int hid_probe(struct usb_interface *intf, const struct usb_device_id *id)
2199static int hid_suspend(struct usb_interface *intf, pm_message_t message) 1368static int hid_suspend(struct usb_interface *intf, pm_message_t message)
2200{ 1369{
2201 struct hid_device *hid = usb_get_intfdata (intf); 1370 struct hid_device *hid = usb_get_intfdata (intf);
1371 struct usbhid_device *usbhid = hid->driver_data;
2202 1372
2203 spin_lock_irq(&hid->inlock); /* Sync with error handler */ 1373 spin_lock_irq(&usbhid->inlock); /* Sync with error handler */
2204 set_bit(HID_SUSPENDED, &hid->iofl); 1374 set_bit(HID_SUSPENDED, &usbhid->iofl);
2205 spin_unlock_irq(&hid->inlock); 1375 spin_unlock_irq(&usbhid->inlock);
2206 del_timer(&hid->io_retry); 1376 del_timer(&usbhid->io_retry);
2207 usb_kill_urb(hid->urbin); 1377 usb_kill_urb(usbhid->urbin);
2208 dev_dbg(&intf->dev, "suspend\n"); 1378 dev_dbg(&intf->dev, "suspend\n");
2209 return 0; 1379 return 0;
2210} 1380}
@@ -2212,10 +1382,11 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
2212static int hid_resume(struct usb_interface *intf) 1382static int hid_resume(struct usb_interface *intf)
2213{ 1383{
2214 struct hid_device *hid = usb_get_intfdata (intf); 1384 struct hid_device *hid = usb_get_intfdata (intf);
1385 struct usbhid_device *usbhid = hid->driver_data;
2215 int status; 1386 int status;
2216 1387
2217 clear_bit(HID_SUSPENDED, &hid->iofl); 1388 clear_bit(HID_SUSPENDED, &usbhid->iofl);
2218 hid->retry_delay = 0; 1389 usbhid->retry_delay = 0;
2219 status = hid_start_in(hid); 1390 status = hid_start_in(hid);
2220 dev_dbg(&intf->dev, "resume status %d\n", status); 1391 dev_dbg(&intf->dev, "resume status %d\n", status);
2221 return status; 1392 return status;
diff --git a/drivers/usb/input/hid-debug.h b/drivers/usb/input/hid-debug.h
deleted file mode 100644
index f04d6d75c098..000000000000
--- a/drivers/usb/input/hid-debug.h
+++ /dev/null
@@ -1,757 +0,0 @@
1/*
2 * $Id: hid-debug.h,v 1.8 2001/09/25 09:37:57 vojtech Exp $
3 *
4 * (c) 1999 Andreas Gal <gal@cs.uni-magdeburg.de>
5 * (c) 2000-2001 Vojtech Pavlik <vojtech@ucw.cz>
6 *
7 * Some debug stuff for the HID parser.
8 */
9
10/*
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 * Should you need to contact me, the author, you can do so either by
26 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
27 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
28 */
29
30#include <linux/input.h>
31
32struct hid_usage_entry {
33 unsigned page;
34 unsigned usage;
35 char *description;
36};
37
38static const struct hid_usage_entry hid_usage_table[] = {
39 { 0, 0, "Undefined" },
40 { 1, 0, "GenericDesktop" },
41 {0, 0x01, "Pointer"},
42 {0, 0x02, "Mouse"},
43 {0, 0x04, "Joystick"},
44 {0, 0x05, "GamePad"},
45 {0, 0x06, "Keyboard"},
46 {0, 0x07, "Keypad"},
47 {0, 0x08, "MultiAxis"},
48 {0, 0x30, "X"},
49 {0, 0x31, "Y"},
50 {0, 0x32, "Z"},
51 {0, 0x33, "Rx"},
52 {0, 0x34, "Ry"},
53 {0, 0x35, "Rz"},
54 {0, 0x36, "Slider"},
55 {0, 0x37, "Dial"},
56 {0, 0x38, "Wheel"},
57 {0, 0x39, "HatSwitch"},
58 {0, 0x3a, "CountedBuffer"},
59 {0, 0x3b, "ByteCount"},
60 {0, 0x3c, "MotionWakeup"},
61 {0, 0x3d, "Start"},
62 {0, 0x3e, "Select"},
63 {0, 0x40, "Vx"},
64 {0, 0x41, "Vy"},
65 {0, 0x42, "Vz"},
66 {0, 0x43, "Vbrx"},
67 {0, 0x44, "Vbry"},
68 {0, 0x45, "Vbrz"},
69 {0, 0x46, "Vno"},
70 {0, 0x80, "SystemControl"},
71 {0, 0x81, "SystemPowerDown"},
72 {0, 0x82, "SystemSleep"},
73 {0, 0x83, "SystemWakeUp"},
74 {0, 0x84, "SystemContextMenu"},
75 {0, 0x85, "SystemMainMenu"},
76 {0, 0x86, "SystemAppMenu"},
77 {0, 0x87, "SystemMenuHelp"},
78 {0, 0x88, "SystemMenuExit"},
79 {0, 0x89, "SystemMenuSelect"},
80 {0, 0x8a, "SystemMenuRight"},
81 {0, 0x8b, "SystemMenuLeft"},
82 {0, 0x8c, "SystemMenuUp"},
83 {0, 0x8d, "SystemMenuDown"},
84 {0, 0x90, "D-PadUp"},
85 {0, 0x91, "D-PadDown"},
86 {0, 0x92, "D-PadRight"},
87 {0, 0x93, "D-PadLeft"},
88 { 2, 0, "Simulation" },
89 {0, 0xb0, "Aileron"},
90 {0, 0xb1, "AileronTrim"},
91 {0, 0xb2, "Anti-Torque"},
92 {0, 0xb3, "Autopilot"},
93 {0, 0xb4, "Chaff"},
94 {0, 0xb5, "Collective"},
95 {0, 0xb6, "DiveBrake"},
96 {0, 0xb7, "ElectronicCountermeasures"},
97 {0, 0xb8, "Elevator"},
98 {0, 0xb9, "ElevatorTrim"},
99 {0, 0xba, "Rudder"},
100 {0, 0xbb, "Throttle"},
101 {0, 0xbc, "FlightCommunications"},
102 {0, 0xbd, "FlareRelease"},
103 {0, 0xbe, "LandingGear"},
104 {0, 0xbf, "ToeBrake"},
105 { 7, 0, "Keyboard" },
106 { 8, 0, "LED" },
107 {0, 0x01, "NumLock"},
108 {0, 0x02, "CapsLock"},
109 {0, 0x03, "ScrollLock"},
110 {0, 0x04, "Compose"},
111 {0, 0x05, "Kana"},
112 {0, 0x4b, "GenericIndicator"},
113 { 9, 0, "Button" },
114 { 10, 0, "Ordinal" },
115 { 12, 0, "Consumer" },
116 {0, 0x238, "HorizontalWheel"},
117 { 13, 0, "Digitizers" },
118 {0, 0x01, "Digitizer"},
119 {0, 0x02, "Pen"},
120 {0, 0x03, "LightPen"},
121 {0, 0x04, "TouchScreen"},
122 {0, 0x05, "TouchPad"},
123 {0, 0x20, "Stylus"},
124 {0, 0x21, "Puck"},
125 {0, 0x22, "Finger"},
126 {0, 0x30, "TipPressure"},
127 {0, 0x31, "BarrelPressure"},
128 {0, 0x32, "InRange"},
129 {0, 0x33, "Touch"},
130 {0, 0x34, "UnTouch"},
131 {0, 0x35, "Tap"},
132 {0, 0x39, "TabletFunctionKey"},
133 {0, 0x3a, "ProgramChangeKey"},
134 {0, 0x3c, "Invert"},
135 {0, 0x42, "TipSwitch"},
136 {0, 0x43, "SecondaryTipSwitch"},
137 {0, 0x44, "BarrelSwitch"},
138 {0, 0x45, "Eraser"},
139 {0, 0x46, "TabletPick"},
140 { 15, 0, "PhysicalInterfaceDevice" },
141 {0, 0x00, "Undefined"},
142 {0, 0x01, "Physical_Interface_Device"},
143 {0, 0x20, "Normal"},
144 {0, 0x21, "Set_Effect_Report"},
145 {0, 0x22, "Effect_Block_Index"},
146 {0, 0x23, "Parameter_Block_Offset"},
147 {0, 0x24, "ROM_Flag"},
148 {0, 0x25, "Effect_Type"},
149 {0, 0x26, "ET_Constant_Force"},
150 {0, 0x27, "ET_Ramp"},
151 {0, 0x28, "ET_Custom_Force_Data"},
152 {0, 0x30, "ET_Square"},
153 {0, 0x31, "ET_Sine"},
154 {0, 0x32, "ET_Triangle"},
155 {0, 0x33, "ET_Sawtooth_Up"},
156 {0, 0x34, "ET_Sawtooth_Down"},
157 {0, 0x40, "ET_Spring"},
158 {0, 0x41, "ET_Damper"},
159 {0, 0x42, "ET_Inertia"},
160 {0, 0x43, "ET_Friction"},
161 {0, 0x50, "Duration"},
162 {0, 0x51, "Sample_Period"},
163 {0, 0x52, "Gain"},
164 {0, 0x53, "Trigger_Button"},
165 {0, 0x54, "Trigger_Repeat_Interval"},
166 {0, 0x55, "Axes_Enable"},
167 {0, 0x56, "Direction_Enable"},
168 {0, 0x57, "Direction"},
169 {0, 0x58, "Type_Specific_Block_Offset"},
170 {0, 0x59, "Block_Type"},
171 {0, 0x5A, "Set_Envelope_Report"},
172 {0, 0x5B, "Attack_Level"},
173 {0, 0x5C, "Attack_Time"},
174 {0, 0x5D, "Fade_Level"},
175 {0, 0x5E, "Fade_Time"},
176 {0, 0x5F, "Set_Condition_Report"},
177 {0, 0x60, "CP_Offset"},
178 {0, 0x61, "Positive_Coefficient"},
179 {0, 0x62, "Negative_Coefficient"},
180 {0, 0x63, "Positive_Saturation"},
181 {0, 0x64, "Negative_Saturation"},
182 {0, 0x65, "Dead_Band"},
183 {0, 0x66, "Download_Force_Sample"},
184 {0, 0x67, "Isoch_Custom_Force_Enable"},
185 {0, 0x68, "Custom_Force_Data_Report"},
186 {0, 0x69, "Custom_Force_Data"},
187 {0, 0x6A, "Custom_Force_Vendor_Defined_Data"},
188 {0, 0x6B, "Set_Custom_Force_Report"},
189 {0, 0x6C, "Custom_Force_Data_Offset"},
190 {0, 0x6D, "Sample_Count"},
191 {0, 0x6E, "Set_Periodic_Report"},
192 {0, 0x6F, "Offset"},
193 {0, 0x70, "Magnitude"},
194 {0, 0x71, "Phase"},
195 {0, 0x72, "Period"},
196 {0, 0x73, "Set_Constant_Force_Report"},
197 {0, 0x74, "Set_Ramp_Force_Report"},
198 {0, 0x75, "Ramp_Start"},
199 {0, 0x76, "Ramp_End"},
200 {0, 0x77, "Effect_Operation_Report"},
201 {0, 0x78, "Effect_Operation"},
202 {0, 0x79, "Op_Effect_Start"},
203 {0, 0x7A, "Op_Effect_Start_Solo"},
204 {0, 0x7B, "Op_Effect_Stop"},
205 {0, 0x7C, "Loop_Count"},
206 {0, 0x7D, "Device_Gain_Report"},
207 {0, 0x7E, "Device_Gain"},
208 {0, 0x7F, "PID_Pool_Report"},
209 {0, 0x80, "RAM_Pool_Size"},
210 {0, 0x81, "ROM_Pool_Size"},
211 {0, 0x82, "ROM_Effect_Block_Count"},
212 {0, 0x83, "Simultaneous_Effects_Max"},
213 {0, 0x84, "Pool_Alignment"},
214 {0, 0x85, "PID_Pool_Move_Report"},
215 {0, 0x86, "Move_Source"},
216 {0, 0x87, "Move_Destination"},
217 {0, 0x88, "Move_Length"},
218 {0, 0x89, "PID_Block_Load_Report"},
219 {0, 0x8B, "Block_Load_Status"},
220 {0, 0x8C, "Block_Load_Success"},
221 {0, 0x8D, "Block_Load_Full"},
222 {0, 0x8E, "Block_Load_Error"},
223 {0, 0x8F, "Block_Handle"},
224 {0, 0x90, "PID_Block_Free_Report"},
225 {0, 0x91, "Type_Specific_Block_Handle"},
226 {0, 0x92, "PID_State_Report"},
227 {0, 0x94, "Effect_Playing"},
228 {0, 0x95, "PID_Device_Control_Report"},
229 {0, 0x96, "PID_Device_Control"},
230 {0, 0x97, "DC_Enable_Actuators"},
231 {0, 0x98, "DC_Disable_Actuators"},
232 {0, 0x99, "DC_Stop_All_Effects"},
233 {0, 0x9A, "DC_Device_Reset"},
234 {0, 0x9B, "DC_Device_Pause"},
235 {0, 0x9C, "DC_Device_Continue"},
236 {0, 0x9F, "Device_Paused"},
237 {0, 0xA0, "Actuators_Enabled"},
238 {0, 0xA4, "Safety_Switch"},
239 {0, 0xA5, "Actuator_Override_Switch"},
240 {0, 0xA6, "Actuator_Power"},
241 {0, 0xA7, "Start_Delay"},
242 {0, 0xA8, "Parameter_Block_Size"},
243 {0, 0xA9, "Device_Managed_Pool"},
244 {0, 0xAA, "Shared_Parameter_Blocks"},
245 {0, 0xAB, "Create_New_Effect_Report"},
246 {0, 0xAC, "RAM_Pool_Available"},
247 { 0x84, 0, "Power Device" },
248 { 0x84, 0x02, "PresentStatus" },
249 { 0x84, 0x03, "ChangeStatus" },
250 { 0x84, 0x04, "UPS" },
251 { 0x84, 0x05, "PowerSupply" },
252 { 0x84, 0x10, "BatterySystem" },
253 { 0x84, 0x11, "BatterySystemID" },
254 { 0x84, 0x12, "Battery" },
255 { 0x84, 0x13, "BatteryID" },
256 { 0x84, 0x14, "Charger" },
257 { 0x84, 0x15, "ChargerID" },
258 { 0x84, 0x16, "PowerConverter" },
259 { 0x84, 0x17, "PowerConverterID" },
260 { 0x84, 0x18, "OutletSystem" },
261 { 0x84, 0x19, "OutletSystemID" },
262 { 0x84, 0x1a, "Input" },
263 { 0x84, 0x1b, "InputID" },
264 { 0x84, 0x1c, "Output" },
265 { 0x84, 0x1d, "OutputID" },
266 { 0x84, 0x1e, "Flow" },
267 { 0x84, 0x1f, "FlowID" },
268 { 0x84, 0x20, "Outlet" },
269 { 0x84, 0x21, "OutletID" },
270 { 0x84, 0x22, "Gang" },
271 { 0x84, 0x24, "PowerSummary" },
272 { 0x84, 0x25, "PowerSummaryID" },
273 { 0x84, 0x30, "Voltage" },
274 { 0x84, 0x31, "Current" },
275 { 0x84, 0x32, "Frequency" },
276 { 0x84, 0x33, "ApparentPower" },
277 { 0x84, 0x35, "PercentLoad" },
278 { 0x84, 0x40, "ConfigVoltage" },
279 { 0x84, 0x41, "ConfigCurrent" },
280 { 0x84, 0x43, "ConfigApparentPower" },
281 { 0x84, 0x53, "LowVoltageTransfer" },
282 { 0x84, 0x54, "HighVoltageTransfer" },
283 { 0x84, 0x56, "DelayBeforeStartup" },
284 { 0x84, 0x57, "DelayBeforeShutdown" },
285 { 0x84, 0x58, "Test" },
286 { 0x84, 0x5a, "AudibleAlarmControl" },
287 { 0x84, 0x60, "Present" },
288 { 0x84, 0x61, "Good" },
289 { 0x84, 0x62, "InternalFailure" },
290 { 0x84, 0x65, "Overload" },
291 { 0x84, 0x66, "OverCharged" },
292 { 0x84, 0x67, "OverTemperature" },
293 { 0x84, 0x68, "ShutdownRequested" },
294 { 0x84, 0x69, "ShutdownImminent" },
295 { 0x84, 0x6b, "SwitchOn/Off" },
296 { 0x84, 0x6c, "Switchable" },
297 { 0x84, 0x6d, "Used" },
298 { 0x84, 0x6e, "Boost" },
299 { 0x84, 0x73, "CommunicationLost" },
300 { 0x84, 0xfd, "iManufacturer" },
301 { 0x84, 0xfe, "iProduct" },
302 { 0x84, 0xff, "iSerialNumber" },
303 { 0x85, 0, "Battery System" },
304 { 0x85, 0x01, "SMBBatteryMode" },
305 { 0x85, 0x02, "SMBBatteryStatus" },
306 { 0x85, 0x03, "SMBAlarmWarning" },
307 { 0x85, 0x04, "SMBChargerMode" },
308 { 0x85, 0x05, "SMBChargerStatus" },
309 { 0x85, 0x06, "SMBChargerSpecInfo" },
310 { 0x85, 0x07, "SMBSelectorState" },
311 { 0x85, 0x08, "SMBSelectorPresets" },
312 { 0x85, 0x09, "SMBSelectorInfo" },
313 { 0x85, 0x29, "RemainingCapacityLimit" },
314 { 0x85, 0x2c, "CapacityMode" },
315 { 0x85, 0x42, "BelowRemainingCapacityLimit" },
316 { 0x85, 0x44, "Charging" },
317 { 0x85, 0x45, "Discharging" },
318 { 0x85, 0x4b, "NeedReplacement" },
319 { 0x85, 0x66, "RemainingCapacity" },
320 { 0x85, 0x68, "RunTimeToEmpty" },
321 { 0x85, 0x6a, "AverageTimeToFull" },
322 { 0x85, 0x83, "DesignCapacity" },
323 { 0x85, 0x85, "ManufacturerDate" },
324 { 0x85, 0x89, "iDeviceChemistry" },
325 { 0x85, 0x8b, "Rechargable" },
326 { 0x85, 0x8f, "iOEMInformation" },
327 { 0x85, 0x8d, "CapacityGranularity1" },
328 { 0x85, 0xd0, "ACPresent" },
329 /* pages 0xff00 to 0xffff are vendor-specific */
330 { 0xffff, 0, "Vendor-specific-FF" },
331 { 0, 0, NULL }
332};
333
334static void resolv_usage_page(unsigned page) {
335 const struct hid_usage_entry *p;
336
337 for (p = hid_usage_table; p->description; p++)
338 if (p->page == page) {
339 printk("%s", p->description);
340 return;
341 }
342 printk("%04x", page);
343}
344
345static void resolv_usage(unsigned usage) {
346 const struct hid_usage_entry *p;
347
348 resolv_usage_page(usage >> 16);
349 printk(".");
350 for (p = hid_usage_table; p->description; p++)
351 if (p->page == (usage >> 16)) {
352 for(++p; p->description && p->usage != 0; p++)
353 if (p->usage == (usage & 0xffff)) {
354 printk("%s", p->description);
355 return;
356 }
357 break;
358 }
359 printk("%04x", usage & 0xffff);
360}
361
362__inline__ static void tab(int n) {
363 while (n--) printk(" ");
364}
365
366static void hid_dump_field(struct hid_field *field, int n) {
367 int j;
368
369 if (field->physical) {
370 tab(n);
371 printk("Physical(");
372 resolv_usage(field->physical); printk(")\n");
373 }
374 if (field->logical) {
375 tab(n);
376 printk("Logical(");
377 resolv_usage(field->logical); printk(")\n");
378 }
379 tab(n); printk("Usage(%d)\n", field->maxusage);
380 for (j = 0; j < field->maxusage; j++) {
381 tab(n+2);resolv_usage(field->usage[j].hid); printk("\n");
382 }
383 if (field->logical_minimum != field->logical_maximum) {
384 tab(n); printk("Logical Minimum(%d)\n", field->logical_minimum);
385 tab(n); printk("Logical Maximum(%d)\n", field->logical_maximum);
386 }
387 if (field->physical_minimum != field->physical_maximum) {
388 tab(n); printk("Physical Minimum(%d)\n", field->physical_minimum);
389 tab(n); printk("Physical Maximum(%d)\n", field->physical_maximum);
390 }
391 if (field->unit_exponent) {
392 tab(n); printk("Unit Exponent(%d)\n", field->unit_exponent);
393 }
394 if (field->unit) {
395 char *systems[5] = { "None", "SI Linear", "SI Rotation", "English Linear", "English Rotation" };
396 char *units[5][8] = {
397 { "None", "None", "None", "None", "None", "None", "None", "None" },
398 { "None", "Centimeter", "Gram", "Seconds", "Kelvin", "Ampere", "Candela", "None" },
399 { "None", "Radians", "Gram", "Seconds", "Kelvin", "Ampere", "Candela", "None" },
400 { "None", "Inch", "Slug", "Seconds", "Fahrenheit", "Ampere", "Candela", "None" },
401 { "None", "Degrees", "Slug", "Seconds", "Fahrenheit", "Ampere", "Candela", "None" }
402 };
403
404 int i;
405 int sys;
406 __u32 data = field->unit;
407
408 /* First nibble tells us which system we're in. */
409 sys = data & 0xf;
410 data >>= 4;
411
412 if(sys > 4) {
413 tab(n); printk("Unit(Invalid)\n");
414 }
415 else {
416 int earlier_unit = 0;
417
418 tab(n); printk("Unit(%s : ", systems[sys]);
419
420 for (i=1 ; i<sizeof(__u32)*2 ; i++) {
421 char nibble = data & 0xf;
422 data >>= 4;
423 if (nibble != 0) {
424 if(earlier_unit++ > 0)
425 printk("*");
426 printk("%s", units[sys][i]);
427 if(nibble != 1) {
428 /* This is a _signed_ nibble(!) */
429
430 int val = nibble & 0x7;
431 if(nibble & 0x08)
432 val = -((0x7 & ~val) +1);
433 printk("^%d", val);
434 }
435 }
436 }
437 printk(")\n");
438 }
439 }
440 tab(n); printk("Report Size(%u)\n", field->report_size);
441 tab(n); printk("Report Count(%u)\n", field->report_count);
442 tab(n); printk("Report Offset(%u)\n", field->report_offset);
443
444 tab(n); printk("Flags( ");
445 j = field->flags;
446 printk("%s", HID_MAIN_ITEM_CONSTANT & j ? "Constant " : "");
447 printk("%s", HID_MAIN_ITEM_VARIABLE & j ? "Variable " : "Array ");
448 printk("%s", HID_MAIN_ITEM_RELATIVE & j ? "Relative " : "Absolute ");
449 printk("%s", HID_MAIN_ITEM_WRAP & j ? "Wrap " : "");
450 printk("%s", HID_MAIN_ITEM_NONLINEAR & j ? "NonLinear " : "");
451 printk("%s", HID_MAIN_ITEM_NO_PREFERRED & j ? "NoPrefferedState " : "");
452 printk("%s", HID_MAIN_ITEM_NULL_STATE & j ? "NullState " : "");
453 printk("%s", HID_MAIN_ITEM_VOLATILE & j ? "Volatile " : "");
454 printk("%s", HID_MAIN_ITEM_BUFFERED_BYTE & j ? "BufferedByte " : "");
455 printk(")\n");
456}
457
458static void __attribute__((unused)) hid_dump_device(struct hid_device *device) {
459 struct hid_report_enum *report_enum;
460 struct hid_report *report;
461 struct list_head *list;
462 unsigned i,k;
463 static char *table[] = {"INPUT", "OUTPUT", "FEATURE"};
464
465 for (i = 0; i < HID_REPORT_TYPES; i++) {
466 report_enum = device->report_enum + i;
467 list = report_enum->report_list.next;
468 while (list != &report_enum->report_list) {
469 report = (struct hid_report *) list;
470 tab(2);
471 printk("%s", table[i]);
472 if (report->id)
473 printk("(%d)", report->id);
474 printk("[%s]", table[report->type]);
475 printk("\n");
476 for (k = 0; k < report->maxfield; k++) {
477 tab(4);
478 printk("Field(%d)\n", k);
479 hid_dump_field(report->field[k], 6);
480 }
481 list = list->next;
482 }
483 }
484}
485
486static void __attribute__((unused)) hid_dump_input(struct hid_usage *usage, __s32 value) {
487 printk("hid-debug: input ");
488 resolv_usage(usage->hid);
489 printk(" = %d\n", value);
490}
491
492
493static char *events[EV_MAX + 1] = {
494 [EV_SYN] = "Sync", [EV_KEY] = "Key",
495 [EV_REL] = "Relative", [EV_ABS] = "Absolute",
496 [EV_MSC] = "Misc", [EV_LED] = "LED",
497 [EV_SND] = "Sound", [EV_REP] = "Repeat",
498 [EV_FF] = "ForceFeedback", [EV_PWR] = "Power",
499 [EV_FF_STATUS] = "ForceFeedbackStatus",
500};
501
502static char *syncs[2] = {
503 [SYN_REPORT] = "Report", [SYN_CONFIG] = "Config",
504};
505static char *keys[KEY_MAX + 1] = {
506 [KEY_RESERVED] = "Reserved", [KEY_ESC] = "Esc",
507 [KEY_1] = "1", [KEY_2] = "2",
508 [KEY_3] = "3", [KEY_4] = "4",
509 [KEY_5] = "5", [KEY_6] = "6",
510 [KEY_7] = "7", [KEY_8] = "8",
511 [KEY_9] = "9", [KEY_0] = "0",
512 [KEY_MINUS] = "Minus", [KEY_EQUAL] = "Equal",
513 [KEY_BACKSPACE] = "Backspace", [KEY_TAB] = "Tab",
514 [KEY_Q] = "Q", [KEY_W] = "W",
515 [KEY_E] = "E", [KEY_R] = "R",
516 [KEY_T] = "T", [KEY_Y] = "Y",
517 [KEY_U] = "U", [KEY_I] = "I",
518 [KEY_O] = "O", [KEY_P] = "P",
519 [KEY_LEFTBRACE] = "LeftBrace", [KEY_RIGHTBRACE] = "RightBrace",
520 [KEY_ENTER] = "Enter", [KEY_LEFTCTRL] = "LeftControl",
521 [KEY_A] = "A", [KEY_S] = "S",
522 [KEY_D] = "D", [KEY_F] = "F",
523 [KEY_G] = "G", [KEY_H] = "H",
524 [KEY_J] = "J", [KEY_K] = "K",
525 [KEY_L] = "L", [KEY_SEMICOLON] = "Semicolon",
526 [KEY_APOSTROPHE] = "Apostrophe", [KEY_GRAVE] = "Grave",
527 [KEY_LEFTSHIFT] = "LeftShift", [KEY_BACKSLASH] = "BackSlash",
528 [KEY_Z] = "Z", [KEY_X] = "X",
529 [KEY_C] = "C", [KEY_V] = "V",
530 [KEY_B] = "B", [KEY_N] = "N",
531 [KEY_M] = "M", [KEY_COMMA] = "Comma",
532 [KEY_DOT] = "Dot", [KEY_SLASH] = "Slash",
533 [KEY_RIGHTSHIFT] = "RightShift", [KEY_KPASTERISK] = "KPAsterisk",
534 [KEY_LEFTALT] = "LeftAlt", [KEY_SPACE] = "Space",
535 [KEY_CAPSLOCK] = "CapsLock", [KEY_F1] = "F1",
536 [KEY_F2] = "F2", [KEY_F3] = "F3",
537 [KEY_F4] = "F4", [KEY_F5] = "F5",
538 [KEY_F6] = "F6", [KEY_F7] = "F7",
539 [KEY_F8] = "F8", [KEY_F9] = "F9",
540 [KEY_F10] = "F10", [KEY_NUMLOCK] = "NumLock",
541 [KEY_SCROLLLOCK] = "ScrollLock", [KEY_KP7] = "KP7",
542 [KEY_KP8] = "KP8", [KEY_KP9] = "KP9",
543 [KEY_KPMINUS] = "KPMinus", [KEY_KP4] = "KP4",
544 [KEY_KP5] = "KP5", [KEY_KP6] = "KP6",
545 [KEY_KPPLUS] = "KPPlus", [KEY_KP1] = "KP1",
546 [KEY_KP2] = "KP2", [KEY_KP3] = "KP3",
547 [KEY_KP0] = "KP0", [KEY_KPDOT] = "KPDot",
548 [KEY_ZENKAKUHANKAKU] = "Zenkaku/Hankaku", [KEY_102ND] = "102nd",
549 [KEY_F11] = "F11", [KEY_F12] = "F12",
550 [KEY_RO] = "RO", [KEY_KATAKANA] = "Katakana",
551 [KEY_HIRAGANA] = "HIRAGANA", [KEY_HENKAN] = "Henkan",
552 [KEY_KATAKANAHIRAGANA] = "Katakana/Hiragana", [KEY_MUHENKAN] = "Muhenkan",
553 [KEY_KPJPCOMMA] = "KPJpComma", [KEY_KPENTER] = "KPEnter",
554 [KEY_RIGHTCTRL] = "RightCtrl", [KEY_KPSLASH] = "KPSlash",
555 [KEY_SYSRQ] = "SysRq", [KEY_RIGHTALT] = "RightAlt",
556 [KEY_LINEFEED] = "LineFeed", [KEY_HOME] = "Home",
557 [KEY_UP] = "Up", [KEY_PAGEUP] = "PageUp",
558 [KEY_LEFT] = "Left", [KEY_RIGHT] = "Right",
559 [KEY_END] = "End", [KEY_DOWN] = "Down",
560 [KEY_PAGEDOWN] = "PageDown", [KEY_INSERT] = "Insert",
561 [KEY_DELETE] = "Delete", [KEY_MACRO] = "Macro",
562 [KEY_MUTE] = "Mute", [KEY_VOLUMEDOWN] = "VolumeDown",
563 [KEY_VOLUMEUP] = "VolumeUp", [KEY_POWER] = "Power",
564 [KEY_KPEQUAL] = "KPEqual", [KEY_KPPLUSMINUS] = "KPPlusMinus",
565 [KEY_PAUSE] = "Pause", [KEY_KPCOMMA] = "KPComma",
566 [KEY_HANGUEL] = "Hangeul", [KEY_HANJA] = "Hanja",
567 [KEY_YEN] = "Yen", [KEY_LEFTMETA] = "LeftMeta",
568 [KEY_RIGHTMETA] = "RightMeta", [KEY_COMPOSE] = "Compose",
569 [KEY_STOP] = "Stop", [KEY_AGAIN] = "Again",
570 [KEY_PROPS] = "Props", [KEY_UNDO] = "Undo",
571 [KEY_FRONT] = "Front", [KEY_COPY] = "Copy",
572 [KEY_OPEN] = "Open", [KEY_PASTE] = "Paste",
573 [KEY_FIND] = "Find", [KEY_CUT] = "Cut",
574 [KEY_HELP] = "Help", [KEY_MENU] = "Menu",
575 [KEY_CALC] = "Calc", [KEY_SETUP] = "Setup",
576 [KEY_SLEEP] = "Sleep", [KEY_WAKEUP] = "WakeUp",
577 [KEY_FILE] = "File", [KEY_SENDFILE] = "SendFile",
578 [KEY_DELETEFILE] = "DeleteFile", [KEY_XFER] = "X-fer",
579 [KEY_PROG1] = "Prog1", [KEY_PROG2] = "Prog2",
580 [KEY_WWW] = "WWW", [KEY_MSDOS] = "MSDOS",
581 [KEY_COFFEE] = "Coffee", [KEY_DIRECTION] = "Direction",
582 [KEY_CYCLEWINDOWS] = "CycleWindows", [KEY_MAIL] = "Mail",
583 [KEY_BOOKMARKS] = "Bookmarks", [KEY_COMPUTER] = "Computer",
584 [KEY_BACK] = "Back", [KEY_FORWARD] = "Forward",
585 [KEY_CLOSECD] = "CloseCD", [KEY_EJECTCD] = "EjectCD",
586 [KEY_EJECTCLOSECD] = "EjectCloseCD", [KEY_NEXTSONG] = "NextSong",
587 [KEY_PLAYPAUSE] = "PlayPause", [KEY_PREVIOUSSONG] = "PreviousSong",
588 [KEY_STOPCD] = "StopCD", [KEY_RECORD] = "Record",
589 [KEY_REWIND] = "Rewind", [KEY_PHONE] = "Phone",
590 [KEY_ISO] = "ISOKey", [KEY_CONFIG] = "Config",
591 [KEY_HOMEPAGE] = "HomePage", [KEY_REFRESH] = "Refresh",
592 [KEY_EXIT] = "Exit", [KEY_MOVE] = "Move",
593 [KEY_EDIT] = "Edit", [KEY_SCROLLUP] = "ScrollUp",
594 [KEY_SCROLLDOWN] = "ScrollDown", [KEY_KPLEFTPAREN] = "KPLeftParenthesis",
595 [KEY_KPRIGHTPAREN] = "KPRightParenthesis", [KEY_NEW] = "New",
596 [KEY_REDO] = "Redo", [KEY_F13] = "F13",
597 [KEY_F14] = "F14", [KEY_F15] = "F15",
598 [KEY_F16] = "F16", [KEY_F17] = "F17",
599 [KEY_F18] = "F18", [KEY_F19] = "F19",
600 [KEY_F20] = "F20", [KEY_F21] = "F21",
601 [KEY_F22] = "F22", [KEY_F23] = "F23",
602 [KEY_F24] = "F24", [KEY_PLAYCD] = "PlayCD",
603 [KEY_PAUSECD] = "PauseCD", [KEY_PROG3] = "Prog3",
604 [KEY_PROG4] = "Prog4", [KEY_SUSPEND] = "Suspend",
605 [KEY_CLOSE] = "Close", [KEY_PLAY] = "Play",
606 [KEY_FASTFORWARD] = "FastForward", [KEY_BASSBOOST] = "BassBoost",
607 [KEY_PRINT] = "Print", [KEY_HP] = "HP",
608 [KEY_CAMERA] = "Camera", [KEY_SOUND] = "Sound",
609 [KEY_QUESTION] = "Question", [KEY_EMAIL] = "Email",
610 [KEY_CHAT] = "Chat", [KEY_SEARCH] = "Search",
611 [KEY_CONNECT] = "Connect", [KEY_FINANCE] = "Finance",
612 [KEY_SPORT] = "Sport", [KEY_SHOP] = "Shop",
613 [KEY_ALTERASE] = "AlternateErase", [KEY_CANCEL] = "Cancel",
614 [KEY_BRIGHTNESSDOWN] = "BrightnessDown", [KEY_BRIGHTNESSUP] = "BrightnessUp",
615 [KEY_MEDIA] = "Media", [KEY_UNKNOWN] = "Unknown",
616 [BTN_0] = "Btn0", [BTN_1] = "Btn1",
617 [BTN_2] = "Btn2", [BTN_3] = "Btn3",
618 [BTN_4] = "Btn4", [BTN_5] = "Btn5",
619 [BTN_6] = "Btn6", [BTN_7] = "Btn7",
620 [BTN_8] = "Btn8", [BTN_9] = "Btn9",
621 [BTN_LEFT] = "LeftBtn", [BTN_RIGHT] = "RightBtn",
622 [BTN_MIDDLE] = "MiddleBtn", [BTN_SIDE] = "SideBtn",
623 [BTN_EXTRA] = "ExtraBtn", [BTN_FORWARD] = "ForwardBtn",
624 [BTN_BACK] = "BackBtn", [BTN_TASK] = "TaskBtn",
625 [BTN_TRIGGER] = "Trigger", [BTN_THUMB] = "ThumbBtn",
626 [BTN_THUMB2] = "ThumbBtn2", [BTN_TOP] = "TopBtn",
627 [BTN_TOP2] = "TopBtn2", [BTN_PINKIE] = "PinkieBtn",
628 [BTN_BASE] = "BaseBtn", [BTN_BASE2] = "BaseBtn2",
629 [BTN_BASE3] = "BaseBtn3", [BTN_BASE4] = "BaseBtn4",
630 [BTN_BASE5] = "BaseBtn5", [BTN_BASE6] = "BaseBtn6",
631 [BTN_DEAD] = "BtnDead", [BTN_A] = "BtnA",
632 [BTN_B] = "BtnB", [BTN_C] = "BtnC",
633 [BTN_X] = "BtnX", [BTN_Y] = "BtnY",
634 [BTN_Z] = "BtnZ", [BTN_TL] = "BtnTL",
635 [BTN_TR] = "BtnTR", [BTN_TL2] = "BtnTL2",
636 [BTN_TR2] = "BtnTR2", [BTN_SELECT] = "BtnSelect",
637 [BTN_START] = "BtnStart", [BTN_MODE] = "BtnMode",
638 [BTN_THUMBL] = "BtnThumbL", [BTN_THUMBR] = "BtnThumbR",
639 [BTN_TOOL_PEN] = "ToolPen", [BTN_TOOL_RUBBER] = "ToolRubber",
640 [BTN_TOOL_BRUSH] = "ToolBrush", [BTN_TOOL_PENCIL] = "ToolPencil",
641 [BTN_TOOL_AIRBRUSH] = "ToolAirbrush", [BTN_TOOL_FINGER] = "ToolFinger",
642 [BTN_TOOL_MOUSE] = "ToolMouse", [BTN_TOOL_LENS] = "ToolLens",
643 [BTN_TOUCH] = "Touch", [BTN_STYLUS] = "Stylus",
644 [BTN_STYLUS2] = "Stylus2", [BTN_TOOL_DOUBLETAP] = "ToolDoubleTap",
645 [BTN_TOOL_TRIPLETAP] = "ToolTripleTap", [BTN_GEAR_DOWN] = "WheelBtn",
646 [BTN_GEAR_UP] = "Gear up", [KEY_OK] = "Ok",
647 [KEY_SELECT] = "Select", [KEY_GOTO] = "Goto",
648 [KEY_CLEAR] = "Clear", [KEY_POWER2] = "Power2",
649 [KEY_OPTION] = "Option", [KEY_INFO] = "Info",
650 [KEY_TIME] = "Time", [KEY_VENDOR] = "Vendor",
651 [KEY_ARCHIVE] = "Archive", [KEY_PROGRAM] = "Program",
652 [KEY_CHANNEL] = "Channel", [KEY_FAVORITES] = "Favorites",
653 [KEY_EPG] = "EPG", [KEY_PVR] = "PVR",
654 [KEY_MHP] = "MHP", [KEY_LANGUAGE] = "Language",
655 [KEY_TITLE] = "Title", [KEY_SUBTITLE] = "Subtitle",
656 [KEY_ANGLE] = "Angle", [KEY_ZOOM] = "Zoom",
657 [KEY_MODE] = "Mode", [KEY_KEYBOARD] = "Keyboard",
658 [KEY_SCREEN] = "Screen", [KEY_PC] = "PC",
659 [KEY_TV] = "TV", [KEY_TV2] = "TV2",
660 [KEY_VCR] = "VCR", [KEY_VCR2] = "VCR2",
661 [KEY_SAT] = "Sat", [KEY_SAT2] = "Sat2",
662 [KEY_CD] = "CD", [KEY_TAPE] = "Tape",
663 [KEY_RADIO] = "Radio", [KEY_TUNER] = "Tuner",
664 [KEY_PLAYER] = "Player", [KEY_TEXT] = "Text",
665 [KEY_DVD] = "DVD", [KEY_AUX] = "Aux",
666 [KEY_MP3] = "MP3", [KEY_AUDIO] = "Audio",
667 [KEY_VIDEO] = "Video", [KEY_DIRECTORY] = "Directory",
668 [KEY_LIST] = "List", [KEY_MEMO] = "Memo",
669 [KEY_CALENDAR] = "Calendar", [KEY_RED] = "Red",
670 [KEY_GREEN] = "Green", [KEY_YELLOW] = "Yellow",
671 [KEY_BLUE] = "Blue", [KEY_CHANNELUP] = "ChannelUp",
672 [KEY_CHANNELDOWN] = "ChannelDown", [KEY_FIRST] = "First",
673 [KEY_LAST] = "Last", [KEY_AB] = "AB",
674 [KEY_NEXT] = "Next", [KEY_RESTART] = "Restart",
675 [KEY_SLOW] = "Slow", [KEY_SHUFFLE] = "Shuffle",
676 [KEY_BREAK] = "Break", [KEY_PREVIOUS] = "Previous",
677 [KEY_DIGITS] = "Digits", [KEY_TEEN] = "TEEN",
678 [KEY_TWEN] = "TWEN", [KEY_DEL_EOL] = "DeleteEOL",
679 [KEY_DEL_EOS] = "DeleteEOS", [KEY_INS_LINE] = "InsertLine",
680 [KEY_DEL_LINE] = "DeleteLine",
681 [KEY_SEND] = "Send", [KEY_REPLY] = "Reply",
682 [KEY_FORWARDMAIL] = "ForwardMail", [KEY_SAVE] = "Save",
683 [KEY_DOCUMENTS] = "Documents",
684 [KEY_FN] = "Fn", [KEY_FN_ESC] = "Fn+ESC",
685 [KEY_FN_1] = "Fn+1", [KEY_FN_2] = "Fn+2",
686 [KEY_FN_B] = "Fn+B", [KEY_FN_D] = "Fn+D",
687 [KEY_FN_E] = "Fn+E", [KEY_FN_F] = "Fn+F",
688 [KEY_FN_S] = "Fn+S",
689 [KEY_FN_F1] = "Fn+F1", [KEY_FN_F2] = "Fn+F2",
690 [KEY_FN_F3] = "Fn+F3", [KEY_FN_F4] = "Fn+F4",
691 [KEY_FN_F5] = "Fn+F5", [KEY_FN_F6] = "Fn+F6",
692 [KEY_FN_F7] = "Fn+F7", [KEY_FN_F8] = "Fn+F8",
693 [KEY_FN_F9] = "Fn+F9", [KEY_FN_F10] = "Fn+F10",
694 [KEY_FN_F11] = "Fn+F11", [KEY_FN_F12] = "Fn+F12",
695 [KEY_KBDILLUMTOGGLE] = "KbdIlluminationToggle",
696 [KEY_KBDILLUMDOWN] = "KbdIlluminationDown",
697 [KEY_KBDILLUMUP] = "KbdIlluminationUp",
698 [KEY_SWITCHVIDEOMODE] = "SwitchVideoMode",
699};
700
701static char *relatives[REL_MAX + 1] = {
702 [REL_X] = "X", [REL_Y] = "Y",
703 [REL_Z] = "Z", [REL_HWHEEL] = "HWheel",
704 [REL_DIAL] = "Dial", [REL_WHEEL] = "Wheel",
705 [REL_MISC] = "Misc",
706};
707
708static char *absolutes[ABS_MAX + 1] = {
709 [ABS_X] = "X", [ABS_Y] = "Y",
710 [ABS_Z] = "Z", [ABS_RX] = "Rx",
711 [ABS_RY] = "Ry", [ABS_RZ] = "Rz",
712 [ABS_THROTTLE] = "Throttle", [ABS_RUDDER] = "Rudder",
713 [ABS_WHEEL] = "Wheel", [ABS_GAS] = "Gas",
714 [ABS_BRAKE] = "Brake", [ABS_HAT0X] = "Hat0X",
715 [ABS_HAT0Y] = "Hat0Y", [ABS_HAT1X] = "Hat1X",
716 [ABS_HAT1Y] = "Hat1Y", [ABS_HAT2X] = "Hat2X",
717 [ABS_HAT2Y] = "Hat2Y", [ABS_HAT3X] = "Hat3X",
718 [ABS_HAT3Y] = "Hat 3Y", [ABS_PRESSURE] = "Pressure",
719 [ABS_DISTANCE] = "Distance", [ABS_TILT_X] = "XTilt",
720 [ABS_TILT_Y] = "YTilt", [ABS_TOOL_WIDTH] = "Tool Width",
721 [ABS_VOLUME] = "Volume", [ABS_MISC] = "Misc",
722};
723
724static char *misc[MSC_MAX + 1] = {
725 [MSC_SERIAL] = "Serial", [MSC_PULSELED] = "Pulseled",
726 [MSC_GESTURE] = "Gesture", [MSC_RAW] = "RawData"
727};
728
729static char *leds[LED_MAX + 1] = {
730 [LED_NUML] = "NumLock", [LED_CAPSL] = "CapsLock",
731 [LED_SCROLLL] = "ScrollLock", [LED_COMPOSE] = "Compose",
732 [LED_KANA] = "Kana", [LED_SLEEP] = "Sleep",
733 [LED_SUSPEND] = "Suspend", [LED_MUTE] = "Mute",
734 [LED_MISC] = "Misc",
735};
736
737static char *repeats[REP_MAX + 1] = {
738 [REP_DELAY] = "Delay", [REP_PERIOD] = "Period"
739};
740
741static char *sounds[SND_MAX + 1] = {
742 [SND_CLICK] = "Click", [SND_BELL] = "Bell",
743 [SND_TONE] = "Tone"
744};
745
746static char **names[EV_MAX + 1] = {
747 [EV_SYN] = syncs, [EV_KEY] = keys,
748 [EV_REL] = relatives, [EV_ABS] = absolutes,
749 [EV_MSC] = misc, [EV_LED] = leds,
750 [EV_SND] = sounds, [EV_REP] = repeats,
751};
752
753static void __attribute__((unused)) resolv_event(__u8 type, __u16 code) {
754
755 printk("%s.%s", events[type] ? events[type] : "?",
756 names[type] ? (names[type][code] ? names[type][code] : "?") : "?");
757}
diff --git a/drivers/usb/input/hid-ff.c b/drivers/usb/input/hid-ff.c
index 0d644fa37c68..bc7f8e6f8c97 100644
--- a/drivers/usb/input/hid-ff.c
+++ b/drivers/usb/input/hid-ff.c
@@ -32,7 +32,8 @@
32#undef DEBUG 32#undef DEBUG
33#include <linux/usb.h> 33#include <linux/usb.h>
34 34
35#include "hid.h" 35#include <linux/hid.h>
36#include "usbhid.h"
36 37
37/* 38/*
38 * This table contains pointers to initializers. To add support for new 39 * This table contains pointers to initializers. To add support for new
@@ -58,6 +59,9 @@ static struct hid_ff_initializer inits[] = {
58 { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */ 59 { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */
59 { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */ 60 { 0x46d, 0xca03, hid_lgff_init }, /* Logitech MOMO force wheel */
60#endif 61#endif
62#ifdef CONFIG_PANTHERLORD_FF
63 { 0x810, 0x0001, hid_plff_init },
64#endif
61#ifdef CONFIG_THRUSTMASTER_FF 65#ifdef CONFIG_THRUSTMASTER_FF
62 { 0x44f, 0xb304, hid_tmff_init }, 66 { 0x44f, 0xb304, hid_tmff_init },
63#endif 67#endif
@@ -71,8 +75,8 @@ static struct hid_ff_initializer inits[] = {
71int hid_ff_init(struct hid_device* hid) 75int hid_ff_init(struct hid_device* hid)
72{ 76{
73 struct hid_ff_initializer *init; 77 struct hid_ff_initializer *init;
74 int vendor = le16_to_cpu(hid->dev->descriptor.idVendor); 78 int vendor = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idVendor);
75 int product = le16_to_cpu(hid->dev->descriptor.idProduct); 79 int product = le16_to_cpu(hid_to_usb_dev(hid)->descriptor.idProduct);
76 80
77 for (init = inits; init->idVendor; init++) 81 for (init = inits; init->idVendor; init++)
78 if (init->idVendor == vendor && init->idProduct == product) 82 if (init->idVendor == vendor && init->idProduct == product)
@@ -80,3 +84,5 @@ int hid_ff_init(struct hid_device* hid)
80 84
81 return init->init(hid); 85 return init->init(hid);
82} 86}
87EXPORT_SYMBOL_GPL(hid_ff_init);
88
diff --git a/drivers/usb/input/hid-input.c b/drivers/usb/input/hid-input.c
deleted file mode 100644
index 3a7e5fbff025..000000000000
--- a/drivers/usb/input/hid-input.c
+++ /dev/null
@@ -1,872 +0,0 @@
1/*
2 * $Id: hid-input.c,v 1.2 2002/04/23 00:59:25 rdamazio Exp $
3 *
4 * Copyright (c) 2000-2001 Vojtech Pavlik
5 *
6 * USB HID to Linux Input mapping
7 */
8
9/*
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
23 *
24 * Should you need to contact me, the author, you can do so either by
25 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
26 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
27 */
28
29#include <linux/module.h>
30#include <linux/slab.h>
31#include <linux/kernel.h>
32#include <linux/usb/input.h>
33
34#undef DEBUG
35
36#include "hid.h"
37
38#define unk KEY_UNKNOWN
39
40static const unsigned char hid_keyboard[256] = {
41 0, 0, 0, 0, 30, 48, 46, 32, 18, 33, 34, 35, 23, 36, 37, 38,
42 50, 49, 24, 25, 16, 19, 31, 20, 22, 47, 17, 45, 21, 44, 2, 3,
43 4, 5, 6, 7, 8, 9, 10, 11, 28, 1, 14, 15, 57, 12, 13, 26,
44 27, 43, 43, 39, 40, 41, 51, 52, 53, 58, 59, 60, 61, 62, 63, 64,
45 65, 66, 67, 68, 87, 88, 99, 70,119,110,102,104,111,107,109,106,
46 105,108,103, 69, 98, 55, 74, 78, 96, 79, 80, 81, 75, 76, 77, 71,
47 72, 73, 82, 83, 86,127,116,117,183,184,185,186,187,188,189,190,
48 191,192,193,194,134,138,130,132,128,129,131,137,133,135,136,113,
49 115,114,unk,unk,unk,121,unk, 89, 93,124, 92, 94, 95,unk,unk,unk,
50 122,123, 90, 91, 85,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
51 unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
52 unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
53 unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
54 unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,unk,
55 29, 42, 56,125, 97, 54,100,126,164,166,165,163,161,115,114,113,
56 150,158,159,128,136,177,178,176,142,152,173,140,unk,unk,unk,unk
57};
58
59static const struct {
60 __s32 x;
61 __s32 y;
62} hid_hat_to_axis[] = {{ 0, 0}, { 0,-1}, { 1,-1}, { 1, 0}, { 1, 1}, { 0, 1}, {-1, 1}, {-1, 0}, {-1,-1}};
63
64#define map_abs(c) do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
65#define map_rel(c) do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
66#define map_key(c) do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
67#define map_led(c) do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
68
69#define map_abs_clear(c) do { map_abs(c); clear_bit(c, bit); } while (0)
70#define map_key_clear(c) do { map_key(c); clear_bit(c, bit); } while (0)
71
72#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
73
74struct hidinput_key_translation {
75 u16 from;
76 u16 to;
77 u8 flags;
78};
79
80#define POWERBOOK_FLAG_FKEY 0x01
81
82static struct hidinput_key_translation powerbook_fn_keys[] = {
83 { KEY_BACKSPACE, KEY_DELETE },
84 { KEY_F1, KEY_BRIGHTNESSDOWN, POWERBOOK_FLAG_FKEY },
85 { KEY_F2, KEY_BRIGHTNESSUP, POWERBOOK_FLAG_FKEY },
86 { KEY_F3, KEY_MUTE, POWERBOOK_FLAG_FKEY },
87 { KEY_F4, KEY_VOLUMEDOWN, POWERBOOK_FLAG_FKEY },
88 { KEY_F5, KEY_VOLUMEUP, POWERBOOK_FLAG_FKEY },
89 { KEY_F6, KEY_NUMLOCK, POWERBOOK_FLAG_FKEY },
90 { KEY_F7, KEY_SWITCHVIDEOMODE, POWERBOOK_FLAG_FKEY },
91 { KEY_F8, KEY_KBDILLUMTOGGLE, POWERBOOK_FLAG_FKEY },
92 { KEY_F9, KEY_KBDILLUMDOWN, POWERBOOK_FLAG_FKEY },
93 { KEY_F10, KEY_KBDILLUMUP, POWERBOOK_FLAG_FKEY },
94 { KEY_UP, KEY_PAGEUP },
95 { KEY_DOWN, KEY_PAGEDOWN },
96 { KEY_LEFT, KEY_HOME },
97 { KEY_RIGHT, KEY_END },
98 { }
99};
100
101static struct hidinput_key_translation powerbook_numlock_keys[] = {
102 { KEY_J, KEY_KP1 },
103 { KEY_K, KEY_KP2 },
104 { KEY_L, KEY_KP3 },
105 { KEY_U, KEY_KP4 },
106 { KEY_I, KEY_KP5 },
107 { KEY_O, KEY_KP6 },
108 { KEY_7, KEY_KP7 },
109 { KEY_8, KEY_KP8 },
110 { KEY_9, KEY_KP9 },
111 { KEY_M, KEY_KP0 },
112 { KEY_DOT, KEY_KPDOT },
113 { KEY_SLASH, KEY_KPPLUS },
114 { KEY_SEMICOLON, KEY_KPMINUS },
115 { KEY_P, KEY_KPASTERISK },
116 { KEY_MINUS, KEY_KPEQUAL },
117 { KEY_0, KEY_KPSLASH },
118 { KEY_F6, KEY_NUMLOCK },
119 { KEY_KPENTER, KEY_KPENTER },
120 { KEY_BACKSPACE, KEY_BACKSPACE },
121 { }
122};
123
124static struct hidinput_key_translation powerbook_iso_keyboard[] = {
125 { KEY_GRAVE, KEY_102ND },
126 { KEY_102ND, KEY_GRAVE },
127 { }
128};
129
130static int usbhid_pb_fnmode = 1;
131module_param_named(pb_fnmode, usbhid_pb_fnmode, int, 0644);
132MODULE_PARM_DESC(pb_fnmode,
133 "Mode of fn key on PowerBooks (0 = disabled, 1 = fkeyslast, 2 = fkeysfirst)");
134
135static struct hidinput_key_translation *find_translation(struct hidinput_key_translation *table, u16 from)
136{
137 struct hidinput_key_translation *trans;
138
139 /* Look for the translation */
140 for (trans = table; trans->from; trans++)
141 if (trans->from == from)
142 return trans;
143
144 return NULL;
145}
146
147static int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
148 struct hid_usage *usage, __s32 value)
149{
150 struct hidinput_key_translation *trans;
151
152 if (usage->code == KEY_FN) {
153 if (value) hid->quirks |= HID_QUIRK_POWERBOOK_FN_ON;
154 else hid->quirks &= ~HID_QUIRK_POWERBOOK_FN_ON;
155
156 input_event(input, usage->type, usage->code, value);
157
158 return 1;
159 }
160
161 if (usbhid_pb_fnmode) {
162 int do_translate;
163
164 trans = find_translation(powerbook_fn_keys, usage->code);
165 if (trans) {
166 if (test_bit(usage->code, hid->pb_pressed_fn))
167 do_translate = 1;
168 else if (trans->flags & POWERBOOK_FLAG_FKEY)
169 do_translate =
170 (usbhid_pb_fnmode == 2 && (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON)) ||
171 (usbhid_pb_fnmode == 1 && !(hid->quirks & HID_QUIRK_POWERBOOK_FN_ON));
172 else
173 do_translate = (hid->quirks & HID_QUIRK_POWERBOOK_FN_ON);
174
175 if (do_translate) {
176 if (value)
177 set_bit(usage->code, hid->pb_pressed_fn);
178 else
179 clear_bit(usage->code, hid->pb_pressed_fn);
180
181 input_event(input, usage->type, trans->to, value);
182
183 return 1;
184 }
185 }
186
187 if (test_bit(usage->code, hid->pb_pressed_numlock) ||
188 test_bit(LED_NUML, input->led)) {
189 trans = find_translation(powerbook_numlock_keys, usage->code);
190
191 if (trans) {
192 if (value)
193 set_bit(usage->code, hid->pb_pressed_numlock);
194 else
195 clear_bit(usage->code, hid->pb_pressed_numlock);
196
197 input_event(input, usage->type, trans->to, value);
198 }
199
200 return 1;
201 }
202 }
203
204 if (hid->quirks & HID_QUIRK_POWERBOOK_ISO_KEYBOARD) {
205 trans = find_translation(powerbook_iso_keyboard, usage->code);
206 if (trans) {
207 input_event(input, usage->type, trans->to, value);
208 return 1;
209 }
210 }
211
212 return 0;
213}
214
215static void hidinput_pb_setup(struct input_dev *input)
216{
217 struct hidinput_key_translation *trans;
218
219 set_bit(KEY_NUMLOCK, input->keybit);
220
221 /* Enable all needed keys */
222 for (trans = powerbook_fn_keys; trans->from; trans++)
223 set_bit(trans->to, input->keybit);
224
225 for (trans = powerbook_numlock_keys; trans->from; trans++)
226 set_bit(trans->to, input->keybit);
227
228 for (trans = powerbook_iso_keyboard; trans->from; trans++)
229 set_bit(trans->to, input->keybit);
230}
231#else
232static inline int hidinput_pb_event(struct hid_device *hid, struct input_dev *input,
233 struct hid_usage *usage, __s32 value)
234{
235 return 0;
236}
237
238static inline void hidinput_pb_setup(struct input_dev *input)
239{
240}
241#endif
242
243static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_field *field,
244 struct hid_usage *usage)
245{
246 struct input_dev *input = hidinput->input;
247 struct hid_device *device = input->private;
248 int max = 0, code;
249 unsigned long *bit = NULL;
250
251 field->hidinput = hidinput;
252
253#ifdef DEBUG
254 printk(KERN_DEBUG "Mapping: ");
255 resolv_usage(usage->hid);
256 printk(" ---> ");
257#endif
258
259 if (field->flags & HID_MAIN_ITEM_CONSTANT)
260 goto ignore;
261
262 switch (usage->hid & HID_USAGE_PAGE) {
263
264 case HID_UP_UNDEFINED:
265 goto ignore;
266
267 case HID_UP_KEYBOARD:
268
269 set_bit(EV_REP, input->evbit);
270
271 if ((usage->hid & HID_USAGE) < 256) {
272 if (!hid_keyboard[usage->hid & HID_USAGE]) goto ignore;
273 map_key_clear(hid_keyboard[usage->hid & HID_USAGE]);
274 } else
275 map_key(KEY_UNKNOWN);
276
277 break;
278
279 case HID_UP_BUTTON:
280
281 code = ((usage->hid - 1) & 0xf);
282
283 switch (field->application) {
284 case HID_GD_MOUSE:
285 case HID_GD_POINTER: code += 0x110; break;
286 case HID_GD_JOYSTICK: code += 0x120; break;
287 case HID_GD_GAMEPAD: code += 0x130; break;
288 default:
289 switch (field->physical) {
290 case HID_GD_MOUSE:
291 case HID_GD_POINTER: code += 0x110; break;
292 case HID_GD_JOYSTICK: code += 0x120; break;
293 case HID_GD_GAMEPAD: code += 0x130; break;
294 default: code += 0x100;
295 }
296 }
297
298 map_key(code);
299 break;
300
301
302 case HID_UP_SIMULATION:
303
304 switch (usage->hid & 0xffff) {
305 case 0xba: map_abs(ABS_RUDDER); break;
306 case 0xbb: map_abs(ABS_THROTTLE); break;
307 case 0xc4: map_abs(ABS_GAS); break;
308 case 0xc5: map_abs(ABS_BRAKE); break;
309 case 0xc8: map_abs(ABS_WHEEL); break;
310 default: goto ignore;
311 }
312 break;
313
314 case HID_UP_GENDESK:
315
316 if ((usage->hid & 0xf0) == 0x80) { /* SystemControl */
317 switch (usage->hid & 0xf) {
318 case 0x1: map_key_clear(KEY_POWER); break;
319 case 0x2: map_key_clear(KEY_SLEEP); break;
320 case 0x3: map_key_clear(KEY_WAKEUP); break;
321 default: goto unknown;
322 }
323 break;
324 }
325
326 if ((usage->hid & 0xf0) == 0x90) { /* D-pad */
327 switch (usage->hid) {
328 case HID_GD_UP: usage->hat_dir = 1; break;
329 case HID_GD_DOWN: usage->hat_dir = 5; break;
330 case HID_GD_RIGHT: usage->hat_dir = 3; break;
331 case HID_GD_LEFT: usage->hat_dir = 7; break;
332 default: goto unknown;
333 }
334 if (field->dpad) {
335 map_abs(field->dpad);
336 goto ignore;
337 }
338 map_abs(ABS_HAT0X);
339 break;
340 }
341
342 switch (usage->hid) {
343
344 /* These usage IDs map directly to the usage codes. */
345 case HID_GD_X: case HID_GD_Y: case HID_GD_Z:
346 case HID_GD_RX: case HID_GD_RY: case HID_GD_RZ:
347 case HID_GD_SLIDER: case HID_GD_DIAL: case HID_GD_WHEEL:
348 if (field->flags & HID_MAIN_ITEM_RELATIVE)
349 map_rel(usage->hid & 0xf);
350 else
351 map_abs(usage->hid & 0xf);
352 break;
353
354 case HID_GD_HATSWITCH:
355 usage->hat_min = field->logical_minimum;
356 usage->hat_max = field->logical_maximum;
357 map_abs(ABS_HAT0X);
358 break;
359
360 case HID_GD_START: map_key_clear(BTN_START); break;
361 case HID_GD_SELECT: map_key_clear(BTN_SELECT); break;
362
363 default: goto unknown;
364 }
365
366 break;
367
368 case HID_UP_LED:
369 if (((usage->hid - 1) & 0xffff) >= LED_MAX)
370 goto ignore;
371 map_led((usage->hid - 1) & 0xffff);
372 break;
373
374 case HID_UP_DIGITIZER:
375
376 switch (usage->hid & 0xff) {
377
378 case 0x30: /* TipPressure */
379 if (!test_bit(BTN_TOUCH, input->keybit)) {
380 device->quirks |= HID_QUIRK_NOTOUCH;
381 set_bit(EV_KEY, input->evbit);
382 set_bit(BTN_TOUCH, input->keybit);
383 }
384
385 map_abs_clear(ABS_PRESSURE);
386 break;
387
388 case 0x32: /* InRange */
389 switch (field->physical & 0xff) {
390 case 0x21: map_key(BTN_TOOL_MOUSE); break;
391 case 0x22: map_key(BTN_TOOL_FINGER); break;
392 default: map_key(BTN_TOOL_PEN); break;
393 }
394 break;
395
396 case 0x3c: /* Invert */
397 map_key_clear(BTN_TOOL_RUBBER);
398 break;
399
400 case 0x33: /* Touch */
401 case 0x42: /* TipSwitch */
402 case 0x43: /* TipSwitch2 */
403 device->quirks &= ~HID_QUIRK_NOTOUCH;
404 map_key_clear(BTN_TOUCH);
405 break;
406
407 case 0x44: /* BarrelSwitch */
408 map_key_clear(BTN_STYLUS);
409 break;
410
411 default: goto unknown;
412 }
413 break;
414
415 case HID_UP_CONSUMER: /* USB HUT v1.1, pages 56-62 */
416
417 switch (usage->hid & HID_USAGE) {
418 case 0x000: goto ignore;
419 case 0x034: map_key_clear(KEY_SLEEP); break;
420 case 0x036: map_key_clear(BTN_MISC); break;
421 case 0x045: map_key_clear(KEY_RADIO); break;
422 case 0x08a: map_key_clear(KEY_WWW); break;
423 case 0x08d: map_key_clear(KEY_PROGRAM); break;
424 case 0x095: map_key_clear(KEY_HELP); break;
425 case 0x09c: map_key_clear(KEY_CHANNELUP); break;
426 case 0x09d: map_key_clear(KEY_CHANNELDOWN); break;
427 case 0x0b0: map_key_clear(KEY_PLAY); break;
428 case 0x0b1: map_key_clear(KEY_PAUSE); break;
429 case 0x0b2: map_key_clear(KEY_RECORD); break;
430 case 0x0b3: map_key_clear(KEY_FASTFORWARD); break;
431 case 0x0b4: map_key_clear(KEY_REWIND); break;
432 case 0x0b5: map_key_clear(KEY_NEXTSONG); break;
433 case 0x0b6: map_key_clear(KEY_PREVIOUSSONG); break;
434 case 0x0b7: map_key_clear(KEY_STOPCD); break;
435 case 0x0b8: map_key_clear(KEY_EJECTCD); break;
436 case 0x0cd: map_key_clear(KEY_PLAYPAUSE); break;
437 case 0x0e0: map_abs_clear(ABS_VOLUME); break;
438 case 0x0e2: map_key_clear(KEY_MUTE); break;
439 case 0x0e5: map_key_clear(KEY_BASSBOOST); break;
440 case 0x0e9: map_key_clear(KEY_VOLUMEUP); break;
441 case 0x0ea: map_key_clear(KEY_VOLUMEDOWN); break;
442 case 0x183: map_key_clear(KEY_CONFIG); break;
443 case 0x18a: map_key_clear(KEY_MAIL); break;
444 case 0x192: map_key_clear(KEY_CALC); break;
445 case 0x194: map_key_clear(KEY_FILE); break;
446 case 0x1a7: map_key_clear(KEY_DOCUMENTS); break;
447 case 0x201: map_key_clear(KEY_NEW); break;
448 case 0x207: map_key_clear(KEY_SAVE); break;
449 case 0x208: map_key_clear(KEY_PRINT); break;
450 case 0x209: map_key_clear(KEY_PROPS); break;
451 case 0x21a: map_key_clear(KEY_UNDO); break;
452 case 0x21b: map_key_clear(KEY_COPY); break;
453 case 0x21c: map_key_clear(KEY_CUT); break;
454 case 0x21d: map_key_clear(KEY_PASTE); break;
455 case 0x221: map_key_clear(KEY_FIND); break;
456 case 0x223: map_key_clear(KEY_HOMEPAGE); break;
457 case 0x224: map_key_clear(KEY_BACK); break;
458 case 0x225: map_key_clear(KEY_FORWARD); break;
459 case 0x226: map_key_clear(KEY_STOP); break;
460 case 0x227: map_key_clear(KEY_REFRESH); break;
461 case 0x22a: map_key_clear(KEY_BOOKMARKS); break;
462 case 0x233: map_key_clear(KEY_SCROLLUP); break;
463 case 0x234: map_key_clear(KEY_SCROLLDOWN); break;
464 case 0x238: map_rel(REL_HWHEEL); break;
465 case 0x279: map_key_clear(KEY_REDO); break;
466 case 0x289: map_key_clear(KEY_REPLY); break;
467 case 0x28b: map_key_clear(KEY_FORWARDMAIL); break;
468 case 0x28c: map_key_clear(KEY_SEND); break;
469
470 /* Reported on a Cherry Cymotion keyboard */
471 case 0x301: map_key_clear(KEY_PROG1); break;
472 case 0x302: map_key_clear(KEY_PROG2); break;
473 case 0x303: map_key_clear(KEY_PROG3); break;
474
475 default: goto ignore;
476 }
477 break;
478
479 case HID_UP_HPVENDOR: /* Reported on a Dutch layout HP5308 */
480
481 set_bit(EV_REP, input->evbit);
482 switch (usage->hid & HID_USAGE) {
483 case 0x021: map_key_clear(KEY_PRINT); break;
484 case 0x070: map_key_clear(KEY_HP); break;
485 case 0x071: map_key_clear(KEY_CAMERA); break;
486 case 0x072: map_key_clear(KEY_SOUND); break;
487 case 0x073: map_key_clear(KEY_QUESTION); break;
488 case 0x080: map_key_clear(KEY_EMAIL); break;
489 case 0x081: map_key_clear(KEY_CHAT); break;
490 case 0x082: map_key_clear(KEY_SEARCH); break;
491 case 0x083: map_key_clear(KEY_CONNECT); break;
492 case 0x084: map_key_clear(KEY_FINANCE); break;
493 case 0x085: map_key_clear(KEY_SPORT); break;
494 case 0x086: map_key_clear(KEY_SHOP); break;
495 default: goto ignore;
496 }
497 break;
498
499 case HID_UP_MSVENDOR:
500 goto ignore;
501
502 case HID_UP_CUSTOM: /* Reported on Logitech and Powerbook USB keyboards */
503
504 set_bit(EV_REP, input->evbit);
505 switch(usage->hid & HID_USAGE) {
506 case 0x003:
507 /* The fn key on Apple PowerBooks */
508 map_key_clear(KEY_FN);
509 hidinput_pb_setup(input);
510 break;
511
512 default: goto ignore;
513 }
514 break;
515
516 case HID_UP_LOGIVENDOR: /* Reported on Logitech Ultra X Media Remote */
517
518 set_bit(EV_REP, input->evbit);
519 switch(usage->hid & HID_USAGE) {
520 case 0x004: map_key_clear(KEY_AGAIN); break;
521 case 0x00d: map_key_clear(KEY_HOME); break;
522 case 0x024: map_key_clear(KEY_SHUFFLE); break;
523 case 0x025: map_key_clear(KEY_TV); break;
524 case 0x026: map_key_clear(KEY_MENU); break;
525 case 0x031: map_key_clear(KEY_AUDIO); break;
526 case 0x032: map_key_clear(KEY_TEXT); break;
527 case 0x033: map_key_clear(KEY_LAST); break;
528 case 0x047: map_key_clear(KEY_MP3); break;
529 case 0x048: map_key_clear(KEY_DVD); break;
530 case 0x049: map_key_clear(KEY_MEDIA); break;
531 case 0x04a: map_key_clear(KEY_VIDEO); break;
532 case 0x04b: map_key_clear(KEY_ANGLE); break;
533 case 0x04c: map_key_clear(KEY_LANGUAGE); break;
534 case 0x04d: map_key_clear(KEY_SUBTITLE); break;
535 case 0x051: map_key_clear(KEY_RED); break;
536 case 0x052: map_key_clear(KEY_CLOSE); break;
537 default: goto ignore;
538 }
539 break;
540
541 case HID_UP_PID:
542
543 switch(usage->hid & HID_USAGE) {
544 case 0xa4: map_key_clear(BTN_DEAD); break;
545 default: goto ignore;
546 }
547 break;
548
549 default:
550 unknown:
551 if (field->report_size == 1) {
552 if (field->report->type == HID_OUTPUT_REPORT) {
553 map_led(LED_MISC);
554 break;
555 }
556 map_key(BTN_MISC);
557 break;
558 }
559 if (field->flags & HID_MAIN_ITEM_RELATIVE) {
560 map_rel(REL_MISC);
561 break;
562 }
563 map_abs(ABS_MISC);
564 break;
565 }
566
567 if (device->quirks & HID_QUIRK_MIGHTYMOUSE) {
568 if (usage->hid == HID_GD_Z)
569 map_rel(REL_HWHEEL);
570 else if (usage->code == BTN_1)
571 map_key(BTN_2);
572 else if (usage->code == BTN_2)
573 map_key(BTN_1);
574 }
575
576 if ((device->quirks & (HID_QUIRK_2WHEEL_MOUSE_HACK_7 | HID_QUIRK_2WHEEL_MOUSE_HACK_5)) &&
577 (usage->type == EV_REL) && (usage->code == REL_WHEEL))
578 set_bit(REL_HWHEEL, bit);
579
580 if (((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
581 || ((device->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007)))
582 goto ignore;
583
584 if ((device->quirks & HID_QUIRK_BAD_RELATIVE_KEYS) &&
585 usage->type == EV_KEY && (field->flags & HID_MAIN_ITEM_RELATIVE))
586 field->flags &= ~HID_MAIN_ITEM_RELATIVE;
587
588 set_bit(usage->type, input->evbit);
589
590 while (usage->code <= max && test_and_set_bit(usage->code, bit))
591 usage->code = find_next_zero_bit(bit, max + 1, usage->code);
592
593 if (usage->code > max)
594 goto ignore;
595
596
597 if (usage->type == EV_ABS) {
598
599 int a = field->logical_minimum;
600 int b = field->logical_maximum;
601
602 if ((device->quirks & HID_QUIRK_BADPAD) && (usage->code == ABS_X || usage->code == ABS_Y)) {
603 a = field->logical_minimum = 0;
604 b = field->logical_maximum = 255;
605 }
606
607 if (field->application == HID_GD_GAMEPAD || field->application == HID_GD_JOYSTICK)
608 input_set_abs_params(input, usage->code, a, b, (b - a) >> 8, (b - a) >> 4);
609 else input_set_abs_params(input, usage->code, a, b, 0, 0);
610
611 }
612
613 if (usage->type == EV_ABS &&
614 (usage->hat_min < usage->hat_max || usage->hat_dir)) {
615 int i;
616 for (i = usage->code; i < usage->code + 2 && i <= max; i++) {
617 input_set_abs_params(input, i, -1, 1, 0, 0);
618 set_bit(i, input->absbit);
619 }
620 if (usage->hat_dir && !field->dpad)
621 field->dpad = usage->code;
622 }
623
624#ifdef DEBUG
625 resolv_event(usage->type, usage->code);
626 printk("\n");
627#endif
628 return;
629
630ignore:
631#ifdef DEBUG
632 printk("IGNORED\n");
633#endif
634 return;
635}
636
637void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
638{
639 struct input_dev *input;
640 int *quirks = &hid->quirks;
641
642 if (!field->hidinput)
643 return;
644
645 input = field->hidinput->input;
646
647 if (!usage->type)
648 return;
649
650 if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
651 || ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
652 if (value) hid->quirks |= HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
653 else hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
654 return;
655 }
656
657 if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
658 input_event(input, usage->type, usage->code, -value);
659 return;
660 }
661
662 if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
663 input_event(input, usage->type, REL_HWHEEL, value);
664 return;
665 }
666
667 if ((hid->quirks & HID_QUIRK_POWERBOOK_HAS_FN) && hidinput_pb_event(hid, input, usage, value))
668 return;
669
670 if (usage->hat_min < usage->hat_max || usage->hat_dir) {
671 int hat_dir = usage->hat_dir;
672 if (!hat_dir)
673 hat_dir = (value - usage->hat_min) * 8 / (usage->hat_max - usage->hat_min + 1) + 1;
674 if (hat_dir < 0 || hat_dir > 8) hat_dir = 0;
675 input_event(input, usage->type, usage->code , hid_hat_to_axis[hat_dir].x);
676 input_event(input, usage->type, usage->code + 1, hid_hat_to_axis[hat_dir].y);
677 return;
678 }
679
680 if (usage->hid == (HID_UP_DIGITIZER | 0x003c)) { /* Invert */
681 *quirks = value ? (*quirks | HID_QUIRK_INVERT) : (*quirks & ~HID_QUIRK_INVERT);
682 return;
683 }
684
685 if (usage->hid == (HID_UP_DIGITIZER | 0x0032)) { /* InRange */
686 if (value) {
687 input_event(input, usage->type, (*quirks & HID_QUIRK_INVERT) ? BTN_TOOL_RUBBER : usage->code, 1);
688 return;
689 }
690 input_event(input, usage->type, usage->code, 0);
691 input_event(input, usage->type, BTN_TOOL_RUBBER, 0);
692 return;
693 }
694
695 if (usage->hid == (HID_UP_DIGITIZER | 0x0030) && (*quirks & HID_QUIRK_NOTOUCH)) { /* Pressure */
696 int a = field->logical_minimum;
697 int b = field->logical_maximum;
698 input_event(input, EV_KEY, BTN_TOUCH, value > a + ((b - a) >> 3));
699 }
700
701 if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
702 dbg("Maximum Effects - %d",value);
703 return;
704 }
705
706 if (usage->hid == (HID_UP_PID | 0x7fUL)) {
707 dbg("PID Pool Report\n");
708 return;
709 }
710
711 if ((usage->type == EV_KEY) && (usage->code == 0)) /* Key 0 is "unassigned", not KEY_UNKNOWN */
712 return;
713
714 input_event(input, usage->type, usage->code, value);
715
716 if ((field->flags & HID_MAIN_ITEM_RELATIVE) && (usage->type == EV_KEY))
717 input_event(input, usage->type, usage->code, 0);
718}
719
720void hidinput_report_event(struct hid_device *hid, struct hid_report *report)
721{
722 struct hid_input *hidinput;
723
724 list_for_each_entry(hidinput, &hid->inputs, list)
725 input_sync(hidinput->input);
726}
727
728static int hidinput_find_field(struct hid_device *hid, unsigned int type, unsigned int code, struct hid_field **field)
729{
730 struct hid_report *report;
731 int i, j;
732
733 list_for_each_entry(report, &hid->report_enum[HID_OUTPUT_REPORT].report_list, list) {
734 for (i = 0; i < report->maxfield; i++) {
735 *field = report->field[i];
736 for (j = 0; j < (*field)->maxusage; j++)
737 if ((*field)->usage[j].type == type && (*field)->usage[j].code == code)
738 return j;
739 }
740 }
741 return -1;
742}
743
744static int hidinput_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
745{
746 struct hid_device *hid = dev->private;
747 struct hid_field *field;
748 int offset;
749
750 if (type == EV_FF)
751 return input_ff_event(dev, type, code, value);
752
753 if (type != EV_LED)
754 return -1;
755
756 if ((offset = hidinput_find_field(hid, type, code, &field)) == -1) {
757 warn("event field not found");
758 return -1;
759 }
760
761 hid_set_field(field, offset, value);
762 hid_submit_report(hid, field->report, USB_DIR_OUT);
763
764 return 0;
765}
766
767static int hidinput_open(struct input_dev *dev)
768{
769 struct hid_device *hid = dev->private;
770 return hid_open(hid);
771}
772
773static void hidinput_close(struct input_dev *dev)
774{
775 struct hid_device *hid = dev->private;
776 hid_close(hid);
777}
778
779/*
780 * Register the input device; print a message.
781 * Configure the input layer interface
782 * Read all reports and initialize the absolute field values.
783 */
784
785int hidinput_connect(struct hid_device *hid)
786{
787 struct usb_device *dev = hid->dev;
788 struct hid_report *report;
789 struct hid_input *hidinput = NULL;
790 struct input_dev *input_dev;
791 int i, j, k;
792
793 INIT_LIST_HEAD(&hid->inputs);
794
795 for (i = 0; i < hid->maxcollection; i++)
796 if (hid->collection[i].type == HID_COLLECTION_APPLICATION ||
797 hid->collection[i].type == HID_COLLECTION_PHYSICAL)
798 if (IS_INPUT_APPLICATION(hid->collection[i].usage))
799 break;
800
801 if (i == hid->maxcollection)
802 return -1;
803
804 for (k = HID_INPUT_REPORT; k <= HID_OUTPUT_REPORT; k++)
805 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
806
807 if (!report->maxfield)
808 continue;
809
810 if (!hidinput) {
811 hidinput = kzalloc(sizeof(*hidinput), GFP_KERNEL);
812 input_dev = input_allocate_device();
813 if (!hidinput || !input_dev) {
814 kfree(hidinput);
815 input_free_device(input_dev);
816 err("Out of memory during hid input probe");
817 return -1;
818 }
819
820 input_dev->private = hid;
821 input_dev->event = hidinput_input_event;
822 input_dev->open = hidinput_open;
823 input_dev->close = hidinput_close;
824
825 input_dev->name = hid->name;
826 input_dev->phys = hid->phys;
827 input_dev->uniq = hid->uniq;
828 usb_to_input_id(dev, &input_dev->id);
829 input_dev->cdev.dev = &hid->intf->dev;
830
831 hidinput->input = input_dev;
832 list_add_tail(&hidinput->list, &hid->inputs);
833 }
834
835 for (i = 0; i < report->maxfield; i++)
836 for (j = 0; j < report->field[i]->maxusage; j++)
837 hidinput_configure_usage(hidinput, report->field[i],
838 report->field[i]->usage + j);
839
840 if (hid->quirks & HID_QUIRK_MULTI_INPUT) {
841 /* This will leave hidinput NULL, so that it
842 * allocates another one if we have more inputs on
843 * the same interface. Some devices (e.g. Happ's
844 * UGCI) cram a lot of unrelated inputs into the
845 * same interface. */
846 hidinput->report = report;
847 input_register_device(hidinput->input);
848 hidinput = NULL;
849 }
850 }
851
852 /* This only gets called when we are a single-input (most of the
853 * time). IOW, not a HID_QUIRK_MULTI_INPUT. The hid_ff_init() is
854 * only useful in this case, and not for multi-input quirks. */
855 if (hidinput) {
856 hid_ff_init(hid);
857 input_register_device(hidinput->input);
858 }
859
860 return 0;
861}
862
863void hidinput_disconnect(struct hid_device *hid)
864{
865 struct hid_input *hidinput, *next;
866
867 list_for_each_entry_safe(hidinput, next, &hid->inputs, list) {
868 list_del(&hidinput->list);
869 input_unregister_device(hidinput->input);
870 kfree(hidinput);
871 }
872}
diff --git a/drivers/usb/input/hid-lgff.c b/drivers/usb/input/hid-lgff.c
index 52be7a8f55aa..4df0968f852e 100644
--- a/drivers/usb/input/hid-lgff.c
+++ b/drivers/usb/input/hid-lgff.c
@@ -29,9 +29,10 @@
29 29
30#include <linux/input.h> 30#include <linux/input.h>
31#include <linux/usb.h> 31#include <linux/usb.h>
32#include "hid.h" 32#include <linux/hid.h>
33#include "usbhid.h"
33 34
34struct device_type { 35struct dev_type {
35 u16 idVendor; 36 u16 idVendor;
36 u16 idProduct; 37 u16 idProduct;
37 const signed short *ff; 38 const signed short *ff;
@@ -47,7 +48,7 @@ static const signed short ff_joystick[] = {
47 -1 48 -1
48}; 49};
49 50
50static const struct device_type devices[] = { 51static const struct dev_type devices[] = {
51 { 0x046d, 0xc211, ff_rumble }, 52 { 0x046d, 0xc211, ff_rumble },
52 { 0x046d, 0xc219, ff_rumble }, 53 { 0x046d, 0xc219, ff_rumble },
53 { 0x046d, 0xc283, ff_joystick }, 54 { 0x046d, 0xc283, ff_joystick },
@@ -76,7 +77,7 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
76 report->field[0]->value[2] = x; 77 report->field[0]->value[2] = x;
77 report->field[0]->value[3] = y; 78 report->field[0]->value[3] = y;
78 dbg("(x, y)=(%04x, %04x)", x, y); 79 dbg("(x, y)=(%04x, %04x)", x, y);
79 hid_submit_report(hid, report, USB_DIR_OUT); 80 usbhid_submit_report(hid, report, USB_DIR_OUT);
80 break; 81 break;
81 82
82 case FF_RUMBLE: 83 case FF_RUMBLE:
@@ -91,7 +92,7 @@ static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *ef
91 report->field[0]->value[2] = left; 92 report->field[0]->value[2] = left;
92 report->field[0]->value[3] = right; 93 report->field[0]->value[3] = right;
93 dbg("(left, right)=(%04x, %04x)", left, right); 94 dbg("(left, right)=(%04x, %04x)", left, right);
94 hid_submit_report(hid, report, USB_DIR_OUT); 95 usbhid_submit_report(hid, report, USB_DIR_OUT);
95 break; 96 break;
96 } 97 }
97 return 0; 98 return 0;
diff --git a/drivers/usb/input/hid-pidff.c b/drivers/usb/input/hid-pidff.c
index 5420c13eb8eb..cbd2d53fefff 100644
--- a/drivers/usb/input/hid-pidff.c
+++ b/drivers/usb/input/hid-pidff.c
@@ -28,7 +28,9 @@
28#include <linux/input.h> 28#include <linux/input.h>
29#include <linux/usb.h> 29#include <linux/usb.h>
30 30
31#include "hid.h" 31#include <linux/hid.h>
32
33#include "usbhid.h"
32 34
33#define PID_EFFECTS_MAX 64 35#define PID_EFFECTS_MAX 64
34 36
@@ -260,7 +262,7 @@ static void pidff_set_envelope_report(struct pidff_device *pidff,
260 debug("attack %u => %d", envelope->attack_level, 262 debug("attack %u => %d", envelope->attack_level,
261 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]); 263 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
262 264
263 hid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE], 265 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
264 USB_DIR_OUT); 266 USB_DIR_OUT);
265} 267}
266 268
@@ -287,7 +289,7 @@ static void pidff_set_constant_force_report(struct pidff_device *pidff,
287 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE], 289 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],
288 effect->u.constant.level); 290 effect->u.constant.level);
289 291
290 hid_submit_report(pidff->hid, pidff->reports[PID_SET_CONSTANT], 292 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONSTANT],
291 USB_DIR_OUT); 293 USB_DIR_OUT);
292} 294}
293 295
@@ -322,7 +324,7 @@ static void pidff_set_effect_report(struct pidff_device *pidff,
322 pidff->effect_direction); 324 pidff->effect_direction);
323 pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay; 325 pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;
324 326
325 hid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT], 327 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
326 USB_DIR_OUT); 328 USB_DIR_OUT);
327} 329}
328 330
@@ -354,7 +356,7 @@ static void pidff_set_periodic_report(struct pidff_device *pidff,
354 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase); 356 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);
355 pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period; 357 pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;
356 358
357 hid_submit_report(pidff->hid, pidff->reports[PID_SET_PERIODIC], 359 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_PERIODIC],
358 USB_DIR_OUT); 360 USB_DIR_OUT);
359 361
360} 362}
@@ -396,8 +398,8 @@ static void pidff_set_condition_report(struct pidff_device *pidff,
396 effect->u.condition[i].left_saturation); 398 effect->u.condition[i].left_saturation);
397 pidff_set(&pidff->set_condition[PID_DEAD_BAND], 399 pidff_set(&pidff->set_condition[PID_DEAD_BAND],
398 effect->u.condition[i].deadband); 400 effect->u.condition[i].deadband);
399 hid_wait_io(pidff->hid); 401 usbhid_wait_io(pidff->hid);
400 hid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION], 402 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],
401 USB_DIR_OUT); 403 USB_DIR_OUT);
402 } 404 }
403} 405}
@@ -438,7 +440,7 @@ static void pidff_set_ramp_force_report(struct pidff_device *pidff,
438 effect->u.ramp.start_level); 440 effect->u.ramp.start_level);
439 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END], 441 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],
440 effect->u.ramp.end_level); 442 effect->u.ramp.end_level);
441 hid_submit_report(pidff->hid, pidff->reports[PID_SET_RAMP], 443 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_RAMP],
442 USB_DIR_OUT); 444 USB_DIR_OUT);
443} 445}
444 446
@@ -463,19 +465,19 @@ static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)
463 int j; 465 int j;
464 466
465 pidff->create_new_effect_type->value[0] = efnum; 467 pidff->create_new_effect_type->value[0] = efnum;
466 hid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT], 468 usbhid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
467 USB_DIR_OUT); 469 USB_DIR_OUT);
468 debug("create_new_effect sent, type: %d", efnum); 470 debug("create_new_effect sent, type: %d", efnum);
469 471
470 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0; 472 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
471 pidff->block_load_status->value[0] = 0; 473 pidff->block_load_status->value[0] = 0;
472 hid_wait_io(pidff->hid); 474 usbhid_wait_io(pidff->hid);
473 475
474 for (j = 0; j < 60; j++) { 476 for (j = 0; j < 60; j++) {
475 debug("pid_block_load requested"); 477 debug("pid_block_load requested");
476 hid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD], 478 usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
477 USB_DIR_IN); 479 USB_DIR_IN);
478 hid_wait_io(pidff->hid); 480 usbhid_wait_io(pidff->hid);
479 if (pidff->block_load_status->value[0] == 481 if (pidff->block_load_status->value[0] ==
480 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) { 482 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
481 debug("device reported free memory: %d bytes", 483 debug("device reported free memory: %d bytes",
@@ -511,8 +513,8 @@ static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)
511 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n; 513 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
512 } 514 }
513 515
514 hid_wait_io(pidff->hid); 516 usbhid_wait_io(pidff->hid);
515 hid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION], 517 usbhid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
516 USB_DIR_OUT); 518 USB_DIR_OUT);
517} 519}
518 520
@@ -534,7 +536,7 @@ static int pidff_playback(struct input_dev *dev, int effect_id, int value)
534static void pidff_erase_pid(struct pidff_device *pidff, int pid_id) 536static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)
535{ 537{
536 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id; 538 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;
537 hid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_FREE], 539 usbhid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_FREE],
538 USB_DIR_OUT); 540 USB_DIR_OUT);
539} 541}
540 542
@@ -714,7 +716,7 @@ static void pidff_set_gain(struct input_dev *dev, u16 gain)
714 struct pidff_device *pidff = dev->ff->private; 716 struct pidff_device *pidff = dev->ff->private;
715 717
716 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain); 718 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);
717 hid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN], 719 usbhid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
718 USB_DIR_OUT); 720 USB_DIR_OUT);
719} 721}
720 722
@@ -739,7 +741,7 @@ static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
739 pidff_set(&pidff->set_effect[PID_GAIN], magnitude); 741 pidff_set(&pidff->set_effect[PID_GAIN], magnitude);
740 pidff->set_effect[PID_START_DELAY].value[0] = 0; 742 pidff->set_effect[PID_START_DELAY].value[0] = 0;
741 743
742 hid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT], 744 usbhid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
743 USB_DIR_OUT); 745 USB_DIR_OUT);
744} 746}
745 747
@@ -1163,19 +1165,19 @@ static void pidff_reset(struct pidff_device *pidff)
1163 1165
1164 pidff->device_control->value[0] = pidff->control_id[PID_RESET]; 1166 pidff->device_control->value[0] = pidff->control_id[PID_RESET];
1165 /* We reset twice as sometimes hid_wait_io isn't waiting long enough */ 1167 /* We reset twice as sometimes hid_wait_io isn't waiting long enough */
1166 hid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT); 1168 usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
1167 hid_wait_io(hid); 1169 usbhid_wait_io(hid);
1168 hid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT); 1170 usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
1169 hid_wait_io(hid); 1171 usbhid_wait_io(hid);
1170 1172
1171 pidff->device_control->value[0] = 1173 pidff->device_control->value[0] =
1172 pidff->control_id[PID_ENABLE_ACTUATORS]; 1174 pidff->control_id[PID_ENABLE_ACTUATORS];
1173 hid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT); 1175 usbhid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
1174 hid_wait_io(hid); 1176 usbhid_wait_io(hid);
1175 1177
1176 /* pool report is sometimes messed up, refetch it */ 1178 /* pool report is sometimes messed up, refetch it */
1177 hid_submit_report(hid, pidff->reports[PID_POOL], USB_DIR_IN); 1179 usbhid_submit_report(hid, pidff->reports[PID_POOL], USB_DIR_IN);
1178 hid_wait_io(hid); 1180 usbhid_wait_io(hid);
1179 1181
1180 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) { 1182 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
1181 int sim_effects = pidff->pool[PID_SIMULTANEOUS_MAX].value[0]; 1183 int sim_effects = pidff->pool[PID_SIMULTANEOUS_MAX].value[0];
@@ -1187,9 +1189,9 @@ static void pidff_reset(struct pidff_device *pidff)
1187 break; 1189 break;
1188 } 1190 }
1189 debug("pid_pool requested again"); 1191 debug("pid_pool requested again");
1190 hid_submit_report(hid, pidff->reports[PID_POOL], 1192 usbhid_submit_report(hid, pidff->reports[PID_POOL],
1191 USB_DIR_IN); 1193 USB_DIR_IN);
1192 hid_wait_io(hid); 1194 usbhid_wait_io(hid);
1193 } 1195 }
1194 } 1196 }
1195} 1197}
@@ -1275,7 +1277,7 @@ int hid_pidff_init(struct hid_device *hid)
1275 1277
1276 if (test_bit(FF_GAIN, dev->ffbit)) { 1278 if (test_bit(FF_GAIN, dev->ffbit)) {
1277 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff); 1279 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);
1278 hid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN], 1280 usbhid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
1279 USB_DIR_OUT); 1281 USB_DIR_OUT);
1280 } 1282 }
1281 1283
diff --git a/drivers/usb/input/hid-plff.c b/drivers/usb/input/hid-plff.c
new file mode 100644
index 000000000000..76d2e6e14db4
--- /dev/null
+++ b/drivers/usb/input/hid-plff.c
@@ -0,0 +1,129 @@
1/*
2 * Force feedback support for PantherLord USB/PS2 2in1 Adapter devices
3 *
4 * Copyright (c) 2007 Anssi Hannula <anssi.hannula@gmail.com>
5 */
6
7/*
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 */
22
23
24/* #define DEBUG */
25
26#define debug(format, arg...) pr_debug("hid-plff: " format "\n" , ## arg)
27
28#include <linux/input.h>
29#include <linux/usb.h>
30#include <linux/hid.h>
31#include "usbhid.h"
32
33struct plff_device {
34 struct hid_report *report;
35};
36
37static int hid_plff_play(struct input_dev *dev, void *data,
38 struct ff_effect *effect)
39{
40 struct hid_device *hid = dev->private;
41 struct plff_device *plff = data;
42 int left, right;
43
44 left = effect->u.rumble.strong_magnitude;
45 right = effect->u.rumble.weak_magnitude;
46 debug("called with 0x%04x 0x%04x", left, right);
47
48 left = left * 0x7f / 0xffff;
49 right = right * 0x7f / 0xffff;
50
51 plff->report->field[0]->value[2] = left;
52 plff->report->field[0]->value[3] = right;
53 debug("running with 0x%02x 0x%02x", left, right);
54 usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
55
56 return 0;
57}
58
59int hid_plff_init(struct hid_device *hid)
60{
61 struct plff_device *plff;
62 struct hid_report *report;
63 struct hid_input *hidinput;
64 struct list_head *report_list =
65 &hid->report_enum[HID_OUTPUT_REPORT].report_list;
66 struct list_head *report_ptr = report_list;
67 struct input_dev *dev;
68 int error;
69
70 /* The device contains 2 output reports (one for each
71 HID_QUIRK_MULTI_INPUT device), both containing 1 field, which
72 contains 4 ff00.0002 usages and 4 16bit absolute values.
73
74 The 2 input reports also contain a field which contains
75 8 ff00.0001 usages and 8 boolean values. Their meaning is
76 currently unknown. */
77
78 if (list_empty(report_list)) {
79 printk(KERN_ERR "hid-plff: no output reports found\n");
80 return -ENODEV;
81 }
82
83 list_for_each_entry(hidinput, &hid->inputs, list) {
84
85 report_ptr = report_ptr->next;
86
87 if (report_ptr == report_list) {
88 printk(KERN_ERR "hid-plff: required output report is missing\n");
89 return -ENODEV;
90 }
91
92 report = list_entry(report_ptr, struct hid_report, list);
93 if (report->maxfield < 1) {
94 printk(KERN_ERR "hid-plff: no fields in the report\n");
95 return -ENODEV;
96 }
97
98 if (report->field[0]->report_count < 4) {
99 printk(KERN_ERR "hid-plff: not enough values in the field\n");
100 return -ENODEV;
101 }
102
103 plff = kzalloc(sizeof(struct plff_device), GFP_KERNEL);
104 if (!plff)
105 return -ENOMEM;
106
107 dev = hidinput->input;
108
109 set_bit(FF_RUMBLE, dev->ffbit);
110
111 error = input_ff_create_memless(dev, plff, hid_plff_play);
112 if (error) {
113 kfree(plff);
114 return error;
115 }
116
117 plff->report = report;
118 plff->report->field[0]->value[0] = 0x00;
119 plff->report->field[0]->value[1] = 0x00;
120 plff->report->field[0]->value[2] = 0x00;
121 plff->report->field[0]->value[3] = 0x00;
122 usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
123 }
124
125 printk(KERN_INFO "hid-plff: Force feedback for PantherLord USB/PS2 "
126 "2in1 Adapters by Anssi Hannula <anssi.hannula@gmail.com>\n");
127
128 return 0;
129}
diff --git a/drivers/usb/input/hid-tmff.c b/drivers/usb/input/hid-tmff.c
index 2d5be4c318ac..ab67331620d0 100644
--- a/drivers/usb/input/hid-tmff.c
+++ b/drivers/usb/input/hid-tmff.c
@@ -32,7 +32,8 @@
32#undef DEBUG 32#undef DEBUG
33#include <linux/usb.h> 33#include <linux/usb.h>
34 34
35#include "hid.h" 35#include <linux/hid.h>
36#include "usbhid.h"
36 37
37/* Usages for thrustmaster devices I know about */ 38/* Usages for thrustmaster devices I know about */
38#define THRUSTMASTER_USAGE_RUMBLE_LR (HID_UP_GENDESK | 0xbb) 39#define THRUSTMASTER_USAGE_RUMBLE_LR (HID_UP_GENDESK | 0xbb)
@@ -70,7 +71,7 @@ static int hid_tmff_play(struct input_dev *dev, void *data, struct ff_effect *ef
70 tmff->rumble->value[0] = left; 71 tmff->rumble->value[0] = left;
71 tmff->rumble->value[1] = right; 72 tmff->rumble->value[1] = right;
72 dbg("(left,right)=(%08x, %08x)", left, right); 73 dbg("(left,right)=(%08x, %08x)", left, right);
73 hid_submit_report(hid, tmff->report, USB_DIR_OUT); 74 usbhid_submit_report(hid, tmff->report, USB_DIR_OUT);
74 75
75 return 0; 76 return 0;
76} 77}
diff --git a/drivers/usb/input/hid-zpff.c b/drivers/usb/input/hid-zpff.c
index d2ce3214572c..7bd8238ca212 100644
--- a/drivers/usb/input/hid-zpff.c
+++ b/drivers/usb/input/hid-zpff.c
@@ -27,7 +27,8 @@
27 27
28#include <linux/input.h> 28#include <linux/input.h>
29#include <linux/usb.h> 29#include <linux/usb.h>
30#include "hid.h" 30#include <linux/hid.h>
31#include "usbhid.h"
31 32
32struct zpff_device { 33struct zpff_device {
33 struct hid_report *report; 34 struct hid_report *report;
@@ -56,7 +57,7 @@ static int hid_zpff_play(struct input_dev *dev, void *data,
56 zpff->report->field[2]->value[0] = left; 57 zpff->report->field[2]->value[0] = left;
57 zpff->report->field[3]->value[0] = right; 58 zpff->report->field[3]->value[0] = right;
58 debug("running with 0x%02x 0x%02x", left, right); 59 debug("running with 0x%02x 0x%02x", left, right);
59 hid_submit_report(hid, zpff->report, USB_DIR_OUT); 60 usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
60 61
61 return 0; 62 return 0;
62} 63}
@@ -101,7 +102,7 @@ int hid_zpff_init(struct hid_device *hid)
101 zpff->report->field[1]->value[0] = 0x02; 102 zpff->report->field[1]->value[0] = 0x02;
102 zpff->report->field[2]->value[0] = 0x00; 103 zpff->report->field[2]->value[0] = 0x00;
103 zpff->report->field[3]->value[0] = 0x00; 104 zpff->report->field[3]->value[0] = 0x00;
104 hid_submit_report(hid, zpff->report, USB_DIR_OUT); 105 usbhid_submit_report(hid, zpff->report, USB_DIR_OUT);
105 106
106 printk(KERN_INFO "Force feedback for Zeroplus based devices by " 107 printk(KERN_INFO "Force feedback for Zeroplus based devices by "
107 "Anssi Hannula <anssi.hannula@gmail.com>\n"); 108 "Anssi Hannula <anssi.hannula@gmail.com>\n");
diff --git a/drivers/usb/input/hid.h b/drivers/usb/input/hid.h
deleted file mode 100644
index 76ad68d9edfd..000000000000
--- a/drivers/usb/input/hid.h
+++ /dev/null
@@ -1,540 +0,0 @@
1#ifndef __HID_H
2#define __HID_H
3
4/*
5 * $Id: hid.h,v 1.24 2001/12/27 10:37:41 vojtech Exp $
6 *
7 * Copyright (c) 1999 Andreas Gal
8 * Copyright (c) 2000-2001 Vojtech Pavlik
9 */
10
11/*
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 *
26 * Should you need to contact me, the author, you can do so either by
27 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
28 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
29 */
30
31#include <linux/types.h>
32#include <linux/slab.h>
33#include <linux/list.h>
34#include <linux/timer.h>
35#include <linux/workqueue.h>
36
37/*
38 * USB HID (Human Interface Device) interface class code
39 */
40
41#define USB_INTERFACE_CLASS_HID 3
42
43/*
44 * USB HID interface subclass and protocol codes
45 */
46
47#define USB_INTERFACE_SUBCLASS_BOOT 1
48#define USB_INTERFACE_PROTOCOL_KEYBOARD 1
49#define USB_INTERFACE_PROTOCOL_MOUSE 2
50
51/*
52 * HID class requests
53 */
54
55#define HID_REQ_GET_REPORT 0x01
56#define HID_REQ_GET_IDLE 0x02
57#define HID_REQ_GET_PROTOCOL 0x03
58#define HID_REQ_SET_REPORT 0x09
59#define HID_REQ_SET_IDLE 0x0A
60#define HID_REQ_SET_PROTOCOL 0x0B
61
62/*
63 * HID class descriptor types
64 */
65
66#define HID_DT_HID (USB_TYPE_CLASS | 0x01)
67#define HID_DT_REPORT (USB_TYPE_CLASS | 0x02)
68#define HID_DT_PHYSICAL (USB_TYPE_CLASS | 0x03)
69
70/*
71 * We parse each description item into this structure. Short items data
72 * values are expanded to 32-bit signed int, long items contain a pointer
73 * into the data area.
74 */
75
76struct hid_item {
77 unsigned format;
78 __u8 size;
79 __u8 type;
80 __u8 tag;
81 union {
82 __u8 u8;
83 __s8 s8;
84 __u16 u16;
85 __s16 s16;
86 __u32 u32;
87 __s32 s32;
88 __u8 *longdata;
89 } data;
90};
91
92/*
93 * HID report item format
94 */
95
96#define HID_ITEM_FORMAT_SHORT 0
97#define HID_ITEM_FORMAT_LONG 1
98
99/*
100 * Special tag indicating long items
101 */
102
103#define HID_ITEM_TAG_LONG 15
104
105/*
106 * HID report descriptor item type (prefix bit 2,3)
107 */
108
109#define HID_ITEM_TYPE_MAIN 0
110#define HID_ITEM_TYPE_GLOBAL 1
111#define HID_ITEM_TYPE_LOCAL 2
112#define HID_ITEM_TYPE_RESERVED 3
113
114/*
115 * HID report descriptor main item tags
116 */
117
118#define HID_MAIN_ITEM_TAG_INPUT 8
119#define HID_MAIN_ITEM_TAG_OUTPUT 9
120#define HID_MAIN_ITEM_TAG_FEATURE 11
121#define HID_MAIN_ITEM_TAG_BEGIN_COLLECTION 10
122#define HID_MAIN_ITEM_TAG_END_COLLECTION 12
123
124/*
125 * HID report descriptor main item contents
126 */
127
128#define HID_MAIN_ITEM_CONSTANT 0x001
129#define HID_MAIN_ITEM_VARIABLE 0x002
130#define HID_MAIN_ITEM_RELATIVE 0x004
131#define HID_MAIN_ITEM_WRAP 0x008
132#define HID_MAIN_ITEM_NONLINEAR 0x010
133#define HID_MAIN_ITEM_NO_PREFERRED 0x020
134#define HID_MAIN_ITEM_NULL_STATE 0x040
135#define HID_MAIN_ITEM_VOLATILE 0x080
136#define HID_MAIN_ITEM_BUFFERED_BYTE 0x100
137
138/*
139 * HID report descriptor collection item types
140 */
141
142#define HID_COLLECTION_PHYSICAL 0
143#define HID_COLLECTION_APPLICATION 1
144#define HID_COLLECTION_LOGICAL 2
145
146/*
147 * HID report descriptor global item tags
148 */
149
150#define HID_GLOBAL_ITEM_TAG_USAGE_PAGE 0
151#define HID_GLOBAL_ITEM_TAG_LOGICAL_MINIMUM 1
152#define HID_GLOBAL_ITEM_TAG_LOGICAL_MAXIMUM 2
153#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MINIMUM 3
154#define HID_GLOBAL_ITEM_TAG_PHYSICAL_MAXIMUM 4
155#define HID_GLOBAL_ITEM_TAG_UNIT_EXPONENT 5
156#define HID_GLOBAL_ITEM_TAG_UNIT 6
157#define HID_GLOBAL_ITEM_TAG_REPORT_SIZE 7
158#define HID_GLOBAL_ITEM_TAG_REPORT_ID 8
159#define HID_GLOBAL_ITEM_TAG_REPORT_COUNT 9
160#define HID_GLOBAL_ITEM_TAG_PUSH 10
161#define HID_GLOBAL_ITEM_TAG_POP 11
162
163/*
164 * HID report descriptor local item tags
165 */
166
167#define HID_LOCAL_ITEM_TAG_USAGE 0
168#define HID_LOCAL_ITEM_TAG_USAGE_MINIMUM 1
169#define HID_LOCAL_ITEM_TAG_USAGE_MAXIMUM 2
170#define HID_LOCAL_ITEM_TAG_DESIGNATOR_INDEX 3
171#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MINIMUM 4
172#define HID_LOCAL_ITEM_TAG_DESIGNATOR_MAXIMUM 5
173#define HID_LOCAL_ITEM_TAG_STRING_INDEX 7
174#define HID_LOCAL_ITEM_TAG_STRING_MINIMUM 8
175#define HID_LOCAL_ITEM_TAG_STRING_MAXIMUM 9
176#define HID_LOCAL_ITEM_TAG_DELIMITER 10
177
178/*
179 * HID usage tables
180 */
181
182#define HID_USAGE_PAGE 0xffff0000
183
184#define HID_UP_UNDEFINED 0x00000000
185#define HID_UP_GENDESK 0x00010000
186#define HID_UP_SIMULATION 0x00020000
187#define HID_UP_KEYBOARD 0x00070000
188#define HID_UP_LED 0x00080000
189#define HID_UP_BUTTON 0x00090000
190#define HID_UP_ORDINAL 0x000a0000
191#define HID_UP_CONSUMER 0x000c0000
192#define HID_UP_DIGITIZER 0x000d0000
193#define HID_UP_PID 0x000f0000
194#define HID_UP_HPVENDOR 0xff7f0000
195#define HID_UP_MSVENDOR 0xff000000
196#define HID_UP_CUSTOM 0x00ff0000
197#define HID_UP_LOGIVENDOR 0xffbc0000
198
199#define HID_USAGE 0x0000ffff
200
201#define HID_GD_POINTER 0x00010001
202#define HID_GD_MOUSE 0x00010002
203#define HID_GD_JOYSTICK 0x00010004
204#define HID_GD_GAMEPAD 0x00010005
205#define HID_GD_KEYBOARD 0x00010006
206#define HID_GD_KEYPAD 0x00010007
207#define HID_GD_MULTIAXIS 0x00010008
208#define HID_GD_X 0x00010030
209#define HID_GD_Y 0x00010031
210#define HID_GD_Z 0x00010032
211#define HID_GD_RX 0x00010033
212#define HID_GD_RY 0x00010034
213#define HID_GD_RZ 0x00010035
214#define HID_GD_SLIDER 0x00010036
215#define HID_GD_DIAL 0x00010037
216#define HID_GD_WHEEL 0x00010038
217#define HID_GD_HATSWITCH 0x00010039
218#define HID_GD_BUFFER 0x0001003a
219#define HID_GD_BYTECOUNT 0x0001003b
220#define HID_GD_MOTION 0x0001003c
221#define HID_GD_START 0x0001003d
222#define HID_GD_SELECT 0x0001003e
223#define HID_GD_VX 0x00010040
224#define HID_GD_VY 0x00010041
225#define HID_GD_VZ 0x00010042
226#define HID_GD_VBRX 0x00010043
227#define HID_GD_VBRY 0x00010044
228#define HID_GD_VBRZ 0x00010045
229#define HID_GD_VNO 0x00010046
230#define HID_GD_FEATURE 0x00010047
231#define HID_GD_UP 0x00010090
232#define HID_GD_DOWN 0x00010091
233#define HID_GD_RIGHT 0x00010092
234#define HID_GD_LEFT 0x00010093
235
236/*
237 * HID report types --- Ouch! HID spec says 1 2 3!
238 */
239
240#define HID_INPUT_REPORT 0
241#define HID_OUTPUT_REPORT 1
242#define HID_FEATURE_REPORT 2
243
244/*
245 * HID device quirks.
246 */
247
248#define HID_QUIRK_INVERT 0x00000001
249#define HID_QUIRK_NOTOUCH 0x00000002
250#define HID_QUIRK_IGNORE 0x00000004
251#define HID_QUIRK_NOGET 0x00000008
252#define HID_QUIRK_HIDDEV 0x00000010
253#define HID_QUIRK_BADPAD 0x00000020
254#define HID_QUIRK_MULTI_INPUT 0x00000040
255#define HID_QUIRK_2WHEEL_MOUSE_HACK_7 0x00000080
256#define HID_QUIRK_2WHEEL_MOUSE_HACK_5 0x00000100
257#define HID_QUIRK_2WHEEL_MOUSE_HACK_ON 0x00000200
258#define HID_QUIRK_MIGHTYMOUSE 0x00000400
259#define HID_QUIRK_CYMOTION 0x00000800
260#define HID_QUIRK_POWERBOOK_HAS_FN 0x00001000
261#define HID_QUIRK_POWERBOOK_FN_ON 0x00002000
262#define HID_QUIRK_INVERT_HWHEEL 0x00004000
263#define HID_QUIRK_POWERBOOK_ISO_KEYBOARD 0x00008000
264#define HID_QUIRK_BAD_RELATIVE_KEYS 0x00010000
265
266/*
267 * This is the global environment of the parser. This information is
268 * persistent for main-items. The global environment can be saved and
269 * restored with PUSH/POP statements.
270 */
271
272struct hid_global {
273 unsigned usage_page;
274 __s32 logical_minimum;
275 __s32 logical_maximum;
276 __s32 physical_minimum;
277 __s32 physical_maximum;
278 __s32 unit_exponent;
279 unsigned unit;
280 unsigned report_id;
281 unsigned report_size;
282 unsigned report_count;
283};
284
285/*
286 * This is the local environment. It is persistent up the next main-item.
287 */
288
289#define HID_MAX_DESCRIPTOR_SIZE 4096
290#define HID_MAX_USAGES 1024
291#define HID_DEFAULT_NUM_COLLECTIONS 16
292
293struct hid_local {
294 unsigned usage[HID_MAX_USAGES]; /* usage array */
295 unsigned collection_index[HID_MAX_USAGES]; /* collection index array */
296 unsigned usage_index;
297 unsigned usage_minimum;
298 unsigned delimiter_depth;
299 unsigned delimiter_branch;
300};
301
302/*
303 * This is the collection stack. We climb up the stack to determine
304 * application and function of each field.
305 */
306
307struct hid_collection {
308 unsigned type;
309 unsigned usage;
310 unsigned level;
311};
312
313struct hid_usage {
314 unsigned hid; /* hid usage code */
315 unsigned collection_index; /* index into collection array */
316 /* hidinput data */
317 __u16 code; /* input driver code */
318 __u8 type; /* input driver type */
319 __s8 hat_min; /* hat switch fun */
320 __s8 hat_max; /* ditto */
321 __s8 hat_dir; /* ditto */
322};
323
324struct hid_input;
325
326struct hid_field {
327 unsigned physical; /* physical usage for this field */
328 unsigned logical; /* logical usage for this field */
329 unsigned application; /* application usage for this field */
330 struct hid_usage *usage; /* usage table for this function */
331 unsigned maxusage; /* maximum usage index */
332 unsigned flags; /* main-item flags (i.e. volatile,array,constant) */
333 unsigned report_offset; /* bit offset in the report */
334 unsigned report_size; /* size of this field in the report */
335 unsigned report_count; /* number of this field in the report */
336 unsigned report_type; /* (input,output,feature) */
337 __s32 *value; /* last known value(s) */
338 __s32 logical_minimum;
339 __s32 logical_maximum;
340 __s32 physical_minimum;
341 __s32 physical_maximum;
342 __s32 unit_exponent;
343 unsigned unit;
344 struct hid_report *report; /* associated report */
345 unsigned index; /* index into report->field[] */
346 /* hidinput data */
347 struct hid_input *hidinput; /* associated input structure */
348 __u16 dpad; /* dpad input code */
349};
350
351#define HID_MAX_FIELDS 64
352
353struct hid_report {
354 struct list_head list;
355 unsigned id; /* id of this report */
356 unsigned type; /* report type */
357 struct hid_field *field[HID_MAX_FIELDS]; /* fields of the report */
358 unsigned maxfield; /* maximum valid field index */
359 unsigned size; /* size of the report (bits) */
360 struct hid_device *device; /* associated device */
361};
362
363struct hid_report_enum {
364 unsigned numbered;
365 struct list_head report_list;
366 struct hid_report *report_id_hash[256];
367};
368
369#define HID_REPORT_TYPES 3
370
371#define HID_MIN_BUFFER_SIZE 64 /* make sure there is at least a packet size of space */
372#define HID_MAX_BUFFER_SIZE 4096 /* 4kb */
373#define HID_CONTROL_FIFO_SIZE 256 /* to init devices with >100 reports */
374#define HID_OUTPUT_FIFO_SIZE 64
375
376struct hid_control_fifo {
377 unsigned char dir;
378 struct hid_report *report;
379};
380
381#define HID_CLAIMED_INPUT 1
382#define HID_CLAIMED_HIDDEV 2
383
384#define HID_CTRL_RUNNING 1
385#define HID_OUT_RUNNING 2
386#define HID_IN_RUNNING 3
387#define HID_RESET_PENDING 4
388#define HID_SUSPENDED 5
389#define HID_CLEAR_HALT 6
390
391struct hid_input {
392 struct list_head list;
393 struct hid_report *report;
394 struct input_dev *input;
395};
396
397struct hid_device { /* device report descriptor */
398 __u8 *rdesc;
399 unsigned rsize;
400 struct hid_collection *collection; /* List of HID collections */
401 unsigned collection_size; /* Number of allocated hid_collections */
402 unsigned maxcollection; /* Number of parsed collections */
403 unsigned maxapplication; /* Number of applications */
404 unsigned version; /* HID version */
405 unsigned country; /* HID country */
406 struct hid_report_enum report_enum[HID_REPORT_TYPES];
407
408 struct usb_device *dev; /* USB device */
409 struct usb_interface *intf; /* USB interface */
410 int ifnum; /* USB interface number */
411
412 unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
413 struct timer_list io_retry; /* Retry timer */
414 unsigned long stop_retry; /* Time to give up, in jiffies */
415 unsigned int retry_delay; /* Delay length in ms */
416 struct work_struct reset_work; /* Task context for resets */
417
418 unsigned int bufsize; /* URB buffer size */
419
420 struct urb *urbin; /* Input URB */
421 char *inbuf; /* Input buffer */
422 dma_addr_t inbuf_dma; /* Input buffer dma */
423 spinlock_t inlock; /* Input fifo spinlock */
424
425 struct urb *urbctrl; /* Control URB */
426 struct usb_ctrlrequest *cr; /* Control request struct */
427 dma_addr_t cr_dma; /* Control request struct dma */
428 struct hid_control_fifo ctrl[HID_CONTROL_FIFO_SIZE]; /* Control fifo */
429 unsigned char ctrlhead, ctrltail; /* Control fifo head & tail */
430 char *ctrlbuf; /* Control buffer */
431 dma_addr_t ctrlbuf_dma; /* Control buffer dma */
432 spinlock_t ctrllock; /* Control fifo spinlock */
433
434 struct urb *urbout; /* Output URB */
435 struct hid_report *out[HID_CONTROL_FIFO_SIZE]; /* Output pipe fifo */
436 unsigned char outhead, outtail; /* Output pipe fifo head & tail */
437 char *outbuf; /* Output buffer */
438 dma_addr_t outbuf_dma; /* Output buffer dma */
439 spinlock_t outlock; /* Output fifo spinlock */
440
441 unsigned claimed; /* Claimed by hidinput, hiddev? */
442 unsigned quirks; /* Various quirks the device can pull on us */
443
444 struct list_head inputs; /* The list of inputs */
445 void *hiddev; /* The hiddev structure */
446 int minor; /* Hiddev minor number */
447
448 wait_queue_head_t wait; /* For sleeping */
449
450 int open; /* is the device open by anyone? */
451 char name[128]; /* Device name */
452 char phys[64]; /* Device physical location */
453 char uniq[64]; /* Device unique identifier (serial #) */
454
455#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
456 unsigned long pb_pressed_fn[NBITS(KEY_MAX)];
457 unsigned long pb_pressed_numlock[NBITS(KEY_MAX)];
458#endif
459};
460
461#define HID_GLOBAL_STACK_SIZE 4
462#define HID_COLLECTION_STACK_SIZE 4
463
464struct hid_parser {
465 struct hid_global global;
466 struct hid_global global_stack[HID_GLOBAL_STACK_SIZE];
467 unsigned global_stack_ptr;
468 struct hid_local local;
469 unsigned collection_stack[HID_COLLECTION_STACK_SIZE];
470 unsigned collection_stack_ptr;
471 struct hid_device *device;
472};
473
474struct hid_class_descriptor {
475 __u8 bDescriptorType;
476 __u16 wDescriptorLength;
477} __attribute__ ((packed));
478
479struct hid_descriptor {
480 __u8 bLength;
481 __u8 bDescriptorType;
482 __u16 bcdHID;
483 __u8 bCountryCode;
484 __u8 bNumDescriptors;
485
486 struct hid_class_descriptor desc[1];
487} __attribute__ ((packed));
488
489#ifdef DEBUG
490#include "hid-debug.h"
491#else
492#define hid_dump_input(a,b) do { } while (0)
493#define hid_dump_device(c) do { } while (0)
494#define hid_dump_field(a,b) do { } while (0)
495#define resolv_usage(a) do { } while (0)
496#define resolv_event(a,b) do { } while (0)
497#endif
498
499#endif
500
501#ifdef CONFIG_USB_HIDINPUT
502/* Applications from HID Usage Tables 4/8/99 Version 1.1 */
503/* We ignore a few input applications that are not widely used */
504#define IS_INPUT_APPLICATION(a) (((a >= 0x00010000) && (a <= 0x00010008)) || (a == 0x00010080) || (a == 0x000c0001))
505extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
506extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
507extern int hidinput_connect(struct hid_device *);
508extern void hidinput_disconnect(struct hid_device *);
509#else
510#define IS_INPUT_APPLICATION(a) (0)
511static inline void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value) { }
512static inline void hidinput_report_event(struct hid_device *hid, struct hid_report *report) { }
513static inline int hidinput_connect(struct hid_device *hid) { return -ENODEV; }
514static inline void hidinput_disconnect(struct hid_device *hid) { }
515#endif
516
517int hid_open(struct hid_device *);
518void hid_close(struct hid_device *);
519int hid_set_field(struct hid_field *, unsigned, __s32);
520void hid_submit_report(struct hid_device *, struct hid_report *, unsigned char dir);
521void hid_init_reports(struct hid_device *hid);
522int hid_wait_io(struct hid_device* hid);
523
524
525#ifdef CONFIG_HID_FF
526int hid_ff_init(struct hid_device *hid);
527
528int hid_lgff_init(struct hid_device *hid);
529int hid_tmff_init(struct hid_device *hid);
530int hid_zpff_init(struct hid_device *hid);
531#ifdef CONFIG_HID_PID
532int hid_pidff_init(struct hid_device *hid);
533#else
534static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
535#endif
536
537#else
538static inline int hid_ff_init(struct hid_device *hid) { return -1; }
539#endif
540
diff --git a/drivers/usb/input/hiddev.c b/drivers/usb/input/hiddev.c
index 7dc14d0cacc1..a8b3d66cd498 100644
--- a/drivers/usb/input/hiddev.c
+++ b/drivers/usb/input/hiddev.c
@@ -32,8 +32,9 @@
32#include <linux/smp_lock.h> 32#include <linux/smp_lock.h>
33#include <linux/input.h> 33#include <linux/input.h>
34#include <linux/usb.h> 34#include <linux/usb.h>
35#include "hid.h" 35#include <linux/hid.h>
36#include <linux/hiddev.h> 36#include <linux/hiddev.h>
37#include "usbhid.h"
37 38
38#ifdef CONFIG_USB_DYNAMIC_MINORS 39#ifdef CONFIG_USB_DYNAMIC_MINORS
39#define HIDDEV_MINOR_BASE 0 40#define HIDDEV_MINOR_BASE 0
@@ -196,7 +197,7 @@ void hiddev_hid_event(struct hid_device *hid, struct hid_field *field,
196 197
197 hiddev_send_event(hid, &uref); 198 hiddev_send_event(hid, &uref);
198} 199}
199 200EXPORT_SYMBOL_GPL(hiddev_hid_event);
200 201
201void hiddev_report_event(struct hid_device *hid, struct hid_report *report) 202void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
202{ 203{
@@ -213,6 +214,7 @@ void hiddev_report_event(struct hid_device *hid, struct hid_report *report)
213 214
214 hiddev_send_event(hid, &uref); 215 hiddev_send_event(hid, &uref);
215} 216}
217
216/* 218/*
217 * fasync file op 219 * fasync file op
218 */ 220 */
@@ -239,7 +241,7 @@ static int hiddev_release(struct inode * inode, struct file * file)
239 241
240 if (!--list->hiddev->open) { 242 if (!--list->hiddev->open) {
241 if (list->hiddev->exist) 243 if (list->hiddev->exist)
242 hid_close(list->hiddev->hid); 244 usbhid_close(list->hiddev->hid);
243 else 245 else
244 kfree(list->hiddev); 246 kfree(list->hiddev);
245 } 247 }
@@ -270,7 +272,7 @@ static int hiddev_open(struct inode *inode, struct file *file)
270 272
271 if (!list->hiddev->open++) 273 if (!list->hiddev->open++)
272 if (list->hiddev->exist) 274 if (list->hiddev->exist)
273 hid_open(hiddev_table[i]->hid); 275 usbhid_open(hiddev_table[i]->hid);
274 276
275 return 0; 277 return 0;
276} 278}
@@ -382,7 +384,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
382 struct hiddev_list *list = file->private_data; 384 struct hiddev_list *list = file->private_data;
383 struct hiddev *hiddev = list->hiddev; 385 struct hiddev *hiddev = list->hiddev;
384 struct hid_device *hid = hiddev->hid; 386 struct hid_device *hid = hiddev->hid;
385 struct usb_device *dev = hid->dev; 387 struct usb_device *dev = hid_to_usb_dev(hid);
386 struct hiddev_collection_info cinfo; 388 struct hiddev_collection_info cinfo;
387 struct hiddev_report_info rinfo; 389 struct hiddev_report_info rinfo;
388 struct hiddev_field_info finfo; 390 struct hiddev_field_info finfo;
@@ -391,6 +393,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
391 struct hiddev_devinfo dinfo; 393 struct hiddev_devinfo dinfo;
392 struct hid_report *report; 394 struct hid_report *report;
393 struct hid_field *field; 395 struct hid_field *field;
396 struct usbhid_device *usbhid = hid->driver_data;
394 void __user *user_arg = (void __user *)arg; 397 void __user *user_arg = (void __user *)arg;
395 int i; 398 int i;
396 399
@@ -420,7 +423,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
420 dinfo.bustype = BUS_USB; 423 dinfo.bustype = BUS_USB;
421 dinfo.busnum = dev->bus->busnum; 424 dinfo.busnum = dev->bus->busnum;
422 dinfo.devnum = dev->devnum; 425 dinfo.devnum = dev->devnum;
423 dinfo.ifnum = hid->ifnum; 426 dinfo.ifnum = usbhid->ifnum;
424 dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor); 427 dinfo.vendor = le16_to_cpu(dev->descriptor.idVendor);
425 dinfo.product = le16_to_cpu(dev->descriptor.idProduct); 428 dinfo.product = le16_to_cpu(dev->descriptor.idProduct);
426 dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice); 429 dinfo.version = le16_to_cpu(dev->descriptor.bcdDevice);
@@ -479,7 +482,7 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
479 } 482 }
480 483
481 case HIDIOCINITREPORT: 484 case HIDIOCINITREPORT:
482 hid_init_reports(hid); 485 usbhid_init_reports(hid);
483 486
484 return 0; 487 return 0;
485 488
@@ -493,8 +496,8 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
493 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 496 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
494 return -EINVAL; 497 return -EINVAL;
495 498
496 hid_submit_report(hid, report, USB_DIR_IN); 499 usbhid_submit_report(hid, report, USB_DIR_IN);
497 hid_wait_io(hid); 500 usbhid_wait_io(hid);
498 501
499 return 0; 502 return 0;
500 503
@@ -508,8 +511,8 @@ static int hiddev_ioctl(struct inode *inode, struct file *file, unsigned int cmd
508 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL) 511 if ((report = hiddev_lookup_report(hid, &rinfo)) == NULL)
509 return -EINVAL; 512 return -EINVAL;
510 513
511 hid_submit_report(hid, report, USB_DIR_OUT); 514 usbhid_submit_report(hid, report, USB_DIR_OUT);
512 hid_wait_io(hid); 515 usbhid_wait_io(hid);
513 516
514 return 0; 517 return 0;
515 518
@@ -745,6 +748,7 @@ static struct usb_class_driver hiddev_class = {
745int hiddev_connect(struct hid_device *hid) 748int hiddev_connect(struct hid_device *hid)
746{ 749{
747 struct hiddev *hiddev; 750 struct hiddev *hiddev;
751 struct usbhid_device *usbhid = hid->driver_data;
748 int i; 752 int i;
749 int retval; 753 int retval;
750 754
@@ -760,7 +764,7 @@ int hiddev_connect(struct hid_device *hid)
760 if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL))) 764 if (!(hiddev = kzalloc(sizeof(struct hiddev), GFP_KERNEL)))
761 return -1; 765 return -1;
762 766
763 retval = usb_register_dev(hid->intf, &hiddev_class); 767 retval = usb_register_dev(usbhid->intf, &hiddev_class);
764 if (retval) { 768 if (retval) {
765 err("Not able to get a minor for this device."); 769 err("Not able to get a minor for this device.");
766 kfree(hiddev); 770 kfree(hiddev);
@@ -772,10 +776,10 @@ int hiddev_connect(struct hid_device *hid)
772 hiddev->hid = hid; 776 hiddev->hid = hid;
773 hiddev->exist = 1; 777 hiddev->exist = 1;
774 778
775 hid->minor = hid->intf->minor; 779 hid->minor = usbhid->intf->minor;
776 hid->hiddev = hiddev; 780 hid->hiddev = hiddev;
777 781
778 hiddev_table[hid->intf->minor - HIDDEV_MINOR_BASE] = hiddev; 782 hiddev_table[usbhid->intf->minor - HIDDEV_MINOR_BASE] = hiddev;
779 783
780 return 0; 784 return 0;
781} 785}
@@ -788,14 +792,15 @@ static struct usb_class_driver hiddev_class;
788void hiddev_disconnect(struct hid_device *hid) 792void hiddev_disconnect(struct hid_device *hid)
789{ 793{
790 struct hiddev *hiddev = hid->hiddev; 794 struct hiddev *hiddev = hid->hiddev;
795 struct usbhid_device *usbhid = hid->driver_data;
791 796
792 hiddev->exist = 0; 797 hiddev->exist = 0;
793 798
794 hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL; 799 hiddev_table[hiddev->hid->minor - HIDDEV_MINOR_BASE] = NULL;
795 usb_deregister_dev(hiddev->hid->intf, &hiddev_class); 800 usb_deregister_dev(usbhid->intf, &hiddev_class);
796 801
797 if (hiddev->open) { 802 if (hiddev->open) {
798 hid_close(hiddev->hid); 803 usbhid_close(hiddev->hid);
799 wake_up_interruptible(&hiddev->wait); 804 wake_up_interruptible(&hiddev->wait);
800 } else { 805 } else {
801 kfree(hiddev); 806 kfree(hiddev);
diff --git a/drivers/usb/input/usbhid.h b/drivers/usb/input/usbhid.h
new file mode 100644
index 000000000000..0023f96d4294
--- /dev/null
+++ b/drivers/usb/input/usbhid.h
@@ -0,0 +1,87 @@
1#ifndef __USBHID_H
2#define __USBHID_H
3
4/*
5 * Copyright (c) 1999 Andreas Gal
6 * Copyright (c) 2000-2001 Vojtech Pavlik
7 * Copyright (c) 2006 Jiri Kosina
8 */
9
10/*
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 */
26
27#include <linux/types.h>
28#include <linux/slab.h>
29#include <linux/list.h>
30#include <linux/timer.h>
31#include <linux/workqueue.h>
32#include <linux/input.h>
33
34/* API provided by hid-core.c for USB HID drivers */
35int usbhid_wait_io(struct hid_device* hid);
36void usbhid_close(struct hid_device *hid);
37int usbhid_open(struct hid_device *hid);
38void usbhid_init_reports(struct hid_device *hid);
39void usbhid_submit_report(struct hid_device *hid, struct hid_report *report, unsigned char dir);
40
41/*
42 * USB-specific HID struct, to be pointed to
43 * from struct hid_device->driver_data
44 */
45
46struct usbhid_device {
47 struct hid_device *hid; /* pointer to corresponding HID dev */
48
49 struct usb_interface *intf; /* USB interface */
50 int ifnum; /* USB interface number */
51
52 unsigned int bufsize; /* URB buffer size */
53
54 struct urb *urbin; /* Input URB */
55 char *inbuf; /* Input buffer */
56 dma_addr_t inbuf_dma; /* Input buffer dma */
57 spinlock_t inlock; /* Input fifo spinlock */
58
59 struct urb *urbctrl; /* Control URB */
60 struct usb_ctrlrequest *cr; /* Control request struct */
61 dma_addr_t cr_dma; /* Control request struct dma */
62 struct hid_control_fifo ctrl[HID_CONTROL_FIFO_SIZE]; /* Control fifo */
63 unsigned char ctrlhead, ctrltail; /* Control fifo head & tail */
64 char *ctrlbuf; /* Control buffer */
65 dma_addr_t ctrlbuf_dma; /* Control buffer dma */
66 spinlock_t ctrllock; /* Control fifo spinlock */
67
68 struct urb *urbout; /* Output URB */
69 struct hid_report *out[HID_CONTROL_FIFO_SIZE]; /* Output pipe fifo */
70 unsigned char outhead, outtail; /* Output pipe fifo head & tail */
71 char *outbuf; /* Output buffer */
72 dma_addr_t outbuf_dma; /* Output buffer dma */
73 spinlock_t outlock; /* Output fifo spinlock */
74
75 unsigned long iofl; /* I/O flags (CTRL_RUNNING, OUT_RUNNING) */
76 struct timer_list io_retry; /* Retry timer */
77 unsigned long stop_retry; /* Time to give up, in jiffies */
78 unsigned int retry_delay; /* Delay length in ms */
79 struct work_struct reset_work; /* Task context for resets */
80
81};
82
83#define hid_to_usb_dev(hid_dev) \
84 container_of(hid_dev->dev->parent, struct usb_device, dev)
85
86#endif
87
diff --git a/drivers/usb/input/usbtouchscreen.c b/drivers/usb/input/usbtouchscreen.c
index 7f3c57da9bc0..86e37a20f8e5 100644
--- a/drivers/usb/input/usbtouchscreen.c
+++ b/drivers/usb/input/usbtouchscreen.c
@@ -66,7 +66,7 @@ struct usbtouch_device_info {
66 66
67 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len); 67 void (*process_pkt) (struct usbtouch_usb *usbtouch, unsigned char *pkt, int len);
68 int (*get_pkt_len) (unsigned char *pkt, int len); 68 int (*get_pkt_len) (unsigned char *pkt, int len);
69 int (*read_data) (unsigned char *pkt, int *x, int *y, int *touch, int *press); 69 int (*read_data) (struct usbtouch_usb *usbtouch, unsigned char *pkt);
70 int (*init) (struct usbtouch_usb *usbtouch); 70 int (*init) (struct usbtouch_usb *usbtouch);
71}; 71};
72 72
@@ -85,6 +85,9 @@ struct usbtouch_usb {
85 struct usbtouch_device_info *type; 85 struct usbtouch_device_info *type;
86 char name[128]; 86 char name[128];
87 char phys[64]; 87 char phys[64];
88
89 int x, y;
90 int touch, press;
88}; 91};
89 92
90 93
@@ -161,14 +164,14 @@ static struct usb_device_id usbtouch_devices[] = {
161#define EGALAX_PKT_TYPE_REPT 0x80 164#define EGALAX_PKT_TYPE_REPT 0x80
162#define EGALAX_PKT_TYPE_DIAG 0x0A 165#define EGALAX_PKT_TYPE_DIAG 0x0A
163 166
164static int egalax_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 167static int egalax_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
165{ 168{
166 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT) 169 if ((pkt[0] & EGALAX_PKT_TYPE_MASK) != EGALAX_PKT_TYPE_REPT)
167 return 0; 170 return 0;
168 171
169 *x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F); 172 dev->x = ((pkt[3] & 0x0F) << 7) | (pkt[4] & 0x7F);
170 *y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F); 173 dev->y = ((pkt[1] & 0x0F) << 7) | (pkt[2] & 0x7F);
171 *touch = pkt[0] & 0x01; 174 dev->touch = pkt[0] & 0x01;
172 175
173 return 1; 176 return 1;
174} 177}
@@ -195,11 +198,11 @@ static int egalax_get_pkt_len(unsigned char *buf, int len)
195 * PanJit Part 198 * PanJit Part
196 */ 199 */
197#ifdef CONFIG_USB_TOUCHSCREEN_PANJIT 200#ifdef CONFIG_USB_TOUCHSCREEN_PANJIT
198static int panjit_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 201static int panjit_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
199{ 202{
200 *x = ((pkt[2] & 0x0F) << 8) | pkt[1]; 203 dev->x = ((pkt[2] & 0x0F) << 8) | pkt[1];
201 *y = ((pkt[4] & 0x0F) << 8) | pkt[3]; 204 dev->y = ((pkt[4] & 0x0F) << 8) | pkt[3];
202 *touch = pkt[0] & 0x01; 205 dev->touch = pkt[0] & 0x01;
203 206
204 return 1; 207 return 1;
205} 208}
@@ -215,11 +218,11 @@ static int panjit_read_data(unsigned char *pkt, int *x, int *y, int *touch, int
215#define MTOUCHUSB_RESET 7 218#define MTOUCHUSB_RESET 7
216#define MTOUCHUSB_REQ_CTRLLR_ID 10 219#define MTOUCHUSB_REQ_CTRLLR_ID 10
217 220
218static int mtouch_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 221static int mtouch_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
219{ 222{
220 *x = (pkt[8] << 8) | pkt[7]; 223 dev->x = (pkt[8] << 8) | pkt[7];
221 *y = (pkt[10] << 8) | pkt[9]; 224 dev->y = (pkt[10] << 8) | pkt[9];
222 *touch = (pkt[2] & 0x40) ? 1 : 0; 225 dev->touch = (pkt[2] & 0x40) ? 1 : 0;
223 226
224 return 1; 227 return 1;
225} 228}
@@ -260,14 +263,32 @@ static int mtouch_init(struct usbtouch_usb *usbtouch)
260 * ITM Part 263 * ITM Part
261 */ 264 */
262#ifdef CONFIG_USB_TOUCHSCREEN_ITM 265#ifdef CONFIG_USB_TOUCHSCREEN_ITM
263static int itm_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 266static int itm_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
264{ 267{
265 *x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F); 268 int touch;
266 *y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F); 269 /*
267 *press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F); 270 * ITM devices report invalid x/y data if not touched.
268 *touch = ~pkt[7] & 0x20; 271 * if the screen was touched before but is not touched any more
272 * report touch as 0 with the last valid x/y data once. then stop
273 * reporting data until touched again.
274 */
275 dev->press = ((pkt[2] & 0x01) << 7) | (pkt[5] & 0x7F);
276
277 touch = ~pkt[7] & 0x20;
278 if (!touch) {
279 if (dev->touch) {
280 dev->touch = 0;
281 return 1;
282 }
269 283
270 return *touch; 284 return 0;
285 }
286
287 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[3] & 0x7F);
288 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[4] & 0x7F);
289 dev->touch = touch;
290
291 return 1;
271} 292}
272#endif 293#endif
273 294
@@ -276,7 +297,7 @@ static int itm_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *pr
276 * eTurboTouch part 297 * eTurboTouch part
277 */ 298 */
278#ifdef CONFIG_USB_TOUCHSCREEN_ETURBO 299#ifdef CONFIG_USB_TOUCHSCREEN_ETURBO
279static int eturbo_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 300static int eturbo_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
280{ 301{
281 unsigned int shift; 302 unsigned int shift;
282 303
@@ -285,9 +306,9 @@ static int eturbo_read_data(unsigned char *pkt, int *x, int *y, int *touch, int
285 return 0; 306 return 0;
286 307
287 shift = (6 - (pkt[0] & 0x03)); 308 shift = (6 - (pkt[0] & 0x03));
288 *x = ((pkt[3] << 7) | pkt[4]) >> shift; 309 dev->x = ((pkt[3] << 7) | pkt[4]) >> shift;
289 *y = ((pkt[1] << 7) | pkt[2]) >> shift; 310 dev->y = ((pkt[1] << 7) | pkt[2]) >> shift;
290 *touch = (pkt[0] & 0x10) ? 1 : 0; 311 dev->touch = (pkt[0] & 0x10) ? 1 : 0;
291 312
292 return 1; 313 return 1;
293} 314}
@@ -307,14 +328,14 @@ static int eturbo_get_pkt_len(unsigned char *buf, int len)
307 * Gunze part 328 * Gunze part
308 */ 329 */
309#ifdef CONFIG_USB_TOUCHSCREEN_GUNZE 330#ifdef CONFIG_USB_TOUCHSCREEN_GUNZE
310static int gunze_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 331static int gunze_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
311{ 332{
312 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80)) 333 if (!(pkt[0] & 0x80) || ((pkt[1] | pkt[2] | pkt[3]) & 0x80))
313 return 0; 334 return 0;
314 335
315 *x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F); 336 dev->x = ((pkt[0] & 0x1F) << 7) | (pkt[2] & 0x7F);
316 *y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F); 337 dev->y = ((pkt[1] & 0x1F) << 7) | (pkt[3] & 0x7F);
317 *touch = pkt[0] & 0x20; 338 dev->touch = pkt[0] & 0x20;
318 339
319 return 1; 340 return 1;
320} 341}
@@ -383,11 +404,11 @@ static int dmc_tsc10_init(struct usbtouch_usb *usbtouch)
383} 404}
384 405
385 406
386static int dmc_tsc10_read_data(unsigned char *pkt, int *x, int *y, int *touch, int *press) 407static int dmc_tsc10_read_data(struct usbtouch_usb *dev, unsigned char *pkt)
387{ 408{
388 *x = ((pkt[2] & 0x03) << 8) | pkt[1]; 409 dev->x = ((pkt[2] & 0x03) << 8) | pkt[1];
389 *y = ((pkt[4] & 0x03) << 8) | pkt[3]; 410 dev->y = ((pkt[4] & 0x03) << 8) | pkt[3];
390 *touch = pkt[0] & 0x01; 411 dev->touch = pkt[0] & 0x01;
391 412
392 return 1; 413 return 1;
393} 414}
@@ -492,23 +513,22 @@ static struct usbtouch_device_info usbtouch_dev_info[] = {
492static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch, 513static void usbtouch_process_pkt(struct usbtouch_usb *usbtouch,
493 unsigned char *pkt, int len) 514 unsigned char *pkt, int len)
494{ 515{
495 int x, y, touch, press;
496 struct usbtouch_device_info *type = usbtouch->type; 516 struct usbtouch_device_info *type = usbtouch->type;
497 517
498 if (!type->read_data(pkt, &x, &y, &touch, &press)) 518 if (!type->read_data(usbtouch, pkt))
499 return; 519 return;
500 520
501 input_report_key(usbtouch->input, BTN_TOUCH, touch); 521 input_report_key(usbtouch->input, BTN_TOUCH, usbtouch->touch);
502 522
503 if (swap_xy) { 523 if (swap_xy) {
504 input_report_abs(usbtouch->input, ABS_X, y); 524 input_report_abs(usbtouch->input, ABS_X, usbtouch->y);
505 input_report_abs(usbtouch->input, ABS_Y, x); 525 input_report_abs(usbtouch->input, ABS_Y, usbtouch->x);
506 } else { 526 } else {
507 input_report_abs(usbtouch->input, ABS_X, x); 527 input_report_abs(usbtouch->input, ABS_X, usbtouch->x);
508 input_report_abs(usbtouch->input, ABS_Y, y); 528 input_report_abs(usbtouch->input, ABS_Y, usbtouch->y);
509 } 529 }
510 if (type->max_press) 530 if (type->max_press)
511 input_report_abs(usbtouch->input, ABS_PRESSURE, press); 531 input_report_abs(usbtouch->input, ABS_PRESSURE, usbtouch->press);
512 input_sync(usbtouch->input); 532 input_sync(usbtouch->input);
513} 533}
514 534
diff --git a/drivers/usb/input/wacom_sys.c b/drivers/usb/input/wacom_sys.c
index e7cc20ab8155..12b42746ded8 100644
--- a/drivers/usb/input/wacom_sys.c
+++ b/drivers/usb/input/wacom_sys.c
@@ -159,13 +159,13 @@ void input_dev_i3s(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
159{ 159{
160 input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_FINGER); 160 input_dev->keybit[LONG(BTN_DIGI)] |= BIT(BTN_TOOL_FINGER);
161 input_dev->keybit[LONG(BTN_LEFT)] |= BIT(BTN_0) | BIT(BTN_1) | BIT(BTN_2) | BIT(BTN_3); 161 input_dev->keybit[LONG(BTN_LEFT)] |= BIT(BTN_0) | BIT(BTN_1) | BIT(BTN_2) | BIT(BTN_3);
162 input_set_abs_params(input_dev, ABS_RX, 0, 4097, 0, 0); 162 input_set_abs_params(input_dev, ABS_RX, 0, 4096, 0, 0);
163} 163}
164 164
165void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac) 165void input_dev_i3(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
166{ 166{
167 input_dev->keybit[LONG(BTN_LEFT)] |= BIT(BTN_4) | BIT(BTN_5) | BIT(BTN_6) | BIT(BTN_7); 167 input_dev->keybit[LONG(BTN_LEFT)] |= BIT(BTN_4) | BIT(BTN_5) | BIT(BTN_6) | BIT(BTN_7);
168 input_set_abs_params(input_dev, ABS_RY, 0, 4097, 0, 0); 168 input_set_abs_params(input_dev, ABS_RY, 0, 4096, 0, 0);
169} 169}
170 170
171void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac) 171void input_dev_i(struct input_dev *input_dev, struct wacom_wac *wacom_wac)
diff --git a/drivers/usb/input/wacom_wac.c b/drivers/usb/input/wacom_wac.c
index 92726fe89379..4142e36730fc 100644
--- a/drivers/usb/input/wacom_wac.c
+++ b/drivers/usb/input/wacom_wac.c
@@ -209,13 +209,15 @@ static int wacom_graphire_irq(struct wacom_wac *wacom, void *wcombo)
209 wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02); 209 wacom_report_key(wcombo, BTN_STYLUS, data[1] & 0x02);
210 wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04); 210 wacom_report_key(wcombo, BTN_STYLUS2, data[1] & 0x04);
211 } 211 }
212 }
213
214 if (data[1] & 0x10)
215 wacom_report_abs(wcombo, ABS_MISC, id); /* report tool id */ 212 wacom_report_abs(wcombo, ABS_MISC, id); /* report tool id */
213 }
216 else 214 else
217 wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */ 215 wacom_report_abs(wcombo, ABS_MISC, 0); /* reset tool id */
218 wacom_report_key(wcombo, wacom->tool[0], data[1] & 0x10); 216
217 if (data[1] & 0x10) /* only report prox-in when in area */
218 wacom_report_key(wcombo, wacom->tool[0], 1);
219 if (!(data[1] & 0x90)) /* report prox-out when physically out */
220 wacom_report_key(wcombo, wacom->tool[0], 0);
219 wacom_input_sync(wcombo); 221 wacom_input_sync(wcombo);
220 222
221 /* send pad data */ 223 /* send pad data */
@@ -405,7 +407,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
405 if ((wacom->features->type == CINTIQ) && !(data[1] & 0x40)) 407 if ((wacom->features->type == CINTIQ) && !(data[1] & 0x40))
406 return 0; 408 return 0;
407 409
408 if (wacom->features->type >= INTUOS3) { 410 if (wacom->features->type >= INTUOS3S) {
409 wacom_report_abs(wcombo, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1)); 411 wacom_report_abs(wcombo, ABS_X, (data[2] << 9) | (data[3] << 1) | ((data[9] >> 1) & 1));
410 wacom_report_abs(wcombo, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1)); 412 wacom_report_abs(wcombo, ABS_Y, (data[4] << 9) | (data[5] << 1) | (data[9] & 1));
411 wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 2) & 0x3f)); 413 wacom_report_abs(wcombo, ABS_DISTANCE, ((data[9] >> 2) & 0x3f));
@@ -423,7 +425,7 @@ static int wacom_intuos_irq(struct wacom_wac *wacom, void *wcombo)
423 425
424 if (data[1] & 0x02) { 426 if (data[1] & 0x02) {
425 /* Rotation packet */ 427 /* Rotation packet */
426 if (wacom->features->type >= INTUOS3) { 428 if (wacom->features->type >= INTUOS3S) {
427 /* I3 marker pen rotation reported as wheel 429 /* I3 marker pen rotation reported as wheel
428 * due to valuator limitation 430 * due to valuator limitation
429 */ 431 */
@@ -547,11 +549,11 @@ static struct wacom_features wacom_features[] = {
547 { "Wacom Graphire3 6x8", 8, 16704, 12064, 511, 63, GRAPHIRE }, 549 { "Wacom Graphire3 6x8", 8, 16704, 12064, 511, 63, GRAPHIRE },
548 { "Wacom Graphire4 4x5", 8, 10208, 7424, 511, 63, WACOM_G4 }, 550 { "Wacom Graphire4 4x5", 8, 10208, 7424, 511, 63, WACOM_G4 },
549 { "Wacom Graphire4 6x8", 8, 16704, 12064, 511, 63, WACOM_G4 }, 551 { "Wacom Graphire4 6x8", 8, 16704, 12064, 511, 63, WACOM_G4 },
550 { "Wacom Volito", 8, 5104, 3712, 511, 0, GRAPHIRE }, 552 { "Wacom Volito", 8, 5104, 3712, 511, 63, GRAPHIRE },
551 { "Wacom PenStation2", 8, 3250, 2320, 255, 0, GRAPHIRE }, 553 { "Wacom PenStation2", 8, 3250, 2320, 255, 63, GRAPHIRE },
552 { "Wacom Volito2 4x5", 8, 5104, 3712, 511, 0, GRAPHIRE }, 554 { "Wacom Volito2 4x5", 8, 5104, 3712, 511, 63, GRAPHIRE },
553 { "Wacom Volito2 2x3", 8, 3248, 2320, 511, 0, GRAPHIRE }, 555 { "Wacom Volito2 2x3", 8, 3248, 2320, 511, 63, GRAPHIRE },
554 { "Wacom PenPartner2", 8, 3250, 2320, 255, 0, GRAPHIRE }, 556 { "Wacom PenPartner2", 8, 3250, 2320, 255, 63, GRAPHIRE },
555 { "Wacom Intuos 4x5", 10, 12700, 10600, 1023, 63, INTUOS }, 557 { "Wacom Intuos 4x5", 10, 12700, 10600, 1023, 63, INTUOS },
556 { "Wacom Intuos 6x8", 10, 20320, 16240, 1023, 63, INTUOS }, 558 { "Wacom Intuos 6x8", 10, 20320, 16240, 1023, 63, INTUOS },
557 { "Wacom Intuos 9x12", 10, 30480, 24060, 1023, 63, INTUOS }, 559 { "Wacom Intuos 9x12", 10, 30480, 24060, 1023, 63, INTUOS },
@@ -580,7 +582,7 @@ static struct wacom_features wacom_features[] = {
580 { "Wacom Intuos3 12x12", 10, 60960, 60960, 1023, 63, INTUOS3L }, 582 { "Wacom Intuos3 12x12", 10, 60960, 60960, 1023, 63, INTUOS3L },
581 { "Wacom Intuos3 12x19", 10, 97536, 60960, 1023, 63, INTUOS3L }, 583 { "Wacom Intuos3 12x19", 10, 97536, 60960, 1023, 63, INTUOS3L },
582 { "Wacom Intuos3 6x11", 10, 54204, 31750, 1023, 63, INTUOS3 }, 584 { "Wacom Intuos3 6x11", 10, 54204, 31750, 1023, 63, INTUOS3 },
583 { "Wacom Intuos3 4x6", 10, 31496, 19685, 1023, 15, INTUOS3S }, 585 { "Wacom Intuos3 4x6", 10, 31496, 19685, 1023, 63, INTUOS3S },
584 { "Wacom Cintiq 21UX", 10, 87200, 65600, 1023, 63, CINTIQ }, 586 { "Wacom Cintiq 21UX", 10, 87200, 65600, 1023, 63, CINTIQ },
585 { "Wacom Intuos2 6x8", 10, 20320, 16240, 1023, 63, INTUOS }, 587 { "Wacom Intuos2 6x8", 10, 20320, 16240, 1023, 63, INTUOS },
586 { } 588 { }
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-23 15:30:16 -0500