input.h 18.4 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7
/*
 * Copyright (c) 1999-2002 Vojtech Pavlik
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published by
 * the Free Software Foundation.
 */
8 9
#ifndef _INPUT_H
#define _INPUT_H
Linus Torvalds's avatar
Linus Torvalds committed
10 11 12

#include <linux/time.h>
#include <linux/list.h>
13
#include <uapi/linux/input.h>
14 15
/* Implementation details, userspace should not care about these */
#define ABS_MT_FIRST		ABS_MT_TOUCH_MAJOR
16
#define ABS_MT_LAST		ABS_MT_TOOL_Y
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21

/*
 * In-kernel definitions.
 */

22
#include <linux/device.h>
Linus Torvalds's avatar
Linus Torvalds committed
23 24
#include <linux/fs.h>
#include <linux/timer.h>
25
#include <linux/mod_devicetable.h>
Linus Torvalds's avatar
Linus Torvalds committed
26

27 28 29 30 31 32 33 34 35 36 37 38
/**
 * struct input_value - input value representation
 * @type: type of value (EV_KEY, EV_ABS, etc)
 * @code: the value code
 * @value: the value
 */
struct input_value {
	__u16 type;
	__u16 code;
	__s32 value;
};

39 40 41 42 43 44
/**
 * struct input_dev - represents an input device
 * @name: name of the device
 * @phys: physical path to the device in the system hierarchy
 * @uniq: unique identification code for the device (if device has it)
 * @id: id of the device (struct input_id)
45
 * @propbit: bitmap of device properties and quirks
46 47 48 49 50 51 52 53 54 55
 * @evbit: bitmap of types of events supported by the device (EV_KEY,
 *	EV_REL, etc.)
 * @keybit: bitmap of keys/buttons this device has
 * @relbit: bitmap of relative axes for the device
 * @absbit: bitmap of absolute axes for the device
 * @mscbit: bitmap of miscellaneous events supported by the device
 * @ledbit: bitmap of leds present on the device
 * @sndbit: bitmap of sound effects supported by the device
 * @ffbit: bitmap of force feedback effects supported by the device
 * @swbit: bitmap of switches present on the device
56 57 58 59
 * @hint_events_per_packet: average number of events generated by the
 *	device in a packet (between EV_SYN/SYN_REPORT events). Used by
 *	event handlers to estimate size of the buffer needed to hold
 *	events.
60 61 62
 * @keycodemax: size of keycode table
 * @keycodesize: size of elements in keycode table
 * @keycode: map of scancodes to keycodes for this device
63
 * @getkeycode: optional legacy method to retrieve current keymap.
64
 * @setkeycode: optional method to alter current keymap, used to implement
65 66 67
 *	sparse keymaps. If not supplied default mechanism will be used.
 *	The method is being called while holding event_lock and thus must
 *	not sleep
68 69 70 71 72 73
 * @ff: force feedback structure associated with the device if device
 *	supports force feedback effects
 * @repeat_key: stores key code of the last key pressed; used to implement
 *	software autorepeat
 * @timer: timer for software autorepeat
 * @rep: current values for autorepeat parameters (delay, rate)
74
 * @mt: pointer to multitouch state
75
 * @absinfo: array of &struct input_absinfo elements holding information
76 77
 *	about absolute axes (current value, min, max, flat, fuzz,
 *	resolution)
78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
 * @key: reflects current state of device's keys/buttons
 * @led: reflects current state of device's LEDs
 * @snd: reflects current state of sound effects
 * @sw: reflects current state of device's switches
 * @open: this method is called when the very first user calls
 *	input_open_device(). The driver must prepare the device
 *	to start generating events (start polling thread,
 *	request an IRQ, submit URB, etc.)
 * @close: this method is called when the very last user calls
 *	input_close_device().
 * @flush: purges the device. Most commonly used to get rid of force
 *	feedback effects loaded into the device when disconnecting
 *	from it
 * @event: event handler for events sent _to_ the device, like EV_LED
 *	or EV_SND. The device is expected to carry out the requested
 *	action (turn on a LED, play sound, etc.) The call is protected
 *	by @event_lock and must not sleep
 * @grab: input handle that currently has the device grabbed (via
 *	EVIOCGRAB ioctl). When a handle grabs a device it becomes sole
 *	recipient for all input events coming from the device
98
 * @event_lock: this spinlock is taken when input core receives
99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114
 *	and processes a new event for the device (in input_event()).
 *	Code that accesses and/or modifies parameters of a device
 *	(such as keymap or absmin, absmax, absfuzz, etc.) after device
 *	has been registered with input core must take this lock.
 * @mutex: serializes calls to open(), close() and flush() methods
 * @users: stores number of users (input handlers) that opened this
 *	device. It is used by input_open_device() and input_close_device()
 *	to make sure that dev->open() is only called when the first
 *	user opens device and dev->close() is called when the very
 *	last user closes the device
 * @going_away: marks devices that are in a middle of unregistering and
 *	causes input_open_device*() fail with -ENODEV.
 * @dev: driver model's view of this device
 * @h_list: list of input handles associated with the device. When
 *	accessing the list dev->mutex must be held
 * @node: used to place the device onto input_dev_list
115 116 117
 * @num_vals: number of values queued in the current frame
 * @max_vals: maximum number of values queued in a frame
 * @vals: array of values queued in the current frame
118 119
 * @devres_managed: indicates that devices is managed with devres framework
 *	and needs not be explicitly unregistered or freed.
120
 */
