1 /*
2 * Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
3 * Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
4 *
5 * USB/RS232 I-Force joysticks and wheels.
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 either by
24 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
25 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
26 */
27
28 #include "iforce.h"
29
30 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>, Johann Deneux <johann.deneux@gmail.com>");
31 MODULE_DESCRIPTION("USB/RS232 I-Force joysticks and wheels driver");
32 MODULE_LICENSE("GPL");
33
34 static signed short btn_joystick[] =
35 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
36 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
37
38 static signed short btn_avb_pegasus[] =
39 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
40 BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
41
42 static signed short btn_wheel[] =
43 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
44 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
45
46 static signed short btn_avb_tw[] =
47 { BTN_TRIGGER, BTN_THUMB, BTN_TOP, BTN_TOP2, BTN_BASE,
48 BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
49
50 static signed short btn_avb_wheel[] =
51 { BTN_GEAR_DOWN, BTN_GEAR_UP, BTN_BASE, BTN_BASE2, BTN_BASE3,
52 BTN_BASE4, BTN_BASE5, BTN_BASE6, -1 };
53
54 static signed short abs_joystick[] =
55 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
56
57 static signed short abs_avb_pegasus[] =
58 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
59 ABS_HAT1X, ABS_HAT1Y, -1 };
60
61 static signed short abs_wheel[] =
62 { ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };
63
64 static signed short ff_iforce[] =
65 { FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_DAMPER,
66 FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN,
67 FF_AUTOCENTER, -1 };
68
69 static struct iforce_device iforce_device[] = {
70 { 0x044f, 0xa01c, "Thrustmaster Motor Sport GT", btn_wheel, abs_wheel, ff_iforce },
71 { 0x046d, 0xc281, "Logitech WingMan Force", btn_joystick, abs_joystick, ff_iforce },
72 { 0x046d, 0xc291, "Logitech WingMan Formula Force", btn_wheel, abs_wheel, ff_iforce },
73 { 0x05ef, 0x020a, "AVB Top Shot Pegasus", btn_avb_pegasus, abs_avb_pegasus, ff_iforce },
74 { 0x05ef, 0x8884, "AVB Mag Turbo Force", btn_avb_wheel, abs_wheel, ff_iforce },
75 { 0x05ef, 0x8888, "AVB Top Shot Force Feedback Racing Wheel", btn_avb_tw, abs_wheel, ff_iforce }, //?
76 { 0x061c, 0xc0a4, "ACT LABS Force RS", btn_wheel, abs_wheel, ff_iforce }, //?
77 { 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback", btn_wheel, abs_wheel, ff_iforce }, //?
78 { 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel", btn_wheel, abs_wheel, ff_iforce }, //?
79 { 0x06f8, 0x0004, "Gullemot Jet Leader 3D", btn_joystick, abs_joystick, ff_iforce }, //?
80 { 0x06d6, 0x29bc, "Trust Force Feedback Race Master", btn_wheel, abs_wheel, ff_iforce },
81 { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]", btn_joystick, abs_joystick, ff_iforce }
82 };
83
iforce_playback(struct input_dev * dev,int effect_id,int value)84 static int iforce_playback(struct input_dev *dev, int effect_id, int value)
85 {
86 struct iforce *iforce = input_get_drvdata(dev);
87 struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
88
89 if (value > 0)
90 set_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
91 else
92 clear_bit(FF_CORE_SHOULD_PLAY, core_effect->flags);
93
94 iforce_control_playback(iforce, effect_id, value);
95 return 0;
96 }
97
iforce_set_gain(struct input_dev * dev,u16 gain)98 static void iforce_set_gain(struct input_dev *dev, u16 gain)
99 {
100 struct iforce *iforce = input_get_drvdata(dev);
101 unsigned char data[3];
102
103 data[0] = gain >> 9;
104 iforce_send_packet(iforce, FF_CMD_GAIN, data);
105 }
106
iforce_set_autocenter(struct input_dev * dev,u16 magnitude)107 static void iforce_set_autocenter(struct input_dev *dev, u16 magnitude)
108 {
109 struct iforce *iforce = input_get_drvdata(dev);
110 unsigned char data[3];
111
112 data[0] = 0x03;
113 data[1] = magnitude >> 9;
114 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
115
116 data[0] = 0x04;
117 data[1] = 0x01;
118 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
119 }
120
121 /*
122 * Function called when an ioctl is performed on the event dev entry.
123 * It uploads an effect to the device
124 */
iforce_upload_effect(struct input_dev * dev,struct ff_effect * effect,struct ff_effect * old)125 static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect, struct ff_effect *old)
126 {
127 struct iforce *iforce = input_get_drvdata(dev);
128 struct iforce_core_effect *core_effect = &iforce->core_effects[effect->id];
129 int ret;
130
131 if (__test_and_set_bit(FF_CORE_IS_USED, core_effect->flags)) {
132 /* Check the effect is not already being updated */
133 if (test_bit(FF_CORE_UPDATE, core_effect->flags))
134 return -EAGAIN;
135 }
136
137 /*
138 * Upload the effect
139 */
140 switch (effect->type) {
141
142 case FF_PERIODIC:
143 ret = iforce_upload_periodic(iforce, effect, old);
144 break;
145
146 case FF_CONSTANT:
147 ret = iforce_upload_constant(iforce, effect, old);
148 break;
149
150 case FF_SPRING:
151 case FF_DAMPER:
152 ret = iforce_upload_condition(iforce, effect, old);
153 break;
154
155 default:
156 return -EINVAL;
157 }
158
159 if (ret == 0) {
160 /* A packet was sent, forbid new updates until we are notified
161 * that the packet was updated
162 */
163 set_bit(FF_CORE_UPDATE, core_effect->flags);
164 }
165 return ret;
166 }
167
168 /*
169 * Erases an effect: it frees the effect id and mark as unused the memory
170 * allocated for the parameters
171 */
iforce_erase_effect(struct input_dev * dev,int effect_id)172 static int iforce_erase_effect(struct input_dev *dev, int effect_id)
173 {
174 struct iforce *iforce = input_get_drvdata(dev);
175 struct iforce_core_effect *core_effect = &iforce->core_effects[effect_id];
176 int err = 0;
177
178 if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
179 err = release_resource(&core_effect->mod1_chunk);
180
181 if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
182 err = release_resource(&core_effect->mod2_chunk);
183
184 /* TODO: remember to change that if more FF_MOD* bits are added */
185 core_effect->flags[0] = 0;
186
187 return err;
188 }
189
iforce_open(struct input_dev * dev)190 static int iforce_open(struct input_dev *dev)
191 {
192 struct iforce *iforce = input_get_drvdata(dev);
193
194 switch (iforce->bus) {
195 #ifdef CONFIG_JOYSTICK_IFORCE_USB
196 case IFORCE_USB:
197 iforce->irq->dev = iforce->usbdev;
198 if (usb_submit_urb(iforce->irq, GFP_KERNEL))
199 return -EIO;
200 break;
201 #endif
202 }
203
204 if (test_bit(EV_FF, dev->evbit)) {
205 /* Enable force feedback */
206 iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
207 }
208
209 return 0;
210 }
211
iforce_release(struct input_dev * dev)212 static void iforce_release(struct input_dev *dev)
213 {
214 struct iforce *iforce = input_get_drvdata(dev);
215 int i;
216
217 if (test_bit(EV_FF, dev->evbit)) {
218 /* Check: no effects should be present in memory */
219 for (i = 0; i < dev->ff->max_effects; i++) {
220 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags)) {
221 dev_warn(&dev->dev,
222 "%s: Device still owns effects\n",
223 __func__);
224 break;
225 }
226 }
227
228 /* Disable force feedback playback */
229 iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
230 }
231
232 switch (iforce->bus) {
233 #ifdef CONFIG_JOYSTICK_IFORCE_USB
234 case IFORCE_USB:
235 usb_kill_urb(iforce->irq);
236
237 /* The device was unplugged before the file
238 * was released */
239 if (iforce->usbdev == NULL) {
240 iforce_delete_device(iforce);
241 kfree(iforce);
242 }
243 break;
244 #endif
245 }
246 }
247
iforce_delete_device(struct iforce * iforce)248 void iforce_delete_device(struct iforce *iforce)
249 {
250 switch (iforce->bus) {
251 #ifdef CONFIG_JOYSTICK_IFORCE_USB
252 case IFORCE_USB:
253 iforce_usb_delete(iforce);
254 break;
255 #endif
256 #ifdef CONFIG_JOYSTICK_IFORCE_232
257 case IFORCE_232:
258 //TODO: Wait for the last packets to be sent
259 break;
260 #endif
261 }
262 }
263
iforce_init_device(struct iforce * iforce)264 int iforce_init_device(struct iforce *iforce)
265 {
266 struct input_dev *input_dev;
267 struct ff_device *ff;
268 unsigned char c[] = "CEOV";
269 int i, error;
270 int ff_effects = 0;
271
272 input_dev = input_allocate_device();
273 if (!input_dev)
274 return -ENOMEM;
275
276 init_waitqueue_head(&iforce->wait);
277 spin_lock_init(&iforce->xmit_lock);
278 mutex_init(&iforce->mem_mutex);
279 iforce->xmit.buf = iforce->xmit_data;
280 iforce->dev = input_dev;
281
282 /*
283 * Input device fields.
284 */
285
286 switch (iforce->bus) {
287 #ifdef CONFIG_JOYSTICK_IFORCE_USB
288 case IFORCE_USB:
289 input_dev->id.bustype = BUS_USB;
290 input_dev->dev.parent = &iforce->usbdev->dev;
291 break;
292 #endif
293 #ifdef CONFIG_JOYSTICK_IFORCE_232
294 case IFORCE_232:
295 input_dev->id.bustype = BUS_RS232;
296 input_dev->dev.parent = &iforce->serio->dev;
297 break;
298 #endif
299 }
300
301 input_set_drvdata(input_dev, iforce);
302
303 input_dev->name = "Unknown I-Force device";
304 input_dev->open = iforce_open;
305 input_dev->close = iforce_release;
306
307 /*
308 * On-device memory allocation.
309 */
310
311 iforce->device_memory.name = "I-Force device effect memory";
312 iforce->device_memory.start = 0;
313 iforce->device_memory.end = 200;
314 iforce->device_memory.flags = IORESOURCE_MEM;
315 iforce->device_memory.parent = NULL;
316 iforce->device_memory.child = NULL;
317 iforce->device_memory.sibling = NULL;
318
319 /*
320 * Wait until device ready - until it sends its first response.
321 */
322
323 for (i = 0; i < 20; i++)
324 if (!iforce_get_id_packet(iforce, "O"))
325 break;
326
327 if (i == 20) { /* 5 seconds */
328 err("Timeout waiting for response from device.");
329 error = -ENODEV;
330 goto fail;
331 }
332
333 /*
334 * Get device info.
335 */
336
337 if (!iforce_get_id_packet(iforce, "M"))
338 input_dev->id.vendor = (iforce->edata[2] << 8) | iforce->edata[1];
339 else
340 dev_warn(&iforce->dev->dev, "Device does not respond to id packet M\n");
341
342 if (!iforce_get_id_packet(iforce, "P"))
343 input_dev->id.product = (iforce->edata[2] << 8) | iforce->edata[1];
344 else
345 dev_warn(&iforce->dev->dev, "Device does not respond to id packet P\n");
346
347 if (!iforce_get_id_packet(iforce, "B"))
348 iforce->device_memory.end = (iforce->edata[2] << 8) | iforce->edata[1];
349 else
350 dev_warn(&iforce->dev->dev, "Device does not respond to id packet B\n");
351
352 if (!iforce_get_id_packet(iforce, "N"))
353 ff_effects = iforce->edata[1];
354 else
355 dev_warn(&iforce->dev->dev, "Device does not respond to id packet N\n");
356
357 /* Check if the device can store more effects than the driver can really handle */
358 if (ff_effects > IFORCE_EFFECTS_MAX) {
359 dev_warn(&iforce->dev->dev, "Limiting number of effects to %d (device reports %d)\n",
360 IFORCE_EFFECTS_MAX, ff_effects);
361 ff_effects = IFORCE_EFFECTS_MAX;
362 }
363
364 /*
365 * Display additional info.
366 */
367
368 for (i = 0; c[i]; i++)
369 if (!iforce_get_id_packet(iforce, c + i))
370 iforce_dump_packet("info", iforce->ecmd, iforce->edata);
371
372 /*
373 * Disable spring, enable force feedback.
374 */
375 iforce_set_autocenter(input_dev, 0);
376
377 /*
378 * Find appropriate device entry
379 */
380
381 for (i = 0; iforce_device[i].idvendor; i++)
382 if (iforce_device[i].idvendor == input_dev->id.vendor &&
383 iforce_device[i].idproduct == input_dev->id.product)
384 break;
385
386 iforce->type = iforce_device + i;
387 input_dev->name = iforce->type->name;
388
389 /*
390 * Set input device bitfields and ranges.
391 */
392
393 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS) |
394 BIT_MASK(EV_FF_STATUS);
395
396 for (i = 0; iforce->type->btn[i] >= 0; i++)
397 set_bit(iforce->type->btn[i], input_dev->keybit);
398 set_bit(BTN_DEAD, input_dev->keybit);
399
400 for (i = 0; iforce->type->abs[i] >= 0; i++) {
401
402 signed short t = iforce->type->abs[i];
403
404 switch (t) {
405
406 case ABS_X:
407 case ABS_Y:
408 case ABS_WHEEL:
409
410 input_set_abs_params(input_dev, t, -1920, 1920, 16, 128);
411 set_bit(t, input_dev->ffbit);
412 break;
413
414 case ABS_THROTTLE:
415 case ABS_GAS:
416 case ABS_BRAKE:
417
418 input_set_abs_params(input_dev, t, 0, 255, 0, 0);
419 break;
420
421 case ABS_RUDDER:
422
423 input_set_abs_params(input_dev, t, -128, 127, 0, 0);
424 break;
425
426 case ABS_HAT0X:
427 case ABS_HAT0Y:
428 case ABS_HAT1X:
429 case ABS_HAT1Y:
430
431 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
432 break;
433 }
434 }
435
436 if (ff_effects) {
437
438 for (i = 0; iforce->type->ff[i] >= 0; i++)
439 set_bit(iforce->type->ff[i], input_dev->ffbit);
440
441 error = input_ff_create(input_dev, ff_effects);
442 if (error)
443 goto fail;
444
445 ff = input_dev->ff;
446 ff->upload = iforce_upload_effect;
447 ff->erase = iforce_erase_effect;
448 ff->set_gain = iforce_set_gain;
449 ff->set_autocenter = iforce_set_autocenter;
450 ff->playback = iforce_playback;
451 }
452 /*
453 * Register input device.
454 */
455
456 error = input_register_device(iforce->dev);
457 if (error)
458 goto fail;
459
460 return 0;
461
462 fail: input_free_device(input_dev);
463 return error;
464 }
465
iforce_init(void)466 static int __init iforce_init(void)
467 {
468 int err = 0;
469
470 #ifdef CONFIG_JOYSTICK_IFORCE_USB
471 err = usb_register(&iforce_usb_driver);
472 if (err)
473 return err;
474 #endif
475 #ifdef CONFIG_JOYSTICK_IFORCE_232
476 err = serio_register_driver(&iforce_serio_drv);
477 #ifdef CONFIG_JOYSTICK_IFORCE_USB
478 if (err)
479 usb_deregister(&iforce_usb_driver);
480 #endif
481 #endif
482 return err;
483 }
484
iforce_exit(void)485 static void __exit iforce_exit(void)
486 {
487 #ifdef CONFIG_JOYSTICK_IFORCE_USB
488 usb_deregister(&iforce_usb_driver);
489 #endif
490 #ifdef CONFIG_JOYSTICK_IFORCE_232
491 serio_unregister_driver(&iforce_serio_drv);
492 #endif
493 }
494
495 module_init(iforce_init);
496 module_exit(iforce_exit);
497