17d928a2bSAnssi Hannula /* 27d928a2bSAnssi Hannula * Force feedback support for memoryless devices 37d928a2bSAnssi Hannula * 47d928a2bSAnssi Hannula * Copyright (c) 2006 Anssi Hannula <[email protected]> 57d928a2bSAnssi Hannula * Copyright (c) 2006 Dmitry Torokhov <[email protected]> 67d928a2bSAnssi Hannula */ 77d928a2bSAnssi Hannula 87d928a2bSAnssi Hannula /* 97d928a2bSAnssi Hannula * This program is free software; you can redistribute it and/or modify 107d928a2bSAnssi Hannula * it under the terms of the GNU General Public License as published by 117d928a2bSAnssi Hannula * the Free Software Foundation; either version 2 of the License, or 127d928a2bSAnssi Hannula * (at your option) any later version. 137d928a2bSAnssi Hannula * 147d928a2bSAnssi Hannula * This program is distributed in the hope that it will be useful, 157d928a2bSAnssi Hannula * but WITHOUT ANY WARRANTY; without even the implied warranty of 167d928a2bSAnssi Hannula * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 177d928a2bSAnssi Hannula * GNU General Public License for more details. 187d928a2bSAnssi Hannula * 197d928a2bSAnssi Hannula * You should have received a copy of the GNU General Public License 207d928a2bSAnssi Hannula * along with this program; if not, write to the Free Software 217d928a2bSAnssi Hannula * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 227d928a2bSAnssi Hannula */ 237d928a2bSAnssi Hannula 247d928a2bSAnssi Hannula /* #define DEBUG */ 257d928a2bSAnssi Hannula 26da0c4901SJoe Perches #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 277d928a2bSAnssi Hannula 285a0e3ad6STejun Heo #include <linux/slab.h> 297d928a2bSAnssi Hannula #include <linux/input.h> 307d928a2bSAnssi Hannula #include <linux/module.h> 317d928a2bSAnssi Hannula #include <linux/mutex.h> 327d928a2bSAnssi Hannula #include <linux/spinlock.h> 33cd354f1aSTim Schmielau #include <linux/jiffies.h> 34c8e1fb4aSAntonio Ospite #include <linux/fixp-arith.h> 357d928a2bSAnssi Hannula 367d928a2bSAnssi Hannula MODULE_LICENSE("GPL"); 377d928a2bSAnssi Hannula MODULE_AUTHOR("Anssi Hannula <[email protected]>"); 387d928a2bSAnssi Hannula MODULE_DESCRIPTION("Force feedback support for memoryless devices"); 397d928a2bSAnssi Hannula 407d928a2bSAnssi Hannula /* Number of effects handled with memoryless devices */ 417d928a2bSAnssi Hannula #define FF_MEMLESS_EFFECTS 16 427d928a2bSAnssi Hannula 437d928a2bSAnssi Hannula /* Envelope update interval in ms */ 447d928a2bSAnssi Hannula #define FF_ENVELOPE_INTERVAL 50 457d928a2bSAnssi Hannula 467d928a2bSAnssi Hannula #define FF_EFFECT_STARTED 0 477d928a2bSAnssi Hannula #define FF_EFFECT_PLAYING 1 487d928a2bSAnssi Hannula #define FF_EFFECT_ABORTING 2 497d928a2bSAnssi Hannula 507d928a2bSAnssi Hannula struct ml_effect_state { 517d928a2bSAnssi Hannula struct ff_effect *effect; 527d928a2bSAnssi Hannula unsigned long flags; /* effect state (STARTED, PLAYING, etc) */ 537d928a2bSAnssi Hannula int count; /* loop count of the effect */ 547d928a2bSAnssi Hannula unsigned long play_at; /* start time */ 557d928a2bSAnssi Hannula unsigned long stop_at; /* stop time */ 567d928a2bSAnssi Hannula unsigned long adj_at; /* last time the effect was sent */ 577d928a2bSAnssi Hannula }; 587d928a2bSAnssi Hannula 597d928a2bSAnssi Hannula struct ml_device { 607d928a2bSAnssi Hannula void *private; 617d928a2bSAnssi Hannula struct ml_effect_state states[FF_MEMLESS_EFFECTS]; 627d928a2bSAnssi Hannula int gain; 637d928a2bSAnssi Hannula struct timer_list timer; 647d928a2bSAnssi Hannula struct input_dev *dev; 657d928a2bSAnssi Hannula 667d928a2bSAnssi Hannula int (*play_effect)(struct input_dev *dev, void *data, 677d928a2bSAnssi Hannula struct ff_effect *effect); 687d928a2bSAnssi Hannula }; 697d928a2bSAnssi Hannula 707d928a2bSAnssi Hannula static const struct ff_envelope *get_envelope(const struct ff_effect *effect) 717d928a2bSAnssi Hannula { 727d928a2bSAnssi Hannula static const struct ff_envelope empty_envelope; 737d928a2bSAnssi Hannula 747d928a2bSAnssi Hannula switch (effect->type) { 757d928a2bSAnssi Hannula case FF_PERIODIC: 767d928a2bSAnssi Hannula return &effect->u.periodic.envelope; 7741091ad0SBaodong Chen 787d928a2bSAnssi Hannula case FF_CONSTANT: 797d928a2bSAnssi Hannula return &effect->u.constant.envelope; 8041091ad0SBaodong Chen 817d928a2bSAnssi Hannula default: 827d928a2bSAnssi Hannula return &empty_envelope; 837d928a2bSAnssi Hannula } 847d928a2bSAnssi Hannula } 857d928a2bSAnssi Hannula 867d928a2bSAnssi Hannula /* 877d928a2bSAnssi Hannula * Check for the next time envelope requires an update on memoryless devices 887d928a2bSAnssi Hannula */ 897d928a2bSAnssi Hannula static unsigned long calculate_next_time(struct ml_effect_state *state) 907d928a2bSAnssi Hannula { 917d928a2bSAnssi Hannula const struct ff_envelope *envelope = get_envelope(state->effect); 927d928a2bSAnssi Hannula unsigned long attack_stop, fade_start, next_fade; 937d928a2bSAnssi Hannula 947d928a2bSAnssi Hannula if (envelope->attack_length) { 957d928a2bSAnssi Hannula attack_stop = state->play_at + 967d928a2bSAnssi Hannula msecs_to_jiffies(envelope->attack_length); 977d928a2bSAnssi Hannula if (time_before(state->adj_at, attack_stop)) 987d928a2bSAnssi Hannula return state->adj_at + 997d928a2bSAnssi Hannula msecs_to_jiffies(FF_ENVELOPE_INTERVAL); 1007d928a2bSAnssi Hannula } 1017d928a2bSAnssi Hannula 1027d928a2bSAnssi Hannula if (state->effect->replay.length) { 1037d928a2bSAnssi Hannula if (envelope->fade_length) { 1047d928a2bSAnssi Hannula /* check when fading should start */ 1057d928a2bSAnssi Hannula fade_start = state->stop_at - 1067d928a2bSAnssi Hannula msecs_to_jiffies(envelope->fade_length); 1077d928a2bSAnssi Hannula 1087d928a2bSAnssi Hannula if (time_before(state->adj_at, fade_start)) 1097d928a2bSAnssi Hannula return fade_start; 1107d928a2bSAnssi Hannula 1117d928a2bSAnssi Hannula /* already fading, advance to next checkpoint */ 1127d928a2bSAnssi Hannula next_fade = state->adj_at + 1137d928a2bSAnssi Hannula msecs_to_jiffies(FF_ENVELOPE_INTERVAL); 1147d928a2bSAnssi Hannula if (time_before(next_fade, state->stop_at)) 1157d928a2bSAnssi Hannula return next_fade; 1167d928a2bSAnssi Hannula } 1177d928a2bSAnssi Hannula 1187d928a2bSAnssi Hannula return state->stop_at; 1197d928a2bSAnssi Hannula } 1207d928a2bSAnssi Hannula 1217d928a2bSAnssi Hannula return state->play_at; 1227d928a2bSAnssi Hannula } 1237d928a2bSAnssi Hannula 1247d928a2bSAnssi Hannula static void ml_schedule_timer(struct ml_device *ml) 1257d928a2bSAnssi Hannula { 1267d928a2bSAnssi Hannula struct ml_effect_state *state; 1277d928a2bSAnssi Hannula unsigned long now = jiffies; 1287d928a2bSAnssi Hannula unsigned long earliest = 0; 1297d928a2bSAnssi Hannula unsigned long next_at; 1307d928a2bSAnssi Hannula int events = 0; 1317d928a2bSAnssi Hannula int i; 1327d928a2bSAnssi Hannula 133da0c4901SJoe Perches pr_debug("calculating next timer\n"); 1347d928a2bSAnssi Hannula 1357d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) { 1367d928a2bSAnssi Hannula 1377d928a2bSAnssi Hannula state = &ml->states[i]; 1387d928a2bSAnssi Hannula 1397d928a2bSAnssi Hannula if (!test_bit(FF_EFFECT_STARTED, &state->flags)) 1407d928a2bSAnssi Hannula continue; 1417d928a2bSAnssi Hannula 1427d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_PLAYING, &state->flags)) 1437d928a2bSAnssi Hannula next_at = calculate_next_time(state); 1447d928a2bSAnssi Hannula else 1457d928a2bSAnssi Hannula next_at = state->play_at; 1467d928a2bSAnssi Hannula 1477d928a2bSAnssi Hannula if (time_before_eq(now, next_at) && 1487d928a2bSAnssi Hannula (++events == 1 || time_before(next_at, earliest))) 1497d928a2bSAnssi Hannula earliest = next_at; 1507d928a2bSAnssi Hannula } 1517d928a2bSAnssi Hannula 1527d928a2bSAnssi Hannula if (!events) { 153da0c4901SJoe Perches pr_debug("no actions\n"); 1547d928a2bSAnssi Hannula del_timer(&ml->timer); 1557d928a2bSAnssi Hannula } else { 156da0c4901SJoe Perches pr_debug("timer set\n"); 1577d928a2bSAnssi Hannula mod_timer(&ml->timer, earliest); 1587d928a2bSAnssi Hannula } 1597d928a2bSAnssi Hannula } 1607d928a2bSAnssi Hannula 1617d928a2bSAnssi Hannula /* 1627d928a2bSAnssi Hannula * Apply an envelope to a value 1637d928a2bSAnssi Hannula */ 1647d928a2bSAnssi Hannula static int apply_envelope(struct ml_effect_state *state, int value, 1657d928a2bSAnssi Hannula struct ff_envelope *envelope) 1667d928a2bSAnssi Hannula { 1677d928a2bSAnssi Hannula struct ff_effect *effect = state->effect; 1687d928a2bSAnssi Hannula unsigned long now = jiffies; 1697d928a2bSAnssi Hannula int time_from_level; 1707d928a2bSAnssi Hannula int time_of_envelope; 1717d928a2bSAnssi Hannula int envelope_level; 1727d928a2bSAnssi Hannula int difference; 1737d928a2bSAnssi Hannula 1747d928a2bSAnssi Hannula if (envelope->attack_length && 1757d928a2bSAnssi Hannula time_before(now, 1767d928a2bSAnssi Hannula state->play_at + msecs_to_jiffies(envelope->attack_length))) { 177da0c4901SJoe Perches pr_debug("value = 0x%x, attack_level = 0x%x\n", 178da0c4901SJoe Perches value, envelope->attack_level); 1797d928a2bSAnssi Hannula time_from_level = jiffies_to_msecs(now - state->play_at); 1807d928a2bSAnssi Hannula time_of_envelope = envelope->attack_length; 1819a932145SDan Carpenter envelope_level = min_t(u16, envelope->attack_level, 0x7fff); 1827d928a2bSAnssi Hannula 1837d928a2bSAnssi Hannula } else if (envelope->fade_length && effect->replay.length && 1847d928a2bSAnssi Hannula time_after(now, 1857d928a2bSAnssi Hannula state->stop_at - msecs_to_jiffies(envelope->fade_length)) && 1867d928a2bSAnssi Hannula time_before(now, state->stop_at)) { 1877d928a2bSAnssi Hannula time_from_level = jiffies_to_msecs(state->stop_at - now); 1887d928a2bSAnssi Hannula time_of_envelope = envelope->fade_length; 1899a932145SDan Carpenter envelope_level = min_t(u16, envelope->fade_level, 0x7fff); 1907d928a2bSAnssi Hannula } else 1917d928a2bSAnssi Hannula return value; 1927d928a2bSAnssi Hannula 1937d928a2bSAnssi Hannula difference = abs(value) - envelope_level; 1947d928a2bSAnssi Hannula 195da0c4901SJoe Perches pr_debug("difference = %d\n", difference); 196da0c4901SJoe Perches pr_debug("time_from_level = 0x%x\n", time_from_level); 197da0c4901SJoe Perches pr_debug("time_of_envelope = 0x%x\n", time_of_envelope); 1987d928a2bSAnssi Hannula 1997d928a2bSAnssi Hannula difference = difference * time_from_level / time_of_envelope; 2007d928a2bSAnssi Hannula 201da0c4901SJoe Perches pr_debug("difference = %d\n", difference); 2027d928a2bSAnssi Hannula 2037d928a2bSAnssi Hannula return value < 0 ? 2047d928a2bSAnssi Hannula -(difference + envelope_level) : (difference + envelope_level); 2057d928a2bSAnssi Hannula } 2067d928a2bSAnssi Hannula 2077d928a2bSAnssi Hannula /* 2087d928a2bSAnssi Hannula * Return the type the effect has to be converted into (memless devices) 2097d928a2bSAnssi Hannula */ 2107d928a2bSAnssi Hannula static int get_compatible_type(struct ff_device *ff, int effect_type) 2117d928a2bSAnssi Hannula { 2127d928a2bSAnssi Hannula 2137d928a2bSAnssi Hannula if (test_bit(effect_type, ff->ffbit)) 2147d928a2bSAnssi Hannula return effect_type; 2157d928a2bSAnssi Hannula 2167d928a2bSAnssi Hannula if (effect_type == FF_PERIODIC && test_bit(FF_RUMBLE, ff->ffbit)) 2177d928a2bSAnssi Hannula return FF_RUMBLE; 2187d928a2bSAnssi Hannula 219da0c4901SJoe Perches pr_err("invalid type in get_compatible_type()\n"); 2207d928a2bSAnssi Hannula 2217d928a2bSAnssi Hannula return 0; 2227d928a2bSAnssi Hannula } 2237d928a2bSAnssi Hannula 2247d928a2bSAnssi Hannula /* 22594ec26c8SJari Vanhala * Only left/right direction should be used (under/over 0x8000) for 22694ec26c8SJari Vanhala * forward/reverse motor direction (to keep calculation fast & simple). 22794ec26c8SJari Vanhala */ 22894ec26c8SJari Vanhala static u16 ml_calculate_direction(u16 direction, u16 force, 22994ec26c8SJari Vanhala u16 new_direction, u16 new_force) 23094ec26c8SJari Vanhala { 23194ec26c8SJari Vanhala if (!force) 23294ec26c8SJari Vanhala return new_direction; 23394ec26c8SJari Vanhala if (!new_force) 23494ec26c8SJari Vanhala return direction; 23594ec26c8SJari Vanhala return (((u32)(direction >> 1) * force + 23694ec26c8SJari Vanhala (new_direction >> 1) * new_force) / 23794ec26c8SJari Vanhala (force + new_force)) << 1; 23894ec26c8SJari Vanhala } 23994ec26c8SJari Vanhala 240559addc2SMauro Carvalho Chehab #define FRAC_N 8 241559addc2SMauro Carvalho Chehab static inline s16 fixp_new16(s16 a) 242559addc2SMauro Carvalho Chehab { 243559addc2SMauro Carvalho Chehab return ((s32)a) >> (16 - FRAC_N); 244559addc2SMauro Carvalho Chehab } 245559addc2SMauro Carvalho Chehab 246559addc2SMauro Carvalho Chehab static inline s16 fixp_mult(s16 a, s16 b) 247559addc2SMauro Carvalho Chehab { 248559addc2SMauro Carvalho Chehab a = ((s32)a * 0x100) / 0x7fff; 249559addc2SMauro Carvalho Chehab return ((s32)(a * b)) >> FRAC_N; 250559addc2SMauro Carvalho Chehab } 251559addc2SMauro Carvalho Chehab 25294ec26c8SJari Vanhala /* 2537d928a2bSAnssi Hannula * Combine two effects and apply gain. 2547d928a2bSAnssi Hannula */ 2557d928a2bSAnssi Hannula static void ml_combine_effects(struct ff_effect *effect, 2567d928a2bSAnssi Hannula struct ml_effect_state *state, 2571b11c88dSDmitry Torokhov int gain) 2587d928a2bSAnssi Hannula { 2597d928a2bSAnssi Hannula struct ff_effect *new = state->effect; 2607d928a2bSAnssi Hannula unsigned int strong, weak, i; 2617d928a2bSAnssi Hannula int x, y; 262559addc2SMauro Carvalho Chehab s16 level; 2637d928a2bSAnssi Hannula 2647d928a2bSAnssi Hannula switch (new->type) { 2657d928a2bSAnssi Hannula case FF_CONSTANT: 2667d928a2bSAnssi Hannula i = new->direction * 360 / 0xffff; 2677d928a2bSAnssi Hannula level = fixp_new16(apply_envelope(state, 2687d928a2bSAnssi Hannula new->u.constant.level, 2697d928a2bSAnssi Hannula &new->u.constant.envelope)); 270559addc2SMauro Carvalho Chehab x = fixp_mult(fixp_sin16(i), level) * gain / 0xffff; 271559addc2SMauro Carvalho Chehab y = fixp_mult(-fixp_cos16(i), level) * gain / 0xffff; 2727d928a2bSAnssi Hannula /* 2737d928a2bSAnssi Hannula * here we abuse ff_ramp to hold x and y of constant force 2747d928a2bSAnssi Hannula * If in future any driver wants something else than x and y 2757d928a2bSAnssi Hannula * in s8, this should be changed to something more generic 2767d928a2bSAnssi Hannula */ 2777d928a2bSAnssi Hannula effect->u.ramp.start_level = 27892310474SHarvey Harrison clamp_val(effect->u.ramp.start_level + x, -0x80, 0x7f); 2797d928a2bSAnssi Hannula effect->u.ramp.end_level = 28092310474SHarvey Harrison clamp_val(effect->u.ramp.end_level + y, -0x80, 0x7f); 2817d928a2bSAnssi Hannula break; 2827d928a2bSAnssi Hannula 2837d928a2bSAnssi Hannula case FF_RUMBLE: 2841b11c88dSDmitry Torokhov strong = (u32)new->u.rumble.strong_magnitude * gain / 0xffff; 2851b11c88dSDmitry Torokhov weak = (u32)new->u.rumble.weak_magnitude * gain / 0xffff; 28694ec26c8SJari Vanhala 28794ec26c8SJari Vanhala if (effect->u.rumble.strong_magnitude + strong) 28894ec26c8SJari Vanhala effect->direction = ml_calculate_direction( 28994ec26c8SJari Vanhala effect->direction, 29094ec26c8SJari Vanhala effect->u.rumble.strong_magnitude, 29194ec26c8SJari Vanhala new->direction, strong); 29294ec26c8SJari Vanhala else if (effect->u.rumble.weak_magnitude + weak) 29394ec26c8SJari Vanhala effect->direction = ml_calculate_direction( 29494ec26c8SJari Vanhala effect->direction, 29594ec26c8SJari Vanhala effect->u.rumble.weak_magnitude, 29694ec26c8SJari Vanhala new->direction, weak); 29794ec26c8SJari Vanhala else 29894ec26c8SJari Vanhala effect->direction = 0; 2997d928a2bSAnssi Hannula effect->u.rumble.strong_magnitude = 3007d928a2bSAnssi Hannula min(strong + effect->u.rumble.strong_magnitude, 3017d928a2bSAnssi Hannula 0xffffU); 3027d928a2bSAnssi Hannula effect->u.rumble.weak_magnitude = 3037d928a2bSAnssi Hannula min(weak + effect->u.rumble.weak_magnitude, 0xffffU); 3047d928a2bSAnssi Hannula break; 3057d928a2bSAnssi Hannula 3067d928a2bSAnssi Hannula case FF_PERIODIC: 3077d928a2bSAnssi Hannula i = apply_envelope(state, abs(new->u.periodic.magnitude), 3087d928a2bSAnssi Hannula &new->u.periodic.envelope); 3097d928a2bSAnssi Hannula 3107d928a2bSAnssi Hannula /* here we also scale it 0x7fff => 0xffff */ 3117d928a2bSAnssi Hannula i = i * gain / 0x7fff; 3127d928a2bSAnssi Hannula 31394ec26c8SJari Vanhala if (effect->u.rumble.strong_magnitude + i) 31494ec26c8SJari Vanhala effect->direction = ml_calculate_direction( 31594ec26c8SJari Vanhala effect->direction, 31694ec26c8SJari Vanhala effect->u.rumble.strong_magnitude, 31794ec26c8SJari Vanhala new->direction, i); 31894ec26c8SJari Vanhala else 31994ec26c8SJari Vanhala effect->direction = 0; 3207d928a2bSAnssi Hannula effect->u.rumble.strong_magnitude = 3217d928a2bSAnssi Hannula min(i + effect->u.rumble.strong_magnitude, 0xffffU); 3227d928a2bSAnssi Hannula effect->u.rumble.weak_magnitude = 3237d928a2bSAnssi Hannula min(i + effect->u.rumble.weak_magnitude, 0xffffU); 3247d928a2bSAnssi Hannula break; 3257d928a2bSAnssi Hannula 3267d928a2bSAnssi Hannula default: 327da0c4901SJoe Perches pr_err("invalid type in ml_combine_effects()\n"); 3287d928a2bSAnssi Hannula break; 3297d928a2bSAnssi Hannula } 3307d928a2bSAnssi Hannula 3317d928a2bSAnssi Hannula } 3327d928a2bSAnssi Hannula 3337d928a2bSAnssi Hannula 3347d928a2bSAnssi Hannula /* 3357d928a2bSAnssi Hannula * Because memoryless devices have only one effect per effect type active 3367d928a2bSAnssi Hannula * at one time we have to combine multiple effects into one 3377d928a2bSAnssi Hannula */ 3387d928a2bSAnssi Hannula static int ml_get_combo_effect(struct ml_device *ml, 3397d928a2bSAnssi Hannula unsigned long *effect_handled, 3407d928a2bSAnssi Hannula struct ff_effect *combo_effect) 3417d928a2bSAnssi Hannula { 3427d928a2bSAnssi Hannula struct ff_effect *effect; 3437d928a2bSAnssi Hannula struct ml_effect_state *state; 3447d928a2bSAnssi Hannula int effect_type; 3457d928a2bSAnssi Hannula int i; 3467d928a2bSAnssi Hannula 3477d928a2bSAnssi Hannula memset(combo_effect, 0, sizeof(struct ff_effect)); 3487d928a2bSAnssi Hannula 3497d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) { 3507d928a2bSAnssi Hannula if (__test_and_set_bit(i, effect_handled)) 3517d928a2bSAnssi Hannula continue; 3527d928a2bSAnssi Hannula 3537d928a2bSAnssi Hannula state = &ml->states[i]; 3547d928a2bSAnssi Hannula effect = state->effect; 3557d928a2bSAnssi Hannula 3567d928a2bSAnssi Hannula if (!test_bit(FF_EFFECT_STARTED, &state->flags)) 3577d928a2bSAnssi Hannula continue; 3587d928a2bSAnssi Hannula 3597d928a2bSAnssi Hannula if (time_before(jiffies, state->play_at)) 3607d928a2bSAnssi Hannula continue; 3617d928a2bSAnssi Hannula 3627d928a2bSAnssi Hannula /* 3637d928a2bSAnssi Hannula * here we have started effects that are either 3647d928a2bSAnssi Hannula * currently playing (and may need be aborted) 3657d928a2bSAnssi Hannula * or need to start playing. 3667d928a2bSAnssi Hannula */ 3677d928a2bSAnssi Hannula effect_type = get_compatible_type(ml->dev->ff, effect->type); 3687d928a2bSAnssi Hannula if (combo_effect->type != effect_type) { 3697d928a2bSAnssi Hannula if (combo_effect->type != 0) { 3707d928a2bSAnssi Hannula __clear_bit(i, effect_handled); 3717d928a2bSAnssi Hannula continue; 3727d928a2bSAnssi Hannula } 3737d928a2bSAnssi Hannula combo_effect->type = effect_type; 3747d928a2bSAnssi Hannula } 3757d928a2bSAnssi Hannula 3767d928a2bSAnssi Hannula if (__test_and_clear_bit(FF_EFFECT_ABORTING, &state->flags)) { 3777d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 3787d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 3797d928a2bSAnssi Hannula } else if (effect->replay.length && 3807d928a2bSAnssi Hannula time_after_eq(jiffies, state->stop_at)) { 3817d928a2bSAnssi Hannula 3827d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 3837d928a2bSAnssi Hannula 3847d928a2bSAnssi Hannula if (--state->count <= 0) { 3857d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 3867d928a2bSAnssi Hannula } else { 3877d928a2bSAnssi Hannula state->play_at = jiffies + 3887d928a2bSAnssi Hannula msecs_to_jiffies(effect->replay.delay); 3897d928a2bSAnssi Hannula state->stop_at = state->play_at + 3907d928a2bSAnssi Hannula msecs_to_jiffies(effect->replay.length); 3917d928a2bSAnssi Hannula } 3927d928a2bSAnssi Hannula } else { 3937d928a2bSAnssi Hannula __set_bit(FF_EFFECT_PLAYING, &state->flags); 3947d928a2bSAnssi Hannula state->adj_at = jiffies; 3957d928a2bSAnssi Hannula ml_combine_effects(combo_effect, state, ml->gain); 3967d928a2bSAnssi Hannula } 3977d928a2bSAnssi Hannula } 3987d928a2bSAnssi Hannula 3997d928a2bSAnssi Hannula return combo_effect->type != 0; 4007d928a2bSAnssi Hannula } 4017d928a2bSAnssi Hannula 4027d928a2bSAnssi Hannula static void ml_play_effects(struct ml_device *ml) 4037d928a2bSAnssi Hannula { 4047d928a2bSAnssi Hannula struct ff_effect effect; 4057d928a2bSAnssi Hannula DECLARE_BITMAP(handled_bm, FF_MEMLESS_EFFECTS); 4067d928a2bSAnssi Hannula 4077d928a2bSAnssi Hannula memset(handled_bm, 0, sizeof(handled_bm)); 4087d928a2bSAnssi Hannula 4097d928a2bSAnssi Hannula while (ml_get_combo_effect(ml, handled_bm, &effect)) 4107d928a2bSAnssi Hannula ml->play_effect(ml->dev, ml->private, &effect); 4117d928a2bSAnssi Hannula 4127d928a2bSAnssi Hannula ml_schedule_timer(ml); 4137d928a2bSAnssi Hannula } 4147d928a2bSAnssi Hannula 415*34445d4bSKees Cook static void ml_effect_timer(struct timer_list *t) 4167d928a2bSAnssi Hannula { 417*34445d4bSKees Cook struct ml_device *ml = from_timer(ml, t, timer); 418*34445d4bSKees Cook struct input_dev *dev = ml->dev; 419bf3204cbSDmitry Torokhov unsigned long flags; 4207d928a2bSAnssi Hannula 421da0c4901SJoe Perches pr_debug("timer: updating effects\n"); 4227d928a2bSAnssi Hannula 423bf3204cbSDmitry Torokhov spin_lock_irqsave(&dev->event_lock, flags); 4247d928a2bSAnssi Hannula ml_play_effects(ml); 425bf3204cbSDmitry Torokhov spin_unlock_irqrestore(&dev->event_lock, flags); 4267d928a2bSAnssi Hannula } 4277d928a2bSAnssi Hannula 428bf3204cbSDmitry Torokhov /* 429bf3204cbSDmitry Torokhov * Sets requested gain for FF effects. Called with dev->event_lock held. 430bf3204cbSDmitry Torokhov */ 4317d928a2bSAnssi Hannula static void ml_ff_set_gain(struct input_dev *dev, u16 gain) 4327d928a2bSAnssi Hannula { 4337d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 4347d928a2bSAnssi Hannula int i; 4357d928a2bSAnssi Hannula 4367d928a2bSAnssi Hannula ml->gain = gain; 4377d928a2bSAnssi Hannula 4387d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) 4397d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &ml->states[i].flags); 4407d928a2bSAnssi Hannula 4417d928a2bSAnssi Hannula ml_play_effects(ml); 4427d928a2bSAnssi Hannula } 4437d928a2bSAnssi Hannula 444bf3204cbSDmitry Torokhov /* 445bf3204cbSDmitry Torokhov * Start/stop specified FF effect. Called with dev->event_lock held. 446bf3204cbSDmitry Torokhov */ 4477d928a2bSAnssi Hannula static int ml_ff_playback(struct input_dev *dev, int effect_id, int value) 4487d928a2bSAnssi Hannula { 4497d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 4507d928a2bSAnssi Hannula struct ml_effect_state *state = &ml->states[effect_id]; 4517d928a2bSAnssi Hannula 4527d928a2bSAnssi Hannula if (value > 0) { 453da0c4901SJoe Perches pr_debug("initiated play\n"); 4547d928a2bSAnssi Hannula 4557d928a2bSAnssi Hannula __set_bit(FF_EFFECT_STARTED, &state->flags); 4567d928a2bSAnssi Hannula state->count = value; 4577d928a2bSAnssi Hannula state->play_at = jiffies + 4587d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.delay); 4597d928a2bSAnssi Hannula state->stop_at = state->play_at + 4607d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.length); 4617d928a2bSAnssi Hannula state->adj_at = state->play_at; 4627d928a2bSAnssi Hannula 4637d928a2bSAnssi Hannula } else { 464da0c4901SJoe Perches pr_debug("initiated stop\n"); 4657d928a2bSAnssi Hannula 4667d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_PLAYING, &state->flags)) 4677d928a2bSAnssi Hannula __set_bit(FF_EFFECT_ABORTING, &state->flags); 4687d928a2bSAnssi Hannula else 4697d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 47025ae0831SJari Vanhala } 4717d928a2bSAnssi Hannula 4727d928a2bSAnssi Hannula ml_play_effects(ml); 4737d928a2bSAnssi Hannula 4747d928a2bSAnssi Hannula return 0; 4757d928a2bSAnssi Hannula } 4767d928a2bSAnssi Hannula 4777d928a2bSAnssi Hannula static int ml_ff_upload(struct input_dev *dev, 4787d928a2bSAnssi Hannula struct ff_effect *effect, struct ff_effect *old) 4797d928a2bSAnssi Hannula { 4807d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 4817d928a2bSAnssi Hannula struct ml_effect_state *state = &ml->states[effect->id]; 4827d928a2bSAnssi Hannula 483bf3204cbSDmitry Torokhov spin_lock_irq(&dev->event_lock); 4847d928a2bSAnssi Hannula 4857d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_STARTED, &state->flags)) { 4867d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 4877d928a2bSAnssi Hannula state->play_at = jiffies + 4887d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.delay); 4897d928a2bSAnssi Hannula state->stop_at = state->play_at + 4907d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.length); 4917d928a2bSAnssi Hannula state->adj_at = state->play_at; 4927d928a2bSAnssi Hannula ml_schedule_timer(ml); 4937d928a2bSAnssi Hannula } 4947d928a2bSAnssi Hannula 495bf3204cbSDmitry Torokhov spin_unlock_irq(&dev->event_lock); 4967d928a2bSAnssi Hannula 4977d928a2bSAnssi Hannula return 0; 4987d928a2bSAnssi Hannula } 4997d928a2bSAnssi Hannula 5007d928a2bSAnssi Hannula static void ml_ff_destroy(struct ff_device *ff) 5017d928a2bSAnssi Hannula { 5027d928a2bSAnssi Hannula struct ml_device *ml = ff->private; 5037d928a2bSAnssi Hannula 5047d928a2bSAnssi Hannula kfree(ml->private); 5057d928a2bSAnssi Hannula } 5067d928a2bSAnssi Hannula 5077d928a2bSAnssi Hannula /** 508e4477d2dSRandy Dunlap * input_ff_create_memless() - create memoryless force-feedback device 5097d928a2bSAnssi Hannula * @dev: input device supporting force-feedback 5107d928a2bSAnssi Hannula * @data: driver-specific data to be passed into @play_effect 5117d928a2bSAnssi Hannula * @play_effect: driver-specific method for playing FF effect 5127d928a2bSAnssi Hannula */ 5137d928a2bSAnssi Hannula int input_ff_create_memless(struct input_dev *dev, void *data, 5147d928a2bSAnssi Hannula int (*play_effect)(struct input_dev *, void *, struct ff_effect *)) 5157d928a2bSAnssi Hannula { 5167d928a2bSAnssi Hannula struct ml_device *ml; 5177d928a2bSAnssi Hannula struct ff_device *ff; 5187d928a2bSAnssi Hannula int error; 5197d928a2bSAnssi Hannula int i; 5207d928a2bSAnssi Hannula 5217d928a2bSAnssi Hannula ml = kzalloc(sizeof(struct ml_device), GFP_KERNEL); 5227d928a2bSAnssi Hannula if (!ml) 5237d928a2bSAnssi Hannula return -ENOMEM; 5247d928a2bSAnssi Hannula 5257d928a2bSAnssi Hannula ml->dev = dev; 5267d928a2bSAnssi Hannula ml->private = data; 5277d928a2bSAnssi Hannula ml->play_effect = play_effect; 5287d928a2bSAnssi Hannula ml->gain = 0xffff; 529*34445d4bSKees Cook timer_setup(&ml->timer, ml_effect_timer, 0); 5307d928a2bSAnssi Hannula 5317d928a2bSAnssi Hannula set_bit(FF_GAIN, dev->ffbit); 5327d928a2bSAnssi Hannula 5337d928a2bSAnssi Hannula error = input_ff_create(dev, FF_MEMLESS_EFFECTS); 5347d928a2bSAnssi Hannula if (error) { 5357d928a2bSAnssi Hannula kfree(ml); 5367d928a2bSAnssi Hannula return error; 5377d928a2bSAnssi Hannula } 5387d928a2bSAnssi Hannula 5397d928a2bSAnssi Hannula ff = dev->ff; 5407d928a2bSAnssi Hannula ff->private = ml; 5417d928a2bSAnssi Hannula ff->upload = ml_ff_upload; 5427d928a2bSAnssi Hannula ff->playback = ml_ff_playback; 5437d928a2bSAnssi Hannula ff->set_gain = ml_ff_set_gain; 5447d928a2bSAnssi Hannula ff->destroy = ml_ff_destroy; 5457d928a2bSAnssi Hannula 5467d928a2bSAnssi Hannula /* we can emulate periodic effects with RUMBLE */ 5477d928a2bSAnssi Hannula if (test_bit(FF_RUMBLE, ff->ffbit)) { 5487d928a2bSAnssi Hannula set_bit(FF_PERIODIC, dev->ffbit); 5497d928a2bSAnssi Hannula set_bit(FF_SINE, dev->ffbit); 5507d928a2bSAnssi Hannula set_bit(FF_TRIANGLE, dev->ffbit); 5517d928a2bSAnssi Hannula set_bit(FF_SQUARE, dev->ffbit); 5527d928a2bSAnssi Hannula } 5537d928a2bSAnssi Hannula 5547d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) 5557d928a2bSAnssi Hannula ml->states[i].effect = &ff->effects[i]; 5567d928a2bSAnssi Hannula 5577d928a2bSAnssi Hannula return 0; 5587d928a2bSAnssi Hannula } 5597d928a2bSAnssi Hannula EXPORT_SYMBOL_GPL(input_ff_create_memless); 560