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

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