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 #include <linux/dmi.h> 28 #include <drm/drmP.h> 29 #include <drm/drm_dp_helper.h> 30 #include <drm/i915_drm.h> 31 #include "i915_drv.h" 32 #include "intel_bios.h" 33 #include <linux/string.h> 34 35 #define SLAVE_ADDR1 0x70 36 #define SLAVE_ADDR2 0x72 37 38 static int panel_type; 39 40 static void * 41 find_section(struct bdb_header *bdb, int section_id) 42 { 43 u8 *base = (u8 *)bdb; 44 int index = 0; 45 u16 total, current_size; 46 u8 current_id; 47 48 /* skip to first section */ 49 index += bdb->header_size; 50 total = bdb->bdb_size; 51 52 /* walk the sections looking for section_id */ 53 while (index + 3 < total) { 54 current_id = *(base + index); 55 index++; 56 57 current_size = *((u16 *)(base + index)); 58 index += 2; 59 60 if (index + current_size > total) 61 return NULL; 62 63 if (current_id == section_id) 64 return base + index; 65 66 index += current_size; 67 } 68 69 return NULL; 70 } 71 72 static u16 73 get_blocksize(void *p) 74 { 75 u16 *block_ptr, block_size; 76 77 block_ptr = (u16 *)((char *)p - 2); 78 block_size = *block_ptr; 79 return block_size; 80 } 81 82 static void 83 fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode, 84 const struct lvds_dvo_timing *dvo_timing) 85 { 86 panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) | 87 dvo_timing->hactive_lo; 88 panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay + 89 ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo); 90 panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start + 91 dvo_timing->hsync_pulse_width; 92 panel_fixed_mode->htotal = panel_fixed_mode->hdisplay + 93 ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo); 94 95 panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) | 96 dvo_timing->vactive_lo; 97 panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay + 98 dvo_timing->vsync_off; 99 panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start + 100 dvo_timing->vsync_pulse_width; 101 panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay + 102 ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo); 103 panel_fixed_mode->clock = dvo_timing->clock * 10; 104 panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED; 105 106 if (dvo_timing->hsync_positive) 107 panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC; 108 else 109 panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC; 110 111 if (dvo_timing->vsync_positive) 112 panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC; 113 else 114 panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC; 115 116 /* Some VBTs have bogus h/vtotal values */ 117 if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal) 118 panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1; 119 if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal) 120 panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1; 121 122 drm_mode_set_name(panel_fixed_mode); 123 } 124 125 static bool 126 lvds_dvo_timing_equal_size(const struct lvds_dvo_timing *a, 127 const struct lvds_dvo_timing *b) 128 { 129 if (a->hactive_hi != b->hactive_hi || 130 a->hactive_lo != b->hactive_lo) 131 return false; 132 133 if (a->hsync_off_hi != b->hsync_off_hi || 134 a->hsync_off_lo != b->hsync_off_lo) 135 return false; 136 137 if (a->hsync_pulse_width != b->hsync_pulse_width) 138 return false; 139 140 if (a->hblank_hi != b->hblank_hi || 141 a->hblank_lo != b->hblank_lo) 142 return false; 143 144 if (a->vactive_hi != b->vactive_hi || 145 a->vactive_lo != b->vactive_lo) 146 return false; 147 148 if (a->vsync_off != b->vsync_off) 149 return false; 150 151 if (a->vsync_pulse_width != b->vsync_pulse_width) 152 return false; 153 154 if (a->vblank_hi != b->vblank_hi || 155 a->vblank_lo != b->vblank_lo) 156 return false; 157 158 return true; 159 } 160 161 static const struct lvds_dvo_timing * 162 get_lvds_dvo_timing(const struct bdb_lvds_lfp_data *lvds_lfp_data, 163 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs, 164 int index) 165 { 166 /* 167 * the size of fp_timing varies on the different platform. 168 * So calculate the DVO timing relative offset in LVDS data 169 * entry to get the DVO timing entry 170 */ 171 172 int lfp_data_size = 173 lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset - 174 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset; 175 int dvo_timing_offset = 176 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset - 177 lvds_lfp_data_ptrs->ptr[0].fp_timing_offset; 178 const char *entry = (const char *)lvds_lfp_data->data + lfp_data_size * index; 179 180 return (const struct lvds_dvo_timing *)(entry + dvo_timing_offset); 181 } 182 183 /* get lvds_fp_timing entry 184 * this function may return NULL if the corresponding entry is invalid 185 */ 186 static const struct lvds_fp_timing * 187 get_lvds_fp_timing(const struct bdb_header *bdb, 188 const struct bdb_lvds_lfp_data *data, 189 const struct bdb_lvds_lfp_data_ptrs *ptrs, 190 int index) 191 { 192 size_t data_ofs = (const u8 *)data - (const u8 *)bdb; 193 u16 data_size = ((const u16 *)data)[-1]; /* stored in header */ 194 size_t ofs; 195 196 if (index >= ARRAY_SIZE(ptrs->ptr)) 197 return NULL; 198 ofs = ptrs->ptr[index].fp_timing_offset; 199 if (ofs < data_ofs || 200 ofs + sizeof(struct lvds_fp_timing) > data_ofs + data_size) 201 return NULL; 202 return (const struct lvds_fp_timing *)((const u8 *)bdb + ofs); 203 } 204 205 /* Try to find integrated panel data */ 206 static void 207 parse_lfp_panel_data(struct drm_i915_private *dev_priv, 208 struct bdb_header *bdb) 209 { 210 const struct bdb_lvds_options *lvds_options; 211 const struct bdb_lvds_lfp_data *lvds_lfp_data; 212 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs; 213 const struct lvds_dvo_timing *panel_dvo_timing; 214 const struct lvds_fp_timing *fp_timing; 215 struct drm_display_mode *panel_fixed_mode; 216 int i, downclock, drrs_mode; 217 218 lvds_options = find_section(bdb, BDB_LVDS_OPTIONS); 219 if (!lvds_options) 220 return; 221 222 dev_priv->vbt.lvds_dither = lvds_options->pixel_dither; 223 if (lvds_options->panel_type == 0xff) 224 return; 225 226 panel_type = lvds_options->panel_type; 227 228 drrs_mode = (lvds_options->dps_panel_type_bits 229 >> (panel_type * 2)) & MODE_MASK; 230 /* 231 * VBT has static DRRS = 0 and seamless DRRS = 2. 232 * The below piece of code is required to adjust vbt.drrs_type 233 * to match the enum drrs_support_type. 234 */ 235 switch (drrs_mode) { 236 case 0: 237 dev_priv->vbt.drrs_type = STATIC_DRRS_SUPPORT; 238 DRM_DEBUG_KMS("DRRS supported mode is static\n"); 239 break; 240 case 2: 241 dev_priv->vbt.drrs_type = SEAMLESS_DRRS_SUPPORT; 242 DRM_DEBUG_KMS("DRRS supported mode is seamless\n"); 243 break; 244 default: 245 dev_priv->vbt.drrs_type = DRRS_NOT_SUPPORTED; 246 DRM_DEBUG_KMS("DRRS not supported (VBT input)\n"); 247 break; 248 } 249 250 lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA); 251 if (!lvds_lfp_data) 252 return; 253 254 lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS); 255 if (!lvds_lfp_data_ptrs) 256 return; 257 258 dev_priv->vbt.lvds_vbt = 1; 259 260 panel_dvo_timing = get_lvds_dvo_timing(lvds_lfp_data, 261 lvds_lfp_data_ptrs, 262 lvds_options->panel_type); 263 264 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); 265 if (!panel_fixed_mode) 266 return; 267 268 fill_detail_timing_data(panel_fixed_mode, panel_dvo_timing); 269 270 dev_priv->vbt.lfp_lvds_vbt_mode = panel_fixed_mode; 271 272 DRM_DEBUG_KMS("Found panel mode in BIOS VBT tables:\n"); 273 drm_mode_debug_printmodeline(panel_fixed_mode); 274 275 /* 276 * Iterate over the LVDS panel timing info to find the lowest clock 277 * for the native resolution. 278 */ 279 downclock = panel_dvo_timing->clock; 280 for (i = 0; i < 16; i++) { 281 const struct lvds_dvo_timing *dvo_timing; 282 283 dvo_timing = get_lvds_dvo_timing(lvds_lfp_data, 284 lvds_lfp_data_ptrs, 285 i); 286 if (lvds_dvo_timing_equal_size(dvo_timing, panel_dvo_timing) && 287 dvo_timing->clock < downclock) 288 downclock = dvo_timing->clock; 289 } 290 291 if (downclock < panel_dvo_timing->clock && i915.lvds_downclock) { 292 dev_priv->lvds_downclock_avail = 1; 293 dev_priv->lvds_downclock = downclock * 10; 294 DRM_DEBUG_KMS("LVDS downclock is found in VBT. " 295 "Normal Clock %dKHz, downclock %dKHz\n", 296 panel_fixed_mode->clock, 10*downclock); 297 } 298 299 fp_timing = get_lvds_fp_timing(bdb, lvds_lfp_data, 300 lvds_lfp_data_ptrs, 301 lvds_options->panel_type); 302 if (fp_timing) { 303 /* check the resolution, just to be sure */ 304 if (fp_timing->x_res == panel_fixed_mode->hdisplay && 305 fp_timing->y_res == panel_fixed_mode->vdisplay) { 306 dev_priv->vbt.bios_lvds_val = fp_timing->lvds_reg_val; 307 DRM_DEBUG_KMS("VBT initial LVDS value %x\n", 308 dev_priv->vbt.bios_lvds_val); 309 } 310 } 311 } 312 313 static void 314 parse_lfp_backlight(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 315 { 316 const struct bdb_lfp_backlight_data *backlight_data; 317 const struct bdb_lfp_backlight_data_entry *entry; 318 319 backlight_data = find_section(bdb, BDB_LVDS_BACKLIGHT); 320 if (!backlight_data) 321 return; 322 323 if (backlight_data->entry_size != sizeof(backlight_data->data[0])) { 324 DRM_DEBUG_KMS("Unsupported backlight data entry size %u\n", 325 backlight_data->entry_size); 326 return; 327 } 328 329 entry = &backlight_data->data[panel_type]; 330 331 dev_priv->vbt.backlight.present = entry->type == BDB_BACKLIGHT_TYPE_PWM; 332 if (!dev_priv->vbt.backlight.present) { 333 DRM_DEBUG_KMS("PWM backlight not present in VBT (type %u)\n", 334 entry->type); 335 return; 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\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 } 348 349 /* Try to find sdvo panel data */ 350 static void 351 parse_sdvo_panel_data(struct drm_i915_private *dev_priv, 352 struct bdb_header *bdb) 353 { 354 struct lvds_dvo_timing *dvo_timing; 355 struct drm_display_mode *panel_fixed_mode; 356 int index; 357 358 index = i915.vbt_sdvo_panel_type; 359 if (index == -2) { 360 DRM_DEBUG_KMS("Ignore SDVO panel mode from BIOS VBT tables.\n"); 361 return; 362 } 363 364 if (index == -1) { 365 struct bdb_sdvo_lvds_options *sdvo_lvds_options; 366 367 sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS); 368 if (!sdvo_lvds_options) 369 return; 370 371 index = sdvo_lvds_options->panel_type; 372 } 373 374 dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS); 375 if (!dvo_timing) 376 return; 377 378 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); 379 if (!panel_fixed_mode) 380 return; 381 382 fill_detail_timing_data(panel_fixed_mode, dvo_timing + index); 383 384 dev_priv->vbt.sdvo_lvds_vbt_mode = panel_fixed_mode; 385 386 DRM_DEBUG_KMS("Found SDVO panel mode in BIOS VBT tables:\n"); 387 drm_mode_debug_printmodeline(panel_fixed_mode); 388 } 389 390 static int intel_bios_ssc_frequency(struct drm_device *dev, 391 bool alternate) 392 { 393 switch (INTEL_INFO(dev)->gen) { 394 case 2: 395 return alternate ? 66667 : 48000; 396 case 3: 397 case 4: 398 return alternate ? 100000 : 96000; 399 default: 400 return alternate ? 100000 : 120000; 401 } 402 } 403 404 static void 405 parse_general_features(struct drm_i915_private *dev_priv, 406 struct bdb_header *bdb) 407 { 408 struct drm_device *dev = dev_priv->dev; 409 struct bdb_general_features *general; 410 411 general = find_section(bdb, BDB_GENERAL_FEATURES); 412 if (general) { 413 dev_priv->vbt.int_tv_support = general->int_tv_support; 414 dev_priv->vbt.int_crt_support = general->int_crt_support; 415 dev_priv->vbt.lvds_use_ssc = general->enable_ssc; 416 dev_priv->vbt.lvds_ssc_freq = 417 intel_bios_ssc_frequency(dev, general->ssc_freq); 418 dev_priv->vbt.display_clock_mode = general->display_clock_mode; 419 dev_priv->vbt.fdi_rx_polarity_inverted = general->fdi_rx_polarity_inverted; 420 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", 421 dev_priv->vbt.int_tv_support, 422 dev_priv->vbt.int_crt_support, 423 dev_priv->vbt.lvds_use_ssc, 424 dev_priv->vbt.lvds_ssc_freq, 425 dev_priv->vbt.display_clock_mode, 426 dev_priv->vbt.fdi_rx_polarity_inverted); 427 } 428 } 429 430 static void 431 parse_general_definitions(struct drm_i915_private *dev_priv, 432 struct bdb_header *bdb) 433 { 434 struct bdb_general_definitions *general; 435 436 general = find_section(bdb, BDB_GENERAL_DEFINITIONS); 437 if (general) { 438 u16 block_size = get_blocksize(general); 439 if (block_size >= sizeof(*general)) { 440 int bus_pin = general->crt_ddc_gmbus_pin; 441 DRM_DEBUG_KMS("crt_ddc_bus_pin: %d\n", bus_pin); 442 if (intel_gmbus_is_port_valid(bus_pin)) 443 dev_priv->vbt.crt_ddc_pin = bus_pin; 444 } else { 445 DRM_DEBUG_KMS("BDB_GD too small (%d). Invalid.\n", 446 block_size); 447 } 448 } 449 } 450 451 static void 452 parse_sdvo_device_mapping(struct drm_i915_private *dev_priv, 453 struct bdb_header *bdb) 454 { 455 struct sdvo_device_mapping *p_mapping; 456 struct bdb_general_definitions *p_defs; 457 union child_device_config *p_child; 458 int i, child_device_num, count; 459 u16 block_size; 460 461 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 462 if (!p_defs) { 463 DRM_DEBUG_KMS("No general definition block is found, unable to construct sdvo mapping.\n"); 464 return; 465 } 466 /* judge whether the size of child device meets the requirements. 467 * If the child device size obtained from general definition block 468 * is different with sizeof(struct child_device_config), skip the 469 * parsing of sdvo device info 470 */ 471 if (p_defs->child_dev_size != sizeof(*p_child)) { 472 /* different child dev size . Ignore it */ 473 DRM_DEBUG_KMS("different child size is found. Invalid.\n"); 474 return; 475 } 476 /* get the block size of general definitions */ 477 block_size = get_blocksize(p_defs); 478 /* get the number of child device */ 479 child_device_num = (block_size - sizeof(*p_defs)) / 480 sizeof(*p_child); 481 count = 0; 482 for (i = 0; i < child_device_num; i++) { 483 p_child = &(p_defs->devices[i]); 484 if (!p_child->old.device_type) { 485 /* skip the device block if device type is invalid */ 486 continue; 487 } 488 if (p_child->old.slave_addr != SLAVE_ADDR1 && 489 p_child->old.slave_addr != SLAVE_ADDR2) { 490 /* 491 * If the slave address is neither 0x70 nor 0x72, 492 * it is not a SDVO device. Skip it. 493 */ 494 continue; 495 } 496 if (p_child->old.dvo_port != DEVICE_PORT_DVOB && 497 p_child->old.dvo_port != DEVICE_PORT_DVOC) { 498 /* skip the incorrect SDVO port */ 499 DRM_DEBUG_KMS("Incorrect SDVO port. Skip it\n"); 500 continue; 501 } 502 DRM_DEBUG_KMS("the SDVO device with slave addr %2x is found on" 503 " %s port\n", 504 p_child->old.slave_addr, 505 (p_child->old.dvo_port == DEVICE_PORT_DVOB) ? 506 "SDVOB" : "SDVOC"); 507 p_mapping = &(dev_priv->sdvo_mappings[p_child->old.dvo_port - 1]); 508 if (!p_mapping->initialized) { 509 p_mapping->dvo_port = p_child->old.dvo_port; 510 p_mapping->slave_addr = p_child->old.slave_addr; 511 p_mapping->dvo_wiring = p_child->old.dvo_wiring; 512 p_mapping->ddc_pin = p_child->old.ddc_pin; 513 p_mapping->i2c_pin = p_child->old.i2c_pin; 514 p_mapping->initialized = 1; 515 DRM_DEBUG_KMS("SDVO device: dvo=%x, addr=%x, wiring=%d, ddc_pin=%d, i2c_pin=%d\n", 516 p_mapping->dvo_port, 517 p_mapping->slave_addr, 518 p_mapping->dvo_wiring, 519 p_mapping->ddc_pin, 520 p_mapping->i2c_pin); 521 } else { 522 DRM_DEBUG_KMS("Maybe one SDVO port is shared by " 523 "two SDVO device.\n"); 524 } 525 if (p_child->old.slave2_addr) { 526 /* Maybe this is a SDVO device with multiple inputs */ 527 /* And the mapping info is not added */ 528 DRM_DEBUG_KMS("there exists the slave2_addr. Maybe this" 529 " is a SDVO device with multiple inputs.\n"); 530 } 531 count++; 532 } 533 534 if (!count) { 535 /* No SDVO device info is found */ 536 DRM_DEBUG_KMS("No SDVO device info is found in VBT\n"); 537 } 538 return; 539 } 540 541 static void 542 parse_driver_features(struct drm_i915_private *dev_priv, 543 struct bdb_header *bdb) 544 { 545 struct bdb_driver_features *driver; 546 547 driver = find_section(bdb, BDB_DRIVER_FEATURES); 548 if (!driver) 549 return; 550 551 if (driver->lvds_config == BDB_DRIVER_FEATURE_EDP) 552 dev_priv->vbt.edp_support = 1; 553 554 if (driver->dual_frequency) 555 dev_priv->render_reclock_avail = true; 556 557 DRM_DEBUG_KMS("DRRS State Enabled:%d\n", driver->drrs_enabled); 558 /* 559 * If DRRS is not supported, drrs_type has to be set to 0. 560 * This is because, VBT is configured in such a way that 561 * static DRRS is 0 and DRRS not supported is represented by 562 * driver->drrs_enabled=false 563 */ 564 if (!driver->drrs_enabled) 565 dev_priv->vbt.drrs_type = DRRS_NOT_SUPPORTED; 566 } 567 568 static void 569 parse_edp(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 570 { 571 struct bdb_edp *edp; 572 struct edp_power_seq *edp_pps; 573 struct edp_link_params *edp_link_params; 574 575 edp = find_section(bdb, BDB_EDP); 576 if (!edp) { 577 if (dev_priv->vbt.edp_support) 578 DRM_DEBUG_KMS("No eDP BDB found but eDP panel supported.\n"); 579 return; 580 } 581 582 switch ((edp->color_depth >> (panel_type * 2)) & 3) { 583 case EDP_18BPP: 584 dev_priv->vbt.edp_bpp = 18; 585 break; 586 case EDP_24BPP: 587 dev_priv->vbt.edp_bpp = 24; 588 break; 589 case EDP_30BPP: 590 dev_priv->vbt.edp_bpp = 30; 591 break; 592 } 593 594 /* Get the eDP sequencing and link info */ 595 edp_pps = &edp->power_seqs[panel_type]; 596 edp_link_params = &edp->link_params[panel_type]; 597 598 dev_priv->vbt.edp_pps = *edp_pps; 599 600 switch (edp_link_params->rate) { 601 case EDP_RATE_1_62: 602 dev_priv->vbt.edp_rate = DP_LINK_BW_1_62; 603 break; 604 case EDP_RATE_2_7: 605 dev_priv->vbt.edp_rate = DP_LINK_BW_2_7; 606 break; 607 default: 608 DRM_DEBUG_KMS("VBT has unknown eDP link rate value %u\n", 609 edp_link_params->rate); 610 break; 611 } 612 613 switch (edp_link_params->lanes) { 614 case EDP_LANE_1: 615 dev_priv->vbt.edp_lanes = 1; 616 break; 617 case EDP_LANE_2: 618 dev_priv->vbt.edp_lanes = 2; 619 break; 620 case EDP_LANE_4: 621 dev_priv->vbt.edp_lanes = 4; 622 break; 623 default: 624 DRM_DEBUG_KMS("VBT has unknown eDP lane count value %u\n", 625 edp_link_params->lanes); 626 break; 627 } 628 629 switch (edp_link_params->preemphasis) { 630 case EDP_PREEMPHASIS_NONE: 631 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_0; 632 break; 633 case EDP_PREEMPHASIS_3_5dB: 634 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_1; 635 break; 636 case EDP_PREEMPHASIS_6dB: 637 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_2; 638 break; 639 case EDP_PREEMPHASIS_9_5dB: 640 dev_priv->vbt.edp_preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_3; 641 break; 642 default: 643 DRM_DEBUG_KMS("VBT has unknown eDP pre-emphasis value %u\n", 644 edp_link_params->preemphasis); 645 break; 646 } 647 648 switch (edp_link_params->vswing) { 649 case EDP_VSWING_0_4V: 650 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_0; 651 break; 652 case EDP_VSWING_0_6V: 653 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_1; 654 break; 655 case EDP_VSWING_0_8V: 656 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_2; 657 break; 658 case EDP_VSWING_1_2V: 659 dev_priv->vbt.edp_vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_3; 660 break; 661 default: 662 DRM_DEBUG_KMS("VBT has unknown eDP voltage swing value %u\n", 663 edp_link_params->vswing); 664 break; 665 } 666 } 667 668 static u8 *goto_next_sequence(u8 *data, int *size) 669 { 670 u16 len; 671 int tmp = *size; 672 673 if (--tmp < 0) 674 return NULL; 675 676 /* goto first element */ 677 data++; 678 while (1) { 679 switch (*data) { 680 case MIPI_SEQ_ELEM_SEND_PKT: 681 /* 682 * skip by this element payload size 683 * skip elem id, command flag and data type 684 */ 685 tmp -= 5; 686 if (tmp < 0) 687 return NULL; 688 689 data += 3; 690 len = *((u16 *)data); 691 692 tmp -= len; 693 if (tmp < 0) 694 return NULL; 695 696 /* skip by len */ 697 data = data + 2 + len; 698 break; 699 case MIPI_SEQ_ELEM_DELAY: 700 /* skip by elem id, and delay is 4 bytes */ 701 tmp -= 5; 702 if (tmp < 0) 703 return NULL; 704 705 data += 5; 706 break; 707 case MIPI_SEQ_ELEM_GPIO: 708 tmp -= 3; 709 if (tmp < 0) 710 return NULL; 711 712 data += 3; 713 break; 714 default: 715 DRM_ERROR("Unknown element\n"); 716 return NULL; 717 } 718 719 /* end of sequence ? */ 720 if (*data == 0) 721 break; 722 } 723 724 /* goto next sequence or end of block byte */ 725 if (--tmp < 0) 726 return NULL; 727 728 data++; 729 730 /* update amount of data left for the sequence block to be parsed */ 731 *size = tmp; 732 return data; 733 } 734 735 static void 736 parse_mipi(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 737 { 738 struct bdb_mipi_config *start; 739 struct bdb_mipi_sequence *sequence; 740 struct mipi_config *config; 741 struct mipi_pps_data *pps; 742 u8 *data, *seq_data; 743 int i, panel_id, seq_size; 744 u16 block_size; 745 746 /* parse MIPI blocks only if LFP type is MIPI */ 747 if (!dev_priv->vbt.has_mipi) 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 /* We have mandatory mipi config blocks. Initialize as generic panel */ 789 dev_priv->vbt.dsi.panel_id = MIPI_DSI_GENERIC_PANEL_ID; 790 791 /* Check if we have sequence block as well */ 792 sequence = find_section(bdb, BDB_MIPI_SEQUENCE); 793 if (!sequence) { 794 DRM_DEBUG_KMS("No MIPI Sequence found, parsing complete\n"); 795 return; 796 } 797 798 DRM_DEBUG_DRIVER("Found MIPI sequence block\n"); 799 800 block_size = get_blocksize(sequence); 801 802 /* 803 * parse the sequence block for individual sequences 804 */ 805 dev_priv->vbt.dsi.seq_version = sequence->version; 806 807 seq_data = &sequence->data[0]; 808 809 /* 810 * sequence block is variable length and hence we need to parse and 811 * get the sequence data for specific panel id 812 */ 813 for (i = 0; i < MAX_MIPI_CONFIGURATIONS; i++) { 814 panel_id = *seq_data; 815 seq_size = *((u16 *) (seq_data + 1)); 816 if (panel_id == panel_type) 817 break; 818 819 /* skip the sequence including seq header of 3 bytes */ 820 seq_data = seq_data + 3 + seq_size; 821 if ((seq_data - &sequence->data[0]) > block_size) { 822 DRM_ERROR("Sequence start is beyond sequence block size, corrupted sequence block\n"); 823 return; 824 } 825 } 826 827 if (i == MAX_MIPI_CONFIGURATIONS) { 828 DRM_ERROR("Sequence block detected but no valid configuration\n"); 829 return; 830 } 831 832 /* check if found sequence is completely within the sequence block 833 * just being paranoid */ 834 if (seq_size > block_size) { 835 DRM_ERROR("Corrupted sequence/size, bailing out\n"); 836 return; 837 } 838 839 /* skip the panel id(1 byte) and seq size(2 bytes) */ 840 dev_priv->vbt.dsi.data = kmemdup(seq_data + 3, seq_size, GFP_KERNEL); 841 if (!dev_priv->vbt.dsi.data) 842 return; 843 844 /* 845 * loop into the sequence data and split into multiple sequneces 846 * There are only 5 types of sequences as of now 847 */ 848 data = dev_priv->vbt.dsi.data; 849 dev_priv->vbt.dsi.size = seq_size; 850 851 /* two consecutive 0x00 indicate end of all sequences */ 852 while (1) { 853 int seq_id = *data; 854 if (MIPI_SEQ_MAX > seq_id && seq_id > MIPI_SEQ_UNDEFINED) { 855 dev_priv->vbt.dsi.sequence[seq_id] = data; 856 DRM_DEBUG_DRIVER("Found mipi sequence - %d\n", seq_id); 857 } else { 858 DRM_ERROR("undefined sequence\n"); 859 goto err; 860 } 861 862 /* partial parsing to skip elements */ 863 data = goto_next_sequence(data, &seq_size); 864 865 if (data == NULL) { 866 DRM_ERROR("Sequence elements going beyond block itself. Sequence block parsing failed\n"); 867 goto err; 868 } 869 870 if (*data == 0) 871 break; /* end of sequence reached */ 872 } 873 874 DRM_DEBUG_DRIVER("MIPI related vbt parsing complete\n"); 875 return; 876 err: 877 kfree(dev_priv->vbt.dsi.data); 878 dev_priv->vbt.dsi.data = NULL; 879 880 /* error during parsing so set all pointers to null 881 * because of partial parsing */ 882 memset(dev_priv->vbt.dsi.sequence, 0, sizeof(dev_priv->vbt.dsi.sequence)); 883 } 884 885 static void parse_ddi_port(struct drm_i915_private *dev_priv, enum port port, 886 struct bdb_header *bdb) 887 { 888 union child_device_config *it, *child = NULL; 889 struct ddi_vbt_port_info *info = &dev_priv->vbt.ddi_port_info[port]; 890 uint8_t hdmi_level_shift; 891 int i, j; 892 bool is_dvi, is_hdmi, is_dp, is_edp, is_crt; 893 uint8_t aux_channel; 894 /* Each DDI port can have more than one value on the "DVO Port" field, 895 * so look for all the possible values for each port and abort if more 896 * than one is found. */ 897 int dvo_ports[][2] = { 898 {DVO_PORT_HDMIA, DVO_PORT_DPA}, 899 {DVO_PORT_HDMIB, DVO_PORT_DPB}, 900 {DVO_PORT_HDMIC, DVO_PORT_DPC}, 901 {DVO_PORT_HDMID, DVO_PORT_DPD}, 902 {DVO_PORT_CRT, -1 /* Port E can only be DVO_PORT_CRT */ }, 903 }; 904 905 /* Find the child device to use, abort if more than one found. */ 906 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 907 it = dev_priv->vbt.child_dev + i; 908 909 for (j = 0; j < 2; j++) { 910 if (dvo_ports[port][j] == -1) 911 break; 912 913 if (it->common.dvo_port == dvo_ports[port][j]) { 914 if (child) { 915 DRM_DEBUG_KMS("More than one child device for port %c in VBT.\n", 916 port_name(port)); 917 return; 918 } 919 child = it; 920 } 921 } 922 } 923 if (!child) 924 return; 925 926 aux_channel = child->raw[25]; 927 928 is_dvi = child->common.device_type & DEVICE_TYPE_TMDS_DVI_SIGNALING; 929 is_dp = child->common.device_type & DEVICE_TYPE_DISPLAYPORT_OUTPUT; 930 is_crt = child->common.device_type & DEVICE_TYPE_ANALOG_OUTPUT; 931 is_hdmi = is_dvi && (child->common.device_type & DEVICE_TYPE_NOT_HDMI_OUTPUT) == 0; 932 is_edp = is_dp && (child->common.device_type & DEVICE_TYPE_INTERNAL_CONNECTOR); 933 934 info->supports_dvi = is_dvi; 935 info->supports_hdmi = is_hdmi; 936 info->supports_dp = is_dp; 937 938 DRM_DEBUG_KMS("Port %c VBT info: DP:%d HDMI:%d DVI:%d EDP:%d CRT:%d\n", 939 port_name(port), is_dp, is_hdmi, is_dvi, is_edp, is_crt); 940 941 if (is_edp && is_dvi) 942 DRM_DEBUG_KMS("Internal DP port %c is TMDS compatible\n", 943 port_name(port)); 944 if (is_crt && port != PORT_E) 945 DRM_DEBUG_KMS("Port %c is analog\n", port_name(port)); 946 if (is_crt && (is_dvi || is_dp)) 947 DRM_DEBUG_KMS("Analog port %c is also DP or TMDS compatible\n", 948 port_name(port)); 949 if (is_dvi && (port == PORT_A || port == PORT_E)) 950 DRM_DEBUG_KMS("Port %c is TMDS compatible\n", port_name(port)); 951 if (!is_dvi && !is_dp && !is_crt) 952 DRM_DEBUG_KMS("Port %c is not DP/TMDS/CRT compatible\n", 953 port_name(port)); 954 if (is_edp && (port == PORT_B || port == PORT_C || port == PORT_E)) 955 DRM_DEBUG_KMS("Port %c is internal DP\n", port_name(port)); 956 957 if (is_dvi) { 958 if (child->common.ddc_pin == 0x05 && port != PORT_B) 959 DRM_DEBUG_KMS("Unexpected DDC pin for port B\n"); 960 if (child->common.ddc_pin == 0x04 && port != PORT_C) 961 DRM_DEBUG_KMS("Unexpected DDC pin for port C\n"); 962 if (child->common.ddc_pin == 0x06 && port != PORT_D) 963 DRM_DEBUG_KMS("Unexpected DDC pin for port D\n"); 964 } 965 966 if (is_dp) { 967 if (aux_channel == 0x40 && port != PORT_A) 968 DRM_DEBUG_KMS("Unexpected AUX channel for port A\n"); 969 if (aux_channel == 0x10 && port != PORT_B) 970 DRM_DEBUG_KMS("Unexpected AUX channel for port B\n"); 971 if (aux_channel == 0x20 && port != PORT_C) 972 DRM_DEBUG_KMS("Unexpected AUX channel for port C\n"); 973 if (aux_channel == 0x30 && port != PORT_D) 974 DRM_DEBUG_KMS("Unexpected AUX channel for port D\n"); 975 } 976 977 if (bdb->version >= 158) { 978 /* The VBT HDMI level shift values match the table we have. */ 979 hdmi_level_shift = child->raw[7] & 0xF; 980 DRM_DEBUG_KMS("VBT HDMI level shift for port %c: %d\n", 981 port_name(port), 982 hdmi_level_shift); 983 info->hdmi_level_shift = hdmi_level_shift; 984 } 985 } 986 987 static void parse_ddi_ports(struct drm_i915_private *dev_priv, 988 struct bdb_header *bdb) 989 { 990 struct drm_device *dev = dev_priv->dev; 991 enum port port; 992 993 if (!HAS_DDI(dev)) 994 return; 995 996 if (!dev_priv->vbt.child_dev_num) 997 return; 998 999 if (bdb->version < 155) 1000 return; 1001 1002 for (port = PORT_A; port < I915_MAX_PORTS; port++) 1003 parse_ddi_port(dev_priv, port, bdb); 1004 } 1005 1006 static void 1007 parse_device_mapping(struct drm_i915_private *dev_priv, 1008 struct bdb_header *bdb) 1009 { 1010 struct bdb_general_definitions *p_defs; 1011 union child_device_config *p_child, *child_dev_ptr; 1012 int i, child_device_num, count; 1013 u16 block_size; 1014 1015 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 1016 if (!p_defs) { 1017 DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n"); 1018 return; 1019 } 1020 /* judge whether the size of child device meets the requirements. 1021 * If the child device size obtained from general definition block 1022 * is different with sizeof(struct child_device_config), skip the 1023 * parsing of sdvo device info 1024 */ 1025 if (p_defs->child_dev_size != sizeof(*p_child)) { 1026 /* different child dev size . Ignore it */ 1027 DRM_DEBUG_KMS("different child size is found. Invalid.\n"); 1028 return; 1029 } 1030 /* get the block size of general definitions */ 1031 block_size = get_blocksize(p_defs); 1032 /* get the number of child device */ 1033 child_device_num = (block_size - sizeof(*p_defs)) / 1034 sizeof(*p_child); 1035 count = 0; 1036 /* get the number of child device that is present */ 1037 for (i = 0; i < child_device_num; i++) { 1038 p_child = &(p_defs->devices[i]); 1039 if (!p_child->common.device_type) { 1040 /* skip the device block if device type is invalid */ 1041 continue; 1042 } 1043 count++; 1044 } 1045 if (!count) { 1046 DRM_DEBUG_KMS("no child dev is parsed from VBT\n"); 1047 return; 1048 } 1049 dev_priv->vbt.child_dev = kcalloc(count, sizeof(*p_child), GFP_KERNEL); 1050 if (!dev_priv->vbt.child_dev) { 1051 DRM_DEBUG_KMS("No memory space for child device\n"); 1052 return; 1053 } 1054 1055 dev_priv->vbt.child_dev_num = count; 1056 count = 0; 1057 for (i = 0; i < child_device_num; i++) { 1058 p_child = &(p_defs->devices[i]); 1059 if (!p_child->common.device_type) { 1060 /* skip the device block if device type is invalid */ 1061 continue; 1062 } 1063 1064 if (p_child->common.dvo_port >= DVO_PORT_MIPIA 1065 && p_child->common.dvo_port <= DVO_PORT_MIPID 1066 &&p_child->common.device_type & DEVICE_TYPE_MIPI_OUTPUT) { 1067 DRM_DEBUG_KMS("Found MIPI as LFP\n"); 1068 dev_priv->vbt.has_mipi = 1; 1069 dev_priv->vbt.dsi.port = p_child->common.dvo_port; 1070 } 1071 1072 child_dev_ptr = dev_priv->vbt.child_dev + count; 1073 count++; 1074 memcpy((void *)child_dev_ptr, (void *)p_child, 1075 sizeof(*p_child)); 1076 } 1077 return; 1078 } 1079 1080 static void 1081 init_vbt_defaults(struct drm_i915_private *dev_priv) 1082 { 1083 struct drm_device *dev = dev_priv->dev; 1084 enum port port; 1085 1086 dev_priv->vbt.crt_ddc_pin = GMBUS_PORT_VGADDC; 1087 1088 /* Default to having backlight */ 1089 dev_priv->vbt.backlight.present = true; 1090 1091 /* LFP panel data */ 1092 dev_priv->vbt.lvds_dither = 1; 1093 dev_priv->vbt.lvds_vbt = 0; 1094 1095 /* SDVO panel data */ 1096 dev_priv->vbt.sdvo_lvds_vbt_mode = NULL; 1097 1098 /* general features */ 1099 dev_priv->vbt.int_tv_support = 1; 1100 dev_priv->vbt.int_crt_support = 1; 1101 1102 /* Default to using SSC */ 1103 dev_priv->vbt.lvds_use_ssc = 1; 1104 /* 1105 * Core/SandyBridge/IvyBridge use alternative (120MHz) reference 1106 * clock for LVDS. 1107 */ 1108 dev_priv->vbt.lvds_ssc_freq = intel_bios_ssc_frequency(dev, 1109 !HAS_PCH_SPLIT(dev)); 1110 DRM_DEBUG_KMS("Set default to SSC at %d kHz\n", dev_priv->vbt.lvds_ssc_freq); 1111 1112 for (port = PORT_A; port < I915_MAX_PORTS; port++) { 1113 struct ddi_vbt_port_info *info = 1114 &dev_priv->vbt.ddi_port_info[port]; 1115 1116 info->hdmi_level_shift = HDMI_LEVEL_SHIFT_UNKNOWN; 1117 1118 info->supports_dvi = (port != PORT_A && port != PORT_E); 1119 info->supports_hdmi = info->supports_dvi; 1120 info->supports_dp = (port != PORT_E); 1121 } 1122 } 1123 1124 static int intel_no_opregion_vbt_callback(const struct dmi_system_id *id) 1125 { 1126 DRM_DEBUG_KMS("Falling back to manually reading VBT from " 1127 "VBIOS ROM for %s\n", 1128 id->ident); 1129 return 1; 1130 } 1131 1132 static const struct dmi_system_id intel_no_opregion_vbt[] = { 1133 { 1134 .callback = intel_no_opregion_vbt_callback, 1135 .ident = "ThinkCentre A57", 1136 .matches = { 1137 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1138 DMI_MATCH(DMI_PRODUCT_NAME, "97027RG"), 1139 }, 1140 }, 1141 { } 1142 }; 1143 1144 static struct bdb_header *validate_vbt(char *base, size_t size, 1145 struct vbt_header *vbt, 1146 const char *source) 1147 { 1148 size_t offset; 1149 struct bdb_header *bdb; 1150 1151 if (vbt == NULL) { 1152 DRM_DEBUG_DRIVER("VBT signature missing\n"); 1153 return NULL; 1154 } 1155 1156 offset = (char *)vbt - base; 1157 if (offset + sizeof(struct vbt_header) > size) { 1158 DRM_DEBUG_DRIVER("VBT header incomplete\n"); 1159 return NULL; 1160 } 1161 1162 if (memcmp(vbt->signature, "$VBT", 4)) { 1163 DRM_DEBUG_DRIVER("VBT invalid signature\n"); 1164 return NULL; 1165 } 1166 1167 offset += vbt->bdb_offset; 1168 if (offset + sizeof(struct bdb_header) > size) { 1169 DRM_DEBUG_DRIVER("BDB header incomplete\n"); 1170 return NULL; 1171 } 1172 1173 bdb = (struct bdb_header *)(base + offset); 1174 if (offset + bdb->bdb_size > size) { 1175 DRM_DEBUG_DRIVER("BDB incomplete\n"); 1176 return NULL; 1177 } 1178 1179 DRM_DEBUG_KMS("Using VBT from %s: %20s\n", 1180 source, vbt->signature); 1181 return bdb; 1182 } 1183 1184 /** 1185 * intel_parse_bios - find VBT and initialize settings from the BIOS 1186 * @dev: DRM device 1187 * 1188 * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers 1189 * to appropriate values. 1190 * 1191 * Returns 0 on success, nonzero on failure. 1192 */ 1193 int 1194 intel_parse_bios(struct drm_device *dev) 1195 { 1196 struct drm_i915_private *dev_priv = dev->dev_private; 1197 #if 0 1198 struct pci_dev *pdev = dev->pdev; 1199 #endif 1200 struct bdb_header *bdb = NULL; 1201 u8 __iomem *bios = NULL; 1202 1203 if (HAS_PCH_NOP(dev)) 1204 return -ENODEV; 1205 1206 init_vbt_defaults(dev_priv); 1207 1208 /* XXX Should this validation be moved to intel_opregion.c? */ 1209 if (!dmi_check_system(intel_no_opregion_vbt) && dev_priv->opregion.vbt) 1210 bdb = validate_vbt((char *)dev_priv->opregion.header, OPREGION_SIZE, 1211 (struct vbt_header *)dev_priv->opregion.vbt, 1212 "OpRegion"); 1213 1214 if (bdb == NULL) { 1215 size_t i, size; 1216 1217 #if 0 1218 bios = pci_map_rom(pdev, &size); 1219 if (!bios) 1220 #endif 1221 return -1; 1222 1223 /* Scour memory looking for the VBT signature */ 1224 for (i = 0; i + 4 < size; i++) { 1225 if (memcmp(bios + i, "$VBT", 4) == 0) { 1226 bdb = validate_vbt(bios, size, 1227 (struct vbt_header *)(bios + i), 1228 "PCI ROM"); 1229 break; 1230 } 1231 } 1232 1233 if (!bdb) { 1234 #if 0 1235 pci_unmap_rom(pdev, bios); 1236 #endif 1237 return -1; 1238 } 1239 } 1240 1241 /* Grab useful general definitions */ 1242 parse_general_features(dev_priv, bdb); 1243 parse_general_definitions(dev_priv, bdb); 1244 parse_lfp_panel_data(dev_priv, bdb); 1245 parse_lfp_backlight(dev_priv, bdb); 1246 parse_sdvo_panel_data(dev_priv, bdb); 1247 parse_sdvo_device_mapping(dev_priv, bdb); 1248 parse_device_mapping(dev_priv, bdb); 1249 parse_driver_features(dev_priv, bdb); 1250 parse_edp(dev_priv, bdb); 1251 parse_mipi(dev_priv, bdb); 1252 parse_ddi_ports(dev_priv, bdb); 1253 1254 #if 0 1255 if (bios) 1256 pci_unmap_rom(pdev, bios); 1257 #endif 1258 1259 return 0; 1260 } 1261 1262 /* Ensure that vital registers have been initialised, even if the BIOS 1263 * is absent or just failing to do its job. 1264 */ 1265 void intel_setup_bios(struct drm_device *dev) 1266 { 1267 struct drm_i915_private *dev_priv = dev->dev_private; 1268 1269 /* Set the Panel Power On/Off timings if uninitialized. */ 1270 if (!HAS_PCH_SPLIT(dev) && 1271 I915_READ(PP_ON_DELAYS) == 0 && I915_READ(PP_OFF_DELAYS) == 0) { 1272 /* Set T2 to 40ms and T5 to 200ms */ 1273 I915_WRITE(PP_ON_DELAYS, 0x019007d0); 1274 1275 /* Set T3 to 35ms and Tx to 200ms */ 1276 I915_WRITE(PP_OFF_DELAYS, 0x015e07d0); 1277 } 1278 } 1279