1*7d928a2bSAnssi Hannula /* 2*7d928a2bSAnssi Hannula * Force feedback support for memoryless devices 3*7d928a2bSAnssi Hannula * 4*7d928a2bSAnssi Hannula * Copyright (c) 2006 Anssi Hannula <[email protected]> 5*7d928a2bSAnssi Hannula * Copyright (c) 2006 Dmitry Torokhov <[email protected]> 6*7d928a2bSAnssi Hannula */ 7*7d928a2bSAnssi Hannula 8*7d928a2bSAnssi Hannula /* 9*7d928a2bSAnssi Hannula * This program is free software; you can redistribute it and/or modify 10*7d928a2bSAnssi Hannula * it under the terms of the GNU General Public License as published by 11*7d928a2bSAnssi Hannula * the Free Software Foundation; either version 2 of the License, or 12*7d928a2bSAnssi Hannula * (at your option) any later version. 13*7d928a2bSAnssi Hannula * 14*7d928a2bSAnssi Hannula * This program is distributed in the hope that it will be useful, 15*7d928a2bSAnssi Hannula * but WITHOUT ANY WARRANTY; without even the implied warranty of 16*7d928a2bSAnssi Hannula * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17*7d928a2bSAnssi Hannula * GNU General Public License for more details. 18*7d928a2bSAnssi Hannula * 19*7d928a2bSAnssi Hannula * You should have received a copy of the GNU General Public License 20*7d928a2bSAnssi Hannula * along with this program; if not, write to the Free Software 21*7d928a2bSAnssi Hannula * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 22*7d928a2bSAnssi Hannula */ 23*7d928a2bSAnssi Hannula 24*7d928a2bSAnssi Hannula /* #define DEBUG */ 25*7d928a2bSAnssi Hannula 26*7d928a2bSAnssi Hannula #define debug(format, arg...) pr_debug("ff-memless: " format "\n", ## arg) 27*7d928a2bSAnssi Hannula 28*7d928a2bSAnssi Hannula #include <linux/input.h> 29*7d928a2bSAnssi Hannula #include <linux/module.h> 30*7d928a2bSAnssi Hannula #include <linux/mutex.h> 31*7d928a2bSAnssi Hannula #include <linux/spinlock.h> 32*7d928a2bSAnssi Hannula #include <linux/sched.h> 33*7d928a2bSAnssi Hannula 34*7d928a2bSAnssi Hannula #include "fixp-arith.h" 35*7d928a2bSAnssi Hannula 36*7d928a2bSAnssi Hannula MODULE_LICENSE("GPL"); 37*7d928a2bSAnssi Hannula MODULE_AUTHOR("Anssi Hannula <[email protected]>"); 38*7d928a2bSAnssi Hannula MODULE_DESCRIPTION("Force feedback support for memoryless devices"); 39*7d928a2bSAnssi Hannula 40*7d928a2bSAnssi Hannula /* Number of effects handled with memoryless devices */ 41*7d928a2bSAnssi Hannula #define FF_MEMLESS_EFFECTS 16 42*7d928a2bSAnssi Hannula 43*7d928a2bSAnssi Hannula /* Envelope update interval in ms */ 44*7d928a2bSAnssi Hannula #define FF_ENVELOPE_INTERVAL 50 45*7d928a2bSAnssi Hannula 46*7d928a2bSAnssi Hannula #define FF_EFFECT_STARTED 0 47*7d928a2bSAnssi Hannula #define FF_EFFECT_PLAYING 1 48*7d928a2bSAnssi Hannula #define FF_EFFECT_ABORTING 2 49*7d928a2bSAnssi Hannula 50*7d928a2bSAnssi Hannula struct ml_effect_state { 51*7d928a2bSAnssi Hannula struct ff_effect *effect; 52*7d928a2bSAnssi Hannula unsigned long flags; /* effect state (STARTED, PLAYING, etc) */ 53*7d928a2bSAnssi Hannula int count; /* loop count of the effect */ 54*7d928a2bSAnssi Hannula unsigned long play_at; /* start time */ 55*7d928a2bSAnssi Hannula unsigned long stop_at; /* stop time */ 56*7d928a2bSAnssi Hannula unsigned long adj_at; /* last time the effect was sent */ 57*7d928a2bSAnssi Hannula }; 58*7d928a2bSAnssi Hannula 59*7d928a2bSAnssi Hannula struct ml_device { 60*7d928a2bSAnssi Hannula void *private; 61*7d928a2bSAnssi Hannula struct ml_effect_state states[FF_MEMLESS_EFFECTS]; 62*7d928a2bSAnssi Hannula int gain; 63*7d928a2bSAnssi Hannula struct timer_list timer; 64*7d928a2bSAnssi Hannula spinlock_t timer_lock; 65*7d928a2bSAnssi Hannula struct input_dev *dev; 66*7d928a2bSAnssi Hannula 67*7d928a2bSAnssi Hannula int (*play_effect)(struct input_dev *dev, void *data, 68*7d928a2bSAnssi Hannula struct ff_effect *effect); 69*7d928a2bSAnssi Hannula }; 70*7d928a2bSAnssi Hannula 71*7d928a2bSAnssi Hannula static const struct ff_envelope *get_envelope(const struct ff_effect *effect) 72*7d928a2bSAnssi Hannula { 73*7d928a2bSAnssi Hannula static const struct ff_envelope empty_envelope; 74*7d928a2bSAnssi Hannula 75*7d928a2bSAnssi Hannula switch (effect->type) { 76*7d928a2bSAnssi Hannula case FF_PERIODIC: 77*7d928a2bSAnssi Hannula return &effect->u.periodic.envelope; 78*7d928a2bSAnssi Hannula case FF_CONSTANT: 79*7d928a2bSAnssi Hannula return &effect->u.constant.envelope; 80*7d928a2bSAnssi Hannula default: 81*7d928a2bSAnssi Hannula return &empty_envelope; 82*7d928a2bSAnssi Hannula } 83*7d928a2bSAnssi Hannula } 84*7d928a2bSAnssi Hannula 85*7d928a2bSAnssi Hannula /* 86*7d928a2bSAnssi Hannula * Check for the next time envelope requires an update on memoryless devices 87*7d928a2bSAnssi Hannula */ 88*7d928a2bSAnssi Hannula static unsigned long calculate_next_time(struct ml_effect_state *state) 89*7d928a2bSAnssi Hannula { 90*7d928a2bSAnssi Hannula const struct ff_envelope *envelope = get_envelope(state->effect); 91*7d928a2bSAnssi Hannula unsigned long attack_stop, fade_start, next_fade; 92*7d928a2bSAnssi Hannula 93*7d928a2bSAnssi Hannula if (envelope->attack_length) { 94*7d928a2bSAnssi Hannula attack_stop = state->play_at + 95*7d928a2bSAnssi Hannula msecs_to_jiffies(envelope->attack_length); 96*7d928a2bSAnssi Hannula if (time_before(state->adj_at, attack_stop)) 97*7d928a2bSAnssi Hannula return state->adj_at + 98*7d928a2bSAnssi Hannula msecs_to_jiffies(FF_ENVELOPE_INTERVAL); 99*7d928a2bSAnssi Hannula } 100*7d928a2bSAnssi Hannula 101*7d928a2bSAnssi Hannula if (state->effect->replay.length) { 102*7d928a2bSAnssi Hannula if (envelope->fade_length) { 103*7d928a2bSAnssi Hannula /* check when fading should start */ 104*7d928a2bSAnssi Hannula fade_start = state->stop_at - 105*7d928a2bSAnssi Hannula msecs_to_jiffies(envelope->fade_length); 106*7d928a2bSAnssi Hannula 107*7d928a2bSAnssi Hannula if (time_before(state->adj_at, fade_start)) 108*7d928a2bSAnssi Hannula return fade_start; 109*7d928a2bSAnssi Hannula 110*7d928a2bSAnssi Hannula /* already fading, advance to next checkpoint */ 111*7d928a2bSAnssi Hannula next_fade = state->adj_at + 112*7d928a2bSAnssi Hannula msecs_to_jiffies(FF_ENVELOPE_INTERVAL); 113*7d928a2bSAnssi Hannula if (time_before(next_fade, state->stop_at)) 114*7d928a2bSAnssi Hannula return next_fade; 115*7d928a2bSAnssi Hannula } 116*7d928a2bSAnssi Hannula 117*7d928a2bSAnssi Hannula return state->stop_at; 118*7d928a2bSAnssi Hannula } 119*7d928a2bSAnssi Hannula 120*7d928a2bSAnssi Hannula return state->play_at; 121*7d928a2bSAnssi Hannula } 122*7d928a2bSAnssi Hannula 123*7d928a2bSAnssi Hannula static void ml_schedule_timer(struct ml_device *ml) 124*7d928a2bSAnssi Hannula { 125*7d928a2bSAnssi Hannula struct ml_effect_state *state; 126*7d928a2bSAnssi Hannula unsigned long now = jiffies; 127*7d928a2bSAnssi Hannula unsigned long earliest = 0; 128*7d928a2bSAnssi Hannula unsigned long next_at; 129*7d928a2bSAnssi Hannula int events = 0; 130*7d928a2bSAnssi Hannula int i; 131*7d928a2bSAnssi Hannula 132*7d928a2bSAnssi Hannula debug("calculating next timer"); 133*7d928a2bSAnssi Hannula 134*7d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) { 135*7d928a2bSAnssi Hannula 136*7d928a2bSAnssi Hannula state = &ml->states[i]; 137*7d928a2bSAnssi Hannula 138*7d928a2bSAnssi Hannula if (!test_bit(FF_EFFECT_STARTED, &state->flags)) 139*7d928a2bSAnssi Hannula continue; 140*7d928a2bSAnssi Hannula 141*7d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_PLAYING, &state->flags)) 142*7d928a2bSAnssi Hannula next_at = calculate_next_time(state); 143*7d928a2bSAnssi Hannula else 144*7d928a2bSAnssi Hannula next_at = state->play_at; 145*7d928a2bSAnssi Hannula 146*7d928a2bSAnssi Hannula if (time_before_eq(now, next_at) && 147*7d928a2bSAnssi Hannula (++events == 1 || time_before(next_at, earliest))) 148*7d928a2bSAnssi Hannula earliest = next_at; 149*7d928a2bSAnssi Hannula } 150*7d928a2bSAnssi Hannula 151*7d928a2bSAnssi Hannula if (!events) { 152*7d928a2bSAnssi Hannula debug("no actions"); 153*7d928a2bSAnssi Hannula del_timer(&ml->timer); 154*7d928a2bSAnssi Hannula } else { 155*7d928a2bSAnssi Hannula debug("timer set"); 156*7d928a2bSAnssi Hannula mod_timer(&ml->timer, earliest); 157*7d928a2bSAnssi Hannula } 158*7d928a2bSAnssi Hannula } 159*7d928a2bSAnssi Hannula 160*7d928a2bSAnssi Hannula /* 161*7d928a2bSAnssi Hannula * Apply an envelope to a value 162*7d928a2bSAnssi Hannula */ 163*7d928a2bSAnssi Hannula static int apply_envelope(struct ml_effect_state *state, int value, 164*7d928a2bSAnssi Hannula struct ff_envelope *envelope) 165*7d928a2bSAnssi Hannula { 166*7d928a2bSAnssi Hannula struct ff_effect *effect = state->effect; 167*7d928a2bSAnssi Hannula unsigned long now = jiffies; 168*7d928a2bSAnssi Hannula int time_from_level; 169*7d928a2bSAnssi Hannula int time_of_envelope; 170*7d928a2bSAnssi Hannula int envelope_level; 171*7d928a2bSAnssi Hannula int difference; 172*7d928a2bSAnssi Hannula 173*7d928a2bSAnssi Hannula if (envelope->attack_length && 174*7d928a2bSAnssi Hannula time_before(now, 175*7d928a2bSAnssi Hannula state->play_at + msecs_to_jiffies(envelope->attack_length))) { 176*7d928a2bSAnssi Hannula debug("value = 0x%x, attack_level = 0x%x", value, 177*7d928a2bSAnssi Hannula envelope->attack_level); 178*7d928a2bSAnssi Hannula time_from_level = jiffies_to_msecs(now - state->play_at); 179*7d928a2bSAnssi Hannula time_of_envelope = envelope->attack_length; 180*7d928a2bSAnssi Hannula envelope_level = min_t(__s16, envelope->attack_level, 0x7fff); 181*7d928a2bSAnssi Hannula 182*7d928a2bSAnssi Hannula } else if (envelope->fade_length && effect->replay.length && 183*7d928a2bSAnssi Hannula time_after(now, 184*7d928a2bSAnssi Hannula state->stop_at - msecs_to_jiffies(envelope->fade_length)) && 185*7d928a2bSAnssi Hannula time_before(now, state->stop_at)) { 186*7d928a2bSAnssi Hannula time_from_level = jiffies_to_msecs(state->stop_at - now); 187*7d928a2bSAnssi Hannula time_of_envelope = envelope->fade_length; 188*7d928a2bSAnssi Hannula envelope_level = min_t(__s16, envelope->fade_level, 0x7fff); 189*7d928a2bSAnssi Hannula } else 190*7d928a2bSAnssi Hannula return value; 191*7d928a2bSAnssi Hannula 192*7d928a2bSAnssi Hannula difference = abs(value) - envelope_level; 193*7d928a2bSAnssi Hannula 194*7d928a2bSAnssi Hannula debug("difference = %d", difference); 195*7d928a2bSAnssi Hannula debug("time_from_level = 0x%x", time_from_level); 196*7d928a2bSAnssi Hannula debug("time_of_envelope = 0x%x", time_of_envelope); 197*7d928a2bSAnssi Hannula 198*7d928a2bSAnssi Hannula difference = difference * time_from_level / time_of_envelope; 199*7d928a2bSAnssi Hannula 200*7d928a2bSAnssi Hannula debug("difference = %d", difference); 201*7d928a2bSAnssi Hannula 202*7d928a2bSAnssi Hannula return value < 0 ? 203*7d928a2bSAnssi Hannula -(difference + envelope_level) : (difference + envelope_level); 204*7d928a2bSAnssi Hannula } 205*7d928a2bSAnssi Hannula 206*7d928a2bSAnssi Hannula /* 207*7d928a2bSAnssi Hannula * Return the type the effect has to be converted into (memless devices) 208*7d928a2bSAnssi Hannula */ 209*7d928a2bSAnssi Hannula static int get_compatible_type(struct ff_device *ff, int effect_type) 210*7d928a2bSAnssi Hannula { 211*7d928a2bSAnssi Hannula 212*7d928a2bSAnssi Hannula if (test_bit(effect_type, ff->ffbit)) 213*7d928a2bSAnssi Hannula return effect_type; 214*7d928a2bSAnssi Hannula 215*7d928a2bSAnssi Hannula if (effect_type == FF_PERIODIC && test_bit(FF_RUMBLE, ff->ffbit)) 216*7d928a2bSAnssi Hannula return FF_RUMBLE; 217*7d928a2bSAnssi Hannula 218*7d928a2bSAnssi Hannula printk(KERN_ERR 219*7d928a2bSAnssi Hannula "ff-memless: invalid type in get_compatible_type()\n"); 220*7d928a2bSAnssi Hannula 221*7d928a2bSAnssi Hannula return 0; 222*7d928a2bSAnssi Hannula } 223*7d928a2bSAnssi Hannula 224*7d928a2bSAnssi Hannula /* 225*7d928a2bSAnssi Hannula * Combine two effects and apply gain. 226*7d928a2bSAnssi Hannula */ 227*7d928a2bSAnssi Hannula static void ml_combine_effects(struct ff_effect *effect, 228*7d928a2bSAnssi Hannula struct ml_effect_state *state, 229*7d928a2bSAnssi Hannula int gain) 230*7d928a2bSAnssi Hannula { 231*7d928a2bSAnssi Hannula struct ff_effect *new = state->effect; 232*7d928a2bSAnssi Hannula unsigned int strong, weak, i; 233*7d928a2bSAnssi Hannula int x, y; 234*7d928a2bSAnssi Hannula fixp_t level; 235*7d928a2bSAnssi Hannula 236*7d928a2bSAnssi Hannula switch (new->type) { 237*7d928a2bSAnssi Hannula case FF_CONSTANT: 238*7d928a2bSAnssi Hannula i = new->direction * 360 / 0xffff; 239*7d928a2bSAnssi Hannula level = fixp_new16(apply_envelope(state, 240*7d928a2bSAnssi Hannula new->u.constant.level, 241*7d928a2bSAnssi Hannula &new->u.constant.envelope)); 242*7d928a2bSAnssi Hannula x = fixp_mult(fixp_sin(i), level) * gain / 0xffff; 243*7d928a2bSAnssi Hannula y = fixp_mult(-fixp_cos(i), level) * gain / 0xffff; 244*7d928a2bSAnssi Hannula /* 245*7d928a2bSAnssi Hannula * here we abuse ff_ramp to hold x and y of constant force 246*7d928a2bSAnssi Hannula * If in future any driver wants something else than x and y 247*7d928a2bSAnssi Hannula * in s8, this should be changed to something more generic 248*7d928a2bSAnssi Hannula */ 249*7d928a2bSAnssi Hannula effect->u.ramp.start_level = 250*7d928a2bSAnssi Hannula max(min(effect->u.ramp.start_level + x, 0x7f), -0x80); 251*7d928a2bSAnssi Hannula effect->u.ramp.end_level = 252*7d928a2bSAnssi Hannula max(min(effect->u.ramp.end_level + y, 0x7f), -0x80); 253*7d928a2bSAnssi Hannula break; 254*7d928a2bSAnssi Hannula 255*7d928a2bSAnssi Hannula case FF_RUMBLE: 256*7d928a2bSAnssi Hannula strong = new->u.rumble.strong_magnitude * gain / 0xffff; 257*7d928a2bSAnssi Hannula weak = new->u.rumble.weak_magnitude * gain / 0xffff; 258*7d928a2bSAnssi Hannula effect->u.rumble.strong_magnitude = 259*7d928a2bSAnssi Hannula min(strong + effect->u.rumble.strong_magnitude, 260*7d928a2bSAnssi Hannula 0xffffU); 261*7d928a2bSAnssi Hannula effect->u.rumble.weak_magnitude = 262*7d928a2bSAnssi Hannula min(weak + effect->u.rumble.weak_magnitude, 0xffffU); 263*7d928a2bSAnssi Hannula break; 264*7d928a2bSAnssi Hannula 265*7d928a2bSAnssi Hannula case FF_PERIODIC: 266*7d928a2bSAnssi Hannula i = apply_envelope(state, abs(new->u.periodic.magnitude), 267*7d928a2bSAnssi Hannula &new->u.periodic.envelope); 268*7d928a2bSAnssi Hannula 269*7d928a2bSAnssi Hannula /* here we also scale it 0x7fff => 0xffff */ 270*7d928a2bSAnssi Hannula i = i * gain / 0x7fff; 271*7d928a2bSAnssi Hannula 272*7d928a2bSAnssi Hannula effect->u.rumble.strong_magnitude = 273*7d928a2bSAnssi Hannula min(i + effect->u.rumble.strong_magnitude, 0xffffU); 274*7d928a2bSAnssi Hannula effect->u.rumble.weak_magnitude = 275*7d928a2bSAnssi Hannula min(i + effect->u.rumble.weak_magnitude, 0xffffU); 276*7d928a2bSAnssi Hannula break; 277*7d928a2bSAnssi Hannula 278*7d928a2bSAnssi Hannula default: 279*7d928a2bSAnssi Hannula printk(KERN_ERR "ff-memless: invalid type in ml_combine_effects()\n"); 280*7d928a2bSAnssi Hannula break; 281*7d928a2bSAnssi Hannula } 282*7d928a2bSAnssi Hannula 283*7d928a2bSAnssi Hannula } 284*7d928a2bSAnssi Hannula 285*7d928a2bSAnssi Hannula 286*7d928a2bSAnssi Hannula /* 287*7d928a2bSAnssi Hannula * Because memoryless devices have only one effect per effect type active 288*7d928a2bSAnssi Hannula * at one time we have to combine multiple effects into one 289*7d928a2bSAnssi Hannula */ 290*7d928a2bSAnssi Hannula static int ml_get_combo_effect(struct ml_device *ml, 291*7d928a2bSAnssi Hannula unsigned long *effect_handled, 292*7d928a2bSAnssi Hannula struct ff_effect *combo_effect) 293*7d928a2bSAnssi Hannula { 294*7d928a2bSAnssi Hannula struct ff_effect *effect; 295*7d928a2bSAnssi Hannula struct ml_effect_state *state; 296*7d928a2bSAnssi Hannula int effect_type; 297*7d928a2bSAnssi Hannula int i; 298*7d928a2bSAnssi Hannula 299*7d928a2bSAnssi Hannula memset(combo_effect, 0, sizeof(struct ff_effect)); 300*7d928a2bSAnssi Hannula 301*7d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) { 302*7d928a2bSAnssi Hannula if (__test_and_set_bit(i, effect_handled)) 303*7d928a2bSAnssi Hannula continue; 304*7d928a2bSAnssi Hannula 305*7d928a2bSAnssi Hannula state = &ml->states[i]; 306*7d928a2bSAnssi Hannula effect = state->effect; 307*7d928a2bSAnssi Hannula 308*7d928a2bSAnssi Hannula if (!test_bit(FF_EFFECT_STARTED, &state->flags)) 309*7d928a2bSAnssi Hannula continue; 310*7d928a2bSAnssi Hannula 311*7d928a2bSAnssi Hannula if (time_before(jiffies, state->play_at)) 312*7d928a2bSAnssi Hannula continue; 313*7d928a2bSAnssi Hannula 314*7d928a2bSAnssi Hannula /* 315*7d928a2bSAnssi Hannula * here we have started effects that are either 316*7d928a2bSAnssi Hannula * currently playing (and may need be aborted) 317*7d928a2bSAnssi Hannula * or need to start playing. 318*7d928a2bSAnssi Hannula */ 319*7d928a2bSAnssi Hannula effect_type = get_compatible_type(ml->dev->ff, effect->type); 320*7d928a2bSAnssi Hannula if (combo_effect->type != effect_type) { 321*7d928a2bSAnssi Hannula if (combo_effect->type != 0) { 322*7d928a2bSAnssi Hannula __clear_bit(i, effect_handled); 323*7d928a2bSAnssi Hannula continue; 324*7d928a2bSAnssi Hannula } 325*7d928a2bSAnssi Hannula combo_effect->type = effect_type; 326*7d928a2bSAnssi Hannula } 327*7d928a2bSAnssi Hannula 328*7d928a2bSAnssi Hannula if (__test_and_clear_bit(FF_EFFECT_ABORTING, &state->flags)) { 329*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 330*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 331*7d928a2bSAnssi Hannula } else if (effect->replay.length && 332*7d928a2bSAnssi Hannula time_after_eq(jiffies, state->stop_at)) { 333*7d928a2bSAnssi Hannula 334*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 335*7d928a2bSAnssi Hannula 336*7d928a2bSAnssi Hannula if (--state->count <= 0) { 337*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 338*7d928a2bSAnssi Hannula } else { 339*7d928a2bSAnssi Hannula state->play_at = jiffies + 340*7d928a2bSAnssi Hannula msecs_to_jiffies(effect->replay.delay); 341*7d928a2bSAnssi Hannula state->stop_at = state->play_at + 342*7d928a2bSAnssi Hannula msecs_to_jiffies(effect->replay.length); 343*7d928a2bSAnssi Hannula } 344*7d928a2bSAnssi Hannula } else { 345*7d928a2bSAnssi Hannula __set_bit(FF_EFFECT_PLAYING, &state->flags); 346*7d928a2bSAnssi Hannula state->adj_at = jiffies; 347*7d928a2bSAnssi Hannula ml_combine_effects(combo_effect, state, ml->gain); 348*7d928a2bSAnssi Hannula } 349*7d928a2bSAnssi Hannula } 350*7d928a2bSAnssi Hannula 351*7d928a2bSAnssi Hannula return combo_effect->type != 0; 352*7d928a2bSAnssi Hannula } 353*7d928a2bSAnssi Hannula 354*7d928a2bSAnssi Hannula static void ml_play_effects(struct ml_device *ml) 355*7d928a2bSAnssi Hannula { 356*7d928a2bSAnssi Hannula struct ff_effect effect; 357*7d928a2bSAnssi Hannula DECLARE_BITMAP(handled_bm, FF_MEMLESS_EFFECTS); 358*7d928a2bSAnssi Hannula 359*7d928a2bSAnssi Hannula memset(handled_bm, 0, sizeof(handled_bm)); 360*7d928a2bSAnssi Hannula 361*7d928a2bSAnssi Hannula while (ml_get_combo_effect(ml, handled_bm, &effect)) 362*7d928a2bSAnssi Hannula ml->play_effect(ml->dev, ml->private, &effect); 363*7d928a2bSAnssi Hannula 364*7d928a2bSAnssi Hannula ml_schedule_timer(ml); 365*7d928a2bSAnssi Hannula } 366*7d928a2bSAnssi Hannula 367*7d928a2bSAnssi Hannula static void ml_effect_timer(unsigned long timer_data) 368*7d928a2bSAnssi Hannula { 369*7d928a2bSAnssi Hannula struct input_dev *dev = (struct input_dev *)timer_data; 370*7d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 371*7d928a2bSAnssi Hannula 372*7d928a2bSAnssi Hannula debug("timer: updating effects"); 373*7d928a2bSAnssi Hannula 374*7d928a2bSAnssi Hannula spin_lock(&ml->timer_lock); 375*7d928a2bSAnssi Hannula ml_play_effects(ml); 376*7d928a2bSAnssi Hannula spin_unlock(&ml->timer_lock); 377*7d928a2bSAnssi Hannula } 378*7d928a2bSAnssi Hannula 379*7d928a2bSAnssi Hannula static void ml_ff_set_gain(struct input_dev *dev, u16 gain) 380*7d928a2bSAnssi Hannula { 381*7d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 382*7d928a2bSAnssi Hannula int i; 383*7d928a2bSAnssi Hannula 384*7d928a2bSAnssi Hannula spin_lock_bh(&ml->timer_lock); 385*7d928a2bSAnssi Hannula 386*7d928a2bSAnssi Hannula ml->gain = gain; 387*7d928a2bSAnssi Hannula 388*7d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) 389*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &ml->states[i].flags); 390*7d928a2bSAnssi Hannula 391*7d928a2bSAnssi Hannula ml_play_effects(ml); 392*7d928a2bSAnssi Hannula 393*7d928a2bSAnssi Hannula spin_unlock_bh(&ml->timer_lock); 394*7d928a2bSAnssi Hannula } 395*7d928a2bSAnssi Hannula 396*7d928a2bSAnssi Hannula static int ml_ff_playback(struct input_dev *dev, int effect_id, int value) 397*7d928a2bSAnssi Hannula { 398*7d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 399*7d928a2bSAnssi Hannula struct ml_effect_state *state = &ml->states[effect_id]; 400*7d928a2bSAnssi Hannula 401*7d928a2bSAnssi Hannula spin_lock_bh(&ml->timer_lock); 402*7d928a2bSAnssi Hannula 403*7d928a2bSAnssi Hannula if (value > 0) { 404*7d928a2bSAnssi Hannula debug("initiated play"); 405*7d928a2bSAnssi Hannula 406*7d928a2bSAnssi Hannula __set_bit(FF_EFFECT_STARTED, &state->flags); 407*7d928a2bSAnssi Hannula state->count = value; 408*7d928a2bSAnssi Hannula state->play_at = jiffies + 409*7d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.delay); 410*7d928a2bSAnssi Hannula state->stop_at = state->play_at + 411*7d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.length); 412*7d928a2bSAnssi Hannula state->adj_at = state->play_at; 413*7d928a2bSAnssi Hannula 414*7d928a2bSAnssi Hannula ml_schedule_timer(ml); 415*7d928a2bSAnssi Hannula 416*7d928a2bSAnssi Hannula } else { 417*7d928a2bSAnssi Hannula debug("initiated stop"); 418*7d928a2bSAnssi Hannula 419*7d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_PLAYING, &state->flags)) 420*7d928a2bSAnssi Hannula __set_bit(FF_EFFECT_ABORTING, &state->flags); 421*7d928a2bSAnssi Hannula else 422*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_STARTED, &state->flags); 423*7d928a2bSAnssi Hannula 424*7d928a2bSAnssi Hannula ml_play_effects(ml); 425*7d928a2bSAnssi Hannula } 426*7d928a2bSAnssi Hannula 427*7d928a2bSAnssi Hannula spin_unlock_bh(&ml->timer_lock); 428*7d928a2bSAnssi Hannula 429*7d928a2bSAnssi Hannula return 0; 430*7d928a2bSAnssi Hannula } 431*7d928a2bSAnssi Hannula 432*7d928a2bSAnssi Hannula static int ml_ff_upload(struct input_dev *dev, 433*7d928a2bSAnssi Hannula struct ff_effect *effect, struct ff_effect *old) 434*7d928a2bSAnssi Hannula { 435*7d928a2bSAnssi Hannula struct ml_device *ml = dev->ff->private; 436*7d928a2bSAnssi Hannula struct ml_effect_state *state = &ml->states[effect->id]; 437*7d928a2bSAnssi Hannula 438*7d928a2bSAnssi Hannula spin_lock_bh(&ml->timer_lock); 439*7d928a2bSAnssi Hannula 440*7d928a2bSAnssi Hannula if (test_bit(FF_EFFECT_STARTED, &state->flags)) { 441*7d928a2bSAnssi Hannula __clear_bit(FF_EFFECT_PLAYING, &state->flags); 442*7d928a2bSAnssi Hannula state->play_at = jiffies + 443*7d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.delay); 444*7d928a2bSAnssi Hannula state->stop_at = state->play_at + 445*7d928a2bSAnssi Hannula msecs_to_jiffies(state->effect->replay.length); 446*7d928a2bSAnssi Hannula state->adj_at = state->play_at; 447*7d928a2bSAnssi Hannula ml_schedule_timer(ml); 448*7d928a2bSAnssi Hannula } 449*7d928a2bSAnssi Hannula 450*7d928a2bSAnssi Hannula spin_unlock_bh(&ml->timer_lock); 451*7d928a2bSAnssi Hannula 452*7d928a2bSAnssi Hannula return 0; 453*7d928a2bSAnssi Hannula } 454*7d928a2bSAnssi Hannula 455*7d928a2bSAnssi Hannula static void ml_ff_destroy(struct ff_device *ff) 456*7d928a2bSAnssi Hannula { 457*7d928a2bSAnssi Hannula struct ml_device *ml = ff->private; 458*7d928a2bSAnssi Hannula 459*7d928a2bSAnssi Hannula kfree(ml->private); 460*7d928a2bSAnssi Hannula } 461*7d928a2bSAnssi Hannula 462*7d928a2bSAnssi Hannula /** 463*7d928a2bSAnssi Hannula * input_ff_create_memless() - create memoryless FF device 464*7d928a2bSAnssi Hannula * @dev: input device supporting force-feedback 465*7d928a2bSAnssi Hannula * @data: driver-specific data to be passed into @play_effect 466*7d928a2bSAnssi Hannula * @play_effect: driver-specific method for playing FF effect 467*7d928a2bSAnssi Hannula */ 468*7d928a2bSAnssi Hannula int input_ff_create_memless(struct input_dev *dev, void *data, 469*7d928a2bSAnssi Hannula int (*play_effect)(struct input_dev *, void *, struct ff_effect *)) 470*7d928a2bSAnssi Hannula { 471*7d928a2bSAnssi Hannula struct ml_device *ml; 472*7d928a2bSAnssi Hannula struct ff_device *ff; 473*7d928a2bSAnssi Hannula int error; 474*7d928a2bSAnssi Hannula int i; 475*7d928a2bSAnssi Hannula 476*7d928a2bSAnssi Hannula ml = kzalloc(sizeof(struct ml_device), GFP_KERNEL); 477*7d928a2bSAnssi Hannula if (!ml) 478*7d928a2bSAnssi Hannula return -ENOMEM; 479*7d928a2bSAnssi Hannula 480*7d928a2bSAnssi Hannula ml->dev = dev; 481*7d928a2bSAnssi Hannula ml->private = data; 482*7d928a2bSAnssi Hannula ml->play_effect = play_effect; 483*7d928a2bSAnssi Hannula ml->gain = 0xffff; 484*7d928a2bSAnssi Hannula spin_lock_init(&ml->timer_lock); 485*7d928a2bSAnssi Hannula setup_timer(&ml->timer, ml_effect_timer, (unsigned long)dev); 486*7d928a2bSAnssi Hannula 487*7d928a2bSAnssi Hannula set_bit(FF_GAIN, dev->ffbit); 488*7d928a2bSAnssi Hannula 489*7d928a2bSAnssi Hannula error = input_ff_create(dev, FF_MEMLESS_EFFECTS); 490*7d928a2bSAnssi Hannula if (error) { 491*7d928a2bSAnssi Hannula kfree(ml); 492*7d928a2bSAnssi Hannula return error; 493*7d928a2bSAnssi Hannula } 494*7d928a2bSAnssi Hannula 495*7d928a2bSAnssi Hannula ff = dev->ff; 496*7d928a2bSAnssi Hannula ff->private = ml; 497*7d928a2bSAnssi Hannula ff->upload = ml_ff_upload; 498*7d928a2bSAnssi Hannula ff->playback = ml_ff_playback; 499*7d928a2bSAnssi Hannula ff->set_gain = ml_ff_set_gain; 500*7d928a2bSAnssi Hannula ff->destroy = ml_ff_destroy; 501*7d928a2bSAnssi Hannula 502*7d928a2bSAnssi Hannula /* we can emulate periodic effects with RUMBLE */ 503*7d928a2bSAnssi Hannula if (test_bit(FF_RUMBLE, ff->ffbit)) { 504*7d928a2bSAnssi Hannula set_bit(FF_PERIODIC, dev->ffbit); 505*7d928a2bSAnssi Hannula set_bit(FF_SINE, dev->ffbit); 506*7d928a2bSAnssi Hannula set_bit(FF_TRIANGLE, dev->ffbit); 507*7d928a2bSAnssi Hannula set_bit(FF_SQUARE, dev->ffbit); 508*7d928a2bSAnssi Hannula } 509*7d928a2bSAnssi Hannula 510*7d928a2bSAnssi Hannula for (i = 0; i < FF_MEMLESS_EFFECTS; i++) 511*7d928a2bSAnssi Hannula ml->states[i].effect = &ff->effects[i]; 512*7d928a2bSAnssi Hannula 513*7d928a2bSAnssi Hannula return 0; 514*7d928a2bSAnssi Hannula } 515*7d928a2bSAnssi Hannula EXPORT_SYMBOL_GPL(input_ff_create_memless); 516