]>
Commit | Line | Data |
---|---|---|
1f67b599 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
76f10845 RV |
2 | /* |
3 | * Copyright (C) ST-Ericsson SA 2010 | |
4 | * | |
76f10845 RV |
5 | * Author: Rabin Vincent <rabin.vincent@stericsson.com> for ST-Ericsson |
6 | */ | |
7 | ||
8 | #include <linux/module.h> | |
76f10845 RV |
9 | #include <linux/slab.h> |
10 | #include <linux/input.h> | |
11 | #include <linux/interrupt.h> | |
12 | #include <linux/platform_device.h> | |
13 | #include <linux/input/matrix_keypad.h> | |
14 | #include <linux/mfd/stmpe.h> | |
15 | ||
16 | /* These are at the same addresses in all STMPE variants */ | |
17 | #define STMPE_KPC_COL 0x60 | |
18 | #define STMPE_KPC_ROW_MSB 0x61 | |
19 | #define STMPE_KPC_ROW_LSB 0x62 | |
20 | #define STMPE_KPC_CTRL_MSB 0x63 | |
21 | #define STMPE_KPC_CTRL_LSB 0x64 | |
22 | #define STMPE_KPC_COMBI_KEY_0 0x65 | |
23 | #define STMPE_KPC_COMBI_KEY_1 0x66 | |
24 | #define STMPE_KPC_COMBI_KEY_2 0x67 | |
25 | #define STMPE_KPC_DATA_BYTE0 0x68 | |
26 | #define STMPE_KPC_DATA_BYTE1 0x69 | |
27 | #define STMPE_KPC_DATA_BYTE2 0x6a | |
28 | #define STMPE_KPC_DATA_BYTE3 0x6b | |
29 | #define STMPE_KPC_DATA_BYTE4 0x6c | |
30 | ||
31 | #define STMPE_KPC_CTRL_LSB_SCAN (0x1 << 0) | |
32 | #define STMPE_KPC_CTRL_LSB_DEBOUNCE (0x7f << 1) | |
33 | #define STMPE_KPC_CTRL_MSB_SCAN_COUNT (0xf << 4) | |
34 | ||
35 | #define STMPE_KPC_ROW_MSB_ROWS 0xff | |
36 | ||
37 | #define STMPE_KPC_DATA_UP (0x1 << 7) | |
38 | #define STMPE_KPC_DATA_ROW (0xf << 3) | |
39 | #define STMPE_KPC_DATA_COL (0x7 << 0) | |
40 | #define STMPE_KPC_DATA_NOKEY_MASK 0x78 | |
41 | ||
42 | #define STMPE_KEYPAD_MAX_DEBOUNCE 127 | |
43 | #define STMPE_KEYPAD_MAX_SCAN_COUNT 15 | |
44 | ||
45 | #define STMPE_KEYPAD_MAX_ROWS 8 | |
46 | #define STMPE_KEYPAD_MAX_COLS 8 | |
47 | #define STMPE_KEYPAD_ROW_SHIFT 3 | |
a4164863 | 48 | #define STMPE_KEYPAD_KEYMAP_MAX_SIZE \ |
76f10845 RV |
49 | (STMPE_KEYPAD_MAX_ROWS * STMPE_KEYPAD_MAX_COLS) |
50 | ||
1c4bfce1 GS |
51 | |
52 | #define STMPE1601_NUM_DATA 5 | |
53 | #define STMPE2401_NUM_DATA 3 | |
54 | #define STMPE2403_NUM_DATA 5 | |
55 | ||
56 | /* Make sure it covers all cases above */ | |
57 | #define MAX_NUM_DATA 5 | |
58 | ||
76f10845 RV |
59 | /** |
60 | * struct stmpe_keypad_variant - model-specific attributes | |
61 | * @auto_increment: whether the KPC_DATA_BYTE register address | |
62 | * auto-increments on multiple read | |
7c12a5b1 | 63 | * @set_pullup: whether the pins need to have their pull-ups set |
76f10845 RV |
64 | * @num_data: number of data bytes |
65 | * @num_normal_data: number of normal keys' data bytes | |
66 | * @max_cols: maximum number of columns supported | |
67 | * @max_rows: maximum number of rows supported | |
68 | * @col_gpios: bitmask of gpios which can be used for columns | |
69 | * @row_gpios: bitmask of gpios which can be used for rows | |
70 | */ | |
71 | struct stmpe_keypad_variant { | |
72 | bool auto_increment; | |
7c12a5b1 | 73 | bool set_pullup; |
76f10845 RV |
74 | int num_data; |
75 | int num_normal_data; | |
76 | int max_cols; | |
77 | int max_rows; | |
78 | unsigned int col_gpios; | |
79 | unsigned int row_gpios; | |
80 | }; | |
81 | ||
82 | static const struct stmpe_keypad_variant stmpe_keypad_variants[] = { | |
83 | [STMPE1601] = { | |
84 | .auto_increment = true, | |
1c4bfce1 | 85 | .num_data = STMPE1601_NUM_DATA, |
76f10845 RV |
86 | .num_normal_data = 3, |
87 | .max_cols = 8, | |
88 | .max_rows = 8, | |
89 | .col_gpios = 0x000ff, /* GPIO 0 - 7 */ | |
90 | .row_gpios = 0x0ff00, /* GPIO 8 - 15 */ | |
91 | }, | |
92 | [STMPE2401] = { | |
93 | .auto_increment = false, | |
7c12a5b1 | 94 | .set_pullup = true, |
1c4bfce1 | 95 | .num_data = STMPE2401_NUM_DATA, |
76f10845 RV |
96 | .num_normal_data = 2, |
97 | .max_cols = 8, | |
98 | .max_rows = 12, | |
99 | .col_gpios = 0x0000ff, /* GPIO 0 - 7*/ | |
2175b0f7 | 100 | .row_gpios = 0x1f7f00, /* GPIO 8-14, 16-20 */ |
76f10845 RV |
101 | }, |
102 | [STMPE2403] = { | |
103 | .auto_increment = true, | |
7c12a5b1 | 104 | .set_pullup = true, |
1c4bfce1 | 105 | .num_data = STMPE2403_NUM_DATA, |
76f10845 RV |
106 | .num_normal_data = 3, |
107 | .max_cols = 8, | |
108 | .max_rows = 12, | |
109 | .col_gpios = 0x0000ff, /* GPIO 0 - 7*/ | |
110 | .row_gpios = 0x1fef00, /* GPIO 8-14, 16-20 */ | |
111 | }, | |
112 | }; | |
113 | ||
a4164863 LW |
114 | /** |
115 | * struct stmpe_keypad - STMPE keypad state container | |
116 | * @stmpe: pointer to parent STMPE device | |
117 | * @input: spawned input device | |
118 | * @variant: STMPE variant | |
119 | * @debounce_ms: debounce interval, in ms. Maximum is | |
120 | * %STMPE_KEYPAD_MAX_DEBOUNCE. | |
121 | * @scan_count: number of key scanning cycles to confirm key data. | |
122 | * Maximum is %STMPE_KEYPAD_MAX_SCAN_COUNT. | |
123 | * @no_autorepeat: disable key autorepeat | |
124 | * @rows: bitmask for the rows | |
125 | * @cols: bitmask for the columns | |
126 | * @keymap: the keymap | |
127 | */ | |
76f10845 RV |
128 | struct stmpe_keypad { |
129 | struct stmpe *stmpe; | |
130 | struct input_dev *input; | |
131 | const struct stmpe_keypad_variant *variant; | |
a4164863 LW |
132 | unsigned int debounce_ms; |
133 | unsigned int scan_count; | |
134 | bool no_autorepeat; | |
76f10845 RV |
135 | unsigned int rows; |
136 | unsigned int cols; | |
a4164863 | 137 | unsigned short keymap[STMPE_KEYPAD_KEYMAP_MAX_SIZE]; |
76f10845 RV |
138 | }; |
139 | ||
140 | static int stmpe_keypad_read_data(struct stmpe_keypad *keypad, u8 *data) | |
141 | { | |
142 | const struct stmpe_keypad_variant *variant = keypad->variant; | |
143 | struct stmpe *stmpe = keypad->stmpe; | |
144 | int ret; | |
145 | int i; | |
146 | ||
147 | if (variant->auto_increment) | |
148 | return stmpe_block_read(stmpe, STMPE_KPC_DATA_BYTE0, | |
149 | variant->num_data, data); | |
150 | ||
151 | for (i = 0; i < variant->num_data; i++) { | |
152 | ret = stmpe_reg_read(stmpe, STMPE_KPC_DATA_BYTE0 + i); | |
153 | if (ret < 0) | |
154 | return ret; | |
155 | ||
156 | data[i] = ret; | |
157 | } | |
158 | ||
159 | return 0; | |
160 | } | |
161 | ||
162 | static irqreturn_t stmpe_keypad_irq(int irq, void *dev) | |
163 | { | |
164 | struct stmpe_keypad *keypad = dev; | |
165 | struct input_dev *input = keypad->input; | |
166 | const struct stmpe_keypad_variant *variant = keypad->variant; | |
1c4bfce1 | 167 | u8 fifo[MAX_NUM_DATA]; |
76f10845 RV |
168 | int ret; |
169 | int i; | |
170 | ||
171 | ret = stmpe_keypad_read_data(keypad, fifo); | |
172 | if (ret < 0) | |
173 | return IRQ_NONE; | |
174 | ||
175 | for (i = 0; i < variant->num_normal_data; i++) { | |
176 | u8 data = fifo[i]; | |
177 | int row = (data & STMPE_KPC_DATA_ROW) >> 3; | |
178 | int col = data & STMPE_KPC_DATA_COL; | |
179 | int code = MATRIX_SCAN_CODE(row, col, STMPE_KEYPAD_ROW_SHIFT); | |
180 | bool up = data & STMPE_KPC_DATA_UP; | |
181 | ||
182 | if ((data & STMPE_KPC_DATA_NOKEY_MASK) | |
183 | == STMPE_KPC_DATA_NOKEY_MASK) | |
184 | continue; | |
185 | ||
186 | input_event(input, EV_MSC, MSC_SCAN, code); | |
187 | input_report_key(input, keypad->keymap[code], !up); | |
188 | input_sync(input); | |
189 | } | |
190 | ||
191 | return IRQ_HANDLED; | |
192 | } | |
193 | ||
5298cc4c | 194 | static int stmpe_keypad_altfunc_init(struct stmpe_keypad *keypad) |
76f10845 RV |
195 | { |
196 | const struct stmpe_keypad_variant *variant = keypad->variant; | |
197 | unsigned int col_gpios = variant->col_gpios; | |
198 | unsigned int row_gpios = variant->row_gpios; | |
199 | struct stmpe *stmpe = keypad->stmpe; | |
7c12a5b1 | 200 | u8 pureg = stmpe->regs[STMPE_IDX_GPPUR_LSB]; |
76f10845 | 201 | unsigned int pins = 0; |
7c12a5b1 LW |
202 | unsigned int pu_pins = 0; |
203 | int ret; | |
76f10845 RV |
204 | int i; |
205 | ||
206 | /* | |
207 | * Figure out which pins need to be set to the keypad alternate | |
208 | * function. | |
209 | * | |
210 | * {cols,rows}_gpios are bitmasks of which pins on the chip can be used | |
211 | * for the keypad. | |
212 | * | |
213 | * keypad->{cols,rows} are a bitmask of which pins (of the ones useable | |
214 | * for the keypad) are used on the board. | |
215 | */ | |
216 | ||
217 | for (i = 0; i < variant->max_cols; i++) { | |
218 | int num = __ffs(col_gpios); | |
219 | ||
7c12a5b1 | 220 | if (keypad->cols & (1 << i)) { |
76f10845 | 221 | pins |= 1 << num; |
7c12a5b1 LW |
222 | pu_pins |= 1 << num; |
223 | } | |
76f10845 RV |
224 | |
225 | col_gpios &= ~(1 << num); | |
226 | } | |
227 | ||
228 | for (i = 0; i < variant->max_rows; i++) { | |
229 | int num = __ffs(row_gpios); | |
230 | ||
231 | if (keypad->rows & (1 << i)) | |
232 | pins |= 1 << num; | |
233 | ||
234 | row_gpios &= ~(1 << num); | |
235 | } | |
236 | ||
7c12a5b1 LW |
237 | ret = stmpe_set_altfunc(stmpe, pins, STMPE_BLOCK_KEYPAD); |
238 | if (ret) | |
239 | return ret; | |
240 | ||
241 | /* | |
242 | * On STMPE24xx, set pin bias to pull-up on all keypad input | |
243 | * pins (columns), this incidentally happen to be maximum 8 pins | |
244 | * and placed at GPIO0-7 so only the LSB of the pull up register | |
245 | * ever needs to be written. | |
246 | */ | |
247 | if (variant->set_pullup) { | |
248 | u8 val; | |
249 | ||
250 | ret = stmpe_reg_read(stmpe, pureg); | |
251 | if (ret) | |
252 | return ret; | |
253 | ||
254 | /* Do not touch unused pins, may be used for GPIO */ | |
255 | val = ret & ~pu_pins; | |
256 | val |= pu_pins; | |
257 | ||
258 | ret = stmpe_reg_write(stmpe, pureg, val); | |
259 | } | |
260 | ||
261 | return 0; | |
76f10845 RV |
262 | } |
263 | ||
5298cc4c | 264 | static int stmpe_keypad_chip_init(struct stmpe_keypad *keypad) |
76f10845 | 265 | { |
76f10845 RV |
266 | const struct stmpe_keypad_variant *variant = keypad->variant; |
267 | struct stmpe *stmpe = keypad->stmpe; | |
268 | int ret; | |
269 | ||
a4164863 | 270 | if (keypad->debounce_ms > STMPE_KEYPAD_MAX_DEBOUNCE) |
76f10845 RV |
271 | return -EINVAL; |
272 | ||
a4164863 | 273 | if (keypad->scan_count > STMPE_KEYPAD_MAX_SCAN_COUNT) |
76f10845 RV |
274 | return -EINVAL; |
275 | ||
276 | ret = stmpe_enable(stmpe, STMPE_BLOCK_KEYPAD); | |
277 | if (ret < 0) | |
278 | return ret; | |
279 | ||
280 | ret = stmpe_keypad_altfunc_init(keypad); | |
281 | if (ret < 0) | |
282 | return ret; | |
283 | ||
284 | ret = stmpe_reg_write(stmpe, STMPE_KPC_COL, keypad->cols); | |
285 | if (ret < 0) | |
286 | return ret; | |
287 | ||
288 | ret = stmpe_reg_write(stmpe, STMPE_KPC_ROW_LSB, keypad->rows); | |
289 | if (ret < 0) | |
290 | return ret; | |
291 | ||
292 | if (variant->max_rows > 8) { | |
293 | ret = stmpe_set_bits(stmpe, STMPE_KPC_ROW_MSB, | |
294 | STMPE_KPC_ROW_MSB_ROWS, | |
295 | keypad->rows >> 8); | |
296 | if (ret < 0) | |
297 | return ret; | |
298 | } | |
299 | ||
300 | ret = stmpe_set_bits(stmpe, STMPE_KPC_CTRL_MSB, | |
301 | STMPE_KPC_CTRL_MSB_SCAN_COUNT, | |
a4164863 | 302 | keypad->scan_count << 4); |
76f10845 RV |
303 | if (ret < 0) |
304 | return ret; | |
305 | ||
306 | return stmpe_set_bits(stmpe, STMPE_KPC_CTRL_LSB, | |
307 | STMPE_KPC_CTRL_LSB_SCAN | | |
308 | STMPE_KPC_CTRL_LSB_DEBOUNCE, | |
309 | STMPE_KPC_CTRL_LSB_SCAN | | |
a4164863 | 310 | (keypad->debounce_ms << 1)); |
76f10845 RV |
311 | } |
312 | ||
a4164863 LW |
313 | static void stmpe_keypad_fill_used_pins(struct stmpe_keypad *keypad, |
314 | u32 used_rows, u32 used_cols) | |
6ea32387 DT |
315 | { |
316 | int row, col; | |
317 | ||
a4164863 LW |
318 | for (row = 0; row < used_rows; row++) { |
319 | for (col = 0; col < used_cols; col++) { | |
6ea32387 | 320 | int code = MATRIX_SCAN_CODE(row, col, |
a4164863 | 321 | STMPE_KEYPAD_ROW_SHIFT); |
6ea32387 DT |
322 | if (keypad->keymap[code] != KEY_RESERVED) { |
323 | keypad->rows |= 1 << row; | |
324 | keypad->cols |= 1 << col; | |
325 | } | |
326 | } | |
327 | } | |
328 | } | |
329 | ||
5298cc4c | 330 | static int stmpe_keypad_probe(struct platform_device *pdev) |
76f10845 RV |
331 | { |
332 | struct stmpe *stmpe = dev_get_drvdata(pdev->dev.parent); | |
a4164863 | 333 | struct device_node *np = pdev->dev.of_node; |
76f10845 RV |
334 | struct stmpe_keypad *keypad; |
335 | struct input_dev *input; | |
a4164863 LW |
336 | u32 rows; |
337 | u32 cols; | |
aaa4f2a7 | 338 | int error; |
76f10845 | 339 | int irq; |
76f10845 | 340 | |
76f10845 RV |
341 | irq = platform_get_irq(pdev, 0); |
342 | if (irq < 0) | |
343 | return irq; | |
344 | ||
aaa4f2a7 VK |
345 | keypad = devm_kzalloc(&pdev->dev, sizeof(struct stmpe_keypad), |
346 | GFP_KERNEL); | |
76f10845 RV |
347 | if (!keypad) |
348 | return -ENOMEM; | |
349 | ||
a4164863 LW |
350 | keypad->stmpe = stmpe; |
351 | keypad->variant = &stmpe_keypad_variants[stmpe->partnum]; | |
352 | ||
353 | of_property_read_u32(np, "debounce-interval", &keypad->debounce_ms); | |
354 | of_property_read_u32(np, "st,scan-count", &keypad->scan_count); | |
355 | keypad->no_autorepeat = of_property_read_bool(np, "st,no-autorepeat"); | |
356 | ||
aaa4f2a7 VK |
357 | input = devm_input_allocate_device(&pdev->dev); |
358 | if (!input) | |
359 | return -ENOMEM; | |
76f10845 RV |
360 | |
361 | input->name = "STMPE keypad"; | |
362 | input->id.bustype = BUS_I2C; | |
363 | input->dev.parent = &pdev->dev; | |
364 | ||
aef01aad | 365 | error = matrix_keypad_parse_properties(&pdev->dev, &rows, &cols); |
a4164863 LW |
366 | if (error) |
367 | return error; | |
368 | ||
369 | error = matrix_keypad_build_keymap(NULL, NULL, rows, cols, | |
aaa4f2a7 VK |
370 | keypad->keymap, input); |
371 | if (error) | |
372 | return error; | |
76f10845 | 373 | |
1932811f | 374 | input_set_capability(input, EV_MSC, MSC_SCAN); |
a4164863 | 375 | if (!keypad->no_autorepeat) |
76f10845 RV |
376 | __set_bit(EV_REP, input->evbit); |
377 | ||
a4164863 | 378 | stmpe_keypad_fill_used_pins(keypad, rows, cols); |
76f10845 | 379 | |
76f10845 | 380 | keypad->input = input; |
76f10845 | 381 | |
aaa4f2a7 VK |
382 | error = stmpe_keypad_chip_init(keypad); |
383 | if (error < 0) | |
384 | return error; | |
76f10845 | 385 | |
aaa4f2a7 VK |
386 | error = devm_request_threaded_irq(&pdev->dev, irq, |
387 | NULL, stmpe_keypad_irq, | |
388 | IRQF_ONESHOT, "stmpe-keypad", keypad); | |
389 | if (error) { | |
390 | dev_err(&pdev->dev, "unable to get irq: %d\n", error); | |
391 | return error; | |
76f10845 RV |
392 | } |
393 | ||
aaa4f2a7 VK |
394 | error = input_register_device(input); |
395 | if (error) { | |
396 | dev_err(&pdev->dev, | |
397 | "unable to register input device: %d\n", error); | |
398 | return error; | |
76f10845 RV |
399 | } |
400 | ||
401 | platform_set_drvdata(pdev, keypad); | |
402 | ||
403 | return 0; | |
76f10845 RV |
404 | } |
405 | ||
e2619cf7 | 406 | static int stmpe_keypad_remove(struct platform_device *pdev) |
76f10845 RV |
407 | { |
408 | struct stmpe_keypad *keypad = platform_get_drvdata(pdev); | |
76f10845 | 409 | |
aaa4f2a7 | 410 | stmpe_disable(keypad->stmpe, STMPE_BLOCK_KEYPAD); |
76f10845 RV |
411 | |
412 | return 0; | |
413 | } | |
414 | ||
415 | static struct platform_driver stmpe_keypad_driver = { | |
416 | .driver.name = "stmpe-keypad", | |
417 | .driver.owner = THIS_MODULE, | |
418 | .probe = stmpe_keypad_probe, | |
1cb0aa88 | 419 | .remove = stmpe_keypad_remove, |
76f10845 | 420 | }; |
5146c84f | 421 | module_platform_driver(stmpe_keypad_driver); |
76f10845 RV |
422 | |
423 | MODULE_LICENSE("GPL v2"); | |
424 | MODULE_DESCRIPTION("STMPExxxx keypad driver"); | |
425 | MODULE_AUTHOR("Rabin Vincent <rabin.vincent@stericsson.com>"); |