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 | |
26 | #include <linux/input.h> |
27 | #include <linux/module.h> |
28 | #include <linux/mutex.h> |
29 | #include <linux/sched.h> |
30 | #include <linux/slab.h> |
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 | /* |
73 | * calculate magnitude of sine wave as average of rumble's |
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)) { |
117 | dev_dbg(&dev->dev, "invalid or not supported effect type in upload\n" ); |
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))) { |
125 | dev_dbg(&dev->dev, "invalid or not supported wave form in upload\n" ); |
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++) |
139 | if (!ff->effect_owners[id]) |
140 | break; |
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 | |
169 | spin_lock_irq(&dev->event_lock); |
170 | ff->effects[id] = *effect; |
171 | ff->effect_owners[id] = file; |
172 | spin_unlock_irq(&dev->event_lock); |
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 | |
194 | spin_lock_irq(&dev->event_lock); |
195 | ff->playback(dev, effect_id, 0); |
196 | ff->effect_owners[effect_id] = NULL; |
197 | spin_unlock_irq(&dev->event_lock); |
198 | |
199 | if (ff->erase) { |
200 | error = ff->erase(dev, effect_id); |
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 | |
206 | return error; |
207 | } |
208 | } |
209 | |
210 | return 0; |
211 | } |
212 | |
213 | /** |
214 | * input_ff_erase - erase a force-feedback effect from device |
215 | * @dev: input device to erase effect from |
216 | * @effect_id: id of the effect to be erased |
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 | /* |
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. |
247 | */ |
248 | int input_ff_flush(struct input_dev *dev, struct file *file) |
249 | { |
250 | struct ff_device *ff = dev->ff; |
251 | int i; |
252 | |
253 | dev_dbg(&dev->dev, "flushing now\n" ); |
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 | } |
264 | EXPORT_SYMBOL_GPL(input_ff_flush); |
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 | |
281 | switch (code) { |
282 | case FF_GAIN: |
283 | if (!test_bit(FF_GAIN, dev->ffbit) || value > 0xffffU) |
284 | break; |
285 | |
286 | ff->set_gain(dev, value); |
287 | break; |
288 | |
289 | case FF_AUTOCENTER: |
290 | if (!test_bit(FF_AUTOCENTER, dev->ffbit) || value > 0xffffU) |
291 | break; |
292 | |
293 | ff->set_autocenter(dev, value); |
294 | break; |
295 | |
296 | default: |
297 | if (check_effect_access(ff, code, NULL) == 0) |
298 | ff->playback(dev, code, value); |
299 | break; |
300 | } |
301 | |
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 | */ |
317 | int input_ff_create(struct input_dev *dev, unsigned int max_effects) |
318 | { |
319 | struct ff_device *ff; |
320 | size_t ff_dev_size; |
321 | int i; |
322 | |
323 | if (!max_effects) { |
324 | dev_err(&dev->dev, "cannot allocate device without any effects\n" ); |
325 | return -EINVAL; |
326 | } |
327 | |
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 | |
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); |
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; |
353 | dev->flush = input_ff_flush; |
354 | dev->event = input_ff_event; |
355 | __set_bit(EV_FF, dev->evbit); |
356 | |
357 | /* Copy "true" bits into ff device bitmap */ |
358 | for_each_set_bit(i, dev->ffbit, FF_CNT) |
359 | __set_bit(i, ff->ffbit); |
360 | |
361 | /* we can emulate RUMBLE with periodic effects */ |
362 | if (test_bit(FF_PERIODIC, ff->ffbit)) |
363 | __set_bit(FF_RUMBLE, dev->ffbit); |
364 | |
365 | return 0; |
366 | } |
367 | EXPORT_SYMBOL_GPL(input_ff_create); |
368 | |
369 | /** |
370 | * input_ff_destroy() - frees force feedback portion of input device |
371 | * @dev: input device supporting force feedback |
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 | { |
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); |
386 | kfree(ff->effects); |
387 | kfree(ff); |
388 | dev->ff = NULL; |
389 | } |
390 | } |
391 | EXPORT_SYMBOL_GPL(input_ff_destroy); |
392 | |