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 <drm/drm_dp_helper.h>
28 #include "drmP.h"
29 #include "drm.h"
30 #include "i915_drm.h"
31 #include "i915_drv.h"
32 #include "intel_bios.h"
33
34 #define SLAVE_ADDR1 0x70
35 #define SLAVE_ADDR2 0x72
36
37 static int panel_type;
38
39 static void *
find_section(struct bdb_header * bdb,int section_id)40 find_section(struct bdb_header *bdb, int section_id)
41 {
42 u8 *base = (u8 *)bdb;
43 int index = 0;
44 u16 total, current_size;
45 u8 current_id;
46
47 /* skip to first section */
48 index += bdb->header_size;
49 total = bdb->bdb_size;
50
51 /* walk the sections looking for section_id */
52 while (index < total) {
53 current_id = *(base + index);
54 index++;
55 current_size = *((u16 *)(base + index));
56 index += 2;
57 if (current_id == section_id)
58 return base + index;
59 index += current_size;
60 }
61
62 return NULL;
63 }
64
65 static u16
get_blocksize(void * p)66 get_blocksize(void *p)
67 {
68 u16 *block_ptr, block_size;
69
70 block_ptr = (u16 *)((char *)p - 2);
71 block_size = *block_ptr;
72 return block_size;
73 }
74
75 static void
fill_detail_timing_data(struct drm_display_mode * panel_fixed_mode,struct lvds_dvo_timing * dvo_timing)76 fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode,
77 struct lvds_dvo_timing *dvo_timing)
78 {
79 panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) |
80 dvo_timing->hactive_lo;
81 panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay +
82 ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo);
83 panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start +
84 dvo_timing->hsync_pulse_width;
85 panel_fixed_mode->htotal = panel_fixed_mode->hdisplay +
86 ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo);
87
88 panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) |
89 dvo_timing->vactive_lo;
90 panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay +
91 dvo_timing->vsync_off;
92 panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start +
93 dvo_timing->vsync_pulse_width;
94 panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay +
95 ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo);
96 panel_fixed_mode->clock = dvo_timing->clock * 10;
97 panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED;
98
99 if (dvo_timing->hsync_positive)
100 panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC;
101 else
102 panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC;
103
104 if (dvo_timing->vsync_positive)
105 panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC;
106 else
107 panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC;
108
109 /* Some VBTs have bogus h/vtotal values */
110 if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal)
111 panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1;
112 if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal)
113 panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1;
114
115 drm_mode_set_name(panel_fixed_mode);
116 }
117
118 /* Try to find integrated panel data */
119 static void
parse_lfp_panel_data(struct drm_i915_private * dev_priv,struct bdb_header * bdb)120 parse_lfp_panel_data(struct drm_i915_private *dev_priv,
121 struct bdb_header *bdb)
122 {
123 struct bdb_lvds_options *lvds_options;
124 struct bdb_lvds_lfp_data *lvds_lfp_data;
125 struct bdb_lvds_lfp_data_ptrs *lvds_lfp_data_ptrs;
126 struct bdb_lvds_lfp_data_entry *entry;
127 struct lvds_dvo_timing *dvo_timing;
128 struct drm_display_mode *panel_fixed_mode;
129 int lfp_data_size, dvo_timing_offset;
130 int i, temp_downclock;
131 struct drm_display_mode *temp_mode;
132
133 lvds_options = find_section(bdb, BDB_LVDS_OPTIONS);
134 if (!lvds_options)
135 return;
136
137 dev_priv->lvds_dither = lvds_options->pixel_dither;
138 if (lvds_options->panel_type == 0xff)
139 return;
140
141 panel_type = lvds_options->panel_type;
142
143 lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA);
144 if (!lvds_lfp_data)
145 return;
146
147 lvds_lfp_data_ptrs = find_section(bdb, BDB_LVDS_LFP_DATA_PTRS);
148 if (!lvds_lfp_data_ptrs)
149 return;
150
151 dev_priv->lvds_vbt = 1;
152
153 lfp_data_size = lvds_lfp_data_ptrs->ptr[1].dvo_timing_offset -
154 lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset;
155 entry = (struct bdb_lvds_lfp_data_entry *)
156 ((uint8_t *)lvds_lfp_data->data + (lfp_data_size *
157 lvds_options->panel_type));
158 dvo_timing_offset = lvds_lfp_data_ptrs->ptr[0].dvo_timing_offset -
159 lvds_lfp_data_ptrs->ptr[0].fp_timing_offset;
160
161 /*
162 * the size of fp_timing varies on the different platform.
163 * So calculate the DVO timing relative offset in LVDS data
164 * entry to get the DVO timing entry
165 */
166 dvo_timing = (struct lvds_dvo_timing *)
167 ((unsigned char *)entry + dvo_timing_offset);
168
169 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
170 if (!panel_fixed_mode)
171 return;
172
173 fill_detail_timing_data(panel_fixed_mode, dvo_timing);
174
175 dev_priv->lfp_lvds_vbt_mode = panel_fixed_mode;
176
177 DRM_DEBUG_KMS("Found panel mode in BIOS VBT tables:\n");
178 drm_mode_debug_printmodeline(panel_fixed_mode);
179
180 temp_mode = kzalloc(sizeof(*temp_mode), GFP_KERNEL);
181 temp_downclock = panel_fixed_mode->clock;
182 /*
183 * enumerate the LVDS panel timing info entry in VBT to check whether
184 * the LVDS downclock is found.
185 */
186 for (i = 0; i < 16; i++) {
187 entry = (struct bdb_lvds_lfp_data_entry *)
188 ((uint8_t *)lvds_lfp_data->data + (lfp_data_size * i));
189 dvo_timing = (struct lvds_dvo_timing *)
190 ((unsigned char *)entry + dvo_timing_offset);
191
192 fill_detail_timing_data(temp_mode, dvo_timing);
193
194 if (temp_mode->hdisplay == panel_fixed_mode->hdisplay &&
195 temp_mode->hsync_start == panel_fixed_mode->hsync_start &&
196 temp_mode->hsync_end == panel_fixed_mode->hsync_end &&
197 temp_mode->htotal == panel_fixed_mode->htotal &&
198 temp_mode->vdisplay == panel_fixed_mode->vdisplay &&
199 temp_mode->vsync_start == panel_fixed_mode->vsync_start &&
200 temp_mode->vsync_end == panel_fixed_mode->vsync_end &&
201 temp_mode->vtotal == panel_fixed_mode->vtotal &&
202 temp_mode->clock < temp_downclock) {
203 /*
204 * downclock is already found. But we expect
205 * to find the lower downclock.
206 */
207 temp_downclock = temp_mode->clock;
208 }
209 /* clear it to zero */
210 memset(temp_mode, 0, sizeof(*temp_mode));
211 }
212 kfree(temp_mode);
213 if (temp_downclock < panel_fixed_mode->clock &&
214 i915_lvds_downclock) {
215 dev_priv->lvds_downclock_avail = 1;
216 dev_priv->lvds_downclock = temp_downclock;
217 DRM_DEBUG_KMS("LVDS downclock is found in VBT. ",
218 "Normal Clock %dKHz, downclock %dKHz\n",
219 temp_downclock, panel_fixed_mode->clock);
220 }
221 return;
222 }
223
224 /* Try to find sdvo panel data */
225 static void
parse_sdvo_panel_data(struct drm_i915_private * dev_priv,struct bdb_header * bdb)226 parse_sdvo_panel_data(struct drm_i915_private *dev_priv,
227 struct bdb_header *bdb)
228 {
229 struct lvds_dvo_timing *dvo_timing;
230 struct drm_display_mode *panel_fixed_mode;
231 int index;
232
233 index = i915_vbt_sdvo_panel_type;
234 if (index == -1) {
235 struct bdb_sdvo_lvds_options *sdvo_lvds_options;
236
237 sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS);
238 if (!sdvo_lvds_options)
239 return;
240
241 index = sdvo_lvds_options->panel_type;
242 }
243
244 dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS);
245 if (!dvo_timing)
246 return;
247
248 panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL);
249 if (!panel_fixed_mode)
250 return;
251
252 fill_detail_timing_data(panel_fixed_mode, dvo_timing + index);
253
254 dev_priv->sdvo_lvds_vbt_mode = panel_fixed_mode;
255
256 DRM_DEBUG_KMS("Found SDVO panel mode in BIOS VBT tables:\n");
257 drm_mode_debug_printmodeline(panel_fixed_mode);
258 }
259
intel_bios_ssc_frequency(struct drm_device * dev,bool alternate)260 static int intel_bios_ssc_frequency(struct drm_device *dev,
261 bool alternate)
262 {
263 switch (INTEL_INFO(dev)->gen) {
264 case 2:
265 return alternate ? 66 : 48;
266 case 3:
267 case 4:
268 return alternate ? 100 : 96;
269 default:
270 return alternate ? 100 : 120;
271 }
272 }
273
274 static void
parse_general_features(struct drm_i915_private * dev_priv,struct bdb_header * bdb)275 parse_general_features(struct drm_i915_private *dev_priv,
276 struct bdb_header *bdb)
277 {
278 struct drm_device *dev = dev_priv->dev;
279 struct bdb_general_features *general;
280
281 general = find_section(bdb, BDB_GENERAL_FEATURES);
282 if (general) {
283 dev_priv->int_tv_support = general->int_tv_support;
284 dev_priv->int_crt_support = general->int_crt_support;
285 dev_priv->lvds_use_ssc = general->enable_ssc;
286 dev_priv->lvds_ssc_freq =
287 intel_bios_ssc_frequency(dev, general->ssc_freq);
288 }
289 }
290
291 static void
parse_general_definitions(struct drm_i915_private * dev_priv,struct bdb_header * bdb)292 parse_general_definitions(struct drm_i915_private *dev_priv,
293 struct bdb_header *bdb)
294 {
295 struct bdb_general_definitions *general;
296
297 general = find_section(bdb, BDB_GENERAL_DEFINITIONS);
298 if (general) {
299 u16 block_size = get_blocksize(general);
300 if (block_size >= sizeof(*general)) {
301 int bus_pin = general->crt_ddc_gmbus_pin;
302 DRM_DEBUG_KMS("crt_ddc_bus_pin: %d\n", bus_pin);
303 if (bus_pin >= 1 && bus_pin <= 6)
304 dev_priv->crt_ddc_pin = bus_pin;
305 } else {
306 DRM_DEBUG_KMS("BDB_GD too small (%d). Invalid.\n",
307 block_size);
308 }
309 }
310 }
311
312 static void
parse_sdvo_device_mapping(struct drm_i915_private * dev_priv,struct bdb_header * bdb)313 parse_sdvo_device_mapping(struct drm_i915_private *dev_priv,
314 struct bdb_header *bdb)
315 {
316 struct sdvo_device_mapping *p_mapping;
317 struct bdb_general_definitions *p_defs;
318 struct child_device_config *p_child;
319 int i, child_device_num, count;
320 u16 block_size;
321
322 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS);
323 if (!p_defs) {
324 DRM_DEBUG_KMS("No general definition block is found, unable to construct sdvo mapping.\n");
325 return;
326 }
327 /* judge whether the size of child device meets the requirements.
328 * If the child device size obtained from general definition block
329 * is different with sizeof(struct child_device_config), skip the
330 * parsing of sdvo device info
331 */
332 if (p_defs->child_dev_size != sizeof(*p_child)) {
333 /* different child dev size . Ignore it */
334 DRM_DEBUG_KMS("different child size is found. Invalid.\n");
335 return;
336 }
337 /* get the block size of general definitions */
338 block_size = get_blocksize(p_defs);
339 /* get the number of child device */
340 child_device_num = (block_size - sizeof(*p_defs)) /
341 sizeof(*p_child);
342 count = 0;
343 for (i = 0; i < child_device_num; i++) {
344 p_child = &(p_defs->devices[i]);
345 if (!p_child->device_type) {
346 /* skip the device block if device type is invalid */
347 continue;
348 }
349 if (p_child->slave_addr != SLAVE_ADDR1 &&
350 p_child->slave_addr != SLAVE_ADDR2) {
351 /*
352 * If the slave address is neither 0x70 nor 0x72,
353 * it is not a SDVO device. Skip it.
354 */
355 continue;
356 }
357 if (p_child->dvo_port != DEVICE_PORT_DVOB &&
358 p_child->dvo_port != DEVICE_PORT_DVOC) {
359 /* skip the incorrect SDVO port */
360 DRM_DEBUG_KMS("Incorrect SDVO port. Skip it \n");
361 continue;
362 }
363 DRM_DEBUG_KMS("the SDVO device with slave addr %2x is found on"
364 " %s port\n",
365 p_child->slave_addr,
366 (p_child->dvo_port == DEVICE_PORT_DVOB) ?
367 "SDVOB" : "SDVOC");
368 p_mapping = &(dev_priv->sdvo_mappings[p_child->dvo_port - 1]);
369 if (!p_mapping->initialized) {
370 p_mapping->dvo_port = p_child->dvo_port;
371 p_mapping->slave_addr = p_child->slave_addr;
372 p_mapping->dvo_wiring = p_child->dvo_wiring;
373 p_mapping->ddc_pin = p_child->ddc_pin;
374 p_mapping->i2c_pin = p_child->i2c_pin;
375 p_mapping->i2c_speed = p_child->i2c_speed;
376 p_mapping->initialized = 1;
377 DRM_DEBUG_KMS("SDVO device: dvo=%x, addr=%x, wiring=%d, ddc_pin=%d, i2c_pin=%d, i2c_speed=%d\n",
378 p_mapping->dvo_port,
379 p_mapping->slave_addr,
380 p_mapping->dvo_wiring,
381 p_mapping->ddc_pin,
382 p_mapping->i2c_pin,
383 p_mapping->i2c_speed);
384 } else {
385 DRM_DEBUG_KMS("Maybe one SDVO port is shared by "
386 "two SDVO device.\n");
387 }
388 if (p_child->slave2_addr) {
389 /* Maybe this is a SDVO device with multiple inputs */
390 /* And the mapping info is not added */
391 DRM_DEBUG_KMS("there exists the slave2_addr. Maybe this"
392 " is a SDVO device with multiple inputs.\n");
393 }
394 count++;
395 }
396
397 if (!count) {
398 /* No SDVO device info is found */
399 DRM_DEBUG_KMS("No SDVO device info is found in VBT\n");
400 }
401 return;
402 }
403
404 static void
parse_driver_features(struct drm_i915_private * dev_priv,struct bdb_header * bdb)405 parse_driver_features(struct drm_i915_private *dev_priv,
406 struct bdb_header *bdb)
407 {
408 struct drm_device *dev = dev_priv->dev;
409 struct bdb_driver_features *driver;
410
411 driver = find_section(bdb, BDB_DRIVER_FEATURES);
412 if (!driver)
413 return;
414
415 if (SUPPORTS_EDP(dev) &&
416 driver->lvds_config == BDB_DRIVER_FEATURE_EDP)
417 dev_priv->edp.support = 1;
418
419 if (driver->dual_frequency)
420 dev_priv->render_reclock_avail = true;
421 }
422
423 static void
parse_edp(struct drm_i915_private * dev_priv,struct bdb_header * bdb)424 parse_edp(struct drm_i915_private *dev_priv, struct bdb_header *bdb)
425 {
426 struct bdb_edp *edp;
427 struct edp_power_seq *edp_pps;
428 struct edp_link_params *edp_link_params;
429
430 edp = find_section(bdb, BDB_EDP);
431 if (!edp) {
432 if (SUPPORTS_EDP(dev_priv->dev) && dev_priv->edp.support) {
433 DRM_DEBUG_KMS("No eDP BDB found but eDP panel "
434 "supported, assume %dbpp panel color "
435 "depth.\n",
436 dev_priv->edp.bpp);
437 }
438 return;
439 }
440
441 switch ((edp->color_depth >> (panel_type * 2)) & 3) {
442 case EDP_18BPP:
443 dev_priv->edp.bpp = 18;
444 break;
445 case EDP_24BPP:
446 dev_priv->edp.bpp = 24;
447 break;
448 case EDP_30BPP:
449 dev_priv->edp.bpp = 30;
450 break;
451 }
452
453 /* Get the eDP sequencing and link info */
454 edp_pps = &edp->power_seqs[panel_type];
455 edp_link_params = &edp->link_params[panel_type];
456
457 dev_priv->edp.pps = *edp_pps;
458
459 dev_priv->edp.rate = edp_link_params->rate ? DP_LINK_BW_2_7 :
460 DP_LINK_BW_1_62;
461 switch (edp_link_params->lanes) {
462 case 0:
463 dev_priv->edp.lanes = 1;
464 break;
465 case 1:
466 dev_priv->edp.lanes = 2;
467 break;
468 case 3:
469 default:
470 dev_priv->edp.lanes = 4;
471 break;
472 }
473 switch (edp_link_params->preemphasis) {
474 case 0:
475 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_0;
476 break;
477 case 1:
478 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_3_5;
479 break;
480 case 2:
481 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_6;
482 break;
483 case 3:
484 dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPHASIS_9_5;
485 break;
486 }
487 switch (edp_link_params->vswing) {
488 case 0:
489 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_400;
490 break;
491 case 1:
492 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_600;
493 break;
494 case 2:
495 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_800;
496 break;
497 case 3:
498 dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_1200;
499 break;
500 }
501 }
502
503 static void
parse_device_mapping(struct drm_i915_private * dev_priv,struct bdb_header * bdb)504 parse_device_mapping(struct drm_i915_private *dev_priv,
505 struct bdb_header *bdb)
506 {
507 struct bdb_general_definitions *p_defs;
508 struct child_device_config *p_child, *child_dev_ptr;
509 int i, child_device_num, count;
510 u16 block_size;
511
512 p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS);
513 if (!p_defs) {
514 DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n");
515 return;
516 }
517 /* judge whether the size of child device meets the requirements.
518 * If the child device size obtained from general definition block
519 * is different with sizeof(struct child_device_config), skip the
520 * parsing of sdvo device info
521 */
522 if (p_defs->child_dev_size != sizeof(*p_child)) {
523 /* different child dev size . Ignore it */
524 DRM_DEBUG_KMS("different child size is found. Invalid.\n");
525 return;
526 }
527 /* get the block size of general definitions */
528 block_size = get_blocksize(p_defs);
529 /* get the number of child device */
530 child_device_num = (block_size - sizeof(*p_defs)) /
531 sizeof(*p_child);
532 count = 0;
533 /* get the number of child device that is present */
534 for (i = 0; i < child_device_num; i++) {
535 p_child = &(p_defs->devices[i]);
536 if (!p_child->device_type) {
537 /* skip the device block if device type is invalid */
538 continue;
539 }
540 count++;
541 }
542 if (!count) {
543 DRM_DEBUG_KMS("no child dev is parsed from VBT \n");
544 return;
545 }
546 dev_priv->child_dev = kzalloc(sizeof(*p_child) * count, GFP_KERNEL);
547 if (!dev_priv->child_dev) {
548 DRM_DEBUG_KMS("No memory space for child device\n");
549 return;
550 }
551
552 dev_priv->child_dev_num = count;
553 count = 0;
554 for (i = 0; i < child_device_num; i++) {
555 p_child = &(p_defs->devices[i]);
556 if (!p_child->device_type) {
557 /* skip the device block if device type is invalid */
558 continue;
559 }
560 child_dev_ptr = dev_priv->child_dev + count;
561 count++;
562 memcpy((void *)child_dev_ptr, (void *)p_child,
563 sizeof(*p_child));
564 }
565 return;
566 }
567
568 static void
init_vbt_defaults(struct drm_i915_private * dev_priv)569 init_vbt_defaults(struct drm_i915_private *dev_priv)
570 {
571 struct drm_device *dev = dev_priv->dev;
572
573 dev_priv->crt_ddc_pin = GMBUS_PORT_VGADDC;
574
575 /* LFP panel data */
576 dev_priv->lvds_dither = 1;
577 dev_priv->lvds_vbt = 0;
578
579 /* SDVO panel data */
580 dev_priv->sdvo_lvds_vbt_mode = NULL;
581
582 /* general features */
583 dev_priv->int_tv_support = 1;
584 dev_priv->int_crt_support = 1;
585
586 /* Default to using SSC */
587 dev_priv->lvds_use_ssc = 1;
588 dev_priv->lvds_ssc_freq = intel_bios_ssc_frequency(dev, 1);
589 DRM_DEBUG("Set default to SSC at %dMHz\n", dev_priv->lvds_ssc_freq);
590
591 /* eDP data */
592 dev_priv->edp.bpp = 18;
593 }
594
595 /**
596 * intel_parse_bios - find VBT and initialize settings from the BIOS
597 * @dev: DRM device
598 *
599 * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers
600 * to appropriate values.
601 *
602 * Returns 0 on success, nonzero on failure.
603 */
604 bool
intel_parse_bios(struct drm_device * dev)605 intel_parse_bios(struct drm_device *dev)
606 {
607 struct drm_i915_private *dev_priv = dev->dev_private;
608 struct pci_dev *pdev = dev->pdev;
609 struct bdb_header *bdb = NULL;
610 u8 __iomem *bios = NULL;
611
612 init_vbt_defaults(dev_priv);
613
614 /* XXX Should this validation be moved to intel_opregion.c? */
615 if (dev_priv->opregion.vbt) {
616 struct vbt_header *vbt = dev_priv->opregion.vbt;
617 if (memcmp(vbt->signature, "$VBT", 4) == 0) {
618 DRM_DEBUG_DRIVER("Using VBT from OpRegion: %20s\n",
619 vbt->signature);
620 bdb = (struct bdb_header *)((char *)vbt + vbt->bdb_offset);
621 } else
622 dev_priv->opregion.vbt = NULL;
623 }
624
625 if (bdb == NULL) {
626 struct vbt_header *vbt = NULL;
627 size_t size;
628 int i;
629
630 bios = pci_map_rom(pdev, &size);
631 if (!bios)
632 return -1;
633
634 /* Scour memory looking for the VBT signature */
635 for (i = 0; i + 4 < size; i++) {
636 if (!memcmp(bios + i, "$VBT", 4)) {
637 vbt = (struct vbt_header *)(bios + i);
638 break;
639 }
640 }
641
642 if (!vbt) {
643 DRM_ERROR("VBT signature missing\n");
644 pci_unmap_rom(pdev, bios);
645 return -1;
646 }
647
648 bdb = (struct bdb_header *)(bios + i + vbt->bdb_offset);
649 }
650
651 /* Grab useful general definitions */
652 parse_general_features(dev_priv, bdb);
653 parse_general_definitions(dev_priv, bdb);
654 parse_lfp_panel_data(dev_priv, bdb);
655 parse_sdvo_panel_data(dev_priv, bdb);
656 parse_sdvo_device_mapping(dev_priv, bdb);
657 parse_device_mapping(dev_priv, bdb);
658 parse_driver_features(dev_priv, bdb);
659 parse_edp(dev_priv, bdb);
660
661 if (bios)
662 pci_unmap_rom(pdev, bios);
663
664 return 0;
665 }
666
667 /* Ensure that vital registers have been initialised, even if the BIOS
668 * is absent or just failing to do its job.
669 */
intel_setup_bios(struct drm_device * dev)670 void intel_setup_bios(struct drm_device *dev)
671 {
672 struct drm_i915_private *dev_priv = dev->dev_private;
673
674 /* Set the Panel Power On/Off timings if uninitialized. */
675 if ((I915_READ(PP_ON_DELAYS) == 0) && (I915_READ(PP_OFF_DELAYS) == 0)) {
676 /* Set T2 to 40ms and T5 to 200ms */
677 I915_WRITE(PP_ON_DELAYS, 0x019007d0);
678
679 /* Set T3 to 35ms and Tx to 200ms */
680 I915_WRITE(PP_OFF_DELAYS, 0x015e07d0);
681 }
682 }
683