1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (c) 2017-2020, The Linux Foundation. All rights reserved. 4 */ 5 6 #include <linux/module.h> 7 #include <linux/slab.h> 8 #include <linux/uaccess.h> 9 #include <linux/debugfs.h> 10 #include <linux/component.h> 11 #include <linux/of_irq.h> 12 #include <linux/delay.h> 13 14 #include "msm_drv.h" 15 #include "msm_kms.h" 16 #include "dp_hpd.h" 17 #include "dp_parser.h" 18 #include "dp_power.h" 19 #include "dp_catalog.h" 20 #include "dp_aux.h" 21 #include "dp_reg.h" 22 #include "dp_link.h" 23 #include "dp_panel.h" 24 #include "dp_ctrl.h" 25 #include "dp_display.h" 26 #include "dp_drm.h" 27 #include "dp_audio.h" 28 #include "dp_debug.h" 29 30 static struct msm_dp *g_dp_display; 31 #define HPD_STRING_SIZE 30 32 33 enum { 34 ISR_DISCONNECTED, 35 ISR_CONNECT_PENDING, 36 ISR_CONNECTED, 37 ISR_HPD_REPLUG_COUNT, 38 ISR_IRQ_HPD_PULSE_COUNT, 39 ISR_HPD_LO_GLITH_COUNT, 40 }; 41 42 /* event thread connection state */ 43 enum { 44 ST_DISCONNECTED, 45 ST_CONNECT_PENDING, 46 ST_CONNECTED, 47 ST_DISCONNECT_PENDING, 48 ST_DISPLAY_OFF, 49 ST_SUSPENDED, 50 }; 51 52 enum { 53 EV_NO_EVENT, 54 /* hpd events */ 55 EV_HPD_INIT_SETUP, 56 EV_HPD_PLUG_INT, 57 EV_IRQ_HPD_INT, 58 EV_HPD_UNPLUG_INT, 59 EV_USER_NOTIFICATION, 60 EV_CONNECT_PENDING_TIMEOUT, 61 EV_DISCONNECT_PENDING_TIMEOUT, 62 }; 63 64 #define EVENT_TIMEOUT (HZ/10) /* 100ms */ 65 #define DP_EVENT_Q_MAX 8 66 67 #define DP_TIMEOUT_5_SECOND (5000/EVENT_TIMEOUT) 68 #define DP_TIMEOUT_NONE 0 69 70 #define WAIT_FOR_RESUME_TIMEOUT_JIFFIES (HZ / 2) 71 72 struct dp_event { 73 u32 event_id; 74 u32 data; 75 u32 delay; 76 }; 77 78 struct dp_display_private { 79 char *name; 80 int irq; 81 82 /* state variables */ 83 bool core_initialized; 84 bool hpd_irq_on; 85 bool audio_supported; 86 87 struct platform_device *pdev; 88 struct dentry *root; 89 90 struct dp_usbpd *usbpd; 91 struct dp_parser *parser; 92 struct dp_power *power; 93 struct dp_catalog *catalog; 94 struct drm_dp_aux *aux; 95 struct dp_link *link; 96 struct dp_panel *panel; 97 struct dp_ctrl *ctrl; 98 struct dp_debug *debug; 99 100 struct dp_usbpd_cb usbpd_cb; 101 struct dp_display_mode dp_mode; 102 struct msm_dp dp_display; 103 104 /* wait for audio signaling */ 105 struct completion audio_comp; 106 107 /* event related only access by event thread */ 108 struct mutex event_mutex; 109 wait_queue_head_t event_q; 110 u32 hpd_state; 111 u32 event_pndx; 112 u32 event_gndx; 113 struct dp_event event_list[DP_EVENT_Q_MAX]; 114 spinlock_t event_lock; 115 116 struct dp_audio *audio; 117 }; 118 119 static const struct of_device_id dp_dt_match[] = { 120 {.compatible = "qcom,sc7180-dp"}, 121 {} 122 }; 123 124 static int dp_add_event(struct dp_display_private *dp_priv, u32 event, 125 u32 data, u32 delay) 126 { 127 unsigned long flag; 128 struct dp_event *todo; 129 int pndx; 130 131 spin_lock_irqsave(&dp_priv->event_lock, flag); 132 pndx = dp_priv->event_pndx + 1; 133 pndx %= DP_EVENT_Q_MAX; 134 if (pndx == dp_priv->event_gndx) { 135 pr_err("event_q is full: pndx=%d gndx=%d\n", 136 dp_priv->event_pndx, dp_priv->event_gndx); 137 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 138 return -EPERM; 139 } 140 todo = &dp_priv->event_list[dp_priv->event_pndx++]; 141 dp_priv->event_pndx %= DP_EVENT_Q_MAX; 142 todo->event_id = event; 143 todo->data = data; 144 todo->delay = delay; 145 wake_up(&dp_priv->event_q); 146 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 147 148 return 0; 149 } 150 151 static int dp_del_event(struct dp_display_private *dp_priv, u32 event) 152 { 153 unsigned long flag; 154 struct dp_event *todo; 155 u32 gndx; 156 157 spin_lock_irqsave(&dp_priv->event_lock, flag); 158 if (dp_priv->event_pndx == dp_priv->event_gndx) { 159 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 160 return -ENOENT; 161 } 162 163 gndx = dp_priv->event_gndx; 164 while (dp_priv->event_pndx != gndx) { 165 todo = &dp_priv->event_list[gndx]; 166 if (todo->event_id == event) { 167 todo->event_id = EV_NO_EVENT; /* deleted */ 168 todo->delay = 0; 169 } 170 gndx++; 171 gndx %= DP_EVENT_Q_MAX; 172 } 173 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 174 175 return 0; 176 } 177 178 void dp_display_signal_audio_start(struct msm_dp *dp_display) 179 { 180 struct dp_display_private *dp; 181 182 dp = container_of(dp_display, struct dp_display_private, dp_display); 183 184 reinit_completion(&dp->audio_comp); 185 } 186 187 void dp_display_signal_audio_complete(struct msm_dp *dp_display) 188 { 189 struct dp_display_private *dp; 190 191 dp = container_of(dp_display, struct dp_display_private, dp_display); 192 193 complete_all(&dp->audio_comp); 194 } 195 196 static int dp_display_bind(struct device *dev, struct device *master, 197 void *data) 198 { 199 int rc = 0; 200 struct dp_display_private *dp; 201 struct drm_device *drm; 202 struct msm_drm_private *priv; 203 204 drm = dev_get_drvdata(master); 205 206 dp = container_of(g_dp_display, 207 struct dp_display_private, dp_display); 208 209 dp->dp_display.drm_dev = drm; 210 priv = drm->dev_private; 211 priv->dp = &(dp->dp_display); 212 213 rc = dp->parser->parse(dp->parser); 214 if (rc) { 215 DRM_ERROR("device tree parsing failed\n"); 216 goto end; 217 } 218 219 rc = dp_aux_register(dp->aux); 220 if (rc) { 221 DRM_ERROR("DRM DP AUX register failed\n"); 222 goto end; 223 } 224 225 rc = dp_power_client_init(dp->power); 226 if (rc) { 227 DRM_ERROR("Power client create failed\n"); 228 goto end; 229 } 230 231 rc = dp_register_audio_driver(dev, dp->audio); 232 if (rc) 233 DRM_ERROR("Audio registration Dp failed\n"); 234 235 end: 236 return rc; 237 } 238 239 static void dp_display_unbind(struct device *dev, struct device *master, 240 void *data) 241 { 242 struct dp_display_private *dp; 243 struct drm_device *drm = dev_get_drvdata(master); 244 struct msm_drm_private *priv = drm->dev_private; 245 246 dp = container_of(g_dp_display, 247 struct dp_display_private, dp_display); 248 249 dp_power_client_deinit(dp->power); 250 dp_aux_unregister(dp->aux); 251 priv->dp = NULL; 252 } 253 254 static const struct component_ops dp_display_comp_ops = { 255 .bind = dp_display_bind, 256 .unbind = dp_display_unbind, 257 }; 258 259 static bool dp_display_is_ds_bridge(struct dp_panel *panel) 260 { 261 return (panel->dpcd[DP_DOWNSTREAMPORT_PRESENT] & 262 DP_DWN_STRM_PORT_PRESENT); 263 } 264 265 static bool dp_display_is_sink_count_zero(struct dp_display_private *dp) 266 { 267 DRM_DEBUG_DP("present=%#x sink_count=%d\n", dp->panel->dpcd[DP_DOWNSTREAMPORT_PRESENT], 268 dp->link->sink_count); 269 return dp_display_is_ds_bridge(dp->panel) && 270 (dp->link->sink_count == 0); 271 } 272 273 static void dp_display_send_hpd_event(struct msm_dp *dp_display) 274 { 275 struct dp_display_private *dp; 276 struct drm_connector *connector; 277 278 dp = container_of(dp_display, struct dp_display_private, dp_display); 279 280 connector = dp->dp_display.connector; 281 drm_helper_hpd_irq_event(connector->dev); 282 } 283 284 285 static int dp_display_send_hpd_notification(struct dp_display_private *dp, 286 bool hpd) 287 { 288 if ((hpd && dp->dp_display.is_connected) || 289 (!hpd && !dp->dp_display.is_connected)) { 290 DRM_DEBUG_DP("HPD already %s\n", (hpd ? "on" : "off")); 291 return 0; 292 } 293 294 /* reset video pattern flag on disconnect */ 295 if (!hpd) 296 dp->panel->video_test = false; 297 298 dp->dp_display.is_connected = hpd; 299 300 DRM_DEBUG_DP("hpd=%d\n", hpd); 301 dp_display_send_hpd_event(&dp->dp_display); 302 303 return 0; 304 } 305 306 static int dp_display_process_hpd_high(struct dp_display_private *dp) 307 { 308 int rc = 0; 309 struct edid *edid; 310 311 dp->panel->max_dp_lanes = dp->parser->max_dp_lanes; 312 313 rc = dp_panel_read_sink_caps(dp->panel, dp->dp_display.connector); 314 if (rc) 315 goto end; 316 317 dp_link_process_request(dp->link); 318 319 edid = dp->panel->edid; 320 321 dp->audio_supported = drm_detect_monitor_audio(edid); 322 dp_panel_handle_sink_request(dp->panel); 323 324 dp->dp_display.max_pclk_khz = DP_MAX_PIXEL_CLK_KHZ; 325 dp->dp_display.max_dp_lanes = dp->parser->max_dp_lanes; 326 327 /* 328 * set sink to normal operation mode -- D0 329 * before dpcd read 330 */ 331 dp_link_psm_config(dp->link, &dp->panel->link_info, false); 332 333 dp_link_reset_phy_params_vx_px(dp->link); 334 rc = dp_ctrl_on_link(dp->ctrl); 335 if (rc) { 336 DRM_ERROR("failed to complete DP link training\n"); 337 goto end; 338 } 339 340 dp_add_event(dp, EV_USER_NOTIFICATION, true, 0); 341 342 end: 343 return rc; 344 } 345 346 static void dp_display_host_init(struct dp_display_private *dp, int reset) 347 { 348 bool flip = false; 349 350 DRM_DEBUG_DP("core_initialized=%d\n", dp->core_initialized); 351 if (dp->core_initialized) { 352 DRM_DEBUG_DP("DP core already initialized\n"); 353 return; 354 } 355 356 if (dp->usbpd->orientation == ORIENTATION_CC2) 357 flip = true; 358 359 dp_power_init(dp->power, flip); 360 dp_ctrl_host_init(dp->ctrl, flip, reset); 361 dp_aux_init(dp->aux); 362 dp->core_initialized = true; 363 } 364 365 static void dp_display_host_deinit(struct dp_display_private *dp) 366 { 367 if (!dp->core_initialized) { 368 DRM_DEBUG_DP("DP core not initialized\n"); 369 return; 370 } 371 372 dp_ctrl_host_deinit(dp->ctrl); 373 dp_aux_deinit(dp->aux); 374 dp_power_deinit(dp->power); 375 376 dp->core_initialized = false; 377 } 378 379 static int dp_display_usbpd_configure_cb(struct device *dev) 380 { 381 int rc = 0; 382 struct dp_display_private *dp; 383 384 if (!dev) { 385 DRM_ERROR("invalid dev\n"); 386 rc = -EINVAL; 387 goto end; 388 } 389 390 dp = container_of(g_dp_display, 391 struct dp_display_private, dp_display); 392 393 dp_display_host_init(dp, false); 394 395 rc = dp_display_process_hpd_high(dp); 396 end: 397 return rc; 398 } 399 400 static int dp_display_usbpd_disconnect_cb(struct device *dev) 401 { 402 int rc = 0; 403 struct dp_display_private *dp; 404 405 if (!dev) { 406 DRM_ERROR("invalid dev\n"); 407 rc = -EINVAL; 408 return rc; 409 } 410 411 dp = container_of(g_dp_display, 412 struct dp_display_private, dp_display); 413 414 dp_add_event(dp, EV_USER_NOTIFICATION, false, 0); 415 416 return rc; 417 } 418 419 static void dp_display_handle_video_request(struct dp_display_private *dp) 420 { 421 if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) { 422 dp->panel->video_test = true; 423 dp_link_send_test_response(dp->link); 424 } 425 } 426 427 static int dp_display_handle_port_ststus_changed(struct dp_display_private *dp) 428 { 429 int rc = 0; 430 431 if (dp_display_is_sink_count_zero(dp)) { 432 DRM_DEBUG_DP("sink count is zero, nothing to do\n"); 433 if (dp->hpd_state != ST_DISCONNECTED) { 434 dp->hpd_state = ST_DISCONNECT_PENDING; 435 dp_add_event(dp, EV_USER_NOTIFICATION, false, 0); 436 } 437 } else { 438 if (dp->hpd_state == ST_DISCONNECTED) { 439 dp->hpd_state = ST_CONNECT_PENDING; 440 rc = dp_display_process_hpd_high(dp); 441 if (rc) 442 dp->hpd_state = ST_DISCONNECTED; 443 } 444 } 445 446 return rc; 447 } 448 449 static int dp_display_handle_irq_hpd(struct dp_display_private *dp) 450 { 451 u32 sink_request = dp->link->sink_request; 452 453 DRM_DEBUG_DP("%d\n", sink_request); 454 if (dp->hpd_state == ST_DISCONNECTED) { 455 if (sink_request & DP_LINK_STATUS_UPDATED) { 456 DRM_DEBUG_DP("Disconnected sink_request: %d\n", sink_request); 457 DRM_ERROR("Disconnected, no DP_LINK_STATUS_UPDATED\n"); 458 return -EINVAL; 459 } 460 } 461 462 dp_ctrl_handle_sink_request(dp->ctrl); 463 464 if (sink_request & DP_TEST_LINK_VIDEO_PATTERN) 465 dp_display_handle_video_request(dp); 466 467 return 0; 468 } 469 470 static int dp_display_usbpd_attention_cb(struct device *dev) 471 { 472 int rc = 0; 473 u32 sink_request; 474 struct dp_display_private *dp; 475 476 if (!dev) { 477 DRM_ERROR("invalid dev\n"); 478 return -EINVAL; 479 } 480 481 dp = container_of(g_dp_display, 482 struct dp_display_private, dp_display); 483 484 /* check for any test request issued by sink */ 485 rc = dp_link_process_request(dp->link); 486 if (!rc) { 487 sink_request = dp->link->sink_request; 488 DRM_DEBUG_DP("hpd_state=%d sink_request=%d\n", dp->hpd_state, sink_request); 489 if (sink_request & DS_PORT_STATUS_CHANGED) 490 rc = dp_display_handle_port_ststus_changed(dp); 491 else 492 rc = dp_display_handle_irq_hpd(dp); 493 } 494 495 return rc; 496 } 497 498 static int dp_hpd_plug_handle(struct dp_display_private *dp, u32 data) 499 { 500 struct dp_usbpd *hpd = dp->usbpd; 501 u32 state; 502 u32 tout = DP_TIMEOUT_5_SECOND; 503 int ret; 504 505 if (!hpd) 506 return 0; 507 508 mutex_lock(&dp->event_mutex); 509 510 state = dp->hpd_state; 511 DRM_DEBUG_DP("hpd_state=%d\n", state); 512 if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) { 513 mutex_unlock(&dp->event_mutex); 514 return 0; 515 } 516 517 if (state == ST_CONNECT_PENDING || state == ST_CONNECTED) { 518 mutex_unlock(&dp->event_mutex); 519 return 0; 520 } 521 522 if (state == ST_DISCONNECT_PENDING) { 523 /* wait until ST_DISCONNECTED */ 524 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 1); /* delay = 1 */ 525 mutex_unlock(&dp->event_mutex); 526 return 0; 527 } 528 529 dp->hpd_state = ST_CONNECT_PENDING; 530 531 hpd->hpd_high = 1; 532 533 ret = dp_display_usbpd_configure_cb(&dp->pdev->dev); 534 if (ret) { /* link train failed */ 535 hpd->hpd_high = 0; 536 dp->hpd_state = ST_DISCONNECTED; 537 538 if (ret == -ECONNRESET) { /* cable unplugged */ 539 dp->core_initialized = false; 540 } 541 542 } else { 543 /* start sentinel checking in case of missing uevent */ 544 dp_add_event(dp, EV_CONNECT_PENDING_TIMEOUT, 0, tout); 545 } 546 547 /* enable HDP irq_hpd/replug interrupt */ 548 dp_catalog_hpd_config_intr(dp->catalog, 549 DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, true); 550 551 mutex_unlock(&dp->event_mutex); 552 553 /* uevent will complete connection part */ 554 return 0; 555 }; 556 557 static int dp_display_enable(struct dp_display_private *dp, u32 data); 558 static int dp_display_disable(struct dp_display_private *dp, u32 data); 559 560 static int dp_connect_pending_timeout(struct dp_display_private *dp, u32 data) 561 { 562 u32 state; 563 564 mutex_lock(&dp->event_mutex); 565 566 state = dp->hpd_state; 567 if (state == ST_CONNECT_PENDING) 568 dp->hpd_state = ST_CONNECTED; 569 570 mutex_unlock(&dp->event_mutex); 571 572 return 0; 573 } 574 575 static void dp_display_handle_plugged_change(struct msm_dp *dp_display, 576 bool plugged) 577 { 578 struct dp_display_private *dp; 579 580 dp = container_of(dp_display, 581 struct dp_display_private, dp_display); 582 583 /* notify audio subsystem only if sink supports audio */ 584 if (dp_display->plugged_cb && dp_display->codec_dev && 585 dp->audio_supported) 586 dp_display->plugged_cb(dp_display->codec_dev, plugged); 587 } 588 589 static int dp_hpd_unplug_handle(struct dp_display_private *dp, u32 data) 590 { 591 struct dp_usbpd *hpd = dp->usbpd; 592 u32 state; 593 594 if (!hpd) 595 return 0; 596 597 mutex_lock(&dp->event_mutex); 598 599 state = dp->hpd_state; 600 601 /* disable irq_hpd/replug interrupts */ 602 dp_catalog_hpd_config_intr(dp->catalog, 603 DP_DP_IRQ_HPD_INT_MASK | DP_DP_HPD_REPLUG_INT_MASK, false); 604 605 /* unplugged, no more irq_hpd handle */ 606 dp_del_event(dp, EV_IRQ_HPD_INT); 607 608 if (state == ST_DISCONNECTED) { 609 /* triggered by irq_hdp with sink_count = 0 */ 610 if (dp->link->sink_count == 0) { 611 dp_ctrl_off_phy(dp->ctrl); 612 hpd->hpd_high = 0; 613 dp->core_initialized = false; 614 } 615 mutex_unlock(&dp->event_mutex); 616 return 0; 617 } 618 619 if (state == ST_DISCONNECT_PENDING) { 620 mutex_unlock(&dp->event_mutex); 621 return 0; 622 } 623 624 if (state == ST_CONNECT_PENDING) { 625 /* wait until CONNECTED */ 626 dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 1); /* delay = 1 */ 627 mutex_unlock(&dp->event_mutex); 628 return 0; 629 } 630 631 dp->hpd_state = ST_DISCONNECT_PENDING; 632 633 /* disable HPD plug interrupts */ 634 dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, false); 635 636 hpd->hpd_high = 0; 637 638 /* 639 * We don't need separate work for disconnect as 640 * connect/attention interrupts are disabled 641 */ 642 dp_display_usbpd_disconnect_cb(&dp->pdev->dev); 643 644 /* start sentinel checking in case of missing uevent */ 645 dp_add_event(dp, EV_DISCONNECT_PENDING_TIMEOUT, 0, DP_TIMEOUT_5_SECOND); 646 647 DRM_DEBUG_DP("hpd_state=%d\n", state); 648 /* signal the disconnect event early to ensure proper teardown */ 649 dp_display_handle_plugged_change(g_dp_display, false); 650 651 /* enable HDP plug interrupt to prepare for next plugin */ 652 dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_PLUG_INT_MASK, true); 653 654 /* uevent will complete disconnection part */ 655 mutex_unlock(&dp->event_mutex); 656 return 0; 657 } 658 659 static int dp_disconnect_pending_timeout(struct dp_display_private *dp, u32 data) 660 { 661 u32 state; 662 663 mutex_lock(&dp->event_mutex); 664 665 state = dp->hpd_state; 666 if (state == ST_DISCONNECT_PENDING) 667 dp->hpd_state = ST_DISCONNECTED; 668 669 mutex_unlock(&dp->event_mutex); 670 671 return 0; 672 } 673 674 static int dp_irq_hpd_handle(struct dp_display_private *dp, u32 data) 675 { 676 u32 state; 677 int ret; 678 679 mutex_lock(&dp->event_mutex); 680 681 /* irq_hpd can happen at either connected or disconnected state */ 682 state = dp->hpd_state; 683 if (state == ST_DISPLAY_OFF || state == ST_SUSPENDED) { 684 mutex_unlock(&dp->event_mutex); 685 return 0; 686 } 687 688 if (state == ST_CONNECT_PENDING) { 689 /* wait until ST_CONNECTED */ 690 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */ 691 mutex_unlock(&dp->event_mutex); 692 return 0; 693 } 694 695 if (state == ST_CONNECT_PENDING || state == ST_DISCONNECT_PENDING) { 696 /* wait until ST_CONNECTED */ 697 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */ 698 mutex_unlock(&dp->event_mutex); 699 return 0; 700 } 701 702 ret = dp_display_usbpd_attention_cb(&dp->pdev->dev); 703 if (ret == -ECONNRESET) { /* cable unplugged */ 704 dp->core_initialized = false; 705 } 706 DRM_DEBUG_DP("hpd_state=%d\n", state); 707 708 mutex_unlock(&dp->event_mutex); 709 710 return 0; 711 } 712 713 static void dp_display_deinit_sub_modules(struct dp_display_private *dp) 714 { 715 dp_debug_put(dp->debug); 716 dp_panel_put(dp->panel); 717 dp_aux_put(dp->aux); 718 dp_audio_put(dp->audio); 719 } 720 721 static int dp_init_sub_modules(struct dp_display_private *dp) 722 { 723 int rc = 0; 724 struct device *dev = &dp->pdev->dev; 725 struct dp_usbpd_cb *cb = &dp->usbpd_cb; 726 struct dp_panel_in panel_in = { 727 .dev = dev, 728 }; 729 730 /* Callback APIs used for cable status change event */ 731 cb->configure = dp_display_usbpd_configure_cb; 732 cb->disconnect = dp_display_usbpd_disconnect_cb; 733 cb->attention = dp_display_usbpd_attention_cb; 734 735 dp->usbpd = dp_hpd_get(dev, cb); 736 if (IS_ERR(dp->usbpd)) { 737 rc = PTR_ERR(dp->usbpd); 738 DRM_ERROR("failed to initialize hpd, rc = %d\n", rc); 739 dp->usbpd = NULL; 740 goto error; 741 } 742 743 dp->parser = dp_parser_get(dp->pdev); 744 if (IS_ERR(dp->parser)) { 745 rc = PTR_ERR(dp->parser); 746 DRM_ERROR("failed to initialize parser, rc = %d\n", rc); 747 dp->parser = NULL; 748 goto error; 749 } 750 751 dp->catalog = dp_catalog_get(dev, &dp->parser->io); 752 if (IS_ERR(dp->catalog)) { 753 rc = PTR_ERR(dp->catalog); 754 DRM_ERROR("failed to initialize catalog, rc = %d\n", rc); 755 dp->catalog = NULL; 756 goto error; 757 } 758 759 dp->power = dp_power_get(dev, dp->parser); 760 if (IS_ERR(dp->power)) { 761 rc = PTR_ERR(dp->power); 762 DRM_ERROR("failed to initialize power, rc = %d\n", rc); 763 dp->power = NULL; 764 goto error; 765 } 766 767 dp->aux = dp_aux_get(dev, dp->catalog); 768 if (IS_ERR(dp->aux)) { 769 rc = PTR_ERR(dp->aux); 770 DRM_ERROR("failed to initialize aux, rc = %d\n", rc); 771 dp->aux = NULL; 772 goto error; 773 } 774 775 dp->link = dp_link_get(dev, dp->aux); 776 if (IS_ERR(dp->link)) { 777 rc = PTR_ERR(dp->link); 778 DRM_ERROR("failed to initialize link, rc = %d\n", rc); 779 dp->link = NULL; 780 goto error_link; 781 } 782 783 panel_in.aux = dp->aux; 784 panel_in.catalog = dp->catalog; 785 panel_in.link = dp->link; 786 787 dp->panel = dp_panel_get(&panel_in); 788 if (IS_ERR(dp->panel)) { 789 rc = PTR_ERR(dp->panel); 790 DRM_ERROR("failed to initialize panel, rc = %d\n", rc); 791 dp->panel = NULL; 792 goto error_link; 793 } 794 795 dp->ctrl = dp_ctrl_get(dev, dp->link, dp->panel, dp->aux, 796 dp->power, dp->catalog, dp->parser); 797 if (IS_ERR(dp->ctrl)) { 798 rc = PTR_ERR(dp->ctrl); 799 DRM_ERROR("failed to initialize ctrl, rc = %d\n", rc); 800 dp->ctrl = NULL; 801 goto error_ctrl; 802 } 803 804 dp->audio = dp_audio_get(dp->pdev, dp->panel, dp->catalog); 805 if (IS_ERR(dp->audio)) { 806 rc = PTR_ERR(dp->audio); 807 pr_err("failed to initialize audio, rc = %d\n", rc); 808 dp->audio = NULL; 809 goto error_ctrl; 810 } 811 812 return rc; 813 814 error_ctrl: 815 dp_panel_put(dp->panel); 816 error_link: 817 dp_aux_put(dp->aux); 818 error: 819 return rc; 820 } 821 822 static int dp_display_set_mode(struct msm_dp *dp_display, 823 struct dp_display_mode *mode) 824 { 825 struct dp_display_private *dp; 826 827 dp = container_of(dp_display, struct dp_display_private, dp_display); 828 829 dp->panel->dp_mode.drm_mode = mode->drm_mode; 830 dp->panel->dp_mode.bpp = mode->bpp; 831 dp->panel->dp_mode.capabilities = mode->capabilities; 832 dp_panel_init_panel_info(dp->panel); 833 return 0; 834 } 835 836 static int dp_display_prepare(struct msm_dp *dp) 837 { 838 return 0; 839 } 840 841 static int dp_display_enable(struct dp_display_private *dp, u32 data) 842 { 843 int rc = 0; 844 struct msm_dp *dp_display; 845 846 dp_display = g_dp_display; 847 848 DRM_DEBUG_DP("sink_count=%d\n", dp->link->sink_count); 849 if (dp_display->power_on) { 850 DRM_DEBUG_DP("Link already setup, return\n"); 851 return 0; 852 } 853 854 rc = dp_ctrl_on_stream(dp->ctrl); 855 if (!rc) 856 dp_display->power_on = true; 857 858 return rc; 859 } 860 861 static int dp_display_post_enable(struct msm_dp *dp_display) 862 { 863 struct dp_display_private *dp; 864 u32 rate; 865 866 dp = container_of(dp_display, struct dp_display_private, dp_display); 867 868 rate = dp->link->link_params.rate; 869 870 if (dp->audio_supported) { 871 dp->audio->bw_code = drm_dp_link_rate_to_bw_code(rate); 872 dp->audio->lane_count = dp->link->link_params.num_lanes; 873 } 874 875 /* signal the connect event late to synchronize video and display */ 876 dp_display_handle_plugged_change(dp_display, true); 877 return 0; 878 } 879 880 static int dp_display_disable(struct dp_display_private *dp, u32 data) 881 { 882 struct msm_dp *dp_display; 883 884 dp_display = g_dp_display; 885 886 if (!dp_display->power_on) 887 return 0; 888 889 /* wait only if audio was enabled */ 890 if (dp_display->audio_enabled) { 891 /* signal the disconnect event */ 892 dp_display_handle_plugged_change(dp_display, false); 893 if (!wait_for_completion_timeout(&dp->audio_comp, 894 HZ * 5)) 895 DRM_ERROR("audio comp timeout\n"); 896 } 897 898 dp_display->audio_enabled = false; 899 900 /* triggered by irq_hpd with sink_count = 0 */ 901 if (dp->link->sink_count == 0) { 902 dp_ctrl_off_link_stream(dp->ctrl); 903 } else { 904 dp_ctrl_off(dp->ctrl); 905 dp->core_initialized = false; 906 } 907 908 dp_display->power_on = false; 909 910 DRM_DEBUG_DP("sink count: %d\n", dp->link->sink_count); 911 return 0; 912 } 913 914 static int dp_display_unprepare(struct msm_dp *dp) 915 { 916 return 0; 917 } 918 919 int dp_display_set_plugged_cb(struct msm_dp *dp_display, 920 hdmi_codec_plugged_cb fn, struct device *codec_dev) 921 { 922 bool plugged; 923 924 dp_display->plugged_cb = fn; 925 dp_display->codec_dev = codec_dev; 926 plugged = dp_display->is_connected; 927 dp_display_handle_plugged_change(dp_display, plugged); 928 929 return 0; 930 } 931 932 int dp_display_validate_mode(struct msm_dp *dp, u32 mode_pclk_khz) 933 { 934 const u32 num_components = 3, default_bpp = 24; 935 struct dp_display_private *dp_display; 936 struct dp_link_info *link_info; 937 u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0; 938 939 if (!dp || !mode_pclk_khz || !dp->connector) { 940 DRM_ERROR("invalid params\n"); 941 return -EINVAL; 942 } 943 944 dp_display = container_of(dp, struct dp_display_private, dp_display); 945 link_info = &dp_display->panel->link_info; 946 947 mode_bpp = dp->connector->display_info.bpc * num_components; 948 if (!mode_bpp) 949 mode_bpp = default_bpp; 950 951 mode_bpp = dp_panel_get_mode_bpp(dp_display->panel, 952 mode_bpp, mode_pclk_khz); 953 954 mode_rate_khz = mode_pclk_khz * mode_bpp; 955 supported_rate_khz = link_info->num_lanes * link_info->rate * 8; 956 957 if (mode_rate_khz > supported_rate_khz) 958 return MODE_BAD; 959 960 return MODE_OK; 961 } 962 963 int dp_display_get_modes(struct msm_dp *dp, 964 struct dp_display_mode *dp_mode) 965 { 966 struct dp_display_private *dp_display; 967 int ret = 0; 968 969 if (!dp) { 970 DRM_ERROR("invalid params\n"); 971 return 0; 972 } 973 974 dp_display = container_of(dp, struct dp_display_private, dp_display); 975 976 ret = dp_panel_get_modes(dp_display->panel, 977 dp->connector, dp_mode); 978 if (dp_mode->drm_mode.clock) 979 dp->max_pclk_khz = dp_mode->drm_mode.clock; 980 return ret; 981 } 982 983 bool dp_display_check_video_test(struct msm_dp *dp) 984 { 985 struct dp_display_private *dp_display; 986 987 dp_display = container_of(dp, struct dp_display_private, dp_display); 988 989 return dp_display->panel->video_test; 990 } 991 992 int dp_display_get_test_bpp(struct msm_dp *dp) 993 { 994 struct dp_display_private *dp_display; 995 996 if (!dp) { 997 DRM_ERROR("invalid params\n"); 998 return 0; 999 } 1000 1001 dp_display = container_of(dp, struct dp_display_private, dp_display); 1002 1003 return dp_link_bit_depth_to_bpp( 1004 dp_display->link->test_video.test_bit_depth); 1005 } 1006 1007 void msm_dp_snapshot(struct msm_disp_state *disp_state, struct msm_dp *dp) 1008 { 1009 struct dp_display_private *dp_display; 1010 1011 dp_display = container_of(dp, struct dp_display_private, dp_display); 1012 1013 /* 1014 * if we are reading registers we need the link clocks to be on 1015 * however till DP cable is connected this will not happen as we 1016 * do not know the resolution to power up with. Hence check the 1017 * power_on status before dumping DP registers to avoid crash due 1018 * to unclocked access 1019 */ 1020 mutex_lock(&dp_display->event_mutex); 1021 1022 if (!dp->power_on) { 1023 mutex_unlock(&dp_display->event_mutex); 1024 return; 1025 } 1026 1027 dp_catalog_snapshot(dp_display->catalog, disp_state); 1028 1029 mutex_unlock(&dp_display->event_mutex); 1030 } 1031 1032 static void dp_display_config_hpd(struct dp_display_private *dp) 1033 { 1034 1035 dp_display_host_init(dp, true); 1036 dp_catalog_ctrl_hpd_config(dp->catalog); 1037 1038 /* Enable interrupt first time 1039 * we are leaving dp clocks on during disconnect 1040 * and never disable interrupt 1041 */ 1042 enable_irq(dp->irq); 1043 } 1044 1045 static int hpd_event_thread(void *data) 1046 { 1047 struct dp_display_private *dp_priv; 1048 unsigned long flag; 1049 struct dp_event *todo; 1050 int timeout_mode = 0; 1051 1052 dp_priv = (struct dp_display_private *)data; 1053 1054 while (1) { 1055 if (timeout_mode) { 1056 wait_event_timeout(dp_priv->event_q, 1057 (dp_priv->event_pndx == dp_priv->event_gndx), 1058 EVENT_TIMEOUT); 1059 } else { 1060 wait_event_interruptible(dp_priv->event_q, 1061 (dp_priv->event_pndx != dp_priv->event_gndx)); 1062 } 1063 spin_lock_irqsave(&dp_priv->event_lock, flag); 1064 todo = &dp_priv->event_list[dp_priv->event_gndx]; 1065 if (todo->delay) { 1066 struct dp_event *todo_next; 1067 1068 dp_priv->event_gndx++; 1069 dp_priv->event_gndx %= DP_EVENT_Q_MAX; 1070 1071 /* re enter delay event into q */ 1072 todo_next = &dp_priv->event_list[dp_priv->event_pndx++]; 1073 dp_priv->event_pndx %= DP_EVENT_Q_MAX; 1074 todo_next->event_id = todo->event_id; 1075 todo_next->data = todo->data; 1076 todo_next->delay = todo->delay - 1; 1077 1078 /* clean up older event */ 1079 todo->event_id = EV_NO_EVENT; 1080 todo->delay = 0; 1081 1082 /* switch to timeout mode */ 1083 timeout_mode = 1; 1084 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 1085 continue; 1086 } 1087 1088 /* timeout with no events in q */ 1089 if (dp_priv->event_pndx == dp_priv->event_gndx) { 1090 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 1091 continue; 1092 } 1093 1094 dp_priv->event_gndx++; 1095 dp_priv->event_gndx %= DP_EVENT_Q_MAX; 1096 timeout_mode = 0; 1097 spin_unlock_irqrestore(&dp_priv->event_lock, flag); 1098 1099 switch (todo->event_id) { 1100 case EV_HPD_INIT_SETUP: 1101 dp_display_config_hpd(dp_priv); 1102 break; 1103 case EV_HPD_PLUG_INT: 1104 dp_hpd_plug_handle(dp_priv, todo->data); 1105 break; 1106 case EV_HPD_UNPLUG_INT: 1107 dp_hpd_unplug_handle(dp_priv, todo->data); 1108 break; 1109 case EV_IRQ_HPD_INT: 1110 dp_irq_hpd_handle(dp_priv, todo->data); 1111 break; 1112 case EV_USER_NOTIFICATION: 1113 dp_display_send_hpd_notification(dp_priv, 1114 todo->data); 1115 break; 1116 case EV_CONNECT_PENDING_TIMEOUT: 1117 dp_connect_pending_timeout(dp_priv, 1118 todo->data); 1119 break; 1120 case EV_DISCONNECT_PENDING_TIMEOUT: 1121 dp_disconnect_pending_timeout(dp_priv, 1122 todo->data); 1123 break; 1124 default: 1125 break; 1126 } 1127 } 1128 1129 return 0; 1130 } 1131 1132 static void dp_hpd_event_setup(struct dp_display_private *dp_priv) 1133 { 1134 init_waitqueue_head(&dp_priv->event_q); 1135 spin_lock_init(&dp_priv->event_lock); 1136 1137 kthread_run(hpd_event_thread, dp_priv, "dp_hpd_handler"); 1138 } 1139 1140 static irqreturn_t dp_display_irq_handler(int irq, void *dev_id) 1141 { 1142 struct dp_display_private *dp = dev_id; 1143 irqreturn_t ret = IRQ_HANDLED; 1144 u32 hpd_isr_status; 1145 1146 if (!dp) { 1147 DRM_ERROR("invalid data\n"); 1148 return IRQ_NONE; 1149 } 1150 1151 hpd_isr_status = dp_catalog_hpd_get_intr_status(dp->catalog); 1152 1153 DRM_DEBUG_DP("hpd isr status=%#x\n", hpd_isr_status); 1154 if (hpd_isr_status & 0x0F) { 1155 /* hpd related interrupts */ 1156 if (hpd_isr_status & DP_DP_HPD_PLUG_INT_MASK) 1157 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0); 1158 1159 if (hpd_isr_status & DP_DP_IRQ_HPD_INT_MASK) { 1160 /* stop sentinel connect pending checking */ 1161 dp_del_event(dp, EV_CONNECT_PENDING_TIMEOUT); 1162 dp_add_event(dp, EV_IRQ_HPD_INT, 0, 0); 1163 } 1164 1165 if (hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK) { 1166 dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0); 1167 dp_add_event(dp, EV_HPD_PLUG_INT, 0, 3); 1168 } 1169 1170 if (hpd_isr_status & DP_DP_HPD_UNPLUG_INT_MASK) 1171 dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0); 1172 } 1173 1174 /* DP controller isr */ 1175 dp_ctrl_isr(dp->ctrl); 1176 1177 /* DP aux isr */ 1178 dp_aux_isr(dp->aux); 1179 1180 return ret; 1181 } 1182 1183 int dp_display_request_irq(struct msm_dp *dp_display) 1184 { 1185 int rc = 0; 1186 struct dp_display_private *dp; 1187 1188 if (!dp_display) { 1189 DRM_ERROR("invalid input\n"); 1190 return -EINVAL; 1191 } 1192 1193 dp = container_of(dp_display, struct dp_display_private, dp_display); 1194 1195 dp->irq = irq_of_parse_and_map(dp->pdev->dev.of_node, 0); 1196 if (dp->irq < 0) { 1197 rc = dp->irq; 1198 DRM_ERROR("failed to get irq: %d\n", rc); 1199 return rc; 1200 } 1201 1202 rc = devm_request_irq(&dp->pdev->dev, dp->irq, 1203 dp_display_irq_handler, 1204 IRQF_TRIGGER_HIGH, "dp_display_isr", dp); 1205 if (rc < 0) { 1206 DRM_ERROR("failed to request IRQ%u: %d\n", 1207 dp->irq, rc); 1208 return rc; 1209 } 1210 disable_irq(dp->irq); 1211 1212 return 0; 1213 } 1214 1215 static int dp_display_probe(struct platform_device *pdev) 1216 { 1217 int rc = 0; 1218 struct dp_display_private *dp; 1219 1220 if (!pdev || !pdev->dev.of_node) { 1221 DRM_ERROR("pdev not found\n"); 1222 return -ENODEV; 1223 } 1224 1225 dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL); 1226 if (!dp) 1227 return -ENOMEM; 1228 1229 dp->pdev = pdev; 1230 dp->name = "drm_dp"; 1231 1232 rc = dp_init_sub_modules(dp); 1233 if (rc) { 1234 DRM_ERROR("init sub module failed\n"); 1235 return -EPROBE_DEFER; 1236 } 1237 1238 mutex_init(&dp->event_mutex); 1239 g_dp_display = &dp->dp_display; 1240 1241 /* Store DP audio handle inside DP display */ 1242 g_dp_display->dp_audio = dp->audio; 1243 1244 init_completion(&dp->audio_comp); 1245 1246 platform_set_drvdata(pdev, g_dp_display); 1247 1248 rc = component_add(&pdev->dev, &dp_display_comp_ops); 1249 if (rc) { 1250 DRM_ERROR("component add failed, rc=%d\n", rc); 1251 dp_display_deinit_sub_modules(dp); 1252 } 1253 1254 return rc; 1255 } 1256 1257 static int dp_display_remove(struct platform_device *pdev) 1258 { 1259 struct dp_display_private *dp; 1260 1261 dp = container_of(g_dp_display, 1262 struct dp_display_private, dp_display); 1263 1264 dp_display_deinit_sub_modules(dp); 1265 1266 component_del(&pdev->dev, &dp_display_comp_ops); 1267 platform_set_drvdata(pdev, NULL); 1268 1269 return 0; 1270 } 1271 1272 static int dp_pm_resume(struct device *dev) 1273 { 1274 struct platform_device *pdev = to_platform_device(dev); 1275 struct msm_dp *dp_display = platform_get_drvdata(pdev); 1276 struct dp_display_private *dp; 1277 int sink_count = 0; 1278 1279 dp = container_of(dp_display, struct dp_display_private, dp_display); 1280 1281 mutex_lock(&dp->event_mutex); 1282 1283 DRM_DEBUG_DP("Before, core_inited=%d power_on=%d\n", 1284 dp->core_initialized, dp_display->power_on); 1285 1286 /* start from disconnected state */ 1287 dp->hpd_state = ST_DISCONNECTED; 1288 1289 /* turn on dp ctrl/phy */ 1290 dp_display_host_init(dp, true); 1291 1292 dp_catalog_ctrl_hpd_config(dp->catalog); 1293 1294 /* 1295 * set sink to normal operation mode -- D0 1296 * before dpcd read 1297 */ 1298 dp_link_psm_config(dp->link, &dp->panel->link_info, false); 1299 1300 if (dp_catalog_link_is_connected(dp->catalog)) { 1301 sink_count = drm_dp_read_sink_count(dp->aux); 1302 if (sink_count < 0) 1303 sink_count = 0; 1304 } 1305 1306 dp->link->sink_count = sink_count; 1307 /* 1308 * can not declared display is connected unless 1309 * HDMI cable is plugged in and sink_count of 1310 * dongle become 1 1311 */ 1312 if (dp->link->sink_count) 1313 dp->dp_display.is_connected = true; 1314 else 1315 dp->dp_display.is_connected = false; 1316 1317 DRM_DEBUG_DP("After, sink_count=%d is_connected=%d core_inited=%d power_on=%d\n", 1318 dp->link->sink_count, dp->dp_display.is_connected, 1319 dp->core_initialized, dp_display->power_on); 1320 1321 mutex_unlock(&dp->event_mutex); 1322 1323 return 0; 1324 } 1325 1326 static int dp_pm_suspend(struct device *dev) 1327 { 1328 struct platform_device *pdev = to_platform_device(dev); 1329 struct msm_dp *dp_display = platform_get_drvdata(pdev); 1330 struct dp_display_private *dp; 1331 1332 dp = container_of(dp_display, struct dp_display_private, dp_display); 1333 1334 mutex_lock(&dp->event_mutex); 1335 1336 DRM_DEBUG_DP("Before, core_inited=%d power_on=%d\n", 1337 dp->core_initialized, dp_display->power_on); 1338 1339 if (dp->core_initialized == true) { 1340 /* mainlink enabled */ 1341 if (dp_power_clk_status(dp->power, DP_CTRL_PM)) 1342 dp_ctrl_off_link_stream(dp->ctrl); 1343 1344 dp_display_host_deinit(dp); 1345 } 1346 1347 dp->hpd_state = ST_SUSPENDED; 1348 1349 /* host_init will be called at pm_resume */ 1350 dp->core_initialized = false; 1351 1352 DRM_DEBUG_DP("After, core_inited=%d power_on=%d\n", 1353 dp->core_initialized, dp_display->power_on); 1354 1355 mutex_unlock(&dp->event_mutex); 1356 1357 return 0; 1358 } 1359 1360 static int dp_pm_prepare(struct device *dev) 1361 { 1362 return 0; 1363 } 1364 1365 static void dp_pm_complete(struct device *dev) 1366 { 1367 1368 } 1369 1370 static const struct dev_pm_ops dp_pm_ops = { 1371 .suspend = dp_pm_suspend, 1372 .resume = dp_pm_resume, 1373 .prepare = dp_pm_prepare, 1374 .complete = dp_pm_complete, 1375 }; 1376 1377 static struct platform_driver dp_display_driver = { 1378 .probe = dp_display_probe, 1379 .remove = dp_display_remove, 1380 .driver = { 1381 .name = "msm-dp-display", 1382 .of_match_table = dp_dt_match, 1383 .suppress_bind_attrs = true, 1384 .pm = &dp_pm_ops, 1385 }, 1386 }; 1387 1388 int __init msm_dp_register(void) 1389 { 1390 int ret; 1391 1392 ret = platform_driver_register(&dp_display_driver); 1393 if (ret) 1394 DRM_ERROR("Dp display driver register failed"); 1395 1396 return ret; 1397 } 1398 1399 void __exit msm_dp_unregister(void) 1400 { 1401 platform_driver_unregister(&dp_display_driver); 1402 } 1403 1404 void msm_dp_irq_postinstall(struct msm_dp *dp_display) 1405 { 1406 struct dp_display_private *dp; 1407 1408 if (!dp_display) 1409 return; 1410 1411 dp = container_of(dp_display, struct dp_display_private, dp_display); 1412 1413 dp_hpd_event_setup(dp); 1414 1415 dp_add_event(dp, EV_HPD_INIT_SETUP, 0, 100); 1416 } 1417 1418 void msm_dp_debugfs_init(struct msm_dp *dp_display, struct drm_minor *minor) 1419 { 1420 struct dp_display_private *dp; 1421 struct device *dev; 1422 int rc; 1423 1424 dp = container_of(dp_display, struct dp_display_private, dp_display); 1425 dev = &dp->pdev->dev; 1426 1427 dp->debug = dp_debug_get(dev, dp->panel, dp->usbpd, 1428 dp->link, &dp->dp_display.connector, 1429 minor); 1430 if (IS_ERR(dp->debug)) { 1431 rc = PTR_ERR(dp->debug); 1432 DRM_ERROR("failed to initialize debug, rc = %d\n", rc); 1433 dp->debug = NULL; 1434 } 1435 } 1436 1437 int msm_dp_modeset_init(struct msm_dp *dp_display, struct drm_device *dev, 1438 struct drm_encoder *encoder) 1439 { 1440 struct msm_drm_private *priv; 1441 int ret; 1442 1443 if (WARN_ON(!encoder) || WARN_ON(!dp_display) || WARN_ON(!dev)) 1444 return -EINVAL; 1445 1446 priv = dev->dev_private; 1447 dp_display->drm_dev = dev; 1448 1449 ret = dp_display_request_irq(dp_display); 1450 if (ret) { 1451 DRM_ERROR("request_irq failed, ret=%d\n", ret); 1452 return ret; 1453 } 1454 1455 dp_display->encoder = encoder; 1456 1457 dp_display->connector = dp_drm_connector_init(dp_display); 1458 if (IS_ERR(dp_display->connector)) { 1459 ret = PTR_ERR(dp_display->connector); 1460 DRM_DEV_ERROR(dev->dev, 1461 "failed to create dp connector: %d\n", ret); 1462 dp_display->connector = NULL; 1463 return ret; 1464 } 1465 1466 priv->connectors[priv->num_connectors++] = dp_display->connector; 1467 return 0; 1468 } 1469 1470 int msm_dp_display_enable(struct msm_dp *dp, struct drm_encoder *encoder) 1471 { 1472 int rc = 0; 1473 struct dp_display_private *dp_display; 1474 u32 state; 1475 1476 dp_display = container_of(dp, struct dp_display_private, dp_display); 1477 if (!dp_display->dp_mode.drm_mode.clock) { 1478 DRM_ERROR("invalid params\n"); 1479 return -EINVAL; 1480 } 1481 1482 mutex_lock(&dp_display->event_mutex); 1483 1484 /* stop sentinel checking */ 1485 dp_del_event(dp_display, EV_CONNECT_PENDING_TIMEOUT); 1486 1487 rc = dp_display_set_mode(dp, &dp_display->dp_mode); 1488 if (rc) { 1489 DRM_ERROR("Failed to perform a mode set, rc=%d\n", rc); 1490 mutex_unlock(&dp_display->event_mutex); 1491 return rc; 1492 } 1493 1494 rc = dp_display_prepare(dp); 1495 if (rc) { 1496 DRM_ERROR("DP display prepare failed, rc=%d\n", rc); 1497 mutex_unlock(&dp_display->event_mutex); 1498 return rc; 1499 } 1500 1501 state = dp_display->hpd_state; 1502 1503 if (state == ST_DISPLAY_OFF) 1504 dp_display_host_init(dp_display, true); 1505 1506 dp_display_enable(dp_display, 0); 1507 1508 rc = dp_display_post_enable(dp); 1509 if (rc) { 1510 DRM_ERROR("DP display post enable failed, rc=%d\n", rc); 1511 dp_display_disable(dp_display, 0); 1512 dp_display_unprepare(dp); 1513 } 1514 1515 /* manual kick off plug event to train link */ 1516 if (state == ST_DISPLAY_OFF) 1517 dp_add_event(dp_display, EV_IRQ_HPD_INT, 0, 0); 1518 1519 /* completed connection */ 1520 dp_display->hpd_state = ST_CONNECTED; 1521 1522 mutex_unlock(&dp_display->event_mutex); 1523 1524 return rc; 1525 } 1526 1527 int msm_dp_display_pre_disable(struct msm_dp *dp, struct drm_encoder *encoder) 1528 { 1529 struct dp_display_private *dp_display; 1530 1531 dp_display = container_of(dp, struct dp_display_private, dp_display); 1532 1533 dp_ctrl_push_idle(dp_display->ctrl); 1534 1535 return 0; 1536 } 1537 1538 int msm_dp_display_disable(struct msm_dp *dp, struct drm_encoder *encoder) 1539 { 1540 int rc = 0; 1541 u32 state; 1542 struct dp_display_private *dp_display; 1543 1544 dp_display = container_of(dp, struct dp_display_private, dp_display); 1545 1546 mutex_lock(&dp_display->event_mutex); 1547 1548 /* stop sentinel checking */ 1549 dp_del_event(dp_display, EV_DISCONNECT_PENDING_TIMEOUT); 1550 1551 dp_display_disable(dp_display, 0); 1552 1553 rc = dp_display_unprepare(dp); 1554 if (rc) 1555 DRM_ERROR("DP display unprepare failed, rc=%d\n", rc); 1556 1557 state = dp_display->hpd_state; 1558 if (state == ST_DISCONNECT_PENDING) { 1559 /* completed disconnection */ 1560 dp_display->hpd_state = ST_DISCONNECTED; 1561 } else { 1562 dp_display->hpd_state = ST_DISPLAY_OFF; 1563 } 1564 1565 mutex_unlock(&dp_display->event_mutex); 1566 return rc; 1567 } 1568 1569 void msm_dp_display_mode_set(struct msm_dp *dp, struct drm_encoder *encoder, 1570 struct drm_display_mode *mode, 1571 struct drm_display_mode *adjusted_mode) 1572 { 1573 struct dp_display_private *dp_display; 1574 1575 dp_display = container_of(dp, struct dp_display_private, dp_display); 1576 1577 memset(&dp_display->dp_mode, 0x0, sizeof(struct dp_display_mode)); 1578 1579 if (dp_display_check_video_test(dp)) 1580 dp_display->dp_mode.bpp = dp_display_get_test_bpp(dp); 1581 else /* Default num_components per pixel = 3 */ 1582 dp_display->dp_mode.bpp = dp->connector->display_info.bpc * 3; 1583 1584 if (!dp_display->dp_mode.bpp) 1585 dp_display->dp_mode.bpp = 24; /* Default bpp */ 1586 1587 drm_mode_copy(&dp_display->dp_mode.drm_mode, adjusted_mode); 1588 1589 dp_display->dp_mode.v_active_low = 1590 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NVSYNC); 1591 1592 dp_display->dp_mode.h_active_low = 1593 !!(dp_display->dp_mode.drm_mode.flags & DRM_MODE_FLAG_NHSYNC); 1594 } 1595