diff options
author | Anssi Hannula <anssi.hannula@gmail.com> | 2006-07-19 01:40:47 -0400 |
---|---|---|
committer | Dmitry Torokhov <dtor@insightbb.com> | 2006-07-19 01:40:47 -0400 |
commit | 224ee88fe39564358ec99b46bf3ee6e6999ae17d (patch) | |
tree | 3b88e3aa94c73ea2ea9c17feb5537287df769265 /drivers/usb/input | |
parent | f6a01c85965c9e6fa8fb893c1fa5db16130d0ccb (diff) |
Input: add force feedback driver for PID devices
This replaces the older PID driver which was never completed.
Signed-off-by: Anssi Hannula <anssi.hannula@gmail.com>
Signed-off-by: Dmitry Torokhov <dtor@mail.ru>
Diffstat (limited to 'drivers/usb/input')
-rw-r--r-- | drivers/usb/input/Kconfig | 8 | ||||
-rw-r--r-- | drivers/usb/input/Makefile | 2 | ||||
-rw-r--r-- | drivers/usb/input/hid-ff.c | 45 | ||||
-rw-r--r-- | drivers/usb/input/hid-input.c | 21 | ||||
-rw-r--r-- | drivers/usb/input/hid-pidff.c | 1330 | ||||
-rw-r--r-- | drivers/usb/input/hid.h | 15 | ||||
-rw-r--r-- | drivers/usb/input/pid.c | 295 | ||||
-rw-r--r-- | drivers/usb/input/pid.h | 62 |
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 | ||
62 | config HID_PID | 62 | config 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 | ||
70 | config LOGITECH_FF | 70 | config 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 |
15 | endif | 15 | endif |
16 | ifeq ($(CONFIG_HID_PID),y) | 16 | ifeq ($(CONFIG_HID_PID),y) |
17 | usbhid-objs += pid.o | 17 | usbhid-objs += hid-pidff.o |
18 | endif | 18 | endif |
19 | ifeq ($(CONFIG_LOGITECH_FF),y) | 19 | ifeq ($(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 | */ | ||
47 | static struct hid_ff_initializer inits[] = { | 53 | static 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 | ||
63 | static 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 | |||
76 | int hid_ff_init(struct hid_device* hid) | 66 | int 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 | ||
53 | static 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 | ||
59 | the 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 | ||
71 | static 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 | ||
79 | static 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 | ||
88 | static 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 | ||
96 | static const u8 pidff_set_periodic[] = { 0x22, 0x70, 0x6f, 0x71, 0x72 }; | ||
97 | static const u8 pidff_set_constant[] = { 0x22, 0x70 }; | ||
98 | |||
99 | #define PID_RAMP_START 1 | ||
100 | #define PID_RAMP_END 2 | ||
101 | static const u8 pidff_set_ramp[] = { 0x22, 0x75, 0x76 }; | ||
102 | |||
103 | #define PID_RAM_POOL_AVAILABLE 1 | ||
104 | static const u8 pidff_block_load[] = { 0x22, 0xac }; | ||
105 | |||
106 | #define PID_LOOP_COUNT 1 | ||
107 | static const u8 pidff_effect_operation[] = { 0x22, 0x7c }; | ||
108 | |||
109 | static const u8 pidff_block_free[] = { 0x22 }; | ||
110 | |||
111 | #define PID_DEVICE_GAIN_FIELD 0 | ||
112 | static 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 | ||
117 | static 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 | ||
123 | static 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 | ||
136 | static 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 | ||
143 | static const u8 pidff_block_load_status[] = { 0x8c, 0x8d }; | ||
144 | |||
145 | #define PID_EFFECT_START 0 | ||
146 | #define PID_EFFECT_STOP 1 | ||
147 | static const u8 pidff_effect_operation_status[] = { 0x79, 0x7b }; | ||
148 | |||
149 | struct pidff_usage { | ||
150 | struct hid_field *field; | ||
151 | s32 *value; | ||
152 | }; | ||
153 | |||
154 | struct 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 | */ | ||
202 | static 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 | */ | ||
211 | static 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 | |||
218 | static 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 | |||
224 | static 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 | */ | ||
242 | static 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 | */ | ||
270 | static 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 | */ | ||
282 | static 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 | */ | ||
297 | static 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 | */ | ||
306 | static 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 | */ | ||
332 | static 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 | */ | ||
345 | static 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 | */ | ||
365 | static 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 | */ | ||
377 | static 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 | */ | ||
408 | static 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 | */ | ||
432 | static 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 | */ | ||
448 | static 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 | */ | ||
461 | static 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 | */ | ||
501 | static 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 | */ | ||
522 | static 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 | */ | ||
534 | static 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 | */ | ||
544 | static 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 | */ | ||
559 | static 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 | */ | ||
712 | static 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 | |||
721 | static 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 | */ | ||
749 | static 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 | */ | ||
759 | static 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 | */ | ||
798 | static 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 | */ | ||
813 | static 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 | */ | ||
854 | static 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 | */ | ||
871 | static 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 | */ | ||
895 | static 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 | */ | ||
921 | static 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 | */ | ||
1007 | static 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 | */ | ||
1067 | static 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 | */ | ||
1159 | static 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 | */ | ||
1200 | static 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 | */ | ||
1238 | int 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 |
529 | int hid_ff_init(struct hid_device *hid); | 529 | int hid_ff_init(struct hid_device *hid); |
530 | |||
531 | int hid_lgff_init(struct hid_device *hid); | ||
532 | int hid_tmff_init(struct hid_device *hid); | ||
533 | #ifdef CONFIG_HID_PID | ||
534 | int hid_pidff_init(struct hid_device *hid); | ||
535 | #else | ||
536 | static inline int hid_pidff_init(struct hid_device *hid) { return -ENODEV; } | ||
537 | #endif | ||
538 | |||
530 | #else | 539 | #else |
531 | static inline int hid_ff_init(struct hid_device *hid) { return -1; } | 540 | static inline int hid_ff_init(struct hid_device *hid) { return -1; } |
532 | #endif | 541 | #endif |
542 | |||
533 | static inline void hid_ff_exit(struct hid_device *hid) | 543 | static 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 | |||
538 | static inline int hid_ff_event(struct hid_device *hid, struct input_dev *input, | 549 | static 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 | ||
546 | int hid_lgff_init(struct hid_device* hid); | ||
547 | int hid_tmff_init(struct hid_device* hid); | ||
548 | int 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 */ | ||
47 | static 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 | |||
52 | static 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 | |||
62 | static 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 | |||
68 | static 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 | |||
74 | static 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 | |||
80 | static 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 | |||
86 | static 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 */ | ||
98 | static 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 | |||
106 | static 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 */ | ||
142 | static 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 | |||
162 | static 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 | |||
259 | int 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 | |||
35 | struct 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 | |||
42 | struct 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 | ||