kernel/drivers/input/joystick/iforce/iforce-ff.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  * 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 /*
  31  * Set the magnitude of a constant force effect
  32  * Return error code
  33  *
  34  * Note: caller must ensure exclusive access to device
  35  */
  36
  37 static int make_magnitude_modifier(struct iforce* iforce,
  38         struct resource* mod_chunk, int no_alloc, __s16 level)
  39 {
  40         unsigned char data[3];
  41
  42         if (!no_alloc) {
  43                 mutex_lock(&iforce->mem_mutex);
  44                 if (allocate_resource(&(iforce->device_memory), mod_chunk, 2,
  45                         iforce->device_memory.start, iforce->device_memory.end, 2L,
  46                         NULL, NULL)) {
  47                         mutex_unlock(&iforce->mem_mutex);
  48                         return -ENOSPC;
  49                 }
  50                 mutex_unlock(&iforce->mem_mutex);
  51         }
  52
  53         data[0] = LO(mod_chunk->start);
  54         data[1] = HI(mod_chunk->start);
  55         data[2] = HIFIX80(level);
  56
  57         iforce_send_packet(iforce, FF_CMD_MAGNITUDE, data);
  58
  59         iforce_dump_packet("magnitude: ", FF_CMD_MAGNITUDE, data);
  60         return 0;
  61 }
  62
  63 /*
  64  * Upload the component of an effect dealing with the period, phase and magnitude
  65  */
  66
  67 static int make_period_modifier(struct iforce* iforce,
  68         struct resource* mod_chunk, int no_alloc,
  69         __s16 magnitude, __s16 offset, u16 period, u16 phase)
  70 {
  71         unsigned char data[7];
  72
  73         period = TIME_SCALE(period);
  74
  75         if (!no_alloc) {
  76                 mutex_lock(&iforce->mem_mutex);
  77                 if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0c,
  78                         iforce->device_memory.start, iforce->device_memory.end, 2L,
  79                         NULL, NULL)) {
  80                         mutex_unlock(&iforce->mem_mutex);
  81                         return -ENOSPC;
  82                 }
  83                 mutex_unlock(&iforce->mem_mutex);
  84         }
  85
  86         data[0] = LO(mod_chunk->start);
  87         data[1] = HI(mod_chunk->start);
  88
  89         data[2] = HIFIX80(magnitude);
  90         data[3] = HIFIX80(offset);
  91         data[4] = HI(phase);
  92
  93         data[5] = LO(period);
  94         data[6] = HI(period);
  95
  96         iforce_send_packet(iforce, FF_CMD_PERIOD, data);
  97
  98         return 0;
  99 }
 100
 101 /*
 102  * Uploads the part of an effect setting the envelope of the force
 103  */
 104
 105 static int make_envelope_modifier(struct iforce* iforce,
 106         struct resource* mod_chunk, int no_alloc,
 107         u16 attack_duration, __s16 initial_level,
 108         u16 fade_duration, __s16 final_level)
 109 {
 110         unsigned char data[8];
 111
 112         attack_duration = TIME_SCALE(attack_duration);
 113         fade_duration = TIME_SCALE(fade_duration);
 114
 115         if (!no_alloc) {
 116                 mutex_lock(&iforce->mem_mutex);
 117                 if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0e,
 118                         iforce->device_memory.start, iforce->device_memory.end, 2L,
 119                         NULL, NULL)) {
 120                         mutex_unlock(&iforce->mem_mutex);
 121                         return -ENOSPC;
 122                 }
 123                 mutex_unlock(&iforce->mem_mutex);
 124         }
 125
 126         data[0] = LO(mod_chunk->start);
 127         data[1] = HI(mod_chunk->start);
 128
 129         data[2] = LO(attack_duration);
 130         data[3] = HI(attack_duration);
 131         data[4] = HI(initial_level);
 132
 133         data[5] = LO(fade_duration);
 134         data[6] = HI(fade_duration);
 135         data[7] = HI(final_level);
 136
 137         iforce_send_packet(iforce, FF_CMD_ENVELOPE, data);
 138
 139         return 0;
 140 }
 141
 142 /*
 143  * Component of spring, friction, inertia... effects
 144  */
 145
 146 static int make_condition_modifier(struct iforce* iforce,
 147         struct resource* mod_chunk, int no_alloc,
 148         __u16 rsat, __u16 lsat, __s16 rk, __s16 lk, u16 db, __s16 center)
 149 {
 150         unsigned char data[10];
 151
 152         if (!no_alloc) {
 153                 mutex_lock(&iforce->mem_mutex);
 154                 if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
 155                         iforce->device_memory.start, iforce->device_memory.end, 2L,
 156                         NULL, NULL)) {
 157                         mutex_unlock(&iforce->mem_mutex);
 158                         return -ENOSPC;
 159                 }
 160                 mutex_unlock(&iforce->mem_mutex);
 161         }
 162
 163         data[0] = LO(mod_chunk->start);
 164         data[1] = HI(mod_chunk->start);
 165
 166         data[2] = (100 * rk) >> 15;     /* Dangerous: the sign is extended by gcc on plateforms providing an arith shift */
 167         data[3] = (100 * lk) >> 15; /* This code is incorrect on cpus lacking arith shift */
 168
 169         center = (500 * center) >> 15;
 170         data[4] = LO(center);
 171         data[5] = HI(center);
 172
 173         db = (1000 * db) >> 16;
 174         data[6] = LO(db);
 175         data[7] = HI(db);
 176
 177         data[8] = (100 * rsat) >> 16;
 178         data[9] = (100 * lsat) >> 16;
 179
 180         iforce_send_packet(iforce, FF_CMD_CONDITION, data);
 181         iforce_dump_packet("condition", FF_CMD_CONDITION, data);
 182
 183         return 0;
 184 }
 185
 186 static unsigned char find_button(struct iforce *iforce, signed short button)
 187 {
 188         int i;
 189
 190         for (i = 1; iforce->type->btn[i] >= 0; i++)
 191                 if (iforce->type->btn[i] == button)
 192                         return i + 1;
 193         return 0;
 194 }
 195
 196 /*
 197  * Analyse the changes in an effect, and tell if we need to send an condition
 198  * parameter packet
 199  */
 200 static int need_condition_modifier(struct iforce *iforce,
 201                                    struct ff_effect *old,
 202                                    struct ff_effect *new)
 203 {
 204         int ret = 0;
 205         int i;
 206
 207         if (new->type != FF_SPRING && new->type != FF_FRICTION) {
 208                 dev_warn(&iforce->dev->dev, "bad effect type in %s\n",
 209                          __func__);
 210                 return 0;
 211         }
 212
 213         for (i = 0; i < 2; i++) {
 214                 ret |= old->u.condition[i].right_saturation != new->u.condition[i].right_saturation
 215                         || old->u.condition[i].left_saturation != new->u.condition[i].left_saturation
 216                         || old->u.condition[i].right_coeff != new->u.condition[i].right_coeff
 217                         || old->u.condition[i].left_coeff != new->u.condition[i].left_coeff
 218                         || old->u.condition[i].deadband != new->u.condition[i].deadband
 219                         || old->u.condition[i].center != new->u.condition[i].center;
 220         }
 221         return ret;
 222 }
 223
 224 /*
 225  * Analyse the changes in an effect, and tell if we need to send a magnitude
 226  * parameter packet
 227  */
 228 static int need_magnitude_modifier(struct iforce *iforce,
 229                                    struct ff_effect *old,
 230                                    struct ff_effect *effect)
 231 {
 232         if (effect->type != FF_CONSTANT) {
 233                 dev_warn(&iforce->dev->dev, "bad effect type in %s\n",
 234                          __func__);
 235                 return 0;
 236         }
 237
 238         return old->u.constant.level != effect->u.constant.level;
 239 }
 240
 241 /*
 242  * Analyse the changes in an effect, and tell if we need to send an envelope
 243  * parameter packet
 244  */
 245 static int need_envelope_modifier(struct iforce *iforce, struct ff_effect *old,
 246                                   struct ff_effect *effect)
 247 {
 248         switch (effect->type) {
 249         case FF_CONSTANT:
 250                 if (old->u.constant.envelope.attack_length != effect->u.constant.envelope.attack_length
 251                 || old->u.constant.envelope.attack_level != effect->u.constant.envelope.attack_level
 252                 || old->u.constant.envelope.fade_length != effect->u.constant.envelope.fade_length
 253                 || old->u.constant.envelope.fade_level != effect->u.constant.envelope.fade_level)
 254                         return 1;
 255                 break;
 256
 257         case FF_PERIODIC:
 258                 if (old->u.periodic.envelope.attack_length != effect->u.periodic.envelope.attack_length
 259                 || old->u.periodic.envelope.attack_level != effect->u.periodic.envelope.attack_level
 260                 || old->u.periodic.envelope.fade_length != effect->u.periodic.envelope.fade_length
 261                 || old->u.periodic.envelope.fade_level != effect->u.periodic.envelope.fade_level)
 262                         return 1;
 263                 break;
 264
 265         default:
 266                 dev_warn(&iforce->dev->dev, "bad effect type in %s\n",
 267                          __func__);
 268         }
 269
 270         return 0;
 271 }
 272
 273 /*
 274  * Analyse the changes in an effect, and tell if we need to send a periodic
 275  * parameter effect
 276  */
 277 static int need_period_modifier(struct iforce *iforce, struct ff_effect *old,
 278                                 struct ff_effect *new)
 279 {
 280         if (new->type != FF_PERIODIC) {
 281                 dev_warn(&iforce->dev->dev, "bad effect type in %s\n",
 282                          __func__);
 283                 return 0;
 284         }
 285         return (old->u.periodic.period != new->u.periodic.period
 286                 || old->u.periodic.magnitude != new->u.periodic.magnitude
 287                 || old->u.periodic.offset != new->u.periodic.offset
 288                 || old->u.periodic.phase != new->u.periodic.phase);
 289 }
 290
 291 /*
 292  * Analyse the changes in an effect, and tell if we need to send an effect
 293  * packet
 294  */
 295 static int need_core(struct ff_effect *old, struct ff_effect *new)
 296 {
 297         if (old->direction != new->direction
 298                 || old->trigger.button != new->trigger.button
 299                 || old->trigger.interval != new->trigger.interval
 300                 || old->replay.length != new->replay.length
 301                 || old->replay.delay != new->replay.delay)
 302                 return 1;
 303
 304         return 0;
 305 }
 306 /*
 307  * Send the part common to all effects to the device
 308  */
 309 static int make_core(struct iforce* iforce, u16 id, u16 mod_id1, u16 mod_id2,
 310         u8 effect_type, u8 axes, u16 duration, u16 delay, u16 button,
 311         u16 interval, u16 direction)
 312 {
 313         unsigned char data[14];
 314
 315         duration = TIME_SCALE(duration);
 316         delay    = TIME_SCALE(delay);
 317         interval = TIME_SCALE(interval);
 318
 319         data[0]  = LO(id);
 320         data[1]  = effect_type;
 321         data[2]  = LO(axes) | find_button(iforce, button);
 322
 323         data[3]  = LO(duration);
 324         data[4]  = HI(duration);
 325
 326         data[5]  = HI(direction);
 327
 328         data[6]  = LO(interval);
 329         data[7]  = HI(interval);
 330
 331         data[8]  = LO(mod_id1);
 332         data[9]  = HI(mod_id1);
 333         data[10] = LO(mod_id2);
 334         data[11] = HI(mod_id2);
 335
 336         data[12] = LO(delay);
 337         data[13] = HI(delay);
 338
 339         /* Stop effect */
 340 /*      iforce_control_playback(iforce, id, 0);*/
 341
 342         iforce_send_packet(iforce, FF_CMD_EFFECT, data);
 343
 344         /* If needed, restart effect */
 345         if (test_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[id].flags)) {
 346                 /* BUG: perhaps we should replay n times, instead of 1. But we do not know n */
 347                 iforce_control_playback(iforce, id, 1);
 348         }
 349
 350         return 0;
 351 }
 352
 353 /*
 354  * Upload a periodic effect to the device
 355  * See also iforce_upload_constant.
 356  */
 357 int iforce_upload_periodic(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
 358 {
 359         u8 wave_code;
 360         int core_id = effect->id;
 361         struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
 362         struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
 363         struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
 364         int param1_err = 1;
 365         int param2_err = 1;
 366         int core_err = 0;
 367
 368         if (!old || need_period_modifier(iforce, old, effect)) {
 369                 param1_err = make_period_modifier(iforce, mod1_chunk,
 370                         old != NULL,
 371                         effect->u.periodic.magnitude, effect->u.periodic.offset,
 372                         effect->u.periodic.period, effect->u.periodic.phase);
 373                 if (param1_err)
 374                         return param1_err;
 375                 set_bit(FF_MOD1_IS_USED, core_effect->flags);
 376         }
 377
 378         if (!old || need_envelope_modifier(iforce, old, effect)) {
 379                 param2_err = make_envelope_modifier(iforce, mod2_chunk,
 380                         old !=NULL,
 381                         effect->u.periodic.envelope.attack_length,
 382                         effect->u.periodic.envelope.attack_level,
 383                         effect->u.periodic.envelope.fade_length,
 384                         effect->u.periodic.envelope.fade_level);
 385                 if (param2_err)
 386                         return param2_err;
 387                 set_bit(FF_MOD2_IS_USED, core_effect->flags);
 388         }
 389
 390         switch (effect->u.periodic.waveform) {
 391                 case FF_SQUARE:         wave_code = 0x20; break;
 392                 case FF_TRIANGLE:       wave_code = 0x21; break;
 393                 case FF_SINE:           wave_code = 0x22; break;
 394                 case FF_SAW_UP:         wave_code = 0x23; break;
 395                 case FF_SAW_DOWN:       wave_code = 0x24; break;
 396                 default:                wave_code = 0x20; break;
 397         }
 398
 399         if (!old || need_core(old, effect)) {
 400                 core_err = make_core(iforce, effect->id,
 401                         mod1_chunk->start,
 402                         mod2_chunk->start,
 403                         wave_code,
 404                         0x20,
 405                         effect->replay.length,
 406                         effect->replay.delay,
 407                         effect->trigger.button,
 408                         effect->trigger.interval,
 409                         effect->direction);
 410         }
 411
 412         /* If one of the parameter creation failed, we already returned an
 413          * error code.
 414          * If the core creation failed, we return its error code.
 415          * Else: if one parameter at least was created, we return 0
 416          *       else we return 1;
 417          */
 418         return core_err < 0 ? core_err : (param1_err && param2_err);
 419 }
 420
 421 /*
 422  * Upload a constant force effect
 423  * Return value:
 424  *  <0 Error code
 425  *  0 Ok, effect created or updated
 426  *  1 effect did not change since last upload, and no packet was therefore sent
 427  */
 428 int iforce_upload_constant(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
 429 {
 430         int core_id = effect->id;
 431         struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
 432         struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
 433         struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
 434         int param1_err = 1;
 435         int param2_err = 1;
 436         int core_err = 0;
 437
 438         if (!old || need_magnitude_modifier(iforce, old, effect)) {
 439                 param1_err = make_magnitude_modifier(iforce, mod1_chunk,
 440                         old != NULL,
 441                         effect->u.constant.level);
 442                 if (param1_err)
 443                         return param1_err;
 444                 set_bit(FF_MOD1_IS_USED, core_effect->flags);
 445         }
 446
 447         if (!old || need_envelope_modifier(iforce, old, effect)) {
 448                 param2_err = make_envelope_modifier(iforce, mod2_chunk,
 449                         old != NULL,
 450                         effect->u.constant.envelope.attack_length,
 451                         effect->u.constant.envelope.attack_level,
 452                         effect->u.constant.envelope.fade_length,
 453                         effect->u.constant.envelope.fade_level);
 454                 if (param2_err)
 455                         return param2_err;
 456                 set_bit(FF_MOD2_IS_USED, core_effect->flags);
 457         }
 458
 459         if (!old || need_core(old, effect)) {
 460                 core_err = make_core(iforce, effect->id,
 461                         mod1_chunk->start,
 462                         mod2_chunk->start,
 463                         0x00,
 464                         0x20,
 465                         effect->replay.length,
 466                         effect->replay.delay,
 467                         effect->trigger.button,
 468                         effect->trigger.interval,
 469                         effect->direction);
 470         }
 471
 472         /* If one of the parameter creation failed, we already returned an
 473          * error code.
 474          * If the core creation failed, we return its error code.
 475          * Else: if one parameter at least was created, we return 0
 476          *       else we return 1;
 477          */
 478         return core_err < 0 ? core_err : (param1_err && param2_err);
 479 }
 480
 481 /*
 482  * Upload an condition effect. Those are for example friction, inertia, springs...
 483  */
 484 int iforce_upload_condition(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
 485 {
 486         int core_id = effect->id;
 487         struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
 488         struct resource* mod1_chunk = &(core_effect->mod1_chunk);
 489         struct resource* mod2_chunk = &(core_effect->mod2_chunk);
 490         u8 type;
 491         int param_err = 1;
 492         int core_err = 0;
 493
 494         switch (effect->type) {
 495                 case FF_SPRING: type = 0x40; break;
 496                 case FF_DAMPER: type = 0x41; break;
 497                 default: return -1;
 498         }
 499
 500         if (!old || need_condition_modifier(iforce, old, effect)) {
 501                 param_err = make_condition_modifier(iforce, mod1_chunk,
 502                         old != NULL,
 503                         effect->u.condition[0].right_saturation,
 504                         effect->u.condition[0].left_saturation,
 505                         effect->u.condition[0].right_coeff,
 506                         effect->u.condition[0].left_coeff,
 507                         effect->u.condition[0].deadband,
 508                         effect->u.condition[0].center);
 509                 if (param_err)
 510                         return param_err;
 511                 set_bit(FF_MOD1_IS_USED, core_effect->flags);
 512
 513                 param_err = make_condition_modifier(iforce, mod2_chunk,
 514                         old != NULL,
 515                         effect->u.condition[1].right_saturation,
 516                         effect->u.condition[1].left_saturation,
 517                         effect->u.condition[1].right_coeff,
 518                         effect->u.condition[1].left_coeff,
 519                         effect->u.condition[1].deadband,
 520                         effect->u.condition[1].center);
 521                 if (param_err)
 522                         return param_err;
 523                 set_bit(FF_MOD2_IS_USED, core_effect->flags);
 524
 525         }
 526
 527         if (!old || need_core(old, effect)) {
 528                 core_err = make_core(iforce, effect->id,
 529                         mod1_chunk->start, mod2_chunk->start,
 530                         type, 0xc0,
 531                         effect->replay.length, effect->replay.delay,
 532                         effect->trigger.button, effect->trigger.interval,
 533                         effect->direction);
 534         }
 535
 536         /* If the parameter creation failed, we already returned an
 537          * error code.
 538          * If the core creation failed, we return its error code.
 539          * Else: if a parameter  was created, we return 0
 540          *       else we return 1;
 541          */
 542         return core_err < 0 ? core_err : param_err;
 543 }