drivers/input/keyboard/gpio_keys_polled.c

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