1 /* 2 * Copyright © 2006-2007 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 * 23 * Authors: 24 * Eric Anholt <eric@anholt.net> 25 * 26 * $FreeBSD: src/sys/dev/drm2/i915/intel_crt.c,v 1.1 2012/05/22 11:07:44 kib Exp $ 27 */ 28 29 #include <dev/drm/drmP.h> 30 #include <dev/drm/drm.h> 31 #include <dev/drm/drm_crtc.h> 32 #include <dev/drm/drm_crtc_helper.h> 33 #include <dev/drm/drm_edid.h> 34 #include "i915_drm.h" 35 #include "i915_drv.h" 36 #include "intel_drv.h" 37 38 /* Here's the desired hotplug mode */ 39 #define ADPA_HOTPLUG_BITS (ADPA_CRT_HOTPLUG_PERIOD_128 | \ 40 ADPA_CRT_HOTPLUG_WARMUP_10MS | \ 41 ADPA_CRT_HOTPLUG_SAMPLE_4S | \ 42 ADPA_CRT_HOTPLUG_VOLTAGE_50 | \ 43 ADPA_CRT_HOTPLUG_VOLREF_325MV | \ 44 ADPA_CRT_HOTPLUG_ENABLE) 45 46 struct intel_crt { 47 struct intel_encoder base; 48 bool force_hotplug_required; 49 }; 50 51 static struct intel_crt *intel_attached_crt(struct drm_connector *connector) 52 { 53 return container_of(intel_attached_encoder(connector), 54 struct intel_crt, base); 55 } 56 57 static void intel_crt_dpms(struct drm_encoder *encoder, int mode) 58 { 59 struct drm_device *dev = encoder->dev; 60 struct drm_i915_private *dev_priv = dev->dev_private; 61 u32 temp, reg; 62 63 if (HAS_PCH_SPLIT(dev)) 64 reg = PCH_ADPA; 65 else 66 reg = ADPA; 67 68 temp = I915_READ(reg); 69 temp &= ~(ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE); 70 temp &= ~ADPA_DAC_ENABLE; 71 72 switch (mode) { 73 case DRM_MODE_DPMS_ON: 74 temp |= ADPA_DAC_ENABLE; 75 break; 76 case DRM_MODE_DPMS_STANDBY: 77 temp |= ADPA_DAC_ENABLE | ADPA_HSYNC_CNTL_DISABLE; 78 break; 79 case DRM_MODE_DPMS_SUSPEND: 80 temp |= ADPA_DAC_ENABLE | ADPA_VSYNC_CNTL_DISABLE; 81 break; 82 case DRM_MODE_DPMS_OFF: 83 temp |= ADPA_HSYNC_CNTL_DISABLE | ADPA_VSYNC_CNTL_DISABLE; 84 break; 85 } 86 87 I915_WRITE(reg, temp); 88 } 89 90 static int intel_crt_mode_valid(struct drm_connector *connector, 91 struct drm_display_mode *mode) 92 { 93 struct drm_device *dev = connector->dev; 94 95 int max_clock = 0; 96 if (mode->flags & DRM_MODE_FLAG_DBLSCAN) 97 return MODE_NO_DBLESCAN; 98 99 if (mode->clock < 25000) 100 return MODE_CLOCK_LOW; 101 102 if (IS_GEN2(dev)) 103 max_clock = 350000; 104 else 105 max_clock = 400000; 106 if (mode->clock > max_clock) 107 return MODE_CLOCK_HIGH; 108 109 return MODE_OK; 110 } 111 112 static bool intel_crt_mode_fixup(struct drm_encoder *encoder, 113 const struct drm_display_mode *mode, 114 struct drm_display_mode *adjusted_mode) 115 { 116 return true; 117 } 118 119 static void intel_crt_mode_set(struct drm_encoder *encoder, 120 struct drm_display_mode *mode, 121 struct drm_display_mode *adjusted_mode) 122 { 123 124 struct drm_device *dev = encoder->dev; 125 struct drm_crtc *crtc = encoder->crtc; 126 struct intel_crtc *intel_crtc = to_intel_crtc(crtc); 127 struct drm_i915_private *dev_priv = dev->dev_private; 128 int dpll_md_reg; 129 u32 adpa, dpll_md; 130 u32 adpa_reg; 131 132 dpll_md_reg = DPLL_MD(intel_crtc->pipe); 133 134 if (HAS_PCH_SPLIT(dev)) 135 adpa_reg = PCH_ADPA; 136 else 137 adpa_reg = ADPA; 138 139 /* 140 * Disable separate mode multiplier used when cloning SDVO to CRT 141 * XXX this needs to be adjusted when we really are cloning 142 */ 143 if (INTEL_INFO(dev)->gen >= 4 && !HAS_PCH_SPLIT(dev)) { 144 dpll_md = I915_READ(dpll_md_reg); 145 I915_WRITE(dpll_md_reg, 146 dpll_md & ~DPLL_MD_UDI_MULTIPLIER_MASK); 147 } 148 149 adpa = ADPA_HOTPLUG_BITS; 150 if (adjusted_mode->flags & DRM_MODE_FLAG_PHSYNC) 151 adpa |= ADPA_HSYNC_ACTIVE_HIGH; 152 if (adjusted_mode->flags & DRM_MODE_FLAG_PVSYNC) 153 adpa |= ADPA_VSYNC_ACTIVE_HIGH; 154 155 /* For CPT allow 3 pipe config, for others just use A or B */ 156 if (HAS_PCH_CPT(dev)) 157 adpa |= PORT_TRANS_SEL_CPT(intel_crtc->pipe); 158 else if (intel_crtc->pipe == 0) 159 adpa |= ADPA_PIPE_A_SELECT; 160 else 161 adpa |= ADPA_PIPE_B_SELECT; 162 163 if (!HAS_PCH_SPLIT(dev)) 164 I915_WRITE(BCLRPAT(intel_crtc->pipe), 0); 165 166 I915_WRITE(adpa_reg, adpa); 167 } 168 169 static bool intel_ironlake_crt_detect_hotplug(struct drm_connector *connector) 170 { 171 struct drm_device *dev = connector->dev; 172 struct intel_crt *crt = intel_attached_crt(connector); 173 struct drm_i915_private *dev_priv = dev->dev_private; 174 u32 adpa; 175 bool ret; 176 177 /* The first time through, trigger an explicit detection cycle */ 178 if (crt->force_hotplug_required) { 179 bool turn_off_dac = HAS_PCH_SPLIT(dev); 180 u32 save_adpa; 181 182 crt->force_hotplug_required = 0; 183 184 save_adpa = adpa = I915_READ(PCH_ADPA); 185 DRM_DEBUG_KMS("trigger hotplug detect cycle: adpa=0x%x\n", adpa); 186 187 adpa |= ADPA_CRT_HOTPLUG_FORCE_TRIGGER; 188 if (turn_off_dac) 189 adpa &= ~ADPA_DAC_ENABLE; 190 191 I915_WRITE(PCH_ADPA, adpa); 192 193 if (_intel_wait_for(dev, 194 (I915_READ(PCH_ADPA) & ADPA_CRT_HOTPLUG_FORCE_TRIGGER) == 0, 195 1000, 1, "915crt")) 196 DRM_DEBUG_KMS("timed out waiting for FORCE_TRIGGER\n"); 197 198 if (turn_off_dac) { 199 I915_WRITE(PCH_ADPA, save_adpa); 200 POSTING_READ(PCH_ADPA); 201 } 202 } 203 204 /* Check the status to see if both blue and green are on now */ 205 adpa = I915_READ(PCH_ADPA); 206 if ((adpa & ADPA_CRT_HOTPLUG_MONITOR_MASK) != 0) 207 ret = true; 208 else 209 ret = false; 210 DRM_DEBUG_KMS("ironlake hotplug adpa=0x%x, result %d\n", adpa, ret); 211 212 return ret; 213 } 214 215 /** 216 * Uses CRT_HOTPLUG_EN and CRT_HOTPLUG_STAT to detect CRT presence. 217 * 218 * Not for i915G/i915GM 219 * 220 * \return true if CRT is connected. 221 * \return false if CRT is disconnected. 222 */ 223 static bool intel_crt_detect_hotplug(struct drm_connector *connector) 224 { 225 struct drm_device *dev = connector->dev; 226 struct drm_i915_private *dev_priv = dev->dev_private; 227 u32 hotplug_en, orig, stat; 228 bool ret = false; 229 int i, tries = 0; 230 231 if (HAS_PCH_SPLIT(dev)) 232 return intel_ironlake_crt_detect_hotplug(connector); 233 234 /* 235 * On 4 series desktop, CRT detect sequence need to be done twice 236 * to get a reliable result. 237 */ 238 239 if (IS_G4X(dev) && !IS_GM45(dev)) 240 tries = 2; 241 else 242 tries = 1; 243 hotplug_en = orig = I915_READ(PORT_HOTPLUG_EN); 244 hotplug_en |= CRT_HOTPLUG_FORCE_DETECT; 245 246 for (i = 0; i < tries ; i++) { 247 /* turn on the FORCE_DETECT */ 248 I915_WRITE(PORT_HOTPLUG_EN, hotplug_en); 249 /* wait for FORCE_DETECT to go off */ 250 if (_intel_wait_for(dev, 251 (I915_READ(PORT_HOTPLUG_EN) & CRT_HOTPLUG_FORCE_DETECT) == 0, 252 1000, 1, "915cr2")) 253 DRM_DEBUG_KMS("timed out waiting for FORCE_DETECT to go off"); 254 } 255 256 stat = I915_READ(PORT_HOTPLUG_STAT); 257 if ((stat & CRT_HOTPLUG_MONITOR_MASK) != CRT_HOTPLUG_MONITOR_NONE) 258 ret = true; 259 260 /* clear the interrupt we just generated, if any */ 261 I915_WRITE(PORT_HOTPLUG_STAT, CRT_HOTPLUG_INT_STATUS); 262 263 /* and put the bits back */ 264 I915_WRITE(PORT_HOTPLUG_EN, orig); 265 266 return ret; 267 } 268 269 static bool intel_crt_detect_ddc(struct drm_connector *connector) 270 { 271 struct intel_crt *crt = intel_attached_crt(connector); 272 struct drm_i915_private *dev_priv = crt->base.base.dev->dev_private; 273 274 /* CRT should always be at 0, but check anyway */ 275 if (crt->base.type != INTEL_OUTPUT_ANALOG) 276 return false; 277 278 if (intel_ddc_probe(&crt->base, dev_priv->crt_ddc_pin)) { 279 struct edid *edid; 280 bool is_digital = false; 281 282 edid = drm_get_edid(connector, 283 dev_priv->gmbus[dev_priv->crt_ddc_pin]); 284 /* 285 * This may be a DVI-I connector with a shared DDC 286 * link between analog and digital outputs, so we 287 * have to check the EDID input spec of the attached device. 288 * 289 * On the other hand, what should we do if it is a broken EDID? 290 */ 291 if (edid != NULL) { 292 is_digital = edid->input & DRM_EDID_INPUT_DIGITAL; 293 connector->display_info.raw_edid = NULL; 294 drm_free(edid, DRM_MEM_KMS); 295 } 296 297 if (!is_digital) { 298 DRM_DEBUG_KMS("CRT detected via DDC:0x50 [EDID]\n"); 299 return true; 300 } else { 301 DRM_DEBUG_KMS("CRT not detected via DDC:0x50 [EDID reports a digital panel]\n"); 302 } 303 } 304 305 return false; 306 } 307 308 static enum drm_connector_status 309 intel_crt_load_detect(struct intel_crt *crt) 310 { 311 struct drm_device *dev = crt->base.base.dev; 312 struct drm_i915_private *dev_priv = dev->dev_private; 313 uint32_t pipe = to_intel_crtc(crt->base.base.crtc)->pipe; 314 uint32_t save_bclrpat; 315 uint32_t save_vtotal; 316 uint32_t vtotal, vactive; 317 uint32_t vsample; 318 uint32_t vblank, vblank_start, vblank_end; 319 uint32_t dsl; 320 uint32_t bclrpat_reg; 321 uint32_t vtotal_reg; 322 uint32_t vblank_reg; 323 uint32_t vsync_reg; 324 uint32_t pipeconf_reg; 325 uint32_t pipe_dsl_reg; 326 uint8_t st00; 327 enum drm_connector_status status; 328 329 DRM_DEBUG_KMS("starting load-detect on CRT\n"); 330 331 bclrpat_reg = BCLRPAT(pipe); 332 vtotal_reg = VTOTAL(pipe); 333 vblank_reg = VBLANK(pipe); 334 vsync_reg = VSYNC(pipe); 335 pipeconf_reg = PIPECONF(pipe); 336 pipe_dsl_reg = PIPEDSL(pipe); 337 338 save_bclrpat = I915_READ(bclrpat_reg); 339 save_vtotal = I915_READ(vtotal_reg); 340 vblank = I915_READ(vblank_reg); 341 342 vtotal = ((save_vtotal >> 16) & 0xfff) + 1; 343 vactive = (save_vtotal & 0x7ff) + 1; 344 345 vblank_start = (vblank & 0xfff) + 1; 346 vblank_end = ((vblank >> 16) & 0xfff) + 1; 347 348 /* Set the border color to purple. */ 349 I915_WRITE(bclrpat_reg, 0x500050); 350 351 if (!IS_GEN2(dev)) { 352 uint32_t pipeconf = I915_READ(pipeconf_reg); 353 I915_WRITE(pipeconf_reg, pipeconf | PIPECONF_FORCE_BORDER); 354 POSTING_READ(pipeconf_reg); 355 /* Wait for next Vblank to substitue 356 * border color for Color info */ 357 intel_wait_for_vblank(dev, pipe); 358 st00 = I915_READ8(VGA_MSR_WRITE); 359 status = ((st00 & (1 << 4)) != 0) ? 360 connector_status_connected : 361 connector_status_disconnected; 362 363 I915_WRITE(pipeconf_reg, pipeconf); 364 } else { 365 bool restore_vblank = false; 366 int count, detect; 367 368 /* 369 * If there isn't any border, add some. 370 * Yes, this will flicker 371 */ 372 if (vblank_start <= vactive && vblank_end >= vtotal) { 373 uint32_t vsync = I915_READ(vsync_reg); 374 uint32_t vsync_start = (vsync & 0xffff) + 1; 375 376 vblank_start = vsync_start; 377 I915_WRITE(vblank_reg, 378 (vblank_start - 1) | 379 ((vblank_end - 1) << 16)); 380 restore_vblank = true; 381 } 382 /* sample in the vertical border, selecting the larger one */ 383 if (vblank_start - vactive >= vtotal - vblank_end) 384 vsample = (vblank_start + vactive) >> 1; 385 else 386 vsample = (vtotal + vblank_end) >> 1; 387 388 /* 389 * Wait for the border to be displayed 390 */ 391 while (I915_READ(pipe_dsl_reg) >= vactive) 392 ; 393 while ((dsl = I915_READ(pipe_dsl_reg)) <= vsample) 394 ; 395 /* 396 * Watch ST00 for an entire scanline 397 */ 398 detect = 0; 399 count = 0; 400 do { 401 count++; 402 /* Read the ST00 VGA status register */ 403 st00 = I915_READ8(VGA_MSR_WRITE); 404 if (st00 & (1 << 4)) 405 detect++; 406 } while ((I915_READ(pipe_dsl_reg) == dsl)); 407 408 /* restore vblank if necessary */ 409 if (restore_vblank) 410 I915_WRITE(vblank_reg, vblank); 411 /* 412 * If more than 3/4 of the scanline detected a monitor, 413 * then it is assumed to be present. This works even on i830, 414 * where there isn't any way to force the border color across 415 * the screen 416 */ 417 status = detect * 4 > count * 3 ? 418 connector_status_connected : 419 connector_status_disconnected; 420 } 421 422 /* Restore previous settings */ 423 I915_WRITE(bclrpat_reg, save_bclrpat); 424 425 return status; 426 } 427 428 static enum drm_connector_status 429 intel_crt_detect(struct drm_connector *connector, bool force) 430 { 431 struct drm_device *dev = connector->dev; 432 struct intel_crt *crt = intel_attached_crt(connector); 433 enum drm_connector_status status; 434 struct intel_load_detect_pipe tmp; 435 436 if (I915_HAS_HOTPLUG(dev)) { 437 if (intel_crt_detect_hotplug(connector)) { 438 DRM_DEBUG_KMS("CRT detected via hotplug\n"); 439 return connector_status_connected; 440 } else { 441 DRM_DEBUG_KMS("CRT not detected via hotplug\n"); 442 return connector_status_disconnected; 443 } 444 } 445 446 if (intel_crt_detect_ddc(connector)) 447 return connector_status_connected; 448 449 if (!force) 450 return connector->status; 451 452 /* for pre-945g platforms use load detect */ 453 if (intel_get_load_detect_pipe(&crt->base, connector, NULL, 454 &tmp)) { 455 if (intel_crt_detect_ddc(connector)) 456 status = connector_status_connected; 457 else 458 status = intel_crt_load_detect(crt); 459 intel_release_load_detect_pipe(&crt->base, connector, 460 &tmp); 461 } else 462 status = connector_status_unknown; 463 464 return status; 465 } 466 467 static void intel_crt_destroy(struct drm_connector *connector) 468 { 469 470 #if 0 471 drm_sysfs_connector_remove(connector); 472 #endif 473 drm_connector_cleanup(connector); 474 drm_free(connector, DRM_MEM_KMS); 475 } 476 477 static int intel_crt_get_modes(struct drm_connector *connector) 478 { 479 struct drm_device *dev = connector->dev; 480 struct drm_i915_private *dev_priv = dev->dev_private; 481 int ret; 482 483 ret = intel_ddc_get_modes(connector, 484 dev_priv->gmbus[dev_priv->crt_ddc_pin]); 485 if (ret || !IS_G4X(dev)) 486 return ret; 487 488 /* Try to probe digital port for output in DVI-I -> VGA mode. */ 489 return (intel_ddc_get_modes(connector, 490 dev_priv->gmbus[GMBUS_PORT_DPB])); 491 } 492 493 static int intel_crt_set_property(struct drm_connector *connector, 494 struct drm_property *property, 495 uint64_t value) 496 { 497 return 0; 498 } 499 500 static void intel_crt_reset(struct drm_connector *connector) 501 { 502 struct drm_device *dev = connector->dev; 503 struct intel_crt *crt = intel_attached_crt(connector); 504 505 if (HAS_PCH_SPLIT(dev)) 506 crt->force_hotplug_required = 1; 507 } 508 509 /* 510 * Routines for controlling stuff on the analog port 511 */ 512 513 static const struct drm_encoder_helper_funcs intel_crt_helper_funcs = { 514 .dpms = intel_crt_dpms, 515 .mode_fixup = intel_crt_mode_fixup, 516 .prepare = intel_encoder_prepare, 517 .commit = intel_encoder_commit, 518 .mode_set = intel_crt_mode_set, 519 }; 520 521 static const struct drm_connector_funcs intel_crt_connector_funcs = { 522 .reset = intel_crt_reset, 523 .dpms = drm_helper_connector_dpms, 524 .detect = intel_crt_detect, 525 .fill_modes = drm_helper_probe_single_connector_modes, 526 .destroy = intel_crt_destroy, 527 .set_property = intel_crt_set_property, 528 }; 529 530 static const struct drm_connector_helper_funcs intel_crt_connector_helper_funcs = { 531 .mode_valid = intel_crt_mode_valid, 532 .get_modes = intel_crt_get_modes, 533 .best_encoder = intel_best_encoder, 534 }; 535 536 static const struct drm_encoder_funcs intel_crt_enc_funcs = { 537 .destroy = intel_encoder_destroy, 538 }; 539 540 static int intel_no_crt_dmi_callback(const struct dmi_system_id *id) 541 { 542 DRM_DEBUG_KMS("Skipping CRT initialization for %s\n", id->ident); 543 return 1; 544 } 545 546 static const struct dmi_system_id intel_no_crt[] = { 547 { 548 .callback = intel_no_crt_dmi_callback, 549 .ident = "ACER ZGB", 550 .matches = { 551 DMI_MATCH(DMI_SYS_VENDOR, "ACER"), 552 DMI_MATCH(DMI_PRODUCT_NAME, "ZGB"), 553 }, 554 }, 555 { } 556 }; 557 558 void intel_crt_init(struct drm_device *dev) 559 { 560 struct drm_connector *connector; 561 struct intel_crt *crt; 562 struct intel_connector *intel_connector; 563 struct drm_i915_private *dev_priv = dev->dev_private; 564 565 /* Skip machines without VGA that falsely report hotplug events */ 566 if (dmi_check_system(intel_no_crt)) 567 return; 568 569 crt = kmalloc(sizeof(struct intel_crt), DRM_MEM_KMS, M_WAITOK | M_ZERO); 570 intel_connector = kmalloc(sizeof(struct intel_connector), DRM_MEM_KMS, 571 M_WAITOK | M_ZERO); 572 573 connector = &intel_connector->base; 574 drm_connector_init(dev, &intel_connector->base, 575 &intel_crt_connector_funcs, DRM_MODE_CONNECTOR_VGA); 576 577 drm_encoder_init(dev, &crt->base.base, &intel_crt_enc_funcs, 578 DRM_MODE_ENCODER_DAC); 579 580 intel_connector_attach_encoder(intel_connector, &crt->base); 581 582 crt->base.type = INTEL_OUTPUT_ANALOG; 583 crt->base.clone_mask = (1 << INTEL_SDVO_NON_TV_CLONE_BIT | 584 1 << INTEL_ANALOG_CLONE_BIT | 585 1 << INTEL_SDVO_LVDS_CLONE_BIT); 586 crt->base.crtc_mask = (1 << 0) | (1 << 1); 587 if (IS_GEN2(dev)) 588 connector->interlace_allowed = 0; 589 else 590 connector->interlace_allowed = 1; 591 connector->doublescan_allowed = 0; 592 593 drm_encoder_helper_add(&crt->base.base, &intel_crt_helper_funcs); 594 drm_connector_helper_add(connector, &intel_crt_connector_helper_funcs); 595 596 #if 0 597 drm_sysfs_connector_add(connector); 598 #endif 599 600 if (I915_HAS_HOTPLUG(dev)) 601 connector->polled = DRM_CONNECTOR_POLL_HPD; 602 else 603 connector->polled = DRM_CONNECTOR_POLL_CONNECT; 604 605 /* 606 * Configure the automatic hotplug detection stuff 607 */ 608 crt->force_hotplug_required = 0; 609 if (HAS_PCH_SPLIT(dev)) { 610 u32 adpa; 611 612 adpa = I915_READ(PCH_ADPA); 613 adpa &= ~ADPA_CRT_HOTPLUG_MASK; 614 adpa |= ADPA_HOTPLUG_BITS; 615 I915_WRITE(PCH_ADPA, adpa); 616 POSTING_READ(PCH_ADPA); 617 618 DRM_DEBUG_KMS("pch crt adpa set to 0x%x\n", adpa); 619 crt->force_hotplug_required = 1; 620 } 621 622 dev_priv->hotplug_supported_mask |= CRT_HOTPLUG_INT_STATUS; 623 } 624