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 < 0) 244 return irq; 245 246 keypad_data = kzalloc(sizeof(struct omap4_keypad), GFP_KERNEL); 247 if (!keypad_data) { 248 dev_err(&pdev->dev, "keypad_data memory allocation failed\n"); 249 return -ENOMEM; 250 } 251 252 keypad_data->irq = irq; 253 254 error = omap4_keypad_parse_dt(&pdev->dev, keypad_data); 255 if (error) 256 goto err_free_keypad; 257 258 res = request_mem_region(res->start, resource_size(res), pdev->name); 259 if (!res) { 260 dev_err(&pdev->dev, "can't request mem region\n"); 261 error = -EBUSY; 262 goto err_free_keypad; 263 } 264 265 keypad_data->base = ioremap(res->start, resource_size(res)); 266 if (!keypad_data->base) { 267 dev_err(&pdev->dev, "can't ioremap mem resource\n"); 268 error = -ENOMEM; 269 goto err_release_mem; 270 } 271 272 273 /* 274 * Enable clocks for the keypad module so that we can read 275 * revision register. 276 */ 277 pm_runtime_enable(&pdev->dev); 278 error = pm_runtime_get_sync(&pdev->dev); 279 if (error) { 280 dev_err(&pdev->dev, "pm_runtime_get_sync() failed\n"); 281 goto err_unmap; 282 } 283 rev = __raw_readl(keypad_data->base + OMAP4_KBD_REVISION); 284 rev &= 0x03 << 30; 285 rev >>= 30; 286 switch (rev) { 287 case KBD_REVISION_OMAP4: 288 keypad_data->reg_offset = 0x00; 289 keypad_data->irqreg_offset = 0x00; 290 break; 291 case KBD_REVISION_OMAP5: 292 keypad_data->reg_offset = 0x10; 293 keypad_data->irqreg_offset = 0x0c; 294 break; 295 default: 296 dev_err(&pdev->dev, 297 "Keypad reports unsupported revision %d", rev); 298 error = -EINVAL; 299 goto err_pm_put_sync; 300 } 301 302 /* input device allocation */ 303 keypad_data->input = input_dev = input_allocate_device(); 304 if (!input_dev) { 305 error = -ENOMEM; 306 goto err_pm_put_sync; 307 } 308 309 input_dev->name = pdev->name; 310 input_dev->dev.parent = &pdev->dev; 311 input_dev->id.bustype = BUS_HOST; 312 input_dev->id.vendor = 0x0001; 313 input_dev->id.product = 0x0001; 314 input_dev->id.version = 0x0001; 315 316 input_dev->open = omap4_keypad_open; 317 input_dev->close = omap4_keypad_close; 318 319 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 320 if (!keypad_data->no_autorepeat) 321 __set_bit(EV_REP, input_dev->evbit); 322 323 input_set_drvdata(input_dev, keypad_data); 324 325 keypad_data->row_shift = get_count_order(keypad_data->cols); 326 max_keys = keypad_data->rows << keypad_data->row_shift; 327 keypad_data->keymap = kcalloc(max_keys, 328 sizeof(keypad_data->keymap[0]), 329 GFP_KERNEL); 330 if (!keypad_data->keymap) { 331 dev_err(&pdev->dev, "Not enough memory for keymap\n"); 332 error = -ENOMEM; 333 goto err_free_input; 334 } 335 336 error = matrix_keypad_build_keymap(NULL, NULL, 337 keypad_data->rows, keypad_data->cols, 338 keypad_data->keymap, input_dev); 339 if (error) { 340 dev_err(&pdev->dev, "failed to build keymap\n"); 341 goto err_free_keymap; 342 } 343 344 error = request_threaded_irq(keypad_data->irq, omap4_keypad_irq_handler, 345 omap4_keypad_irq_thread_fn, IRQF_ONESHOT, 346 "omap4-keypad", keypad_data); 347 if (error) { 348 dev_err(&pdev->dev, "failed to register interrupt\n"); 349 goto err_free_keymap; 350 } 351 352 device_init_wakeup(&pdev->dev, true); 353 pm_runtime_put_sync(&pdev->dev); 354 355 error = input_register_device(keypad_data->input); 356 if (error < 0) { 357 dev_err(&pdev->dev, "failed to register input device\n"); 358 goto err_pm_disable; 359 } 360 361 platform_set_drvdata(pdev, keypad_data); 362 return 0; 363 364 err_pm_disable: 365 pm_runtime_disable(&pdev->dev); 366 free_irq(keypad_data->irq, keypad_data); 367 err_free_keymap: 368 kfree(keypad_data->keymap); 369 err_free_input: 370 input_free_device(input_dev); 371 err_pm_put_sync: 372 pm_runtime_put_sync(&pdev->dev); 373 err_unmap: 374 iounmap(keypad_data->base); 375 err_release_mem: 376 release_mem_region(res->start, resource_size(res)); 377 err_free_keypad: 378 kfree(keypad_data); 379 return error; 380 } 381 382 static int omap4_keypad_remove(struct platform_device *pdev) 383 { 384 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 385 struct resource *res; 386 387 free_irq(keypad_data->irq, keypad_data); 388 389 pm_runtime_disable(&pdev->dev); 390 391 input_unregister_device(keypad_data->input); 392 393 iounmap(keypad_data->base); 394 395 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 396 release_mem_region(res->start, resource_size(res)); 397 398 kfree(keypad_data->keymap); 399 kfree(keypad_data); 400 401 return 0; 402 } 403 404 static const struct of_device_id omap_keypad_dt_match[] = { 405 { .compatible = "ti,omap4-keypad" }, 406 {}, 407 }; 408 MODULE_DEVICE_TABLE(of, omap_keypad_dt_match); 409 410 #ifdef CONFIG_PM_SLEEP 411 static int omap4_keypad_suspend(struct device *dev) 412 { 413 struct platform_device *pdev = to_platform_device(dev); 414 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 415 int error; 416 417 if (device_may_wakeup(&pdev->dev)) { 418 error = enable_irq_wake(keypad_data->irq); 419 if (!error) 420 keypad_data->irq_wake_enabled = true; 421 } 422 423 return 0; 424 } 425 426 static int omap4_keypad_resume(struct device *dev) 427 { 428 struct platform_device *pdev = to_platform_device(dev); 429 struct omap4_keypad *keypad_data = platform_get_drvdata(pdev); 430 431 if (device_may_wakeup(&pdev->dev) && keypad_data->irq_wake_enabled) { 432 disable_irq_wake(keypad_data->irq); 433 keypad_data->irq_wake_enabled = false; 434 } 435 436 return 0; 437 } 438 #endif 439 440 static SIMPLE_DEV_PM_OPS(omap4_keypad_pm_ops, 441 omap4_keypad_suspend, omap4_keypad_resume); 442 443 static struct platform_driver omap4_keypad_driver = { 444 .probe = omap4_keypad_probe, 445 .remove = omap4_keypad_remove, 446 .driver = { 447 .name = "omap4-keypad", 448 .pm = &omap4_keypad_pm_ops, 449 .of_match_table = omap_keypad_dt_match, 450 }, 451 }; 452 module_platform_driver(omap4_keypad_driver); 453 454 MODULE_AUTHOR("Texas Instruments"); 455 MODULE_DESCRIPTION("OMAP4 Keypad Driver"); 456 MODULE_LICENSE("GPL"); 457 MODULE_ALIAS("platform:omap4-keypad"); 458