drivers/input/keyboard/lm8333.c

   1 /*
   2  * LM8333 keypad driver
   3  * Copyright (C) 2012 Wolfram Sang, Pengutronix <w.sang@pengutronix.de>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License.
   8  */
   9
  10 #include <linux/module.h>
  11 #include <linux/slab.h>
  12 #include <linux/irq.h>
  13 #include <linux/i2c.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/input/matrix_keypad.h>
  16 #include <linux/input/lm8333.h>
  17
  18 #define LM8333_FIFO_READ                0x20
  19 #define LM8333_DEBOUNCE                 0x22
  20 #define LM8333_READ_INT                 0xD0
  21 #define LM8333_ACTIVE                   0xE4
  22 #define LM8333_READ_ERROR               0xF0
  23
  24 #define LM8333_KEYPAD_IRQ               (1 << 0)
  25 #define LM8333_ERROR_IRQ                (1 << 3)
  26
  27 #define LM8333_ERROR_KEYOVR             0x04
  28 #define LM8333_ERROR_FIFOOVR            0x40
  29
  30 #define LM8333_FIFO_TRANSFER_SIZE       16
  31
  32 #define LM8333_NUM_ROWS         8
  33 #define LM8333_NUM_COLS         16
  34 #define LM8333_ROW_SHIFT        4
  35
  36 struct lm8333 {
  37         struct i2c_client *client;
  38         struct input_dev *input;
  39         unsigned short keycodes[LM8333_NUM_ROWS << LM8333_ROW_SHIFT];
  40 };
  41
  42 /* The accessors try twice because the first access may be needed for wakeup */
  43 #define LM8333_READ_RETRIES 2
  44
  45 int lm8333_read8(struct lm8333 *lm8333, u8 cmd)
  46 {
  47         int retries = 0, ret;
  48
  49         do {
  50                 ret = i2c_smbus_read_byte_data(lm8333->client, cmd);
  51         } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  52
  53         return ret;
  54 }
  55
  56 int lm8333_write8(struct lm8333 *lm8333, u8 cmd, u8 val)
  57 {
  58         int retries = 0, ret;
  59
  60         do {
  61                 ret = i2c_smbus_write_byte_data(lm8333->client, cmd, val);
  62         } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  63
  64         return ret;
  65 }
  66
  67 int lm8333_read_block(struct lm8333 *lm8333, u8 cmd, u8 len, u8 *buf)
  68 {
  69         int retries = 0, ret;
  70
  71         do {
  72                 ret = i2c_smbus_read_i2c_block_data(lm8333->client,
  73                                                     cmd, len, buf);
  74         } while (ret < 0 && retries++ < LM8333_READ_RETRIES);
  75
  76         return ret;
  77 }
  78
  79 static void lm8333_key_handler(struct lm8333 *lm8333)
  80 {
  81         struct input_dev *input = lm8333->input;
  82         u8 keys[LM8333_FIFO_TRANSFER_SIZE];
  83         u8 code, pressed;
  84         int i, ret;
  85
  86         ret = lm8333_read_block(lm8333, LM8333_FIFO_READ,
  87                                 LM8333_FIFO_TRANSFER_SIZE, keys);
  88         if (ret != LM8333_FIFO_TRANSFER_SIZE) {
  89                 dev_err(&lm8333->client->dev,
  90                         "Error %d while reading FIFO\n", ret);
  91                 return;
  92         }
  93
  94         for (i = 0; i < LM8333_FIFO_TRANSFER_SIZE && keys[i]; i++) {
  95                 pressed = keys[i] & 0x80;
  96                 code = keys[i] & 0x7f;
  97
  98                 input_event(input, EV_MSC, MSC_SCAN, code);
  99                 input_report_key(input, lm8333->keycodes[code], pressed);
 100         }
 101
 102         input_sync(input);
 103 }
 104
 105 static irqreturn_t lm8333_irq_thread(int irq, void *data)
 106 {
 107         struct lm8333 *lm8333 = data;
 108         u8 status = lm8333_read8(lm8333, LM8333_READ_INT);
 109
 110         if (!status)
 111                 return IRQ_NONE;
 112
 113         if (status & LM8333_ERROR_IRQ) {
 114                 u8 err = lm8333_read8(lm8333, LM8333_READ_ERROR);
 115
 116                 if (err & (LM8333_ERROR_KEYOVR | LM8333_ERROR_FIFOOVR)) {
 117                         u8 dummy[LM8333_FIFO_TRANSFER_SIZE];
 118
 119                         lm8333_read_block(lm8333, LM8333_FIFO_READ,
 120                                         LM8333_FIFO_TRANSFER_SIZE, dummy);
 121                 }
 122                 dev_err(&lm8333->client->dev, "Got error %02x\n", err);
 123         }
 124
 125         if (status & LM8333_KEYPAD_IRQ)
 126                 lm8333_key_handler(lm8333);
 127
 128         return IRQ_HANDLED;
 129 }
 130
 131 static int lm8333_probe(struct i2c_client *client,
 132                                   const struct i2c_device_id *id)
 133 {
 134         const struct lm8333_platform_data *pdata = client->dev.platform_data;
 135         struct lm8333 *lm8333;
 136         struct input_dev *input;
 137         int err, active_time;
 138
 139         if (!pdata)
 140                 return -EINVAL;
 141
 142         active_time = pdata->active_time ?: 500;
 143         if (active_time / 3 <= pdata->debounce_time / 3) {
 144                 dev_err(&client->dev, "Active time not big enough!\n");
 145                 return -EINVAL;
 146         }
 147
 148         lm8333 = kzalloc(sizeof(*lm8333), GFP_KERNEL);
 149         input = input_allocate_device();
 150         if (!lm8333 || !input) {
 151                 err = -ENOMEM;
 152                 goto free_mem;
 153         }
 154
 155         lm8333->client = client;
 156         lm8333->input = input;
 157
 158         input->name = client->name;
 159         input->dev.parent = &client->dev;
 160         input->id.bustype = BUS_I2C;
 161
 162         input_set_capability(input, EV_MSC, MSC_SCAN);
 163
 164         err = matrix_keypad_build_keymap(pdata->matrix_data, NULL,
 165                                          LM8333_NUM_ROWS, LM8333_NUM_COLS,
 166                                          lm8333->keycodes, input);
 167         if (err)
 168                 goto free_mem;
 169
 170         if (pdata->debounce_time) {
 171                 err = lm8333_write8(lm8333, LM8333_DEBOUNCE,
 172                                     pdata->debounce_time / 3);
 173                 if (err)
 174                         dev_warn(&client->dev, "Unable to set debounce time\n");
 175         }
 176
 177         if (pdata->active_time) {
 178                 err = lm8333_write8(lm8333, LM8333_ACTIVE,
 179                                     pdata->active_time / 3);
 180                 if (err)
 181                         dev_warn(&client->dev, "Unable to set active time\n");
 182         }
 183
 184         err = request_threaded_irq(client->irq, NULL, lm8333_irq_thread,
 185                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 186                                    "lm8333", lm8333);
 187         if (err)
 188                 goto free_mem;
 189
 190         err = input_register_device(input);
 191         if (err)
 192                 goto free_irq;
 193
 194         i2c_set_clientdata(client, lm8333);
 195         return 0;
 196
 197  free_irq:
 198         free_irq(client->irq, lm8333);
 199  free_mem:
 200         input_free_device(input);
 201         kfree(lm8333);
 202         return err;
 203 }
 204
 205 static int lm8333_remove(struct i2c_client *client)
 206 {
 207         struct lm8333 *lm8333 = i2c_get_clientdata(client);
 208
 209         free_irq(client->irq, lm8333);
 210         input_unregister_device(lm8333->input);
 211         kfree(lm8333);
 212
 213         return 0;
 214 }
 215
 216 static const struct i2c_device_id lm8333_id[] = {
 217         { "lm8333", 0 },
 218         { }
 219 };
 220 MODULE_DEVICE_TABLE(i2c, lm8333_id);
 221
 222 static struct i2c_driver lm8333_driver = {
 223         .driver = {
 224                 .name           = "lm8333",
 225                 .owner          = THIS_MODULE,
 226         },
 227         .probe          = lm8333_probe,
 228         .remove         = lm8333_remove,
 229         .id_table       = lm8333_id,
 230 };
 231 module_i2c_driver(lm8333_driver);
 232
 233 MODULE_AUTHOR("Wolfram Sang <w.sang@pengutronix.de>");
 234 MODULE_DESCRIPTION("LM8333 keyboard driver");
 235 MODULE_LICENSE("GPL v2");