1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Microchip AT42QT1050 QTouch Sensor Controller 4 * 5 * Copyright (C) 2019 Pengutronix, Marco Felsch <kernel@pengutronix.de> 6 * 7 * Base on AT42QT1070 driver by: 8 * Bo Shen <voice.shen@atmel.com> 9 * Copyright (C) 2011 Atmel 10 */ 11 12 #include <linux/delay.h> 13 #include <linux/i2c.h> 14 #include <linux/input.h> 15 #include <linux/interrupt.h> 16 #include <linux/kernel.h> 17 #include <linux/log2.h> 18 #include <linux/module.h> 19 #include <linux/of.h> 20 #include <linux/regmap.h> 21 22 /* Chip ID */ 23 #define QT1050_CHIP_ID 0x00 24 #define QT1050_CHIP_ID_VER 0x46 25 26 /* Firmware version */ 27 #define QT1050_FW_VERSION 0x01 28 29 /* Detection status */ 30 #define QT1050_DET_STATUS 0x02 31 32 /* Key status */ 33 #define QT1050_KEY_STATUS 0x03 34 35 /* Key Signals */ 36 #define QT1050_KEY_SIGNAL_0_MSB 0x06 37 #define QT1050_KEY_SIGNAL_0_LSB 0x07 38 #define QT1050_KEY_SIGNAL_1_MSB 0x08 39 #define QT1050_KEY_SIGNAL_1_LSB 0x09 40 #define QT1050_KEY_SIGNAL_2_MSB 0x0c 41 #define QT1050_KEY_SIGNAL_2_LSB 0x0d 42 #define QT1050_KEY_SIGNAL_3_MSB 0x0e 43 #define QT1050_KEY_SIGNAL_3_LSB 0x0f 44 #define QT1050_KEY_SIGNAL_4_MSB 0x10 45 #define QT1050_KEY_SIGNAL_4_LSB 0x11 46 47 /* Reference data */ 48 #define QT1050_REF_DATA_0_MSB 0x14 49 #define QT1050_REF_DATA_0_LSB 0x15 50 #define QT1050_REF_DATA_1_MSB 0x16 51 #define QT1050_REF_DATA_1_LSB 0x17 52 #define QT1050_REF_DATA_2_MSB 0x1a 53 #define QT1050_REF_DATA_2_LSB 0x1b 54 #define QT1050_REF_DATA_3_MSB 0x1c 55 #define QT1050_REF_DATA_3_LSB 0x1d 56 #define QT1050_REF_DATA_4_MSB 0x1e 57 #define QT1050_REF_DATA_4_LSB 0x1f 58 59 /* Negative threshold level */ 60 #define QT1050_NTHR_0 0x21 61 #define QT1050_NTHR_1 0x22 62 #define QT1050_NTHR_2 0x24 63 #define QT1050_NTHR_3 0x25 64 #define QT1050_NTHR_4 0x26 65 66 /* Pulse / Scale */ 67 #define QT1050_PULSE_SCALE_0 0x28 68 #define QT1050_PULSE_SCALE_1 0x29 69 #define QT1050_PULSE_SCALE_2 0x2b 70 #define QT1050_PULSE_SCALE_3 0x2c 71 #define QT1050_PULSE_SCALE_4 0x2d 72 73 /* Detection integrator counter / AKS */ 74 #define QT1050_DI_AKS_0 0x2f 75 #define QT1050_DI_AKS_1 0x30 76 #define QT1050_DI_AKS_2 0x32 77 #define QT1050_DI_AKS_3 0x33 78 #define QT1050_DI_AKS_4 0x34 79 80 /* Charge Share Delay */ 81 #define QT1050_CSD_0 0x36 82 #define QT1050_CSD_1 0x37 83 #define QT1050_CSD_2 0x39 84 #define QT1050_CSD_3 0x3a 85 #define QT1050_CSD_4 0x3b 86 87 /* Low Power Mode */ 88 #define QT1050_LPMODE 0x3d 89 90 /* Calibration and Reset */ 91 #define QT1050_RES_CAL 0x3f 92 #define QT1050_RES_CAL_RESET BIT(7) 93 #define QT1050_RES_CAL_CALIBRATE BIT(1) 94 95 #define QT1050_MAX_KEYS 5 96 #define QT1050_RESET_TIME 255 97 98 struct qt1050_key_regs { 99 unsigned int nthr; 100 unsigned int pulse_scale; 101 unsigned int di_aks; 102 unsigned int csd; 103 }; 104 105 struct qt1050_key { 106 u32 num; 107 u32 charge_delay; 108 u32 thr_cnt; 109 u32 samples; 110 u32 scale; 111 u32 keycode; 112 }; 113 114 struct qt1050_priv { 115 struct i2c_client *client; 116 struct input_dev *input; 117 struct regmap *regmap; 118 struct qt1050_key keys[QT1050_MAX_KEYS]; 119 unsigned short keycodes[QT1050_MAX_KEYS]; 120 u8 reg_keys; 121 u8 last_keys; 122 }; 123 124 static const struct qt1050_key_regs qt1050_key_regs_data[] = { 125 { 126 .nthr = QT1050_NTHR_0, 127 .pulse_scale = QT1050_PULSE_SCALE_0, 128 .di_aks = QT1050_DI_AKS_0, 129 .csd = QT1050_CSD_0, 130 }, { 131 .nthr = QT1050_NTHR_1, 132 .pulse_scale = QT1050_PULSE_SCALE_1, 133 .di_aks = QT1050_DI_AKS_1, 134 .csd = QT1050_CSD_1, 135 }, { 136 .nthr = QT1050_NTHR_2, 137 .pulse_scale = QT1050_PULSE_SCALE_2, 138 .di_aks = QT1050_DI_AKS_2, 139 .csd = QT1050_CSD_2, 140 }, { 141 .nthr = QT1050_NTHR_3, 142 .pulse_scale = QT1050_PULSE_SCALE_3, 143 .di_aks = QT1050_DI_AKS_3, 144 .csd = QT1050_CSD_3, 145 }, { 146 .nthr = QT1050_NTHR_4, 147 .pulse_scale = QT1050_PULSE_SCALE_4, 148 .di_aks = QT1050_DI_AKS_4, 149 .csd = QT1050_CSD_4, 150 } 151 }; 152 153 static bool qt1050_volatile_reg(struct device *dev, unsigned int reg) 154 { 155 switch (reg) { 156 case QT1050_DET_STATUS: 157 case QT1050_KEY_STATUS: 158 case QT1050_KEY_SIGNAL_0_MSB: 159 case QT1050_KEY_SIGNAL_0_LSB: 160 case QT1050_KEY_SIGNAL_1_MSB: 161 case QT1050_KEY_SIGNAL_1_LSB: 162 case QT1050_KEY_SIGNAL_2_MSB: 163 case QT1050_KEY_SIGNAL_2_LSB: 164 case QT1050_KEY_SIGNAL_3_MSB: 165 case QT1050_KEY_SIGNAL_3_LSB: 166 case QT1050_KEY_SIGNAL_4_MSB: 167 case QT1050_KEY_SIGNAL_4_LSB: 168 return true; 169 default: 170 return false; 171 } 172 } 173 174 static const struct regmap_range qt1050_readable_ranges[] = { 175 regmap_reg_range(QT1050_CHIP_ID, QT1050_KEY_STATUS), 176 regmap_reg_range(QT1050_KEY_SIGNAL_0_MSB, QT1050_KEY_SIGNAL_1_LSB), 177 regmap_reg_range(QT1050_KEY_SIGNAL_2_MSB, QT1050_KEY_SIGNAL_4_LSB), 178 regmap_reg_range(QT1050_REF_DATA_0_MSB, QT1050_REF_DATA_1_LSB), 179 regmap_reg_range(QT1050_REF_DATA_2_MSB, QT1050_REF_DATA_4_LSB), 180 regmap_reg_range(QT1050_NTHR_0, QT1050_NTHR_1), 181 regmap_reg_range(QT1050_NTHR_2, QT1050_NTHR_4), 182 regmap_reg_range(QT1050_PULSE_SCALE_0, QT1050_PULSE_SCALE_1), 183 regmap_reg_range(QT1050_PULSE_SCALE_2, QT1050_PULSE_SCALE_4), 184 regmap_reg_range(QT1050_DI_AKS_0, QT1050_DI_AKS_1), 185 regmap_reg_range(QT1050_DI_AKS_2, QT1050_DI_AKS_4), 186 regmap_reg_range(QT1050_CSD_0, QT1050_CSD_1), 187 regmap_reg_range(QT1050_CSD_2, QT1050_RES_CAL), 188 }; 189 190 static const struct regmap_access_table qt1050_readable_table = { 191 .yes_ranges = qt1050_readable_ranges, 192 .n_yes_ranges = ARRAY_SIZE(qt1050_readable_ranges), 193 }; 194 195 static const struct regmap_range qt1050_writeable_ranges[] = { 196 regmap_reg_range(QT1050_NTHR_0, QT1050_NTHR_1), 197 regmap_reg_range(QT1050_NTHR_2, QT1050_NTHR_4), 198 regmap_reg_range(QT1050_PULSE_SCALE_0, QT1050_PULSE_SCALE_1), 199 regmap_reg_range(QT1050_PULSE_SCALE_2, QT1050_PULSE_SCALE_4), 200 regmap_reg_range(QT1050_DI_AKS_0, QT1050_DI_AKS_1), 201 regmap_reg_range(QT1050_DI_AKS_2, QT1050_DI_AKS_4), 202 regmap_reg_range(QT1050_CSD_0, QT1050_CSD_1), 203 regmap_reg_range(QT1050_CSD_2, QT1050_RES_CAL), 204 }; 205 206 static const struct regmap_access_table qt1050_writeable_table = { 207 .yes_ranges = qt1050_writeable_ranges, 208 .n_yes_ranges = ARRAY_SIZE(qt1050_writeable_ranges), 209 }; 210 211 static const struct regmap_config qt1050_regmap_config = { 212 .reg_bits = 8, 213 .val_bits = 8, 214 .max_register = QT1050_RES_CAL, 215 216 .cache_type = REGCACHE_MAPLE, 217 218 .wr_table = &qt1050_writeable_table, 219 .rd_table = &qt1050_readable_table, 220 .volatile_reg = qt1050_volatile_reg, 221 }; 222 223 static bool qt1050_identify(struct qt1050_priv *ts) 224 { 225 unsigned int val; 226 int err; 227 228 /* Read Chip ID */ 229 err = regmap_read(ts->regmap, QT1050_CHIP_ID, &val); 230 if (err) { 231 dev_err(&ts->client->dev, "Failed to read chip ID: %d\n", err); 232 return false; 233 } 234 235 if (val != QT1050_CHIP_ID_VER) { 236 dev_err(&ts->client->dev, "ID %d not supported\n", val); 237 return false; 238 } 239 240 /* Read firmware version */ 241 err = regmap_read(ts->regmap, QT1050_FW_VERSION, &val); 242 if (err) { 243 dev_err(&ts->client->dev, "could not read the firmware version\n"); 244 return false; 245 } 246 247 dev_info(&ts->client->dev, "AT42QT1050 firmware version %1d.%1d\n", 248 val >> 4, val & 0xf); 249 250 return true; 251 } 252 253 static irqreturn_t qt1050_irq_threaded(int irq, void *dev_id) 254 { 255 struct qt1050_priv *ts = dev_id; 256 struct input_dev *input = ts->input; 257 unsigned long new_keys, changed; 258 unsigned int val; 259 int i, err; 260 261 /* Read the detected status register, thus clearing interrupt */ 262 err = regmap_read(ts->regmap, QT1050_DET_STATUS, &val); 263 if (err) { 264 dev_err(&ts->client->dev, "Fail to read detection status: %d\n", 265 err); 266 return IRQ_NONE; 267 } 268 269 /* Read which key changed, keys are not continuous */ 270 err = regmap_read(ts->regmap, QT1050_KEY_STATUS, &val); 271 if (err) { 272 dev_err(&ts->client->dev, 273 "Fail to determine the key status: %d\n", err); 274 return IRQ_NONE; 275 } 276 new_keys = (val & 0x70) >> 2 | (val & 0x6) >> 1; 277 changed = ts->last_keys ^ new_keys; 278 /* Report registered keys only */ 279 changed &= ts->reg_keys; 280 281 for_each_set_bit(i, &changed, QT1050_MAX_KEYS) 282 input_report_key(input, ts->keys[i].keycode, 283 test_bit(i, &new_keys)); 284 285 ts->last_keys = new_keys; 286 input_sync(input); 287 288 return IRQ_HANDLED; 289 } 290 291 static const struct qt1050_key_regs *qt1050_get_key_regs(int key_num) 292 { 293 return &qt1050_key_regs_data[key_num]; 294 } 295 296 static int qt1050_set_key(struct regmap *map, int number, int on) 297 { 298 const struct qt1050_key_regs *key_regs; 299 300 key_regs = qt1050_get_key_regs(number); 301 302 return regmap_update_bits(map, key_regs->di_aks, 0xfc, 303 on ? BIT(4) : 0x00); 304 } 305 306 static int qt1050_apply_fw_data(struct qt1050_priv *ts) 307 { 308 struct regmap *map = ts->regmap; 309 struct qt1050_key *button = &ts->keys[0]; 310 const struct qt1050_key_regs *key_regs; 311 int i, err; 312 313 /* Disable all keys and enable only the specified ones */ 314 for (i = 0; i < QT1050_MAX_KEYS; i++) { 315 err = qt1050_set_key(map, i, 0); 316 if (err) 317 return err; 318 } 319 320 for (i = 0; i < QT1050_MAX_KEYS; i++, button++) { 321 /* Keep KEY_RESERVED keys off */ 322 if (button->keycode == KEY_RESERVED) 323 continue; 324 325 err = qt1050_set_key(map, button->num, 1); 326 if (err) 327 return err; 328 329 key_regs = qt1050_get_key_regs(button->num); 330 331 err = regmap_write(map, key_regs->pulse_scale, 332 (button->samples << 4) | (button->scale)); 333 if (err) 334 return err; 335 err = regmap_write(map, key_regs->csd, button->charge_delay); 336 if (err) 337 return err; 338 err = regmap_write(map, key_regs->nthr, button->thr_cnt); 339 if (err) 340 return err; 341 } 342 343 return 0; 344 } 345 346 static int qt1050_parse_fw(struct qt1050_priv *ts) 347 { 348 struct device *dev = &ts->client->dev; 349 int nbuttons; 350 351 nbuttons = device_get_child_node_count(dev); 352 if (nbuttons == 0 || nbuttons > QT1050_MAX_KEYS) 353 return -ENODEV; 354 355 device_for_each_child_node_scoped(dev, child) { 356 struct qt1050_key button; 357 358 /* Required properties */ 359 if (fwnode_property_read_u32(child, "linux,code", 360 &button.keycode)) { 361 dev_err(dev, "Button without keycode\n"); 362 return -EINVAL; 363 } 364 if (button.keycode >= KEY_MAX) { 365 dev_err(dev, "Invalid keycode 0x%x\n", 366 button.keycode); 367 return -EINVAL; 368 } 369 370 if (fwnode_property_read_u32(child, "reg", 371 &button.num)) { 372 dev_err(dev, "Button without pad number\n"); 373 return -EINVAL; 374 } 375 if (button.num < 0 || button.num > QT1050_MAX_KEYS - 1) 376 return -EINVAL; 377 378 ts->reg_keys |= BIT(button.num); 379 380 /* Optional properties */ 381 if (fwnode_property_read_u32(child, 382 "microchip,pre-charge-time-ns", 383 &button.charge_delay)) { 384 button.charge_delay = 0; 385 } else { 386 if (button.charge_delay % 2500 == 0) 387 button.charge_delay = 388 button.charge_delay / 2500; 389 else 390 button.charge_delay = 0; 391 } 392 393 if (fwnode_property_read_u32(child, "microchip,average-samples", 394 &button.samples)) { 395 button.samples = 0; 396 } else { 397 if (is_power_of_2(button.samples)) 398 button.samples = ilog2(button.samples); 399 else 400 button.samples = 0; 401 } 402 403 if (fwnode_property_read_u32(child, "microchip,average-scaling", 404 &button.scale)) { 405 button.scale = 0; 406 } else { 407 if (is_power_of_2(button.scale)) 408 button.scale = ilog2(button.scale); 409 else 410 button.scale = 0; 411 412 } 413 414 if (fwnode_property_read_u32(child, "microchip,threshold", 415 &button.thr_cnt)) { 416 button.thr_cnt = 20; 417 } else { 418 if (button.thr_cnt > 255) 419 button.thr_cnt = 20; 420 } 421 422 ts->keys[button.num] = button; 423 } 424 425 return 0; 426 } 427 428 static int qt1050_probe(struct i2c_client *client) 429 { 430 struct qt1050_priv *ts; 431 struct input_dev *input; 432 struct device *dev = &client->dev; 433 struct regmap *map; 434 unsigned int status, i; 435 int err; 436 437 /* Check basic functionality */ 438 err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE); 439 if (!err) { 440 dev_err(&client->dev, "%s adapter not supported\n", 441 dev_driver_string(&client->adapter->dev)); 442 return -ENODEV; 443 } 444 445 if (!client->irq) { 446 dev_err(dev, "assign a irq line to this device\n"); 447 return -EINVAL; 448 } 449 450 ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL); 451 if (!ts) 452 return -ENOMEM; 453 454 input = devm_input_allocate_device(dev); 455 if (!input) 456 return -ENOMEM; 457 458 map = devm_regmap_init_i2c(client, &qt1050_regmap_config); 459 if (IS_ERR(map)) 460 return PTR_ERR(map); 461 462 ts->client = client; 463 ts->input = input; 464 ts->regmap = map; 465 466 i2c_set_clientdata(client, ts); 467 468 /* Identify the qt1050 chip */ 469 if (!qt1050_identify(ts)) 470 return -ENODEV; 471 472 /* Get pdata */ 473 err = qt1050_parse_fw(ts); 474 if (err) { 475 dev_err(dev, "Failed to parse firmware: %d\n", err); 476 return err; 477 } 478 479 input->name = "AT42QT1050 QTouch Sensor"; 480 input->dev.parent = &client->dev; 481 input->id.bustype = BUS_I2C; 482 483 /* Add the keycode */ 484 input->keycode = ts->keycodes; 485 input->keycodesize = sizeof(ts->keycodes[0]); 486 input->keycodemax = QT1050_MAX_KEYS; 487 488 __set_bit(EV_KEY, input->evbit); 489 for (i = 0; i < QT1050_MAX_KEYS; i++) { 490 ts->keycodes[i] = ts->keys[i].keycode; 491 __set_bit(ts->keycodes[i], input->keybit); 492 } 493 494 /* Trigger re-calibration */ 495 err = regmap_update_bits(ts->regmap, QT1050_RES_CAL, 0x7f, 496 QT1050_RES_CAL_CALIBRATE); 497 if (err) { 498 dev_err(dev, "Trigger calibration failed: %d\n", err); 499 return err; 500 } 501 err = regmap_read_poll_timeout(ts->regmap, QT1050_DET_STATUS, status, 502 status >> 7 == 1, 10000, 200000); 503 if (err) { 504 dev_err(dev, "Calibration failed: %d\n", err); 505 return err; 506 } 507 508 /* Soft reset to set defaults */ 509 err = regmap_update_bits(ts->regmap, QT1050_RES_CAL, 510 QT1050_RES_CAL_RESET, QT1050_RES_CAL_RESET); 511 if (err) { 512 dev_err(dev, "Trigger soft reset failed: %d\n", err); 513 return err; 514 } 515 msleep(QT1050_RESET_TIME); 516 517 /* Set pdata */ 518 err = qt1050_apply_fw_data(ts); 519 if (err) { 520 dev_err(dev, "Failed to set firmware data: %d\n", err); 521 return err; 522 } 523 524 err = devm_request_threaded_irq(dev, client->irq, NULL, 525 qt1050_irq_threaded, IRQF_ONESHOT, 526 "qt1050", ts); 527 if (err) { 528 dev_err(&client->dev, "Failed to request irq: %d\n", err); 529 return err; 530 } 531 532 /* Clear #CHANGE line */ 533 err = regmap_read(ts->regmap, QT1050_DET_STATUS, &status); 534 if (err) { 535 dev_err(dev, "Failed to clear #CHANGE line level: %d\n", err); 536 return err; 537 } 538 539 /* Register the input device */ 540 err = input_register_device(ts->input); 541 if (err) { 542 dev_err(&client->dev, "Failed to register input device: %d\n", 543 err); 544 return err; 545 } 546 547 return 0; 548 } 549 550 static int qt1050_suspend(struct device *dev) 551 { 552 struct i2c_client *client = to_i2c_client(dev); 553 struct qt1050_priv *ts = i2c_get_clientdata(client); 554 555 disable_irq(client->irq); 556 557 /* 558 * Set measurement interval to 1s (125 x 8ms) if wakeup is allowed 559 * else turn off. The 1s interval seems to be a good compromise between 560 * low power and response time. 561 */ 562 return regmap_write(ts->regmap, QT1050_LPMODE, 563 device_may_wakeup(dev) ? 125 : 0); 564 } 565 566 static int qt1050_resume(struct device *dev) 567 { 568 struct i2c_client *client = to_i2c_client(dev); 569 struct qt1050_priv *ts = i2c_get_clientdata(client); 570 571 enable_irq(client->irq); 572 573 /* Set measurement interval back to 16ms (2 x 8ms) */ 574 return regmap_write(ts->regmap, QT1050_LPMODE, 2); 575 } 576 577 static DEFINE_SIMPLE_DEV_PM_OPS(qt1050_pm_ops, qt1050_suspend, qt1050_resume); 578 579 static const struct of_device_id __maybe_unused qt1050_of_match[] = { 580 { .compatible = "microchip,qt1050", }, 581 { }, 582 }; 583 MODULE_DEVICE_TABLE(of, qt1050_of_match); 584 585 static struct i2c_driver qt1050_driver = { 586 .driver = { 587 .name = "qt1050", 588 .of_match_table = of_match_ptr(qt1050_of_match), 589 .pm = pm_sleep_ptr(&qt1050_pm_ops), 590 }, 591 .probe = qt1050_probe, 592 }; 593 594 module_i2c_driver(qt1050_driver); 595 596 MODULE_AUTHOR("Marco Felsch <kernel@pengutronix.de"); 597 MODULE_DESCRIPTION("Driver for AT42QT1050 QTouch sensor"); 598 MODULE_LICENSE("GPL v2"); 599