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