drivers/input/misc/atmel_captouch.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Atmel Atmegaxx Capacitive Touch Button Driver
   4  *
   5  * Copyright (C) 2016 Google, inc.
   6  */
   7
   8 /*
   9  * It's irrelevant that the HW used to develop captouch driver is based
  10  * on Atmega88PA part and uses QtouchADC parts for sensing touch.
  11  * Calling this driver "captouch" is an arbitrary way to distinguish
  12  * the protocol this driver supported by other atmel/qtouch drivers.
  13  *
  14  * Captouch driver supports a newer/different version of the I2C
  15  * registers/commands than the qt1070.c driver.
  16  * Don't let the similarity of the general driver structure fool you.
  17  *
  18  * For raw i2c access from userspace, use i2cset/i2cget
  19  * to poke at /dev/i2c-N devices.
  20  */
  21
  22 #include <linux/device.h>
  23 #include <linux/kernel.h>
  24 #include <linux/module.h>
  25 #include <linux/init.h>
  26 #include <linux/i2c.h>
  27 #include <linux/input.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/slab.h>
  30
  31 /* Maximum number of buttons supported */
  32 #define MAX_NUM_OF_BUTTONS              8
  33
  34 /* Registers */
  35 #define REG_KEY1_THRESHOLD              0x02
  36 #define REG_KEY2_THRESHOLD              0x03
  37 #define REG_KEY3_THRESHOLD              0x04
  38 #define REG_KEY4_THRESHOLD              0x05
  39
  40 #define REG_KEY1_REF_H                  0x20
  41 #define REG_KEY1_REF_L                  0x21
  42 #define REG_KEY2_REF_H                  0x22
  43 #define REG_KEY2_REF_L                  0x23
  44 #define REG_KEY3_REF_H                  0x24
  45 #define REG_KEY3_REF_L                  0x25
  46 #define REG_KEY4_REF_H                  0x26
  47 #define REG_KEY4_REF_L                  0x27
  48
  49 #define REG_KEY1_DLT_H                  0x30
  50 #define REG_KEY1_DLT_L                  0x31
  51 #define REG_KEY2_DLT_H                  0x32
  52 #define REG_KEY2_DLT_L                  0x33
  53 #define REG_KEY3_DLT_H                  0x34
  54 #define REG_KEY3_DLT_L                  0x35
  55 #define REG_KEY4_DLT_H                  0x36
  56 #define REG_KEY4_DLT_L                  0x37
  57
  58 #define REG_KEY_STATE                   0x3C
  59
  60 /*
  61  * @i2c_client: I2C slave device client pointer
  62  * @input: Input device pointer
  63  * @num_btn: Number of buttons
  64  * @keycodes: map of button# to KeyCode
  65  * @prev_btn: Previous key state to detect button "press" or "release"
  66  * @xfer_buf: I2C transfer buffer
  67  */
  68 struct atmel_captouch_device {
  69         struct i2c_client *client;
  70         struct input_dev *input;
  71         u32 num_btn;
  72         u32 keycodes[MAX_NUM_OF_BUTTONS];
  73         u8 prev_btn;
  74         u8 xfer_buf[8] ____cacheline_aligned;
  75 };
  76
  77 /*
  78  * Read from I2C slave device
  79  * The protocol is that the client has to provide both the register address
  80  * and the length, and while reading back the device would prepend the data
  81  * with address and length for verification.
  82  */
  83 static int atmel_read(struct atmel_captouch_device *capdev,
  84                          u8 reg, u8 *data, size_t len)
  85 {
  86         struct i2c_client *client = capdev->client;
  87         struct device *dev = &client->dev;
  88         struct i2c_msg msg[2];
  89         int err;
  90
  91         if (len > sizeof(capdev->xfer_buf) - 2)
  92                 return -EINVAL;
  93
  94         capdev->xfer_buf[0] = reg;
  95         capdev->xfer_buf[1] = len;
  96
  97         msg[0].addr = client->addr;
  98         msg[0].flags = 0;
  99         msg[0].buf = capdev->xfer_buf;
 100         msg[0].len = 2;
 101
 102         msg[1].addr = client->addr;
 103         msg[1].flags = I2C_M_RD;
 104         msg[1].buf = capdev->xfer_buf;
 105         msg[1].len = len + 2;
 106
 107         err = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
 108         if (err != ARRAY_SIZE(msg))
 109                 return err < 0 ? err : -EIO;
 110
 111         if (capdev->xfer_buf[0] != reg) {
 112                 dev_err(dev,
 113                         "I2C read error: register address does not match (%#02x vs %02x)\n",
 114                         capdev->xfer_buf[0], reg);
 115                 return -ECOMM;
 116         }
 117
 118         memcpy(data, &capdev->xfer_buf[2], len);
 119
 120         return 0;
 121 }
 122
 123 /*
 124  * Handle interrupt and report the key changes to the input system.
 125  * Multi-touch can be supported; however, it really depends on whether
 126  * the device can multi-touch.
 127  */
 128 static irqreturn_t atmel_captouch_isr(int irq, void *data)
 129 {
 130         struct atmel_captouch_device *capdev = data;
 131         struct device *dev = &capdev->client->dev;
 132         int error;
 133         int i;
 134         u8 new_btn;
 135         u8 changed_btn;
 136
 137         error = atmel_read(capdev, REG_KEY_STATE, &new_btn, 1);
 138         if (error) {
 139                 dev_err(dev, "failed to read button state: %d\n", error);
 140                 goto out;
 141         }
 142
 143         dev_dbg(dev, "%s: button state %#02x\n", __func__, new_btn);
 144
 145         changed_btn = new_btn ^ capdev->prev_btn;
 146         capdev->prev_btn = new_btn;
 147
 148         for (i = 0; i < capdev->num_btn; i++) {
 149                 if (changed_btn & BIT(i))
 150                         input_report_key(capdev->input,
 151                                          capdev->keycodes[i],
 152                                          new_btn & BIT(i));
 153         }
 154
 155         input_sync(capdev->input);
 156
 157 out:
 158         return IRQ_HANDLED;
 159 }
 160
 161 /*
 162  * Probe function to setup the device, input system and interrupt
 163  */
 164 static int atmel_captouch_probe(struct i2c_client *client)
 165 {
 166         struct atmel_captouch_device *capdev;
 167         struct device *dev = &client->dev;
 168         struct device_node *node;
 169         int i;
 170         int err;
 171
 172         if (!i2c_check_functionality(client->adapter,
 173                                      I2C_FUNC_SMBUS_BYTE_DATA |
 174                                         I2C_FUNC_SMBUS_WORD_DATA |
 175                                         I2C_FUNC_SMBUS_I2C_BLOCK)) {
 176                 dev_err(dev, "needed i2c functionality is not supported\n");
 177                 return -EINVAL;
 178         }
 179
 180         capdev = devm_kzalloc(dev, sizeof(*capdev), GFP_KERNEL);
 181         if (!capdev)
 182                 return -ENOMEM;
 183
 184         capdev->client = client;
 185
 186         err = atmel_read(capdev, REG_KEY_STATE,
 187                             &capdev->prev_btn, sizeof(capdev->prev_btn));
 188         if (err) {
 189                 dev_err(dev, "failed to read initial button state: %d\n", err);
 190                 return err;
 191         }
 192
 193         capdev->input = devm_input_allocate_device(dev);
 194         if (!capdev->input) {
 195                 dev_err(dev, "failed to allocate input device\n");
 196                 return -ENOMEM;
 197         }
 198
 199         capdev->input->id.bustype = BUS_I2C;
 200         capdev->input->id.product = 0x880A;
 201         capdev->input->id.version = 0;
 202         capdev->input->name = "ATMegaXX Capacitive Button Controller";
 203         __set_bit(EV_KEY, capdev->input->evbit);
 204
 205         node = dev->of_node;
 206         if (!node) {
 207                 dev_err(dev, "failed to find matching node in device tree\n");
 208                 return -EINVAL;
 209         }
 210
 211         if (of_property_read_bool(node, "autorepeat"))
 212                 __set_bit(EV_REP, capdev->input->evbit);
 213
 214         capdev->num_btn = of_property_count_u32_elems(node, "linux,keymap");
 215         if (capdev->num_btn > MAX_NUM_OF_BUTTONS)
 216                 capdev->num_btn = MAX_NUM_OF_BUTTONS;
 217
 218         err = of_property_read_u32_array(node, "linux,keycodes",
 219                                          capdev->keycodes,
 220                                          capdev->num_btn);
 221         if (err) {
 222                 dev_err(dev,
 223                         "failed to read linux,keycode property: %d\n", err);
 224                 return err;
 225         }
 226
 227         for (i = 0; i < capdev->num_btn; i++)
 228                 __set_bit(capdev->keycodes[i], capdev->input->keybit);
 229
 230         capdev->input->keycode = capdev->keycodes;
 231         capdev->input->keycodesize = sizeof(capdev->keycodes[0]);
 232         capdev->input->keycodemax = capdev->num_btn;
 233
 234         err = input_register_device(capdev->input);
 235         if (err)
 236                 return err;
 237
 238         err = devm_request_threaded_irq(dev, client->irq,
 239                                         NULL, atmel_captouch_isr,
 240                                         IRQF_ONESHOT,
 241                                         "atmel_captouch", capdev);
 242         if (err) {
 243                 dev_err(dev, "failed to request irq %d: %d\n",
 244                         client->irq, err);
 245                 return err;
 246         }
 247
 248         return 0;
 249 }
 250
 251 static const struct of_device_id atmel_captouch_of_id[] = {
 252         {
 253                 .compatible = "atmel,captouch",
 254         },
 255         { /* sentinel */ }
 256 };
 257 MODULE_DEVICE_TABLE(of, atmel_captouch_of_id);
 258
 259 static const struct i2c_device_id atmel_captouch_id[] = {
 260         { "atmel_captouch" },
 261         { }
 262 };
 263 MODULE_DEVICE_TABLE(i2c, atmel_captouch_id);
 264
 265 static struct i2c_driver atmel_captouch_driver = {
 266         .probe          = atmel_captouch_probe,
 267         .id_table       = atmel_captouch_id,
 268         .driver         = {
 269                 .name   = "atmel_captouch",
 270                 .of_match_table = atmel_captouch_of_id,
 271         },
 272 };
 273 module_i2c_driver(atmel_captouch_driver);
 274
 275 /* Module information */
 276 MODULE_AUTHOR("Hung-yu Wu <hywu@google.com>");
 277 MODULE_DESCRIPTION("Atmel ATmegaXX Capacitance Touch Sensor I2C Driver");
 278 MODULE_LICENSE("GPL v2");