Linus Torvalds's avatar
Linus Torvalds committed
121
struct input_dev {
122 123 124
	const char *name;
	const char *phys;
	const char *uniq;
Linus Torvalds's avatar
Linus Torvalds committed
125 126
	struct input_id id;

127 128
	unsigned long propbit[BITS_TO_LONGS(INPUT_PROP_CNT)];

129 130 131 132 133 134 135 136 137
	unsigned long evbit[BITS_TO_LONGS(EV_CNT)];
	unsigned long keybit[BITS_TO_LONGS(KEY_CNT)];
	unsigned long relbit[BITS_TO_LONGS(REL_CNT)];
	unsigned long absbit[BITS_TO_LONGS(ABS_CNT)];
	unsigned long mscbit[BITS_TO_LONGS(MSC_CNT)];
	unsigned long ledbit[BITS_TO_LONGS(LED_CNT)];
	unsigned long sndbit[BITS_TO_LONGS(SND_CNT)];
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
	unsigned long swbit[BITS_TO_LONGS(SW_CNT)];
Linus Torvalds's avatar
Linus Torvalds committed
138

139 140
	unsigned int hint_events_per_packet;

Linus Torvalds's avatar
Linus Torvalds committed
141 142 143
	unsigned int keycodemax;
	unsigned int keycodesize;
	void *keycode;
144

145
	int (*setkeycode)(struct input_dev *dev,
146 147
			  const struct input_keymap_entry *ke,
			  unsigned int *old_keycode);
148
	int (*getkeycode)(struct input_dev *dev,
149
			  struct input_keymap_entry *ke);
Linus Torvalds's avatar
Linus Torvalds committed
150

151 152
	struct ff_device *ff;

Linus Torvalds's avatar
Linus Torvalds committed
153 154 155
	unsigned int repeat_key;
	struct timer_list timer;

156
	int rep[REP_CNT];
Linus Torvalds's avatar
Linus Torvalds committed
157

158
	struct input_mt *mt;
159

160 161
	struct input_absinfo *absinfo;

162 163 164 165
	unsigned long key[BITS_TO_LONGS(KEY_CNT)];
	unsigned long led[BITS_TO_LONGS(LED_CNT)];
	unsigned long snd[BITS_TO_LONGS(SND_CNT)];
	unsigned long sw[BITS_TO_LONGS(SW_CNT)];
Linus Torvalds's avatar
Linus Torvalds committed
166 167 168 169 170 171

