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