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