Version:  2.0.40 2.2.26 2.4.37 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6

Linux/drivers/input/keyboard/gpio_keys_polled.c

  1 /*
  2  *  Driver for buttons on GPIO lines not capable of generating interrupts
  3  *
  4  *  Copyright (C) 2007-2010 Gabor Juhos <juhosg@openwrt.org>
  5  *  Copyright (C) 2010 Nuno Goncalves <nunojpg@gmail.com>
  6  *
  7  *  This file was based on: /drivers/input/misc/cobalt_btns.c
  8  *      Copyright (C) 2007 Yoichi Yuasa <yoichi_yuasa@tripeaks.co.jp>
  9  *
 10  *  also was based on: /drivers/input/keyboard/gpio_keys.c
 11  *      Copyright 2005 Phil Blundell
 12  *
 13  *  This program is free software; you can redistribute it and/or modify
 14  *  it under the terms of the GNU General Public License version 2 as
 15  *  published by the Free Software Foundation.
 16  */
 17 
 18 #include <linux/kernel.h>
 19 #include <linux/module.h>
 20 #include <linux/slab.h>
 21 #include <linux/input.h>
 22 #include <linux/input-polldev.h>
 23 #include <linux/ioport.h>
 24 #include <linux/platform_device.h>
 25 #include <linux/gpio.h>
 26 #include <linux/gpio/consumer.h>
 27 #include <linux/gpio_keys.h>
 28 #include <linux/property.h>
 29 
 30 #define DRV_NAME        "gpio-keys-polled"
 31 
 32 struct gpio_keys_button_data {
 33         int last_state;
 34         int count;
 35         int threshold;
 36         int can_sleep;
 37 };
 38 
 39 struct gpio_keys_polled_dev {
 40         struct input_polled_dev *poll_dev;
 41         struct device *dev;
 42         const struct gpio_keys_platform_data *pdata;
 43         unsigned long rel_axis_seen[BITS_TO_LONGS(REL_CNT)];
 44         unsigned long abs_axis_seen[BITS_TO_LONGS(ABS_CNT)];
 45         struct gpio_keys_button_data data[0];
 46 };
 47 
 48 static void gpio_keys_button_event(struct input_polled_dev *dev,
 49                                    struct gpio_keys_button *button,
 50                                    int state)
 51 {
 52         struct gpio_keys_polled_dev *bdev = dev->private;
 53         struct input_dev *input = dev->input;
 54         unsigned int type = button->type ?: EV_KEY;
 55 
 56         if (type == EV_REL) {
 57                 if (state) {
 58                         input_event(input, type, button->code, button->value);
 59                         __set_bit(button->code, bdev->rel_axis_seen);
 60                 }
 61         } else if (type == EV_ABS) {
 62                 if (state) {
 63                         input_event(input, type, button->code, button->value);
 64                         __set_bit(button->code, bdev->abs_axis_seen);
 65                 }
 66         } else {
 67                 input_event(input, type, button->code, state);
 68                 input_sync(input);
 69         }
 70 }
 71 
 72 static void gpio_keys_polled_check_state(struct input_polled_dev *dev,
 73                                          struct gpio_keys_button *button,
 74                                          struct gpio_keys_button_data *bdata)
 75 {
 76         int state;
 77 
 78         if (bdata->can_sleep)
 79                 state = !!gpiod_get_value_cansleep(button->gpiod);
 80         else
 81                 state = !!gpiod_get_value(button->gpiod);
 82 
 83         gpio_keys_button_event(dev, button, state);
 84 
 85         if (state != bdata->last_state) {
 86                 bdata->count = 0;
 87                 bdata->last_state = state;
 88         }
 89 }
 90 
 91 static void gpio_keys_polled_poll(struct input_polled_dev *dev)
 92 {
 93         struct gpio_keys_polled_dev *bdev = dev->private;
 94         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 95         struct input_dev *input = dev->input;
 96         int i;
 97 
 98         memset(bdev->rel_axis_seen, 0, sizeof(bdev->rel_axis_seen));
 99         memset(bdev->abs_axis_seen, 0, sizeof(bdev->abs_axis_seen));
100 
101         for (i = 0; i < pdata->nbuttons; i++) {
102                 struct gpio_keys_button_data *bdata = &bdev->data[i];
103 
104                 if (bdata->count < bdata->threshold) {
105                         bdata->count++;
106                         gpio_keys_button_event(dev, &pdata->buttons[i],
107                                                bdata->last_state);
108                 } else {
109                         gpio_keys_polled_check_state(dev, &pdata->buttons[i],
110                                                      bdata);
111                 }
112         }
113 
114         for_each_set_bit(i, input->relbit, REL_CNT) {
115                 if (!test_bit(i, bdev->rel_axis_seen))
116                         input_event(input, EV_REL, i, 0);
117         }
118 
119         for_each_set_bit(i, input->absbit, ABS_CNT) {
120                 if (!test_bit(i, bdev->abs_axis_seen))
121                         input_event(input, EV_ABS, i, 0);
122         }
123 
124         input_sync(input);
125 }
126 
127 static void gpio_keys_polled_open(struct input_polled_dev *dev)
128 {
129         struct gpio_keys_polled_dev *bdev = dev->private;
130         const struct gpio_keys_platform_data *pdata = bdev->pdata;
131 
132         if (pdata->enable)
133                 pdata->enable(bdev->dev);
134 }
135 
136 static void gpio_keys_polled_close(struct input_polled_dev *dev)
137 {
138         struct gpio_keys_polled_dev *bdev = dev->private;
139         const struct gpio_keys_platform_data *pdata = bdev->pdata;
140 
141         if (pdata->disable)
142                 pdata->disable(bdev->dev);
143 }
144 
145 static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct device *dev)
146 {
147         struct gpio_keys_platform_data *pdata;
148         struct gpio_keys_button *button;
149         struct fwnode_handle *child;
150         int error;
151         int nbuttons;
152 
153         nbuttons = device_get_child_node_count(dev);
154         if (nbuttons == 0)
155                 return NULL;
156 
157         pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
158                              GFP_KERNEL);
159         if (!pdata)
160                 return ERR_PTR(-ENOMEM);
161 
162         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
163 
164         pdata->rep = device_property_present(dev, "autorepeat");
165         device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
166 
167         device_for_each_child_node(dev, child) {
168                 struct gpio_desc *desc;
169 
170                 desc = devm_get_gpiod_from_child(dev, NULL, child);
171                 if (IS_ERR(desc)) {
172                         error = PTR_ERR(desc);
173                         if (error != -EPROBE_DEFER)
174                                 dev_err(dev,
175                                         "Failed to get gpio flags, error: %d\n",
176                                         error);
177                         fwnode_handle_put(child);
178                         return ERR_PTR(error);
179                 }
180 
181                 button = &pdata->buttons[pdata->nbuttons++];
182                 button->gpiod = desc;
183 
184                 if (fwnode_property_read_u32(child, "linux,code", &button->code)) {
185                         dev_err(dev, "Button without keycode: %d\n",
186                                 pdata->nbuttons - 1);
187                         fwnode_handle_put(child);
188                         return ERR_PTR(-EINVAL);
189                 }
190 
191                 fwnode_property_read_string(child, "label", &button->desc);
192 
193                 if (fwnode_property_read_u32(child, "linux,input-type",
194                                              &button->type))
195                         button->type = EV_KEY;
196 
197                 if (fwnode_property_read_u32(child, "linux,input-value",
198                                              (u32 *)&button->value))
199                         button->value = 1;
200 
201                 button->wakeup =
202                         fwnode_property_read_bool(child, "wakeup-source") ||
203                         /* legacy name */
204                         fwnode_property_read_bool(child, "gpio-key,wakeup");
205 
206                 if (fwnode_property_read_u32(child, "debounce-interval",
207                                              &button->debounce_interval))
208                         button->debounce_interval = 5;
209         }
210 
211         if (pdata->nbuttons == 0)
212                 return ERR_PTR(-EINVAL);
213 
214         return pdata;
215 }
216 
217 static void gpio_keys_polled_set_abs_params(struct input_dev *input,
218         const struct gpio_keys_platform_data *pdata, unsigned int code)
219 {
220         int i, min = 0, max = 0;
221 
222         for (i = 0; i < pdata->nbuttons; i++) {
223                 struct gpio_keys_button *button = &pdata->buttons[i];
224 
225                 if (button->type != EV_ABS || button->code != code)
226                         continue;
227 
228                 if (button->value < min)
229                         min = button->value;
230                 if (button->value > max)
231                         max = button->value;
232         }
233         input_set_abs_params(input, code, min, max, 0, 0);
234 }
235 
236 static const struct of_device_id gpio_keys_polled_of_match[] = {
237         { .compatible = "gpio-keys-polled", },
238         { },
239 };
240 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
241 
242 static int gpio_keys_polled_probe(struct platform_device *pdev)
243 {
244         struct device *dev = &pdev->dev;
245         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
246         struct gpio_keys_polled_dev *bdev;
247         struct input_polled_dev *poll_dev;
248         struct input_dev *input;
249         size_t size;
250         int error;
251         int i;
252 
253         if (!pdata) {
254                 pdata = gpio_keys_polled_get_devtree_pdata(dev);
255                 if (IS_ERR(pdata))
256                         return PTR_ERR(pdata);
257                 if (!pdata) {
258                         dev_err(dev, "missing platform data\n");
259                         return -EINVAL;
260                 }
261         }
262 
263         if (!pdata->poll_interval) {
264                 dev_err(dev, "missing poll_interval value\n");
265                 return -EINVAL;
266         }
267 
268         size = sizeof(struct gpio_keys_polled_dev) +
269                         pdata->nbuttons * sizeof(struct gpio_keys_button_data);
270         bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
271         if (!bdev) {
272                 dev_err(dev, "no memory for private data\n");
273                 return -ENOMEM;
274         }
275 
276         poll_dev = devm_input_allocate_polled_device(&pdev->dev);
277         if (!poll_dev) {
278                 dev_err(dev, "no memory for polled device\n");
279                 return -ENOMEM;
280         }
281 
282         poll_dev->private = bdev;
283         poll_dev->poll = gpio_keys_polled_poll;
284         poll_dev->poll_interval = pdata->poll_interval;
285         poll_dev->open = gpio_keys_polled_open;
286         poll_dev->close = gpio_keys_polled_close;
287 
288         input = poll_dev->input;
289 
290         input->name = pdev->name;
291         input->phys = DRV_NAME"/input0";
292 
293         input->id.bustype = BUS_HOST;
294         input->id.vendor = 0x0001;
295         input->id.product = 0x0001;
296         input->id.version = 0x0100;
297 
298         __set_bit(EV_KEY, input->evbit);
299         if (pdata->rep)
300                 __set_bit(EV_REP, input->evbit);
301 
302         for (i = 0; i < pdata->nbuttons; i++) {
303                 struct gpio_keys_button *button = &pdata->buttons[i];
304                 struct gpio_keys_button_data *bdata = &bdev->data[i];
305                 unsigned int type = button->type ?: EV_KEY;
306 
307                 if (button->wakeup) {
308                         dev_err(dev, DRV_NAME " does not support wakeup\n");
309                         return -EINVAL;
310                 }
311 
312                 /*
313                  * Legacy GPIO number so request the GPIO here and
314                  * convert it to descriptor.
315                  */
316                 if (!button->gpiod && gpio_is_valid(button->gpio)) {
317                         unsigned flags = GPIOF_IN;
318 
319                         if (button->active_low)
320                                 flags |= GPIOF_ACTIVE_LOW;
321 
322                         error = devm_gpio_request_one(&pdev->dev, button->gpio,
323                                         flags, button->desc ? : DRV_NAME);
324                         if (error) {
325                                 dev_err(dev, "unable to claim gpio %u, err=%d\n",
326                                         button->gpio, error);
327                                 return error;
328                         }
329 
330                         button->gpiod = gpio_to_desc(button->gpio);
331                 }
332 
333                 if (IS_ERR(button->gpiod))
334                         return PTR_ERR(button->gpiod);
335 
336                 bdata->can_sleep = gpiod_cansleep(button->gpiod);
337                 bdata->last_state = -1;
338                 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
339                                                 pdata->poll_interval);
340 
341                 input_set_capability(input, type, button->code);
342                 if (type == EV_ABS)
343                         gpio_keys_polled_set_abs_params(input, pdata,
344                                                         button->code);
345         }
346 
347         bdev->poll_dev = poll_dev;
348         bdev->dev = dev;
349         bdev->pdata = pdata;
350         platform_set_drvdata(pdev, bdev);
351 
352         error = input_register_polled_device(poll_dev);
353         if (error) {
354                 dev_err(dev, "unable to register polled device, err=%d\n",
355                         error);
356                 return error;
357         }
358 
359         /* report initial state of the buttons */
360         for (i = 0; i < pdata->nbuttons; i++)
361                 gpio_keys_polled_check_state(poll_dev, &pdata->buttons[i],
362                                              &bdev->data[i]);
363 
364         input_sync(input);
365 
366         return 0;
367 }
368 
369 static struct platform_driver gpio_keys_polled_driver = {
370         .probe  = gpio_keys_polled_probe,
371         .driver = {
372                 .name   = DRV_NAME,
373                 .of_match_table = gpio_keys_polled_of_match,
374         },
375 };
376 module_platform_driver(gpio_keys_polled_driver);
377 
378 MODULE_LICENSE("GPL v2");
379 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
380 MODULE_DESCRIPTION("Polled GPIO Buttons driver");
381 MODULE_ALIAS("platform:" DRV_NAME);
382 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us