drivers/usb/input/hid-tmff.c

   1 /*
   2  * Force feedback support for various HID compliant devices by ThrustMaster:
   3  *    ThrustMaster FireStorm Dual Power 2
   4  * and possibly others whose device ids haven't been added.
   5  *
   6  *  Modified to support ThrustMaster devices by Zinx Verituse
   7  *  on 2003-01-25 from the Logitech force feedback driver,
   8  *  which is by Johann Deneux.
   9  *
  10  *  Copyright (c) 2003 Zinx Verituse <zinx@epicsol.org>
  11  *  Copyright (c) 2002 Johann Deneux
  12  */
  13
  14 /*
  15  * This program is free software; you can redistribute it and/or modify
  16  * it under the terms of the GNU General Public License as published by
  17  * the Free Software Foundation; either version 2 of the License, or
  18  * (at your option) any later version.
  19  *
  20  * This program is distributed in the hope that it will be useful,
  21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  * GNU General Public License for more details.
  24  *
  25  * You should have received a copy of the GNU General Public License
  26  * along with this program; if not, write to the Free Software
  27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  28  */
  29
  30 #include <linux/input.h>
  31 #include <linux/sched.h>
  32
  33 #undef DEBUG
  34 #include <linux/usb.h>
  35
  36 #include <linux/circ_buf.h>
  37
  38 #include "hid.h"
  39 #include "fixp-arith.h"
  40
  41 /* Usages for thrustmaster devices I know about */
  42 #define THRUSTMASTER_USAGE_RUMBLE_LR    (HID_UP_GENDESK | 0xbb)
  43 #define DELAY_CALC(t,delay)             ((t) + (delay)*HZ/1000)
  44
  45 /* Effect status */
  46 #define EFFECT_STARTED 0        /* Effect is going to play after some time */
  47 #define EFFECT_PLAYING 1        /* Effect is playing */
  48 #define EFFECT_USED    2
  49
  50 /* For tmff_device::flags */
  51 #define DEVICE_CLOSING 0        /* The driver is being unitialised */
  52
  53 /* Check that the current process can access an effect */
  54 #define CHECK_OWNERSHIP(effect) (current->pid == 0 \
  55         || effect.owner == current->pid)
  56
  57 #define TMFF_CHECK_ID(id)       ((id) >= 0 && (id) < TMFF_EFFECTS)
  58
  59 #define TMFF_CHECK_OWNERSHIP(i, l) \
  60         (test_bit(EFFECT_USED, l->effects[i].flags) \
  61         && CHECK_OWNERSHIP(l->effects[i]))
  62
  63 #define TMFF_EFFECTS 8
  64
  65 struct tmff_effect {
  66         pid_t owner;
  67
  68         struct ff_effect effect;
  69
  70         unsigned long flags[1];
  71         unsigned int count;             /* Number of times left to play */
  72
  73         unsigned long play_at;          /* When the effect starts to play */
  74         unsigned long stop_at;          /* When the effect ends */
  75 };
  76
  77 struct tmff_device {
  78         struct hid_device *hid;
  79
  80         struct hid_report *report;
  81
  82         struct hid_field *rumble;
  83
  84         unsigned int effects_playing;
  85         struct tmff_effect effects[TMFF_EFFECTS];
  86         spinlock_t lock;             /* device-level lock. Having locks on
  87                                         a per-effect basis could be nice, but
  88                                         isn't really necessary */
  89
  90         unsigned long flags[1];      /* Contains various information about the
  91                                         state of the driver for this device */
  92
  93         struct timer_list timer;
  94 };
  95
  96 /* Callbacks */
  97 static void hid_tmff_exit(struct hid_device *hid);
  98 static int hid_tmff_event(struct hid_device *hid, struct input_dev *input,
  99                           unsigned int type, unsigned int code, int value);
 100 static int hid_tmff_flush(struct input_dev *input, struct file *file);
 101 static int hid_tmff_upload_effect(struct input_dev *input,
 102                                   struct ff_effect *effect);
 103 static int hid_tmff_erase(struct input_dev *input, int id);
 104
 105 /* Local functions */
 106 static void hid_tmff_recalculate_timer(struct tmff_device *tmff);
 107 static void hid_tmff_timer(unsigned long timer_data);
 108
 109 int hid_tmff_init(struct hid_device *hid)
 110 {
 111         struct tmff_device *private;
 112         struct list_head *pos;
 113         struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
 114         struct input_dev *input_dev = hidinput->input;
 115
 116         private = kmalloc(sizeof(struct tmff_device), GFP_KERNEL);
 117         if (!private)
 118                 return -ENOMEM;
 119
 120         memset(private, 0, sizeof(struct tmff_device));
 121         hid->ff_private = private;
 122
 123         /* Find the report to use */
 124         __list_for_each(pos, &hid->report_enum[HID_OUTPUT_REPORT].report_list) {
 125                 struct hid_report *report = (struct hid_report *)pos;
 126                 int fieldnum;
 127
 128                 for (fieldnum = 0; fieldnum < report->maxfield; ++fieldnum) {
 129                         struct hid_field *field = report->field[fieldnum];
 130
 131                         if (field->maxusage <= 0)
 132                                 continue;
 133
 134                         switch (field->usage[0].hid) {
 135                                 case THRUSTMASTER_USAGE_RUMBLE_LR:
 136                                         if (field->report_count < 2) {
 137                                                 warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR with report_count < 2");
 138                                                 continue;
 139                                         }
 140
 141                                         if (field->logical_maximum == field->logical_minimum) {
 142                                                 warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR with logical_maximum == logical_minimum");
 143                                                 continue;
 144                                         }
 145
 146                                         if (private->report && private->report != report) {
 147                                                 warn("ignoring THRUSTMASTER_USAGE_RUMBLE_LR in other report");
 148                                                 continue;
 149                                         }
 150
 151                                         if (private->rumble && private->rumble != field) {
 152                                                 warn("ignoring duplicate THRUSTMASTER_USAGE_RUMBLE_LR");
 153                                                 continue;
 154                                         }
 155
 156                                         private->report = report;
 157                                         private->rumble = field;
 158
 159                                         set_bit(FF_RUMBLE, input_dev->ffbit);
 160                                         break;
 161
 162                                 default:
 163                                         warn("ignoring unknown output usage %08x", field->usage[0].hid);
 164                                         continue;
 165                         }
 166
 167                         /* Fallthrough to here only when a valid usage is found */
 168                         input_dev->upload_effect = hid_tmff_upload_effect;
 169                         input_dev->flush = hid_tmff_flush;
 170
 171                         set_bit(EV_FF, input_dev->evbit);
 172                         input_dev->ff_effects_max = TMFF_EFFECTS;
 173                 }
 174         }
 175
 176         private->hid = hid;
 177
 178         spin_lock_init(&private->lock);
 179         init_timer(&private->timer);
 180         private->timer.data = (unsigned long)private;
 181         private->timer.function = hid_tmff_timer;
 182
 183         /* Event and exit callbacks */
 184         hid->ff_exit = hid_tmff_exit;
 185         hid->ff_event = hid_tmff_event;
 186
 187         info("Force feedback for ThrustMaster rumble pad devices by Zinx Verituse <zinx@epicsol.org>");
 188
 189         return 0;
 190 }
 191
 192 static void hid_tmff_exit(struct hid_device *hid)
 193 {
 194         struct tmff_device *tmff = hid->ff_private;
 195         unsigned long flags;
 196
 197         spin_lock_irqsave(&tmff->lock, flags);
 198
 199         set_bit(DEVICE_CLOSING, tmff->flags);
 200         del_timer_sync(&tmff->timer);
 201
 202         spin_unlock_irqrestore(&tmff->lock, flags);
 203
 204         kfree(tmff);
 205 }
 206
 207 static int hid_tmff_event(struct hid_device *hid, struct input_dev *input,
 208                           unsigned int type, unsigned int code, int value)
 209 {
 210         struct tmff_device *tmff = hid->ff_private;
 211         struct tmff_effect *effect = &tmff->effects[code];
 212         unsigned long flags;
 213
 214         if (type != EV_FF)
 215                 return -EINVAL;
 216         if (!TMFF_CHECK_ID(code))
 217                 return -EINVAL;
 218         if (!TMFF_CHECK_OWNERSHIP(code, tmff))
 219                 return -EACCES;
 220         if (value < 0)
 221                 return -EINVAL;
 222
 223         spin_lock_irqsave(&tmff->lock, flags);
 224
 225         if (value > 0) {
 226                 set_bit(EFFECT_STARTED, effect->flags);
 227                 clear_bit(EFFECT_PLAYING, effect->flags);
 228                 effect->count = value;
 229                 effect->play_at = DELAY_CALC(jiffies, effect->effect.replay.delay);
 230         } else {
 231                 clear_bit(EFFECT_STARTED, effect->flags);
 232                 clear_bit(EFFECT_PLAYING, effect->flags);
 233         }
 234
 235         hid_tmff_recalculate_timer(tmff);
 236
 237         spin_unlock_irqrestore(&tmff->lock, flags);
 238
 239         return 0;
 240
 241 }
 242
 243 /* Erase all effects this process owns */
 244
 245 static int hid_tmff_flush(struct input_dev *dev, struct file *file)
 246 {
 247         struct hid_device *hid = dev->private;
 248         struct tmff_device *tmff = hid->ff_private;
 249         int i;
 250
 251         for (i=0; i<dev->ff_effects_max; ++i)
 252
 253              /* NOTE: no need to lock here. The only times EFFECT_USED is
 254                 modified is when effects are uploaded or when an effect is
 255                 erased. But a process cannot close its dev/input/eventX fd
 256                 and perform ioctls on the same fd all at the same time */
 257
 258                 if (current->pid == tmff->effects[i].owner
 259                      && test_bit(EFFECT_USED, tmff->effects[i].flags))
 260                         if (hid_tmff_erase(dev, i))
 261                                 warn("erase effect %d failed", i);
 262
 263
 264         return 0;
 265 }
 266
 267 static int hid_tmff_erase(struct input_dev *dev, int id)
 268 {
 269         struct hid_device *hid = dev->private;
 270         struct tmff_device *tmff = hid->ff_private;
 271         unsigned long flags;
 272
 273         if (!TMFF_CHECK_ID(id))
 274                 return -EINVAL;
 275         if (!TMFF_CHECK_OWNERSHIP(id, tmff))
 276                 return -EACCES;
 277
 278         spin_lock_irqsave(&tmff->lock, flags);
 279
 280         tmff->effects[id].flags[0] = 0;
 281         hid_tmff_recalculate_timer(tmff);
 282
 283         spin_unlock_irqrestore(&tmff->lock, flags);
 284
 285         return 0;
 286 }
 287
 288 static int hid_tmff_upload_effect(struct input_dev *input,
 289                                   struct ff_effect *effect)
 290 {
 291         struct hid_device *hid = input->private;
 292         struct tmff_device *tmff = hid->ff_private;
 293         int id;
 294         unsigned long flags;
 295
 296         if (!test_bit(effect->type, input->ffbit))
 297                 return -EINVAL;
 298         if (effect->id != -1 && !TMFF_CHECK_ID(effect->id))
 299                 return -EINVAL;
 300
 301         spin_lock_irqsave(&tmff->lock, flags);
 302
 303         if (effect->id == -1) {
 304                 /* Find a free effect */
 305                 for (id = 0; id < TMFF_EFFECTS && test_bit(EFFECT_USED, tmff->effects[id].flags); ++id);
 306
 307                 if (id >= TMFF_EFFECTS) {
 308                         spin_unlock_irqrestore(&tmff->lock, flags);
 309                         return -ENOSPC;
 310                 }
 311
 312                 effect->id = id;
 313                 tmff->effects[id].owner = current->pid;
 314                 tmff->effects[id].flags[0] = 0;
 315                 set_bit(EFFECT_USED, tmff->effects[id].flags);
 316
 317         } else {
 318                 /* Re-uploading an owned effect, to change parameters */
 319                 id = effect->id;
 320                 clear_bit(EFFECT_PLAYING, tmff->effects[id].flags);
 321         }
 322
 323         tmff->effects[id].effect = *effect;
 324
 325         hid_tmff_recalculate_timer(tmff);
 326
 327         spin_unlock_irqrestore(&tmff->lock, flags);
 328         return 0;
 329 }
 330
 331 /* Start the timer for the next start/stop/delay */
 332 /* Always call this while tmff->lock is locked */
 333
 334 static void hid_tmff_recalculate_timer(struct tmff_device *tmff)
 335 {
 336         int i;
 337         int events = 0;
 338         unsigned long next_time;
 339
 340         next_time = 0;  /* Shut up compiler's incorrect warning */
 341
 342         /* Find the next change in an effect's status */
 343         for (i = 0; i < TMFF_EFFECTS; ++i) {
 344                 struct tmff_effect *effect = &tmff->effects[i];
 345                 unsigned long play_time;
 346
 347                 if (!test_bit(EFFECT_STARTED, effect->flags))
 348                         continue;
 349
 350                 effect->stop_at = DELAY_CALC(effect->play_at, effect->effect.replay.length);
 351
 352                 if (!test_bit(EFFECT_PLAYING, effect->flags))
 353                         play_time = effect->play_at;
 354                 else
 355                         play_time = effect->stop_at;
 356
 357                 events++;
 358
 359                 if (time_after(jiffies, play_time))
 360                         play_time = jiffies;
 361
 362                 if (events == 1)
 363                         next_time = play_time;
 364                 else {
 365                         if (time_after(next_time, play_time))
 366                                 next_time = play_time;
 367                 }
 368         }
 369
 370         if (!events && tmff->effects_playing) {
 371                 /* Treat all effects turning off as an event */
 372                 events = 1;
 373                 next_time = jiffies;
 374         }
 375
 376         if (!events) {
 377                 /* No events, no time, no need for a timer. */
 378                 del_timer_sync(&tmff->timer);
 379                 return;
 380         }
 381
 382         mod_timer(&tmff->timer, next_time);
 383 }
 384
 385 /* Changes values from 0 to 0xffff into values from minimum to maximum */
 386 static inline int hid_tmff_scale(unsigned int in, int minimum, int maximum)
 387 {
 388         int ret;
 389
 390         ret = (in * (maximum - minimum) / 0xffff) + minimum;
 391         if (ret < minimum)
 392                 return minimum;
 393         if (ret > maximum)
 394                 return maximum;
 395         return ret;
 396 }
 397
 398 static void hid_tmff_timer(unsigned long timer_data)
 399 {
 400         struct tmff_device *tmff = (struct tmff_device *) timer_data;
 401         struct hid_device *hid = tmff->hid;
 402         unsigned long flags;
 403         int left = 0, right = 0;        /* Rumbling */
 404         int i;
 405
 406         spin_lock_irqsave(&tmff->lock, flags);
 407
 408         tmff->effects_playing = 0;
 409
 410         for (i = 0; i < TMFF_EFFECTS; ++i) {
 411                 struct tmff_effect *effect = &tmff->effects[i];
 412
 413                 if (!test_bit(EFFECT_STARTED, effect->flags))
 414                         continue;
 415
 416                 if (!time_after(jiffies, effect->play_at))
 417                         continue;
 418
 419                 if (time_after(jiffies, effect->stop_at)) {
 420
 421                         dbg("Finished playing once %d", i);
 422                         clear_bit(EFFECT_PLAYING, effect->flags);
 423
 424                         if (--effect->count <= 0) {
 425                                 dbg("Stopped %d", i);
 426                                 clear_bit(EFFECT_STARTED, effect->flags);
 427                                 continue;
 428                         } else {
 429                                 dbg("Start again %d", i);
 430                                 effect->play_at = DELAY_CALC(jiffies, effect->effect.replay.delay);
 431                                 continue;
 432                         }
 433                 }
 434
 435                 ++tmff->effects_playing;
 436
 437                 set_bit(EFFECT_PLAYING, effect->flags);
 438
 439                 switch (effect->effect.type) {
 440                         case FF_RUMBLE:
 441                                 right += effect->effect.u.rumble.strong_magnitude;
 442                                 left += effect->effect.u.rumble.weak_magnitude;
 443                                 break;
 444                         default:
 445                                 BUG();
 446                                 break;
 447                 }
 448         }
 449
 450         left = hid_tmff_scale(left, tmff->rumble->logical_minimum, tmff->rumble->logical_maximum);
 451         right = hid_tmff_scale(right, tmff->rumble->logical_minimum, tmff->rumble->logical_maximum);
 452
 453         if (left != tmff->rumble->value[0] || right != tmff->rumble->value[1]) {
 454                 tmff->rumble->value[0] = left;
 455                 tmff->rumble->value[1] = right;
 456                 dbg("(left,right)=(%08x, %08x)", left, right);
 457                 hid_submit_report(hid, tmff->report, USB_DIR_OUT);
 458         }
 459
 460         if (!test_bit(DEVICE_CLOSING, tmff->flags))
 461                 hid_tmff_recalculate_timer(tmff);
 462
 463         spin_unlock_irqrestore(&tmff->lock, flags);
 464 }