1 /* 2 * Driver for keys on TCA6416 I2C IO expander 3 * 4 * Copyright (C) 2010 Texas Instruments 5 * 6 * Author : Sriramakrishnan.A.G. <srk@ti.com> 7 * 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. 11 */ 12 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> 24 25 #define TCA6416_INPUT 0 26 #define TCA6416_OUTPUT 1 27 #define TCA6416_INVERT 2 28 #define TCA6416_DIRECTION 3 29 30 static const struct i2c_device_id tca6416_id[] = { 31 { "tca6416-keys", 16, }, 32 { "tca6408-keys", 8, }, 33 { } 34 }; 35 MODULE_DEVICE_TABLE(i2c, tca6416_id); 36 37 struct tca6416_drv_data { 38 struct input_dev *input; 39 struct tca6416_button data[0]; 40 }; 41 42 struct tca6416_keypad_chip { 43 uint16_t reg_output; 44 uint16_t reg_direction; 45 uint16_t reg_input; 46 47 struct i2c_client *client; 48 struct input_dev *input; 49 struct delayed_work dwork; 50 int io_size; 51 int irqnum; 52 u16 pinmask; 53 bool use_polling; 54 struct tca6416_button buttons[0]; 55 }; 56 57 static int tca6416_write_reg(struct tca6416_keypad_chip *chip, int reg, u16 val) 58 { 59 int error; 60 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); 64 if (error < 0) { 65 dev_err(&chip->client->dev, 66 "%s failed, reg: %d, val: %d, error: %d\n", 67 __func__, reg, val, error); 68 return error; 69 } 70 71 return 0; 72 } 73 74 static int tca6416_read_reg(struct tca6416_keypad_chip *chip, int reg, u16 *val) 75 { 76 int retval; 77 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); 81 if (retval < 0) { 82 dev_err(&chip->client->dev, "%s failed, reg: %d, error: %d\n", 83 __func__, reg, retval); 84 return retval; 85 } 86 87 *val = (u16)retval; 88 return 0; 89 } 90 91 static void tca6416_keys_scan(struct tca6416_keypad_chip *chip) 92 { 93 struct input_dev *input = chip->input; 94 u16 reg_val, val; 95 int error, i, pin_index; 96 97 error = tca6416_read_reg(chip, TCA6416_INPUT, ®_val); 98 if (error) 99 return; 100 101 reg_val &= chip->pinmask; 102 103 /* Figure out which lines have changed */ 104 val = reg_val ^ chip->reg_input; 105 chip->reg_input = reg_val; 106 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; 113 114 input_event(input, type, button->code, !!state); 115 input_sync(input); 116 } 117 118 if (chip->pinmask & (1 << i)) 119 pin_index++; 120 } 121 } 122 123 /* 124 * This is threaded IRQ handler and this can (and will) sleep. 125 */ 126 static irqreturn_t tca6416_keys_isr(int irq, void *dev_id) 127 { 128 struct tca6416_keypad_chip *chip = dev_id; 129 130 tca6416_keys_scan(chip); 131 132 return IRQ_HANDLED; 133 } 134 135 static void tca6416_keys_work_func(struct work_struct *work) 136 { 137 struct tca6416_keypad_chip *chip = 138 container_of(work, struct tca6416_keypad_chip, dwork.work); 139 140 tca6416_keys_scan(chip); 141 schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100)); 142 } 143 144 static int tca6416_keys_open(struct input_dev *dev) 145 { 146 struct tca6416_keypad_chip *chip = input_get_drvdata(dev); 147 148 /* Get initial device state in case it has switches */ 149 tca6416_keys_scan(chip); 150 151 if (chip->use_polling) 152 schedule_delayed_work(&chip->dwork, msecs_to_jiffies(100)); 153 else 154 enable_irq(chip->irqnum); 155 156 return 0; 157 } 158 159 static void tca6416_keys_close(struct input_dev *dev) 160 { 161 struct tca6416_keypad_chip *chip = input_get_drvdata(dev); 162 163 if (chip->use_polling) 164 cancel_delayed_work_sync(&chip->dwork); 165 else 166 disable_irq(chip->irqnum); 167 } 168 169 static int tca6416_setup_registers(struct tca6416_keypad_chip *chip) 170 { 171 int error; 172 173 error = tca6416_read_reg(chip, TCA6416_OUTPUT, &chip->reg_output); 174 if (error) 175 return error; 176 177 error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction); 178 if (error) 179 return error; 180 181 /* ensure that keypad pins are set to input */ 182 error = tca6416_write_reg(chip, TCA6416_DIRECTION, 183 chip->reg_direction | chip->pinmask); 184 if (error) 185 return error; 186 187 error = tca6416_read_reg(chip, TCA6416_DIRECTION, &chip->reg_direction); 188 if (error) 189 return error; 190 191 error = tca6416_read_reg(chip, TCA6416_INPUT, &chip->reg_input); 192 if (error) 193 return error; 194 195 chip->reg_input &= chip->pinmask; 196 197 return 0; 198 } 199 200 static int tca6416_keypad_probe(struct i2c_client *client, 201 const struct i2c_device_id *id) 202 { 203 struct tca6416_keys_platform_data *pdata; 204 struct tca6416_keypad_chip *chip; 205 struct input_dev *input; 206 int error; 207 int i; 208 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)); 213 return -ENODEV; 214 } 215 216 pdata = dev_get_platdata(&client->dev); 217 if (!pdata) { 218 dev_dbg(&client->dev, "no platform data\n"); 219 return -EINVAL; 220 } 221 222 chip = kzalloc(sizeof(struct tca6416_keypad_chip) + 223 pdata->nbuttons * sizeof(struct tca6416_button), 224 GFP_KERNEL); 225 input = input_allocate_device(); 226 if (!chip || !input) { 227 error = -ENOMEM; 228 goto fail1; 229 } 230 231 chip->client = client; 232 chip->input = input; 233 chip->io_size = id->driver_data; 234 chip->pinmask = pdata->pinmask; 235 chip->use_polling = pdata->use_polling; 236 237 INIT_DELAYED_WORK(&chip->dwork, tca6416_keys_work_func); 238 239 input->phys = "tca6416-keys/input0"; 240 input->name = client->name; 241 input->dev.parent = &client->dev; 242 243 input->open = tca6416_keys_open; 244 input->close = tca6416_keys_close; 245 246 input->id.bustype = BUS_HOST; 247 input->id.vendor = 0x0001; 248 input->id.product = 0x0001; 249 input->id.version = 0x0100; 250 251 /* Enable auto repeat feature of Linux input subsystem */ 252 if (pdata->rep) 253 __set_bit(EV_REP, input->evbit); 254 255 for (i = 0; i < pdata->nbuttons; i++) { 256 unsigned int type; 257 258 chip->buttons[i] = pdata->buttons[i]; 259 type = (pdata->buttons[i].type) ?: EV_KEY; 260 input_set_capability(input, type, pdata->buttons[i].code); 261 } 262 263 input_set_drvdata(input, chip); 264 265 /* 266 * Initialize cached registers from their original values. 267 * we can't share this chip with another i2c master. 268 */ 269 error = tca6416_setup_registers(chip); 270 if (error) 271 goto fail1; 272 273 if (!chip->use_polling) { 274 if (pdata->irq_is_gpio) 275 chip->irqnum = gpio_to_irq(client->irq); 276 else 277 chip->irqnum = client->irq; 278 279 error = request_threaded_irq(chip->irqnum, NULL, 280 tca6416_keys_isr, 281 IRQF_TRIGGER_FALLING | 282 IRQF_ONESHOT, 283 "tca6416-keypad", chip); 284 if (error) { 285 dev_dbg(&client->dev, 286 "Unable to claim irq %d; error %d\n", 287 chip->irqnum, error); 288 goto fail1; 289 } 290 disable_irq(chip->irqnum); 291 } 292 293 error = input_register_device(input); 294 if (error) { 295 dev_dbg(&client->dev, 296 "Unable to register input device, error: %d\n", error); 297 goto fail2; 298 } 299 300 i2c_set_clientdata(client, chip); 301 device_init_wakeup(&client->dev, 1); 302 303 return 0; 304 305 fail2: 306 if (!chip->use_polling) { 307 free_irq(chip->irqnum, chip); 308 enable_irq(chip->irqnum); 309 } 310 fail1: 311 input_free_device(input); 312 kfree(chip); 313 return error; 314 } 315 316 static int tca6416_keypad_remove(struct i2c_client *client) 317 { 318 struct tca6416_keypad_chip *chip = i2c_get_clientdata(client); 319 320 if (!chip->use_polling) { 321 free_irq(chip->irqnum, chip); 322 enable_irq(chip->irqnum); 323 } 324 325 input_unregister_device(chip->input); 326 kfree(chip); 327 328 return 0; 329 } 330 331 #ifdef CONFIG_PM_SLEEP 332 static int tca6416_keypad_suspend(struct device *dev) 333 { 334 struct i2c_client *client = to_i2c_client(dev); 335 struct tca6416_keypad_chip *chip = i2c_get_clientdata(client); 336 337 if (device_may_wakeup(dev)) 338 enable_irq_wake(chip->irqnum); 339 340 return 0; 341 } 342 343 static int tca6416_keypad_resume(struct device *dev) 344 { 345 struct i2c_client *client = to_i2c_client(dev); 346 struct tca6416_keypad_chip *chip = i2c_get_clientdata(client); 347 348 if (device_may_wakeup(dev)) 349 disable_irq_wake(chip->irqnum); 350 351 return 0; 352 } 353 #endif 354 355 static SIMPLE_DEV_PM_OPS(tca6416_keypad_dev_pm_ops, 356 tca6416_keypad_suspend, tca6416_keypad_resume); 357 358 static struct i2c_driver tca6416_keypad_driver = { 359 .driver = { 360 .name = "tca6416-keypad", 361 .pm = &tca6416_keypad_dev_pm_ops, 362 }, 363 .probe = tca6416_keypad_probe, 364 .remove = tca6416_keypad_remove, 365 .id_table = tca6416_id, 366 }; 367 368 static int __init tca6416_keypad_init(void) 369 { 370 return i2c_add_driver(&tca6416_keypad_driver); 371 } 372 373 subsys_initcall(tca6416_keypad_init); 374 375 static void __exit tca6416_keypad_exit(void) 376 { 377 i2c_del_driver(&tca6416_keypad_driver); 378 } 379 module_exit(tca6416_keypad_exit); 380 381 MODULE_AUTHOR("Sriramakrishnan <srk@ti.com>"); 382 MODULE_DESCRIPTION("Keypad driver over tca6146 IO expander"); 383 MODULE_LICENSE("GPL"); 384