kernel/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/leds.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 #define QT2160_CMD_DRIVE_X    70
  43 #define QT2160_CMD_PWMEN_X    74
  44 #define QT2160_CMD_PWM_DUTY   76
  45
  46 #define QT2160_NUM_LEDS_X       8
  47
  48 #define QT2160_CYCLE_INTERVAL   (2*HZ)
  49
  50 static unsigned char qt2160_key2code[] = {
  51         KEY_0, KEY_1, KEY_2, KEY_3,
  52         KEY_4, KEY_5, KEY_6, KEY_7,
  53         KEY_8, KEY_9, KEY_A, KEY_B,
  54         KEY_C, KEY_D, KEY_E, KEY_F,
  55 };
  56
  57 #ifdef CONFIG_LEDS_CLASS
  58 struct qt2160_led {
  59         struct qt2160_data *qt2160;
  60         struct led_classdev cdev;
  61         struct work_struct work;
  62         char name[32];
  63         int id;
  64         enum led_brightness new_brightness;
  65 };
  66 #endif
  67
  68 struct qt2160_data {
  69         struct i2c_client *client;
  70         struct input_dev *input;
  71         struct delayed_work dwork;
  72         spinlock_t lock;        /* Protects canceling/rescheduling of dwork */
  73         unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
  74         u16 key_matrix;
  75 #ifdef CONFIG_LEDS_CLASS
  76         struct qt2160_led leds[QT2160_NUM_LEDS_X];
  77         struct mutex led_lock;
  78 #endif
  79 };
  80
  81 static int qt2160_read(struct i2c_client *client, u8 reg);
  82 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data);
  83
  84 #ifdef CONFIG_LEDS_CLASS
  85
  86 static void qt2160_led_work(struct work_struct *work)
  87 {
  88         struct qt2160_led *led = container_of(work, struct qt2160_led, work);
  89         struct qt2160_data *qt2160 = led->qt2160;
  90         struct i2c_client *client = qt2160->client;
  91         int value = led->new_brightness;
  92         u32 drive, pwmen;
  93
  94         mutex_lock(&qt2160->led_lock);
  95
  96         drive = qt2160_read(client, QT2160_CMD_DRIVE_X);
  97         pwmen = qt2160_read(client, QT2160_CMD_PWMEN_X);
  98         if (value != LED_OFF) {
  99                 drive |= (1 << led->id);
 100                 pwmen |= (1 << led->id);
 101
 102         } else {
 103                 drive &= ~(1 << led->id);
 104                 pwmen &= ~(1 << led->id);
 105         }
 106         qt2160_write(client, QT2160_CMD_DRIVE_X, drive);
 107         qt2160_write(client, QT2160_CMD_PWMEN_X, pwmen);
 108
 109         /*
 110          * Changing this register will change the brightness
 111          * of every LED in the qt2160. It's a HW limitation.
 112          */
 113         if (value != LED_OFF)
 114                 qt2160_write(client, QT2160_CMD_PWM_DUTY, value);
 115
 116         mutex_unlock(&qt2160->led_lock);
 117 }
 118
 119 static void qt2160_led_set(struct led_classdev *cdev,
 120                            enum led_brightness value)
 121 {
 122         struct qt2160_led *led = container_of(cdev, struct qt2160_led, cdev);
 123
 124         led->new_brightness = value;
 125         schedule_work(&led->work);
 126 }
 127
 128 #endif /* CONFIG_LEDS_CLASS */
 129
 130 static int qt2160_read_block(struct i2c_client *client,
 131                              u8 inireg, u8 *buffer, unsigned int count)
 132 {
 133         int error, idx = 0;
 134
 135         /*
 136          * Can't use SMBus block data read. Check for I2C functionality to speed
 137          * things up whenever possible. Otherwise we will be forced to read
 138          * sequentially.
 139          */
 140         if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))     {
 141
 142                 error = i2c_smbus_write_byte(client, inireg + idx);
 143                 if (error) {
 144                         dev_err(&client->dev,
 145                                 "couldn't send request. Returned %d\n", error);
 146                         return error;
 147                 }
 148
 149                 error = i2c_master_recv(client, buffer, count);
 150                 if (error != count) {
 151                         dev_err(&client->dev,
 152                                 "couldn't read registers. Returned %d bytes\n", error);
 153                         return error;
 154                 }
 155         } else {
 156
 157                 while (count--) {
 158                         int data;
 159
 160                         error = i2c_smbus_write_byte(client, inireg + idx);
 161                         if (error) {
 162                                 dev_err(&client->dev,
 163                                         "couldn't send request. Returned %d\n", error);
 164                                 return error;
 165                         }
 166
 167                         data = i2c_smbus_read_byte(client);
 168                         if (data < 0) {
 169                                 dev_err(&client->dev,
 170                                         "couldn't read register. Returned %d\n", data);
 171                                 return data;
 172                         }
 173
 174                         buffer[idx++] = data;
 175                 }
 176         }
 177
 178         return 0;
 179 }
 180
 181 static int qt2160_get_key_matrix(struct qt2160_data *qt2160)
 182 {
 183         struct i2c_client *client = qt2160->client;
 184         struct input_dev *input = qt2160->input;
 185         u8 regs[6];
 186         u16 old_matrix, new_matrix;
 187         int ret, i, mask;
 188
 189         dev_dbg(&client->dev, "requesting keys...\n");
 190
 191         /*
 192          * Read all registers from General Status Register
 193          * to GPIOs register
 194          */
 195         ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6);
 196         if (ret) {
 197                 dev_err(&client->dev,
 198                         "could not perform chip read.\n");
 199                 return ret;
 200         }
 201
 202         old_matrix = qt2160->key_matrix;
 203         qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1];
 204
 205         mask = 0x01;
 206         for (i = 0; i < 16; ++i, mask <<= 1) {
 207                 int keyval = new_matrix & mask;
 208
 209                 if ((old_matrix & mask) != keyval) {
 210                         input_report_key(input, qt2160->keycodes[i], keyval);
 211                         dev_dbg(&client->dev, "key %d %s\n",
 212                                 i, keyval ? "pressed" : "released");
 213                 }
 214         }
 215
 216         input_sync(input);
 217
 218         return 0;
 219 }
 220
 221 static irqreturn_t qt2160_irq(int irq, void *_qt2160)
 222 {
 223         struct qt2160_data *qt2160 = _qt2160;
 224         unsigned long flags;
 225
 226         spin_lock_irqsave(&qt2160->lock, flags);
 227
 228         mod_delayed_work(system_wq, &qt2160->dwork, 0);
 229
 230         spin_unlock_irqrestore(&qt2160->lock, flags);
 231
 232         return IRQ_HANDLED;
 233 }
 234
 235 static void qt2160_schedule_read(struct qt2160_data *qt2160)
 236 {
 237         spin_lock_irq(&qt2160->lock);
 238         schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL);
 239         spin_unlock_irq(&qt2160->lock);
 240 }
 241
 242 static void qt2160_worker(struct work_struct *work)
 243 {
 244         struct qt2160_data *qt2160 =
 245                 container_of(work, struct qt2160_data, dwork.work);
 246
 247         dev_dbg(&qt2160->client->dev, "worker\n");
 248
 249         qt2160_get_key_matrix(qt2160);
 250
 251         /* Avoid device lock up by checking every so often */
 252         qt2160_schedule_read(qt2160);
 253 }
 254
 255 static int qt2160_read(struct i2c_client *client, u8 reg)
 256 {
 257         int ret;
 258
 259         ret = i2c_smbus_write_byte(client, reg);
 260         if (ret) {
 261                 dev_err(&client->dev,
 262                         "couldn't send request. Returned %d\n", ret);
 263                 return ret;
 264         }
 265
 266         ret = i2c_smbus_read_byte(client);
 267         if (ret < 0) {
 268                 dev_err(&client->dev,
 269                         "couldn't read register. Returned %d\n", ret);
 270                 return ret;
 271         }
 272
 273         return ret;
 274 }
 275
 276 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data)
 277 {
 278         int ret;
 279
 280         ret = i2c_smbus_write_byte_data(client, reg, data);
 281         if (ret < 0)
 282                 dev_err(&client->dev,
 283                         "couldn't write data. Returned %d\n", ret);
 284
 285         return ret;
 286 }
 287
 288 #ifdef CONFIG_LEDS_CLASS
 289
 290 static int qt2160_register_leds(struct qt2160_data *qt2160)
 291 {
 292         struct i2c_client *client = qt2160->client;
 293         int ret;
 294         int i;
 295
 296         mutex_init(&qt2160->led_lock);
 297
 298         for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
 299                 struct qt2160_led *led = &qt2160->leds[i];
 300
 301                 snprintf(led->name, sizeof(led->name), "qt2160:x%d", i);
 302                 led->cdev.name = led->name;
 303                 led->cdev.brightness_set = qt2160_led_set;
 304                 led->cdev.brightness = LED_OFF;
 305                 led->id = i;
 306                 led->qt2160 = qt2160;
 307
 308                 INIT_WORK(&led->work, qt2160_led_work);
 309
 310                 ret = led_classdev_register(&client->dev, &led->cdev);
 311                 if (ret < 0)
 312                         return ret;
 313         }
 314
 315         /* Tur off LEDs */
 316         qt2160_write(client, QT2160_CMD_DRIVE_X, 0);
 317         qt2160_write(client, QT2160_CMD_PWMEN_X, 0);
 318         qt2160_write(client, QT2160_CMD_PWM_DUTY, 0);
 319
 320         return 0;
 321 }
 322
 323 static void qt2160_unregister_leds(struct qt2160_data *qt2160)
 324 {
 325         int i;
 326
 327         for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
 328                 led_classdev_unregister(&qt2160->leds[i].cdev);
 329                 cancel_work_sync(&qt2160->leds[i].work);
 330         }
 331 }
 332
 333 #else
 334
 335 static inline int qt2160_register_leds(struct qt2160_data *qt2160)
 336 {
 337         return 0;
 338 }
 339
 340 static inline void qt2160_unregister_leds(struct qt2160_data *qt2160)
 341 {
 342 }
 343
 344 #endif
 345
 346 static bool qt2160_identify(struct i2c_client *client)
 347 {
 348         int id, ver, rev;
 349
 350         /* Read Chid ID to check if chip is valid */
 351         id = qt2160_read(client, QT2160_CMD_CHIPID);
 352         if (id != QT2160_VALID_CHIPID) {
 353                 dev_err(&client->dev, "ID %d not supported\n", id);
 354                 return false;
 355         }
 356
 357         /* Read chip firmware version */
 358         ver = qt2160_read(client, QT2160_CMD_CODEVER);
 359         if (ver < 0) {
 360                 dev_err(&client->dev, "could not get firmware version\n");
 361                 return false;
 362         }
 363
 364         /* Read chip firmware revision */
 365         rev = qt2160_read(client, QT2160_CMD_SUBVER);
 366         if (rev < 0) {
 367                 dev_err(&client->dev, "could not get firmware revision\n");
 368                 return false;
 369         }
 370
 371         dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n",
 372                         ver >> 4, ver & 0xf, rev);
 373
 374         return true;
 375 }
 376
 377 static int qt2160_probe(struct i2c_client *client,
 378                         const struct i2c_device_id *id)
 379 {
 380         struct qt2160_data *qt2160;
 381         struct input_dev *input;
 382         int i;
 383         int error;
 384
 385         /* Check functionality */
 386         error = i2c_check_functionality(client->adapter,
 387                         I2C_FUNC_SMBUS_BYTE);
 388         if (!error) {
 389                 dev_err(&client->dev, "%s adapter not supported\n",
 390                                 dev_driver_string(&client->adapter->dev));
 391                 return -ENODEV;
 392         }
 393
 394         if (!qt2160_identify(client))
 395                 return -ENODEV;
 396
 397         /* Chip is valid and active. Allocate structure */
 398         qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL);
 399         input = input_allocate_device();
 400         if (!qt2160 || !input) {
 401                 dev_err(&client->dev, "insufficient memory\n");
 402                 error = -ENOMEM;
 403                 goto err_free_mem;
 404         }
 405
 406         qt2160->client = client;
 407         qt2160->input = input;
 408         INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker);
 409         spin_lock_init(&qt2160->lock);
 410
 411         input->name = "AT42QT2160 Touch Sense Keyboard";
 412         input->id.bustype = BUS_I2C;
 413
 414         input->keycode = qt2160->keycodes;
 415         input->keycodesize = sizeof(qt2160->keycodes[0]);
 416         input->keycodemax = ARRAY_SIZE(qt2160_key2code);
 417
 418         __set_bit(EV_KEY, input->evbit);
 419         __clear_bit(EV_REP, input->evbit);
 420         for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) {
 421                 qt2160->keycodes[i] = qt2160_key2code[i];
 422                 __set_bit(qt2160_key2code[i], input->keybit);
 423         }
 424         __clear_bit(KEY_RESERVED, input->keybit);
 425
 426         /* Calibrate device */
 427         error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1);
 428         if (error) {
 429                 dev_err(&client->dev, "failed to calibrate device\n");
 430                 goto err_free_mem;
 431         }
 432
 433         if (client->irq) {
 434                 error = request_irq(client->irq, qt2160_irq,
 435                                     IRQF_TRIGGER_FALLING, "qt2160", qt2160);
 436                 if (error) {
 437                         dev_err(&client->dev,
 438                                 "failed to allocate irq %d\n", client->irq);
 439                         goto err_free_mem;
 440                 }
 441         }
 442
 443         error = qt2160_register_leds(qt2160);
 444         if (error) {
 445                 dev_err(&client->dev, "Failed to register leds\n");
 446                 goto err_free_irq;
 447         }
 448
 449         error = input_register_device(qt2160->input);
 450         if (error) {
 451                 dev_err(&client->dev,
 452                         "Failed to register input device\n");
 453                 goto err_unregister_leds;
 454         }
 455
 456         i2c_set_clientdata(client, qt2160);
 457         qt2160_schedule_read(qt2160);
 458
 459         return 0;
 460
 461 err_unregister_leds:
 462         qt2160_unregister_leds(qt2160);
 463 err_free_irq:
 464         if (client->irq)
 465                 free_irq(client->irq, qt2160);
 466 err_free_mem:
 467         input_free_device(input);
 468         kfree(qt2160);
 469         return error;
 470 }
 471
 472 static int qt2160_remove(struct i2c_client *client)
 473 {
 474         struct qt2160_data *qt2160 = i2c_get_clientdata(client);
 475
 476         qt2160_unregister_leds(qt2160);
 477
 478         /* Release IRQ so no queue will be scheduled */
 479         if (client->irq)
 480                 free_irq(client->irq, qt2160);
 481
 482         cancel_delayed_work_sync(&qt2160->dwork);
 483
 484         input_unregister_device(qt2160->input);
 485         kfree(qt2160);
 486
 487         return 0;
 488 }
 489
 490 static const struct i2c_device_id qt2160_idtable[] = {
 491         { "qt2160", 0, },
 492         { }
 493 };
 494
 495 MODULE_DEVICE_TABLE(i2c, qt2160_idtable);
 496
 497 static struct i2c_driver qt2160_driver = {
 498         .driver = {
 499                 .name   = "qt2160",
 500                 .owner  = THIS_MODULE,
 501         },
 502
 503         .id_table       = qt2160_idtable,
 504         .probe          = qt2160_probe,
 505         .remove         = qt2160_remove,
 506 };
 507
 508 module_i2c_driver(qt2160_driver);
 509
 510 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
 511 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
 512 MODULE_LICENSE("GPL");