Commit | Line | Data |
---|---|---|
509ca1a9 AH |
1 | /* |
2 | * Force feedback support for Linux input subsystem | |
3 | * | |
4 | * Copyright (c) 2006 Anssi Hannula <anssi.hannula@gmail.com> | |
5 | * Copyright (c) 2006 Dmitry Torokhov <dtor@mail.ru> | |
6 | */ | |
7 | ||
8 | /* | |
9 | * This program is free software; you can redistribute it and/or modify | |
10 | * it under the terms of the GNU General Public License as published by | |
11 | * the Free Software Foundation; either version 2 of the License, or | |
12 | * (at your option) any later version. | |
13 | * | |
14 | * This program is distributed in the hope that it will be useful, | |
15 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 | * GNU General Public License for more details. | |
18 | * | |
19 | * You should have received a copy of the GNU General Public License | |
20 | * along with this program; if not, write to the Free Software | |
21 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
22 | */ | |
23 | ||
24 | /* #define DEBUG */ | |
25 | ||
509ca1a9 AH |
26 | #include <linux/input.h> |
27 | #include <linux/module.h> | |
28 | #include <linux/mutex.h> | |
83680cdb | 29 | #include <linux/sched.h> |
5a0e3ad6 | 30 | #include <linux/slab.h> |
509ca1a9 AH |
31 | |
32 | /* | |
33 | * Check that the effect_id is a valid effect and whether the user | |
34 | * is the owner | |
35 | */ | |
36 | static int check_effect_access(struct ff_device *ff, int effect_id, | |
37 | struct file *file) | |
38 | { | |
39 | if (effect_id < 0 || effect_id >= ff->max_effects || | |
40 | !ff->effect_owners[effect_id]) | |
41 | return -EINVAL; | |
42 | ||
43 | if (file && ff->effect_owners[effect_id] != file) | |
44 | return -EACCES; | |
45 | ||
46 | return 0; | |
47 | } | |
48 | ||
49 | /* | |
50 | * Checks whether 2 effects can be combined together | |
51 | */ | |
52 | static inline int check_effects_compatible(struct ff_effect *e1, | |
53 | struct ff_effect *e2) | |
54 | { | |
55 | return e1->type == e2->type && | |
56 | (e1->type != FF_PERIODIC || | |
57 | e1->u.periodic.waveform == e2->u.periodic.waveform); | |
58 | } | |
59 | ||
60 | /* | |
61 | * Convert an effect into compatible one | |
62 | */ | |
63 | static int compat_effect(struct ff_device *ff, struct ff_effect *effect) | |
64 | { | |
65 | int magnitude; | |
66 | ||
67 | switch (effect->type) { | |
68 | case FF_RUMBLE: | |
69 | if (!test_bit(FF_PERIODIC, ff->ffbit)) | |
70 | return -EINVAL; | |
71 | ||
72 | /* | |
8a4dda79 | 73 | * calculate magnitude of sine wave as average of rumble's |
509ca1a9 AH |
74 | * 2/3 of strong magnitude and 1/3 of weak magnitude |
75 | */ | |
76 | magnitude = effect->u.rumble.strong_magnitude / 3 + | |
77 | effect->u.rumble.weak_magnitude / 6; | |
78 | ||
79 | effect->type = FF_PERIODIC; | |
80 | effect->u.periodic.waveform = FF_SINE; | |
81 | effect->u.periodic.period = 50; | |
82 | effect->u.periodic.magnitude = max(magnitude, 0x7fff); | |
83 | effect->u.periodic.offset = 0; | |
84 | effect->u.periodic.phase = 0; | |
85 | effect->u.periodic.envelope.attack_length = 0; | |
86 | effect->u.periodic.envelope.attack_level = 0; | |
87 | effect->u.periodic.envelope.fade_length = 0; | |
88 | effect->u.periodic.envelope.fade_level = 0; | |
89 | ||
90 | return 0; | |
91 | ||
92 | default: | |
93 | /* Let driver handle conversion */ | |
94 | return 0; | |
95 | } | |
96 | } | |
97 | ||
98 | /** | |
99 | * input_ff_upload() - upload effect into force-feedback device | |
100 | * @dev: input device | |
101 | * @effect: effect to be uploaded | |
102 | * @file: owner of the effect | |
103 | */ | |
104 | int input_ff_upload(struct input_dev *dev, struct ff_effect *effect, | |
105 | struct file *file) | |
106 | { | |
107 | struct ff_device *ff = dev->ff; | |
108 | struct ff_effect *old; | |
109 | int ret = 0; | |
110 | int id; | |
111 | ||
112 | if (!test_bit(EV_FF, dev->evbit)) | |
113 | return -ENOSYS; | |
114 | ||
115 | if (effect->type < FF_EFFECT_MIN || effect->type > FF_EFFECT_MAX || | |
116 | !test_bit(effect->type, dev->ffbit)) { | |
2afebafd | 117 | dev_dbg(&dev->dev, "invalid or not supported effect type in upload\n"); |
509ca1a9 AH |
118 | return -EINVAL; |
119 | } | |
120 | ||
121 | if (effect->type == FF_PERIODIC && | |
122 | (effect->u.periodic.waveform < FF_WAVEFORM_MIN || | |
123 | effect->u.periodic.waveform > FF_WAVEFORM_MAX || | |
124 | !test_bit(effect->u.periodic.waveform, dev->ffbit))) { | |
2afebafd | 125 | dev_dbg(&dev->dev, "invalid or not supported wave form in upload\n"); |
509ca1a9 AH |
126 | return -EINVAL; |
127 | } | |
128 | ||
129 | if (!test_bit(effect->type, ff->ffbit)) { | |
130 | ret = compat_effect(ff, effect); | |
131 | if (ret) | |
132 | return ret; | |
133 | } | |
134 | ||
135 | mutex_lock(&ff->mutex); | |
136 | ||
137 | if (effect->id == -1) { | |
138 | for (id = 0; id < ff->max_effects; id++) | |
41091ad0 BC |
139 | if (!ff->effect_owners[id]) |
140 | break; | |
509ca1a9 AH |
141 | |
142 | if (id >= ff->max_effects) { | |
143 | ret = -ENOSPC; | |
144 | goto out; | |
145 | } | |
146 | ||
147 | effect->id = id; | |
148 | old = NULL; | |
149 | ||
150 | } else { | |
151 | id = effect->id; | |
152 | ||
153 | ret = check_effect_access(ff, id, file); | |
154 | if (ret) | |
155 | goto out; | |
156 | ||
157 | old = &ff->effects[id]; | |
158 | ||
159 | if (!check_effects_compatible(effect, old)) { | |
160 | ret = -EINVAL; | |
161 | goto out; | |
162 | } | |
163 | } | |
164 | ||
165 | ret = ff->upload(dev, effect, old); | |
166 | if (ret) | |
167 | goto out; | |
168 | ||
656acd2b | 169 | spin_lock_irq(&dev->event_lock); |
509ca1a9 AH |
170 | ff->effects[id] = *effect; |
171 | ff->effect_owners[id] = file; | |
656acd2b | 172 | spin_unlock_irq(&dev->event_lock); |
509ca1a9 AH |
173 | |
174 | out: | |
175 | mutex_unlock(&ff->mutex); | |
176 | return ret; | |
177 | } | |
178 | EXPORT_SYMBOL_GPL(input_ff_upload); | |
179 | ||
180 | /* | |
181 | * Erases the effect if the requester is also the effect owner. The mutex | |
182 | * should already be locked before calling this function. | |
183 | */ | |
184 | static int erase_effect(struct input_dev *dev, int effect_id, | |
185 | struct file *file) | |
186 | { | |
187 | struct ff_device *ff = dev->ff; | |
188 | int error; | |
189 | ||
190 | error = check_effect_access(ff, effect_id, file); | |
191 | if (error) | |
192 | return error; | |
193 | ||
656acd2b | 194 | spin_lock_irq(&dev->event_lock); |
509ca1a9 | 195 | ff->playback(dev, effect_id, 0); |
656acd2b DT |
196 | ff->effect_owners[effect_id] = NULL; |
197 | spin_unlock_irq(&dev->event_lock); | |
509ca1a9 AH |
198 | |
199 | if (ff->erase) { | |
200 | error = ff->erase(dev, effect_id); | |
656acd2b DT |
201 | if (error) { |
202 | spin_lock_irq(&dev->event_lock); | |
203 | ff->effect_owners[effect_id] = file; | |
204 | spin_unlock_irq(&dev->event_lock); | |
205 | ||
509ca1a9 | 206 | return error; |
656acd2b | 207 | } |
509ca1a9 AH |
208 | } |
209 | ||
509ca1a9 AH |
210 | return 0; |
211 | } | |
212 | ||
213 | /** | |
e4477d2d | 214 | * input_ff_erase - erase a force-feedback effect from device |
509ca1a9 | 215 | * @dev: input device to erase effect from |
4e3e4629 | 216 | * @effect_id: id of the effect to be erased |
509ca1a9 AH |
217 | * @file: purported owner of the request |
218 | * | |
219 | * This function erases a force-feedback effect from specified device. | |
220 | * The effect will only be erased if it was uploaded through the same | |
221 | * file handle that is requesting erase. | |
222 | */ | |
223 | int input_ff_erase(struct input_dev *dev, int effect_id, struct file *file) | |
224 | { | |
225 | struct ff_device *ff = dev->ff; | |
226 | int ret; | |
227 | ||
228 | if (!test_bit(EV_FF, dev->evbit)) | |
229 | return -ENOSYS; | |
230 | ||
231 | mutex_lock(&ff->mutex); | |
232 | ret = erase_effect(dev, effect_id, file); | |
233 | mutex_unlock(&ff->mutex); | |
234 | ||
235 | return ret; | |
236 | } | |
237 | EXPORT_SYMBOL_GPL(input_ff_erase); | |
238 | ||
239 | /* | |
e8b95728 DT |
240 | * input_ff_flush - erase all effects owned by a file handle |
241 | * @dev: input device to erase effect from | |
242 | * @file: purported owner of the effects | |
243 | * | |
244 | * This function erases all force-feedback effects associated with | |
245 | * the given owner from specified device. Note that @file may be %NULL, | |
246 | * in which case all effects will be erased. | |
509ca1a9 | 247 | */ |
e8b95728 | 248 | int input_ff_flush(struct input_dev *dev, struct file *file) |
509ca1a9 AH |
249 | { |
250 | struct ff_device *ff = dev->ff; | |
251 | int i; | |
252 | ||
2afebafd | 253 | dev_dbg(&dev->dev, "flushing now\n"); |
509ca1a9 AH |
254 | |
255 | mutex_lock(&ff->mutex); | |
256 | ||
257 | for (i = 0; i < ff->max_effects; i++) | |
258 | erase_effect(dev, i, file); | |
259 | ||
260 | mutex_unlock(&ff->mutex); | |
261 | ||
262 | return 0; | |
263 | } | |
e8b95728 | 264 | EXPORT_SYMBOL_GPL(input_ff_flush); |
509ca1a9 AH |
265 | |
266 | /** | |
267 | * input_ff_event() - generic handler for force-feedback events | |
268 | * @dev: input device to send the effect to | |
269 | * @type: event type (anything but EV_FF is ignored) | |
270 | * @code: event code | |
271 | * @value: event value | |
272 | */ | |
273 | int input_ff_event(struct input_dev *dev, unsigned int type, | |
274 | unsigned int code, int value) | |
275 | { | |
276 | struct ff_device *ff = dev->ff; | |
277 | ||
278 | if (type != EV_FF) | |
279 | return 0; | |
280 | ||
509ca1a9 AH |
281 | switch (code) { |
282 | case FF_GAIN: | |
379d7cfa | 283 | if (!test_bit(FF_GAIN, dev->ffbit) || value > 0xffffU) |
509ca1a9 AH |
284 | break; |
285 | ||
286 | ff->set_gain(dev, value); | |
287 | break; | |
288 | ||
289 | case FF_AUTOCENTER: | |
379d7cfa | 290 | if (!test_bit(FF_AUTOCENTER, dev->ffbit) || value > 0xffffU) |
509ca1a9 AH |
291 | break; |
292 | ||
293 | ff->set_autocenter(dev, value); | |
294 | break; | |
295 | ||
296 | default: | |
dec3eb01 DT |
297 | if (check_effect_access(ff, code, NULL) == 0) |
298 | ff->playback(dev, code, value); | |
509ca1a9 AH |
299 | break; |
300 | } | |
301 | ||
509ca1a9 AH |
302 | return 0; |
303 | } | |
304 | EXPORT_SYMBOL_GPL(input_ff_event); | |
305 | ||
306 | /** | |
307 | * input_ff_create() - create force-feedback device | |
308 | * @dev: input device supporting force-feedback | |
309 | * @max_effects: maximum number of effects supported by the device | |
310 | * | |
311 | * This function allocates all necessary memory for a force feedback | |
312 | * portion of an input device and installs all default handlers. | |
313 | * @dev->ffbit should be already set up before calling this function. | |
314 | * Once ff device is created you need to setup its upload, erase, | |
315 | * playback and other handlers before registering input device | |
316 | */ | |
05be8b81 | 317 | int input_ff_create(struct input_dev *dev, unsigned int max_effects) |
509ca1a9 AH |
318 | { |
319 | struct ff_device *ff; | |
05be8b81 | 320 | size_t ff_dev_size; |
509ca1a9 AH |
321 | int i; |
322 | ||
323 | if (!max_effects) { | |
2afebafd | 324 | dev_err(&dev->dev, "cannot allocate device without any effects\n"); |
509ca1a9 AH |
325 | return -EINVAL; |
326 | } | |
327 | ||
33b96d93 EV |
328 | if (max_effects > FF_MAX_EFFECTS) { |
329 | dev_err(&dev->dev, "cannot allocate more than FF_MAX_EFFECTS effects\n"); | |
330 | return -EINVAL; | |
331 | } | |
332 | ||
05be8b81 DC |
333 | ff_dev_size = sizeof(struct ff_device) + |
334 | max_effects * sizeof(struct file *); | |
335 | if (ff_dev_size < max_effects) /* overflow */ | |
336 | return -EINVAL; | |
337 | ||
338 | ff = kzalloc(ff_dev_size, GFP_KERNEL); | |
509ca1a9 AH |
339 | if (!ff) |
340 | return -ENOMEM; | |
341 | ||
342 | ff->effects = kcalloc(max_effects, sizeof(struct ff_effect), | |
343 | GFP_KERNEL); | |
344 | if (!ff->effects) { | |
345 | kfree(ff); | |
346 | return -ENOMEM; | |
347 | } | |
348 | ||
349 | ff->max_effects = max_effects; | |
350 | mutex_init(&ff->mutex); | |
351 | ||
352 | dev->ff = ff; | |
e8b95728 | 353 | dev->flush = input_ff_flush; |
509ca1a9 | 354 | dev->event = input_ff_event; |
bf3204cb | 355 | __set_bit(EV_FF, dev->evbit); |
509ca1a9 AH |
356 | |
357 | /* Copy "true" bits into ff device bitmap */ | |
948cea14 AG |
358 | for_each_set_bit(i, dev->ffbit, FF_CNT) |
359 | __set_bit(i, ff->ffbit); | |
509ca1a9 AH |
360 | |
361 | /* we can emulate RUMBLE with periodic effects */ | |
362 | if (test_bit(FF_PERIODIC, ff->ffbit)) | |
bf3204cb | 363 | __set_bit(FF_RUMBLE, dev->ffbit); |
509ca1a9 AH |
364 | |
365 | return 0; | |
366 | } | |
367 | EXPORT_SYMBOL_GPL(input_ff_create); | |
368 | ||
369 | /** | |
721a730e | 370 | * input_ff_destroy() - frees force feedback portion of input device |
e4477d2d | 371 | * @dev: input device supporting force feedback |
509ca1a9 AH |
372 | * |
373 | * This function is only needed in error path as input core will | |
374 | * automatically free force feedback structures when device is | |
375 | * destroyed. | |
376 | */ | |
377 | void input_ff_destroy(struct input_dev *dev) | |
378 | { | |
bf3204cb DT |
379 | struct ff_device *ff = dev->ff; |
380 | ||
381 | __clear_bit(EV_FF, dev->evbit); | |
382 | if (ff) { | |
383 | if (ff->destroy) | |
384 | ff->destroy(ff); | |
385 | kfree(ff->private); | |
6a47081c | 386 | kfree(ff->effects); |
bf3204cb | 387 | kfree(ff); |
509ca1a9 AH |
388 | dev->ff = NULL; |
389 | } | |
390 | } | |
391 | EXPORT_SYMBOL_GPL(input_ff_destroy); |