1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * Samsung keypad driver
5 * Copyright (C) 2010 Samsung Electronics Co.Ltd
6 * Author: Joonyoung Shim <jy0922.shim@samsung.com>
7 * Author: Donghwa Lee <dh09.lee@samsung.com>
10 #include <linux/clk.h>
11 #include <linux/delay.h>
12 #include <linux/err.h>
13 #include <linux/input.h>
14 #include <linux/interrupt.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
19 #include <linux/pm_runtime.h>
20 #include <linux/slab.h>
22 #include <linux/sched.h>
23 #include <linux/input/samsung-keypad.h>
25 #define SAMSUNG_KEYIFCON 0x00
26 #define SAMSUNG_KEYIFSTSCLR 0x04
27 #define SAMSUNG_KEYIFCOL 0x08
28 #define SAMSUNG_KEYIFROW 0x0c
29 #define SAMSUNG_KEYIFFC 0x10
31 /* SAMSUNG_KEYIFCON */
32 #define SAMSUNG_KEYIFCON_INT_F_EN (1 << 0)
33 #define SAMSUNG_KEYIFCON_INT_R_EN (1 << 1)
34 #define SAMSUNG_KEYIFCON_DF_EN (1 << 2)
35 #define SAMSUNG_KEYIFCON_FC_EN (1 << 3)
36 #define SAMSUNG_KEYIFCON_WAKEUPEN (1 << 4)
38 /* SAMSUNG_KEYIFSTSCLR */
39 #define SAMSUNG_KEYIFSTSCLR_P_INT_MASK (0xff << 0)
40 #define SAMSUNG_KEYIFSTSCLR_R_INT_MASK (0xff << 8)
41 #define SAMSUNG_KEYIFSTSCLR_R_INT_OFFSET 8
42 #define S5PV210_KEYIFSTSCLR_P_INT_MASK (0x3fff << 0)
43 #define S5PV210_KEYIFSTSCLR_R_INT_MASK (0x3fff << 16)
44 #define S5PV210_KEYIFSTSCLR_R_INT_OFFSET 16
46 /* SAMSUNG_KEYIFCOL */
47 #define SAMSUNG_KEYIFCOL_MASK (0xff << 0)
48 #define S5PV210_KEYIFCOLEN_MASK (0xff << 8)
50 /* SAMSUNG_KEYIFROW */
51 #define SAMSUNG_KEYIFROW_MASK (0xff << 0)
52 #define S5PV210_KEYIFROW_MASK (0x3fff << 0)
55 #define SAMSUNG_KEYIFFC_MASK (0x3ff << 0)
57 enum samsung_keypad_type
{
62 struct samsung_keypad
{
63 struct input_dev
*input_dev
;
64 struct platform_device
*pdev
;
67 wait_queue_head_t wait
;
71 enum samsung_keypad_type type
;
72 unsigned int row_shift
;
75 unsigned int row_state
[SAMSUNG_MAX_COLS
];
76 unsigned short keycodes
[];
79 static void samsung_keypad_scan(struct samsung_keypad
*keypad
,
80 unsigned int *row_state
)
85 for (col
= 0; col
< keypad
->cols
; col
++) {
86 if (keypad
->type
== KEYPAD_TYPE_S5PV210
) {
87 val
= S5PV210_KEYIFCOLEN_MASK
;
88 val
&= ~(1 << col
) << 8;
90 val
= SAMSUNG_KEYIFCOL_MASK
;
94 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCOL
);
97 val
= readl(keypad
->base
+ SAMSUNG_KEYIFROW
);
98 row_state
[col
] = ~val
& ((1 << keypad
->rows
) - 1);
101 /* KEYIFCOL reg clear */
102 writel(0, keypad
->base
+ SAMSUNG_KEYIFCOL
);
105 static bool samsung_keypad_report(struct samsung_keypad
*keypad
,
106 unsigned int *row_state
)
108 struct input_dev
*input_dev
= keypad
->input_dev
;
109 unsigned int changed
;
110 unsigned int pressed
;
111 unsigned int key_down
= 0;
113 unsigned int col
, row
;
115 for (col
= 0; col
< keypad
->cols
; col
++) {
116 changed
= row_state
[col
] ^ keypad
->row_state
[col
];
117 key_down
|= row_state
[col
];
121 for (row
= 0; row
< keypad
->rows
; row
++) {
122 if (!(changed
& (1 << row
)))
125 pressed
= row_state
[col
] & (1 << row
);
127 dev_dbg(&keypad
->input_dev
->dev
,
128 "key %s, row: %d, col: %d\n",
129 pressed
? "pressed" : "released", row
, col
);
131 val
= MATRIX_SCAN_CODE(row
, col
, keypad
->row_shift
);
133 input_event(input_dev
, EV_MSC
, MSC_SCAN
, val
);
134 input_report_key(input_dev
,
135 keypad
->keycodes
[val
], pressed
);
137 input_sync(keypad
->input_dev
);
140 memcpy(keypad
->row_state
, row_state
, sizeof(keypad
->row_state
));
145 static irqreturn_t
samsung_keypad_irq(int irq
, void *dev_id
)
147 struct samsung_keypad
*keypad
= dev_id
;
148 unsigned int row_state
[SAMSUNG_MAX_COLS
];
151 pm_runtime_get_sync(&keypad
->pdev
->dev
);
154 readl(keypad
->base
+ SAMSUNG_KEYIFSTSCLR
);
155 /* Clear interrupt. */
156 writel(~0x0, keypad
->base
+ SAMSUNG_KEYIFSTSCLR
);
158 samsung_keypad_scan(keypad
, row_state
);
160 key_down
= samsung_keypad_report(keypad
, row_state
);
162 wait_event_timeout(keypad
->wait
, keypad
->stopped
,
163 msecs_to_jiffies(50));
165 } while (key_down
&& !keypad
->stopped
);
167 pm_runtime_put(&keypad
->pdev
->dev
);
172 static void samsung_keypad_start(struct samsung_keypad
*keypad
)
176 pm_runtime_get_sync(&keypad
->pdev
->dev
);
178 /* Tell IRQ thread that it may poll the device. */
179 keypad
->stopped
= false;
181 clk_enable(keypad
->clk
);
183 /* Enable interrupt bits. */
184 val
= readl(keypad
->base
+ SAMSUNG_KEYIFCON
);
185 val
|= SAMSUNG_KEYIFCON_INT_F_EN
| SAMSUNG_KEYIFCON_INT_R_EN
;
186 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCON
);
188 /* KEYIFCOL reg clear. */
189 writel(0, keypad
->base
+ SAMSUNG_KEYIFCOL
);
191 pm_runtime_put(&keypad
->pdev
->dev
);
194 static void samsung_keypad_stop(struct samsung_keypad
*keypad
)
198 pm_runtime_get_sync(&keypad
->pdev
->dev
);
200 /* Signal IRQ thread to stop polling and disable the handler. */
201 keypad
->stopped
= true;
202 wake_up(&keypad
->wait
);
203 disable_irq(keypad
->irq
);
205 /* Clear interrupt. */
206 writel(~0x0, keypad
->base
+ SAMSUNG_KEYIFSTSCLR
);
208 /* Disable interrupt bits. */
209 val
= readl(keypad
->base
+ SAMSUNG_KEYIFCON
);
210 val
&= ~(SAMSUNG_KEYIFCON_INT_F_EN
| SAMSUNG_KEYIFCON_INT_R_EN
);
211 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCON
);
213 clk_disable(keypad
->clk
);
216 * Now that chip should not generate interrupts we can safely
217 * re-enable the handler.
219 enable_irq(keypad
->irq
);
221 pm_runtime_put(&keypad
->pdev
->dev
);
224 static int samsung_keypad_open(struct input_dev
*input_dev
)
226 struct samsung_keypad
*keypad
= input_get_drvdata(input_dev
);
228 samsung_keypad_start(keypad
);
233 static void samsung_keypad_close(struct input_dev
*input_dev
)
235 struct samsung_keypad
*keypad
= input_get_drvdata(input_dev
);
237 samsung_keypad_stop(keypad
);
241 static struct samsung_keypad_platdata
*
242 samsung_keypad_parse_dt(struct device
*dev
)
244 struct samsung_keypad_platdata
*pdata
;
245 struct matrix_keymap_data
*keymap_data
;
246 uint32_t *keymap
, num_rows
= 0, num_cols
= 0;
247 struct device_node
*np
= dev
->of_node
, *key_np
;
248 unsigned int key_count
;
251 dev_err(dev
, "missing device tree data\n");
252 return ERR_PTR(-EINVAL
);
255 pdata
= devm_kzalloc(dev
, sizeof(*pdata
), GFP_KERNEL
);
257 dev_err(dev
, "could not allocate memory for platform data\n");
258 return ERR_PTR(-ENOMEM
);
261 of_property_read_u32(np
, "samsung,keypad-num-rows", &num_rows
);
262 of_property_read_u32(np
, "samsung,keypad-num-columns", &num_cols
);
263 if (!num_rows
|| !num_cols
) {
264 dev_err(dev
, "number of keypad rows/columns not specified\n");
265 return ERR_PTR(-EINVAL
);
267 pdata
->rows
= num_rows
;
268 pdata
->cols
= num_cols
;
270 keymap_data
= devm_kzalloc(dev
, sizeof(*keymap_data
), GFP_KERNEL
);
272 dev_err(dev
, "could not allocate memory for keymap data\n");
273 return ERR_PTR(-ENOMEM
);
275 pdata
->keymap_data
= keymap_data
;
277 key_count
= of_get_child_count(np
);
278 keymap_data
->keymap_size
= key_count
;
279 keymap
= devm_kcalloc(dev
, key_count
, sizeof(uint32_t), GFP_KERNEL
);
281 dev_err(dev
, "could not allocate memory for keymap\n");
282 return ERR_PTR(-ENOMEM
);
284 keymap_data
->keymap
= keymap
;
286 for_each_child_of_node(np
, key_np
) {
287 u32 row
, col
, key_code
;
288 of_property_read_u32(key_np
, "keypad,row", &row
);
289 of_property_read_u32(key_np
, "keypad,column", &col
);
290 of_property_read_u32(key_np
, "linux,code", &key_code
);
291 *keymap
++ = KEY(row
, col
, key_code
);
294 pdata
->no_autorepeat
= of_property_read_bool(np
, "linux,input-no-autorepeat");
296 pdata
->wakeup
= of_property_read_bool(np
, "wakeup-source") ||
298 of_property_read_bool(np
, "linux,input-wakeup");
304 static struct samsung_keypad_platdata
*
305 samsung_keypad_parse_dt(struct device
*dev
)
307 dev_err(dev
, "no platform data defined\n");
309 return ERR_PTR(-EINVAL
);
313 static int samsung_keypad_probe(struct platform_device
*pdev
)
315 const struct samsung_keypad_platdata
*pdata
;
316 const struct matrix_keymap_data
*keymap_data
;
317 struct samsung_keypad
*keypad
;
318 struct resource
*res
;
319 struct input_dev
*input_dev
;
320 unsigned int row_shift
;
321 unsigned int keymap_size
;
324 pdata
= dev_get_platdata(&pdev
->dev
);
326 pdata
= samsung_keypad_parse_dt(&pdev
->dev
);
328 return PTR_ERR(pdata
);
331 keymap_data
= pdata
->keymap_data
;
333 dev_err(&pdev
->dev
, "no keymap data defined\n");
337 if (!pdata
->rows
|| pdata
->rows
> SAMSUNG_MAX_ROWS
)
340 if (!pdata
->cols
|| pdata
->cols
> SAMSUNG_MAX_COLS
)
343 /* initialize the gpio */
345 pdata
->cfg_gpio(pdata
->rows
, pdata
->cols
);
347 row_shift
= get_count_order(pdata
->cols
);
348 keymap_size
= (pdata
->rows
<< row_shift
) * sizeof(keypad
->keycodes
[0]);
350 keypad
= devm_kzalloc(&pdev
->dev
, sizeof(*keypad
) + keymap_size
,
352 input_dev
= devm_input_allocate_device(&pdev
->dev
);
353 if (!keypad
|| !input_dev
)
356 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
360 keypad
->base
= devm_ioremap(&pdev
->dev
, res
->start
, resource_size(res
));
364 keypad
->clk
= devm_clk_get(&pdev
->dev
, "keypad");
365 if (IS_ERR(keypad
->clk
)) {
366 dev_err(&pdev
->dev
, "failed to get keypad clk\n");
367 return PTR_ERR(keypad
->clk
);
370 error
= clk_prepare(keypad
->clk
);
372 dev_err(&pdev
->dev
, "keypad clock prepare failed\n");
376 keypad
->input_dev
= input_dev
;
378 keypad
->row_shift
= row_shift
;
379 keypad
->rows
= pdata
->rows
;
380 keypad
->cols
= pdata
->cols
;
381 keypad
->stopped
= true;
382 init_waitqueue_head(&keypad
->wait
);
384 if (pdev
->dev
.of_node
)
385 keypad
->type
= of_device_is_compatible(pdev
->dev
.of_node
,
386 "samsung,s5pv210-keypad");
388 keypad
->type
= platform_get_device_id(pdev
)->driver_data
;
390 input_dev
->name
= pdev
->name
;
391 input_dev
->id
.bustype
= BUS_HOST
;
392 input_dev
->dev
.parent
= &pdev
->dev
;
394 input_dev
->open
= samsung_keypad_open
;
395 input_dev
->close
= samsung_keypad_close
;
397 error
= matrix_keypad_build_keymap(keymap_data
, NULL
,
398 pdata
->rows
, pdata
->cols
,
399 keypad
->keycodes
, input_dev
);
401 dev_err(&pdev
->dev
, "failed to build keymap\n");
402 goto err_unprepare_clk
;
405 input_set_capability(input_dev
, EV_MSC
, MSC_SCAN
);
406 if (!pdata
->no_autorepeat
)
407 __set_bit(EV_REP
, input_dev
->evbit
);
409 input_set_drvdata(input_dev
, keypad
);
411 keypad
->irq
= platform_get_irq(pdev
, 0);
412 if (keypad
->irq
< 0) {
414 goto err_unprepare_clk
;
417 error
= devm_request_threaded_irq(&pdev
->dev
, keypad
->irq
, NULL
,
418 samsung_keypad_irq
, IRQF_ONESHOT
,
419 dev_name(&pdev
->dev
), keypad
);
421 dev_err(&pdev
->dev
, "failed to register keypad interrupt\n");
422 goto err_unprepare_clk
;
425 device_init_wakeup(&pdev
->dev
, pdata
->wakeup
);
426 platform_set_drvdata(pdev
, keypad
);
427 pm_runtime_enable(&pdev
->dev
);
429 error
= input_register_device(keypad
->input_dev
);
431 goto err_disable_runtime_pm
;
433 if (pdev
->dev
.of_node
) {
434 devm_kfree(&pdev
->dev
, (void *)pdata
->keymap_data
->keymap
);
435 devm_kfree(&pdev
->dev
, (void *)pdata
->keymap_data
);
436 devm_kfree(&pdev
->dev
, (void *)pdata
);
440 err_disable_runtime_pm
:
441 pm_runtime_disable(&pdev
->dev
);
443 clk_unprepare(keypad
->clk
);
447 static void samsung_keypad_remove(struct platform_device
*pdev
)
449 struct samsung_keypad
*keypad
= platform_get_drvdata(pdev
);
451 pm_runtime_disable(&pdev
->dev
);
453 input_unregister_device(keypad
->input_dev
);
455 clk_unprepare(keypad
->clk
);
458 static int samsung_keypad_runtime_suspend(struct device
*dev
)
460 struct platform_device
*pdev
= to_platform_device(dev
);
461 struct samsung_keypad
*keypad
= platform_get_drvdata(pdev
);
468 /* This may fail on some SoCs due to lack of controller support */
469 error
= enable_irq_wake(keypad
->irq
);
471 keypad
->wake_enabled
= true;
473 val
= readl(keypad
->base
+ SAMSUNG_KEYIFCON
);
474 val
|= SAMSUNG_KEYIFCON_WAKEUPEN
;
475 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCON
);
477 clk_disable(keypad
->clk
);
482 static int samsung_keypad_runtime_resume(struct device
*dev
)
484 struct platform_device
*pdev
= to_platform_device(dev
);
485 struct samsung_keypad
*keypad
= platform_get_drvdata(pdev
);
491 clk_enable(keypad
->clk
);
493 val
= readl(keypad
->base
+ SAMSUNG_KEYIFCON
);
494 val
&= ~SAMSUNG_KEYIFCON_WAKEUPEN
;
495 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCON
);
497 if (keypad
->wake_enabled
)
498 disable_irq_wake(keypad
->irq
);
503 static void samsung_keypad_toggle_wakeup(struct samsung_keypad
*keypad
,
508 clk_enable(keypad
->clk
);
510 val
= readl(keypad
->base
+ SAMSUNG_KEYIFCON
);
512 val
|= SAMSUNG_KEYIFCON_WAKEUPEN
;
513 if (device_may_wakeup(&keypad
->pdev
->dev
))
514 enable_irq_wake(keypad
->irq
);
516 val
&= ~SAMSUNG_KEYIFCON_WAKEUPEN
;
517 if (device_may_wakeup(&keypad
->pdev
->dev
))
518 disable_irq_wake(keypad
->irq
);
520 writel(val
, keypad
->base
+ SAMSUNG_KEYIFCON
);
522 clk_disable(keypad
->clk
);
525 static int samsung_keypad_suspend(struct device
*dev
)
527 struct platform_device
*pdev
= to_platform_device(dev
);
528 struct samsung_keypad
*keypad
= platform_get_drvdata(pdev
);
529 struct input_dev
*input_dev
= keypad
->input_dev
;
531 mutex_lock(&input_dev
->mutex
);
533 if (input_device_enabled(input_dev
))
534 samsung_keypad_stop(keypad
);
536 samsung_keypad_toggle_wakeup(keypad
, true);
538 mutex_unlock(&input_dev
->mutex
);
543 static int samsung_keypad_resume(struct device
*dev
)
545 struct platform_device
*pdev
= to_platform_device(dev
);
546 struct samsung_keypad
*keypad
= platform_get_drvdata(pdev
);
547 struct input_dev
*input_dev
= keypad
->input_dev
;
549 mutex_lock(&input_dev
->mutex
);
551 samsung_keypad_toggle_wakeup(keypad
, false);
553 if (input_device_enabled(input_dev
))
554 samsung_keypad_start(keypad
);
556 mutex_unlock(&input_dev
->mutex
);
561 static const struct dev_pm_ops samsung_keypad_pm_ops
= {
562 SYSTEM_SLEEP_PM_OPS(samsung_keypad_suspend
, samsung_keypad_resume
)
563 RUNTIME_PM_OPS(samsung_keypad_runtime_suspend
,
564 samsung_keypad_runtime_resume
, NULL
)
568 static const struct of_device_id samsung_keypad_dt_match
[] = {
569 { .compatible
= "samsung,s3c6410-keypad" },
570 { .compatible
= "samsung,s5pv210-keypad" },
573 MODULE_DEVICE_TABLE(of
, samsung_keypad_dt_match
);
576 static const struct platform_device_id samsung_keypad_driver_ids
[] = {
578 .name
= "samsung-keypad",
579 .driver_data
= KEYPAD_TYPE_SAMSUNG
,
581 .name
= "s5pv210-keypad",
582 .driver_data
= KEYPAD_TYPE_S5PV210
,
586 MODULE_DEVICE_TABLE(platform
, samsung_keypad_driver_ids
);
588 static struct platform_driver samsung_keypad_driver
= {
589 .probe
= samsung_keypad_probe
,
590 .remove
= samsung_keypad_remove
,
592 .name
= "samsung-keypad",
593 .of_match_table
= of_match_ptr(samsung_keypad_dt_match
),
594 .pm
= pm_ptr(&samsung_keypad_pm_ops
),
596 .id_table
= samsung_keypad_driver_ids
,
598 module_platform_driver(samsung_keypad_driver
);
600 MODULE_DESCRIPTION("Samsung keypad driver");
601 MODULE_AUTHOR("Joonyoung Shim <jy0922.shim@samsung.com>");
602 MODULE_AUTHOR("Donghwa Lee <dh09.lee@samsung.com>");
603 MODULE_LICENSE("GPL");