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