Merge tag 'v4.17-rc6' into next
[muen/linux.git] / drivers / input / ff-core.c
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);