drivers/input/keyboard/qt1070.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  *  Atmel AT42QT1070 QTouch Sensor Controller
   4  *
   5  *  Copyright (C) 2011 Atmel
   6  *
   7  *  Authors: Bo Shen <voice.shen@atmel.com>
   8  *
   9  *  Base on AT42QT2160 driver by:
  10  *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
  11  *  Copyright (C) 2009
  12  */
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/i2c.h>
  16 #include <linux/input.h>
  17 #include <linux/slab.h>
  18 #include <linux/irq.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/jiffies.h>
  21 #include <linux/delay.h>
  22
  23 /* Address for each register */
  24 #define CHIP_ID            0x00
  25 #define QT1070_CHIP_ID     0x2E
  26
  27 #define FW_VERSION         0x01
  28 #define QT1070_FW_VERSION  0x15
  29
  30 #define DET_STATUS         0x02
  31
  32 #define KEY_STATUS         0x03
  33
  34 /* Calibrate */
  35 #define CALIBRATE_CMD      0x38
  36 #define QT1070_CAL_TIME    200
  37
  38 /* Reset */
  39 #define RESET              0x39
  40 #define QT1070_RESET_TIME  255
  41
  42 /* AT42QT1070 support up to 7 keys */
  43 static const unsigned short qt1070_key2code[] = {
  44         KEY_0, KEY_1, KEY_2, KEY_3,
  45         KEY_4, KEY_5, KEY_6,
  46 };
  47
  48 struct qt1070_data {
  49         struct i2c_client *client;
  50         struct input_dev *input;
  51         unsigned int irq;
  52         unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
  53         u8 last_keys;
  54 };
  55
  56 static int qt1070_read(struct i2c_client *client, u8 reg)
  57 {
  58         int ret;
  59
  60         ret = i2c_smbus_read_byte_data(client, reg);
  61         if (ret < 0)
  62                 dev_err(&client->dev,
  63                         "can not read register, returned %d\n", ret);
  64
  65         return ret;
  66 }
  67
  68 static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
  69 {
  70         int ret;
  71
  72         ret = i2c_smbus_write_byte_data(client, reg, data);
  73         if (ret < 0)
  74                 dev_err(&client->dev,
  75                         "can not write register, returned %d\n", ret);
  76
  77         return ret;
  78 }
  79
  80 static bool qt1070_identify(struct i2c_client *client)
  81 {
  82         int id, ver;
  83
  84         /* Read Chip ID */
  85         id = qt1070_read(client, CHIP_ID);
  86         if (id != QT1070_CHIP_ID) {
  87                 dev_err(&client->dev, "ID %d not supported\n", id);
  88                 return false;
  89         }
  90
  91         /* Read firmware version */
  92         ver = qt1070_read(client, FW_VERSION);
  93         if (ver < 0) {
  94                 dev_err(&client->dev, "could not read the firmware version\n");
  95                 return false;
  96         }
  97
  98         dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver);
  99
 100         return true;
 101 }
 102
 103 static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
 104 {
 105         struct qt1070_data *data = dev_id;
 106         struct i2c_client *client = data->client;
 107         struct input_dev *input = data->input;
 108         int i;
 109         u8 new_keys, keyval, mask = 0x01;
 110
 111         /* Read the detected status register, thus clearing interrupt */
 112         qt1070_read(client, DET_STATUS);
 113
 114         /* Read which key changed */
 115         new_keys = qt1070_read(client, KEY_STATUS);
 116
 117         for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
 118                 keyval = new_keys & mask;
 119                 if ((data->last_keys & mask) != keyval)
 120                         input_report_key(input, data->keycodes[i], keyval);
 121                 mask <<= 1;
 122         }
 123         input_sync(input);
 124
 125         data->last_keys = new_keys;
 126         return IRQ_HANDLED;
 127 }
 128
 129 static int qt1070_probe(struct i2c_client *client)
 130 {
 131         struct qt1070_data *data;
 132         struct input_dev *input;
 133         int i;
 134         int err;
 135
 136         err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
 137         if (!err) {
 138                 dev_err(&client->dev, "%s adapter not supported\n",
 139                         dev_driver_string(&client->adapter->dev));
 140                 return -ENODEV;
 141         }
 142
 143         if (!client->irq) {
 144                 dev_err(&client->dev, "please assign the irq to this device\n");
 145                 return -EINVAL;
 146         }
 147
 148         /* Identify the qt1070 chip */
 149         if (!qt1070_identify(client))
 150                 return -ENODEV;
 151
 152         data = devm_kzalloc(&client->dev, sizeof(struct qt1070_data),
 153                             GFP_KERNEL);
 154         if (!data)
 155                 return -ENOMEM;
 156
 157         input = devm_input_allocate_device(&client->dev);
 158         if (!input)
 159                 return -ENOMEM;
 160
 161         data->client = client;
 162         data->input = input;
 163         data->irq = client->irq;
 164
 165         input->name = "AT42QT1070 QTouch Sensor";
 166         input->id.bustype = BUS_I2C;
 167
 168         /* Add the keycode */
 169         input->keycode = data->keycodes;
 170         input->keycodesize = sizeof(data->keycodes[0]);
 171         input->keycodemax = ARRAY_SIZE(qt1070_key2code);
 172
 173         __set_bit(EV_KEY, input->evbit);
 174
 175         for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
 176                 data->keycodes[i] = qt1070_key2code[i];
 177                 __set_bit(qt1070_key2code[i], input->keybit);
 178         }
 179
 180         /* Calibrate device */
 181         qt1070_write(client, CALIBRATE_CMD, 1);
 182         msleep(QT1070_CAL_TIME);
 183
 184         /* Soft reset */
 185         qt1070_write(client, RESET, 1);
 186         msleep(QT1070_RESET_TIME);
 187
 188         err = devm_request_threaded_irq(&client->dev, client->irq,
 189                                         NULL, qt1070_interrupt,
 190                                         IRQF_TRIGGER_NONE | IRQF_ONESHOT,
 191                                         client->dev.driver->name, data);
 192         if (err) {
 193                 dev_err(&client->dev, "fail to request irq\n");
 194                 return err;
 195         }
 196
 197         /* Register the input device */
 198         err = input_register_device(data->input);
 199         if (err) {
 200                 dev_err(&client->dev, "Failed to register input device\n");
 201                 return err;
 202         }
 203
 204         i2c_set_clientdata(client, data);
 205
 206         /* Read to clear the chang line */
 207         qt1070_read(client, DET_STATUS);
 208
 209         return 0;
 210 }
 211
 212 static int qt1070_suspend(struct device *dev)
 213 {
 214         struct i2c_client *client = to_i2c_client(dev);
 215         struct qt1070_data *data = i2c_get_clientdata(client);
 216
 217         if (device_may_wakeup(dev))
 218                 enable_irq_wake(data->irq);
 219
 220         return 0;
 221 }
 222
 223 static int qt1070_resume(struct device *dev)
 224 {
 225         struct i2c_client *client = to_i2c_client(dev);
 226         struct qt1070_data *data = i2c_get_clientdata(client);
 227
 228         if (device_may_wakeup(dev))
 229                 disable_irq_wake(data->irq);
 230
 231         return 0;
 232 }
 233
 234 static DEFINE_SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume);
 235
 236 static const struct i2c_device_id qt1070_id[] = {
 237         { "qt1070" },
 238         { }
 239 };
 240 MODULE_DEVICE_TABLE(i2c, qt1070_id);
 241
 242 #ifdef CONFIG_OF
 243 static const struct of_device_id qt1070_of_match[] = {
 244         { .compatible = "qt1070", },
 245         { },
 246 };
 247 MODULE_DEVICE_TABLE(of, qt1070_of_match);
 248 #endif
 249
 250 static struct i2c_driver qt1070_driver = {
 251         .driver = {
 252                 .name   = "qt1070",
 253                 .of_match_table = of_match_ptr(qt1070_of_match),
 254                 .pm     = pm_sleep_ptr(&qt1070_pm_ops),
 255         },
 256         .id_table       = qt1070_id,
 257         .probe          = qt1070_probe,
 258 };
 259
 260 module_i2c_driver(qt1070_driver);
 261
 262 MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
 263 MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
 264 MODULE_LICENSE("GPL");