INPUT_REGISTER_HANDL(9) Input Subsystem INPUT_REGISTER_HANDL(9)NAME
input_register_handle - register a new input handle
SYNOPSIS
int input_register_handle(struct input_handle * handle);
ARGUMENTS
handle
handle to register
DESCRIPTION
This function puts a new input handle onto device's and handler's lists so that events can flow through it once it is opened using
input_open_device.
This function is supposed to be called from handler's connect method.
COPYRIGHT Kernel Hackers Manual 3.10 June 2014 INPUT_REGISTER_HANDL(9)
Check Out this Related Man Page
STRUCT INPUT_DEV(9) Input Subsystem STRUCT INPUT_DEV(9)NAME
struct_input_dev - represents an input device
SYNOPSIS
struct input_dev {
const char * name;
const char * phys;
const char * uniq;
struct input_id id;
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)];
unsigned int keycodemax;
unsigned int keycodesize;
void * keycode;
int (* setkeycode) (struct input_dev *dev,unsigned int scancode, unsigned int keycode);
int (* getkeycode) (struct input_dev *dev,unsigned int scancode, unsigned int *keycode);
struct ff_device * ff;
unsigned int repeat_key;
struct timer_list timer;
int sync;
int abs[ABS_MAX + 1];
int rep[REP_MAX + 1];
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)];
int absmax[ABS_MAX + 1];
int absmin[ABS_MAX + 1];
int absfuzz[ABS_MAX + 1];
int absflat[ABS_MAX + 1];
int absres[ABS_MAX + 1];
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);
struct input_handle * grab;
spinlock_t event_lock;
struct mutex mutex;
unsigned int users;
bool going_away;
struct device dev;
struct list_head h_list;
struct list_head node;
};
MEMBERS
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)
evbit[BITS_TO_LONGS(EV_CNT)]
bitmap of types of events supported by the device (EV_KEY, EV_REL, etc.)
keybit[BITS_TO_LONGS(KEY_CNT)]
bitmap of keys/buttons this device has
relbit[BITS_TO_LONGS(REL_CNT)]
bitmap of relative axes for the device
absbit[BITS_TO_LONGS(ABS_CNT)]
bitmap of absolute axes for the device
mscbit[BITS_TO_LONGS(MSC_CNT)]
bitmap of miscellaneous events supported by the device
ledbit[BITS_TO_LONGS(LED_CNT)]
bitmap of leds present on the device
sndbit[BITS_TO_LONGS(SND_CNT)]
bitmap of sound effects supported by the device
ffbit[BITS_TO_LONGS(FF_CNT)]
bitmap of force feedback effects supported by the device
swbit[BITS_TO_LONGS(SW_CNT)]
bitmap of switches present on the device
keycodemax
size of keycode table
keycodesize
size of elements in keycode table
keycode
map of scancodes to keycodes for this device
setkeycode
optional method to alter current keymap, used to implement sparse keymaps. If not supplied default mechanism will be used. The method
is being called while holding event_lock and thus must not sleep
getkeycode
optional method to retrieve current keymap. If not supplied default mechanism will be used. The method is being called while holding
event_lock and thus must not sleep
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
sync
set to 1 when there were no new events since last EV_SYNC
abs[ABS_MAX + 1]
current values for reports from absolute axes
rep[REP_MAX + 1]
current values for autorepeat parameters (delay, rate)
key[BITS_TO_LONGS(KEY_CNT)]
reflects current state of device's keys/buttons
led[BITS_TO_LONGS(LED_CNT)]
reflects current state of device's LEDs
snd[BITS_TO_LONGS(SND_CNT)]
reflects current state of sound effects
sw[BITS_TO_LONGS(SW_CNT)]
reflects current state of device's switches
absmax[ABS_MAX + 1]
maximum values for events coming from absolute axes
absmin[ABS_MAX + 1]
minimum values for events coming from absolute axes
absfuzz[ABS_MAX + 1]
describes noisiness for axes
absflat[ABS_MAX + 1]
size of the center flat position (used by joydev)
absres[ABS_MAX + 1]
resolution used for events coming form absolute axes
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
event_lock
this spinlock is is taken when input core receives 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
COPYRIGHT Kernel Hackers Manual 2.6. July 2010 STRUCT INPUT_DEV(9)