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#include <linux/bits.h>
16#include <linux/bitfield.h>
17#include <linux/kernel.h>
18#include <linux/module.h>
19#include <linux/interrupt.h>
20#include <linux/input.h>
21#include <linux/io.h>
22#include <linux/device.h>
23#include <linux/platform_device.h>
24#include <linux/property.h>
25#include <linux/clk.h>
26#include <linux/err.h>
27#include <linux/input/matrix_keypad.h>
28#include <linux/slab.h>
29#include <linux/of.h>
30
31/*
32 * Keypad Controller registers
33 */
34#define KPC 0x0000 /* Keypad Control register */
35#define KPDK 0x0008 /* Keypad Direct Key register */
36#define KPREC 0x0010 /* Keypad Rotary Encoder register */
37#define KPMK 0x0018 /* Keypad Matrix Key register */
38#define KPAS 0x0020 /* Keypad Automatic Scan register */
39
40/* Keypad Automatic Scan Multiple Key Presser register 0-3 */
41#define KPASMKP0 0x0028
42#define KPASMKP1 0x0030
43#define KPASMKP2 0x0038
44#define KPASMKP3 0x0040
45#define KPKDI 0x0048
46
47/* bit definitions */
48#define KPC_MKRN_MASK GENMASK(28, 26)
49#define KPC_MKCN_MASK GENMASK(25, 23)
50#define KPC_DKN_MASK GENMASK(8, 6)
51#define KPC_MKRN(n) FIELD_PREP(KPC_MKRN_MASK, (n) - 1)
52#define KPC_MKCN(n) FIELD_PREP(KPC_MKCN_MASK, (n) - 1)
53#define KPC_DKN(n) FIELD_PREP(KPC_DKN_MASK, (n) - 1)
54
55#define KPC_AS BIT(30) /* Automatic Scan bit */
56#define KPC_ASACT BIT(29) /* Automatic Scan on Activity */
57#define KPC_MI BIT(22) /* Matrix interrupt bit */
58#define KPC_IMKP BIT(21) /* Ignore Multiple Key Press */
59
60#define KPC_MS(n) BIT(13 + (n)) /* Matrix scan line 'n' */
61#define KPC_MS_ALL GENMASK(20, 13)
62
63#define KPC_ME BIT(12) /* Matrix Keypad Enable */
64#define KPC_MIE BIT(11) /* Matrix Interrupt Enable */
65#define KPC_DK_DEB_SEL BIT(9) /* Direct Keypad Debounce Select */
66#define KPC_DI BIT(5) /* Direct key interrupt bit */
67#define KPC_RE_ZERO_DEB BIT(4) /* Rotary Encoder Zero Debounce */
68#define KPC_REE1 BIT(3) /* Rotary Encoder1 Enable */
69#define KPC_REE0 BIT(2) /* Rotary Encoder0 Enable */
70#define KPC_DE BIT(1) /* Direct Keypad Enable */
71#define KPC_DIE BIT(0) /* Direct Keypad interrupt Enable */
72
73#define KPDK_DKP BIT(31)
74#define KPDK_DK_MASK GENMASK(7, 0)
75#define KPDK_DK(n) FIELD_GET(KPDK_DK_MASK, n)
76
77#define KPREC_OF1 BIT(31)
78#define KPREC_UF1 BIT(30)
79#define KPREC_OF0 BIT(15)
80#define KPREC_UF0 BIT(14)
81
82#define KPREC_RECOUNT0_MASK GENMASK(7, 0)
83#define KPREC_RECOUNT1_MASK GENMASK(23, 16)
84#define KPREC_RECOUNT0(n) FIELD_GET(KPREC_RECOUNT0_MASK, n)
85#define KPREC_RECOUNT1(n) FIELD_GET(KPREC_RECOUNT1_MASK, n)
86
87#define KPMK_MKP BIT(31)
88#define KPAS_SO BIT(31)
89#define KPASMKPx_SO BIT(31)
90
91#define KPAS_MUKP_MASK GENMASK(30, 26)
92#define KPAS_RP_MASK GENMASK(7, 4)
93#define KPAS_CP_MASK GENMASK(3, 0)
94#define KPAS_MUKP(n) FIELD_GET(KPAS_MUKP_MASK, n)
95#define KPAS_RP(n) FIELD_GET(KPAS_RP_MASK, n)
96#define KPAS_CP(n) FIELD_GET(KPAS_CP_MASK, n)
97
98#define KPASMKP_MKC_MASK GENMASK(7, 0)
99
100#define keypad_readl(off) __raw_readl(keypad->mmio_base + (off))
101#define keypad_writel(off, v) __raw_writel((v), keypad->mmio_base + (off))
102
103#define MAX_MATRIX_KEY_ROWS 8
104#define MAX_MATRIX_KEY_COLS 8
105#define MAX_DIRECT_KEY_NUM 8
106#define MAX_ROTARY_ENCODERS 2
107
108#define MAX_MATRIX_KEY_NUM (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)
109#define MAX_KEYPAD_KEYS (MAX_MATRIX_KEY_NUM + MAX_DIRECT_KEY_NUM)
110
111struct pxa27x_keypad_rotary {
112 unsigned short *key_codes;
113 int rel_code;
114 bool enabled;
115};
116
117struct pxa27x_keypad {
118 struct clk *clk;
119 struct input_dev *input_dev;
120 void __iomem *mmio_base;
121
122 int irq;
123
124 unsigned int matrix_key_rows;
125 unsigned int matrix_key_cols;
126 unsigned int row_shift;
127
128 unsigned int direct_key_num;
129 unsigned int direct_key_mask;
130 bool direct_key_low_active;
131
132 /* key debounce interval */
133 unsigned int debounce_interval;
134
135 unsigned short keycodes[MAX_KEYPAD_KEYS];
136
137 /* state row bits of each column scan */
138 u32 matrix_key_state[MAX_MATRIX_KEY_COLS];
139 u32 direct_key_state;
140
141 struct pxa27x_keypad_rotary rotary[MAX_ROTARY_ENCODERS];
142};
143
144static int pxa27x_keypad_matrix_key_parse(struct pxa27x_keypad *keypad)
145{
146 struct input_dev *input_dev = keypad->input_dev;
147 struct device *dev = input_dev->dev.parent;
148 int error;
149
150 error = matrix_keypad_parse_properties(dev, rows: &keypad->matrix_key_rows,
151 cols: &keypad->matrix_key_cols);
152 if (error)
153 return error;
154
155 if (keypad->matrix_key_rows > MAX_MATRIX_KEY_ROWS ||
156 keypad->matrix_key_cols > MAX_MATRIX_KEY_COLS) {
157 dev_err(dev, "rows or cols exceeds maximum value\n");
158 return -EINVAL;
159 }
160
161 keypad->row_shift = get_count_order(count: keypad->matrix_key_cols);
162
163 error = matrix_keypad_build_keymap(NULL, NULL,
164 rows: keypad->matrix_key_rows,
165 cols: keypad->matrix_key_cols,
166 keymap: keypad->keycodes, input_dev);
167 if (error)
168 return error;
169
170 return 0;
171}
172
173static int pxa27x_keypad_direct_key_parse(struct pxa27x_keypad *keypad)
174{
175 struct input_dev *input_dev = keypad->input_dev;
176 struct device *dev = input_dev->dev.parent;
177 unsigned short code;
178 int count;
179 int i;
180 int error;
181
182 error = device_property_read_u32(dev, propname: "marvell,direct-key-count",
183 val: &keypad->direct_key_num);
184 if (error) {
185 /*
186 * If do not have marvel,direct-key-count defined,
187 * it means direct key is not supported.
188 */
189 return error == -EINVAL ? 0 : error;
190 }
191
192 error = device_property_read_u32(dev, propname: "marvell,direct-key-mask",
193 val: &keypad->direct_key_mask);
194 if (error) {
195 if (error != -EINVAL)
196 return error;
197
198 /*
199 * If marvell,direct-key-mask is not defined, driver will use
200 * a default value based on number of direct keys set up.
201 * The default value is calculated in pxa27x_keypad_config().
202 */
203 keypad->direct_key_mask = 0;
204 }
205
206 keypad->direct_key_low_active =
207 device_property_read_bool(dev, propname: "marvell,direct-key-low-active");
208
209 count = device_property_count_u16(dev, propname: "marvell,direct-key-map");
210 if (count <= 0 || count > MAX_DIRECT_KEY_NUM)
211 return -EINVAL;
212
213 error = device_property_read_u16_array(dev, propname: "marvell,direct-key-map",
214 val: &keypad->keycodes[MAX_MATRIX_KEY_NUM],
215 nval: count);
216
217 for (i = 0; i < count; i++) {
218 code = keypad->keycodes[MAX_MATRIX_KEY_NUM + i];
219 __set_bit(code, input_dev->keybit);
220 }
221
222 return 0;
223}
224
225static int pxa27x_keypad_rotary_parse(struct pxa27x_keypad *keypad)
226{
227 static const char * const rotaryname[] = { "marvell,rotary0", "marvell,rotary1" };
228 struct input_dev *input_dev = keypad->input_dev;
229 struct device *dev = input_dev->dev.parent;
230 struct pxa27x_keypad_rotary *encoder;
231 unsigned int code;
232 int i;
233 int error;
234
235 error = device_property_read_u32(dev, propname: "marvell,rotary-rel-key", val: &code);
236 if (!error) {
237 for (i = 0; i < MAX_ROTARY_ENCODERS; i++, code >>= 16) {
238 encoder = &keypad->rotary[i];
239 encoder->enabled = true;
240 encoder->rel_code = code & 0xffff;
241 input_set_capability(dev: input_dev, EV_REL, code: encoder->rel_code);
242 }
243
244 return 0;
245 }
246
247 for (i = 0; i < MAX_ROTARY_ENCODERS; i++) {
248 encoder = &keypad->rotary[i];
249
250 /*
251 * If the prop is not set, it means keypad does not need
252 * initialize the rotaryX.
253 */
254 if (!device_property_present(dev, propname: rotaryname[i]))
255 continue;
256
257 error = device_property_read_u32(dev, propname: rotaryname[i], val: &code);
258 if (error)
259 return error;
260
261 /*
262 * Not all up/down key code are valid.
263 * Now we depends on direct-rel-code.
264 */
265 if (!(code & 0xffff) || !(code >> 16))
266 return -EINVAL;
267
268 encoder->enabled = true;
269 encoder->rel_code = -1;
270 encoder->key_codes = &keypad->keycodes[MAX_MATRIX_KEY_NUM + i * 2];
271 encoder->key_codes[0] = code & 0xffff;
272 encoder->key_codes[1] = code >> 16;
273
274 input_set_capability(dev: input_dev, EV_KEY, code: encoder->key_codes[0]);
275 input_set_capability(dev: input_dev, EV_KEY, code: encoder->key_codes[1]);
276 }
277
278 return 0;
279}
280
281static int pxa27x_keypad_parse_properties(struct pxa27x_keypad *keypad)
282{
283 struct input_dev *input_dev = keypad->input_dev;
284 struct device *dev = input_dev->dev.parent;
285 int error;
286
287 error = pxa27x_keypad_matrix_key_parse(keypad);
288 if (error) {
289 dev_err(dev, "failed to parse matrix key\n");
290 return error;
291 }
292
293 error = pxa27x_keypad_direct_key_parse(keypad);
294 if (error) {
295 dev_err(dev, "failed to parse direct key\n");
296 return error;
297 }
298
299 error = pxa27x_keypad_rotary_parse(keypad);
300 if (error) {
301 dev_err(dev, "failed to parse rotary key\n");
302 return error;
303 }
304
305 error = device_property_read_u32(dev, propname: "marvell,debounce-interval",
306 val: &keypad->debounce_interval);
307 if (error) {
308 dev_err(dev, "failed to parse debounce-interval\n");
309 return error;
310 }
311
312 /*
313 * The keycodes may not only includes matrix key but also the direct
314 * key or rotary key.
315 */
316 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
317
318 return 0;
319}
320
321static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)
322{
323 struct input_dev *input_dev = keypad->input_dev;
324 int row, col, num_keys_pressed = 0;
325 u32 new_state[MAX_MATRIX_KEY_COLS];
326 u32 kpas = keypad_readl(KPAS);
327
328 num_keys_pressed = KPAS_MUKP(kpas);
329
330 memset(new_state, 0, sizeof(new_state));
331
332 if (num_keys_pressed == 0)
333 goto scan;
334
335 if (num_keys_pressed == 1) {
336 col = KPAS_CP(kpas);
337 row = KPAS_RP(kpas);
338
339 /* if invalid row/col, treat as no key pressed */
340 if (col >= keypad->matrix_key_cols ||
341 row >= keypad->matrix_key_rows)
342 goto scan;
343
344 new_state[col] = BIT(row);
345 goto scan;
346 }
347
348 if (num_keys_pressed > 1) {
349 u32 kpasmkp0 = keypad_readl(KPASMKP0);
350 u32 kpasmkp1 = keypad_readl(KPASMKP1);
351 u32 kpasmkp2 = keypad_readl(KPASMKP2);
352 u32 kpasmkp3 = keypad_readl(KPASMKP3);
353
354 new_state[0] = kpasmkp0 & KPASMKP_MKC_MASK;
355 new_state[1] = (kpasmkp0 >> 16) & KPASMKP_MKC_MASK;
356 new_state[2] = kpasmkp1 & KPASMKP_MKC_MASK;
357 new_state[3] = (kpasmkp1 >> 16) & KPASMKP_MKC_MASK;
358 new_state[4] = kpasmkp2 & KPASMKP_MKC_MASK;
359 new_state[5] = (kpasmkp2 >> 16) & KPASMKP_MKC_MASK;
360 new_state[6] = kpasmkp3 & KPASMKP_MKC_MASK;
361 new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;
362 }
363scan:
364 for (col = 0; col < keypad->matrix_key_cols; col++) {
365 u32 bits_changed;
366 int code;
367
368 bits_changed = keypad->matrix_key_state[col] ^ new_state[col];
369 if (bits_changed == 0)
370 continue;
371
372 for (row = 0; row < keypad->matrix_key_rows; row++) {
373 if ((bits_changed & BIT(row)) == 0)
374 continue;
375
376 code = MATRIX_SCAN_CODE(row, col, keypad->row_shift);
377
378 input_event(dev: input_dev, EV_MSC, MSC_SCAN, value: code);
379 input_report_key(dev: input_dev, code: keypad->keycodes[code],
380 value: new_state[col] & BIT(row));
381 }
382 }
383 input_sync(dev: input_dev);
384 memcpy(keypad->matrix_key_state, new_state, sizeof(new_state));
385}
386
387#define DEFAULT_KPREC (0x007f007f)
388
389static inline int rotary_delta(u32 kprec)
390{
391 if (kprec & KPREC_OF0)
392 return (kprec & 0xff) + 0x7f;
393 else if (kprec & KPREC_UF0)
394 return (kprec & 0xff) - 0x7f - 0xff;
395 else
396 return (kprec & 0xff) - 0x7f;
397}
398
399static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)
400{
401 struct pxa27x_keypad_rotary *encoder = &keypad->rotary[r];
402 struct input_dev *dev = keypad->input_dev;
403
404 if (!encoder->enabled || delta == 0)
405 return;
406
407 if (encoder->rel_code == -1) {
408 int idx = delta > 0 ? 0 : 1;
409 int code = MAX_MATRIX_KEY_NUM + 2 * r + idx;
410 unsigned char keycode = encoder->key_codes[idx];
411
412 /* simulate a press-n-release */
413 input_event(dev, EV_MSC, MSC_SCAN, value: code);
414 input_report_key(dev, code: keycode, value: 1);
415 input_sync(dev);
416 input_event(dev, EV_MSC, MSC_SCAN, value: code);
417 input_report_key(dev, code: keycode, value: 0);
418 input_sync(dev);
419 } else {
420 input_report_rel(dev, code: encoder->rel_code, value: delta);
421 input_sync(dev);
422 }
423}
424
425static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)
426{
427 u32 kprec;
428 int i;
429
430 /* read and reset to default count value */
431 kprec = keypad_readl(KPREC);
432 keypad_writel(KPREC, DEFAULT_KPREC);
433
434 for (i = 0; i < MAX_ROTARY_ENCODERS; i++) {
435 report_rotary_event(keypad, r: 0, delta: rotary_delta(kprec));
436 kprec >>= 16;
437 }
438}
439
440static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
441{
442 struct input_dev *input_dev = keypad->input_dev;
443 unsigned int new_state;
444 u32 kpdk, bits_changed;
445 int i;
446
447 kpdk = keypad_readl(KPDK);
448
449 if (keypad->rotary[0].enabled || keypad->rotary[1].enabled)
450 pxa27x_keypad_scan_rotary(keypad);
451
452 /*
453 * The KPDR_DK only output the key pin level, so it relates to board,
454 * and low level may be active.
455 */
456 if (keypad->direct_key_low_active)
457 new_state = ~KPDK_DK(kpdk) & keypad->direct_key_mask;
458 else
459 new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;
460
461 bits_changed = keypad->direct_key_state ^ new_state;
462
463 if (bits_changed == 0)
464 return;
465
466 for (i = 0; i < keypad->direct_key_num; i++) {
467 if (bits_changed & BIT(i)) {
468 int code = MAX_MATRIX_KEY_NUM + i;
469
470 input_event(dev: input_dev, EV_MSC, MSC_SCAN, value: code);
471 input_report_key(dev: input_dev, code: keypad->keycodes[code],
472 value: new_state & BIT(i));
473 }
474 }
475 input_sync(dev: input_dev);
476 keypad->direct_key_state = new_state;
477}
478
479static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
480{
481 struct pxa27x_keypad *keypad = dev_id;
482 unsigned long kpc = keypad_readl(KPC);
483
484 if (kpc & KPC_DI)
485 pxa27x_keypad_scan_direct(keypad);
486
487 if (kpc & KPC_MI)
488 pxa27x_keypad_scan_matrix(keypad);
489
490 return IRQ_HANDLED;
491}
492
493static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)
494{
495 unsigned int mask = 0, direct_key_num = 0;
496 unsigned long kpc = 0;
497
498 /* clear pending interrupt bit */
499 keypad_readl(KPC);
500
501 /* enable matrix keys with automatic scan */
502 if (keypad->matrix_key_rows && keypad->matrix_key_cols) {
503 kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;
504 kpc |= KPC_MKRN(keypad->matrix_key_rows) |
505 KPC_MKCN(keypad->matrix_key_cols);
506 }
507
508 /* enable rotary key, debounce interval same as direct keys */
509 if (keypad->rotary[0].enabled) {
510 mask |= 0x03;
511 direct_key_num = 2;
512 kpc |= KPC_REE0;
513 }
514
515 if (keypad->rotary[1].enabled) {
516 mask |= 0x0c;
517 direct_key_num = 4;
518 kpc |= KPC_REE1;
519 }
520
521 if (keypad->direct_key_num > direct_key_num)
522 direct_key_num = keypad->direct_key_num;
523
524 /*
525 * Direct keys usage may not start from KP_DKIN0, check the platfrom
526 * mask data to config the specific.
527 */
528 if (!keypad->direct_key_mask)
529 keypad->direct_key_mask = GENMASK(direct_key_num - 1, 0) & ~mask;
530
531 /* enable direct key */
532 if (direct_key_num)
533 kpc |= KPC_DE | KPC_DIE | KPC_DKN(direct_key_num);
534
535 keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);
536 keypad_writel(KPREC, DEFAULT_KPREC);
537 keypad_writel(KPKDI, keypad->debounce_interval);
538}
539
540static int pxa27x_keypad_open(struct input_dev *dev)
541{
542 struct pxa27x_keypad *keypad = input_get_drvdata(dev);
543 int ret;
544 /* Enable unit clock */
545 ret = clk_prepare_enable(clk: keypad->clk);
546 if (ret)
547 return ret;
548
549 pxa27x_keypad_config(keypad);
550
551 return 0;
552}
553
554static void pxa27x_keypad_close(struct input_dev *dev)
555{
556 struct pxa27x_keypad *keypad = input_get_drvdata(dev);
557
558 /* Disable clock unit */
559 clk_disable_unprepare(clk: keypad->clk);
560}
561
562static int pxa27x_keypad_suspend(struct device *dev)
563{
564 struct platform_device *pdev = to_platform_device(dev);
565 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
566
567 /*
568 * If the keypad is used a wake up source, clock can not be disabled.
569 * Or it can not detect the key pressing.
570 */
571 if (device_may_wakeup(dev: &pdev->dev))
572 enable_irq_wake(irq: keypad->irq);
573 else
574 clk_disable_unprepare(clk: keypad->clk);
575
576 return 0;
577}
578
579static int pxa27x_keypad_resume(struct device *dev)
580{
581 struct platform_device *pdev = to_platform_device(dev);
582 struct pxa27x_keypad *keypad = platform_get_drvdata(pdev);
583 struct input_dev *input_dev = keypad->input_dev;
584 int error;
585
586 /*
587 * If the keypad is used as wake up source, the clock is not turned
588 * off. So do not need configure it again.
589 */
590 if (device_may_wakeup(dev: &pdev->dev)) {
591 disable_irq_wake(irq: keypad->irq);
592 } else {
593 guard(mutex)(T: &input_dev->mutex);
594
595 if (input_device_enabled(dev: input_dev)) {
596 /* Enable unit clock */
597 error = clk_prepare_enable(clk: keypad->clk);
598 if (error)
599 return error;
600
601 pxa27x_keypad_config(keypad);
602 }
603 }
604
605 return 0;
606}
607
608static DEFINE_SIMPLE_DEV_PM_OPS(pxa27x_keypad_pm_ops,
609 pxa27x_keypad_suspend, pxa27x_keypad_resume);
610
611static int pxa27x_keypad_probe(struct platform_device *pdev)
612{
613 struct pxa27x_keypad *keypad;
614 struct input_dev *input_dev;
615 int irq;
616 int error;
617
618 irq = platform_get_irq(pdev, 0);
619 if (irq < 0)
620 return -ENXIO;
621
622 keypad = devm_kzalloc(dev: &pdev->dev, size: sizeof(*keypad),
623 GFP_KERNEL);
624 if (!keypad)
625 return -ENOMEM;
626
627 input_dev = devm_input_allocate_device(&pdev->dev);
628 if (!input_dev)
629 return -ENOMEM;
630
631 keypad->input_dev = input_dev;
632 keypad->irq = irq;
633
634 keypad->mmio_base = devm_platform_ioremap_resource(pdev, index: 0);
635 if (IS_ERR(ptr: keypad->mmio_base))
636 return PTR_ERR(ptr: keypad->mmio_base);
637
638 keypad->clk = devm_clk_get(dev: &pdev->dev, NULL);
639 if (IS_ERR(ptr: keypad->clk)) {
640 dev_err(&pdev->dev, "failed to get keypad clock\n");
641 return PTR_ERR(ptr: keypad->clk);
642 }
643
644 input_dev->name = pdev->name;
645 input_dev->id.bustype = BUS_HOST;
646 input_dev->open = pxa27x_keypad_open;
647 input_dev->close = pxa27x_keypad_close;
648 input_dev->dev.parent = &pdev->dev;
649
650 input_dev->keycode = keypad->keycodes;
651 input_dev->keycodesize = sizeof(keypad->keycodes[0]);
652 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
653
654 input_set_drvdata(dev: input_dev, data: keypad);
655
656 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
657 input_set_capability(dev: input_dev, EV_MSC, MSC_SCAN);
658
659 error = pxa27x_keypad_parse_properties(keypad);
660 if (error) {
661 dev_err(&pdev->dev, "failed to parse keypad properties\n");
662 return error;
663 }
664
665 error = devm_request_irq(dev: &pdev->dev, irq, handler: pxa27x_keypad_irq_handler,
666 irqflags: 0, devname: pdev->name, dev_id: keypad);
667 if (error) {
668 dev_err(&pdev->dev, "failed to request IRQ\n");
669 return error;
670 }
671
672 /* Register the input device */
673 error = input_register_device(input_dev);
674 if (error) {
675 dev_err(&pdev->dev, "failed to register input device\n");
676 return error;
677 }
678
679 platform_set_drvdata(pdev, data: keypad);
680 device_init_wakeup(dev: &pdev->dev, enable: 1);
681
682 return 0;
683}
684
685#ifdef CONFIG_OF
686static const struct of_device_id pxa27x_keypad_dt_match[] = {
687 { .compatible = "marvell,pxa27x-keypad" },
688 {},
689};
690MODULE_DEVICE_TABLE(of, pxa27x_keypad_dt_match);
691#endif
692
693static struct platform_driver pxa27x_keypad_driver = {
694 .probe = pxa27x_keypad_probe,
695 .driver = {
696 .name = "pxa27x-keypad",
697 .of_match_table = of_match_ptr(pxa27x_keypad_dt_match),
698 .pm = pm_sleep_ptr(&pxa27x_keypad_pm_ops),
699 },
700};
701module_platform_driver(pxa27x_keypad_driver);
702
703MODULE_DESCRIPTION("PXA27x Keypad Controller Driver");
704MODULE_LICENSE("GPL");
705/* work with hotplug and coldplug */
706MODULE_ALIAS("platform:pxa27x-keypad");
707

source code of linux/drivers/input/keyboard/pxa27x_keypad.c