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