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