1 /*
2 * $Id: iforce-main.c,v 1.19 2002/07/07 10:22:50 jdeneux Exp $
3 *
4 * Copyright (c) 2000-2002 Vojtech Pavlik <vojtech@ucw.cz>
5 * Copyright (c) 2001-2002 Johann Deneux <deneux@ifrance.com>
6 *
7 * USB/RS232 I-Force joysticks and wheels.
8 */
9
10 /*
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 *
25 * Should you need to contact me, the author, you can do so either by
26 * e-mail - mail your message to <vojtech@ucw.cz>, or by paper mail:
27 * Vojtech Pavlik, Simunkova 1594, Prague 8, 182 00 Czech Republic
28 */
29
30 #include "iforce.h"
31
32 MODULE_AUTHOR("Vojtech Pavlik <vojtech@ucw.cz>, Johann Deneux <deneux@ifrance.com>");
33 MODULE_DESCRIPTION("USB/RS232 I-Force joysticks and wheels driver");
34 MODULE_LICENSE("GPL");
35
36 static signed short btn_joystick[] =
37 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
38 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
39
40 static signed short btn_avb_pegasus[] =
41 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
42 BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
43
44 static signed short btn_wheel[] =
45 { BTN_TRIGGER, BTN_TOP, BTN_THUMB, BTN_TOP2, BTN_BASE,
46 BTN_BASE2, BTN_BASE3, BTN_BASE4, BTN_BASE5, BTN_A, BTN_B, BTN_C, -1 };
47
48 static signed short btn_avb_tw[] =
49 { BTN_TRIGGER, BTN_THUMB, BTN_TOP, BTN_TOP2, BTN_BASE,
50 BTN_BASE2, BTN_BASE3, BTN_BASE4, -1 };
51
52 static signed short btn_avb_wheel[] =
53 { BTN_GEAR_DOWN, BTN_GEAR_UP, BTN_BASE, BTN_BASE2, BTN_BASE3,
54 BTN_BASE4, BTN_BASE5, BTN_BASE6, -1 };
55
56 static signed short abs_joystick[] =
57 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_HAT0X, ABS_HAT0Y, -1 };
58
59 static signed short abs_avb_pegasus[] =
60 { ABS_X, ABS_Y, ABS_THROTTLE, ABS_RUDDER, ABS_HAT0X, ABS_HAT0Y,
61 ABS_HAT1X, ABS_HAT1Y, -1 };
62
63 static signed short abs_wheel[] =
64 { ABS_WHEEL, ABS_GAS, ABS_BRAKE, ABS_HAT0X, ABS_HAT0Y, -1 };
65
66 static signed short ff_iforce[] =
67 { FF_PERIODIC, FF_CONSTANT, FF_SPRING, FF_DAMPER,
68 FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, FF_SAW_DOWN, FF_GAIN,
69 FF_AUTOCENTER, -1 };
70
71 static struct iforce_device iforce_device[] = {
72 { 0x044f, 0xa01c, "Thrustmaster Motor Sport GT", btn_wheel, abs_wheel, ff_iforce },
73 { 0x046d, 0xc281, "Logitech WingMan Force", btn_joystick, abs_joystick, ff_iforce },
74 { 0x046d, 0xc291, "Logitech WingMan Formula Force", btn_wheel, abs_wheel, ff_iforce },
75 { 0x05ef, 0x020a, "AVB Top Shot Pegasus", btn_avb_pegasus, abs_avb_pegasus, ff_iforce },
76 { 0x05ef, 0x8884, "AVB Mag Turbo Force", btn_avb_wheel, abs_wheel, ff_iforce },
77 { 0x05ef, 0x8888, "AVB Top Shot Force Feedback Racing Wheel", btn_avb_tw, abs_wheel, ff_iforce }, //?
78 { 0x061c, 0xc0a4, "ACT LABS Force RS", btn_wheel, abs_wheel, ff_iforce }, //?
79 { 0x06f8, 0x0001, "Guillemot Race Leader Force Feedback", btn_wheel, abs_wheel, ff_iforce }, //?
80 { 0x06f8, 0x0004, "Guillemot Force Feedback Racing Wheel", btn_wheel, abs_wheel, ff_iforce }, //?
81 { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]", btn_joystick, abs_joystick, ff_iforce }
82 };
83
84
85
86 static int iforce_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
87 {
88 struct iforce* iforce = (struct iforce*)(dev->private);
89 unsigned char data[3];
90
91 if (type != EV_FF)
92 return -1;
93
94 switch (code) {
95
96 case FF_GAIN:
97
98 data[0] = value >> 9;
99 iforce_send_packet(iforce, FF_CMD_GAIN, data);
100
101 return 0;
102
103 case FF_AUTOCENTER:
104
105 data[0] = 0x03;
106 data[1] = value >> 9;
107 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
108
109 data[0] = 0x04;
110 data[1] = 0x01;
111 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
112
113 return 0;
114
115 default: /* Play or stop an effect */
116
117 if (!CHECK_OWNERSHIP(code, iforce)) {
118 return -1;
119 }
120 if (value > 0) {
121 set_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[code].flags);
122 }
123 else {
124 clear_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[code].flags);
125 }
126
127 iforce_control_playback(iforce, code, value);
128 return 0;
129 }
130
131 return -1;
132 }
133
134 /*
135 * Function called when an ioctl is performed on the event dev entry.
136 * It uploads an effect to the device
137 */
138 static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect)
139 {
140 struct iforce* iforce = (struct iforce*)(dev->private);
141 int id;
142 int ret;
143 int is_update;
144
145 /* Check this effect type is supported by this device */
146 if (!test_bit(effect->type, iforce->dev.ffbit))
147 return -EINVAL;
148
149 /*
150 * If we want to create a new effect, get a free id
151 */
152 if (effect->id == -1) {
153
154 for (id=0; id < FF_EFFECTS_MAX; ++id)
155 if (!test_and_set_bit(FF_CORE_IS_USED, iforce->core_effects[id].flags)) break;
156
157 if ( id == FF_EFFECTS_MAX || id >= iforce->dev.ff_effects_max)
158 return -ENOMEM;
159
160 effect->id = id;
161 iforce->core_effects[id].owner = current->pid;
162 iforce->core_effects[id].flags[0] = (1<<FF_CORE_IS_USED); /* Only IS_USED bit must be set */
163
164 is_update = FALSE;
165 }
166 else {
167 /* We want to update an effect */
168 if (!CHECK_OWNERSHIP(effect->id, iforce)) return -EACCES;
169
170 /* Parameter type cannot be updated */
171 if (effect->type != iforce->core_effects[effect->id].effect.type)
172 return -EINVAL;
173
174 /* Check the effect is not already being updated */
175 if (test_bit(FF_CORE_UPDATE, iforce->core_effects[effect->id].flags)) {
176 return -EAGAIN;
177 }
178
179 is_update = TRUE;
180 }
181
182 /*
183 * Upload the effect
184 */
185 switch (effect->type) {
186
187 case FF_PERIODIC:
188 ret = iforce_upload_periodic(iforce, effect, is_update);
189 break;
190
191 case FF_CONSTANT:
192 ret = iforce_upload_constant(iforce, effect, is_update);
193 break;
194
195 case FF_SPRING:
196 case FF_DAMPER:
197 ret = iforce_upload_condition(iforce, effect, is_update);
198 break;
199
200 default:
201 return -EINVAL;
202 }
203 if (ret == 0) {
204 /* A packet was sent, forbid new updates until we are notified
205 * that the packet was updated
206 */
207 set_bit(FF_CORE_UPDATE, iforce->core_effects[effect->id].flags);
208 }
209 iforce->core_effects[effect->id].effect = *effect;
210 return ret;
211 }
212
213 /*
214 * Erases an effect: it frees the effect id and mark as unused the memory
215 * allocated for the parameters
216 */
217 static int iforce_erase_effect(struct input_dev *dev, int effect_id)
218 {
219 struct iforce* iforce = (struct iforce*)(dev->private);
220 int err = 0;
221 struct iforce_core_effect* core_effect;
222
223 /* Check who is trying to erase this effect */
224 if (iforce->core_effects[effect_id].owner != current->pid) {
225 printk(KERN_WARNING "iforce-main.c: %d tried to erase an effect belonging to %d\n", current->pid, iforce->core_effects[effect_id].owner);
226 return -EACCES;
227 }
228
229 if (effect_id < 0 || effect_id >= FF_EFFECTS_MAX)
230 return -EINVAL;
231
232 core_effect = iforce->core_effects + effect_id;
233
234 if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
235 err = release_resource(&(iforce->core_effects[effect_id].mod1_chunk));
236
237 if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
238 err = release_resource(&(iforce->core_effects[effect_id].mod2_chunk));
239
240 /*TODO: remember to change that if more FF_MOD* bits are added */
241 core_effect->flags[0] = 0;
242
243 return err;
244 }
245
246 static int iforce_open(struct input_dev *dev)
247 {
248 struct iforce *iforce = dev->private;
249
250 switch (iforce->bus) {
251 #ifdef CONFIG_JOYSTICK_IFORCE_USB
252 case IFORCE_USB:
253 iforce->irq->dev = iforce->usbdev;
254 if (usb_submit_urb(iforce->irq, GFP_KERNEL))
255 return -EIO;
256 break;
257 #endif
258 }
259
260 /* Enable force feedback */
261 iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
262
263 return 0;
264 }
265
266 static int iforce_flush(struct input_dev *dev, struct file *file)
267 {
268 struct iforce *iforce = dev->private;
269 int i;
270
271 /* Erase all effects this process owns */
272 for (i=0; i<dev->ff_effects_max; ++i) {
273
274 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags) &&
275 current->pid == iforce->core_effects[i].owner) {
276
277 /* Stop effect */
278 input_report_ff(dev, i, 0);
279
280 /* Free ressources assigned to effect */
281 if (iforce_erase_effect(dev, i)) {
282 printk(KERN_WARNING "iforce_flush: erase effect %d failed\n", i);
283 }
284 }
285
286 }
287 return 0;
288 }
289
290 static void iforce_release(struct input_dev *dev)
291 {
292 struct iforce *iforce = dev->private;
293 int i;
294
295 /* Check: no effect should be present in memory */
296 for (i=0; i<dev->ff_effects_max; ++i) {
297 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags))
298 break;
299 }
300 if (i<dev->ff_effects_max) {
301 printk(KERN_WARNING "iforce_release: Device still owns effects\n");
302 }
303
304 /* Disable force feedback playback */
305 iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
306
307 switch (iforce->bus) {
308 #ifdef CONFIG_JOYSTICK_IFORCE_USB
309 case IFORCE_USB:
310 usb_unlink_urb(iforce->irq);
311
312 /* The device was unplugged before the file
313 * was released */
314 if (iforce->usbdev == NULL) {
315 iforce_delete_device(iforce);
316 kfree(iforce);
317 }
318 break;
319 #endif
320 }
321 }
322
323 void iforce_delete_device(struct iforce *iforce)
324 {
325 switch (iforce->bus) {
326 #ifdef CONFIG_JOYSTICK_IFORCE_USB
327 case IFORCE_USB:
328 iforce_usb_delete(iforce);
329 break;
330 #endif
331 #ifdef CONFIG_JOYSTICK_IFORCE_232
332 case IFORCE_232:
333 //TODO: Wait for the last packets to be sent
334 break;
335 #endif
336 }
337 }
338
339 int iforce_init_device(struct iforce *iforce)
340 {
341 unsigned char c[] = "CEOV";
342 int i;
343
344 init_waitqueue_head(&iforce->wait);
345 spin_lock_init(&iforce->xmit_lock);
346 init_MUTEX(&iforce->mem_mutex);
347 iforce->xmit.buf = iforce->xmit_data;
348
349 iforce->dev.ff_effects_max = 10;
350
351 /*
352 * Input device fields.
353 */
354
355 switch (iforce->bus) {
356 #ifdef CONFIG_JOYSTICK_IFORCE_USB
357 case IFORCE_USB:
358 iforce->dev.id.bustype = BUS_USB;
359 iforce->dev.dev = &iforce->usbdev->dev;
360 break;
361 #endif
362 #ifdef CONFIG_JOYSTICK_IFORCE_232
363 case IFORCE_232:
364 iforce->dev.id.bustype = BUS_RS232;
365 iforce->dev.dev = &iforce->serio->dev;
366 break;
367 #endif
368 }
369
370 iforce->dev.private = iforce;
371 iforce->dev.name = "Unknown I-Force device";
372 iforce->dev.open = iforce_open;
373 iforce->dev.close = iforce_release;
374 iforce->dev.flush = iforce_flush;
375 iforce->dev.event = iforce_input_event;
376 iforce->dev.upload_effect = iforce_upload_effect;
377 iforce->dev.erase_effect = iforce_erase_effect;
378
379 /*
380 * On-device memory allocation.
381 */
382
383 iforce->device_memory.name = "I-Force device effect memory";
384 iforce->device_memory.start = 0;
385 iforce->device_memory.end = 200;
386 iforce->device_memory.flags = IORESOURCE_MEM;
387 iforce->device_memory.parent = NULL;
388 iforce->device_memory.child = NULL;
389 iforce->device_memory.sibling = NULL;
390
391 /*
392 * Wait until device ready - until it sends its first response.
393 */
394
395 for (i = 0; i < 20; i++)
396 if (!iforce_get_id_packet(iforce, "O"))
397 break;
398
399 if (i == 20) { /* 5 seconds */
400 printk(KERN_ERR "iforce-main.c: Timeout waiting for response from device.\n");
401 return -1;
402 }
403
404 /*
405 * Get device info.
406 */
407
408 if (!iforce_get_id_packet(iforce, "M"))
409 iforce->dev.id.vendor = (iforce->edata[2] << 8) | iforce->edata[1];
410 else
411 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet M\n");
412
413 if (!iforce_get_id_packet(iforce, "P"))
414 iforce->dev.id.product = (iforce->edata[2] << 8) | iforce->edata[1];
415 else
416 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet P\n");
417
418 if (!iforce_get_id_packet(iforce, "B"))
419 iforce->device_memory.end = (iforce->edata[2] << 8) | iforce->edata[1];
420 else
421 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet B\n");
422
423 if (!iforce_get_id_packet(iforce, "N"))
424 iforce->dev.ff_effects_max = iforce->edata[1];
425 else
426 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet N\n");
427
428 /* Check if the device can store more effects than the driver can really handle */
429 if (iforce->dev.ff_effects_max > FF_EFFECTS_MAX) {
430 printk(KERN_WARNING "input??: Device can handle %d effects, but N_EFFECTS_MAX is set to %d in iforce.h\n",
431 iforce->dev.ff_effects_max, FF_EFFECTS_MAX);
432 iforce->dev.ff_effects_max = FF_EFFECTS_MAX;
433 }
434
435 /*
436 * Display additional info.
437 */
438
439 for (i = 0; c[i]; i++)
440 if (!iforce_get_id_packet(iforce, c + i))
441 iforce_dump_packet("info", iforce->ecmd, iforce->edata);
442
443 /*
444 * Disable spring, enable force feedback.
445 * FIXME: We should use iforce_set_autocenter() et al here.
446 */
447
448 iforce_send_packet(iforce, FF_CMD_AUTOCENTER, "\004\000");
449
450 /*
451 * Find appropriate device entry
452 */
453
454 for (i = 0; iforce_device[i].idvendor; i++)
455 if (iforce_device[i].idvendor == iforce->dev.id.vendor &&
456 iforce_device[i].idproduct == iforce->dev.id.product)
457 break;
458
459 iforce->type = iforce_device + i;
460 iforce->dev.name = iforce->type->name;
461
462 /*
463 * Set input device bitfields and ranges.
464 */
465
466 iforce->dev.evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_FF) | BIT(EV_FF_STATUS);
467
468 for (i = 0; iforce->type->btn[i] >= 0; i++) {
469 signed short t = iforce->type->btn[i];
470 set_bit(t, iforce->dev.keybit);
471 }
472 set_bit(BTN_DEAD, iforce->dev.keybit);
473
474 for (i = 0; iforce->type->abs[i] >= 0; i++) {
475
476 signed short t = iforce->type->abs[i];
477 set_bit(t, iforce->dev.absbit);
478
479 switch (t) {
480
481 case ABS_X:
482 case ABS_Y:
483 case ABS_WHEEL:
484
485 iforce->dev.absmax[t] = 1920;
486 iforce->dev.absmin[t] = -1920;
487 iforce->dev.absflat[t] = 128;
488 iforce->dev.absfuzz[t] = 16;
489
490 set_bit(t, iforce->dev.ffbit);
491 break;
492
493 case ABS_THROTTLE:
494 case ABS_GAS:
495 case ABS_BRAKE:
496
497 iforce->dev.absmax[t] = 255;
498 iforce->dev.absmin[t] = 0;
499 break;
500
501 case ABS_RUDDER:
502
503 iforce->dev.absmax[t] = 127;
504 iforce->dev.absmin[t] = -128;
505 break;
506
507 case ABS_HAT0X:
508 case ABS_HAT0Y:
509 case ABS_HAT1X:
510 case ABS_HAT1Y:
511 iforce->dev.absmax[t] = 1;
512 iforce->dev.absmin[t] = -1;
513 break;
514 }
515 }
516
517 for (i = 0; iforce->type->ff[i] >= 0; i++)
518 set_bit(iforce->type->ff[i], iforce->dev.ffbit);
519
520 /*
521 * Register input device.
522 */
523
524 input_register_device(&iforce->dev);
525
526 printk(KERN_DEBUG "iforce->dev.open = %p\n", iforce->dev.open);
527
528 printk(KERN_INFO "input: %s [%d effects, %ld bytes memory]\n",
529 iforce->dev.name, iforce->dev.ff_effects_max,
530 iforce->device_memory.end);
531
532 return 0;
533 }
534
535 static int __init iforce_init(void)
536 {
537 #ifdef CONFIG_JOYSTICK_IFORCE_USB
538 usb_register(&iforce_usb_driver);
539 #endif
540 #ifdef CONFIG_JOYSTICK_IFORCE_232
541 serio_register_driver(&iforce_serio_drv);
542 #endif
543 return 0;
544 }
545
546 static void __exit iforce_exit(void)
547 {
548 #ifdef CONFIG_JOYSTICK_IFORCE_USB
549 usb_deregister(&iforce_usb_driver);
550 #endif
551 #ifdef CONFIG_JOYSTICK_IFORCE_232
552 serio_unregister_driver(&iforce_serio_drv);
553 #endif
554 }
555
556 module_init(iforce_init);
557 module_exit(iforce_exit);
558
|
This page was automatically generated by the
LXR engine.
|