	int (*open)(struct input_dev *dev);
	void (*close)(struct input_dev *dev);
	int (*flush)(struct input_dev *dev, struct file *file);
	int (*event)(struct input_dev *dev, unsigned int type, unsigned int code, int value);

Arnd Bergmann's avatar
Arnd Bergmann committed
172
	struct input_handle __rcu *grab;
173

174 175 176
	spinlock_t event_lock;
	struct mutex mutex;

177
	unsigned int users;
178
	bool going_away;
179

180
	struct device dev;
Linus Torvalds's avatar
Linus Torvalds committed
181 182 183

	struct list_head	h_list;
	struct list_head	node;
184 185 186 187

	unsigned int num_vals;
	unsigned int max_vals;
	struct input_value *vals;
188 189

	bool devres_managed;
Linus Torvalds's avatar
Linus Torvalds committed
190
};
191
#define to_input_dev(d) container_of(d, struct input_dev, dev)
Linus Torvalds's avatar
Linus Torvalds committed
192

193 194 195 196 197 198 199 200
/*
 * Verify that we are in sync with input_device_id mod_devicetable.h #defines
 */

#if EV_MAX != INPUT_DEVICE_ID_EV_MAX
#error "EV_MAX and INPUT_DEVICE_ID_EV_MAX do not match"
#endif

201 202 203 204
#if KEY_MIN_INTERESTING != INPUT_DEVICE_ID_KEY_MIN_INTERESTING
#error "KEY_MIN_INTERESTING and INPUT_DEVICE_ID_KEY_MIN_INTERESTING do not match"
#endif

205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
#if KEY_MAX != INPUT_DEVICE_ID_KEY_MAX
#error "KEY_MAX and INPUT_DEVICE_ID_KEY_MAX do not match"
#endif

#if REL_MAX != INPUT_DEVICE_ID_REL_MAX
#error "REL_MAX and INPUT_DEVICE_ID_REL_MAX do not match"
#endif

#if ABS_MAX != INPUT_DEVICE_ID_ABS_MAX
#error "ABS_MAX and INPUT_DEVICE_ID_ABS_MAX do not match"
#endif

#if MSC_MAX != INPUT_DEVICE_ID_MSC_MAX
#error "MSC_MAX and INPUT_DEVICE_ID_MSC_MAX do not match"
#endif

#if LED_MAX != INPUT_DEVICE_ID_LED_MAX
#error "LED_MAX and INPUT_DEVICE_ID_LED_MAX do not match"
#endif

#if SND_MAX != INPUT_DEVICE_ID_SND_MAX
#error "SND_MAX and INPUT_DEVICE_ID_SND_MAX do not match"
#endif

#if FF_MAX != INPUT_DEVICE_ID_FF_MAX
#error "FF_MAX and INPUT_DEVICE_ID_FF_MAX do not match"
#endif

#if SW_MAX != INPUT_DEVICE_ID_SW_MAX
#error "SW_MAX and INPUT_DEVICE_ID_SW_MAX do not match"
#endif

#define INPUT_DEVICE_ID_MATCH_DEVICE \
Linus Torvalds's avatar
Linus Torvalds committed
238
	(INPUT_DEVICE_ID_MATCH_BUS | INPUT_DEVICE_ID_MATCH_VENDOR | INPUT_DEVICE_ID_MATCH_PRODUCT)
239
#define INPUT_DEVICE_ID_MATCH_DEVICE_AND_VERSION \
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243
	(INPUT_DEVICE_ID_MATCH_DEVICE | INPUT_DEVICE_ID_MATCH_VERSION)

struct input_handle;

