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         struct gpio_desc *gpiod;
  34         int last_state;
  35         int count;
  36         int threshold;
  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                                    const 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                                          const struct gpio_keys_button *button,
  74                                          struct gpio_keys_button_data *bdata)
  75 {
  76         int state;
  77
  78         state = gpiod_get_value_cansleep(bdata->gpiod);
  79         if (state < 0) {
  80                 dev_err(dev->input->dev.parent,
  81                         "failed to get gpio state: %d\n", state);
  82         } else {
  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
  92 static void gpio_keys_polled_poll(struct input_polled_dev *dev)
  93 {
  94         struct gpio_keys_polled_dev *bdev = dev->private;
  95         const struct gpio_keys_platform_data *pdata = bdev->pdata;
  96         struct input_dev *input = dev->input;
  97         int i;
  98
  99         memset(bdev->rel_axis_seen, 0, sizeof(bdev->rel_axis_seen));
 100         memset(bdev->abs_axis_seen, 0, sizeof(bdev->abs_axis_seen));
 101
 102         for (i = 0; i < pdata->nbuttons; i++) {
 103                 struct gpio_keys_button_data *bdata = &bdev->data[i];
 104
 105                 if (bdata->count < bdata->threshold) {
 106                         bdata->count++;
 107                         gpio_keys_button_event(dev, &pdata->buttons[i],
 108                                                bdata->last_state);
 109                 } else {
 110                         gpio_keys_polled_check_state(dev, &pdata->buttons[i],
 111                                                      bdata);
 112                 }
 113         }
 114
 115         for_each_set_bit(i, input->relbit, REL_CNT) {
 116                 if (!test_bit(i, bdev->rel_axis_seen))
 117                         input_event(input, EV_REL, i, 0);
 118         }
 119
 120         for_each_set_bit(i, input->absbit, ABS_CNT) {
 121                 if (!test_bit(i, bdev->abs_axis_seen))
 122                         input_event(input, EV_ABS, i, 0);
 123         }
 124
 125         input_sync(input);
 126 }
 127
 128 static void gpio_keys_polled_open(struct input_polled_dev *dev)
 129 {
 130         struct gpio_keys_polled_dev *bdev = dev->private;
 131         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 132
 133         if (pdata->enable)
 134                 pdata->enable(bdev->dev);
 135 }
 136
 137 static void gpio_keys_polled_close(struct input_polled_dev *dev)
 138 {
 139         struct gpio_keys_polled_dev *bdev = dev->private;
 140         const struct gpio_keys_platform_data *pdata = bdev->pdata;
 141
 142         if (pdata->disable)
 143                 pdata->disable(bdev->dev);
 144 }
 145
 146 static struct gpio_keys_platform_data *
 147 gpio_keys_polled_get_devtree_pdata(struct device *dev)
 148 {
 149         struct gpio_keys_platform_data *pdata;
 150         struct gpio_keys_button *button;
 151         struct fwnode_handle *child;
 152         int nbuttons;
 153
 154         nbuttons = device_get_child_node_count(dev);
 155         if (nbuttons == 0)
 156                 return ERR_PTR(-EINVAL);
 157
 158         pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
 159                              GFP_KERNEL);
 160         if (!pdata)
 161                 return ERR_PTR(-ENOMEM);
 162
 163         button = (struct gpio_keys_button *)(pdata + 1);
 164
 165         pdata->buttons = button;
 166         pdata->nbuttons = nbuttons;
 167
 168         pdata->rep = device_property_present(dev, "autorepeat");
 169         device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
 170
 171         device_for_each_child_node(dev, child) {
 172                 if (fwnode_property_read_u32(child, "linux,code",
 173                                              &button->code)) {
 174                         dev_err(dev, "button without keycode\n");
 175                         fwnode_handle_put(child);
 176                         return ERR_PTR(-EINVAL);
 177                 }
 178
 179                 fwnode_property_read_string(child, "label", &button->desc);
 180
 181                 if (fwnode_property_read_u32(child, "linux,input-type",
 182                                              &button->type))
 183                         button->type = EV_KEY;
 184
 185                 if (fwnode_property_read_u32(child, "linux,input-value",
 186                                              (u32 *)&button->value))
 187                         button->value = 1;
 188
 189                 button->wakeup =
 190                         fwnode_property_read_bool(child, "wakeup-source") ||
 191                         /* legacy name */
 192                         fwnode_property_read_bool(child, "gpio-key,wakeup");
 193
 194                 if (fwnode_property_read_u32(child, "debounce-interval",
 195                                              &button->debounce_interval))
 196                         button->debounce_interval = 5;
 197
 198                 button++;
 199         }
 200
 201         return pdata;
 202 }
 203
 204 static void gpio_keys_polled_set_abs_params(struct input_dev *input,
 205         const struct gpio_keys_platform_data *pdata, unsigned int code)
 206 {
 207         int i, min = 0, max = 0;
 208
 209         for (i = 0; i < pdata->nbuttons; i++) {
 210                 const struct gpio_keys_button *button = &pdata->buttons[i];
 211
 212                 if (button->type != EV_ABS || button->code != code)
 213                         continue;
 214
 215                 if (button->value < min)
 216                         min = button->value;
 217                 if (button->value > max)
 218                         max = button->value;
 219         }
 220
 221         input_set_abs_params(input, code, min, max, 0, 0);
 222 }
 223
 224 static const struct of_device_id gpio_keys_polled_of_match[] = {
 225         { .compatible = "gpio-keys-polled", },
 226         { },
 227 };
 228 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
 229
 230 static int gpio_keys_polled_probe(struct platform_device *pdev)
 231 {
 232         struct device *dev = &pdev->dev;
 233         struct fwnode_handle *child = NULL;
 234         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
 235         struct gpio_keys_polled_dev *bdev;
 236         struct input_polled_dev *poll_dev;
 237         struct input_dev *input;
 238         size_t size;
 239         int error;
 240         int i;
 241
 242         if (!pdata) {
 243                 pdata = gpio_keys_polled_get_devtree_pdata(dev);
 244                 if (IS_ERR(pdata))
 245                         return PTR_ERR(pdata);
 246         }
 247
 248         if (!pdata->poll_interval) {
 249                 dev_err(dev, "missing poll_interval value\n");
 250                 return -EINVAL;
 251         }
 252
 253         size = sizeof(struct gpio_keys_polled_dev) +
 254                         pdata->nbuttons * sizeof(struct gpio_keys_button_data);
 255         bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
 256         if (!bdev) {
 257                 dev_err(dev, "no memory for private data\n");
 258                 return -ENOMEM;
 259         }
 260
 261         poll_dev = devm_input_allocate_polled_device(&pdev->dev);
 262         if (!poll_dev) {
 263                 dev_err(dev, "no memory for polled device\n");
 264                 return -ENOMEM;
 265         }
 266
 267         poll_dev->private = bdev;
 268         poll_dev->poll = gpio_keys_polled_poll;
 269         poll_dev->poll_interval = pdata->poll_interval;
 270         poll_dev->open = gpio_keys_polled_open;
 271         poll_dev->close = gpio_keys_polled_close;
 272
 273         input = poll_dev->input;
 274
 275         input->name = pdev->name;
 276         input->phys = DRV_NAME"/input0";
 277
 278         input->id.bustype = BUS_HOST;
 279         input->id.vendor = 0x0001;
 280         input->id.product = 0x0001;
 281         input->id.version = 0x0100;
 282
 283         __set_bit(EV_KEY, input->evbit);
 284         if (pdata->rep)
 285                 __set_bit(EV_REP, input->evbit);
 286
 287         for (i = 0; i < pdata->nbuttons; i++) {
 288                 const struct gpio_keys_button *button = &pdata->buttons[i];
 289                 struct gpio_keys_button_data *bdata = &bdev->data[i];
 290                 unsigned int type = button->type ?: EV_KEY;
 291
 292                 if (button->wakeup) {
 293                         dev_err(dev, DRV_NAME " does not support wakeup\n");
 294                         fwnode_handle_put(child);
 295                         return -EINVAL;
 296                 }
 297
 298                 if (!dev_get_platdata(dev)) {
 299                         /* No legacy static platform data */
 300                         child = device_get_next_child_node(dev, child);
 301                         if (!child) {
 302                                 dev_err(dev, "missing child device node\n");
 303                                 return -EINVAL;
 304                         }
 305
 306                         bdata->gpiod = devm_get_gpiod_from_child(dev, NULL,
 307                                                                  child);
 308                         if (IS_ERR(bdata->gpiod)) {
 309                                 error = PTR_ERR(bdata->gpiod);
 310                                 if (error != -EPROBE_DEFER)
 311                                         dev_err(dev,
 312                                                 "failed to get gpio: %d\n",
 313                                                 error);
 314                                 fwnode_handle_put(child);
 315                                 return error;
 316                         }
 317
 318                         error = gpiod_direction_input(bdata->gpiod);
 319                         if (error) {
 320                                 dev_err(dev, "Failed to configure GPIO %d as input: %d\n",
 321                                         desc_to_gpio(bdata->gpiod), error);
 322                                 fwnode_handle_put(child);
 323                                 return error;
 324                         }
 325                 } else if (gpio_is_valid(button->gpio)) {
 326                         /*
 327                          * Legacy GPIO number so request the GPIO here and
 328                          * convert it to descriptor.
 329                          */
 330                         unsigned flags = GPIOF_IN;
 331
 332                         if (button->active_low)
 333                                 flags |= GPIOF_ACTIVE_LOW;
 334
 335                         error = devm_gpio_request_one(&pdev->dev, button->gpio,
 336                                         flags, button->desc ? : DRV_NAME);
 337                         if (error) {
 338                                 dev_err(dev,
 339                                         "unable to claim gpio %u, err=%d\n",
 340                                         button->gpio, error);
 341                                 return error;
 342                         }
 343
 344                         bdata->gpiod = gpio_to_desc(button->gpio);
 345                         if (!bdata->gpiod) {
 346                                 dev_err(dev,
 347                                         "unable to convert gpio %u to descriptor\n",
 348                                         button->gpio);
 349                                 return -EINVAL;
 350                         }
 351                 }
 352
 353                 bdata->last_state = -1;
 354                 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
 355                                                 pdata->poll_interval);
 356
 357                 input_set_capability(input, type, button->code);
 358                 if (type == EV_ABS)
 359                         gpio_keys_polled_set_abs_params(input, pdata,
 360                                                         button->code);
 361         }
 362
 363         fwnode_handle_put(child);
 364
 365         bdev->poll_dev = poll_dev;
 366         bdev->dev = dev;
 367         bdev->pdata = pdata;
 368         platform_set_drvdata(pdev, bdev);
 369
 370         error = input_register_polled_device(poll_dev);
 371         if (error) {
 372                 dev_err(dev, "unable to register polled device, err=%d\n",
 373                         error);
 374                 return error;
 375         }
 376
 377         /* report initial state of the buttons */
 378         for (i = 0; i < pdata->nbuttons; i++)
 379                 gpio_keys_polled_check_state(poll_dev, &pdata->buttons[i],
 380                                              &bdev->data[i]);
 381
 382         input_sync(input);
 383
 384         return 0;
 385 }
 386
 387 static struct platform_driver gpio_keys_polled_driver = {
 388         .probe  = gpio_keys_polled_probe,
 389         .driver = {
 390                 .name   = DRV_NAME,
 391                 .of_match_table = gpio_keys_polled_of_match,
 392         },
 393 };
 394 module_platform_driver(gpio_keys_polled_driver);
 395
 396 MODULE_LICENSE("GPL v2");
 397 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 398 MODULE_DESCRIPTION("Polled GPIO Buttons driver");
 399 MODULE_ALIAS("platform:" DRV_NAME);