1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * qt2160.c - Atmel AT42QT2160 Touch Sense Controller 4 * 5 * Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com> 6 */ 7 8 #include <linux/kernel.h> 9 #include <linux/leds.h> 10 #include <linux/module.h> 11 #include <linux/slab.h> 12 #include <linux/jiffies.h> 13 #include <linux/i2c.h> 14 #include <linux/irq.h> 15 #include <linux/interrupt.h> 16 #include <linux/input.h> 17 18 #define QT2160_VALID_CHIPID 0x11 19 20 #define QT2160_CMD_CHIPID 0 21 #define QT2160_CMD_CODEVER 1 22 #define QT2160_CMD_GSTAT 2 23 #define QT2160_CMD_KEYS3 3 24 #define QT2160_CMD_KEYS4 4 25 #define QT2160_CMD_SLIDE 5 26 #define QT2160_CMD_GPIOS 6 27 #define QT2160_CMD_SUBVER 7 28 #define QT2160_CMD_CALIBRATE 10 29 #define QT2160_CMD_DRIVE_X 70 30 #define QT2160_CMD_PWMEN_X 74 31 #define QT2160_CMD_PWM_DUTY 76 32 33 #define QT2160_NUM_LEDS_X 8 34 35 #define QT2160_CYCLE_INTERVAL (2*HZ) 36 37 static unsigned char qt2160_key2code[] = { 38 KEY_0, KEY_1, KEY_2, KEY_3, 39 KEY_4, KEY_5, KEY_6, KEY_7, 40 KEY_8, KEY_9, KEY_A, KEY_B, 41 KEY_C, KEY_D, KEY_E, KEY_F, 42 }; 43 44 #ifdef CONFIG_LEDS_CLASS 45 struct qt2160_led { 46 struct qt2160_data *qt2160; 47 struct led_classdev cdev; 48 char name[32]; 49 int id; 50 enum led_brightness brightness; 51 }; 52 #endif 53 54 struct qt2160_data { 55 struct i2c_client *client; 56 struct input_dev *input; 57 struct delayed_work dwork; 58 unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)]; 59 u16 key_matrix; 60 #ifdef CONFIG_LEDS_CLASS 61 struct qt2160_led leds[QT2160_NUM_LEDS_X]; 62 #endif 63 }; 64 65 static int qt2160_read(struct i2c_client *client, u8 reg); 66 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data); 67 68 #ifdef CONFIG_LEDS_CLASS 69 70 static int qt2160_led_set(struct led_classdev *cdev, 71 enum led_brightness value) 72 { 73 struct qt2160_led *led = container_of(cdev, struct qt2160_led, cdev); 74 struct qt2160_data *qt2160 = led->qt2160; 75 struct i2c_client *client = qt2160->client; 76 u32 drive, pwmen; 77 78 if (value != led->brightness) { 79 drive = qt2160_read(client, QT2160_CMD_DRIVE_X); 80 pwmen = qt2160_read(client, QT2160_CMD_PWMEN_X); 81 if (value != LED_OFF) { 82 drive |= BIT(led->id); 83 pwmen |= BIT(led->id); 84 85 } else { 86 drive &= ~BIT(led->id); 87 pwmen &= ~BIT(led->id); 88 } 89 qt2160_write(client, QT2160_CMD_DRIVE_X, drive); 90 qt2160_write(client, QT2160_CMD_PWMEN_X, pwmen); 91 92 /* 93 * Changing this register will change the brightness 94 * of every LED in the qt2160. It's a HW limitation. 95 */ 96 if (value != LED_OFF) 97 qt2160_write(client, QT2160_CMD_PWM_DUTY, value); 98 99 led->brightness = value; 100 } 101 102 return 0; 103 } 104 105 #endif /* CONFIG_LEDS_CLASS */ 106 107 static int qt2160_read_block(struct i2c_client *client, 108 u8 inireg, u8 *buffer, unsigned int count) 109 { 110 int error, idx = 0; 111 112 /* 113 * Can't use SMBus block data read. Check for I2C functionality to speed 114 * things up whenever possible. Otherwise we will be forced to read 115 * sequentially. 116 */ 117 if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 118 119 error = i2c_smbus_write_byte(client, inireg + idx); 120 if (error) { 121 dev_err(&client->dev, 122 "couldn't send request. Returned %d\n", error); 123 return error; 124 } 125 126 error = i2c_master_recv(client, buffer, count); 127 if (error != count) { 128 dev_err(&client->dev, 129 "couldn't read registers. Returned %d bytes\n", error); 130 return error; 131 } 132 } else { 133 134 while (count--) { 135 int data; 136 137 error = i2c_smbus_write_byte(client, inireg + idx); 138 if (error) { 139 dev_err(&client->dev, 140 "couldn't send request. Returned %d\n", error); 141 return error; 142 } 143 144 data = i2c_smbus_read_byte(client); 145 if (data < 0) { 146 dev_err(&client->dev, 147 "couldn't read register. Returned %d\n", data); 148 return data; 149 } 150 151 buffer[idx++] = data; 152 } 153 } 154 155 return 0; 156 } 157 158 static int qt2160_get_key_matrix(struct qt2160_data *qt2160) 159 { 160 struct i2c_client *client = qt2160->client; 161 struct input_dev *input = qt2160->input; 162 u8 regs[6]; 163 u16 old_matrix, new_matrix; 164 int ret, i, mask; 165 166 dev_dbg(&client->dev, "requesting keys...\n"); 167 168 /* 169 * Read all registers from General Status Register 170 * to GPIOs register 171 */ 172 ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6); 173 if (ret) { 174 dev_err(&client->dev, 175 "could not perform chip read.\n"); 176 return ret; 177 } 178 179 old_matrix = qt2160->key_matrix; 180 qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1]; 181 182 mask = 0x01; 183 for (i = 0; i < 16; ++i, mask <<= 1) { 184 int keyval = new_matrix & mask; 185 186 if ((old_matrix & mask) != keyval) { 187 input_report_key(input, qt2160->keycodes[i], keyval); 188 dev_dbg(&client->dev, "key %d %s\n", 189 i, keyval ? "pressed" : "released"); 190 } 191 } 192 193 input_sync(input); 194 195 return 0; 196 } 197 198 static irqreturn_t qt2160_irq(int irq, void *_qt2160) 199 { 200 struct qt2160_data *qt2160 = _qt2160; 201 202 mod_delayed_work(system_wq, &qt2160->dwork, 0); 203 204 return IRQ_HANDLED; 205 } 206 207 static void qt2160_schedule_read(struct qt2160_data *qt2160) 208 { 209 schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL); 210 } 211 212 static void qt2160_worker(struct work_struct *work) 213 { 214 struct qt2160_data *qt2160 = 215 container_of(work, struct qt2160_data, dwork.work); 216 217 dev_dbg(&qt2160->client->dev, "worker\n"); 218 219 qt2160_get_key_matrix(qt2160); 220 221 /* Avoid device lock up by checking every so often */ 222 qt2160_schedule_read(qt2160); 223 } 224 225 static int qt2160_read(struct i2c_client *client, u8 reg) 226 { 227 int ret; 228 229 ret = i2c_smbus_write_byte(client, reg); 230 if (ret) { 231 dev_err(&client->dev, 232 "couldn't send request. Returned %d\n", ret); 233 return ret; 234 } 235 236 ret = i2c_smbus_read_byte(client); 237 if (ret < 0) { 238 dev_err(&client->dev, 239 "couldn't read register. Returned %d\n", ret); 240 return ret; 241 } 242 243 return ret; 244 } 245 246 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data) 247 { 248 int ret; 249 250 ret = i2c_smbus_write_byte_data(client, reg, data); 251 if (ret < 0) 252 dev_err(&client->dev, 253 "couldn't write data. Returned %d\n", ret); 254 255 return ret; 256 } 257 258 #ifdef CONFIG_LEDS_CLASS 259 260 static int qt2160_register_leds(struct qt2160_data *qt2160) 261 { 262 struct i2c_client *client = qt2160->client; 263 int ret; 264 int i; 265 266 for (i = 0; i < QT2160_NUM_LEDS_X; i++) { 267 struct qt2160_led *led = &qt2160->leds[i]; 268 269 snprintf(led->name, sizeof(led->name), "qt2160:x%d", i); 270 led->cdev.name = led->name; 271 led->cdev.brightness_set_blocking = qt2160_led_set; 272 led->cdev.brightness = LED_OFF; 273 led->id = i; 274 led->qt2160 = qt2160; 275 276 ret = led_classdev_register(&client->dev, &led->cdev); 277 if (ret < 0) 278 return ret; 279 } 280 281 /* Tur off LEDs */ 282 qt2160_write(client, QT2160_CMD_DRIVE_X, 0); 283 qt2160_write(client, QT2160_CMD_PWMEN_X, 0); 284 qt2160_write(client, QT2160_CMD_PWM_DUTY, 0); 285 286 return 0; 287 } 288 289 static void qt2160_unregister_leds(struct qt2160_data *qt2160) 290 { 291 int i; 292 293 for (i = 0; i < QT2160_NUM_LEDS_X; i++) 294 led_classdev_unregister(&qt2160->leds[i].cdev); 295 } 296 297 #else 298 299 static inline int qt2160_register_leds(struct qt2160_data *qt2160) 300 { 301 return 0; 302 } 303 304 static inline void qt2160_unregister_leds(struct qt2160_data *qt2160) 305 { 306 } 307 308 #endif 309 310 static bool qt2160_identify(struct i2c_client *client) 311 { 312 int id, ver, rev; 313 314 /* Read Chid ID to check if chip is valid */ 315 id = qt2160_read(client, QT2160_CMD_CHIPID); 316 if (id != QT2160_VALID_CHIPID) { 317 dev_err(&client->dev, "ID %d not supported\n", id); 318 return false; 319 } 320 321 /* Read chip firmware version */ 322 ver = qt2160_read(client, QT2160_CMD_CODEVER); 323 if (ver < 0) { 324 dev_err(&client->dev, "could not get firmware version\n"); 325 return false; 326 } 327 328 /* Read chip firmware revision */ 329 rev = qt2160_read(client, QT2160_CMD_SUBVER); 330 if (rev < 0) { 331 dev_err(&client->dev, "could not get firmware revision\n"); 332 return false; 333 } 334 335 dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n", 336 ver >> 4, ver & 0xf, rev); 337 338 return true; 339 } 340 341 static int qt2160_probe(struct i2c_client *client, 342 const struct i2c_device_id *id) 343 { 344 struct qt2160_data *qt2160; 345 struct input_dev *input; 346 int i; 347 int error; 348 349 /* Check functionality */ 350 error = i2c_check_functionality(client->adapter, 351 I2C_FUNC_SMBUS_BYTE); 352 if (!error) { 353 dev_err(&client->dev, "%s adapter not supported\n", 354 dev_driver_string(&client->adapter->dev)); 355 return -ENODEV; 356 } 357 358 if (!qt2160_identify(client)) 359 return -ENODEV; 360 361 /* Chip is valid and active. Allocate structure */ 362 qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL); 363 input = input_allocate_device(); 364 if (!qt2160 || !input) { 365 dev_err(&client->dev, "insufficient memory\n"); 366 error = -ENOMEM; 367 goto err_free_mem; 368 } 369 370 qt2160->client = client; 371 qt2160->input = input; 372 INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker); 373 374 input->name = "AT42QT2160 Touch Sense Keyboard"; 375 input->id.bustype = BUS_I2C; 376 377 input->keycode = qt2160->keycodes; 378 input->keycodesize = sizeof(qt2160->keycodes[0]); 379 input->keycodemax = ARRAY_SIZE(qt2160_key2code); 380 381 __set_bit(EV_KEY, input->evbit); 382 __clear_bit(EV_REP, input->evbit); 383 for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) { 384 qt2160->keycodes[i] = qt2160_key2code[i]; 385 __set_bit(qt2160_key2code[i], input->keybit); 386 } 387 __clear_bit(KEY_RESERVED, input->keybit); 388 389 /* Calibrate device */ 390 error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1); 391 if (error) { 392 dev_err(&client->dev, "failed to calibrate device\n"); 393 goto err_free_mem; 394 } 395 396 if (client->irq) { 397 error = request_irq(client->irq, qt2160_irq, 398 IRQF_TRIGGER_FALLING, "qt2160", qt2160); 399 if (error) { 400 dev_err(&client->dev, 401 "failed to allocate irq %d\n", client->irq); 402 goto err_free_mem; 403 } 404 } 405 406 error = qt2160_register_leds(qt2160); 407 if (error) { 408 dev_err(&client->dev, "Failed to register leds\n"); 409 goto err_free_irq; 410 } 411 412 error = input_register_device(qt2160->input); 413 if (error) { 414 dev_err(&client->dev, 415 "Failed to register input device\n"); 416 goto err_unregister_leds; 417 } 418 419 i2c_set_clientdata(client, qt2160); 420 qt2160_schedule_read(qt2160); 421 422 return 0; 423 424 err_unregister_leds: 425 qt2160_unregister_leds(qt2160); 426 err_free_irq: 427 if (client->irq) 428 free_irq(client->irq, qt2160); 429 err_free_mem: 430 input_free_device(input); 431 kfree(qt2160); 432 return error; 433 } 434 435 static int qt2160_remove(struct i2c_client *client) 436 { 437 struct qt2160_data *qt2160 = i2c_get_clientdata(client); 438 439 qt2160_unregister_leds(qt2160); 440 441 /* Release IRQ so no queue will be scheduled */ 442 if (client->irq) 443 free_irq(client->irq, qt2160); 444 445 cancel_delayed_work_sync(&qt2160->dwork); 446 447 input_unregister_device(qt2160->input); 448 kfree(qt2160); 449 450 return 0; 451 } 452 453 static const struct i2c_device_id qt2160_idtable[] = { 454 { "qt2160", 0, }, 455 { } 456 }; 457 458 MODULE_DEVICE_TABLE(i2c, qt2160_idtable); 459 460 static struct i2c_driver qt2160_driver = { 461 .driver = { 462 .name = "qt2160", 463 }, 464 465 .id_table = qt2160_idtable, 466 .probe = qt2160_probe, 467 .remove = qt2160_remove, 468 }; 469 470 module_i2c_driver(qt2160_driver); 471 472 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>"); 473 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor"); 474 MODULE_LICENSE("GPL"); 475