244 245 246
/**
 * struct input_handler - implements one of interfaces for input devices
 * @private: driver-specific data
247 248 249
 * @event: event handler. This method is being called by input core with
 *	interrupts disabled and dev->event_lock spinlock held and so
 *	it may not sleep
250 251 252
 * @events: event sequence handler. This method is being called by
 *	input core with interrupts disabled and dev->event_lock
 *	spinlock held and so it may not sleep
253 254
 * @filter: similar to @event; separates normal event handlers from
 *	"filters".
255 256
 * @match: called after comparing device's id with handler's id_table
 *	to perform fine-grained matching between device and handler
257 258 259 260 261
 * @connect: called when attaching a handler to an input device
 * @disconnect: disconnects a handler from input device
 * @start: starts handler for given handle. This function is called by
 *	input core right after connect() method and also when a process
 *	that "grabbed" a device releases it
262 263
 * @legacy_minors: set to %true by drivers using legacy minor ranges
 * @minor: beginning of range of 32 legacy minors for devices this driver
264 265 266 267 268 269
 *	can provide
 * @name: name of the handler, to be shown in /proc/bus/input/handlers
 * @id_table: pointer to a table of input_device_ids this driver can
 *	handle
 * @h_list: list of input handles associated with the handler
 * @node: for placing the driver onto input_handler_list
270 271 272 273 274 275
 *
 * Input handlers attach to input devices and create input handles. There
 * are likely several handlers attached to any given input device at the
 * same time. All of them will get their copy of input event generated by
 * the device.
 *
276 277 278 279 280
 * The very same structure is used to implement input filters. Input core
 * allows filters to run first and will not pass event to regular handlers
 * if any of the filters indicate that the event should be filtered (by
 * returning %true from their filter() method).
 *
281 282
 * Note that input core serializes calls to connect() and disconnect()
 * methods.
283
 */
Linus Torvalds's avatar
Linus Torvalds committed
284 285 286 287 288
struct input_handler {

	void *private;

	void (*event)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
289 290
	void (*events)(struct input_handle *handle,
		       const struct input_value *vals, unsigned int count);
291
	bool (*filter)(struct input_handle *handle, unsigned int type, unsigned int code, int value);
292
	bool (*match)(struct input_handler *handler, struct input_dev *dev);
293
	int (*connect)(struct input_handler *handler, struct input_dev *dev, const struct input_device_id *id);
Linus Torvalds's avatar
Linus Torvalds committed
294
	void (*disconnect)(struct input_handle *handle);
295
	void (*start)(struct input_handle *handle);
Linus Torvalds's avatar
Linus Torvalds committed
296

297
	bool legacy_minors;
Linus Torvalds's avatar
Linus Torvalds committed
298
	int minor;
299
	const char *name;
Linus Torvalds's avatar
Linus Torvalds committed
300

301
	const struct input_device_id *id_table;
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306

	struct list_head	h_list;
	struct list_head	node;
};

307 308 309 310 311 312 313 314 315 316 317 318
/**
 * struct input_handle - links input device with an input handler
 * @private: handler-specific data
 * @open: counter showing whether the handle is 'open', i.e. should deliver
 *	events from its device
 * @name: name given to the handle by handler that created it
 * @dev: input device the handle is attached to
 * @handler: handler that works with the device through this handle
 * @d_node: used to put the handle on device's list of attached handles
 * @h_node: used to put the handle on handler's list of handles from which
 *	it gets events
 */
Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322 323
struct input_handle {

	void *private;

	int open;
324
	const char *name;
Linus Torvalds's avatar
Linus Torvalds committed
325 326 327 328 329 330 331 332

	struct input_dev *dev;
	struct input_handler *handler;

	struct list_head	d_node;
	struct list_head	h_node;
};

333 334
struct input_dev __must_check *input_allocate_device(void);
struct input_dev __must_check *devm_input_allocate_device(struct device *);
335
void input_free_device(struct input_dev *dev);
336 337 338

static inline struct input_dev *input_get_device(struct input_dev *dev)
{
339
	return dev ? to_input_dev(get_device(&dev->dev)) : NULL;
340 341 342 343
}

