aboutsummaryrefslogtreecommitdiffstats
path: root/drivers
diff options
context:
space:
mode:
Diffstat (limited to 'drivers')
-rw-r--r--drivers/usb/input/Kconfig8
-rw-r--r--drivers/usb/input/Makefile2
-rw-r--r--drivers/usb/input/hid-ff.c45
-rw-r--r--drivers/usb/input/hid-input.c21
-rw-r--r--drivers/usb/input/hid-pidff.c1330
-rw-r--r--drivers/usb/input/hid.h15
-rw-r--r--drivers/usb/input/pid.c295
-rw-r--r--drivers/usb/input/pid.h62
8 files changed, 1364 insertions, 414 deletions
diff --git a/drivers/usb/input/Kconfig b/drivers/usb/input/Kconfig
index 650103bc9618..7ec22c8decc8 100644
--- a/drivers/usb/input/Kconfig
+++ b/drivers/usb/input/Kconfig
@@ -60,12 +60,12 @@ config HID_FF
60 If unsure, say N. 60 If unsure, say N.
61 61
62config HID_PID 62config HID_PID
63 bool "PID Devices (Microsoft Sidewinder Force Feedback 2)" 63 bool "PID device support"
64 depends on HID_FF 64 depends on HID_FF
65 help 65 help
66 Say Y here if you have a PID-compliant joystick and wish to enable force 66 Say Y here if you have a PID-compliant device and wish to enable force
67 feedback for it. The Microsoft Sidewinder Force Feedback 2 is one such 67 feedback for it. Microsoft Sidewinder Force Feedback 2 is one of such
68 device. 68 devices.
69 69
70config LOGITECH_FF 70config LOGITECH_FF
71 bool "Logitech WingMan *3D support" 71 bool "Logitech WingMan *3D support"
diff --git a/drivers/usb/input/Makefile b/drivers/usb/input/Makefile
index 764114529c56..84e72dcfc920 100644
--- a/drivers/usb/input/Makefile
+++ b/drivers/usb/input/Makefile
@@ -14,7 +14,7 @@ ifeq ($(CONFIG_USB_HIDINPUT),y)
14 usbhid-objs += hid-input.o 14 usbhid-objs += hid-input.o
15endif 15endif
16ifeq ($(CONFIG_HID_PID),y) 16ifeq ($(CONFIG_HID_PID),y)
17 usbhid-objs += pid.o 17 usbhid-objs += hid-pidff.o
18endif 18endif
19ifeq ($(CONFIG_LOGITECH_FF),y) 19ifeq ($(CONFIG_LOGITECH_FF),y)
20 usbhid-objs += hid-lgff.o 20 usbhid-objs += hid-lgff.o
diff --git a/drivers/usb/input/hid-ff.c b/drivers/usb/input/hid-ff.c
index d5c91ee67991..1b4882202144 100644
--- a/drivers/usb/input/hid-ff.c
+++ b/drivers/usb/input/hid-ff.c
@@ -44,45 +44,34 @@ struct hid_ff_initializer {
44 int (*init)(struct hid_device*); 44 int (*init)(struct hid_device*);
45}; 45};
46 46
47/*
48 * We try pidff when no other driver is found because PID is the
49 * standards compliant way of implementing force feedback in HID.
50 * pidff_init() will quickly abort if the device doesn't appear to
51 * be a PID device
52 */
47static struct hid_ff_initializer inits[] = { 53static struct hid_ff_initializer inits[] = {
48#ifdef CONFIG_LOGITECH_FF 54#ifdef CONFIG_LOGITECH_FF
49 {0x46d, 0xc211, hid_lgff_init}, // Logitech Cordless rumble pad 55 { 0x46d, 0xc211, hid_lgff_init }, /* Logitech Cordless rumble pad */
50 {0x46d, 0xc283, hid_lgff_init}, // Logitech Wingman Force 3d 56 { 0x46d, 0xc283, hid_lgff_init }, /* Logitech Wingman Force 3d */
51 {0x46d, 0xc295, hid_lgff_init}, // Logitech MOMO force wheel 57 { 0x46d, 0xc295, hid_lgff_init }, /* Logitech MOMO force wheel */
52 {0x46d, 0xc219, hid_lgff_init}, // Logitech Cordless rumble pad 2 58 { 0x46d, 0xc219, hid_lgff_init }, /* Logitech Cordless rumble pad 2 */
53#endif
54#ifdef CONFIG_HID_PID
55 {0x45e, 0x001b, hid_pid_init},
56#endif 59#endif
57#ifdef CONFIG_THRUSTMASTER_FF 60#ifdef CONFIG_THRUSTMASTER_FF
58 {0x44f, 0xb304, hid_tmff_init}, 61 { 0x44f, 0xb304, hid_tmff_init },
59#endif 62#endif
60 {0, 0, NULL} /* Terminating entry */ 63 { 0, 0, hid_pidff_init} /* Matches anything */
61}; 64};
62 65
63static struct hid_ff_initializer *hid_get_ff_init(__u16 idVendor,
64 __u16 idProduct)
65{
66 struct hid_ff_initializer *init;
67 for (init = inits;
68 init->idVendor
69 && !(init->idVendor == idVendor
70 && init->idProduct == idProduct);
71 init++);
72
73 return init->idVendor? init : NULL;
74}
75
76int hid_ff_init(struct hid_device* hid) 66int hid_ff_init(struct hid_device* hid)
77{ 67{
78 struct hid_ff_initializer *init; 68 struct hid_ff_initializer *init;
69 int vendor = le16_to_cpu(hid->dev->descriptor.idVendor);
70 int product = le16_to_cpu(hid->dev->descriptor.idProduct);
79 71
80 init = hid_get_ff_init(le16_to_cpu(hid->dev->descriptor.idVendor), 72 for (init = inits; init->idVendor; init++)
81 le16_to_cpu(hid->dev->descriptor.idProduct)); 73 if (init->idVendor == vendor && init->idProduct == product)
74 break;
82 75
83 if (!init) {
84 dbg("hid_ff_init could not find initializer");
85 return -ENOSYS;
86 }
87 return init->init(hid); 76 return init->init(hid);
88} 77}
diff --git a/drivers/usb/input/hid-input.c b/drivers/usb/input/hid-input.c
index 7208839f2dbf..37b9ea8ec3b3 100644
--- a/drivers/usb/input/hid-input.c
+++ b/drivers/usb/input/hid-input.c
@@ -65,11 +65,9 @@ static const struct {
65#define map_rel(c) do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_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) 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) 67#define map_led(c) do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
68#define map_ff(c) do { usage->code = c; usage->type = EV_FF; bit = input->ffbit; max = FF_MAX; } while (0)
69 68
70#define map_abs_clear(c) do { map_abs(c); clear_bit(c, bit); } while (0) 69#define map_abs_clear(c) do { map_abs(c); clear_bit(c, bit); } while (0)
71#define map_key_clear(c) do { map_key(c); clear_bit(c, bit); } while (0) 70#define map_key_clear(c) do { map_key(c); clear_bit(c, bit); } while (0)
72#define map_ff_effect(c) do { set_bit(c, input->ffbit); } while (0)
73 71
74#ifdef CONFIG_USB_HIDINPUT_POWERBOOK 72#ifdef CONFIG_USB_HIDINPUT_POWERBOOK
75 73
@@ -525,23 +523,7 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
525 523
526 case HID_UP_PID: 524 case HID_UP_PID:
527 525
528 set_bit(EV_FF, input->evbit);
529 switch(usage->hid & HID_USAGE) { 526 switch(usage->hid & HID_USAGE) {
530 case 0x26: map_ff_effect(FF_CONSTANT); goto ignore;
531 case 0x27: map_ff_effect(FF_RAMP); goto ignore;
532 case 0x28: map_ff_effect(FF_CUSTOM); goto ignore;
533 case 0x30: map_ff_effect(FF_SQUARE); map_ff_effect(FF_PERIODIC); goto ignore;
534 case 0x31: map_ff_effect(FF_SINE); map_ff_effect(FF_PERIODIC); goto ignore;
535 case 0x32: map_ff_effect(FF_TRIANGLE); map_ff_effect(FF_PERIODIC); goto ignore;
536 case 0x33: map_ff_effect(FF_SAW_UP); map_ff_effect(FF_PERIODIC); goto ignore;
537 case 0x34: map_ff_effect(FF_SAW_DOWN); map_ff_effect(FF_PERIODIC); goto ignore;
538 case 0x40: map_ff_effect(FF_SPRING); goto ignore;
539 case 0x41: map_ff_effect(FF_DAMPER); goto ignore;
540 case 0x42: map_ff_effect(FF_INERTIA); goto ignore;
541 case 0x43: map_ff_effect(FF_FRICTION); goto ignore;
542 case 0x7e: map_ff(FF_GAIN); break;
543 case 0x83: input->ff_effects_max = field->value[0]; goto ignore;
544 case 0x98: map_ff(FF_AUTOCENTER); break;
545 case 0xa4: map_key_clear(BTN_DEAD); break; 527 case 0xa4: map_key_clear(BTN_DEAD); break;
546 default: goto ignore; 528 default: goto ignore;
547 } 529 }
@@ -698,8 +680,7 @@ void hidinput_hid_event(struct hid_device *hid, struct hid_field *field, struct
698 } 680 }
699 681
700 if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */ 682 if (usage->hid == (HID_UP_PID | 0x83UL)) { /* Simultaneous Effects Max */
701 input->ff_effects_max = value; 683 dbg("Maximum Effects - %d",value);
702 dbg("Maximum Effects - %d",input->ff_effects_max);
703 return; 684 return;
704 } 685 }
705 686
diff --git a/drivers/usb/input/hid-pidff.c b/drivers/usb/input/hid-pidff.c
new file mode 100644
index 000000000000..5420c13eb8eb
--- /dev/null
+++ b/drivers/usb/input/hid-pidff.c
@@ -0,0 +1,1330 @@
1/*
2 * Force feedback driver for USB HID PID compliant devices
3 *
4 * Copyright (c) 2005, 2006 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/* #define DEBUG */
24
25#define debug(format, arg...) pr_debug("hid-pidff: " format "\n" , ## arg)
26
27#include <linux/sched.h>
28#include <linux/input.h>
29#include <linux/usb.h>
30
31#include "hid.h"
32
33#define PID_EFFECTS_MAX 64
34
35/* Report usage table used to put reports into an array */
36
37#define PID_SET_EFFECT 0
38#define PID_EFFECT_OPERATION 1
39#define PID_DEVICE_GAIN 2
40#define PID_POOL 3
41#define PID_BLOCK_LOAD 4
42#define PID_BLOCK_FREE 5
43#define PID_DEVICE_CONTROL 6
44#define PID_CREATE_NEW_EFFECT 7
45
46#define PID_REQUIRED_REPORTS 7
47
48#define PID_SET_ENVELOPE 8
49#define PID_SET_CONDITION 9
50#define PID_SET_PERIODIC 10
51#define PID_SET_CONSTANT 11
52#define PID_SET_RAMP 12
53static const u8 pidff_reports[] = {
54 0x21, 0x77, 0x7d, 0x7f, 0x89, 0x90, 0x96, 0xab,
55 0x5a, 0x5f, 0x6e, 0x73, 0x74
56};
57
58/* device_control is really 0x95, but 0x96 specified as it is the usage of
59the only field in that report */
60
61/* Value usage tables used to put fields and values into arrays */
62
63#define PID_EFFECT_BLOCK_INDEX 0
64
65#define PID_DURATION 1
66#define PID_GAIN 2
67#define PID_TRIGGER_BUTTON 3
68#define PID_TRIGGER_REPEAT_INT 4
69#define PID_DIRECTION_ENABLE 5
70#define PID_START_DELAY 6
71static const u8 pidff_set_effect[] = {
72 0x22, 0x50, 0x52, 0x53, 0x54, 0x56, 0xa7
73};
74
75#define PID_ATTACK_LEVEL 1
76#define PID_ATTACK_TIME 2
77#define PID_FADE_LEVEL 3
78#define PID_FADE_TIME 4
79static const u8 pidff_set_envelope[] = { 0x22, 0x5b, 0x5c, 0x5d, 0x5e };
80
81#define PID_PARAM_BLOCK_OFFSET 1
82#define PID_CP_OFFSET 2
83#define PID_POS_COEFFICIENT 3
84#define PID_NEG_COEFFICIENT 4
85#define PID_POS_SATURATION 5
86#define PID_NEG_SATURATION 6
87#define PID_DEAD_BAND 7
88static const u8 pidff_set_condition[] = {
89 0x22, 0x23, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65
90};
91
92#define PID_MAGNITUDE 1
93#define PID_OFFSET 2
94#define PID_PHASE 3
95#define PID_PERIOD 4
96static const u8 pidff_set_periodic[] = { 0x22, 0x70, 0x6f, 0x71, 0x72 };
97static const u8 pidff_set_constant[] = { 0x22, 0x70 };
98
99#define PID_RAMP_START 1
100#define PID_RAMP_END 2
101static const u8 pidff_set_ramp[] = { 0x22, 0x75, 0x76 };
102
103#define PID_RAM_POOL_AVAILABLE 1
104static const u8 pidff_block_load[] = { 0x22, 0xac };
105
106#define PID_LOOP_COUNT 1
107static const u8 pidff_effect_operation[] = { 0x22, 0x7c };
108
109static const u8 pidff_block_free[] = { 0x22 };
110
111#define PID_DEVICE_GAIN_FIELD 0
112static const u8 pidff_device_gain[] = { 0x7e };
113
114#define PID_RAM_POOL_SIZE 0
115#define PID_SIMULTANEOUS_MAX 1
116#define PID_DEVICE_MANAGED_POOL 2
117static const u8 pidff_pool[] = { 0x80, 0x83, 0xa9 };
118
119/* Special field key tables used to put special field keys into arrays */
120
121#define PID_ENABLE_ACTUATORS 0
122#define PID_RESET 1
123static const u8 pidff_device_control[] = { 0x97, 0x9a };
124
125#define PID_CONSTANT 0
126#define PID_RAMP 1
127#define PID_SQUARE 2
128#define PID_SINE 3
129#define PID_TRIANGLE 4
130#define PID_SAW_UP 5
131#define PID_SAW_DOWN 6
132#define PID_SPRING 7
133#define PID_DAMPER 8
134#define PID_INERTIA 9
135#define PID_FRICTION 10
136static const u8 pidff_effect_types[] = {
137 0x26, 0x27, 0x30, 0x31, 0x32, 0x33, 0x34,
138 0x40, 0x41, 0x42, 0x43
139};
140
141#define PID_BLOCK_LOAD_SUCCESS 0
142#define PID_BLOCK_LOAD_FULL 1
143static const u8 pidff_block_load_status[] = { 0x8c, 0x8d };
144
145#define PID_EFFECT_START 0
146#define PID_EFFECT_STOP 1
147static const u8 pidff_effect_operation_status[] = { 0x79, 0x7b };
148
149struct pidff_usage {
150 struct hid_field *field;
151 s32 *value;
152};
153
154struct pidff_device {
155 struct hid_device *hid;
156
157 struct hid_report *reports[sizeof(pidff_reports)];
158
159 struct pidff_usage set_effect[sizeof(pidff_set_effect)];
160 struct pidff_usage set_envelope[sizeof(pidff_set_envelope)];
161 struct pidff_usage set_condition[sizeof(pidff_set_condition)];
162 struct pidff_usage set_periodic[sizeof(pidff_set_periodic)];
163 struct pidff_usage set_constant[sizeof(pidff_set_constant)];
164 struct pidff_usage set_ramp[sizeof(pidff_set_ramp)];
165
166 struct pidff_usage device_gain[sizeof(pidff_device_gain)];
167 struct pidff_usage block_load[sizeof(pidff_block_load)];
168 struct pidff_usage pool[sizeof(pidff_pool)];
169 struct pidff_usage effect_operation[sizeof(pidff_effect_operation)];
170 struct pidff_usage block_free[sizeof(pidff_block_free)];
171
172 /* Special field is a field that is not composed of
173 usage<->value pairs that pidff_usage values are */
174
175 /* Special field in create_new_effect */
176 struct hid_field *create_new_effect_type;
177
178 /* Special fields in set_effect */
179 struct hid_field *set_effect_type;
180 struct hid_field *effect_direction;
181
182 /* Special field in device_control */
183 struct hid_field *device_control;
184
185 /* Special field in block_load */
186 struct hid_field *block_load_status;
187
188 /* Special field in effect_operation */
189 struct hid_field *effect_operation_status;
190
191 int control_id[sizeof(pidff_device_control)];
192 int type_id[sizeof(pidff_effect_types)];
193 int status_id[sizeof(pidff_block_load_status)];
194 int operation_id[sizeof(pidff_effect_operation_status)];
195
196 int pid_id[PID_EFFECTS_MAX];
197};
198
199/*
200 * Scale an unsigned value with range 0..max for the given field
201 */
202static int pidff_rescale(int i, int max, struct hid_field *field)
203{
204 return i * (field->logical_maximum - field->logical_minimum) / max +
205 field->logical_minimum;
206}
207
208/*
209 * Scale a signed value in range -0x8000..0x7fff for the given field
210 */
211static int pidff_rescale_signed(int i, struct hid_field *field)
212{
213 return i == 0 ? 0 : i >
214 0 ? i * field->logical_maximum / 0x7fff : i *
215 field->logical_minimum / -0x8000;
216}
217
218static void pidff_set(struct pidff_usage *usage, u16 value)
219{
220 usage->value[0] = pidff_rescale(value, 0xffff, usage->field);
221 debug("calculated from %d to %d", value, usage->value[0]);
222}
223
224static void pidff_set_signed(struct pidff_usage *usage, s16 value)
225{
226 if (usage->field->logical_minimum < 0)
227 usage->value[0] = pidff_rescale_signed(value, usage->field);
228 else {
229 if (value < 0)
230 usage->value[0] =
231 pidff_rescale(-value, 0x8000, usage->field);
232 else
233 usage->value[0] =
234 pidff_rescale(value, 0x7fff, usage->field);
235 }
236 debug("calculated from %d to %d", value, usage->value[0]);
237}
238
239/*
240 * Send envelope report to the device
241 */
242static void pidff_set_envelope_report(struct pidff_device *pidff,
243 struct ff_envelope *envelope)
244{
245 pidff->set_envelope[PID_EFFECT_BLOCK_INDEX].value[0] =
246 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
247
248 pidff->set_envelope[PID_ATTACK_LEVEL].value[0] =
249 pidff_rescale(envelope->attack_level >
250 0x7fff ? 0x7fff : envelope->attack_level, 0x7fff,
251 pidff->set_envelope[PID_ATTACK_LEVEL].field);
252 pidff->set_envelope[PID_FADE_LEVEL].value[0] =
253 pidff_rescale(envelope->fade_level >
254 0x7fff ? 0x7fff : envelope->fade_level, 0x7fff,
255 pidff->set_envelope[PID_FADE_LEVEL].field);
256
257 pidff->set_envelope[PID_ATTACK_TIME].value[0] = envelope->attack_length;
258 pidff->set_envelope[PID_FADE_TIME].value[0] = envelope->fade_length;
259
260 debug("attack %u => %d", envelope->attack_level,
261 pidff->set_envelope[PID_ATTACK_LEVEL].value[0]);
262
263 hid_submit_report(pidff->hid, pidff->reports[PID_SET_ENVELOPE],
264 USB_DIR_OUT);
265}
266
267/*
268 * Test if the new envelope differs from old one
269 */
270static int pidff_needs_set_envelope(struct ff_envelope *envelope,
271 struct ff_envelope *old)
272{
273 return envelope->attack_level != old->attack_level ||
274 envelope->fade_level != old->fade_level ||
275 envelope->attack_length != old->attack_length ||
276 envelope->fade_length != old->fade_length;
277}
278
279/*
280 * Send constant force report to the device
281 */
282static void pidff_set_constant_force_report(struct pidff_device *pidff,
283 struct ff_effect *effect)
284{
285 pidff->set_constant[PID_EFFECT_BLOCK_INDEX].value[0] =
286 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
287 pidff_set_signed(&pidff->set_constant[PID_MAGNITUDE],
288 effect->u.constant.level);
289
290 hid_submit_report(pidff->hid, pidff->reports[PID_SET_CONSTANT],
291 USB_DIR_OUT);
292}
293
294/*
295 * Test if the constant parameters have changed between effects
296 */
297static int pidff_needs_set_constant(struct ff_effect *effect,
298 struct ff_effect *old)
299{
300 return effect->u.constant.level != old->u.constant.level;
301}
302
303/*
304 * Send set effect report to the device
305 */
306static void pidff_set_effect_report(struct pidff_device *pidff,
307 struct ff_effect *effect)
308{
309 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =
310 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
311 pidff->set_effect_type->value[0] =
312 pidff->create_new_effect_type->value[0];
313 pidff->set_effect[PID_DURATION].value[0] = effect->replay.length;
314 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = effect->trigger.button;
315 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] =
316 effect->trigger.interval;
317 pidff->set_effect[PID_GAIN].value[0] =
318 pidff->set_effect[PID_GAIN].field->logical_maximum;
319 pidff->set_effect[PID_DIRECTION_ENABLE].value[0] = 1;
320 pidff->effect_direction->value[0] =
321 pidff_rescale(effect->direction, 0xffff,
322 pidff->effect_direction);
323 pidff->set_effect[PID_START_DELAY].value[0] = effect->replay.delay;
324
325 hid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
326 USB_DIR_OUT);
327}
328
329/*
330 * Test if the values used in set_effect have changed
331 */
332static int pidff_needs_set_effect(struct ff_effect *effect,
333 struct ff_effect *old)
334{
335 return effect->replay.length != old->replay.length ||
336 effect->trigger.interval != old->trigger.interval ||
337 effect->trigger.button != old->trigger.button ||
338 effect->direction != old->direction ||
339 effect->replay.delay != old->replay.delay;
340}
341
342/*
343 * Send periodic effect report to the device
344 */
345static void pidff_set_periodic_report(struct pidff_device *pidff,
346 struct ff_effect *effect)
347{
348 pidff->set_periodic[PID_EFFECT_BLOCK_INDEX].value[0] =
349 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
350 pidff_set_signed(&pidff->set_periodic[PID_MAGNITUDE],
351 effect->u.periodic.magnitude);
352 pidff_set_signed(&pidff->set_periodic[PID_OFFSET],
353 effect->u.periodic.offset);
354 pidff_set(&pidff->set_periodic[PID_PHASE], effect->u.periodic.phase);
355 pidff->set_periodic[PID_PERIOD].value[0] = effect->u.periodic.period;
356
357 hid_submit_report(pidff->hid, pidff->reports[PID_SET_PERIODIC],
358 USB_DIR_OUT);
359
360}
361
362/*
363 * Test if periodic effect parameters have changed
364 */
365static int pidff_needs_set_periodic(struct ff_effect *effect,
366 struct ff_effect *old)
367{
368 return effect->u.periodic.magnitude != old->u.periodic.magnitude ||
369 effect->u.periodic.offset != old->u.periodic.offset ||
370 effect->u.periodic.phase != old->u.periodic.phase ||
371 effect->u.periodic.period != old->u.periodic.period;
372}
373
374/*
375 * Send condition effect reports to the device
376 */
377static void pidff_set_condition_report(struct pidff_device *pidff,
378 struct ff_effect *effect)
379{
380 int i;
381
382 pidff->set_condition[PID_EFFECT_BLOCK_INDEX].value[0] =
383 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
384
385 for (i = 0; i < 2; i++) {
386 pidff->set_condition[PID_PARAM_BLOCK_OFFSET].value[0] = i;
387 pidff_set_signed(&pidff->set_condition[PID_CP_OFFSET],
388 effect->u.condition[i].center);
389 pidff_set_signed(&pidff->set_condition[PID_POS_COEFFICIENT],
390 effect->u.condition[i].right_coeff);
391 pidff_set_signed(&pidff->set_condition[PID_NEG_COEFFICIENT],
392 effect->u.condition[i].left_coeff);
393 pidff_set(&pidff->set_condition[PID_POS_SATURATION],
394 effect->u.condition[i].right_saturation);
395 pidff_set(&pidff->set_condition[PID_NEG_SATURATION],
396 effect->u.condition[i].left_saturation);
397 pidff_set(&pidff->set_condition[PID_DEAD_BAND],
398 effect->u.condition[i].deadband);
399 hid_wait_io(pidff->hid);
400 hid_submit_report(pidff->hid, pidff->reports[PID_SET_CONDITION],
401 USB_DIR_OUT);
402 }
403}
404
405/*
406 * Test if condition effect parameters have changed
407 */
408static int pidff_needs_set_condition(struct ff_effect *effect,
409 struct ff_effect *old)
410{
411 int i;
412 int ret = 0;
413
414 for (i = 0; i < 2; i++) {
415 struct ff_condition_effect *cond = &effect->u.condition[i];
416 struct ff_condition_effect *old_cond = &old->u.condition[i];
417
418 ret |= cond->center != old_cond->center ||
419 cond->right_coeff != old_cond->right_coeff ||
420 cond->left_coeff != old_cond->left_coeff ||
421 cond->right_saturation != old_cond->right_saturation ||
422 cond->left_saturation != old_cond->left_saturation ||
423 cond->deadband != old_cond->deadband;
424 }
425
426 return ret;
427}
428
429/*
430 * Send ramp force report to the device
431 */
432static void pidff_set_ramp_force_report(struct pidff_device *pidff,
433 struct ff_effect *effect)
434{
435 pidff->set_ramp[PID_EFFECT_BLOCK_INDEX].value[0] =
436 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
437 pidff_set_signed(&pidff->set_ramp[PID_RAMP_START],
438 effect->u.ramp.start_level);
439 pidff_set_signed(&pidff->set_ramp[PID_RAMP_END],
440 effect->u.ramp.end_level);
441 hid_submit_report(pidff->hid, pidff->reports[PID_SET_RAMP],
442 USB_DIR_OUT);
443}
444
445/*
446 * Test if ramp force parameters have changed
447 */
448static int pidff_needs_set_ramp(struct ff_effect *effect, struct ff_effect *old)
449{
450 return effect->u.ramp.start_level != old->u.ramp.start_level ||
451 effect->u.ramp.end_level != old->u.ramp.end_level;
452}
453
454/*
455 * Send a request for effect upload to the device
456 *
457 * Returns 0 if device reported success, -ENOSPC if the device reported memory
458 * is full. Upon unknown response the function will retry for 60 times, if
459 * still unsuccessful -EIO is returned.
460 */
461static int pidff_request_effect_upload(struct pidff_device *pidff, int efnum)
462{
463 int j;
464
465 pidff->create_new_effect_type->value[0] = efnum;
466 hid_submit_report(pidff->hid, pidff->reports[PID_CREATE_NEW_EFFECT],
467 USB_DIR_OUT);
468 debug("create_new_effect sent, type: %d", efnum);
469
470 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] = 0;
471 pidff->block_load_status->value[0] = 0;
472 hid_wait_io(pidff->hid);
473
474 for (j = 0; j < 60; j++) {
475 debug("pid_block_load requested");
476 hid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_LOAD],
477 USB_DIR_IN);
478 hid_wait_io(pidff->hid);
479 if (pidff->block_load_status->value[0] ==
480 pidff->status_id[PID_BLOCK_LOAD_SUCCESS]) {
481 debug("device reported free memory: %d bytes",
482 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
483 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);
484 return 0;
485 }
486 if (pidff->block_load_status->value[0] ==
487 pidff->status_id[PID_BLOCK_LOAD_FULL]) {
488 debug("not enough memory free: %d bytes",
489 pidff->block_load[PID_RAM_POOL_AVAILABLE].value ?
490 pidff->block_load[PID_RAM_POOL_AVAILABLE].value[0] : -1);
491 return -ENOSPC;
492 }
493 }
494 printk(KERN_ERR "hid-pidff: pid_block_load failed 60 times\n");
495 return -EIO;
496}
497
498/*
499 * Play the effect with PID id n times
500 */
501static void pidff_playback_pid(struct pidff_device *pidff, int pid_id, int n)
502{
503 pidff->effect_operation[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;
504
505 if (n == 0) {
506 pidff->effect_operation_status->value[0] =
507 pidff->operation_id[PID_EFFECT_STOP];
508 } else {
509 pidff->effect_operation_status->value[0] =
510 pidff->operation_id[PID_EFFECT_START];
511 pidff->effect_operation[PID_LOOP_COUNT].value[0] = n;
512 }
513
514 hid_wait_io(pidff->hid);
515 hid_submit_report(pidff->hid, pidff->reports[PID_EFFECT_OPERATION],
516 USB_DIR_OUT);
517}
518
519/**
520 * Play the effect with effect id @effect_id for @value times
521 */
522static int pidff_playback(struct input_dev *dev, int effect_id, int value)
523{
524 struct pidff_device *pidff = dev->ff->private;
525
526 pidff_playback_pid(pidff, pidff->pid_id[effect_id], value);
527
528 return 0;
529}
530
531/*
532 * Erase effect with PID id
533 */
534static void pidff_erase_pid(struct pidff_device *pidff, int pid_id)
535{
536 pidff->block_free[PID_EFFECT_BLOCK_INDEX].value[0] = pid_id;
537 hid_submit_report(pidff->hid, pidff->reports[PID_BLOCK_FREE],
538 USB_DIR_OUT);
539}
540
541/*
542 * Stop and erase effect with effect_id
543 */
544static int pidff_erase_effect(struct input_dev *dev, int effect_id)
545{
546 struct pidff_device *pidff = dev->ff->private;
547 int pid_id = pidff->pid_id[effect_id];
548
549 debug("starting to erase %d/%d", effect_id, pidff->pid_id[effect_id]);
550 pidff_playback_pid(pidff, pid_id, 0);
551 pidff_erase_pid(pidff, pid_id);
552
553 return 0;
554}
555
556/*
557 * Effect upload handler
558 */
559static int pidff_upload_effect(struct input_dev *dev, struct ff_effect *effect,
560 struct ff_effect *old)
561{
562 struct pidff_device *pidff = dev->ff->private;
563 int type_id;
564 int error;
565
566 switch (effect->type) {
567 case FF_CONSTANT:
568 if (!old) {
569 error = pidff_request_effect_upload(pidff,
570 pidff->type_id[PID_CONSTANT]);
571 if (error)
572 return error;
573 }
574 if (!old || pidff_needs_set_effect(effect, old))
575 pidff_set_effect_report(pidff, effect);
576 if (!old || pidff_needs_set_constant(effect, old))
577 pidff_set_constant_force_report(pidff, effect);
578 if (!old ||
579 pidff_needs_set_envelope(&effect->u.constant.envelope,
580 &old->u.constant.envelope))
581 pidff_set_envelope_report(pidff,
582 &effect->u.constant.envelope);
583 break;
584
585 case FF_PERIODIC:
586 if (!old) {
587 switch (effect->u.periodic.waveform) {
588 case FF_SQUARE:
589 type_id = PID_SQUARE;
590 break;
591 case FF_TRIANGLE:
592 type_id = PID_TRIANGLE;
593 break;
594 case FF_SINE:
595 type_id = PID_SINE;
596 break;
597 case FF_SAW_UP:
598 type_id = PID_SAW_UP;
599 break;
600 case FF_SAW_DOWN:
601 type_id = PID_SAW_DOWN;
602 break;
603 default:
604 printk(KERN_ERR
605 "hid-pidff: invalid waveform\n");
606 return -EINVAL;
607 }
608
609 error = pidff_request_effect_upload(pidff,
610 pidff->type_id[type_id]);
611 if (error)
612 return error;
613 }
614 if (!old || pidff_needs_set_effect(effect, old))
615 pidff_set_effect_report(pidff, effect);
616 if (!old || pidff_needs_set_periodic(effect, old))
617 pidff_set_periodic_report(pidff, effect);
618 if (!old ||
619 pidff_needs_set_envelope(&effect->u.periodic.envelope,
620 &old->u.periodic.envelope))
621 pidff_set_envelope_report(pidff,
622 &effect->u.periodic.envelope);
623 break;
624
625 case FF_RAMP:
626 if (!old) {
627 error = pidff_request_effect_upload(pidff,
628 pidff->type_id[PID_RAMP]);
629 if (error)
630 return error;
631 }
632 if (!old || pidff_needs_set_effect(effect, old))
633 pidff_set_effect_report(pidff, effect);
634 if (!old || pidff_needs_set_ramp(effect, old))
635 pidff_set_ramp_force_report(pidff, effect);
636 if (!old ||
637 pidff_needs_set_envelope(&effect->u.ramp.envelope,
638 &old->u.ramp.envelope))
639 pidff_set_envelope_report(pidff,
640 &effect->u.ramp.envelope);
641 break;
642
643 case FF_SPRING:
644 if (!old) {
645 error = pidff_request_effect_upload(pidff,
646 pidff->type_id[PID_SPRING]);
647 if (error)
648 return error;
649 }
650 if (!old || pidff_needs_set_effect(effect, old))
651 pidff_set_effect_report(pidff, effect);
652 if (!old || pidff_needs_set_condition(effect, old))
653 pidff_set_condition_report(pidff, effect);
654 break;
655
656 case FF_FRICTION:
657 if (!old) {
658 error = pidff_request_effect_upload(pidff,
659 pidff->type_id[PID_FRICTION]);
660 if (error)
661 return error;
662 }
663 if (!old || pidff_needs_set_effect(effect, old))
664 pidff_set_effect_report(pidff, effect);
665 if (!old || pidff_needs_set_condition(effect, old))
666 pidff_set_condition_report(pidff, effect);
667 break;
668
669 case FF_DAMPER:
670 if (!old) {
671 error = pidff_request_effect_upload(pidff,
672 pidff->type_id[PID_DAMPER]);
673 if (error)
674 return error;
675 }
676 if (!old || pidff_needs_set_effect(effect, old))
677 pidff_set_effect_report(pidff, effect);
678 if (!old || pidff_needs_set_condition(effect, old))
679 pidff_set_condition_report(pidff, effect);
680 break;
681
682 case FF_INERTIA:
683 if (!old) {
684 error = pidff_request_effect_upload(pidff,
685 pidff->type_id[PID_INERTIA]);
686 if (error)
687 return error;
688 }
689 if (!old || pidff_needs_set_effect(effect, old))
690 pidff_set_effect_report(pidff, effect);
691 if (!old || pidff_needs_set_condition(effect, old))
692 pidff_set_condition_report(pidff, effect);
693 break;
694
695 default:
696 printk(KERN_ERR "hid-pidff: invalid type\n");
697 return -EINVAL;
698 }
699
700 if (!old)
701 pidff->pid_id[effect->id] =
702 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0];
703
704 debug("uploaded");
705
706 return 0;
707}
708
709/*
710 * set_gain() handler
711 */
712static void pidff_set_gain(struct input_dev *dev, u16 gain)
713{
714 struct pidff_device *pidff = dev->ff->private;
715
716 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], gain);
717 hid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
718 USB_DIR_OUT);
719}
720
721static void pidff_autocenter(struct pidff_device *pidff, u16 magnitude)
722{
723 struct hid_field *field =
724 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field;
725
726 if (!magnitude) {
727 pidff_playback_pid(pidff, field->logical_minimum, 0);
728 return;
729 }
730
731 pidff_playback_pid(pidff, field->logical_minimum, 1);
732
733 pidff->set_effect[PID_EFFECT_BLOCK_INDEX].value[0] =
734 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum;
735 pidff->set_effect_type->value[0] = pidff->type_id[PID_SPRING];
736 pidff->set_effect[PID_DURATION].value[0] = 0;
737 pidff->set_effect[PID_TRIGGER_BUTTON].value[0] = 0;
738 pidff->set_effect[PID_TRIGGER_REPEAT_INT].value[0] = 0;
739 pidff_set(&pidff->set_effect[PID_GAIN], magnitude);
740 pidff->set_effect[PID_START_DELAY].value[0] = 0;
741
742 hid_submit_report(pidff->hid, pidff->reports[PID_SET_EFFECT],
743 USB_DIR_OUT);
744}
745
746/*
747 * pidff_set_autocenter() handler
748 */
749static void pidff_set_autocenter(struct input_dev *dev, u16 magnitude)
750{
751 struct pidff_device *pidff = dev->ff->private;
752
753 pidff_autocenter(pidff, magnitude);
754}
755
756/*
757 * Find fields from a report and fill a pidff_usage
758 */
759static int pidff_find_fields(struct pidff_usage *usage, const u8 *table,
760 struct hid_report *report, int count, int strict)
761{
762 int i, j, k, found;
763
764 for (k = 0; k < count; k++) {
765 found = 0;
766 for (i = 0; i < report->maxfield; i++) {
767 if (report->field[i]->maxusage !=
768 report->field[i]->report_count) {
769 debug("maxusage and report_count do not match, "
770 "skipping");
771 continue;
772 }
773 for (j = 0; j < report->field[i]->maxusage; j++) {
774 if (report->field[i]->usage[j].hid ==
775 (HID_UP_PID | table[k])) {
776 debug("found %d at %d->%d", k, i, j);
777 usage[k].field = report->field[i];
778 usage[k].value =
779 &report->field[i]->value[j];
780 found = 1;
781 break;
782 }
783 }
784 if (found)
785 break;
786 }
787 if (!found && strict) {
788 debug("failed to locate %d", k);
789 return -1;
790 }
791 }
792 return 0;
793}
794
795/*
796 * Return index into pidff_reports for the given usage
797 */
798static int pidff_check_usage(int usage)
799{
800 int i;
801
802 for (i = 0; i < sizeof(pidff_reports); i++)
803 if (usage == (HID_UP_PID | pidff_reports[i]))
804 return i;
805
806 return -1;
807}
808
809/*
810 * Find the reports and fill pidff->reports[]
811 * report_type specifies either OUTPUT or FEATURE reports
812 */
813static void pidff_find_reports(struct hid_device *hid, int report_type,
814 struct pidff_device *pidff)
815{
816 struct hid_report *report;
817 int i, ret;
818
819 list_for_each_entry(report,
820 &hid->report_enum[report_type].report_list, list) {
821 if (report->maxfield < 1)
822 continue;
823 ret = pidff_check_usage(report->field[0]->logical);
824 if (ret != -1) {
825 debug("found usage 0x%02x from field->logical",
826 pidff_reports[ret]);
827 pidff->reports[ret] = report;
828 continue;
829 }
830
831 /*
832 * Sometimes logical collections are stacked to indicate
833 * different usages for the report and the field, in which
834 * case we want the usage of the parent. However, Linux HID
835 * implementation hides this fact, so we have to dig it up
836 * ourselves
837 */
838 i = report->field[0]->usage[0].collection_index;
839 if (i <= 0 ||
840 hid->collection[i - 1].type != HID_COLLECTION_LOGICAL)
841 continue;
842 ret = pidff_check_usage(hid->collection[i - 1].usage);
843 if (ret != -1 && !pidff->reports[ret]) {
844 debug("found usage 0x%02x from collection array",
845 pidff_reports[ret]);
846 pidff->reports[ret] = report;
847 }
848 }
849}
850
851/*
852 * Test if the required reports have been found
853 */
854static int pidff_reports_ok(struct pidff_device *pidff)
855{
856 int i;
857
858 for (i = 0; i <= PID_REQUIRED_REPORTS; i++) {
859 if (!pidff->reports[i]) {
860 debug("%d missing", i);
861 return 0;
862 }
863 }
864
865 return 1;
866}
867
868/*
869 * Find a field with a specific usage within a report
870 */
871static struct hid_field *pidff_find_special_field(struct hid_report *report,
872 int usage, int enforce_min)
873{
874 int i;
875
876 for (i = 0; i < report->maxfield; i++) {
877 if (report->field[i]->logical == (HID_UP_PID | usage) &&
878 report->field[i]->report_count > 0) {
879 if (!enforce_min ||
880 report->field[i]->logical_minimum == 1)
881 return report->field[i];
882 else {
883 printk(KERN_ERR "hid-pidff: logical_minimum "
884 "is not 1 as it should be\n");
885 return NULL;
886 }
887 }
888 }
889 return NULL;
890}
891
892/*
893 * Fill a pidff->*_id struct table
894 */
895static int pidff_find_special_keys(int *keys, struct hid_field *fld,
896 const u8 *usagetable, int count)
897{
898
899 int i, j;
900 int found = 0;
901
902 for (i = 0; i < count; i++) {
903 for (j = 0; j < fld->maxusage; j++) {
904 if (fld->usage[j].hid == (HID_UP_PID | usagetable[i])) {
905 keys[i] = j + 1;
906 found++;
907 break;
908 }
909 }
910 }
911 return found;
912}
913
914#define PIDFF_FIND_SPECIAL_KEYS(keys, field, name) \
915 pidff_find_special_keys(pidff->keys, pidff->field, pidff_ ## name, \
916 sizeof(pidff_ ## name))
917
918/*
919 * Find and check the special fields
920 */
921static int pidff_find_special_fields(struct pidff_device *pidff)
922{
923 debug("finding special fields");
924
925 pidff->create_new_effect_type =
926 pidff_find_special_field(pidff->reports[PID_CREATE_NEW_EFFECT],
927 0x25, 1);
928 pidff->set_effect_type =
929 pidff_find_special_field(pidff->reports[PID_SET_EFFECT],
930 0x25, 1);
931 pidff->effect_direction =
932 pidff_find_special_field(pidff->reports[PID_SET_EFFECT],
933 0x57, 0);
934 pidff->device_control =
935 pidff_find_special_field(pidff->reports[PID_DEVICE_CONTROL],
936 0x96, 1);
937 pidff->block_load_status =
938 pidff_find_special_field(pidff->reports[PID_BLOCK_LOAD],
939 0x8b, 1);
940 pidff->effect_operation_status =
941 pidff_find_special_field(pidff->reports[PID_EFFECT_OPERATION],
942 0x78, 1);
943
944 debug("search done");
945
946 if (!pidff->create_new_effect_type || !pidff->set_effect_type) {
947 printk(KERN_ERR "hid-pidff: effect lists not found\n");
948 return -1;
949 }
950
951 if (!pidff->effect_direction) {
952 printk(KERN_ERR "hid-pidff: direction field not found\n");
953 return -1;
954 }
955
956 if (!pidff->device_control) {
957 printk(KERN_ERR "hid-pidff: device control field not found\n");
958 return -1;
959 }
960
961 if (!pidff->block_load_status) {
962 printk(KERN_ERR
963 "hid-pidff: block load status field not found\n");
964 return -1;
965 }
966
967 if (!pidff->effect_operation_status) {
968 printk(KERN_ERR
969 "hid-pidff: effect operation field not found\n");
970 return -1;
971 }
972
973 pidff_find_special_keys(pidff->control_id, pidff->device_control,
974 pidff_device_control,
975 sizeof(pidff_device_control));
976
977 PIDFF_FIND_SPECIAL_KEYS(control_id, device_control, device_control);
978
979 if (!PIDFF_FIND_SPECIAL_KEYS(type_id, create_new_effect_type,
980 effect_types)) {
981 printk(KERN_ERR "hid-pidff: no effect types found\n");
982 return -1;
983 }
984
985 if (PIDFF_FIND_SPECIAL_KEYS(status_id, block_load_status,
986 block_load_status) !=
987 sizeof(pidff_block_load_status)) {
988 printk(KERN_ERR
989 "hidpidff: block load status identifiers not found\n");
990 return -1;
991 }
992
993 if (PIDFF_FIND_SPECIAL_KEYS(operation_id, effect_operation_status,
994 effect_operation_status) !=
995 sizeof(pidff_effect_operation_status)) {
996 printk(KERN_ERR
997 "hidpidff: effect operation identifiers not found\n");
998 return -1;
999 }
1000
1001 return 0;
1002}
1003
1004/**
1005 * Find the implemented effect types
1006 */
1007static int pidff_find_effects(struct pidff_device *pidff,
1008 struct input_dev *dev)
1009{
1010 int i;
1011
1012 for (i = 0; i < sizeof(pidff_effect_types); i++) {
1013 int pidff_type = pidff->type_id[i];
1014 if (pidff->set_effect_type->usage[pidff_type].hid !=
1015 pidff->create_new_effect_type->usage[pidff_type].hid) {
1016 printk(KERN_ERR "hid-pidff: "
1017 "effect type number %d is invalid\n", i);
1018 return -1;
1019 }
1020 }
1021
1022 if (pidff->type_id[PID_CONSTANT])
1023 set_bit(FF_CONSTANT, dev->ffbit);
1024 if (pidff->type_id[PID_RAMP])
1025 set_bit(FF_RAMP, dev->ffbit);
1026 if (pidff->type_id[PID_SQUARE]) {
1027 set_bit(FF_SQUARE, dev->ffbit);
1028 set_bit(FF_PERIODIC, dev->ffbit);
1029 }
1030 if (pidff->type_id[PID_SINE]) {
1031 set_bit(FF_SINE, dev->ffbit);
1032 set_bit(FF_PERIODIC, dev->ffbit);
1033 }
1034 if (pidff->type_id[PID_TRIANGLE]) {
1035 set_bit(FF_TRIANGLE, dev->ffbit);
1036 set_bit(FF_PERIODIC, dev->ffbit);
1037 }
1038 if (pidff->type_id[PID_SAW_UP]) {
1039 set_bit(FF_SAW_UP, dev->ffbit);
1040 set_bit(FF_PERIODIC, dev->ffbit);
1041 }
1042 if (pidff->type_id[PID_SAW_DOWN]) {
1043 set_bit(FF_SAW_DOWN, dev->ffbit);
1044 set_bit(FF_PERIODIC, dev->ffbit);
1045 }
1046 if (pidff->type_id[PID_SPRING])
1047 set_bit(FF_SPRING, dev->ffbit);
1048 if (pidff->type_id[PID_DAMPER])
1049 set_bit(FF_DAMPER, dev->ffbit);
1050 if (pidff->type_id[PID_INERTIA])
1051 set_bit(FF_INERTIA, dev->ffbit);
1052 if (pidff->type_id[PID_FRICTION])
1053 set_bit(FF_FRICTION, dev->ffbit);
1054
1055 return 0;
1056
1057}
1058
1059#define PIDFF_FIND_FIELDS(name, report, strict) \
1060 pidff_find_fields(pidff->name, pidff_ ## name, \
1061 pidff->reports[report], \
1062 sizeof(pidff_ ## name), strict)
1063
1064/*
1065 * Fill and check the pidff_usages
1066 */
1067static int pidff_init_fields(struct pidff_device *pidff, struct input_dev *dev)
1068{
1069 int envelope_ok = 0;
1070
1071 if (PIDFF_FIND_FIELDS(set_effect, PID_SET_EFFECT, 1)) {
1072 printk(KERN_ERR
1073 "hid-pidff: unknown set_effect report layout\n");
1074 return -ENODEV;
1075 }
1076
1077 PIDFF_FIND_FIELDS(block_load, PID_BLOCK_LOAD, 0);
1078 if (!pidff->block_load[PID_EFFECT_BLOCK_INDEX].value) {
1079 printk(KERN_ERR
1080 "hid-pidff: unknown pid_block_load report layout\n");
1081 return -ENODEV;
1082 }
1083
1084 if (PIDFF_FIND_FIELDS(effect_operation, PID_EFFECT_OPERATION, 1)) {
1085 printk(KERN_ERR
1086 "hid-pidff: unknown effect_operation report layout\n");
1087 return -ENODEV;
1088 }
1089
1090 if (PIDFF_FIND_FIELDS(block_free, PID_BLOCK_FREE, 1)) {
1091 printk(KERN_ERR
1092 "hid-pidff: unknown pid_block_free report layout\n");
1093 return -ENODEV;
1094 }
1095
1096 if (!PIDFF_FIND_FIELDS(set_envelope, PID_SET_ENVELOPE, 1))
1097 envelope_ok = 1;
1098
1099 if (pidff_find_special_fields(pidff) || pidff_find_effects(pidff, dev))
1100 return -ENODEV;
1101
1102 if (!envelope_ok) {
1103 if (test_and_clear_bit(FF_CONSTANT, dev->ffbit))
1104 printk(KERN_WARNING "hid-pidff: "
1105 "has constant effect but no envelope\n");
1106 if (test_and_clear_bit(FF_RAMP, dev->ffbit))
1107 printk(KERN_WARNING "hid-pidff: "
1108 "has ramp effect but no envelope\n");
1109
1110 if (test_and_clear_bit(FF_PERIODIC, dev->ffbit))
1111 printk(KERN_WARNING "hid-pidff: "
1112 "has periodic effect but no envelope\n");
1113 }
1114
1115 if (test_bit(FF_CONSTANT, dev->ffbit) &&
1116 PIDFF_FIND_FIELDS(set_constant, PID_SET_CONSTANT, 1)) {
1117 printk(KERN_WARNING
1118 "hid-pidff: unknown constant effect layout\n");
1119 clear_bit(FF_CONSTANT, dev->ffbit);
1120 }
1121
1122 if (test_bit(FF_RAMP, dev->ffbit) &&
1123 PIDFF_FIND_FIELDS(set_ramp, PID_SET_RAMP, 1)) {
1124 printk(KERN_WARNING "hid-pidff: unknown ramp effect layout\n");
1125 clear_bit(FF_RAMP, dev->ffbit);
1126 }
1127
1128 if ((test_bit(FF_SPRING, dev->ffbit) ||
1129 test_bit(FF_DAMPER, dev->ffbit) ||
1130 test_bit(FF_FRICTION, dev->ffbit) ||
1131 test_bit(FF_INERTIA, dev->ffbit)) &&
1132 PIDFF_FIND_FIELDS(set_condition, PID_SET_CONDITION, 1)) {
1133 printk(KERN_WARNING
1134 "hid-pidff: unknown condition effect layout\n");
1135 clear_bit(FF_SPRING, dev->ffbit);
1136 clear_bit(FF_DAMPER, dev->ffbit);
1137 clear_bit(FF_FRICTION, dev->ffbit);
1138 clear_bit(FF_INERTIA, dev->ffbit);
1139 }
1140
1141 if (test_bit(FF_PERIODIC, dev->ffbit) &&
1142 PIDFF_FIND_FIELDS(set_periodic, PID_SET_PERIODIC, 1)) {
1143 printk(KERN_WARNING
1144 "hid-pidff: unknown periodic effect layout\n");
1145 clear_bit(FF_PERIODIC, dev->ffbit);
1146 }
1147
1148 PIDFF_FIND_FIELDS(pool, PID_POOL, 0);
1149
1150 if (!PIDFF_FIND_FIELDS(device_gain, PID_DEVICE_GAIN, 1))
1151 set_bit(FF_GAIN, dev->ffbit);
1152
1153 return 0;
1154}
1155
1156/*
1157 * Reset the device
1158 */
1159static void pidff_reset(struct pidff_device *pidff)
1160{
1161 struct hid_device *hid = pidff->hid;
1162 int i = 0;
1163
1164 pidff->device_control->value[0] = pidff->control_id[PID_RESET];
1165 /* 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);
1167 hid_wait_io(hid);
1168 hid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
1169 hid_wait_io(hid);
1170
1171 pidff->device_control->value[0] =
1172 pidff->control_id[PID_ENABLE_ACTUATORS];
1173 hid_submit_report(hid, pidff->reports[PID_DEVICE_CONTROL], USB_DIR_OUT);
1174 hid_wait_io(hid);
1175
1176 /* pool report is sometimes messed up, refetch it */
1177 hid_submit_report(hid, pidff->reports[PID_POOL], USB_DIR_IN);
1178 hid_wait_io(hid);
1179
1180 if (pidff->pool[PID_SIMULTANEOUS_MAX].value) {
1181 int sim_effects = pidff->pool[PID_SIMULTANEOUS_MAX].value[0];
1182 while (sim_effects < 2) {
1183 if (i++ > 20) {
1184 printk(KERN_WARNING "hid-pidff: device reports "
1185 "%d simultaneous effects\n",
1186 sim_effects);
1187 break;
1188 }
1189 debug("pid_pool requested again");
1190 hid_submit_report(hid, pidff->reports[PID_POOL],
1191 USB_DIR_IN);
1192 hid_wait_io(hid);
1193 }
1194 }
1195}
1196
1197/*
1198 * Test if autocenter modification is using the supported method
1199 */
1200static int pidff_check_autocenter(struct pidff_device *pidff,
1201 struct input_dev *dev)
1202{
1203 int error;
1204
1205 /*
1206 * Let's find out if autocenter modification is supported
1207 * Specification doesn't specify anything, so we request an
1208 * effect upload and cancel it immediately. If the approved
1209 * effect id was one above the minimum, then we assume the first
1210 * effect id is a built-in spring type effect used for autocenter
1211 */
1212
1213 error = pidff_request_effect_upload(pidff, 1);
1214 if (error) {
1215 printk(KERN_ERR "hid-pidff: upload request failed\n");
1216 return error;
1217 }
1218
1219 if (pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0] ==
1220 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum + 1) {
1221 pidff_autocenter(pidff, 0xffff);
1222 set_bit(FF_AUTOCENTER, dev->ffbit);
1223 } else {
1224 printk(KERN_NOTICE "hid-pidff: "
1225 "device has unknown autocenter control method\n");
1226 }
1227
1228 pidff_erase_pid(pidff,
1229 pidff->block_load[PID_EFFECT_BLOCK_INDEX].value[0]);
1230
1231 return 0;
1232
1233}
1234
1235/*
1236 * Check if the device is PID and initialize it
1237 */
1238int hid_pidff_init(struct hid_device *hid)
1239{
1240 struct pidff_device *pidff;
1241 struct hid_input *hidinput = list_entry(hid->inputs.next,
1242 struct hid_input, list);
1243 struct input_dev *dev = hidinput->input;
1244 struct ff_device *ff;
1245 int max_effects;
1246 int error;
1247
1248 debug("starting pid init");
1249
1250 if (list_empty(&hid->report_enum[HID_OUTPUT_REPORT].report_list)) {
1251 debug("not a PID device, no output report");
1252 return -ENODEV;
1253 }
1254
1255 pidff = kzalloc(sizeof(*pidff), GFP_KERNEL);
1256 if (!pidff)
1257 return -ENOMEM;
1258
1259 pidff->hid = hid;
1260
1261 pidff_find_reports(hid, HID_OUTPUT_REPORT, pidff);
1262 pidff_find_reports(hid, HID_FEATURE_REPORT, pidff);
1263
1264 if (!pidff_reports_ok(pidff)) {
1265 debug("reports not ok, aborting");
1266 error = -ENODEV;
1267 goto fail;
1268 }
1269
1270 error = pidff_init_fields(pidff, dev);
1271 if (error)
1272 goto fail;
1273
1274 pidff_reset(pidff);
1275
1276 if (test_bit(FF_GAIN, dev->ffbit)) {
1277 pidff_set(&pidff->device_gain[PID_DEVICE_GAIN_FIELD], 0xffff);
1278 hid_submit_report(pidff->hid, pidff->reports[PID_DEVICE_GAIN],
1279 USB_DIR_OUT);
1280 }
1281
1282 error = pidff_check_autocenter(pidff, dev);
1283 if (error)
1284 goto fail;
1285
1286 max_effects =
1287 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_maximum -
1288 pidff->block_load[PID_EFFECT_BLOCK_INDEX].field->logical_minimum +
1289 1;
1290 debug("max effects is %d", max_effects);
1291
1292 if (max_effects > PID_EFFECTS_MAX)
1293 max_effects = PID_EFFECTS_MAX;
1294
1295 if (pidff->pool[PID_SIMULTANEOUS_MAX].value)
1296 debug("max simultaneous effects is %d",
1297 pidff->pool[PID_SIMULTANEOUS_MAX].value[0]);
1298
1299 if (pidff->pool[PID_RAM_POOL_SIZE].value)
1300 debug("device memory size is %d bytes",
1301 pidff->pool[PID_RAM_POOL_SIZE].value[0]);
1302
1303 if (pidff->pool[PID_DEVICE_MANAGED_POOL].value &&
1304 pidff->pool[PID_DEVICE_MANAGED_POOL].value[0] == 0) {
1305 printk(KERN_NOTICE "hid-pidff: "
1306 "device does not support device managed pool\n");
1307 goto fail;
1308 }
1309
1310 error = input_ff_create(dev, max_effects);
1311 if (error)
1312 goto fail;
1313
1314 ff = dev->ff;
1315 ff->private = pidff;
1316 ff->upload = pidff_upload_effect;
1317 ff->erase = pidff_erase_effect;
1318 ff->set_gain = pidff_set_gain;
1319 ff->set_autocenter = pidff_set_autocenter;
1320 ff->playback = pidff_playback;
1321
1322 printk(KERN_INFO "Force feedback for USB HID PID devices by "
1323 "Anssi Hannula <anssi.hannula@gmail.com>\n");
1324
1325 return 0;
1326
1327 fail:
1328 kfree(pidff);
1329 return error;
1330}
diff --git a/drivers/usb/input/hid.h b/drivers/usb/input/hid.h
index 778e575de352..29f1613bd08c 100644
--- a/drivers/usb/input/hid.h
+++ b/drivers/usb/input/hid.h
@@ -527,14 +527,25 @@ int hid_wait_io(struct hid_device* hid);
527 527
528#ifdef CONFIG_HID_FF 528#ifdef CONFIG_HID_FF
529int hid_ff_init(struct hid_device *hid); 529int hid_ff_init(struct hid_device *hid);
530
531int hid_lgff_init(struct hid_device *hid);
532int hid_tmff_init(struct hid_device *hid);
533#ifdef CONFIG_HID_PID
534int hid_pidff_init(struct hid_device *hid);
535#else
536static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; }
537#endif
538
530#else 539#else
531static inline int hid_ff_init(struct hid_device *hid) { return -1; } 540static inline int hid_ff_init(struct hid_device *hid) { return -1; }
532#endif 541#endif
542
533static inline void hid_ff_exit(struct hid_device *hid) 543static inline void hid_ff_exit(struct hid_device *hid)
534{ 544{
535 if (hid->ff_exit) 545 if (hid->ff_exit)
536 hid->ff_exit(hid); 546 hid->ff_exit(hid);
537} 547}
548
538static inline int hid_ff_event(struct hid_device *hid, struct input_dev *input, 549static inline int hid_ff_event(struct hid_device *hid, struct input_dev *input,
539 unsigned int type, unsigned int code, int value) 550 unsigned int type, unsigned int code, int value)
540{ 551{
@@ -543,7 +554,3 @@ static inline int hid_ff_event(struct hid_device *hid, struct input_dev *input,
543 return -ENOSYS; 554 return -ENOSYS;
544} 555}
545 556
546int hid_lgff_init(struct hid_device* hid);
547int hid_tmff_init(struct hid_device* hid);
548int hid_pid_init(struct hid_device* hid);
549
diff --git a/drivers/usb/input/pid.c b/drivers/usb/input/pid.c
deleted file mode 100644
index d9d9f656b8c9..000000000000
--- a/drivers/usb/input/pid.c
+++ /dev/null
@@ -1,295 +0,0 @@
1/*
2 * PID Force feedback support for hid devices.
3 *
4 * Copyright (c) 2002 Rodrigo Damazio.
5 * Portions by Johann Deneux and Bjorn Augustson
6 */
7
8/*
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 *
23 * Should you need to contact me, the author, you can do so by
24 * e-mail - mail your message to <rdamazio@lsi.usp.br>
25 */
26
27#include <linux/config.h>
28#include <linux/module.h>
29#include <linux/slab.h>
30#include <linux/kernel.h>
31#include <linux/init.h>
32#include <linux/mm.h>
33#include <linux/smp_lock.h>
34#include <linux/spinlock.h>
35#include <linux/input.h>
36#include <linux/usb.h>
37#include "hid.h"
38#include "pid.h"
39
40#define CHECK_OWNERSHIP(i, hid_pid) \
41 ((i) < FF_EFFECTS_MAX && i >= 0 && \
42 test_bit(FF_PID_FLAGS_USED, &hid_pid->effects[(i)].flags) && \
43 (current->pid == 0 || \
44 (hid_pid)->effects[(i)].owner == current->pid))
45
46/* Called when a transfer is completed */
47static void hid_pid_ctrl_out(struct urb *u, struct pt_regs *regs)
48{
49 dev_dbg(&u->dev->dev, "hid_pid_ctrl_out - Transfer Completed\n");
50}
51
52static void hid_pid_exit(struct hid_device *hid)
53{
54 struct hid_ff_pid *private = hid->ff_private;
55
56 if (private->urbffout) {
57 usb_kill_urb(private->urbffout);
58 usb_free_urb(private->urbffout);
59 }
60}
61
62static int pid_upload_periodic(struct hid_ff_pid *pid, struct ff_effect *effect, int is_update)
63{
64 dev_info(&pid->hid->dev->dev, "requested periodic force upload\n");
65 return 0;
66}
67
68static int pid_upload_constant(struct hid_ff_pid *pid, struct ff_effect *effect, int is_update)
69{
70 dev_info(&pid->hid->dev->dev, "requested constant force upload\n");
71 return 0;
72}
73
74static int pid_upload_condition(struct hid_ff_pid *pid, struct ff_effect *effect, int is_update)
75{
76 dev_info(&pid->hid->dev->dev, "requested Condition force upload\n");
77 return 0;
78}
79
80static int pid_upload_ramp(struct hid_ff_pid *pid, struct ff_effect *effect, int is_update)
81{
82 dev_info(&pid->hid->dev->dev, "request ramp force upload\n");
83 return 0;
84}
85
86static int hid_pid_event(struct hid_device *hid, struct input_dev *input,
87 unsigned int type, unsigned int code, int value)
88{
89 dev_dbg(&hid->dev->dev, "PID event received: type=%d,code=%d,value=%d.\n", type, code, value);
90
91 if (type != EV_FF)
92 return -1;
93
94 return 0;
95}
96
97/* Lock must be held by caller */
98static void hid_pid_ctrl_playback(struct hid_device *hid, struct hid_pid_effect *effect, int play)
99{
100 if (play)
101 set_bit(FF_PID_FLAGS_PLAYING, &effect->flags);
102 else
103 clear_bit(FF_PID_FLAGS_PLAYING, &effect->flags);
104}
105
106static int hid_pid_erase(struct input_dev *dev, int id)
107{
108 struct hid_device *hid = dev->private;
109 struct hid_ff_pid *pid = hid->ff_private;
110 struct hid_field *field;
111 unsigned long flags;
112 int ret;
113
114 if (!CHECK_OWNERSHIP(id, pid))
115 return -EACCES;
116
117 /* Find report */
118 field = hid_find_field_by_usage(hid, HID_UP_PID | FF_PID_USAGE_BLOCK_FREE,
119 HID_OUTPUT_REPORT);
120 if (!field) {
121 dev_err(&hid->dev->dev, "couldn't find report\n");
122 return -EIO;
123 }
124
125 ret = hid_set_field(field, 0, pid->effects[id].device_id);
126 if (ret) {
127 dev_err(&hid->dev->dev, "couldn't set field\n");
128 return ret;
129 }
130
131 hid_submit_report(hid, field->report, USB_DIR_OUT);
132
133 spin_lock_irqsave(&pid->lock, flags);
134 hid_pid_ctrl_playback(hid, pid->effects + id, 0);
135 pid->effects[id].flags = 0;
136 spin_unlock_irqrestore(&pid->lock, flags);
137
138 return 0;
139}
140
141/* Erase all effects this process owns */
142static int hid_pid_flush(struct input_dev *dev, struct file *file)
143{
144 struct hid_device *hid = dev->private;
145 struct hid_ff_pid *pid = hid->ff_private;
146 int i;
147
148 /*NOTE: no need to lock here. The only times EFFECT_USED is
149 modified is when effects are uploaded or when an effect is
150 erased. But a process cannot close its dev/input/eventX fd
151 and perform ioctls on the same fd all at the same time */
152 /*FIXME: multiple threads, anyone? */
153 for (i = 0; i < dev->ff_effects_max; ++i)
154 if (current->pid == pid->effects[i].owner
155 && test_bit(FF_PID_FLAGS_USED, &pid->effects[i].flags))
156 if (hid_pid_erase(dev, i))
157 dev_warn(&hid->dev->dev, "erase effect %d failed", i);
158
159 return 0;
160}
161
162static int hid_pid_upload_effect(struct input_dev *dev,
163 struct ff_effect *effect)
164{
165 struct hid_ff_pid *pid_private = (struct hid_ff_pid *)(dev->private);
166 int ret;
167 int is_update;
168 unsigned long flags;
169
170 dev_dbg(&pid_private->hid->dev->dev, "upload effect called: effect_type=%x\n", effect->type);
171 /* Check this effect type is supported by this device */
172 if (!test_bit(effect->type, dev->ffbit)) {
173 dev_dbg(&pid_private->hid->dev->dev,
174 "invalid kind of effect requested.\n");
175 return -EINVAL;
176 }
177
178 /*
179 * If we want to create a new effect, get a free id
180 */
181 if (effect->id == -1) {
182 int id = 0;
183
184 // Spinlock so we don`t get a race condition when choosing IDs
185 spin_lock_irqsave(&pid_private->lock, flags);
186
187 while (id < FF_EFFECTS_MAX)
188 if (!test_and_set_bit(FF_PID_FLAGS_USED, &pid_private->effects[id++].flags))
189 break;
190
191 if (id == FF_EFFECTS_MAX) {
192 spin_unlock_irqrestore(&pid_private->lock, flags);
193// TEMP - We need to get ff_effects_max correctly first: || id >= dev->ff_effects_max) {
194 dev_dbg(&pid_private->hid->dev->dev, "Not enough device memory\n");
195 return -ENOMEM;
196 }
197
198 effect->id = id;
199 dev_dbg(&pid_private->hid->dev->dev, "effect ID is %d.\n", id);
200 pid_private->effects[id].owner = current->pid;
201 pid_private->effects[id].flags = (1 << FF_PID_FLAGS_USED);
202 spin_unlock_irqrestore(&pid_private->lock, flags);
203
204 is_update = FF_PID_FALSE;
205 } else {
206 /* We want to update an effect */
207 if (!CHECK_OWNERSHIP(effect->id, pid_private))
208 return -EACCES;
209
210 /* Parameter type cannot be updated */
211 if (effect->type != pid_private->effects[effect->id].effect.type)
212 return -EINVAL;
213
214 /* Check the effect is not already being updated */
215 if (test_bit(FF_PID_FLAGS_UPDATING, &pid_private->effects[effect->id].flags))
216 return -EAGAIN;
217
218 is_update = FF_PID_TRUE;
219 }
220
221 /*
222 * Upload the effect
223 */
224 switch (effect->type) {
225 case FF_PERIODIC:
226 ret = pid_upload_periodic(pid_private, effect, is_update);
227 break;
228
229 case FF_CONSTANT:
230 ret = pid_upload_constant(pid_private, effect, is_update);
231 break;
232
233 case FF_SPRING:
234 case FF_FRICTION:
235 case FF_DAMPER:
236 case FF_INERTIA:
237 ret = pid_upload_condition(pid_private, effect, is_update);
238 break;
239
240 case FF_RAMP:
241 ret = pid_upload_ramp(pid_private, effect, is_update);
242 break;
243
244 default:
245 dev_dbg(&pid_private->hid->dev->dev,
246 "invalid type of effect requested - %x.\n",
247 effect->type);
248 return -EINVAL;
249 }
250 /* If a packet was sent, forbid new updates until we are notified
251 * that the packet was updated
252 */
253 if (ret == 0)
254 set_bit(FF_PID_FLAGS_UPDATING, &pid_private->effects[effect->id].flags);
255 pid_private->effects[effect->id].effect = *effect;
256 return ret;
257}
258
259int hid_pid_init(struct hid_device *hid)
260{
261 struct hid_ff_pid *private;
262 struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
263 struct input_dev *input_dev = hidinput->input;
264
265 private = hid->ff_private = kzalloc(sizeof(struct hid_ff_pid), GFP_KERNEL);
266 if (!private)
267 return -ENOMEM;
268
269 private->hid = hid;
270
271 hid->ff_exit = hid_pid_exit;
272 hid->ff_event = hid_pid_event;
273
274 /* Open output URB */
275 if (!(private->urbffout = usb_alloc_urb(0, GFP_KERNEL))) {
276 kfree(private);
277 return -1;
278 }
279
280 usb_fill_control_urb(private->urbffout, hid->dev, 0,
281 (void *)&private->ffcr, private->ctrl_buffer, 8,
282 hid_pid_ctrl_out, hid);
283
284 input_dev->upload_effect = hid_pid_upload_effect;
285 input_dev->flush = hid_pid_flush;
286 input_dev->ff_effects_max = 8; // A random default
287 set_bit(EV_FF, input_dev->evbit);
288 set_bit(EV_FF_STATUS, input_dev->evbit);
289
290 spin_lock_init(&private->lock);
291
292 printk(KERN_INFO "Force feedback driver for PID devices by Rodrigo Damazio <rdamazio@lsi.usp.br>.\n");
293
294 return 0;
295}
diff --git a/drivers/usb/input/pid.h b/drivers/usb/input/pid.h
deleted file mode 100644
index a2cb9627ed0e..000000000000
--- a/drivers/usb/input/pid.h
+++ /dev/null
@@ -1,62 +0,0 @@
1/*
2 * PID Force feedback support for hid devices.
3 *
4 * Copyright (c) 2002 Rodrigo Damazio.
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 * Should you need to contact me, the author, you can do so by
23 * e-mail - mail your message to <rdamazio@lsi.usp.br>
24 */
25
26#define FF_EFFECTS_MAX 64
27
28#define FF_PID_FLAGS_USED 1 /* If the effect exists */
29#define FF_PID_FLAGS_UPDATING 2 /* If the effect is being updated */
30#define FF_PID_FLAGS_PLAYING 3 /* If the effect is currently being played */
31
32#define FF_PID_FALSE 0
33#define FF_PID_TRUE 1
34
35struct hid_pid_effect {
36 unsigned long flags;
37 pid_t owner;
38 unsigned int device_id; /* The device-assigned ID */
39 struct ff_effect effect;
40};
41
42struct hid_ff_pid {
43 struct hid_device *hid;
44 unsigned long gain;
45
46 struct urb *urbffout;
47 struct usb_ctrlrequest ffcr;
48 spinlock_t lock;
49
50 unsigned char ctrl_buffer[8];
51
52 struct hid_pid_effect effects[FF_EFFECTS_MAX];
53};
54
55/*
56 * Constants from the PID usage table (still far from complete)
57 */
58
59#define FF_PID_USAGE_BLOCK_LOAD 0x89UL
60#define FF_PID_USAGE_BLOCK_FREE 0x90UL
61#define FF_PID_USAGE_NEW_EFFECT 0xABUL
62#define FF_PID_USAGE_POOL_REPORT 0x7FUL
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-21 15:40:59 -0500