1/* 2 * Copyright © 2006 Intel Corporation 3 * 4 * Permission is hereby granted, free of charge, to any person obtaining a 5 * copy of this software and associated documentation files (the "Software"), 6 * to deal in the Software without restriction, including without limitation 7 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 8 * and/or sell copies of the Software, and to permit persons to whom the 9 * Software is furnished to do so, subject to the following conditions: 10 * 11 * The above copyright notice and this permission notice (including the next 12 * paragraph) shall be included in all copies or substantial portions of the 13 * Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 * SOFTWARE. 22 * 23 * Authors: 24 * Eric Anholt <eric@anholt.net> 25 * 26 */ 27 28#include <sys/cdefs.h> 29__FBSDID("$FreeBSD$"); 30 31#include <dev/drm2/drmP.h> 32#include <dev/drm2/drm_dp_helper.h> 33#include <dev/drm2/i915/i915_drm.h> 34#include <dev/drm2/i915/i915_drv.h> 35#include <dev/drm2/i915/intel_bios.h> 36 37#define SLAVE_ADDR1 0x70 38#define SLAVE_ADDR2 0x72 39 40static int panel_type; 41 42static void * 43find_section(struct bdb_header *bdb, int section_id) 44{ 45 u8 *base = (u8 *)bdb; 46 int index = 0; 47 u16 total, current_size; 48 u8 current_id; 49 50 /* skip to first section */ 51 index += bdb->header_size; 52 total = bdb->bdb_size; 53 54 /* walk the sections looking for section_id */ 55 while (index < total) { 56 current_id = *(base + index); 57 index++; 58 current_size = *((u16 *)(base + index)); 59 index += 2; 60 if (current_id == section_id) 61 return base + index; 62 index += current_size; 63 } 64 65 return NULL; 66} 67 68static u16 69get_blocksize(void *p) 70{ 71 u16 *block_ptr, block_size; 72 73 block_ptr = (u16 *)((char *)p - 2); 74 block_size = *block_ptr; 75 return block_size; 76} 77 78static void 79fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode, 80 const struct lvds_dvo_timing *dvo_timing) 81{ 82 panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) | 83 dvo_timing->hactive_lo; 84 panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay + 85 ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo); 86 panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start + 87 dvo_timing->hsync_pulse_width; 88 panel_fixed_mode->htotal = panel_fixed_mode->hdisplay + 89 ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo); 90 91 panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) | 92 dvo_timing->vactive_lo; 93 panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay + 94 dvo_timing->vsync_off; 95 panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start + 96 dvo_timing->vsync_pulse_width; 97 panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay + 98 ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo); 99 panel_fixed_mode->clock = dvo_timing->clock * 10; 100 panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED; 101 102 if (dvo_timing->hsync_positive) 103 panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC; 104 else 105 panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC; 106 107 if (dvo_timing->vsync_positive) 108 panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC; 109 else 110 panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC; 111 112 /* Some VBTs have bogus h/vtotal values */ 113 if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal) 114 panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1; 115 if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal) 116 panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1; 117 118 drm_mode_set_name(panel_fixed_mode); 119} 120 121static bool 122lvds_dvo_timing_equal_size(const struct lvds_dvo_timing *a, 123 const struct lvds_dvo_timing *b) 124{ 125 if (a->hactive_hi != b->hactive_hi || 126 a->hactive_lo != b->hactive_lo) 127 return false; 128 129 if (a->hsync_off_hi != b->hsync_off_hi || 130 a->hsync_off_lo != b->hsync_off_lo) 131 return false; 132 133 if (a->hsync_pulse_width != b->hsync_pulse_width) 134 return false; 135 136 if (a->hblank_hi != b->hblank_hi || 137 a->hblank_lo != b->hblank_lo) 138 return false; 139 140 if (a->vactive_hi != b->vactive_hi || 141 a->vactive_lo != b->vactive_lo) 142 return false; 143 144 if (a->vsync_off != b->vsync_off) 145 return false; 146 147 if (a->vsync_pulse_width != b->vsync_pulse_width) 148 return false; 149 150 if (a->vblank_hi != b->vblank_hi || 151 a->vblank_lo != b->vblank_lo) 152 return false; 153 154 return true; 155} 156 157static const struct lvds_dvo_timing * 158get_lvds_dvo_timing(const struct bdb_lvds_lfp_data *lvds_lfp_data, 159 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs, 160 int index) 161{ 162 /* 163 * the size of fp_timing varies on the different platform. 164 * So calculate the DVO timing relative offset in LVDS data 165 * entry to get the DVO timing entry 166 */ 167 168 int lfp_data_size = 169 lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset - 170 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset; 171 int dvo_timing_offset = 172 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset - 173 lvds_lfp_data_ptrs->ptr[0].fp_timing_offset; 174 const char *entry = (const char *)lvds_lfp_data->data + lfp_data_size * index; 175 176 return (const struct lvds_dvo_timing *)(entry + dvo_timing_offset); 177} 178 179/* get lvds_fp_timing entry 180 * this function may return NULL if the corresponding entry is invalid 181 */ 182static const struct lvds_fp_timing * 183get_lvds_fp_timing(const struct bdb_header *bdb, 184 const struct bdb_lvds_lfp_data *data, 185 const struct bdb_lvds_lfp_data_ptrs *ptrs, 186 int index) 187{ 188 size_t data_ofs = (const u8 *)data - (const u8 *)bdb; 189 u16 data_size = ((const u16 *)data)[-1]; /* stored in header */ 190 size_t ofs; 191 192 if (index >= ARRAY_SIZE(ptrs->ptr)) 193 return NULL; 194 ofs = ptrs->ptr[index].fp_timing_offset; 195 if (ofs < data_ofs || 196 ofs + sizeof(struct lvds_fp_timing) > data_ofs + data_size) 197 return NULL; 198 return (const struct lvds_fp_timing *)((const u8 *)bdb + ofs); 199} 200 201/* Try to find integrated panel data */ 202static void 203parse_lfp_panel_data(struct drm_i915_private *dev_priv, 204 struct bdb_header *bdb) 205{ 206 const struct bdb_lvds_options *lvds_options; 207 const struct bdb_lvds_lfp_data *lvds_lfp_data; 208 const struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs; 209 const struct lvds_dvo_timing *panel_dvo_timing; 210 const struct lvds_fp_timing *fp_timing; 211 struct drm_display_mode *panel_fixed_mode; 212 int i, downclock; 213 214 lvds_options = find_section(bdb, BDB_LVDS_OPTIONS); 215 if (!lvds_options) 216 return; 217 218 dev_priv->lvds_dither = lvds_options->pixel_dither; 219 if (lvds_options->panel_type == 0xff) 220 return; 221 222 panel_type = lvds_options->panel_type; 223 224 lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA); 225 if (!lvds_lfp_data) 226 return; 227 228 lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS); 229 if (!lvds_lfp_data_ptrs) 230 return; 231 232 dev_priv->lvds_vbt = 1; 233 234 panel_dvo_timing = get_lvds_dvo_timing(lvds_lfp_data, 235 lvds_lfp_data_ptrs, 236 lvds_options->panel_type); 237 238 panel_fixed_mode = malloc(sizeof(*panel_fixed_mode), DRM_MEM_KMS, M_WAITOK | M_ZERO); 239 if (!panel_fixed_mode) 240 return; 241 242 fill_detail_timing_data(panel_fixed_mode, panel_dvo_timing); 243 244 dev_priv->lfp_lvds_vbt_mode = panel_fixed_mode; 245 246 DRM_DEBUG_KMS("Found panel mode in BIOS VBT tables:\n"); 247 drm_mode_debug_printmodeline(panel_fixed_mode); 248 249 /* 250 * Iterate over the LVDS panel timing info to find the lowest clock 251 * for the native resolution. 252 */ 253 downclock = panel_dvo_timing->clock; 254 for (i = 0; i < 16; i++) { 255 const struct lvds_dvo_timing *dvo_timing; 256 257 dvo_timing = get_lvds_dvo_timing(lvds_lfp_data, 258 lvds_lfp_data_ptrs, 259 i); 260 if (lvds_dvo_timing_equal_size(dvo_timing, panel_dvo_timing) && 261 dvo_timing->clock < downclock) 262 downclock = dvo_timing->clock; 263 } 264 265 if (downclock < panel_dvo_timing->clock && i915_lvds_downclock) { 266 dev_priv->lvds_downclock_avail = 1; 267 dev_priv->lvds_downclock = downclock * 10; 268 DRM_DEBUG_KMS("LVDS downclock is found in VBT. " 269 "Normal Clock %dKHz, downclock %dKHz\n", 270 panel_fixed_mode->clock, 10*downclock); 271 } 272 273 fp_timing = get_lvds_fp_timing(bdb, lvds_lfp_data, 274 lvds_lfp_data_ptrs, 275 lvds_options->panel_type); 276 if (fp_timing) { 277 /* check the resolution, just to be sure */ 278 if (fp_timing->x_res == panel_fixed_mode->hdisplay && 279 fp_timing->y_res == panel_fixed_mode->vdisplay) { 280 dev_priv->bios_lvds_val = fp_timing->lvds_reg_val; 281 DRM_DEBUG_KMS("VBT initial LVDS value %x\n", 282 dev_priv->bios_lvds_val); 283 } 284 } 285} 286 287/* Try to find sdvo panel data */ 288static void 289parse_sdvo_panel_data(struct drm_i915_private *dev_priv, 290 struct bdb_header *bdb) 291{ 292 struct lvds_dvo_timing *dvo_timing; 293 struct drm_display_mode *panel_fixed_mode; 294 int index; 295 296 index = i915_vbt_sdvo_panel_type; 297 if (index == -2) { 298 DRM_DEBUG_KMS("Ignore SDVO panel mode from BIOS VBT tables.\n"); 299 return; 300 } 301 302 if (index == -1) { 303 struct bdb_sdvo_lvds_options *sdvo_lvds_options; 304 305 sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS); 306 if (!sdvo_lvds_options) 307 return; 308 309 index = sdvo_lvds_options->panel_type; 310 } 311 312 dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS); 313 if (!dvo_timing) 314 return; 315 316 panel_fixed_mode = malloc(sizeof(*panel_fixed_mode), DRM_MEM_KMS, M_WAITOK | M_ZERO); 317 if (!panel_fixed_mode) 318 return; 319 320 fill_detail_timing_data(panel_fixed_mode, dvo_timing + index); 321 322 dev_priv->sdvo_lvds_vbt_mode = panel_fixed_mode; 323 324 DRM_DEBUG_KMS("Found SDVO panel mode in BIOS VBT tables:\n"); 325 drm_mode_debug_printmodeline(panel_fixed_mode); 326} 327 328static int intel_bios_ssc_frequency(struct drm_device *dev, 329 bool alternate) 330{ 331 switch (INTEL_INFO(dev)->gen) { 332 case 2: 333 return alternate ? 66 : 48; 334 case 3: 335 case 4: 336 return alternate ? 100 : 96; 337 default: 338 return alternate ? 100 : 120; 339 } 340} 341 342static void 343parse_general_features(struct drm_i915_private *dev_priv, 344 struct bdb_header *bdb) 345{ 346 struct drm_device *dev = dev_priv->dev; 347 struct bdb_general_features *general; 348 349 general = find_section(bdb, BDB_GENERAL_FEATURES); 350 if (general) { 351 dev_priv->int_tv_support = general->int_tv_support; 352 dev_priv->int_crt_support = general->int_crt_support; 353 dev_priv->lvds_use_ssc = general->enable_ssc; 354 dev_priv->lvds_ssc_freq = 355 intel_bios_ssc_frequency(dev, general->ssc_freq); 356 dev_priv->display_clock_mode = general->display_clock_mode; 357 dev_priv->fdi_rx_polarity_inverted = general->fdi_rx_polarity_inverted; 358 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", 359 dev_priv->int_tv_support, 360 dev_priv->int_crt_support, 361 dev_priv->lvds_use_ssc, 362 dev_priv->lvds_ssc_freq, 363 dev_priv->display_clock_mode, 364 dev_priv->fdi_rx_polarity_inverted); 365 } 366} 367 368static void 369parse_general_definitions(struct drm_i915_private *dev_priv, 370 struct bdb_header *bdb) 371{ 372 struct bdb_general_definitions *general; 373 374 general = find_section(bdb, BDB_GENERAL_DEFINITIONS); 375 if (general) { 376 u16 block_size = get_blocksize(general); 377 if (block_size >= sizeof(*general)) { 378 int bus_pin = general->crt_ddc_gmbus_pin; 379 DRM_DEBUG_KMS("crt_ddc_bus_pin: %d\n", bus_pin); 380 if (intel_gmbus_is_port_valid(bus_pin)) 381 dev_priv->crt_ddc_pin = bus_pin; 382 } else { 383 DRM_DEBUG_KMS("BDB_GD too small (%d). Invalid.\n", 384 block_size); 385 } 386 } 387} 388 389static void 390parse_sdvo_device_mapping(struct drm_i915_private *dev_priv, 391 struct bdb_header *bdb) 392{ 393 struct sdvo_device_mapping *p_mapping; 394 struct bdb_general_definitions *p_defs; 395 struct child_device_config *p_child; 396 int i, child_device_num, count; 397 u16 block_size; 398 399 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 400 if (!p_defs) { 401 DRM_DEBUG_KMS("No general definition block is found, unable to construct sdvo mapping.\n"); 402 return; 403 } 404 /* judge whether the size of child device meets the requirements. 405 * If the child device size obtained from general definition block 406 * is different with sizeof(struct child_device_config), skip the 407 * parsing of sdvo device info 408 */ 409 if (p_defs->child_dev_size != sizeof(*p_child)) { 410 /* different child dev size . Ignore it */ 411 DRM_DEBUG_KMS("different child size is found. Invalid.\n"); 412 return; 413 } 414 /* get the block size of general definitions */ 415 block_size = get_blocksize(p_defs); 416 /* get the number of child device */ 417 child_device_num = (block_size - sizeof(*p_defs)) / 418 sizeof(*p_child); 419 count = 0; 420 for (i = 0; i < child_device_num; i++) { 421 p_child = &(p_defs->devices[i]); 422 if (!p_child->device_type) { 423 /* skip the device block if device type is invalid */ 424 continue; 425 } 426 if (p_child->slave_addr != SLAVE_ADDR1 && 427 p_child->slave_addr != SLAVE_ADDR2) { 428 /* 429 * If the slave address is neither 0x70 nor 0x72, 430 * it is not a SDVO device. Skip it. 431 */ 432 continue; 433 } 434 if (p_child->dvo_port != DEVICE_PORT_DVOB && 435 p_child->dvo_port != DEVICE_PORT_DVOC) { 436 /* skip the incorrect SDVO port */ 437 DRM_DEBUG_KMS("Incorrect SDVO port. Skip it\n"); 438 continue; 439 } 440 DRM_DEBUG_KMS("the SDVO device with slave addr %2x is found on" 441 " %s port\n", 442 p_child->slave_addr, 443 (p_child->dvo_port == DEVICE_PORT_DVOB) ? 444 "SDVOB" : "SDVOC"); 445 p_mapping = &(dev_priv->sdvo_mappings[p_child->dvo_port - 1]); 446 if (!p_mapping->initialized) { 447 p_mapping->dvo_port = p_child->dvo_port; 448 p_mapping->slave_addr = p_child->slave_addr; 449 p_mapping->dvo_wiring = p_child->dvo_wiring; 450 p_mapping->ddc_pin = p_child->ddc_pin; 451 p_mapping->i2c_pin = p_child->i2c_pin; 452 p_mapping->initialized = 1; 453 DRM_DEBUG_KMS("SDVO device: dvo=%x, addr=%x, wiring=%d, ddc_pin=%d, i2c_pin=%d\n", 454 p_mapping->dvo_port, 455 p_mapping->slave_addr, 456 p_mapping->dvo_wiring, 457 p_mapping->ddc_pin, 458 p_mapping->i2c_pin); 459 } else { 460 DRM_DEBUG_KMS("Maybe one SDVO port is shared by " 461 "two SDVO device.\n"); 462 } 463 if (p_child->slave2_addr) { 464 /* Maybe this is a SDVO device with multiple inputs */ 465 /* And the mapping info is not added */ 466 DRM_DEBUG_KMS("there exists the slave2_addr. Maybe this" 467 " is a SDVO device with multiple inputs.\n"); 468 } 469 count++; 470 } 471 472 if (!count) { 473 /* No SDVO device info is found */ 474 DRM_DEBUG_KMS("No SDVO device info is found in VBT\n"); 475 } 476 return; 477} 478 479static void 480parse_driver_features(struct drm_i915_private *dev_priv, 481 struct bdb_header *bdb) 482{ 483 struct drm_device *dev = dev_priv->dev; 484 struct bdb_driver_features *driver; 485 486 driver = find_section(bdb, BDB_DRIVER_FEATURES); 487 if (!driver) 488 return; 489 490 if (SUPPORTS_EDP(dev) && 491 driver->lvds_config == BDB_DRIVER_FEATURE_EDP) 492 dev_priv->edp.support = 1; 493 494 if (driver->dual_frequency) 495 dev_priv->render_reclock_avail = true; 496} 497 498static void 499parse_edp(struct drm_i915_private *dev_priv, struct bdb_header *bdb) 500{ 501 struct bdb_edp *edp; 502 struct edp_power_seq *edp_pps; 503 struct edp_link_params *edp_link_params; 504 505 edp = find_section(bdb, BDB_EDP); 506 if (!edp) { 507 if (SUPPORTS_EDP(dev_priv->dev) && dev_priv->edp.support) 508 DRM_DEBUG_KMS("No eDP BDB found but eDP panel supported.\n"); 509 return; 510 } 511 512 switch ((edp->color_depth >> (panel_type * 2)) & 3) { 513 case EDP_18BPP: 514 dev_priv->edp.bpp = 18; 515 break; 516 case EDP_24BPP: 517 dev_priv->edp.bpp = 24; 518 break; 519 case EDP_30BPP: 520 dev_priv->edp.bpp = 30; 521 break; 522 } 523 524 /* Get the eDP sequencing and link info */ 525 edp_pps = &edp->power_seqs[panel_type]; 526 edp_link_params = &edp->link_params[panel_type]; 527 528 dev_priv->edp.pps = *edp_pps; 529 530 dev_priv->edp.rate = edp_link_params->rate ? DP_LINK_BW_2_7 : 531 DP_LINK_BW_1_62; 532 switch (edp_link_params->lanes) { 533 case 0: 534 dev_priv->edp.lanes = 1; 535 break; 536 case 1: 537 dev_priv->edp.lanes = 2; 538 break; 539 case 3: 540 default: 541 dev_priv->edp.lanes = 4; 542 break; 543 } 544 switch (edp_link_params->preemphasis) { 545 case 0: 546 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_0; 547 break; 548 case 1: 549 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_3_5; 550 break; 551 case 2: 552 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_6; 553 break; 554 case 3: 555 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_9_5; 556 break; 557 } 558 switch (edp_link_params->vswing) { 559 case 0: 560 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_400; 561 break; 562 case 1: 563 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_600; 564 break; 565 case 2: 566 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_800; 567 break; 568 case 3: 569 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_1200; 570 break; 571 } 572} 573 574static void 575parse_device_mapping(struct drm_i915_private *dev_priv, 576 struct bdb_header *bdb) 577{ 578 struct bdb_general_definitions *p_defs; 579 struct child_device_config *p_child, *child_dev_ptr; 580 int i, child_device_num, count; 581 u16 block_size; 582 583 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); 584 if (!p_defs) { 585 DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n"); 586 return; 587 } 588 /* judge whether the size of child device meets the requirements. 589 * If the child device size obtained from general definition block 590 * is different with sizeof(struct child_device_config), skip the 591 * parsing of sdvo device info 592 */ 593 if (p_defs->child_dev_size != sizeof(*p_child)) { 594 /* different child dev size . Ignore it */ 595 DRM_DEBUG_KMS("different child size is found. Invalid.\n"); 596 return; 597 } 598 /* get the block size of general definitions */ 599 block_size = get_blocksize(p_defs); 600 /* get the number of child device */ 601 child_device_num = (block_size - sizeof(*p_defs)) / 602 sizeof(*p_child); 603 count = 0; 604 /* get the number of child device that is present */ 605 for (i = 0; i < child_device_num; i++) { 606 p_child = &(p_defs->devices[i]); 607 if (!p_child->device_type) { 608 /* skip the device block if device type is invalid */ 609 continue; 610 } 611 count++; 612 } 613 if (!count) { 614 DRM_DEBUG_KMS("no child dev is parsed from VBT\n"); 615 return; 616 } 617 dev_priv->child_dev = malloc(count * sizeof(*p_child), DRM_MEM_KMS, M_WAITOK | M_ZERO); 618 if (!dev_priv->child_dev) { 619 DRM_DEBUG_KMS("No memory space for child device\n"); 620 return; 621 } 622 623 dev_priv->child_dev_num = count; 624 count = 0; 625 for (i = 0; i < child_device_num; i++) { 626 p_child = &(p_defs->devices[i]); 627 if (!p_child->device_type) { 628 /* skip the device block if device type is invalid */ 629 continue; 630 } 631 child_dev_ptr = dev_priv->child_dev + count; 632 count++; 633 memcpy((void *)child_dev_ptr, (void *)p_child, 634 sizeof(*p_child)); 635 } 636 return; 637} 638 639static void 640init_vbt_defaults(struct drm_i915_private *dev_priv) 641{ 642 struct drm_device *dev = dev_priv->dev; 643 644 dev_priv->crt_ddc_pin = GMBUS_PORT_VGADDC; 645 646 /* LFP panel data */ 647 dev_priv->lvds_dither = 1; 648 dev_priv->lvds_vbt = 0; 649 650 /* SDVO panel data */ 651 dev_priv->sdvo_lvds_vbt_mode = NULL; 652 653 /* general features */ 654 dev_priv->int_tv_support = 1; 655 dev_priv->int_crt_support = 1; 656 657 /* Default to using SSC */ 658 dev_priv->lvds_use_ssc = 1; 659 dev_priv->lvds_ssc_freq = intel_bios_ssc_frequency(dev, 1); 660 DRM_DEBUG_KMS("Set default to SSC at %dMHz\n", dev_priv->lvds_ssc_freq); 661} 662 663static int __init intel_no_opregion_vbt_callback(const struct dmi_system_id *id) 664{ 665 DRM_DEBUG_KMS("Falling back to manually reading VBT from " 666 "VBIOS ROM for %s\n", 667 id->ident); 668 return 1; 669} 670 671static const struct dmi_system_id intel_no_opregion_vbt[] = { 672 { 673 .callback = intel_no_opregion_vbt_callback, 674 .ident = "ThinkCentre A57", 675 .matches = { 676 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 677 DMI_MATCH(DMI_PRODUCT_NAME, "97027RG"), 678 }, 679 }, 680 { } 681}; 682 683/** 684 * intel_parse_bios - find VBT and initialize settings from the BIOS 685 * @dev: DRM device 686 * 687 * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers 688 * to appropriate values. 689 * 690 * Returns 0 on success, nonzero on failure. 691 */ 692int 693intel_parse_bios(struct drm_device *dev) 694{ 695 struct drm_i915_private *dev_priv = dev->dev_private; 696 device_t vga_dev = device_get_parent(dev->dev);; 697 struct bdb_header *bdb = NULL; 698 u8 __iomem *bios = NULL; 699 700 init_vbt_defaults(dev_priv); 701 702 /* XXX Should this validation be moved to intel_opregion.c? */ 703 if (!dmi_check_system(intel_no_opregion_vbt) && dev_priv->opregion.vbt) { 704 struct vbt_header *vbt = dev_priv->opregion.vbt; 705 if (memcmp(vbt->signature, "$VBT", 4) == 0) { 706 DRM_DEBUG_KMS("Using VBT from OpRegion: %20s\n", 707 vbt->signature); 708 bdb = (struct bdb_header *)((char *)vbt + vbt->bdb_offset); 709 } else 710 dev_priv->opregion.vbt = NULL; 711 } 712 713 if (bdb == NULL) { 714 struct vbt_header *vbt = NULL; 715 size_t size; 716 int i; 717 718 bios = vga_pci_map_bios(vga_dev, &size); 719 if (!bios) 720 return -1; 721 722 /* Scour memory looking for the VBT signature */ 723 for (i = 0; i + 4 < size; i++) { 724 if (!memcmp(bios + i, "$VBT", 4)) { 725 vbt = (struct vbt_header *)(bios + i); 726 break; 727 } 728 } 729 730 if (!vbt) { 731 DRM_DEBUG_DRIVER("VBT signature missing\n"); 732 vga_pci_unmap_bios(vga_dev, bios); 733 return -1; 734 } 735 736 bdb = (struct bdb_header *)(bios + i + vbt->bdb_offset); 737 } 738 739 /* Grab useful general definitions */ 740 parse_general_features(dev_priv, bdb); 741 parse_general_definitions(dev_priv, bdb); 742 parse_lfp_panel_data(dev_priv, bdb); 743 parse_sdvo_panel_data(dev_priv, bdb); 744 parse_sdvo_device_mapping(dev_priv, bdb); 745 parse_device_mapping(dev_priv, bdb); 746 parse_driver_features(dev_priv, bdb); 747 parse_edp(dev_priv, bdb); 748 749 if (bios) 750 vga_pci_unmap_bios(vga_dev, bios); 751 752 return 0; 753} 754 755/* 756 * NOTE Linux<->FreeBSD: 757 * Apparently, Linux doesn't free those pointers. 758 * TODO: Report that upstream. 759 */ 760void 761intel_free_parsed_bios_data(struct drm_device *dev) 762{ 763 struct drm_i915_private *dev_priv = dev->dev_private; 764 765 free(dev_priv->lfp_lvds_vbt_mode, DRM_MEM_KMS); 766 free(dev_priv->sdvo_lvds_vbt_mode, DRM_MEM_KMS); 767 free(dev_priv->child_dev, DRM_MEM_KMS); 768 769 dev_priv->lfp_lvds_vbt_mode = NULL; 770 dev_priv->sdvo_lvds_vbt_mode = NULL; 771 dev_priv->child_dev = NULL; 772} 773 774/* Ensure that vital registers have been initialised, even if the BIOS 775 * is absent or just failing to do its job. 776 */ 777void intel_setup_bios(struct drm_device *dev) 778{ 779 struct drm_i915_private *dev_priv = dev->dev_private; 780 781 /* Set the Panel Power On/Off timings if uninitialized. */ 782 if (!HAS_PCH_SPLIT(dev) && 783 I915_READ(PP_ON_DELAYS) == 0 && I915_READ(PP_OFF_DELAYS) == 0) { 784 /* Set T2 to 40ms and T5 to 200ms */ 785 I915_WRITE(PP_ON_DELAYS, 0x019007d0); 786 787 /* Set T3 to 35ms and Tx to 200ms */ 788 I915_WRITE(PP_OFF_DELAYS, 0x015e07d0); 789 } 790} 791