?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/efi: Enforce CONFIG_RELOCATABLE for EFI boot stub
[linux/fpc-iii.git] / arch / x86 / boot / compressed / eboot.c
blob9b883a89aad5244ce0b7a13e35cc3d87f99be843
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/pci.h>
12 #include <asm/efi.h>
13 #include <asm/setup.h>
14 #include <asm/desc.h>
15
16 #undef memcpy /* Use memcpy from misc.c */
17
18 #include "eboot.h"
19
20 static efi_system_table_t *sys_table;
21
22 static void efi_char16_printk(efi_char16_t *str)
23 {
24 struct efi_simple_text_output_protocol *out;
25
26 out = (struct efi_simple_text_output_protocol *)sys_table->con_out;
27 efi_call_phys2(out->output_string, out, str);
28 }
29
30 static void efi_printk(char *str)
31 {
32 char *s8;
33
34 for (s8 = str; *s8; s8++) {
35 efi_char16_t ch[2] = { 0 };
36
37 ch[0] = *s8;
38 if (*s8 == '\n') {
39 efi_char16_t nl[2] = { '\r', 0 };
40 efi_char16_printk(nl);
41 }
42
43 efi_char16_printk(ch);
44 }
45 }
46
47 static efi_status_t __get_map(efi_memory_desc_t **map, unsigned long *map_size,
48 unsigned long *desc_size)
49 {
50 efi_memory_desc_t *m = NULL;
51 efi_status_t status;
52 unsigned long key;
53 u32 desc_version;
54
55 *map_size = sizeof(*m) * 32;
56 again:
57 /*
58 * Add an additional efi_memory_desc_t because we're doing an
59 * allocation which may be in a new descriptor region.
60 */
61 *map_size += sizeof(*m);
62 status = efi_call_phys3(sys_table->boottime->allocate_pool,
63 EFI_LOADER_DATA, *map_size, (void **)&m);
64 if (status != EFI_SUCCESS)
65 goto fail;
66
67 status = efi_call_phys5(sys_table->boottime->get_memory_map, map_size,
68 m, &key, desc_size, &desc_version);
69 if (status == EFI_BUFFER_TOO_SMALL) {
70 efi_call_phys1(sys_table->boottime->free_pool, m);
71 goto again;
72 }
73
74 if (status != EFI_SUCCESS)
75 efi_call_phys1(sys_table->boottime->free_pool, m);
76
77 fail:
78 *map = m;
79 return status;
80 }
81
82 /*
83 * Allocate at the highest possible address that is not above 'max'.
84 */
85 static efi_status_t high_alloc(unsigned long size, unsigned long align,
86 unsigned long *addr, unsigned long max)
87 {
88 unsigned long map_size, desc_size;
89 efi_memory_desc_t *map;
90 efi_status_t status;
91 unsigned long nr_pages;
92 u64 max_addr = 0;
93 int i;
94
95 status = __get_map(&map, &map_size, &desc_size);
96 if (status != EFI_SUCCESS)
97 goto fail;
98
99 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
100 again:
101 for (i = 0; i < map_size / desc_size; i++) {
102 efi_memory_desc_t *desc;
103 unsigned long m = (unsigned long)map;
104 u64 start, end;
105
106 desc = (efi_memory_desc_t *)(m + (i * desc_size));
107 if (desc->type != EFI_CONVENTIONAL_MEMORY)
108 continue;
109
110 if (desc->num_pages < nr_pages)
111 continue;
112
113 start = desc->phys_addr;
114 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
115
116 if ((start + size) > end || (start + size) > max)
117 continue;
118
119 if (end - size > max)
120 end = max;
121
122 if (round_down(end - size, align) < start)
123 continue;
124
125 start = round_down(end - size, align);
126
127 /*
128 * Don't allocate at 0x0. It will confuse code that
129 * checks pointers against NULL.
130 */
131 if (start == 0x0)
132 continue;
133
134 if (start > max_addr)
135 max_addr = start;
136 }
137
138 if (!max_addr)
139 status = EFI_NOT_FOUND;
140 else {
141 status = efi_call_phys4(sys_table->boottime->allocate_pages,
142 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
143 nr_pages, &max_addr);
144 if (status != EFI_SUCCESS) {
145 max = max_addr;
146 max_addr = 0;
147 goto again;
148 }
149
150 *addr = max_addr;
151 }
152
153 free_pool:
154 efi_call_phys1(sys_table->boottime->free_pool, map);
155
156 fail:
157 return status;
158 }
159
160 /*
161 * Allocate at the lowest possible address.
162 */
163 static efi_status_t low_alloc(unsigned long size, unsigned long align,
164 unsigned long *addr)
165 {
166 unsigned long map_size, desc_size;
167 efi_memory_desc_t *map;
168 efi_status_t status;
169 unsigned long nr_pages;
170 int i;
171
172 status = __get_map(&map, &map_size, &desc_size);
173 if (status != EFI_SUCCESS)
174 goto fail;
175
176 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
177 for (i = 0; i < map_size / desc_size; i++) {
178 efi_memory_desc_t *desc;
179 unsigned long m = (unsigned long)map;
180 u64 start, end;
181
182 desc = (efi_memory_desc_t *)(m + (i * desc_size));
183
184 if (desc->type != EFI_CONVENTIONAL_MEMORY)
185 continue;
186
187 if (desc->num_pages < nr_pages)
188 continue;
189
190 start = desc->phys_addr;
191 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
192
193 /*
194 * Don't allocate at 0x0. It will confuse code that
195 * checks pointers against NULL. Skip the first 8
196 * bytes so we start at a nice even number.
197 */
198 if (start == 0x0)
199 start += 8;
200
201 start = round_up(start, align);
202 if ((start + size) > end)
203 continue;
204
205 status = efi_call_phys4(sys_table->boottime->allocate_pages,
206 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
207 nr_pages, &start);
208 if (status == EFI_SUCCESS) {
209 *addr = start;
210 break;
211 }
212 }
213
214 if (i == map_size / desc_size)
215 status = EFI_NOT_FOUND;
216
217 free_pool:
218 efi_call_phys1(sys_table->boottime->free_pool, map);
219 fail:
220 return status;
221 }
222
223 static void low_free(unsigned long size, unsigned long addr)
224 {
225 unsigned long nr_pages;
226
227 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
228 efi_call_phys2(sys_table->boottime->free_pages, addr, nr_pages);
229 }
230
231 static void find_bits(unsigned long mask, u8 *pos, u8 *size)
232 {
233 u8 first, len;
234
235 first = 0;
236 len = 0;
237
238 if (mask) {
239 while (!(mask & 0x1)) {
240 mask = mask >> 1;
241 first++;
242 }
243
244 while (mask & 0x1) {
245 mask = mask >> 1;
246 len++;
247 }
248 }
249
250 *pos = first;
251 *size = len;
252 }
253
254 static efi_status_t setup_efi_pci(struct boot_params *params)
255 {
256 efi_pci_io_protocol *pci;
257 efi_status_t status;
258 void **pci_handle;
259 efi_guid_t pci_proto = EFI_PCI_IO_PROTOCOL_GUID;
260 unsigned long nr_pci, size = 0;
261 int i;
262 struct setup_data *data;
263
264 data = (struct setup_data *)(unsigned long)params->hdr.setup_data;
265
266 while (data && data->next)
267 data = (struct setup_data *)(unsigned long)data->next;
268
269 status = efi_call_phys5(sys_table->boottime->locate_handle,
270 EFI_LOCATE_BY_PROTOCOL, &pci_proto,
271 NULL, &size, pci_handle);
272
273 if (status == EFI_BUFFER_TOO_SMALL) {
274 status = efi_call_phys3(sys_table->boottime->allocate_pool,
275 EFI_LOADER_DATA, size, &pci_handle);
276
277 if (status != EFI_SUCCESS)
278 return status;
279
280 status = efi_call_phys5(sys_table->boottime->locate_handle,
281 EFI_LOCATE_BY_PROTOCOL, &pci_proto,
282 NULL, &size, pci_handle);
283 }
284
285 if (status != EFI_SUCCESS)
286 goto free_handle;
287
288 nr_pci = size / sizeof(void *);
289 for (i = 0; i < nr_pci; i++) {
290 void *h = pci_handle[i];
291 uint64_t attributes;
292 struct pci_setup_rom *rom;
293
294 status = efi_call_phys3(sys_table->boottime->handle_protocol,
295 h, &pci_proto, &pci);
296
297 if (status != EFI_SUCCESS)
298 continue;
299
300 if (!pci)
301 continue;
302
303 #ifdef CONFIG_X86_64
304 status = efi_call_phys4(pci->attributes, pci,
305 EfiPciIoAttributeOperationGet, 0,
306 &attributes);
307 #else
308 status = efi_call_phys5(pci->attributes, pci,
309 EfiPciIoAttributeOperationGet, 0, 0,
310 &attributes);
311 #endif
312 if (status != EFI_SUCCESS)
313 continue;
314
315 if (!pci->romimage || !pci->romsize)
316 continue;
317
318 size = pci->romsize + sizeof(*rom);
319
320 status = efi_call_phys3(sys_table->boottime->allocate_pool,
321 EFI_LOADER_DATA, size, &rom);
322
323 if (status != EFI_SUCCESS)
324 continue;
325
326 rom->data.type = SETUP_PCI;
327 rom->data.len = size - sizeof(struct setup_data);
328 rom->data.next = 0;
329 rom->pcilen = pci->romsize;
330
331 status = efi_call_phys5(pci->pci.read, pci,
332 EfiPciIoWidthUint16, PCI_VENDOR_ID,
333 1, &(rom->vendor));
334
335 if (status != EFI_SUCCESS)
336 goto free_struct;
337
338 status = efi_call_phys5(pci->pci.read, pci,
339 EfiPciIoWidthUint16, PCI_DEVICE_ID,
340 1, &(rom->devid));
341
342 if (status != EFI_SUCCESS)
343 goto free_struct;
344
345 status = efi_call_phys5(pci->get_location, pci,
346 &(rom->segment), &(rom->bus),
347 &(rom->device), &(rom->function));
348
349 if (status != EFI_SUCCESS)
350 goto free_struct;
351
352 memcpy(rom->romdata, pci->romimage, pci->romsize);
353
354 if (data)
355 data->next = (unsigned long)rom;
356 else
357 params->hdr.setup_data = (unsigned long)rom;
358
359 data = (struct setup_data *)rom;
360
361 continue;
362 free_struct:
363 efi_call_phys1(sys_table->boottime->free_pool, rom);
364 }
365
366 free_handle:
367 efi_call_phys1(sys_table->boottime->free_pool, pci_handle);
368 return status;
369 }
370
371 /*
372 * See if we have Graphics Output Protocol
373 */
374 static efi_status_t setup_gop(struct screen_info *si, efi_guid_t *proto,
375 unsigned long size)
376 {
377 struct efi_graphics_output_protocol *gop, *first_gop;
378 struct efi_pixel_bitmask pixel_info;
379 unsigned long nr_gops;
380 efi_status_t status;
381 void **gop_handle;
382 u16 width, height;
383 u32 fb_base, fb_size;
384 u32 pixels_per_scan_line;
385 int pixel_format;
386 int i;
387
388 status = efi_call_phys3(sys_table->boottime->allocate_pool,
389 EFI_LOADER_DATA, size, &gop_handle);
390 if (status != EFI_SUCCESS)
391 return status;
392
393 status = efi_call_phys5(sys_table->boottime->locate_handle,
394 EFI_LOCATE_BY_PROTOCOL, proto,
395 NULL, &size, gop_handle);
396 if (status != EFI_SUCCESS)
397 goto free_handle;
398
399 first_gop = NULL;
400
401 nr_gops = size / sizeof(void *);
402 for (i = 0; i < nr_gops; i++) {
403 struct efi_graphics_output_mode_info *info;
404 efi_guid_t conout_proto = EFI_CONSOLE_OUT_DEVICE_GUID;
405 bool conout_found = false;
406 void *dummy;
407 void *h = gop_handle[i];
408
409 status = efi_call_phys3(sys_table->boottime->handle_protocol,
410 h, proto, &gop);
411 if (status != EFI_SUCCESS)
412 continue;
413
414 status = efi_call_phys3(sys_table->boottime->handle_protocol,
415 h, &conout_proto, &dummy);
416
417 if (status == EFI_SUCCESS)
418 conout_found = true;
419
420 status = efi_call_phys4(gop->query_mode, gop,
421 gop->mode->mode, &size, &info);
422 if (status == EFI_SUCCESS && (!first_gop || conout_found)) {
423 /*
424 * Systems that use the UEFI Console Splitter may
425 * provide multiple GOP devices, not all of which are
426 * backed by real hardware. The workaround is to search
427 * for a GOP implementing the ConOut protocol, and if
428 * one isn't found, to just fall back to the first GOP.
429 */
430 width = info->horizontal_resolution;
431 height = info->vertical_resolution;
432 fb_base = gop->mode->frame_buffer_base;
433 fb_size = gop->mode->frame_buffer_size;
434 pixel_format = info->pixel_format;
435 pixel_info = info->pixel_information;
436 pixels_per_scan_line = info->pixels_per_scan_line;
437
438 /*
439 * Once we've found a GOP supporting ConOut,
440 * don't bother looking any further.
441 */
442 first_gop = gop;
443 if (conout_found)
444 break;
445 }
446 }
447
448 /* Did we find any GOPs? */
449 if (!first_gop)
450 goto free_handle;
451
452 /* EFI framebuffer */
453 si->orig_video_isVGA = VIDEO_TYPE_EFI;
454
455 si->lfb_width = width;
456 si->lfb_height = height;
457 si->lfb_base = fb_base;
458 si->pages = 1;
459
460 if (pixel_format == PIXEL_RGB_RESERVED_8BIT_PER_COLOR) {
461 si->lfb_depth = 32;
462 si->lfb_linelength = pixels_per_scan_line * 4;
463 si->red_size = 8;
464 si->red_pos = 0;
465 si->green_size = 8;
466 si->green_pos = 8;
467 si->blue_size = 8;
468 si->blue_pos = 16;
469 si->rsvd_size = 8;
470 si->rsvd_pos = 24;
471 } else if (pixel_format == PIXEL_BGR_RESERVED_8BIT_PER_COLOR) {
472 si->lfb_depth = 32;
473 si->lfb_linelength = pixels_per_scan_line * 4;
474 si->red_size = 8;
475 si->red_pos = 16;
476 si->green_size = 8;
477 si->green_pos = 8;
478 si->blue_size = 8;
479 si->blue_pos = 0;
480 si->rsvd_size = 8;
481 si->rsvd_pos = 24;
482 } else if (pixel_format == PIXEL_BIT_MASK) {
483 find_bits(pixel_info.red_mask, &si->red_pos, &si->red_size);
484 find_bits(pixel_info.green_mask, &si->green_pos,
485 &si->green_size);
486 find_bits(pixel_info.blue_mask, &si->blue_pos, &si->blue_size);
487 find_bits(pixel_info.reserved_mask, &si->rsvd_pos,
488 &si->rsvd_size);
489 si->lfb_depth = si->red_size + si->green_size +
490 si->blue_size + si->rsvd_size;
491 si->lfb_linelength = (pixels_per_scan_line * si->lfb_depth) / 8;
492 } else {
493 si->lfb_depth = 4;
494 si->lfb_linelength = si->lfb_width / 2;
495 si->red_size = 0;
496 si->red_pos = 0;
497 si->green_size = 0;
498 si->green_pos = 0;
499 si->blue_size = 0;
500 si->blue_pos = 0;
501 si->rsvd_size = 0;
502 si->rsvd_pos = 0;
503 }
504
505 si->lfb_size = si->lfb_linelength * si->lfb_height;
506
507 si->capabilities |= VIDEO_CAPABILITY_SKIP_QUIRKS;
508
509 free_handle:
510 efi_call_phys1(sys_table->boottime->free_pool, gop_handle);
511 return status;
512 }
513
514 /*
515 * See if we have Universal Graphics Adapter (UGA) protocol
516 */
517 static efi_status_t setup_uga(struct screen_info *si, efi_guid_t *uga_proto,
518 unsigned long size)
519 {
520 struct efi_uga_draw_protocol *uga, *first_uga;
521 unsigned long nr_ugas;
522 efi_status_t status;
523 u32 width, height;
524 void **uga_handle = NULL;
525 int i;
526
527 status = efi_call_phys3(sys_table->boottime->allocate_pool,
528 EFI_LOADER_DATA, size, &uga_handle);
529 if (status != EFI_SUCCESS)
530 return status;
531
532 status = efi_call_phys5(sys_table->boottime->locate_handle,
533 EFI_LOCATE_BY_PROTOCOL, uga_proto,
534 NULL, &size, uga_handle);
535 if (status != EFI_SUCCESS)
536 goto free_handle;
537
538 first_uga = NULL;
539
540 nr_ugas = size / sizeof(void *);
541 for (i = 0; i < nr_ugas; i++) {
542 efi_guid_t pciio_proto = EFI_PCI_IO_PROTOCOL_GUID;
543 void *handle = uga_handle[i];
544 u32 w, h, depth, refresh;
545 void *pciio;
546
547 status = efi_call_phys3(sys_table->boottime->handle_protocol,
548 handle, uga_proto, &uga);
549 if (status != EFI_SUCCESS)
550 continue;
551
552 efi_call_phys3(sys_table->boottime->handle_protocol,
553 handle, &pciio_proto, &pciio);
554
555 status = efi_call_phys5(uga->get_mode, uga, &w, &h,
556 &depth, &refresh);
557 if (status == EFI_SUCCESS && (!first_uga || pciio)) {
558 width = w;
559 height = h;
560
561 /*
562 * Once we've found a UGA supporting PCIIO,
563 * don't bother looking any further.
564 */
565 if (pciio)
566 break;
567
568 first_uga = uga;
569 }
570 }
571
572 if (!first_uga)
573 goto free_handle;
574
575 /* EFI framebuffer */
576 si->orig_video_isVGA = VIDEO_TYPE_EFI;
577
578 si->lfb_depth = 32;
579 si->lfb_width = width;
580 si->lfb_height = height;
581
582 si->red_size = 8;
583 si->red_pos = 16;
584 si->green_size = 8;
585 si->green_pos = 8;
586 si->blue_size = 8;
587 si->blue_pos = 0;
588 si->rsvd_size = 8;
589 si->rsvd_pos = 24;
590
591
592 free_handle:
593 efi_call_phys1(sys_table->boottime->free_pool, uga_handle);
594 return status;
595 }
596
597 void setup_graphics(struct boot_params *boot_params)
598 {
599 efi_guid_t graphics_proto = EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID;
600 struct screen_info *si;
601 efi_guid_t uga_proto = EFI_UGA_PROTOCOL_GUID;
602 efi_status_t status;
603 unsigned long size;
604 void **gop_handle = NULL;
605 void **uga_handle = NULL;
606
607 si = &boot_params->screen_info;
608 memset(si, 0, sizeof(*si));
609
610 size = 0;
611 status = efi_call_phys5(sys_table->boottime->locate_handle,
612 EFI_LOCATE_BY_PROTOCOL, &graphics_proto,
613 NULL, &size, gop_handle);
614 if (status == EFI_BUFFER_TOO_SMALL)
615 status = setup_gop(si, &graphics_proto, size);
616
617 if (status != EFI_SUCCESS) {
618 size = 0;
619 status = efi_call_phys5(sys_table->boottime->locate_handle,
620 EFI_LOCATE_BY_PROTOCOL, &uga_proto,
621 NULL, &size, uga_handle);
622 if (status == EFI_BUFFER_TOO_SMALL)
623 setup_uga(si, &uga_proto, size);
624 }
625 }
626
627 struct initrd {
628 efi_file_handle_t *handle;
629 u64 size;
630 };
631
632 /*
633 * Check the cmdline for a LILO-style initrd= arguments.
634 *
635 * We only support loading an initrd from the same filesystem as the
636 * kernel image.
637 */
638 static efi_status_t handle_ramdisks(efi_loaded_image_t *image,
639 struct setup_header *hdr)
640 {
641 struct initrd *initrds;
642 unsigned long initrd_addr;
643 efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
644 u64 initrd_total;
645 efi_file_io_interface_t *io;
646 efi_file_handle_t *fh;
647 efi_status_t status;
648 int nr_initrds;
649 char *str;
650 int i, j, k;
651
652 initrd_addr = 0;
653 initrd_total = 0;
654
655 str = (char *)(unsigned long)hdr->cmd_line_ptr;
656
657 j = 0; /* See close_handles */
658
659 if (!str || !*str)
660 return EFI_SUCCESS;
661
662 for (nr_initrds = 0; *str; nr_initrds++) {
663 str = strstr(str, "initrd=");
664 if (!str)
665 break;
666
667 str += 7;
668
669 /* Skip any leading slashes */
670 while (*str == '/' || *str == '\\')
671 str++;
672
673 while (*str && *str != ' ' && *str != '\n')
674 str++;
675 }
676
677 if (!nr_initrds)
678 return EFI_SUCCESS;
679
680 status = efi_call_phys3(sys_table->boottime->allocate_pool,
681 EFI_LOADER_DATA,
682 nr_initrds * sizeof(*initrds),
683 &initrds);
684 if (status != EFI_SUCCESS) {
685 efi_printk("Failed to alloc mem for initrds\n");
686 goto fail;
687 }
688
689 str = (char *)(unsigned long)hdr->cmd_line_ptr;
690 for (i = 0; i < nr_initrds; i++) {
691 struct initrd *initrd;
692 efi_file_handle_t *h;
693 efi_file_info_t *info;
694 efi_char16_t filename_16[256];
695 unsigned long info_sz;
696 efi_guid_t info_guid = EFI_FILE_INFO_ID;
697 efi_char16_t *p;
698 u64 file_sz;
699
700 str = strstr(str, "initrd=");
701 if (!str)
702 break;
703
704 str += 7;
705
706 initrd = &initrds[i];
707 p = filename_16;
708
709 /* Skip any leading slashes */
710 while (*str == '/' || *str == '\\')
711 str++;
712
713 while (*str && *str != ' ' && *str != '\n') {
714 if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
715 break;
716
717 if (*str == '/') {
718 *p++ = '\\';
719 *str++;
720 } else {
721 *p++ = *str++;
722 }
723 }
724
725 *p = '\0';
726
727 /* Only open the volume once. */
728 if (!i) {
729 efi_boot_services_t *boottime;
730
731 boottime = sys_table->boottime;
732
733 status = efi_call_phys3(boottime->handle_protocol,
734 image->device_handle, &fs_proto, &io);
735 if (status != EFI_SUCCESS) {
736 efi_printk("Failed to handle fs_proto\n");
737 goto free_initrds;
738 }
739
740 status = efi_call_phys2(io->open_volume, io, &fh);
741 if (status != EFI_SUCCESS) {
742 efi_printk("Failed to open volume\n");
743 goto free_initrds;
744 }
745 }
746
747 status = efi_call_phys5(fh->open, fh, &h, filename_16,
748 EFI_FILE_MODE_READ, (u64)0);
749 if (status != EFI_SUCCESS) {
750 efi_printk("Failed to open initrd file: ");
751 efi_char16_printk(filename_16);
752 efi_printk("\n");
753 goto close_handles;
754 }
755
756 initrd->handle = h;
757
758 info_sz = 0;
759 status = efi_call_phys4(h->get_info, h, &info_guid,
760 &info_sz, NULL);
761 if (status != EFI_BUFFER_TOO_SMALL) {
762 efi_printk("Failed to get initrd info size\n");
763 goto close_handles;
764 }
765
766 grow:
767 status = efi_call_phys3(sys_table->boottime->allocate_pool,
768 EFI_LOADER_DATA, info_sz, &info);
769 if (status != EFI_SUCCESS) {
770 efi_printk("Failed to alloc mem for initrd info\n");
771 goto close_handles;
772 }
773
774 status = efi_call_phys4(h->get_info, h, &info_guid,
775 &info_sz, info);
776 if (status == EFI_BUFFER_TOO_SMALL) {
777 efi_call_phys1(sys_table->boottime->free_pool, info);
778 goto grow;
779 }
780
781 file_sz = info->file_size;
782 efi_call_phys1(sys_table->boottime->free_pool, info);
783
784 if (status != EFI_SUCCESS) {
785 efi_printk("Failed to get initrd info\n");
786 goto close_handles;
787 }
788
789 initrd->size = file_sz;
790 initrd_total += file_sz;
791 }
792
793 if (initrd_total) {
794 unsigned long addr;
795
796 /*
797 * Multiple initrd's need to be at consecutive
798 * addresses in memory, so allocate enough memory for
799 * all the initrd's.
800 */
801 status = high_alloc(initrd_total, 0x1000,
802 &initrd_addr, hdr->initrd_addr_max);
803 if (status != EFI_SUCCESS) {
804 efi_printk("Failed to alloc highmem for initrds\n");
805 goto close_handles;
806 }
807
808 /* We've run out of free low memory. */
809 if (initrd_addr > hdr->initrd_addr_max) {
810 efi_printk("We've run out of free low memory\n");
811 status = EFI_INVALID_PARAMETER;
812 goto free_initrd_total;
813 }
814
815 addr = initrd_addr;
816 for (j = 0; j < nr_initrds; j++) {
817 u64 size;
818
819 size = initrds[j].size;
820 while (size) {
821 u64 chunksize;
822 if (size > EFI_READ_CHUNK_SIZE)
823 chunksize = EFI_READ_CHUNK_SIZE;
824 else
825 chunksize = size;
826 status = efi_call_phys3(fh->read,
827 initrds[j].handle,
828 &chunksize, addr);
829 if (status != EFI_SUCCESS) {
830 efi_printk("Failed to read initrd\n");
831 goto free_initrd_total;
832 }
833 addr += chunksize;
834 size -= chunksize;
835 }
836
837 efi_call_phys1(fh->close, initrds[j].handle);
838 }
839
840 }
841
842 efi_call_phys1(sys_table->boottime->free_pool, initrds);
843
844 hdr->ramdisk_image = initrd_addr;
845 hdr->ramdisk_size = initrd_total;
846
847 return status;
848
849 free_initrd_total:
850 low_free(initrd_total, initrd_addr);
851
852 close_handles:
853 for (k = j; k < i; k++)
854 efi_call_phys1(fh->close, initrds[k].handle);
855 free_initrds:
856 efi_call_phys1(sys_table->boottime->free_pool, initrds);
857 fail:
858 hdr->ramdisk_image = 0;
859 hdr->ramdisk_size = 0;
860
861 return status;
862 }
863
864 /*
865 * Because the x86 boot code expects to be passed a boot_params we
866 * need to create one ourselves (usually the bootloader would create
867 * one for us).
868 *
869 * The caller is responsible for filling out ->code32_start in the
870 * returned boot_params.
871 */
872 struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
873 {
874 struct boot_params *boot_params;
875 struct sys_desc_table *sdt;
876 struct apm_bios_info *bi;
877 struct setup_header *hdr;
878 struct efi_info *efi;
879 efi_loaded_image_t *image;
880 void *options;
881 u32 load_options_size;
882 efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
883 int options_size = 0;
884 efi_status_t status;
885 unsigned long cmdline;
886 u16 *s2;
887 u8 *s1;
888 int i;
889
890 sys_table = _table;
891
892 /* Check if we were booted by the EFI firmware */
893 if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
894 return NULL;
895
896 status = efi_call_phys3(sys_table->boottime->handle_protocol,
897 handle, &proto, (void *)&image);
898 if (status != EFI_SUCCESS) {
899 efi_printk("Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
900 return NULL;
901 }
902
903 status = low_alloc(0x4000, 1, (unsigned long *)&boot_params);
904 if (status != EFI_SUCCESS) {
905 efi_printk("Failed to alloc lowmem for boot params\n");
906 return NULL;
907 }
908
909 memset(boot_params, 0x0, 0x4000);
910
911 hdr = &boot_params->hdr;
912 efi = &boot_params->efi_info;
913 bi = &boot_params->apm_bios_info;
914 sdt = &boot_params->sys_desc_table;
915
916 /* Copy the second sector to boot_params */
917 memcpy(&hdr->jump, image->image_base + 512, 512);
918
919 /*
920 * Fill out some of the header fields ourselves because the
921 * EFI firmware loader doesn't load the first sector.
922 */
923 hdr->root_flags = 1;
924 hdr->vid_mode = 0xffff;
925 hdr->boot_flag = 0xAA55;
926
927 hdr->type_of_loader = 0x21;
928
929 /* Convert unicode cmdline to ascii */
930 options = image->load_options;
931 load_options_size = image->load_options_size / 2; /* ASCII */
932 cmdline = 0;
933 s2 = (u16 *)options;
934
935 if (s2) {
936 while (*s2 && *s2 != '\n' && options_size < load_options_size) {
937 s2++;
938 options_size++;
939 }
940
941 if (options_size) {
942 if (options_size > hdr->cmdline_size)
943 options_size = hdr->cmdline_size;
944
945 options_size++; /* NUL termination */
946
947 status = low_alloc(options_size, 1, &cmdline);
948 if (status != EFI_SUCCESS) {
949 efi_printk("Failed to alloc mem for cmdline\n");
950 goto fail;
951 }
952
953 s1 = (u8 *)(unsigned long)cmdline;
954 s2 = (u16 *)options;
955
956 for (i = 0; i < options_size - 1; i++)
957 *s1++ = *s2++;
958
959 *s1 = '\0';
960 }
961 }
962
963 hdr->cmd_line_ptr = cmdline;
964
965 hdr->ramdisk_image = 0;
966 hdr->ramdisk_size = 0;
967
968 /* Clear APM BIOS info */
969 memset(bi, 0, sizeof(*bi));
970
971 memset(sdt, 0, sizeof(*sdt));
972
973 status = handle_ramdisks(image, hdr);
974 if (status != EFI_SUCCESS)
975 goto fail2;
976
977 return boot_params;
978 fail2:
979 if (options_size)
980 low_free(options_size, hdr->cmd_line_ptr);
981 fail:
982 low_free(0x4000, (unsigned long)boot_params);
983 return NULL;
984 }
985
986 static efi_status_t exit_boot(struct boot_params *boot_params,
987 void *handle)
988 {
989 struct efi_info *efi = &boot_params->efi_info;
990 struct e820entry *e820_map = &boot_params->e820_map[0];
991 struct e820entry *prev = NULL;
992 unsigned long size, key, desc_size, _size;
993 efi_memory_desc_t *mem_map;
994 efi_status_t status;
995 __u32 desc_version;
996 bool called_exit = false;
997 u8 nr_entries;
998 int i;
999
1000 size = sizeof(*mem_map) * 32;
1001
1002 again:
1003 size += sizeof(*mem_map) * 2;
1004 _size = size;
1005 status = low_alloc(size, 1, (unsigned long *)&mem_map);
1006 if (status != EFI_SUCCESS)
1007 return status;
1008
1009 get_map:
1010 status = efi_call_phys5(sys_table->boottime->get_memory_map, &size,
1011 mem_map, &key, &desc_size, &desc_version);
1012 if (status == EFI_BUFFER_TOO_SMALL) {
1013 low_free(_size, (unsigned long)mem_map);
1014 goto again;
1015 }
1016
1017 if (status != EFI_SUCCESS)
1018 goto free_mem_map;
1019
1020 memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));
1021 efi->efi_systab = (unsigned long)sys_table;
1022 efi->efi_memdesc_size = desc_size;
1023 efi->efi_memdesc_version = desc_version;
1024 efi->efi_memmap = (unsigned long)mem_map;
1025 efi->efi_memmap_size = size;
1026
1027 #ifdef CONFIG_X86_64
1028 efi->efi_systab_hi = (unsigned long)sys_table >> 32;
1029 efi->efi_memmap_hi = (unsigned long)mem_map >> 32;
1030 #endif
1031
1032 /* Might as well exit boot services now */
1033 status = efi_call_phys2(sys_table->boottime->exit_boot_services,
1034 handle, key);
1035 if (status != EFI_SUCCESS) {
1036 /*
1037 * ExitBootServices() will fail if any of the event
1038 * handlers change the memory map. In which case, we
1039 * must be prepared to retry, but only once so that
1040 * we're guaranteed to exit on repeated failures instead
1041 * of spinning forever.
1042 */
1043 if (called_exit)
1044 goto free_mem_map;
1045
1046 called_exit = true;
1047 goto get_map;
1048 }
1049
1050 /* Historic? */
1051 boot_params->alt_mem_k = 32 * 1024;
1052
1053 /*
1054 * Convert the EFI memory map to E820.
1055 */
1056 nr_entries = 0;
1057 for (i = 0; i < size / desc_size; i++) {
1058 efi_memory_desc_t *d;
1059 unsigned int e820_type = 0;
1060 unsigned long m = (unsigned long)mem_map;
1061
1062 d = (efi_memory_desc_t *)(m + (i * desc_size));
1063 switch (d->type) {
1064 case EFI_RESERVED_TYPE:
1065 case EFI_RUNTIME_SERVICES_CODE:
1066 case EFI_RUNTIME_SERVICES_DATA:
1067 case EFI_MEMORY_MAPPED_IO:
1068 case EFI_MEMORY_MAPPED_IO_PORT_SPACE:
1069 case EFI_PAL_CODE:
1070 e820_type = E820_RESERVED;
1071 break;
1072
1073 case EFI_UNUSABLE_MEMORY:
1074 e820_type = E820_UNUSABLE;
1075 break;
1076
1077 case EFI_ACPI_RECLAIM_MEMORY:
1078 e820_type = E820_ACPI;
1079 break;
1080
1081 case EFI_LOADER_CODE:
1082 case EFI_LOADER_DATA:
1083 case EFI_BOOT_SERVICES_CODE:
1084 case EFI_BOOT_SERVICES_DATA:
1085 case EFI_CONVENTIONAL_MEMORY:
1086 e820_type = E820_RAM;
1087 break;
1088
1089 case EFI_ACPI_MEMORY_NVS:
1090 e820_type = E820_NVS;
1091 break;
1092
1093 default:
1094 continue;
1095 }
1096
1097 /* Merge adjacent mappings */
1098 if (prev && prev->type == e820_type &&
1099 (prev->addr + prev->size) == d->phys_addr)
1100 prev->size += d->num_pages << 12;
1101 else {
1102 e820_map->addr = d->phys_addr;
1103 e820_map->size = d->num_pages << 12;
1104 e820_map->type = e820_type;
1105 prev = e820_map++;
1106 nr_entries++;
1107 }
1108 }
1109
1110 boot_params->e820_entries = nr_entries;
1111
1112 return EFI_SUCCESS;
1113
1114 free_mem_map:
1115 low_free(_size, (unsigned long)mem_map);
1116 return status;
1117 }
1118
1119 static efi_status_t relocate_kernel(struct setup_header *hdr)
1120 {
1121 unsigned long start, nr_pages;
1122 efi_status_t status;
1123
1124 /*
1125 * The EFI firmware loader could have placed the kernel image
1126 * anywhere in memory, but the kernel has various restrictions
1127 * on the max physical address it can run at. Attempt to move
1128 * the kernel to boot_params.pref_address, or as low as
1129 * possible.
1130 */
1131 start = hdr->pref_address;
1132 nr_pages = round_up(hdr->init_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
1133
1134 status = efi_call_phys4(sys_table->boottime->allocate_pages,
1135 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
1136 nr_pages, &start);
1137 if (status != EFI_SUCCESS) {
1138 status = low_alloc(hdr->init_size, hdr->kernel_alignment,
1139 &start);
1140 if (status != EFI_SUCCESS)
1141 efi_printk("Failed to alloc mem for kernel\n");
1142 }
1143
1144 if (status == EFI_SUCCESS)
1145 memcpy((void *)start, (void *)(unsigned long)hdr->code32_start,
1146 hdr->init_size);
1147
1148 hdr->pref_address = hdr->code32_start;
1149 hdr->code32_start = (__u32)start;
1150
1151 return status;
1152 }
1153
1154 /*
1155 * On success we return a pointer to a boot_params structure, and NULL
1156 * on failure.
1157 */
1158 struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
1159 struct boot_params *boot_params)
1160 {
1161 struct desc_ptr *gdt, *idt;
1162 efi_loaded_image_t *image;
1163 struct setup_header *hdr = &boot_params->hdr;
1164 efi_status_t status;
1165 struct desc_struct *desc;
1166
1167 sys_table = _table;
1168
1169 /* Check if we were booted by the EFI firmware */
1170 if (sys_table->hdr.signature != EFI_SYSTEM_TABLE_SIGNATURE)
1171 goto fail;
1172
1173 setup_graphics(boot_params);
1174
1175 setup_efi_pci(boot_params);
1176
1177 status = efi_call_phys3(sys_table->boottime->allocate_pool,
1178 EFI_LOADER_DATA, sizeof(*gdt),
1179 (void **)&gdt);
1180 if (status != EFI_SUCCESS) {
1181 efi_printk("Failed to alloc mem for gdt structure\n");
1182 goto fail;
1183 }
1184
1185 gdt->size = 0x800;
1186 status = low_alloc(gdt->size, 8, (unsigned long *)&gdt->address);
1187 if (status != EFI_SUCCESS) {
1188 efi_printk("Failed to alloc mem for gdt\n");
1189 goto fail;
1190 }
1191
1192 status = efi_call_phys3(sys_table->boottime->allocate_pool,
1193 EFI_LOADER_DATA, sizeof(*idt),
1194 (void **)&idt);
1195 if (status != EFI_SUCCESS) {
1196 efi_printk("Failed to alloc mem for idt structure\n");
1197 goto fail;
1198 }
1199
1200 idt->size = 0;
1201 idt->address = 0;
1202
1203 /*
1204 * If the kernel isn't already loaded at the preferred load
1205 * address, relocate it.
1206 */
1207 if (hdr->pref_address != hdr->code32_start) {
1208 status = relocate_kernel(hdr);
1209
1210 if (status != EFI_SUCCESS)
1211 goto fail;
1212 }
1213
1214 status = exit_boot(boot_params, handle);
1215 if (status != EFI_SUCCESS)
1216 goto fail;
1217
1218 memset((char *)gdt->address, 0x0, gdt->size);
1219 desc = (struct desc_struct *)gdt->address;
1220
1221 /* The first GDT is a dummy and the second is unused. */
1222 desc += 2;
1223
1224 desc->limit0 = 0xffff;
1225 desc->base0 = 0x0000;
1226 desc->base1 = 0x0000;
1227 desc->type = SEG_TYPE_CODE | SEG_TYPE_EXEC_READ;
1228 desc->s = DESC_TYPE_CODE_DATA;
1229 desc->dpl = 0;
1230 desc->p = 1;
1231 desc->limit = 0xf;
1232 desc->avl = 0;
1233 desc->l = 0;
1234 desc->d = SEG_OP_SIZE_32BIT;
1235 desc->g = SEG_GRANULARITY_4KB;
1236 desc->base2 = 0x00;
1237
1238 desc++;
1239 desc->limit0 = 0xffff;
1240 desc->base0 = 0x0000;
1241 desc->base1 = 0x0000;
1242 desc->type = SEG_TYPE_DATA | SEG_TYPE_READ_WRITE;
1243 desc->s = DESC_TYPE_CODE_DATA;
1244 desc->dpl = 0;
1245 desc->p = 1;
1246 desc->limit = 0xf;
1247 desc->avl = 0;
1248 desc->l = 0;
1249 desc->d = SEG_OP_SIZE_32BIT;
1250 desc->g = SEG_GRANULARITY_4KB;
1251 desc->base2 = 0x00;
1252
1253 #ifdef CONFIG_X86_64
1254 /* Task segment value */
1255 desc++;
1256 desc->limit0 = 0x0000;
1257 desc->base0 = 0x0000;
1258 desc->base1 = 0x0000;
1259 desc->type = SEG_TYPE_TSS;
1260 desc->s = 0;
1261 desc->dpl = 0;
1262 desc->p = 1;
1263 desc->limit = 0x0;
1264 desc->avl = 0;
1265 desc->l = 0;
1266 desc->d = 0;
1267 desc->g = SEG_GRANULARITY_4KB;
1268 desc->base2 = 0x00;
1269 #endif /* CONFIG_X86_64 */
1270
1271 asm volatile ("lidt %0" : : "m" (*idt));
1272 asm volatile ("lgdt %0" : : "m" (*gdt));
1273
1274 asm volatile("cli");
1275
1276 return boot_params;
1277 fail:
1278 return NULL;
1279 }
Linux with added FPC-III support