static inline void input_put_device(struct input_dev *dev)
{
344 345
	if (dev)
		put_device(&dev->dev);
346 347
}

348 349
static inline void *input_get_drvdata(struct input_dev *dev)
{
350
	return dev_get_drvdata(&dev->dev);
351 352 353 354
}

static inline void input_set_drvdata(struct input_dev *dev, void *data)
{
355
	dev_set_drvdata(&dev->dev, data);
356 357
}

358
int __must_check input_register_device(struct input_dev *);
Linus Torvalds's avatar
Linus Torvalds committed
359 360
void input_unregister_device(struct input_dev *);

361 362
void input_reset_device(struct input_dev *);

363
int __must_check input_register_handler(struct input_handler *);
Linus Torvalds's avatar
Linus Torvalds committed
364 365
void input_unregister_handler(struct input_handler *);

366 367 368 369
int __must_check input_get_new_minor(int legacy_base, unsigned int legacy_num,
				     bool allow_dynamic);
void input_free_minor(unsigned int minor);

370 371 372
int input_handler_for_each_handle(struct input_handler *, void *data,
				  int (*fn)(struct input_handle *, void *));

373 374 375
int input_register_handle(struct input_handle *);
void input_unregister_handle(struct input_handle *);

Linus Torvalds's avatar
Linus Torvalds committed
376 377 378 379 380 381
int input_grab_device(struct input_handle *);
void input_release_device(struct input_handle *);

int input_open_device(struct input_handle *);
void input_close_device(struct input_handle *);

382
int input_flush_device(struct input_handle *handle, struct file *file);
Linus Torvalds's avatar
Linus Torvalds committed
383 384

void input_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);
385
void input_inject_event(struct input_handle *handle, unsigned int type, unsigned int code, int value);
Linus Torvalds's avatar
Linus Torvalds committed
386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406

static inline void input_report_key(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_KEY, code, !!value);
}

static inline void input_report_rel(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_REL, code, value);
}

static inline void input_report_abs(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_ABS, code, value);
}

static inline void input_report_ff_status(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_FF_STATUS, code, value);
}

407 408 409 410 411
static inline void input_report_switch(struct input_dev *dev, unsigned int code, int value)
{
	input_event(dev, EV_SW, code, !!value);
}

Linus Torvalds's avatar
Linus Torvalds committed
412 413 414 415 416
static inline void input_sync(struct input_dev *dev)
{
	input_event(dev, EV_SYN, SYN_REPORT, 0);
}

417 418 419 420 421
static inline void input_mt_sync(struct input_dev *dev)
{
	input_event(dev, EV_SYN, SYN_MT_REPORT, 0);
}

422 423
void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code);

424 425 426 427 428 429 430 431 432 433 434 435 436 437 438
/**
 * input_set_events_per_packet - tell handlers about the driver event rate
 * @dev: the input device used by the driver
 * @n_events: the average number of events between calls to input_sync()
 *
 * If the event rate sent from a device is unusually large, use this
 * function to set the expected event rate. This will allow handlers
 * to set up an appropriate buffer size for the event stream, in order
 * to minimize information loss.
 */
static inline void input_set_events_per_packet(struct input_dev *dev, int n_events)
{
	dev->hint_events_per_packet = n_events;
}

439 440 441
void input_alloc_absinfo(struct input_dev *dev);
void input_set_abs_params(struct input_dev *dev, unsigned int axis,
			  int min, int max, int fuzz, int flat);
Linus Torvalds's avatar
Linus Torvalds committed
442

443 444 445 446
#define INPUT_GENERATE_ABS_ACCESSORS(_suffix, _item)			\
static inline int input_abs_get_##_suffix(struct input_dev *dev,	\
					  unsigned int axis)		\
{									\
447
	return dev->absinfo ? dev->absinfo[axis]._item : 0;		\
448 449 450 451 452
}									\
									\
