drivers/input/keyboard/adp5588-keys.c

   1 /*
   2  * File: drivers/input/keyboard/adp5588_keys.c
   3  * Description:  keypad driver for ADP5588 and ADP5587
   4  *               I2C QWERTY Keypad and IO Expander
   5  * Bugs: Enter bugs at http://blackfin.uclinux.org/
   6  *
   7  * Copyright (C) 2008-2009 Analog Devices Inc.
   8  * Licensed under the GPL-2 or later.
   9  */
  10
  11 #include <linux/module.h>
  12 #include <linux/version.h>
  13 #include <linux/init.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/irq.h>
  16 #include <linux/workqueue.h>
  17 #include <linux/errno.h>
  18 #include <linux/pm.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/input.h>
  21 #include <linux/i2c.h>
  22 #include <linux/slab.h>
  23
  24 #include <linux/i2c/adp5588.h>
  25
  26  /* Configuration Register1 */
  27 #define AUTO_INC        (1 << 7)
  28 #define GPIEM_CFG       (1 << 6)
  29 #define OVR_FLOW_M      (1 << 5)
  30 #define INT_CFG         (1 << 4)
  31 #define OVR_FLOW_IEN    (1 << 3)
  32 #define K_LCK_IM        (1 << 2)
  33 #define GPI_IEN         (1 << 1)
  34 #define KE_IEN          (1 << 0)
  35
  36 /* Interrupt Status Register */
  37 #define CMP2_INT        (1 << 5)
  38 #define CMP1_INT        (1 << 4)
  39 #define OVR_FLOW_INT    (1 << 3)
  40 #define K_LCK_INT       (1 << 2)
  41 #define GPI_INT         (1 << 1)
  42 #define KE_INT          (1 << 0)
  43
  44 /* Key Lock and Event Counter Register */
  45 #define K_LCK_EN        (1 << 6)
  46 #define LCK21           0x30
  47 #define KEC             0xF
  48
  49 /* Key Event Register xy */
  50 #define KEY_EV_PRESSED          (1 << 7)
  51 #define KEY_EV_MASK             (0x7F)
  52
  53 #define KP_SEL(x)               (0xFFFF >> (16 - x))    /* 2^x-1 */
  54
  55 #define KEYP_MAX_EVENT          10
  56
  57 /*
  58  * Early pre 4.0 Silicon required to delay readout by at least 25ms,
  59  * since the Event Counter Register updated 25ms after the interrupt
  60  * asserted.
  61  */
  62 #define WA_DELAYED_READOUT_REVID(rev)           ((rev) < 4)
  63
  64 struct adp5588_kpad {
  65         struct i2c_client *client;
  66         struct input_dev *input;
  67         struct delayed_work work;
  68         unsigned long delay;
  69         unsigned short keycode[ADP5588_KEYMAPSIZE];
  70 };
  71
  72 static int adp5588_read(struct i2c_client *client, u8 reg)
  73 {
  74         int ret = i2c_smbus_read_byte_data(client, reg);
  75
  76         if (ret < 0)
  77                 dev_err(&client->dev, "Read Error\n");
  78
  79         return ret;
  80 }
  81
  82 static int adp5588_write(struct i2c_client *client, u8 reg, u8 val)
  83 {
  84         return i2c_smbus_write_byte_data(client, reg, val);
  85 }
  86
  87 static void adp5588_work(struct work_struct *work)
  88 {
  89         struct adp5588_kpad *kpad = container_of(work,
  90                                                 struct adp5588_kpad, work.work);
  91         struct i2c_client *client = kpad->client;
  92         int i, key, status, ev_cnt;
  93
  94         status = adp5588_read(client, INT_STAT);
  95
  96         if (status & OVR_FLOW_INT)      /* Unlikely and should never happen */
  97                 dev_err(&client->dev, "Event Overflow Error\n");
  98
  99         if (status & KE_INT) {
 100                 ev_cnt = adp5588_read(client, KEY_LCK_EC_STAT) & KEC;
 101                 if (ev_cnt) {
 102                         for (i = 0; i < ev_cnt; i++) {
 103                                 key = adp5588_read(client, Key_EVENTA + i);
 104                                 input_report_key(kpad->input,
 105                                         kpad->keycode[(key & KEY_EV_MASK) - 1],
 106                                         key & KEY_EV_PRESSED);
 107                         }
 108                         input_sync(kpad->input);
 109                 }
 110         }
 111         adp5588_write(client, INT_STAT, status); /* Status is W1C */
 112 }
 113
 114 static irqreturn_t adp5588_irq(int irq, void *handle)
 115 {
 116         struct adp5588_kpad *kpad = handle;
 117
 118         /*
 119          * use keventd context to read the event fifo registers
 120          * Schedule readout at least 25ms after notification for
 121          * REVID < 4
 122          */
 123
 124         schedule_delayed_work(&kpad->work, kpad->delay);
 125
 126         return IRQ_HANDLED;
 127 }
 128
 129 static int __devinit adp5588_setup(struct i2c_client *client)
 130 {
 131         struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
 132         int i, ret;
 133
 134         ret = adp5588_write(client, KP_GPIO1, KP_SEL(pdata->rows));
 135         ret |= adp5588_write(client, KP_GPIO2, KP_SEL(pdata->cols) & 0xFF);
 136         ret |= adp5588_write(client, KP_GPIO3, KP_SEL(pdata->cols) >> 8);
 137
 138         if (pdata->en_keylock) {
 139                 ret |= adp5588_write(client, UNLOCK1, pdata->unlock_key1);
 140                 ret |= adp5588_write(client, UNLOCK2, pdata->unlock_key2);
 141                 ret |= adp5588_write(client, KEY_LCK_EC_STAT, K_LCK_EN);
 142         }
 143
 144         for (i = 0; i < KEYP_MAX_EVENT; i++)
 145                 ret |= adp5588_read(client, Key_EVENTA);
 146
 147         ret |= adp5588_write(client, INT_STAT, CMP2_INT | CMP1_INT |
 148                                         OVR_FLOW_INT | K_LCK_INT |
 149                                         GPI_INT | KE_INT); /* Status is W1C */
 150
 151         ret |= adp5588_write(client, CFG, INT_CFG | OVR_FLOW_IEN | KE_IEN);
 152
 153         if (ret < 0) {
 154                 dev_err(&client->dev, "Write Error\n");
 155                 return ret;
 156         }
 157
 158         return 0;
 159 }
 160
 161 static int __devinit adp5588_probe(struct i2c_client *client,
 162                                         const struct i2c_device_id *id)
 163 {
 164         struct adp5588_kpad *kpad;
 165         struct adp5588_kpad_platform_data *pdata = client->dev.platform_data;
 166         struct input_dev *input;
 167         unsigned int revid;
 168         int ret, i;
 169         int error;
 170
 171         if (!i2c_check_functionality(client->adapter,
 172                                         I2C_FUNC_SMBUS_BYTE_DATA)) {
 173                 dev_err(&client->dev, "SMBUS Byte Data not Supported\n");
 174                 return -EIO;
 175         }
 176
 177         if (!pdata) {
 178                 dev_err(&client->dev, "no platform data?\n");
 179                 return -EINVAL;
 180         }
 181
 182         if (!pdata->rows || !pdata->cols || !pdata->keymap) {
 183                 dev_err(&client->dev, "no rows, cols or keymap from pdata\n");
 184                 return -EINVAL;
 185         }
 186
 187         if (pdata->keymapsize != ADP5588_KEYMAPSIZE) {
 188                 dev_err(&client->dev, "invalid keymapsize\n");
 189                 return -EINVAL;
 190         }
 191
 192         if (!client->irq) {
 193                 dev_err(&client->dev, "no IRQ?\n");
 194                 return -EINVAL;
 195         }
 196
 197         kpad = kzalloc(sizeof(*kpad), GFP_KERNEL);
 198         input = input_allocate_device();
 199         if (!kpad || !input) {
 200                 error = -ENOMEM;
 201                 goto err_free_mem;
 202         }
 203
 204         kpad->client = client;
 205         kpad->input = input;
 206         INIT_DELAYED_WORK(&kpad->work, adp5588_work);
 207
 208         ret = adp5588_read(client, DEV_ID);
 209         if (ret < 0) {
 210                 error = ret;
 211                 goto err_free_mem;
 212         }
 213
 214         revid = (u8) ret & ADP5588_DEVICE_ID_MASK;
 215         if (WA_DELAYED_READOUT_REVID(revid))
 216                 kpad->delay = msecs_to_jiffies(30);
 217
 218         input->name = client->name;
 219         input->phys = "adp5588-keys/input0";
 220         input->dev.parent = &client->dev;
 221
 222         input_set_drvdata(input, kpad);
 223
 224         input->id.bustype = BUS_I2C;
 225         input->id.vendor = 0x0001;
 226         input->id.product = 0x0001;
 227         input->id.version = revid;
 228
 229         input->keycodesize = sizeof(kpad->keycode[0]);
 230         input->keycodemax = pdata->keymapsize;
 231         input->keycode = kpad->keycode;
 232
 233         memcpy(kpad->keycode, pdata->keymap,
 234                 pdata->keymapsize * input->keycodesize);
 235
 236         /* setup input device */
 237         __set_bit(EV_KEY, input->evbit);
 238
 239         if (pdata->repeat)
 240                 __set_bit(EV_REP, input->evbit);
 241
 242         for (i = 0; i < input->keycodemax; i++)
 243                 __set_bit(kpad->keycode[i] & KEY_MAX, input->keybit);
 244         __clear_bit(KEY_RESERVED, input->keybit);
 245
 246         error = input_register_device(input);
 247         if (error) {
 248                 dev_err(&client->dev, "unable to register input device\n");
 249                 goto err_free_mem;
 250         }
 251
 252         error = request_irq(client->irq, adp5588_irq,
 253                             IRQF_TRIGGER_FALLING | IRQF_DISABLED,
 254                             client->dev.driver->name, kpad);
 255         if (error) {
 256                 dev_err(&client->dev, "irq %d busy?\n", client->irq);
 257                 goto err_unreg_dev;
 258         }
 259
 260         error = adp5588_setup(client);
 261         if (error)
 262                 goto err_free_irq;
 263
 264         device_init_wakeup(&client->dev, 1);
 265         i2c_set_clientdata(client, kpad);
 266
 267         dev_info(&client->dev, "Rev.%d keypad, irq %d\n", revid, client->irq);
 268         return 0;
 269
 270  err_free_irq:
 271         free_irq(client->irq, kpad);
 272  err_unreg_dev:
 273         input_unregister_device(input);
 274         input = NULL;
 275  err_free_mem:
 276         input_free_device(input);
 277         kfree(kpad);
 278
 279         return error;
 280 }
 281
 282 static int __devexit adp5588_remove(struct i2c_client *client)
 283 {
 284         struct adp5588_kpad *kpad = i2c_get_clientdata(client);
 285
 286         adp5588_write(client, CFG, 0);
 287         free_irq(client->irq, kpad);
 288         cancel_delayed_work_sync(&kpad->work);
 289         input_unregister_device(kpad->input);
 290         i2c_set_clientdata(client, NULL);
 291         kfree(kpad);
 292
 293         return 0;
 294 }
 295
 296 #ifdef CONFIG_PM
 297 static int adp5588_suspend(struct device *dev)
 298 {
 299         struct adp5588_kpad *kpad = dev_get_drvdata(dev);
 300         struct i2c_client *client = kpad->client;
 301
 302         disable_irq(client->irq);
 303         cancel_delayed_work_sync(&kpad->work);
 304
 305         if (device_may_wakeup(&client->dev))
 306                 enable_irq_wake(client->irq);
 307
 308         return 0;
 309 }
 310
 311 static int adp5588_resume(struct device *dev)
 312 {
 313         struct adp5588_kpad *kpad = dev_get_drvdata(dev);
 314         struct i2c_client *client = kpad->client;
 315
 316         if (device_may_wakeup(&client->dev))
 317                 disable_irq_wake(client->irq);
 318
 319         enable_irq(client->irq);
 320
 321         return 0;
 322 }
 323
 324 static const struct dev_pm_ops adp5588_dev_pm_ops = {
 325         .suspend = adp5588_suspend,
 326         .resume  = adp5588_resume,
 327 };
 328 #endif
 329
 330 static const struct i2c_device_id adp5588_id[] = {
 331         { KBUILD_MODNAME, 0 },
 332         { "adp5587-keys", 0 },
 333         { }
 334 };
 335 MODULE_DEVICE_TABLE(i2c, adp5588_id);
 336
 337 static struct i2c_driver adp5588_driver = {
 338         .driver = {
 339                 .name = KBUILD_MODNAME,
 340 #ifdef CONFIG_PM
 341                 .pm   = &adp5588_dev_pm_ops,
 342 #endif
 343         },
 344         .probe    = adp5588_probe,
 345         .remove   = __devexit_p(adp5588_remove),
 346         .id_table = adp5588_id,
 347 };
 348
 349 static int __init adp5588_init(void)
 350 {
 351         return i2c_add_driver(&adp5588_driver);
 352 }
 353 module_init(adp5588_init);
 354
 355 static void __exit adp5588_exit(void)
 356 {
 357         i2c_del_driver(&adp5588_driver);
 358 }
 359 module_exit(adp5588_exit);
 360
 361 MODULE_LICENSE("GPL");
 362 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 363 MODULE_DESCRIPTION("ADP5588/87 Keypad driver");
 364 MODULE_ALIAS("platform:adp5588-keys");