]>
Commit | Line | Data |
---|---|---|
0867b421 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> | |
23 | #include "psb_drm.h" | |
24 | #include "psb_drv.h" | |
25 | #include "psb_intel_drv.h" | |
26 | #include "psb_intel_reg.h" | |
27 | #include "psb_intel_bios.h" | |
28 | ||
29 | ||
30 | static void *find_section(struct bdb_header *bdb, int section_id) | |
31 | { | |
32 | u8 *base = (u8 *)bdb; | |
33 | int index = 0; | |
34 | u16 total, current_size; | |
35 | u8 current_id; | |
36 | ||
37 | /* skip to first section */ | |
38 | index += bdb->header_size; | |
39 | total = bdb->bdb_size; | |
40 | ||
41 | /* walk the sections looking for section_id */ | |
42 | while (index < total) { | |
43 | current_id = *(base + index); | |
44 | index++; | |
45 | current_size = *((u16 *)(base + index)); | |
46 | index += 2; | |
47 | if (current_id == section_id) | |
48 | return base + index; | |
49 | index += current_size; | |
50 | } | |
51 | ||
52 | return NULL; | |
53 | } | |
54 | ||
55 | static void fill_detail_timing_data(struct drm_display_mode *panel_fixed_mode, | |
56 | struct lvds_dvo_timing *dvo_timing) | |
57 | { | |
58 | panel_fixed_mode->hdisplay = (dvo_timing->hactive_hi << 8) | | |
59 | dvo_timing->hactive_lo; | |
60 | panel_fixed_mode->hsync_start = panel_fixed_mode->hdisplay + | |
61 | ((dvo_timing->hsync_off_hi << 8) | dvo_timing->hsync_off_lo); | |
62 | panel_fixed_mode->hsync_end = panel_fixed_mode->hsync_start + | |
63 | dvo_timing->hsync_pulse_width; | |
64 | panel_fixed_mode->htotal = panel_fixed_mode->hdisplay + | |
65 | ((dvo_timing->hblank_hi << 8) | dvo_timing->hblank_lo); | |
66 | ||
67 | panel_fixed_mode->vdisplay = (dvo_timing->vactive_hi << 8) | | |
68 | dvo_timing->vactive_lo; | |
69 | panel_fixed_mode->vsync_start = panel_fixed_mode->vdisplay + | |
70 | dvo_timing->vsync_off; | |
71 | panel_fixed_mode->vsync_end = panel_fixed_mode->vsync_start + | |
72 | dvo_timing->vsync_pulse_width; | |
73 | panel_fixed_mode->vtotal = panel_fixed_mode->vdisplay + | |
74 | ((dvo_timing->vblank_hi << 8) | dvo_timing->vblank_lo); | |
75 | panel_fixed_mode->clock = dvo_timing->clock * 10; | |
76 | panel_fixed_mode->type = DRM_MODE_TYPE_PREFERRED; | |
77 | ||
78 | /* Some VBTs have bogus h/vtotal values */ | |
79 | if (panel_fixed_mode->hsync_end > panel_fixed_mode->htotal) | |
80 | panel_fixed_mode->htotal = panel_fixed_mode->hsync_end + 1; | |
81 | if (panel_fixed_mode->vsync_end > panel_fixed_mode->vtotal) | |
82 | panel_fixed_mode->vtotal = panel_fixed_mode->vsync_end + 1; | |
83 | ||
84 | drm_mode_set_name(panel_fixed_mode); | |
85 | } | |
86 | ||
87 | static void parse_backlight_data(struct drm_psb_private *dev_priv, | |
88 | struct bdb_header *bdb) | |
89 | { | |
90 | struct bdb_lvds_backlight *vbt_lvds_bl = NULL; | |
91 | struct bdb_lvds_backlight *lvds_bl; | |
92 | u8 p_type = 0; | |
93 | void *bl_start = NULL; | |
94 | struct bdb_lvds_options *lvds_opts | |
95 | = find_section(bdb, BDB_LVDS_OPTIONS); | |
96 | ||
97 | dev_priv->lvds_bl = NULL; | |
98 | ||
99 | if (lvds_opts) { | |
100 | DRM_DEBUG("lvds_options found at %p\n", lvds_opts); | |
101 | p_type = lvds_opts->panel_type; | |
102 | } else { | |
103 | DRM_DEBUG("no lvds_options\n"); | |
104 | return; | |
105 | } | |
106 | ||
107 | bl_start = find_section(bdb, BDB_LVDS_BACKLIGHT); | |
108 | vbt_lvds_bl = (struct bdb_lvds_backlight *)(bl_start + 1) + p_type; | |
109 | ||
110 | lvds_bl = kzalloc(sizeof(*vbt_lvds_bl), GFP_KERNEL); | |
111 | if (!lvds_bl) { | |
112 | DRM_DEBUG("No memory\n"); | |
113 | return; | |
114 | } | |
115 | ||
116 | memcpy(lvds_bl, vbt_lvds_bl, sizeof(*vbt_lvds_bl)); | |
117 | ||
118 | dev_priv->lvds_bl = lvds_bl; | |
119 | } | |
120 | ||
121 | /* Try to find integrated panel data */ | |
122 | static void parse_lfp_panel_data(struct drm_psb_private *dev_priv, | |
123 | struct bdb_header *bdb) | |
124 | { | |
125 | struct bdb_lvds_options *lvds_options; | |
126 | struct bdb_lvds_lfp_data *lvds_lfp_data; | |
127 | struct bdb_lvds_lfp_data_entry *entry; | |
128 | struct lvds_dvo_timing *dvo_timing; | |
129 | struct drm_display_mode *panel_fixed_mode; | |
130 | ||
131 | /* Defaults if we can't find VBT info */ | |
132 | dev_priv->lvds_dither = 0; | |
133 | dev_priv->lvds_vbt = 0; | |
134 | ||
135 | lvds_options = find_section(bdb, BDB_LVDS_OPTIONS); | |
136 | if (!lvds_options) | |
137 | return; | |
138 | ||
139 | dev_priv->lvds_dither = lvds_options->pixel_dither; | |
140 | if (lvds_options->panel_type == 0xff) | |
141 | return; | |
142 | ||
143 | lvds_lfp_data = find_section(bdb, BDB_LVDS_LFP_DATA); | |
144 | if (!lvds_lfp_data) | |
145 | return; | |
146 | ||
147 | dev_priv->lvds_vbt = 1; | |
148 | ||
149 | entry = &lvds_lfp_data->data[lvds_options->panel_type]; | |
150 | dvo_timing = &entry->dvo_timing; | |
151 | ||
152 | panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), | |
153 | GFP_KERNEL); | |
154 | ||
155 | fill_detail_timing_data(panel_fixed_mode, dvo_timing); | |
156 | ||
157 | dev_priv->lfp_lvds_vbt_mode = panel_fixed_mode; | |
158 | ||
159 | DRM_DEBUG("Found panel mode in BIOS VBT tables:\n"); | |
160 | drm_mode_debug_printmodeline(panel_fixed_mode); | |
161 | ||
162 | return; | |
163 | } | |
164 | ||
165 | /* Try to find sdvo panel data */ | |
166 | static void parse_sdvo_panel_data(struct drm_psb_private *dev_priv, | |
167 | struct bdb_header *bdb) | |
168 | { | |
169 | struct bdb_sdvo_lvds_options *sdvo_lvds_options; | |
170 | struct lvds_dvo_timing *dvo_timing; | |
171 | struct drm_display_mode *panel_fixed_mode; | |
172 | ||
173 | dev_priv->sdvo_lvds_vbt_mode = NULL; | |
174 | ||
175 | sdvo_lvds_options = find_section(bdb, BDB_SDVO_LVDS_OPTIONS); | |
176 | if (!sdvo_lvds_options) | |
177 | return; | |
178 | ||
179 | dvo_timing = find_section(bdb, BDB_SDVO_PANEL_DTDS); | |
180 | if (!dvo_timing) | |
181 | return; | |
182 | ||
183 | panel_fixed_mode = kzalloc(sizeof(*panel_fixed_mode), GFP_KERNEL); | |
184 | ||
185 | if (!panel_fixed_mode) | |
186 | return; | |
187 | ||
188 | fill_detail_timing_data(panel_fixed_mode, | |
189 | dvo_timing + sdvo_lvds_options->panel_type); | |
190 | ||
191 | dev_priv->sdvo_lvds_vbt_mode = panel_fixed_mode; | |
192 | ||
193 | return; | |
194 | } | |
195 | ||
196 | static void parse_general_features(struct drm_psb_private *dev_priv, | |
197 | struct bdb_header *bdb) | |
198 | { | |
199 | struct bdb_general_features *general; | |
200 | ||
201 | /* Set sensible defaults in case we can't find the general block */ | |
202 | dev_priv->int_tv_support = 1; | |
203 | dev_priv->int_crt_support = 1; | |
204 | ||
205 | general = find_section(bdb, BDB_GENERAL_FEATURES); | |
206 | if (general) { | |
207 | dev_priv->int_tv_support = general->int_tv_support; | |
208 | dev_priv->int_crt_support = general->int_crt_support; | |
209 | dev_priv->lvds_use_ssc = general->enable_ssc; | |
210 | ||
211 | if (dev_priv->lvds_use_ssc) { | |
212 | dev_priv->lvds_ssc_freq | |
213 | = general->ssc_freq ? 100 : 96; | |
214 | } | |
215 | } | |
216 | } | |
217 | ||
218 | /** | |
219 | * psb_intel_init_bios - initialize VBIOS settings & find VBT | |
220 | * @dev: DRM device | |
221 | * | |
222 | * Loads the Video BIOS and checks that the VBT exists. Sets scratch registers | |
223 | * to appropriate values. | |
224 | * | |
225 | * VBT existence is a sanity check that is relied on by other i830_bios.c code. | |
226 | * Note that it would be better to use a BIOS call to get the VBT, as BIOSes may | |
227 | * feed an updated VBT back through that, compared to what we'll fetch using | |
228 | * this method of groping around in the BIOS data. | |
229 | * | |
230 | * Returns 0 on success, nonzero on failure. | |
231 | */ | |
232 | bool psb_intel_init_bios(struct drm_device *dev) | |
233 | { | |
234 | struct drm_psb_private *dev_priv = dev->dev_private; | |
235 | struct pci_dev *pdev = dev->pdev; | |
236 | struct vbt_header *vbt = NULL; | |
237 | struct bdb_header *bdb; | |
238 | u8 __iomem *bios; | |
239 | size_t size; | |
240 | int i; | |
241 | ||
242 | bios = pci_map_rom(pdev, &size); | |
243 | if (!bios) | |
244 | return -1; | |
245 | ||
246 | /* Scour memory looking for the VBT signature */ | |
247 | for (i = 0; i + 4 < size; i++) { | |
248 | if (!memcmp(bios + i, "$VBT", 4)) { | |
249 | vbt = (struct vbt_header *)(bios + i); | |
250 | break; | |
251 | } | |
252 | } | |
253 | ||
254 | if (!vbt) { | |
255 | DRM_ERROR("VBT signature missing\n"); | |
256 | pci_unmap_rom(pdev, bios); | |
257 | return -1; | |
258 | } | |
259 | ||
260 | bdb = (struct bdb_header *)(bios + i + vbt->bdb_offset); | |
261 | ||
262 | /* Grab useful general definitions */ | |
263 | parse_general_features(dev_priv, bdb); | |
264 | parse_lfp_panel_data(dev_priv, bdb); | |
265 | parse_sdvo_panel_data(dev_priv, bdb); | |
266 | parse_backlight_data(dev_priv, bdb); | |
267 | ||
268 | pci_unmap_rom(pdev, bios); | |
269 | ||
270 | return 0; | |
271 | } | |
272 | ||
273 | /** | |
25985edc | 274 | * Destroy and free VBT data |
0867b421 | 275 | */ |
487e873d | 276 | void psb_intel_destroy_bios(struct drm_device *dev) |
0867b421 AC |
277 | { |
278 | struct drm_psb_private *dev_priv = dev->dev_private; | |
279 | struct drm_display_mode *sdvo_lvds_vbt_mode = | |
280 | dev_priv->sdvo_lvds_vbt_mode; | |
281 | struct drm_display_mode *lfp_lvds_vbt_mode = | |
282 | dev_priv->lfp_lvds_vbt_mode; | |
283 | struct bdb_lvds_backlight *lvds_bl = | |
284 | dev_priv->lvds_bl; | |
285 | ||
286 | /*free sdvo panel mode*/ | |
287 | if (sdvo_lvds_vbt_mode) { | |
288 | dev_priv->sdvo_lvds_vbt_mode = NULL; | |
289 | kfree(sdvo_lvds_vbt_mode); | |
290 | } | |
291 | ||
292 | if (lfp_lvds_vbt_mode) { | |
293 | dev_priv->lfp_lvds_vbt_mode = NULL; | |
294 | kfree(lfp_lvds_vbt_mode); | |
295 | } | |
296 | ||
297 | if (lvds_bl) { | |
298 | dev_priv->lvds_bl = NULL; | |
299 | kfree(lvds_bl); | |
300 | } | |
301 | } |