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