drivers/input/joystick/iforce/iforce-main.c

   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         { 0x06f8, 0x0004, "Gullemot Jet Leader 3D",                     btn_joystick, abs_joystick, ff_iforce }, //?
  82         { 0x06d6, 0x29bc, "Trust Force Feedback Race Master",           btn_wheel, abs_wheel, ff_iforce },
  83         { 0x0000, 0x0000, "Unknown I-Force Device [%04x:%04x]",         btn_joystick, abs_joystick, ff_iforce }
  84 };
  85
  86
  87
  88 static int iforce_input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value)
  89 {
  90         struct iforce* iforce = dev->private;
  91         unsigned char data[3];
  92
  93         if (type != EV_FF)
  94                 return -1;
  95
  96         switch (code) {
  97
  98                 case FF_GAIN:
  99
 100                         data[0] = value >> 9;
 101                         iforce_send_packet(iforce, FF_CMD_GAIN, data);
 102
 103                         return 0;
 104
 105                 case FF_AUTOCENTER:
 106
 107                         data[0] = 0x03;
 108                         data[1] = value >> 9;
 109                         iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
 110
 111                         data[0] = 0x04;
 112                         data[1] = 0x01;
 113                         iforce_send_packet(iforce, FF_CMD_AUTOCENTER, data);
 114
 115                         return 0;
 116
 117                 default: /* Play or stop an effect */
 118
 119                         if (!CHECK_OWNERSHIP(code, iforce)) {
 120                                 return -1;
 121                         }
 122                         if (value > 0) {
 123                                 set_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[code].flags);
 124                         }
 125                         else {
 126                                 clear_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[code].flags);
 127                         }
 128
 129                         iforce_control_playback(iforce, code, value);
 130                         return 0;
 131         }
 132
 133         return -1;
 134 }
 135
 136 /*
 137  * Function called when an ioctl is performed on the event dev entry.
 138  * It uploads an effect to the device
 139  */
 140 static int iforce_upload_effect(struct input_dev *dev, struct ff_effect *effect)
 141 {
 142         struct iforce* iforce = dev->private;
 143         int id;
 144         int ret;
 145         int is_update;
 146
 147 /* Check this effect type is supported by this device */
 148         if (!test_bit(effect->type, iforce->dev->ffbit))
 149                 return -EINVAL;
 150
 151 /*
 152  * If we want to create a new effect, get a free id
 153  */
 154         if (effect->id == -1) {
 155
 156                 for (id = 0; id < FF_EFFECTS_MAX; ++id)
 157                         if (!test_and_set_bit(FF_CORE_IS_USED, iforce->core_effects[id].flags))
 158                                 break;
 159
 160                 if (id == FF_EFFECTS_MAX || id >= iforce->dev->ff_effects_max)
 161                         return -ENOMEM;
 162
 163                 effect->id = id;
 164                 iforce->core_effects[id].owner = current->pid;
 165                 iforce->core_effects[id].flags[0] = (1 << FF_CORE_IS_USED);     /* Only IS_USED bit must be set */
 166
 167                 is_update = FALSE;
 168         }
 169         else {
 170                 /* We want to update an effect */
 171                 if (!CHECK_OWNERSHIP(effect->id, iforce))
 172                         return -EACCES;
 173
 174                 /* Parameter type cannot be updated */
 175                 if (effect->type != iforce->core_effects[effect->id].effect.type)
 176                         return -EINVAL;
 177
 178                 /* Check the effect is not already being updated */
 179                 if (test_bit(FF_CORE_UPDATE, iforce->core_effects[effect->id].flags))
 180                         return -EAGAIN;
 181
 182                 is_update = TRUE;
 183         }
 184
 185 /*
 186  * Upload the effect
 187  */
 188         switch (effect->type) {
 189
 190                 case FF_PERIODIC:
 191                         ret = iforce_upload_periodic(iforce, effect, is_update);
 192                         break;
 193
 194                 case FF_CONSTANT:
 195                         ret = iforce_upload_constant(iforce, effect, is_update);
 196                         break;
 197
 198                 case FF_SPRING:
 199                 case FF_DAMPER:
 200                         ret = iforce_upload_condition(iforce, effect, is_update);
 201                         break;
 202
 203                 default:
 204                         return -EINVAL;
 205         }
 206         if (ret == 0) {
 207                 /* A packet was sent, forbid new updates until we are notified
 208                  * that the packet was updated
 209                  */
 210                 set_bit(FF_CORE_UPDATE, iforce->core_effects[effect->id].flags);
 211         }
 212         iforce->core_effects[effect->id].effect = *effect;
 213         return ret;
 214 }
 215
 216 /*
 217  * Erases an effect: it frees the effect id and mark as unused the memory
 218  * allocated for the parameters
 219  */
 220 static int iforce_erase_effect(struct input_dev *dev, int effect_id)
 221 {
 222         struct iforce* iforce = dev->private;
 223         int err = 0;
 224         struct iforce_core_effect* core_effect;
 225
 226         if (effect_id < 0 || effect_id >= FF_EFFECTS_MAX)
 227                 return -EINVAL;
 228
 229         core_effect = &iforce->core_effects[effect_id];
 230
 231         /* Check who is trying to erase this effect */
 232         if (core_effect->owner != current->pid) {
 233                 printk(KERN_WARNING "iforce-main.c: %d tried to erase an effect belonging to %d\n", current->pid, core_effect->owner);
 234                 return -EACCES;
 235         }
 236
 237         if (test_bit(FF_MOD1_IS_USED, core_effect->flags))
 238                 err = release_resource(&core_effect->mod1_chunk);
 239
 240         if (!err && test_bit(FF_MOD2_IS_USED, core_effect->flags))
 241                 err = release_resource(&core_effect->mod2_chunk);
 242
 243         /*TODO: remember to change that if more FF_MOD* bits are added */
 244         core_effect->flags[0] = 0;
 245
 246         return err;
 247 }
 248
 249 static int iforce_open(struct input_dev *dev)
 250 {
 251         struct iforce *iforce = dev->private;
 252
 253         switch (iforce->bus) {
 254 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 255                 case IFORCE_USB:
 256                         iforce->irq->dev = iforce->usbdev;
 257                         if (usb_submit_urb(iforce->irq, GFP_KERNEL))
 258                                 return -EIO;
 259                         break;
 260 #endif
 261         }
 262
 263         /* Enable force feedback */
 264         iforce_send_packet(iforce, FF_CMD_ENABLE, "\004");
 265
 266         return 0;
 267 }
 268
 269 static int iforce_flush(struct input_dev *dev, struct file *file)
 270 {
 271         struct iforce *iforce = dev->private;
 272         int i;
 273
 274         /* Erase all effects this process owns */
 275         for (i=0; i<dev->ff_effects_max; ++i) {
 276
 277                 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags) &&
 278                         current->pid == iforce->core_effects[i].owner) {
 279
 280                         /* Stop effect */
 281                         input_report_ff(dev, i, 0);
 282
 283                         /* Free ressources assigned to effect */
 284                         if (iforce_erase_effect(dev, i)) {
 285                                 printk(KERN_WARNING "iforce_flush: erase effect %d failed\n", i);
 286                         }
 287                 }
 288
 289         }
 290         return 0;
 291 }
 292
 293 static void iforce_release(struct input_dev *dev)
 294 {
 295         struct iforce *iforce = dev->private;
 296         int i;
 297
 298         /* Check: no effect should be present in memory */
 299         for (i=0; i<dev->ff_effects_max; ++i) {
 300                 if (test_bit(FF_CORE_IS_USED, iforce->core_effects[i].flags))
 301                         break;
 302         }
 303         if (i<dev->ff_effects_max) {
 304                 printk(KERN_WARNING "iforce_release: Device still owns effects\n");
 305         }
 306
 307         /* Disable force feedback playback */
 308         iforce_send_packet(iforce, FF_CMD_ENABLE, "\001");
 309
 310         switch (iforce->bus) {
 311 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 312                 case IFORCE_USB:
 313                         usb_unlink_urb(iforce->irq);
 314
 315                         /* The device was unplugged before the file
 316                          * was released */
 317                         if (iforce->usbdev == NULL) {
 318                                 iforce_delete_device(iforce);
 319                                 kfree(iforce);
 320                         }
 321                 break;
 322 #endif
 323         }
 324 }
 325
 326 void iforce_delete_device(struct iforce *iforce)
 327 {
 328         switch (iforce->bus) {
 329 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 330         case IFORCE_USB:
 331                 iforce_usb_delete(iforce);
 332                 break;
 333 #endif
 334 #ifdef CONFIG_JOYSTICK_IFORCE_232
 335         case IFORCE_232:
 336                 //TODO: Wait for the last packets to be sent
 337                 break;
 338 #endif
 339         }
 340 }
 341
 342 int iforce_init_device(struct iforce *iforce)
 343 {
 344         struct input_dev *input_dev;
 345         unsigned char c[] = "CEOV";
 346         int i;
 347
 348         input_dev = input_allocate_device();
 349         if (!input_dev)
 350                 return -ENOMEM;
 351
 352         init_waitqueue_head(&iforce->wait);
 353         spin_lock_init(&iforce->xmit_lock);
 354         mutex_init(&iforce->mem_mutex);
 355         iforce->xmit.buf = iforce->xmit_data;
 356         iforce->dev = input_dev;
 357
 358 /*
 359  * Input device fields.
 360  */
 361
 362         switch (iforce->bus) {
 363 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 364         case IFORCE_USB:
 365                 input_dev->id.bustype = BUS_USB;
 366                 input_dev->cdev.dev = &iforce->usbdev->dev;
 367                 break;
 368 #endif
 369 #ifdef CONFIG_JOYSTICK_IFORCE_232
 370         case IFORCE_232:
 371                 input_dev->id.bustype = BUS_RS232;
 372                 input_dev->cdev.dev = &iforce->serio->dev;
 373                 break;
 374 #endif
 375         }
 376
 377         input_dev->private = iforce;
 378         input_dev->name = "Unknown I-Force device";
 379         input_dev->open = iforce_open;
 380         input_dev->close = iforce_release;
 381         input_dev->flush = iforce_flush;
 382         input_dev->event = iforce_input_event;
 383         input_dev->upload_effect = iforce_upload_effect;
 384         input_dev->erase_effect = iforce_erase_effect;
 385         input_dev->ff_effects_max = 10;
 386
 387 /*
 388  * On-device memory allocation.
 389  */
 390
 391         iforce->device_memory.name = "I-Force device effect memory";
 392         iforce->device_memory.start = 0;
 393         iforce->device_memory.end = 200;
 394         iforce->device_memory.flags = IORESOURCE_MEM;
 395         iforce->device_memory.parent = NULL;
 396         iforce->device_memory.child = NULL;
 397         iforce->device_memory.sibling = NULL;
 398
 399 /*
 400  * Wait until device ready - until it sends its first response.
 401  */
 402
 403         for (i = 0; i < 20; i++)
 404                 if (!iforce_get_id_packet(iforce, "O"))
 405                         break;
 406
 407         if (i == 20) { /* 5 seconds */
 408                 printk(KERN_ERR "iforce-main.c: Timeout waiting for response from device.\n");
 409                 input_free_device(input_dev);
 410                 return -ENODEV;
 411         }
 412
 413 /*
 414  * Get device info.
 415  */
 416
 417         if (!iforce_get_id_packet(iforce, "M"))
 418                 input_dev->id.vendor = (iforce->edata[2] << 8) | iforce->edata[1];
 419         else
 420                 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet M\n");
 421
 422         if (!iforce_get_id_packet(iforce, "P"))
 423                 input_dev->id.product = (iforce->edata[2] << 8) | iforce->edata[1];
 424         else
 425                 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet P\n");
 426
 427         if (!iforce_get_id_packet(iforce, "B"))
 428                 iforce->device_memory.end = (iforce->edata[2] << 8) | iforce->edata[1];
 429         else
 430                 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet B\n");
 431
 432         if (!iforce_get_id_packet(iforce, "N"))
 433                 iforce->dev->ff_effects_max = iforce->edata[1];
 434         else
 435                 printk(KERN_WARNING "iforce-main.c: Device does not respond to id packet N\n");
 436
 437         /* Check if the device can store more effects than the driver can really handle */
 438         if (iforce->dev->ff_effects_max > FF_EFFECTS_MAX) {
 439                 printk(KERN_WARNING "input??: Device can handle %d effects, but N_EFFECTS_MAX is set to %d in iforce.h\n",
 440                         iforce->dev->ff_effects_max, FF_EFFECTS_MAX);
 441                 iforce->dev->ff_effects_max = FF_EFFECTS_MAX;
 442         }
 443
 444 /*
 445  * Display additional info.
 446  */
 447
 448         for (i = 0; c[i]; i++)
 449                 if (!iforce_get_id_packet(iforce, c + i))
 450                         iforce_dump_packet("info", iforce->ecmd, iforce->edata);
 451
 452 /*
 453  * Disable spring, enable force feedback.
 454  * FIXME: We should use iforce_set_autocenter() et al here.
 455  */
 456
 457         iforce_send_packet(iforce, FF_CMD_AUTOCENTER, "\004\000");
 458
 459 /*
 460  * Find appropriate device entry
 461  */
 462
 463         for (i = 0; iforce_device[i].idvendor; i++)
 464                 if (iforce_device[i].idvendor == input_dev->id.vendor &&
 465                     iforce_device[i].idproduct == input_dev->id.product)
 466                         break;
 467
 468         iforce->type = iforce_device + i;
 469         input_dev->name = iforce->type->name;
 470
 471 /*
 472  * Set input device bitfields and ranges.
 473  */
 474
 475         input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS) | BIT(EV_FF) | BIT(EV_FF_STATUS);
 476
 477         for (i = 0; iforce->type->btn[i] >= 0; i++) {
 478                 signed short t = iforce->type->btn[i];
 479                 set_bit(t, input_dev->keybit);
 480         }
 481         set_bit(BTN_DEAD, input_dev->keybit);
 482
 483         for (i = 0; iforce->type->abs[i] >= 0; i++) {
 484
 485                 signed short t = iforce->type->abs[i];
 486
 487                 switch (t) {
 488
 489                         case ABS_X:
 490                         case ABS_Y:
 491                         case ABS_WHEEL:
 492
 493                                 input_set_abs_params(input_dev, t, -1920, 1920, 16, 128);
 494                                 set_bit(t, input_dev->ffbit);
 495                                 break;
 496
 497                         case ABS_THROTTLE:
 498                         case ABS_GAS:
 499                         case ABS_BRAKE:
 500
 501                                 input_set_abs_params(input_dev, t, 0, 255, 0, 0);
 502                                 break;
 503
 504                         case ABS_RUDDER:
 505
 506                                 input_set_abs_params(input_dev, t, -128, 127, 0, 0);
 507                                 break;
 508
 509                         case ABS_HAT0X:
 510                         case ABS_HAT0Y:
 511                         case ABS_HAT1X:
 512                         case ABS_HAT1Y:
 513
 514                                 input_set_abs_params(input_dev, t, -1, 1, 0, 0);
 515                                 break;
 516                 }
 517         }
 518
 519         for (i = 0; iforce->type->ff[i] >= 0; i++)
 520                 set_bit(iforce->type->ff[i], input_dev->ffbit);
 521
 522 /*
 523  * Register input device.
 524  */
 525
 526         input_register_device(iforce->dev);
 527
 528         printk(KERN_DEBUG "iforce->dev->open = %p\n", iforce->dev->open);
 529
 530         return 0;
 531 }
 532
 533 static int __init iforce_init(void)
 534 {
 535 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 536         usb_register(&iforce_usb_driver);
 537 #endif
 538 #ifdef CONFIG_JOYSTICK_IFORCE_232
 539         serio_register_driver(&iforce_serio_drv);
 540 #endif
 541         return 0;
 542 }
 543
 544 static void __exit iforce_exit(void)
 545 {
 546 #ifdef CONFIG_JOYSTICK_IFORCE_USB
 547         usb_deregister(&iforce_usb_driver);
 548 #endif
 549 #ifdef CONFIG_JOYSTICK_IFORCE_232
 550         serio_unregister_driver(&iforce_serio_drv);
 551 #endif
 552 }
 553
 554 module_init(iforce_init);
 555 module_exit(iforce_exit);