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"); 462