]> nv-tegra.nvidia Code Review - linux-2.6.git/blob - drivers/input/joystick/iforce/iforce-ff.c
x86: save/restore eflags in context switch
[linux-2.6.git] / 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 -ENOSPC;
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 -ENOSPC;
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 -ENOSPC;
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 -ENOSPC;
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 }