1 /* 2 * Copyright © 2008 Intel Corporation 3 * 2014 Red Hat Inc. 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice (including the next 13 * paragraph) shall be included in all copies or substantial portions of the 14 * Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 22 * IN THE SOFTWARE. 23 * 24 */ 25 26 #include <drm/drmP.h> 27 #include "i915_drv.h" 28 #include "intel_drv.h" 29 #include <drm/drm_atomic_helper.h> 30 #include <drm/drm_crtc_helper.h> 31 #include <drm/drm_edid.h> 32 33 #if 0 34 static bool intel_dp_mst_compute_config(struct intel_encoder *encoder, 35 struct intel_crtc_state *pipe_config) 36 { 37 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 38 struct intel_digital_port *intel_dig_port = intel_mst->primary; 39 struct intel_dp *intel_dp = &intel_dig_port->dp; 40 struct drm_atomic_state *state; 41 int bpp, i; 42 int lane_count, slots; 43 const struct drm_display_mode *adjusted_mode = &pipe_config->base.adjusted_mode; 44 struct drm_connector *drm_connector; 45 struct intel_connector *connector, *found = NULL; 46 struct drm_connector_state *connector_state; 47 int mst_pbn; 48 49 pipe_config->dp_encoder_is_mst = true; 50 pipe_config->has_pch_encoder = false; 51 bpp = 24; 52 /* 53 * for MST we always configure max link bw - the spec doesn't 54 * seem to suggest we should do otherwise. 55 */ 56 lane_count = drm_dp_max_lane_count(intel_dp->dpcd); 57 58 59 pipe_config->lane_count = lane_count; 60 61 pipe_config->pipe_bpp = 24; 62 pipe_config->port_clock = intel_dp_max_link_rate(intel_dp); 63 64 state = pipe_config->base.state; 65 66 for_each_connector_in_state(state, drm_connector, connector_state, i) { 67 connector = to_intel_connector(drm_connector); 68 69 if (connector_state->best_encoder == &encoder->base) { 70 found = connector; 71 break; 72 } 73 } 74 75 if (!found) { 76 DRM_ERROR("can't find connector\n"); 77 return false; 78 } 79 80 mst_pbn = drm_dp_calc_pbn_mode(adjusted_mode->crtc_clock, bpp); 81 82 pipe_config->pbn = mst_pbn; 83 slots = drm_dp_find_vcpi_slots(&intel_dp->mst_mgr, mst_pbn); 84 85 intel_link_compute_m_n(bpp, lane_count, 86 adjusted_mode->crtc_clock, 87 pipe_config->port_clock, 88 &pipe_config->dp_m_n); 89 90 pipe_config->dp_m_n.tu = slots; 91 92 return true; 93 94 } 95 96 static void intel_mst_disable_dp(struct intel_encoder *encoder) 97 { 98 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 99 struct intel_digital_port *intel_dig_port = intel_mst->primary; 100 struct intel_dp *intel_dp = &intel_dig_port->dp; 101 int ret; 102 103 DRM_DEBUG_KMS("%d\n", intel_dp->active_mst_links); 104 105 drm_dp_mst_reset_vcpi_slots(&intel_dp->mst_mgr, intel_mst->connector->port); 106 107 ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); 108 if (ret) { 109 DRM_ERROR("failed to update payload %d\n", ret); 110 } 111 } 112 113 static void intel_mst_post_disable_dp(struct intel_encoder *encoder) 114 { 115 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 116 struct intel_digital_port *intel_dig_port = intel_mst->primary; 117 struct intel_dp *intel_dp = &intel_dig_port->dp; 118 119 DRM_DEBUG_KMS("%d\n", intel_dp->active_mst_links); 120 121 /* this can fail */ 122 drm_dp_check_act_status(&intel_dp->mst_mgr); 123 /* and this can also fail */ 124 drm_dp_update_payload_part2(&intel_dp->mst_mgr); 125 126 drm_dp_mst_deallocate_vcpi(&intel_dp->mst_mgr, intel_mst->connector->port); 127 128 intel_dp->active_mst_links--; 129 130 intel_mst->connector = NULL; 131 if (intel_dp->active_mst_links == 0) { 132 intel_dig_port->base.post_disable(&intel_dig_port->base); 133 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_OFF); 134 } 135 } 136 137 static void intel_mst_pre_enable_dp(struct intel_encoder *encoder) 138 { 139 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 140 struct intel_digital_port *intel_dig_port = intel_mst->primary; 141 struct intel_dp *intel_dp = &intel_dig_port->dp; 142 struct drm_device *dev = encoder->base.dev; 143 struct drm_i915_private *dev_priv = to_i915(dev); 144 enum port port = intel_dig_port->port; 145 int ret; 146 uint32_t temp; 147 struct intel_connector *found = NULL, *connector; 148 int slots; 149 struct drm_crtc *crtc = encoder->base.crtc; 150 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 151 152 for_each_intel_connector(dev, connector) { 153 if (connector->base.state->best_encoder == &encoder->base) { 154 found = connector; 155 break; 156 } 157 } 158 159 if (!found) { 160 DRM_ERROR("can't find connector\n"); 161 return; 162 } 163 164 /* MST encoders are bound to a crtc, not to a connector, 165 * force the mapping here for get_hw_state. 166 */ 167 found->encoder = encoder; 168 169 DRM_DEBUG_KMS("%d\n", intel_dp->active_mst_links); 170 171 intel_mst->connector = found; 172 173 if (intel_dp->active_mst_links == 0) { 174 intel_prepare_ddi_buffer(&intel_dig_port->base); 175 176 intel_ddi_clk_select(&intel_dig_port->base, intel_crtc->config); 177 178 intel_dp_set_link_params(intel_dp, intel_crtc->config); 179 180 intel_ddi_init_dp_buf_reg(&intel_dig_port->base); 181 182 intel_dp_sink_dpms(intel_dp, DRM_MODE_DPMS_ON); 183 184 intel_dp_start_link_train(intel_dp); 185 intel_dp_stop_link_train(intel_dp); 186 } 187 188 ret = drm_dp_mst_allocate_vcpi(&intel_dp->mst_mgr, 189 intel_mst->connector->port, 190 intel_crtc->config->pbn, &slots); 191 if (ret == false) { 192 DRM_ERROR("failed to allocate vcpi\n"); 193 return; 194 } 195 196 197 intel_dp->active_mst_links++; 198 temp = I915_READ(DP_TP_STATUS(port)); 199 I915_WRITE(DP_TP_STATUS(port), temp); 200 201 ret = drm_dp_update_payload_part1(&intel_dp->mst_mgr); 202 } 203 204 static void intel_mst_enable_dp(struct intel_encoder *encoder) 205 { 206 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 207 struct intel_digital_port *intel_dig_port = intel_mst->primary; 208 struct intel_dp *intel_dp = &intel_dig_port->dp; 209 struct drm_device *dev = intel_dig_port->base.base.dev; 210 struct drm_i915_private *dev_priv = to_i915(dev); 211 enum port port = intel_dig_port->port; 212 int ret; 213 214 DRM_DEBUG_KMS("%d\n", intel_dp->active_mst_links); 215 216 if (intel_wait_for_register(dev_priv, 217 DP_TP_STATUS(port), 218 DP_TP_STATUS_ACT_SENT, 219 DP_TP_STATUS_ACT_SENT, 220 1)) 221 DRM_ERROR("Timed out waiting for ACT sent\n"); 222 223 ret = drm_dp_check_act_status(&intel_dp->mst_mgr); 224 225 ret = drm_dp_update_payload_part2(&intel_dp->mst_mgr); 226 } 227 228 static bool intel_dp_mst_enc_get_hw_state(struct intel_encoder *encoder, 229 enum pipe *pipe) 230 { 231 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 232 *pipe = intel_mst->pipe; 233 if (intel_mst->connector) 234 return true; 235 return false; 236 } 237 238 static void intel_dp_mst_enc_get_config(struct intel_encoder *encoder, 239 struct intel_crtc_state *pipe_config) 240 { 241 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(&encoder->base); 242 struct intel_digital_port *intel_dig_port = intel_mst->primary; 243 struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc); 244 struct drm_device *dev = encoder->base.dev; 245 struct drm_i915_private *dev_priv = to_i915(dev); 246 enum transcoder cpu_transcoder = pipe_config->cpu_transcoder; 247 u32 temp, flags = 0; 248 249 temp = I915_READ(TRANS_DDI_FUNC_CTL(cpu_transcoder)); 250 if (temp & TRANS_DDI_PHSYNC) 251 flags |= DRM_MODE_FLAG_PHSYNC; 252 else 253 flags |= DRM_MODE_FLAG_NHSYNC; 254 if (temp & TRANS_DDI_PVSYNC) 255 flags |= DRM_MODE_FLAG_PVSYNC; 256 else 257 flags |= DRM_MODE_FLAG_NVSYNC; 258 259 switch (temp & TRANS_DDI_BPC_MASK) { 260 case TRANS_DDI_BPC_6: 261 pipe_config->pipe_bpp = 18; 262 break; 263 case TRANS_DDI_BPC_8: 264 pipe_config->pipe_bpp = 24; 265 break; 266 case TRANS_DDI_BPC_10: 267 pipe_config->pipe_bpp = 30; 268 break; 269 case TRANS_DDI_BPC_12: 270 pipe_config->pipe_bpp = 36; 271 break; 272 default: 273 break; 274 } 275 pipe_config->base.adjusted_mode.flags |= flags; 276 277 pipe_config->lane_count = 278 ((temp & DDI_PORT_WIDTH_MASK) >> DDI_PORT_WIDTH_SHIFT) + 1; 279 280 intel_dp_get_m_n(crtc, pipe_config); 281 282 intel_ddi_clock_get(&intel_dig_port->base, pipe_config); 283 } 284 285 static int intel_dp_mst_get_ddc_modes(struct drm_connector *connector) 286 { 287 struct intel_connector *intel_connector = to_intel_connector(connector); 288 struct intel_dp *intel_dp = intel_connector->mst_port; 289 struct edid *edid; 290 int ret; 291 292 if (!intel_dp) { 293 return intel_connector_update_modes(connector, NULL); 294 } 295 296 edid = drm_dp_mst_get_edid(connector, &intel_dp->mst_mgr, intel_connector->port); 297 ret = intel_connector_update_modes(connector, edid); 298 kfree(edid); 299 300 return ret; 301 } 302 303 static enum drm_connector_status 304 intel_dp_mst_detect(struct drm_connector *connector, bool force) 305 { 306 struct intel_connector *intel_connector = to_intel_connector(connector); 307 struct intel_dp *intel_dp = intel_connector->mst_port; 308 309 if (!intel_dp) 310 return connector_status_disconnected; 311 return drm_dp_mst_detect_port(connector, &intel_dp->mst_mgr, intel_connector->port); 312 } 313 314 static int 315 intel_dp_mst_set_property(struct drm_connector *connector, 316 struct drm_property *property, 317 uint64_t val) 318 { 319 return 0; 320 } 321 322 static void 323 intel_dp_mst_connector_destroy(struct drm_connector *connector) 324 { 325 struct intel_connector *intel_connector = to_intel_connector(connector); 326 327 if (!IS_ERR_OR_NULL(intel_connector->edid)) 328 kfree(intel_connector->edid); 329 330 drm_connector_cleanup(connector); 331 kfree(connector); 332 } 333 334 static const struct drm_connector_funcs intel_dp_mst_connector_funcs = { 335 .dpms = drm_atomic_helper_connector_dpms, 336 .detect = intel_dp_mst_detect, 337 .fill_modes = drm_helper_probe_single_connector_modes, 338 .set_property = intel_dp_mst_set_property, 339 .atomic_get_property = intel_connector_atomic_get_property, 340 .late_register = intel_connector_register, 341 .early_unregister = intel_connector_unregister, 342 .destroy = intel_dp_mst_connector_destroy, 343 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 344 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 345 }; 346 347 static int intel_dp_mst_get_modes(struct drm_connector *connector) 348 { 349 return intel_dp_mst_get_ddc_modes(connector); 350 } 351 352 static enum drm_mode_status 353 intel_dp_mst_mode_valid(struct drm_connector *connector, 354 struct drm_display_mode *mode) 355 { 356 int max_dotclk = to_i915(connector->dev)->max_dotclk_freq; 357 358 /* TODO - validate mode against available PBN for link */ 359 if (mode->clock < 10000) 360 return MODE_CLOCK_LOW; 361 362 if (mode->flags & DRM_MODE_FLAG_DBLCLK) 363 return MODE_H_ILLEGAL; 364 365 if (mode->clock > max_dotclk) 366 return MODE_CLOCK_HIGH; 367 368 return MODE_OK; 369 } 370 371 static struct drm_encoder *intel_mst_atomic_best_encoder(struct drm_connector *connector, 372 struct drm_connector_state *state) 373 { 374 struct intel_connector *intel_connector = to_intel_connector(connector); 375 struct intel_dp *intel_dp = intel_connector->mst_port; 376 struct intel_crtc *crtc = to_intel_crtc(state->crtc); 377 378 if (!intel_dp) 379 return NULL; 380 return &intel_dp->mst_encoders[crtc->pipe]->base.base; 381 } 382 383 static struct drm_encoder *intel_mst_best_encoder(struct drm_connector *connector) 384 { 385 struct intel_connector *intel_connector = to_intel_connector(connector); 386 struct intel_dp *intel_dp = intel_connector->mst_port; 387 if (!intel_dp) 388 return NULL; 389 return &intel_dp->mst_encoders[0]->base.base; 390 } 391 392 static const struct drm_connector_helper_funcs intel_dp_mst_connector_helper_funcs = { 393 .get_modes = intel_dp_mst_get_modes, 394 .mode_valid = intel_dp_mst_mode_valid, 395 .atomic_best_encoder = intel_mst_atomic_best_encoder, 396 .best_encoder = intel_mst_best_encoder, 397 }; 398 #endif 399 400 #if 0 /* unused */ 401 static void intel_dp_mst_encoder_destroy(struct drm_encoder *encoder) 402 { 403 struct intel_dp_mst_encoder *intel_mst = enc_to_mst(encoder); 404 405 drm_encoder_cleanup(encoder); 406 kfree(intel_mst); 407 } 408 409 static const struct drm_encoder_funcs intel_dp_mst_enc_funcs = { 410 .destroy = intel_dp_mst_encoder_destroy, 411 }; 412 #endif 413 414 #if 0 415 static bool intel_dp_mst_get_hw_state(struct intel_connector *connector) 416 { 417 if (connector->encoder && connector->base.state->crtc) { 418 enum pipe pipe; 419 if (!connector->encoder->get_hw_state(connector->encoder, &pipe)) 420 return false; 421 return true; 422 } 423 return false; 424 } 425 426 static void intel_connector_add_to_fbdev(struct intel_connector *connector) 427 { 428 #ifdef CONFIG_DRM_FBDEV_EMULATION 429 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 430 431 if (dev_priv->fbdev) 432 drm_fb_helper_add_one_connector(&dev_priv->fbdev->helper, 433 &connector->base); 434 #endif 435 } 436 437 static void intel_connector_remove_from_fbdev(struct intel_connector *connector) 438 { 439 #ifdef CONFIG_DRM_FBDEV_EMULATION 440 struct drm_i915_private *dev_priv = to_i915(connector->base.dev); 441 442 if (dev_priv->fbdev) 443 drm_fb_helper_remove_one_connector(&dev_priv->fbdev->helper, 444 &connector->base); 445 #endif 446 } 447 448 static struct drm_connector *intel_dp_add_mst_connector(struct drm_dp_mst_topology_mgr *mgr, struct drm_dp_mst_port *port, const char *pathprop) 449 { 450 struct intel_dp *intel_dp = container_of(mgr, struct intel_dp, mst_mgr); 451 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); 452 struct drm_device *dev = intel_dig_port->base.base.dev; 453 struct intel_connector *intel_connector; 454 struct drm_connector *connector; 455 int i; 456 457 intel_connector = intel_connector_alloc(); 458 if (!intel_connector) 459 return NULL; 460 461 connector = &intel_connector->base; 462 drm_connector_init(dev, connector, &intel_dp_mst_connector_funcs, DRM_MODE_CONNECTOR_DisplayPort); 463 drm_connector_helper_add(connector, &intel_dp_mst_connector_helper_funcs); 464 465 intel_connector->get_hw_state = intel_dp_mst_get_hw_state; 466 intel_connector->mst_port = intel_dp; 467 intel_connector->port = port; 468 469 for (i = PIPE_A; i <= PIPE_C; i++) { 470 drm_mode_connector_attach_encoder(&intel_connector->base, 471 &intel_dp->mst_encoders[i]->base.base); 472 } 473 intel_dp_add_properties(intel_dp, connector); 474 475 drm_object_attach_property(&connector->base, dev->mode_config.path_property, 0); 476 drm_object_attach_property(&connector->base, dev->mode_config.tile_property, 0); 477 478 drm_mode_connector_set_path_property(connector, pathprop); 479 return connector; 480 } 481 482 static void intel_dp_register_mst_connector(struct drm_connector *connector) 483 { 484 struct intel_connector *intel_connector = to_intel_connector(connector); 485 struct drm_device *dev = connector->dev; 486 487 drm_modeset_lock_all(dev); 488 intel_connector_add_to_fbdev(intel_connector); 489 drm_modeset_unlock_all(dev); 490 491 drm_connector_register(&intel_connector->base); 492 } 493 494 static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr, 495 struct drm_connector *connector) 496 { 497 struct intel_connector *intel_connector = to_intel_connector(connector); 498 struct drm_device *dev = connector->dev; 499 500 drm_connector_unregister(connector); 501 502 /* need to nuke the connector */ 503 drm_modeset_lock_all(dev); 504 intel_connector_remove_from_fbdev(intel_connector); 505 intel_connector->mst_port = NULL; 506 drm_modeset_unlock_all(dev); 507 508 drm_connector_unreference(&intel_connector->base); 509 DRM_DEBUG_KMS("\n"); 510 } 511 512 static void intel_dp_mst_hotplug(struct drm_dp_mst_topology_mgr *mgr) 513 { 514 struct intel_dp *intel_dp = container_of(mgr, struct intel_dp, mst_mgr); 515 struct intel_digital_port *intel_dig_port = dp_to_dig_port(intel_dp); 516 struct drm_device *dev = intel_dig_port->base.base.dev; 517 518 drm_kms_helper_hotplug_event(dev); 519 } 520 521 static const struct drm_dp_mst_topology_cbs mst_cbs = { 522 .add_connector = intel_dp_add_mst_connector, 523 .register_connector = intel_dp_register_mst_connector, 524 .destroy_connector = intel_dp_destroy_mst_connector, 525 .hotplug = intel_dp_mst_hotplug, 526 }; 527 528 static struct intel_dp_mst_encoder * 529 intel_dp_create_fake_mst_encoder(struct intel_digital_port *intel_dig_port, enum pipe pipe) 530 { 531 struct intel_dp_mst_encoder *intel_mst; 532 struct intel_encoder *intel_encoder; 533 struct drm_device *dev = intel_dig_port->base.base.dev; 534 535 intel_mst = kzalloc(sizeof(*intel_mst), GFP_KERNEL); 536 537 if (!intel_mst) 538 return NULL; 539 540 intel_mst->pipe = pipe; 541 intel_encoder = &intel_mst->base; 542 intel_mst->primary = intel_dig_port; 543 544 drm_encoder_init(dev, &intel_encoder->base, &intel_dp_mst_enc_funcs, 545 DRM_MODE_ENCODER_DPMST, "DP-MST %c", pipe_name(pipe)); 546 547 intel_encoder->type = INTEL_OUTPUT_DP_MST; 548 intel_encoder->crtc_mask = 0x7; 549 intel_encoder->cloneable = 0; 550 551 intel_encoder->compute_config = intel_dp_mst_compute_config; 552 intel_encoder->disable = intel_mst_disable_dp; 553 intel_encoder->post_disable = intel_mst_post_disable_dp; 554 intel_encoder->pre_enable = intel_mst_pre_enable_dp; 555 intel_encoder->enable = intel_mst_enable_dp; 556 intel_encoder->get_hw_state = intel_dp_mst_enc_get_hw_state; 557 intel_encoder->get_config = intel_dp_mst_enc_get_config; 558 559 return intel_mst; 560 561 } 562 563 static bool 564 intel_dp_create_fake_mst_encoders(struct intel_digital_port *intel_dig_port) 565 { 566 int i; 567 struct intel_dp *intel_dp = &intel_dig_port->dp; 568 569 for (i = PIPE_A; i <= PIPE_C; i++) 570 intel_dp->mst_encoders[i] = intel_dp_create_fake_mst_encoder(intel_dig_port, i); 571 return true; 572 } 573 #endif 574 575 int 576 intel_dp_mst_encoder_init(struct intel_digital_port *intel_dig_port, int conn_base_id) 577 { 578 struct intel_dp *intel_dp = &intel_dig_port->dp; 579 #if 0 580 struct drm_device *dev = intel_dig_port->base.base.dev; 581 int ret; 582 583 intel_dp->can_mst = true; 584 intel_dp->mst_mgr.cbs = &mst_cbs; 585 586 /* create encoders */ 587 intel_dp_create_fake_mst_encoders(intel_dig_port); 588 ret = drm_dp_mst_topology_mgr_init(&intel_dp->mst_mgr, dev->dev, &intel_dp->aux, 16, 3, conn_base_id); 589 if (ret) { 590 intel_dp->can_mst = false; 591 return ret; 592 } 593 #endif 594 intel_dp->can_mst = false; 595 return 0; 596 } 597 598 void 599 intel_dp_mst_encoder_cleanup(struct intel_digital_port *intel_dig_port) 600 { 601 struct intel_dp *intel_dp = &intel_dig_port->dp; 602 603 if (!intel_dp->can_mst) 604 return; 605 606 #if 0 607 drm_dp_mst_topology_mgr_destroy(&intel_dp->mst_mgr); 608 #endif 609 /* encoders will get killed by normal cleanup */ 610 } 611