1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * OMAP4 Keypad Driver 4 * 5 * Copyright (C) 2010 Texas Instruments 6 * 7 * Author: Abraham Arce <x0066660@ti.com> 8 * Initial Code: Syed Rafiuddin <rafiuddin.syed@ti.com> 9 */ 10 11 #include <linux/module.h> 12 #include <linux/interrupt.h> 13 #include <linux/platform_device.h> 14 #include <linux/errno.h> 15 #include <linux/io.h> 16 #include <linux/of.h> 17 #include <linux/input.h> 18 #include <linux/input/matrix_keypad.h> 19 #include <linux/slab.h> 20 #include <linux/pm_runtime.h> 21 22 /* OMAP4 registers */ 23 #define OMAP4_KBD_REVISION 0x00 24 #define OMAP4_KBD_SYSCONFIG 0x10 25 #define OMAP4_KBD_SYSSTATUS 0x14 26 #define OMAP4_KBD_IRQSTATUS 0x18 27 #define OMAP4_KBD_IRQENABLE 0x1C 28 #define OMAP4_KBD_WAKEUPENABLE 0x20 29 #define OMAP4_KBD_PENDING 0x24 30 #define OMAP4_KBD_CTRL 0x28 31 #define OMAP4_KBD_DEBOUNCINGTIME 0x2C 32 #define OMAP4_KBD_LONGKEYTIME 0x30 33 #define OMAP4_KBD_TIMEOUT 0x34 34 #define OMAP4_KBD_STATEMACHINE 0x38 35 #define OMAP4_KBD_ROWINPUTS 0x3C 36 #define OMAP4_KBD_COLUMNOUTPUTS 0x40 37 #define OMAP4_KBD_FULLCODE31_0 0x44 38 #define OMAP4_KBD_FULLCODE63_32 0x48 39 40 /* OMAP4 bit definitions */ 41 #define OMAP4_DEF_IRQENABLE_EVENTEN BIT(0) 42 #define OMAP4_DEF_IRQENABLE_LONGKEY BIT(1) 43 #define OMAP4_DEF_WUP_EVENT_ENA BIT(0) 44 #define OMAP4_DEF_WUP_LONG_KEY_ENA BIT(1) 45 #define OMAP4_DEF_CTRL_NOSOFTMODE BIT(1) 46 #define OMAP4_DEF_CTRL_PTV_SHIFT 2 47 48 /* OMAP4 values */ 49 #define OMAP4_VAL_IRQDISABLE 0x0 50 51 /* 52 * Errata i689: If a key is released for a time shorter than debounce time, 53 * the keyboard will idle and never detect the key release. The workaround 54 * is to use at least a 12ms debounce time. See omap5432 TRM chapter 55 * "26.4.6.2 Keyboard Controller Timer" for more information. 56 */ 57 #define OMAP4_KEYPAD_PTV_DIV_128 0x6 58 #define OMAP4_KEYPAD_DEBOUNCINGTIME_MS(dbms, ptv) \ 59 ((((dbms) * 1000) / ((1 << ((ptv) + 1)) * (1000000 / 32768))) - 1) 60 #define OMAP4_VAL_DEBOUNCINGTIME_16MS \ 61 OMAP4_KEYPAD_DEBOUNCINGTIME_MS(16, OMAP4_KEYPAD_PTV_DIV_128) 62 63 enum { 64 KBD_REVISION_OMAP4 = 0, 65 KBD_REVISION_OMAP5, 66 }; 67 68 struct omap4_keypad { 69 struct input_dev *input; 70 71 void __iomem *base; 72 bool irq_wake_enabled; 73 unsigned int irq; 74 75 unsigned int rows; 76 unsigned int cols; 77 u32 reg_offset; 78 u32 irqreg_offset; 79 unsigned int row_shift; 80 bool no_autorepeat; 81 unsigned char key_state[8]; 82 unsigned short *keymap; 83 }; 84 85 static int kbd_readl(struct omap4_keypad *keypad_data, u32 offset) 86 { 87 return __raw_readl(keypad_data->base + 88 keypad_data->reg_offset + offset); 89 } 90 91 static void kbd_writel(struct omap4_keypad *keypad_data, u32 offset, u32 value) 92 { 93 __raw_writel(value, 94 keypad_data->base + keypad_data->reg_offset + offset); 95 } 96 97 static int kbd_read_irqreg(struct omap4_keypad *keypad_data, u32 offset) 98 { 99 return __raw_readl(keypad_data->base + 100 keypad_data->irqreg_offset + offset); 101 } 102 103 static void kbd_write_irqreg(struct omap4_keypad *keypad_data, 104 u32 offset, u32 value) 105 { 106 __raw_writel(value, 107 keypad_data->base + keypad_data->irqreg_offset + offset); 108 } 109 110 111 /* Interrupt handlers */ 112 static irqreturn_t omap4_keypad_irq_handler(int irq, void *dev_id) 113 { 114 struct omap4_keypad *keypad_data = dev_id; 115 116 if (kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS)) 117 return IRQ_WAKE_THREAD; 118 119 return IRQ_NONE; 120 } 121 122 static irqreturn_t omap4_keypad_irq_thread_fn(int irq, void *dev_id) 123 { 124 struct omap4_keypad *keypad_data = dev_id; 125 struct input_dev *input_dev = keypad_data->input; 126 unsigned char key_state[ARRAY_SIZE(keypad_data->key_state)]; 127 unsigned int col, row, code, changed; 128 u32 *new_state = (u32 *) key_state; 129 130 *new_state = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE31_0); 131 *(new_state + 1) = kbd_readl(keypad_data, OMAP4_KBD_FULLCODE63_32); 132 133 for (row = 0; row < keypad_data->rows; row++) { 134 changed = key_state[row] ^ keypad_data->key_state[row]; 135 if (!changed) 136 continue; 137 138 for (col = 0; col < keypad_data->cols; col++) { 139 if (changed & (1 << col)) { 140 code = MATRIX_SCAN_CODE(row, col, 141 keypad_data->row_shift); 142 input_event(input_dev, EV_MSC, MSC_SCAN, code); 143 input_report_key(input_dev, 144 keypad_data->keymap[code], 145 key_state[row] & (1 << col)); 146 } 147 } 148 } 149 150 input_sync(input_dev); 151 152 memcpy(keypad_data->key_state, key_state, 153 sizeof(keypad_data->key_state)); 154 155 /* clear pending interrupts */ 156 kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS, 157 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS)); 158 159 return IRQ_HANDLED; 160 } 161 162 static int omap4_keypad_open(struct input_dev *input) 163 { 164 struct omap4_keypad *keypad_data = input_get_drvdata(input); 165 166 pm_runtime_get_sync(input->dev.parent); 167 168 disable_irq(keypad_data->irq); 169 170 kbd_writel(keypad_data, OMAP4_KBD_CTRL, 171 OMAP4_DEF_CTRL_NOSOFTMODE | 172 (OMAP4_KEYPAD_PTV_DIV_128 << OMAP4_DEF_CTRL_PTV_SHIFT)); 173 kbd_writel(keypad_data, OMAP4_KBD_DEBOUNCINGTIME, 174 OMAP4_VAL_DEBOUNCINGTIME_16MS); 175 /* clear pending interrupts */ 176 kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS, 177 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS)); 178 kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE, 179 OMAP4_DEF_IRQENABLE_EVENTEN | 180 OMAP4_DEF_IRQENABLE_LONGKEY); 181 kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE, 182 OMAP4_DEF_WUP_EVENT_ENA | OMAP4_DEF_WUP_LONG_KEY_ENA); 183 184 enable_irq(keypad_data->irq); 185 186 return 0; 187 } 188 189 static void omap4_keypad_close(struct input_dev *input) 190 { 191 struct omap4_keypad *keypad_data = input_get_drvdata(input); 192 193 disable_irq(keypad_data->irq); 194 195 /* Disable interrupts and wake-up events */ 196 kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQENABLE, 197 OMAP4_VAL_IRQDISABLE); 198 kbd_writel(keypad_data, OMAP4_KBD_WAKEUPENABLE, 0); 199 200 /* clear pending interrupts */ 201 kbd_write_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS, 202 kbd_read_irqreg(keypad_data, OMAP4_KBD_IRQSTATUS)); 203 204 enable_irq(keypad_data->irq); 205 206 pm_runtime_put_sync(input->dev.parent); 207 } 208 209 static int omap4_keypad_parse_dt(struct device *dev, 210 struct omap4_keypad *keypad_data) 211 { 212 struct device_node *np = dev->of_node; 213 int err; 214 215 err = matrix_keypad_parse_properties(dev, &keypad_data->rows, 216 &keypad_data->cols); 217 if (err) 218 return err; 219 220 if (of_get_property(np, "linux,input-no-autorepeat", NULL)) 221 keypad_data->no_autorepeat = true; 222 223 return 0; 224 } 225 226 static int omap4_keypad_probe(struct platform_device *pdev) 227 { 228 struct omap4_keypad *keypad_data; 229 struct input_dev *input_dev; 230 struct resource *res; 231 unsigned int max_keys; 232 int rev; 233 int irq; 234 int error; 235 236 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 237 if (!res) { 238 dev_err(&pdev->dev, "no base address specified\n"); 239 return -EINVAL; 240 } 241 242 irq = platform_get_irq(pdev, 0); 243 if (!irq) { 244 dev_err(&pdev->dev, "no keyboard irq assigned\n"); 245 return -EINVAL; 246 } 247 248 keypad_data = kzalloc(sizeof(struct omap4_keypad), GFP_KERNEL); 249 if (!keypad_data) { 250 dev_err(&pdev->dev, "keypad_data memory allocation failed\n"); 251 return -ENOMEM; 252 } 253 254 keypad_data->irq = irq; 255 256 error = omap4_keypad_parse_dt(&pdev->dev, keypad_data); 257 if (error) 258 goto err_free_keypad; 259 260 res = request_mem_region(res->start, resource_size(res), pdev->name); 261 if (!res) { 262 dev_err(&pdev->dev, "can't request mem region\n"); 263 error = -EBUSY; 264 goto err_free_keypad; 265 } 266 267 keypad_data->base = ioremap(res->start, resource_size(res)); 268 if (!keypad_data->base) { 269 dev_err(&pdev->dev, "can't ioremap mem resource\n"); 270 error = -ENOMEM; 271 goto err_release_mem; 272 } 273 274 275 /* 276 * Enable clocks for the keypad module so that we can read 277 * revision register. 278 */ 279 pm_runtime_enable(&pdev->dev); 280 error = pm_runtime_get_sync(&pdev->dev); 281 if (error) { 282 dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n"); 283 goto err_unmap; 284 } 285 rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION); 286 rev &= 0x03 << 30; 287 rev >>= 30; 288 switch (rev) { 289 case KBD_REVISION_OMAP4: 290 keypad_data->reg_offset = 0x00; 291 keypad_data->irqreg_offset = 0x00; 292 break; 293 case KBD_REVISION_OMAP5: 294 keypad_data->reg_offset = 0x10; 295 keypad_data->irqreg_offset = 0x0c; 296 break; 297 default: 298 dev_err(&pdev->dev, 299 "Keypad reports unsupported revision %d", rev); 300 error = -EINVAL; 301 goto err_pm_put_sync; 302 } 303 304 /* input device allocation */ 305 keypad_data->input = input_dev = input_allocate_device(); 306 if (!input_dev) { 307 error = -ENOMEM; 308 goto err_pm_put_sync; 309 } 310 311 input_dev->name = pdev->name; 312 input_dev->dev.parent = &pdev->dev; 313 input_dev->id.bustype = BUS_HOST; 314 input_dev->id.vendor = 0x0001; 315 input_dev->id.product = 0x0001; 316 input_dev->id.version = 0x0001; 317 318 input_dev->open = omap4_keypad_open; 319 input_dev->close = omap4_keypad_close; 320 321 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 322 if (!keypad_data->no_autorepeat) 323 __set_bit(EV_REP, input_dev->evbit); 324 325 input_set_drvdata(input_dev, keypad_data); 326 327 keypad_data->row_shift = get_count_order(keypad_data->cols); 328 max_keys = keypad_data->rows << keypad_data->row_shift; 329 keypad_data->keymap = kcalloc(max_keys, 330 sizeof(keypad_data->keymap[0]), 331 GFP_KERNEL); 332 if (!keypad_data->keymap) { 333 dev_err(&pdev->dev, "Not enough memory for keymap\n"); 334 error = -ENOMEM; 335 goto err_free_input; 336 } 337 338 error = matrix_keypad_build_keymap(NULL, NULL, 339 keypad_data->rows, keypad_data->cols, 340 keypad_data->keymap, input_dev); 341 if (error) { 342 dev_err(&pdev->dev, "failed to build keymap\n"); 343 goto err_free_keymap; 344 } 345 346 error = request_threaded_irq(keypad_data->irq, omap4_keypad_irq_handler, 347 omap4_keypad_irq_thread_fn, IRQF_ONESHOT, 348 "omap4-keypad", keypad_data); 349 if (error) { 350 dev_err(&pdev->dev, "failed to register interrupt\n"); 351 goto err_free_keymap; 352 } 353 354 device_init_wakeup(&pdev->dev, true); 355 pm_runtime_put_sync(&pdev->dev); 356 357 error = input_register_device(keypad_data->input); 358 if (error < 0) { 359 dev_err(&pdev->dev, "failed to register input device\n"); 360 goto err_pm_disable; 361 } 362 363 platform_set_drvdata(pdev, keypad_data); 364 return 0; 365 366 err_pm_disable: 367 pm_runtime_disable(&pdev->dev); 368 free_irq(keypad_data->irq, keypad_data); 369 err_free_keymap: 370 kfree(keypad_data->keymap); 371 err_free_input: 372 input_free_device(input_dev); 373 err_pm_put_sync: 374 pm_runtime_put_sync(&pdev->dev); 375 err_unmap: 376 iounmap(keypad_data->base); 377 err_release_mem: 378 release_mem_region(res->start, resource_size(res)); 379 err_free_keypad: 380 kfree(keypad_data); 381 return error; 382 } 383 384 static int omap4_keypad_remove(struct platform_device *pdev) 385 { 386 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 387 struct resource *res; 388 389 free_irq(keypad_data->irq, keypad_data); 390 391 pm_runtime_disable(&pdev->dev); 392 393 input_unregister_device(keypad_data->input); 394 395 iounmap(keypad_data->base); 396 397 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 398 release_mem_region(res->start, resource_size(res)); 399 400 kfree(keypad_data->keymap); 401 kfree(keypad_data); 402 403 return 0; 404 } 405 406 static const struct of_device_id omap_keypad_dt_match[] = { 407 { .compatible = "ti,omap4-keypad" }, 408 {}, 409 }; 410 MODULE_DEVICE_TABLE(of, omap_keypad_dt_match); 411 412 #ifdef CONFIG_PM_SLEEP 413 static int omap4_keypad_suspend(struct device *dev) 414 { 415 struct platform_device *pdev = to_platform_device(dev); 416 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 417 int error; 418 419 if (device_may_wakeup(&pdev->dev)) { 420 error = enable_irq_wake(keypad_data->irq); 421 if (!error) 422 keypad_data->irq_wake_enabled = true; 423 } 424 425 return 0; 426 } 427 428 static int omap4_keypad_resume(struct device *dev) 429 { 430 struct platform_device *pdev = to_platform_device(dev); 431 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 432 433 if (device_may_wakeup(&pdev->dev) && keypad_data->irq_wake_enabled) { 434 disable_irq_wake(keypad_data->irq); 435 keypad_data->irq_wake_enabled = false; 436 } 437 438 return 0; 439 } 440 #endif 441 442 static SIMPLE_DEV_PM_OPS(omap4_keypad_pm_ops, 443 omap4_keypad_suspend, omap4_keypad_resume); 444 445 static struct platform_driver omap4_keypad_driver = { 446 .probe = omap4_keypad_probe, 447 .remove = omap4_keypad_remove, 448 .driver = { 449 .name = "omap4-keypad", 450 .pm = &omap4_keypad_pm_ops, 451 .of_match_table = omap_keypad_dt_match, 452 }, 453 }; 454 module_platform_driver(omap4_keypad_driver); 455 456 MODULE_AUTHOR("Texas Instruments"); 457 MODULE_DESCRIPTION("OMAP4 Keypad Driver"); 458 MODULE_LICENSE("GPL"); 459 MODULE_ALIAS("platform:omap4-keypad"); 460