Commit | Line | Data |
---|---|---|
f910b411 AC |
1 | /* |
2 | * Copyright (c) 2006 Intel Corporation | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms and conditions of the GNU General Public License, | |
6 | * version 2, as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope it will be useful, but WITHOUT | |
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
11 | * more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License along with | |
14 | * this program; if not, write to the Free Software Foundation, Inc., | |
15 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
16 | * | |
17 | * Authors: | |
18 | * Eric Anholt <eric@anholt.net> | |
19 | * | |
20 | */ | |
21 | #include <drm/drmP.h> | |
22 | #include <drm/drm.h> | |
760285e7 | 23 | #include <drm/gma_drm.h> |
f910b411 AC |
24 | #include "psb_drv.h" |
25 | #include "psb_intel_drv.h" | |
26 | #include "psb_intel_reg.h" | |
27 | #include "intel_bios.h" | |
28 | ||
1fb28e9e AC |
29 | #define SLAVE_ADDR1 0x70 |
30 | #define SLAVE_ADDR2 0x72 | |
f910b411 AC |
31 | |
32 | static void *find_section(struct bdb_header *bdb, int section_id) | |
33 | { | |
34 | u8 *base = (u8 *)bdb; | |
35 | int index = 0; | |
36 | u16 total, current_size; | |
37 | u8 current_id; | |
38 | ||
39 | /* skip to first section */ | |
40 | index += bdb->header_size; | |
41 | total = bdb->bdb_size; | |
42 | ||
43 | /* walk the sections looking for section_id */ | |
44 | while (index < total) { | |
45 | current_id = *(base + index); | |
46 | index++; | |
47 | current_size = *((u16 *)(base + index)); | |
48 | index += 2; | |
49 | if (current_id == section_id) | |
50 | return base + index; | |
51 | index += current_size; | |
52 | } | |
53 | ||
54 | return NULL; | |
55 | } | |
56 | ||
d112a816 ZY |
57 | static void |
58 | parse_edp(struct drm_psb_private *dev_priv, struct bdb_header *bdb) | |
59 | { | |
60 | struct bdb_edp *edp; | |
61 | struct edp_power_seq *edp_pps; | |
62 | struct edp_link_params *edp_link_params; | |
63 | uint8_t panel_type; | |
64 | ||
65 | edp = find_section(bdb, BDB_EDP); | |
66 | ||
67 | dev_priv->edp.bpp = 18; | |
68 | if (!edp) { | |
69 | if (dev_priv->edp.support) { | |
70 | DRM_DEBUG_KMS("No eDP BDB found but eDP panel supported, assume %dbpp panel color depth.\n", | |
71 | dev_priv->edp.bpp); | |
72 | } | |
73 | return; | |
74 | } | |
75 | ||
76 | panel_type = dev_priv->panel_type; | |
77 | switch ((edp->color_depth >> (panel_type * 2)) & 3) { | |
78 | case EDP_18BPP: | |
79 | dev_priv->edp.bpp = 18; | |
80 | break; | |
81 | case EDP_24BPP: | |
82 | dev_priv->edp.bpp = 24; | |
83 | break; | |
84 | case EDP_30BPP: | |
85 | dev_priv->edp.bpp = 30; | |
86 | break; | |
87 | } | |
88 | ||
89 | /* Get the eDP sequencing and link info */ | |
90 | edp_pps = &edp->power_seqs[panel_type]; | |
91 | edp_link_params = &edp->link_params[panel_type]; | |
92 | ||
93 | dev_priv->edp.pps = *edp_pps; | |
94 | ||
95 | DRM_DEBUG_KMS("EDP timing in vbt t1_t3 %d t8 %d t9 %d t10 %d t11_t12 %d\n", | |
96 | dev_priv->edp.pps.t1_t3, dev_priv->edp.pps.t8, | |
97 | dev_priv->edp.pps.t9, dev_priv->edp.pps.t10, | |
98 | dev_priv->edp.pps.t11_t12); | |
99 | ||
100 | dev_priv->edp.rate = edp_link_params->rate ? DP_LINK_BW_2_7 : | |
101 | DP_LINK_BW_1_62; | |
102 | switch (edp_link_params->lanes) { | |
103 | case 0: | |
104 | dev_priv->edp.lanes = 1; | |
105 | break; | |
106 | case 1: | |
107 | dev_priv->edp.lanes = 2; | |
108 | break; | |
109 | case 3: | |
110 | default: | |
111 | dev_priv->edp.lanes = 4; | |
112 | break; | |
113 | } | |
114 | DRM_DEBUG_KMS("VBT reports EDP: Lane_count %d, Lane_rate %d, Bpp %d\n", | |
115 | dev_priv->edp.lanes, dev_priv->edp.rate, dev_priv->edp.bpp); | |
116 | ||
117 | switch (edp_link_params->preemphasis) { | |
118 | case 0: | |
31160006 | 119 | dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_0; |
d112a816 ZY |
120 | break; |
121 | case 1: | |
31160006 | 122 | dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_1; |
d112a816 ZY |
123 | break; |
124 | case 2: | |
31160006 | 125 | dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_2; |
d112a816 ZY |
126 | break; |
127 | case 3: | |
31160006 | 128 | dev_priv->edp.preemphasis = DP_TRAIN_PRE_EMPH_LEVEL_3; |
d112a816 ZY |
129 | break; |
130 | } | |
131 | switch (edp_link_params->vswing) { | |
132 | case 0: | |
31160006 | 133 | dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_0; |
d112a816 ZY |
134 | break; |
135 | case 1: | |
31160006 | 136 | dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_1; |
d112a816 ZY |
137 | break; |
138 | case 2: | |
31160006 | 139 | dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_2; |
d112a816 ZY |
140 | break; |
141 | case 3: | |
31160006 | 142 | dev_priv->edp.vswing = DP_TRAIN_VOLTAGE_SWING_LEVEL_3; |
d112a816 ZY |
143 | break; |
144 | } | |
145 | DRM_DEBUG_KMS("VBT reports EDP: VSwing %d, Preemph %d\n", | |
146 | dev_priv->edp.vswing, dev_priv->edp.preemphasis); | |
147 | } | |
148 | ||
1fb28e9e AC |
149 | static u16 |
150 | get_blocksize(void *p) | |
151 | { | |
152 | u16 *block_ptr, block_size; | |
153 | ||
154 | block_ptr = (u16 *)((char *)p - 2); | |
155 | block_size = *block_ptr; | |
156 | return block_size; | |
157 | } | |
158 | ||
f910b411 AC |
159 | static void fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode, |
160 | struct lvds_dvo_timing *dvo_timing) | |
161 | { | |
162 | panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) | | |
163 | dvo_timing->hactive_lo; | |
164 | panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay + | |
165 | ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo); | |
166 | panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start + | |
167 | dvo_timing->hsync_pulse_width; | |
168 | panel_fixed_mode->htotal = panel_fixed_mode->hdisplay + | |
169 | ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo); | |
170 | ||
171 | panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) | | |
172 | dvo_timing->vactive_lo; | |
173 | panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay + | |
174 | dvo_timing->vsync_off; | |
175 | panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start + | |
176 | dvo_timing->vsync_pulse_width; | |
177 | panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay + | |
178 | ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo); | |
179 | panel_fixed_mode->clock = dvo_timing->clock * 10; | |
180 | panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED; | |
181 | ||
1fb28e9e AC |
182 | if (dvo_timing->hsync_positive) |
183 | panel_fixed_mode->flags |= DRM_MODE_FLAG_PHSYNC; | |
184 | else | |
185 | panel_fixed_mode->flags |= DRM_MODE_FLAG_NHSYNC; | |
186 | ||
187 | if (dvo_timing->vsync_positive) | |
188 | panel_fixed_mode->flags |= DRM_MODE_FLAG_PVSYNC; | |
189 | else | |
190 | panel_fixed_mode->flags |= DRM_MODE_FLAG_NVSYNC; | |
191 | ||
f910b411 AC |
192 | /* Some VBTs have bogus h/vtotal values */ |
193 | if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal) | |
194 | panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1; | |
195 | if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal) | |
196 | panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1; | |
197 | ||
198 | drm_mode_set_name(panel_fixed_mode); | |
199 | } | |
200 | ||
201 | static void parse_backlight_data(struct drm_psb_private *dev_priv, | |
202 | struct bdb_header *bdb) | |
203 | { | |
204 | struct bdb_lvds_backlight *vbt_lvds_bl = NULL; | |
205 | struct bdb_lvds_backlight *lvds_bl; | |
206 | u8 p_type = 0; | |
207 | void *bl_start = NULL; | |
208 | struct bdb_lvds_options *lvds_opts | |
209 | = find_section(bdb, BDB_LVDS_OPTIONS); | |
210 | ||
211 | dev_priv->lvds_bl = NULL; | |
212 | ||
213 | if (lvds_opts) | |
214 | p_type = lvds_opts->panel_type; | |
215 | else | |
216 | return; | |
217 | ||
218 | bl_start = find_section(bdb, BDB_LVDS_BACKLIGHT); | |
219 | vbt_lvds_bl = (struct bdb_lvds_backlight *)(bl_start + 1) + p_type; | |
220 | ||
bc6a5419 | 221 | lvds_bl = kmemdup(vbt_lvds_bl, sizeof(*vbt_lvds_bl), GFP_KERNEL); |
f910b411 AC |
222 | if (!lvds_bl) { |
223 | dev_err(dev_priv->dev->dev, "out of memory for backlight data\n"); | |
224 | return; | |
225 | } | |
f910b411 AC |
226 | dev_priv->lvds_bl = lvds_bl; |
227 | } | |
228 | ||
229 | /* Try to find integrated panel data */ | |
230 | static void parse_lfp_panel_data(struct drm_psb_private *dev_priv, | |
231 | struct bdb_header *bdb) | |
232 | { | |
233 | struct bdb_lvds_options *lvds_options; | |
234 | struct bdb_lvds_lfp_data *lvds_lfp_data; | |
235 | struct bdb_lvds_lfp_data_entry *entry; | |
236 | struct lvds_dvo_timing *dvo_timing; | |
237 | struct drm_display_mode *panel_fixed_mode; | |
238 | ||
239 | /* Defaults if we can't find VBT info */ | |
240 | dev_priv->lvds_dither = 0; | |
241 | dev_priv->lvds_vbt = 0; | |
242 | ||
243 | lvds_options = find_section(bdb, BDB_LVDS_OPTIONS); | |
244 | if (!lvds_options) | |
245 | return; | |
246 | ||
247 | dev_priv->lvds_dither = lvds_options->pixel_dither; | |
d112a816 ZY |
248 | dev_priv->panel_type = lvds_options->panel_type; |
249 | ||
f910b411 AC |
250 | if (lvds_options->panel_type == 0xff) |
251 | return; | |
252 | ||
253 | lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA); | |
254 | if (!lvds_lfp_data) | |
255 | return; | |
256 | ||
257 | ||
258 | entry = &lvds_lfp_data->data[lvds_options->panel_type]; | |
259 | dvo_timing = &entry->dvo_timing; | |
260 | ||
261 | panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), | |
262 | GFP_KERNEL); | |
263 | if (panel_fixed_mode == NULL) { | |
264 | dev_err(dev_priv->dev->dev, "out of memory for fixed panel mode\n"); | |
265 | return; | |
266 | } | |
267 | ||
268 | dev_priv->lvds_vbt = 1; | |
269 | fill_detail_timing_data(panel_fixed_mode, dvo_timing); | |
270 | ||
271 | if (panel_fixed_mode->htotal > 0 && panel_fixed_mode->vtotal > 0) { | |
272 | dev_priv->lfp_lvds_vbt_mode = panel_fixed_mode; | |
273 | drm_mode_debug_printmodeline(panel_fixed_mode); | |
274 | } else { | |
275 | dev_dbg(dev_priv->dev->dev, "ignoring invalid LVDS VBT\n"); | |
276 | dev_priv->lvds_vbt = 0; | |
277 | kfree(panel_fixed_mode); | |
278 | } | |
279 | return; | |
280 | } | |
281 | ||
282 | /* Try to find sdvo panel data */ | |
283 | static void parse_sdvo_panel_data(struct drm_psb_private *dev_priv, | |
284 | struct bdb_header *bdb) | |
285 | { | |
286 | struct bdb_sdvo_lvds_options *sdvo_lvds_options; | |
287 | struct lvds_dvo_timing *dvo_timing; | |
288 | struct drm_display_mode *panel_fixed_mode; | |
289 | ||
290 | dev_priv->sdvo_lvds_vbt_mode = NULL; | |
291 | ||
292 | sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS); | |
293 | if (!sdvo_lvds_options) | |
294 | return; | |
295 | ||
296 | dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS); | |
297 | if (!dvo_timing) | |
298 | return; | |
299 | ||
300 | panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); | |
301 | ||
302 | if (!panel_fixed_mode) | |
303 | return; | |
304 | ||
305 | fill_detail_timing_data(panel_fixed_mode, | |
306 | dvo_timing + sdvo_lvds_options->panel_type); | |
307 | ||
308 | dev_priv->sdvo_lvds_vbt_mode = panel_fixed_mode; | |
309 | ||
310 | return; | |
311 | } | |
312 | ||
313 | static void parse_general_features(struct drm_psb_private *dev_priv, | |
314 | struct bdb_header *bdb) | |
315 | { | |
316 | struct bdb_general_features *general; | |
317 | ||
318 | /* Set sensible defaults in case we can't find the general block */ | |
319 | dev_priv->int_tv_support = 1; | |
320 | dev_priv->int_crt_support = 1; | |
321 | ||
322 | general = find_section(bdb, BDB_GENERAL_FEATURES); | |
323 | if (general) { | |
324 | dev_priv->int_tv_support = general->int_tv_support; | |
325 | dev_priv->int_crt_support = general->int_crt_support; | |
326 | dev_priv->lvds_use_ssc = general->enable_ssc; | |
327 | ||
328 | if (dev_priv->lvds_use_ssc) { | |
329 | dev_priv->lvds_ssc_freq | |
330 | = general->ssc_freq ? 100 : 96; | |
331 | } | |
332 | } | |
333 | } | |
334 | ||
1fb28e9e AC |
335 | static void |
336 | parse_sdvo_device_mapping(struct drm_psb_private *dev_priv, | |
337 | struct bdb_header *bdb) | |
338 | { | |
339 | struct sdvo_device_mapping *p_mapping; | |
340 | struct bdb_general_definitions *p_defs; | |
341 | struct child_device_config *p_child; | |
342 | int i, child_device_num, count; | |
343 | u16 block_size; | |
344 | ||
345 | p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); | |
346 | if (!p_defs) { | |
347 | DRM_DEBUG_KMS("No general definition block is found, unable to construct sdvo mapping.\n"); | |
348 | return; | |
349 | } | |
350 | /* judge whether the size of child device meets the requirements. | |
351 | * If the child device size obtained from general definition block | |
352 | * is different with sizeof(struct child_device_config), skip the | |
353 | * parsing of sdvo device info | |
354 | */ | |
355 | if (p_defs->child_dev_size != sizeof(*p_child)) { | |
356 | /* different child dev size . Ignore it */ | |
357 | DRM_DEBUG_KMS("different child size is found. Invalid.\n"); | |
358 | return; | |
359 | } | |
360 | /* get the block size of general definitions */ | |
361 | block_size = get_blocksize(p_defs); | |
362 | /* get the number of child device */ | |
363 | child_device_num = (block_size - sizeof(*p_defs)) / | |
364 | sizeof(*p_child); | |
365 | count = 0; | |
366 | for (i = 0; i < child_device_num; i++) { | |
367 | p_child = &(p_defs->devices[i]); | |
368 | if (!p_child->device_type) { | |
369 | /* skip the device block if device type is invalid */ | |
370 | continue; | |
371 | } | |
372 | if (p_child->slave_addr != SLAVE_ADDR1 && | |
373 | p_child->slave_addr != SLAVE_ADDR2) { | |
374 | /* | |
375 | * If the slave address is neither 0x70 nor 0x72, | |
376 | * it is not a SDVO device. Skip it. | |
377 | */ | |
378 | continue; | |
379 | } | |
380 | if (p_child->dvo_port != DEVICE_PORT_DVOB && | |
381 | p_child->dvo_port != DEVICE_PORT_DVOC) { | |
382 | /* skip the incorrect SDVO port */ | |
383 | DRM_DEBUG_KMS("Incorrect SDVO port. Skip it\n"); | |
384 | continue; | |
385 | } | |
386 | DRM_DEBUG_KMS("the SDVO device with slave addr %2x is found on" | |
387 | " %s port\n", | |
388 | p_child->slave_addr, | |
389 | (p_child->dvo_port == DEVICE_PORT_DVOB) ? | |
390 | "SDVOB" : "SDVOC"); | |
391 | p_mapping = &(dev_priv->sdvo_mappings[p_child->dvo_port - 1]); | |
392 | if (!p_mapping->initialized) { | |
393 | p_mapping->dvo_port = p_child->dvo_port; | |
394 | p_mapping->slave_addr = p_child->slave_addr; | |
395 | p_mapping->dvo_wiring = p_child->dvo_wiring; | |
396 | p_mapping->ddc_pin = p_child->ddc_pin; | |
397 | p_mapping->i2c_pin = p_child->i2c_pin; | |
398 | p_mapping->initialized = 1; | |
399 | DRM_DEBUG_KMS("SDVO device: dvo=%x, addr=%x, wiring=%d, ddc_pin=%d, i2c_pin=%d\n", | |
400 | p_mapping->dvo_port, | |
401 | p_mapping->slave_addr, | |
402 | p_mapping->dvo_wiring, | |
403 | p_mapping->ddc_pin, | |
404 | p_mapping->i2c_pin); | |
405 | } else { | |
406 | DRM_DEBUG_KMS("Maybe one SDVO port is shared by " | |
407 | "two SDVO device.\n"); | |
408 | } | |
409 | if (p_child->slave2_addr) { | |
410 | /* Maybe this is a SDVO device with multiple inputs */ | |
411 | /* And the mapping info is not added */ | |
412 | DRM_DEBUG_KMS("there exists the slave2_addr. Maybe this" | |
413 | " is a SDVO device with multiple inputs.\n"); | |
414 | } | |
415 | count++; | |
416 | } | |
417 | ||
418 | if (!count) { | |
419 | /* No SDVO device info is found */ | |
420 | DRM_DEBUG_KMS("No SDVO device info is found in VBT\n"); | |
421 | } | |
422 | return; | |
423 | } | |
424 | ||
425 | ||
642c52fc AC |
426 | static void |
427 | parse_driver_features(struct drm_psb_private *dev_priv, | |
428 | struct bdb_header *bdb) | |
429 | { | |
430 | struct bdb_driver_features *driver; | |
431 | ||
432 | driver = find_section(bdb, BDB_DRIVER_FEATURES); | |
433 | if (!driver) | |
434 | return; | |
435 | ||
d112a816 ZY |
436 | if (driver->lvds_config == BDB_DRIVER_FEATURE_EDP) |
437 | dev_priv->edp.support = 1; | |
438 | ||
642c52fc AC |
439 | /* This bit means to use 96Mhz for DPLL_A or not */ |
440 | if (driver->primary_lfp_id) | |
441 | dev_priv->dplla_96mhz = true; | |
442 | else | |
443 | dev_priv->dplla_96mhz = false; | |
444 | } | |
445 | ||
1fb28e9e AC |
446 | static void |
447 | parse_device_mapping(struct drm_psb_private *dev_priv, | |
448 | struct bdb_header *bdb) | |
449 | { | |
450 | struct bdb_general_definitions *p_defs; | |
451 | struct child_device_config *p_child, *child_dev_ptr; | |
452 | int i, child_device_num, count; | |
453 | u16 block_size; | |
454 | ||
455 | p_defs = find_section(bdb, BDB_GENERAL_DEFINITIONS); | |
456 | if (!p_defs) { | |
457 | DRM_DEBUG_KMS("No general definition block is found, no devices defined.\n"); | |
458 | return; | |
459 | } | |
460 | /* judge whether the size of child device meets the requirements. | |
461 | * If the child device size obtained from general definition block | |
462 | * is different with sizeof(struct child_device_config), skip the | |
463 | * parsing of sdvo device info | |
464 | */ | |
465 | if (p_defs->child_dev_size != sizeof(*p_child)) { | |
466 | /* different child dev size . Ignore it */ | |
467 | DRM_DEBUG_KMS("different child size is found. Invalid.\n"); | |
468 | return; | |
469 | } | |
470 | /* get the block size of general definitions */ | |
471 | block_size = get_blocksize(p_defs); | |
472 | /* get the number of child device */ | |
473 | child_device_num = (block_size - sizeof(*p_defs)) / | |
474 | sizeof(*p_child); | |
475 | count = 0; | |
476 | /* get the number of child devices that are present */ | |
477 | for (i = 0; i < child_device_num; i++) { | |
478 | p_child = &(p_defs->devices[i]); | |
479 | if (!p_child->device_type) { | |
480 | /* skip the device block if device type is invalid */ | |
481 | continue; | |
482 | } | |
483 | count++; | |
484 | } | |
485 | if (!count) { | |
486 | DRM_DEBUG_KMS("no child dev is parsed from VBT\n"); | |
487 | return; | |
488 | } | |
489 | dev_priv->child_dev = kcalloc(count, sizeof(*p_child), GFP_KERNEL); | |
490 | if (!dev_priv->child_dev) { | |
491 | DRM_DEBUG_KMS("No memory space for child devices\n"); | |
492 | return; | |
493 | } | |
494 | ||
495 | dev_priv->child_dev_num = count; | |
496 | count = 0; | |
497 | for (i = 0; i < child_device_num; i++) { | |
498 | p_child = &(p_defs->devices[i]); | |
499 | if (!p_child->device_type) { | |
500 | /* skip the device block if device type is invalid */ | |
501 | continue; | |
502 | } | |
503 | child_dev_ptr = dev_priv->child_dev + count; | |
504 | count++; | |
505 | memcpy((void *)child_dev_ptr, (void *)p_child, | |
506 | sizeof(*p_child)); | |
507 | } | |
508 | return; | |
509 | } | |
510 | ||
511 | ||
f910b411 AC |
512 | /** |
513 | * psb_intel_init_bios - initialize VBIOS settings & find VBT | |
514 | * @dev: DRM device | |
515 | * | |
516 | * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers | |
517 | * to appropriate values. | |
518 | * | |
519 | * VBT existence is a sanity check that is relied on by other i830_bios.c code. | |
520 | * Note that it would be better to use a BIOS call to get the VBT, as BIOSes may | |
521 | * feed an updated VBT back through that, compared to what we'll fetch using | |
522 | * this method of groping around in the BIOS data. | |
523 | * | |
524 | * Returns 0 on success, nonzero on failure. | |
525 | */ | |
0317c6ce | 526 | int psb_intel_init_bios(struct drm_device *dev) |
f910b411 AC |
527 | { |
528 | struct drm_psb_private *dev_priv = dev->dev_private; | |
529 | struct pci_dev *pdev = dev->pdev; | |
530 | struct vbt_header *vbt = NULL; | |
1fb28e9e AC |
531 | struct bdb_header *bdb = NULL; |
532 | u8 __iomem *bios = NULL; | |
f910b411 AC |
533 | size_t size; |
534 | int i; | |
535 | ||
d112a816 ZY |
536 | |
537 | dev_priv->panel_type = 0xff; | |
538 | ||
1fb28e9e AC |
539 | /* XXX Should this validation be moved to intel_opregion.c? */ |
540 | if (dev_priv->opregion.vbt) { | |
541 | struct vbt_header *vbt = dev_priv->opregion.vbt; | |
542 | if (memcmp(vbt->signature, "$VBT", 4) == 0) { | |
543 | DRM_DEBUG_KMS("Using VBT from OpRegion: %20s\n", | |
544 | vbt->signature); | |
545 | bdb = (struct bdb_header *)((char *)vbt + vbt->bdb_offset); | |
546 | } else | |
547 | dev_priv->opregion.vbt = NULL; | |
548 | } | |
f910b411 | 549 | |
1fb28e9e AC |
550 | if (bdb == NULL) { |
551 | bios = pci_map_rom(pdev, &size); | |
552 | if (!bios) | |
553 | return -1; | |
554 | ||
555 | /* Scour memory looking for the VBT signature */ | |
556 | for (i = 0; i + 4 < size; i++) { | |
557 | if (!memcmp(bios + i, "$VBT", 4)) { | |
558 | vbt = (struct vbt_header *)(bios + i); | |
559 | break; | |
560 | } | |
f910b411 | 561 | } |
f910b411 | 562 | |
1fb28e9e AC |
563 | if (!vbt) { |
564 | dev_err(dev->dev, "VBT signature missing\n"); | |
565 | pci_unmap_rom(pdev, bios); | |
566 | return -1; | |
567 | } | |
568 | bdb = (struct bdb_header *)(bios + i + vbt->bdb_offset); | |
f910b411 AC |
569 | } |
570 | ||
1fb28e9e | 571 | /* Grab useful general dxefinitions */ |
f910b411 | 572 | parse_general_features(dev_priv, bdb); |
642c52fc | 573 | parse_driver_features(dev_priv, bdb); |
f910b411 AC |
574 | parse_lfp_panel_data(dev_priv, bdb); |
575 | parse_sdvo_panel_data(dev_priv, bdb); | |
1fb28e9e AC |
576 | parse_sdvo_device_mapping(dev_priv, bdb); |
577 | parse_device_mapping(dev_priv, bdb); | |
f910b411 | 578 | parse_backlight_data(dev_priv, bdb); |
d112a816 | 579 | parse_edp(dev_priv, bdb); |
f910b411 | 580 | |
1fb28e9e AC |
581 | if (bios) |
582 | pci_unmap_rom(pdev, bios); | |
f910b411 AC |
583 | |
584 | return 0; | |
585 | } | |
586 | ||
587 | /** | |
588 | * Destroy and free VBT data | |
589 | */ | |
590 | void psb_intel_destroy_bios(struct drm_device *dev) | |
591 | { | |
592 | struct drm_psb_private *dev_priv = dev->dev_private; | |
f910b411 | 593 | |
4ab2c7f1 AC |
594 | kfree(dev_priv->sdvo_lvds_vbt_mode); |
595 | kfree(dev_priv->lfp_lvds_vbt_mode); | |
596 | kfree(dev_priv->lvds_bl); | |
f910b411 | 597 | } |