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