1 /* -----------------------------------------------------------------------
2 *
3 * Copyright 2011 Intel Corporation; author Matt Fleming
4 *
5 * This file is part of the Linux kernel, and is made available under
6 * the terms of the GNU General Public License version 2.
7 *
8 * ----------------------------------------------------------------------- */
9
10 #include <linux/efi.h>
11 #include <linux/screen_info.h>
12 #include <asm/efi.h>
13 #include <asm/setup.h>
14
find_bits(unsigned long mask,u8 * pos,u8 * size)15 static void find_bits(unsigned long mask, u8 *pos, u8 *size)
16 {
17 u8 first, len;
18
19 first = 0;
20 len = 0;
21
22 if (mask) {
23 while (!(mask & 0x1)) {
24 mask = mask >> 1;
25 first++;
26 }
27
28 while (mask & 0x1) {
29 mask = mask >> 1;
30 len++;
31 }
32 }
33
34 *pos = first;
35 *size = len;
36 }
37
38 static void
setup_pixel_info(struct screen_info * si,u32 pixels_per_scan_line,struct efi_pixel_bitmask pixel_info,int pixel_format)39 setup_pixel_info(struct screen_info *si, u32 pixels_per_scan_line,
40 struct efi_pixel_bitmask pixel_info, int pixel_format)
41 {
42 if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
43 si->lfb_depth = 32;
44 si->lfb_linelength = pixels_per_scan_line * 4;
45 si->red_size = 8;
46 si->red_pos = 0;
47 si->green_size = 8;
48 si->green_pos = 8;
49 si->blue_size = 8;
50 si->blue_pos = 16;
51 si->rsvd_size = 8;
52 si->rsvd_pos = 24;
53 } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
54 si->lfb_depth = 32;
55 si->lfb_linelength = pixels_per_scan_line * 4;
56 si->red_size = 8;
57 si->red_pos = 16;
58 si->green_size = 8;
59 si->green_pos = 8;
60 si->blue_size = 8;
61 si->blue_pos = 0;
62 si->rsvd_size = 8;
63 si->rsvd_pos = 24;
64 } else if (pixel_format == PIXEL_BIT_MASK) {
65 find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
66 find_bits(pixel_info.green_mask, &si->green_pos,
67 &si->green_size);
68 find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
69 find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
70 &si->rsvd_size);
71 si->lfb_depth = si->red_size + si->green_size +
72 si->blue_size + si->rsvd_size;
73 si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
74 } else {
75 si->lfb_depth = 4;
76 si->lfb_linelength = si->lfb_width / 2;
77 si->red_size = 0;
78 si->red_pos = 0;
79 si->green_size = 0;
80 si->green_pos = 0;
81 si->blue_size = 0;
82 si->blue_pos = 0;
83 si->rsvd_size = 0;
84 si->rsvd_pos = 0;
85 }
86 }
87
88 static efi_status_t
setup_gop32(efi_system_table_t * sys_table_arg,struct screen_info * si,efi_guid_t * proto,unsigned long size,void ** gop_handle)89 setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si,
90 efi_guid_t *proto, unsigned long size, void **gop_handle)
91 {
92 struct efi_graphics_output_protocol_32 *gop32, *first_gop;
93 unsigned long nr_gops;
94 u16 width, height;
95 u32 pixels_per_scan_line;
96 u32 ext_lfb_base;
97 u64 fb_base;
98 struct efi_pixel_bitmask pixel_info;
99 int pixel_format;
100 efi_status_t status;
101 u32 *handles = (u32 *)(unsigned long)gop_handle;
102 int i;
103
104 first_gop = NULL;
105 gop32 = NULL;
106
107 nr_gops = size / sizeof(u32);
108 for (i = 0; i < nr_gops; i++) {
109 struct efi_graphics_output_protocol_mode_32 *mode;
110 struct efi_graphics_output_mode_info *info = NULL;
111 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
112 bool conout_found = false;
113 void *dummy = NULL;
114 efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
115 u64 current_fb_base;
116
117 status = efi_call_early(handle_protocol, h,
118 proto, (void **)&gop32);
119 if (status != EFI_SUCCESS)
120 continue;
121
122 status = efi_call_early(handle_protocol, h,
123 &conout_proto, &dummy);
124 if (status == EFI_SUCCESS)
125 conout_found = true;
126
127 mode = (void *)(unsigned long)gop32->mode;
128 info = (void *)(unsigned long)mode->info;
129 current_fb_base = mode->frame_buffer_base;
130
131 if ((!first_gop || conout_found) &&
132 info->pixel_format != PIXEL_BLT_ONLY) {
133 /*
134 * Systems that use the UEFI Console Splitter may
135 * provide multiple GOP devices, not all of which are
136 * backed by real hardware. The workaround is to search
137 * for a GOP implementing the ConOut protocol, and if
138 * one isn't found, to just fall back to the first GOP.
139 */
140 width = info->horizontal_resolution;
141 height = info->vertical_resolution;
142 pixel_format = info->pixel_format;
143 pixel_info = info->pixel_information;
144 pixels_per_scan_line = info->pixels_per_scan_line;
145 fb_base = current_fb_base;
146
147 /*
148 * Once we've found a GOP supporting ConOut,
149 * don't bother looking any further.
150 */
151 first_gop = gop32;
152 if (conout_found)
153 break;
154 }
155 }
156
157 /* Did we find any GOPs? */
158 if (!first_gop)
159 return EFI_NOT_FOUND;
160
161 /* EFI framebuffer */
162 si->orig_video_isVGA = VIDEO_TYPE_EFI;
163
164 si->lfb_width = width;
165 si->lfb_height = height;
166 si->lfb_base = fb_base;
167
168 ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
169 if (ext_lfb_base) {
170 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
171 si->ext_lfb_base = ext_lfb_base;
172 }
173
174 si->pages = 1;
175
176 setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
177
178 si->lfb_size = si->lfb_linelength * si->lfb_height;
179
180 si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
181
182 return EFI_SUCCESS;
183 }
184
185 static efi_status_t
setup_gop64(efi_system_table_t * sys_table_arg,struct screen_info * si,efi_guid_t * proto,unsigned long size,void ** gop_handle)186 setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si,
187 efi_guid_t *proto, unsigned long size, void **gop_handle)
188 {
189 struct efi_graphics_output_protocol_64 *gop64, *first_gop;
190 unsigned long nr_gops;
191 u16 width, height;
192 u32 pixels_per_scan_line;
193 u32 ext_lfb_base;
194 u64 fb_base;
195 struct efi_pixel_bitmask pixel_info;
196 int pixel_format;
197 efi_status_t status;
198 u64 *handles = (u64 *)(unsigned long)gop_handle;
199 int i;
200
201 first_gop = NULL;
202 gop64 = NULL;
203
204 nr_gops = size / sizeof(u64);
205 for (i = 0; i < nr_gops; i++) {
206 struct efi_graphics_output_protocol_mode_64 *mode;
207 struct efi_graphics_output_mode_info *info = NULL;
208 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
209 bool conout_found = false;
210 void *dummy = NULL;
211 efi_handle_t h = (efi_handle_t)(unsigned long)handles[i];
212 u64 current_fb_base;
213
214 status = efi_call_early(handle_protocol, h,
215 proto, (void **)&gop64);
216 if (status != EFI_SUCCESS)
217 continue;
218
219 status = efi_call_early(handle_protocol, h,
220 &conout_proto, &dummy);
221 if (status == EFI_SUCCESS)
222 conout_found = true;
223
224 mode = (void *)(unsigned long)gop64->mode;
225 info = (void *)(unsigned long)mode->info;
226 current_fb_base = mode->frame_buffer_base;
227
228 if ((!first_gop || conout_found) &&
229 info->pixel_format != PIXEL_BLT_ONLY) {
230 /*
231 * Systems that use the UEFI Console Splitter may
232 * provide multiple GOP devices, not all of which are
233 * backed by real hardware. The workaround is to search
234 * for a GOP implementing the ConOut protocol, and if
235 * one isn't found, to just fall back to the first GOP.
236 */
237 width = info->horizontal_resolution;
238 height = info->vertical_resolution;
239 pixel_format = info->pixel_format;
240 pixel_info = info->pixel_information;
241 pixels_per_scan_line = info->pixels_per_scan_line;
242 fb_base = current_fb_base;
243
244 /*
245 * Once we've found a GOP supporting ConOut,
246 * don't bother looking any further.
247 */
248 first_gop = gop64;
249 if (conout_found)
250 break;
251 }
252 }
253
254 /* Did we find any GOPs? */
255 if (!first_gop)
256 return EFI_NOT_FOUND;
257
258 /* EFI framebuffer */
259 si->orig_video_isVGA = VIDEO_TYPE_EFI;
260
261 si->lfb_width = width;
262 si->lfb_height = height;
263 si->lfb_base = fb_base;
264
265 ext_lfb_base = (u64)(unsigned long)fb_base >> 32;
266 if (ext_lfb_base) {
267 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE;
268 si->ext_lfb_base = ext_lfb_base;
269 }
270
271 si->pages = 1;
272
273 setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format);
274
275 si->lfb_size = si->lfb_linelength * si->lfb_height;
276
277 si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
278
279 return EFI_SUCCESS;
280 }
281
282 /*
283 * See if we have Graphics Output Protocol
284 */
efi_setup_gop(efi_system_table_t * sys_table_arg,struct screen_info * si,efi_guid_t * proto,unsigned long size)285 efi_status_t efi_setup_gop(efi_system_table_t *sys_table_arg,
286 struct screen_info *si, efi_guid_t *proto,
287 unsigned long size)
288 {
289 efi_status_t status;
290 void **gop_handle = NULL;
291
292 status = efi_call_early(allocate_pool, EFI_LOADER_DATA,
293 size, (void **)&gop_handle);
294 if (status != EFI_SUCCESS)
295 return status;
296
297 status = efi_call_early(locate_handle,
298 EFI_LOCATE_BY_PROTOCOL,
299 proto, NULL, &size, gop_handle);
300 if (status != EFI_SUCCESS)
301 goto free_handle;
302
303 if (efi_is_64bit()) {
304 status = setup_gop64(sys_table_arg, si, proto, size,
305 gop_handle);
306 } else {
307 status = setup_gop32(sys_table_arg, si, proto, size,
308 gop_handle);
309 }
310
311 free_handle:
312 efi_call_early(free_pool, gop_handle);
313 return status;
314 }
315