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 } 540