1 /* 2 * Copyright © 2006 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 FROM, 20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 * SOFTWARE. 22 * 23 * Authors: 24 * Eric Anholt <eric@anholt.net> 25 * 26 */ 27 28 #include <drm/drm_dp_helper.h> 29 #include <drm/drmP.h> 30 #include <drm/i915_drm.h> 31 #include "i915_drv.h" 32 33 #define _INTEL_BIOS_PRIVATE 34 #include "intel_vbt_defs.h" 35 36 /** 37 * DOC: Video BIOS Table (VBT) 38 * 39 * The Video BIOS Table, or VBT, provides platform and board specific 40 * configuration information to the driver that is not discoverable or available 41 * through other means. The configuration is mostly related to display 42 * hardware. The VBT is available via the ACPI OpRegion or, on older systems, in 43 * the PCI ROM. 44 * 45 * The VBT consists of a VBT Header (defined as &struct vbt_header), a BDB 46 * Header (&struct bdb_header), and a number of BIOS Data Blocks (BDB) that 47 * contain the actual configuration information. The VBT Header, and thus the 48 * VBT, begins with "$VBT" signature. The VBT Header contains the offset of the 49 * BDB Header. The data blocks are concatenated after the BDB Header. The data 50 * blocks have a 1-byte Block ID, 2-byte Block Size, and Block Size bytes of 51 * data. (Block 53, the MIPI Sequence Block is an exception.) 52 * 53 * The driver parses the VBT during load. The relevant information is stored in 54 * driver private data for ease of use, and the actual VBT is not read after 55 * that. 56 */ 57 58 #define SLAVE_ADDR1 0x70 59 #define SLAVE_ADDR2 0x72 60 61 /* Get BDB block size given a pointer to Block ID. */ 62 static u32 _get_blocksize(const u8 *block_base) 63 { 64 /* The MIPI Sequence Block v3+ has a separate size field. */ 65 if (*block_base == BDB_MIPI_SEQUENCE && *(block_base + 3) >= 3) 66 return *((const u32 *)(block_base + 4)); 67 else 68 return *((const u16 *)(block_base + 1)); 69 } 70 71 /* Get BDB block size give a pointer to data after Block ID and Block Size. */ 72 static u32 get_blocksize(const void *block_data) 73 { 74 return _get_blocksize(block_data - 3); 75 } 76 77 static const void * 78 find_section(const void *_bdb, int section_id) 79 { 80 const struct bdb_header *bdb = _bdb; 81 const u8 *base = _bdb; 82 int index = 0; 83 u32 total, current_size; 84 u8 current_id; 85 86 /* skip to first section */ 87 index += bdb->header_size; 88 total = bdb->bdb_size; 89 90 /* walk the sections looking for section_id */ 91 while (index + 3 < total) { 92 current_id = *(base + index); 93 current_size = _get_blocksize(base + index); 94 index += 3; 95 96 if (index + current_size > total) 97 return NULL; 98 99 if (current_id == section_id) 100 return base + index; 101 102 index += current_size; 103 } 104 105 return NULL; 106 } 107 108 static void 109 fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode, 110 const struct lvds_dvo_timing *dvo_timing) 111 { 112 panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) | 113 dvo_timing->hactive_lo; 114 panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay + 115 ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo); 116 panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start + 117 ((dvo_timing->hsync_pulse_width_hi << 8) | 118 dvo_timing->hsync_pulse_width_lo); 119 panel_fixed_mode->htotal = panel_fixed_mode->hdisplay + 120 ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo); 121 122 panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) | 123 dvo_timing->vactive_lo; 124 panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay + 125 ((dvo_timing->vsync_off_hi << 4) | dvo_timing->vsync_off_lo); 126 panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start + 127 ((dvo_timing->vsync_pulse_width_hi << 4) | 128 dvo_timing->vsync_pulse_width_lo); 129 panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay + 130 ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo); 131 panel_fixed_mode->clock = dvo_timing->clock * 10; 132 panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED; 133 134 if (dvo_timing->hsync_positive) 135 panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC; 136 else 137 panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC; 138 139 if (dvo_timing->vsync_positive) 140 panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC; 141 else 142 panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC; 143 144 panel_fixed_mode->width_mm = (dvo_timing->himage_hi << 8) | 145 dvo_timing->himage_lo; 146 panel_fixed_mode->height_mm = (dvo_timing->vimage_hi << 8) | 147 dvo_timing->vimage_lo; 148 149 /* Some VBTs have bogus h/vtotal values */ 150 if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal) 151 panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1; 152 if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal) 153 panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1; 154 155 drm_mode_set_name(panel_fixed_mode); 156 } 157 158 static const struct lvds_dvo_timing * 159 get_lvds_dvo_timing(const struct bdb_lvds_lfp_data *lvds_lfp_data, 160 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs, 161 int index) 162 { 163 /* 164 * the size of fp_timing varies on the different platform. 165 * So calculate the DVO timing relative offset in LVDS data 166 * entry to get the DVO timing entry 167 */ 168 169 int lfp_data_size = 170 lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset - 171 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset; 172 int dvo_timing_offset = 173 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset - 174 lvds_lfp_data_ptrs->ptr[0].fp_timing_offset; 175 char *entry = (char *)lvds_lfp_data->data + lfp_data_size * index; 176 177 return (struct lvds_dvo_timing *)(entry + dvo_timing_offset); 178 } 179 180 /* get lvds_fp_timing entry 181 * this function may return NULL if the corresponding entry is invalid 182 */ 183 static const struct lvds_fp_timing * 184 get_lvds_fp_timing(const struct bdb_header *bdb, 185 const struct bdb_lvds_lfp_data *data, 186 const struct bdb_lvds_lfp_data_ptrs *ptrs, 187 int index) 188 { 189 size_t data_ofs = (const u8 *)data - (const u8 *)bdb; 190 u16 data_size = ((const u16 *)data)[-1]; /* stored in header */ 191 size_t ofs; 192 193 if (index >= ARRAY_SIZE(ptrs->ptr)) 194 return NULL; 195 ofs = ptrs->ptr[index].fp_timing_offset; 196 if (ofs < data_ofs || 197 ofs + sizeof(struct lvds_fp_timing) > data_ofs + data_size) 198 return NULL; 199 return (const struct lvds_fp_timing *)((const u8 *)bdb + ofs); 200 } 201 202 /* Try to find integrated panel data */ 203 static void 204 parse_lfp_panel_data(struct drm_i915_private *dev_priv, 205 const struct bdb_header *bdb) 206 { 207 const struct bdb_lvds_options *lvds_options; 208 const struct bdb_lvds_lfp_data *lvds_lfp_data; 209 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs; 210 const struct lvds_dvo_timing *panel_dvo_timing; 211 const struct lvds_fp_timing *fp_timing; 212 struct drm_display_mode *panel_fixed_mode; 213 int panel_type; 214 int drrs_mode; 215 int ret; 216 217 lvds_options = find_section(bdb, BDB_LVDS_OPTIONS); 218 if (!lvds_options) 219 return; 220 221 dev_priv->vbt.lvds_dither = lvds_options->pixel_dither; 222 223 ret = intel_opregion_get_panel_type(dev_priv); 224 if (ret >= 0) { 225 WARN_ON(ret > 0xf); 226 panel_type = ret; 227 DRM_DEBUG_KMS("Panel type: %d (OpRegion)\n", panel_type); 228 } else { 229 if (lvds_options->panel_type > 0xf) { 230 DRM_DEBUG_KMS("Invalid VBT panel type 0x%x\n", 231 lvds_options->panel_type); 232 return; 233 } 234 panel_type = lvds_options->panel_type; 235 DRM_DEBUG_KMS("Panel type: %d (VBT)\n", panel_type); 236 } 237 238 dev_priv->vbt.panel_type = panel_type; 239 240 drrs_mode = (lvds_options->dps_panel_type_bits 241 >> (panel_type * 2)) & MODE_MASK; 242 /* 243 * VBT has static DRRS = 0 and seamless DRRS = 2. 244 * The below piece of code is required to adjust vbt.drrs_type 245 * to match the enum drrs_support_type. 246 */ 247 switch (drrs_mode) { 248 case 0: 249 dev_priv->vbt.drrs_type = STATIC_DRRS_SUPPORT; 250 DRM_DEBUG_KMS("DRRS supported mode is static\n"); 251 break; 252 case 2: 253 dev_priv->vbt.drrs_type = SEAMLESS_DRRS_SUPPORT; 254 DRM_DEBUG_KMS("DRRS supported mode is seamless\n"); 255 break; 256 default: 257 dev_priv->vbt.drrs_type = DRRS_NOT_SUPPORTED; 258 DRM_DEBUG_KMS("DRRS not supported (VBT input)\n"); 259 break; 260 } 261 262 lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA); 263 if (!lvds_lfp_data) 264 return; 265 266 lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS); 267 if (!lvds_lfp_data_ptrs) 268 return; 269 270 dev_priv->vbt.lvds_vbt = 1; 271 272 panel_dvo_timing = get_lvds_dvo_timing(lvds_lfp_data, 273 lvds_lfp_data_ptrs, 274 panel_type); 275 276 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); 277 if (!panel_fixed_mode) 278 return; 279 280 fill_detail_timing_data(panel_fixed_mode, panel_dvo_timing); 281 282 dev_priv->vbt.lfp_lvds_vbt_mode = panel_fixed_mode; 283 284 DRM_DEBUG_KMS("Found panel mode in BIOS VBT tables:\n"); 285 drm_mode_debug_printmodeline(panel_fixed_mode); 286 287 fp_timing = get_lvds_fp_timing(bdb, lvds_lfp_data, 288 lvds_lfp_data_ptrs, 289 panel_type); 290 if (fp_timing) { 291 /* check the resolution, just to be sure */ 292 if (fp_timing->x_res == panel_fixed_mode->hdisplay && 293 fp_timing->y_res == panel_fixed_mode->vdisplay) { 294 dev_priv->vbt.bios_lvds_val = fp_timing->lvds_reg_val; 295 DRM_DEBUG_KMS("VBT initial LVDS value %x\n", 296 dev_priv->vbt.bios_lvds_val); 297 } 298 } 299 } 300 301 static void 302 parse_lfp_backlight(struct drm_i915_private *dev_priv, 303 const struct bdb_header *bdb) 304 { 305 const struct bdb_lfp_backlight_data *backlight_data; 306 const struct bdb_lfp_backlight_data_entry *entry; 307 int panel_type = dev_priv->vbt.panel_type; 308 309 backlight_data = find_section(bdb, BDB_LVDS_BACKLIGHT); 310 if (!backlight_data) 311 return; 312 313 if (backlight_data->entry_size != sizeof(backlight_data->data[0])) { 314 DRM_DEBUG_KMS("Unsupported backlight data entry size %u\n", 315 backlight_data->entry_size); 316 return; 317 } 318 319 entry = &backlight_data->data[panel_type]; 320 321 dev_priv->vbt.backlight.present = entry->type == BDB_BACKLIGHT_TYPE_PWM; 322 if (!dev_priv->vbt.backlight.present) { 323 DRM_DEBUG_KMS("PWM backlight not present in VBT (type %u)\n", 324 entry->type); 325 return; 326 } 327 328 dev_priv->vbt.backlight.type = INTEL_BACKLIGHT_DISPLAY_DDI; 329 if (bdb->version >= 191 && 330 get_blocksize(backlight_data) >= sizeof(*backlight_data)) { 331 const struct bdb_lfp_backlight_control_method *method; 332 333 method = &backlight_data->backlight_control[panel_type]; 334 dev_priv->vbt.backlight.type = method->type; 335 dev_priv->vbt.backlight.controller = method->controller; 336 } 337 338 dev_priv->vbt.backlight.pwm_freq_hz = entry->pwm_freq_hz; 339 dev_priv->vbt.backlight.active_low_pwm = entry->active_low_pwm; 340 dev_priv->vbt.backlight.min_brightness = entry->min_brightness; 341 DRM_DEBUG_KMS("VBT backlight PWM modulation frequency %u Hz, " 342 "active %s, min brightness %u, level %u, controller %u\n", 343 dev_priv->vbt.backlight.pwm_freq_hz, 344 dev_priv->vbt.backlight.active_low_pwm ? "low" : "high", 345 dev_priv->vbt.backlight.min_brightness, 346 backlight_data->level[panel_type], 347 dev_priv->vbt.backlight.controller); 348 } 349 350 /* Try to find sdvo panel data */ 351 static void 352 parse_sdvo_panel_data(struct drm_i915_private *dev_priv, 353 const struct bdb_header *bdb) 354 { 355 const struct lvds_dvo_timing *dvo_timing; 356 struct drm_display_mode *panel_fixed_mode; 357 int index; 358 359 index = i915_modparams.vbt_sdvo_panel_type; 360 if (index == -2) { 361 DRM_DEBUG_KMS("Ignore SDVO panel mode from BIOS VBT tables.\n"); 362 return; 363 } 364 365 if (index == -1) { 366 const struct bdb_sdvo_lvds_options *sdvo_lvds_options; 367 368 sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS); 369 if (!sdvo_lvds_options) 370 return; 371 372 index = sdvo_lvds_options->panel_type; 373 } 374 375 dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS); 376 if (!dvo_timing) 377 return; 378 379 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); 380 if (!panel_fixed_mode) 381 return; 382 383 fill_detail_timing_data(panel_fixed_mode, dvo_timing + index); 384 385 dev_priv->vbt.sdvo_lvds_vbt_mode = panel_fixed_mode; 386 387 DRM_DEBUG_KMS("Found SDVO panel mode in BIOS VBT tables:\n"); 388 drm_mode_debug_printmodeline(panel_fixed_mode); 389 } 390 391 static int intel_bios_ssc_frequency(struct drm_i915_private *dev_priv, 392 bool alternate) 393 { 394 switch (INTEL_INFO(dev_priv)->gen) { 395 case 2: 396 return alternate ? 66667 : 48000; 397 case 3: 398 case 4: 399 return alternate ? 100000 : 96000; 400 default: 401 return alternate ? 100000 : 120000; 402 } 403 } 404 405 static void 406 parse_general_features(struct drm_i915_private *dev_priv, 407 const struct bdb_header *bdb) 408 { 409 const struct bdb_general_features *general; 410 411 general = find_section(bdb, BDB_GENERAL_FEATURES); 412 if (!general) 413 return; 414 415 dev_priv->vbt.int_tv_support = general->int_tv_support; 416 /* int_crt_support can't be trusted on earlier platforms */ 417 if (bdb->version >= 155 && 418 (HAS_DDI(dev_priv) || IS_VALLEYVIEW(dev_priv))) 419 dev_priv->vbt.int_crt_support = general->int_crt_support; 420 dev_priv->vbt.lvds_use_ssc = general->enable_ssc; 421 dev_priv->vbt.lvds_ssc_freq = 422 intel_bios_ssc_frequency(dev_priv, general->ssc_freq); 423 dev_priv->vbt.display_clock_mode = general->display_clock_mode; 424 dev_priv->vbt.fdi_rx_polarity_inverted = general->fdi_rx_polarity_inverted; 425 DRM_DEBUG_KMS("BDB_GENERAL_FEATURES int_tv_support %d int_crt_support %d lvds_use_ssc %d lvds_ssc_freq %d display_clock_mode %d fdi_rx_polarity_inverted %d\n", 426 dev_priv->vbt.int_tv_support, 427 dev_priv->vbt.int_crt_support, 428 dev_priv->vbt.lvds_use_ssc, 429 dev_priv->vbt.lvds_ssc_freq, 430 dev_priv->vbt.display_clock_mode, 431 dev_priv->vbt.fdi_rx_polarity_inverted); 432 } 433 434 static const struct child_device_config * 435 child_device_ptr(const struct bdb_general_definitions *defs, int i) 436 { 437 return (const void *) &defs->devices[i * defs->child_dev_size]; 438 } 439 440 static void 441 parse_sdvo_device_mapping(struct drm_i915_private *dev_priv, u8 bdb_version) 442 { 443 struct sdvo_device_mapping *mapping; 444 const struct child_device_config *child; 445 int i, count = 0; 446 447 /* 448 * Only parse SDVO mappings on gens that could have SDVO. This isn't 449 * accurate and doesn't have to be, as long as it's not too strict. 450 */ 451 if (!IS_GEN(dev_priv, 3, 7)) { 452 DRM_DEBUG_KMS("Skipping SDVO device mapping\n"); 453 return; 454 } 455 456 for (i = 0, count = 0; i < dev_priv->vbt.child_dev_num; i++) { 457 child = dev_priv->vbt.child_dev + i; 458 459 if (child->slave_addr != SLAVE_ADDR1 && 460 child->slave_addr != SLAVE_ADDR2) { 461 /* 462 * If the slave address is neither 0x70 nor 0x72, 463 * it is not a SDVO device. Skip it. 464 */ 465 continue; 466 } 467 if (child->dvo_port != DEVICE_PORT_DVOB && 468 child->dvo_port != DEVICE_PORT_DVOC) { 469 /* skip the incorrect SDVO port */ 470 DRM_DEBUG_KMS("Incorrect SDVO port. Skip it\n"); 471 continue; 472 } 473 DRM_DEBUG_KMS("the SDVO device with slave addr %2x is found on" 474 " %s port\n", 475 child->slave_addr, 476 (child->dvo_port == DEVICE_PORT_DVOB) ? 477 "SDVOB" : "SDVOC"); 478 mapping = &dev_priv->vbt.sdvo_mappings[child->dvo_port - 1]; 479 if (!mapping->initialized) { 480 mapping->dvo_port = child->dvo_port; 481 mapping->slave_addr = child->slave_addr; 482 mapping->dvo_wiring = child->dvo_wiring; 483 mapping->ddc_pin = child->ddc_pin; 484 mapping->i2c_pin = child->i2c_pin; 485 mapping->initialized = 1; 486 DRM_DEBUG_KMS("SDVO device: dvo=%x, addr=%x, wiring=%d, ddc_pin=%d, i2c_pin=%d\n", 487 mapping->dvo_port, 488 mapping->slave_addr, 489 mapping->dvo_wiring, 490 mapping->ddc_pin, 491 mapping->i2c_pin); 492 } else { 493 DRM_DEBUG_KMS("Maybe one SDVO port is shared by " 494 "two SDVO device.\n"); 495 } 496 if (child->slave2_addr) { 497 /* Maybe this is a SDVO device with multiple inputs */ 498 /* And the mapping info is not added */ 499 DRM_DEBUG_KMS("there exists the slave2_addr. Maybe this" 500 " is a SDVO device with multiple inputs.\n"); 501 } 502 count++; 503 } 504 505 if (!count) { 506 /* No SDVO device info is found */ 507 DRM_DEBUG_KMS("No SDVO device info is found in VBT\n"); 508 } 509 } 510 511 static void 512 parse_driver_features(struct drm_i915_private *dev_priv, 513 const struct bdb_header *bdb) 514 { 515 const struct bdb_driver_features *driver; 516 517 driver = find_section(bdb, BDB_DRIVER_FEATURES); 518 if (!driver) 519 return; 520 521 if (driver->lvds_config == BDB_DRIVER_FEATURE_EDP) 522 dev_priv->vbt.edp.support = 1; 523 524 DRM_DEBUG_KMS("DRRS State Enabled:%d\n", driver->drrs_enabled); 525 /* 526 * If DRRS is not supported, drrs_type has to be set to 0. 527 * This is because, VBT is configured in such a way that 528 * static DRRS is 0 and DRRS not supported is represented by 529 * driver->drrs_enabled=false 530 */ 531 if (!driver->drrs_enabled) 532 dev_priv->vbt.drrs_type = DRRS_NOT_SUPPORTED; 533 } 534 535 static void 536 parse_edp(struct drm_i915_private *dev_priv, const struct bdb_header *bdb) 537 { 538 const struct bdb_edp *edp; 539 const struct edp_power_seq *edp_pps; 540 const struct edp_fast_link_params *edp_link_params; 541 int panel_type = dev_priv->vbt.panel_type; 542 543 edp = find_section(bdb, BDB_EDP); 544 if (!edp) { 545 if (dev_priv->vbt.edp.support) 546 DRM_DEBUG_KMS("No eDP BDB found but eDP panel supported.\n"); 547 return; 548 } 549 550 switch ((edp->color_depth >> (panel_type * 2)) & 3) { 551 case EDP_18BPP: 552 dev_priv->vbt.edp.bpp = 18; 553 break; 554 case EDP_24BPP: 555 dev_priv->vbt.edp.bpp = 24; 556 break; 557 case EDP_30BPP: 558 dev_priv->vbt.edp.bpp = 30; 559 break; 560 } 561 562 /* Get the eDP sequencing and link info */ 563 edp_pps = &edp->power_seqs[panel_type]; 564 edp_link_params = &edp->fast_link_params[panel_type]; 565 566 dev_priv->vbt.edp.pps = *edp_pps; 567 568 switch (edp_link_params->rate) { 569 case EDP_RATE_1_62: 570 dev_priv->vbt.edp.rate = DP_LINK_BW_1_62; 571 break; 572 case EDP_RATE_2_7: 573 dev_priv->vbt.edp.rate = DP_LINK_BW_2_7; 574 break; 575 default: 576 DRM_DEBUG_KMS("VBT has unknown eDP link rate value %u\n", 577 edp_link_params->rate); 578 break; 579 } 580 581 switch (edp_link_params->lanes) { 582 case EDP_LANE_1: 583 dev_priv->vbt.edp.lanes = 1; 584 break; 585 case EDP_LANE_2: 586 dev_priv->vbt.edp.lanes = 2; 587 break; 588 case EDP_LANE_4: 589 dev_priv->vbt.edp.lanes = 4; 590 break; 591 default: 592 DRM_DEBUG_KMS("VBT has unknown eDP lane count value %u\n", 593 edp_link_params->lanes); 594 break; 595 } 596 597 switch (edp_link_params->preemphasis) { 598 case EDP_PREEMPHASIS_NONE: 599 dev_priv->vbt.edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_0; 600 break; 601 case EDP_PREEMPHASIS_3_5dB: 602 dev_priv->vbt.edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_1; 603 break; 604 case EDP_PREEMPHASIS_6dB: 605 dev_priv->vbt.edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_2; 606 break; 607 case EDP_PREEMPHASIS_9_5dB: 608 dev_priv->vbt.edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_3; 609 break; 610 default: 611 DRM_DEBUG_KMS("VBT has unknown eDP pre-emphasis value %u\n", 612 edp_link_params->preemphasis); 613 break; 614 } 615 616 switch (edp_link_params->vswing) { 617 case EDP_VSWING_0_4V: 618 dev_priv->vbt.edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_0; 619 break; 620 case EDP_VSWING_0_6V: 621 dev_priv->vbt.edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_1; 622 break; 623 case EDP_VSWING_0_8V: 624 dev_priv->vbt.edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_2; 625 break; 626 case EDP_VSWING_1_2V: 627 dev_priv->vbt.edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_3; 628 break; 629 default: 630 DRM_DEBUG_KMS("VBT has unknown eDP voltage swing value %u\n", 631 edp_link_params->vswing); 632 break; 633 } 634 635 if (bdb->version >= 173) { 636 uint8_t vswing; 637 638 /* Don't read from VBT if module parameter has valid value*/ 639 if (i915_modparams.edp_vswing) { 640 dev_priv->vbt.edp.low_vswing = 641 i915_modparams.edp_vswing == 1; 642 } else { 643 vswing = (edp->edp_vswing_preemph >> (panel_type * 4)) & 0xF; 644 dev_priv->vbt.edp.low_vswing = vswing == 0; 645 } 646 } 647 } 648 649 static void 650 parse_psr(struct drm_i915_private *dev_priv, const struct bdb_header *bdb) 651 { 652 const struct bdb_psr *psr; 653 const struct psr_table *psr_table; 654 int panel_type = dev_priv->vbt.panel_type; 655 656 psr = find_section(bdb, BDB_PSR); 657 if (!psr) { 658 DRM_DEBUG_KMS("No PSR BDB found.\n"); 659 return; 660 } 661 662 psr_table = &psr->psr_table[panel_type]; 663 664 dev_priv->vbt.psr.full_link = psr_table->full_link; 665 dev_priv->vbt.psr.require_aux_wakeup = psr_table->require_aux_to_wakeup; 666 667 /* Allowed VBT values goes from 0 to 15 */ 668 dev_priv->vbt.psr.idle_frames = psr_table->idle_frames < 0 ? 0 : 669 psr_table->idle_frames > 15 ? 15 : psr_table->idle_frames; 670 671 switch (psr_table->lines_to_wait) { 672 case 0: 673 dev_priv->vbt.psr.lines_to_wait = PSR_0_LINES_TO_WAIT; 674 break; 675 case 1: 676 dev_priv->vbt.psr.lines_to_wait = PSR_1_LINE_TO_WAIT; 677 break; 678 case 2: 679 dev_priv->vbt.psr.lines_to_wait = PSR_4_LINES_TO_WAIT; 680 break; 681 case 3: 682 dev_priv->vbt.psr.lines_to_wait = PSR_8_LINES_TO_WAIT; 683 break; 684 default: 685 DRM_DEBUG_KMS("VBT has unknown PSR lines to wait %u\n", 686 psr_table->lines_to_wait); 687 break; 688 } 689 690 dev_priv->vbt.psr.tp1_wakeup_time = psr_table->tp1_wakeup_time; 691 dev_priv->vbt.psr.tp2_tp3_wakeup_time = psr_table->tp2_tp3_wakeup_time; 692 } 693 694 static void parse_dsi_backlight_ports(struct drm_i915_private *dev_priv, 695 u16 version, enum port port) 696 { 697 if (!dev_priv->vbt.dsi.config->dual_link || version < 197) { 698 dev_priv->vbt.dsi.bl_ports = BIT(port); 699 if (dev_priv->vbt.dsi.config->cabc_supported) 700 dev_priv->vbt.dsi.cabc_ports = BIT(port); 701 702 return; 703 } 704 705 switch (dev_priv->vbt.dsi.config->dl_dcs_backlight_ports) { 706 case DL_DCS_PORT_A: 707 dev_priv->vbt.dsi.bl_ports = BIT(PORT_A); 708 break; 709 case DL_DCS_PORT_C: 710 dev_priv->vbt.dsi.bl_ports = BIT(PORT_C); 711 break; 712 default: 713 case DL_DCS_PORT_A_AND_C: 714 dev_priv->vbt.dsi.bl_ports = BIT(PORT_A) | BIT(PORT_C); 715 break; 716 } 717 718 if (!dev_priv->vbt.dsi.config->cabc_supported) 719 return; 720 721 switch (dev_priv->vbt.dsi.config->dl_dcs_cabc_ports) { 722 case DL_DCS_PORT_A: 723 dev_priv->vbt.dsi.cabc_ports = BIT(PORT_A); 724 break; 725 case DL_DCS_PORT_C: 726 dev_priv->vbt.dsi.cabc_ports = BIT(PORT_C); 727 break; 728 default: 729 case DL_DCS_PORT_A_AND_C: 730 dev_priv->vbt.dsi.cabc_ports = 731 BIT(PORT_A) | BIT(PORT_C); 732 break; 733 } 734 } 735 736 static void 737 parse_mipi_config(struct drm_i915_private *dev_priv, 738 const struct bdb_header *bdb) 739 { 740 const struct bdb_mipi_config *start; 741 const struct mipi_config *config; 742 const struct mipi_pps_data *pps; 743 int panel_type = dev_priv->vbt.panel_type; 744 enum port port; 745 746 /* parse MIPI blocks only if LFP type is MIPI */ 747 if (!intel_bios_is_dsi_present(dev_priv, &port)) 748 return; 749 750 /* Initialize this to undefined indicating no generic MIPI support */ 751 dev_priv->vbt.dsi.panel_id = MIPI_DSI_UNDEFINED_PANEL_ID; 752 753 /* Block #40 is already parsed and panel_fixed_mode is 754 * stored in dev_priv->lfp_lvds_vbt_mode 755 * resuse this when needed 756 */ 757 758 /* Parse #52 for panel index used from panel_type already 759 * parsed 760 */ 761 start = find_section(bdb, BDB_MIPI_CONFIG); 762 if (!start) { 763 DRM_DEBUG_KMS("No MIPI config BDB found"); 764 return; 765 } 766 767 DRM_DEBUG_DRIVER("Found MIPI Config block, panel index = %d\n", 768 panel_type); 769 770 /* 771 * get hold of the correct configuration block and pps data as per 772 * the panel_type as index 773 */ 774 config = &start->config[panel_type]; 775 pps = &start->pps[panel_type]; 776 777 /* store as of now full data. Trim when we realise all is not needed */ 778 dev_priv->vbt.dsi.config = kmemdup(config, sizeof(struct mipi_config), GFP_KERNEL); 779 if (!dev_priv->vbt.dsi.config) 780 return; 781 782 dev_priv->vbt.dsi.pps = kmemdup(pps, sizeof(struct mipi_pps_data), GFP_KERNEL); 783 if (!dev_priv->vbt.dsi.pps) { 784 kfree(dev_priv->vbt.dsi.config); 785 return; 786 } 787 788 parse_dsi_backlight_ports(dev_priv, bdb->version, port); 789 790 /* We have mandatory mipi config blocks. Initialize as generic panel */ 791 dev_priv->vbt.dsi.panel_id = MIPI_DSI_GENERIC_PANEL_ID; 792 } 793 794 /* Find the sequence block and size for the given panel. */ 795 static const u8 * 796 find_panel_sequence_block(const struct bdb_mipi_sequence *sequence, 797 u16 panel_id, u32 *seq_size) 798 { 799 u32 total = get_blocksize(sequence); 800 const u8 *data = &sequence->data[0]; 801 u8 current_id; 802 u32 current_size; 803 int header_size = sequence->version >= 3 ? 5 : 3; 804 int index = 0; 805 int i; 806 807 /* skip new block size */ 808 if (sequence->version >= 3) 809 data += 4; 810 811 for (i = 0; i < MAX_MIPI_CONFIGURATIONS && index < total; i++) { 812 if (index + header_size > total) { 813 DRM_ERROR("Invalid sequence block (header)\n"); 814 return NULL; 815 } 816 817 current_id = *(data + index); 818 if (sequence->version >= 3) 819 current_size = *((const u32 *)(data + index + 1)); 820 else 821 current_size = *((const u16 *)(data + index + 1)); 822 823 index += header_size; 824 825 if (index + current_size > total) { 826 DRM_ERROR("Invalid sequence block\n"); 827 return NULL; 828 } 829 830 if (current_id == panel_id) { 831 *seq_size = current_size; 832 return data + index; 833 } 834 835 index += current_size; 836 } 837 838 DRM_ERROR("Sequence block detected but no valid configuration\n"); 839 840 return NULL; 841 } 842 843 static int goto_next_sequence(const u8 *data, int index, int total) 844 { 845 u16 len; 846 847 /* Skip Sequence Byte. */ 848 for (index = index + 1; index < total; index += len) { 849 u8 operation_byte = *(data + index); 850 index++; 851 852 switch (operation_byte) { 853 case MIPI_SEQ_ELEM_END: 854 return index; 855 case MIPI_SEQ_ELEM_SEND_PKT: 856 if (index + 4 > total) 857 return 0; 858 859 len = *((const u16 *)(data + index + 2)) + 4; 860 break; 861 case MIPI_SEQ_ELEM_DELAY: 862 len = 4; 863 break; 864 case MIPI_SEQ_ELEM_GPIO: 865 len = 2; 866 break; 867 case MIPI_SEQ_ELEM_I2C: 868 if (index + 7 > total) 869 return 0; 870 len = *(data + index + 6) + 7; 871 break; 872 default: 873 DRM_ERROR("Unknown operation byte\n"); 874 return 0; 875 } 876 } 877 878 return 0; 879 } 880 881 static int goto_next_sequence_v3(const u8 *data, int index, int total) 882 { 883 int seq_end; 884 u16 len; 885 u32 size_of_sequence; 886 887 /* 888 * Could skip sequence based on Size of Sequence alone, but also do some 889 * checking on the structure. 890 */ 891 if (total < 5) { 892 DRM_ERROR("Too small sequence size\n"); 893 return 0; 894 } 895 896 /* Skip Sequence Byte. */ 897 index++; 898 899 /* 900 * Size of Sequence. Excludes the Sequence Byte and the size itself, 901 * includes MIPI_SEQ_ELEM_END byte, excludes the final MIPI_SEQ_END 902 * byte. 903 */ 904 size_of_sequence = *((const uint32_t *)(data + index)); 905 index += 4; 906 907 seq_end = index + size_of_sequence; 908 if (seq_end > total) { 909 DRM_ERROR("Invalid sequence size\n"); 910 return 0; 911 } 912 913 for (; index < total; index += len) { 914 u8 operation_byte = *(data + index); 915 index++; 916 917 if (operation_byte == MIPI_SEQ_ELEM_END) { 918 if (index != seq_end) { 919 DRM_ERROR("Invalid element structure\n"); 920 return 0; 921 } 922 return index; 923 } 924 925 len = *(data + index); 926 index++; 927 928 /* 929 * FIXME: Would be nice to check elements like for v1/v2 in 930 * goto_next_sequence() above. 931 */ 932 switch (operation_byte) { 933 case MIPI_SEQ_ELEM_SEND_PKT: 934 case MIPI_SEQ_ELEM_DELAY: 935 case MIPI_SEQ_ELEM_GPIO: 936 case MIPI_SEQ_ELEM_I2C: 937 case MIPI_SEQ_ELEM_SPI: 938 case MIPI_SEQ_ELEM_PMIC: 939 break; 940 default: 941 DRM_ERROR("Unknown operation byte %u\n", 942 operation_byte); 943 break; 944 } 945 } 946 947 return 0; 948 } 949 950 static void 951 parse_mipi_sequence(struct drm_i915_private *dev_priv, 952 const struct bdb_header *bdb) 953 { 954 int panel_type = dev_priv->vbt.panel_type; 955 const struct bdb_mipi_sequence *sequence; 956 const u8 *seq_data; 957 u32 seq_size; 958 u8 *data; 959 int index = 0; 960 961 /* Only our generic panel driver uses the sequence block. */ 962 if (dev_priv->vbt.dsi.panel_id != MIPI_DSI_GENERIC_PANEL_ID) 963 return; 964 965 sequence = find_section(bdb, BDB_MIPI_SEQUENCE); 966 if (!sequence) { 967 DRM_DEBUG_KMS("No MIPI Sequence found, parsing complete\n"); 968 return; 969 } 970 971 /* Fail gracefully for forward incompatible sequence block. */ 972 if (sequence->version >= 4) { 973 DRM_ERROR("Unable to parse MIPI Sequence Block v%u\n", 974 sequence->version); 975 return; 976 } 977 978 DRM_DEBUG_DRIVER("Found MIPI sequence block v%u\n", sequence->version); 979 980 seq_data = find_panel_sequence_block(sequence, panel_type, &seq_size); 981 if (!seq_data) 982 return; 983 984 data = kmemdup(seq_data, seq_size, GFP_KERNEL); 985 if (!data) 986 return; 987 988 /* Parse the sequences, store pointers to each sequence. */ 989 for (;;) { 990 u8 seq_id = *(data + index); 991 if (seq_id == MIPI_SEQ_END) 992 break; 993 994 if (seq_id >= MIPI_SEQ_MAX) { 995 DRM_ERROR("Unknown sequence %u\n", seq_id); 996 goto err; 997 } 998 999 /* Log about presence of sequences we won't run. */ 1000 if (seq_id == MIPI_SEQ_TEAR_ON || seq_id == MIPI_SEQ_TEAR_OFF) 1001 DRM_DEBUG_KMS("Unsupported sequence %u\n", seq_id); 1002 1003 dev_priv->vbt.dsi.sequence[seq_id] = data + index; 1004 1005 if (sequence->version >= 3) 1006 index = goto_next_sequence_v3(data, index, seq_size); 1007 else 1008 index = goto_next_sequence(data, index, seq_size); 1009 if (!index) { 1010 DRM_ERROR("Invalid sequence %u\n", seq_id); 1011 goto err; 1012 } 1013 } 1014 1015 dev_priv->vbt.dsi.data = data; 1016 dev_priv->vbt.dsi.size = seq_size; 1017 dev_priv->vbt.dsi.seq_version = sequence->version; 1018 1019 DRM_DEBUG_DRIVER("MIPI related VBT parsing complete\n"); 1020 return; 1021 1022 err: 1023 kfree(data); 1024 memset(dev_priv->vbt.dsi.sequence, 0, sizeof(dev_priv->vbt.dsi.sequence)); 1025 } 1026 1027 static u8 translate_iboost(u8 val) 1028 { 1029 static const u8 mapping[] = { 1, 3, 7 }; /* See VBT spec */ 1030 1031 if (val >= ARRAY_SIZE(mapping)) { 1032 DRM_DEBUG_KMS("Unsupported I_boost value found in VBT (%d), display may not work properly\n", val); 1033 return 0; 1034 } 1035 return mapping[val]; 1036 } 1037 1038 static void sanitize_ddc_pin(struct drm_i915_private *dev_priv, 1039 enum port port) 1040 { 1041 const struct ddi_vbt_port_info *info = 1042 &dev_priv->vbt.ddi_port_info[port]; 1043 enum port p; 1044 1045 if (!info->alternate_ddc_pin) 1046 return; 1047 1048 for_each_port_masked(p, (1 << port) - 1) { 1049 struct ddi_vbt_port_info *i = &dev_priv->vbt.ddi_port_info[p]; 1050 1051 if (info->alternate_ddc_pin != i->alternate_ddc_pin) 1052 continue; 1053 1054 DRM_DEBUG_KMS("port %c trying to use the same DDC pin (0x%x) as port %c, " 1055 "disabling port %c DVI/HDMI support\n", 1056 port_name(p), i->alternate_ddc_pin, 1057 port_name(port), port_name(p)); 1058 1059 /* 1060 * If we have multiple ports supposedly sharing the 1061 * pin, then dvi/hdmi couldn't exist on the shared 1062 * port. Otherwise they share the same ddc bin and 1063 * system couldn't communicate with them separately. 1064 * 1065 * Due to parsing the ports in alphabetical order, 1066 * a higher port will always clobber a lower one. 1067 */ 1068 i->supports_dvi = false; 1069 i->supports_hdmi = false; 1070 i->alternate_ddc_pin = 0; 1071 } 1072 } 1073 1074 static void sanitize_aux_ch(struct drm_i915_private *dev_priv, 1075 enum port port) 1076 { 1077 const struct ddi_vbt_port_info *info = 1078 &dev_priv->vbt.ddi_port_info[port]; 1079 enum port p; 1080 1081 if (!info->alternate_aux_channel) 1082 return; 1083 1084 for_each_port_masked(p, (1 << port) - 1) { 1085 struct ddi_vbt_port_info *i = &dev_priv->vbt.ddi_port_info[p]; 1086 1087 if (info->alternate_aux_channel != i->alternate_aux_channel) 1088 continue; 1089 1090 DRM_DEBUG_KMS("port %c trying to use the same AUX CH (0x%x) as port %c, " 1091 "disabling port %c DP support\n", 1092 port_name(p), i->alternate_aux_channel, 1093 port_name(port), port_name(p)); 1094 1095 /* 1096 * If we have multiple ports supposedlt sharing the 1097 * aux channel, then DP couldn't exist on the shared 1098 * port. Otherwise they share the same aux channel 1099 * and system couldn't communicate with them separately. 1100 * 1101 * Due to parsing the ports in alphabetical order, 1102 * a higher port will always clobber a lower one. 1103 */ 1104 i->supports_dp = false; 1105 i->alternate_aux_channel = 0; 1106 } 1107 } 1108 1109 static const u8 cnp_ddc_pin_map[] = { 1110 [0] = 0, /* N/A */ 1111 [DDC_BUS_DDI_B] = GMBUS_PIN_1_BXT, 1112 [DDC_BUS_DDI_C] = GMBUS_PIN_2_BXT, 1113 [DDC_BUS_DDI_D] = GMBUS_PIN_4_CNP, /* sic */ 1114 [DDC_BUS_DDI_F] = GMBUS_PIN_3_BXT, /* sic */ 1115 }; 1116 1117 static u8 map_ddc_pin(struct drm_i915_private *dev_priv, u8 vbt_pin) 1118 { 1119 if (HAS_PCH_CNP(dev_priv)) { 1120 if (vbt_pin < ARRAY_SIZE(cnp_ddc_pin_map)) { 1121 return cnp_ddc_pin_map[vbt_pin]; 1122 } else { 1123 DRM_DEBUG_KMS("Ignoring alternate pin: VBT claims DDC pin %d, which is not valid for this platform\n", vbt_pin); 1124 return 0; 1125 } 1126 } 1127 1128 return vbt_pin; 1129 } 1130 1131 static void parse_ddi_port(struct drm_i915_private *dev_priv, enum port port, 1132 u8 bdb_version) 1133 { 1134 struct child_device_config *it, *child = NULL; 1135 struct ddi_vbt_port_info *info = &dev_priv->vbt.ddi_port_info[port]; 1136 uint8_t hdmi_level_shift; 1137 int i, j; 1138 bool is_dvi, is_hdmi, is_dp, is_edp, is_crt; 1139 uint8_t aux_channel, ddc_pin; 1140 /* Each DDI port can have more than one value on the "DVO Port" field, 1141 * so look for all the possible values for each port. 1142 */ 1143 int dvo_ports[][3] = { 1144 {DVO_PORT_HDMIA, DVO_PORT_DPA, -1}, 1145 {DVO_PORT_HDMIB, DVO_PORT_DPB, -1}, 1146 {DVO_PORT_HDMIC, DVO_PORT_DPC, -1}, 1147 {DVO_PORT_HDMID, DVO_PORT_DPD, -1}, 1148 {DVO_PORT_CRT, DVO_PORT_HDMIE, DVO_PORT_DPE}, 1149 }; 1150 1151 /* 1152 * Find the first child device to reference the port, report if more 1153 * than one found. 1154 */ 1155 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1156 it = dev_priv->vbt.child_dev + i; 1157 1158 for (j = 0; j < 3; j++) { 1159 if (dvo_ports[port][j] == -1) 1160 break; 1161 1162 if (it->dvo_port == dvo_ports[port][j]) { 1163 if (child) { 1164 DRM_DEBUG_KMS("More than one child device for port %c in VBT, using the first.\n", 1165 port_name(port)); 1166 } else { 1167 child = it; 1168 } 1169 } 1170 } 1171 } 1172 if (!child) 1173 return; 1174 1175 aux_channel = child->aux_channel; 1176 ddc_pin = child->ddc_pin; 1177 1178 is_dvi = child->device_type & DEVICE_TYPE_TMDS_DVI_SIGNALING; 1179 is_dp = child->device_type & DEVICE_TYPE_DISPLAYPORT_OUTPUT; 1180 is_crt = child->device_type & DEVICE_TYPE_ANALOG_OUTPUT; 1181 is_hdmi = is_dvi && (child->device_type & DEVICE_TYPE_NOT_HDMI_OUTPUT) == 0; 1182 is_edp = is_dp && (child->device_type & DEVICE_TYPE_INTERNAL_CONNECTOR); 1183 1184 if (port == PORT_A && is_dvi) { 1185 DRM_DEBUG_KMS("VBT claims port A supports DVI%s, ignoring\n", 1186 is_hdmi ? "/HDMI" : ""); 1187 is_dvi = false; 1188 is_hdmi = false; 1189 } 1190 1191 if (port == PORT_A && is_dvi) { 1192 DRM_DEBUG_KMS("VBT claims port A supports DVI%s, ignoring\n", 1193 is_hdmi ? "/HDMI" : ""); 1194 is_dvi = false; 1195 is_hdmi = false; 1196 } 1197 1198 info->supports_dvi = is_dvi; 1199 info->supports_hdmi = is_hdmi; 1200 info->supports_dp = is_dp; 1201 info->supports_edp = is_edp; 1202 1203 DRM_DEBUG_KMS("Port %c VBT info: DP:%d HDMI:%d DVI:%d EDP:%d CRT:%d\n", 1204 port_name(port), is_dp, is_hdmi, is_dvi, is_edp, is_crt); 1205 1206 if (is_edp && is_dvi) 1207 DRM_DEBUG_KMS("Internal DP port %c is TMDS compatible\n", 1208 port_name(port)); 1209 if (is_crt && port != PORT_E) 1210 DRM_DEBUG_KMS("Port %c is analog\n", port_name(port)); 1211 if (is_crt && (is_dvi || is_dp)) 1212 DRM_DEBUG_KMS("Analog port %c is also DP or TMDS compatible\n", 1213 port_name(port)); 1214 if (is_dvi && (port == PORT_A || port == PORT_E)) 1215 DRM_DEBUG_KMS("Port %c is TMDS compatible\n", port_name(port)); 1216 if (!is_dvi && !is_dp && !is_crt) 1217 DRM_DEBUG_KMS("Port %c is not DP/TMDS/CRT compatible\n", 1218 port_name(port)); 1219 if (is_edp && (port == PORT_B || port == PORT_C || port == PORT_E)) 1220 DRM_DEBUG_KMS("Port %c is internal DP\n", port_name(port)); 1221 1222 if (is_dvi) { 1223 info->alternate_ddc_pin = map_ddc_pin(dev_priv, ddc_pin); 1224 1225 sanitize_ddc_pin(dev_priv, port); 1226 } 1227 1228 if (is_dp) { 1229 info->alternate_aux_channel = aux_channel; 1230 1231 sanitize_aux_ch(dev_priv, port); 1232 } 1233 1234 if (bdb_version >= 158) { 1235 /* The VBT HDMI level shift values match the table we have. */ 1236 hdmi_level_shift = child->hdmi_level_shifter_value; 1237 DRM_DEBUG_KMS("VBT HDMI level shift for port %c: %d\n", 1238 port_name(port), 1239 hdmi_level_shift); 1240 info->hdmi_level_shift = hdmi_level_shift; 1241 } 1242 1243 /* Parse the I_boost config for SKL and above */ 1244 if (bdb_version >= 196 && child->iboost) { 1245 info->dp_boost_level = translate_iboost(child->dp_iboost_level); 1246 DRM_DEBUG_KMS("VBT (e)DP boost level for port %c: %d\n", 1247 port_name(port), info->dp_boost_level); 1248 info->hdmi_boost_level = translate_iboost(child->hdmi_iboost_level); 1249 DRM_DEBUG_KMS("VBT HDMI boost level for port %c: %d\n", 1250 port_name(port), info->hdmi_boost_level); 1251 } 1252 } 1253 1254 static void parse_ddi_ports(struct drm_i915_private *dev_priv, u8 bdb_version) 1255 { 1256 enum port port; 1257 1258 if (!HAS_DDI(dev_priv) && !IS_CHERRYVIEW(dev_priv)) 1259 return; 1260 1261 if (!dev_priv->vbt.child_dev_num) 1262 return; 1263 1264 if (bdb_version < 155) 1265 return; 1266 1267 for (port = PORT_A; port < I915_MAX_PORTS; port++) 1268 parse_ddi_port(dev_priv, port, bdb_version); 1269 } 1270 1271 static void 1272 parse_general_definitions(struct drm_i915_private *dev_priv, 1273 const struct bdb_header *bdb) 1274 { 1275 const struct bdb_general_definitions *defs; 1276 const struct child_device_config *child; 1277 int i, child_device_num, count; 1278 u8 expected_size; 1279 u16 block_size; 1280 int bus_pin; 1281 1282 defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 1283 if (!defs) { 1284 DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n"); 1285 return; 1286 } 1287 1288 block_size = get_blocksize(defs); 1289 if (block_size < sizeof(*defs)) { 1290 DRM_DEBUG_KMS("General definitions block too small (%u)\n", 1291 block_size); 1292 return; 1293 } 1294 1295 bus_pin = defs->crt_ddc_gmbus_pin; 1296 DRM_DEBUG_KMS("crt_ddc_bus_pin: %d\n", bus_pin); 1297 if (intel_gmbus_is_valid_pin(dev_priv, bus_pin)) 1298 dev_priv->vbt.crt_ddc_pin = bus_pin; 1299 1300 if (bdb->version < 106) { 1301 expected_size = 22; 1302 } else if (bdb->version < 111) { 1303 expected_size = 27; 1304 } else if (bdb->version < 195) { 1305 expected_size = LEGACY_CHILD_DEVICE_CONFIG_SIZE; 1306 } else if (bdb->version == 195) { 1307 expected_size = 37; 1308 } else if (bdb->version <= 197) { 1309 expected_size = 38; 1310 } else { 1311 expected_size = 38; 1312 BUILD_BUG_ON(sizeof(*child) < 38); 1313 DRM_DEBUG_DRIVER("Expected child device config size for VBT version %u not known; assuming %u\n", 1314 bdb->version, expected_size); 1315 } 1316 1317 /* Flag an error for unexpected size, but continue anyway. */ 1318 if (defs->child_dev_size != expected_size) 1319 DRM_ERROR("Unexpected child device config size %u (expected %u for VBT version %u)\n", 1320 defs->child_dev_size, expected_size, bdb->version); 1321 1322 /* The legacy sized child device config is the minimum we need. */ 1323 if (defs->child_dev_size < LEGACY_CHILD_DEVICE_CONFIG_SIZE) { 1324 DRM_DEBUG_KMS("Child device config size %u is too small.\n", 1325 defs->child_dev_size); 1326 return; 1327 } 1328 1329 /* get the number of child device */ 1330 child_device_num = (block_size - sizeof(*defs)) / defs->child_dev_size; 1331 count = 0; 1332 /* get the number of child device that is present */ 1333 for (i = 0; i < child_device_num; i++) { 1334 child = child_device_ptr(defs, i); 1335 if (!child->device_type) 1336 continue; 1337 count++; 1338 } 1339 if (!count) { 1340 DRM_DEBUG_KMS("no child dev is parsed from VBT\n"); 1341 return; 1342 } 1343 dev_priv->vbt.child_dev = kcalloc(count, sizeof(*child), GFP_KERNEL); 1344 if (!dev_priv->vbt.child_dev) { 1345 DRM_DEBUG_KMS("No memory space for child device\n"); 1346 return; 1347 } 1348 1349 dev_priv->vbt.child_dev_num = count; 1350 count = 0; 1351 for (i = 0; i < child_device_num; i++) { 1352 child = child_device_ptr(defs, i); 1353 if (!child->device_type) 1354 continue; 1355 1356 /* 1357 * Copy as much as we know (sizeof) and is available 1358 * (child_dev_size) of the child device. Accessing the data must 1359 * depend on VBT version. 1360 */ 1361 memcpy(dev_priv->vbt.child_dev + count, child, 1362 min_t(size_t, defs->child_dev_size, sizeof(*child))); 1363 count++; 1364 } 1365 } 1366 1367 /* Common defaults which may be overridden by VBT. */ 1368 static void 1369 init_vbt_defaults(struct drm_i915_private *dev_priv) 1370 { 1371 enum port port; 1372 1373 dev_priv->vbt.crt_ddc_pin = GMBUS_PIN_VGADDC; 1374 1375 /* Default to having backlight */ 1376 dev_priv->vbt.backlight.present = true; 1377 1378 /* LFP panel data */ 1379 dev_priv->vbt.lvds_dither = 1; 1380 dev_priv->vbt.lvds_vbt = 0; 1381 1382 /* SDVO panel data */ 1383 dev_priv->vbt.sdvo_lvds_vbt_mode = NULL; 1384 1385 /* general features */ 1386 dev_priv->vbt.int_tv_support = 1; 1387 dev_priv->vbt.int_crt_support = 1; 1388 1389 /* Default to using SSC */ 1390 dev_priv->vbt.lvds_use_ssc = 1; 1391 /* 1392 * Core/SandyBridge/IvyBridge use alternative (120MHz) reference 1393 * clock for LVDS. 1394 */ 1395 dev_priv->vbt.lvds_ssc_freq = intel_bios_ssc_frequency(dev_priv, 1396 !HAS_PCH_SPLIT(dev_priv)); 1397 DRM_DEBUG_KMS("Set default to SSC at %d kHz\n", dev_priv->vbt.lvds_ssc_freq); 1398 1399 for (port = PORT_A; port < I915_MAX_PORTS; port++) { 1400 struct ddi_vbt_port_info *info = 1401 &dev_priv->vbt.ddi_port_info[port]; 1402 1403 info->hdmi_level_shift = HDMI_LEVEL_SHIFT_UNKNOWN; 1404 } 1405 } 1406 1407 /* Defaults to initialize only if there is no VBT. */ 1408 static void 1409 init_vbt_missing_defaults(struct drm_i915_private *dev_priv) 1410 { 1411 enum port port; 1412 1413 for (port = PORT_A; port < I915_MAX_PORTS; port++) { 1414 struct ddi_vbt_port_info *info = 1415 &dev_priv->vbt.ddi_port_info[port]; 1416 1417 info->supports_dvi = (port != PORT_A && port != PORT_E); 1418 info->supports_hdmi = info->supports_dvi; 1419 info->supports_dp = (port != PORT_E); 1420 } 1421 } 1422 1423 static const struct bdb_header *get_bdb_header(const struct vbt_header *vbt) 1424 { 1425 const void *_vbt = vbt; 1426 1427 return _vbt + vbt->bdb_offset; 1428 } 1429 1430 /** 1431 * intel_bios_is_valid_vbt - does the given buffer contain a valid VBT 1432 * @buf: pointer to a buffer to validate 1433 * @size: size of the buffer 1434 * 1435 * Returns true on valid VBT. 1436 */ 1437 bool intel_bios_is_valid_vbt(const void *buf, size_t size) 1438 { 1439 const struct vbt_header *vbt = buf; 1440 const struct bdb_header *bdb; 1441 1442 if (!vbt) 1443 return false; 1444 1445 if (sizeof(struct vbt_header) > size) { 1446 DRM_DEBUG_DRIVER("VBT header incomplete\n"); 1447 return false; 1448 } 1449 1450 if (memcmp(vbt->signature, "$VBT", 4)) { 1451 DRM_DEBUG_DRIVER("VBT invalid signature\n"); 1452 return false; 1453 } 1454 1455 if (range_overflows_t(size_t, 1456 vbt->bdb_offset, 1457 sizeof(struct bdb_header), 1458 size)) { 1459 DRM_DEBUG_DRIVER("BDB header incomplete\n"); 1460 return false; 1461 } 1462 1463 bdb = get_bdb_header(vbt); 1464 if (range_overflows_t(size_t, vbt->bdb_offset, bdb->bdb_size, size)) { 1465 DRM_DEBUG_DRIVER("BDB incomplete\n"); 1466 return false; 1467 } 1468 1469 return vbt; 1470 } 1471 1472 static const struct vbt_header *find_vbt(void __iomem *bios, size_t size) 1473 { 1474 size_t i; 1475 1476 /* Scour memory looking for the VBT signature. */ 1477 for (i = 0; i + 4 < size; i++) { 1478 void *vbt; 1479 1480 if (ioread32(bios + i) != *((const u32 *) "$VBT")) 1481 continue; 1482 1483 /* 1484 * This is the one place where we explicitly discard the address 1485 * space (__iomem) of the BIOS/VBT. 1486 */ 1487 vbt = (void __force *) bios + i; 1488 if (intel_bios_is_valid_vbt(vbt, size - i)) 1489 return vbt; 1490 1491 break; 1492 } 1493 1494 return NULL; 1495 } 1496 1497 /** 1498 * intel_bios_init - find VBT and initialize settings from the BIOS 1499 * @dev_priv: i915 device instance 1500 * 1501 * Parse and initialize settings from the Video BIOS Tables (VBT). If the VBT 1502 * was not found in ACPI OpRegion, try to find it in PCI ROM first. Also 1503 * initialize some defaults if the VBT is not present at all. 1504 */ 1505 void intel_bios_init(struct drm_i915_private *dev_priv) 1506 { 1507 struct pci_dev *pdev = dev_priv->drm.pdev; 1508 const struct vbt_header *vbt = dev_priv->opregion.vbt; 1509 const struct bdb_header *bdb; 1510 u8 __iomem *bios = NULL; 1511 1512 if (HAS_PCH_NOP(dev_priv)) { 1513 DRM_DEBUG_KMS("Skipping VBT init due to disabled display.\n"); 1514 return; 1515 } 1516 1517 init_vbt_defaults(dev_priv); 1518 1519 /* If the OpRegion does not have VBT, look in PCI ROM. */ 1520 if (!vbt) { 1521 size_t size; 1522 1523 bios = pci_map_rom(pdev, &size); 1524 if (!bios) 1525 goto out; 1526 1527 vbt = find_vbt(bios, size); 1528 if (!vbt) 1529 goto out; 1530 1531 DRM_DEBUG_KMS("Found valid VBT in PCI ROM\n"); 1532 } 1533 1534 bdb = get_bdb_header(vbt); 1535 1536 DRM_DEBUG_KMS("VBT signature \"%.*s\", BDB version %d\n", 1537 (int)sizeof(vbt->signature), vbt->signature, bdb->version); 1538 1539 /* Grab useful general definitions */ 1540 parse_general_features(dev_priv, bdb); 1541 parse_general_definitions(dev_priv, bdb); 1542 parse_lfp_panel_data(dev_priv, bdb); 1543 parse_lfp_backlight(dev_priv, bdb); 1544 parse_sdvo_panel_data(dev_priv, bdb); 1545 parse_driver_features(dev_priv, bdb); 1546 parse_edp(dev_priv, bdb); 1547 parse_psr(dev_priv, bdb); 1548 parse_mipi_config(dev_priv, bdb); 1549 parse_mipi_sequence(dev_priv, bdb); 1550 1551 /* Further processing on pre-parsed data */ 1552 parse_sdvo_device_mapping(dev_priv, bdb->version); 1553 parse_ddi_ports(dev_priv, bdb->version); 1554 1555 out: 1556 if (!vbt) { 1557 DRM_INFO("Failed to find VBIOS tables (VBT)\n"); 1558 init_vbt_missing_defaults(dev_priv); 1559 } 1560 1561 if (bios) 1562 pci_unmap_rom(pdev, bios); 1563 } 1564 1565 /** 1566 * intel_bios_is_tv_present - is integrated TV present in VBT 1567 * @dev_priv: i915 device instance 1568 * 1569 * Return true if TV is present. If no child devices were parsed from VBT, 1570 * assume TV is present. 1571 */ 1572 bool intel_bios_is_tv_present(struct drm_i915_private *dev_priv) 1573 { 1574 const struct child_device_config *child; 1575 int i; 1576 1577 if (!dev_priv->vbt.int_tv_support) 1578 return false; 1579 1580 if (!dev_priv->vbt.child_dev_num) 1581 return true; 1582 1583 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1584 child = dev_priv->vbt.child_dev + i; 1585 /* 1586 * If the device type is not TV, continue. 1587 */ 1588 switch (child->device_type) { 1589 case DEVICE_TYPE_INT_TV: 1590 case DEVICE_TYPE_TV: 1591 case DEVICE_TYPE_TV_SVIDEO_COMPOSITE: 1592 break; 1593 default: 1594 continue; 1595 } 1596 /* Only when the addin_offset is non-zero, it is regarded 1597 * as present. 1598 */ 1599 if (child->addin_offset) 1600 return true; 1601 } 1602 1603 return false; 1604 } 1605 1606 /** 1607 * intel_bios_is_lvds_present - is LVDS present in VBT 1608 * @dev_priv: i915 device instance 1609 * @i2c_pin: i2c pin for LVDS if present 1610 * 1611 * Return true if LVDS is present. If no child devices were parsed from VBT, 1612 * assume LVDS is present. 1613 */ 1614 bool intel_bios_is_lvds_present(struct drm_i915_private *dev_priv, u8 *i2c_pin) 1615 { 1616 const struct child_device_config *child; 1617 int i; 1618 1619 if (!dev_priv->vbt.child_dev_num) 1620 return true; 1621 1622 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1623 child = dev_priv->vbt.child_dev + i; 1624 1625 /* If the device type is not LFP, continue. 1626 * We have to check both the new identifiers as well as the 1627 * old for compatibility with some BIOSes. 1628 */ 1629 if (child->device_type != DEVICE_TYPE_INT_LFP && 1630 child->device_type != DEVICE_TYPE_LFP) 1631 continue; 1632 1633 if (intel_gmbus_is_valid_pin(dev_priv, child->i2c_pin)) 1634 *i2c_pin = child->i2c_pin; 1635 1636 /* However, we cannot trust the BIOS writers to populate 1637 * the VBT correctly. Since LVDS requires additional 1638 * information from AIM blocks, a non-zero addin offset is 1639 * a good indicator that the LVDS is actually present. 1640 */ 1641 if (child->addin_offset) 1642 return true; 1643 1644 /* But even then some BIOS writers perform some black magic 1645 * and instantiate the device without reference to any 1646 * additional data. Trust that if the VBT was written into 1647 * the OpRegion then they have validated the LVDS's existence. 1648 */ 1649 if (dev_priv->opregion.vbt) 1650 return true; 1651 } 1652 1653 return false; 1654 } 1655 1656 /** 1657 * intel_bios_is_port_present - is the specified digital port present 1658 * @dev_priv: i915 device instance 1659 * @port: port to check 1660 * 1661 * Return true if the device in %port is present. 1662 */ 1663 bool intel_bios_is_port_present(struct drm_i915_private *dev_priv, enum port port) 1664 { 1665 const struct child_device_config *child; 1666 static const struct { 1667 u16 dp, hdmi; 1668 } port_mapping[] = { 1669 [PORT_B] = { DVO_PORT_DPB, DVO_PORT_HDMIB, }, 1670 [PORT_C] = { DVO_PORT_DPC, DVO_PORT_HDMIC, }, 1671 [PORT_D] = { DVO_PORT_DPD, DVO_PORT_HDMID, }, 1672 [PORT_E] = { DVO_PORT_DPE, DVO_PORT_HDMIE, }, 1673 }; 1674 int i; 1675 1676 /* FIXME maybe deal with port A as well? */ 1677 if (WARN_ON(port == PORT_A) || port >= ARRAY_SIZE(port_mapping)) 1678 return false; 1679 1680 if (!dev_priv->vbt.child_dev_num) 1681 return false; 1682 1683 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1684 child = dev_priv->vbt.child_dev + i; 1685 1686 if ((child->dvo_port == port_mapping[port].dp || 1687 child->dvo_port == port_mapping[port].hdmi) && 1688 (child->device_type & (DEVICE_TYPE_TMDS_DVI_SIGNALING | 1689 DEVICE_TYPE_DISPLAYPORT_OUTPUT))) 1690 return true; 1691 } 1692 1693 return false; 1694 } 1695 1696 /** 1697 * intel_bios_is_port_edp - is the device in given port eDP 1698 * @dev_priv: i915 device instance 1699 * @port: port to check 1700 * 1701 * Return true if the device in %port is eDP. 1702 */ 1703 bool intel_bios_is_port_edp(struct drm_i915_private *dev_priv, enum port port) 1704 { 1705 const struct child_device_config *child; 1706 static const short port_mapping[] = { 1707 [PORT_B] = DVO_PORT_DPB, 1708 [PORT_C] = DVO_PORT_DPC, 1709 [PORT_D] = DVO_PORT_DPD, 1710 [PORT_E] = DVO_PORT_DPE, 1711 }; 1712 int i; 1713 1714 if (HAS_DDI(dev_priv)) 1715 return dev_priv->vbt.ddi_port_info[port].supports_edp; 1716 1717 if (!dev_priv->vbt.child_dev_num) 1718 return false; 1719 1720 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1721 child = dev_priv->vbt.child_dev + i; 1722 1723 if (child->dvo_port == port_mapping[port] && 1724 (child->device_type & DEVICE_TYPE_eDP_BITS) == 1725 (DEVICE_TYPE_eDP & DEVICE_TYPE_eDP_BITS)) 1726 return true; 1727 } 1728 1729 return false; 1730 } 1731 1732 static bool child_dev_is_dp_dual_mode(const struct child_device_config *child, 1733 enum port port) 1734 { 1735 static const struct { 1736 u16 dp, hdmi; 1737 } port_mapping[] = { 1738 /* 1739 * Buggy VBTs may declare DP ports as having 1740 * HDMI type dvo_port :( So let's check both. 1741 */ 1742 [PORT_B] = { DVO_PORT_DPB, DVO_PORT_HDMIB, }, 1743 [PORT_C] = { DVO_PORT_DPC, DVO_PORT_HDMIC, }, 1744 [PORT_D] = { DVO_PORT_DPD, DVO_PORT_HDMID, }, 1745 [PORT_E] = { DVO_PORT_DPE, DVO_PORT_HDMIE, }, 1746 }; 1747 1748 if (port == PORT_A || port >= ARRAY_SIZE(port_mapping)) 1749 return false; 1750 1751 if ((child->device_type & DEVICE_TYPE_DP_DUAL_MODE_BITS) != 1752 (DEVICE_TYPE_DP_DUAL_MODE & DEVICE_TYPE_DP_DUAL_MODE_BITS)) 1753 return false; 1754 1755 if (child->dvo_port == port_mapping[port].dp) 1756 return true; 1757 1758 /* Only accept a HDMI dvo_port as DP++ if it has an AUX channel */ 1759 if (child->dvo_port == port_mapping[port].hdmi && 1760 child->aux_channel != 0) 1761 return true; 1762 1763 return false; 1764 } 1765 1766 bool intel_bios_is_port_dp_dual_mode(struct drm_i915_private *dev_priv, 1767 enum port port) 1768 { 1769 const struct child_device_config *child; 1770 int i; 1771 1772 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1773 child = dev_priv->vbt.child_dev + i; 1774 1775 if (child_dev_is_dp_dual_mode(child, port)) 1776 return true; 1777 } 1778 1779 return false; 1780 } 1781 1782 /** 1783 * intel_bios_is_dsi_present - is DSI present in VBT 1784 * @dev_priv: i915 device instance 1785 * @port: port for DSI if present 1786 * 1787 * Return true if DSI is present, and return the port in %port. 1788 */ 1789 bool intel_bios_is_dsi_present(struct drm_i915_private *dev_priv, 1790 enum port *port) 1791 { 1792 const struct child_device_config *child; 1793 u8 dvo_port; 1794 int i; 1795 1796 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1797 child = dev_priv->vbt.child_dev + i; 1798 1799 if (!(child->device_type & DEVICE_TYPE_MIPI_OUTPUT)) 1800 continue; 1801 1802 dvo_port = child->dvo_port; 1803 1804 switch (dvo_port) { 1805 case DVO_PORT_MIPIA: 1806 case DVO_PORT_MIPIC: 1807 if (port) 1808 *port = dvo_port - DVO_PORT_MIPIA; 1809 return true; 1810 case DVO_PORT_MIPIB: 1811 case DVO_PORT_MIPID: 1812 DRM_DEBUG_KMS("VBT has unsupported DSI port %c\n", 1813 port_name(dvo_port - DVO_PORT_MIPIA)); 1814 break; 1815 } 1816 } 1817 1818 return false; 1819 } 1820 1821 /** 1822 * intel_bios_is_port_hpd_inverted - is HPD inverted for %port 1823 * @dev_priv: i915 device instance 1824 * @port: port to check 1825 * 1826 * Return true if HPD should be inverted for %port. 1827 */ 1828 bool 1829 intel_bios_is_port_hpd_inverted(struct drm_i915_private *dev_priv, 1830 enum port port) 1831 { 1832 const struct child_device_config *child; 1833 int i; 1834 1835 if (WARN_ON_ONCE(!IS_GEN9_LP(dev_priv))) 1836 return false; 1837 1838 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1839 child = dev_priv->vbt.child_dev + i; 1840 1841 if (!child->hpd_invert) 1842 continue; 1843 1844 switch (child->dvo_port) { 1845 case DVO_PORT_DPA: 1846 case DVO_PORT_HDMIA: 1847 if (port == PORT_A) 1848 return true; 1849 break; 1850 case DVO_PORT_DPB: 1851 case DVO_PORT_HDMIB: 1852 if (port == PORT_B) 1853 return true; 1854 break; 1855 case DVO_PORT_DPC: 1856 case DVO_PORT_HDMIC: 1857 if (port == PORT_C) 1858 return true; 1859 break; 1860 default: 1861 break; 1862 } 1863 } 1864 1865 return false; 1866 } 1867 1868 /** 1869 * intel_bios_is_lspcon_present - if LSPCON is attached on %port 1870 * @dev_priv: i915 device instance 1871 * @port: port to check 1872 * 1873 * Return true if LSPCON is present on this port 1874 */ 1875 bool 1876 intel_bios_is_lspcon_present(struct drm_i915_private *dev_priv, 1877 enum port port) 1878 { 1879 const struct child_device_config *child; 1880 int i; 1881 1882 if (!HAS_LSPCON(dev_priv)) 1883 return false; 1884 1885 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 1886 child = dev_priv->vbt.child_dev + i; 1887 1888 if (!child->lspcon) 1889 continue; 1890 1891 switch (child->dvo_port) { 1892 case DVO_PORT_DPA: 1893 case DVO_PORT_HDMIA: 1894 if (port == PORT_A) 1895 return true; 1896 break; 1897 case DVO_PORT_DPB: 1898 case DVO_PORT_HDMIB: 1899 if (port == PORT_B) 1900 return true; 1901 break; 1902 case DVO_PORT_DPC: 1903 case DVO_PORT_HDMIC: 1904 if (port == PORT_C) 1905 return true; 1906 break; 1907 case DVO_PORT_DPD: 1908 case DVO_PORT_HDMID: 1909 if (port == PORT_D) 1910 return true; 1911 break; 1912 default: 1913 break; 1914 } 1915 } 1916 1917 return false; 1918 } 1919