drivers/input/keyboard/matrix_keypad.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  GPIO driven matrix keyboard driver
   4  *
   5  *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
   6  *
   7  *  Based on corgikbd.c
   8  */
   9
  10 #include <linux/types.h>
  11 #include <linux/delay.h>
  12 #include <linux/gpio/consumer.h>
  13 #include <linux/platform_device.h>
  14 #include <linux/input.h>
  15 #include <linux/irq.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/jiffies.h>
  18 #include <linux/module.h>
  19 #include <linux/gpio.h>
  20 #include <linux/input/matrix_keypad.h>
  21 #include <linux/slab.h>
  22 #include <linux/of.h>
  23
  24 struct matrix_keypad {
  25         struct input_dev *input_dev;
  26         unsigned int row_shift;
  27
  28         unsigned int col_scan_delay_us;
  29         /* key debounce interval in milli-second */
  30         unsigned int debounce_ms;
  31         bool drive_inactive_cols;
  32
  33         struct gpio_desc *row_gpios[MATRIX_MAX_ROWS];
  34         unsigned int num_row_gpios;
  35
  36         struct gpio_desc *col_gpios[MATRIX_MAX_ROWS];
  37         unsigned int num_col_gpios;
  38
  39         unsigned int row_irqs[MATRIX_MAX_ROWS];
  40         DECLARE_BITMAP(wakeup_enabled_irqs, MATRIX_MAX_ROWS);
  41
  42         uint32_t last_key_state[MATRIX_MAX_COLS];
  43         struct delayed_work work;
  44         spinlock_t lock;
  45         bool scan_pending;
  46         bool stopped;
  47 };
  48
  49 /*
  50  * NOTE: If drive_inactive_cols is false, then the GPIO has to be put into
  51  * HiZ when de-activated to cause minmal side effect when scanning other
  52  * columns. In that case it is configured here to be input, otherwise it is
  53  * driven with the inactive value.
  54  */
  55 static void __activate_col(struct matrix_keypad *keypad, int col, bool on)
  56 {
  57         if (on) {
  58                 gpiod_direction_output(keypad->col_gpios[col], 1);
  59         } else {
  60                 gpiod_set_value_cansleep(keypad->col_gpios[col], 0);
  61                 if (!keypad->drive_inactive_cols)
  62                         gpiod_direction_input(keypad->col_gpios[col]);
  63         }
  64 }
  65
  66 static void activate_col(struct matrix_keypad *keypad, int col, bool on)
  67 {
  68         __activate_col(keypad, col, on);
  69
  70         if (on && keypad->col_scan_delay_us)
  71                 udelay(keypad->col_scan_delay_us);
  72 }
  73
  74 static void activate_all_cols(struct matrix_keypad *keypad, bool on)
  75 {
  76         int col;
  77
  78         for (col = 0; col < keypad->num_col_gpios; col++)
  79                 __activate_col(keypad, col, on);
  80 }
  81
  82 static bool row_asserted(struct matrix_keypad *keypad, int row)
  83 {
  84         return gpiod_get_value_cansleep(keypad->row_gpios[row]);
  85 }
  86
  87 static void enable_row_irqs(struct matrix_keypad *keypad)
  88 {
  89         int i;
  90
  91         for (i = 0; i < keypad->num_row_gpios; i++)
  92                 enable_irq(keypad->row_irqs[i]);
  93 }
  94
  95 static void disable_row_irqs(struct matrix_keypad *keypad)
  96 {
  97         int i;
  98
  99         for (i = 0; i < keypad->num_row_gpios; i++)
 100                 disable_irq_nosync(keypad->row_irqs[i]);
 101 }
 102
 103 /*
 104  * This gets the keys from keyboard and reports it to input subsystem
 105  */
 106 static void matrix_keypad_scan(struct work_struct *work)
 107 {
 108         struct matrix_keypad *keypad =
 109                 container_of(work, struct matrix_keypad, work.work);
 110         struct input_dev *input_dev = keypad->input_dev;
 111         const unsigned short *keycodes = input_dev->keycode;
 112         uint32_t new_state[MATRIX_MAX_COLS];
 113         int row, col, code;
 114
 115         /* de-activate all columns for scanning */
 116         activate_all_cols(keypad, false);
 117
 118         memset(new_state, 0, sizeof(new_state));
 119
 120         for (row = 0; row < keypad->num_row_gpios; row++)
 121                 gpiod_direction_input(keypad->row_gpios[row]);
 122
 123         /* assert each column and read the row status out */
 124         for (col = 0; col < keypad->num_col_gpios; col++) {
 125
 126                 activate_col(keypad, col, true);
 127
 128                 for (row = 0; row < keypad->num_row_gpios; row++)
 129                         new_state[col] |=
 130                                 row_asserted(keypad, row) ? BIT(row) : 0;
 131
 132                 activate_col(keypad, col, false);
 133         }
 134
 135         for (col = 0; col < keypad->num_col_gpios; col++) {
 136                 uint32_t bits_changed;
 137
 138                 bits_changed = keypad->last_key_state[col] ^ new_state[col];
 139                 if (bits_changed == 0)
 140                         continue;
 141
 142                 for (row = 0; row < keypad->num_row_gpios; row++) {
 143                         if (!(bits_changed & BIT(row)))
 144                                 continue;
 145
 146                         code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
 147                         input_event(input_dev, EV_MSC, MSC_SCAN, code);
 148                         input_report_key(input_dev,
 149                                          keycodes[code],
 150                                          new_state[col] & (1 << row));
 151                 }
 152         }
 153         input_sync(input_dev);
 154
 155         memcpy(keypad->last_key_state, new_state, sizeof(new_state));
 156
 157         activate_all_cols(keypad, true);
 158
 159         /* Enable IRQs again */
 160         scoped_guard(spinlock_irq, &keypad->lock) {
 161                 keypad->scan_pending = false;
 162                 enable_row_irqs(keypad);
 163         }
 164 }
 165
 166 static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
 167 {
 168         struct matrix_keypad *keypad = id;
 169
 170         guard(spinlock_irqsave)(&keypad->lock);
 171
 172         /*
 173          * See if another IRQ beaten us to it and scheduled the
 174          * scan already. In that case we should not try to
 175          * disable IRQs again.
 176          */
 177         if (unlikely(keypad->scan_pending || keypad->stopped))
 178                 goto out;
 179
 180         disable_row_irqs(keypad);
 181         keypad->scan_pending = true;
 182         schedule_delayed_work(&keypad->work,
 183                               msecs_to_jiffies(keypad->debounce_ms));
 184
 185 out:
 186         return IRQ_HANDLED;
 187 }
 188
 189 static int matrix_keypad_start(struct input_dev *dev)
 190 {
 191         struct matrix_keypad *keypad = input_get_drvdata(dev);
 192
 193         keypad->stopped = false;
 194         mb();
 195
 196         /*
 197          * Schedule an immediate key scan to capture current key state;
 198          * columns will be activated and IRQs be enabled after the scan.
 199          */
 200         schedule_delayed_work(&keypad->work, 0);
 201
 202         return 0;
 203 }
 204
 205 static void matrix_keypad_stop(struct input_dev *dev)
 206 {
 207         struct matrix_keypad *keypad = input_get_drvdata(dev);
 208
 209         scoped_guard(spinlock_irq, &keypad->lock) {
 210                 keypad->stopped = true;
 211         }
 212
 213         flush_delayed_work(&keypad->work);
 214         /*
 215          * matrix_keypad_scan() will leave IRQs enabled;
 216          * we should disable them now.
 217          */
 218         disable_row_irqs(keypad);
 219 }
 220
 221 static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
 222 {
 223         int i;
 224
 225         for_each_clear_bit(i, keypad->wakeup_enabled_irqs,
 226                            keypad->num_row_gpios)
 227                 if (enable_irq_wake(keypad->row_irqs[i]) == 0)
 228                         __set_bit(i, keypad->wakeup_enabled_irqs);
 229 }
 230
 231 static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
 232 {
 233         int i;
 234
 235         for_each_set_bit(i, keypad->wakeup_enabled_irqs,
 236                          keypad->num_row_gpios) {
 237                 disable_irq_wake(keypad->row_irqs[i]);
 238                 __clear_bit(i, keypad->wakeup_enabled_irqs);
 239         }
 240 }
 241
 242 static int matrix_keypad_suspend(struct device *dev)
 243 {
 244         struct platform_device *pdev = to_platform_device(dev);
 245         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 246
 247         matrix_keypad_stop(keypad->input_dev);
 248
 249         if (device_may_wakeup(&pdev->dev))
 250                 matrix_keypad_enable_wakeup(keypad);
 251
 252         return 0;
 253 }
 254
 255 static int matrix_keypad_resume(struct device *dev)
 256 {
 257         struct platform_device *pdev = to_platform_device(dev);
 258         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 259
 260         if (device_may_wakeup(&pdev->dev))
 261                 matrix_keypad_disable_wakeup(keypad);
 262
 263         matrix_keypad_start(keypad->input_dev);
 264
 265         return 0;
 266 }
 267
 268 static DEFINE_SIMPLE_DEV_PM_OPS(matrix_keypad_pm_ops,
 269                                 matrix_keypad_suspend, matrix_keypad_resume);
 270
 271 static int matrix_keypad_init_gpio(struct platform_device *pdev,
 272                                    struct matrix_keypad *keypad)
 273 {
 274         bool active_low;
 275         int nrow, ncol;
 276         int err;
 277         int i;
 278
 279         nrow = gpiod_count(&pdev->dev, "row");
 280         ncol = gpiod_count(&pdev->dev, "col");
 281         if (nrow < 0 || ncol < 0) {
 282                 dev_err(&pdev->dev, "missing row or column GPIOs\n");
 283                 return -EINVAL;
 284         }
 285
 286         keypad->num_row_gpios = nrow;
 287         keypad->num_col_gpios = ncol;
 288
 289         active_low = device_property_read_bool(&pdev->dev, "gpio-activelow");
 290
 291         /* initialize strobe lines as outputs, activated */
 292         for (i = 0; i < keypad->num_col_gpios; i++) {
 293                 keypad->col_gpios[i] = devm_gpiod_get_index(&pdev->dev, "col",
 294                                                             i, GPIOD_ASIS);
 295                 err = PTR_ERR_OR_ZERO(keypad->col_gpios[i]);
 296                 if (err) {
 297                         dev_err(&pdev->dev,
 298                                 "failed to request GPIO for COL%d: %d\n",
 299                                 i, err);
 300                         return err;
 301                 }
 302
 303                 gpiod_set_consumer_name(keypad->col_gpios[i], "matrix_kbd_col");
 304
 305                 if (active_low ^ gpiod_is_active_low(keypad->col_gpios[i]))
 306                         gpiod_toggle_active_low(keypad->col_gpios[i]);
 307
 308                 gpiod_direction_output(keypad->col_gpios[i], 1);
 309         }
 310
 311         for (i = 0; i < keypad->num_row_gpios; i++) {
 312                 keypad->row_gpios[i] = devm_gpiod_get_index(&pdev->dev, "row",
 313                                                             i, GPIOD_IN);
 314                 err = PTR_ERR_OR_ZERO(keypad->row_gpios[i]);
 315                 if (err) {
 316                         dev_err(&pdev->dev,
 317                                 "failed to request GPIO for ROW%d: %d\n",
 318                                 i, err);
 319                         return err;
 320                 }
 321
 322                 gpiod_set_consumer_name(keypad->row_gpios[i], "matrix_kbd_row");
 323
 324                 if (active_low ^ gpiod_is_active_low(keypad->row_gpios[i]))
 325                         gpiod_toggle_active_low(keypad->row_gpios[i]);
 326         }
 327
 328         return 0;
 329 }
 330
 331 static int matrix_keypad_setup_interrupts(struct platform_device *pdev,
 332                                           struct matrix_keypad *keypad)
 333 {
 334         int err;
 335         int irq;
 336         int i;
 337
 338         for (i = 0; i < keypad->num_row_gpios; i++) {
 339                 irq = gpiod_to_irq(keypad->row_gpios[i]);
 340                 if (irq < 0) {
 341                         err = irq;
 342                         dev_err(&pdev->dev,
 343                                 "Unable to convert GPIO line %i to irq: %d\n",
 344                                 i, err);
 345                         return err;
 346                 }
 347
 348                 err = devm_request_any_context_irq(&pdev->dev, irq,
 349                                                    matrix_keypad_interrupt,
 350                                                    IRQF_TRIGGER_RISING |
 351                                                         IRQF_TRIGGER_FALLING,
 352                                                    "matrix-keypad", keypad);
 353                 if (err < 0) {
 354                         dev_err(&pdev->dev,
 355                                 "Unable to acquire interrupt for row %i: %d\n",
 356                                 i, err);
 357                         return err;
 358                 }
 359
 360                 keypad->row_irqs[i] = irq;
 361         }
 362
 363         /* initialized as disabled - enabled by input->open */
 364         disable_row_irqs(keypad);
 365
 366         return 0;
 367 }
 368
 369 static int matrix_keypad_probe(struct platform_device *pdev)
 370 {
 371         struct matrix_keypad *keypad;
 372         struct input_dev *input_dev;
 373         bool wakeup;
 374         int err;
 375
 376         keypad = devm_kzalloc(&pdev->dev, sizeof(*keypad), GFP_KERNEL);
 377         if (!keypad)
 378                 return -ENOMEM;
 379
 380         input_dev = devm_input_allocate_device(&pdev->dev);
 381         if (!input_dev)
 382                 return -ENOMEM;
 383
 384         keypad->input_dev = input_dev;
 385         keypad->stopped = true;
 386         INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
 387         spin_lock_init(&keypad->lock);
 388
 389         keypad->drive_inactive_cols =
 390                 device_property_read_bool(&pdev->dev, "drive-inactive-cols");
 391         device_property_read_u32(&pdev->dev, "debounce-delay-ms",
 392                                  &keypad->debounce_ms);
 393         device_property_read_u32(&pdev->dev, "col-scan-delay-us",
 394                                  &keypad->col_scan_delay_us);
 395
 396         err = matrix_keypad_init_gpio(pdev, keypad);
 397         if (err)
 398                 return err;
 399
 400         keypad->row_shift = get_count_order(keypad->num_col_gpios);
 401
 402         err = matrix_keypad_setup_interrupts(pdev, keypad);
 403         if (err)
 404                 return err;
 405
 406         input_dev->name         = pdev->name;
 407         input_dev->id.bustype   = BUS_HOST;
 408         input_dev->open         = matrix_keypad_start;
 409         input_dev->close        = matrix_keypad_stop;
 410
 411         err = matrix_keypad_build_keymap(NULL, NULL,
 412                                          keypad->num_row_gpios,
 413                                          keypad->num_col_gpios,
 414                                          NULL, input_dev);
 415         if (err) {
 416                 dev_err(&pdev->dev, "failed to build keymap\n");
 417                 return -ENOMEM;
 418         }
 419
 420         if (!device_property_read_bool(&pdev->dev, "linux,no-autorepeat"))
 421                 __set_bit(EV_REP, input_dev->evbit);
 422
 423         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
 424         input_set_drvdata(input_dev, keypad);
 425
 426         err = input_register_device(keypad->input_dev);
 427         if (err)
 428                 return err;
 429
 430         wakeup = device_property_read_bool(&pdev->dev, "wakeup-source") ||
 431                  /* legacy */
 432                  device_property_read_bool(&pdev->dev, "linux,wakeup");
 433         device_init_wakeup(&pdev->dev, wakeup);
 434
 435         platform_set_drvdata(pdev, keypad);
 436
 437         return 0;
 438 }
 439
 440 #ifdef CONFIG_OF
 441 static const struct of_device_id matrix_keypad_dt_match[] = {
 442         { .compatible = "gpio-matrix-keypad" },
 443         { }
 444 };
 445 MODULE_DEVICE_TABLE(of, matrix_keypad_dt_match);
 446 #endif
 447
 448 static struct platform_driver matrix_keypad_driver = {
 449         .probe          = matrix_keypad_probe,
 450         .driver         = {
 451                 .name   = "matrix-keypad",
 452                 .pm     = pm_sleep_ptr(&matrix_keypad_pm_ops),
 453                 .of_match_table = of_match_ptr(matrix_keypad_dt_match),
 454         },
 455 };
 456 module_platform_driver(matrix_keypad_driver);
 457
 458 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
 459 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
 460 MODULE_LICENSE("GPL v2");
 461 MODULE_ALIAS("platform:matrix-keypad");