This source file includes following definitions.
- iforce_playback
- iforce_set_gain
- iforce_set_autocenter
- iforce_upload_effect
- iforce_erase_effect
- iforce_open
- iforce_close
- iforce_init_device
1
2
3
4
5
6
7
8
9 #include <asm/unaligned.h>
10 #include "iforce.h"
11
12 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>, Johann Deneux <johann.deneux@gmail.com>");
13 MODULE_DESCRIPTION("Core I-Force joysticks and wheels driver");
14 MODULE_LICENSE("GPL");
15
16 static signed short btn_joystick[] =
17 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
18 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A,
19 BTN_B, BTN_C, BTN_DEAD, -1 };
20
21 static signed short btn_joystick_avb[] =
22 { BTN_TRIGGER, BTN_THUMB, BTN_TOP, BTN_TOP2, BTN_BASE,
23 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_DEAD, -1 };
24
25 static signed short btn_wheel[] =
26 { BTN_GEAR_DOWN, BTN_GEAR_UP, BTN_BASE, BTN_BASE2, BTN_BASE3,
27 BTN_BASE4, BTN_BASE5, BTN_BASE6, -1 };
28
29 static signed short abs_joystick[] =
30 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
31
32 static signed short abs_joystick_rudder[] =
33 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y, -1 };
34
35 static signed short abs_avb_pegasus[] =
36 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
37 ABS_HAT1X, ABS_HAT1Y, -1 };
38
39 static signed short abs_wheel[] =
40 { ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };
41
42 static signed short ff_iforce[] =
43 { FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_DAMPER,
44 FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN,
45 FF_AUTOCENTER, -1 };
46
47 static struct iforce_device iforce_device[] = {
48 { 0x044f, 0xa01c, "Thrustmaster Motor Sport GT", btn_wheel, abs_wheel, ff_iforce },
49 { 0x046d, 0xc281, "Logitech WingMan Force", btn_joystick, abs_joystick, ff_iforce },
50 { 0x046d, 0xc291, "Logitech WingMan Formula Force", btn_wheel, abs_wheel, ff_iforce },
51 { 0x05ef, 0x020a, "AVB Top Shot Pegasus", btn_joystick_avb, abs_avb_pegasus, ff_iforce },
52 { 0x05ef, 0x8884, "AVB Mag Turbo Force", btn_wheel, abs_wheel, ff_iforce },
53 { 0x05ef, 0x8888, "AVB Top Shot Force Feedback Racing Wheel", btn_wheel, abs_wheel, ff_iforce },
54 { 0x061c, 0xc0a4, "ACT LABS Force RS", btn_wheel, abs_wheel, ff_iforce },
55 { 0x061c, 0xc084, "ACT LABS Force RS", btn_wheel, abs_wheel, ff_iforce },
56 { 0x06a3, 0xff04, "Saitek R440 Force Wheel", btn_wheel, abs_wheel, ff_iforce },
57 { 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback", btn_wheel, abs_wheel, ff_iforce },
58 { 0x06f8, 0x0001, "Guillemot Jet Leader Force Feedback", btn_joystick, abs_joystick_rudder, ff_iforce },
59 { 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel", btn_wheel, abs_wheel, ff_iforce },
60 { 0x06f8, 0xa302, "Guillemot Jet Leader 3D", btn_joystick, abs_joystick, ff_iforce },
61 { 0x06d6, 0x29bc, "Trust Force Feedback Race Master", btn_wheel, abs_wheel, ff_iforce },
62 { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]", btn_joystick, abs_joystick, ff_iforce }
63 };
64
65 static int iforce_playback(struct input_dev *dev, int effect_id, int value)
66 {
67 struct iforce *iforce = input_get_drvdata(dev);
68 struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
69
70 if (value > 0)
71 set_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
72 else
73 clear_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
74
75 iforce_control_playback(iforce, effect_id, value);
76 return 0;
77 }
78
79 static void iforce_set_gain(struct input_dev *dev, u16 gain)
80 {
81 struct iforce *iforce = input_get_drvdata(dev);
82 unsigned char data[3];
83
84 data[0] = gain >> 9;
85 iforce_send_packet(iforce, FF_CMD_GAIN, data);
86 }
87
88 static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
89 {
90 struct iforce *iforce = input_get_drvdata(dev);
91 unsigned char data[3];
92
93 data[0] = 0x03;
94 data[1] = magnitude >> 9;
95 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
96
97 data[0] = 0x04;
98 data[1] = 0x01;
99 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
100 }
101
102
103
104
105
106 static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
107 {
108 struct iforce *iforce = input_get_drvdata(dev);
109 struct iforce_core_effect *core_effect = &iforce->core_effects[effect->id];
110 int ret;
111
112 if (__test_and_set_bit(FF_CORE_IS_USED, core_effect->flags)) {
113
114 if (test_bit(FF_CORE_UPDATE, core_effect->flags))
115 return -EAGAIN;
116 }
117
118
119
120
121 switch (effect->type) {
122 case FF_PERIODIC:
123 ret = iforce_upload_periodic(iforce, effect, old);
124 break;
125
126 case FF_CONSTANT:
127 ret = iforce_upload_constant(iforce, effect, old);
128 break;
129
130 case FF_SPRING:
131 case FF_DAMPER:
132 ret = iforce_upload_condition(iforce, effect, old);
133 break;
134
135 default:
136 return -EINVAL;
137 }
138
139 if (ret == 0) {
140
141
142
143 set_bit(FF_CORE_UPDATE, core_effect->flags);
144 }
145 return ret;
146 }
147
148
149
150
151
152 static int iforce_erase_effect(struct input_dev *dev, int effect_id)
153 {
154 struct iforce *iforce = input_get_drvdata(dev);
155 struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
156 int err = 0;
157
158 if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
159 err = release_resource(&core_effect->mod1_chunk);
160
161 if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
162 err = release_resource(&core_effect->mod2_chunk);
163
164
165 core_effect->flags[0] = 0;
166
167 return err;
168 }
169
170 static int iforce_open(struct input_dev *dev)
171 {
172 struct iforce *iforce = input_get_drvdata(dev);
173
174 iforce->xport_ops->start_io(iforce);
175
176 if (test_bit(EV_FF, dev->evbit)) {
177
178 iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
179 }
180
181 return 0;
182 }
183
184 static void iforce_close(struct input_dev *dev)
185 {
186 struct iforce *iforce = input_get_drvdata(dev);
187 int i;
188
189 if (test_bit(EV_FF, dev->evbit)) {
190
191 for (i = 0; i < dev->ff->max_effects; i++) {
192 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags)) {
193 dev_warn(&dev->dev,
194 "%s: Device still owns effects\n",
195 __func__);
196 break;
197 }
198 }
199
200
201 iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
202
203 wait_event_interruptible(iforce->wait,
204 !test_bit(IFORCE_XMIT_RUNNING, iforce->xmit_flags));
205 }
206
207 iforce->xport_ops->stop_io(iforce);
208 }
209
210 int iforce_init_device(struct device *parent, u16 bustype,
211 struct iforce *iforce)
212 {
213 struct input_dev *input_dev;
214 struct ff_device *ff;
215 u8 c[] = "CEOV";
216 u8 buf[IFORCE_MAX_LENGTH];
217 size_t len;
218 int i, error;
219 int ff_effects = 0;
220
221 input_dev = input_allocate_device();
222 if (!input_dev)
223 return -ENOMEM;
224
225 init_waitqueue_head(&iforce->wait);
226 spin_lock_init(&iforce->xmit_lock);
227 mutex_init(&iforce->mem_mutex);
228 iforce->xmit.buf = iforce->xmit_data;
229 iforce->dev = input_dev;
230
231
232
233
234
235 input_dev->id.bustype = bustype;
236 input_dev->dev.parent = parent;
237
238 input_set_drvdata(input_dev, iforce);
239
240 input_dev->name = "Unknown I-Force device";
241 input_dev->open = iforce_open;
242 input_dev->close = iforce_close;
243
244
245
246
247
248 iforce->device_memory.name = "I-Force device effect memory";
249 iforce->device_memory.start = 0;
250 iforce->device_memory.end = 200;
251 iforce->device_memory.flags = IORESOURCE_MEM;
252 iforce->device_memory.parent = NULL;
253 iforce->device_memory.child = NULL;
254 iforce->device_memory.sibling = NULL;
255
256
257
258
259
260 for (i = 0; i < 20; i++)
261 if (!iforce_get_id_packet(iforce, 'O', buf, &len))
262 break;
263
264 if (i == 20) {
265 dev_err(&input_dev->dev,
266 "Timeout waiting for response from device.\n");
267 error = -ENODEV;
268 goto fail;
269 }
270
271
272
273
274
275 if (!iforce_get_id_packet(iforce, 'M', buf, &len) || len < 3)
276 input_dev->id.vendor = get_unaligned_le16(buf + 1);
277 else
278 dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n");
279
280 if (!iforce_get_id_packet(iforce, 'P', buf, &len) || len < 3)
281 input_dev->id.product = get_unaligned_le16(buf + 1);
282 else
283 dev_warn(&iforce->dev->dev, "Device does not respond to id packet P\n");
284
285 if (!iforce_get_id_packet(iforce, 'B', buf, &len) || len < 3)
286 iforce->device_memory.end = get_unaligned_le16(buf + 1);
287 else
288 dev_warn(&iforce->dev->dev, "Device does not respond to id packet B\n");
289
290 if (!iforce_get_id_packet(iforce, 'N', buf, &len) || len < 2)
291 ff_effects = buf[1];
292 else
293 dev_warn(&iforce->dev->dev, "Device does not respond to id packet N\n");
294
295
296 if (ff_effects > IFORCE_EFFECTS_MAX) {
297 dev_warn(&iforce->dev->dev, "Limiting number of effects to %d (device reports %d)\n",
298 IFORCE_EFFECTS_MAX, ff_effects);
299 ff_effects = IFORCE_EFFECTS_MAX;
300 }
301
302
303
304
305
306 for (i = 0; c[i]; i++)
307 if (!iforce_get_id_packet(iforce, c[i], buf, &len))
308 iforce_dump_packet(iforce, "info",
309 (FF_CMD_QUERY & 0xff00) | len, buf);
310
311
312
313
314 iforce_set_autocenter(input_dev, 0);
315
316
317
318
319
320 for (i = 0; iforce_device[i].idvendor; i++)
321 if (iforce_device[i].idvendor == input_dev->id.vendor &&
322 iforce_device[i].idproduct == input_dev->id.product)
323 break;
324
325 iforce->type = iforce_device + i;
326 input_dev->name = iforce->type->name;
327
328
329
330
331
332 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
333 BIT_MASK(EV_FF_STATUS);
334
335 for (i = 0; iforce->type->btn[i] >= 0; i++)
336 set_bit(iforce->type->btn[i], input_dev->keybit);
337
338 for (i = 0; iforce->type->abs[i] >= 0; i++) {
339
340 signed short t = iforce->type->abs[i];
341
342 switch (t) {
343 case ABS_X:
344 case ABS_Y:
345 case ABS_WHEEL:
346 input_set_abs_params(input_dev, t, -1920, 1920, 16, 128);
347 set_bit(t, input_dev->ffbit);
348 break;
349
350 case ABS_THROTTLE:
351 case ABS_GAS:
352 case ABS_BRAKE:
353 input_set_abs_params(input_dev, t, 0, 255, 0, 0);
354 break;
355
356 case ABS_RUDDER:
357 input_set_abs_params(input_dev, t, -128, 127, 0, 0);
358 break;
359
360 case ABS_HAT0X:
361 case ABS_HAT0Y:
362 case ABS_HAT1X:
363 case ABS_HAT1Y:
364 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
365 break;
366 }
367 }
368
369 if (ff_effects) {
370
371 for (i = 0; iforce->type->ff[i] >= 0; i++)
372 set_bit(iforce->type->ff[i], input_dev->ffbit);
373
374 error = input_ff_create(input_dev, ff_effects);
375 if (error)
376 goto fail;
377
378 ff = input_dev->ff;
379 ff->upload = iforce_upload_effect;
380 ff->erase = iforce_erase_effect;
381 ff->set_gain = iforce_set_gain;
382 ff->set_autocenter = iforce_set_autocenter;
383 ff->playback = iforce_playback;
384 }
385
386
387
388
389 error = input_register_device(iforce->dev);
390 if (error)
391 goto fail;
392
393 return 0;
394
395 fail: input_free_device(input_dev);
396 return error;
397 }
398 EXPORT_SYMBOL(iforce_init_device);