1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * linux/drivers/input/keyboard/pxa27x_keypad.c 4 * 5 * Driver for the pxa27x matrix keyboard controller. 6 * 7 * Created: Feb 22, 2007 8 * Author: Rodolfo Giometti <giometti@linux.it> 9 * 10 * Based on a previous implementations by Kevin O'Connor 11 * <kevin_at_koconnor.net> and Alex Osborne <bobofdoom@gmail.com> and 12 * on some suggestions by Nicolas Pitre <nico@fluxnic.net>. 13 */ 14 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/interrupt.h> 19 #include <linux/input.h> 20 #include <linux/io.h> 21 #include <linux/device.h> 22 #include <linux/platform_device.h> 23 #include <linux/clk.h> 24 #include <linux/err.h> 25 #include <linux/input/matrix_keypad.h> 26 #include <linux/slab.h> 27 #include <linux/of.h> 28 29 #include <linux/platform_data/keypad-pxa27x.h> 30 /* 31 * Keypad Controller registers 32 */ 33 #define KPC 0x0000 /* Keypad Control register */ 34 #define KPDK 0x0008 /* Keypad Direct Key register */ 35 #define KPREC 0x0010 /* Keypad Rotary Encoder register */ 36 #define KPMK 0x0018 /* Keypad Matrix Key register */ 37 #define KPAS 0x0020 /* Keypad Automatic Scan register */ 38 39 /* Keypad Automatic Scan Multiple Key Presser register 0-3 */ 40 #define KPASMKP0 0x0028 41 #define KPASMKP1 0x0030 42 #define KPASMKP2 0x0038 43 #define KPASMKP3 0x0040 44 #define KPKDI 0x0048 45 46 /* bit definitions */ 47 #define KPC_MKRN(n) ((((n) - 1) & 0x7) << 26) /* matrix key row number */ 48 #define KPC_MKCN(n) ((((n) - 1) & 0x7) << 23) /* matrix key column number */ 49 #define KPC_DKN(n) ((((n) - 1) & 0x7) << 6) /* direct key number */ 50 51 #define KPC_AS (0x1 << 30) /* Automatic Scan bit */ 52 #define KPC_ASACT (0x1 << 29) /* Automatic Scan on Activity */ 53 #define KPC_MI (0x1 << 22) /* Matrix interrupt bit */ 54 #define KPC_IMKP (0x1 << 21) /* Ignore Multiple Key Press */ 55 56 #define KPC_MS(n) (0x1 << (13 + (n))) /* Matrix scan line 'n' */ 57 #define KPC_MS_ALL (0xff << 13) 58 59 #define KPC_ME (0x1 << 12) /* Matrix Keypad Enable */ 60 #define KPC_MIE (0x1 << 11) /* Matrix Interrupt Enable */ 61 #define KPC_DK_DEB_SEL (0x1 << 9) /* Direct Keypad Debounce Select */ 62 #define KPC_DI (0x1 << 5) /* Direct key interrupt bit */ 63 #define KPC_RE_ZERO_DEB (0x1 << 4) /* Rotary Encoder Zero Debounce */ 64 #define KPC_REE1 (0x1 << 3) /* Rotary Encoder1 Enable */ 65 #define KPC_REE0 (0x1 << 2) /* Rotary Encoder0 Enable */ 66 #define KPC_DE (0x1 << 1) /* Direct Keypad Enable */ 67 #define KPC_DIE (0x1 << 0) /* Direct Keypad interrupt Enable */ 68 69 #define KPDK_DKP (0x1 << 31) 70 #define KPDK_DK(n) ((n) & 0xff) 71 72 #define KPREC_OF1 (0x1 << 31) 73 #define kPREC_UF1 (0x1 << 30) 74 #define KPREC_OF0 (0x1 << 15) 75 #define KPREC_UF0 (0x1 << 14) 76 77 #define KPREC_RECOUNT0(n) ((n) & 0xff) 78 #define KPREC_RECOUNT1(n) (((n) >> 16) & 0xff) 79 80 #define KPMK_MKP (0x1 << 31) 81 #define KPAS_SO (0x1 << 31) 82 #define KPASMKPx_SO (0x1 << 31) 83 84 #define KPAS_MUKP(n) (((n) >> 26) & 0x1f) 85 #define KPAS_RP(n) (((n) >> 4) & 0xf) 86 #define KPAS_CP(n) ((n) & 0xf) 87 88 #define KPASMKP_MKC_MASK (0xff) 89 90 #define keypad_readl(off) __raw_readl(keypad->mmio_base + (off)) 91 #define keypad_writel(off, v) __raw_writel((v), keypad->mmio_base + (off)) 92 93 #define MAX_MATRIX_KEY_NUM (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS) 94 #define MAX_KEYPAD_KEYS (MAX_MATRIX_KEY_NUM + MAX_DIRECT_KEY_NUM) 95 96 struct pxa27x_keypad { 97 const struct pxa27x_keypad_platform_data *pdata; 98 99 struct clk *clk; 100 struct input_dev *input_dev; 101 void __iomem *mmio_base; 102 103 int irq; 104 105 unsigned short keycodes[MAX_KEYPAD_KEYS]; 106 int rotary_rel_code[2]; 107 108 unsigned int row_shift; 109 110 /* state row bits of each column scan */ 111 uint32_t matrix_key_state[MAX_MATRIX_KEY_COLS]; 112 uint32_t direct_key_state; 113 114 unsigned int direct_key_mask; 115 }; 116 117 #ifdef CONFIG_OF 118 static int pxa27x_keypad_matrix_key_parse_dt(struct pxa27x_keypad *keypad, 119 struct pxa27x_keypad_platform_data *pdata) 120 { 121 struct input_dev *input_dev = keypad->input_dev; 122 struct device *dev = input_dev->dev.parent; 123 u32 rows, cols; 124 int error; 125 126 error = matrix_keypad_parse_properties(dev, &rows, &cols); 127 if (error) 128 return error; 129 130 if (rows > MAX_MATRIX_KEY_ROWS || cols > MAX_MATRIX_KEY_COLS) { 131 dev_err(dev, "rows or cols exceeds maximum value\n"); 132 return -EINVAL; 133 } 134 135 pdata->matrix_key_rows = rows; 136 pdata->matrix_key_cols = cols; 137 138 error = matrix_keypad_build_keymap(NULL, NULL, 139 pdata->matrix_key_rows, 140 pdata->matrix_key_cols, 141 keypad->keycodes, input_dev); 142 if (error) 143 return error; 144 145 return 0; 146 } 147 148 static int pxa27x_keypad_direct_key_parse_dt(struct pxa27x_keypad *keypad, 149 struct pxa27x_keypad_platform_data *pdata) 150 { 151 struct input_dev *input_dev = keypad->input_dev; 152 struct device *dev = input_dev->dev.parent; 153 struct device_node *np = dev->of_node; 154 const __be16 *prop; 155 unsigned short code; 156 unsigned int proplen, size; 157 int i; 158 int error; 159 160 error = of_property_read_u32(np, "marvell,direct-key-count", 161 &pdata->direct_key_num); 162 if (error) { 163 /* 164 * If do not have marvel,direct-key-count defined, 165 * it means direct key is not supported. 166 */ 167 return error == -EINVAL ? 0 : error; 168 } 169 170 error = of_property_read_u32(np, "marvell,direct-key-mask", 171 &pdata->direct_key_mask); 172 if (error) { 173 if (error != -EINVAL) 174 return error; 175 176 /* 177 * If marvell,direct-key-mask is not defined, driver will use 178 * default value. Default value is set when configure the keypad. 179 */ 180 pdata->direct_key_mask = 0; 181 } 182 183 pdata->direct_key_low_active = of_property_read_bool(np, 184 "marvell,direct-key-low-active"); 185 186 prop = of_get_property(np, "marvell,direct-key-map", &proplen); 187 if (!prop) 188 return -EINVAL; 189 190 if (proplen % sizeof(u16)) 191 return -EINVAL; 192 193 size = proplen / sizeof(u16); 194 195 /* Only MAX_DIRECT_KEY_NUM is accepted.*/ 196 if (size > MAX_DIRECT_KEY_NUM) 197 return -EINVAL; 198 199 for (i = 0; i < size; i++) { 200 code = be16_to_cpup(prop + i); 201 keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = code; 202 __set_bit(code, input_dev->keybit); 203 } 204 205 return 0; 206 } 207 208 static int pxa27x_keypad_rotary_parse_dt(struct pxa27x_keypad *keypad, 209 struct pxa27x_keypad_platform_data *pdata) 210 { 211 const __be32 *prop; 212 int i, relkey_ret; 213 unsigned int code, proplen; 214 const char *rotaryname[2] = { 215 "marvell,rotary0", "marvell,rotary1"}; 216 const char relkeyname[] = {"marvell,rotary-rel-key"}; 217 struct input_dev *input_dev = keypad->input_dev; 218 struct device *dev = input_dev->dev.parent; 219 struct device_node *np = dev->of_node; 220 221 relkey_ret = of_property_read_u32(np, relkeyname, &code); 222 /* if can read correct rotary key-code, we do not need this. */ 223 if (relkey_ret == 0) { 224 unsigned short relcode; 225 226 /* rotary0 taks lower half, rotary1 taks upper half. */ 227 relcode = code & 0xffff; 228 pdata->rotary0_rel_code = (code & 0xffff); 229 __set_bit(relcode, input_dev->relbit); 230 231 relcode = code >> 16; 232 pdata->rotary1_rel_code = relcode; 233 __set_bit(relcode, input_dev->relbit); 234 } 235 236 for (i = 0; i < 2; i++) { 237 prop = of_get_property(np, rotaryname[i], &proplen); 238 /* 239 * If the prop is not set, it means keypad does not need 240 * initialize the rotaryX. 241 */ 242 if (!prop) 243 continue; 244 245 code = be32_to_cpup(prop); 246 /* 247 * Not all up/down key code are valid. 248 * Now we depends on direct-rel-code. 249 */ 250 if ((!(code & 0xffff) || !(code >> 16)) && relkey_ret) { 251 return relkey_ret; 252 } else { 253 unsigned int n = MAX_MATRIX_KEY_NUM + (i << 1); 254 unsigned short keycode; 255 256 keycode = code & 0xffff; 257 keypad->keycodes[n] = keycode; 258 __set_bit(keycode, input_dev->keybit); 259 260 keycode = code >> 16; 261 keypad->keycodes[n + 1] = keycode; 262 __set_bit(keycode, input_dev->keybit); 263 264 if (i == 0) 265 pdata->rotary0_rel_code = -1; 266 else 267 pdata->rotary1_rel_code = -1; 268 } 269 if (i == 0) 270 pdata->enable_rotary0 = 1; 271 else 272 pdata->enable_rotary1 = 1; 273 } 274 275 keypad->rotary_rel_code[0] = pdata->rotary0_rel_code; 276 keypad->rotary_rel_code[1] = pdata->rotary1_rel_code; 277 278 return 0; 279 } 280 281 static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad) 282 { 283 struct input_dev *input_dev = keypad->input_dev; 284 struct device *dev = input_dev->dev.parent; 285 struct device_node *np = dev->of_node; 286 struct pxa27x_keypad_platform_data *pdata; 287 int error; 288 289 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 290 if (!pdata) { 291 dev_err(dev, "failed to allocate memory for pdata\n"); 292 return -ENOMEM; 293 } 294 295 error = pxa27x_keypad_matrix_key_parse_dt(keypad, pdata); 296 if (error) { 297 dev_err(dev, "failed to parse matrix key\n"); 298 return error; 299 } 300 301 error = pxa27x_keypad_direct_key_parse_dt(keypad, pdata); 302 if (error) { 303 dev_err(dev, "failed to parse direct key\n"); 304 return error; 305 } 306 307 error = pxa27x_keypad_rotary_parse_dt(keypad, pdata); 308 if (error) { 309 dev_err(dev, "failed to parse rotary key\n"); 310 return error; 311 } 312 313 error = of_property_read_u32(np, "marvell,debounce-interval", 314 &pdata->debounce_interval); 315 if (error) { 316 dev_err(dev, "failed to parse debounce-interval\n"); 317 return error; 318 } 319 320 /* 321 * The keycodes may not only includes matrix key but also the direct 322 * key or rotary key. 323 */ 324 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes); 325 326 keypad->pdata = pdata; 327 return 0; 328 } 329 330 #else 331 332 static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad) 333 { 334 dev_info(keypad->input_dev->dev.parent, "missing platform data\n"); 335 336 return -EINVAL; 337 } 338 339 #endif 340 341 static int pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad) 342 { 343 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 344 struct input_dev *input_dev = keypad->input_dev; 345 unsigned short keycode; 346 int i; 347 int error; 348 349 error = matrix_keypad_build_keymap(pdata->matrix_keymap_data, NULL, 350 pdata->matrix_key_rows, 351 pdata->matrix_key_cols, 352 keypad->keycodes, input_dev); 353 if (error) 354 return error; 355 356 /* 357 * The keycodes may not only include matrix keys but also the direct 358 * or rotary keys. 359 */ 360 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes); 361 362 /* For direct keys. */ 363 for (i = 0; i < pdata->direct_key_num; i++) { 364 keycode = pdata->direct_key_map[i]; 365 keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = keycode; 366 __set_bit(keycode, input_dev->keybit); 367 } 368 369 if (pdata->enable_rotary0) { 370 if (pdata->rotary0_up_key && pdata->rotary0_down_key) { 371 keycode = pdata->rotary0_up_key; 372 keypad->keycodes[MAX_MATRIX_KEY_NUM + 0] = keycode; 373 __set_bit(keycode, input_dev->keybit); 374 375 keycode = pdata->rotary0_down_key; 376 keypad->keycodes[MAX_MATRIX_KEY_NUM + 1] = keycode; 377 __set_bit(keycode, input_dev->keybit); 378 379 keypad->rotary_rel_code[0] = -1; 380 } else { 381 keypad->rotary_rel_code[0] = pdata->rotary0_rel_code; 382 __set_bit(pdata->rotary0_rel_code, input_dev->relbit); 383 } 384 } 385 386 if (pdata->enable_rotary1) { 387 if (pdata->rotary1_up_key && pdata->rotary1_down_key) { 388 keycode = pdata->rotary1_up_key; 389 keypad->keycodes[MAX_MATRIX_KEY_NUM + 2] = keycode; 390 __set_bit(keycode, input_dev->keybit); 391 392 keycode = pdata->rotary1_down_key; 393 keypad->keycodes[MAX_MATRIX_KEY_NUM + 3] = keycode; 394 __set_bit(keycode, input_dev->keybit); 395 396 keypad->rotary_rel_code[1] = -1; 397 } else { 398 keypad->rotary_rel_code[1] = pdata->rotary1_rel_code; 399 __set_bit(pdata->rotary1_rel_code, input_dev->relbit); 400 } 401 } 402 403 __clear_bit(KEY_RESERVED, input_dev->keybit); 404 405 return 0; 406 } 407 408 static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad) 409 { 410 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 411 struct input_dev *input_dev = keypad->input_dev; 412 int row, col, num_keys_pressed = 0; 413 uint32_t new_state[MAX_MATRIX_KEY_COLS]; 414 uint32_t kpas = keypad_readl(KPAS); 415 416 num_keys_pressed = KPAS_MUKP(kpas); 417 418 memset(new_state, 0, sizeof(new_state)); 419 420 if (num_keys_pressed == 0) 421 goto scan; 422 423 if (num_keys_pressed == 1) { 424 col = KPAS_CP(kpas); 425 row = KPAS_RP(kpas); 426 427 /* if invalid row/col, treat as no key pressed */ 428 if (col >= pdata->matrix_key_cols || 429 row >= pdata->matrix_key_rows) 430 goto scan; 431 432 new_state[col] = (1 << row); 433 goto scan; 434 } 435 436 if (num_keys_pressed > 1) { 437 uint32_t kpasmkp0 = keypad_readl(KPASMKP0); 438 uint32_t kpasmkp1 = keypad_readl(KPASMKP1); 439 uint32_t kpasmkp2 = keypad_readl(KPASMKP2); 440 uint32_t kpasmkp3 = keypad_readl(KPASMKP3); 441 442 new_state[0] = kpasmkp0 & KPASMKP_MKC_MASK; 443 new_state[1] = (kpasmkp0 >> 16) & KPASMKP_MKC_MASK; 444 new_state[2] = kpasmkp1 & KPASMKP_MKC_MASK; 445 new_state[3] = (kpasmkp1 >> 16) & KPASMKP_MKC_MASK; 446 new_state[4] = kpasmkp2 & KPASMKP_MKC_MASK; 447 new_state[5] = (kpasmkp2 >> 16) & KPASMKP_MKC_MASK; 448 new_state[6] = kpasmkp3 & KPASMKP_MKC_MASK; 449 new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK; 450 } 451 scan: 452 for (col = 0; col < pdata->matrix_key_cols; col++) { 453 uint32_t bits_changed; 454 int code; 455 456 bits_changed = keypad->matrix_key_state[col] ^ new_state[col]; 457 if (bits_changed == 0) 458 continue; 459 460 for (row = 0; row < pdata->matrix_key_rows; row++) { 461 if ((bits_changed & (1 << row)) == 0) 462 continue; 463 464 code = MATRIX_SCAN_CODE(row, col, keypad->row_shift); 465 466 input_event(input_dev, EV_MSC, MSC_SCAN, code); 467 input_report_key(input_dev, keypad->keycodes[code], 468 new_state[col] & (1 << row)); 469 } 470 } 471 input_sync(input_dev); 472 memcpy(keypad->matrix_key_state, new_state, sizeof(new_state)); 473 } 474 475 #define DEFAULT_KPREC (0x007f007f) 476 477 static inline int rotary_delta(uint32_t kprec) 478 { 479 if (kprec & KPREC_OF0) 480 return (kprec & 0xff) + 0x7f; 481 else if (kprec & KPREC_UF0) 482 return (kprec & 0xff) - 0x7f - 0xff; 483 else 484 return (kprec & 0xff) - 0x7f; 485 } 486 487 static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta) 488 { 489 struct input_dev *dev = keypad->input_dev; 490 491 if (delta == 0) 492 return; 493 494 if (keypad->rotary_rel_code[r] == -1) { 495 int code = MAX_MATRIX_KEY_NUM + 2 * r + (delta > 0 ? 0 : 1); 496 unsigned char keycode = keypad->keycodes[code]; 497 498 /* simulate a press-n-release */ 499 input_event(dev, EV_MSC, MSC_SCAN, code); 500 input_report_key(dev, keycode, 1); 501 input_sync(dev); 502 input_event(dev, EV_MSC, MSC_SCAN, code); 503 input_report_key(dev, keycode, 0); 504 input_sync(dev); 505 } else { 506 input_report_rel(dev, keypad->rotary_rel_code[r], delta); 507 input_sync(dev); 508 } 509 } 510 511 static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad) 512 { 513 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 514 uint32_t kprec; 515 516 /* read and reset to default count value */ 517 kprec = keypad_readl(KPREC); 518 keypad_writel(KPREC, DEFAULT_KPREC); 519 520 if (pdata->enable_rotary0) 521 report_rotary_event(keypad, 0, rotary_delta(kprec)); 522 523 if (pdata->enable_rotary1) 524 report_rotary_event(keypad, 1, rotary_delta(kprec >> 16)); 525 } 526 527 static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad) 528 { 529 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 530 struct input_dev *input_dev = keypad->input_dev; 531 unsigned int new_state; 532 uint32_t kpdk, bits_changed; 533 int i; 534 535 kpdk = keypad_readl(KPDK); 536 537 if (pdata->enable_rotary0 || pdata->enable_rotary1) 538 pxa27x_keypad_scan_rotary(keypad); 539 540 /* 541 * The KPDR_DK only output the key pin level, so it relates to board, 542 * and low level may be active. 543 */ 544 if (pdata->direct_key_low_active) 545 new_state = ~KPDK_DK(kpdk) & keypad->direct_key_mask; 546 else 547 new_state = KPDK_DK(kpdk) & keypad->direct_key_mask; 548 549 bits_changed = keypad->direct_key_state ^ new_state; 550 551 if (bits_changed == 0) 552 return; 553 554 for (i = 0; i < pdata->direct_key_num; i++) { 555 if (bits_changed & (1 << i)) { 556 int code = MAX_MATRIX_KEY_NUM + i; 557 558 input_event(input_dev, EV_MSC, MSC_SCAN, code); 559 input_report_key(input_dev, keypad->keycodes[code], 560 new_state & (1 << i)); 561 } 562 } 563 input_sync(input_dev); 564 keypad->direct_key_state = new_state; 565 } 566 567 static void clear_wakeup_event(struct pxa27x_keypad *keypad) 568 { 569 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 570 571 if (pdata->clear_wakeup_event) 572 (pdata->clear_wakeup_event)(); 573 } 574 575 static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id) 576 { 577 struct pxa27x_keypad *keypad = dev_id; 578 unsigned long kpc = keypad_readl(KPC); 579 580 clear_wakeup_event(keypad); 581 582 if (kpc & KPC_DI) 583 pxa27x_keypad_scan_direct(keypad); 584 585 if (kpc & KPC_MI) 586 pxa27x_keypad_scan_matrix(keypad); 587 588 return IRQ_HANDLED; 589 } 590 591 static void pxa27x_keypad_config(struct pxa27x_keypad *keypad) 592 { 593 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata; 594 unsigned int mask = 0, direct_key_num = 0; 595 unsigned long kpc = 0; 596 597 /* clear pending interrupt bit */ 598 keypad_readl(KPC); 599 600 /* enable matrix keys with automatic scan */ 601 if (pdata->matrix_key_rows && pdata->matrix_key_cols) { 602 kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL; 603 kpc |= KPC_MKRN(pdata->matrix_key_rows) | 604 KPC_MKCN(pdata->matrix_key_cols); 605 } 606 607 /* enable rotary key, debounce interval same as direct keys */ 608 if (pdata->enable_rotary0) { 609 mask |= 0x03; 610 direct_key_num = 2; 611 kpc |= KPC_REE0; 612 } 613 614 if (pdata->enable_rotary1) { 615 mask |= 0x0c; 616 direct_key_num = 4; 617 kpc |= KPC_REE1; 618 } 619 620 if (pdata->direct_key_num > direct_key_num) 621 direct_key_num = pdata->direct_key_num; 622 623 /* 624 * Direct keys usage may not start from KP_DKIN0, check the platfrom 625 * mask data to config the specific. 626 */ 627 if (pdata->direct_key_mask) 628 keypad->direct_key_mask = pdata->direct_key_mask; 629 else 630 keypad->direct_key_mask = ((1 << direct_key_num) - 1) & ~mask; 631 632 /* enable direct key */ 633 if (direct_key_num) 634 kpc |= KPC_DE | KPC_DIE | KPC_DKN(direct_key_num); 635 636 keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB); 637 keypad_writel(KPREC, DEFAULT_KPREC); 638 keypad_writel(KPKDI, pdata->debounce_interval); 639 } 640 641 static int pxa27x_keypad_open(struct input_dev *dev) 642 { 643 struct pxa27x_keypad *keypad = input_get_drvdata(dev); 644 int ret; 645 /* Enable unit clock */ 646 ret = clk_prepare_enable(keypad->clk); 647 if (ret) 648 return ret; 649 650 pxa27x_keypad_config(keypad); 651 652 return 0; 653 } 654 655 static void pxa27x_keypad_close(struct input_dev *dev) 656 { 657 struct pxa27x_keypad *keypad = input_get_drvdata(dev); 658 659 /* Disable clock unit */ 660 clk_disable_unprepare(keypad->clk); 661 } 662 663 static int pxa27x_keypad_suspend(struct device *dev) 664 { 665 struct platform_device *pdev = to_platform_device(dev); 666 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev); 667 668 /* 669 * If the keypad is used a wake up source, clock can not be disabled. 670 * Or it can not detect the key pressing. 671 */ 672 if (device_may_wakeup(&pdev->dev)) 673 enable_irq_wake(keypad->irq); 674 else 675 clk_disable_unprepare(keypad->clk); 676 677 return 0; 678 } 679 680 static int pxa27x_keypad_resume(struct device *dev) 681 { 682 struct platform_device *pdev = to_platform_device(dev); 683 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev); 684 struct input_dev *input_dev = keypad->input_dev; 685 int ret = 0; 686 687 /* 688 * If the keypad is used as wake up source, the clock is not turned 689 * off. So do not need configure it again. 690 */ 691 if (device_may_wakeup(&pdev->dev)) { 692 disable_irq_wake(keypad->irq); 693 } else { 694 mutex_lock(&input_dev->mutex); 695 696 if (input_device_enabled(input_dev)) { 697 /* Enable unit clock */ 698 ret = clk_prepare_enable(keypad->clk); 699 if (!ret) 700 pxa27x_keypad_config(keypad); 701 } 702 703 mutex_unlock(&input_dev->mutex); 704 } 705 706 return ret; 707 } 708 709 static DEFINE_SIMPLE_DEV_PM_OPS(pxa27x_keypad_pm_ops, 710 pxa27x_keypad_suspend, pxa27x_keypad_resume); 711 712 713 static int pxa27x_keypad_probe(struct platform_device *pdev) 714 { 715 const struct pxa27x_keypad_platform_data *pdata = 716 dev_get_platdata(&pdev->dev); 717 struct device_node *np = pdev->dev.of_node; 718 struct pxa27x_keypad *keypad; 719 struct input_dev *input_dev; 720 int irq, error; 721 722 /* Driver need build keycode from device tree or pdata */ 723 if (!np && !pdata) 724 return -EINVAL; 725 726 irq = platform_get_irq(pdev, 0); 727 if (irq < 0) 728 return -ENXIO; 729 730 keypad = devm_kzalloc(&pdev->dev, sizeof(*keypad), 731 GFP_KERNEL); 732 if (!keypad) 733 return -ENOMEM; 734 735 input_dev = devm_input_allocate_device(&pdev->dev); 736 if (!input_dev) 737 return -ENOMEM; 738 739 keypad->pdata = pdata; 740 keypad->input_dev = input_dev; 741 keypad->irq = irq; 742 743 keypad->mmio_base = devm_platform_ioremap_resource(pdev, 0); 744 if (IS_ERR(keypad->mmio_base)) 745 return PTR_ERR(keypad->mmio_base); 746 747 keypad->clk = devm_clk_get(&pdev->dev, NULL); 748 if (IS_ERR(keypad->clk)) { 749 dev_err(&pdev->dev, "failed to get keypad clock\n"); 750 return PTR_ERR(keypad->clk); 751 } 752 753 input_dev->name = pdev->name; 754 input_dev->id.bustype = BUS_HOST; 755 input_dev->open = pxa27x_keypad_open; 756 input_dev->close = pxa27x_keypad_close; 757 input_dev->dev.parent = &pdev->dev; 758 759 input_dev->keycode = keypad->keycodes; 760 input_dev->keycodesize = sizeof(keypad->keycodes[0]); 761 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes); 762 763 input_set_drvdata(input_dev, keypad); 764 765 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP); 766 input_set_capability(input_dev, EV_MSC, MSC_SCAN); 767 768 if (pdata) { 769 error = pxa27x_keypad_build_keycode(keypad); 770 } else { 771 error = pxa27x_keypad_build_keycode_from_dt(keypad); 772 /* 773 * Data that we get from DT resides in dynamically 774 * allocated memory so we need to update our pdata 775 * pointer. 776 */ 777 pdata = keypad->pdata; 778 } 779 if (error) { 780 dev_err(&pdev->dev, "failed to build keycode\n"); 781 return error; 782 } 783 784 keypad->row_shift = get_count_order(pdata->matrix_key_cols); 785 786 if ((pdata->enable_rotary0 && keypad->rotary_rel_code[0] != -1) || 787 (pdata->enable_rotary1 && keypad->rotary_rel_code[1] != -1)) { 788 input_dev->evbit[0] |= BIT_MASK(EV_REL); 789 } 790 791 error = devm_request_irq(&pdev->dev, irq, pxa27x_keypad_irq_handler, 792 0, pdev->name, keypad); 793 if (error) { 794 dev_err(&pdev->dev, "failed to request IRQ\n"); 795 return error; 796 } 797 798 /* Register the input device */ 799 error = input_register_device(input_dev); 800 if (error) { 801 dev_err(&pdev->dev, "failed to register input device\n"); 802 return error; 803 } 804 805 platform_set_drvdata(pdev, keypad); 806 device_init_wakeup(&pdev->dev, 1); 807 808 return 0; 809 } 810 811 #ifdef CONFIG_OF 812 static const struct of_device_id pxa27x_keypad_dt_match[] = { 813 { .compatible = "marvell,pxa27x-keypad" }, 814 {}, 815 }; 816 MODULE_DEVICE_TABLE(of, pxa27x_keypad_dt_match); 817 #endif 818 819 static struct platform_driver pxa27x_keypad_driver = { 820 .probe = pxa27x_keypad_probe, 821 .driver = { 822 .name = "pxa27x-keypad", 823 .of_match_table = of_match_ptr(pxa27x_keypad_dt_match), 824 .pm = pm_sleep_ptr(&pxa27x_keypad_pm_ops), 825 }, 826 }; 827 module_platform_driver(pxa27x_keypad_driver); 828 829 MODULE_DESCRIPTION("PXA27x Keypad Controller Driver"); 830 MODULE_LICENSE("GPL"); 831 /* work with hotplug and coldplug */ 832 MODULE_ALIAS("platform:pxa27x-keypad"); 833