input-poller.c 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Support for polling mode for input devices.
  4. */
  5. #include <linux/device.h>
  6. #include <linux/input.h>
  7. #include <linux/jiffies.h>
  8. #include <linux/mutex.h>
  9. #include <linux/slab.h>
  10. #include <linux/types.h>
  11. #include <linux/workqueue.h>
  12. #include "input-poller.h"
  13. struct input_dev_poller {
  14. void (*poll)(struct input_dev *dev);
  15. unsigned int poll_interval; /* msec */
  16. unsigned int poll_interval_max; /* msec */
  17. unsigned int poll_interval_min; /* msec */
  18. struct input_dev *input;
  19. struct delayed_work work;
  20. };
  21. static void input_dev_poller_queue_work(struct input_dev_poller *poller)
  22. {
  23. unsigned long delay;
  24. delay = msecs_to_jiffies(poller->poll_interval);
  25. if (delay >= HZ)
  26. delay = round_jiffies_relative(delay);
  27. queue_delayed_work(system_freezable_wq, &poller->work, delay);
  28. }
  29. static void input_dev_poller_work(struct work_struct *work)
  30. {
  31. struct input_dev_poller *poller =
  32. container_of(work, struct input_dev_poller, work.work);
  33. poller->poll(poller->input);
  34. input_dev_poller_queue_work(poller);
  35. }
  36. void input_dev_poller_finalize(struct input_dev_poller *poller)
  37. {
  38. if (!poller->poll_interval)
  39. poller->poll_interval = 500;
  40. if (!poller->poll_interval_max)
  41. poller->poll_interval_max = poller->poll_interval;
  42. }
  43. void input_dev_poller_start(struct input_dev_poller *poller)
  44. {
  45. /* Only start polling if polling is enabled */
  46. if (poller->poll_interval > 0) {
  47. poller->poll(poller->input);
  48. input_dev_poller_queue_work(poller);
  49. }
  50. }
  51. void input_dev_poller_stop(struct input_dev_poller *poller)
  52. {
  53. cancel_delayed_work_sync(&poller->work);
  54. }
  55. int input_setup_polling(struct input_dev *dev,
  56. void (*poll_fn)(struct input_dev *dev))
  57. {
  58. struct input_dev_poller *poller;
  59. poller = kzalloc(sizeof(*poller), GFP_KERNEL);
  60. if (!poller) {
  61. /*
  62. * We want to show message even though kzalloc() may have
  63. * printed backtrace as knowing what instance of input
  64. * device we were dealing with is helpful.
  65. */
  66. dev_err(dev->dev.parent ?: &dev->dev,
  67. "%s: unable to allocate poller structure\n", __func__);
  68. return -ENOMEM;
  69. }
  70. INIT_DELAYED_WORK(&poller->work, input_dev_poller_work);
  71. poller->input = dev;
  72. poller->poll = poll_fn;
  73. dev->poller = poller;
  74. return 0;
  75. }
  76. EXPORT_SYMBOL(input_setup_polling);
  77. static bool input_dev_ensure_poller(struct input_dev *dev)
  78. {
  79. if (!dev->poller) {
  80. dev_err(dev->dev.parent ?: &dev->dev,
  81. "poller structure has not been set up\n");
  82. return false;
  83. }
  84. return true;
  85. }
  86. void input_set_poll_interval(struct input_dev *dev, unsigned int interval)
  87. {
  88. if (input_dev_ensure_poller(dev))
  89. dev->poller->poll_interval = interval;
  90. }
  91. EXPORT_SYMBOL(input_set_poll_interval);
  92. void input_set_min_poll_interval(struct input_dev *dev, unsigned int interval)
  93. {
  94. if (input_dev_ensure_poller(dev))
  95. dev->poller->poll_interval_min = interval;
  96. }
  97. EXPORT_SYMBOL(input_set_min_poll_interval);
  98. void input_set_max_poll_interval(struct input_dev *dev, unsigned int interval)
  99. {
  100. if (input_dev_ensure_poller(dev))
  101. dev->poller->poll_interval_max = interval;
  102. }
  103. EXPORT_SYMBOL(input_set_max_poll_interval);
  104. int input_get_poll_interval(struct input_dev *dev)
  105. {
  106. if (!dev->poller)
  107. return -EINVAL;
  108. return dev->poller->poll_interval;
  109. }
  110. EXPORT_SYMBOL(input_get_poll_interval);
  111. /* SYSFS interface */
  112. static ssize_t input_dev_get_poll_interval(struct device *dev,
  113. struct device_attribute *attr,
  114. char *buf)
  115. {
  116. struct input_dev *input = to_input_dev(dev);
  117. return sprintf(buf, "%d\n", input->poller->poll_interval);
  118. }
  119. static ssize_t input_dev_set_poll_interval(struct device *dev,
  120. struct device_attribute *attr,
  121. const char *buf, size_t count)
  122. {
  123. struct input_dev *input = to_input_dev(dev);
  124. struct input_dev_poller *poller = input->poller;
  125. unsigned int interval;
  126. int err;
  127. err = kstrtouint(buf, 0, &interval);
  128. if (err)
  129. return err;
  130. if (interval < poller->poll_interval_min)
  131. return -EINVAL;
  132. if (interval > poller->poll_interval_max)
  133. return -EINVAL;
  134. mutex_lock(&input->mutex);
  135. poller->poll_interval = interval;
  136. if (input->users) {
  137. cancel_delayed_work_sync(&poller->work);
  138. if (poller->poll_interval > 0)
  139. input_dev_poller_queue_work(poller);
  140. }
  141. mutex_unlock(&input->mutex);
  142. return count;
  143. }
  144. static DEVICE_ATTR(poll, 0644,
  145. input_dev_get_poll_interval, input_dev_set_poll_interval);
  146. static ssize_t input_dev_get_poll_max(struct device *dev,
  147. struct device_attribute *attr, char *buf)
  148. {
  149. struct input_dev *input = to_input_dev(dev);
  150. return sprintf(buf, "%d\n", input->poller->poll_interval_max);
  151. }
  152. static DEVICE_ATTR(max, 0444, input_dev_get_poll_max, NULL);
  153. static ssize_t input_dev_get_poll_min(struct device *dev,
  154. struct device_attribute *attr, char *buf)
  155. {
  156. struct input_dev *input = to_input_dev(dev);
  157. return sprintf(buf, "%d\n", input->poller->poll_interval_min);
  158. }
  159. static DEVICE_ATTR(min, 0444, input_dev_get_poll_min, NULL);
  160. static umode_t input_poller_attrs_visible(struct kobject *kobj,
  161. struct attribute *attr, int n)
  162. {
  163. struct device *dev = kobj_to_dev(kobj);
  164. struct input_dev *input = to_input_dev(dev);
  165. return input->poller ? attr->mode : 0;
  166. }
  167. static struct attribute *input_poller_attrs[] = {
  168. &dev_attr_poll.attr,
  169. &dev_attr_max.attr,
  170. &dev_attr_min.attr,
  171. NULL
  172. };
  173. struct attribute_group input_poller_attribute_group = {
  174. .is_visible = input_poller_attrs_visible,
  175. .attrs = input_poller_attrs,
  176. };