1 /* 2 * Driver for Pixcir I2C touchscreen controllers. 3 * 4 * Copyright (C) 2010-2011 Pixcir, Inc. 5 * 6 * This software is licensed under the terms of the GNU General Public 7 * License version 2, as published by the Free Software Foundation, and 8 * may be copied, distributed, and modified under those terms. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 16 #include <linux/delay.h> 17 #include <linux/module.h> 18 #include <linux/interrupt.h> 19 #include <linux/slab.h> 20 #include <linux/i2c.h> 21 #include <linux/input.h> 22 #include <linux/input/mt.h> 23 #include <linux/input/touchscreen.h> 24 #include <linux/gpio.h> 25 #include <linux/gpio/consumer.h> 26 #include <linux/of_device.h> 27 #include <linux/platform_data/pixcir_i2c_ts.h> 28 #include <asm/unaligned.h> 29 30 #define PIXCIR_MAX_SLOTS 5 /* Max fingers supported by driver */ 31 32 struct pixcir_i2c_ts_data { 33 struct i2c_client *client; 34 struct input_dev *input; 35 struct gpio_desc *gpio_attb; 36 struct gpio_desc *gpio_reset; 37 struct gpio_desc *gpio_enable; 38 struct gpio_desc *gpio_wake; 39 const struct pixcir_i2c_chip_data *chip; 40 struct touchscreen_properties prop; 41 int max_fingers; /* Max fingers supported in this instance */ 42 bool running; 43 }; 44 45 struct pixcir_report_data { 46 int num_touches; 47 struct input_mt_pos pos[PIXCIR_MAX_SLOTS]; 48 int ids[PIXCIR_MAX_SLOTS]; 49 }; 50 51 static void pixcir_ts_parse(struct pixcir_i2c_ts_data *tsdata, 52 struct pixcir_report_data *report) 53 { 54 u8 rdbuf[2 + PIXCIR_MAX_SLOTS * 5]; 55 u8 wrbuf[1] = { 0 }; 56 u8 *bufptr; 57 u8 touch; 58 int ret, i; 59 int readsize; 60 const struct pixcir_i2c_chip_data *chip = tsdata->chip; 61 62 memset(report, 0, sizeof(struct pixcir_report_data)); 63 64 i = chip->has_hw_ids ? 1 : 0; 65 readsize = 2 + tsdata->max_fingers * (4 + i); 66 if (readsize > sizeof(rdbuf)) 67 readsize = sizeof(rdbuf); 68 69 ret = i2c_master_send(tsdata->client, wrbuf, sizeof(wrbuf)); 70 if (ret != sizeof(wrbuf)) { 71 dev_err(&tsdata->client->dev, 72 "%s: i2c_master_send failed(), ret=%d\n", 73 __func__, ret); 74 return; 75 } 76 77 ret = i2c_master_recv(tsdata->client, rdbuf, readsize); 78 if (ret != readsize) { 79 dev_err(&tsdata->client->dev, 80 "%s: i2c_master_recv failed(), ret=%d\n", 81 __func__, ret); 82 return; 83 } 84 85 touch = rdbuf[0] & 0x7; 86 if (touch > tsdata->max_fingers) 87 touch = tsdata->max_fingers; 88 89 report->num_touches = touch; 90 bufptr = &rdbuf[2]; 91 92 for (i = 0; i < touch; i++) { 93 touchscreen_set_mt_pos(&report->pos[i], &tsdata->prop, 94 get_unaligned_le16(bufptr), 95 get_unaligned_le16(bufptr + 2)); 96 if (chip->has_hw_ids) { 97 report->ids[i] = bufptr[4]; 98 bufptr = bufptr + 5; 99 } else { 100 bufptr = bufptr + 4; 101 } 102 } 103 } 104 105 static void pixcir_ts_report(struct pixcir_i2c_ts_data *ts, 106 struct pixcir_report_data *report) 107 { 108 int slots[PIXCIR_MAX_SLOTS]; 109 int n, i, slot; 110 struct device *dev = &ts->client->dev; 111 const struct pixcir_i2c_chip_data *chip = ts->chip; 112 113 n = report->num_touches; 114 if (n > PIXCIR_MAX_SLOTS) 115 n = PIXCIR_MAX_SLOTS; 116 117 if (!ts->chip->has_hw_ids) 118 input_mt_assign_slots(ts->input, slots, report->pos, n, 0); 119 120 for (i = 0; i < n; i++) { 121 if (chip->has_hw_ids) { 122 slot = input_mt_get_slot_by_key(ts->input, 123 report->ids[i]); 124 if (slot < 0) { 125 dev_dbg(dev, "no free slot for id 0x%x\n", 126 report->ids[i]); 127 continue; 128 } 129 } else { 130 slot = slots[i]; 131 } 132 133 input_mt_slot(ts->input, slot); 134 input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true); 135 136 input_report_abs(ts->input, ABS_MT_POSITION_X, 137 report->pos[i].x); 138 input_report_abs(ts->input, ABS_MT_POSITION_Y, 139 report->pos[i].y); 140 141 dev_dbg(dev, "%d: slot %d, x %d, y %d\n", 142 i, slot, report->pos[i].x, report->pos[i].y); 143 } 144 145 input_mt_sync_frame(ts->input); 146 input_sync(ts->input); 147 } 148 149 static irqreturn_t pixcir_ts_isr(int irq, void *dev_id) 150 { 151 struct pixcir_i2c_ts_data *tsdata = dev_id; 152 struct pixcir_report_data report; 153 154 while (tsdata->running) { 155 /* parse packet */ 156 pixcir_ts_parse(tsdata, &report); 157 158 /* report it */ 159 pixcir_ts_report(tsdata, &report); 160 161 if (gpiod_get_value_cansleep(tsdata->gpio_attb)) { 162 if (report.num_touches) { 163 /* 164 * Last report with no finger up? 165 * Do it now then. 166 */ 167 input_mt_sync_frame(tsdata->input); 168 input_sync(tsdata->input); 169 } 170 break; 171 } 172 173 msleep(20); 174 } 175 176 return IRQ_HANDLED; 177 } 178 179 static void pixcir_reset(struct pixcir_i2c_ts_data *tsdata) 180 { 181 if (!IS_ERR_OR_NULL(tsdata->gpio_reset)) { 182 gpiod_set_value_cansleep(tsdata->gpio_reset, 1); 183 ndelay(100); /* datasheet section 1.2.3 says 80ns min. */ 184 gpiod_set_value_cansleep(tsdata->gpio_reset, 0); 185 /* wait for controller ready. 100ms guess. */ 186 msleep(100); 187 } 188 } 189 190 static int pixcir_set_power_mode(struct pixcir_i2c_ts_data *ts, 191 enum pixcir_power_mode mode) 192 { 193 struct device *dev = &ts->client->dev; 194 int ret; 195 196 if (mode == PIXCIR_POWER_ACTIVE || mode == PIXCIR_POWER_IDLE) { 197 if (ts->gpio_wake) 198 gpiod_set_value_cansleep(ts->gpio_wake, 1); 199 } 200 201 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_POWER_MODE); 202 if (ret < 0) { 203 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 204 __func__, PIXCIR_REG_POWER_MODE, ret); 205 return ret; 206 } 207 208 ret &= ~PIXCIR_POWER_MODE_MASK; 209 ret |= mode; 210 211 /* Always AUTO_IDLE */ 212 ret |= PIXCIR_POWER_ALLOW_IDLE; 213 214 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_POWER_MODE, ret); 215 if (ret < 0) { 216 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 217 __func__, PIXCIR_REG_POWER_MODE, ret); 218 return ret; 219 } 220 221 if (mode == PIXCIR_POWER_HALT) { 222 if (ts->gpio_wake) 223 gpiod_set_value_cansleep(ts->gpio_wake, 0); 224 } 225 226 return 0; 227 } 228 229 /* 230 * Set the interrupt mode for the device i.e. ATTB line behaviour 231 * 232 * @polarity : 1 for active high, 0 for active low. 233 */ 234 static int pixcir_set_int_mode(struct pixcir_i2c_ts_data *ts, 235 enum pixcir_int_mode mode, bool polarity) 236 { 237 struct device *dev = &ts->client->dev; 238 int ret; 239 240 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); 241 if (ret < 0) { 242 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 243 __func__, PIXCIR_REG_INT_MODE, ret); 244 return ret; 245 } 246 247 ret &= ~PIXCIR_INT_MODE_MASK; 248 ret |= mode; 249 250 if (polarity) 251 ret |= PIXCIR_INT_POL_HIGH; 252 else 253 ret &= ~PIXCIR_INT_POL_HIGH; 254 255 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); 256 if (ret < 0) { 257 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 258 __func__, PIXCIR_REG_INT_MODE, ret); 259 return ret; 260 } 261 262 return 0; 263 } 264 265 /* 266 * Enable/disable interrupt generation 267 */ 268 static int pixcir_int_enable(struct pixcir_i2c_ts_data *ts, bool enable) 269 { 270 struct device *dev = &ts->client->dev; 271 int ret; 272 273 ret = i2c_smbus_read_byte_data(ts->client, PIXCIR_REG_INT_MODE); 274 if (ret < 0) { 275 dev_err(dev, "%s: can't read reg 0x%x : %d\n", 276 __func__, PIXCIR_REG_INT_MODE, ret); 277 return ret; 278 } 279 280 if (enable) 281 ret |= PIXCIR_INT_ENABLE; 282 else 283 ret &= ~PIXCIR_INT_ENABLE; 284 285 ret = i2c_smbus_write_byte_data(ts->client, PIXCIR_REG_INT_MODE, ret); 286 if (ret < 0) { 287 dev_err(dev, "%s: can't write reg 0x%x : %d\n", 288 __func__, PIXCIR_REG_INT_MODE, ret); 289 return ret; 290 } 291 292 return 0; 293 } 294 295 static int pixcir_start(struct pixcir_i2c_ts_data *ts) 296 { 297 struct device *dev = &ts->client->dev; 298 int error; 299 300 if (ts->gpio_enable) { 301 gpiod_set_value_cansleep(ts->gpio_enable, 1); 302 msleep(100); 303 } 304 305 /* LEVEL_TOUCH interrupt with active low polarity */ 306 error = pixcir_set_int_mode(ts, PIXCIR_INT_LEVEL_TOUCH, 0); 307 if (error) { 308 dev_err(dev, "Failed to set interrupt mode: %d\n", error); 309 return error; 310 } 311 312 ts->running = true; 313 mb(); /* Update status before IRQ can fire */ 314 315 /* enable interrupt generation */ 316 error = pixcir_int_enable(ts, true); 317 if (error) { 318 dev_err(dev, "Failed to enable interrupt generation: %d\n", 319 error); 320 return error; 321 } 322 323 return 0; 324 } 325 326 static int pixcir_stop(struct pixcir_i2c_ts_data *ts) 327 { 328 int error; 329 330 /* Disable interrupt generation */ 331 error = pixcir_int_enable(ts, false); 332 if (error) { 333 dev_err(&ts->client->dev, 334 "Failed to disable interrupt generation: %d\n", 335 error); 336 return error; 337 } 338 339 /* Exit ISR if running, no more report parsing */ 340 ts->running = false; 341 mb(); /* update status before we synchronize irq */ 342 343 /* Wait till running ISR is complete */ 344 synchronize_irq(ts->client->irq); 345 346 if (ts->gpio_enable) 347 gpiod_set_value_cansleep(ts->gpio_enable, 0); 348 349 return 0; 350 } 351 352 static int pixcir_input_open(struct input_dev *dev) 353 { 354 struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); 355 356 return pixcir_start(ts); 357 } 358 359 static void pixcir_input_close(struct input_dev *dev) 360 { 361 struct pixcir_i2c_ts_data *ts = input_get_drvdata(dev); 362 363 pixcir_stop(ts); 364 } 365 366 static int __maybe_unused pixcir_i2c_ts_suspend(struct device *dev) 367 { 368 struct i2c_client *client = to_i2c_client(dev); 369 struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); 370 struct input_dev *input = ts->input; 371 int ret = 0; 372 373 mutex_lock(&input->mutex); 374 375 if (device_may_wakeup(&client->dev)) { 376 if (!input->users) { 377 ret = pixcir_start(ts); 378 if (ret) { 379 dev_err(dev, "Failed to start\n"); 380 goto unlock; 381 } 382 } 383 } else if (input->users) { 384 ret = pixcir_stop(ts); 385 } 386 387 unlock: 388 mutex_unlock(&input->mutex); 389 390 return ret; 391 } 392 393 static int __maybe_unused pixcir_i2c_ts_resume(struct device *dev) 394 { 395 struct i2c_client *client = to_i2c_client(dev); 396 struct pixcir_i2c_ts_data *ts = i2c_get_clientdata(client); 397 struct input_dev *input = ts->input; 398 int ret = 0; 399 400 mutex_lock(&input->mutex); 401 402 if (device_may_wakeup(&client->dev)) { 403 404 if (!input->users) { 405 ret = pixcir_stop(ts); 406 if (ret) { 407 dev_err(dev, "Failed to stop\n"); 408 goto unlock; 409 } 410 } 411 } else if (input->users) { 412 ret = pixcir_start(ts); 413 } 414 415 unlock: 416 mutex_unlock(&input->mutex); 417 418 return ret; 419 } 420 421 static SIMPLE_DEV_PM_OPS(pixcir_dev_pm_ops, 422 pixcir_i2c_ts_suspend, pixcir_i2c_ts_resume); 423 424 #ifdef CONFIG_OF 425 static const struct of_device_id pixcir_of_match[]; 426 427 static int pixcir_parse_dt(struct device *dev, 428 struct pixcir_i2c_ts_data *tsdata) 429 { 430 tsdata->chip = of_device_get_match_data(dev); 431 if (!tsdata->chip) 432 return -EINVAL; 433 434 return 0; 435 } 436 #else 437 static int pixcir_parse_dt(struct device *dev, 438 struct pixcir_i2c_ts_data *tsdata) 439 { 440 return -EINVAL; 441 } 442 #endif 443 444 static int pixcir_i2c_ts_probe(struct i2c_client *client, 445 const struct i2c_device_id *id) 446 { 447 const struct pixcir_ts_platform_data *pdata = 448 dev_get_platdata(&client->dev); 449 struct device *dev = &client->dev; 450 struct pixcir_i2c_ts_data *tsdata; 451 struct input_dev *input; 452 int error; 453 454 tsdata = devm_kzalloc(dev, sizeof(*tsdata), GFP_KERNEL); 455 if (!tsdata) 456 return -ENOMEM; 457 458 if (pdata) { 459 tsdata->chip = &pdata->chip; 460 } else if (dev->of_node) { 461 error = pixcir_parse_dt(dev, tsdata); 462 if (error) 463 return error; 464 } else { 465 dev_err(&client->dev, "platform data not defined\n"); 466 return -EINVAL; 467 } 468 469 if (!tsdata->chip->max_fingers) { 470 dev_err(dev, "Invalid max_fingers in chip data\n"); 471 return -EINVAL; 472 } 473 474 input = devm_input_allocate_device(dev); 475 if (!input) { 476 dev_err(dev, "Failed to allocate input device\n"); 477 return -ENOMEM; 478 } 479 480 tsdata->client = client; 481 tsdata->input = input; 482 483 input->name = client->name; 484 input->id.bustype = BUS_I2C; 485 input->open = pixcir_input_open; 486 input->close = pixcir_input_close; 487 input->dev.parent = &client->dev; 488 489 if (pdata) { 490 input_set_abs_params(input, ABS_MT_POSITION_X, 0, pdata->x_max, 0, 0); 491 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, pdata->y_max, 0, 0); 492 } else { 493 input_set_capability(input, EV_ABS, ABS_MT_POSITION_X); 494 input_set_capability(input, EV_ABS, ABS_MT_POSITION_Y); 495 touchscreen_parse_properties(input, true, &tsdata->prop); 496 if (!input_abs_get_max(input, ABS_MT_POSITION_X) || 497 !input_abs_get_max(input, ABS_MT_POSITION_Y)) { 498 dev_err(dev, "Touchscreen size is not specified\n"); 499 return -EINVAL; 500 } 501 } 502 503 tsdata->max_fingers = tsdata->chip->max_fingers; 504 if (tsdata->max_fingers > PIXCIR_MAX_SLOTS) { 505 tsdata->max_fingers = PIXCIR_MAX_SLOTS; 506 dev_info(dev, "Limiting maximum fingers to %d\n", 507 tsdata->max_fingers); 508 } 509 510 error = input_mt_init_slots(input, tsdata->max_fingers, 511 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 512 if (error) { 513 dev_err(dev, "Error initializing Multi-Touch slots\n"); 514 return error; 515 } 516 517 input_set_drvdata(input, tsdata); 518 519 tsdata->gpio_attb = devm_gpiod_get(dev, "attb", GPIOD_IN); 520 if (IS_ERR(tsdata->gpio_attb)) { 521 error = PTR_ERR(tsdata->gpio_attb); 522 dev_err(dev, "Failed to request ATTB gpio: %d\n", error); 523 return error; 524 } 525 526 tsdata->gpio_reset = devm_gpiod_get_optional(dev, "reset", 527 GPIOD_OUT_LOW); 528 if (IS_ERR(tsdata->gpio_reset)) { 529 error = PTR_ERR(tsdata->gpio_reset); 530 dev_err(dev, "Failed to request RESET gpio: %d\n", error); 531 return error; 532 } 533 534 tsdata->gpio_wake = devm_gpiod_get_optional(dev, "wake", 535 GPIOD_OUT_HIGH); 536 if (IS_ERR(tsdata->gpio_wake)) { 537 error = PTR_ERR(tsdata->gpio_wake); 538 if (error != -EPROBE_DEFER) 539 dev_err(dev, "Failed to get wake gpio: %d\n", error); 540 return error; 541 } 542 543 tsdata->gpio_enable = devm_gpiod_get_optional(dev, "enable", 544 GPIOD_OUT_HIGH); 545 if (IS_ERR(tsdata->gpio_enable)) { 546 error = PTR_ERR(tsdata->gpio_enable); 547 if (error != -EPROBE_DEFER) 548 dev_err(dev, "Failed to get enable gpio: %d\n", error); 549 return error; 550 } 551 552 if (tsdata->gpio_enable) 553 msleep(100); 554 555 error = devm_request_threaded_irq(dev, client->irq, NULL, pixcir_ts_isr, 556 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 557 client->name, tsdata); 558 if (error) { 559 dev_err(dev, "failed to request irq %d\n", client->irq); 560 return error; 561 } 562 563 pixcir_reset(tsdata); 564 565 /* Always be in IDLE mode to save power, device supports auto wake */ 566 error = pixcir_set_power_mode(tsdata, PIXCIR_POWER_IDLE); 567 if (error) { 568 dev_err(dev, "Failed to set IDLE mode\n"); 569 return error; 570 } 571 572 /* Stop device till opened */ 573 error = pixcir_stop(tsdata); 574 if (error) 575 return error; 576 577 error = input_register_device(input); 578 if (error) 579 return error; 580 581 i2c_set_clientdata(client, tsdata); 582 583 return 0; 584 } 585 586 static const struct i2c_device_id pixcir_i2c_ts_id[] = { 587 { "pixcir_ts", 0 }, 588 { "pixcir_tangoc", 0 }, 589 { } 590 }; 591 MODULE_DEVICE_TABLE(i2c, pixcir_i2c_ts_id); 592 593 #ifdef CONFIG_OF 594 static const struct pixcir_i2c_chip_data pixcir_ts_data = { 595 .max_fingers = 2, 596 /* no hw id support */ 597 }; 598 599 static const struct pixcir_i2c_chip_data pixcir_tangoc_data = { 600 .max_fingers = 5, 601 .has_hw_ids = true, 602 }; 603 604 static const struct of_device_id pixcir_of_match[] = { 605 { .compatible = "pixcir,pixcir_ts", .data = &pixcir_ts_data }, 606 { .compatible = "pixcir,pixcir_tangoc", .data = &pixcir_tangoc_data }, 607 { } 608 }; 609 MODULE_DEVICE_TABLE(of, pixcir_of_match); 610 #endif 611 612 static struct i2c_driver pixcir_i2c_ts_driver = { 613 .driver = { 614 .name = "pixcir_ts", 615 .pm = &pixcir_dev_pm_ops, 616 .of_match_table = of_match_ptr(pixcir_of_match), 617 }, 618 .probe = pixcir_i2c_ts_probe, 619 .id_table = pixcir_i2c_ts_id, 620 }; 621 622 module_i2c_driver(pixcir_i2c_ts_driver); 623 624 MODULE_AUTHOR("Jianchun Bian <jcbian@pixcir.com.cn>, Dequan Meng <dqmeng@pixcir.com.cn>"); 625 MODULE_DESCRIPTION("Pixcir I2C Touchscreen Driver"); 626 MODULE_LICENSE("GPL"); 627