blob: f2a4381d0ab80cf899672defc8779483118b0bca [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Johann Deneux598972d2007-04-12 01:30:24 -04005 * Copyright (c) 2001-2002, 2007 Johann Deneux <johann.deneux@gmail.com>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 *
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
39static 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) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -050045 mutex_lock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 if (allocate_resource(&(iforce->device_memory), mod_chunk, 2,
47 iforce->device_memory.start, iforce->device_memory.end, 2L,
48 NULL, NULL)) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -050049 mutex_unlock(&iforce->mem_mutex);
Anssi Hannulafe65b972006-06-05 00:18:21 -040050 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 }
Ingo Molnar72ba9f02006-02-19 00:22:30 -050052 mutex_unlock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 }
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
69static 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) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -050078 mutex_lock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0c,
80 iforce->device_memory.start, iforce->device_memory.end, 2L,
81 NULL, NULL)) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -050082 mutex_unlock(&iforce->mem_mutex);
Anssi Hannulafe65b972006-06-05 00:18:21 -040083 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -070084 }
Ingo Molnar72ba9f02006-02-19 00:22:30 -050085 mutex_unlock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 }
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
107static 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) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500118 mutex_lock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 if (allocate_resource(&(iforce->device_memory), mod_chunk, 0x0e,
120 iforce->device_memory.start, iforce->device_memory.end, 2L,
121 NULL, NULL)) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500122 mutex_unlock(&iforce->mem_mutex);
Anssi Hannulafe65b972006-06-05 00:18:21 -0400123 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124 }
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500125 mutex_unlock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 }
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
148static 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) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500155 mutex_lock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 if (allocate_resource(&(iforce->device_memory), mod_chunk, 8,
157 iforce->device_memory.start, iforce->device_memory.end, 2L,
158 NULL, NULL)) {
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500159 mutex_unlock(&iforce->mem_mutex);
Anssi Hannulafe65b972006-06-05 00:18:21 -0400160 return -ENOSPC;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 }
Ingo Molnar72ba9f02006-02-19 00:22:30 -0500162 mutex_unlock(&iforce->mem_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163 }
164
165 data[0] = LO(mod_chunk->start);
166 data[1] = HI(mod_chunk->start);
167
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400168 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400171 center = (500 * center) >> 15;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 data[4] = LO(center);
173 data[5] = HI(center);
174
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400175 db = (1000 * db) >> 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700176 data[6] = LO(db);
177 data[7] = HI(db);
178
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400179 data[8] = (100 * rsat) >> 16;
180 data[9] = (100 * lsat) >> 16;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181
182 iforce_send_packet(iforce, FF_CMD_CONDITION, data);
183 iforce_dump_packet("condition", FF_CMD_CONDITION, data);
184
185 return 0;
186}
187
188static unsigned char find_button(struct iforce *iforce, signed short button)
189{
190 int i;
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 for (i = 1; iforce->type->btn[i] >= 0; i++)
193 if (iforce->type->btn[i] == button)
194 return i + 1;
195 return 0;
196}
197
198/*
199 * Analyse the changes in an effect, and tell if we need to send an condition
200 * parameter packet
201 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400202static int need_condition_modifier(struct ff_effect *old, struct ff_effect *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203{
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400204 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 int i;
206
207 if (new->type != FF_SPRING && new->type != FF_FRICTION) {
Johann Deneux598972d2007-04-12 01:30:24 -0400208 warn("bad effect type in need_condition_modifier");
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400209 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210 }
211
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400212 for (i = 0; i < 2; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 ret |= old->u.condition[i].right_saturation != new->u.condition[i].right_saturation
214 || old->u.condition[i].left_saturation != new->u.condition[i].left_saturation
215 || old->u.condition[i].right_coeff != new->u.condition[i].right_coeff
216 || old->u.condition[i].left_coeff != new->u.condition[i].left_coeff
217 || old->u.condition[i].deadband != new->u.condition[i].deadband
218 || old->u.condition[i].center != new->u.condition[i].center;
219 }
220 return ret;
221}
222
223/*
224 * Analyse the changes in an effect, and tell if we need to send a magnitude
225 * parameter packet
226 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400227static int need_magnitude_modifier(struct ff_effect *old, struct ff_effect *effect)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 if (effect->type != FF_CONSTANT) {
Johann Deneux598972d2007-04-12 01:30:24 -0400230 warn("bad effect type in need_envelope_modifier");
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400231 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 }
233
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400234 return old->u.constant.level != effect->u.constant.level;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235}
236
237/*
238 * Analyse the changes in an effect, and tell if we need to send an envelope
239 * parameter packet
240 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400241static int need_envelope_modifier(struct ff_effect *old, struct ff_effect *effect)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 switch (effect->type) {
244 case FF_CONSTANT:
245 if (old->u.constant.envelope.attack_length != effect->u.constant.envelope.attack_length
246 || old->u.constant.envelope.attack_level != effect->u.constant.envelope.attack_level
247 || old->u.constant.envelope.fade_length != effect->u.constant.envelope.fade_length
248 || old->u.constant.envelope.fade_level != effect->u.constant.envelope.fade_level)
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400249 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 break;
251
252 case FF_PERIODIC:
253 if (old->u.periodic.envelope.attack_length != effect->u.periodic.envelope.attack_length
254 || old->u.periodic.envelope.attack_level != effect->u.periodic.envelope.attack_level
255 || old->u.periodic.envelope.fade_length != effect->u.periodic.envelope.fade_length
256 || old->u.periodic.envelope.fade_level != effect->u.periodic.envelope.fade_level)
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400257 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 break;
259
260 default:
Johann Deneux598972d2007-04-12 01:30:24 -0400261 warn("bad effect type in need_envelope_modifier");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262 }
263
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400264 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265}
266
267/*
268 * Analyse the changes in an effect, and tell if we need to send a periodic
269 * parameter effect
270 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400271static int need_period_modifier(struct ff_effect *old, struct ff_effect *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 if (new->type != FF_PERIODIC) {
Johann Deneux598972d2007-04-12 01:30:24 -0400274 warn("bad effect type in need_period_modifier");
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400275 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 return (old->u.periodic.period != new->u.periodic.period
278 || old->u.periodic.magnitude != new->u.periodic.magnitude
279 || old->u.periodic.offset != new->u.periodic.offset
280 || old->u.periodic.phase != new->u.periodic.phase);
281}
282
283/*
284 * Analyse the changes in an effect, and tell if we need to send an effect
285 * packet
286 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400287static int need_core(struct ff_effect *old, struct ff_effect *new)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 if (old->direction != new->direction
290 || old->trigger.button != new->trigger.button
291 || old->trigger.interval != new->trigger.interval
292 || old->replay.length != new->replay.length
293 || old->replay.delay != new->replay.delay)
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400294 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400296 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297}
298/*
299 * Send the part common to all effects to the device
300 */
301static int make_core(struct iforce* iforce, u16 id, u16 mod_id1, u16 mod_id2,
302 u8 effect_type, u8 axes, u16 duration, u16 delay, u16 button,
303 u16 interval, u16 direction)
304{
305 unsigned char data[14];
306
307 duration = TIME_SCALE(duration);
308 delay = TIME_SCALE(delay);
309 interval = TIME_SCALE(interval);
310
311 data[0] = LO(id);
312 data[1] = effect_type;
313 data[2] = LO(axes) | find_button(iforce, button);
314
315 data[3] = LO(duration);
316 data[4] = HI(duration);
317
318 data[5] = HI(direction);
319
320 data[6] = LO(interval);
321 data[7] = HI(interval);
322
323 data[8] = LO(mod_id1);
324 data[9] = HI(mod_id1);
325 data[10] = LO(mod_id2);
326 data[11] = HI(mod_id2);
327
328 data[12] = LO(delay);
329 data[13] = HI(delay);
330
331 /* Stop effect */
332/* iforce_control_playback(iforce, id, 0);*/
333
334 iforce_send_packet(iforce, FF_CMD_EFFECT, data);
335
336 /* If needed, restart effect */
337 if (test_bit(FF_CORE_SHOULD_PLAY, iforce->core_effects[id].flags)) {
338 /* BUG: perhaps we should replay n times, instead of 1. But we do not know n */
339 iforce_control_playback(iforce, id, 1);
340 }
341
342 return 0;
343}
344
345/*
346 * Upload a periodic effect to the device
347 * See also iforce_upload_constant.
348 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400349int iforce_upload_periodic(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350{
351 u8 wave_code;
352 int core_id = effect->id;
353 struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
354 struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
355 struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
356 int param1_err = 1;
357 int param2_err = 1;
358 int core_err = 0;
359
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400360 if (!old || need_period_modifier(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 param1_err = make_period_modifier(iforce, mod1_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400362 old != NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363 effect->u.periodic.magnitude, effect->u.periodic.offset,
364 effect->u.periodic.period, effect->u.periodic.phase);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400365 if (param1_err)
366 return param1_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 set_bit(FF_MOD1_IS_USED, core_effect->flags);
368 }
369
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400370 if (!old || need_envelope_modifier(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 param2_err = make_envelope_modifier(iforce, mod2_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400372 old !=NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373 effect->u.periodic.envelope.attack_length,
374 effect->u.periodic.envelope.attack_level,
375 effect->u.periodic.envelope.fade_length,
376 effect->u.periodic.envelope.fade_level);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400377 if (param2_err)
378 return param2_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 set_bit(FF_MOD2_IS_USED, core_effect->flags);
380 }
381
382 switch (effect->u.periodic.waveform) {
383 case FF_SQUARE: wave_code = 0x20; break;
384 case FF_TRIANGLE: wave_code = 0x21; break;
385 case FF_SINE: wave_code = 0x22; break;
386 case FF_SAW_UP: wave_code = 0x23; break;
387 case FF_SAW_DOWN: wave_code = 0x24; break;
388 default: wave_code = 0x20; break;
389 }
390
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400391 if (!old || need_core(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392 core_err = make_core(iforce, effect->id,
393 mod1_chunk->start,
394 mod2_chunk->start,
395 wave_code,
396 0x20,
397 effect->replay.length,
398 effect->replay.delay,
399 effect->trigger.button,
400 effect->trigger.interval,
401 effect->direction);
402 }
403
404 /* If one of the parameter creation failed, we already returned an
405 * error code.
406 * If the core creation failed, we return its error code.
407 * Else: if one parameter at least was created, we return 0
408 * else we return 1;
409 */
410 return core_err < 0 ? core_err : (param1_err && param2_err);
411}
412
413/*
414 * Upload a constant force effect
415 * Return value:
416 * <0 Error code
417 * 0 Ok, effect created or updated
418 * 1 effect did not change since last upload, and no packet was therefore sent
419 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400420int iforce_upload_constant(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421{
422 int core_id = effect->id;
423 struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
424 struct resource* mod1_chunk = &(iforce->core_effects[core_id].mod1_chunk);
425 struct resource* mod2_chunk = &(iforce->core_effects[core_id].mod2_chunk);
426 int param1_err = 1;
427 int param2_err = 1;
428 int core_err = 0;
429
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400430 if (!old || need_magnitude_modifier(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 param1_err = make_magnitude_modifier(iforce, mod1_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400432 old != NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433 effect->u.constant.level);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400434 if (param1_err)
435 return param1_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 set_bit(FF_MOD1_IS_USED, core_effect->flags);
437 }
438
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400439 if (!old || need_envelope_modifier(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 param2_err = make_envelope_modifier(iforce, mod2_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400441 old != NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442 effect->u.constant.envelope.attack_length,
443 effect->u.constant.envelope.attack_level,
444 effect->u.constant.envelope.fade_length,
445 effect->u.constant.envelope.fade_level);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400446 if (param2_err)
447 return param2_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 set_bit(FF_MOD2_IS_USED, core_effect->flags);
449 }
450
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400451 if (!old || need_core(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 core_err = make_core(iforce, effect->id,
453 mod1_chunk->start,
454 mod2_chunk->start,
455 0x00,
456 0x20,
457 effect->replay.length,
458 effect->replay.delay,
459 effect->trigger.button,
460 effect->trigger.interval,
461 effect->direction);
462 }
463
464 /* If one of the parameter creation failed, we already returned an
465 * error code.
466 * If the core creation failed, we return its error code.
467 * Else: if one parameter at least was created, we return 0
468 * else we return 1;
469 */
470 return core_err < 0 ? core_err : (param1_err && param2_err);
471}
472
473/*
474 * Upload an condition effect. Those are for example friction, inertia, springs...
475 */
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400476int iforce_upload_condition(struct iforce *iforce, struct ff_effect *effect, struct ff_effect *old)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477{
478 int core_id = effect->id;
479 struct iforce_core_effect* core_effect = iforce->core_effects + core_id;
480 struct resource* mod1_chunk = &(core_effect->mod1_chunk);
481 struct resource* mod2_chunk = &(core_effect->mod2_chunk);
482 u8 type;
483 int param_err = 1;
484 int core_err = 0;
485
486 switch (effect->type) {
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400487 case FF_SPRING: type = 0x40; break;
488 case FF_DAMPER: type = 0x41; break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 default: return -1;
490 }
491
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400492 if (!old || need_condition_modifier(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 param_err = make_condition_modifier(iforce, mod1_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400494 old != NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 effect->u.condition[0].right_saturation,
496 effect->u.condition[0].left_saturation,
497 effect->u.condition[0].right_coeff,
498 effect->u.condition[0].left_coeff,
499 effect->u.condition[0].deadband,
500 effect->u.condition[0].center);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400501 if (param_err)
502 return param_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 set_bit(FF_MOD1_IS_USED, core_effect->flags);
504
505 param_err = make_condition_modifier(iforce, mod2_chunk,
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400506 old != NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507 effect->u.condition[1].right_saturation,
508 effect->u.condition[1].left_saturation,
509 effect->u.condition[1].right_coeff,
510 effect->u.condition[1].left_coeff,
511 effect->u.condition[1].deadband,
512 effect->u.condition[1].center);
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400513 if (param_err)
514 return param_err;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 set_bit(FF_MOD2_IS_USED, core_effect->flags);
516
517 }
518
Anssi Hannulaf6a01c82006-07-19 01:40:39 -0400519 if (!old || need_core(old, effect)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 core_err = make_core(iforce, effect->id,
521 mod1_chunk->start, mod2_chunk->start,
522 type, 0xc0,
523 effect->replay.length, effect->replay.delay,
524 effect->trigger.button, effect->trigger.interval,
525 effect->direction);
526 }
527
528 /* If the parameter creation failed, we already returned an
529 * error code.
530 * If the core creation failed, we return its error code.
531 * Else: if a parameter was created, we return 0
532 * else we return 1;
533 */
534 return core_err < 0 ? core_err : param_err;
535}