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