1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <linux/types.h>
28#include <linux/module.h>
29#include <linux/init.h>
30#include <linux/delay.h>
31#include <linux/slab.h>
32#include <linux/interrupt.h>
33#include <linux/workqueue.h>
34#include <linux/gpio.h>
35#include <linux/i2c.h>
36#include <linux/input.h>
37#include <linux/input/tca8418_keypad.h>
38#include <linux/of.h>
39
40
41#define TCA8418_MAX_ROWS 8
42#define TCA8418_MAX_COLS 10
43
44
45#define REG_CFG 0x01
46#define REG_INT_STAT 0x02
47#define REG_KEY_LCK_EC 0x03
48#define REG_KEY_EVENT_A 0x04
49#define REG_KEY_EVENT_B 0x05
50#define REG_KEY_EVENT_C 0x06
51#define REG_KEY_EVENT_D 0x07
52#define REG_KEY_EVENT_E 0x08
53#define REG_KEY_EVENT_F 0x09
54#define REG_KEY_EVENT_G 0x0A
55#define REG_KEY_EVENT_H 0x0B
56#define REG_KEY_EVENT_I 0x0C
57#define REG_KEY_EVENT_J 0x0D
58#define REG_KP_LCK_TIMER 0x0E
59#define REG_UNLOCK1 0x0F
60#define REG_UNLOCK2 0x10
61#define REG_GPIO_INT_STAT1 0x11
62#define REG_GPIO_INT_STAT2 0x12
63#define REG_GPIO_INT_STAT3 0x13
64#define REG_GPIO_DAT_STAT1 0x14
65#define REG_GPIO_DAT_STAT2 0x15
66#define REG_GPIO_DAT_STAT3 0x16
67#define REG_GPIO_DAT_OUT1 0x17
68#define REG_GPIO_DAT_OUT2 0x18
69#define REG_GPIO_DAT_OUT3 0x19
70#define REG_GPIO_INT_EN1 0x1A
71#define REG_GPIO_INT_EN2 0x1B
72#define REG_GPIO_INT_EN3 0x1C
73#define REG_KP_GPIO1 0x1D
74#define REG_KP_GPIO2 0x1E
75#define REG_KP_GPIO3 0x1F
76#define REG_GPI_EM1 0x20
77#define REG_GPI_EM2 0x21
78#define REG_GPI_EM3 0x22
79#define REG_GPIO_DIR1 0x23
80#define REG_GPIO_DIR2 0x24
81#define REG_GPIO_DIR3 0x25
82#define REG_GPIO_INT_LVL1 0x26
83#define REG_GPIO_INT_LVL2 0x27
84#define REG_GPIO_INT_LVL3 0x28
85#define REG_DEBOUNCE_DIS1 0x29
86#define REG_DEBOUNCE_DIS2 0x2A
87#define REG_DEBOUNCE_DIS3 0x2B
88#define REG_GPIO_PULL1 0x2C
89#define REG_GPIO_PULL2 0x2D
90#define REG_GPIO_PULL3 0x2E
91
92
93#define CFG_AI BIT(7)
94#define CFG_GPI_E_CFG BIT(6)
95#define CFG_OVR_FLOW_M BIT(5)
96#define CFG_INT_CFG BIT(4)
97#define CFG_OVR_FLOW_IEN BIT(3)
98#define CFG_K_LCK_IEN BIT(2)
99#define CFG_GPI_IEN BIT(1)
100#define CFG_KE_IEN BIT(0)
101
102#define INT_STAT_CAD_INT BIT(4)
103#define INT_STAT_OVR_FLOW_INT BIT(3)
104#define INT_STAT_K_LCK_INT BIT(2)
105#define INT_STAT_GPI_INT BIT(1)
106#define INT_STAT_K_INT BIT(0)
107
108
109#define KEY_LCK_EC_KEC 0x7
110#define KEY_EVENT_CODE 0x7f
111#define KEY_EVENT_VALUE 0x80
112
113struct tca8418_keypad {
114 struct i2c_client *client;
115 struct input_dev *input;
116
117 unsigned int row_shift;
118};
119
120
121
122
123static int tca8418_write_byte(struct tca8418_keypad *keypad_data,
124 int reg, u8 val)
125{
126 int error;
127
128 error = i2c_smbus_write_byte_data(keypad_data->client, reg, val);
129 if (error < 0) {
130 dev_err(&keypad_data->client->dev,
131 "%s failed, reg: %d, val: %d, error: %d\n",
132 __func__, reg, val, error);
133 return error;
134 }
135
136 return 0;
137}
138
139
140
141
142static int tca8418_read_byte(struct tca8418_keypad *keypad_data,
143 int reg, u8 *val)
144{
145 int error;
146
147 error = i2c_smbus_read_byte_data(keypad_data->client, reg);
148 if (error < 0) {
149 dev_err(&keypad_data->client->dev,
150 "%s failed, reg: %d, error: %d\n",
151 __func__, reg, error);
152 return error;
153 }
154
155 *val = (u8)error;
156
157 return 0;
158}
159
160static void tca8418_read_keypad(struct tca8418_keypad *keypad_data)
161{
162 struct input_dev *input = keypad_data->input;
163 unsigned short *keymap = input->keycode;
164 int error, col, row;
165 u8 reg, state, code;
166
167
168 error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, ®);
169
170
171 while (error >= 0 && reg > 0) {
172 state = reg & KEY_EVENT_VALUE;
173 code = reg & KEY_EVENT_CODE;
174
175 row = code / TCA8418_MAX_COLS;
176 col = code % TCA8418_MAX_COLS;
177
178 row = (col) ? row : row - 1;
179 col = (col) ? col - 1 : TCA8418_MAX_COLS - 1;
180
181 code = MATRIX_SCAN_CODE(row, col, keypad_data->row_shift);
182 input_event(input, EV_MSC, MSC_SCAN, code);
183 input_report_key(input, keymap[code], state);
184
185
186 error = tca8418_read_byte(keypad_data, REG_KEY_EVENT_A, ®);
187 }
188
189 if (error < 0)
190 dev_err(&keypad_data->client->dev,
191 "unable to read REG_KEY_EVENT_A\n");
192
193 input_sync(input);
194}
195
196
197
198
199static 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, ®);
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
222 reg = 0xff;
223 error = tca8418_write_byte(keypad_data, REG_INT_STAT, 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
233
234static int tca8418_configure(struct tca8418_keypad *keypad_data,
235 u32 rows, u32 cols)
236{
237 int reg, error;
238
239
240 error = tca8418_write_byte(keypad_data, REG_CFG,
241 CFG_INT_CFG | CFG_OVR_FLOW_IEN | CFG_KE_IEN);
242 if (error < 0)
243 return -ENODEV;
244
245
246
247 reg = ~(~0 << rows);
248 reg += (~(~0 << cols)) << 8;
249
250
251 error |= tca8418_write_byte(keypad_data, REG_KP_GPIO1, reg);
252 error |= tca8418_write_byte(keypad_data, REG_KP_GPIO2, reg >> 8);
253 error |= tca8418_write_byte(keypad_data, REG_KP_GPIO3, reg >> 16);
254
255
256 error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS1, reg);
257 error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS2, reg >> 8);
258 error |= tca8418_write_byte(keypad_data, REG_DEBOUNCE_DIS3, reg >> 16);
259
260 return error;
261}
262
263static int tca8418_keypad_probe(struct i2c_client *client,
264 const struct i2c_device_id *id)
265{
266 struct device *dev = &client->dev;
267 const struct tca8418_keypad_platform_data *pdata =
268 dev_get_platdata(dev);
269 struct tca8418_keypad *keypad_data;
270 struct input_dev *input;
271 const struct matrix_keymap_data *keymap_data = NULL;
272 u32 rows = 0, cols = 0;
273 bool rep = false;
274 bool irq_is_gpio = false;
275 int irq;
276 int error, row_shift, max_keys;
277
278
279 if (pdata) {
280 if (!pdata->keymap_data) {
281 dev_err(dev, "no keymap data defined\n");
282 return -EINVAL;
283 }
284 keymap_data = pdata->keymap_data;
285 rows = pdata->rows;
286 cols = pdata->cols;
287 rep = pdata->rep;
288 irq_is_gpio = pdata->irq_is_gpio;
289 } else {
290 struct device_node *np = dev->of_node;
291 int err;
292
293 err = matrix_keypad_parse_of_params(dev, &rows, &cols);
294 if (err)
295 return err;
296 rep = of_property_read_bool(np, "keypad,autorepeat");
297 }
298
299 if (!rows || rows > TCA8418_MAX_ROWS) {
300 dev_err(dev, "invalid rows\n");
301 return -EINVAL;
302 }
303
304 if (!cols || cols > TCA8418_MAX_COLS) {
305 dev_err(dev, "invalid columns\n");
306 return -EINVAL;
307 }
308
309
310 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE)) {
311 dev_err(dev, "%s adapter not supported\n",
312 dev_driver_string(&client->adapter->dev));
313 return -ENODEV;
314 }
315
316 row_shift = get_count_order(cols);
317 max_keys = rows << row_shift;
318
319
320 keypad_data = devm_kzalloc(dev, sizeof(*keypad_data), GFP_KERNEL);
321 if (!keypad_data)
322 return -ENOMEM;
323
324 keypad_data->client = client;
325 keypad_data->row_shift = row_shift;
326
327
328 error = tca8418_configure(keypad_data, rows, cols);
329 if (error < 0)
330 return error;
331
332
333 input = devm_input_allocate_device(dev);
334 if (!input)
335 return -ENOMEM;
336
337 keypad_data->input = input;
338
339 input->name = client->name;
340 input->id.bustype = BUS_I2C;
341 input->id.vendor = 0x0001;
342 input->id.product = 0x001;
343 input->id.version = 0x0001;
344
345 error = matrix_keypad_build_keymap(keymap_data, NULL, rows, cols,
346 NULL, input);
347 if (error) {
348 dev_err(dev, "Failed to build keymap\n");
349 return error;
350 }
351
352 if (rep)
353 __set_bit(EV_REP, input->evbit);
354 input_set_capability(input, EV_MSC, MSC_SCAN);
355
356 input_set_drvdata(input, keypad_data);
357
358 irq = client->irq;
359 if (irq_is_gpio)
360 irq = gpio_to_irq(irq);
361
362 error = devm_request_threaded_irq(dev, irq, NULL, tca8418_irq_handler,
363 IRQF_TRIGGER_FALLING |
364 IRQF_SHARED |
365 IRQF_ONESHOT,
366 client->name, keypad_data);
367 if (error) {
368 dev_err(dev, "Unable to claim irq %d; error %d\n",
369 client->irq, error);
370 return error;
371 }
372
373 error = input_register_device(input);
374 if (error) {
375 dev_err(dev, "Unable to register input device, error: %d\n",
376 error);
377 return error;
378 }
379
380 return 0;
381}
382
383static const struct i2c_device_id tca8418_id[] = {
384 { TCA8418_NAME, 8418, },
385 { }
386};
387MODULE_DEVICE_TABLE(i2c, tca8418_id);
388
389#ifdef CONFIG_OF
390static const struct of_device_id tca8418_dt_ids[] = {
391 { .compatible = "ti,tca8418", },
392 { }
393};
394MODULE_DEVICE_TABLE(of, tca8418_dt_ids);
395#endif
396
397static struct i2c_driver tca8418_keypad_driver = {
398 .driver = {
399 .name = TCA8418_NAME,
400 .owner = THIS_MODULE,
401 .of_match_table = of_match_ptr(tca8418_dt_ids),
402 },
403 .probe = tca8418_keypad_probe,
404 .id_table = tca8418_id,
405};
406
407static int __init tca8418_keypad_init(void)
408{
409 return i2c_add_driver(&tca8418_keypad_driver);
410}
411subsys_initcall(tca8418_keypad_init);
412
413static void __exit tca8418_keypad_exit(void)
414{
415 i2c_del_driver(&tca8418_keypad_driver);
416}
417module_exit(tca8418_keypad_exit);
418
419MODULE_AUTHOR("Kyle Manna <kyle.manna@fuel7.com>");
420MODULE_DESCRIPTION("Keypad driver for TCA8418");
421MODULE_LICENSE("GPL");
422
