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 void 669 parse_psr(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 670 { 671 struct bdb_psr *psr; 672 struct psr_table *psr_table; 673 674 psr = find_section(bdb, BDB_PSR); 675 if (!psr) { 676 DRM_DEBUG_KMS("No PSR BDB found.\n"); 677 return; 678 } 679 680 psr_table = &psr->psr_table[panel_type]; 681 682 dev_priv->vbt.psr.full_link = psr_table->full_link; 683 dev_priv->vbt.psr.require_aux_wakeup = psr_table->require_aux_to_wakeup; 684 685 /* Allowed VBT values goes from 0 to 15 */ 686 dev_priv->vbt.psr.idle_frames = psr_table->idle_frames < 0 ? 0 : 687 psr_table->idle_frames > 15 ? 15 : psr_table->idle_frames; 688 689 switch (psr_table->lines_to_wait) { 690 case 0: 691 dev_priv->vbt.psr.lines_to_wait = PSR_0_LINES_TO_WAIT; 692 break; 693 case 1: 694 dev_priv->vbt.psr.lines_to_wait = PSR_1_LINE_TO_WAIT; 695 break; 696 case 2: 697 dev_priv->vbt.psr.lines_to_wait = PSR_4_LINES_TO_WAIT; 698 break; 699 case 3: 700 dev_priv->vbt.psr.lines_to_wait = PSR_8_LINES_TO_WAIT; 701 break; 702 default: 703 DRM_DEBUG_KMS("VBT has unknown PSR lines to wait %u\n", 704 psr_table->lines_to_wait); 705 break; 706 } 707 708 dev_priv->vbt.psr.tp1_wakeup_time = psr_table->tp1_wakeup_time; 709 dev_priv->vbt.psr.tp2_tp3_wakeup_time = psr_table->tp2_tp3_wakeup_time; 710 } 711 712 static u8 *goto_next_sequence(u8 *data, int *size) 713 { 714 u16 len; 715 int tmp = *size; 716 717 if (--tmp < 0) 718 return NULL; 719 720 /* goto first element */ 721 data++; 722 while (1) { 723 switch (*data) { 724 case MIPI_SEQ_ELEM_SEND_PKT: 725 /* 726 * skip by this element payload size 727 * skip elem id, command flag and data type 728 */ 729 tmp -= 5; 730 if (tmp < 0) 731 return NULL; 732 733 data += 3; 734 len = *((u16 *)data); 735 736 tmp -= len; 737 if (tmp < 0) 738 return NULL; 739 740 /* skip by len */ 741 data = data + 2 + len; 742 break; 743 case MIPI_SEQ_ELEM_DELAY: 744 /* skip by elem id, and delay is 4 bytes */ 745 tmp -= 5; 746 if (tmp < 0) 747 return NULL; 748 749 data += 5; 750 break; 751 case MIPI_SEQ_ELEM_GPIO: 752 tmp -= 3; 753 if (tmp < 0) 754 return NULL; 755 756 data += 3; 757 break; 758 default: 759 DRM_ERROR("Unknown element\n"); 760 return NULL; 761 } 762 763 /* end of sequence ? */ 764 if (*data == 0) 765 break; 766 } 767 768 /* goto next sequence or end of block byte */ 769 if (--tmp < 0) 770 return NULL; 771 772 data++; 773 774 /* update amount of data left for the sequence block to be parsed */ 775 *size = tmp; 776 return data; 777 } 778 779 static void 780 parse_mipi(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 781 { 782 struct bdb_mipi_config *start; 783 struct bdb_mipi_sequence *sequence; 784 struct mipi_config *config; 785 struct mipi_pps_data *pps; 786 u8 *data, *seq_data; 787 int i, panel_id, seq_size; 788 u16 block_size; 789 790 /* parse MIPI blocks only if LFP type is MIPI */ 791 if (!dev_priv->vbt.has_mipi) 792 return; 793 794 /* Initialize this to undefined indicating no generic MIPI support */ 795 dev_priv->vbt.dsi.panel_id = MIPI_DSI_UNDEFINED_PANEL_ID; 796 797 /* Block #40 is already parsed and panel_fixed_mode is 798 * stored in dev_priv->lfp_lvds_vbt_mode 799 * resuse this when needed 800 */ 801 802 /* Parse #52 for panel index used from panel_type already 803 * parsed 804 */ 805 start = find_section(bdb, BDB_MIPI_CONFIG); 806 if (!start) { 807 DRM_DEBUG_KMS("No MIPI config BDB found"); 808 return; 809 } 810 811 DRM_DEBUG_DRIVER("Found MIPI Config block, panel index = %d\n", 812 panel_type); 813 814 /* 815 * get hold of the correct configuration block and pps data as per 816 * the panel_type as index 817 */ 818 config = &start->config[panel_type]; 819 pps = &start->pps[panel_type]; 820 821 /* store as of now full data. Trim when we realise all is not needed */ 822 dev_priv->vbt.dsi.config = kmemdup(config, sizeof(struct mipi_config), GFP_KERNEL); 823 if (!dev_priv->vbt.dsi.config) 824 return; 825 826 dev_priv->vbt.dsi.pps = kmemdup(pps, sizeof(struct mipi_pps_data), GFP_KERNEL); 827 if (!dev_priv->vbt.dsi.pps) { 828 kfree(dev_priv->vbt.dsi.config); 829 return; 830 } 831 832 /* We have mandatory mipi config blocks. Initialize as generic panel */ 833 dev_priv->vbt.dsi.panel_id = MIPI_DSI_GENERIC_PANEL_ID; 834 835 /* Check if we have sequence block as well */ 836 sequence = find_section(bdb, BDB_MIPI_SEQUENCE); 837 if (!sequence) { 838 DRM_DEBUG_KMS("No MIPI Sequence found, parsing complete\n"); 839 return; 840 } 841 842 DRM_DEBUG_DRIVER("Found MIPI sequence block\n"); 843 844 block_size = get_blocksize(sequence); 845 846 /* 847 * parse the sequence block for individual sequences 848 */ 849 dev_priv->vbt.dsi.seq_version = sequence->version; 850 851 seq_data = &sequence->data[0]; 852 853 /* 854 * sequence block is variable length and hence we need to parse and 855 * get the sequence data for specific panel id 856 */ 857 for (i = 0; i < MAX_MIPI_CONFIGURATIONS; i++) { 858 panel_id = *seq_data; 859 seq_size = *((u16 *) (seq_data + 1)); 860 if (panel_id == panel_type) 861 break; 862 863 /* skip the sequence including seq header of 3 bytes */ 864 seq_data = seq_data + 3 + seq_size; 865 if ((seq_data - &sequence->data[0]) > block_size) { 866 DRM_ERROR("Sequence start is beyond sequence block size, corrupted sequence block\n"); 867 return; 868 } 869 } 870 871 if (i == MAX_MIPI_CONFIGURATIONS) { 872 DRM_ERROR("Sequence block detected but no valid configuration\n"); 873 return; 874 } 875 876 /* check if found sequence is completely within the sequence block 877 * just being paranoid */ 878 if (seq_size > block_size) { 879 DRM_ERROR("Corrupted sequence/size, bailing out\n"); 880 return; 881 } 882 883 /* skip the panel id(1 byte) and seq size(2 bytes) */ 884 dev_priv->vbt.dsi.data = kmemdup(seq_data + 3, seq_size, GFP_KERNEL); 885 if (!dev_priv->vbt.dsi.data) 886 return; 887 888 /* 889 * loop into the sequence data and split into multiple sequneces 890 * There are only 5 types of sequences as of now 891 */ 892 data = dev_priv->vbt.dsi.data; 893 dev_priv->vbt.dsi.size = seq_size; 894 895 /* two consecutive 0x00 indicate end of all sequences */ 896 while (1) { 897 int seq_id = *data; 898 if (MIPI_SEQ_MAX > seq_id && seq_id > MIPI_SEQ_UNDEFINED) { 899 dev_priv->vbt.dsi.sequence[seq_id] = data; 900 DRM_DEBUG_DRIVER("Found mipi sequence - %d\n", seq_id); 901 } else { 902 DRM_ERROR("undefined sequence\n"); 903 goto err; 904 } 905 906 /* partial parsing to skip elements */ 907 data = goto_next_sequence(data, &seq_size); 908 909 if (data == NULL) { 910 DRM_ERROR("Sequence elements going beyond block itself. Sequence block parsing failed\n"); 911 goto err; 912 } 913 914 if (*data == 0) 915 break; /* end of sequence reached */ 916 } 917 918 DRM_DEBUG_DRIVER("MIPI related vbt parsing complete\n"); 919 return; 920 err: 921 kfree(dev_priv->vbt.dsi.data); 922 dev_priv->vbt.dsi.data = NULL; 923 924 /* error during parsing so set all pointers to null 925 * because of partial parsing */ 926 memset(dev_priv->vbt.dsi.sequence, 0, sizeof(dev_priv->vbt.dsi.sequence)); 927 } 928 929 static void parse_ddi_port(struct drm_i915_private *dev_priv, enum port port, 930 struct bdb_header *bdb) 931 { 932 union child_device_config *it, *child = NULL; 933 struct ddi_vbt_port_info *info = &dev_priv->vbt.ddi_port_info[port]; 934 uint8_t hdmi_level_shift; 935 int i, j; 936 bool is_dvi, is_hdmi, is_dp, is_edp, is_crt; 937 uint8_t aux_channel; 938 /* Each DDI port can have more than one value on the "DVO Port" field, 939 * so look for all the possible values for each port and abort if more 940 * than one is found. */ 941 int dvo_ports[][2] = { 942 {DVO_PORT_HDMIA, DVO_PORT_DPA}, 943 {DVO_PORT_HDMIB, DVO_PORT_DPB}, 944 {DVO_PORT_HDMIC, DVO_PORT_DPC}, 945 {DVO_PORT_HDMID, DVO_PORT_DPD}, 946 {DVO_PORT_CRT, -1 /* Port E can only be DVO_PORT_CRT */ }, 947 }; 948 949 /* Find the child device to use, abort if more than one found. */ 950 for (i = 0; i < dev_priv->vbt.child_dev_num; i++) { 951 it = dev_priv->vbt.child_dev + i; 952 953 for (j = 0; j < 2; j++) { 954 if (dvo_ports[port][j] == -1) 955 break; 956 957 if (it->common.dvo_port == dvo_ports[port][j]) { 958 if (child) { 959 DRM_DEBUG_KMS("More than one child device for port %c in VBT.\n", 960 port_name(port)); 961 return; 962 } 963 child = it; 964 } 965 } 966 } 967 if (!child) 968 return; 969 970 aux_channel = child->raw[25]; 971 972 is_dvi = child->common.device_type & DEVICE_TYPE_TMDS_DVI_SIGNALING; 973 is_dp = child->common.device_type & DEVICE_TYPE_DISPLAYPORT_OUTPUT; 974 is_crt = child->common.device_type & DEVICE_TYPE_ANALOG_OUTPUT; 975 is_hdmi = is_dvi && (child->common.device_type & DEVICE_TYPE_NOT_HDMI_OUTPUT) == 0; 976 is_edp = is_dp && (child->common.device_type & DEVICE_TYPE_INTERNAL_CONNECTOR); 977 978 info->supports_dvi = is_dvi; 979 info->supports_hdmi = is_hdmi; 980 info->supports_dp = is_dp; 981 982 DRM_DEBUG_KMS("Port %c VBT info: DP:%d HDMI:%d DVI:%d EDP:%d CRT:%d\n", 983 port_name(port), is_dp, is_hdmi, is_dvi, is_edp, is_crt); 984 985 if (is_edp && is_dvi) 986 DRM_DEBUG_KMS("Internal DP port %c is TMDS compatible\n", 987 port_name(port)); 988 if (is_crt && port != PORT_E) 989 DRM_DEBUG_KMS("Port %c is analog\n", port_name(port)); 990 if (is_crt && (is_dvi || is_dp)) 991 DRM_DEBUG_KMS("Analog port %c is also DP or TMDS compatible\n", 992 port_name(port)); 993 if (is_dvi && (port == PORT_A || port == PORT_E)) 994 DRM_DEBUG_KMS("Port %c is TMDS compatible\n", port_name(port)); 995 if (!is_dvi && !is_dp && !is_crt) 996 DRM_DEBUG_KMS("Port %c is not DP/TMDS/CRT compatible\n", 997 port_name(port)); 998 if (is_edp && (port == PORT_B || port == PORT_C || port == PORT_E)) 999 DRM_DEBUG_KMS("Port %c is internal DP\n", port_name(port)); 1000 1001 if (is_dvi) { 1002 if (child->common.ddc_pin == 0x05 && port != PORT_B) 1003 DRM_DEBUG_KMS("Unexpected DDC pin for port B\n"); 1004 if (child->common.ddc_pin == 0x04 && port != PORT_C) 1005 DRM_DEBUG_KMS("Unexpected DDC pin for port C\n"); 1006 if (child->common.ddc_pin == 0x06 && port != PORT_D) 1007 DRM_DEBUG_KMS("Unexpected DDC pin for port D\n"); 1008 } 1009 1010 if (is_dp) { 1011 if (aux_channel == 0x40 && port != PORT_A) 1012 DRM_DEBUG_KMS("Unexpected AUX channel for port A\n"); 1013 if (aux_channel == 0x10 && port != PORT_B) 1014 DRM_DEBUG_KMS("Unexpected AUX channel for port B\n"); 1015 if (aux_channel == 0x20 && port != PORT_C) 1016 DRM_DEBUG_KMS("Unexpected AUX channel for port C\n"); 1017 if (aux_channel == 0x30 && port != PORT_D) 1018 DRM_DEBUG_KMS("Unexpected AUX channel for port D\n"); 1019 } 1020 1021 if (bdb->version >= 158) { 1022 /* The VBT HDMI level shift values match the table we have. */ 1023 hdmi_level_shift = child->raw[7] & 0xF; 1024 DRM_DEBUG_KMS("VBT HDMI level shift for port %c: %d\n", 1025 port_name(port), 1026 hdmi_level_shift); 1027 info->hdmi_level_shift = hdmi_level_shift; 1028 } 1029 } 1030 1031 static void parse_ddi_ports(struct drm_i915_private *dev_priv, 1032 struct bdb_header *bdb) 1033 { 1034 struct drm_device *dev = dev_priv->dev; 1035 enum port port; 1036 1037 if (!HAS_DDI(dev)) 1038 return; 1039 1040 if (!dev_priv->vbt.child_dev_num) 1041 return; 1042 1043 if (bdb->version < 155) 1044 return; 1045 1046 for (port = PORT_A; port < I915_MAX_PORTS; port++) 1047 parse_ddi_port(dev_priv, port, bdb); 1048 } 1049 1050 static void 1051 parse_device_mapping(struct drm_i915_private *dev_priv, 1052 struct bdb_header *bdb) 1053 { 1054 struct bdb_general_definitions *p_defs; 1055 union child_device_config *p_child, *child_dev_ptr; 1056 int i, child_device_num, count; 1057 u16 block_size; 1058 1059 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 1060 if (!p_defs) { 1061 DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n"); 1062 return; 1063 } 1064 /* judge whether the size of child device meets the requirements. 1065 * If the child device size obtained from general definition block 1066 * is different with sizeof(struct child_device_config), skip the 1067 * parsing of sdvo device info 1068 */ 1069 if (p_defs->child_dev_size != sizeof(*p_child)) { 1070 /* different child dev size . Ignore it */ 1071 DRM_DEBUG_KMS("different child size is found. Invalid.\n"); 1072 return; 1073 } 1074 /* get the block size of general definitions */ 1075 block_size = get_blocksize(p_defs); 1076 /* get the number of child device */ 1077 child_device_num = (block_size - sizeof(*p_defs)) / 1078 sizeof(*p_child); 1079 count = 0; 1080 /* get the number of child device that is present */ 1081 for (i = 0; i < child_device_num; i++) { 1082 p_child = &(p_defs->devices[i]); 1083 if (!p_child->common.device_type) { 1084 /* skip the device block if device type is invalid */ 1085 continue; 1086 } 1087 count++; 1088 } 1089 if (!count) { 1090 DRM_DEBUG_KMS("no child dev is parsed from VBT\n"); 1091 return; 1092 } 1093 dev_priv->vbt.child_dev = kcalloc(count, sizeof(*p_child), GFP_KERNEL); 1094 if (!dev_priv->vbt.child_dev) { 1095 DRM_DEBUG_KMS("No memory space for child device\n"); 1096 return; 1097 } 1098 1099 dev_priv->vbt.child_dev_num = count; 1100 count = 0; 1101 for (i = 0; i < child_device_num; i++) { 1102 p_child = &(p_defs->devices[i]); 1103 if (!p_child->common.device_type) { 1104 /* skip the device block if device type is invalid */ 1105 continue; 1106 } 1107 1108 if (p_child->common.dvo_port >= DVO_PORT_MIPIA 1109 && p_child->common.dvo_port <= DVO_PORT_MIPID 1110 &&p_child->common.device_type & DEVICE_TYPE_MIPI_OUTPUT) { 1111 DRM_DEBUG_KMS("Found MIPI as LFP\n"); 1112 dev_priv->vbt.has_mipi = 1; 1113 dev_priv->vbt.dsi.port = p_child->common.dvo_port; 1114 } 1115 1116 child_dev_ptr = dev_priv->vbt.child_dev + count; 1117 count++; 1118 memcpy((void *)child_dev_ptr, (void *)p_child, 1119 sizeof(*p_child)); 1120 } 1121 return; 1122 } 1123 1124 static void 1125 init_vbt_defaults(struct drm_i915_private *dev_priv) 1126 { 1127 struct drm_device *dev = dev_priv->dev; 1128 enum port port; 1129 1130 dev_priv->vbt.crt_ddc_pin = GMBUS_PORT_VGADDC; 1131 1132 /* Default to having backlight */ 1133 dev_priv->vbt.backlight.present = true; 1134 1135 /* LFP panel data */ 1136 dev_priv->vbt.lvds_dither = 1; 1137 dev_priv->vbt.lvds_vbt = 0; 1138 1139 /* SDVO panel data */ 1140 dev_priv->vbt.sdvo_lvds_vbt_mode = NULL; 1141 1142 /* general features */ 1143 dev_priv->vbt.int_tv_support = 1; 1144 dev_priv->vbt.int_crt_support = 1; 1145 1146 /* Default to using SSC */ 1147 dev_priv->vbt.lvds_use_ssc = 1; 1148 /* 1149 * Core/SandyBridge/IvyBridge use alternative (120MHz) reference 1150 * clock for LVDS. 1151 */ 1152 dev_priv->vbt.lvds_ssc_freq = intel_bios_ssc_frequency(dev, 1153 !HAS_PCH_SPLIT(dev)); 1154 DRM_DEBUG_KMS("Set default to SSC at %d kHz\n", dev_priv->vbt.lvds_ssc_freq); 1155 1156 for (port = PORT_A; port < I915_MAX_PORTS; port++) { 1157 struct ddi_vbt_port_info *info = 1158 &dev_priv->vbt.ddi_port_info[port]; 1159 1160 info->hdmi_level_shift = HDMI_LEVEL_SHIFT_UNKNOWN; 1161 1162 info->supports_dvi = (port != PORT_A && port != PORT_E); 1163 info->supports_hdmi = info->supports_dvi; 1164 info->supports_dp = (port != PORT_E); 1165 } 1166 } 1167 1168 static int intel_no_opregion_vbt_callback(const struct dmi_system_id *id) 1169 { 1170 DRM_DEBUG_KMS("Falling back to manually reading VBT from " 1171 "VBIOS ROM for %s\n", 1172 id->ident); 1173 return 1; 1174 } 1175 1176 static const struct dmi_system_id intel_no_opregion_vbt[] = { 1177 { 1178 .callback = intel_no_opregion_vbt_callback, 1179 .ident = "ThinkCentre A57", 1180 .matches = { 1181 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 1182 DMI_MATCH(DMI_PRODUCT_NAME, "97027RG"), 1183 }, 1184 }, 1185 { } 1186 }; 1187 1188 static struct bdb_header *validate_vbt(char *base, size_t size, 1189 struct vbt_header *vbt, 1190 const char *source) 1191 { 1192 size_t offset; 1193 struct bdb_header *bdb; 1194 1195 if (vbt == NULL) { 1196 DRM_DEBUG_DRIVER("VBT signature missing\n"); 1197 return NULL; 1198 } 1199 1200 offset = (char *)vbt - base; 1201 if (offset + sizeof(struct vbt_header) > size) { 1202 DRM_DEBUG_DRIVER("VBT header incomplete\n"); 1203 return NULL; 1204 } 1205 1206 if (memcmp(vbt->signature, "$VBT", 4)) { 1207 DRM_DEBUG_DRIVER("VBT invalid signature\n"); 1208 return NULL; 1209 } 1210 1211 offset += vbt->bdb_offset; 1212 if (offset + sizeof(struct bdb_header) > size) { 1213 DRM_DEBUG_DRIVER("BDB header incomplete\n"); 1214 return NULL; 1215 } 1216 1217 bdb = (struct bdb_header *)(base + offset); 1218 if (offset + bdb->bdb_size > size) { 1219 DRM_DEBUG_DRIVER("BDB incomplete\n"); 1220 return NULL; 1221 } 1222 1223 DRM_DEBUG_KMS("Using VBT from %s: %20s\n", 1224 source, vbt->signature); 1225 return bdb; 1226 } 1227 1228 /** 1229 * intel_parse_bios - find VBT and initialize settings from the BIOS 1230 * @dev: DRM device 1231 * 1232 * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers 1233 * to appropriate values. 1234 * 1235 * Returns 0 on success, nonzero on failure. 1236 */ 1237 int 1238 intel_parse_bios(struct drm_device *dev) 1239 { 1240 struct drm_i915_private *dev_priv = dev->dev_private; 1241 #if 0 1242 struct pci_dev *pdev = dev->pdev; 1243 #endif 1244 struct bdb_header *bdb = NULL; 1245 u8 __iomem *bios = NULL; 1246 1247 if (HAS_PCH_NOP(dev)) 1248 return -ENODEV; 1249 1250 init_vbt_defaults(dev_priv); 1251 1252 /* XXX Should this validation be moved to intel_opregion.c? */ 1253 if (!dmi_check_system(intel_no_opregion_vbt) && dev_priv->opregion.vbt) 1254 bdb = validate_vbt((char *)dev_priv->opregion.header, OPREGION_SIZE, 1255 (struct vbt_header *)dev_priv->opregion.vbt, 1256 "OpRegion"); 1257 1258 if (bdb == NULL) { 1259 size_t i, size; 1260 1261 #if 0 1262 bios = pci_map_rom(pdev, &size); 1263 if (!bios) 1264 #endif 1265 return -1; 1266 1267 /* Scour memory looking for the VBT signature */ 1268 for (i = 0; i + 4 < size; i++) { 1269 if (memcmp(bios + i, "$VBT", 4) == 0) { 1270 bdb = validate_vbt(bios, size, 1271 (struct vbt_header *)(bios + i), 1272 "PCI ROM"); 1273 break; 1274 } 1275 } 1276 1277 if (!bdb) { 1278 #if 0 1279 pci_unmap_rom(pdev, bios); 1280 #endif 1281 return -1; 1282 } 1283 } 1284 1285 /* Grab useful general definitions */ 1286 parse_general_features(dev_priv, bdb); 1287 parse_general_definitions(dev_priv, bdb); 1288 parse_lfp_panel_data(dev_priv, bdb); 1289 parse_lfp_backlight(dev_priv, bdb); 1290 parse_sdvo_panel_data(dev_priv, bdb); 1291 parse_sdvo_device_mapping(dev_priv, bdb); 1292 parse_device_mapping(dev_priv, bdb); 1293 parse_driver_features(dev_priv, bdb); 1294 parse_edp(dev_priv, bdb); 1295 parse_psr(dev_priv, bdb); 1296 parse_mipi(dev_priv, bdb); 1297 parse_ddi_ports(dev_priv, bdb); 1298 1299 #if 0 1300 if (bios) 1301 pci_unmap_rom(pdev, bios); 1302 #endif 1303 1304 return 0; 1305 } 1306 1307 /* Ensure that vital registers have been initialised, even if the BIOS 1308 * is absent or just failing to do its job. 1309 */ 1310 void intel_setup_bios(struct drm_device *dev) 1311 { 1312 struct drm_i915_private *dev_priv = dev->dev_private; 1313 1314 /* Set the Panel Power On/Off timings if uninitialized. */ 1315 if (!HAS_PCH_SPLIT(dev) && 1316 I915_READ(PP_ON_DELAYS) == 0 && I915_READ(PP_OFF_DELAYS) == 0) { 1317 /* Set T2 to 40ms and T5 to 200ms */ 1318 I915_WRITE(PP_ON_DELAYS, 0x019007d0); 1319 1320 /* Set T3 to 35ms and Tx to 200ms */ 1321 I915_WRITE(PP_OFF_DELAYS, 0x015e07d0); 1322 } 1323 } 1324