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