Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
Input: spear-keyboard - drop support for platform data
There are no in-kernel users of spear kbd_platform_data in the kernel,
and the driver supports configuration via device tree, so drop
support of static platform data and move properties parsing from
OF-specific methods to generic ones.
Link: https://lore.kernel.org/r/vppjxui76im26uamznx7evm5lmbe3d6v3oxsa7mqyytykh4zm6@nhlf33v3hp6g
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
+15
-220
+15
-56
drivers/input/keyboard/spear-keyboard.c
+15
-56
drivers/input/keyboard/spear-keyboard.c
···
14
14
#include <linux/errno.h>
15
15
#include <linux/interrupt.h>
16
16
#include <linux/input.h>
17
+
#include <linux/input/matrix_keypad.h>
17
18
#include <linux/io.h>
18
19
#include <linux/irq.h>
19
20
#include <linux/kernel.h>
···
23
22
#include <linux/platform_device.h>
24
23
#include <linux/slab.h>
25
24
#include <linux/types.h>
26
-
#include <linux/platform_data/keyboard-spear.h>
27
25
28
26
/* Keyboard Registers */
29
27
#define MODE_CTL_REG 0x00
···
56
56
void __iomem *io_base;
57
57
struct clk *clk;
58
58
unsigned int irq;
59
-
unsigned int mode;
60
-
unsigned int suspended_rate;
59
+
u32 mode;
60
+
u32 suspended_rate;
61
+
u32 mode_ctl_reg;
61
62
unsigned short last_key;
62
63
unsigned short keycodes[NUM_ROWS * NUM_COLS];
63
-
bool rep;
64
64
bool irq_wake_enabled;
65
-
u32 mode_ctl_reg;
66
65
};
67
66
68
67
static irqreturn_t spear_kbd_interrupt(int irq, void *dev_id)
···
142
143
kbd->last_key = KEY_RESERVED;
143
144
}
144
145
145
-
#ifdef CONFIG_OF
146
-
static int spear_kbd_parse_dt(struct platform_device *pdev,
147
-
struct spear_kbd *kbd)
148
-
{
149
-
struct device_node *np = pdev->dev.of_node;
150
-
int error;
151
-
u32 val, suspended_rate;
152
-
153
-
if (!np) {
154
-
dev_err(&pdev->dev, "Missing DT data\n");
155
-
return -EINVAL;
156
-
}
157
-
158
-
if (of_property_read_bool(np, "autorepeat"))
159
-
kbd->rep = true;
160
-
161
-
if (of_property_read_u32(np, "suspended_rate", &suspended_rate))
162
-
kbd->suspended_rate = suspended_rate;
163
-
164
-
error = of_property_read_u32(np, "st,mode", &val);
165
-
if (error) {
166
-
dev_err(&pdev->dev, "DT: Invalid or missing mode\n");
167
-
return error;
168
-
}
169
-
170
-
kbd->mode = val;
171
-
return 0;
172
-
}
173
-
#else
174
-
static inline int spear_kbd_parse_dt(struct platform_device *pdev,
175
-
struct spear_kbd *kbd)
176
-
{
177
-
return -ENOSYS;
178
-
}
179
-
#endif
180
-
181
146
static int spear_kbd_probe(struct platform_device *pdev)
182
147
{
183
-
struct kbd_platform_data *pdata = dev_get_platdata(&pdev->dev);
184
-
const struct matrix_keymap_data *keymap = pdata ? pdata->keymap : NULL;
185
148
struct spear_kbd *kbd;
186
149
struct input_dev *input_dev;
187
150
int irq;
···
159
198
return -ENOMEM;
160
199
}
161
200
201
+
error = device_property_read_u32(&pdev->dev, "st,mode", &kbd->mode);
202
+
if (error) {
203
+
dev_err(&pdev->dev, "Invalid or missing mode\n");
204
+
return error;
205
+
}
206
+
207
+
device_property_read_u32(&pdev->dev, "suspended_rate", &kbd->suspended_rate);
208
+
162
209
input_dev = devm_input_allocate_device(&pdev->dev);
163
210
if (!input_dev) {
164
211
dev_err(&pdev->dev, "unable to allocate input device\n");
···
175
206
176
207
kbd->input = input_dev;
177
208
kbd->irq = irq;
178
-
179
-
if (!pdata) {
180
-
error = spear_kbd_parse_dt(pdev, kbd);
181
-
if (error)
182
-
return error;
183
-
} else {
184
-
kbd->mode = pdata->mode;
185
-
kbd->rep = pdata->rep;
186
-
kbd->suspended_rate = pdata->suspended_rate;
187
-
}
188
209
189
210
kbd->io_base = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
190
211
if (IS_ERR(kbd->io_base))
···
193
234
input_dev->open = spear_kbd_open;
194
235
input_dev->close = spear_kbd_close;
195
236
196
-
error = matrix_keypad_build_keymap(keymap, NULL, NUM_ROWS, NUM_COLS,
237
+
error = matrix_keypad_build_keymap(NULL, NULL, NUM_ROWS, NUM_COLS,
197
238
kbd->keycodes, input_dev);
198
239
if (error) {
199
240
dev_err(&pdev->dev, "Failed to build keymap\n");
200
241
return error;
201
242
}
202
243
203
-
if (kbd->rep)
244
+
if (device_property_read_bool(&pdev->dev, "autorepeat"))
204
245
__set_bit(EV_REP, input_dev->evbit);
205
246
input_set_capability(input_dev, EV_MSC, MSC_SCAN);
206
247
207
248
input_set_drvdata(input_dev, kbd);
208
249
209
250
error = devm_request_irq(&pdev->dev, irq, spear_kbd_interrupt, 0,
210
-
"keyboard", kbd);
251
+
"keyboard", kbd);
211
252
if (error) {
212
253
dev_err(&pdev->dev, "request_irq failed\n");
213
254
return error;
-164
include/linux/platform_data/keyboard-spear.h
-164
include/linux/platform_data/keyboard-spear.h
···
1
-
/*
2
-
* Copyright (C) 2010 ST Microelectronics
3
-
* Rajeev Kumar <rajeevkumar.linux@gmail.com>
4
-
*
5
-
* This file is licensed under the terms of the GNU General Public
6
-
* License version 2. This program is licensed "as is" without any
7
-
* warranty of any kind, whether express or implied.
8
-
*/
9
-
10
-
#ifndef __PLAT_KEYBOARD_H
11
-
#define __PLAT_KEYBOARD_H
12
-
13
-
#include <linux/bitops.h>
14
-
#include <linux/input.h>
15
-
#include <linux/input/matrix_keypad.h>
16
-
#include <linux/types.h>
17
-
18
-
#define DECLARE_9x9_KEYMAP(_name) \
19
-
int _name[] = { \
20
-
KEY(0, 0, KEY_ESC), \
21
-
KEY(0, 1, KEY_1), \
22
-
KEY(0, 2, KEY_2), \
23
-
KEY(0, 3, KEY_3), \
24
-
KEY(0, 4, KEY_4), \
25
-
KEY(0, 5, KEY_5), \
26
-
KEY(0, 6, KEY_6), \
27
-
KEY(0, 7, KEY_7), \
28
-
KEY(0, 8, KEY_8), \
29
-
KEY(1, 0, KEY_9), \
30
-
KEY(1, 1, KEY_MINUS), \
31
-
KEY(1, 2, KEY_EQUAL), \
32
-
KEY(1, 3, KEY_BACKSPACE), \
33
-
KEY(1, 4, KEY_TAB), \
34
-
KEY(1, 5, KEY_Q), \
35
-
KEY(1, 6, KEY_W), \
36
-
KEY(1, 7, KEY_E), \
37
-
KEY(1, 8, KEY_R), \
38
-
KEY(2, 0, KEY_T), \
39
-
KEY(2, 1, KEY_Y), \
40
-
KEY(2, 2, KEY_U), \
41
-
KEY(2, 3, KEY_I), \
42
-
KEY(2, 4, KEY_O), \
43
-
KEY(2, 5, KEY_P), \
44
-
KEY(2, 6, KEY_LEFTBRACE), \
45
-
KEY(2, 7, KEY_RIGHTBRACE), \
46
-
KEY(2, 8, KEY_ENTER), \
47
-
KEY(3, 0, KEY_LEFTCTRL), \
48
-
KEY(3, 1, KEY_A), \
49
-
KEY(3, 2, KEY_S), \
50
-
KEY(3, 3, KEY_D), \
51
-
KEY(3, 4, KEY_F), \
52
-
KEY(3, 5, KEY_G), \
53
-
KEY(3, 6, KEY_H), \
54
-
KEY(3, 7, KEY_J), \
55
-
KEY(3, 8, KEY_K), \
56
-
KEY(4, 0, KEY_L), \
57
-
KEY(4, 1, KEY_SEMICOLON), \
58
-
KEY(4, 2, KEY_APOSTROPHE), \
59
-
KEY(4, 3, KEY_GRAVE), \
60
-
KEY(4, 4, KEY_LEFTSHIFT), \
61
-
KEY(4, 5, KEY_BACKSLASH), \
62
-
KEY(4, 6, KEY_Z), \
63
-
KEY(4, 7, KEY_X), \
64
-
KEY(4, 8, KEY_C), \
65
-
KEY(5, 0, KEY_V), \
66
-
KEY(5, 1, KEY_B), \
67
-
KEY(5, 2, KEY_N), \
68
-
KEY(5, 3, KEY_M), \
69
-
KEY(5, 4, KEY_COMMA), \
70
-
KEY(5, 5, KEY_DOT), \
71
-
KEY(5, 6, KEY_SLASH), \
72
-
KEY(5, 7, KEY_RIGHTSHIFT), \
73
-
KEY(5, 8, KEY_KPASTERISK), \
74
-
KEY(6, 0, KEY_LEFTALT), \
75
-
KEY(6, 1, KEY_SPACE), \
76
-
KEY(6, 2, KEY_CAPSLOCK), \
77
-
KEY(6, 3, KEY_F1), \
78
-
KEY(6, 4, KEY_F2), \
79
-
KEY(6, 5, KEY_F3), \
80
-
KEY(6, 6, KEY_F4), \
81
-
KEY(6, 7, KEY_F5), \
82
-
KEY(6, 8, KEY_F6), \
83
-
KEY(7, 0, KEY_F7), \
84
-
KEY(7, 1, KEY_F8), \
85
-
KEY(7, 2, KEY_F9), \
86
-
KEY(7, 3, KEY_F10), \
87
-
KEY(7, 4, KEY_NUMLOCK), \
88
-
KEY(7, 5, KEY_SCROLLLOCK), \
89
-
KEY(7, 6, KEY_KP7), \
90
-
KEY(7, 7, KEY_KP8), \
91
-
KEY(7, 8, KEY_KP9), \
92
-
KEY(8, 0, KEY_KPMINUS), \
93
-
KEY(8, 1, KEY_KP4), \
94
-
KEY(8, 2, KEY_KP5), \
95
-
KEY(8, 3, KEY_KP6), \
96
-
KEY(8, 4, KEY_KPPLUS), \
97
-
KEY(8, 5, KEY_KP1), \
98
-
KEY(8, 6, KEY_KP2), \
99
-
KEY(8, 7, KEY_KP3), \
100
-
KEY(8, 8, KEY_KP0), \
101
-
}
102
-
103
-
#define DECLARE_6x6_KEYMAP(_name) \
104
-
int _name[] = { \
105
-
KEY(0, 0, KEY_RESERVED), \
106
-
KEY(0, 1, KEY_1), \
107
-
KEY(0, 2, KEY_2), \
108
-
KEY(0, 3, KEY_3), \
109
-
KEY(0, 4, KEY_4), \
110
-
KEY(0, 5, KEY_5), \
111
-
KEY(1, 0, KEY_Q), \
112
-
KEY(1, 1, KEY_W), \
113
-
KEY(1, 2, KEY_E), \
114
-
KEY(1, 3, KEY_R), \
115
-
KEY(1, 4, KEY_T), \
116
-
KEY(1, 5, KEY_Y), \
117
-
KEY(2, 0, KEY_D), \
118
-
KEY(2, 1, KEY_F), \
119
-
KEY(2, 2, KEY_G), \
120
-
KEY(2, 3, KEY_H), \
121
-
KEY(2, 4, KEY_J), \
122
-
KEY(2, 5, KEY_K), \
123
-
KEY(3, 0, KEY_B), \
124
-
KEY(3, 1, KEY_N), \
125
-
KEY(3, 2, KEY_M), \
126
-
KEY(3, 3, KEY_COMMA), \
127
-
KEY(3, 4, KEY_DOT), \
128
-
KEY(3, 5, KEY_SLASH), \
129
-
KEY(4, 0, KEY_F6), \
130
-
KEY(4, 1, KEY_F7), \
131
-
KEY(4, 2, KEY_F8), \
132
-
KEY(4, 3, KEY_F9), \
133
-
KEY(4, 4, KEY_F10), \
134
-
KEY(4, 5, KEY_NUMLOCK), \
135
-
KEY(5, 0, KEY_KP2), \
136
-
KEY(5, 1, KEY_KP3), \
137
-
KEY(5, 2, KEY_KP0), \
138
-
KEY(5, 3, KEY_KPDOT), \
139
-
KEY(5, 4, KEY_RO), \
140
-
KEY(5, 5, KEY_ZENKAKUHANKAKU), \
141
-
}
142
-
143
-
#define KEYPAD_9x9 0
144
-
#define KEYPAD_6x6 1
145
-
#define KEYPAD_2x2 2
146
-
147
-
/**
148
-
* struct kbd_platform_data - spear keyboard platform data
149
-
* keymap: pointer to keymap data (table and size)
150
-
* rep: enables key autorepeat
151
-
* mode: choose keyboard support(9x9, 6x6, 2x2)
152
-
* suspended_rate: rate at which keyboard would operate in suspended mode
153
-
*
154
-
* This structure is supposed to be used by platform code to supply
155
-
* keymaps to drivers that implement keyboards.
156
-
*/
157
-
struct kbd_platform_data {
158
-
const struct matrix_keymap_data *keymap;
159
-
bool rep;
160
-
unsigned int mode;
161
-
unsigned int suspended_rate;
162
-
};
163
-
164
-
#endif /* __PLAT_KEYBOARD_H */