1 /* -----------------------------------------------------------------------
3 * Copyright 2011 Intel Corporation; author Matt Fleming
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.
8 * ----------------------------------------------------------------------- */
10 #include <linux/efi.h>
11 #include <linux/pci.h>
13 #include <asm/setup.h>
16 #include "../string.h"
19 static efi_system_table_t
*sys_table
;
21 static struct efi_config
*efi_early
;
23 __pure
const struct efi_config
*__efi_early(void)
28 #define BOOT_SERVICES(bits) \
29 static void setup_boot_services##bits(struct efi_config *c) \
31 efi_system_table_##bits##_t *table; \
33 table = (typeof(table))sys_table; \
35 c->boot_services = table->boottime; \
36 c->text_output = table->con_out; \
41 void efi_char16_printk(efi_system_table_t
*, efi_char16_t
*);
44 __file_size32(void *__fh
, efi_char16_t
*filename_16
,
45 void **handle
, u64
*file_sz
)
47 efi_file_handle_32_t
*h
, *fh
= __fh
;
48 efi_file_info_t
*info
;
50 efi_guid_t info_guid
= EFI_FILE_INFO_ID
;
53 status
= efi_early
->call((unsigned long)fh
->open
, fh
, &h
, filename_16
,
54 EFI_FILE_MODE_READ
, (u64
)0);
55 if (status
!= EFI_SUCCESS
) {
56 efi_printk(sys_table
, "Failed to open file: ");
57 efi_char16_printk(sys_table
, filename_16
);
58 efi_printk(sys_table
, "\n");
65 status
= efi_early
->call((unsigned long)h
->get_info
, h
, &info_guid
,
67 if (status
!= EFI_BUFFER_TOO_SMALL
) {
68 efi_printk(sys_table
, "Failed to get file info size\n");
73 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
,
74 info_sz
, (void **)&info
);
75 if (status
!= EFI_SUCCESS
) {
76 efi_printk(sys_table
, "Failed to alloc mem for file info\n");
80 status
= efi_early
->call((unsigned long)h
->get_info
, h
, &info_guid
,
82 if (status
== EFI_BUFFER_TOO_SMALL
) {
83 efi_call_early(free_pool
, info
);
87 *file_sz
= info
->file_size
;
88 efi_call_early(free_pool
, info
);
90 if (status
!= EFI_SUCCESS
)
91 efi_printk(sys_table
, "Failed to get initrd info\n");
97 __file_size64(void *__fh
, efi_char16_t
*filename_16
,
98 void **handle
, u64
*file_sz
)
100 efi_file_handle_64_t
*h
, *fh
= __fh
;
101 efi_file_info_t
*info
;
103 efi_guid_t info_guid
= EFI_FILE_INFO_ID
;
106 status
= efi_early
->call((unsigned long)fh
->open
, fh
, &h
, filename_16
,
107 EFI_FILE_MODE_READ
, (u64
)0);
108 if (status
!= EFI_SUCCESS
) {
109 efi_printk(sys_table
, "Failed to open file: ");
110 efi_char16_printk(sys_table
, filename_16
);
111 efi_printk(sys_table
, "\n");
118 status
= efi_early
->call((unsigned long)h
->get_info
, h
, &info_guid
,
120 if (status
!= EFI_BUFFER_TOO_SMALL
) {
121 efi_printk(sys_table
, "Failed to get file info size\n");
126 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
,
127 info_sz
, (void **)&info
);
128 if (status
!= EFI_SUCCESS
) {
129 efi_printk(sys_table
, "Failed to alloc mem for file info\n");
133 status
= efi_early
->call((unsigned long)h
->get_info
, h
, &info_guid
,
135 if (status
== EFI_BUFFER_TOO_SMALL
) {
136 efi_call_early(free_pool
, info
);
140 *file_sz
= info
->file_size
;
141 efi_call_early(free_pool
, info
);
143 if (status
!= EFI_SUCCESS
)
144 efi_printk(sys_table
, "Failed to get initrd info\n");
149 efi_file_size(efi_system_table_t
*sys_table
, void *__fh
,
150 efi_char16_t
*filename_16
, void **handle
, u64
*file_sz
)
153 return __file_size64(__fh
, filename_16
, handle
, file_sz
);
155 return __file_size32(__fh
, filename_16
, handle
, file_sz
);
159 efi_file_read(void *handle
, unsigned long *size
, void *addr
)
163 if (efi_early
->is64
) {
164 efi_file_handle_64_t
*fh
= handle
;
166 func
= (unsigned long)fh
->read
;
167 return efi_early
->call(func
, handle
, size
, addr
);
169 efi_file_handle_32_t
*fh
= handle
;
171 func
= (unsigned long)fh
->read
;
172 return efi_early
->call(func
, handle
, size
, addr
);
176 efi_status_t
efi_file_close(void *handle
)
178 if (efi_early
->is64
) {
179 efi_file_handle_64_t
*fh
= handle
;
181 return efi_early
->call((unsigned long)fh
->close
, handle
);
183 efi_file_handle_32_t
*fh
= handle
;
185 return efi_early
->call((unsigned long)fh
->close
, handle
);
189 static inline efi_status_t
__open_volume32(void *__image
, void **__fh
)
191 efi_file_io_interface_t
*io
;
192 efi_loaded_image_32_t
*image
= __image
;
193 efi_file_handle_32_t
*fh
;
194 efi_guid_t fs_proto
= EFI_FILE_SYSTEM_GUID
;
196 void *handle
= (void *)(unsigned long)image
->device_handle
;
199 status
= efi_call_early(handle_protocol
, handle
,
200 &fs_proto
, (void **)&io
);
201 if (status
!= EFI_SUCCESS
) {
202 efi_printk(sys_table
, "Failed to handle fs_proto\n");
206 func
= (unsigned long)io
->open_volume
;
207 status
= efi_early
->call(func
, io
, &fh
);
208 if (status
!= EFI_SUCCESS
)
209 efi_printk(sys_table
, "Failed to open volume\n");
215 static inline efi_status_t
__open_volume64(void *__image
, void **__fh
)
217 efi_file_io_interface_t
*io
;
218 efi_loaded_image_64_t
*image
= __image
;
219 efi_file_handle_64_t
*fh
;
220 efi_guid_t fs_proto
= EFI_FILE_SYSTEM_GUID
;
222 void *handle
= (void *)(unsigned long)image
->device_handle
;
225 status
= efi_call_early(handle_protocol
, handle
,
226 &fs_proto
, (void **)&io
);
227 if (status
!= EFI_SUCCESS
) {
228 efi_printk(sys_table
, "Failed to handle fs_proto\n");
232 func
= (unsigned long)io
->open_volume
;
233 status
= efi_early
->call(func
, io
, &fh
);
234 if (status
!= EFI_SUCCESS
)
235 efi_printk(sys_table
, "Failed to open volume\n");
242 efi_open_volume(efi_system_table_t
*sys_table
, void *__image
, void **__fh
)
245 return __open_volume64(__image
, __fh
);
247 return __open_volume32(__image
, __fh
);
250 void efi_char16_printk(efi_system_table_t
*table
, efi_char16_t
*str
)
252 unsigned long output_string
;
255 if (efi_early
->is64
) {
256 struct efi_simple_text_output_protocol_64
*out
;
259 offset
= offsetof(typeof(*out
), output_string
);
260 output_string
= efi_early
->text_output
+ offset
;
261 out
= (typeof(out
))(unsigned long)efi_early
->text_output
;
262 func
= (u64
*)output_string
;
264 efi_early
->call(*func
, out
, str
);
266 struct efi_simple_text_output_protocol_32
*out
;
269 offset
= offsetof(typeof(*out
), output_string
);
270 output_string
= efi_early
->text_output
+ offset
;
271 out
= (typeof(out
))(unsigned long)efi_early
->text_output
;
272 func
= (u32
*)output_string
;
274 efi_early
->call(*func
, out
, str
);
279 __setup_efi_pci32(efi_pci_io_protocol_32
*pci
, struct pci_setup_rom
**__rom
)
281 struct pci_setup_rom
*rom
= NULL
;
286 status
= efi_early
->call(pci
->attributes
, pci
,
287 EfiPciIoAttributeOperationGet
, 0, 0,
289 if (status
!= EFI_SUCCESS
)
292 if (!pci
->romimage
|| !pci
->romsize
)
293 return EFI_INVALID_PARAMETER
;
295 size
= pci
->romsize
+ sizeof(*rom
);
297 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
, size
, &rom
);
298 if (status
!= EFI_SUCCESS
) {
299 efi_printk(sys_table
, "Failed to alloc mem for rom\n");
303 memset(rom
, 0, sizeof(*rom
));
305 rom
->data
.type
= SETUP_PCI
;
306 rom
->data
.len
= size
- sizeof(struct setup_data
);
308 rom
->pcilen
= pci
->romsize
;
311 status
= efi_early
->call(pci
->pci
.read
, pci
, EfiPciIoWidthUint16
,
312 PCI_VENDOR_ID
, 1, &(rom
->vendor
));
314 if (status
!= EFI_SUCCESS
) {
315 efi_printk(sys_table
, "Failed to read rom->vendor\n");
319 status
= efi_early
->call(pci
->pci
.read
, pci
, EfiPciIoWidthUint16
,
320 PCI_DEVICE_ID
, 1, &(rom
->devid
));
322 if (status
!= EFI_SUCCESS
) {
323 efi_printk(sys_table
, "Failed to read rom->devid\n");
327 status
= efi_early
->call(pci
->get_location
, pci
, &(rom
->segment
),
328 &(rom
->bus
), &(rom
->device
), &(rom
->function
));
330 if (status
!= EFI_SUCCESS
)
333 memcpy(rom
->romdata
, pci
->romimage
, pci
->romsize
);
337 efi_call_early(free_pool
, rom
);
342 setup_efi_pci32(struct boot_params
*params
, void **pci_handle
,
345 efi_pci_io_protocol_32
*pci
= NULL
;
346 efi_guid_t pci_proto
= EFI_PCI_IO_PROTOCOL_GUID
;
347 u32
*handles
= (u32
*)(unsigned long)pci_handle
;
349 unsigned long nr_pci
;
350 struct setup_data
*data
;
353 data
= (struct setup_data
*)(unsigned long)params
->hdr
.setup_data
;
355 while (data
&& data
->next
)
356 data
= (struct setup_data
*)(unsigned long)data
->next
;
358 nr_pci
= size
/ sizeof(u32
);
359 for (i
= 0; i
< nr_pci
; i
++) {
360 struct pci_setup_rom
*rom
= NULL
;
363 status
= efi_call_early(handle_protocol
, h
,
364 &pci_proto
, (void **)&pci
);
366 if (status
!= EFI_SUCCESS
)
372 status
= __setup_efi_pci32(pci
, &rom
);
373 if (status
!= EFI_SUCCESS
)
377 data
->next
= (unsigned long)rom
;
379 params
->hdr
.setup_data
= (unsigned long)rom
;
381 data
= (struct setup_data
*)rom
;
387 __setup_efi_pci64(efi_pci_io_protocol_64
*pci
, struct pci_setup_rom
**__rom
)
389 struct pci_setup_rom
*rom
;
394 status
= efi_early
->call(pci
->attributes
, pci
,
395 EfiPciIoAttributeOperationGet
, 0,
397 if (status
!= EFI_SUCCESS
)
400 if (!pci
->romimage
|| !pci
->romsize
)
401 return EFI_INVALID_PARAMETER
;
403 size
= pci
->romsize
+ sizeof(*rom
);
405 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
, size
, &rom
);
406 if (status
!= EFI_SUCCESS
) {
407 efi_printk(sys_table
, "Failed to alloc mem for rom\n");
411 rom
->data
.type
= SETUP_PCI
;
412 rom
->data
.len
= size
- sizeof(struct setup_data
);
414 rom
->pcilen
= pci
->romsize
;
417 status
= efi_early
->call(pci
->pci
.read
, pci
, EfiPciIoWidthUint16
,
418 PCI_VENDOR_ID
, 1, &(rom
->vendor
));
420 if (status
!= EFI_SUCCESS
) {
421 efi_printk(sys_table
, "Failed to read rom->vendor\n");
425 status
= efi_early
->call(pci
->pci
.read
, pci
, EfiPciIoWidthUint16
,
426 PCI_DEVICE_ID
, 1, &(rom
->devid
));
428 if (status
!= EFI_SUCCESS
) {
429 efi_printk(sys_table
, "Failed to read rom->devid\n");
433 status
= efi_early
->call(pci
->get_location
, pci
, &(rom
->segment
),
434 &(rom
->bus
), &(rom
->device
), &(rom
->function
));
436 if (status
!= EFI_SUCCESS
)
439 memcpy(rom
->romdata
, pci
->romimage
, pci
->romsize
);
443 efi_call_early(free_pool
, rom
);
449 setup_efi_pci64(struct boot_params
*params
, void **pci_handle
,
452 efi_pci_io_protocol_64
*pci
= NULL
;
453 efi_guid_t pci_proto
= EFI_PCI_IO_PROTOCOL_GUID
;
454 u64
*handles
= (u64
*)(unsigned long)pci_handle
;
456 unsigned long nr_pci
;
457 struct setup_data
*data
;
460 data
= (struct setup_data
*)(unsigned long)params
->hdr
.setup_data
;
462 while (data
&& data
->next
)
463 data
= (struct setup_data
*)(unsigned long)data
->next
;
465 nr_pci
= size
/ sizeof(u64
);
466 for (i
= 0; i
< nr_pci
; i
++) {
467 struct pci_setup_rom
*rom
= NULL
;
470 status
= efi_call_early(handle_protocol
, h
,
471 &pci_proto
, (void **)&pci
);
473 if (status
!= EFI_SUCCESS
)
479 status
= __setup_efi_pci64(pci
, &rom
);
480 if (status
!= EFI_SUCCESS
)
484 data
->next
= (unsigned long)rom
;
486 params
->hdr
.setup_data
= (unsigned long)rom
;
488 data
= (struct setup_data
*)rom
;
494 * There's no way to return an informative status from this function,
495 * because any analysis (and printing of error messages) needs to be
496 * done directly at the EFI function call-site.
498 * For example, EFI_INVALID_PARAMETER could indicate a bug or maybe we
499 * just didn't find any PCI devices, but there's no way to tell outside
500 * the context of the call.
502 static void setup_efi_pci(struct boot_params
*params
)
505 void **pci_handle
= NULL
;
506 efi_guid_t pci_proto
= EFI_PCI_IO_PROTOCOL_GUID
;
507 unsigned long size
= 0;
509 status
= efi_call_early(locate_handle
,
510 EFI_LOCATE_BY_PROTOCOL
,
511 &pci_proto
, NULL
, &size
, pci_handle
);
513 if (status
== EFI_BUFFER_TOO_SMALL
) {
514 status
= efi_call_early(allocate_pool
,
516 size
, (void **)&pci_handle
);
518 if (status
!= EFI_SUCCESS
) {
519 efi_printk(sys_table
, "Failed to alloc mem for pci_handle\n");
523 status
= efi_call_early(locate_handle
,
524 EFI_LOCATE_BY_PROTOCOL
, &pci_proto
,
525 NULL
, &size
, pci_handle
);
528 if (status
!= EFI_SUCCESS
)
532 setup_efi_pci64(params
, pci_handle
, size
);
534 setup_efi_pci32(params
, pci_handle
, size
);
537 efi_call_early(free_pool
, pci_handle
);
541 setup_uga32(void **uga_handle
, unsigned long size
, u32
*width
, u32
*height
)
543 struct efi_uga_draw_protocol
*uga
= NULL
, *first_uga
;
544 efi_guid_t uga_proto
= EFI_UGA_PROTOCOL_GUID
;
545 unsigned long nr_ugas
;
546 u32
*handles
= (u32
*)uga_handle
;;
547 efi_status_t status
= EFI_INVALID_PARAMETER
;
551 nr_ugas
= size
/ sizeof(u32
);
552 for (i
= 0; i
< nr_ugas
; i
++) {
553 efi_guid_t pciio_proto
= EFI_PCI_IO_PROTOCOL_GUID
;
554 u32 w
, h
, depth
, refresh
;
556 u32 handle
= handles
[i
];
558 status
= efi_call_early(handle_protocol
, handle
,
559 &uga_proto
, (void **)&uga
);
560 if (status
!= EFI_SUCCESS
)
563 efi_call_early(handle_protocol
, handle
, &pciio_proto
, &pciio
);
565 status
= efi_early
->call((unsigned long)uga
->get_mode
, uga
,
566 &w
, &h
, &depth
, &refresh
);
567 if (status
== EFI_SUCCESS
&& (!first_uga
|| pciio
)) {
572 * Once we've found a UGA supporting PCIIO,
573 * don't bother looking any further.
586 setup_uga64(void **uga_handle
, unsigned long size
, u32
*width
, u32
*height
)
588 struct efi_uga_draw_protocol
*uga
= NULL
, *first_uga
;
589 efi_guid_t uga_proto
= EFI_UGA_PROTOCOL_GUID
;
590 unsigned long nr_ugas
;
591 u64
*handles
= (u64
*)uga_handle
;;
592 efi_status_t status
= EFI_INVALID_PARAMETER
;
596 nr_ugas
= size
/ sizeof(u64
);
597 for (i
= 0; i
< nr_ugas
; i
++) {
598 efi_guid_t pciio_proto
= EFI_PCI_IO_PROTOCOL_GUID
;
599 u32 w
, h
, depth
, refresh
;
601 u64 handle
= handles
[i
];
603 status
= efi_call_early(handle_protocol
, handle
,
604 &uga_proto
, (void **)&uga
);
605 if (status
!= EFI_SUCCESS
)
608 efi_call_early(handle_protocol
, handle
, &pciio_proto
, &pciio
);
610 status
= efi_early
->call((unsigned long)uga
->get_mode
, uga
,
611 &w
, &h
, &depth
, &refresh
);
612 if (status
== EFI_SUCCESS
&& (!first_uga
|| pciio
)) {
617 * Once we've found a UGA supporting PCIIO,
618 * don't bother looking any further.
631 * See if we have Universal Graphics Adapter (UGA) protocol
633 static efi_status_t
setup_uga(struct screen_info
*si
, efi_guid_t
*uga_proto
,
638 void **uga_handle
= NULL
;
640 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
,
641 size
, (void **)&uga_handle
);
642 if (status
!= EFI_SUCCESS
)
645 status
= efi_call_early(locate_handle
,
646 EFI_LOCATE_BY_PROTOCOL
,
647 uga_proto
, NULL
, &size
, uga_handle
);
648 if (status
!= EFI_SUCCESS
)
655 status
= setup_uga64(uga_handle
, size
, &width
, &height
);
657 status
= setup_uga32(uga_handle
, size
, &width
, &height
);
659 if (!width
&& !height
)
662 /* EFI framebuffer */
663 si
->orig_video_isVGA
= VIDEO_TYPE_EFI
;
666 si
->lfb_width
= width
;
667 si
->lfb_height
= height
;
679 efi_call_early(free_pool
, uga_handle
);
683 void setup_graphics(struct boot_params
*boot_params
)
685 efi_guid_t graphics_proto
= EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID
;
686 struct screen_info
*si
;
687 efi_guid_t uga_proto
= EFI_UGA_PROTOCOL_GUID
;
690 void **gop_handle
= NULL
;
691 void **uga_handle
= NULL
;
693 si
= &boot_params
->screen_info
;
694 memset(si
, 0, sizeof(*si
));
697 status
= efi_call_early(locate_handle
,
698 EFI_LOCATE_BY_PROTOCOL
,
699 &graphics_proto
, NULL
, &size
, gop_handle
);
700 if (status
== EFI_BUFFER_TOO_SMALL
)
701 status
= efi_setup_gop(NULL
, si
, &graphics_proto
, size
);
703 if (status
!= EFI_SUCCESS
) {
705 status
= efi_call_early(locate_handle
,
706 EFI_LOCATE_BY_PROTOCOL
,
707 &uga_proto
, NULL
, &size
, uga_handle
);
708 if (status
== EFI_BUFFER_TOO_SMALL
)
709 setup_uga(si
, &uga_proto
, size
);
714 * Because the x86 boot code expects to be passed a boot_params we
715 * need to create one ourselves (usually the bootloader would create
718 * The caller is responsible for filling out ->code32_start in the
719 * returned boot_params.
721 struct boot_params
*make_boot_params(struct efi_config
*c
)
723 struct boot_params
*boot_params
;
724 struct apm_bios_info
*bi
;
725 struct setup_header
*hdr
;
726 efi_loaded_image_t
*image
;
727 void *options
, *handle
;
728 efi_guid_t proto
= LOADED_IMAGE_PROTOCOL_GUID
;
729 int options_size
= 0;
735 unsigned long ramdisk_addr
;
736 unsigned long ramdisk_size
;
739 sys_table
= (efi_system_table_t
*)(unsigned long)efi_early
->table
;
740 handle
= (void *)(unsigned long)efi_early
->image_handle
;
742 /* Check if we were booted by the EFI firmware */
743 if (sys_table
->hdr
.signature
!= EFI_SYSTEM_TABLE_SIGNATURE
)
747 setup_boot_services64(efi_early
);
749 setup_boot_services32(efi_early
);
751 status
= efi_call_early(handle_protocol
, handle
,
752 &proto
, (void *)&image
);
753 if (status
!= EFI_SUCCESS
) {
754 efi_printk(sys_table
, "Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
758 status
= efi_low_alloc(sys_table
, 0x4000, 1,
759 (unsigned long *)&boot_params
);
760 if (status
!= EFI_SUCCESS
) {
761 efi_printk(sys_table
, "Failed to alloc lowmem for boot params\n");
765 memset(boot_params
, 0x0, 0x4000);
767 hdr
= &boot_params
->hdr
;
768 bi
= &boot_params
->apm_bios_info
;
770 /* Copy the second sector to boot_params */
771 memcpy(&hdr
->jump
, image
->image_base
+ 512, 512);
774 * Fill out some of the header fields ourselves because the
775 * EFI firmware loader doesn't load the first sector.
778 hdr
->vid_mode
= 0xffff;
779 hdr
->boot_flag
= 0xAA55;
781 hdr
->type_of_loader
= 0x21;
783 /* Convert unicode cmdline to ascii */
784 cmdline_ptr
= efi_convert_cmdline(sys_table
, image
, &options_size
);
787 hdr
->cmd_line_ptr
= (unsigned long)cmdline_ptr
;
788 /* Fill in upper bits of command line address, NOP on 32 bit */
789 boot_params
->ext_cmd_line_ptr
= (u64
)(unsigned long)cmdline_ptr
>> 32;
791 hdr
->ramdisk_image
= 0;
792 hdr
->ramdisk_size
= 0;
794 /* Clear APM BIOS info */
795 memset(bi
, 0, sizeof(*bi
));
797 status
= efi_parse_options(cmdline_ptr
);
798 if (status
!= EFI_SUCCESS
)
801 status
= handle_cmdline_files(sys_table
, image
,
802 (char *)(unsigned long)hdr
->cmd_line_ptr
,
803 "initrd=", hdr
->initrd_addr_max
,
804 &ramdisk_addr
, &ramdisk_size
);
806 if (status
!= EFI_SUCCESS
&&
807 hdr
->xloadflags
& XLF_CAN_BE_LOADED_ABOVE_4G
) {
808 efi_printk(sys_table
, "Trying to load files to higher address\n");
809 status
= handle_cmdline_files(sys_table
, image
,
810 (char *)(unsigned long)hdr
->cmd_line_ptr
,
812 &ramdisk_addr
, &ramdisk_size
);
815 if (status
!= EFI_SUCCESS
)
817 hdr
->ramdisk_image
= ramdisk_addr
& 0xffffffff;
818 hdr
->ramdisk_size
= ramdisk_size
& 0xffffffff;
819 boot_params
->ext_ramdisk_image
= (u64
)ramdisk_addr
>> 32;
820 boot_params
->ext_ramdisk_size
= (u64
)ramdisk_size
>> 32;
824 efi_free(sys_table
, options_size
, hdr
->cmd_line_ptr
);
826 efi_free(sys_table
, 0x4000, (unsigned long)boot_params
);
830 static void add_e820ext(struct boot_params
*params
,
831 struct setup_data
*e820ext
, u32 nr_entries
)
833 struct setup_data
*data
;
837 e820ext
->type
= SETUP_E820_EXT
;
838 e820ext
->len
= nr_entries
* sizeof(struct e820entry
);
841 data
= (struct setup_data
*)(unsigned long)params
->hdr
.setup_data
;
843 while (data
&& data
->next
)
844 data
= (struct setup_data
*)(unsigned long)data
->next
;
847 data
->next
= (unsigned long)e820ext
;
849 params
->hdr
.setup_data
= (unsigned long)e820ext
;
852 static efi_status_t
setup_e820(struct boot_params
*params
,
853 struct setup_data
*e820ext
, u32 e820ext_size
)
855 struct e820entry
*e820_map
= ¶ms
->e820_map
[0];
856 struct efi_info
*efi
= ¶ms
->efi_info
;
857 struct e820entry
*prev
= NULL
;
863 nr_desc
= efi
->efi_memmap_size
/ efi
->efi_memdesc_size
;
865 for (i
= 0; i
< nr_desc
; i
++) {
866 efi_memory_desc_t
*d
;
867 unsigned int e820_type
= 0;
868 unsigned long m
= efi
->efi_memmap
;
871 m
|= (u64
)efi
->efi_memmap_hi
<< 32;
874 d
= (efi_memory_desc_t
*)(m
+ (i
* efi
->efi_memdesc_size
));
876 case EFI_RESERVED_TYPE
:
877 case EFI_RUNTIME_SERVICES_CODE
:
878 case EFI_RUNTIME_SERVICES_DATA
:
879 case EFI_MEMORY_MAPPED_IO
:
880 case EFI_MEMORY_MAPPED_IO_PORT_SPACE
:
882 e820_type
= E820_RESERVED
;
885 case EFI_UNUSABLE_MEMORY
:
886 e820_type
= E820_UNUSABLE
;
889 case EFI_ACPI_RECLAIM_MEMORY
:
890 e820_type
= E820_ACPI
;
893 case EFI_LOADER_CODE
:
894 case EFI_LOADER_DATA
:
895 case EFI_BOOT_SERVICES_CODE
:
896 case EFI_BOOT_SERVICES_DATA
:
897 case EFI_CONVENTIONAL_MEMORY
:
898 e820_type
= E820_RAM
;
901 case EFI_ACPI_MEMORY_NVS
:
902 e820_type
= E820_NVS
;
905 case EFI_PERSISTENT_MEMORY
:
906 e820_type
= E820_PMEM
;
913 /* Merge adjacent mappings */
914 if (prev
&& prev
->type
== e820_type
&&
915 (prev
->addr
+ prev
->size
) == d
->phys_addr
) {
916 prev
->size
+= d
->num_pages
<< 12;
920 if (nr_entries
== ARRAY_SIZE(params
->e820_map
)) {
921 u32 need
= (nr_desc
- i
) * sizeof(struct e820entry
) +
922 sizeof(struct setup_data
);
924 if (!e820ext
|| e820ext_size
< need
)
925 return EFI_BUFFER_TOO_SMALL
;
927 /* boot_params map full, switch to e820 extended */
928 e820_map
= (struct e820entry
*)e820ext
->data
;
931 e820_map
->addr
= d
->phys_addr
;
932 e820_map
->size
= d
->num_pages
<< PAGE_SHIFT
;
933 e820_map
->type
= e820_type
;
938 if (nr_entries
> ARRAY_SIZE(params
->e820_map
)) {
939 u32 nr_e820ext
= nr_entries
- ARRAY_SIZE(params
->e820_map
);
941 add_e820ext(params
, e820ext
, nr_e820ext
);
942 nr_entries
-= nr_e820ext
;
945 params
->e820_entries
= (u8
)nr_entries
;
950 static efi_status_t
alloc_e820ext(u32 nr_desc
, struct setup_data
**e820ext
,
956 size
= sizeof(struct setup_data
) +
957 sizeof(struct e820entry
) * nr_desc
;
960 efi_call_early(free_pool
, *e820ext
);
965 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
,
966 size
, (void **)e820ext
);
967 if (status
== EFI_SUCCESS
)
968 *e820ext_size
= size
;
973 static efi_status_t
exit_boot(struct boot_params
*boot_params
,
974 void *handle
, bool is64
)
976 struct efi_info
*efi
= &boot_params
->efi_info
;
977 unsigned long map_sz
, key
, desc_size
;
978 efi_memory_desc_t
*mem_map
;
979 struct setup_data
*e820ext
;
980 const char *signature
;
982 __u32 nr_desc
, prev_nr_desc
;
985 bool called_exit
= false;
994 status
= efi_get_memory_map(sys_table
, &mem_map
, &map_sz
, &desc_size
,
995 &desc_version
, &key
);
997 if (status
!= EFI_SUCCESS
)
1000 prev_nr_desc
= nr_desc
;
1001 nr_desc
= map_sz
/ desc_size
;
1002 if (nr_desc
> prev_nr_desc
&&
1003 nr_desc
> ARRAY_SIZE(boot_params
->e820_map
)) {
1004 u32 nr_e820ext
= nr_desc
- ARRAY_SIZE(boot_params
->e820_map
);
1006 status
= alloc_e820ext(nr_e820ext
, &e820ext
, &e820ext_size
);
1007 if (status
!= EFI_SUCCESS
)
1010 efi_call_early(free_pool
, mem_map
);
1011 goto get_map
; /* Allocated memory, get map again */
1014 signature
= is64
? EFI64_LOADER_SIGNATURE
: EFI32_LOADER_SIGNATURE
;
1015 memcpy(&efi
->efi_loader_signature
, signature
, sizeof(__u32
));
1017 efi
->efi_systab
= (unsigned long)sys_table
;
1018 efi
->efi_memdesc_size
= desc_size
;
1019 efi
->efi_memdesc_version
= desc_version
;
1020 efi
->efi_memmap
= (unsigned long)mem_map
;
1021 efi
->efi_memmap_size
= map_sz
;
1023 #ifdef CONFIG_X86_64
1024 efi
->efi_systab_hi
= (unsigned long)sys_table
>> 32;
1025 efi
->efi_memmap_hi
= (unsigned long)mem_map
>> 32;
1028 /* Might as well exit boot services now */
1029 status
= efi_call_early(exit_boot_services
, handle
, key
);
1030 if (status
!= EFI_SUCCESS
) {
1032 * ExitBootServices() will fail if any of the event
1033 * handlers change the memory map. In which case, we
1034 * must be prepared to retry, but only once so that
1035 * we're guaranteed to exit on repeated failures instead
1036 * of spinning forever.
1042 efi_call_early(free_pool
, mem_map
);
1047 boot_params
->alt_mem_k
= 32 * 1024;
1049 status
= setup_e820(boot_params
, e820ext
, e820ext_size
);
1050 if (status
!= EFI_SUCCESS
)
1056 efi_call_early(free_pool
, mem_map
);
1061 * On success we return a pointer to a boot_params structure, and NULL
1064 struct boot_params
*efi_main(struct efi_config
*c
,
1065 struct boot_params
*boot_params
)
1067 struct desc_ptr
*gdt
= NULL
;
1068 efi_loaded_image_t
*image
;
1069 struct setup_header
*hdr
= &boot_params
->hdr
;
1070 efi_status_t status
;
1071 struct desc_struct
*desc
;
1073 efi_system_table_t
*_table
;
1078 _table
= (efi_system_table_t
*)(unsigned long)efi_early
->table
;
1079 handle
= (void *)(unsigned long)efi_early
->image_handle
;
1080 is64
= efi_early
->is64
;
1084 /* Check if we were booted by the EFI firmware */
1085 if (sys_table
->hdr
.signature
!= EFI_SYSTEM_TABLE_SIGNATURE
)
1089 setup_boot_services64(efi_early
);
1091 setup_boot_services32(efi_early
);
1093 setup_graphics(boot_params
);
1095 setup_efi_pci(boot_params
);
1097 status
= efi_call_early(allocate_pool
, EFI_LOADER_DATA
,
1098 sizeof(*gdt
), (void **)&gdt
);
1099 if (status
!= EFI_SUCCESS
) {
1100 efi_printk(sys_table
, "Failed to alloc mem for gdt structure\n");
1105 status
= efi_low_alloc(sys_table
, gdt
->size
, 8,
1106 (unsigned long *)&gdt
->address
);
1107 if (status
!= EFI_SUCCESS
) {
1108 efi_printk(sys_table
, "Failed to alloc mem for gdt\n");
1113 * If the kernel isn't already loaded at the preferred load
1114 * address, relocate it.
1116 if (hdr
->pref_address
!= hdr
->code32_start
) {
1117 unsigned long bzimage_addr
= hdr
->code32_start
;
1118 status
= efi_relocate_kernel(sys_table
, &bzimage_addr
,
1119 hdr
->init_size
, hdr
->init_size
,
1121 hdr
->kernel_alignment
);
1122 if (status
!= EFI_SUCCESS
) {
1123 efi_printk(sys_table
, "efi_relocate_kernel() failed!\n");
1127 hdr
->pref_address
= hdr
->code32_start
;
1128 hdr
->code32_start
= bzimage_addr
;
1131 status
= exit_boot(boot_params
, handle
, is64
);
1132 if (status
!= EFI_SUCCESS
) {
1133 efi_printk(sys_table
, "exit_boot() failed!\n");
1137 memset((char *)gdt
->address
, 0x0, gdt
->size
);
1138 desc
= (struct desc_struct
*)gdt
->address
;
1140 /* The first GDT is a dummy and the second is unused. */
1143 desc
->limit0
= 0xffff;
1144 desc
->base0
= 0x0000;
1145 desc
->base1
= 0x0000;
1146 desc
->type
= SEG_TYPE_CODE
| SEG_TYPE_EXEC_READ
;
1147 desc
->s
= DESC_TYPE_CODE_DATA
;
1153 desc
->d
= SEG_OP_SIZE_32BIT
;
1154 desc
->g
= SEG_GRANULARITY_4KB
;
1158 desc
->limit0
= 0xffff;
1159 desc
->base0
= 0x0000;
1160 desc
->base1
= 0x0000;
1161 desc
->type
= SEG_TYPE_DATA
| SEG_TYPE_READ_WRITE
;
1162 desc
->s
= DESC_TYPE_CODE_DATA
;
1168 desc
->d
= SEG_OP_SIZE_32BIT
;
1169 desc
->g
= SEG_GRANULARITY_4KB
;
1172 #ifdef CONFIG_X86_64
1173 /* Task segment value */
1175 desc
->limit0
= 0x0000;
1176 desc
->base0
= 0x0000;
1177 desc
->base1
= 0x0000;
1178 desc
->type
= SEG_TYPE_TSS
;
1186 desc
->g
= SEG_GRANULARITY_4KB
;
1188 #endif /* CONFIG_X86_64 */
1190 asm volatile("cli");
1191 asm volatile ("lgdt %0" : : "m" (*gdt
));
1195 efi_printk(sys_table
, "efi_main() failed!\n");