static inline void input_abs_set_##_suffix(struct input_dev *dev,	\
					   unsigned int axis, int val)	\
{									\
453 454 455
	input_alloc_absinfo(dev);					\
	if (dev->absinfo)						\
		dev->absinfo[axis]._item = val;				\
456 457
}

458 459 460
INPUT_GENERATE_ABS_ACCESSORS(val, value)
INPUT_GENERATE_ABS_ACCESSORS(min, minimum)
INPUT_GENERATE_ABS_ACCESSORS(max, maximum)
461 462
INPUT_GENERATE_ABS_ACCESSORS(fuzz, fuzz)
INPUT_GENERATE_ABS_ACCESSORS(flat, flat)
463
INPUT_GENERATE_ABS_ACCESSORS(res, resolution)
464

465 466 467 468
int input_scancode_to_scalar(const struct input_keymap_entry *ke,
			     unsigned int *scancode);

int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke);
469
int input_set_keycode(struct input_dev *dev,
470
		      const struct input_keymap_entry *ke);
471

472 473
void input_enable_softrepeat(struct input_dev *dev, int delay, int period);

474
extern struct class input_class;
Linus Torvalds's avatar
Linus Torvalds committed
475

476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491
/**
 * struct ff_device - force-feedback part of an input device
 * @upload: Called to upload an new effect into device
 * @erase: Called to erase an effect from device
 * @playback: Called to request device to start playing specified effect
 * @set_gain: Called to set specified gain
 * @set_autocenter: Called to auto-center device
 * @destroy: called by input core when parent input device is being
 *	destroyed
 * @private: driver-specific data, will be freed automatically
 * @ffbit: bitmap of force feedback capabilities truly supported by
 *	device (not emulated like ones in input_dev->ffbit)
 * @mutex: mutex for serializing access to the device
 * @max_effects: maximum number of effects supported by device
 * @effects: pointer to an array of effects currently loaded into device
 * @effect_owners: array of effect owners; when file handle owning
492
 *	an effect gets closed the effect is automatically erased
493 494 495 496 497
 *
 * Every force-feedback device must implement upload() and playback()
 * methods; erase() is optional. set_gain() and set_autocenter() need
 * only be implemented if driver sets up FF_GAIN and FF_AUTOCENTER
 * bits.
498 499 500 501
 *
 * Note that playback(), set_gain() and set_autocenter() are called with
 * dev->event_lock spinlock held and interrupts off and thus may not
 * sleep.
502 503 504 505 506 507 508 509 510 511 512 513 514 515
 */
struct ff_device {
	int (*upload)(struct input_dev *dev, struct ff_effect *effect,
		      struct ff_effect *old);
	int (*erase)(struct input_dev *dev, int effect_id);

	int (*playback)(struct input_dev *dev, int effect_id, int value);
	void (*set_gain)(struct input_dev *dev, u16 gain);
	void (*set_autocenter)(struct input_dev *dev, u16 magnitude);

	void (*destroy)(struct ff_device *);

	void *private;

516
	unsigned long ffbit[BITS_TO_LONGS(FF_CNT)];
517 518 519 520 521 522 523 524

	struct mutex mutex;

	int max_effects;
	struct ff_effect *effects;
	struct file *effect_owners[];
};

525
int input_ff_create(struct input_dev *dev, unsigned int max_effects);
526 527 528 529 530 531 532
void input_ff_destroy(struct input_dev *dev);

int input_ff_event(struct input_dev *dev, unsigned int type, unsigned int code, int value);

int input_ff_upload(struct input_dev *dev, struct ff_effect *effect, struct file *file);
int input_ff_erase(struct input_dev *dev, int effect_id, struct file *file);

533 534 535
int input_ff_create_memless(struct input_dev *dev, void *data,
		int (*play_effect)(struct input_dev *, void *, struct ff_effect *));

Linus Torvalds's avatar
Linus Torvalds committed
536
#endif