1// SPDX-License-Identifier: GPL-2.0-only 2/* 3 * Generic DSI Command Mode panel driver 4 * 5 * Copyright (C) 2013 Texas Instruments 6 * Author: Tomi Valkeinen <tomi.valkeinen@ti.com> 7 */ 8 9/* #define DEBUG */ 10 11#include <linux/backlight.h> 12#include <linux/delay.h> 13#include <linux/err.h> 14#include <linux/fb.h> 15#include <linux/gpio/consumer.h> 16#include <linux/interrupt.h> 17#include <linux/jiffies.h> 18#include <linux/mod_devicetable.h> 19#include <linux/module.h> 20#include <linux/platform_device.h> 21#include <linux/sched/signal.h> 22#include <linux/slab.h> 23#include <linux/workqueue.h> 24 25#include <video/omapfb_dss.h> 26#include <video/mipi_display.h> 27 28/* DSI Virtual channel. Hardcoded for now. */ 29#define TCH 0 30 31#define DCS_READ_NUM_ERRORS 0x05 32#define DCS_BRIGHTNESS 0x51 33#define DCS_CTRL_DISPLAY 0x53 34#define DCS_GET_ID1 0xda 35#define DCS_GET_ID2 0xdb 36#define DCS_GET_ID3 0xdc 37 38struct panel_drv_data { 39 struct omap_dss_device dssdev; 40 struct omap_dss_device *in; 41 42 struct omap_video_timings timings; 43 44 struct platform_device *pdev; 45 46 struct mutex lock; 47 48 struct backlight_device *bldev; 49 50 unsigned long hw_guard_end; /* next value of jiffies when we can 51 * issue the next sleep in/out command 52 */ 53 unsigned long hw_guard_wait; /* max guard time in jiffies */ 54 55 /* panel HW configuration from DT or platform data */ 56 struct gpio_desc *reset_gpio; 57 struct gpio_desc *ext_te_gpio; 58 59 bool use_dsi_backlight; 60 61 struct omap_dsi_pin_config pin_config; 62 63 /* runtime variables */ 64 bool enabled; 65 66 bool te_enabled; 67 68 atomic_t do_update; 69 int channel; 70 71 struct delayed_work te_timeout_work; 72 73 bool intro_printed; 74 75 bool ulps_enabled; 76 unsigned ulps_timeout; 77 struct delayed_work ulps_work; 78}; 79 80#define to_panel_data(p) container_of(p, struct panel_drv_data, dssdev) 81 82static irqreturn_t dsicm_te_isr(int irq, void *data); 83static void dsicm_te_timeout_work_callback(struct work_struct *work); 84static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable); 85 86static int dsicm_panel_reset(struct panel_drv_data *ddata); 87 88static void dsicm_ulps_work(struct work_struct *work); 89 90static void hw_guard_start(struct panel_drv_data *ddata, int guard_msec) 91{ 92 ddata->hw_guard_wait = msecs_to_jiffies(guard_msec); 93 ddata->hw_guard_end = jiffies + ddata->hw_guard_wait; 94} 95 96static void hw_guard_wait(struct panel_drv_data *ddata) 97{ 98 unsigned long wait = ddata->hw_guard_end - jiffies; 99 100 if ((long)wait > 0 && time_before_eq(wait, ddata->hw_guard_wait)) { 101 set_current_state(TASK_UNINTERRUPTIBLE); 102 schedule_timeout(wait); 103 } 104} 105 106static int dsicm_dcs_read_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 *data) 107{ 108 struct omap_dss_device *in = ddata->in; 109 int r; 110 u8 buf[1]; 111 112 r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, buf, 1); 113 114 if (r < 0) 115 return r; 116 117 *data = buf[0]; 118 119 return 0; 120} 121 122static int dsicm_dcs_write_0(struct panel_drv_data *ddata, u8 dcs_cmd) 123{ 124 struct omap_dss_device *in = ddata->in; 125 return in->ops.dsi->dcs_write(in, ddata->channel, &dcs_cmd, 1); 126} 127 128static int dsicm_dcs_write_1(struct panel_drv_data *ddata, u8 dcs_cmd, u8 param) 129{ 130 struct omap_dss_device *in = ddata->in; 131 u8 buf[2] = { dcs_cmd, param }; 132 133 return in->ops.dsi->dcs_write(in, ddata->channel, buf, 2); 134} 135 136static int dsicm_sleep_in(struct panel_drv_data *ddata) 137 138{ 139 struct omap_dss_device *in = ddata->in; 140 u8 cmd; 141 int r; 142 143 hw_guard_wait(ddata); 144 145 cmd = MIPI_DCS_ENTER_SLEEP_MODE; 146 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, &cmd, 1); 147 if (r) 148 return r; 149 150 hw_guard_start(ddata, 120); 151 152 usleep_range(5000, 10000); 153 154 return 0; 155} 156 157static int dsicm_sleep_out(struct panel_drv_data *ddata) 158{ 159 int r; 160 161 hw_guard_wait(ddata); 162 163 r = dsicm_dcs_write_0(ddata, MIPI_DCS_EXIT_SLEEP_MODE); 164 if (r) 165 return r; 166 167 hw_guard_start(ddata, 120); 168 169 usleep_range(5000, 10000); 170 171 return 0; 172} 173 174static int dsicm_get_id(struct panel_drv_data *ddata, u8 *id1, u8 *id2, u8 *id3) 175{ 176 int r; 177 178 r = dsicm_dcs_read_1(ddata, DCS_GET_ID1, id1); 179 if (r) 180 return r; 181 r = dsicm_dcs_read_1(ddata, DCS_GET_ID2, id2); 182 if (r) 183 return r; 184 r = dsicm_dcs_read_1(ddata, DCS_GET_ID3, id3); 185 if (r) 186 return r; 187 188 return 0; 189} 190 191static int dsicm_set_update_window(struct panel_drv_data *ddata, 192 u16 x, u16 y, u16 w, u16 h) 193{ 194 struct omap_dss_device *in = ddata->in; 195 int r; 196 u16 x1 = x; 197 u16 x2 = x + w - 1; 198 u16 y1 = y; 199 u16 y2 = y + h - 1; 200 201 u8 buf[5]; 202 buf[0] = MIPI_DCS_SET_COLUMN_ADDRESS; 203 buf[1] = (x1 >> 8) & 0xff; 204 buf[2] = (x1 >> 0) & 0xff; 205 buf[3] = (x2 >> 8) & 0xff; 206 buf[4] = (x2 >> 0) & 0xff; 207 208 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf)); 209 if (r) 210 return r; 211 212 buf[0] = MIPI_DCS_SET_PAGE_ADDRESS; 213 buf[1] = (y1 >> 8) & 0xff; 214 buf[2] = (y1 >> 0) & 0xff; 215 buf[3] = (y2 >> 8) & 0xff; 216 buf[4] = (y2 >> 0) & 0xff; 217 218 r = in->ops.dsi->dcs_write_nosync(in, ddata->channel, buf, sizeof(buf)); 219 if (r) 220 return r; 221 222 in->ops.dsi->bta_sync(in, ddata->channel); 223 224 return r; 225} 226 227static void dsicm_queue_ulps_work(struct panel_drv_data *ddata) 228{ 229 if (ddata->ulps_timeout > 0) 230 schedule_delayed_work(&ddata->ulps_work, 231 msecs_to_jiffies(ddata->ulps_timeout)); 232} 233 234static void dsicm_cancel_ulps_work(struct panel_drv_data *ddata) 235{ 236 cancel_delayed_work(&ddata->ulps_work); 237} 238 239static int dsicm_enter_ulps(struct panel_drv_data *ddata) 240{ 241 struct omap_dss_device *in = ddata->in; 242 int r; 243 244 if (ddata->ulps_enabled) 245 return 0; 246 247 dsicm_cancel_ulps_work(ddata); 248 249 r = _dsicm_enable_te(ddata, false); 250 if (r) 251 goto err; 252 253 if (ddata->ext_te_gpio) 254 disable_irq(gpiod_to_irq(ddata->ext_te_gpio)); 255 256 in->ops.dsi->disable(in, false, true); 257 258 ddata->ulps_enabled = true; 259 260 return 0; 261 262err: 263 dev_err(&ddata->pdev->dev, "enter ULPS failed"); 264 dsicm_panel_reset(ddata); 265 266 ddata->ulps_enabled = false; 267 268 dsicm_queue_ulps_work(ddata); 269 270 return r; 271} 272 273static int dsicm_exit_ulps(struct panel_drv_data *ddata) 274{ 275 struct omap_dss_device *in = ddata->in; 276 int r; 277 278 if (!ddata->ulps_enabled) 279 return 0; 280 281 r = in->ops.dsi->enable(in); 282 if (r) { 283 dev_err(&ddata->pdev->dev, "failed to enable DSI\n"); 284 goto err1; 285 } 286 287 in->ops.dsi->enable_hs(in, ddata->channel, true); 288 289 r = _dsicm_enable_te(ddata, true); 290 if (r) { 291 dev_err(&ddata->pdev->dev, "failed to re-enable TE"); 292 goto err2; 293 } 294 295 if (ddata->ext_te_gpio) 296 enable_irq(gpiod_to_irq(ddata->ext_te_gpio)); 297 298 dsicm_queue_ulps_work(ddata); 299 300 ddata->ulps_enabled = false; 301 302 return 0; 303 304err2: 305 dev_err(&ddata->pdev->dev, "failed to exit ULPS"); 306 307 r = dsicm_panel_reset(ddata); 308 if (!r) { 309 if (ddata->ext_te_gpio) 310 enable_irq(gpiod_to_irq(ddata->ext_te_gpio)); 311 ddata->ulps_enabled = false; 312 } 313err1: 314 dsicm_queue_ulps_work(ddata); 315 316 return r; 317} 318 319static int dsicm_wake_up(struct panel_drv_data *ddata) 320{ 321 if (ddata->ulps_enabled) 322 return dsicm_exit_ulps(ddata); 323 324 dsicm_cancel_ulps_work(ddata); 325 dsicm_queue_ulps_work(ddata); 326 return 0; 327} 328 329static int dsicm_bl_update_status(struct backlight_device *dev) 330{ 331 struct panel_drv_data *ddata = dev_get_drvdata(&dev->dev); 332 struct omap_dss_device *in = ddata->in; 333 int r; 334 int level = backlight_get_brightness(dev); 335 336 dev_dbg(&ddata->pdev->dev, "update brightness to %d\n", level); 337 338 mutex_lock(&ddata->lock); 339 340 if (ddata->enabled) { 341 in->ops.dsi->bus_lock(in); 342 343 r = dsicm_wake_up(ddata); 344 if (!r) 345 r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, level); 346 347 in->ops.dsi->bus_unlock(in); 348 } else { 349 r = 0; 350 } 351 352 mutex_unlock(&ddata->lock); 353 354 return r; 355} 356 357static int dsicm_bl_get_intensity(struct backlight_device *dev) 358{ 359 if (dev->props.fb_blank == FB_BLANK_UNBLANK && 360 dev->props.power == FB_BLANK_UNBLANK) 361 return dev->props.brightness; 362 363 return 0; 364} 365 366static const struct backlight_ops dsicm_bl_ops = { 367 .get_brightness = dsicm_bl_get_intensity, 368 .update_status = dsicm_bl_update_status, 369}; 370 371static void dsicm_get_resolution(struct omap_dss_device *dssdev, 372 u16 *xres, u16 *yres) 373{ 374 *xres = dssdev->panel.timings.x_res; 375 *yres = dssdev->panel.timings.y_res; 376} 377 378static ssize_t dsicm_num_errors_show(struct device *dev, 379 struct device_attribute *attr, char *buf) 380{ 381 struct panel_drv_data *ddata = dev_get_drvdata(dev); 382 struct omap_dss_device *in = ddata->in; 383 u8 errors = 0; 384 int r; 385 386 mutex_lock(&ddata->lock); 387 388 if (ddata->enabled) { 389 in->ops.dsi->bus_lock(in); 390 391 r = dsicm_wake_up(ddata); 392 if (!r) 393 r = dsicm_dcs_read_1(ddata, DCS_READ_NUM_ERRORS, 394 &errors); 395 396 in->ops.dsi->bus_unlock(in); 397 } else { 398 r = -ENODEV; 399 } 400 401 mutex_unlock(&ddata->lock); 402 403 if (r) 404 return r; 405 406 return sysfs_emit(buf, "%d\n", errors); 407} 408 409static ssize_t dsicm_hw_revision_show(struct device *dev, 410 struct device_attribute *attr, char *buf) 411{ 412 struct panel_drv_data *ddata = dev_get_drvdata(dev); 413 struct omap_dss_device *in = ddata->in; 414 u8 id1, id2, id3; 415 int r; 416 417 mutex_lock(&ddata->lock); 418 419 if (ddata->enabled) { 420 in->ops.dsi->bus_lock(in); 421 422 r = dsicm_wake_up(ddata); 423 if (!r) 424 r = dsicm_get_id(ddata, &id1, &id2, &id3); 425 426 in->ops.dsi->bus_unlock(in); 427 } else { 428 r = -ENODEV; 429 } 430 431 mutex_unlock(&ddata->lock); 432 433 if (r) 434 return r; 435 436 return sysfs_emit(buf, "%02x.%02x.%02x\n", id1, id2, id3); 437} 438 439static ssize_t dsicm_store_ulps(struct device *dev, 440 struct device_attribute *attr, 441 const char *buf, size_t count) 442{ 443 struct panel_drv_data *ddata = dev_get_drvdata(dev); 444 struct omap_dss_device *in = ddata->in; 445 unsigned long t; 446 int r; 447 448 r = kstrtoul(buf, 0, &t); 449 if (r) 450 return r; 451 452 mutex_lock(&ddata->lock); 453 454 if (ddata->enabled) { 455 in->ops.dsi->bus_lock(in); 456 457 if (t) 458 r = dsicm_enter_ulps(ddata); 459 else 460 r = dsicm_wake_up(ddata); 461 462 in->ops.dsi->bus_unlock(in); 463 } 464 465 mutex_unlock(&ddata->lock); 466 467 if (r) 468 return r; 469 470 return count; 471} 472 473static ssize_t dsicm_show_ulps(struct device *dev, 474 struct device_attribute *attr, 475 char *buf) 476{ 477 struct panel_drv_data *ddata = dev_get_drvdata(dev); 478 unsigned t; 479 480 mutex_lock(&ddata->lock); 481 t = ddata->ulps_enabled; 482 mutex_unlock(&ddata->lock); 483 484 return sysfs_emit(buf, "%u\n", t); 485} 486 487static ssize_t dsicm_store_ulps_timeout(struct device *dev, 488 struct device_attribute *attr, 489 const char *buf, size_t count) 490{ 491 struct panel_drv_data *ddata = dev_get_drvdata(dev); 492 struct omap_dss_device *in = ddata->in; 493 unsigned long t; 494 int r; 495 496 r = kstrtoul(buf, 0, &t); 497 if (r) 498 return r; 499 500 mutex_lock(&ddata->lock); 501 ddata->ulps_timeout = t; 502 503 if (ddata->enabled) { 504 /* dsicm_wake_up will restart the timer */ 505 in->ops.dsi->bus_lock(in); 506 r = dsicm_wake_up(ddata); 507 in->ops.dsi->bus_unlock(in); 508 } 509 510 mutex_unlock(&ddata->lock); 511 512 if (r) 513 return r; 514 515 return count; 516} 517 518static ssize_t dsicm_show_ulps_timeout(struct device *dev, 519 struct device_attribute *attr, 520 char *buf) 521{ 522 struct panel_drv_data *ddata = dev_get_drvdata(dev); 523 unsigned t; 524 525 mutex_lock(&ddata->lock); 526 t = ddata->ulps_timeout; 527 mutex_unlock(&ddata->lock); 528 529 return sysfs_emit(buf, "%u\n", t); 530} 531 532static DEVICE_ATTR(num_dsi_errors, S_IRUGO, dsicm_num_errors_show, NULL); 533static DEVICE_ATTR(hw_revision, S_IRUGO, dsicm_hw_revision_show, NULL); 534static DEVICE_ATTR(ulps, S_IRUGO | S_IWUSR, 535 dsicm_show_ulps, dsicm_store_ulps); 536static DEVICE_ATTR(ulps_timeout, S_IRUGO | S_IWUSR, 537 dsicm_show_ulps_timeout, dsicm_store_ulps_timeout); 538 539static struct attribute *dsicm_attrs[] = { 540 &dev_attr_num_dsi_errors.attr, 541 &dev_attr_hw_revision.attr, 542 &dev_attr_ulps.attr, 543 &dev_attr_ulps_timeout.attr, 544 NULL, 545}; 546 547static const struct attribute_group dsicm_attr_group = { 548 .attrs = dsicm_attrs, 549}; 550 551static void dsicm_hw_reset(struct panel_drv_data *ddata) 552{ 553 /* 554 * Note that we appear to activate the reset line here. However 555 * existing DTSes specified incorrect polarity for it (active high), 556 * so in fact this deasserts the reset line. 557 */ 558 gpiod_set_value_cansleep(ddata->reset_gpio, 1); 559 udelay(10); 560 /* reset the panel */ 561 gpiod_set_value_cansleep(ddata->reset_gpio, 0); 562 /* keep reset asserted */ 563 udelay(10); 564 /* release reset line */ 565 gpiod_set_value_cansleep(ddata->reset_gpio, 1); 566 /* wait after releasing reset */ 567 usleep_range(5000, 10000); 568} 569 570static int dsicm_power_on(struct panel_drv_data *ddata) 571{ 572 struct omap_dss_device *in = ddata->in; 573 u8 id1, id2, id3; 574 int r; 575 struct omap_dss_dsi_config dsi_config = { 576 .mode = OMAP_DSS_DSI_CMD_MODE, 577 .pixel_format = OMAP_DSS_DSI_FMT_RGB888, 578 .timings = &ddata->timings, 579 .hs_clk_min = 150000000, 580 .hs_clk_max = 300000000, 581 .lp_clk_min = 7000000, 582 .lp_clk_max = 10000000, 583 }; 584 585 if (ddata->pin_config.num_pins > 0) { 586 r = in->ops.dsi->configure_pins(in, &ddata->pin_config); 587 if (r) { 588 dev_err(&ddata->pdev->dev, 589 "failed to configure DSI pins\n"); 590 goto err0; 591 } 592 } 593 594 r = in->ops.dsi->set_config(in, &dsi_config); 595 if (r) { 596 dev_err(&ddata->pdev->dev, "failed to configure DSI\n"); 597 goto err0; 598 } 599 600 r = in->ops.dsi->enable(in); 601 if (r) { 602 dev_err(&ddata->pdev->dev, "failed to enable DSI\n"); 603 goto err0; 604 } 605 606 dsicm_hw_reset(ddata); 607 608 in->ops.dsi->enable_hs(in, ddata->channel, false); 609 610 r = dsicm_sleep_out(ddata); 611 if (r) 612 goto err; 613 614 r = dsicm_get_id(ddata, &id1, &id2, &id3); 615 if (r) 616 goto err; 617 618 r = dsicm_dcs_write_1(ddata, DCS_BRIGHTNESS, 0xff); 619 if (r) 620 goto err; 621 622 r = dsicm_dcs_write_1(ddata, DCS_CTRL_DISPLAY, 623 (1<<2) | (1<<5)); /* BL | BCTRL */ 624 if (r) 625 goto err; 626 627 r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_PIXEL_FORMAT, 628 MIPI_DCS_PIXEL_FMT_24BIT); 629 if (r) 630 goto err; 631 632 r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_ON); 633 if (r) 634 goto err; 635 636 r = _dsicm_enable_te(ddata, ddata->te_enabled); 637 if (r) 638 goto err; 639 640 r = in->ops.dsi->enable_video_output(in, ddata->channel); 641 if (r) 642 goto err; 643 644 ddata->enabled = 1; 645 646 if (!ddata->intro_printed) { 647 dev_info(&ddata->pdev->dev, "panel revision %02x.%02x.%02x\n", 648 id1, id2, id3); 649 ddata->intro_printed = true; 650 } 651 652 in->ops.dsi->enable_hs(in, ddata->channel, true); 653 654 return 0; 655err: 656 dev_err(&ddata->pdev->dev, "error while enabling panel, issuing HW reset\n"); 657 658 dsicm_hw_reset(ddata); 659 660 in->ops.dsi->disable(in, true, false); 661err0: 662 return r; 663} 664 665static void dsicm_power_off(struct panel_drv_data *ddata) 666{ 667 struct omap_dss_device *in = ddata->in; 668 int r; 669 670 in->ops.dsi->disable_video_output(in, ddata->channel); 671 672 r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_DISPLAY_OFF); 673 if (!r) 674 r = dsicm_sleep_in(ddata); 675 676 if (r) { 677 dev_err(&ddata->pdev->dev, 678 "error disabling panel, issuing HW reset\n"); 679 dsicm_hw_reset(ddata); 680 } 681 682 in->ops.dsi->disable(in, true, false); 683 684 ddata->enabled = 0; 685} 686 687static int dsicm_panel_reset(struct panel_drv_data *ddata) 688{ 689 dev_err(&ddata->pdev->dev, "performing LCD reset\n"); 690 691 dsicm_power_off(ddata); 692 dsicm_hw_reset(ddata); 693 return dsicm_power_on(ddata); 694} 695 696static int dsicm_connect(struct omap_dss_device *dssdev) 697{ 698 struct panel_drv_data *ddata = to_panel_data(dssdev); 699 struct omap_dss_device *in = ddata->in; 700 struct device *dev = &ddata->pdev->dev; 701 int r; 702 703 if (omapdss_device_is_connected(dssdev)) 704 return 0; 705 706 r = in->ops.dsi->connect(in, dssdev); 707 if (r) { 708 dev_err(dev, "Failed to connect to video source\n"); 709 return r; 710 } 711 712 r = in->ops.dsi->request_vc(ddata->in, &ddata->channel); 713 if (r) { 714 dev_err(dev, "failed to get virtual channel\n"); 715 goto err_req_vc; 716 } 717 718 r = in->ops.dsi->set_vc_id(ddata->in, ddata->channel, TCH); 719 if (r) { 720 dev_err(dev, "failed to set VC_ID\n"); 721 goto err_vc_id; 722 } 723 724 return 0; 725 726err_vc_id: 727 in->ops.dsi->release_vc(ddata->in, ddata->channel); 728err_req_vc: 729 in->ops.dsi->disconnect(in, dssdev); 730 return r; 731} 732 733static void dsicm_disconnect(struct omap_dss_device *dssdev) 734{ 735 struct panel_drv_data *ddata = to_panel_data(dssdev); 736 struct omap_dss_device *in = ddata->in; 737 738 if (!omapdss_device_is_connected(dssdev)) 739 return; 740 741 in->ops.dsi->release_vc(in, ddata->channel); 742 in->ops.dsi->disconnect(in, dssdev); 743} 744 745static int dsicm_enable(struct omap_dss_device *dssdev) 746{ 747 struct panel_drv_data *ddata = to_panel_data(dssdev); 748 struct omap_dss_device *in = ddata->in; 749 int r; 750 751 dev_dbg(&ddata->pdev->dev, "enable\n"); 752 753 mutex_lock(&ddata->lock); 754 755 if (!omapdss_device_is_connected(dssdev)) { 756 r = -ENODEV; 757 goto err; 758 } 759 760 if (omapdss_device_is_enabled(dssdev)) { 761 r = 0; 762 goto err; 763 } 764 765 in->ops.dsi->bus_lock(in); 766 767 r = dsicm_power_on(ddata); 768 769 in->ops.dsi->bus_unlock(in); 770 771 if (r) 772 goto err; 773 774 dssdev->state = OMAP_DSS_DISPLAY_ACTIVE; 775 776 mutex_unlock(&ddata->lock); 777 778 return 0; 779err: 780 dev_dbg(&ddata->pdev->dev, "enable failed\n"); 781 mutex_unlock(&ddata->lock); 782 return r; 783} 784 785static void dsicm_disable(struct omap_dss_device *dssdev) 786{ 787 struct panel_drv_data *ddata = to_panel_data(dssdev); 788 struct omap_dss_device *in = ddata->in; 789 int r; 790 791 dev_dbg(&ddata->pdev->dev, "disable\n"); 792 793 mutex_lock(&ddata->lock); 794 795 dsicm_cancel_ulps_work(ddata); 796 797 in->ops.dsi->bus_lock(in); 798 799 if (omapdss_device_is_enabled(dssdev)) { 800 r = dsicm_wake_up(ddata); 801 if (!r) 802 dsicm_power_off(ddata); 803 } 804 805 in->ops.dsi->bus_unlock(in); 806 807 dssdev->state = OMAP_DSS_DISPLAY_DISABLED; 808 809 mutex_unlock(&ddata->lock); 810} 811 812static void dsicm_framedone_cb(int err, void *data) 813{ 814 struct panel_drv_data *ddata = data; 815 struct omap_dss_device *in = ddata->in; 816 817 dev_dbg(&ddata->pdev->dev, "framedone, err %d\n", err); 818 in->ops.dsi->bus_unlock(ddata->in); 819} 820 821static irqreturn_t dsicm_te_isr(int irq, void *data) 822{ 823 struct panel_drv_data *ddata = data; 824 struct omap_dss_device *in = ddata->in; 825 int old; 826 int r; 827 828 old = atomic_cmpxchg(&ddata->do_update, 1, 0); 829 830 if (old) { 831 cancel_delayed_work(&ddata->te_timeout_work); 832 833 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb, 834 ddata); 835 if (r) 836 goto err; 837 } 838 839 return IRQ_HANDLED; 840err: 841 dev_err(&ddata->pdev->dev, "start update failed\n"); 842 in->ops.dsi->bus_unlock(in); 843 return IRQ_HANDLED; 844} 845 846static void dsicm_te_timeout_work_callback(struct work_struct *work) 847{ 848 struct panel_drv_data *ddata = container_of(work, struct panel_drv_data, 849 te_timeout_work.work); 850 struct omap_dss_device *in = ddata->in; 851 852 dev_err(&ddata->pdev->dev, "TE not received for 250ms!\n"); 853 854 atomic_set(&ddata->do_update, 0); 855 in->ops.dsi->bus_unlock(in); 856} 857 858static int dsicm_update(struct omap_dss_device *dssdev, 859 u16 x, u16 y, u16 w, u16 h) 860{ 861 struct panel_drv_data *ddata = to_panel_data(dssdev); 862 struct omap_dss_device *in = ddata->in; 863 int r; 864 865 dev_dbg(&ddata->pdev->dev, "update %d, %d, %d x %d\n", x, y, w, h); 866 867 mutex_lock(&ddata->lock); 868 in->ops.dsi->bus_lock(in); 869 870 r = dsicm_wake_up(ddata); 871 if (r) 872 goto err; 873 874 if (!ddata->enabled) { 875 r = 0; 876 goto err; 877 } 878 879 /* XXX no need to send this every frame, but dsi break if not done */ 880 r = dsicm_set_update_window(ddata, 0, 0, 881 dssdev->panel.timings.x_res, 882 dssdev->panel.timings.y_res); 883 if (r) 884 goto err; 885 886 if (ddata->te_enabled && ddata->ext_te_gpio) { 887 schedule_delayed_work(&ddata->te_timeout_work, 888 msecs_to_jiffies(250)); 889 atomic_set(&ddata->do_update, 1); 890 } else { 891 r = in->ops.dsi->update(in, ddata->channel, dsicm_framedone_cb, 892 ddata); 893 if (r) 894 goto err; 895 } 896 897 /* note: no bus_unlock here. unlock is in framedone_cb */ 898 mutex_unlock(&ddata->lock); 899 return 0; 900err: 901 in->ops.dsi->bus_unlock(in); 902 mutex_unlock(&ddata->lock); 903 return r; 904} 905 906static int dsicm_sync(struct omap_dss_device *dssdev) 907{ 908 struct panel_drv_data *ddata = to_panel_data(dssdev); 909 struct omap_dss_device *in = ddata->in; 910 911 dev_dbg(&ddata->pdev->dev, "sync\n"); 912 913 mutex_lock(&ddata->lock); 914 in->ops.dsi->bus_lock(in); 915 in->ops.dsi->bus_unlock(in); 916 mutex_unlock(&ddata->lock); 917 918 dev_dbg(&ddata->pdev->dev, "sync done\n"); 919 920 return 0; 921} 922 923static int _dsicm_enable_te(struct panel_drv_data *ddata, bool enable) 924{ 925 struct omap_dss_device *in = ddata->in; 926 int r; 927 928 if (enable) 929 r = dsicm_dcs_write_1(ddata, MIPI_DCS_SET_TEAR_ON, 0); 930 else 931 r = dsicm_dcs_write_0(ddata, MIPI_DCS_SET_TEAR_OFF); 932 933 if (!ddata->ext_te_gpio) 934 in->ops.dsi->enable_te(in, enable); 935 936 /* possible panel bug */ 937 msleep(100); 938 939 return r; 940} 941 942static int dsicm_enable_te(struct omap_dss_device *dssdev, bool enable) 943{ 944 struct panel_drv_data *ddata = to_panel_data(dssdev); 945 struct omap_dss_device *in = ddata->in; 946 int r; 947 948 mutex_lock(&ddata->lock); 949 950 if (ddata->te_enabled == enable) 951 goto end; 952 953 in->ops.dsi->bus_lock(in); 954 955 if (ddata->enabled) { 956 r = dsicm_wake_up(ddata); 957 if (r) 958 goto err; 959 960 r = _dsicm_enable_te(ddata, enable); 961 if (r) 962 goto err; 963 } 964 965 ddata->te_enabled = enable; 966 967 in->ops.dsi->bus_unlock(in); 968end: 969 mutex_unlock(&ddata->lock); 970 971 return 0; 972err: 973 in->ops.dsi->bus_unlock(in); 974 mutex_unlock(&ddata->lock); 975 976 return r; 977} 978 979static int dsicm_get_te(struct omap_dss_device *dssdev) 980{ 981 struct panel_drv_data *ddata = to_panel_data(dssdev); 982 int r; 983 984 mutex_lock(&ddata->lock); 985 r = ddata->te_enabled; 986 mutex_unlock(&ddata->lock); 987 988 return r; 989} 990 991static int dsicm_memory_read(struct omap_dss_device *dssdev, 992 void *buf, size_t size, 993 u16 x, u16 y, u16 w, u16 h) 994{ 995 struct panel_drv_data *ddata = to_panel_data(dssdev); 996 struct omap_dss_device *in = ddata->in; 997 int r; 998 int first = 1; 999 int plen; 1000 unsigned buf_used = 0; 1001 1002 if (size < w * h * 3) 1003 return -ENOMEM; 1004 1005 mutex_lock(&ddata->lock); 1006 1007 if (!ddata->enabled) { 1008 r = -ENODEV; 1009 goto err1; 1010 } 1011 1012 size = min(w * h * 3, 1013 dssdev->panel.timings.x_res * 1014 dssdev->panel.timings.y_res * 3); 1015 1016 in->ops.dsi->bus_lock(in); 1017 1018 r = dsicm_wake_up(ddata); 1019 if (r) 1020 goto err2; 1021 1022 /* plen 1 or 2 goes into short packet. until checksum error is fixed, 1023 * use short packets. plen 32 works, but bigger packets seem to cause 1024 * an error. */ 1025 if (size % 2) 1026 plen = 1; 1027 else 1028 plen = 2; 1029 1030 dsicm_set_update_window(ddata, x, y, w, h); 1031 1032 r = in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, plen); 1033 if (r) 1034 goto err2; 1035 1036 while (buf_used < size) { 1037 u8 dcs_cmd = first ? 0x2e : 0x3e; 1038 first = 0; 1039 1040 r = in->ops.dsi->dcs_read(in, ddata->channel, dcs_cmd, 1041 buf + buf_used, size - buf_used); 1042 1043 if (r < 0) { 1044 dev_err(dssdev->dev, "read error\n"); 1045 goto err3; 1046 } 1047 1048 buf_used += r; 1049 1050 if (r < plen) { 1051 dev_err(&ddata->pdev->dev, "short read\n"); 1052 break; 1053 } 1054 1055 if (signal_pending(current)) { 1056 dev_err(&ddata->pdev->dev, "signal pending, " 1057 "aborting memory read\n"); 1058 r = -ERESTARTSYS; 1059 goto err3; 1060 } 1061 } 1062 1063 r = buf_used; 1064 1065err3: 1066 in->ops.dsi->set_max_rx_packet_size(in, ddata->channel, 1); 1067err2: 1068 in->ops.dsi->bus_unlock(in); 1069err1: 1070 mutex_unlock(&ddata->lock); 1071 return r; 1072} 1073 1074static void dsicm_ulps_work(struct work_struct *work) 1075{ 1076 struct panel_drv_data *ddata = container_of(work, struct panel_drv_data, 1077 ulps_work.work); 1078 struct omap_dss_device *dssdev = &ddata->dssdev; 1079 struct omap_dss_device *in = ddata->in; 1080 1081 mutex_lock(&ddata->lock); 1082 1083 if (dssdev->state != OMAP_DSS_DISPLAY_ACTIVE || !ddata->enabled) { 1084 mutex_unlock(&ddata->lock); 1085 return; 1086 } 1087 1088 in->ops.dsi->bus_lock(in); 1089 1090 dsicm_enter_ulps(ddata); 1091 1092 in->ops.dsi->bus_unlock(in); 1093 mutex_unlock(&ddata->lock); 1094} 1095 1096static struct omap_dss_driver dsicm_ops = { 1097 .connect = dsicm_connect, 1098 .disconnect = dsicm_disconnect, 1099 1100 .enable = dsicm_enable, 1101 .disable = dsicm_disable, 1102 1103 .update = dsicm_update, 1104 .sync = dsicm_sync, 1105 1106 .get_resolution = dsicm_get_resolution, 1107 .get_recommended_bpp = omapdss_default_get_recommended_bpp, 1108 1109 .enable_te = dsicm_enable_te, 1110 .get_te = dsicm_get_te, 1111 1112 .memory_read = dsicm_memory_read, 1113}; 1114 1115static int dsicm_probe(struct platform_device *pdev) 1116{ 1117 struct backlight_properties props; 1118 struct panel_drv_data *ddata; 1119 struct backlight_device *bldev = NULL; 1120 struct device *dev = &pdev->dev; 1121 struct omap_dss_device *dssdev; 1122 int r; 1123 1124 dev_dbg(dev, "probe\n"); 1125 1126 if (!pdev->dev.of_node) 1127 return -ENODEV; 1128 1129 ddata = devm_kzalloc(dev, sizeof(*ddata), GFP_KERNEL); 1130 if (!ddata) 1131 return -ENOMEM; 1132 1133 platform_set_drvdata(pdev, ddata); 1134 ddata->pdev = pdev; 1135 1136 ddata->in = omapdss_of_find_source_for_first_ep(pdev->dev.of_node); 1137 r = PTR_ERR_OR_ZERO(ddata->in); 1138 if (r) { 1139 dev_err(&pdev->dev, "failed to find video source: %d\n", r); 1140 return r; 1141 } 1142 1143 ddata->timings.x_res = 864; 1144 ddata->timings.y_res = 480; 1145 ddata->timings.pixelclock = 864 * 480 * 60; 1146 1147 dssdev = &ddata->dssdev; 1148 dssdev->dev = dev; 1149 dssdev->driver = &dsicm_ops; 1150 dssdev->panel.timings = ddata->timings; 1151 dssdev->type = OMAP_DISPLAY_TYPE_DSI; 1152 dssdev->owner = THIS_MODULE; 1153 1154 dssdev->panel.dsi_pix_fmt = OMAP_DSS_DSI_FMT_RGB888; 1155 dssdev->caps = OMAP_DSS_DISPLAY_CAP_MANUAL_UPDATE | 1156 OMAP_DSS_DISPLAY_CAP_TEAR_ELIM; 1157 1158 r = omapdss_register_display(dssdev); 1159 if (r) { 1160 dev_err(dev, "Failed to register panel\n"); 1161 goto err_reg; 1162 } 1163 1164 mutex_init(&ddata->lock); 1165 1166 atomic_set(&ddata->do_update, 0); 1167 1168 ddata->reset_gpio = devm_gpiod_get(&pdev->dev, "reset", GPIOD_OUT_LOW); 1169 r = PTR_ERR_OR_ZERO(ddata->reset_gpio); 1170 if (r) { 1171 dev_err(&pdev->dev, "Failed to request reset gpio: %d\n", r); 1172 return r; 1173 } 1174 1175 gpiod_set_consumer_name(ddata->reset_gpio, "taal rst"); 1176 1177 ddata->ext_te_gpio = devm_gpiod_get_optional(&pdev->dev, "te", 1178 GPIOD_IN); 1179 r = PTR_ERR_OR_ZERO(ddata->ext_te_gpio); 1180 if (r) { 1181 dev_err(&pdev->dev, "Failed to request TE gpio: %d\n", r); 1182 return r; 1183 } 1184 1185 if (ddata->ext_te_gpio) { 1186 gpiod_set_consumer_name(ddata->ext_te_gpio, "taal irq"); 1187 1188 r = devm_request_irq(dev, gpiod_to_irq(ddata->ext_te_gpio), 1189 dsicm_te_isr, 1190 IRQF_TRIGGER_RISING, 1191 "taal vsync", ddata); 1192 1193 if (r) { 1194 dev_err(dev, "IRQ request failed\n"); 1195 return r; 1196 } 1197 1198 INIT_DEFERRABLE_WORK(&ddata->te_timeout_work, 1199 dsicm_te_timeout_work_callback); 1200 1201 dev_dbg(dev, "Using GPIO TE\n"); 1202 } 1203 1204 INIT_DELAYED_WORK(&ddata->ulps_work, dsicm_ulps_work); 1205 1206 dsicm_hw_reset(ddata); 1207 1208 if (ddata->use_dsi_backlight) { 1209 memset(&props, 0, sizeof(struct backlight_properties)); 1210 props.max_brightness = 255; 1211 1212 props.type = BACKLIGHT_RAW; 1213 bldev = backlight_device_register(dev_name(dev), 1214 dev, ddata, &dsicm_bl_ops, &props); 1215 if (IS_ERR(bldev)) { 1216 r = PTR_ERR(bldev); 1217 goto err_reg; 1218 } 1219 1220 ddata->bldev = bldev; 1221 1222 bldev->props.fb_blank = FB_BLANK_UNBLANK; 1223 bldev->props.power = FB_BLANK_UNBLANK; 1224 bldev->props.brightness = 255; 1225 1226 dsicm_bl_update_status(bldev); 1227 } 1228 1229 r = sysfs_create_group(&dev->kobj, &dsicm_attr_group); 1230 if (r) { 1231 dev_err(dev, "failed to create sysfs files\n"); 1232 goto err_sysfs_create; 1233 } 1234 1235 return 0; 1236 1237err_sysfs_create: 1238 if (bldev != NULL) 1239 backlight_device_unregister(bldev); 1240err_reg: 1241 return r; 1242} 1243 1244static void dsicm_remove(struct platform_device *pdev) 1245{ 1246 struct panel_drv_data *ddata = platform_get_drvdata(pdev); 1247 struct omap_dss_device *dssdev = &ddata->dssdev; 1248 struct backlight_device *bldev; 1249 1250 dev_dbg(&pdev->dev, "remove\n"); 1251 1252 omapdss_unregister_display(dssdev); 1253 1254 dsicm_disable(dssdev); 1255 dsicm_disconnect(dssdev); 1256 1257 sysfs_remove_group(&pdev->dev.kobj, &dsicm_attr_group); 1258 1259 bldev = ddata->bldev; 1260 if (bldev != NULL) { 1261 bldev->props.power = FB_BLANK_POWERDOWN; 1262 dsicm_bl_update_status(bldev); 1263 backlight_device_unregister(bldev); 1264 } 1265 1266 omap_dss_put_device(ddata->in); 1267 1268 dsicm_cancel_ulps_work(ddata); 1269 1270 /* reset, to be sure that the panel is in a valid state */ 1271 dsicm_hw_reset(ddata); 1272} 1273 1274static const struct of_device_id dsicm_of_match[] = { 1275 { .compatible = "omapdss,panel-dsi-cm", }, 1276 {}, 1277}; 1278 1279MODULE_DEVICE_TABLE(of, dsicm_of_match); 1280 1281static struct platform_driver dsicm_driver = { 1282 .probe = dsicm_probe, 1283 .remove_new = dsicm_remove, 1284 .driver = { 1285 .name = "panel-dsi-cm", 1286 .of_match_table = dsicm_of_match, 1287 }, 1288}; 1289 1290module_platform_driver(dsicm_driver); 1291 1292MODULE_AUTHOR("Tomi Valkeinen <tomi.valkeinen@ti.com>"); 1293MODULE_DESCRIPTION("Generic DSI Command Mode Panel Driver"); 1294MODULE_LICENSE("GPL"); 1295