Version:  2.0.40 2.2.26 2.4.37 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0

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         struct gpio_keys_button_data data[0];
 44 };
 45 
 46 static void gpio_keys_polled_check_state(struct input_dev *input,
 47                                          struct gpio_keys_button *button,
 48                                          struct gpio_keys_button_data *bdata)
 49 {
 50         int state;
 51 
 52         if (bdata->can_sleep)
 53                 state = !!gpiod_get_value_cansleep(button->gpiod);
 54         else
 55                 state = !!gpiod_get_value(button->gpiod);
 56 
 57         if (state != bdata->last_state) {
 58                 unsigned int type = button->type ?: EV_KEY;
 59 
 60                 input_event(input, type, button->code, state);
 61                 input_sync(input);
 62                 bdata->count = 0;
 63                 bdata->last_state = state;
 64         }
 65 }
 66 
 67 static void gpio_keys_polled_poll(struct input_polled_dev *dev)
 68 {
 69         struct gpio_keys_polled_dev *bdev = dev->private;
 70         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 71         struct input_dev *input = dev->input;
 72         int i;
 73 
 74         for (i = 0; i < pdata->nbuttons; i++) {
 75                 struct gpio_keys_button_data *bdata = &bdev->data[i];
 76 
 77                 if (bdata->count < bdata->threshold)
 78                         bdata->count++;
 79                 else
 80                         gpio_keys_polled_check_state(input, &pdata->buttons[i],
 81                                                      bdata);
 82         }
 83 }
 84 
 85 static void gpio_keys_polled_open(struct input_polled_dev *dev)
 86 {
 87         struct gpio_keys_polled_dev *bdev = dev->private;
 88         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 89 
 90         if (pdata->enable)
 91                 pdata->enable(bdev->dev);
 92 }
 93 
 94 static void gpio_keys_polled_close(struct input_polled_dev *dev)
 95 {
 96         struct gpio_keys_polled_dev *bdev = dev->private;
 97         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 98 
 99         if (pdata->disable)
100                 pdata->disable(bdev->dev);
101 }
102 
103 static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct device *dev)
104 {
105         struct gpio_keys_platform_data *pdata;
106         struct gpio_keys_button *button;
107         struct fwnode_handle *child;
108         int error;
109         int nbuttons;
110 
111         nbuttons = device_get_child_node_count(dev);
112         if (nbuttons == 0)
113                 return NULL;
114 
115         pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
116                              GFP_KERNEL);
117         if (!pdata)
118                 return ERR_PTR(-ENOMEM);
119 
120         pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
121 
122         pdata->rep = device_property_present(dev, "autorepeat");
123         device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
124 
125         device_for_each_child_node(dev, child) {
126                 struct gpio_desc *desc;
127 
128                 desc = devm_get_gpiod_from_child(dev, child);
129                 if (IS_ERR(desc)) {
130                         error = PTR_ERR(desc);
131                         if (error != -EPROBE_DEFER)
132                                 dev_err(dev,
133                                         "Failed to get gpio flags, error: %d\n",
134                                         error);
135                         fwnode_handle_put(child);
136                         return ERR_PTR(error);
137                 }
138 
139                 button = &pdata->buttons[pdata->nbuttons++];
140                 button->gpiod = desc;
141 
142                 if (fwnode_property_read_u32(child, "linux,code", &button->code)) {
143                         dev_err(dev, "Button without keycode: %d\n",
144                                 pdata->nbuttons - 1);
145                         fwnode_handle_put(child);
146                         return ERR_PTR(-EINVAL);
147                 }
148 
149                 fwnode_property_read_string(child, "label", &button->desc);
150 
151                 if (fwnode_property_read_u32(child, "linux,input-type",
152                                              &button->type))
153                         button->type = EV_KEY;
154 
155                 button->wakeup = fwnode_property_present(child, "gpio-key,wakeup");
156 
157                 if (fwnode_property_read_u32(child, "debounce-interval",
158                                              &button->debounce_interval))
159                         button->debounce_interval = 5;
160         }
161 
162         if (pdata->nbuttons == 0)
163                 return ERR_PTR(-EINVAL);
164 
165         return pdata;
166 }
167 
168 static const struct of_device_id gpio_keys_polled_of_match[] = {
169         { .compatible = "gpio-keys-polled", },
170         { },
171 };
172 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
173 
174 static int gpio_keys_polled_probe(struct platform_device *pdev)
175 {
176         struct device *dev = &pdev->dev;
177         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
178         struct gpio_keys_polled_dev *bdev;
179         struct input_polled_dev *poll_dev;
180         struct input_dev *input;
181         size_t size;
182         int error;
183         int i;
184 
185         if (!pdata) {
186                 pdata = gpio_keys_polled_get_devtree_pdata(dev);
187                 if (IS_ERR(pdata))
188                         return PTR_ERR(pdata);
189                 if (!pdata) {
190                         dev_err(dev, "missing platform data\n");
191                         return -EINVAL;
192                 }
193         }
194 
195         if (!pdata->poll_interval) {
196                 dev_err(dev, "missing poll_interval value\n");
197                 return -EINVAL;
198         }
199 
200         size = sizeof(struct gpio_keys_polled_dev) +
201                         pdata->nbuttons * sizeof(struct gpio_keys_button_data);
202         bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
203         if (!bdev) {
204                 dev_err(dev, "no memory for private data\n");
205                 return -ENOMEM;
206         }
207 
208         poll_dev = devm_input_allocate_polled_device(&pdev->dev);
209         if (!poll_dev) {
210                 dev_err(dev, "no memory for polled device\n");
211                 return -ENOMEM;
212         }
213 
214         poll_dev->private = bdev;
215         poll_dev->poll = gpio_keys_polled_poll;
216         poll_dev->poll_interval = pdata->poll_interval;
217         poll_dev->open = gpio_keys_polled_open;
218         poll_dev->close = gpio_keys_polled_close;
219 
220         input = poll_dev->input;
221 
222         input->name = pdev->name;
223         input->phys = DRV_NAME"/input0";
224 
225         input->id.bustype = BUS_HOST;
226         input->id.vendor = 0x0001;
227         input->id.product = 0x0001;
228         input->id.version = 0x0100;
229 
230         __set_bit(EV_KEY, input->evbit);
231         if (pdata->rep)
232                 __set_bit(EV_REP, input->evbit);
233 
234         for (i = 0; i < pdata->nbuttons; i++) {
235                 struct gpio_keys_button *button = &pdata->buttons[i];
236                 struct gpio_keys_button_data *bdata = &bdev->data[i];
237                 unsigned int type = button->type ?: EV_KEY;
238 
239                 if (button->wakeup) {
240                         dev_err(dev, DRV_NAME " does not support wakeup\n");
241                         return -EINVAL;
242                 }
243 
244                 /*
245                  * Legacy GPIO number so request the GPIO here and
246                  * convert it to descriptor.
247                  */
248                 if (!button->gpiod && gpio_is_valid(button->gpio)) {
249                         unsigned flags = 0;
250 
251                         if (button->active_low)
252                                 flags |= GPIOF_ACTIVE_LOW;
253 
254                         error = devm_gpio_request_one(&pdev->dev, button->gpio,
255                                         flags, button->desc ? : DRV_NAME);
256                         if (error) {
257                                 dev_err(dev, "unable to claim gpio %u, err=%d\n",
258                                         button->gpio, error);
259                                 return error;
260                         }
261 
262                         button->gpiod = gpio_to_desc(button->gpio);
263                 }
264 
265                 if (IS_ERR(button->gpiod))
266                         return PTR_ERR(button->gpiod);
267 
268                 bdata->can_sleep = gpiod_cansleep(button->gpiod);
269                 bdata->last_state = -1;
270                 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
271                                                 pdata->poll_interval);
272 
273                 input_set_capability(input, type, button->code);
274         }
275 
276         bdev->poll_dev = poll_dev;
277         bdev->dev = dev;
278         bdev->pdata = pdata;
279         platform_set_drvdata(pdev, bdev);
280 
281         error = input_register_polled_device(poll_dev);
282         if (error) {
283                 dev_err(dev, "unable to register polled device, err=%d\n",
284                         error);
285                 return error;
286         }
287 
288         /* report initial state of the buttons */
289         for (i = 0; i < pdata->nbuttons; i++)
290                 gpio_keys_polled_check_state(input, &pdata->buttons[i],
291                                              &bdev->data[i]);
292 
293         return 0;
294 }
295 
296 static struct platform_driver gpio_keys_polled_driver = {
297         .probe  = gpio_keys_polled_probe,
298         .driver = {
299                 .name   = DRV_NAME,
300                 .of_match_table = gpio_keys_polled_of_match,
301         },
302 };
303 module_platform_driver(gpio_keys_polled_driver);
304 
305 MODULE_LICENSE("GPL v2");
306 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
307 MODULE_DESCRIPTION("Polled GPIO Buttons driver");
308 MODULE_ALIAS("platform:" DRV_NAME);
309 

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