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[];
  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         int nbuttons;
 148
 149         nbuttons = device_get_child_node_count(dev);
 150         if (nbuttons == 0)
 151                 return ERR_PTR(-EINVAL);
 152
 153         pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
 154                              GFP_KERNEL);
 155         if (!pdata)
 156                 return ERR_PTR(-ENOMEM);
 157
 158         button = (struct gpio_keys_button *)(pdata + 1);
 159
 160         pdata->buttons = button;
 161         pdata->nbuttons = nbuttons;
 162
 163         pdata->rep = device_property_present(dev, "autorepeat");
 164         device_property_read_u32(dev, "poll-interval", &pdata->poll_interval);
 165
 166         device_property_read_string(dev, "label", &pdata->name);
 167
 168         device_for_each_child_node_scoped(dev, child) {
 169                 if (fwnode_property_read_u32(child, "linux,code",
 170                                              &button->code)) {
 171                         dev_err(dev, "button without keycode\n");
 172                         return ERR_PTR(-EINVAL);
 173                 }
 174
 175                 fwnode_property_read_string(child, "label", &button->desc);
 176
 177                 if (fwnode_property_read_u32(child, "linux,input-type",
 178                                              &button->type))
 179                         button->type = EV_KEY;
 180
 181                 if (fwnode_property_read_u32(child, "linux,input-value",
 182                                              (u32 *)&button->value))
 183                         button->value = 1;
 184
 185                 button->wakeup =
 186                         fwnode_property_read_bool(child, "wakeup-source") ||
 187                         /* legacy name */
 188                         fwnode_property_read_bool(child, "gpio-key,wakeup");
 189
 190                 if (fwnode_property_read_u32(child, "debounce-interval",
 191                                              &button->debounce_interval))
 192                         button->debounce_interval = 5;
 193
 194                 button++;
 195         }
 196
 197         return pdata;
 198 }
 199
 200 static void gpio_keys_polled_set_abs_params(struct input_dev *input,
 201         const struct gpio_keys_platform_data *pdata, unsigned int code)
 202 {
 203         int i, min = 0, max = 0;
 204
 205         for (i = 0; i < pdata->nbuttons; i++) {
 206                 const struct gpio_keys_button *button = &pdata->buttons[i];
 207
 208                 if (button->type != EV_ABS || button->code != code)
 209                         continue;
 210
 211                 if (button->value < min)
 212                         min = button->value;
 213                 if (button->value > max)
 214                         max = button->value;
 215         }
 216
 217         input_set_abs_params(input, code, min, max, 0, 0);
 218 }
 219
 220 static const struct of_device_id gpio_keys_polled_of_match[] = {
 221         { .compatible = "gpio-keys-polled", },
 222         { },
 223 };
 224 MODULE_DEVICE_TABLE(of, gpio_keys_polled_of_match);
 225
 226 static int gpio_keys_polled_probe(struct platform_device *pdev)
 227 {
 228         struct device *dev = &pdev->dev;
 229         struct fwnode_handle *child = NULL;
 230         const struct gpio_keys_platform_data *pdata = dev_get_platdata(dev);
 231         struct gpio_keys_polled_dev *bdev;
 232         struct input_dev *input;
 233         int error;
 234         int i;
 235
 236         if (!pdata) {
 237                 pdata = gpio_keys_polled_get_devtree_pdata(dev);
 238                 if (IS_ERR(pdata))
 239                         return PTR_ERR(pdata);
 240         }
 241
 242         if (!pdata->poll_interval) {
 243                 dev_err(dev, "missing poll_interval value\n");
 244                 return -EINVAL;
 245         }
 246
 247         bdev = devm_kzalloc(dev, struct_size(bdev, data, pdata->nbuttons),
 248                             GFP_KERNEL);
 249         if (!bdev) {
 250                 dev_err(dev, "no memory for private data\n");
 251                 return -ENOMEM;
 252         }
 253
 254         input = devm_input_allocate_device(dev);
 255         if (!input) {
 256                 dev_err(dev, "no memory for input device\n");
 257                 return -ENOMEM;
 258         }
 259
 260         input_set_drvdata(input, bdev);
 261
 262         input->name = pdata->name ?: pdev->name;
 263         input->phys = DRV_NAME"/input0";
 264
 265         input->id.bustype = BUS_HOST;
 266         input->id.vendor = 0x0001;
 267         input->id.product = 0x0001;
 268         input->id.version = 0x0100;
 269
 270         input->open = gpio_keys_polled_open;
 271         input->close = gpio_keys_polled_close;
 272
 273         __set_bit(EV_KEY, input->evbit);
 274         if (pdata->rep)
 275                 __set_bit(EV_REP, input->evbit);
 276
 277         for (i = 0; i < pdata->nbuttons; i++) {
 278                 const struct gpio_keys_button *button = &pdata->buttons[i];
 279                 struct gpio_keys_button_data *bdata = &bdev->data[i];
 280                 unsigned int type = button->type ?: EV_KEY;
 281
 282                 if (button->wakeup) {
 283                         dev_err(dev, DRV_NAME " does not support wakeup\n");
 284                         fwnode_handle_put(child);
 285                         return -EINVAL;
 286                 }
 287
 288                 if (!dev_get_platdata(dev)) {
 289                         /* No legacy static platform data */
 290                         child = device_get_next_child_node(dev, child);
 291                         if (!child) {
 292                                 dev_err(dev, "missing child device node\n");
 293                                 return -EINVAL;
 294                         }
 295
 296                         bdata->gpiod = devm_fwnode_gpiod_get(dev, child,
 297                                                              NULL, GPIOD_IN,
 298                                                              button->desc);
 299                         if (IS_ERR(bdata->gpiod)) {
 300                                 fwnode_handle_put(child);
 301                                 return dev_err_probe(dev, PTR_ERR(bdata->gpiod),
 302                                                      "failed to get gpio\n");
 303                         }
 304                 } else if (gpio_is_valid(button->gpio)) {
 305                         /*
 306                          * Legacy GPIO number so request the GPIO here and
 307                          * convert it to descriptor.
 308                          */
 309                         unsigned flags = GPIOF_IN;
 310
 311                         if (button->active_low)
 312                                 flags |= GPIOF_ACTIVE_LOW;
 313
 314                         error = devm_gpio_request_one(dev, button->gpio,
 315                                         flags, button->desc ? : DRV_NAME);
 316                         if (error)
 317                                 return dev_err_probe(dev, error,
 318                                                      "unable to claim gpio %u\n",
 319                                                      button->gpio);
 320
 321                         bdata->gpiod = gpio_to_desc(button->gpio);
 322                         if (!bdata->gpiod) {
 323                                 dev_err(dev,
 324                                         "unable to convert gpio %u to descriptor\n",
 325                                         button->gpio);
 326                                 return -EINVAL;
 327                         }
 328                 }
 329
 330                 bdata->last_state = -1;
 331                 bdata->threshold = DIV_ROUND_UP(button->debounce_interval,
 332                                                 pdata->poll_interval);
 333
 334                 input_set_capability(input, type, button->code);
 335                 if (type == EV_ABS)
 336                         gpio_keys_polled_set_abs_params(input, pdata,
 337                                                         button->code);
 338         }
 339
 340         fwnode_handle_put(child);
 341
 342         bdev->input = input;
 343         bdev->dev = dev;
 344         bdev->pdata = pdata;
 345
 346         error = input_setup_polling(input, gpio_keys_polled_poll);
 347         if (error) {
 348                 dev_err(dev, "unable to set up polling, err=%d\n", error);
 349                 return error;
 350         }
 351
 352         input_set_poll_interval(input, pdata->poll_interval);
 353
 354         error = input_register_device(input);
 355         if (error) {
 356                 dev_err(dev, "unable to register polled device, err=%d\n",
 357                         error);
 358                 return error;
 359         }
 360
 361         /* report initial state of the buttons */
 362         for (i = 0; i < pdata->nbuttons; i++)
 363                 gpio_keys_polled_check_state(input, &pdata->buttons[i],
 364                                              &bdev->data[i]);
 365
 366         input_sync(input);
 367
 368         return 0;
 369 }
 370
 371 static struct platform_driver gpio_keys_polled_driver = {
 372         .probe  = gpio_keys_polled_probe,
 373         .driver = {
 374                 .name   = DRV_NAME,
 375                 .of_match_table = gpio_keys_polled_of_match,
 376         },
 377 };
 378 module_platform_driver(gpio_keys_polled_driver);
 379
 380 MODULE_LICENSE("GPL v2");
 381 MODULE_AUTHOR("Gabor Juhos <juhosg@openwrt.org>");
 382 MODULE_DESCRIPTION("Polled GPIO Buttons driver");
 383 MODULE_ALIAS("platform:" DRV_NAME);