drivers/input/keyboard/qt2160.c

   1 /*
   2  *  qt2160.c - Atmel AT42QT2160 Touch Sense Controller
   3  *
   4  *  Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include <linux/kernel.h>
  22 #include <linux/init.h>
  23 #include <linux/module.h>
  24 #include <linux/slab.h>
  25 #include <linux/jiffies.h>
  26 #include <linux/i2c.h>
  27 #include <linux/irq.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/input.h>
  30
  31 #define QT2160_VALID_CHIPID  0x11
  32
  33 #define QT2160_CMD_CHIPID     0
  34 #define QT2160_CMD_CODEVER    1
  35 #define QT2160_CMD_GSTAT      2
  36 #define QT2160_CMD_KEYS3      3
  37 #define QT2160_CMD_KEYS4      4
  38 #define QT2160_CMD_SLIDE      5
  39 #define QT2160_CMD_GPIOS      6
  40 #define QT2160_CMD_SUBVER     7
  41 #define QT2160_CMD_CALIBRATE  10
  42
  43 #define QT2160_CYCLE_INTERVAL   (2*HZ)
  44
  45 static unsigned char qt2160_key2code[] = {
  46         KEY_0, KEY_1, KEY_2, KEY_3,
  47         KEY_4, KEY_5, KEY_6, KEY_7,
  48         KEY_8, KEY_9, KEY_A, KEY_B,
  49         KEY_C, KEY_D, KEY_E, KEY_F,
  50 };
  51
  52 struct qt2160_data {
  53         struct i2c_client *client;
  54         struct input_dev *input;
  55         struct delayed_work dwork;
  56         spinlock_t lock;        /* Protects canceling/rescheduling of dwork */
  57         unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
  58         u16 key_matrix;
  59 };
  60
  61 static int qt2160_read_block(struct i2c_client *client,
  62                              u8 inireg, u8 *buffer, unsigned int count)
  63 {
  64         int error, idx = 0;
  65
  66         /*
  67          * Can't use SMBus block data read. Check for I2C functionality to speed
  68          * things up whenever possible. Otherwise we will be forced to read
  69          * sequentially.
  70          */
  71         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))     {
  72
  73                 error = i2c_smbus_write_byte(client, inireg + idx);
  74                 if (error) {
  75                         dev_err(&client->dev,
  76                                 "couldn't send request. Returned %d\n", error);
  77                         return error;
  78                 }
  79
  80                 error = i2c_master_recv(client, buffer, count);
  81                 if (error != count) {
  82                         dev_err(&client->dev,
  83                                 "couldn't read registers. Returned %d bytes\n", error);
  84                         return error;
  85                 }
  86         } else {
  87
  88                 while (count--) {
  89                         int data;
  90
  91                         error = i2c_smbus_write_byte(client, inireg + idx);
  92                         if (error) {
  93                                 dev_err(&client->dev,
  94                                         "couldn't send request. Returned %d\n", error);
  95                                 return error;
  96                         }
  97
  98                         data = i2c_smbus_read_byte(client);
  99                         if (data < 0) {
 100                                 dev_err(&client->dev,
 101                                         "couldn't read register. Returned %d\n", data);
 102                                 return data;
 103                         }
 104
 105                         buffer[idx++] = data;
 106                 }
 107         }
 108
 109         return 0;
 110 }
 111
 112 static int qt2160_get_key_matrix(struct qt2160_data *qt2160)
 113 {
 114         struct i2c_client *client = qt2160->client;
 115         struct input_dev *input = qt2160->input;
 116         u8 regs[6];
 117         u16 old_matrix, new_matrix;
 118         int ret, i, mask;
 119
 120         dev_dbg(&client->dev, "requesting keys...\n");
 121
 122         /*
 123          * Read all registers from General Status Register
 124          * to GPIOs register
 125          */
 126         ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6);
 127         if (ret) {
 128                 dev_err(&client->dev,
 129                         "could not perform chip read.\n");
 130                 return ret;
 131         }
 132
 133         old_matrix = qt2160->key_matrix;
 134         qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1];
 135
 136         mask = 0x01;
 137         for (i = 0; i < 16; ++i, mask <<= 1) {
 138                 int keyval = new_matrix & mask;
 139
 140                 if ((old_matrix & mask) != keyval) {
 141                         input_report_key(input, qt2160->keycodes[i], keyval);
 142                         dev_dbg(&client->dev, "key %d %s\n",
 143                                 i, keyval ? "pressed" : "released");
 144                 }
 145         }
 146
 147         input_sync(input);
 148
 149         return 0;
 150 }
 151
 152 static irqreturn_t qt2160_irq(int irq, void *_qt2160)
 153 {
 154         struct qt2160_data *qt2160 = _qt2160;
 155         unsigned long flags;
 156
 157         spin_lock_irqsave(&qt2160->lock, flags);
 158
 159         mod_delayed_work(system_wq, &qt2160->dwork, 0);
 160
 161         spin_unlock_irqrestore(&qt2160->lock, flags);
 162
 163         return IRQ_HANDLED;
 164 }
 165
 166 static void qt2160_schedule_read(struct qt2160_data *qt2160)
 167 {
 168         spin_lock_irq(&qt2160->lock);
 169         schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL);
 170         spin_unlock_irq(&qt2160->lock);
 171 }
 172
 173 static void qt2160_worker(struct work_struct *work)
 174 {
 175         struct qt2160_data *qt2160 =
 176                 container_of(work, struct qt2160_data, dwork.work);
 177
 178         dev_dbg(&qt2160->client->dev, "worker\n");
 179
 180         qt2160_get_key_matrix(qt2160);
 181
 182         /* Avoid device lock up by checking every so often */
 183         qt2160_schedule_read(qt2160);
 184 }
 185
 186 static int __devinit qt2160_read(struct i2c_client *client, u8 reg)
 187 {
 188         int ret;
 189
 190         ret = i2c_smbus_write_byte(client, reg);
 191         if (ret) {
 192                 dev_err(&client->dev,
 193                         "couldn't send request. Returned %d\n", ret);
 194                 return ret;
 195         }
 196
 197         ret = i2c_smbus_read_byte(client);
 198         if (ret < 0) {
 199                 dev_err(&client->dev,
 200                         "couldn't read register. Returned %d\n", ret);
 201                 return ret;
 202         }
 203
 204         return ret;
 205 }
 206
 207 static int __devinit qt2160_write(struct i2c_client *client, u8 reg, u8 data)
 208 {
 209         int ret;
 210
 211         ret = i2c_smbus_write_byte_data(client, reg, data);
 212         if (ret < 0)
 213                 dev_err(&client->dev,
 214                         "couldn't write data. Returned %d\n", ret);
 215
 216         return ret;
 217 }
 218
 219
 220 static bool __devinit qt2160_identify(struct i2c_client *client)
 221 {
 222         int id, ver, rev;
 223
 224         /* Read Chid ID to check if chip is valid */
 225         id = qt2160_read(client, QT2160_CMD_CHIPID);
 226         if (id != QT2160_VALID_CHIPID) {
 227                 dev_err(&client->dev, "ID %d not supported\n", id);
 228                 return false;
 229         }
 230
 231         /* Read chip firmware version */
 232         ver = qt2160_read(client, QT2160_CMD_CODEVER);
 233         if (ver < 0) {
 234                 dev_err(&client->dev, "could not get firmware version\n");
 235                 return false;
 236         }
 237
 238         /* Read chip firmware revision */
 239         rev = qt2160_read(client, QT2160_CMD_SUBVER);
 240         if (rev < 0) {
 241                 dev_err(&client->dev, "could not get firmware revision\n");
 242                 return false;
 243         }
 244
 245         dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n",
 246                         ver >> 4, ver & 0xf, rev);
 247
 248         return true;
 249 }
 250
 251 static int __devinit qt2160_probe(struct i2c_client *client,
 252                                   const struct i2c_device_id *id)
 253 {
 254         struct qt2160_data *qt2160;
 255         struct input_dev *input;
 256         int i;
 257         int error;
 258
 259         /* Check functionality */
 260         error = i2c_check_functionality(client->adapter,
 261                         I2C_FUNC_SMBUS_BYTE);
 262         if (!error) {
 263                 dev_err(&client->dev, "%s adapter not supported\n",
 264                                 dev_driver_string(&client->adapter->dev));
 265                 return -ENODEV;
 266         }
 267
 268         if (!qt2160_identify(client))
 269                 return -ENODEV;
 270
 271         /* Chip is valid and active. Allocate structure */
 272         qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL);
 273         input = input_allocate_device();
 274         if (!qt2160 || !input) {
 275                 dev_err(&client->dev, "insufficient memory\n");
 276                 error = -ENOMEM;
 277                 goto err_free_mem;
 278         }
 279
 280         qt2160->client = client;
 281         qt2160->input = input;
 282         INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker);
 283         spin_lock_init(&qt2160->lock);
 284
 285         input->name = "AT42QT2160 Touch Sense Keyboard";
 286         input->id.bustype = BUS_I2C;
 287
 288         input->keycode = qt2160->keycodes;
 289         input->keycodesize = sizeof(qt2160->keycodes[0]);
 290         input->keycodemax = ARRAY_SIZE(qt2160_key2code);
 291
 292         __set_bit(EV_KEY, input->evbit);
 293         __clear_bit(EV_REP, input->evbit);
 294         for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) {
 295                 qt2160->keycodes[i] = qt2160_key2code[i];
 296                 __set_bit(qt2160_key2code[i], input->keybit);
 297         }
 298         __clear_bit(KEY_RESERVED, input->keybit);
 299
 300         /* Calibrate device */
 301         error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1);
 302         if (error) {
 303                 dev_err(&client->dev, "failed to calibrate device\n");
 304                 goto err_free_mem;
 305         }
 306
 307         if (client->irq) {
 308                 error = request_irq(client->irq, qt2160_irq,
 309                                     IRQF_TRIGGER_FALLING, "qt2160", qt2160);
 310                 if (error) {
 311                         dev_err(&client->dev,
 312                                 "failed to allocate irq %d\n", client->irq);
 313                         goto err_free_mem;
 314                 }
 315         }
 316
 317         error = input_register_device(qt2160->input);
 318         if (error) {
 319                 dev_err(&client->dev,
 320                         "Failed to register input device\n");
 321                 goto err_free_irq;
 322         }
 323
 324         i2c_set_clientdata(client, qt2160);
 325         qt2160_schedule_read(qt2160);
 326
 327         return 0;
 328
 329 err_free_irq:
 330         if (client->irq)
 331                 free_irq(client->irq, qt2160);
 332 err_free_mem:
 333         input_free_device(input);
 334         kfree(qt2160);
 335         return error;
 336 }
 337
 338 static int __devexit qt2160_remove(struct i2c_client *client)
 339 {
 340         struct qt2160_data *qt2160 = i2c_get_clientdata(client);
 341
 342         /* Release IRQ so no queue will be scheduled */
 343         if (client->irq)
 344                 free_irq(client->irq, qt2160);
 345
 346         cancel_delayed_work_sync(&qt2160->dwork);
 347
 348         input_unregister_device(qt2160->input);
 349         kfree(qt2160);
 350
 351         return 0;
 352 }
 353
 354 static const struct i2c_device_id qt2160_idtable[] = {
 355         { "qt2160", 0, },
 356         { }
 357 };
 358
 359 MODULE_DEVICE_TABLE(i2c, qt2160_idtable);
 360
 361 static struct i2c_driver qt2160_driver = {
 362         .driver = {
 363                 .name   = "qt2160",
 364                 .owner  = THIS_MODULE,
 365         },
 366
 367         .id_table       = qt2160_idtable,
 368         .probe          = qt2160_probe,
 369         .remove         = __devexit_p(qt2160_remove),
 370 };
 371
 372 module_i2c_driver(qt2160_driver);
 373
 374 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
 375 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
 376 MODULE_LICENSE("GPL");