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

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