1 /* 2 * Copyright (C) ST-Ericsson SA 2010 3 * 4 * Author: Jayeeta Banerjee <jayeeta.banerjee@stericsson.com> 5 * Author: Sundar Iyer <sundar.iyer@stericsson.com> 6 * 7 * License Terms: GNU General Public License, version 2 8 * 9 * TC35893 MFD Keypad Controller driver 10 */ 11 12 #include <linux/module.h> 13 #include <linux/interrupt.h> 14 #include <linux/input.h> 15 #include <linux/platform_device.h> 16 #include <linux/input/matrix_keypad.h> 17 #include <linux/i2c.h> 18 #include <linux/slab.h> 19 #include <linux/mfd/tc3589x.h> 20 21 /* Maximum supported keypad matrix row/columns size */ 22 #define TC3589x_MAX_KPROW 8 23 #define TC3589x_MAX_KPCOL 12 24 25 /* keypad related Constants */ 26 #define TC3589x_MAX_DEBOUNCE_SETTLE 0xFF 27 #define DEDICATED_KEY_VAL 0xFF 28 29 /* Pull up/down masks */ 30 #define TC3589x_NO_PULL_MASK 0x0 31 #define TC3589x_PULL_DOWN_MASK 0x1 32 #define TC3589x_PULL_UP_MASK 0x2 33 #define TC3589x_PULLUP_ALL_MASK 0xAA 34 #define TC3589x_IO_PULL_VAL(index, mask) ((mask)<<((index)%4)*2)) 35 36 /* Bit masks for IOCFG register */ 37 #define IOCFG_BALLCFG 0x01 38 #define IOCFG_IG 0x08 39 40 #define KP_EVCODE_COL_MASK 0x0F 41 #define KP_EVCODE_ROW_MASK 0x70 42 #define KP_RELEASE_EVT_MASK 0x80 43 44 #define KP_ROW_SHIFT 4 45 46 #define KP_NO_VALID_KEY_MASK 0x7F 47 48 /* bit masks for RESTCTRL register */ 49 #define TC3589x_KBDRST 0x2 50 #define TC3589x_IRQRST 0x10 51 #define TC3589x_RESET_ALL 0x1B 52 53 /* KBDMFS register bit mask */ 54 #define TC3589x_KBDMFS_EN 0x1 55 56 /* CLKEN register bitmask */ 57 #define KPD_CLK_EN 0x1 58 59 /* RSTINTCLR register bit mask */ 60 #define IRQ_CLEAR 0x1 61 62 /* bit masks for keyboard interrupts*/ 63 #define TC3589x_EVT_LOSS_INT 0x8 64 #define TC3589x_EVT_INT 0x4 65 #define TC3589x_KBD_LOSS_INT 0x2 66 #define TC3589x_KBD_INT 0x1 67 68 /* bit masks for keyboard interrupt clear*/ 69 #define TC3589x_EVT_INT_CLR 0x2 70 #define TC3589x_KBD_INT_CLR 0x1 71 72 /** 73 * struct tc35893_keypad_platform_data - platform specific keypad data 74 * @keymap_data: matrix scan code table for keycodes 75 * @krow: mask for available rows, value is 0xFF 76 * @kcol: mask for available columns, value is 0xFF 77 * @debounce_period: platform specific debounce time 78 * @settle_time: platform specific settle down time 79 * @irqtype: type of interrupt, falling or rising edge 80 * @enable_wakeup: specifies if keypad event can wake up system from sleep 81 * @no_autorepeat: flag for auto repetition 82 */ 83 struct tc3589x_keypad_platform_data { 84 const struct matrix_keymap_data *keymap_data; 85 u8 krow; 86 u8 kcol; 87 u8 debounce_period; 88 u8 settle_time; 89 unsigned long irqtype; 90 bool enable_wakeup; 91 bool no_autorepeat; 92 }; 93 94 /** 95 * struct tc_keypad - data structure used by keypad driver 96 * @tc3589x: pointer to tc35893 97 * @input: pointer to input device object 98 * @board: keypad platform device 99 * @krow: number of rows 100 * @kcol: number of columns 101 * @keymap: matrix scan code table for keycodes 102 * @keypad_stopped: holds keypad status 103 */ 104 struct tc_keypad { 105 struct tc3589x *tc3589x; 106 struct input_dev *input; 107 const struct tc3589x_keypad_platform_data *board; 108 unsigned int krow; 109 unsigned int kcol; 110 unsigned short *keymap; 111 bool keypad_stopped; 112 }; 113 114 static int tc3589x_keypad_init_key_hardware(struct tc_keypad *keypad) 115 { 116 int ret; 117 struct tc3589x *tc3589x = keypad->tc3589x; 118 const struct tc3589x_keypad_platform_data *board = keypad->board; 119 120 /* validate platform configuration */ 121 if (board->kcol > TC3589x_MAX_KPCOL || board->krow > TC3589x_MAX_KPROW) 122 return -EINVAL; 123 124 /* configure KBDSIZE 4 LSbits for cols and 4 MSbits for rows */ 125 ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSIZE, 126 (board->krow << KP_ROW_SHIFT) | board->kcol); 127 if (ret < 0) 128 return ret; 129 130 /* configure dedicated key config, no dedicated key selected */ 131 ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_LSB, DEDICATED_KEY_VAL); 132 if (ret < 0) 133 return ret; 134 135 ret = tc3589x_reg_write(tc3589x, TC3589x_KBCFG_MSB, DEDICATED_KEY_VAL); 136 if (ret < 0) 137 return ret; 138 139 /* Configure settle time */ 140 ret = tc3589x_reg_write(tc3589x, TC3589x_KBDSETTLE_REG, 141 board->settle_time); 142 if (ret < 0) 143 return ret; 144 145 /* Configure debounce time */ 146 ret = tc3589x_reg_write(tc3589x, TC3589x_KBDBOUNCE, 147 board->debounce_period); 148 if (ret < 0) 149 return ret; 150 151 /* Start of initialise keypad GPIOs */ 152 ret = tc3589x_set_bits(tc3589x, TC3589x_IOCFG, 0x0, IOCFG_IG); 153 if (ret < 0) 154 return ret; 155 156 /* Configure pull-up resistors for all row GPIOs */ 157 ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_LSB, 158 TC3589x_PULLUP_ALL_MASK); 159 if (ret < 0) 160 return ret; 161 162 ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG0_MSB, 163 TC3589x_PULLUP_ALL_MASK); 164 if (ret < 0) 165 return ret; 166 167 /* Configure pull-up resistors for all column GPIOs */ 168 ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_LSB, 169 TC3589x_PULLUP_ALL_MASK); 170 if (ret < 0) 171 return ret; 172 173 ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG1_MSB, 174 TC3589x_PULLUP_ALL_MASK); 175 if (ret < 0) 176 return ret; 177 178 ret = tc3589x_reg_write(tc3589x, TC3589x_IOPULLCFG2_LSB, 179 TC3589x_PULLUP_ALL_MASK); 180 181 return ret; 182 } 183 184 #define TC35893_DATA_REGS 4 185 #define TC35893_KEYCODE_FIFO_EMPTY 0x7f 186 #define TC35893_KEYCODE_FIFO_CLEAR 0xff 187 #define TC35893_KEYPAD_ROW_SHIFT 0x3 188 189 static irqreturn_t tc3589x_keypad_irq(int irq, void *dev) 190 { 191 struct tc_keypad *keypad = dev; 192 struct tc3589x *tc3589x = keypad->tc3589x; 193 u8 i, row_index, col_index, kbd_code, up; 194 u8 code; 195 196 for (i = 0; i < TC35893_DATA_REGS * 2; i++) { 197 kbd_code = tc3589x_reg_read(tc3589x, TC3589x_EVTCODE_FIFO); 198 199 /* loop till fifo is empty and no more keys are pressed */ 200 if (kbd_code == TC35893_KEYCODE_FIFO_EMPTY || 201 kbd_code == TC35893_KEYCODE_FIFO_CLEAR) 202 continue; 203 204 /* valid key is found */ 205 col_index = kbd_code & KP_EVCODE_COL_MASK; 206 row_index = (kbd_code & KP_EVCODE_ROW_MASK) >> KP_ROW_SHIFT; 207 code = MATRIX_SCAN_CODE(row_index, col_index, 208 TC35893_KEYPAD_ROW_SHIFT); 209 up = kbd_code & KP_RELEASE_EVT_MASK; 210 211 input_event(keypad->input, EV_MSC, MSC_SCAN, code); 212 input_report_key(keypad->input, keypad->keymap[code], !up); 213 input_sync(keypad->input); 214 } 215 216 /* clear IRQ */ 217 tc3589x_set_bits(tc3589x, TC3589x_KBDIC, 218 0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR); 219 /* enable IRQ */ 220 tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 221 0x0, TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT); 222 223 return IRQ_HANDLED; 224 } 225 226 static int tc3589x_keypad_enable(struct tc_keypad *keypad) 227 { 228 struct tc3589x *tc3589x = keypad->tc3589x; 229 int ret; 230 231 /* pull the keypad module out of reset */ 232 ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x0); 233 if (ret < 0) 234 return ret; 235 236 /* configure KBDMFS */ 237 ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMFS, 0x0, TC3589x_KBDMFS_EN); 238 if (ret < 0) 239 return ret; 240 241 /* enable the keypad clock */ 242 ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x0, KPD_CLK_EN); 243 if (ret < 0) 244 return ret; 245 246 /* clear pending IRQs */ 247 ret = tc3589x_set_bits(tc3589x, TC3589x_RSTINTCLR, 0x0, 0x1); 248 if (ret < 0) 249 return ret; 250 251 /* enable the IRQs */ 252 ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 0x0, 253 TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT); 254 if (ret < 0) 255 return ret; 256 257 keypad->keypad_stopped = false; 258 259 return ret; 260 } 261 262 static int tc3589x_keypad_disable(struct tc_keypad *keypad) 263 { 264 struct tc3589x *tc3589x = keypad->tc3589x; 265 int ret; 266 267 /* clear IRQ */ 268 ret = tc3589x_set_bits(tc3589x, TC3589x_KBDIC, 269 0x0, TC3589x_EVT_INT_CLR | TC3589x_KBD_INT_CLR); 270 if (ret < 0) 271 return ret; 272 273 /* disable all interrupts */ 274 ret = tc3589x_set_bits(tc3589x, TC3589x_KBDMSK, 275 ~(TC3589x_EVT_LOSS_INT | TC3589x_EVT_INT), 0x0); 276 if (ret < 0) 277 return ret; 278 279 /* disable the keypad module */ 280 ret = tc3589x_set_bits(tc3589x, TC3589x_CLKEN, 0x1, 0x0); 281 if (ret < 0) 282 return ret; 283 284 /* put the keypad module into reset */ 285 ret = tc3589x_set_bits(tc3589x, TC3589x_RSTCTRL, TC3589x_KBDRST, 0x1); 286 287 keypad->keypad_stopped = true; 288 289 return ret; 290 } 291 292 static int tc3589x_keypad_open(struct input_dev *input) 293 { 294 int error; 295 struct tc_keypad *keypad = input_get_drvdata(input); 296 297 /* enable the keypad module */ 298 error = tc3589x_keypad_enable(keypad); 299 if (error < 0) { 300 dev_err(&input->dev, "failed to enable keypad module\n"); 301 return error; 302 } 303 304 error = tc3589x_keypad_init_key_hardware(keypad); 305 if (error < 0) { 306 dev_err(&input->dev, "failed to configure keypad module\n"); 307 return error; 308 } 309 310 return 0; 311 } 312 313 static void tc3589x_keypad_close(struct input_dev *input) 314 { 315 struct tc_keypad *keypad = input_get_drvdata(input); 316 317 /* disable the keypad module */ 318 tc3589x_keypad_disable(keypad); 319 } 320 321 static const struct tc3589x_keypad_platform_data * 322 tc3589x_keypad_of_probe(struct device *dev) 323 { 324 struct device_node *np = dev->of_node; 325 struct tc3589x_keypad_platform_data *plat; 326 u32 cols, rows; 327 u32 debounce_ms; 328 int proplen; 329 330 if (!np) 331 return ERR_PTR(-ENODEV); 332 333 plat = devm_kzalloc(dev, sizeof(*plat), GFP_KERNEL); 334 if (!plat) 335 return ERR_PTR(-ENOMEM); 336 337 of_property_read_u32(np, "keypad,num-columns", &cols); 338 of_property_read_u32(np, "keypad,num-rows", &rows); 339 plat->kcol = (u8) cols; 340 plat->krow = (u8) rows; 341 if (!plat->krow || !plat->kcol || 342 plat->krow > TC_KPD_ROWS || plat->kcol > TC_KPD_COLUMNS) { 343 dev_err(dev, 344 "keypad columns/rows not properly specified (%ux%u)\n", 345 plat->kcol, plat->krow); 346 return ERR_PTR(-EINVAL); 347 } 348 349 if (!of_get_property(np, "linux,keymap", &proplen)) { 350 dev_err(dev, "property linux,keymap not found\n"); 351 return ERR_PTR(-ENOENT); 352 } 353 354 plat->no_autorepeat = of_property_read_bool(np, "linux,no-autorepeat"); 355 plat->enable_wakeup = of_property_read_bool(np, "linux,wakeup"); 356 357 /* The custom delay format is ms/16 */ 358 of_property_read_u32(np, "debounce-delay-ms", &debounce_ms); 359 if (debounce_ms) 360 plat->debounce_period = debounce_ms * 16; 361 else 362 plat->debounce_period = TC_KPD_DEBOUNCE_PERIOD; 363 364 plat->settle_time = TC_KPD_SETTLE_TIME; 365 /* FIXME: should be property of the IRQ resource? */ 366 plat->irqtype = IRQF_TRIGGER_FALLING; 367 368 return plat; 369 } 370 371 static int tc3589x_keypad_probe(struct platform_device *pdev) 372 { 373 struct tc3589x *tc3589x = dev_get_drvdata(pdev->dev.parent); 374 struct tc_keypad *keypad; 375 struct input_dev *input; 376 const struct tc3589x_keypad_platform_data *plat; 377 int error, irq; 378 379 plat = tc3589x_keypad_of_probe(&pdev->dev); 380 if (IS_ERR(plat)) { 381 dev_err(&pdev->dev, "invalid keypad platform data\n"); 382 return PTR_ERR(plat); 383 } 384 385 irq = platform_get_irq(pdev, 0); 386 if (irq < 0) 387 return irq; 388 389 keypad = kzalloc(sizeof(struct tc_keypad), GFP_KERNEL); 390 input = input_allocate_device(); 391 if (!keypad || !input) { 392 dev_err(&pdev->dev, "failed to allocate keypad memory\n"); 393 error = -ENOMEM; 394 goto err_free_mem; 395 } 396 397 keypad->board = plat; 398 keypad->input = input; 399 keypad->tc3589x = tc3589x; 400 401 input->id.bustype = BUS_I2C; 402 input->name = pdev->name; 403 input->dev.parent = &pdev->dev; 404 405 input->open = tc3589x_keypad_open; 406 input->close = tc3589x_keypad_close; 407 408 error = matrix_keypad_build_keymap(plat->keymap_data, NULL, 409 TC3589x_MAX_KPROW, TC3589x_MAX_KPCOL, 410 NULL, input); 411 if (error) { 412 dev_err(&pdev->dev, "Failed to build keymap\n"); 413 goto err_free_mem; 414 } 415 416 keypad->keymap = input->keycode; 417 418 input_set_capability(input, EV_MSC, MSC_SCAN); 419 if (!plat->no_autorepeat) 420 __set_bit(EV_REP, input->evbit); 421 422 input_set_drvdata(input, keypad); 423 424 error = request_threaded_irq(irq, NULL, tc3589x_keypad_irq, 425 plat->irqtype | IRQF_ONESHOT, 426 "tc3589x-keypad", keypad); 427 if (error < 0) { 428 dev_err(&pdev->dev, 429 "Could not allocate irq %d,error %d\n", 430 irq, error); 431 goto err_free_mem; 432 } 433 434 error = input_register_device(input); 435 if (error) { 436 dev_err(&pdev->dev, "Could not register input device\n"); 437 goto err_free_irq; 438 } 439 440 /* let platform decide if keypad is a wakeup source or not */ 441 device_init_wakeup(&pdev->dev, plat->enable_wakeup); 442 device_set_wakeup_capable(&pdev->dev, plat->enable_wakeup); 443 444 platform_set_drvdata(pdev, keypad); 445 446 return 0; 447 448 err_free_irq: 449 free_irq(irq, keypad); 450 err_free_mem: 451 input_free_device(input); 452 kfree(keypad); 453 return error; 454 } 455 456 static int tc3589x_keypad_remove(struct platform_device *pdev) 457 { 458 struct tc_keypad *keypad = platform_get_drvdata(pdev); 459 int irq = platform_get_irq(pdev, 0); 460 461 if (!keypad->keypad_stopped) 462 tc3589x_keypad_disable(keypad); 463 464 free_irq(irq, keypad); 465 466 input_unregister_device(keypad->input); 467 468 kfree(keypad); 469 470 return 0; 471 } 472 473 #ifdef CONFIG_PM_SLEEP 474 static int tc3589x_keypad_suspend(struct device *dev) 475 { 476 struct platform_device *pdev = to_platform_device(dev); 477 struct tc_keypad *keypad = platform_get_drvdata(pdev); 478 int irq = platform_get_irq(pdev, 0); 479 480 /* keypad is already off; we do nothing */ 481 if (keypad->keypad_stopped) 482 return 0; 483 484 /* if device is not a wakeup source, disable it for powersave */ 485 if (!device_may_wakeup(&pdev->dev)) 486 tc3589x_keypad_disable(keypad); 487 else 488 enable_irq_wake(irq); 489 490 return 0; 491 } 492 493 static int tc3589x_keypad_resume(struct device *dev) 494 { 495 struct platform_device *pdev = to_platform_device(dev); 496 struct tc_keypad *keypad = platform_get_drvdata(pdev); 497 int irq = platform_get_irq(pdev, 0); 498 499 if (!keypad->keypad_stopped) 500 return 0; 501 502 /* enable the device to resume normal operations */ 503 if (!device_may_wakeup(&pdev->dev)) 504 tc3589x_keypad_enable(keypad); 505 else 506 disable_irq_wake(irq); 507 508 return 0; 509 } 510 #endif 511 512 static SIMPLE_DEV_PM_OPS(tc3589x_keypad_dev_pm_ops, 513 tc3589x_keypad_suspend, tc3589x_keypad_resume); 514 515 static struct platform_driver tc3589x_keypad_driver = { 516 .driver = { 517 .name = "tc3589x-keypad", 518 .pm = &tc3589x_keypad_dev_pm_ops, 519 }, 520 .probe = tc3589x_keypad_probe, 521 .remove = tc3589x_keypad_remove, 522 }; 523 module_platform_driver(tc3589x_keypad_driver); 524 525 MODULE_LICENSE("GPL v2"); 526 MODULE_AUTHOR("Jayeeta Banerjee/Sundar Iyer"); 527 MODULE_DESCRIPTION("TC35893 Keypad Driver"); 528 MODULE_ALIAS("platform:tc3589x-keypad"); 529