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