2 * Driver for keys on TCA6416 I2C IO expander
4 * Copyright (C) 2010 Texas Instruments
6 * Author : Sriramakrishnan.A.G. <srk@ti.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
13 #include <linux/types.h>
14 #include <linux/module.h>
15 #include <linux/init.h>
16 #include <linux/delay.h>
17 #include <linux/slab.h>
18 #include <linux/interrupt.h>
19 #include <linux/workqueue.h>
20 #include <linux/gpio.h>
21 #include <linux/i2c.h>
22 #include <linux/input.h>
23 #include <linux/tca6416_keypad.h>
25 #define TCA6416_INPUT 0
26 #define TCA6416_OUTPUT 1
27 #define TCA6416_INVERT 2
28 #define TCA6416_DIRECTION 3
30 static const struct i2c_device_id tca6416_id
[] = {
31 { "tca6416-keys", 16, },
32 { "tca6408-keys", 8, },
35 MODULE_DEVICE_TABLE(i2c
, tca6416_id
);
37 struct tca6416_drv_data
{
38 struct input_dev
*input
;
39 struct tca6416_button data
[0];
42 struct tca6416_keypad_chip
{
44 uint16_t reg_direction
;
47 struct i2c_client
*client
;
48 struct input_dev
*input
;
49 struct delayed_work dwork
;
54 struct tca6416_button buttons
[0];
57 static int tca6416_write_reg(struct tca6416_keypad_chip
*chip
, int reg
, u16 val
)
61 error
= chip
->io_size
> 8 ?
62 i2c_smbus_write_word_data(chip
->client
, reg
<< 1, val
) :
63 i2c_smbus_write_byte_data(chip
->client
, reg
, val
);
65 dev_err(&chip
->client
->dev
,
66 "%s failed, reg: %d, val: %d, error: %d\n",
67 __func__
, reg
, val
, error
);
74 static int tca6416_read_reg(struct tca6416_keypad_chip
*chip
, int reg
, u16
*val
)
78 retval
= chip
->io_size
> 8 ?
79 i2c_smbus_read_word_data(chip
->client
, reg
<< 1) :
80 i2c_smbus_read_byte_data(chip
->client
, reg
);
82 dev_err(&chip
->client
->dev
, "%s failed, reg: %d, error: %d\n",
83 __func__
, reg
, retval
);
91 static void tca6416_keys_scan(struct tca6416_keypad_chip
*chip
)
93 struct input_dev
*input
= chip
->input
;
95 int error
, i
, pin_index
;
97 error
= tca6416_read_reg(chip
, TCA6416_INPUT
, ®_val
);
101 reg_val
&= chip
->pinmask
;
103 /* Figure out which lines have changed */
104 val
= reg_val
^ chip
->reg_input
;
105 chip
->reg_input
= reg_val
;
107 for (i
= 0, pin_index
= 0; i
< 16; i
++) {
108 if (val
& (1 << i
)) {
109 struct tca6416_button
*button
= &chip
->buttons
[pin_index
];
110 unsigned int type
= button
->type
?: EV_KEY
;
111 int state
= ((reg_val
& (1 << i
)) ? 1 : 0)
112 ^ button
->active_low
;
114 input_event(input
, type
, button
->code
, !!state
);
118 if (chip
->pinmask
& (1 << i
))
124 * This is threaded IRQ handler and this can (and will) sleep.
126 static irqreturn_t
tca6416_keys_isr(int irq
, void *dev_id
)
128 struct tca6416_keypad_chip
*chip
= dev_id
;
130 tca6416_keys_scan(chip
);
135 static void tca6416_keys_work_func(struct work_struct
*work
)
137 struct tca6416_keypad_chip
*chip
=
138 container_of(work
, struct tca6416_keypad_chip
, dwork
.work
);
140 tca6416_keys_scan(chip
);
141 schedule_delayed_work(&chip
->dwork
, msecs_to_jiffies(100));
144 static int tca6416_keys_open(struct input_dev
*dev
)
146 struct tca6416_keypad_chip
*chip
= input_get_drvdata(dev
);
148 /* Get initial device state in case it has switches */
149 tca6416_keys_scan(chip
);
151 if (chip
->use_polling
)
152 schedule_delayed_work(&chip
->dwork
, msecs_to_jiffies(100));
154 enable_irq(chip
->irqnum
);
159 static void tca6416_keys_close(struct input_dev
*dev
)
161 struct tca6416_keypad_chip
*chip
= input_get_drvdata(dev
);
163 if (chip
->use_polling
)
164 cancel_delayed_work_sync(&chip
->dwork
);
166 disable_irq(chip
->irqnum
);
169 static int tca6416_setup_registers(struct tca6416_keypad_chip
*chip
)
173 error
= tca6416_read_reg(chip
, TCA6416_OUTPUT
, &chip
->reg_output
);
177 error
= tca6416_read_reg(chip
, TCA6416_DIRECTION
, &chip
->reg_direction
);
181 /* ensure that keypad pins are set to input */
182 error
= tca6416_write_reg(chip
, TCA6416_DIRECTION
,
183 chip
->reg_direction
| chip
->pinmask
);
187 error
= tca6416_read_reg(chip
, TCA6416_DIRECTION
, &chip
->reg_direction
);
191 error
= tca6416_read_reg(chip
, TCA6416_INPUT
, &chip
->reg_input
);
195 chip
->reg_input
&= chip
->pinmask
;
200 static int tca6416_keypad_probe(struct i2c_client
*client
,
201 const struct i2c_device_id
*id
)
203 struct tca6416_keys_platform_data
*pdata
;
204 struct tca6416_keypad_chip
*chip
;
205 struct input_dev
*input
;
209 /* Check functionality */
210 if (!i2c_check_functionality(client
->adapter
, I2C_FUNC_SMBUS_BYTE
)) {
211 dev_err(&client
->dev
, "%s adapter not supported\n",
212 dev_driver_string(&client
->adapter
->dev
));
216 pdata
= dev_get_platdata(&client
->dev
);
218 dev_dbg(&client
->dev
, "no platform data\n");
222 chip
= kzalloc(struct_size(chip
, buttons
, pdata
->nbuttons
), GFP_KERNEL
);
223 input
= input_allocate_device();
224 if (!chip
|| !input
) {
229 chip
->client
= client
;
231 chip
->io_size
= id
->driver_data
;
232 chip
->pinmask
= pdata
->pinmask
;
233 chip
->use_polling
= pdata
->use_polling
;
235 INIT_DELAYED_WORK(&chip
->dwork
, tca6416_keys_work_func
);
237 input
->phys
= "tca6416-keys/input0";
238 input
->name
= client
->name
;
239 input
->dev
.parent
= &client
->dev
;
241 input
->open
= tca6416_keys_open
;
242 input
->close
= tca6416_keys_close
;
244 input
->id
.bustype
= BUS_HOST
;
245 input
->id
.vendor
= 0x0001;
246 input
->id
.product
= 0x0001;
247 input
->id
.version
= 0x0100;
249 /* Enable auto repeat feature of Linux input subsystem */
251 __set_bit(EV_REP
, input
->evbit
);
253 for (i
= 0; i
< pdata
->nbuttons
; i
++) {
256 chip
->buttons
[i
] = pdata
->buttons
[i
];
257 type
= (pdata
->buttons
[i
].type
) ?: EV_KEY
;
258 input_set_capability(input
, type
, pdata
->buttons
[i
].code
);
261 input_set_drvdata(input
, chip
);
264 * Initialize cached registers from their original values.
265 * we can't share this chip with another i2c master.
267 error
= tca6416_setup_registers(chip
);
271 if (!chip
->use_polling
) {
272 if (pdata
->irq_is_gpio
)
273 chip
->irqnum
= gpio_to_irq(client
->irq
);
275 chip
->irqnum
= client
->irq
;
277 error
= request_threaded_irq(chip
->irqnum
, NULL
,
279 IRQF_TRIGGER_FALLING
|
281 "tca6416-keypad", chip
);
283 dev_dbg(&client
->dev
,
284 "Unable to claim irq %d; error %d\n",
285 chip
->irqnum
, error
);
288 disable_irq(chip
->irqnum
);
291 error
= input_register_device(input
);
293 dev_dbg(&client
->dev
,
294 "Unable to register input device, error: %d\n", error
);
298 i2c_set_clientdata(client
, chip
);
299 device_init_wakeup(&client
->dev
, 1);
304 if (!chip
->use_polling
) {
305 free_irq(chip
->irqnum
, chip
);
306 enable_irq(chip
->irqnum
);
309 input_free_device(input
);
314 static int tca6416_keypad_remove(struct i2c_client
*client
)
316 struct tca6416_keypad_chip
*chip
= i2c_get_clientdata(client
);
318 if (!chip
->use_polling
) {
319 free_irq(chip
->irqnum
, chip
);
320 enable_irq(chip
->irqnum
);
323 input_unregister_device(chip
->input
);
329 #ifdef CONFIG_PM_SLEEP
330 static int tca6416_keypad_suspend(struct device
*dev
)
332 struct i2c_client
*client
= to_i2c_client(dev
);
333 struct tca6416_keypad_chip
*chip
= i2c_get_clientdata(client
);
335 if (device_may_wakeup(dev
))
336 enable_irq_wake(chip
->irqnum
);
341 static int tca6416_keypad_resume(struct device
*dev
)
343 struct i2c_client
*client
= to_i2c_client(dev
);
344 struct tca6416_keypad_chip
*chip
= i2c_get_clientdata(client
);
346 if (device_may_wakeup(dev
))
347 disable_irq_wake(chip
->irqnum
);
353 static SIMPLE_DEV_PM_OPS(tca6416_keypad_dev_pm_ops
,
354 tca6416_keypad_suspend
, tca6416_keypad_resume
);
356 static struct i2c_driver tca6416_keypad_driver
= {
358 .name
= "tca6416-keypad",
359 .pm
= &tca6416_keypad_dev_pm_ops
,
361 .probe
= tca6416_keypad_probe
,
362 .remove
= tca6416_keypad_remove
,
363 .id_table
= tca6416_id
,
366 static int __init
tca6416_keypad_init(void)
368 return i2c_add_driver(&tca6416_keypad_driver
);
371 subsys_initcall(tca6416_keypad_init
);
373 static void __exit
tca6416_keypad_exit(void)
375 i2c_del_driver(&tca6416_keypad_driver
);
377 module_exit(tca6416_keypad_exit
);
379 MODULE_AUTHOR("Sriramakrishnan <srk@ti.com>");
380 MODULE_DESCRIPTION("Keypad driver over tca6146 IO expander");
381 MODULE_LICENSE("GPL");