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

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