drivers/input/keyboard/lm8333.c

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