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 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 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 89 __gop_query32(efi_system_table_t *sys_table_arg, 90 struct efi_graphics_output_protocol_32 *gop32, 91 struct efi_graphics_output_mode_info **info, 92 unsigned long *size, u64 *fb_base) 93 { 94 struct efi_graphics_output_protocol_mode_32 *mode; 95 efi_graphics_output_protocol_query_mode query_mode; 96 efi_status_t status; 97 unsigned long m; 98 99 m = gop32->mode; 100 mode = (struct efi_graphics_output_protocol_mode_32 *)m; 101 query_mode = (void *)(unsigned long)gop32->query_mode; 102 103 status = __efi_call_early(query_mode, (void *)gop32, mode->mode, size, 104 info); 105 if (status != EFI_SUCCESS) 106 return status; 107 108 *fb_base = mode->frame_buffer_base; 109 return status; 110 } 111 112 static efi_status_t 113 setup_gop32(efi_system_table_t *sys_table_arg, struct screen_info *si, 114 efi_guid_t *proto, unsigned long size, void **gop_handle) 115 { 116 struct efi_graphics_output_protocol_32 *gop32, *first_gop; 117 unsigned long nr_gops; 118 u16 width, height; 119 u32 pixels_per_scan_line; 120 u32 ext_lfb_base; 121 u64 fb_base; 122 struct efi_pixel_bitmask pixel_info; 123 int pixel_format; 124 efi_status_t status = EFI_NOT_FOUND; 125 u32 *handles = (u32 *)(unsigned long)gop_handle; 126 int i; 127 128 first_gop = NULL; 129 gop32 = NULL; 130 131 nr_gops = size / sizeof(u32); 132 for (i = 0; i < nr_gops; i++) { 133 struct efi_graphics_output_mode_info *info = NULL; 134 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID; 135 bool conout_found = false; 136 void *dummy = NULL; 137 efi_handle_t h = (efi_handle_t)(unsigned long)handles[i]; 138 u64 current_fb_base; 139 140 status = efi_call_early(handle_protocol, h, 141 proto, (void **)&gop32); 142 if (status != EFI_SUCCESS) 143 continue; 144 145 status = efi_call_early(handle_protocol, h, 146 &conout_proto, &dummy); 147 if (status == EFI_SUCCESS) 148 conout_found = true; 149 150 status = __gop_query32(sys_table_arg, gop32, &info, &size, 151 ¤t_fb_base); 152 if (status == EFI_SUCCESS && (!first_gop || conout_found) && 153 info->pixel_format != PIXEL_BLT_ONLY) { 154 /* 155 * Systems that use the UEFI Console Splitter may 156 * provide multiple GOP devices, not all of which are 157 * backed by real hardware. The workaround is to search 158 * for a GOP implementing the ConOut protocol, and if 159 * one isn't found, to just fall back to the first GOP. 160 */ 161 width = info->horizontal_resolution; 162 height = info->vertical_resolution; 163 pixel_format = info->pixel_format; 164 pixel_info = info->pixel_information; 165 pixels_per_scan_line = info->pixels_per_scan_line; 166 fb_base = current_fb_base; 167 168 /* 169 * Once we've found a GOP supporting ConOut, 170 * don't bother looking any further. 171 */ 172 first_gop = gop32; 173 if (conout_found) 174 break; 175 } 176 } 177 178 /* Did we find any GOPs? */ 179 if (!first_gop) 180 goto out; 181 182 /* EFI framebuffer */ 183 si->orig_video_isVGA = VIDEO_TYPE_EFI; 184 185 si->lfb_width = width; 186 si->lfb_height = height; 187 si->lfb_base = fb_base; 188 189 ext_lfb_base = (u64)(unsigned long)fb_base >> 32; 190 if (ext_lfb_base) { 191 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE; 192 si->ext_lfb_base = ext_lfb_base; 193 } 194 195 si->pages = 1; 196 197 setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format); 198 199 si->lfb_size = si->lfb_linelength * si->lfb_height; 200 201 si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS; 202 out: 203 return status; 204 } 205 206 static efi_status_t 207 __gop_query64(efi_system_table_t *sys_table_arg, 208 struct efi_graphics_output_protocol_64 *gop64, 209 struct efi_graphics_output_mode_info **info, 210 unsigned long *size, u64 *fb_base) 211 { 212 struct efi_graphics_output_protocol_mode_64 *mode; 213 efi_graphics_output_protocol_query_mode query_mode; 214 efi_status_t status; 215 unsigned long m; 216 217 m = gop64->mode; 218 mode = (struct efi_graphics_output_protocol_mode_64 *)m; 219 query_mode = (void *)(unsigned long)gop64->query_mode; 220 221 status = __efi_call_early(query_mode, (void *)gop64, mode->mode, size, 222 info); 223 if (status != EFI_SUCCESS) 224 return status; 225 226 *fb_base = mode->frame_buffer_base; 227 return status; 228 } 229 230 static efi_status_t 231 setup_gop64(efi_system_table_t *sys_table_arg, struct screen_info *si, 232 efi_guid_t *proto, unsigned long size, void **gop_handle) 233 { 234 struct efi_graphics_output_protocol_64 *gop64, *first_gop; 235 unsigned long nr_gops; 236 u16 width, height; 237 u32 pixels_per_scan_line; 238 u32 ext_lfb_base; 239 u64 fb_base; 240 struct efi_pixel_bitmask pixel_info; 241 int pixel_format; 242 efi_status_t status = EFI_NOT_FOUND; 243 u64 *handles = (u64 *)(unsigned long)gop_handle; 244 int i; 245 246 first_gop = NULL; 247 gop64 = NULL; 248 249 nr_gops = size / sizeof(u64); 250 for (i = 0; i < nr_gops; i++) { 251 struct efi_graphics_output_mode_info *info = NULL; 252 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID; 253 bool conout_found = false; 254 void *dummy = NULL; 255 efi_handle_t h = (efi_handle_t)(unsigned long)handles[i]; 256 u64 current_fb_base; 257 258 status = efi_call_early(handle_protocol, h, 259 proto, (void **)&gop64); 260 if (status != EFI_SUCCESS) 261 continue; 262 263 status = efi_call_early(handle_protocol, h, 264 &conout_proto, &dummy); 265 if (status == EFI_SUCCESS) 266 conout_found = true; 267 268 status = __gop_query64(sys_table_arg, gop64, &info, &size, 269 ¤t_fb_base); 270 if (status == EFI_SUCCESS && (!first_gop || conout_found) && 271 info->pixel_format != PIXEL_BLT_ONLY) { 272 /* 273 * Systems that use the UEFI Console Splitter may 274 * provide multiple GOP devices, not all of which are 275 * backed by real hardware. The workaround is to search 276 * for a GOP implementing the ConOut protocol, and if 277 * one isn't found, to just fall back to the first GOP. 278 */ 279 width = info->horizontal_resolution; 280 height = info->vertical_resolution; 281 pixel_format = info->pixel_format; 282 pixel_info = info->pixel_information; 283 pixels_per_scan_line = info->pixels_per_scan_line; 284 fb_base = current_fb_base; 285 286 /* 287 * Once we've found a GOP supporting ConOut, 288 * don't bother looking any further. 289 */ 290 first_gop = gop64; 291 if (conout_found) 292 break; 293 } 294 } 295 296 /* Did we find any GOPs? */ 297 if (!first_gop) 298 goto out; 299 300 /* EFI framebuffer */ 301 si->orig_video_isVGA = VIDEO_TYPE_EFI; 302 303 si->lfb_width = width; 304 si->lfb_height = height; 305 si->lfb_base = fb_base; 306 307 ext_lfb_base = (u64)(unsigned long)fb_base >> 32; 308 if (ext_lfb_base) { 309 si->capabilities |= VIDEO_CAPABILITY_64BIT_BASE; 310 si->ext_lfb_base = ext_lfb_base; 311 } 312 313 si->pages = 1; 314 315 setup_pixel_info(si, pixels_per_scan_line, pixel_info, pixel_format); 316 317 si->lfb_size = si->lfb_linelength * si->lfb_height; 318 319 si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS; 320 out: 321 return status; 322 } 323 324 /* 325 * See if we have Graphics Output Protocol 326 */ 327 efi_status_t efi_setup_gop(efi_system_table_t *sys_table_arg, 328 struct screen_info *si, efi_guid_t *proto, 329 unsigned long size) 330 { 331 efi_status_t status; 332 void **gop_handle = NULL; 333 334 status = efi_call_early(allocate_pool, EFI_LOADER_DATA, 335 size, (void **)&gop_handle); 336 if (status != EFI_SUCCESS) 337 return status; 338 339 status = efi_call_early(locate_handle, 340 EFI_LOCATE_BY_PROTOCOL, 341 proto, NULL, &size, gop_handle); 342 if (status != EFI_SUCCESS) 343 goto free_handle; 344 345 if (efi_is_64bit()) { 346 status = setup_gop64(sys_table_arg, si, proto, size, 347 gop_handle); 348 } else { 349 status = setup_gop32(sys_table_arg, si, proto, size, 350 gop_handle); 351 } 352 353 free_handle: 354 efi_call_early(free_pool, gop_handle); 355 return status; 356 } 357