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