drivers/input/keyboard/matrix_keypad.c

   1 /*
   2  *  GPIO driven matrix keyboard driver
   3  *
   4  *  Copyright (c) 2008 Marek Vasut <marek.vasut@gmail.com>
   5  *
   6  *  Based on corgikbd.c
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 2 as
  10  *  published by the Free Software Foundation.
  11  *
  12  */
  13
  14 #include <linux/types.h>
  15 #include <linux/delay.h>
  16 #include <linux/platform_device.h>
  17 #include <linux/init.h>
  18 #include <linux/input.h>
  19 #include <linux/irq.h>
  20 #include <linux/interrupt.h>
  21 #include <linux/jiffies.h>
  22 #include <linux/module.h>
  23 #include <linux/gpio.h>
  24 #include <linux/input/matrix_keypad.h>
  25 #include <linux/slab.h>
  26
  27 struct matrix_keypad {
  28         const struct matrix_keypad_platform_data *pdata;
  29         struct input_dev *input_dev;
  30         unsigned int row_shift;
  31
  32         DECLARE_BITMAP(disabled_gpios, MATRIX_MAX_ROWS);
  33
  34         uint32_t last_key_state[MATRIX_MAX_COLS];
  35         struct delayed_work work;
  36         spinlock_t lock;
  37         bool scan_pending;
  38         bool stopped;
  39         bool gpio_all_disabled;
  40
  41         unsigned short keycodes[];
  42 };
  43
  44 /*
  45  * NOTE: normally the GPIO has to be put into HiZ when de-activated to cause
  46  * minmal side effect when scanning other columns, here it is configured to
  47  * be input, and it should work on most platforms.
  48  */
  49 static void __activate_col(const struct matrix_keypad_platform_data *pdata,
  50                            int col, bool on)
  51 {
  52         bool level_on = !pdata->active_low;
  53
  54         if (on) {
  55                 gpio_direction_output(pdata->col_gpios[col], level_on);
  56         } else {
  57                 gpio_set_value_cansleep(pdata->col_gpios[col], !level_on);
  58                 gpio_direction_input(pdata->col_gpios[col]);
  59         }
  60 }
  61
  62 static void activate_col(const struct matrix_keypad_platform_data *pdata,
  63                          int col, bool on)
  64 {
  65         __activate_col(pdata, col, on);
  66
  67         if (on && pdata->col_scan_delay_us)
  68                 udelay(pdata->col_scan_delay_us);
  69 }
  70
  71 static void activate_all_cols(const struct matrix_keypad_platform_data *pdata,
  72                               bool on)
  73 {
  74         int col;
  75
  76         for (col = 0; col < pdata->num_col_gpios; col++)
  77                 __activate_col(pdata, col, on);
  78 }
  79
  80 static bool row_asserted(const struct matrix_keypad_platform_data *pdata,
  81                          int row)
  82 {
  83         return gpio_get_value_cansleep(pdata->row_gpios[row]) ?
  84                         !pdata->active_low : pdata->active_low;
  85 }
  86
  87 static void enable_row_irqs(struct matrix_keypad *keypad)
  88 {
  89         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
  90         int i;
  91
  92         if (pdata->clustered_irq > 0)
  93                 enable_irq(pdata->clustered_irq);
  94         else {
  95                 for (i = 0; i < pdata->num_row_gpios; i++)
  96                         enable_irq(gpio_to_irq(pdata->row_gpios[i]));
  97         }
  98 }
  99
 100 static void disable_row_irqs(struct matrix_keypad *keypad)
 101 {
 102         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 103         int i;
 104
 105         if (pdata->clustered_irq > 0)
 106                 disable_irq_nosync(pdata->clustered_irq);
 107         else {
 108                 for (i = 0; i < pdata->num_row_gpios; i++)
 109                         disable_irq_nosync(gpio_to_irq(pdata->row_gpios[i]));
 110         }
 111 }
 112
 113 /*
 114  * This gets the keys from keyboard and reports it to input subsystem
 115  */
 116 static void matrix_keypad_scan(struct work_struct *work)
 117 {
 118         struct matrix_keypad *keypad =
 119                 container_of(work, struct matrix_keypad, work.work);
 120         struct input_dev *input_dev = keypad->input_dev;
 121         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 122         uint32_t new_state[MATRIX_MAX_COLS];
 123         int row, col, code;
 124
 125         /* de-activate all columns for scanning */
 126         activate_all_cols(pdata, false);
 127
 128         memset(new_state, 0, sizeof(new_state));
 129
 130         /* assert each column and read the row status out */
 131         for (col = 0; col < pdata->num_col_gpios; col++) {
 132
 133                 activate_col(pdata, col, true);
 134
 135                 for (row = 0; row < pdata->num_row_gpios; row++)
 136                         new_state[col] |=
 137                                 row_asserted(pdata, row) ? (1 << row) : 0;
 138
 139                 activate_col(pdata, col, false);
 140         }
 141
 142         for (col = 0; col < pdata->num_col_gpios; col++) {
 143                 uint32_t bits_changed;
 144
 145                 bits_changed = keypad->last_key_state[col] ^ new_state[col];
 146                 if (bits_changed == 0)
 147                         continue;
 148
 149                 for (row = 0; row < pdata->num_row_gpios; row++) {
 150                         if ((bits_changed & (1 << row)) == 0)
 151                                 continue;
 152
 153                         code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
 154                         input_event(input_dev, EV_MSC, MSC_SCAN, code);
 155                         input_report_key(input_dev,
 156                                          keypad->keycodes[code],
 157                                          new_state[col] & (1 << row));
 158                 }
 159         }
 160         input_sync(input_dev);
 161
 162         memcpy(keypad->last_key_state, new_state, sizeof(new_state));
 163
 164         activate_all_cols(pdata, true);
 165
 166         /* Enable IRQs again */
 167         spin_lock_irq(&keypad->lock);
 168         keypad->scan_pending = false;
 169         enable_row_irqs(keypad);
 170         spin_unlock_irq(&keypad->lock);
 171 }
 172
 173 static irqreturn_t matrix_keypad_interrupt(int irq, void *id)
 174 {
 175         struct matrix_keypad *keypad = id;
 176         unsigned long flags;
 177
 178         spin_lock_irqsave(&keypad->lock, flags);
 179
 180         /*
 181          * See if another IRQ beaten us to it and scheduled the
 182          * scan already. In that case we should not try to
 183          * disable IRQs again.
 184          */
 185         if (unlikely(keypad->scan_pending || keypad->stopped))
 186                 goto out;
 187
 188         disable_row_irqs(keypad);
 189         keypad->scan_pending = true;
 190         schedule_delayed_work(&keypad->work,
 191                 msecs_to_jiffies(keypad->pdata->debounce_ms));
 192
 193 out:
 194         spin_unlock_irqrestore(&keypad->lock, flags);
 195         return IRQ_HANDLED;
 196 }
 197
 198 static int matrix_keypad_start(struct input_dev *dev)
 199 {
 200         struct matrix_keypad *keypad = input_get_drvdata(dev);
 201
 202         keypad->stopped = false;
 203         mb();
 204
 205         /*
 206          * Schedule an immediate key scan to capture current key state;
 207          * columns will be activated and IRQs be enabled after the scan.
 208          */
 209         schedule_delayed_work(&keypad->work, 0);
 210
 211         return 0;
 212 }
 213
 214 static void matrix_keypad_stop(struct input_dev *dev)
 215 {
 216         struct matrix_keypad *keypad = input_get_drvdata(dev);
 217
 218         keypad->stopped = true;
 219         mb();
 220         flush_work(&keypad->work.work);
 221         /*
 222          * matrix_keypad_scan() will leave IRQs enabled;
 223          * we should disable them now.
 224          */
 225         disable_row_irqs(keypad);
 226 }
 227
 228 #ifdef CONFIG_PM_SLEEP
 229 static void matrix_keypad_enable_wakeup(struct matrix_keypad *keypad)
 230 {
 231         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 232         unsigned int gpio;
 233         int i;
 234
 235         if (pdata->clustered_irq > 0) {
 236                 if (enable_irq_wake(pdata->clustered_irq) == 0)
 237                         keypad->gpio_all_disabled = true;
 238         } else {
 239
 240                 for (i = 0; i < pdata->num_row_gpios; i++) {
 241                         if (!test_bit(i, keypad->disabled_gpios)) {
 242                                 gpio = pdata->row_gpios[i];
 243
 244                                 if (enable_irq_wake(gpio_to_irq(gpio)) == 0)
 245                                         __set_bit(i, keypad->disabled_gpios);
 246                         }
 247                 }
 248         }
 249 }
 250
 251 static void matrix_keypad_disable_wakeup(struct matrix_keypad *keypad)
 252 {
 253         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 254         unsigned int gpio;
 255         int i;
 256
 257         if (pdata->clustered_irq > 0) {
 258                 if (keypad->gpio_all_disabled) {
 259                         disable_irq_wake(pdata->clustered_irq);
 260                         keypad->gpio_all_disabled = false;
 261                 }
 262         } else {
 263                 for (i = 0; i < pdata->num_row_gpios; i++) {
 264                         if (test_and_clear_bit(i, keypad->disabled_gpios)) {
 265                                 gpio = pdata->row_gpios[i];
 266                                 disable_irq_wake(gpio_to_irq(gpio));
 267                         }
 268                 }
 269         }
 270 }
 271
 272 static int matrix_keypad_suspend(struct device *dev)
 273 {
 274         struct platform_device *pdev = to_platform_device(dev);
 275         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 276
 277         matrix_keypad_stop(keypad->input_dev);
 278
 279         if (device_may_wakeup(&pdev->dev))
 280                 matrix_keypad_enable_wakeup(keypad);
 281
 282         return 0;
 283 }
 284
 285 static int matrix_keypad_resume(struct device *dev)
 286 {
 287         struct platform_device *pdev = to_platform_device(dev);
 288         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 289
 290         if (device_may_wakeup(&pdev->dev))
 291                 matrix_keypad_disable_wakeup(keypad);
 292
 293         matrix_keypad_start(keypad->input_dev);
 294
 295         return 0;
 296 }
 297 #endif
 298
 299 static SIMPLE_DEV_PM_OPS(matrix_keypad_pm_ops,
 300                          matrix_keypad_suspend, matrix_keypad_resume);
 301
 302 static int __devinit matrix_keypad_init_gpio(struct platform_device *pdev,
 303                                              struct matrix_keypad *keypad)
 304 {
 305         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 306         int i, err;
 307
 308         /* initialized strobe lines as outputs, activated */
 309         for (i = 0; i < pdata->num_col_gpios; i++) {
 310                 err = gpio_request(pdata->col_gpios[i], "matrix_kbd_col");
 311                 if (err) {
 312                         dev_err(&pdev->dev,
 313                                 "failed to request GPIO%d for COL%d\n",
 314                                 pdata->col_gpios[i], i);
 315                         goto err_free_cols;
 316                 }
 317
 318                 gpio_direction_output(pdata->col_gpios[i], !pdata->active_low);
 319         }
 320
 321         for (i = 0; i < pdata->num_row_gpios; i++) {
 322                 err = gpio_request(pdata->row_gpios[i], "matrix_kbd_row");
 323                 if (err) {
 324                         dev_err(&pdev->dev,
 325                                 "failed to request GPIO%d for ROW%d\n",
 326                                 pdata->row_gpios[i], i);
 327                         goto err_free_rows;
 328                 }
 329
 330                 gpio_direction_input(pdata->row_gpios[i]);
 331         }
 332
 333         if (pdata->clustered_irq > 0) {
 334                 err = request_irq(pdata->clustered_irq,
 335                                 matrix_keypad_interrupt,
 336                                 pdata->clustered_irq_flags,
 337                                 "matrix-keypad", keypad);
 338                 if (err) {
 339                         dev_err(&pdev->dev,
 340                                 "Unable to acquire clustered interrupt\n");
 341                         goto err_free_rows;
 342                 }
 343         } else {
 344                 for (i = 0; i < pdata->num_row_gpios; i++) {
 345                         err = request_irq(gpio_to_irq(pdata->row_gpios[i]),
 346                                         matrix_keypad_interrupt,
 347                                         IRQF_TRIGGER_RISING |
 348                                         IRQF_TRIGGER_FALLING,
 349                                         "matrix-keypad", keypad);
 350                         if (err) {
 351                                 dev_err(&pdev->dev,
 352                                         "Unable to acquire interrupt for GPIO line %i\n",
 353                                         pdata->row_gpios[i]);
 354                                 goto err_free_irqs;
 355                         }
 356                 }
 357         }
 358
 359         /* initialized as disabled - enabled by input->open */
 360         disable_row_irqs(keypad);
 361         return 0;
 362
 363 err_free_irqs:
 364         while (--i >= 0)
 365                 free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
 366         i = pdata->num_row_gpios;
 367 err_free_rows:
 368         while (--i >= 0)
 369                 gpio_free(pdata->row_gpios[i]);
 370         i = pdata->num_col_gpios;
 371 err_free_cols:
 372         while (--i >= 0)
 373                 gpio_free(pdata->col_gpios[i]);
 374
 375         return err;
 376 }
 377
 378 static void matrix_keypad_free_gpio(struct matrix_keypad *keypad)
 379 {
 380         const struct matrix_keypad_platform_data *pdata = keypad->pdata;
 381         int i;
 382
 383         if (pdata->clustered_irq > 0) {
 384                 free_irq(pdata->clustered_irq, keypad);
 385         } else {
 386                 for (i = 0; i < pdata->num_row_gpios; i++)
 387                         free_irq(gpio_to_irq(pdata->row_gpios[i]), keypad);
 388         }
 389
 390         for (i = 0; i < pdata->num_row_gpios; i++)
 391                 gpio_free(pdata->row_gpios[i]);
 392
 393         for (i = 0; i < pdata->num_col_gpios; i++)
 394                 gpio_free(pdata->col_gpios[i]);
 395 }
 396
 397 static int __devinit matrix_keypad_probe(struct platform_device *pdev)
 398 {
 399         const struct matrix_keypad_platform_data *pdata;
 400         const struct matrix_keymap_data *keymap_data;
 401         struct matrix_keypad *keypad;
 402         struct input_dev *input_dev;
 403         unsigned int row_shift;
 404         size_t keymap_size;
 405         int err;
 406
 407         pdata = pdev->dev.platform_data;
 408         if (!pdata) {
 409                 dev_err(&pdev->dev, "no platform data defined\n");
 410                 return -EINVAL;
 411         }
 412
 413         keymap_data = pdata->keymap_data;
 414         if (!keymap_data) {
 415                 dev_err(&pdev->dev, "no keymap data defined\n");
 416                 return -EINVAL;
 417         }
 418
 419         row_shift = get_count_order(pdata->num_col_gpios);
 420         keymap_size = (pdata->num_row_gpios << row_shift) *
 421                         sizeof(keypad->keycodes[0]);
 422         keypad = kzalloc(sizeof(struct matrix_keypad) + keymap_size,
 423                          GFP_KERNEL);
 424         input_dev = input_allocate_device();
 425         if (!keypad || !input_dev) {
 426                 err = -ENOMEM;
 427                 goto err_free_mem;
 428         }
 429
 430         keypad->input_dev = input_dev;
 431         keypad->pdata = pdata;
 432         keypad->row_shift = row_shift;
 433         keypad->stopped = true;
 434         INIT_DELAYED_WORK(&keypad->work, matrix_keypad_scan);
 435         spin_lock_init(&keypad->lock);
 436
 437         input_dev->name         = pdev->name;
 438         input_dev->id.bustype   = BUS_HOST;
 439         input_dev->dev.parent   = &pdev->dev;
 440         input_dev->open         = matrix_keypad_start;
 441         input_dev->close        = matrix_keypad_stop;
 442
 443         err = matrix_keypad_build_keymap(keymap_data, NULL,
 444                                          pdata->num_row_gpios,
 445                                          pdata->num_col_gpios,
 446                                          keypad->keycodes, input_dev);
 447         if (err)
 448                 goto err_free_mem;
 449
 450         if (!pdata->no_autorepeat)
 451                 __set_bit(EV_REP, input_dev->evbit);
 452         input_set_capability(input_dev, EV_MSC, MSC_SCAN);
 453         input_set_drvdata(input_dev, keypad);
 454
 455         err = matrix_keypad_init_gpio(pdev, keypad);
 456         if (err)
 457                 goto err_free_mem;
 458
 459         err = input_register_device(keypad->input_dev);
 460         if (err)
 461                 goto err_free_gpio;
 462
 463         device_init_wakeup(&pdev->dev, pdata->wakeup);
 464         platform_set_drvdata(pdev, keypad);
 465
 466         return 0;
 467
 468 err_free_gpio:
 469         matrix_keypad_free_gpio(keypad);
 470 err_free_mem:
 471         input_free_device(input_dev);
 472         kfree(keypad);
 473         return err;
 474 }
 475
 476 static int __devexit matrix_keypad_remove(struct platform_device *pdev)
 477 {
 478         struct matrix_keypad *keypad = platform_get_drvdata(pdev);
 479
 480         device_init_wakeup(&pdev->dev, 0);
 481
 482         matrix_keypad_free_gpio(keypad);
 483         input_unregister_device(keypad->input_dev);
 484         kfree(keypad);
 485
 486         platform_set_drvdata(pdev, NULL);
 487
 488         return 0;
 489 }
 490
 491 static struct platform_driver matrix_keypad_driver = {
 492         .probe          = matrix_keypad_probe,
 493         .remove         = __devexit_p(matrix_keypad_remove),
 494         .driver         = {
 495                 .name   = "matrix-keypad",
 496                 .owner  = THIS_MODULE,
 497                 .pm     = &matrix_keypad_pm_ops,
 498         },
 499 };
 500 module_platform_driver(matrix_keypad_driver);
 501
 502 MODULE_AUTHOR("Marek Vasut <marek.vasut@gmail.com>");
 503 MODULE_DESCRIPTION("GPIO Driven Matrix Keypad Driver");
 504 MODULE_LICENSE("GPL v2");
 505 MODULE_ALIAS("platform:matrix-keypad");