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