1 | /* |
2 | * Driver for TCA8418 I2C keyboard |
3 | * |
4 | * Copyright (C) 2011 Fuel7, Inc. All rights reserved. |
5 | * |
6 | * Author: Kyle Manna <kyle.manna@fuel7.com> |
7 | * |
8 | * This program is free software; you can redistribute it and/or |
9 | * modify it under the terms of the GNU General Public |
10 | * License v2 as published by the Free Software Foundation. |
11 | * |
12 | * This program is distributed in the hope that it will be useful, |
13 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
15 | * General Public License for more details. |
16 | * |
17 | * You should have received a copy of the GNU General Public |
18 | * License along with this program; if not, write to the |
19 | * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
20 | * Boston, MA 021110-1307, USA. |
21 | * |
22 | * If you can't comply with GPLv2, alternative licensing terms may be |
23 | * arranged. Please contact Fuel7, Inc. (http://fuel7.com/) for proprietary |
24 | * alternative licensing inquiries. |
25 | */ |
26 | |
27 | #include <linux/delay.h> |
28 | #include <linux/i2c.h> |
29 | #include <linux/init.h> |
30 | #include <linux/input.h> |
31 | #include <linux/input/matrix_keypad.h> |
32 | #include <linux/interrupt.h> |
33 | #include <linux/module.h> |
34 | #include <linux/of.h> |
35 | #include <linux/property.h> |
36 | #include <linux/slab.h> |
37 | #include <linux/types.h> |
38 | |
39 | /* TCA8418 hardware limits */ |
40 | #define TCA8418_MAX_ROWS 8 |
41 | #define TCA8418_MAX_COLS 10 |
42 | |
43 | /* TCA8418 register offsets */ |
44 | #define REG_CFG 0x01 |
45 | #define REG_INT_STAT 0x02 |
46 | #define REG_KEY_LCK_EC 0x03 |
47 | #define REG_KEY_EVENT_A 0x04 |
48 | #define REG_KEY_EVENT_B 0x05 |
49 | #define REG_KEY_EVENT_C 0x06 |
50 | #define REG_KEY_EVENT_D 0x07 |
51 | #define REG_KEY_EVENT_E 0x08 |
52 | #define REG_KEY_EVENT_F 0x09 |
53 | #define REG_KEY_EVENT_G 0x0A |
54 | #define REG_KEY_EVENT_H 0x0B |
55 | #define REG_KEY_EVENT_I 0x0C |
56 | #define REG_KEY_EVENT_J 0x0D |
57 | #define REG_KP_LCK_TIMER 0x0E |
58 | #define REG_UNLOCK1 0x0F |
59 | #define REG_UNLOCK2 0x10 |
60 | #define REG_GPIO_INT_STAT1 0x11 |
61 | #define REG_GPIO_INT_STAT2 0x12 |
62 | #define REG_GPIO_INT_STAT3 0x13 |
63 | #define REG_GPIO_DAT_STAT1 0x14 |
64 | #define REG_GPIO_DAT_STAT2 0x15 |
65 | #define REG_GPIO_DAT_STAT3 0x16 |
66 | #define REG_GPIO_DAT_OUT1 0x17 |
67 | #define REG_GPIO_DAT_OUT2 0x18 |
68 | #define REG_GPIO_DAT_OUT3 0x19 |
69 | #define REG_GPIO_INT_EN1 0x1A |
70 | #define REG_GPIO_INT_EN2 0x1B |
71 | #define REG_GPIO_INT_EN3 0x1C |
72 | #define REG_KP_GPIO1 0x1D |
73 | #define REG_KP_GPIO2 0x1E |
74 | #define REG_KP_GPIO3 0x1F |
75 | #define REG_GPI_EM1 0x20 |
76 | #define REG_GPI_EM2 0x21 |
77 | #define REG_GPI_EM3 0x22 |
78 | #define REG_GPIO_DIR1 0x23 |
79 | #define REG_GPIO_DIR2 0x24 |
80 | #define REG_GPIO_DIR3 0x25 |
81 | #define REG_GPIO_INT_LVL1 0x26 |
82 | #define REG_GPIO_INT_LVL2 0x27 |
83 | #define REG_GPIO_INT_LVL3 0x28 |
84 | #define REG_DEBOUNCE_DIS1 0x29 |
85 | #define REG_DEBOUNCE_DIS2 0x2A |
86 | #define REG_DEBOUNCE_DIS3 0x2B |
87 | #define REG_GPIO_PULL1 0x2C |
88 | #define REG_GPIO_PULL2 0x2D |
89 | #define REG_GPIO_PULL3 0x2E |
90 | |
91 | /* TCA8418 bit definitions */ |
92 | #define CFG_AI BIT(7) |
93 | #define CFG_GPI_E_CFG BIT(6) |
94 | #define CFG_OVR_FLOW_M BIT(5) |
95 | #define CFG_INT_CFG BIT(4) |
96 | #define CFG_OVR_FLOW_IEN BIT(3) |
97 | #define CFG_K_LCK_IEN BIT(2) |
98 | #define CFG_GPI_IEN BIT(1) |
99 | #define CFG_KE_IEN BIT(0) |
100 | |
101 | #define INT_STAT_CAD_INT BIT(4) |
102 | #define INT_STAT_OVR_FLOW_INT BIT(3) |
103 | #define INT_STAT_K_LCK_INT BIT(2) |
104 | #define INT_STAT_GPI_INT BIT(1) |
105 | #define INT_STAT_K_INT BIT(0) |
106 | |
107 | /* TCA8418 register masks */ |
108 | #define KEY_LCK_EC_KEC 0x7 |
109 | #define KEY_EVENT_CODE 0x7f |
110 | #define KEY_EVENT_VALUE 0x80 |
111 | |
112 | struct tca8418_keypad { |
113 | struct i2c_client *client; |
114 | struct input_dev *input; |
115 | |
116 | unsigned int row_shift; |
117 | }; |
118 | |
119 | /* |
120 | * Write a byte to the TCA8418 |
121 | */ |
122 | static int tca8418_write_byte(struct tca8418_keypad *keypad_data, |
123 | int reg, u8 val) |
124 | { |
125 | int error; |
126 | |
127 | error = i2c_smbus_write_byte_data(client: keypad_data->client, command: reg, value: val); |
128 | if (error < 0) { |
129 | dev_err(&keypad_data->client->dev, |
130 | "%s failed, reg: %d, val: %d, error: %d\n" , |
131 | __func__, reg, val, error); |
132 | return error; |
133 | } |
134 | |
135 | return 0; |
136 | } |
137 | |
138 | /* |
139 | * Read a byte from the TCA8418 |
140 | */ |
141 | static int tca8418_read_byte(struct tca8418_keypad *keypad_data, |
142 | int reg, u8 *val) |
143 | { |
144 | int error; |
145 | |
146 | error = i2c_smbus_read_byte_data(client: keypad_data->client, command: reg); |
147 | if (error < 0) { |
148 | dev_err(&keypad_data->client->dev, |
149 | "%s failed, reg: %d, error: %d\n" , |
150 | __func__, reg, error); |
151 | return error; |
152 | } |
153 | |
154 | *val = (u8)error; |
155 | |
156 | return 0; |
157 | } |
158 | |
159 | static void tca8418_read_keypad(struct tca8418_keypad *keypad_data) |
160 | { |
161 | struct input_dev *input = keypad_data->input; |
162 | unsigned short *keymap = input->keycode; |
163 | int error, col, row; |
164 | u8 reg, state, code; |
165 | |
166 | do { |
167 | error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, val: ®); |
168 | if (error < 0) { |
169 | dev_err(&keypad_data->client->dev, |
170 | "unable to read REG_KEY_EVENT_A\n" ); |
171 | break; |
172 | } |
173 | |
174 | /* Assume that key code 0 signifies empty FIFO */ |
175 | if (reg <= 0) |
176 | break; |
177 | |
178 | state = reg & KEY_EVENT_VALUE; |
179 | code = reg & KEY_EVENT_CODE; |
180 | |
181 | row = code / TCA8418_MAX_COLS; |
182 | col = code % TCA8418_MAX_COLS; |
183 | |
184 | row = (col) ? row : row - 1; |
185 | col = (col) ? col - 1 : TCA8418_MAX_COLS - 1; |
186 | |
187 | code = MATRIX_SCAN_CODE(row, col, keypad_data->row_shift); |
188 | input_event(dev: input, EV_MSC, MSC_SCAN, value: code); |
189 | input_report_key(dev: input, code: keymap[code], value: state); |
190 | |
191 | } while (1); |
192 | |
193 | input_sync(dev: input); |
194 | } |
195 | |
196 | /* |
197 | * Threaded IRQ handler and this can (and will) sleep. |
198 | */ |
199 | static irqreturn_t tca8418_irq_handler(int irq, void *dev_id) |
200 | { |
201 | struct tca8418_keypad *keypad_data = dev_id; |
202 | u8 reg; |
203 | int error; |
204 | |
205 | error = tca8418_read_byte(keypad_data, REG_INT_STAT, val: ®); |
206 | if (error) { |
207 | dev_err(&keypad_data->client->dev, |
208 | "unable to read REG_INT_STAT\n" ); |
209 | return IRQ_NONE; |
210 | } |
211 | |
212 | if (!reg) |
213 | return IRQ_NONE; |
214 | |
215 | if (reg & INT_STAT_OVR_FLOW_INT) |
216 | dev_warn(&keypad_data->client->dev, "overflow occurred\n" ); |
217 | |
218 | if (reg & INT_STAT_K_INT) |
219 | tca8418_read_keypad(keypad_data); |
220 | |
221 | /* Clear all interrupts, even IRQs we didn't check (GPI, CAD, LCK) */ |
222 | reg = 0xff; |
223 | error = tca8418_write_byte(keypad_data, REG_INT_STAT, val: reg); |
224 | if (error) |
225 | dev_err(&keypad_data->client->dev, |
226 | "unable to clear REG_INT_STAT\n" ); |
227 | |
228 | return IRQ_HANDLED; |
229 | } |
230 | |
231 | /* |
232 | * Configure the TCA8418 for keypad operation |
233 | */ |
234 | static int tca8418_configure(struct tca8418_keypad *keypad_data, |
235 | u32 rows, u32 cols) |
236 | { |
237 | int reg, error = 0; |
238 | |
239 | /* Assemble a mask for row and column registers */ |
240 | reg = ~(~0 << rows); |
241 | reg += (~(~0 << cols)) << 8; |
242 | |
243 | /* Set registers to keypad mode */ |
244 | error |= tca8418_write_byte(keypad_data, REG_KP_GPIO1, val: reg); |
245 | error |= tca8418_write_byte(keypad_data, REG_KP_GPIO2, val: reg >> 8); |
246 | error |= tca8418_write_byte(keypad_data, REG_KP_GPIO3, val: reg >> 16); |
247 | |
248 | /* Enable column debouncing */ |
249 | error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS1, val: reg); |
250 | error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS2, val: reg >> 8); |
251 | error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS3, val: reg >> 16); |
252 | |
253 | if (error) |
254 | return error; |
255 | |
256 | error = tca8418_write_byte(keypad_data, REG_CFG, |
257 | CFG_INT_CFG | CFG_OVR_FLOW_IEN | CFG_KE_IEN); |
258 | |
259 | return error; |
260 | } |
261 | |
262 | static int tca8418_keypad_probe(struct i2c_client *client) |
263 | { |
264 | struct device *dev = &client->dev; |
265 | struct tca8418_keypad *keypad_data; |
266 | struct input_dev *input; |
267 | u32 rows = 0, cols = 0; |
268 | int error, row_shift; |
269 | u8 reg; |
270 | |
271 | /* Check i2c driver capabilities */ |
272 | if (!i2c_check_functionality(adap: client->adapter, I2C_FUNC_SMBUS_BYTE)) { |
273 | dev_err(dev, "%s adapter not supported\n" , |
274 | dev_driver_string(&client->adapter->dev)); |
275 | return -ENODEV; |
276 | } |
277 | |
278 | error = matrix_keypad_parse_properties(dev, rows: &rows, cols: &cols); |
279 | if (error) |
280 | return error; |
281 | |
282 | if (!rows || rows > TCA8418_MAX_ROWS) { |
283 | dev_err(dev, "invalid rows\n" ); |
284 | return -EINVAL; |
285 | } |
286 | |
287 | if (!cols || cols > TCA8418_MAX_COLS) { |
288 | dev_err(dev, "invalid columns\n" ); |
289 | return -EINVAL; |
290 | } |
291 | |
292 | row_shift = get_count_order(count: cols); |
293 | |
294 | /* Allocate memory for keypad_data and input device */ |
295 | keypad_data = devm_kzalloc(dev, size: sizeof(*keypad_data), GFP_KERNEL); |
296 | if (!keypad_data) |
297 | return -ENOMEM; |
298 | |
299 | keypad_data->client = client; |
300 | keypad_data->row_shift = row_shift; |
301 | |
302 | /* Read key lock register, if this fails assume device not present */ |
303 | error = tca8418_read_byte(keypad_data, REG_KEY_LCK_EC, val: ®); |
304 | if (error) |
305 | return -ENODEV; |
306 | |
307 | /* Configure input device */ |
308 | input = devm_input_allocate_device(dev); |
309 | if (!input) |
310 | return -ENOMEM; |
311 | |
312 | keypad_data->input = input; |
313 | |
314 | input->name = client->name; |
315 | input->id.bustype = BUS_I2C; |
316 | input->id.vendor = 0x0001; |
317 | input->id.product = 0x001; |
318 | input->id.version = 0x0001; |
319 | |
320 | error = matrix_keypad_build_keymap(NULL, NULL, rows, cols, NULL, input_dev: input); |
321 | if (error) { |
322 | dev_err(dev, "Failed to build keymap\n" ); |
323 | return error; |
324 | } |
325 | |
326 | if (device_property_read_bool(dev, propname: "keypad,autorepeat" )) |
327 | __set_bit(EV_REP, input->evbit); |
328 | |
329 | input_set_capability(dev: input, EV_MSC, MSC_SCAN); |
330 | |
331 | error = devm_request_threaded_irq(dev, irq: client->irq, |
332 | NULL, thread_fn: tca8418_irq_handler, |
333 | IRQF_SHARED | IRQF_ONESHOT, |
334 | devname: client->name, dev_id: keypad_data); |
335 | if (error) { |
336 | dev_err(dev, "Unable to claim irq %d; error %d\n" , |
337 | client->irq, error); |
338 | return error; |
339 | } |
340 | |
341 | /* Initialize the chip */ |
342 | error = tca8418_configure(keypad_data, rows, cols); |
343 | if (error < 0) |
344 | return error; |
345 | |
346 | error = input_register_device(input); |
347 | if (error) { |
348 | dev_err(dev, "Unable to register input device, error: %d\n" , |
349 | error); |
350 | return error; |
351 | } |
352 | |
353 | return 0; |
354 | } |
355 | |
356 | static const struct i2c_device_id tca8418_id[] = { |
357 | { "tca8418" , 8418, }, |
358 | { } |
359 | }; |
360 | MODULE_DEVICE_TABLE(i2c, tca8418_id); |
361 | |
362 | static const struct of_device_id tca8418_dt_ids[] = { |
363 | { .compatible = "ti,tca8418" , }, |
364 | { } |
365 | }; |
366 | MODULE_DEVICE_TABLE(of, tca8418_dt_ids); |
367 | |
368 | static struct i2c_driver tca8418_keypad_driver = { |
369 | .driver = { |
370 | .name = "tca8418_keypad" , |
371 | .of_match_table = tca8418_dt_ids, |
372 | }, |
373 | .probe = tca8418_keypad_probe, |
374 | .id_table = tca8418_id, |
375 | }; |
376 | |
377 | static int __init tca8418_keypad_init(void) |
378 | { |
379 | return i2c_add_driver(&tca8418_keypad_driver); |
380 | } |
381 | subsys_initcall(tca8418_keypad_init); |
382 | |
383 | static void __exit tca8418_keypad_exit(void) |
384 | { |
385 | i2c_del_driver(driver: &tca8418_keypad_driver); |
386 | } |
387 | module_exit(tca8418_keypad_exit); |
388 | |
389 | MODULE_AUTHOR("Kyle Manna <kyle.manna@fuel7.com>" ); |
390 | MODULE_DESCRIPTION("Keypad driver for TCA8418" ); |
391 | MODULE_LICENSE("GPL" ); |
392 | |