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