1// SPDX-License-Identifier: GPL-2.0-only 2 3#include <linux/delay.h> 4#include <linux/i2c.h> 5#include <linux/input.h> 6#include <linux/input/mt.h> 7#include <linux/input/touchscreen.h> 8#include <linux/interrupt.h> 9#include <linux/irq.h> 10#include <linux/kernel.h> 11#include <linux/module.h> 12#include <linux/of.h> 13#include <linux/regulator/consumer.h> 14#include <linux/slab.h> 15 16/* Register Map */ 17 18#define ZINITIX_SWRESET_CMD 0x0000 19#define ZINITIX_WAKEUP_CMD 0x0001 20 21#define ZINITIX_IDLE_CMD 0x0004 22#define ZINITIX_SLEEP_CMD 0x0005 23 24#define ZINITIX_CLEAR_INT_STATUS_CMD 0x0003 25#define ZINITIX_CALIBRATE_CMD 0x0006 26#define ZINITIX_SAVE_STATUS_CMD 0x0007 27#define ZINITIX_SAVE_CALIBRATION_CMD 0x0008 28#define ZINITIX_RECALL_FACTORY_CMD 0x000f 29 30#define ZINITIX_THRESHOLD 0x0020 31 32#define ZINITIX_LARGE_PALM_REJECT_AREA_TH 0x003F 33 34#define ZINITIX_DEBUG_REG 0x0115 /* 0~7 */ 35 36#define ZINITIX_TOUCH_MODE 0x0010 37#define ZINITIX_CHIP_REVISION 0x0011 38#define ZINITIX_FIRMWARE_VERSION 0x0012 39 40#define ZINITIX_USB_DETECT 0x116 41 42#define ZINITIX_MINOR_FW_VERSION 0x0121 43 44#define ZINITIX_VENDOR_ID 0x001C 45#define ZINITIX_HW_ID 0x0014 46 47#define ZINITIX_DATA_VERSION_REG 0x0013 48#define ZINITIX_SUPPORTED_FINGER_NUM 0x0015 49#define ZINITIX_EEPROM_INFO 0x0018 50#define ZINITIX_INITIAL_TOUCH_MODE 0x0019 51 52#define ZINITIX_TOTAL_NUMBER_OF_X 0x0060 53#define ZINITIX_TOTAL_NUMBER_OF_Y 0x0061 54 55#define ZINITIX_DELAY_RAW_FOR_HOST 0x007f 56 57#define ZINITIX_BUTTON_SUPPORTED_NUM 0x00B0 58#define ZINITIX_BUTTON_SENSITIVITY 0x00B2 59#define ZINITIX_DUMMY_BUTTON_SENSITIVITY 0X00C8 60 61#define ZINITIX_X_RESOLUTION 0x00C0 62#define ZINITIX_Y_RESOLUTION 0x00C1 63 64#define ZINITIX_POINT_STATUS_REG 0x0080 65#define ZINITIX_ICON_STATUS_REG 0x00AA 66 67#define ZINITIX_POINT_COORD_REG (ZINITIX_POINT_STATUS_REG + 2) 68 69#define ZINITIX_AFE_FREQUENCY 0x0100 70#define ZINITIX_DND_N_COUNT 0x0122 71#define ZINITIX_DND_U_COUNT 0x0135 72 73#define ZINITIX_RAWDATA_REG 0x0200 74 75#define ZINITIX_EEPROM_INFO_REG 0x0018 76 77#define ZINITIX_INT_ENABLE_FLAG 0x00f0 78#define ZINITIX_PERIODICAL_INTERRUPT_INTERVAL 0x00f1 79 80#define ZINITIX_BTN_WIDTH 0x016d 81 82#define ZINITIX_CHECKSUM_RESULT 0x012c 83 84#define ZINITIX_INIT_FLASH 0x01d0 85#define ZINITIX_WRITE_FLASH 0x01d1 86#define ZINITIX_READ_FLASH 0x01d2 87 88#define ZINITIX_INTERNAL_FLAG_02 0x011e 89#define ZINITIX_INTERNAL_FLAG_03 0x011f 90 91#define ZINITIX_I2C_CHECKSUM_WCNT 0x016a 92#define ZINITIX_I2C_CHECKSUM_RESULT 0x016c 93 94/* Interrupt & status register flags */ 95 96#define BIT_PT_CNT_CHANGE BIT(0) 97#define BIT_DOWN BIT(1) 98#define BIT_MOVE BIT(2) 99#define BIT_UP BIT(3) 100#define BIT_PALM BIT(4) 101#define BIT_PALM_REJECT BIT(5) 102#define BIT_RESERVED_0 BIT(6) 103#define BIT_RESERVED_1 BIT(7) 104#define BIT_WEIGHT_CHANGE BIT(8) 105#define BIT_PT_NO_CHANGE BIT(9) 106#define BIT_REJECT BIT(10) 107#define BIT_PT_EXIST BIT(11) 108#define BIT_RESERVED_2 BIT(12) 109#define BIT_ERROR BIT(13) 110#define BIT_DEBUG BIT(14) 111#define BIT_ICON_EVENT BIT(15) 112 113#define SUB_BIT_EXIST BIT(0) 114#define SUB_BIT_DOWN BIT(1) 115#define SUB_BIT_MOVE BIT(2) 116#define SUB_BIT_UP BIT(3) 117#define SUB_BIT_UPDATE BIT(4) 118#define SUB_BIT_WAIT BIT(5) 119 120#define DEFAULT_TOUCH_POINT_MODE 2 121#define MAX_SUPPORTED_FINGER_NUM 5 122 123#define CHIP_ON_DELAY 15 // ms 124#define FIRMWARE_ON_DELAY 40 // ms 125 126struct point_coord { 127 __le16 x; 128 __le16 y; 129 u8 width; 130 u8 sub_status; 131 // currently unused, but needed as padding: 132 u8 minor_width; 133 u8 angle; 134}; 135 136struct touch_event { 137 __le16 status; 138 u8 finger_mask; 139 u8 time_stamp; 140 struct point_coord point_coord[MAX_SUPPORTED_FINGER_NUM]; 141}; 142 143struct bt541_ts_data { 144 struct i2c_client *client; 145 struct input_dev *input_dev; 146 struct touchscreen_properties prop; 147 struct regulator_bulk_data supplies[2]; 148 u32 zinitix_mode; 149}; 150 151static int zinitix_read_data(struct i2c_client *client, 152 u16 reg, void *values, size_t length) 153{ 154 __le16 reg_le = cpu_to_le16(reg); 155 int ret; 156 157 /* A single i2c_transfer() transaction does not work here. */ 158 ret = i2c_master_send(client, (u8 *)®_le, sizeof(reg_le)); 159 if (ret != sizeof(reg_le)) 160 return ret < 0 ? ret : -EIO; 161 162 ret = i2c_master_recv(client, (u8 *)values, length); 163 if (ret != length) 164 return ret < 0 ? ret : -EIO; 165 166 return 0; 167} 168 169static int zinitix_write_u16(struct i2c_client *client, u16 reg, u16 value) 170{ 171 __le16 packet[2] = {cpu_to_le16(reg), cpu_to_le16(value)}; 172 int ret; 173 174 ret = i2c_master_send(client, (u8 *)packet, sizeof(packet)); 175 if (ret != sizeof(packet)) 176 return ret < 0 ? ret : -EIO; 177 178 return 0; 179} 180 181static int zinitix_write_cmd(struct i2c_client *client, u16 reg) 182{ 183 __le16 reg_le = cpu_to_le16(reg); 184 int ret; 185 186 ret = i2c_master_send(client, (u8 *)®_le, sizeof(reg_le)); 187 if (ret != sizeof(reg_le)) 188 return ret < 0 ? ret : -EIO; 189 190 return 0; 191} 192 193static int zinitix_init_touch(struct bt541_ts_data *bt541) 194{ 195 struct i2c_client *client = bt541->client; 196 int i; 197 int error; 198 199 error = zinitix_write_cmd(client, ZINITIX_SWRESET_CMD); 200 if (error) { 201 dev_err(&client->dev, "Failed to write reset command\n"); 202 return error; 203 } 204 205 error = zinitix_write_u16(client, ZINITIX_INT_ENABLE_FLAG, 0x0); 206 if (error) { 207 dev_err(&client->dev, 208 "Failed to reset interrupt enable flag\n"); 209 return error; 210 } 211 212 /* initialize */ 213 error = zinitix_write_u16(client, ZINITIX_X_RESOLUTION, 214 bt541->prop.max_x); 215 if (error) 216 return error; 217 218 error = zinitix_write_u16(client, ZINITIX_Y_RESOLUTION, 219 bt541->prop.max_y); 220 if (error) 221 return error; 222 223 error = zinitix_write_u16(client, ZINITIX_SUPPORTED_FINGER_NUM, 224 MAX_SUPPORTED_FINGER_NUM); 225 if (error) 226 return error; 227 228 error = zinitix_write_u16(client, ZINITIX_INITIAL_TOUCH_MODE, 229 bt541->zinitix_mode); 230 if (error) 231 return error; 232 233 error = zinitix_write_u16(client, ZINITIX_TOUCH_MODE, 234 bt541->zinitix_mode); 235 if (error) 236 return error; 237 238 error = zinitix_write_u16(client, ZINITIX_INT_ENABLE_FLAG, 239 BIT_PT_CNT_CHANGE | BIT_DOWN | BIT_MOVE | 240 BIT_UP); 241 if (error) 242 return error; 243 244 /* clear queue */ 245 for (i = 0; i < 10; i++) { 246 zinitix_write_cmd(client, ZINITIX_CLEAR_INT_STATUS_CMD); 247 udelay(10); 248 } 249 250 return 0; 251} 252 253static int zinitix_init_regulators(struct bt541_ts_data *bt541) 254{ 255 struct device *dev = &bt541->client->dev; 256 int error; 257 258 /* 259 * Some older device trees have erroneous names for the regulators, 260 * so check if "vddo" is present and in that case use these names. 261 * Else use the proper supply names on the component. 262 */ 263 if (of_property_present(dev->of_node, "vddo-supply")) { 264 bt541->supplies[0].supply = "vdd"; 265 bt541->supplies[1].supply = "vddo"; 266 } else { 267 /* Else use the proper supply names */ 268 bt541->supplies[0].supply = "vcca"; 269 bt541->supplies[1].supply = "vdd"; 270 } 271 error = devm_regulator_bulk_get(dev, 272 ARRAY_SIZE(bt541->supplies), 273 bt541->supplies); 274 if (error < 0) { 275 dev_err(dev, "Failed to get regulators: %d\n", error); 276 return error; 277 } 278 279 return 0; 280} 281 282static int zinitix_send_power_on_sequence(struct bt541_ts_data *bt541) 283{ 284 int error; 285 struct i2c_client *client = bt541->client; 286 287 error = zinitix_write_u16(client, 0xc000, 0x0001); 288 if (error) { 289 dev_err(&client->dev, 290 "Failed to send power sequence(vendor cmd enable)\n"); 291 return error; 292 } 293 udelay(10); 294 295 error = zinitix_write_cmd(client, 0xc004); 296 if (error) { 297 dev_err(&client->dev, 298 "Failed to send power sequence (intn clear)\n"); 299 return error; 300 } 301 udelay(10); 302 303 error = zinitix_write_u16(client, 0xc002, 0x0001); 304 if (error) { 305 dev_err(&client->dev, 306 "Failed to send power sequence (nvm init)\n"); 307 return error; 308 } 309 mdelay(2); 310 311 error = zinitix_write_u16(client, 0xc001, 0x0001); 312 if (error) { 313 dev_err(&client->dev, 314 "Failed to send power sequence (program start)\n"); 315 return error; 316 } 317 msleep(FIRMWARE_ON_DELAY); 318 319 return 0; 320} 321 322static void zinitix_report_finger(struct bt541_ts_data *bt541, int slot, 323 const struct point_coord *p) 324{ 325 u16 x, y; 326 327 if (unlikely(!(p->sub_status & 328 (SUB_BIT_UP | SUB_BIT_DOWN | SUB_BIT_MOVE)))) { 329 dev_dbg(&bt541->client->dev, "unknown finger event %#02x\n", 330 p->sub_status); 331 return; 332 } 333 334 x = le16_to_cpu(p->x); 335 y = le16_to_cpu(p->y); 336 337 input_mt_slot(bt541->input_dev, slot); 338 if (input_mt_report_slot_state(bt541->input_dev, MT_TOOL_FINGER, 339 !(p->sub_status & SUB_BIT_UP))) { 340 touchscreen_report_pos(bt541->input_dev, 341 &bt541->prop, x, y, true); 342 input_report_abs(bt541->input_dev, 343 ABS_MT_TOUCH_MAJOR, p->width); 344 dev_dbg(&bt541->client->dev, "finger %d %s (%u, %u)\n", 345 slot, p->sub_status & SUB_BIT_DOWN ? "down" : "move", 346 x, y); 347 } else { 348 dev_dbg(&bt541->client->dev, "finger %d up (%u, %u)\n", 349 slot, x, y); 350 } 351} 352 353static irqreturn_t zinitix_ts_irq_handler(int irq, void *bt541_handler) 354{ 355 struct bt541_ts_data *bt541 = bt541_handler; 356 struct i2c_client *client = bt541->client; 357 struct touch_event touch_event; 358 unsigned long finger_mask; 359 int error; 360 int i; 361 362 memset(&touch_event, 0, sizeof(struct touch_event)); 363 364 error = zinitix_read_data(bt541->client, ZINITIX_POINT_STATUS_REG, 365 &touch_event, sizeof(struct touch_event)); 366 if (error) { 367 dev_err(&client->dev, "Failed to read in touchpoint struct\n"); 368 goto out; 369 } 370 371 finger_mask = touch_event.finger_mask; 372 for_each_set_bit(i, &finger_mask, MAX_SUPPORTED_FINGER_NUM) { 373 const struct point_coord *p = &touch_event.point_coord[i]; 374 375 /* Only process contacts that are actually reported */ 376 if (p->sub_status & SUB_BIT_EXIST) 377 zinitix_report_finger(bt541, i, p); 378 } 379 380 input_mt_sync_frame(bt541->input_dev); 381 input_sync(bt541->input_dev); 382 383out: 384 zinitix_write_cmd(bt541->client, ZINITIX_CLEAR_INT_STATUS_CMD); 385 return IRQ_HANDLED; 386} 387 388static int zinitix_start(struct bt541_ts_data *bt541) 389{ 390 int error; 391 392 error = regulator_bulk_enable(ARRAY_SIZE(bt541->supplies), 393 bt541->supplies); 394 if (error) { 395 dev_err(&bt541->client->dev, 396 "Failed to enable regulators: %d\n", error); 397 return error; 398 } 399 400 msleep(CHIP_ON_DELAY); 401 402 error = zinitix_send_power_on_sequence(bt541); 403 if (error) { 404 dev_err(&bt541->client->dev, 405 "Error while sending power-on sequence: %d\n", error); 406 return error; 407 } 408 409 error = zinitix_init_touch(bt541); 410 if (error) { 411 dev_err(&bt541->client->dev, 412 "Error while configuring touch IC\n"); 413 return error; 414 } 415 416 enable_irq(bt541->client->irq); 417 418 return 0; 419} 420 421static int zinitix_stop(struct bt541_ts_data *bt541) 422{ 423 int error; 424 425 disable_irq(bt541->client->irq); 426 427 error = regulator_bulk_disable(ARRAY_SIZE(bt541->supplies), 428 bt541->supplies); 429 if (error) { 430 dev_err(&bt541->client->dev, 431 "Failed to disable regulators: %d\n", error); 432 return error; 433 } 434 435 return 0; 436} 437 438static int zinitix_input_open(struct input_dev *dev) 439{ 440 struct bt541_ts_data *bt541 = input_get_drvdata(dev); 441 442 return zinitix_start(bt541); 443} 444 445static void zinitix_input_close(struct input_dev *dev) 446{ 447 struct bt541_ts_data *bt541 = input_get_drvdata(dev); 448 449 zinitix_stop(bt541); 450} 451 452static int zinitix_init_input_dev(struct bt541_ts_data *bt541) 453{ 454 struct input_dev *input_dev; 455 int error; 456 457 input_dev = devm_input_allocate_device(&bt541->client->dev); 458 if (!input_dev) { 459 dev_err(&bt541->client->dev, 460 "Failed to allocate input device."); 461 return -ENOMEM; 462 } 463 464 input_set_drvdata(input_dev, bt541); 465 bt541->input_dev = input_dev; 466 467 input_dev->name = "Zinitix Capacitive TouchScreen"; 468 input_dev->phys = "input/ts"; 469 input_dev->id.bustype = BUS_I2C; 470 input_dev->open = zinitix_input_open; 471 input_dev->close = zinitix_input_close; 472 473 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X); 474 input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y); 475 input_set_abs_params(input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0); 476 input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); 477 478 touchscreen_parse_properties(input_dev, true, &bt541->prop); 479 if (!bt541->prop.max_x || !bt541->prop.max_y) { 480 dev_err(&bt541->client->dev, 481 "Touchscreen-size-x and/or touchscreen-size-y not set in dts\n"); 482 return -EINVAL; 483 } 484 485 error = input_mt_init_slots(input_dev, MAX_SUPPORTED_FINGER_NUM, 486 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 487 if (error) { 488 dev_err(&bt541->client->dev, 489 "Failed to initialize MT slots: %d", error); 490 return error; 491 } 492 493 error = input_register_device(input_dev); 494 if (error) { 495 dev_err(&bt541->client->dev, 496 "Failed to register input device: %d", error); 497 return error; 498 } 499 500 return 0; 501} 502 503static int zinitix_ts_probe(struct i2c_client *client) 504{ 505 struct bt541_ts_data *bt541; 506 int error; 507 508 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 509 dev_err(&client->dev, 510 "Failed to assert adapter's support for plain I2C.\n"); 511 return -ENXIO; 512 } 513 514 bt541 = devm_kzalloc(&client->dev, sizeof(*bt541), GFP_KERNEL); 515 if (!bt541) 516 return -ENOMEM; 517 518 bt541->client = client; 519 i2c_set_clientdata(client, bt541); 520 521 error = zinitix_init_regulators(bt541); 522 if (error) { 523 dev_err(&client->dev, 524 "Failed to initialize regulators: %d\n", error); 525 return error; 526 } 527 528 error = devm_request_threaded_irq(&client->dev, client->irq, 529 NULL, zinitix_ts_irq_handler, 530 IRQF_ONESHOT | IRQF_NO_AUTOEN, 531 client->name, bt541); 532 if (error) { 533 dev_err(&client->dev, "Failed to request IRQ: %d\n", error); 534 return error; 535 } 536 537 error = zinitix_init_input_dev(bt541); 538 if (error) { 539 dev_err(&client->dev, 540 "Failed to initialize input device: %d\n", error); 541 return error; 542 } 543 544 error = device_property_read_u32(&client->dev, "zinitix,mode", 545 &bt541->zinitix_mode); 546 if (error < 0) { 547 /* fall back to mode 2 */ 548 bt541->zinitix_mode = DEFAULT_TOUCH_POINT_MODE; 549 } 550 551 if (bt541->zinitix_mode != 2) { 552 /* 553 * If there are devices that don't support mode 2, support 554 * for other modes (0, 1) will be needed. 555 */ 556 dev_err(&client->dev, 557 "Malformed zinitix,mode property, must be 2 (supplied: %d)\n", 558 bt541->zinitix_mode); 559 return -EINVAL; 560 } 561 562 return 0; 563} 564 565static int zinitix_suspend(struct device *dev) 566{ 567 struct i2c_client *client = to_i2c_client(dev); 568 struct bt541_ts_data *bt541 = i2c_get_clientdata(client); 569 570 mutex_lock(&bt541->input_dev->mutex); 571 572 if (input_device_enabled(bt541->input_dev)) 573 zinitix_stop(bt541); 574 575 mutex_unlock(&bt541->input_dev->mutex); 576 577 return 0; 578} 579 580static int zinitix_resume(struct device *dev) 581{ 582 struct i2c_client *client = to_i2c_client(dev); 583 struct bt541_ts_data *bt541 = i2c_get_clientdata(client); 584 int ret = 0; 585 586 mutex_lock(&bt541->input_dev->mutex); 587 588 if (input_device_enabled(bt541->input_dev)) 589 ret = zinitix_start(bt541); 590 591 mutex_unlock(&bt541->input_dev->mutex); 592 593 return ret; 594} 595 596static DEFINE_SIMPLE_DEV_PM_OPS(zinitix_pm_ops, zinitix_suspend, zinitix_resume); 597 598#ifdef CONFIG_OF 599static const struct of_device_id zinitix_of_match[] = { 600 { .compatible = "zinitix,bt402" }, 601 { .compatible = "zinitix,bt403" }, 602 { .compatible = "zinitix,bt404" }, 603 { .compatible = "zinitix,bt412" }, 604 { .compatible = "zinitix,bt413" }, 605 { .compatible = "zinitix,bt431" }, 606 { .compatible = "zinitix,bt432" }, 607 { .compatible = "zinitix,bt531" }, 608 { .compatible = "zinitix,bt532" }, 609 { .compatible = "zinitix,bt538" }, 610 { .compatible = "zinitix,bt541" }, 611 { .compatible = "zinitix,bt548" }, 612 { .compatible = "zinitix,bt554" }, 613 { .compatible = "zinitix,at100" }, 614 { } 615}; 616MODULE_DEVICE_TABLE(of, zinitix_of_match); 617#endif 618 619static struct i2c_driver zinitix_ts_driver = { 620 .probe = zinitix_ts_probe, 621 .driver = { 622 .name = "Zinitix-TS", 623 .pm = pm_sleep_ptr(&zinitix_pm_ops), 624 .of_match_table = of_match_ptr(zinitix_of_match), 625 }, 626}; 627module_i2c_driver(zinitix_ts_driver); 628 629MODULE_AUTHOR("Michael Srba <Michael.Srba@seznam.cz>"); 630MODULE_DESCRIPTION("Zinitix touchscreen driver"); 631MODULE_LICENSE("GPL v2"); 632