| 1 |
/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */ |
| 2 |
/* |
| 3 |
* Copyright (c) 1999-2002 Vojtech Pavlik |
| 4 |
* |
| 5 |
* This program is free software; you can redistribute it and/or modify it |
| 6 |
* under the terms of the GNU General Public License version 2 as published by |
| 7 |
* the Free Software Foundation. |
| 8 |
*/ |
| 9 |
#ifndef _UAPI_INPUT_H |
| 10 |
#define _UAPI_INPUT_H |
| 11 |
|
| 12 |
|
| 13 |
#ifndef __KERNEL__ |
| 14 |
#include <sys/time.h> |
| 15 |
#include <sys/ioccom.h> |
| 16 |
#include <sys/types.h> |
| 17 |
#endif |
| 18 |
|
| 19 |
#include "input-event-codes.h" |
| 20 |
|
| 21 |
/* |
| 22 |
* The event structure itself |
| 23 |
* Note that __USE_TIME_BITS64 is defined by libc based on |
| 24 |
* application's request to use 64 bit time_t. |
| 25 |
*/ |
| 26 |
|
| 27 |
struct input_event { |
| 28 |
#if 1 /* (__BITS_PER_LONG != 32 || !defined(__USE_TIME_BITS64)) && !defined(__KERNEL) */ |
| 29 |
struct timeval time; |
| 30 |
#define input_event_sec time.tv_sec |
| 31 |
#define input_event_usec time.tv_usec |
| 32 |
#else |
| 33 |
__kernel_ulong_t __sec; |
| 34 |
__kernel_ulong_t __usec; |
| 35 |
#define input_event_sec __sec |
| 36 |
#define input_event_usec __usec |
| 37 |
#endif |
| 38 |
uint16_t type; |
| 39 |
uint16_t code; |
| 40 |
int32_t value; |
| 41 |
}; |
| 42 |
|
| 43 |
/* |
| 44 |
* Protocol version. |
| 45 |
*/ |
| 46 |
|
| 47 |
#define EV_VERSION 0x010001 |
| 48 |
|
| 49 |
/* |
| 50 |
* IOCTLs (0x00 - 0x7f) |
| 51 |
*/ |
| 52 |
|
| 53 |
struct input_id { |
| 54 |
uint16_t bustype; |
| 55 |
uint16_t vendor; |
| 56 |
uint16_t product; |
| 57 |
uint16_t version; |
| 58 |
}; |
| 59 |
|
| 60 |
/** |
| 61 |
* struct input_absinfo - used by EVIOCGABS/EVIOCSABS ioctls |
| 62 |
* @value: latest reported value for the axis. |
| 63 |
* @minimum: specifies minimum value for the axis. |
| 64 |
* @maximum: specifies maximum value for the axis. |
| 65 |
* @fuzz: specifies fuzz value that is used to filter noise from |
| 66 |
* the event stream. |
| 67 |
* @flat: values that are within this value will be discarded by |
| 68 |
* joydev interface and reported as 0 instead. |
| 69 |
* @resolution: specifies resolution for the values reported for |
| 70 |
* the axis. |
| 71 |
* |
| 72 |
* Note that input core does not clamp reported values to the |
| 73 |
* [minimum, maximum] limits, such task is left to userspace. |
| 74 |
* |
| 75 |
* The default resolution for main axes (ABS_X, ABS_Y, ABS_Z) |
| 76 |
* is reported in units per millimeter (units/mm), resolution |
| 77 |
* for rotational axes (ABS_RX, ABS_RY, ABS_RZ) is reported |
| 78 |
* in units per radian. |
| 79 |
* When INPUT_PROP_ACCELEROMETER is set the resolution changes. |
| 80 |
* The main axes (ABS_X, ABS_Y, ABS_Z) are then reported in |
| 81 |
* in units per g (units/g) and in units per degree per second |
| 82 |
* (units/deg/s) for rotational axes (ABS_RX, ABS_RY, ABS_RZ). |
| 83 |
*/ |
| 84 |
struct input_absinfo { |
| 85 |
int32_t value; |
| 86 |
int32_t minimum; |
| 87 |
int32_t maximum; |
| 88 |
int32_t fuzz; |
| 89 |
int32_t flat; |
| 90 |
int32_t resolution; |
| 91 |
}; |
| 92 |
|
| 93 |
/** |
| 94 |
* struct input_keymap_entry - used by EVIOCGKEYCODE/EVIOCSKEYCODE ioctls |
| 95 |
* @scancode: scancode represented in machine-endian form. |
| 96 |
* @len: length of the scancode that resides in @scancode buffer. |
| 97 |
* @index: index in the keymap, may be used instead of scancode |
| 98 |
* @flags: allows to specify how kernel should handle the request. For |
| 99 |
* example, setting INPUT_KEYMAP_BY_INDEX flag indicates that kernel |
| 100 |
* should perform lookup in keymap by @index instead of @scancode |
| 101 |
* @keycode: key code assigned to this scancode |
| 102 |
* |
| 103 |
* The structure is used to retrieve and modify keymap data. Users have |
| 104 |
* option of performing lookup either by @scancode itself or by @index |
| 105 |
* in keymap entry. EVIOCGKEYCODE will also return scancode or index |
| 106 |
* (depending on which element was used to perform lookup). |
| 107 |
*/ |
| 108 |
struct input_keymap_entry { |
| 109 |
#define INPUT_KEYMAP_BY_INDEX (1 << 0) |
| 110 |
uint8_t flags; |
| 111 |
uint8_t len; |
| 112 |
uint16_t index; |
| 113 |
uint32_t keycode; |
| 114 |
uint8_t scancode[32]; |
| 115 |
}; |
| 116 |
|
| 117 |
struct input_mask { |
| 118 |
uint32_t type; |
| 119 |
uint32_t codes_size; |
| 120 |
uint64_t codes_ptr; |
| 121 |
}; |
| 122 |
|
| 123 |
#define EVIOCGVERSION _IOR('E', 0x01, int) /* get driver version */ |
| 124 |
#define EVIOCGID _IOR('E', 0x02, struct input_id) /* get device ID */ |
| 125 |
#define EVIOCGREP _IOR('E', 0x03, unsigned int[2]) /* get repeat settings */ |
| 126 |
#define EVIOCSREP _IOW('E', 0x03, unsigned int[2]) /* set repeat settings */ |
| 127 |
|
| 128 |
#define EVIOCGKEYCODE _IOWR('E', 0x04, unsigned int[2]) /* get keycode */ |
| 129 |
#define EVIOCGKEYCODE_V2 _IOWR('E', 0x04, struct input_keymap_entry) |
| 130 |
#define EVIOCSKEYCODE _IOW('E', 0x04, unsigned int[2]) /* set keycode */ |
| 131 |
#define EVIOCSKEYCODE_V2 _IOW('E', 0x04, struct input_keymap_entry) |
| 132 |
|
| 133 |
#define EVIOCGNAME(len) _IOC(IOC_OUT, 'E', 0x06, len) /* get device name */ |
| 134 |
#define EVIOCGPHYS(len) _IOC(IOC_OUT, 'E', 0x07, len) /* get physical location */ |
| 135 |
#define EVIOCGUNIQ(len) _IOC(IOC_OUT, 'E', 0x08, len) /* get unique identifier */ |
| 136 |
#define EVIOCGPROP(len) _IOC(IOC_OUT, 'E', 0x09, len) /* get device properties */ |
| 137 |
|
| 138 |
/** |
| 139 |
* EVIOCGMTSLOTS(len) - get MT slot values |
| 140 |
* @len: size of the data buffer in bytes |
| 141 |
* |
| 142 |
* The ioctl buffer argument should be binary equivalent to |
| 143 |
* |
| 144 |
* struct input_mt_request_layout { |
| 145 |
* uint32_t code; |
| 146 |
* int32_t values[num_slots]; |
| 147 |
* }; |
| 148 |
* |
| 149 |
* where num_slots is the (arbitrary) number of MT slots to extract. |
| 150 |
* |
| 151 |
* The ioctl size argument (len) is the size of the buffer, which |
| 152 |
* should satisfy len = (num_slots + 1) * sizeof(int32_t). If len is |
| 153 |
* too small to fit all available slots, the first num_slots are |
| 154 |
* returned. |
| 155 |
* |
| 156 |
* Before the call, code is set to the wanted ABS_MT event type. On |
| 157 |
* return, values[] is filled with the slot values for the specified |
| 158 |
* ABS_MT code. |
| 159 |
* |
| 160 |
* If the request code is not an ABS_MT value, -EINVAL is returned. |
| 161 |
*/ |
| 162 |
#define EVIOCGMTSLOTS(len) _IOC(IOC_INOUT, 'E', 0x0a, len) |
| 163 |
|
| 164 |
#define EVIOCGKEY(len) _IOC(IOC_OUT, 'E', 0x18, len) /* get global key state */ |
| 165 |
#define EVIOCGLED(len) _IOC(IOC_OUT, 'E', 0x19, len) /* get all LEDs */ |
| 166 |
#define EVIOCGSND(len) _IOC(IOC_OUT, 'E', 0x1a, len) /* get all sounds status */ |
| 167 |
#define EVIOCGSW(len) _IOC(IOC_OUT, 'E', 0x1b, len) /* get all switch states */ |
| 168 |
|
| 169 |
#define EVIOCGBIT(ev,len) _IOC(IOC_OUT, 'E', 0x20 + (ev), len) /* get event bits */ |
| 170 |
#define EVIOCGABS(abs) _IOR('E', 0x40 + (abs), struct input_absinfo) /* get abs value/limits */ |
| 171 |
#define EVIOCSABS(abs) _IOW('E', 0xc0 + (abs), struct input_absinfo) /* set abs value/limits */ |
| 172 |
|
| 173 |
#define EVIOCSFF _IOW('E', 0x80, struct ff_effect) /* send a force effect to a force feedback device */ |
| 174 |
#define EVIOCRMFF _IOWINT('E', 0x81) /* Erase a force effect */ |
| 175 |
#define EVIOCGEFFECTS _IOR('E', 0x84, int) /* Report number of effects playable at the same time */ |
| 176 |
|
| 177 |
#define EVIOCGRAB _IOWINT('E', 0x90) /* Grab/Release device */ |
| 178 |
#define EVIOCREVOKE _IOWINT('E', 0x91) /* Revoke device access */ |
| 179 |
|
| 180 |
/** |
| 181 |
* EVIOCGMASK - Retrieve current event mask |
| 182 |
* |
| 183 |
* This ioctl allows user to retrieve the current event mask for specific |
| 184 |
* event type. The argument must be of type "struct input_mask" and |
| 185 |
* specifies the event type to query, the address of the receive buffer and |
| 186 |
* the size of the receive buffer. |
| 187 |
* |
| 188 |
* The event mask is a per-client mask that specifies which events are |
| 189 |
* forwarded to the client. Each event code is represented by a single bit |
| 190 |
* in the event mask. If the bit is set, the event is passed to the client |
| 191 |
* normally. Otherwise, the event is filtered and will never be queued on |
| 192 |
* the client's receive buffer. |
| 193 |
* |
| 194 |
* Event masks do not affect global state of the input device. They only |
| 195 |
* affect the file descriptor they are applied to. |
| 196 |
* |
| 197 |
* The default event mask for a client has all bits set, i.e. all events |
| 198 |
* are forwarded to the client. If the kernel is queried for an unknown |
| 199 |
* event type or if the receive buffer is larger than the number of |
| 200 |
* event codes known to the kernel, the kernel returns all zeroes for those |
| 201 |
* codes. |
| 202 |
* |
| 203 |
* At maximum, codes_size bytes are copied. |
| 204 |
* |
| 205 |
* This ioctl may fail with ENODEV in case the file is revoked, EFAULT |
| 206 |
* if the receive-buffer points to invalid memory, or EINVAL if the kernel |
| 207 |
* does not implement the ioctl. |
| 208 |
*/ |
| 209 |
#define EVIOCGMASK _IOW('E', 0x92, struct input_mask) /* Get event-masks */ |
| 210 |
|
| 211 |
/** |
| 212 |
* EVIOCSMASK - Set event mask |
| 213 |
* |
| 214 |
* This ioctl is the counterpart to EVIOCGMASK. Instead of receiving the |
| 215 |
* current event mask, this changes the client's event mask for a specific |
| 216 |
* type. See EVIOCGMASK for a description of event-masks and the |
| 217 |
* argument-type. |
| 218 |
* |
| 219 |
* This ioctl provides full forward compatibility. If the passed event type |
| 220 |
* is unknown to the kernel, or if the number of event codes specified in |
| 221 |
* the mask is bigger than what is known to the kernel, the ioctl is still |
| 222 |
* accepted and applied. However, any unknown codes are left untouched and |
| 223 |
* stay cleared. That means, the kernel always filters unknown codes |
| 224 |
* regardless of what the client requests. If the new mask doesn't cover |
| 225 |
* all known event-codes, all remaining codes are automatically cleared and |
| 226 |
* thus filtered. |
| 227 |
* |
| 228 |
* This ioctl may fail with ENODEV in case the file is revoked. EFAULT is |
| 229 |
* returned if the receive-buffer points to invalid memory. EINVAL is returned |
| 230 |
* if the kernel does not implement the ioctl. |
| 231 |
*/ |
| 232 |
#define EVIOCSMASK _IOW('E', 0x93, struct input_mask) /* Set event-masks */ |
| 233 |
|
| 234 |
#define EVIOCSCLOCKID _IOW('E', 0xa0, int) /* Set clockid to be used for timestamps */ |
| 235 |
|
| 236 |
/* |
| 237 |
* IDs. |
| 238 |
*/ |
| 239 |
|
| 240 |
#define ID_BUS 0 |
| 241 |
#define ID_VENDOR 1 |
| 242 |
#define ID_PRODUCT 2 |
| 243 |
#define ID_VERSION 3 |
| 244 |
|
| 245 |
#define BUS_PCI 0x01 |
| 246 |
#define BUS_ISAPNP 0x02 |
| 247 |
#define BUS_USB 0x03 |
| 248 |
#define BUS_HIL 0x04 |
| 249 |
#define BUS_BLUETOOTH 0x05 |
| 250 |
#define BUS_VIRTUAL 0x06 |
| 251 |
|
| 252 |
#define BUS_ISA 0x10 |
| 253 |
#define BUS_I8042 0x11 |
| 254 |
#define BUS_XTKBD 0x12 |
| 255 |
#define BUS_RS232 0x13 |
| 256 |
#define BUS_GAMEPORT 0x14 |
| 257 |
#define BUS_PARPORT 0x15 |
| 258 |
#define BUS_AMIGA 0x16 |
| 259 |
#define BUS_ADB 0x17 |
| 260 |
#define BUS_I2C 0x18 |
| 261 |
#define BUS_HOST 0x19 |
| 262 |
#define BUS_GSC 0x1A |
| 263 |
#define BUS_ATARI 0x1B |
| 264 |
#define BUS_SPI 0x1C |
| 265 |
#define BUS_RMI 0x1D |
| 266 |
#define BUS_CEC 0x1E |
| 267 |
#define BUS_INTEL_ISHTP 0x1F |
| 268 |
|
| 269 |
/* |
| 270 |
* MT_TOOL types |
| 271 |
*/ |
| 272 |
#define MT_TOOL_FINGER 0x00 |
| 273 |
#define MT_TOOL_PEN 0x01 |
| 274 |
#define MT_TOOL_PALM 0x02 |
| 275 |
#define MT_TOOL_DIAL 0x0a |
| 276 |
#define MT_TOOL_MAX 0x0f |
| 277 |
|
| 278 |
/* |
| 279 |
* Values describing the status of a force-feedback effect |
| 280 |
*/ |
| 281 |
#define FF_STATUS_STOPPED 0x00 |
| 282 |
#define FF_STATUS_PLAYING 0x01 |
| 283 |
#define FF_STATUS_MAX 0x01 |
| 284 |
|
| 285 |
/* |
| 286 |
* Structures used in ioctls to upload effects to a device |
| 287 |
* They are pieces of a bigger structure (called ff_effect) |
| 288 |
*/ |
| 289 |
|
| 290 |
/* |
| 291 |
* All duration values are expressed in ms. Values above 32767 ms (0x7fff) |
| 292 |
* should not be used and have unspecified results. |
| 293 |
*/ |
| 294 |
|
| 295 |
/** |
| 296 |
* struct ff_replay - defines scheduling of the force-feedback effect |
| 297 |
* @length: duration of the effect |
| 298 |
* @delay: delay before effect should start playing |
| 299 |
*/ |
| 300 |
struct ff_replay { |
| 301 |
uint16_t length; |
| 302 |
uint16_t delay; |
| 303 |
}; |
| 304 |
|
| 305 |
/** |
| 306 |
* struct ff_trigger - defines what triggers the force-feedback effect |
| 307 |
* @button: number of the button triggering the effect |
| 308 |
* @interval: controls how soon the effect can be re-triggered |
| 309 |
*/ |
| 310 |
struct ff_trigger { |
| 311 |
uint16_t button; |
| 312 |
uint16_t interval; |
| 313 |
}; |
| 314 |
|
| 315 |
/** |
| 316 |
* struct ff_envelope - generic force-feedback effect envelope |
| 317 |
* @attack_length: duration of the attack (ms) |
| 318 |
* @attack_level: level at the beginning of the attack |
| 319 |
* @fade_length: duration of fade (ms) |
| 320 |
* @fade_level: level at the end of fade |
| 321 |
* |
| 322 |
* The @attack_level and @fade_level are absolute values; when applying |
| 323 |
* envelope force-feedback core will convert to positive/negative |
| 324 |
* value based on polarity of the default level of the effect. |
| 325 |
* Valid range for the attack and fade levels is 0x0000 - 0x7fff |
| 326 |
*/ |
| 327 |
struct ff_envelope { |
| 328 |
uint16_t attack_length; |
| 329 |
uint16_t attack_level; |
| 330 |
uint16_t fade_length; |
| 331 |
uint16_t fade_level; |
| 332 |
}; |
| 333 |
|
| 334 |
/** |
| 335 |
* struct ff_constant_effect - defines parameters of a constant force-feedback effect |
| 336 |
* @level: strength of the effect; may be negative |
| 337 |
* @envelope: envelope data |
| 338 |
*/ |
| 339 |
struct ff_constant_effect { |
| 340 |
int16_t level; |
| 341 |
struct ff_envelope envelope; |
| 342 |
}; |
| 343 |
|
| 344 |
/** |
| 345 |
* struct ff_ramp_effect - defines parameters of a ramp force-feedback effect |
| 346 |
* @start_level: beginning strength of the effect; may be negative |
| 347 |
* @end_level: final strength of the effect; may be negative |
| 348 |
* @envelope: envelope data |
| 349 |
*/ |
| 350 |
struct ff_ramp_effect { |
| 351 |
int16_t start_level; |
| 352 |
int16_t end_level; |
| 353 |
struct ff_envelope envelope; |
| 354 |
}; |
| 355 |
|
| 356 |
/** |
| 357 |
* struct ff_condition_effect - defines a spring or friction force-feedback effect |
| 358 |
* @right_saturation: maximum level when joystick moved all way to the right |
| 359 |
* @left_saturation: same for the left side |
| 360 |
* @right_coeff: controls how fast the force grows when the joystick moves |
| 361 |
* to the right |
| 362 |
* @left_coeff: same for the left side |
| 363 |
* @deadband: size of the dead zone, where no force is produced |
| 364 |
* @center: position of the dead zone |
| 365 |
*/ |
| 366 |
struct ff_condition_effect { |
| 367 |
uint16_t right_saturation; |
| 368 |
uint16_t left_saturation; |
| 369 |
|
| 370 |
int16_t right_coeff; |
| 371 |
int16_t left_coeff; |
| 372 |
|
| 373 |
uint16_t deadband; |
| 374 |
int16_t center; |
| 375 |
}; |
| 376 |
|
| 377 |
/** |
| 378 |
* struct ff_periodic_effect - defines parameters of a periodic force-feedback effect |
| 379 |
* @waveform: kind of the effect (wave) |
| 380 |
* @period: period of the wave (ms) |
| 381 |
* @magnitude: peak value |
| 382 |
* @offset: mean value of the wave (roughly) |
| 383 |
* @phase: 'horizontal' shift |
| 384 |
* @envelope: envelope data |
| 385 |
* @custom_len: number of samples (FF_CUSTOM only) |
| 386 |
* @custom_data: buffer of samples (FF_CUSTOM only) |
| 387 |
* |
| 388 |
* Known waveforms - FF_SQUARE, FF_TRIANGLE, FF_SINE, FF_SAW_UP, |
| 389 |
* FF_SAW_DOWN, FF_CUSTOM. The exact syntax FF_CUSTOM is undefined |
| 390 |
* for the time being as no driver supports it yet. |
| 391 |
* |
| 392 |
* Note: the data pointed by custom_data is copied by the driver. |
| 393 |
* You can therefore dispose of the memory after the upload/update. |
| 394 |
*/ |
| 395 |
struct ff_periodic_effect { |
| 396 |
uint16_t waveform; |
| 397 |
uint16_t period; |
| 398 |
int16_t magnitude; |
| 399 |
int16_t offset; |
| 400 |
uint16_t phase; |
| 401 |
|
| 402 |
struct ff_envelope envelope; |
| 403 |
|
| 404 |
uint32_t custom_len; |
| 405 |
int16_t *custom_data; |
| 406 |
}; |
| 407 |
|
| 408 |
/** |
| 409 |
* struct ff_rumble_effect - defines parameters of a periodic force-feedback effect |
| 410 |
* @strong_magnitude: magnitude of the heavy motor |
| 411 |
* @weak_magnitude: magnitude of the light one |
| 412 |
* |
| 413 |
* Some rumble pads have two motors of different weight. Strong_magnitude |
| 414 |
* represents the magnitude of the vibration generated by the heavy one. |
| 415 |
*/ |
| 416 |
struct ff_rumble_effect { |
| 417 |
uint16_t strong_magnitude; |
| 418 |
uint16_t weak_magnitude; |
| 419 |
}; |
| 420 |
|
| 421 |
/** |
| 422 |
* struct ff_effect - defines force feedback effect |
| 423 |
* @type: type of the effect (FF_CONSTANT, FF_PERIODIC, FF_RAMP, FF_SPRING, |
| 424 |
* FF_FRICTION, FF_DAMPER, FF_RUMBLE, FF_INERTIA, or FF_CUSTOM) |
| 425 |
* @id: an unique id assigned to an effect |
| 426 |
* @direction: direction of the effect |
| 427 |
* @trigger: trigger conditions (struct ff_trigger) |
| 428 |
* @replay: scheduling of the effect (struct ff_replay) |
| 429 |
* @u: effect-specific structure (one of ff_constant_effect, ff_ramp_effect, |
| 430 |
* ff_periodic_effect, ff_condition_effect, ff_rumble_effect) further |
| 431 |
* defining effect parameters |
| 432 |
* |
| 433 |
* This structure is sent through ioctl from the application to the driver. |
| 434 |
* To create a new effect application should set its @id to -1; the kernel |
| 435 |
* will return assigned @id which can later be used to update or delete |
| 436 |
* this effect. |
| 437 |
* |
| 438 |
* Direction of the effect is encoded as follows: |
| 439 |
* 0 deg -> 0x0000 (down) |
| 440 |
* 90 deg -> 0x4000 (left) |
| 441 |
* 180 deg -> 0x8000 (up) |
| 442 |
* 270 deg -> 0xC000 (right) |
| 443 |
*/ |
| 444 |
struct ff_effect { |
| 445 |
uint16_t type; |
| 446 |
int16_t id; |
| 447 |
uint16_t direction; |
| 448 |
struct ff_trigger trigger; |
| 449 |
struct ff_replay replay; |
| 450 |
|
| 451 |
union { |
| 452 |
struct ff_constant_effect constant; |
| 453 |
struct ff_ramp_effect ramp; |
| 454 |
struct ff_periodic_effect periodic; |
| 455 |
struct ff_condition_effect condition[2]; /* One for each axis */ |
| 456 |
struct ff_rumble_effect rumble; |
| 457 |
} u; |
| 458 |
}; |
| 459 |
|
| 460 |
/* |
| 461 |
* Force feedback effect types |
| 462 |
*/ |
| 463 |
|
| 464 |
#define FF_RUMBLE 0x50 |
| 465 |
#define FF_PERIODIC 0x51 |
| 466 |
#define FF_CONSTANT 0x52 |
| 467 |
#define FF_SPRING 0x53 |
| 468 |
#define FF_FRICTION 0x54 |
| 469 |
#define FF_DAMPER 0x55 |
| 470 |
#define FF_INERTIA 0x56 |
| 471 |
#define FF_RAMP 0x57 |
| 472 |
|
| 473 |
#define FF_EFFECT_MIN FF_RUMBLE |
| 474 |
#define FF_EFFECT_MAX FF_RAMP |
| 475 |
|
| 476 |
/* |
| 477 |
* Force feedback periodic effect types |
| 478 |
*/ |
| 479 |
|
| 480 |
#define FF_SQUARE 0x58 |
| 481 |
#define FF_TRIANGLE 0x59 |
| 482 |
#define FF_SINE 0x5a |
| 483 |
#define FF_SAW_UP 0x5b |
| 484 |
#define FF_SAW_DOWN 0x5c |
| 485 |
#define FF_CUSTOM 0x5d |
| 486 |
|
| 487 |
#define FF_WAVEFORM_MIN FF_SQUARE |
| 488 |
#define FF_WAVEFORM_MAX FF_CUSTOM |
| 489 |
|
| 490 |
/* |
| 491 |
* Set ff device properties |
| 492 |
*/ |
| 493 |
|
| 494 |
#define FF_GAIN 0x60 |
| 495 |
#define FF_AUTOCENTER 0x61 |
| 496 |
|
| 497 |
/* |
| 498 |
* ff->playback(effect_id = FF_GAIN) is the first effect_id to |
| 499 |
* cause a collision with another ff method, in this case ff->set_gain(). |
| 500 |
* Therefore the greatest safe value for effect_id is FF_GAIN - 1, |
| 501 |
* and thus the total number of effects should never exceed FF_GAIN. |
| 502 |
*/ |
| 503 |
#define FF_MAX_EFFECTS FF_GAIN |
| 504 |
|
| 505 |
#define FF_MAX 0x7f |
| 506 |
#define FF_CNT (FF_MAX+1) |
| 507 |
|
| 508 |
#endif /* _UAPI_INPUT_H */ |