1 /* 2 * TPO TD043MTEA1 Panel driver 3 * 4 * Author: Gražvydas Ignotas <notasas@gmail.com> 5 * Converted to new DSS device model: Tomi Valkeinen <tomi.valkeinen@ti.com> 6 * 7 * This program is free software; you can redistribute it and/or modify 8 * it under the terms of the GNU General Public License as published by 9 * the Free Software Foundation; either version 2 of the License, or 10 * (at your option) any later version. 11 */ 12 13 #include <linux/module.h> 14 #include <linux/delay.h> 15 #include <linux/spi/spi.h> 16 #include <linux/regulator/consumer.h> 17 #include <linux/gpio.h> 18 #include <linux/err.h> 19 #include <linux/slab.h> 20 #include <linux/of_gpio.h> 21 22 #include <video/omapfb_dss.h> 23 24 #define TPO_R02_MODE(x) ((x) & 7) 25 #define TPO_R02_MODE_800x480 7 26 #define TPO_R02_NCLK_RISING BIT(3) 27 #define TPO_R02_HSYNC_HIGH BIT(4) 28 #define TPO_R02_VSYNC_HIGH BIT(5) 29 30 #define TPO_R03_NSTANDBY BIT(0) 31 #define TPO_R03_EN_CP_CLK BIT(1) 32 #define TPO_R03_EN_VGL_PUMP BIT(2) 33 #define TPO_R03_EN_PWM BIT(3) 34 #define TPO_R03_DRIVING_CAP_100 BIT(4) 35 #define TPO_R03_EN_PRE_CHARGE BIT(6) 36 #define TPO_R03_SOFTWARE_CTL BIT(7) 37 38 #define TPO_R04_NFLIP_H BIT(0) 39 #define TPO_R04_NFLIP_V BIT(1) 40 #define TPO_R04_CP_CLK_FREQ_1H BIT(2) 41 #define TPO_R04_VGL_FREQ_1H BIT(4) 42 43 #define TPO_R03_VAL_NORMAL (TPO_R03_NSTANDBY | TPO_R03_EN_CP_CLK | \ 44 TPO_R03_EN_VGL_PUMP | TPO_R03_EN_PWM | \ 45 TPO_R03_DRIVING_CAP_100 | TPO_R03_EN_PRE_CHARGE | \ 46 TPO_R03_SOFTWARE_CTL) 47 48 #define TPO_R03_VAL_STANDBY (TPO_R03_DRIVING_CAP_100 | \ 49 TPO_R03_EN_PRE_CHARGE | TPO_R03_SOFTWARE_CTL) 50 51 static const u16 tpo_td043_def_gamma[12] = { 52 105, 315, 381, 431, 490, 537, 579, 686, 780, 837, 880, 1023 53 }; 54 55 struct panel_drv_data { 56 struct omap_dss_device dssdev; 57 struct omap_dss_device *in; 58 59 struct omap_video_timings videomode; 60 61 int data_lines; 62 63 struct spi_device *spi; 64 struct regulator *vcc_reg; 65 int nreset_gpio; 66 u16 gamma[12]; 67 u32 mode; 68 u32 hmirror:1; 69 u32 vmirror:1; 70 u32 powered_on:1; 71 u32 spi_suspended:1; 72 u32 power_on_resume:1; 73 }; 74 75 static const struct omap_video_timings tpo_td043_timings = { 76 .x_res = 800, 77 .y_res = 480, 78 79 .pixelclock = 36000000, 80 81 .hsw = 1, 82 .hfp = 68, 83 .hbp = 214, 84 85 .vsw = 1, 86 .vfp = 39, 87 .vbp = 34, 88 89 .vsync_level = OMAPDSS_SIG_ACTIVE_LOW, 90 .hsync_level = OMAPDSS_SIG_ACTIVE_LOW, 91 .data_pclk_edge = OMAPDSS_DRIVE_SIG_FALLING_EDGE, 92 .de_level = OMAPDSS_SIG_ACTIVE_HIGH, 93 .sync_pclk_edge = OMAPDSS_DRIVE_SIG_RISING_EDGE, 94 }; 95 96 #define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev) 97 98 static int tpo_td043_write(struct spi_device *spi, u8 addr, u8 data) 99 { 100 struct spi_message m; 101 struct spi_transfer xfer; 102 u16 w; 103 int r; 104 105 spi_message_init(&m); 106 107 memset(&xfer, 0, sizeof(xfer)); 108 109 w = ((u16)addr << 10) | (1 << 8) | data; 110 xfer.tx_buf = &w; 111 xfer.bits_per_word = 16; 112 xfer.len = 2; 113 spi_message_add_tail(&xfer, &m); 114 115 r = spi_sync(spi, &m); 116 if (r < 0) 117 dev_warn(&spi->dev, "failed to write to LCD reg (%d)\n", r); 118 return r; 119 } 120 121 static void tpo_td043_write_gamma(struct spi_device *spi, u16 gamma[12]) 122 { 123 u8 i, val; 124 125 /* gamma bits [9:8] */ 126 for (val = i = 0; i < 4; i++) 127 val |= (gamma[i] & 0x300) >> ((i + 1) * 2); 128 tpo_td043_write(spi, 0x11, val); 129 130 for (val = i = 0; i < 4; i++) 131 val |= (gamma[i+4] & 0x300) >> ((i + 1) * 2); 132 tpo_td043_write(spi, 0x12, val); 133 134 for (val = i = 0; i < 4; i++) 135 val |= (gamma[i+8] & 0x300) >> ((i + 1) * 2); 136 tpo_td043_write(spi, 0x13, val); 137 138 /* gamma bits [7:0] */ 139 for (val = i = 0; i < 12; i++) 140 tpo_td043_write(spi, 0x14 + i, gamma[i] & 0xff); 141 } 142 143 static int tpo_td043_write_mirror(struct spi_device *spi, bool h, bool v) 144 { 145 u8 reg4 = TPO_R04_NFLIP_H | TPO_R04_NFLIP_V | 146 TPO_R04_CP_CLK_FREQ_1H | TPO_R04_VGL_FREQ_1H; 147 if (h) 148 reg4 &= ~TPO_R04_NFLIP_H; 149 if (v) 150 reg4 &= ~TPO_R04_NFLIP_V; 151 152 return tpo_td043_write(spi, 4, reg4); 153 } 154 155 static int tpo_td043_set_hmirror(struct omap_dss_device *dssdev, bool enable) 156 { 157 struct panel_drv_data *ddata = dev_get_drvdata(dssdev->dev); 158 159 ddata->hmirror = enable; 160 return tpo_td043_write_mirror(ddata->spi, ddata->hmirror, 161 ddata->vmirror); 162 } 163 164 static bool tpo_td043_get_hmirror(struct omap_dss_device *dssdev) 165 { 166 struct panel_drv_data *ddata = dev_get_drvdata(dssdev->dev); 167 168 return ddata->hmirror; 169 } 170 171 static ssize_t tpo_td043_vmirror_show(struct device *dev, 172 struct device_attribute *attr, char *buf) 173 { 174 struct panel_drv_data *ddata = dev_get_drvdata(dev); 175 176 return snprintf(buf, PAGE_SIZE, "%d\n", ddata->vmirror); 177 } 178 179 static ssize_t tpo_td043_vmirror_store(struct device *dev, 180 struct device_attribute *attr, const char *buf, size_t count) 181 { 182 struct panel_drv_data *ddata = dev_get_drvdata(dev); 183 int val; 184 int ret; 185 186 ret = kstrtoint(buf, 0, &val); 187 if (ret < 0) 188 return ret; 189 190 val = !!val; 191 192 ret = tpo_td043_write_mirror(ddata->spi, ddata->hmirror, val); 193 if (ret < 0) 194 return ret; 195 196 ddata->vmirror = val; 197 198 return count; 199 } 200 201 static ssize_t tpo_td043_mode_show(struct device *dev, 202 struct device_attribute *attr, char *buf) 203 { 204 struct panel_drv_data *ddata = dev_get_drvdata(dev); 205 206 return snprintf(buf, PAGE_SIZE, "%d\n", ddata->mode); 207 } 208 209 static ssize_t tpo_td043_mode_store(struct device *dev, 210 struct device_attribute *attr, const char *buf, size_t count) 211 { 212 struct panel_drv_data *ddata = dev_get_drvdata(dev); 213 long val; 214 int ret; 215 216 ret = kstrtol(buf, 0, &val); 217 if (ret != 0 || val & ~7) 218 return -EINVAL; 219 220 ddata->mode = val; 221 222 val |= TPO_R02_NCLK_RISING; 223 tpo_td043_write(ddata->spi, 2, val); 224 225 return count; 226 } 227 228 static ssize_t tpo_td043_gamma_show(struct device *dev, 229 struct device_attribute *attr, char *buf) 230 { 231 struct panel_drv_data *ddata = dev_get_drvdata(dev); 232 ssize_t len = 0; 233 int ret; 234 int i; 235 236 for (i = 0; i < ARRAY_SIZE(ddata->gamma); i++) { 237 ret = snprintf(buf + len, PAGE_SIZE - len, "%u ", 238 ddata->gamma[i]); 239 if (ret < 0) 240 return ret; 241 len += ret; 242 } 243 buf[len - 1] = '\n'; 244 245 return len; 246 } 247 248 static ssize_t tpo_td043_gamma_store(struct device *dev, 249 struct device_attribute *attr, const char *buf, size_t count) 250 { 251 struct panel_drv_data *ddata = dev_get_drvdata(dev); 252 unsigned int g[12]; 253 int ret; 254 int i; 255 256 ret = sscanf(buf, "%u %u %u %u %u %u %u %u %u %u %u %u", 257 &g[0], &g[1], &g[2], &g[3], &g[4], &g[5], 258 &g[6], &g[7], &g[8], &g[9], &g[10], &g[11]); 259 260 if (ret != 12) 261 return -EINVAL; 262 263 for (i = 0; i < 12; i++) 264 ddata->gamma[i] = g[i]; 265 266 tpo_td043_write_gamma(ddata->spi, ddata->gamma); 267 268 return count; 269 } 270 271 static DEVICE_ATTR(vmirror, S_IRUGO | S_IWUSR, 272 tpo_td043_vmirror_show, tpo_td043_vmirror_store); 273 static DEVICE_ATTR(mode, S_IRUGO | S_IWUSR, 274 tpo_td043_mode_show, tpo_td043_mode_store); 275 static DEVICE_ATTR(gamma, S_IRUGO | S_IWUSR, 276 tpo_td043_gamma_show, tpo_td043_gamma_store); 277 278 static struct attribute *tpo_td043_attrs[] = { 279 &dev_attr_vmirror.attr, 280 &dev_attr_mode.attr, 281 &dev_attr_gamma.attr, 282 NULL, 283 }; 284 285 static const struct attribute_group tpo_td043_attr_group = { 286 .attrs = tpo_td043_attrs, 287 }; 288 289 static int tpo_td043_power_on(struct panel_drv_data *ddata) 290 { 291 int r; 292 293 if (ddata->powered_on) 294 return 0; 295 296 r = regulator_enable(ddata->vcc_reg); 297 if (r != 0) 298 return r; 299 300 /* wait for panel to stabilize */ 301 msleep(160); 302 303 if (gpio_is_valid(ddata->nreset_gpio)) 304 gpio_set_value(ddata->nreset_gpio, 1); 305 306 tpo_td043_write(ddata->spi, 2, 307 TPO_R02_MODE(ddata->mode) | TPO_R02_NCLK_RISING); 308 tpo_td043_write(ddata->spi, 3, TPO_R03_VAL_NORMAL); 309 tpo_td043_write(ddata->spi, 0x20, 0xf0); 310 tpo_td043_write(ddata->spi, 0x21, 0xf0); 311 tpo_td043_write_mirror(ddata->spi, ddata->hmirror, 312 ddata->vmirror); 313 tpo_td043_write_gamma(ddata->spi, ddata->gamma); 314 315 ddata->powered_on = 1; 316 return 0; 317 } 318 319 static void tpo_td043_power_off(struct panel_drv_data *ddata) 320 { 321 if (!ddata->powered_on) 322 return; 323 324 tpo_td043_write(ddata->spi, 3, 325 TPO_R03_VAL_STANDBY | TPO_R03_EN_PWM); 326 327 if (gpio_is_valid(ddata->nreset_gpio)) 328 gpio_set_value(ddata->nreset_gpio, 0); 329 330 /* wait for at least 2 vsyncs before cutting off power */ 331 msleep(50); 332 333 tpo_td043_write(ddata->spi, 3, TPO_R03_VAL_STANDBY); 334 335 regulator_disable(ddata->vcc_reg); 336 337 ddata->powered_on = 0; 338 } 339 340 static int tpo_td043_connect(struct omap_dss_device *dssdev) 341 { 342 struct panel_drv_data *ddata = to_panel_data(dssdev); 343 struct omap_dss_device *in = ddata->in; 344 int r; 345 346 if (omapdss_device_is_connected(dssdev)) 347 return 0; 348 349 r = in->ops.dpi->connect(in, dssdev); 350 if (r) 351 return r; 352 353 return 0; 354 } 355 356 static void tpo_td043_disconnect(struct omap_dss_device *dssdev) 357 { 358 struct panel_drv_data *ddata = to_panel_data(dssdev); 359 struct omap_dss_device *in = ddata->in; 360 361 if (!omapdss_device_is_connected(dssdev)) 362 return; 363 364 in->ops.dpi->disconnect(in, dssdev); 365 } 366 367 static int tpo_td043_enable(struct omap_dss_device *dssdev) 368 { 369 struct panel_drv_data *ddata = to_panel_data(dssdev); 370 struct omap_dss_device *in = ddata->in; 371 int r; 372 373 if (!omapdss_device_is_connected(dssdev)) 374 return -ENODEV; 375 376 if (omapdss_device_is_enabled(dssdev)) 377 return 0; 378 379 if (ddata->data_lines) 380 in->ops.dpi->set_data_lines(in, ddata->data_lines); 381 in->ops.dpi->set_timings(in, &ddata->videomode); 382 383 r = in->ops.dpi->enable(in); 384 if (r) 385 return r; 386 387 /* 388 * If we are resuming from system suspend, SPI clocks might not be 389 * enabled yet, so we'll program the LCD from SPI PM resume callback. 390 */ 391 if (!ddata->spi_suspended) { 392 r = tpo_td043_power_on(ddata); 393 if (r) { 394 in->ops.dpi->disable(in); 395 return r; 396 } 397 } 398 399 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; 400 401 return 0; 402 } 403 404 static void tpo_td043_disable(struct omap_dss_device *dssdev) 405 { 406 struct panel_drv_data *ddata = to_panel_data(dssdev); 407 struct omap_dss_device *in = ddata->in; 408 409 if (!omapdss_device_is_enabled(dssdev)) 410 return; 411 412 in->ops.dpi->disable(in); 413 414 if (!ddata->spi_suspended) 415 tpo_td043_power_off(ddata); 416 417 dssdev->state = OMAP_DSS_DISPLAY_DISABLED; 418 } 419 420 static void tpo_td043_set_timings(struct omap_dss_device *dssdev, 421 struct omap_video_timings *timings) 422 { 423 struct panel_drv_data *ddata = to_panel_data(dssdev); 424 struct omap_dss_device *in = ddata->in; 425 426 ddata->videomode = *timings; 427 dssdev->panel.timings = *timings; 428 429 in->ops.dpi->set_timings(in, timings); 430 } 431 432 static void tpo_td043_get_timings(struct omap_dss_device *dssdev, 433 struct omap_video_timings *timings) 434 { 435 struct panel_drv_data *ddata = to_panel_data(dssdev); 436 437 *timings = ddata->videomode; 438 } 439 440 static int tpo_td043_check_timings(struct omap_dss_device *dssdev, 441 struct omap_video_timings *timings) 442 { 443 struct panel_drv_data *ddata = to_panel_data(dssdev); 444 struct omap_dss_device *in = ddata->in; 445 446 return in->ops.dpi->check_timings(in, timings); 447 } 448 449 static struct omap_dss_driver tpo_td043_ops = { 450 .connect = tpo_td043_connect, 451 .disconnect = tpo_td043_disconnect, 452 453 .enable = tpo_td043_enable, 454 .disable = tpo_td043_disable, 455 456 .set_timings = tpo_td043_set_timings, 457 .get_timings = tpo_td043_get_timings, 458 .check_timings = tpo_td043_check_timings, 459 460 .set_mirror = tpo_td043_set_hmirror, 461 .get_mirror = tpo_td043_get_hmirror, 462 463 .get_resolution = omapdss_default_get_resolution, 464 }; 465 466 467 static int tpo_td043_probe_of(struct spi_device *spi) 468 { 469 struct device_node *node = spi->dev.of_node; 470 struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); 471 struct omap_dss_device *in; 472 int gpio; 473 474 gpio = of_get_named_gpio(node, "reset-gpios", 0); 475 if (!gpio_is_valid(gpio)) { 476 dev_err(&spi->dev, "failed to parse enable gpio\n"); 477 return gpio; 478 } 479 ddata->nreset_gpio = gpio; 480 481 in = omapdss_of_find_source_for_first_ep(node); 482 if (IS_ERR(in)) { 483 dev_err(&spi->dev, "failed to find video source\n"); 484 return PTR_ERR(in); 485 } 486 487 ddata->in = in; 488 489 return 0; 490 } 491 492 static int tpo_td043_probe(struct spi_device *spi) 493 { 494 struct panel_drv_data *ddata; 495 struct omap_dss_device *dssdev; 496 int r; 497 498 dev_dbg(&spi->dev, "%s\n", __func__); 499 500 if (!spi->dev.of_node) 501 return -ENODEV; 502 503 spi->bits_per_word = 16; 504 spi->mode = SPI_MODE_0; 505 506 r = spi_setup(spi); 507 if (r < 0) { 508 dev_err(&spi->dev, "spi_setup failed: %d\n", r); 509 return r; 510 } 511 512 ddata = devm_kzalloc(&spi->dev, sizeof(*ddata), GFP_KERNEL); 513 if (ddata == NULL) 514 return -ENOMEM; 515 516 dev_set_drvdata(&spi->dev, ddata); 517 518 ddata->spi = spi; 519 520 r = tpo_td043_probe_of(spi); 521 if (r) 522 return r; 523 524 ddata->mode = TPO_R02_MODE_800x480; 525 memcpy(ddata->gamma, tpo_td043_def_gamma, sizeof(ddata->gamma)); 526 527 ddata->vcc_reg = devm_regulator_get(&spi->dev, "vcc"); 528 if (IS_ERR(ddata->vcc_reg)) { 529 dev_err(&spi->dev, "failed to get LCD VCC regulator\n"); 530 r = PTR_ERR(ddata->vcc_reg); 531 goto err_regulator; 532 } 533 534 if (gpio_is_valid(ddata->nreset_gpio)) { 535 r = devm_gpio_request_one(&spi->dev, 536 ddata->nreset_gpio, GPIOF_OUT_INIT_LOW, 537 "lcd reset"); 538 if (r < 0) { 539 dev_err(&spi->dev, "couldn't request reset GPIO\n"); 540 goto err_gpio_req; 541 } 542 } 543 544 r = sysfs_create_group(&spi->dev.kobj, &tpo_td043_attr_group); 545 if (r) { 546 dev_err(&spi->dev, "failed to create sysfs files\n"); 547 goto err_sysfs; 548 } 549 550 ddata->videomode = tpo_td043_timings; 551 552 dssdev = &ddata->dssdev; 553 dssdev->dev = &spi->dev; 554 dssdev->driver = &tpo_td043_ops; 555 dssdev->type = OMAP_DISPLAY_TYPE_DPI; 556 dssdev->owner = THIS_MODULE; 557 dssdev->panel.timings = ddata->videomode; 558 559 r = omapdss_register_display(dssdev); 560 if (r) { 561 dev_err(&spi->dev, "Failed to register panel\n"); 562 goto err_reg; 563 } 564 565 return 0; 566 567 err_reg: 568 sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group); 569 err_sysfs: 570 err_gpio_req: 571 err_regulator: 572 omap_dss_put_device(ddata->in); 573 return r; 574 } 575 576 static int tpo_td043_remove(struct spi_device *spi) 577 { 578 struct panel_drv_data *ddata = dev_get_drvdata(&spi->dev); 579 struct omap_dss_device *dssdev = &ddata->dssdev; 580 struct omap_dss_device *in = ddata->in; 581 582 dev_dbg(&ddata->spi->dev, "%s\n", __func__); 583 584 omapdss_unregister_display(dssdev); 585 586 tpo_td043_disable(dssdev); 587 tpo_td043_disconnect(dssdev); 588 589 omap_dss_put_device(in); 590 591 sysfs_remove_group(&spi->dev.kobj, &tpo_td043_attr_group); 592 593 return 0; 594 } 595 596 #ifdef CONFIG_PM_SLEEP 597 static int tpo_td043_spi_suspend(struct device *dev) 598 { 599 struct panel_drv_data *ddata = dev_get_drvdata(dev); 600 601 dev_dbg(dev, "tpo_td043_spi_suspend, tpo %p\n", ddata); 602 603 ddata->power_on_resume = ddata->powered_on; 604 tpo_td043_power_off(ddata); 605 ddata->spi_suspended = 1; 606 607 return 0; 608 } 609 610 static int tpo_td043_spi_resume(struct device *dev) 611 { 612 struct panel_drv_data *ddata = dev_get_drvdata(dev); 613 int ret; 614 615 dev_dbg(dev, "tpo_td043_spi_resume\n"); 616 617 if (ddata->power_on_resume) { 618 ret = tpo_td043_power_on(ddata); 619 if (ret) 620 return ret; 621 } 622 ddata->spi_suspended = 0; 623 624 return 0; 625 } 626 #endif 627 628 static SIMPLE_DEV_PM_OPS(tpo_td043_spi_pm, 629 tpo_td043_spi_suspend, tpo_td043_spi_resume); 630 631 static const struct of_device_id tpo_td043_of_match[] = { 632 { .compatible = "omapdss,tpo,td043mtea1", }, 633 {}, 634 }; 635 636 MODULE_DEVICE_TABLE(of, tpo_td043_of_match); 637 638 static struct spi_driver tpo_td043_spi_driver = { 639 .driver = { 640 .name = "panel-tpo-td043mtea1", 641 .pm = &tpo_td043_spi_pm, 642 .of_match_table = tpo_td043_of_match, 643 .suppress_bind_attrs = true, 644 }, 645 .probe = tpo_td043_probe, 646 .remove = tpo_td043_remove, 647 }; 648 649 module_spi_driver(tpo_td043_spi_driver); 650 651 MODULE_ALIAS("spi:tpo,td043mtea1"); 652 MODULE_AUTHOR("Gražvydas Ignotas <notasas@gmail.com>"); 653 MODULE_DESCRIPTION("TPO TD043MTEA1 LCD Driver"); 654 MODULE_LICENSE("GPL"); 655