History

Input: pxa27x-keypad - drop support for platform data

There are no in-kernel users of pxa27x_keypad_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.

Dmitry Torokhov committed 1 year ago

Commit ca734f51 parent 770f82c2 files · +121 −330Browse files

Unified · Split

2 files
  1. drivers/input/keyboard/pxa27x_keypad.c +121 −257
  2. include/linux/platform_data/keypad-pxa27x.h +0 −73
drivers/input/keyboard/pxa27x_keypad.c+121−257
@@ -21,13 +21,13 @@ · 20 unmodified lines
21#include <linux/io.h>21#include <linux/io.h>
22#include <linux/device.h>22#include <linux/device.h>
23#include <linux/platform_device.h>23#include <linux/platform_device.h>
24#include <linux/property.h>
24#include <linux/clk.h>25#include <linux/clk.h>
25#include <linux/err.h>26#include <linux/err.h>
26#include <linux/input/matrix_keypad.h>27#include <linux/input/matrix_keypad.h>
27#include <linux/slab.h>28#include <linux/slab.h>
28#include <linux/of.h>29#include <linux/of.h>
29 30
30#include <linux/platform_data/keypad-pxa27x.h>
31/*31/*
32 * Keypad Controller registers32 * Keypad Controller registers
33 */33 */
@@ -100,54 +100,69 @@ · 66 unmodified lines
100#define keypad_readl(off) __raw_readl(keypad->mmio_base + (off))100#define keypad_readl(off) __raw_readl(keypad->mmio_base + (off))
101#define keypad_writel(off, v) __raw_writel((v), keypad->mmio_base + (off))101#define keypad_writel(off, v) __raw_writel((v), keypad->mmio_base + (off))
102 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
103#define MAX_MATRIX_KEY_NUM (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)108#define MAX_MATRIX_KEY_NUM (MAX_MATRIX_KEY_ROWS * MAX_MATRIX_KEY_COLS)
104#define MAX_KEYPAD_KEYS (MAX_MATRIX_KEY_NUM + MAX_DIRECT_KEY_NUM)109#define MAX_KEYPAD_KEYS (MAX_MATRIX_KEY_NUM + MAX_DIRECT_KEY_NUM)
105 110
106struct pxa27x_keypad {111struct pxa27x_keypad_rotary {
107 const struct pxa27x_keypad_platform_data *pdata;112 unsigned short *key_codes;
113 int rel_code;
114 bool enabled;
115};
108 116
117struct pxa27x_keypad {
109 struct clk *clk;118 struct clk *clk;
110 struct input_dev *input_dev;119 struct input_dev *input_dev;
111 void __iomem *mmio_base;120 void __iomem *mmio_base;
112 121
113 int irq;122 int irq;
114 123
115 unsigned short keycodes[MAX_KEYPAD_KEYS];124 unsigned int matrix_key_rows;
116 int rotary_rel_code[2];125 unsigned int matrix_key_cols;
117
118 unsigned int row_shift;126 unsigned int row_shift;
119 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
120 /* state row bits of each column scan */137 /* state row bits of each column scan */
121 u32 matrix_key_state[MAX_MATRIX_KEY_COLS];138 u32 matrix_key_state[MAX_MATRIX_KEY_COLS];
122 u32 direct_key_state;139 u32 direct_key_state;
123 140
124 unsigned int direct_key_mask;141 struct pxa27x_keypad_rotary rotary[MAX_ROTARY_ENCODERS];
125};142};
126 143
127#ifdef CONFIG_OF144static int pxa27x_keypad_matrix_key_parse(struct pxa27x_keypad *keypad)
128static int pxa27x_keypad_matrix_key_parse_dt(struct pxa27x_keypad *keypad,
129 struct pxa27x_keypad_platform_data *pdata)
130{145{
131 struct input_dev *input_dev = keypad->input_dev;146 struct input_dev *input_dev = keypad->input_dev;
132 struct device *dev = input_dev->dev.parent;147 struct device *dev = input_dev->dev.parent;
133 u32 rows, cols;
134 int error;148 int error;
135 149
136 error = matrix_keypad_parse_properties(dev, &rows, &cols);150 error = matrix_keypad_parse_properties(dev, &keypad->matrix_key_rows,
151 &keypad->matrix_key_cols);
137 if (error)152 if (error)
138 return error;153 return error;
139 154
140 if (rows > MAX_MATRIX_KEY_ROWS || cols > MAX_MATRIX_KEY_COLS) {155 if (keypad->matrix_key_rows > MAX_MATRIX_KEY_ROWS ||
156 keypad->matrix_key_cols > MAX_MATRIX_KEY_COLS) {
141 dev_err(dev, "rows or cols exceeds maximum value\n");157 dev_err(dev, "rows or cols exceeds maximum value\n");
142 return -EINVAL;158 return -EINVAL;
143 }159 }
144 160
145 pdata->matrix_key_rows = rows;161 keypad->row_shift = get_count_order(keypad->matrix_key_cols);
146 pdata->matrix_key_cols = cols;
147 162
148 error = matrix_keypad_build_keymap(NULL, NULL,163 error = matrix_keypad_build_keymap(NULL, NULL,
149 pdata->matrix_key_rows,164 keypad->matrix_key_rows,
150 pdata->matrix_key_cols,165 keypad->matrix_key_cols,
151 keypad->keycodes, input_dev);166 keypad->keycodes, input_dev);
152 if (error)167 if (error)
153 return error;168 return error;
@@ -155,20 +170,17 @@ static int pxa27x_keypad_matrix_key_parse_dt(struct pxa27x_keypad *keypad, · 1 unmodified line
155 return 0;170 return 0;
156}171}
157 172
158static int pxa27x_keypad_direct_key_parse_dt(struct pxa27x_keypad *keypad,173static int pxa27x_keypad_direct_key_parse(struct pxa27x_keypad *keypad)
159 struct pxa27x_keypad_platform_data *pdata)
160{174{
161 struct input_dev *input_dev = keypad->input_dev;175 struct input_dev *input_dev = keypad->input_dev;
162 struct device *dev = input_dev->dev.parent;176 struct device *dev = input_dev->dev.parent;
163 struct device_node *np = dev->of_node;
164 const __be16 *prop;
165 unsigned short code;177 unsigned short code;
166 unsigned int proplen, size;178 int count;
167 int i;179 int i;
168 int error;180 int error;
169 181
170 error = of_property_read_u32(np, "marvell,direct-key-count",182 error = device_property_read_u32(dev, "marvell,direct-key-count",
171 &pdata->direct_key_num);183 &keypad->direct_key_num);
172 if (error) {184 if (error) {
173 /*185 /*
174 * If do not have marvel,direct-key-count defined,186 * If do not have marvel,direct-key-count defined,
@@ -177,151 +189,121 @@ static int pxa27x_keypad_direct_key_parse_dt(struct pxa27x_keypad *keypad, · 2 unmodified lines
177 return error == -EINVAL ? 0 : error;189 return error == -EINVAL ? 0 : error;
178 }190 }
179 191
180 error = of_property_read_u32(np, "marvell,direct-key-mask",192 error = device_property_read_u32(dev, "marvell,direct-key-mask",
181 &pdata->direct_key_mask);193 &keypad->direct_key_mask);
182 if (error) {194 if (error) {
183 if (error != -EINVAL)195 if (error != -EINVAL)
184 return error;196 return error;
185 197
186 /*198 /*
187 * If marvell,direct-key-mask is not defined, driver will use199 * If marvell,direct-key-mask is not defined, driver will use
188 * default value. Default value is set when configure the keypad.200 * a default value based on number of direct keys set up.
201 * The default value is calculated in pxa27x_keypad_config().
189 */202 */
190 pdata->direct_key_mask = 0;203 keypad->direct_key_mask = 0;
191 }204 }
192 205
193 pdata->direct_key_low_active = of_property_read_bool(np,206 keypad->direct_key_low_active =
194 "marvell,direct-key-low-active");207 device_property_read_bool(dev, "marvell,direct-key-low-active");
195
196 prop = of_get_property(np, "marvell,direct-key-map", &proplen);
197 if (!prop)
198 return -EINVAL;
199 208
200 if (proplen % sizeof(u16))209 count = device_property_count_u16(dev, "marvell,direct-key-map");
210 if (count <= 0 || count > MAX_DIRECT_KEY_NUM)
201 return -EINVAL;211 return -EINVAL;
202 212
203 size = proplen / sizeof(u16);213 error = device_property_read_u16_array(dev, "marvell,direct-key-map",
204 214 &keypad->keycodes[MAX_MATRIX_KEY_NUM],
205 /* Only MAX_DIRECT_KEY_NUM is accepted.*/215 count);
206 if (size > MAX_DIRECT_KEY_NUM)
207 return -EINVAL;
208 216
209 for (i = 0; i < size; i++) {217 for (i = 0; i < count; i++) {
210 code = be16_to_cpup(prop + i);218 code = keypad->keycodes[MAX_MATRIX_KEY_NUM + i];
211 keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = code;
212 __set_bit(code, input_dev->keybit);219 __set_bit(code, input_dev->keybit);
213 }220 }
214 221
215 return 0;222 return 0;
216}223}
217 224
218static int pxa27x_keypad_rotary_parse_dt(struct pxa27x_keypad *keypad,225static int pxa27x_keypad_rotary_parse(struct pxa27x_keypad *keypad)
219 struct pxa27x_keypad_platform_data *pdata)
220{226{
221 const __be32 *prop;227 static const char * const rotaryname[] = { "marvell,rotary0", "marvell,rotary1" };
222 int i, relkey_ret;
223 unsigned int code, proplen;
224 const char *rotaryname[2] = {
225 "marvell,rotary0", "marvell,rotary1"};
226 const char relkeyname[] = {"marvell,rotary-rel-key"};
227 struct input_dev *input_dev = keypad->input_dev;228 struct input_dev *input_dev = keypad->input_dev;
228 struct device *dev = input_dev->dev.parent;229 struct device *dev = input_dev->dev.parent;
229 struct device_node *np = dev->of_node;230 struct pxa27x_keypad_rotary *encoder;
230 231 unsigned int code;
231 relkey_ret = of_property_read_u32(np, relkeyname, &code);232 int i;
232 /* if can read correct rotary key-code, we do not need this. */233 int error;
233 if (relkey_ret == 0) {
234 unsigned short relcode;
235 234
236 /* rotary0 taks lower half, rotary1 taks upper half. */235 error = device_property_read_u32(dev, "marvell,rotary-rel-key", &code);
237 relcode = code & 0xffff;236 if (!error) {
238 pdata->rotary0_rel_code = (code & 0xffff);237 for (i = 0; i < MAX_ROTARY_ENCODERS; i++, code >>= 16) {
239 __set_bit(relcode, input_dev->relbit);238 encoder = &keypad->rotary[i];
239 encoder->enabled = true;
240 encoder->rel_code = code & 0xffff;
241 input_set_capability(input_dev, EV_REL, encoder->rel_code);
242 }
240 243
241 relcode = code >> 16;244 return 0;
242 pdata->rotary1_rel_code = relcode;
243 __set_bit(relcode, input_dev->relbit);
244 }245 }
245 246
246 for (i = 0; i < 2; i++) {247 for (i = 0; i < MAX_ROTARY_ENCODERS; i++) {
247 prop = of_get_property(np, rotaryname[i], &proplen);248 encoder = &keypad->rotary[i];
249
248 /*250 /*
249 * If the prop is not set, it means keypad does not need251 * If the prop is not set, it means keypad does not need
250 * initialize the rotaryX.252 * initialize the rotaryX.
251 */253 */
252 if (!prop)254 if (!device_property_present(dev, rotaryname[i]))
253 continue;255 continue;
254 256
255 code = be32_to_cpup(prop);257 error = device_property_read_u32(dev, rotaryname[i], &code);
258 if (error)
259 return error;
260
256 /*261 /*
257 * Not all up/down key code are valid.262 * Not all up/down key code are valid.
258 * Now we depends on direct-rel-code.263 * Now we depends on direct-rel-code.
259 */264 */
260 if ((!(code & 0xffff) || !(code >> 16)) && relkey_ret) {265 if (!(code & 0xffff) || !(code >> 16))
261 return relkey_ret;266 return -EINVAL;
262 } else {267
263 unsigned int n = MAX_MATRIX_KEY_NUM + (i << 1);268 encoder->enabled = true;
264 unsigned short keycode;269 encoder->rel_code = -1;
265 270 encoder->key_codes = &keypad->keycodes[MAX_MATRIX_KEY_NUM + i * 2];
266 keycode = code & 0xffff;271 encoder->key_codes[0] = code & 0xffff;
267 keypad->keycodes[n] = keycode;272 encoder->key_codes[1] = code >> 16;
268 __set_bit(keycode, input_dev->keybit);
269
270 keycode = code >> 16;
271 keypad->keycodes[n + 1] = keycode;
272 __set_bit(keycode, input_dev->keybit);
273
274 if (i == 0)
275 pdata->rotary0_rel_code = -1;
276 else
277 pdata->rotary1_rel_code = -1;
278 }
279 if (i == 0)
280 pdata->enable_rotary0 = 1;
281 else
282 pdata->enable_rotary1 = 1;
283 }
284 273
285 keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;274 input_set_capability(input_dev, EV_KEY, encoder->key_codes[0]);
286 keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;275 input_set_capability(input_dev, EV_KEY, encoder->key_codes[1]);
276 }
287 277
288 return 0;278 return 0;
289}279}
290 280
291static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad)281static int pxa27x_keypad_parse_properties(struct pxa27x_keypad *keypad)
292{282{
293 struct input_dev *input_dev = keypad->input_dev;283 struct input_dev *input_dev = keypad->input_dev;
294 struct device *dev = input_dev->dev.parent;284 struct device *dev = input_dev->dev.parent;
295 struct device_node *np = dev->of_node;
296 struct pxa27x_keypad_platform_data *pdata;
297 int error;285 int error;
298 286
299 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);287 error = pxa27x_keypad_matrix_key_parse(keypad);
300 if (!pdata) {
301 dev_err(dev, "failed to allocate memory for pdata\n");
302 return -ENOMEM;
303 }
304
305 error = pxa27x_keypad_matrix_key_parse_dt(keypad, pdata);
306 if (error) {288 if (error) {
307 dev_err(dev, "failed to parse matrix key\n");289 dev_err(dev, "failed to parse matrix key\n");
308 return error;290 return error;
309 }291 }
310 292
311 error = pxa27x_keypad_direct_key_parse_dt(keypad, pdata);293 error = pxa27x_keypad_direct_key_parse(keypad);
312 if (error) {294 if (error) {
313 dev_err(dev, "failed to parse direct key\n");295 dev_err(dev, "failed to parse direct key\n");
314 return error;296 return error;
315 }297 }
316 298
317 error = pxa27x_keypad_rotary_parse_dt(keypad, pdata);299 error = pxa27x_keypad_rotary_parse(keypad);
318 if (error) {300 if (error) {
319 dev_err(dev, "failed to parse rotary key\n");301 dev_err(dev, "failed to parse rotary key\n");
320 return error;302 return error;
321 }303 }
322 304
323 error = of_property_read_u32(np, "marvell,debounce-interval",305 error = device_property_read_u32(dev, "marvell,debounce-interval",
324 &pdata->debounce_interval);306 &keypad->debounce_interval);
325 if (error) {307 if (error) {
326 dev_err(dev, "failed to parse debounce-interval\n");308 dev_err(dev, "failed to parse debounce-interval\n");
327 return error;309 return error;
@@ -333,91 +315,11 @@ static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad) · 5 unmodified lines
333 */315 */
334 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);316 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
335 317
336 keypad->pdata = pdata;
337 return 0;
338}
339
340#else
341
342static int pxa27x_keypad_build_keycode_from_dt(struct pxa27x_keypad *keypad)
343{
344 dev_info(keypad->input_dev->dev.parent, "missing platform data\n");
345
346 return -EINVAL;
347}
348
349#endif
350
351static int pxa27x_keypad_build_keycode(struct pxa27x_keypad *keypad)
352{
353 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
354 struct input_dev *input_dev = keypad->input_dev;
355 unsigned short keycode;
356 int i;
357 int error;
358
359 error = matrix_keypad_build_keymap(pdata->matrix_keymap_data, NULL,
360 pdata->matrix_key_rows,
361 pdata->matrix_key_cols,
362 keypad->keycodes, input_dev);
363 if (error)
364 return error;
365
366 /*
367 * The keycodes may not only include matrix keys but also the direct
368 * or rotary keys.
369 */
370 input_dev->keycodemax = ARRAY_SIZE(keypad->keycodes);
371
372 /* For direct keys. */
373 for (i = 0; i < pdata->direct_key_num; i++) {
374 keycode = pdata->direct_key_map[i];
375 keypad->keycodes[MAX_MATRIX_KEY_NUM + i] = keycode;
376 __set_bit(keycode, input_dev->keybit);
377 }
378
379 if (pdata->enable_rotary0) {
380 if (pdata->rotary0_up_key && pdata->rotary0_down_key) {
381 keycode = pdata->rotary0_up_key;
382 keypad->keycodes[MAX_MATRIX_KEY_NUM + 0] = keycode;
383 __set_bit(keycode, input_dev->keybit);
384
385 keycode = pdata->rotary0_down_key;
386 keypad->keycodes[MAX_MATRIX_KEY_NUM + 1] = keycode;
387 __set_bit(keycode, input_dev->keybit);
388
389 keypad->rotary_rel_code[0] = -1;
390 } else {
391 keypad->rotary_rel_code[0] = pdata->rotary0_rel_code;
392 __set_bit(pdata->rotary0_rel_code, input_dev->relbit);
393 }
394 }
395
396 if (pdata->enable_rotary1) {
397 if (pdata->rotary1_up_key && pdata->rotary1_down_key) {
398 keycode = pdata->rotary1_up_key;
399 keypad->keycodes[MAX_MATRIX_KEY_NUM + 2] = keycode;
400 __set_bit(keycode, input_dev->keybit);
401
402 keycode = pdata->rotary1_down_key;
403 keypad->keycodes[MAX_MATRIX_KEY_NUM + 3] = keycode;
404 __set_bit(keycode, input_dev->keybit);
405
406 keypad->rotary_rel_code[1] = -1;
407 } else {
408 keypad->rotary_rel_code[1] = pdata->rotary1_rel_code;
409 __set_bit(pdata->rotary1_rel_code, input_dev->relbit);
410 }
411 }
412
413 __clear_bit(KEY_RESERVED, input_dev->keybit);
414
415 return 0;318 return 0;
416}319}
417 320
418static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)321static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad)
419{322{
420 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
421 struct input_dev *input_dev = keypad->input_dev;323 struct input_dev *input_dev = keypad->input_dev;
422 int row, col, num_keys_pressed = 0;324 int row, col, num_keys_pressed = 0;
423 u32 new_state[MAX_MATRIX_KEY_COLS];325 u32 new_state[MAX_MATRIX_KEY_COLS];
@@ -435,8 +337,8 @@ static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad) · 11 unmodified lines
435 row = KPAS_RP(kpas);337 row = KPAS_RP(kpas);
436 338
437 /* if invalid row/col, treat as no key pressed */339 /* if invalid row/col, treat as no key pressed */
438 if (col >= pdata->matrix_key_cols ||340 if (col >= keypad->matrix_key_cols ||
439 row >= pdata->matrix_key_rows)341 row >= keypad->matrix_key_rows)
440 goto scan;342 goto scan;
441 343
442 new_state[col] = BIT(row);344 new_state[col] = BIT(row);
@@ -459,7 +361,7 @@ static void pxa27x_keypad_scan_matrix(struct pxa27x_keypad *keypad) · 16 unmodified lines
459 new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;361 new_state[7] = (kpasmkp3 >> 16) & KPASMKP_MKC_MASK;
460 }362 }
461scan:363scan:
462 for (col = 0; col < pdata->matrix_key_cols; col++) {364 for (col = 0; col < keypad->matrix_key_cols; col++) {
463 u32 bits_changed;365 u32 bits_changed;
464 int code;366 int code;
465 367
@@ -467,7 +369,7 @@ scan: · 1 unmodified line
467 if (bits_changed == 0)369 if (bits_changed == 0)
468 continue;370 continue;
469 371
470 for (row = 0; row < pdata->matrix_key_rows; row++) {372 for (row = 0; row < keypad->matrix_key_rows; row++) {
471 if ((bits_changed & BIT(row)) == 0)373 if ((bits_changed & BIT(row)) == 0)
472 continue;374 continue;
473 375
@@ -496,14 +398,16 @@ static inline int rotary_delta(u32 kprec) · 22 unmodified lines
496 398
497static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)399static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta)
498{400{
401 struct pxa27x_keypad_rotary *encoder = &keypad->rotary[r];
499 struct input_dev *dev = keypad->input_dev;402 struct input_dev *dev = keypad->input_dev;
500 403
501 if (delta == 0)404 if (!encoder->enabled || delta == 0)
502 return;405 return;
503 406
504 if (keypad->rotary_rel_code[r] == -1) {407 if (encoder->rel_code == -1) {
505 int code = MAX_MATRIX_KEY_NUM + 2 * r + (delta > 0 ? 0 : 1);408 int idx = delta > 0 ? 0 : 1;
506 unsigned char keycode = keypad->keycodes[code];409 int code = MAX_MATRIX_KEY_NUM + 2 * r + idx;
410 unsigned char keycode = encoder->key_codes[idx];
507 411
508 /* simulate a press-n-release */412 /* simulate a press-n-release */
509 input_event(dev, EV_MSC, MSC_SCAN, code);413 input_event(dev, EV_MSC, MSC_SCAN, code);
@@ -513,30 +417,28 @@ static void report_rotary_event(struct pxa27x_keypad *keypad, int r, int delta) · 3 unmodified lines
513 input_report_key(dev, keycode, 0);417 input_report_key(dev, keycode, 0);
514 input_sync(dev);418 input_sync(dev);
515 } else {419 } else {
516 input_report_rel(dev, keypad->rotary_rel_code[r], delta);420 input_report_rel(dev, encoder->rel_code, delta);
517 input_sync(dev);421 input_sync(dev);
518 }422 }
519}423}
520 424
521static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)425static void pxa27x_keypad_scan_rotary(struct pxa27x_keypad *keypad)
522{426{
523 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
524 u32 kprec;427 u32 kprec;
428 int i;
525 429
526 /* read and reset to default count value */430 /* read and reset to default count value */
527 kprec = keypad_readl(KPREC);431 kprec = keypad_readl(KPREC);
528 keypad_writel(KPREC, DEFAULT_KPREC);432 keypad_writel(KPREC, DEFAULT_KPREC);
529 433
530 if (pdata->enable_rotary0)434 for (i = 0; i < MAX_ROTARY_ENCODERS; i++) {
531 report_rotary_event(keypad, 0, rotary_delta(kprec));435 report_rotary_event(keypad, 0, rotary_delta(kprec));
532 436 kprec >>= 16;
533 if (pdata->enable_rotary1)437 }
534 report_rotary_event(keypad, 1, rotary_delta(kprec >> 16));
535}438}
536 439
537static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)440static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
538{441{
539 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
540 struct input_dev *input_dev = keypad->input_dev;442 struct input_dev *input_dev = keypad->input_dev;
541 unsigned int new_state;443 unsigned int new_state;
542 u32 kpdk, bits_changed;444 u32 kpdk, bits_changed;
@@ -544,14 +446,14 @@ static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad) · 1 unmodified line
544 446
545 kpdk = keypad_readl(KPDK);447 kpdk = keypad_readl(KPDK);
546 448
547 if (pdata->enable_rotary0 || pdata->enable_rotary1)449 if (keypad->rotary[0].enabled || keypad->rotary[1].enabled)
548 pxa27x_keypad_scan_rotary(keypad);450 pxa27x_keypad_scan_rotary(keypad);
549 451
550 /*452 /*
551 * The KPDR_DK only output the key pin level, so it relates to board,453 * The KPDR_DK only output the key pin level, so it relates to board,
552 * and low level may be active.454 * and low level may be active.
553 */455 */
554 if (pdata->direct_key_low_active)456 if (keypad->direct_key_low_active)
555 new_state = ~KPDK_DK(kpdk) & keypad->direct_key_mask;457 new_state = ~KPDK_DK(kpdk) & keypad->direct_key_mask;
556 else458 else
557 new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;459 new_state = KPDK_DK(kpdk) & keypad->direct_key_mask;
@@ -561,7 +463,7 @@ static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad) · 3 unmodified lines
561 if (bits_changed == 0)463 if (bits_changed == 0)
562 return;464 return;
563 465
564 for (i = 0; i < pdata->direct_key_num; i++) {466 for (i = 0; i < keypad->direct_key_num; i++) {
565 if (bits_changed & BIT(i)) {467 if (bits_changed & BIT(i)) {
566 int code = MAX_MATRIX_KEY_NUM + i;468 int code = MAX_MATRIX_KEY_NUM + i;
567 469
@@ -574,21 +476,11 @@ static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad) · 6 unmodified lines
574 keypad->direct_key_state = new_state;476 keypad->direct_key_state = new_state;
575}477}
576 478
577static void clear_wakeup_event(struct pxa27x_keypad *keypad)
578{
579 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
580
581 if (pdata->clear_wakeup_event)
582 (pdata->clear_wakeup_event)();
583}
584
585static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)479static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
586{480{
587 struct pxa27x_keypad *keypad = dev_id;481 struct pxa27x_keypad *keypad = dev_id;
588 unsigned long kpc = keypad_readl(KPC);482 unsigned long kpc = keypad_readl(KPC);
589 483
590 clear_wakeup_event(keypad);
591
592 if (kpc & KPC_DI)484 if (kpc & KPC_DI)
593 pxa27x_keypad_scan_direct(keypad);485 pxa27x_keypad_scan_direct(keypad);
594 486
@@ -600,7 +492,6 @@ static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id) · 5 unmodified lines
600 492
601static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)493static void pxa27x_keypad_config(struct pxa27x_keypad *keypad)
602{494{
603 const struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
604 unsigned int mask = 0, direct_key_num = 0;495 unsigned int mask = 0, direct_key_num = 0;
605 unsigned long kpc = 0;496 unsigned long kpc = 0;
606 497
@@ -608,35 +499,33 @@ static void pxa27x_keypad_config(struct pxa27x_keypad *keypad) · 1 unmodified line
608 keypad_readl(KPC);499 keypad_readl(KPC);
609 500
610 /* enable matrix keys with automatic scan */501 /* enable matrix keys with automatic scan */
611 if (pdata->matrix_key_rows && pdata->matrix_key_cols) {502 if (keypad->matrix_key_rows && keypad->matrix_key_cols) {
612 kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;503 kpc |= KPC_ASACT | KPC_MIE | KPC_ME | KPC_MS_ALL;
613 kpc |= KPC_MKRN(pdata->matrix_key_rows) |504 kpc |= KPC_MKRN(keypad->matrix_key_rows) |
614 KPC_MKCN(pdata->matrix_key_cols);505 KPC_MKCN(keypad->matrix_key_cols);
615 }506 }
616 507
617 /* enable rotary key, debounce interval same as direct keys */508 /* enable rotary key, debounce interval same as direct keys */
618 if (pdata->enable_rotary0) {509 if (keypad->rotary[0].enabled) {
619 mask |= 0x03;510 mask |= 0x03;
620 direct_key_num = 2;511 direct_key_num = 2;
621 kpc |= KPC_REE0;512 kpc |= KPC_REE0;
622 }513 }
623 514
624 if (pdata->enable_rotary1) {515 if (keypad->rotary[1].enabled) {
625 mask |= 0x0c;516 mask |= 0x0c;
626 direct_key_num = 4;517 direct_key_num = 4;
627 kpc |= KPC_REE1;518 kpc |= KPC_REE1;
628 }519 }
629 520
630 if (pdata->direct_key_num > direct_key_num)521 if (keypad->direct_key_num > direct_key_num)
631 direct_key_num = pdata->direct_key_num;522 direct_key_num = keypad->direct_key_num;
632 523
633 /*524 /*
634 * Direct keys usage may not start from KP_DKIN0, check the platfrom525 * Direct keys usage may not start from KP_DKIN0, check the platfrom
635 * mask data to config the specific.526 * mask data to config the specific.
636 */527 */
637 if (pdata->direct_key_mask)528 if (!keypad->direct_key_mask)
638 keypad->direct_key_mask = pdata->direct_key_mask;
639 else
640 keypad->direct_key_mask = GENMASK(direct_key_num - 1, 0) & ~mask;529 keypad->direct_key_mask = GENMASK(direct_key_num - 1, 0) & ~mask;
641 530
642 /* enable direct key */531 /* enable direct key */
@@ -645,7 +534,7 @@ static void pxa27x_keypad_config(struct pxa27x_keypad *keypad) · 2 unmodified lines
645 534
646 keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);535 keypad_writel(KPC, kpc | KPC_RE_ZERO_DEB);
647 keypad_writel(KPREC, DEFAULT_KPREC);536 keypad_writel(KPREC, DEFAULT_KPREC);
648 keypad_writel(KPKDI, pdata->debounce_interval);537 keypad_writel(KPKDI, keypad->debounce_interval);
649}538}
650 539
651static int pxa27x_keypad_open(struct input_dev *dev)540static int pxa27x_keypad_open(struct input_dev *dev)
@@ -719,19 +608,12 @@ static int pxa27x_keypad_resume(struct device *dev) · 67 unmodified lines
719static DEFINE_SIMPLE_DEV_PM_OPS(pxa27x_keypad_pm_ops,608static DEFINE_SIMPLE_DEV_PM_OPS(pxa27x_keypad_pm_ops,
720 pxa27x_keypad_suspend, pxa27x_keypad_resume);609 pxa27x_keypad_suspend, pxa27x_keypad_resume);
721 610
722
723static int pxa27x_keypad_probe(struct platform_device *pdev)611static int pxa27x_keypad_probe(struct platform_device *pdev)
724{612{
725 const struct pxa27x_keypad_platform_data *pdata =
726 dev_get_platdata(&pdev->dev);
727 struct device_node *np = pdev->dev.of_node;
728 struct pxa27x_keypad *keypad;613 struct pxa27x_keypad *keypad;
729 struct input_dev *input_dev;614 struct input_dev *input_dev;
730 int irq, error;615 int irq;
731 616 int error;
732 /* Driver need build keycode from device tree or pdata */
733 if (!np && !pdata)
734 return -EINVAL;
735 617
736 irq = platform_get_irq(pdev, 0);618 irq = platform_get_irq(pdev, 0);
737 if (irq < 0)619 if (irq < 0)
@@ -746,7 +628,6 @@ static int pxa27x_keypad_probe(struct platform_device *pdev) · 8 unmodified lines
746 if (!input_dev)628 if (!input_dev)
747 return -ENOMEM;629 return -ENOMEM;
748 630
749 keypad->pdata = pdata;
750 keypad->input_dev = input_dev;631 keypad->input_dev = input_dev;
751 keypad->irq = irq;632 keypad->irq = irq;
752 633
@@ -775,29 +656,12 @@ static int pxa27x_keypad_probe(struct platform_device *pdev) · 22 unmodified lines
775 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);656 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
776 input_set_capability(input_dev, EV_MSC, MSC_SCAN);657 input_set_capability(input_dev, EV_MSC, MSC_SCAN);
777 658
778 if (pdata) {659 error = pxa27x_keypad_parse_properties(keypad);
779 error = pxa27x_keypad_build_keycode(keypad);
780 } else {
781 error = pxa27x_keypad_build_keycode_from_dt(keypad);
782 /*
783 * Data that we get from DT resides in dynamically
784 * allocated memory so we need to update our pdata
785 * pointer.
786 */
787 pdata = keypad->pdata;
788 }
789 if (error) {660 if (error) {
790 dev_err(&pdev->dev, "failed to build keycode\n");661 dev_err(&pdev->dev, "failed to parse keypad properties\n");
791 return error;662 return error;
792 }663 }
793 664
794 keypad->row_shift = get_count_order(pdata->matrix_key_cols);
795
796 if ((pdata->enable_rotary0 && keypad->rotary_rel_code[0] != -1) ||
797 (pdata->enable_rotary1 && keypad->rotary_rel_code[1] != -1)) {
798 input_dev->evbit[0] |= BIT_MASK(EV_REL);
799 }
800
801 error = devm_request_irq(&pdev->dev, irq, pxa27x_keypad_irq_handler,665 error = devm_request_irq(&pdev->dev, irq, pxa27x_keypad_irq_handler,
802 0, pdev->name, keypad);666 0, pdev->name, keypad);
803 if (error) {667 if (error) {
include/linux/platform_data/keypad-pxa27x.h+0−73
@@ -1,73 +0,0 @@
1/* SPDX-License-Identifier: GPL-2.0 */
2#ifndef __ASM_ARCH_PXA27x_KEYPAD_H
3#define __ASM_ARCH_PXA27x_KEYPAD_H
4
5#include <linux/input.h>
6#include <linux/input/matrix_keypad.h>
7
8#define MAX_MATRIX_KEY_ROWS (8)
9#define MAX_MATRIX_KEY_COLS (8)
10#define MATRIX_ROW_SHIFT (3)
11#define MAX_DIRECT_KEY_NUM (8)
12
13/* pxa3xx keypad platform specific parameters
14 *
15 * NOTE:
16 * 1. direct_key_num indicates the number of keys in the direct keypad
17 * _plus_ the number of rotary-encoder sensor inputs, this can be
18 * left as 0 if only rotary encoders are enabled, the driver will
19 * automatically calculate this
20 *
21 * 2. direct_key_map is the key code map for the direct keys, if rotary
22 * encoder(s) are enabled, direct key 0/1(2/3) will be ignored
23 *
24 * 3. rotary can be either interpreted as a relative input event (e.g.
25 * REL_WHEEL/REL_HWHEEL) or specific keys (e.g. UP/DOWN/LEFT/RIGHT)
26 *
27 * 4. matrix key and direct key will use the same debounce_interval by
28 * default, which should be sufficient in most cases
29 *
30 * pxa168 keypad platform specific parameter
31 *
32 * NOTE:
33 * clear_wakeup_event callback is a workaround required to clear the
34 * keypad interrupt. The keypad wake must be cleared in addition to
35 * reading the MI/DI bits in the KPC register.
36 */
37struct pxa27x_keypad_platform_data {
38
39 /* code map for the matrix keys */
40 const struct matrix_keymap_data *matrix_keymap_data;
41 unsigned int matrix_key_rows;
42 unsigned int matrix_key_cols;
43
44 /* direct keys */
45 int direct_key_num;
46 unsigned int direct_key_map[MAX_DIRECT_KEY_NUM];
47 /* the key output may be low active */
48 int direct_key_low_active;
49 /* give board a chance to choose the start direct key */
50 unsigned int direct_key_mask;
51
52 /* rotary encoders 0 */
53 int enable_rotary0;
54 int rotary0_rel_code;
55 int rotary0_up_key;
56 int rotary0_down_key;
57
58 /* rotary encoders 1 */
59 int enable_rotary1;
60 int rotary1_rel_code;
61 int rotary1_up_key;
62 int rotary1_down_key;
63
64 /* key debounce interval */
65 unsigned int debounce_interval;
66
67 /* clear wakeup event requirement for pxa168 */
68 void (*clear_wakeup_event)(void);
69};
70
71extern void pxa_set_keypad_info(struct pxa27x_keypad_platform_data *info);
72
73#endif /* __ASM_ARCH_PXA27x_KEYPAD_H */