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 const struct i2c_device_id *id) 131 { 132 struct qt1070_data *data; 133 struct input_dev *input; 134 int i; 135 int err; 136 137 err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); 138 if (!err) { 139 dev_err(&client->dev, "%s adapter not supported\n", 140 dev_driver_string(&client->adapter->dev)); 141 return -ENODEV; 142 } 143 144 if (!client->irq) { 145 dev_err(&client->dev, "please assign the irq to this device\n"); 146 return -EINVAL; 147 } 148 149 /* Identify the qt1070 chip */ 150 if (!qt1070_identify(client)) 151 return -ENODEV; 152 153 data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL); 154 input = input_allocate_device(); 155 if (!data || !input) { 156 dev_err(&client->dev, "insufficient memory\n"); 157 err = -ENOMEM; 158 goto err_free_mem; 159 } 160 161 data->client = client; 162 data->input = input; 163 data->irq = client->irq; 164 165 input->name = "AT42QT1070 QTouch Sensor"; 166 input->dev.parent = &client->dev; 167 input->id.bustype = BUS_I2C; 168 169 /* Add the keycode */ 170 input->keycode = data->keycodes; 171 input->keycodesize = sizeof(data->keycodes[0]); 172 input->keycodemax = ARRAY_SIZE(qt1070_key2code); 173 174 __set_bit(EV_KEY, input->evbit); 175 176 for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) { 177 data->keycodes[i] = qt1070_key2code[i]; 178 __set_bit(qt1070_key2code[i], input->keybit); 179 } 180 181 /* Calibrate device */ 182 qt1070_write(client, CALIBRATE_CMD, 1); 183 msleep(QT1070_CAL_TIME); 184 185 /* Soft reset */ 186 qt1070_write(client, RESET, 1); 187 msleep(QT1070_RESET_TIME); 188 189 err = request_threaded_irq(client->irq, 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 goto err_free_mem; 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 goto err_free_irq; 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 err_free_irq: 212 free_irq(client->irq, data); 213 err_free_mem: 214 input_free_device(input); 215 kfree(data); 216 return err; 217 } 218 219 static int qt1070_remove(struct i2c_client *client) 220 { 221 struct qt1070_data *data = i2c_get_clientdata(client); 222 223 /* Release IRQ */ 224 free_irq(client->irq, data); 225 226 input_unregister_device(data->input); 227 kfree(data); 228 229 return 0; 230 } 231 232 #ifdef CONFIG_PM_SLEEP 233 static int qt1070_suspend(struct device *dev) 234 { 235 struct i2c_client *client = to_i2c_client(dev); 236 struct qt1070_data *data = i2c_get_clientdata(client); 237 238 if (device_may_wakeup(dev)) 239 enable_irq_wake(data->irq); 240 241 return 0; 242 } 243 244 static int qt1070_resume(struct device *dev) 245 { 246 struct i2c_client *client = to_i2c_client(dev); 247 struct qt1070_data *data = i2c_get_clientdata(client); 248 249 if (device_may_wakeup(dev)) 250 disable_irq_wake(data->irq); 251 252 return 0; 253 } 254 #endif 255 256 static SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume); 257 258 static const struct i2c_device_id qt1070_id[] = { 259 { "qt1070", 0 }, 260 { }, 261 }; 262 MODULE_DEVICE_TABLE(i2c, qt1070_id); 263 264 #ifdef CONFIG_OF 265 static const struct of_device_id qt1070_of_match[] = { 266 { .compatible = "qt1070", }, 267 { }, 268 }; 269 MODULE_DEVICE_TABLE(of, qt1070_of_match); 270 #endif 271 272 static struct i2c_driver qt1070_driver = { 273 .driver = { 274 .name = "qt1070", 275 .of_match_table = of_match_ptr(qt1070_of_match), 276 .pm = &qt1070_pm_ops, 277 }, 278 .id_table = qt1070_id, 279 .probe = qt1070_probe, 280 .remove = qt1070_remove, 281 }; 282 283 module_i2c_driver(qt1070_driver); 284 285 MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>"); 286 MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor"); 287 MODULE_LICENSE("GPL"); 288