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/phy/phy.h> 13 #include <linux/delay.h> 14 #include <linux/string_choices.h> 15 #include <drm/display/drm_dp_aux_bus.h> 16 #include <drm/drm_edid.h> 17 18 #include "msm_drv.h" 19 #include "msm_kms.h" 20 #include "dp_ctrl.h" 21 #include "dp_catalog.h" 22 #include "dp_aux.h" 23 #include "dp_reg.h" 24 #include "dp_link.h" 25 #include "dp_panel.h" 26 #include "dp_display.h" 27 #include "dp_drm.h" 28 #include "dp_audio.h" 29 #include "dp_debug.h" 30 31 static bool psr_enabled = false; 32 module_param(psr_enabled, bool, 0); 33 MODULE_PARM_DESC(psr_enabled, "enable PSR for eDP and DP displays"); 34 35 #define HPD_STRING_SIZE 30 36 37 enum { 38 ISR_DISCONNECTED, 39 ISR_CONNECT_PENDING, 40 ISR_CONNECTED, 41 ISR_HPD_REPLUG_COUNT, 42 ISR_IRQ_HPD_PULSE_COUNT, 43 ISR_HPD_LO_GLITH_COUNT, 44 }; 45 46 /* event thread connection state */ 47 enum { 48 ST_DISCONNECTED, 49 ST_MAINLINK_READY, 50 ST_CONNECTED, 51 ST_DISCONNECT_PENDING, 52 ST_DISPLAY_OFF, 53 }; 54 55 enum { 56 EV_NO_EVENT, 57 /* hpd events */ 58 EV_HPD_PLUG_INT, 59 EV_IRQ_HPD_INT, 60 EV_HPD_UNPLUG_INT, 61 EV_USER_NOTIFICATION, 62 }; 63 64 #define EVENT_TIMEOUT (HZ/10) /* 100ms */ 65 #define DP_EVENT_Q_MAX 8 66 67 #define DP_TIMEOUT_NONE 0 68 69 #define WAIT_FOR_RESUME_TIMEOUT_JIFFIES (HZ / 2) 70 71 struct msm_dp_event { 72 u32 event_id; 73 u32 data; 74 u32 delay; 75 }; 76 77 struct msm_dp_display_private { 78 int irq; 79 80 unsigned int id; 81 82 /* state variables */ 83 bool core_initialized; 84 bool phy_initialized; 85 bool audio_supported; 86 87 struct drm_device *drm_dev; 88 89 struct msm_dp_catalog *catalog; 90 struct drm_dp_aux *aux; 91 struct msm_dp_link *link; 92 struct msm_dp_panel *panel; 93 struct msm_dp_ctrl *ctrl; 94 95 struct msm_dp_display_mode msm_dp_mode; 96 struct msm_dp msm_dp_display; 97 98 /* wait for audio signaling */ 99 struct completion audio_comp; 100 101 /* event related only access by event thread */ 102 struct mutex event_mutex; 103 wait_queue_head_t event_q; 104 u32 hpd_state; 105 u32 event_pndx; 106 u32 event_gndx; 107 struct task_struct *ev_tsk; 108 struct msm_dp_event event_list[DP_EVENT_Q_MAX]; 109 spinlock_t event_lock; 110 111 bool wide_bus_supported; 112 113 struct msm_dp_audio *audio; 114 }; 115 116 struct msm_dp_desc { 117 phys_addr_t io_start; 118 unsigned int id; 119 bool wide_bus_supported; 120 }; 121 122 static const struct msm_dp_desc msm_dp_desc_sa8775p[] = { 123 { .io_start = 0x0af54000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 124 { .io_start = 0x0af5c000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 125 { .io_start = 0x22154000, .id = MSM_DP_CONTROLLER_2, .wide_bus_supported = true }, 126 { .io_start = 0x2215c000, .id = MSM_DP_CONTROLLER_3, .wide_bus_supported = true }, 127 {} 128 }; 129 130 static const struct msm_dp_desc msm_dp_desc_sc7180[] = { 131 { .io_start = 0x0ae90000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 132 {} 133 }; 134 135 static const struct msm_dp_desc msm_dp_desc_sc7280[] = { 136 { .io_start = 0x0ae90000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 137 { .io_start = 0x0aea0000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 138 {} 139 }; 140 141 static const struct msm_dp_desc msm_dp_desc_sc8180x[] = { 142 { .io_start = 0x0ae90000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 143 { .io_start = 0x0ae98000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 144 { .io_start = 0x0ae9a000, .id = MSM_DP_CONTROLLER_2, .wide_bus_supported = true }, 145 {} 146 }; 147 148 static const struct msm_dp_desc msm_dp_desc_sc8280xp[] = { 149 { .io_start = 0x0ae90000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 150 { .io_start = 0x0ae98000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 151 { .io_start = 0x0ae9a000, .id = MSM_DP_CONTROLLER_2, .wide_bus_supported = true }, 152 { .io_start = 0x0aea0000, .id = MSM_DP_CONTROLLER_3, .wide_bus_supported = true }, 153 { .io_start = 0x22090000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 154 { .io_start = 0x22098000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 155 { .io_start = 0x2209a000, .id = MSM_DP_CONTROLLER_2, .wide_bus_supported = true }, 156 { .io_start = 0x220a0000, .id = MSM_DP_CONTROLLER_3, .wide_bus_supported = true }, 157 {} 158 }; 159 160 static const struct msm_dp_desc msm_dp_desc_sm8650[] = { 161 { .io_start = 0x0af54000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 162 {} 163 }; 164 165 static const struct msm_dp_desc msm_dp_desc_x1e80100[] = { 166 { .io_start = 0x0ae90000, .id = MSM_DP_CONTROLLER_0, .wide_bus_supported = true }, 167 { .io_start = 0x0ae98000, .id = MSM_DP_CONTROLLER_1, .wide_bus_supported = true }, 168 { .io_start = 0x0ae9a000, .id = MSM_DP_CONTROLLER_2, .wide_bus_supported = true }, 169 { .io_start = 0x0aea0000, .id = MSM_DP_CONTROLLER_3, .wide_bus_supported = true }, 170 {} 171 }; 172 173 static const struct of_device_id msm_dp_dt_match[] = { 174 { .compatible = "qcom,sa8775p-dp", .data = &msm_dp_desc_sa8775p }, 175 { .compatible = "qcom,sc7180-dp", .data = &msm_dp_desc_sc7180 }, 176 { .compatible = "qcom,sc7280-dp", .data = &msm_dp_desc_sc7280 }, 177 { .compatible = "qcom,sc7280-edp", .data = &msm_dp_desc_sc7280 }, 178 { .compatible = "qcom,sc8180x-dp", .data = &msm_dp_desc_sc8180x }, 179 { .compatible = "qcom,sc8180x-edp", .data = &msm_dp_desc_sc8180x }, 180 { .compatible = "qcom,sc8280xp-dp", .data = &msm_dp_desc_sc8280xp }, 181 { .compatible = "qcom,sc8280xp-edp", .data = &msm_dp_desc_sc8280xp }, 182 { .compatible = "qcom,sdm845-dp", .data = &msm_dp_desc_sc7180 }, 183 { .compatible = "qcom,sm8350-dp", .data = &msm_dp_desc_sc7180 }, 184 { .compatible = "qcom,sm8650-dp", .data = &msm_dp_desc_sm8650 }, 185 { .compatible = "qcom,x1e80100-dp", .data = &msm_dp_desc_x1e80100 }, 186 {} 187 }; 188 189 static struct msm_dp_display_private *dev_get_dp_display_private(struct device *dev) 190 { 191 struct msm_dp *dp = dev_get_drvdata(dev); 192 193 return container_of(dp, struct msm_dp_display_private, msm_dp_display); 194 } 195 196 static int msm_dp_add_event(struct msm_dp_display_private *msm_dp_priv, u32 event, 197 u32 data, u32 delay) 198 { 199 unsigned long flag; 200 struct msm_dp_event *todo; 201 int pndx; 202 203 spin_lock_irqsave(&msm_dp_priv->event_lock, flag); 204 pndx = msm_dp_priv->event_pndx + 1; 205 pndx %= DP_EVENT_Q_MAX; 206 if (pndx == msm_dp_priv->event_gndx) { 207 pr_err("event_q is full: pndx=%d gndx=%d\n", 208 msm_dp_priv->event_pndx, msm_dp_priv->event_gndx); 209 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 210 return -EPERM; 211 } 212 todo = &msm_dp_priv->event_list[msm_dp_priv->event_pndx++]; 213 msm_dp_priv->event_pndx %= DP_EVENT_Q_MAX; 214 todo->event_id = event; 215 todo->data = data; 216 todo->delay = delay; 217 wake_up(&msm_dp_priv->event_q); 218 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 219 220 return 0; 221 } 222 223 static int msm_dp_del_event(struct msm_dp_display_private *msm_dp_priv, u32 event) 224 { 225 unsigned long flag; 226 struct msm_dp_event *todo; 227 u32 gndx; 228 229 spin_lock_irqsave(&msm_dp_priv->event_lock, flag); 230 if (msm_dp_priv->event_pndx == msm_dp_priv->event_gndx) { 231 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 232 return -ENOENT; 233 } 234 235 gndx = msm_dp_priv->event_gndx; 236 while (msm_dp_priv->event_pndx != gndx) { 237 todo = &msm_dp_priv->event_list[gndx]; 238 if (todo->event_id == event) { 239 todo->event_id = EV_NO_EVENT; /* deleted */ 240 todo->delay = 0; 241 } 242 gndx++; 243 gndx %= DP_EVENT_Q_MAX; 244 } 245 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 246 247 return 0; 248 } 249 250 void msm_dp_display_signal_audio_start(struct msm_dp *msm_dp_display) 251 { 252 struct msm_dp_display_private *dp; 253 254 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 255 256 reinit_completion(&dp->audio_comp); 257 } 258 259 void msm_dp_display_signal_audio_complete(struct msm_dp *msm_dp_display) 260 { 261 struct msm_dp_display_private *dp; 262 263 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 264 265 complete_all(&dp->audio_comp); 266 } 267 268 static int msm_dp_hpd_event_thread_start(struct msm_dp_display_private *msm_dp_priv); 269 270 static int msm_dp_display_bind(struct device *dev, struct device *master, 271 void *data) 272 { 273 int rc = 0; 274 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 275 struct msm_drm_private *priv = dev_get_drvdata(master); 276 struct drm_device *drm = priv->dev; 277 278 dp->msm_dp_display.drm_dev = drm; 279 priv->dp[dp->id] = &dp->msm_dp_display; 280 281 282 283 dp->drm_dev = drm; 284 dp->aux->drm_dev = drm; 285 rc = msm_dp_aux_register(dp->aux); 286 if (rc) { 287 DRM_ERROR("DRM DP AUX register failed\n"); 288 goto end; 289 } 290 291 292 rc = msm_dp_register_audio_driver(dev, dp->audio); 293 if (rc) { 294 DRM_ERROR("Audio registration Dp failed\n"); 295 goto end; 296 } 297 298 rc = msm_dp_hpd_event_thread_start(dp); 299 if (rc) { 300 DRM_ERROR("Event thread create failed\n"); 301 goto end; 302 } 303 304 return 0; 305 end: 306 return rc; 307 } 308 309 static void msm_dp_display_unbind(struct device *dev, struct device *master, 310 void *data) 311 { 312 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 313 struct msm_drm_private *priv = dev_get_drvdata(master); 314 315 kthread_stop(dp->ev_tsk); 316 317 of_dp_aux_depopulate_bus(dp->aux); 318 319 msm_dp_unregister_audio_driver(dev, dp->audio); 320 msm_dp_aux_unregister(dp->aux); 321 dp->drm_dev = NULL; 322 dp->aux->drm_dev = NULL; 323 priv->dp[dp->id] = NULL; 324 } 325 326 static const struct component_ops msm_dp_display_comp_ops = { 327 .bind = msm_dp_display_bind, 328 .unbind = msm_dp_display_unbind, 329 }; 330 331 static void msm_dp_display_send_hpd_event(struct msm_dp *msm_dp_display) 332 { 333 struct msm_dp_display_private *dp; 334 struct drm_connector *connector; 335 336 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 337 338 connector = dp->msm_dp_display.connector; 339 drm_helper_hpd_irq_event(connector->dev); 340 } 341 342 static int msm_dp_display_send_hpd_notification(struct msm_dp_display_private *dp, 343 bool hpd) 344 { 345 if ((hpd && dp->msm_dp_display.link_ready) || 346 (!hpd && !dp->msm_dp_display.link_ready)) { 347 drm_dbg_dp(dp->drm_dev, "HPD already %s\n", str_on_off(hpd)); 348 return 0; 349 } 350 351 /* reset video pattern flag on disconnect */ 352 if (!hpd) { 353 dp->panel->video_test = false; 354 if (!dp->msm_dp_display.is_edp) 355 drm_dp_set_subconnector_property(dp->msm_dp_display.connector, 356 connector_status_disconnected, 357 dp->panel->dpcd, 358 dp->panel->downstream_ports); 359 } 360 361 dp->msm_dp_display.link_ready = hpd; 362 363 drm_dbg_dp(dp->drm_dev, "type=%d hpd=%d\n", 364 dp->msm_dp_display.connector_type, hpd); 365 msm_dp_display_send_hpd_event(&dp->msm_dp_display); 366 367 return 0; 368 } 369 370 static void msm_dp_display_lttpr_init(struct msm_dp_display_private *dp) 371 { 372 u8 lttpr_caps[DP_LTTPR_COMMON_CAP_SIZE]; 373 int rc; 374 375 if (drm_dp_read_lttpr_common_caps(dp->aux, dp->panel->dpcd, lttpr_caps)) 376 return; 377 378 rc = drm_dp_lttpr_init(dp->aux, drm_dp_lttpr_count(lttpr_caps)); 379 if (rc) 380 DRM_ERROR("failed to set LTTPRs transparency mode, rc=%d\n", rc); 381 } 382 383 static int msm_dp_display_process_hpd_high(struct msm_dp_display_private *dp) 384 { 385 struct drm_connector *connector = dp->msm_dp_display.connector; 386 const struct drm_display_info *info = &connector->display_info; 387 int rc = 0; 388 389 rc = msm_dp_panel_read_sink_caps(dp->panel, connector); 390 if (rc) 391 goto end; 392 393 msm_dp_display_lttpr_init(dp); 394 395 msm_dp_link_process_request(dp->link); 396 397 if (!dp->msm_dp_display.is_edp) 398 drm_dp_set_subconnector_property(connector, 399 connector_status_connected, 400 dp->panel->dpcd, 401 dp->panel->downstream_ports); 402 403 dp->msm_dp_display.psr_supported = dp->panel->psr_cap.version && psr_enabled; 404 405 dp->audio_supported = info->has_audio; 406 msm_dp_panel_handle_sink_request(dp->panel); 407 408 /* 409 * set sink to normal operation mode -- D0 410 * before dpcd read 411 */ 412 msm_dp_link_psm_config(dp->link, &dp->panel->link_info, false); 413 414 msm_dp_link_reset_phy_params_vx_px(dp->link); 415 rc = msm_dp_ctrl_on_link(dp->ctrl); 416 if (rc) { 417 DRM_ERROR("failed to complete DP link training\n"); 418 goto end; 419 } 420 421 msm_dp_add_event(dp, EV_USER_NOTIFICATION, true, 0); 422 423 end: 424 return rc; 425 } 426 427 static void msm_dp_display_host_phy_init(struct msm_dp_display_private *dp) 428 { 429 drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n", 430 dp->msm_dp_display.connector_type, dp->core_initialized, 431 dp->phy_initialized); 432 433 if (!dp->phy_initialized) { 434 msm_dp_ctrl_phy_init(dp->ctrl); 435 dp->phy_initialized = true; 436 } 437 } 438 439 static void msm_dp_display_host_phy_exit(struct msm_dp_display_private *dp) 440 { 441 drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n", 442 dp->msm_dp_display.connector_type, dp->core_initialized, 443 dp->phy_initialized); 444 445 if (dp->phy_initialized) { 446 msm_dp_ctrl_phy_exit(dp->ctrl); 447 dp->phy_initialized = false; 448 } 449 } 450 451 static void msm_dp_display_host_init(struct msm_dp_display_private *dp) 452 { 453 drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n", 454 dp->msm_dp_display.connector_type, dp->core_initialized, 455 dp->phy_initialized); 456 457 msm_dp_ctrl_core_clk_enable(dp->ctrl); 458 msm_dp_ctrl_reset_irq_ctrl(dp->ctrl, true); 459 msm_dp_aux_init(dp->aux); 460 dp->core_initialized = true; 461 } 462 463 static void msm_dp_display_host_deinit(struct msm_dp_display_private *dp) 464 { 465 drm_dbg_dp(dp->drm_dev, "type=%d core_init=%d phy_init=%d\n", 466 dp->msm_dp_display.connector_type, dp->core_initialized, 467 dp->phy_initialized); 468 469 msm_dp_ctrl_reset_irq_ctrl(dp->ctrl, false); 470 msm_dp_aux_deinit(dp->aux); 471 msm_dp_ctrl_core_clk_disable(dp->ctrl); 472 dp->core_initialized = false; 473 } 474 475 static int msm_dp_display_usbpd_configure_cb(struct device *dev) 476 { 477 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 478 479 msm_dp_display_host_phy_init(dp); 480 481 return msm_dp_display_process_hpd_high(dp); 482 } 483 484 static int msm_dp_display_notify_disconnect(struct device *dev) 485 { 486 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 487 488 msm_dp_add_event(dp, EV_USER_NOTIFICATION, false, 0); 489 490 return 0; 491 } 492 493 static void msm_dp_display_handle_video_request(struct msm_dp_display_private *dp) 494 { 495 if (dp->link->sink_request & DP_TEST_LINK_VIDEO_PATTERN) { 496 dp->panel->video_test = true; 497 msm_dp_link_send_test_response(dp->link); 498 } 499 } 500 501 static int msm_dp_display_handle_port_status_changed(struct msm_dp_display_private *dp) 502 { 503 int rc = 0; 504 505 if (drm_dp_is_branch(dp->panel->dpcd) && dp->link->sink_count == 0) { 506 drm_dbg_dp(dp->drm_dev, "sink count is zero, nothing to do\n"); 507 if (dp->hpd_state != ST_DISCONNECTED) { 508 dp->hpd_state = ST_DISCONNECT_PENDING; 509 msm_dp_add_event(dp, EV_USER_NOTIFICATION, false, 0); 510 } 511 } else { 512 if (dp->hpd_state == ST_DISCONNECTED) { 513 dp->hpd_state = ST_MAINLINK_READY; 514 rc = msm_dp_display_process_hpd_high(dp); 515 if (rc) 516 dp->hpd_state = ST_DISCONNECTED; 517 } 518 } 519 520 return rc; 521 } 522 523 static int msm_dp_display_handle_irq_hpd(struct msm_dp_display_private *dp) 524 { 525 u32 sink_request = dp->link->sink_request; 526 527 drm_dbg_dp(dp->drm_dev, "%d\n", sink_request); 528 if (dp->hpd_state == ST_DISCONNECTED) { 529 if (sink_request & DP_LINK_STATUS_UPDATED) { 530 drm_dbg_dp(dp->drm_dev, "Disconnected sink_request: %d\n", 531 sink_request); 532 DRM_ERROR("Disconnected, no DP_LINK_STATUS_UPDATED\n"); 533 return -EINVAL; 534 } 535 } 536 537 msm_dp_ctrl_handle_sink_request(dp->ctrl); 538 539 if (sink_request & DP_TEST_LINK_VIDEO_PATTERN) 540 msm_dp_display_handle_video_request(dp); 541 542 return 0; 543 } 544 545 static int msm_dp_display_usbpd_attention_cb(struct device *dev) 546 { 547 int rc = 0; 548 u32 sink_request; 549 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 550 551 /* check for any test request issued by sink */ 552 rc = msm_dp_link_process_request(dp->link); 553 if (!rc) { 554 sink_request = dp->link->sink_request; 555 drm_dbg_dp(dp->drm_dev, "hpd_state=%d sink_request=%d\n", 556 dp->hpd_state, sink_request); 557 if (sink_request & DS_PORT_STATUS_CHANGED) 558 rc = msm_dp_display_handle_port_status_changed(dp); 559 else 560 rc = msm_dp_display_handle_irq_hpd(dp); 561 } 562 563 return rc; 564 } 565 566 static int msm_dp_hpd_plug_handle(struct msm_dp_display_private *dp, u32 data) 567 { 568 u32 state; 569 int ret; 570 struct platform_device *pdev = dp->msm_dp_display.pdev; 571 572 msm_dp_aux_enable_xfers(dp->aux, true); 573 574 mutex_lock(&dp->event_mutex); 575 576 state = dp->hpd_state; 577 drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n", 578 dp->msm_dp_display.connector_type, state); 579 580 if (state == ST_DISPLAY_OFF) { 581 mutex_unlock(&dp->event_mutex); 582 return 0; 583 } 584 585 if (state == ST_MAINLINK_READY || state == ST_CONNECTED) { 586 mutex_unlock(&dp->event_mutex); 587 return 0; 588 } 589 590 if (state == ST_DISCONNECT_PENDING) { 591 /* wait until ST_DISCONNECTED */ 592 msm_dp_add_event(dp, EV_HPD_PLUG_INT, 0, 1); /* delay = 1 */ 593 mutex_unlock(&dp->event_mutex); 594 return 0; 595 } 596 597 ret = pm_runtime_resume_and_get(&pdev->dev); 598 if (ret) { 599 DRM_ERROR("failed to pm_runtime_resume\n"); 600 mutex_unlock(&dp->event_mutex); 601 return ret; 602 } 603 604 ret = msm_dp_display_usbpd_configure_cb(&pdev->dev); 605 if (ret) { /* link train failed */ 606 dp->hpd_state = ST_DISCONNECTED; 607 pm_runtime_put_sync(&pdev->dev); 608 } else { 609 dp->hpd_state = ST_MAINLINK_READY; 610 } 611 612 drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n", 613 dp->msm_dp_display.connector_type, state); 614 mutex_unlock(&dp->event_mutex); 615 616 /* uevent will complete connection part */ 617 return 0; 618 }; 619 620 static void msm_dp_display_handle_plugged_change(struct msm_dp *msm_dp_display, 621 bool plugged) 622 { 623 struct msm_dp_display_private *dp; 624 625 dp = container_of(msm_dp_display, 626 struct msm_dp_display_private, msm_dp_display); 627 628 /* notify audio subsystem only if sink supports audio */ 629 if (msm_dp_display->plugged_cb && msm_dp_display->codec_dev && 630 dp->audio_supported) 631 msm_dp_display->plugged_cb(msm_dp_display->codec_dev, plugged); 632 } 633 634 static int msm_dp_hpd_unplug_handle(struct msm_dp_display_private *dp, u32 data) 635 { 636 u32 state; 637 struct platform_device *pdev = dp->msm_dp_display.pdev; 638 639 msm_dp_aux_enable_xfers(dp->aux, false); 640 641 mutex_lock(&dp->event_mutex); 642 643 state = dp->hpd_state; 644 645 drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n", 646 dp->msm_dp_display.connector_type, state); 647 648 /* unplugged, no more irq_hpd handle */ 649 msm_dp_del_event(dp, EV_IRQ_HPD_INT); 650 651 if (state == ST_DISCONNECTED) { 652 /* triggered by irq_hdp with sink_count = 0 */ 653 if (dp->link->sink_count == 0) { 654 msm_dp_display_host_phy_exit(dp); 655 } 656 msm_dp_display_notify_disconnect(&dp->msm_dp_display.pdev->dev); 657 mutex_unlock(&dp->event_mutex); 658 return 0; 659 } else if (state == ST_DISCONNECT_PENDING) { 660 mutex_unlock(&dp->event_mutex); 661 return 0; 662 } else if (state == ST_MAINLINK_READY) { 663 msm_dp_ctrl_off_link(dp->ctrl); 664 msm_dp_display_host_phy_exit(dp); 665 dp->hpd_state = ST_DISCONNECTED; 666 msm_dp_display_notify_disconnect(&dp->msm_dp_display.pdev->dev); 667 pm_runtime_put_sync(&pdev->dev); 668 mutex_unlock(&dp->event_mutex); 669 return 0; 670 } 671 672 /* 673 * We don't need separate work for disconnect as 674 * connect/attention interrupts are disabled 675 */ 676 msm_dp_display_notify_disconnect(&dp->msm_dp_display.pdev->dev); 677 678 if (state == ST_DISPLAY_OFF) { 679 dp->hpd_state = ST_DISCONNECTED; 680 } else { 681 dp->hpd_state = ST_DISCONNECT_PENDING; 682 } 683 684 /* signal the disconnect event early to ensure proper teardown */ 685 msm_dp_display_handle_plugged_change(&dp->msm_dp_display, false); 686 687 drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n", 688 dp->msm_dp_display.connector_type, state); 689 690 /* uevent will complete disconnection part */ 691 pm_runtime_put_sync(&pdev->dev); 692 mutex_unlock(&dp->event_mutex); 693 return 0; 694 } 695 696 static int msm_dp_irq_hpd_handle(struct msm_dp_display_private *dp, u32 data) 697 { 698 u32 state; 699 700 mutex_lock(&dp->event_mutex); 701 702 /* irq_hpd can happen at either connected or disconnected state */ 703 state = dp->hpd_state; 704 drm_dbg_dp(dp->drm_dev, "Before, type=%d hpd_state=%d\n", 705 dp->msm_dp_display.connector_type, state); 706 707 if (state == ST_DISPLAY_OFF) { 708 mutex_unlock(&dp->event_mutex); 709 return 0; 710 } 711 712 if (state == ST_MAINLINK_READY || state == ST_DISCONNECT_PENDING) { 713 /* wait until ST_CONNECTED */ 714 msm_dp_add_event(dp, EV_IRQ_HPD_INT, 0, 1); /* delay = 1 */ 715 mutex_unlock(&dp->event_mutex); 716 return 0; 717 } 718 719 msm_dp_display_usbpd_attention_cb(&dp->msm_dp_display.pdev->dev); 720 721 drm_dbg_dp(dp->drm_dev, "After, type=%d hpd_state=%d\n", 722 dp->msm_dp_display.connector_type, state); 723 724 mutex_unlock(&dp->event_mutex); 725 726 return 0; 727 } 728 729 static void msm_dp_display_deinit_sub_modules(struct msm_dp_display_private *dp) 730 { 731 msm_dp_audio_put(dp->audio); 732 msm_dp_panel_put(dp->panel); 733 msm_dp_aux_put(dp->aux); 734 } 735 736 static int msm_dp_init_sub_modules(struct msm_dp_display_private *dp) 737 { 738 int rc = 0; 739 struct device *dev = &dp->msm_dp_display.pdev->dev; 740 struct phy *phy; 741 742 phy = devm_phy_get(dev, "dp"); 743 if (IS_ERR(phy)) 744 return PTR_ERR(phy); 745 746 rc = phy_set_mode_ext(phy, PHY_MODE_DP, 747 dp->msm_dp_display.is_edp ? PHY_SUBMODE_EDP : PHY_SUBMODE_DP); 748 if (rc) { 749 DRM_ERROR("failed to set phy submode, rc = %d\n", rc); 750 dp->catalog = NULL; 751 goto error; 752 } 753 754 dp->catalog = msm_dp_catalog_get(dev); 755 if (IS_ERR(dp->catalog)) { 756 rc = PTR_ERR(dp->catalog); 757 DRM_ERROR("failed to initialize catalog, rc = %d\n", rc); 758 dp->catalog = NULL; 759 goto error; 760 } 761 762 dp->aux = msm_dp_aux_get(dev, dp->catalog, 763 phy, 764 dp->msm_dp_display.is_edp); 765 if (IS_ERR(dp->aux)) { 766 rc = PTR_ERR(dp->aux); 767 DRM_ERROR("failed to initialize aux, rc = %d\n", rc); 768 dp->aux = NULL; 769 goto error; 770 } 771 772 dp->link = msm_dp_link_get(dev, dp->aux); 773 if (IS_ERR(dp->link)) { 774 rc = PTR_ERR(dp->link); 775 DRM_ERROR("failed to initialize link, rc = %d\n", rc); 776 dp->link = NULL; 777 goto error_link; 778 } 779 780 dp->panel = msm_dp_panel_get(dev, dp->aux, dp->link, dp->catalog); 781 if (IS_ERR(dp->panel)) { 782 rc = PTR_ERR(dp->panel); 783 DRM_ERROR("failed to initialize panel, rc = %d\n", rc); 784 dp->panel = NULL; 785 goto error_link; 786 } 787 788 dp->ctrl = msm_dp_ctrl_get(dev, dp->link, dp->panel, dp->aux, 789 dp->catalog, 790 phy); 791 if (IS_ERR(dp->ctrl)) { 792 rc = PTR_ERR(dp->ctrl); 793 DRM_ERROR("failed to initialize ctrl, rc = %d\n", rc); 794 dp->ctrl = NULL; 795 goto error_ctrl; 796 } 797 798 dp->audio = msm_dp_audio_get(dp->msm_dp_display.pdev, dp->catalog); 799 if (IS_ERR(dp->audio)) { 800 rc = PTR_ERR(dp->audio); 801 pr_err("failed to initialize audio, rc = %d\n", rc); 802 dp->audio = NULL; 803 goto error_ctrl; 804 } 805 806 return rc; 807 808 error_ctrl: 809 msm_dp_panel_put(dp->panel); 810 error_link: 811 msm_dp_aux_put(dp->aux); 812 error: 813 return rc; 814 } 815 816 static int msm_dp_display_set_mode(struct msm_dp *msm_dp_display, 817 struct msm_dp_display_mode *mode) 818 { 819 struct msm_dp_display_private *dp; 820 821 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 822 823 drm_mode_copy(&dp->panel->msm_dp_mode.drm_mode, &mode->drm_mode); 824 dp->panel->msm_dp_mode.bpp = mode->bpp; 825 dp->panel->msm_dp_mode.out_fmt_is_yuv_420 = mode->out_fmt_is_yuv_420; 826 msm_dp_panel_init_panel_info(dp->panel); 827 return 0; 828 } 829 830 static int msm_dp_display_enable(struct msm_dp_display_private *dp, bool force_link_train) 831 { 832 int rc = 0; 833 struct msm_dp *msm_dp_display = &dp->msm_dp_display; 834 835 drm_dbg_dp(dp->drm_dev, "sink_count=%d\n", dp->link->sink_count); 836 if (msm_dp_display->power_on) { 837 drm_dbg_dp(dp->drm_dev, "Link already setup, return\n"); 838 return 0; 839 } 840 841 rc = msm_dp_ctrl_on_stream(dp->ctrl, force_link_train); 842 if (!rc) 843 msm_dp_display->power_on = true; 844 845 return rc; 846 } 847 848 static int msm_dp_display_post_enable(struct msm_dp *msm_dp_display) 849 { 850 struct msm_dp_display_private *dp; 851 u32 rate; 852 853 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 854 855 rate = dp->link->link_params.rate; 856 857 if (dp->audio_supported) { 858 dp->audio->bw_code = drm_dp_link_rate_to_bw_code(rate); 859 dp->audio->lane_count = dp->link->link_params.num_lanes; 860 } 861 862 /* signal the connect event late to synchronize video and display */ 863 msm_dp_display_handle_plugged_change(msm_dp_display, true); 864 865 if (msm_dp_display->psr_supported) 866 msm_dp_ctrl_config_psr(dp->ctrl); 867 868 return 0; 869 } 870 871 static int msm_dp_display_disable(struct msm_dp_display_private *dp) 872 { 873 struct msm_dp *msm_dp_display = &dp->msm_dp_display; 874 875 if (!msm_dp_display->power_on) 876 return 0; 877 878 /* wait only if audio was enabled */ 879 if (msm_dp_display->audio_enabled) { 880 /* signal the disconnect event */ 881 msm_dp_display_handle_plugged_change(msm_dp_display, false); 882 if (!wait_for_completion_timeout(&dp->audio_comp, 883 HZ * 5)) 884 DRM_ERROR("audio comp timeout\n"); 885 } 886 887 msm_dp_display->audio_enabled = false; 888 889 if (dp->link->sink_count == 0) { 890 /* 891 * irq_hpd with sink_count = 0 892 * hdmi unplugged out of dongle 893 */ 894 msm_dp_ctrl_off_link_stream(dp->ctrl); 895 } else { 896 /* 897 * unplugged interrupt 898 * dongle unplugged out of DUT 899 */ 900 msm_dp_ctrl_off(dp->ctrl); 901 msm_dp_display_host_phy_exit(dp); 902 } 903 904 msm_dp_display->power_on = false; 905 906 drm_dbg_dp(dp->drm_dev, "sink count: %d\n", dp->link->sink_count); 907 return 0; 908 } 909 910 int msm_dp_display_set_plugged_cb(struct msm_dp *msm_dp_display, 911 hdmi_codec_plugged_cb fn, struct device *codec_dev) 912 { 913 bool plugged; 914 915 msm_dp_display->plugged_cb = fn; 916 msm_dp_display->codec_dev = codec_dev; 917 plugged = msm_dp_display->link_ready; 918 msm_dp_display_handle_plugged_change(msm_dp_display, plugged); 919 920 return 0; 921 } 922 923 /** 924 * msm_dp_bridge_mode_valid - callback to determine if specified mode is valid 925 * @bridge: Pointer to drm bridge structure 926 * @info: display info 927 * @mode: Pointer to drm mode structure 928 * Returns: Validity status for specified mode 929 */ 930 enum drm_mode_status msm_dp_bridge_mode_valid(struct drm_bridge *bridge, 931 const struct drm_display_info *info, 932 const struct drm_display_mode *mode) 933 { 934 const u32 num_components = 3, default_bpp = 24; 935 struct msm_dp_display_private *msm_dp_display; 936 struct msm_dp_link_info *link_info; 937 u32 mode_rate_khz = 0, supported_rate_khz = 0, mode_bpp = 0; 938 struct msm_dp *dp; 939 int mode_pclk_khz = mode->clock; 940 941 dp = to_dp_bridge(bridge)->msm_dp_display; 942 943 if (!dp || !mode_pclk_khz || !dp->connector) { 944 DRM_ERROR("invalid params\n"); 945 return -EINVAL; 946 } 947 948 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 949 link_info = &msm_dp_display->panel->link_info; 950 951 if ((drm_mode_is_420_only(&dp->connector->display_info, mode) && 952 msm_dp_display->panel->vsc_sdp_supported) || 953 msm_dp_wide_bus_available(dp)) 954 mode_pclk_khz /= 2; 955 956 if (mode_pclk_khz > DP_MAX_PIXEL_CLK_KHZ) 957 return MODE_CLOCK_HIGH; 958 959 mode_bpp = dp->connector->display_info.bpc * num_components; 960 if (!mode_bpp) 961 mode_bpp = default_bpp; 962 963 mode_bpp = msm_dp_panel_get_mode_bpp(msm_dp_display->panel, 964 mode_bpp, mode_pclk_khz); 965 966 mode_rate_khz = mode_pclk_khz * mode_bpp; 967 supported_rate_khz = link_info->num_lanes * link_info->rate * 8; 968 969 if (mode_rate_khz > supported_rate_khz) 970 return MODE_BAD; 971 972 return MODE_OK; 973 } 974 975 int msm_dp_display_get_modes(struct msm_dp *dp) 976 { 977 struct msm_dp_display_private *msm_dp_display; 978 979 if (!dp) { 980 DRM_ERROR("invalid params\n"); 981 return 0; 982 } 983 984 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 985 986 return msm_dp_panel_get_modes(msm_dp_display->panel, 987 dp->connector); 988 } 989 990 bool msm_dp_display_check_video_test(struct msm_dp *dp) 991 { 992 struct msm_dp_display_private *msm_dp_display; 993 994 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 995 996 return msm_dp_display->panel->video_test; 997 } 998 999 int msm_dp_display_get_test_bpp(struct msm_dp *dp) 1000 { 1001 struct msm_dp_display_private *msm_dp_display; 1002 1003 if (!dp) { 1004 DRM_ERROR("invalid params\n"); 1005 return 0; 1006 } 1007 1008 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1009 1010 return msm_dp_link_bit_depth_to_bpp( 1011 msm_dp_display->link->test_video.test_bit_depth); 1012 } 1013 1014 void msm_dp_snapshot(struct msm_disp_state *disp_state, struct msm_dp *dp) 1015 { 1016 struct msm_dp_display_private *msm_dp_display; 1017 1018 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1019 1020 /* 1021 * if we are reading registers we need the link clocks to be on 1022 * however till DP cable is connected this will not happen as we 1023 * do not know the resolution to power up with. Hence check the 1024 * power_on status before dumping DP registers to avoid crash due 1025 * to unclocked access 1026 */ 1027 mutex_lock(&msm_dp_display->event_mutex); 1028 1029 if (!dp->power_on) { 1030 mutex_unlock(&msm_dp_display->event_mutex); 1031 return; 1032 } 1033 1034 msm_dp_catalog_snapshot(msm_dp_display->catalog, disp_state); 1035 1036 mutex_unlock(&msm_dp_display->event_mutex); 1037 } 1038 1039 void msm_dp_display_set_psr(struct msm_dp *msm_dp_display, bool enter) 1040 { 1041 struct msm_dp_display_private *dp; 1042 1043 if (!msm_dp_display) { 1044 DRM_ERROR("invalid params\n"); 1045 return; 1046 } 1047 1048 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1049 msm_dp_ctrl_set_psr(dp->ctrl, enter); 1050 } 1051 1052 static int hpd_event_thread(void *data) 1053 { 1054 struct msm_dp_display_private *msm_dp_priv; 1055 unsigned long flag; 1056 struct msm_dp_event *todo; 1057 int timeout_mode = 0; 1058 1059 msm_dp_priv = (struct msm_dp_display_private *)data; 1060 1061 while (1) { 1062 if (timeout_mode) { 1063 wait_event_timeout(msm_dp_priv->event_q, 1064 (msm_dp_priv->event_pndx == msm_dp_priv->event_gndx) || 1065 kthread_should_stop(), EVENT_TIMEOUT); 1066 } else { 1067 wait_event_interruptible(msm_dp_priv->event_q, 1068 (msm_dp_priv->event_pndx != msm_dp_priv->event_gndx) || 1069 kthread_should_stop()); 1070 } 1071 1072 if (kthread_should_stop()) 1073 break; 1074 1075 spin_lock_irqsave(&msm_dp_priv->event_lock, flag); 1076 todo = &msm_dp_priv->event_list[msm_dp_priv->event_gndx]; 1077 if (todo->delay) { 1078 struct msm_dp_event *todo_next; 1079 1080 msm_dp_priv->event_gndx++; 1081 msm_dp_priv->event_gndx %= DP_EVENT_Q_MAX; 1082 1083 /* re enter delay event into q */ 1084 todo_next = &msm_dp_priv->event_list[msm_dp_priv->event_pndx++]; 1085 msm_dp_priv->event_pndx %= DP_EVENT_Q_MAX; 1086 todo_next->event_id = todo->event_id; 1087 todo_next->data = todo->data; 1088 todo_next->delay = todo->delay - 1; 1089 1090 /* clean up older event */ 1091 todo->event_id = EV_NO_EVENT; 1092 todo->delay = 0; 1093 1094 /* switch to timeout mode */ 1095 timeout_mode = 1; 1096 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 1097 continue; 1098 } 1099 1100 /* timeout with no events in q */ 1101 if (msm_dp_priv->event_pndx == msm_dp_priv->event_gndx) { 1102 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 1103 continue; 1104 } 1105 1106 msm_dp_priv->event_gndx++; 1107 msm_dp_priv->event_gndx %= DP_EVENT_Q_MAX; 1108 timeout_mode = 0; 1109 spin_unlock_irqrestore(&msm_dp_priv->event_lock, flag); 1110 1111 switch (todo->event_id) { 1112 case EV_HPD_PLUG_INT: 1113 msm_dp_hpd_plug_handle(msm_dp_priv, todo->data); 1114 break; 1115 case EV_HPD_UNPLUG_INT: 1116 msm_dp_hpd_unplug_handle(msm_dp_priv, todo->data); 1117 break; 1118 case EV_IRQ_HPD_INT: 1119 msm_dp_irq_hpd_handle(msm_dp_priv, todo->data); 1120 break; 1121 case EV_USER_NOTIFICATION: 1122 msm_dp_display_send_hpd_notification(msm_dp_priv, 1123 todo->data); 1124 break; 1125 default: 1126 break; 1127 } 1128 } 1129 1130 return 0; 1131 } 1132 1133 static int msm_dp_hpd_event_thread_start(struct msm_dp_display_private *msm_dp_priv) 1134 { 1135 /* set event q to empty */ 1136 msm_dp_priv->event_gndx = 0; 1137 msm_dp_priv->event_pndx = 0; 1138 1139 msm_dp_priv->ev_tsk = kthread_run(hpd_event_thread, msm_dp_priv, "dp_hpd_handler"); 1140 if (IS_ERR(msm_dp_priv->ev_tsk)) 1141 return PTR_ERR(msm_dp_priv->ev_tsk); 1142 1143 return 0; 1144 } 1145 1146 static irqreturn_t msm_dp_display_irq_handler(int irq, void *dev_id) 1147 { 1148 struct msm_dp_display_private *dp = dev_id; 1149 irqreturn_t ret = IRQ_NONE; 1150 u32 hpd_isr_status; 1151 1152 if (!dp) { 1153 DRM_ERROR("invalid data\n"); 1154 return IRQ_NONE; 1155 } 1156 1157 hpd_isr_status = msm_dp_catalog_hpd_get_intr_status(dp->catalog); 1158 1159 if (hpd_isr_status & 0x0F) { 1160 drm_dbg_dp(dp->drm_dev, "type=%d isr=0x%x\n", 1161 dp->msm_dp_display.connector_type, hpd_isr_status); 1162 /* hpd related interrupts */ 1163 if (hpd_isr_status & DP_DP_HPD_PLUG_INT_MASK) 1164 msm_dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0); 1165 1166 if (hpd_isr_status & DP_DP_IRQ_HPD_INT_MASK) { 1167 msm_dp_add_event(dp, EV_IRQ_HPD_INT, 0, 0); 1168 } 1169 1170 if (hpd_isr_status & DP_DP_HPD_REPLUG_INT_MASK) { 1171 msm_dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0); 1172 msm_dp_add_event(dp, EV_HPD_PLUG_INT, 0, 3); 1173 } 1174 1175 if (hpd_isr_status & DP_DP_HPD_UNPLUG_INT_MASK) 1176 msm_dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0); 1177 1178 ret = IRQ_HANDLED; 1179 } 1180 1181 /* DP controller isr */ 1182 ret |= msm_dp_ctrl_isr(dp->ctrl); 1183 1184 /* DP aux isr */ 1185 ret |= msm_dp_aux_isr(dp->aux); 1186 1187 return ret; 1188 } 1189 1190 static int msm_dp_display_request_irq(struct msm_dp_display_private *dp) 1191 { 1192 int rc = 0; 1193 struct platform_device *pdev = dp->msm_dp_display.pdev; 1194 1195 dp->irq = platform_get_irq(pdev, 0); 1196 if (dp->irq < 0) { 1197 DRM_ERROR("failed to get irq\n"); 1198 return dp->irq; 1199 } 1200 1201 rc = devm_request_irq(&pdev->dev, dp->irq, msm_dp_display_irq_handler, 1202 IRQF_TRIGGER_HIGH|IRQF_NO_AUTOEN, 1203 "dp_display_isr", dp); 1204 1205 if (rc < 0) { 1206 DRM_ERROR("failed to request IRQ%u: %d\n", 1207 dp->irq, rc); 1208 return rc; 1209 } 1210 1211 return 0; 1212 } 1213 1214 static const struct msm_dp_desc *msm_dp_display_get_desc(struct platform_device *pdev) 1215 { 1216 const struct msm_dp_desc *descs = of_device_get_match_data(&pdev->dev); 1217 struct resource *res; 1218 int i; 1219 1220 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 1221 if (!res) 1222 return NULL; 1223 1224 for (i = 0; i < descs[i].io_start; i++) { 1225 if (descs[i].io_start == res->start) 1226 return &descs[i]; 1227 } 1228 1229 dev_err(&pdev->dev, "unknown displayport instance\n"); 1230 return NULL; 1231 } 1232 1233 static int msm_dp_display_probe_tail(struct device *dev) 1234 { 1235 struct msm_dp *dp = dev_get_drvdata(dev); 1236 int ret; 1237 1238 /* 1239 * External bridges are mandatory for eDP interfaces: one has to 1240 * provide at least an eDP panel (which gets wrapped into panel-bridge). 1241 * 1242 * For DisplayPort interfaces external bridges are optional, so 1243 * silently ignore an error if one is not present (-ENODEV). 1244 */ 1245 dp->next_bridge = devm_drm_of_get_bridge(&dp->pdev->dev, dp->pdev->dev.of_node, 1, 0); 1246 if (IS_ERR(dp->next_bridge)) { 1247 ret = PTR_ERR(dp->next_bridge); 1248 dp->next_bridge = NULL; 1249 if (dp->is_edp || ret != -ENODEV) 1250 return ret; 1251 } 1252 1253 ret = component_add(dev, &msm_dp_display_comp_ops); 1254 if (ret) 1255 DRM_ERROR("component add failed, rc=%d\n", ret); 1256 1257 return ret; 1258 } 1259 1260 static int msm_dp_auxbus_done_probe(struct drm_dp_aux *aux) 1261 { 1262 return msm_dp_display_probe_tail(aux->dev); 1263 } 1264 1265 static int msm_dp_display_get_connector_type(struct platform_device *pdev, 1266 const struct msm_dp_desc *desc) 1267 { 1268 struct device_node *node = pdev->dev.of_node; 1269 struct device_node *aux_bus = of_get_child_by_name(node, "aux-bus"); 1270 struct device_node *panel = of_get_child_by_name(aux_bus, "panel"); 1271 int connector_type; 1272 1273 if (panel) 1274 connector_type = DRM_MODE_CONNECTOR_eDP; 1275 else 1276 connector_type = DRM_MODE_SUBCONNECTOR_DisplayPort; 1277 1278 of_node_put(panel); 1279 of_node_put(aux_bus); 1280 1281 return connector_type; 1282 } 1283 1284 static int msm_dp_display_probe(struct platform_device *pdev) 1285 { 1286 int rc = 0; 1287 struct msm_dp_display_private *dp; 1288 const struct msm_dp_desc *desc; 1289 1290 if (!pdev || !pdev->dev.of_node) { 1291 DRM_ERROR("pdev not found\n"); 1292 return -ENODEV; 1293 } 1294 1295 dp = devm_kzalloc(&pdev->dev, sizeof(*dp), GFP_KERNEL); 1296 if (!dp) 1297 return -ENOMEM; 1298 1299 desc = msm_dp_display_get_desc(pdev); 1300 if (!desc) 1301 return -EINVAL; 1302 1303 dp->msm_dp_display.pdev = pdev; 1304 dp->id = desc->id; 1305 dp->msm_dp_display.connector_type = msm_dp_display_get_connector_type(pdev, desc); 1306 dp->wide_bus_supported = desc->wide_bus_supported; 1307 dp->msm_dp_display.is_edp = 1308 (dp->msm_dp_display.connector_type == DRM_MODE_CONNECTOR_eDP); 1309 1310 rc = msm_dp_init_sub_modules(dp); 1311 if (rc) { 1312 DRM_ERROR("init sub module failed\n"); 1313 return -EPROBE_DEFER; 1314 } 1315 1316 /* setup event q */ 1317 mutex_init(&dp->event_mutex); 1318 init_waitqueue_head(&dp->event_q); 1319 spin_lock_init(&dp->event_lock); 1320 1321 /* Store DP audio handle inside DP display */ 1322 dp->msm_dp_display.msm_dp_audio = dp->audio; 1323 1324 init_completion(&dp->audio_comp); 1325 1326 platform_set_drvdata(pdev, &dp->msm_dp_display); 1327 1328 rc = devm_pm_runtime_enable(&pdev->dev); 1329 if (rc) 1330 goto err; 1331 1332 rc = msm_dp_display_request_irq(dp); 1333 if (rc) 1334 goto err; 1335 1336 if (dp->msm_dp_display.is_edp) { 1337 rc = devm_of_dp_aux_populate_bus(dp->aux, msm_dp_auxbus_done_probe); 1338 if (rc) { 1339 DRM_ERROR("eDP auxbus population failed, rc=%d\n", rc); 1340 goto err; 1341 } 1342 } else { 1343 rc = msm_dp_display_probe_tail(&pdev->dev); 1344 if (rc) 1345 goto err; 1346 } 1347 1348 return rc; 1349 1350 err: 1351 msm_dp_display_deinit_sub_modules(dp); 1352 return rc; 1353 } 1354 1355 static void msm_dp_display_remove(struct platform_device *pdev) 1356 { 1357 struct msm_dp_display_private *dp = dev_get_dp_display_private(&pdev->dev); 1358 1359 component_del(&pdev->dev, &msm_dp_display_comp_ops); 1360 msm_dp_display_deinit_sub_modules(dp); 1361 platform_set_drvdata(pdev, NULL); 1362 } 1363 1364 static int msm_dp_pm_runtime_suspend(struct device *dev) 1365 { 1366 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 1367 1368 disable_irq(dp->irq); 1369 1370 if (dp->msm_dp_display.is_edp) { 1371 msm_dp_display_host_phy_exit(dp); 1372 msm_dp_catalog_ctrl_hpd_disable(dp->catalog); 1373 } 1374 msm_dp_display_host_deinit(dp); 1375 1376 return 0; 1377 } 1378 1379 static int msm_dp_pm_runtime_resume(struct device *dev) 1380 { 1381 struct msm_dp_display_private *dp = dev_get_dp_display_private(dev); 1382 1383 /* 1384 * for eDP, host cotroller, HPD block and PHY are enabled here 1385 * but with HPD irq disabled 1386 * 1387 * for DP, only host controller is enabled here. 1388 * HPD block is enabled at msm_dp_bridge_hpd_enable() 1389 * PHY will be enabled at plugin handler later 1390 */ 1391 msm_dp_display_host_init(dp); 1392 if (dp->msm_dp_display.is_edp) { 1393 msm_dp_catalog_ctrl_hpd_enable(dp->catalog); 1394 msm_dp_display_host_phy_init(dp); 1395 } 1396 1397 enable_irq(dp->irq); 1398 return 0; 1399 } 1400 1401 static const struct dev_pm_ops msm_dp_pm_ops = { 1402 SET_RUNTIME_PM_OPS(msm_dp_pm_runtime_suspend, msm_dp_pm_runtime_resume, NULL) 1403 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, 1404 pm_runtime_force_resume) 1405 }; 1406 1407 static struct platform_driver msm_dp_display_driver = { 1408 .probe = msm_dp_display_probe, 1409 .remove = msm_dp_display_remove, 1410 .driver = { 1411 .name = "msm-dp-display", 1412 .of_match_table = msm_dp_dt_match, 1413 .suppress_bind_attrs = true, 1414 .pm = &msm_dp_pm_ops, 1415 }, 1416 }; 1417 1418 int __init msm_dp_register(void) 1419 { 1420 int ret; 1421 1422 ret = platform_driver_register(&msm_dp_display_driver); 1423 if (ret) 1424 DRM_ERROR("Dp display driver register failed"); 1425 1426 return ret; 1427 } 1428 1429 void __exit msm_dp_unregister(void) 1430 { 1431 platform_driver_unregister(&msm_dp_display_driver); 1432 } 1433 1434 bool msm_dp_is_yuv_420_enabled(const struct msm_dp *msm_dp_display, 1435 const struct drm_display_mode *mode) 1436 { 1437 struct msm_dp_display_private *dp; 1438 const struct drm_display_info *info; 1439 1440 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1441 info = &msm_dp_display->connector->display_info; 1442 1443 return dp->panel->vsc_sdp_supported && drm_mode_is_420_only(info, mode); 1444 } 1445 1446 bool msm_dp_needs_periph_flush(const struct msm_dp *msm_dp_display, 1447 const struct drm_display_mode *mode) 1448 { 1449 return msm_dp_is_yuv_420_enabled(msm_dp_display, mode); 1450 } 1451 1452 bool msm_dp_wide_bus_available(const struct msm_dp *msm_dp_display) 1453 { 1454 struct msm_dp_display_private *dp; 1455 1456 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1457 1458 if (dp->msm_dp_mode.out_fmt_is_yuv_420) 1459 return false; 1460 1461 return dp->wide_bus_supported; 1462 } 1463 1464 void msm_dp_display_debugfs_init(struct msm_dp *msm_dp_display, struct dentry *root, bool is_edp) 1465 { 1466 struct msm_dp_display_private *dp; 1467 struct device *dev; 1468 int rc; 1469 1470 dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1471 dev = &dp->msm_dp_display.pdev->dev; 1472 1473 rc = msm_dp_debug_init(dev, dp->panel, dp->link, dp->msm_dp_display.connector, root, is_edp); 1474 if (rc) 1475 DRM_ERROR("failed to initialize debug, rc = %d\n", rc); 1476 } 1477 1478 int msm_dp_modeset_init(struct msm_dp *msm_dp_display, struct drm_device *dev, 1479 struct drm_encoder *encoder, bool yuv_supported) 1480 { 1481 struct msm_dp_display_private *msm_dp_priv; 1482 int ret; 1483 1484 msm_dp_display->drm_dev = dev; 1485 1486 msm_dp_priv = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1487 1488 ret = msm_dp_bridge_init(msm_dp_display, dev, encoder, yuv_supported); 1489 if (ret) { 1490 DRM_DEV_ERROR(dev->dev, 1491 "failed to create dp bridge: %d\n", ret); 1492 return ret; 1493 } 1494 1495 msm_dp_display->connector = msm_dp_drm_connector_init(msm_dp_display, encoder); 1496 if (IS_ERR(msm_dp_display->connector)) { 1497 ret = PTR_ERR(msm_dp_display->connector); 1498 DRM_DEV_ERROR(dev->dev, 1499 "failed to create dp connector: %d\n", ret); 1500 msm_dp_display->connector = NULL; 1501 return ret; 1502 } 1503 1504 msm_dp_priv->panel->connector = msm_dp_display->connector; 1505 1506 return 0; 1507 } 1508 1509 void msm_dp_bridge_atomic_enable(struct drm_bridge *drm_bridge, 1510 struct drm_atomic_state *state) 1511 { 1512 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 1513 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 1514 int rc = 0; 1515 struct msm_dp_display_private *msm_dp_display; 1516 u32 hpd_state; 1517 bool force_link_train = false; 1518 1519 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1520 if (!msm_dp_display->msm_dp_mode.drm_mode.clock) { 1521 DRM_ERROR("invalid params\n"); 1522 return; 1523 } 1524 1525 if (dp->is_edp) 1526 msm_dp_hpd_plug_handle(msm_dp_display, 0); 1527 1528 mutex_lock(&msm_dp_display->event_mutex); 1529 if (pm_runtime_resume_and_get(&dp->pdev->dev)) { 1530 DRM_ERROR("failed to pm_runtime_resume\n"); 1531 mutex_unlock(&msm_dp_display->event_mutex); 1532 return; 1533 } 1534 1535 hpd_state = msm_dp_display->hpd_state; 1536 if (hpd_state != ST_DISPLAY_OFF && hpd_state != ST_MAINLINK_READY) { 1537 mutex_unlock(&msm_dp_display->event_mutex); 1538 return; 1539 } 1540 1541 rc = msm_dp_display_set_mode(dp, &msm_dp_display->msm_dp_mode); 1542 if (rc) { 1543 DRM_ERROR("Failed to perform a mode set, rc=%d\n", rc); 1544 mutex_unlock(&msm_dp_display->event_mutex); 1545 return; 1546 } 1547 1548 hpd_state = msm_dp_display->hpd_state; 1549 1550 if (hpd_state == ST_DISPLAY_OFF) { 1551 msm_dp_display_host_phy_init(msm_dp_display); 1552 force_link_train = true; 1553 } 1554 1555 msm_dp_display_enable(msm_dp_display, force_link_train); 1556 1557 rc = msm_dp_display_post_enable(dp); 1558 if (rc) { 1559 DRM_ERROR("DP display post enable failed, rc=%d\n", rc); 1560 msm_dp_display_disable(msm_dp_display); 1561 } 1562 1563 /* completed connection */ 1564 msm_dp_display->hpd_state = ST_CONNECTED; 1565 1566 drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type); 1567 mutex_unlock(&msm_dp_display->event_mutex); 1568 } 1569 1570 void msm_dp_bridge_atomic_disable(struct drm_bridge *drm_bridge, 1571 struct drm_atomic_state *state) 1572 { 1573 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 1574 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 1575 struct msm_dp_display_private *msm_dp_display; 1576 1577 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1578 1579 msm_dp_ctrl_push_idle(msm_dp_display->ctrl); 1580 } 1581 1582 void msm_dp_bridge_atomic_post_disable(struct drm_bridge *drm_bridge, 1583 struct drm_atomic_state *state) 1584 { 1585 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 1586 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 1587 u32 hpd_state; 1588 struct msm_dp_display_private *msm_dp_display; 1589 1590 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1591 1592 if (dp->is_edp) 1593 msm_dp_hpd_unplug_handle(msm_dp_display, 0); 1594 1595 mutex_lock(&msm_dp_display->event_mutex); 1596 1597 hpd_state = msm_dp_display->hpd_state; 1598 if (hpd_state != ST_DISCONNECT_PENDING && hpd_state != ST_CONNECTED) 1599 drm_dbg_dp(dp->drm_dev, "type=%d wrong hpd_state=%d\n", 1600 dp->connector_type, hpd_state); 1601 1602 msm_dp_display_disable(msm_dp_display); 1603 1604 hpd_state = msm_dp_display->hpd_state; 1605 if (hpd_state == ST_DISCONNECT_PENDING) { 1606 /* completed disconnection */ 1607 msm_dp_display->hpd_state = ST_DISCONNECTED; 1608 } else { 1609 msm_dp_display->hpd_state = ST_DISPLAY_OFF; 1610 } 1611 1612 drm_dbg_dp(dp->drm_dev, "type=%d Done\n", dp->connector_type); 1613 1614 pm_runtime_put_sync(&dp->pdev->dev); 1615 mutex_unlock(&msm_dp_display->event_mutex); 1616 } 1617 1618 void msm_dp_bridge_mode_set(struct drm_bridge *drm_bridge, 1619 const struct drm_display_mode *mode, 1620 const struct drm_display_mode *adjusted_mode) 1621 { 1622 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(drm_bridge); 1623 struct msm_dp *dp = msm_dp_bridge->msm_dp_display; 1624 struct msm_dp_display_private *msm_dp_display; 1625 struct msm_dp_panel *msm_dp_panel; 1626 1627 msm_dp_display = container_of(dp, struct msm_dp_display_private, msm_dp_display); 1628 msm_dp_panel = msm_dp_display->panel; 1629 1630 memset(&msm_dp_display->msm_dp_mode, 0x0, sizeof(struct msm_dp_display_mode)); 1631 1632 if (msm_dp_display_check_video_test(dp)) 1633 msm_dp_display->msm_dp_mode.bpp = msm_dp_display_get_test_bpp(dp); 1634 else /* Default num_components per pixel = 3 */ 1635 msm_dp_display->msm_dp_mode.bpp = dp->connector->display_info.bpc * 3; 1636 1637 if (!msm_dp_display->msm_dp_mode.bpp) 1638 msm_dp_display->msm_dp_mode.bpp = 24; /* Default bpp */ 1639 1640 drm_mode_copy(&msm_dp_display->msm_dp_mode.drm_mode, adjusted_mode); 1641 1642 msm_dp_display->msm_dp_mode.v_active_low = 1643 !!(msm_dp_display->msm_dp_mode.drm_mode.flags & DRM_MODE_FLAG_NVSYNC); 1644 1645 msm_dp_display->msm_dp_mode.h_active_low = 1646 !!(msm_dp_display->msm_dp_mode.drm_mode.flags & DRM_MODE_FLAG_NHSYNC); 1647 1648 msm_dp_display->msm_dp_mode.out_fmt_is_yuv_420 = 1649 drm_mode_is_420_only(&dp->connector->display_info, adjusted_mode) && 1650 msm_dp_panel->vsc_sdp_supported; 1651 1652 /* populate wide_bus_support to different layers */ 1653 msm_dp_display->ctrl->wide_bus_en = 1654 msm_dp_display->msm_dp_mode.out_fmt_is_yuv_420 ? false : msm_dp_display->wide_bus_supported; 1655 msm_dp_display->catalog->wide_bus_en = 1656 msm_dp_display->msm_dp_mode.out_fmt_is_yuv_420 ? false : msm_dp_display->wide_bus_supported; 1657 } 1658 1659 void msm_dp_bridge_hpd_enable(struct drm_bridge *bridge) 1660 { 1661 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(bridge); 1662 struct msm_dp *msm_dp_display = msm_dp_bridge->msm_dp_display; 1663 struct msm_dp_display_private *dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1664 1665 /* 1666 * this is for external DP with hpd irq enabled case, 1667 * step-1: msm_dp_pm_runtime_resume() enable dp host only 1668 * step-2: enable hdp block and have hpd irq enabled here 1669 * step-3: waiting for plugin irq while phy is not initialized 1670 * step-4: DP PHY is initialized at plugin handler before link training 1671 * 1672 */ 1673 mutex_lock(&dp->event_mutex); 1674 if (pm_runtime_resume_and_get(&msm_dp_display->pdev->dev)) { 1675 DRM_ERROR("failed to resume power\n"); 1676 mutex_unlock(&dp->event_mutex); 1677 return; 1678 } 1679 1680 msm_dp_catalog_ctrl_hpd_enable(dp->catalog); 1681 1682 /* enable HDP interrupts */ 1683 msm_dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_INT_MASK, true); 1684 1685 msm_dp_display->internal_hpd = true; 1686 mutex_unlock(&dp->event_mutex); 1687 } 1688 1689 void msm_dp_bridge_hpd_disable(struct drm_bridge *bridge) 1690 { 1691 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(bridge); 1692 struct msm_dp *msm_dp_display = msm_dp_bridge->msm_dp_display; 1693 struct msm_dp_display_private *dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1694 1695 mutex_lock(&dp->event_mutex); 1696 /* disable HDP interrupts */ 1697 msm_dp_catalog_hpd_config_intr(dp->catalog, DP_DP_HPD_INT_MASK, false); 1698 msm_dp_catalog_ctrl_hpd_disable(dp->catalog); 1699 1700 msm_dp_display->internal_hpd = false; 1701 1702 pm_runtime_put_sync(&msm_dp_display->pdev->dev); 1703 mutex_unlock(&dp->event_mutex); 1704 } 1705 1706 void msm_dp_bridge_hpd_notify(struct drm_bridge *bridge, 1707 enum drm_connector_status status) 1708 { 1709 struct msm_dp_bridge *msm_dp_bridge = to_dp_bridge(bridge); 1710 struct msm_dp *msm_dp_display = msm_dp_bridge->msm_dp_display; 1711 struct msm_dp_display_private *dp = container_of(msm_dp_display, struct msm_dp_display_private, msm_dp_display); 1712 1713 /* Without next_bridge interrupts are handled by the DP core directly */ 1714 if (msm_dp_display->internal_hpd) 1715 return; 1716 1717 if (!msm_dp_display->link_ready && status == connector_status_connected) 1718 msm_dp_add_event(dp, EV_HPD_PLUG_INT, 0, 0); 1719 else if (msm_dp_display->link_ready && status == connector_status_disconnected) 1720 msm_dp_add_event(dp, EV_HPD_UNPLUG_INT, 0, 0); 1721 } 1722