Lines Matching refs:dev
86 static void input_start_autorepeat(struct input_dev *dev, int code)
88 if (test_bit(EV_REP, dev->evbit) &&
89 dev->rep[REP_PERIOD] && dev->rep[REP_DELAY] &&
90 dev->timer.function) {
91 dev->repeat_key = code;
92 mod_timer(&dev->timer,
93 jiffies + msecs_to_jiffies(dev->rep[REP_DELAY]));
97 static void input_stop_autorepeat(struct input_dev *dev)
99 del_timer(&dev->timer);
105 * dev->event_lock held and interrupts disabled.
140 * dev->event_lock held and interrupts disabled.
142 static void input_pass_values(struct input_dev *dev,
153 handle = rcu_dereference(dev->grab);
157 list_for_each_entry_rcu(handle, &dev->h_list, d_node)
168 if (test_bit(EV_REP, dev->evbit) && test_bit(EV_KEY, dev->evbit)) {
172 input_start_autorepeat(dev, v->code);
174 input_stop_autorepeat(dev);
180 static void input_pass_event(struct input_dev *dev,
185 input_pass_values(dev, vals, ARRAY_SIZE(vals));
190 * dev->event_lock here to avoid racing with input_event
195 struct input_dev *dev = from_timer(dev, t, timer);
198 spin_lock_irqsave(&dev->event_lock, flags);
200 if (test_bit(dev->repeat_key, dev->key) &&
201 is_event_supported(dev->repeat_key, dev->keybit, KEY_MAX)) {
203 { EV_KEY, dev->repeat_key, 2 },
207 input_set_timestamp(dev, ktime_get());
208 input_pass_values(dev, vals, ARRAY_SIZE(vals));
210 if (dev->rep[REP_PERIOD])
211 mod_timer(&dev->timer, jiffies +
212 msecs_to_jiffies(dev->rep[REP_PERIOD]));
215 spin_unlock_irqrestore(&dev->event_lock, flags);
225 static int input_handle_abs_event(struct input_dev *dev,
228 struct input_mt *mt = dev->mt;
246 pold = &dev->absinfo[code].value;
259 dev->absinfo[code].fuzz);
267 if (is_mt_event && mt && mt->slot != input_abs_get_val(dev, ABS_MT_SLOT)) {
268 input_abs_set_val(dev, ABS_MT_SLOT, mt->slot);
275 static int input_get_disposition(struct input_dev *dev,
299 if (is_event_supported(code, dev->keybit, KEY_MAX)) {
307 if (!!test_bit(code, dev->key) != !!value) {
309 __change_bit(code, dev->key);
316 if (is_event_supported(code, dev->swbit, SW_MAX) &&
317 !!test_bit(code, dev->sw) != !!value) {
319 __change_bit(code, dev->sw);
325 if (is_event_supported(code, dev->absbit, ABS_MAX))
326 disposition = input_handle_abs_event(dev, code, &value);
331 if (is_event_supported(code, dev->relbit, REL_MAX) && value)
337 if (is_event_supported(code, dev->mscbit, MSC_MAX))
343 if (is_event_supported(code, dev->ledbit, LED_MAX) &&
344 !!test_bit(code, dev->led) != !!value) {
346 __change_bit(code, dev->led);
352 if (is_event_supported(code, dev->sndbit, SND_MAX)) {
354 if (!!test_bit(code, dev->snd) != !!value)
355 __change_bit(code, dev->snd);
361 if (code <= REP_MAX && value >= 0 && dev->rep[code] != value) {
362 dev->rep[code] = value;
381 static void input_handle_event(struct input_dev *dev,
384 int disposition = input_get_disposition(dev, type, code, &value);
389 if ((disposition & INPUT_PASS_TO_DEVICE) && dev->event)
390 dev->event(dev, type, code, value);
392 if (!dev->vals)
399 v = &dev->vals[dev->num_vals++];
402 v->value = dev->mt->slot;
405 v = &dev->vals[dev->num_vals++];
412 if (dev->num_vals >= 2)
413 input_pass_values(dev, dev->vals, dev->num_vals);
414 dev->num_vals = 0;
421 dev->timestamp[INPUT_CLK_MONO] = ktime_set(0, 0);
422 } else if (dev->num_vals >= dev->max_vals - 2) {
423 dev->vals[dev->num_vals++] = input_value_sync;
424 input_pass_values(dev, dev->vals, dev->num_vals);
425 dev->num_vals = 0;
432 * @dev: device that generated the event
447 void input_event(struct input_dev *dev,
452 if (is_event_supported(type, dev->evbit, EV_MAX)) {
454 spin_lock_irqsave(&dev->event_lock, flags);
455 input_handle_event(dev, type, code, value);
456 spin_unlock_irqrestore(&dev->event_lock, flags);
475 struct input_dev *dev = handle->dev;
479 if (is_event_supported(type, dev->evbit, EV_MAX)) {
480 spin_lock_irqsave(&dev->event_lock, flags);
483 grab = rcu_dereference(dev->grab);
485 input_handle_event(dev, type, code, value);
488 spin_unlock_irqrestore(&dev->event_lock, flags);
495 * @dev: the input device emitting absolute events
500 void input_alloc_absinfo(struct input_dev *dev)
502 if (dev->absinfo)
505 dev->absinfo = kcalloc(ABS_CNT, sizeof(*dev->absinfo), GFP_KERNEL);
506 if (!dev->absinfo) {
507 dev_err(dev->dev.parent ?: &dev->dev,
518 void input_set_abs_params(struct input_dev *dev, unsigned int axis,
523 input_alloc_absinfo(dev);
524 if (!dev->absinfo)
527 absinfo = &dev->absinfo[axis];
533 __set_bit(EV_ABS, dev->evbit);
534 __set_bit(axis, dev->absbit);
549 struct input_dev *dev = handle->dev;
552 retval = mutex_lock_interruptible(&dev->mutex);
556 if (dev->grab) {
561 rcu_assign_pointer(dev->grab, handle);
564 mutex_unlock(&dev->mutex);
571 struct input_dev *dev = handle->dev;
574 grabber = rcu_dereference_protected(dev->grab,
575 lockdep_is_held(&dev->mutex));
577 rcu_assign_pointer(dev->grab, NULL);
581 list_for_each_entry(handle, &dev->h_list, d_node)
598 struct input_dev *dev = handle->dev;
600 mutex_lock(&dev->mutex);
602 mutex_unlock(&dev->mutex);
615 struct input_dev *dev = handle->dev;
618 retval = mutex_lock_interruptible(&dev->mutex);
622 if (dev->going_away) {
629 if (dev->users++) {
637 if (dev->open) {
638 retval = dev->open(dev);
640 dev->users--;
651 if (dev->poller)
652 input_dev_poller_start(dev->poller);
655 mutex_unlock(&dev->mutex);
662 struct input_dev *dev = handle->dev;
665 retval = mutex_lock_interruptible(&dev->mutex);
669 if (dev->flush)
670 retval = dev->flush(dev, file);
672 mutex_unlock(&dev->mutex);
686 struct input_dev *dev = handle->dev;
688 mutex_lock(&dev->mutex);
692 if (!--dev->users) {
693 if (dev->poller)
694 input_dev_poller_stop(dev->poller);
696 if (dev->close)
697 dev->close(dev);
709 mutex_unlock(&dev->mutex);
715 * The function must be called with dev->event_lock held.
717 static void input_dev_release_keys(struct input_dev *dev)
722 if (is_event_supported(EV_KEY, dev->evbit, EV_MAX)) {
723 for_each_set_bit(code, dev->key, KEY_CNT) {
724 input_pass_event(dev, EV_KEY, code, 0);
729 input_pass_event(dev, EV_SYN, SYN_REPORT, 1);
731 memset(dev->key, 0, sizeof(dev->key));
738 static void input_disconnect_device(struct input_dev *dev)
743 * Mark device as going away. Note that we take dev->mutex here
744 * not to protect access to dev->going_away but rather to ensure
747 mutex_lock(&dev->mutex);
748 dev->going_away = true;
749 mutex_unlock(&dev->mutex);
751 spin_lock_irq(&dev->event_lock);
759 input_dev_release_keys(dev);
761 list_for_each_entry(handle, &dev->h_list, d_node)
764 spin_unlock_irq(&dev->event_lock);
806 static unsigned int input_fetch_keycode(struct input_dev *dev,
809 switch (dev->keycodesize) {
811 return ((u8 *)dev->keycode)[index];
814 return ((u16 *)dev->keycode)[index];
817 return ((u32 *)dev->keycode)[index];
821 static int input_default_getkeycode(struct input_dev *dev,
827 if (!dev->keycodesize)
838 if (index >= dev->keycodemax)
841 ke->keycode = input_fetch_keycode(dev, index);
849 static int input_default_setkeycode(struct input_dev *dev,
857 if (!dev->keycodesize)
868 if (index >= dev->keycodemax)
871 if (dev->keycodesize < sizeof(ke->keycode) &&
872 (ke->keycode >> (dev->keycodesize * 8)))
875 switch (dev->keycodesize) {
877 u8 *k = (u8 *)dev->keycode;
883 u16 *k = (u16 *)dev->keycode;
889 u32 *k = (u32 *)dev->keycode;
897 __clear_bit(*old_keycode, dev->keybit);
898 for (i = 0; i < dev->keycodemax; i++) {
899 if (input_fetch_keycode(dev, i) == *old_keycode) {
900 __set_bit(*old_keycode, dev->keybit);
907 __set_bit(ke->keycode, dev->keybit);
913 * @dev: input device which keymap is being queried
919 int input_get_keycode(struct input_dev *dev, struct input_keymap_entry *ke)
924 spin_lock_irqsave(&dev->event_lock, flags);
925 retval = dev->getkeycode(dev, ke);
926 spin_unlock_irqrestore(&dev->event_lock, flags);
934 * @dev: input device which keymap is being updated
940 int input_set_keycode(struct input_dev *dev,
950 spin_lock_irqsave(&dev->event_lock, flags);
952 retval = dev->setkeycode(dev, ke, &old_keycode);
957 __clear_bit(KEY_RESERVED, dev->keybit);
964 dev_warn(dev->dev.parent ?: &dev->dev,
967 } else if (test_bit(EV_KEY, dev->evbit) &&
968 !is_event_supported(old_keycode, dev->keybit, KEY_MAX) &&
969 __test_and_clear_bit(old_keycode, dev->key)) {
975 input_pass_values(dev, vals, ARRAY_SIZE(vals));
979 spin_unlock_irqrestore(&dev->event_lock, flags);
985 bool input_match_device_id(const struct input_dev *dev,
989 if (id->bustype != dev->id.bustype)
993 if (id->vendor != dev->id.vendor)
997 if (id->product != dev->id.product)
1001 if (id->version != dev->id.version)
1004 if (!bitmap_subset(id->evbit, dev->evbit, EV_MAX) ||
1005 !bitmap_subset(id->keybit, dev->keybit, KEY_MAX) ||
1006 !bitmap_subset(id->relbit, dev->relbit, REL_MAX) ||
1007 !bitmap_subset(id->absbit, dev->absbit, ABS_MAX) ||
1008 !bitmap_subset(id->mscbit, dev->mscbit, MSC_MAX) ||
1009 !bitmap_subset(id->ledbit, dev->ledbit, LED_MAX) ||
1010 !bitmap_subset(id->sndbit, dev->sndbit, SND_MAX) ||
1011 !bitmap_subset(id->ffbit, dev->ffbit, FF_MAX) ||
1012 !bitmap_subset(id->swbit, dev->swbit, SW_MAX) ||
1013 !bitmap_subset(id->propbit, dev->propbit, INPUT_PROP_MAX)) {
1022 struct input_dev *dev)
1027 if (input_match_device_id(dev, id) &&
1028 (!handler->match || handler->match(handler, dev))) {
1036 static int input_attach_handler(struct input_dev *dev, struct input_handler *handler)
1041 id = input_match_device(handler, dev);
1045 error = handler->connect(handler, dev, id);
1048 handler->name, kobject_name(&dev->dev.kobj), error);
1179 struct input_dev *dev = container_of(v, struct input_dev, node);
1180 const char *path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
1184 dev->id.bustype, dev->id.vendor, dev->id.product, dev->id.version);
1186 seq_printf(seq, "N: Name=\"%s\"\n", dev->name ? dev->name : "");
1187 seq_printf(seq, "P: Phys=%s\n", dev->phys ? dev->phys : "");
1189 seq_printf(seq, "U: Uniq=%s\n", dev->uniq ? dev->uniq : "");
1192 list_for_each_entry(handle, &dev->h_list, d_node)
1196 input_seq_print_bitmap(seq, "PROP", dev->propbit, INPUT_PROP_MAX);
1198 input_seq_print_bitmap(seq, "EV", dev->evbit, EV_MAX);
1199 if (test_bit(EV_KEY, dev->evbit))
1200 input_seq_print_bitmap(seq, "KEY", dev->keybit, KEY_MAX);
1201 if (test_bit(EV_REL, dev->evbit))
1202 input_seq_print_bitmap(seq, "REL", dev->relbit, REL_MAX);
1203 if (test_bit(EV_ABS, dev->evbit))
1204 input_seq_print_bitmap(seq, "ABS", dev->absbit, ABS_MAX);
1205 if (test_bit(EV_MSC, dev->evbit))
1206 input_seq_print_bitmap(seq, "MSC", dev->mscbit, MSC_MAX);
1207 if (test_bit(EV_LED, dev->evbit))
1208 input_seq_print_bitmap(seq, "LED", dev->ledbit, LED_MAX);
1209 if (test_bit(EV_SND, dev->evbit))
1210 input_seq_print_bitmap(seq, "SND", dev->sndbit, SND_MAX);
1211 if (test_bit(EV_FF, dev->evbit))
1212 input_seq_print_bitmap(seq, "FF", dev->ffbit, FF_MAX);
1213 if (test_bit(EV_SW, dev->evbit))
1214 input_seq_print_bitmap(seq, "SW", dev->swbit, SW_MAX);
1343 static ssize_t input_dev_show_##name(struct device *dev, \
1347 struct input_dev *input_dev = to_input_dev(dev); \
1406 static ssize_t input_dev_show_modalias(struct device *dev,
1410 struct input_dev *id = to_input_dev(dev);
1422 static ssize_t input_dev_show_properties(struct device *dev,
1426 struct input_dev *input_dev = to_input_dev(dev);
1447 static ssize_t input_dev_show_id_##name(struct device *dev, \
1451 struct input_dev *input_dev = to_input_dev(dev); \
1504 static ssize_t input_dev_show_cap_##bm(struct device *dev, \
1508 struct input_dev *input_dev = to_input_dev(dev); \
1554 struct input_dev *dev = to_input_dev(device);
1556 input_ff_destroy(dev);
1557 input_mt_destroy_slots(dev);
1558 kfree(dev->poller);
1559 kfree(dev->absinfo);
1560 kfree(dev->vals);
1561 kfree(dev);
1589 struct input_dev *dev)
1598 dev, 0);
1620 #define INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev) \
1622 int err = input_add_uevent_modalias_var(env, dev); \
1629 struct input_dev *dev = to_input_dev(device);
1632 dev->id.bustype, dev->id.vendor,
1633 dev->id.product, dev->id.version);
1634 if (dev->name)
1635 INPUT_ADD_HOTPLUG_VAR("NAME=\"%s\"", dev->name);
1636 if (dev->phys)
1637 INPUT_ADD_HOTPLUG_VAR("PHYS=\"%s\"", dev->phys);
1638 if (dev->uniq)
1639 INPUT_ADD_HOTPLUG_VAR("UNIQ=\"%s\"", dev->uniq);
1641 INPUT_ADD_HOTPLUG_BM_VAR("PROP=", dev->propbit, INPUT_PROP_MAX);
1643 INPUT_ADD_HOTPLUG_BM_VAR("EV=", dev->evbit, EV_MAX);
1644 if (test_bit(EV_KEY, dev->evbit))
1645 INPUT_ADD_HOTPLUG_BM_VAR("KEY=", dev->keybit, KEY_MAX);
1646 if (test_bit(EV_REL, dev->evbit))
1647 INPUT_ADD_HOTPLUG_BM_VAR("REL=", dev->relbit, REL_MAX);
1648 if (test_bit(EV_ABS, dev->evbit))
1649 INPUT_ADD_HOTPLUG_BM_VAR("ABS=", dev->absbit, ABS_MAX);
1650 if (test_bit(EV_MSC, dev->evbit))
1651 INPUT_ADD_HOTPLUG_BM_VAR("MSC=", dev->mscbit, MSC_MAX);
1652 if (test_bit(EV_LED, dev->evbit))
1653 INPUT_ADD_HOTPLUG_BM_VAR("LED=", dev->ledbit, LED_MAX);
1654 if (test_bit(EV_SND, dev->evbit))
1655 INPUT_ADD_HOTPLUG_BM_VAR("SND=", dev->sndbit, SND_MAX);
1656 if (test_bit(EV_FF, dev->evbit))
1657 INPUT_ADD_HOTPLUG_BM_VAR("FF=", dev->ffbit, FF_MAX);
1658 if (test_bit(EV_SW, dev->evbit))
1659 INPUT_ADD_HOTPLUG_BM_VAR("SW=", dev->swbit, SW_MAX);
1661 INPUT_ADD_HOTPLUG_MODALIAS_VAR(dev);
1666 #define INPUT_DO_TOGGLE(dev, type, bits, on) \
1671 if (!test_bit(EV_##type, dev->evbit)) \
1674 for_each_set_bit(i, dev->bits##bit, type##_CNT) { \
1675 active = test_bit(i, dev->bits); \
1679 dev->event(dev, EV_##type, i, on ? active : 0); \
1683 static void input_dev_toggle(struct input_dev *dev, bool activate)
1685 if (!dev->event)
1688 INPUT_DO_TOGGLE(dev, LED, led, activate);
1689 INPUT_DO_TOGGLE(dev, SND, snd, activate);
1691 if (activate && test_bit(EV_REP, dev->evbit)) {
1692 dev->event(dev, EV_REP, REP_PERIOD, dev->rep[REP_PERIOD]);
1693 dev->event(dev, EV_REP, REP_DELAY, dev->rep[REP_DELAY]);
1699 * @dev: input device whose state needs to be reset
1705 void input_reset_device(struct input_dev *dev)
1709 mutex_lock(&dev->mutex);
1710 spin_lock_irqsave(&dev->event_lock, flags);
1712 input_dev_toggle(dev, true);
1713 input_dev_release_keys(dev);
1715 spin_unlock_irqrestore(&dev->event_lock, flags);
1716 mutex_unlock(&dev->mutex);
1721 static int input_dev_suspend(struct device *dev)
1723 struct input_dev *input_dev = to_input_dev(dev);
1741 static int input_dev_resume(struct device *dev)
1743 struct input_dev *input_dev = to_input_dev(dev);
1755 static int input_dev_freeze(struct device *dev)
1757 struct input_dev *input_dev = to_input_dev(dev);
1772 static int input_dev_poweroff(struct device *dev)
1774 struct input_dev *input_dev = to_input_dev(dev);
1804 static char *input_devnode(struct device *dev, umode_t *mode)
1806 return kasprintf(GFP_KERNEL, "input/%s", dev_name(dev));
1827 struct input_dev *dev;
1829 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1830 if (dev) {
1831 dev->dev.type = &input_dev_type;
1832 dev->dev.class = &input_class;
1833 device_initialize(&dev->dev);
1834 mutex_init(&dev->mutex);
1835 spin_lock_init(&dev->event_lock);
1836 timer_setup(&dev->timer, NULL, 0);
1837 INIT_LIST_HEAD(&dev->h_list);
1838 INIT_LIST_HEAD(&dev->node);
1840 dev_set_name(&dev->dev, "input%lu",
1846 return dev;
1854 static int devm_input_device_match(struct device *dev, void *res, void *data)
1861 static void devm_input_device_release(struct device *dev, void *res)
1866 dev_dbg(dev, "%s: dropping reference to %s\n",
1867 __func__, dev_name(&input->dev));
1873 * @dev: device owning the input device being created
1889 struct input_dev *devm_input_allocate_device(struct device *dev)
1905 input->dev.parent = dev;
1909 devres_add(dev, devres);
1917 * @dev: input device to free
1929 void input_free_device(struct input_dev *dev)
1931 if (dev) {
1932 if (dev->devres_managed)
1933 WARN_ON(devres_destroy(dev->dev.parent,
1936 dev));
1937 input_put_device(dev);
1944 * @dev: input device to set timestamp for
1956 void input_set_timestamp(struct input_dev *dev, ktime_t timestamp)
1958 dev->timestamp[INPUT_CLK_MONO] = timestamp;
1959 dev->timestamp[INPUT_CLK_REAL] = ktime_mono_to_real(timestamp);
1960 dev->timestamp[INPUT_CLK_BOOT] = ktime_mono_to_any(timestamp,
1967 * @dev: input device to get timestamp from
1971 ktime_t *input_get_timestamp(struct input_dev *dev)
1975 if (!ktime_compare(dev->timestamp[INPUT_CLK_MONO], invalid_timestamp))
1976 input_set_timestamp(dev, ktime_get());
1978 return dev->timestamp;
1984 * @dev: device that is capable of emitting or accepting event
1989 * bitmap the function also adjusts dev->evbit.
1991 void input_set_capability(struct input_dev *dev, unsigned int type, unsigned int code)
2003 __set_bit(code, dev->keybit);
2007 __set_bit(code, dev->relbit);
2011 input_alloc_absinfo(dev);
2012 if (!dev->absinfo)
2015 __set_bit(code, dev->absbit);
2019 __set_bit(code, dev->mscbit);
2023 __set_bit(code, dev->swbit);
2027 __set_bit(code, dev->ledbit);
2031 __set_bit(code, dev->sndbit);
2035 __set_bit(code, dev->ffbit);
2048 __set_bit(type, dev->evbit);
2052 static unsigned int input_estimate_events_per_packet(struct input_dev *dev)
2058 if (dev->mt) {
2059 mt_slots = dev->mt->num_slots;
2060 } else if (test_bit(ABS_MT_TRACKING_ID, dev->absbit)) {
2061 mt_slots = dev->absinfo[ABS_MT_TRACKING_ID].maximum -
2062 dev->absinfo[ABS_MT_TRACKING_ID].minimum + 1,
2064 } else if (test_bit(ABS_MT_POSITION_X, dev->absbit)) {
2072 if (test_bit(EV_ABS, dev->evbit))
2073 for_each_set_bit(i, dev->absbit, ABS_CNT)
2076 if (test_bit(EV_REL, dev->evbit))
2077 events += bitmap_weight(dev->relbit, REL_CNT);
2085 #define INPUT_CLEANSE_BITMASK(dev, type, bits) \
2087 if (!test_bit(EV_##type, dev->evbit)) \
2088 memset(dev->bits##bit, 0, \
2089 sizeof(dev->bits##bit)); \
2092 static void input_cleanse_bitmasks(struct input_dev *dev)
2094 INPUT_CLEANSE_BITMASK(dev, KEY, key);
2095 INPUT_CLEANSE_BITMASK(dev, REL, rel);
2096 INPUT_CLEANSE_BITMASK(dev, ABS, abs);
2097 INPUT_CLEANSE_BITMASK(dev, MSC, msc);
2098 INPUT_CLEANSE_BITMASK(dev, LED, led);
2099 INPUT_CLEANSE_BITMASK(dev, SND, snd);
2100 INPUT_CLEANSE_BITMASK(dev, FF, ff);
2101 INPUT_CLEANSE_BITMASK(dev, SW, sw);
2104 static void __input_unregister_device(struct input_dev *dev)
2108 input_disconnect_device(dev);
2112 list_for_each_entry_safe(handle, next, &dev->h_list, d_node)
2114 WARN_ON(!list_empty(&dev->h_list));
2116 del_timer_sync(&dev->timer);
2117 list_del_init(&dev->node);
2123 device_del(&dev->dev);
2126 static void devm_input_device_unregister(struct device *dev, void *res)
2131 dev_dbg(dev, "%s: unregistering device %s\n",
2132 __func__, dev_name(&input->dev));
2138 * @dev: input device
2144 void input_enable_softrepeat(struct input_dev *dev, int delay, int period)
2146 dev->timer.function = input_repeat_key;
2147 dev->rep[REP_DELAY] = delay;
2148 dev->rep[REP_PERIOD] = period;
2154 * @dev: device to be registered
2175 int input_register_device(struct input_dev *dev)
2183 if (test_bit(EV_ABS, dev->evbit) && !dev->absinfo) {
2184 dev_err(&dev->dev,
2185 "Absolute device without dev->absinfo, refusing to register\n");
2189 if (dev->devres_managed) {
2195 devres->input = dev;
2199 __set_bit(EV_SYN, dev->evbit);
2202 __clear_bit(KEY_RESERVED, dev->keybit);
2204 /* Make sure that bitmasks not mentioned in dev->evbit are clean. */
2205 input_cleanse_bitmasks(dev);
2207 packet_size = input_estimate_events_per_packet(dev);
2208 if (dev->hint_events_per_packet < packet_size)
2209 dev->hint_events_per_packet = packet_size;
2211 dev->max_vals = dev->hint_events_per_packet + 2;
2212 dev->vals = kcalloc(dev->max_vals, sizeof(*dev->vals), GFP_KERNEL);
2213 if (!dev->vals) {
2222 if (!dev->rep[REP_DELAY] && !dev->rep[REP_PERIOD])
2223 input_enable_softrepeat(dev, 250, 33);
2225 if (!dev->getkeycode)
2226 dev->getkeycode = input_default_getkeycode;
2228 if (!dev->setkeycode)
2229 dev->setkeycode = input_default_setkeycode;
2231 if (dev->poller)
2232 input_dev_poller_finalize(dev->poller);
2234 error = device_add(&dev->dev);
2238 path = kobject_get_path(&dev->dev.kobj, GFP_KERNEL);
2240 dev->name ? dev->name : "Unspecified device",
2248 list_add_tail(&dev->node, &input_dev_list);
2251 input_attach_handler(dev, handler);
2257 if (dev->devres_managed) {
2258 dev_dbg(dev->dev.parent, "%s: registering %s with devres.\n",
2259 __func__, dev_name(&dev->dev));
2260 devres_add(dev->dev.parent, devres);
2265 device_del(&dev->dev);
2267 kfree(dev->vals);
2268 dev->vals = NULL;
2277 * @dev: device to be unregistered
2282 void input_unregister_device(struct input_dev *dev)
2284 if (dev->devres_managed) {
2285 WARN_ON(devres_destroy(dev->dev.parent,
2288 dev));
2289 __input_unregister_device(dev);
2295 __input_unregister_device(dev);
2296 input_put_device(dev);
2311 struct input_dev *dev;
2322 list_for_each_entry(dev, &input_dev_list, node)
2323 input_attach_handler(dev, handler);
2403 struct input_dev *dev = handle->dev;
2407 * We take dev->mutex here to prevent race with
2410 error = mutex_lock_interruptible(&dev->mutex);
2419 list_add_rcu(&handle->d_node, &dev->h_list);
2421 list_add_tail_rcu(&handle->d_node, &dev->h_list);
2423 mutex_unlock(&dev->mutex);
2452 struct input_dev *dev = handle->dev;
2457 * Take dev->mutex to prevent race with input_release_device().
2459 mutex_lock(&dev->mutex);
2461 mutex_unlock(&dev->mutex);