aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorMatt Fleming <matt.fleming@intel.com>2013-09-25 07:50:59 -0400
committerMatt Fleming <matt.fleming@intel.com>2013-09-25 07:50:59 -0400
commit3203209d61440e02429fc52f192797adf5d8c053 (patch)
tree2c7c3c039ca9d71ae93b7bbc3710952fef6671d1
parent9efff3899b90e5ead9e676af9736e891ee23ce41 (diff)
parent4e283088bd9af0ff119d6e15bca81a83d6e8e30c (diff)
Merge branch 'arm/common' into next
Diffstat
-rw-r--r--Documentation/efi-stub.txt (renamed from Documentation/x86/efi-stub.txt)0
-rw-r--r--arch/x86/Kconfig2
-rw-r--r--arch/x86/boot/compressed/eboot.c580
-rw-r--r--arch/x86/boot/compressed/eboot.h9
-rw-r--r--drivers/firmware/efi/efi-stub-helper.c638
-rw-r--r--include/linux/efi.h50
6 files changed, 712 insertions, 567 deletions
diff --git a/Documentation/x86/efi-stub.txt b/Documentation/efi-stub.txt
index 44e6bb6ead10..44e6bb6ead10 100644
--- a/Documentation/x86/efi-stub.txt
+++ b/Documentation/efi-stub.txt
diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
index b32ebf92b0ce..ec65b51af959 100644
--- a/arch/x86/Kconfig
+++ b/arch/x86/Kconfig
@@ -1579,7 +1579,7 @@ config EFI_STUB
1579 This kernel feature allows a bzImage to be loaded directly 1579 This kernel feature allows a bzImage to be loaded directly
1580 by EFI firmware without the use of a bootloader. 1580 by EFI firmware without the use of a bootloader.
1581 1581
1582 See Documentation/x86/efi-stub.txt for more information. 1582 See Documentation/efi-stub.txt for more information.
1583 1583
1584config SECCOMP 1584config SECCOMP
1585 def_bool y 1585 def_bool y
diff --git a/arch/x86/boot/compressed/eboot.c b/arch/x86/boot/compressed/eboot.c
index b7388a425f09..beb07a4529ac 100644
--- a/arch/x86/boot/compressed/eboot.c
+++ b/arch/x86/boot/compressed/eboot.c
@@ -19,214 +19,10 @@
19 19
20static efi_system_table_t *sys_table; 20static efi_system_table_t *sys_table;
21 21
22static 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
30static 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
47static 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;
56again:
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
77fail:
78 *map = m;
79 return status;
80}
81
82/*
83 * Allocate at the highest possible address that is not above 'max'.
84 */
85static 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;
100again:
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 22
106 desc = (efi_memory_desc_t *)(m + (i * desc_size)); 23#include "../../../../drivers/firmware/efi/efi-stub-helper.c"
107 if (desc->type != EFI_CONVENTIONAL_MEMORY)
108 continue;
109
110 if (desc->num_pages < nr_pages)
111 continue;
112 24
113 start = desc->phys_addr;
114 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
115 25
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
153free_pool:
154 efi_call_phys1(sys_table->boottime->free_pool, map);
155
156fail:
157 return status;
158}
159
160/*
161 * Allocate at the lowest possible address.
162 */
163static 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
217free_pool:
218 efi_call_phys1(sys_table->boottime->free_pool, map);
219fail:
220 return status;
221}
222
223static 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 26
231static void find_bits(unsigned long mask, u8 *pos, u8 *size) 27static void find_bits(unsigned long mask, u8 *pos, u8 *size)
232{ 28{
@@ -624,242 +420,6 @@ void setup_graphics(struct boot_params *boot_params)
624 } 420 }
625} 421}
626 422
627struct 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 */
638static 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
766grow:
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
849free_initrd_total:
850 low_free(initrd_total, initrd_addr);
851
852close_handles:
853 for (k = j; k < i; k++)
854 efi_call_phys1(fh->close, initrds[k].handle);
855free_initrds:
856 efi_call_phys1(sys_table->boottime->free_pool, initrds);
857fail:
858 hdr->ramdisk_image = 0;
859 hdr->ramdisk_size = 0;
860
861 return status;
862}
863 423
864/* 424/*
865 * Because the x86 boot code expects to be passed a boot_params we 425 * Because the x86 boot code expects to be passed a boot_params we
@@ -875,14 +435,15 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
875 struct efi_info *efi; 435 struct efi_info *efi;
876 efi_loaded_image_t *image; 436 efi_loaded_image_t *image;
877 void *options; 437 void *options;
878 u32 load_options_size;
879 efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID; 438 efi_guid_t proto = LOADED_IMAGE_PROTOCOL_GUID;
880 int options_size = 0; 439 int options_size = 0;
881 efi_status_t status; 440 efi_status_t status;
882 unsigned long cmdline; 441 char *cmdline_ptr;
883 u16 *s2; 442 u16 *s2;
884 u8 *s1; 443 u8 *s1;
885 int i; 444 int i;
445 unsigned long ramdisk_addr;
446 unsigned long ramdisk_size;
886 447
887 sys_table = _table; 448 sys_table = _table;
888 449
@@ -893,13 +454,14 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
893 status = efi_call_phys3(sys_table->boottime->handle_protocol, 454 status = efi_call_phys3(sys_table->boottime->handle_protocol,
894 handle, &proto, (void *)&image); 455 handle, &proto, (void *)&image);
895 if (status != EFI_SUCCESS) { 456 if (status != EFI_SUCCESS) {
896 efi_printk("Failed to get handle for LOADED_IMAGE_PROTOCOL\n"); 457 efi_printk(sys_table, "Failed to get handle for LOADED_IMAGE_PROTOCOL\n");
897 return NULL; 458 return NULL;
898 } 459 }
899 460
900 status = low_alloc(0x4000, 1, (unsigned long *)&boot_params); 461 status = efi_low_alloc(sys_table, 0x4000, 1,
462 (unsigned long *)&boot_params);
901 if (status != EFI_SUCCESS) { 463 if (status != EFI_SUCCESS) {
902 efi_printk("Failed to alloc lowmem for boot params\n"); 464 efi_printk(sys_table, "Failed to alloc lowmem for boot params\n");
903 return NULL; 465 return NULL;
904 } 466 }
905 467
@@ -926,40 +488,11 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
926 hdr->type_of_loader = 0x21; 488 hdr->type_of_loader = 0x21;
927 489
928 /* Convert unicode cmdline to ascii */ 490 /* Convert unicode cmdline to ascii */
929 options = image->load_options; 491 cmdline_ptr = efi_convert_cmdline_to_ascii(sys_table, image,
930 load_options_size = image->load_options_size / 2; /* ASCII */ 492 &options_size);
931 cmdline = 0; 493 if (!cmdline_ptr)
932 s2 = (u16 *)options; 494 goto fail;
933 495 hdr->cmd_line_ptr = (unsigned long)cmdline_ptr;
934 if (s2) {
935 while (*s2 && *s2 != '\n' && options_size < load_options_size) {
936 s2++;
937 options_size++;
938 }
939
940 if (options_size) {
941 if (options_size > hdr->cmdline_size)
942 options_size = hdr->cmdline_size;
943
944 options_size++; /* NUL termination */
945
946 status = low_alloc(options_size, 1, &cmdline);
947 if (status != EFI_SUCCESS) {
948 efi_printk("Failed to alloc mem for cmdline\n");
949 goto fail;
950 }
951
952 s1 = (u8 *)(unsigned long)cmdline;
953 s2 = (u16 *)options;
954
955 for (i = 0; i < options_size - 1; i++)
956 *s1++ = *s2++;
957
958 *s1 = '\0';
959 }
960 }
961
962 hdr->cmd_line_ptr = cmdline;
963 496
964 hdr->ramdisk_image = 0; 497 hdr->ramdisk_image = 0;
965 hdr->ramdisk_size = 0; 498 hdr->ramdisk_size = 0;
@@ -969,16 +502,20 @@ struct boot_params *make_boot_params(void *handle, efi_system_table_t *_table)
969 502
970 memset(sdt, 0, sizeof(*sdt)); 503 memset(sdt, 0, sizeof(*sdt));
971 504
972 status = handle_ramdisks(image, hdr); 505 status = handle_cmdline_files(sys_table, image,
506 (char *)(unsigned long)hdr->cmd_line_ptr,
507 "initrd=", hdr->initrd_addr_max,
508 &ramdisk_addr, &ramdisk_size);
973 if (status != EFI_SUCCESS) 509 if (status != EFI_SUCCESS)
974 goto fail2; 510 goto fail2;
511 hdr->ramdisk_image = ramdisk_addr;
512 hdr->ramdisk_size = ramdisk_size;
975 513
976 return boot_params; 514 return boot_params;
977fail2: 515fail2:
978 if (options_size) 516 efi_free(sys_table, options_size, hdr->cmd_line_ptr);
979 low_free(options_size, hdr->cmd_line_ptr);
980fail: 517fail:
981 low_free(0x4000, (unsigned long)boot_params); 518 efi_free(sys_table, 0x4000, (unsigned long)boot_params);
982 return NULL; 519 return NULL;
983} 520}
984 521
@@ -996,25 +533,12 @@ static efi_status_t exit_boot(struct boot_params *boot_params,
996 u8 nr_entries; 533 u8 nr_entries;
997 int i; 534 int i;
998 535
999 size = sizeof(*mem_map) * 32;
1000
1001again:
1002 size += sizeof(*mem_map) * 2;
1003 _size = size;
1004 status = low_alloc(size, 1, (unsigned long *)&mem_map);
1005 if (status != EFI_SUCCESS)
1006 return status;
1007
1008get_map: 536get_map:
1009 status = efi_call_phys5(sys_table->boottime->get_memory_map, &size, 537 status = efi_get_memory_map(sys_table, &mem_map, &size, &desc_size,
1010 mem_map, &key, &desc_size, &desc_version); 538 &desc_version, &key);
1011 if (status == EFI_BUFFER_TOO_SMALL) {
1012 low_free(_size, (unsigned long)mem_map);
1013 goto again;
1014 }
1015 539
1016 if (status != EFI_SUCCESS) 540 if (status != EFI_SUCCESS)
1017 goto free_mem_map; 541 return status;
1018 542
1019 memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32)); 543 memcpy(&efi->efi_loader_signature, EFI_LOADER_SIGNATURE, sizeof(__u32));
1020 efi->efi_systab = (unsigned long)sys_table; 544 efi->efi_systab = (unsigned long)sys_table;
@@ -1043,6 +567,7 @@ get_map:
1043 goto free_mem_map; 567 goto free_mem_map;
1044 568
1045 called_exit = true; 569 called_exit = true;
570 efi_call_phys1(sys_table->boottime->free_pool, mem_map);
1046 goto get_map; 571 goto get_map;
1047 } 572 }
1048 573
@@ -1111,44 +636,10 @@ get_map:
1111 return EFI_SUCCESS; 636 return EFI_SUCCESS;
1112 637
1113free_mem_map: 638free_mem_map:
1114 low_free(_size, (unsigned long)mem_map); 639 efi_call_phys1(sys_table->boottime->free_pool, mem_map);
1115 return status; 640 return status;
1116} 641}
1117 642
1118static efi_status_t relocate_kernel(struct setup_header *hdr)
1119{
1120 unsigned long start, nr_pages;
1121 efi_status_t status;
1122
1123 /*
1124 * The EFI firmware loader could have placed the kernel image
1125 * anywhere in memory, but the kernel has various restrictions
1126 * on the max physical address it can run at. Attempt to move
1127 * the kernel to boot_params.pref_address, or as low as
1128 * possible.
1129 */
1130 start = hdr->pref_address;
1131 nr_pages = round_up(hdr->init_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
1132
1133 status = efi_call_phys4(sys_table->boottime->allocate_pages,
1134 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
1135 nr_pages, &start);
1136 if (status != EFI_SUCCESS) {
1137 status = low_alloc(hdr->init_size, hdr->kernel_alignment,
1138 &start);
1139 if (status != EFI_SUCCESS)
1140 efi_printk("Failed to alloc mem for kernel\n");
1141 }
1142
1143 if (status == EFI_SUCCESS)
1144 memcpy((void *)start, (void *)(unsigned long)hdr->code32_start,
1145 hdr->init_size);
1146
1147 hdr->pref_address = hdr->code32_start;
1148 hdr->code32_start = (__u32)start;
1149
1150 return status;
1151}
1152 643
1153/* 644/*
1154 * On success we return a pointer to a boot_params structure, and NULL 645 * On success we return a pointer to a boot_params structure, and NULL
@@ -1177,14 +668,15 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
1177 EFI_LOADER_DATA, sizeof(*gdt), 668 EFI_LOADER_DATA, sizeof(*gdt),
1178 (void **)&gdt); 669 (void **)&gdt);
1179 if (status != EFI_SUCCESS) { 670 if (status != EFI_SUCCESS) {
1180 efi_printk("Failed to alloc mem for gdt structure\n"); 671 efi_printk(sys_table, "Failed to alloc mem for gdt structure\n");
1181 goto fail; 672 goto fail;
1182 } 673 }
1183 674
1184 gdt->size = 0x800; 675 gdt->size = 0x800;
1185 status = low_alloc(gdt->size, 8, (unsigned long *)&gdt->address); 676 status = efi_low_alloc(sys_table, gdt->size, 8,
677 (unsigned long *)&gdt->address);
1186 if (status != EFI_SUCCESS) { 678 if (status != EFI_SUCCESS) {
1187 efi_printk("Failed to alloc mem for gdt\n"); 679 efi_printk(sys_table, "Failed to alloc mem for gdt\n");
1188 goto fail; 680 goto fail;
1189 } 681 }
1190 682
@@ -1192,7 +684,7 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
1192 EFI_LOADER_DATA, sizeof(*idt), 684 EFI_LOADER_DATA, sizeof(*idt),
1193 (void **)&idt); 685 (void **)&idt);
1194 if (status != EFI_SUCCESS) { 686 if (status != EFI_SUCCESS) {
1195 efi_printk("Failed to alloc mem for idt structure\n"); 687 efi_printk(sys_table, "Failed to alloc mem for idt structure\n");
1196 goto fail; 688 goto fail;
1197 } 689 }
1198 690
@@ -1204,10 +696,16 @@ struct boot_params *efi_main(void *handle, efi_system_table_t *_table,
1204 * address, relocate it. 696 * address, relocate it.
1205 */ 697 */
1206 if (hdr->pref_address != hdr->code32_start) { 698 if (hdr->pref_address != hdr->code32_start) {
1207 status = relocate_kernel(hdr); 699 unsigned long bzimage_addr = hdr->code32_start;
1208 700 status = efi_relocate_kernel(sys_table, &bzimage_addr,
701 hdr->init_size, hdr->init_size,
702 hdr->pref_address,
703 hdr->kernel_alignment);
1209 if (status != EFI_SUCCESS) 704 if (status != EFI_SUCCESS)
1210 goto fail; 705 goto fail;
706
707 hdr->pref_address = hdr->code32_start;
708 hdr->code32_start = bzimage_addr;
1211 } 709 }
1212 710
1213 status = exit_boot(boot_params, handle); 711 status = exit_boot(boot_params, handle);
diff --git a/arch/x86/boot/compressed/eboot.h b/arch/x86/boot/compressed/eboot.h
index e5b0a8f91c5f..81b6b652b46a 100644
--- a/arch/x86/boot/compressed/eboot.h
+++ b/arch/x86/boot/compressed/eboot.h
@@ -11,9 +11,6 @@
11 11
12#define DESC_TYPE_CODE_DATA (1 << 0) 12#define DESC_TYPE_CODE_DATA (1 << 0)
13 13
14#define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)
15#define EFI_READ_CHUNK_SIZE (1024 * 1024)
16
17#define EFI_CONSOLE_OUT_DEVICE_GUID \ 14#define EFI_CONSOLE_OUT_DEVICE_GUID \
18 EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x0, 0x90, 0x27, \ 15 EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x0, 0x90, 0x27, \
19 0x3f, 0xc1, 0x4d) 16 0x3f, 0xc1, 0x4d)
@@ -62,10 +59,4 @@ struct efi_uga_draw_protocol {
62 void *blt; 59 void *blt;
63}; 60};
64 61
65struct efi_simple_text_output_protocol {
66 void *reset;
67 void *output_string;
68 void *test_string;
69};
70
71#endif /* BOOT_COMPRESSED_EBOOT_H */ 62#endif /* BOOT_COMPRESSED_EBOOT_H */
diff --git a/drivers/firmware/efi/efi-stub-helper.c b/drivers/firmware/efi/efi-stub-helper.c
new file mode 100644
index 000000000000..cc0581daa9ed
--- /dev/null
+++ b/drivers/firmware/efi/efi-stub-helper.c
@@ -0,0 +1,638 @@
1/*
2 * Helper functions used by the EFI stub on multiple
3 * architectures. This should be #included by the EFI stub
4 * implementation files.
5 *
6 * Copyright 2011 Intel Corporation; author Matt Fleming
7 *
8 * This file is part of the Linux kernel, and is made available
9 * under the terms of the GNU General Public License version 2.
10 *
11 */
12#define EFI_READ_CHUNK_SIZE (1024 * 1024)
13
14struct file_info {
15 efi_file_handle_t *handle;
16 u64 size;
17};
18
19
20
21
22static void efi_char16_printk(efi_system_table_t *sys_table_arg,
23 efi_char16_t *str)
24{
25 struct efi_simple_text_output_protocol *out;
26
27 out = (struct efi_simple_text_output_protocol *)sys_table_arg->con_out;
28 efi_call_phys2(out->output_string, out, str);
29}
30
31static void efi_printk(efi_system_table_t *sys_table_arg, char *str)
32{
33 char *s8;
34
35 for (s8 = str; *s8; s8++) {
36 efi_char16_t ch[2] = { 0 };
37
38 ch[0] = *s8;
39 if (*s8 == '\n') {
40 efi_char16_t nl[2] = { '\r', 0 };
41 efi_char16_printk(sys_table_arg, nl);
42 }
43
44 efi_char16_printk(sys_table_arg, ch);
45 }
46}
47
48
49static efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
50 efi_memory_desc_t **map,
51 unsigned long *map_size,
52 unsigned long *desc_size,
53 u32 *desc_ver,
54 unsigned long *key_ptr)
55{
56 efi_memory_desc_t *m = NULL;
57 efi_status_t status;
58 unsigned long key;
59 u32 desc_version;
60
61 *map_size = sizeof(*m) * 32;
62again:
63 /*
64 * Add an additional efi_memory_desc_t because we're doing an
65 * allocation which may be in a new descriptor region.
66 */
67 *map_size += sizeof(*m);
68 status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
69 EFI_LOADER_DATA, *map_size, (void **)&m);
70 if (status != EFI_SUCCESS)
71 goto fail;
72
73 status = efi_call_phys5(sys_table_arg->boottime->get_memory_map,
74 map_size, m, &key, desc_size, &desc_version);
75 if (status == EFI_BUFFER_TOO_SMALL) {
76 efi_call_phys1(sys_table_arg->boottime->free_pool, m);
77 goto again;
78 }
79
80 if (status != EFI_SUCCESS)
81 efi_call_phys1(sys_table_arg->boottime->free_pool, m);
82 if (key_ptr && status == EFI_SUCCESS)
83 *key_ptr = key;
84 if (desc_ver && status == EFI_SUCCESS)
85 *desc_ver = desc_version;
86
87fail:
88 *map = m;
89 return status;
90}
91
92/*
93 * Allocate at the highest possible address that is not above 'max'.
94 */
95static efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg,
96 unsigned long size, unsigned long align,
97 unsigned long *addr, unsigned long max)
98{
99 unsigned long map_size, desc_size;
100 efi_memory_desc_t *map;
101 efi_status_t status;
102 unsigned long nr_pages;
103 u64 max_addr = 0;
104 int i;
105
106 status = efi_get_memory_map(sys_table_arg, &map, &map_size, &desc_size,
107 NULL, NULL);
108 if (status != EFI_SUCCESS)
109 goto fail;
110
111 /*
112 * Enforce minimum alignment that EFI requires when requesting
113 * a specific address. We are doing page-based allocations,
114 * so we must be aligned to a page.
115 */
116 if (align < EFI_PAGE_SIZE)
117 align = EFI_PAGE_SIZE;
118
119 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
120again:
121 for (i = 0; i < map_size / desc_size; i++) {
122 efi_memory_desc_t *desc;
123 unsigned long m = (unsigned long)map;
124 u64 start, end;
125
126 desc = (efi_memory_desc_t *)(m + (i * desc_size));
127 if (desc->type != EFI_CONVENTIONAL_MEMORY)
128 continue;
129
130 if (desc->num_pages < nr_pages)
131 continue;
132
133 start = desc->phys_addr;
134 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
135
136 if ((start + size) > end || (start + size) > max)
137 continue;
138
139 if (end - size > max)
140 end = max;
141
142 if (round_down(end - size, align) < start)
143 continue;
144
145 start = round_down(end - size, align);
146
147 /*
148 * Don't allocate at 0x0. It will confuse code that
149 * checks pointers against NULL.
150 */
151 if (start == 0x0)
152 continue;
153
154 if (start > max_addr)
155 max_addr = start;
156 }
157
158 if (!max_addr)
159 status = EFI_NOT_FOUND;
160 else {
161 status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
162 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
163 nr_pages, &max_addr);
164 if (status != EFI_SUCCESS) {
165 max = max_addr;
166 max_addr = 0;
167 goto again;
168 }
169
170 *addr = max_addr;
171 }
172
173 efi_call_phys1(sys_table_arg->boottime->free_pool, map);
174
175fail:
176 return status;
177}
178
179/*
180 * Allocate at the lowest possible address.
181 */
182static efi_status_t efi_low_alloc(efi_system_table_t *sys_table_arg,
183 unsigned long size, unsigned long align,
184 unsigned long *addr)
185{
186 unsigned long map_size, desc_size;
187 efi_memory_desc_t *map;
188 efi_status_t status;
189 unsigned long nr_pages;
190 int i;
191
192 status = efi_get_memory_map(sys_table_arg, &map, &map_size, &desc_size,
193 NULL, NULL);
194 if (status != EFI_SUCCESS)
195 goto fail;
196
197 /*
198 * Enforce minimum alignment that EFI requires when requesting
199 * a specific address. We are doing page-based allocations,
200 * so we must be aligned to a page.
201 */
202 if (align < EFI_PAGE_SIZE)
203 align = EFI_PAGE_SIZE;
204
205 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
206 for (i = 0; i < map_size / desc_size; i++) {
207 efi_memory_desc_t *desc;
208 unsigned long m = (unsigned long)map;
209 u64 start, end;
210
211 desc = (efi_memory_desc_t *)(m + (i * desc_size));
212
213 if (desc->type != EFI_CONVENTIONAL_MEMORY)
214 continue;
215
216 if (desc->num_pages < nr_pages)
217 continue;
218
219 start = desc->phys_addr;
220 end = start + desc->num_pages * (1UL << EFI_PAGE_SHIFT);
221
222 /*
223 * Don't allocate at 0x0. It will confuse code that
224 * checks pointers against NULL. Skip the first 8
225 * bytes so we start at a nice even number.
226 */
227 if (start == 0x0)
228 start += 8;
229
230 start = round_up(start, align);
231 if ((start + size) > end)
232 continue;
233
234 status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
235 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
236 nr_pages, &start);
237 if (status == EFI_SUCCESS) {
238 *addr = start;
239 break;
240 }
241 }
242
243 if (i == map_size / desc_size)
244 status = EFI_NOT_FOUND;
245
246 efi_call_phys1(sys_table_arg->boottime->free_pool, map);
247fail:
248 return status;
249}
250
251static void efi_free(efi_system_table_t *sys_table_arg, unsigned long size,
252 unsigned long addr)
253{
254 unsigned long nr_pages;
255
256 if (!size)
257 return;
258
259 nr_pages = round_up(size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
260 efi_call_phys2(sys_table_arg->boottime->free_pages, addr, nr_pages);
261}
262
263
264/*
265 * Check the cmdline for a LILO-style file= arguments.
266 *
267 * We only support loading a file from the same filesystem as
268 * the kernel image.
269 */
270static efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
271 efi_loaded_image_t *image,
272 char *cmd_line, char *option_string,
273 unsigned long max_addr,
274 unsigned long *load_addr,
275 unsigned long *load_size)
276{
277 struct file_info *files;
278 unsigned long file_addr;
279 efi_guid_t fs_proto = EFI_FILE_SYSTEM_GUID;
280 u64 file_size_total;
281 efi_file_io_interface_t *io;
282 efi_file_handle_t *fh;
283 efi_status_t status;
284 int nr_files;
285 char *str;
286 int i, j, k;
287
288 file_addr = 0;
289 file_size_total = 0;
290
291 str = cmd_line;
292
293 j = 0; /* See close_handles */
294
295 if (!load_addr || !load_size)
296 return EFI_INVALID_PARAMETER;
297
298 *load_addr = 0;
299 *load_size = 0;
300
301 if (!str || !*str)
302 return EFI_SUCCESS;
303
304 for (nr_files = 0; *str; nr_files++) {
305 str = strstr(str, option_string);
306 if (!str)
307 break;
308
309 str += strlen(option_string);
310
311 /* Skip any leading slashes */
312 while (*str == '/' || *str == '\\')
313 str++;
314
315 while (*str && *str != ' ' && *str != '\n')
316 str++;
317 }
318
319 if (!nr_files)
320 return EFI_SUCCESS;
321
322 status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
323 EFI_LOADER_DATA,
324 nr_files * sizeof(*files),
325 (void **)&files);
326 if (status != EFI_SUCCESS) {
327 efi_printk(sys_table_arg, "Failed to alloc mem for file handle list\n");
328 goto fail;
329 }
330
331 str = cmd_line;
332 for (i = 0; i < nr_files; i++) {
333 struct file_info *file;
334 efi_file_handle_t *h;
335 efi_file_info_t *info;
336 efi_char16_t filename_16[256];
337 unsigned long info_sz;
338 efi_guid_t info_guid = EFI_FILE_INFO_ID;
339 efi_char16_t *p;
340 u64 file_sz;
341
342 str = strstr(str, option_string);
343 if (!str)
344 break;
345
346 str += strlen(option_string);
347
348 file = &files[i];
349 p = filename_16;
350
351 /* Skip any leading slashes */
352 while (*str == '/' || *str == '\\')
353 str++;
354
355 while (*str && *str != ' ' && *str != '\n') {
356 if ((u8 *)p >= (u8 *)filename_16 + sizeof(filename_16))
357 break;
358
359 if (*str == '/') {
360 *p++ = '\\';
361 str++;
362 } else {
363 *p++ = *str++;
364 }
365 }
366
367 *p = '\0';
368
369 /* Only open the volume once. */
370 if (!i) {
371 efi_boot_services_t *boottime;
372
373 boottime = sys_table_arg->boottime;
374
375 status = efi_call_phys3(boottime->handle_protocol,
376 image->device_handle, &fs_proto,
377 (void **)&io);
378 if (status != EFI_SUCCESS) {
379 efi_printk(sys_table_arg, "Failed to handle fs_proto\n");
380 goto free_files;
381 }
382
383 status = efi_call_phys2(io->open_volume, io, &fh);
384 if (status != EFI_SUCCESS) {
385 efi_printk(sys_table_arg, "Failed to open volume\n");
386 goto free_files;
387 }
388 }
389
390 status = efi_call_phys5(fh->open, fh, &h, filename_16,
391 EFI_FILE_MODE_READ, (u64)0);
392 if (status != EFI_SUCCESS) {
393 efi_printk(sys_table_arg, "Failed to open file: ");
394 efi_char16_printk(sys_table_arg, filename_16);
395 efi_printk(sys_table_arg, "\n");
396 goto close_handles;
397 }
398
399 file->handle = h;
400
401 info_sz = 0;
402 status = efi_call_phys4(h->get_info, h, &info_guid,
403 &info_sz, NULL);
404 if (status != EFI_BUFFER_TOO_SMALL) {
405 efi_printk(sys_table_arg, "Failed to get file info size\n");
406 goto close_handles;
407 }
408
409grow:
410 status = efi_call_phys3(sys_table_arg->boottime->allocate_pool,
411 EFI_LOADER_DATA, info_sz,
412 (void **)&info);
413 if (status != EFI_SUCCESS) {
414 efi_printk(sys_table_arg, "Failed to alloc mem for file info\n");
415 goto close_handles;
416 }
417
418 status = efi_call_phys4(h->get_info, h, &info_guid,
419 &info_sz, info);
420 if (status == EFI_BUFFER_TOO_SMALL) {
421 efi_call_phys1(sys_table_arg->boottime->free_pool,
422 info);
423 goto grow;
424 }
425
426 file_sz = info->file_size;
427 efi_call_phys1(sys_table_arg->boottime->free_pool, info);
428
429 if (status != EFI_SUCCESS) {
430 efi_printk(sys_table_arg, "Failed to get file info\n");
431 goto close_handles;
432 }
433
434 file->size = file_sz;
435 file_size_total += file_sz;
436 }
437
438 if (file_size_total) {
439 unsigned long addr;
440
441 /*
442 * Multiple files need to be at consecutive addresses in memory,
443 * so allocate enough memory for all the files. This is used
444 * for loading multiple files.
445 */
446 status = efi_high_alloc(sys_table_arg, file_size_total, 0x1000,
447 &file_addr, max_addr);
448 if (status != EFI_SUCCESS) {
449 efi_printk(sys_table_arg, "Failed to alloc highmem for files\n");
450 goto close_handles;
451 }
452
453 /* We've run out of free low memory. */
454 if (file_addr > max_addr) {
455 efi_printk(sys_table_arg, "We've run out of free low memory\n");
456 status = EFI_INVALID_PARAMETER;
457 goto free_file_total;
458 }
459
460 addr = file_addr;
461 for (j = 0; j < nr_files; j++) {
462 unsigned long size;
463
464 size = files[j].size;
465 while (size) {
466 unsigned long chunksize;
467 if (size > EFI_READ_CHUNK_SIZE)
468 chunksize = EFI_READ_CHUNK_SIZE;
469 else
470 chunksize = size;
471 status = efi_call_phys3(fh->read,
472 files[j].handle,
473 &chunksize,
474 (void *)addr);
475 if (status != EFI_SUCCESS) {
476 efi_printk(sys_table_arg, "Failed to read file\n");
477 goto free_file_total;
478 }
479 addr += chunksize;
480 size -= chunksize;
481 }
482
483 efi_call_phys1(fh->close, files[j].handle);
484 }
485
486 }
487
488 efi_call_phys1(sys_table_arg->boottime->free_pool, files);
489
490 *load_addr = file_addr;
491 *load_size = file_size_total;
492
493 return status;
494
495free_file_total:
496 efi_free(sys_table_arg, file_size_total, file_addr);
497
498close_handles:
499 for (k = j; k < i; k++)
500 efi_call_phys1(fh->close, files[k].handle);
501free_files:
502 efi_call_phys1(sys_table_arg->boottime->free_pool, files);
503fail:
504 *load_addr = 0;
505 *load_size = 0;
506
507 return status;
508}
509/*
510 * Relocate a kernel image, either compressed or uncompressed.
511 * In the ARM64 case, all kernel images are currently
512 * uncompressed, and as such when we relocate it we need to
513 * allocate additional space for the BSS segment. Any low
514 * memory that this function should avoid needs to be
515 * unavailable in the EFI memory map, as if the preferred
516 * address is not available the lowest available address will
517 * be used.
518 */
519static efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
520 unsigned long *image_addr,
521 unsigned long image_size,
522 unsigned long alloc_size,
523 unsigned long preferred_addr,
524 unsigned long alignment)
525{
526 unsigned long cur_image_addr;
527 unsigned long new_addr = 0;
528 efi_status_t status;
529 unsigned long nr_pages;
530 efi_physical_addr_t efi_addr = preferred_addr;
531
532 if (!image_addr || !image_size || !alloc_size)
533 return EFI_INVALID_PARAMETER;
534 if (alloc_size < image_size)
535 return EFI_INVALID_PARAMETER;
536
537 cur_image_addr = *image_addr;
538
539 /*
540 * The EFI firmware loader could have placed the kernel image
541 * anywhere in memory, but the kernel has restrictions on the
542 * max physical address it can run at. Some architectures
543 * also have a prefered address, so first try to relocate
544 * to the preferred address. If that fails, allocate as low
545 * as possible while respecting the required alignment.
546 */
547 nr_pages = round_up(alloc_size, EFI_PAGE_SIZE) / EFI_PAGE_SIZE;
548 status = efi_call_phys4(sys_table_arg->boottime->allocate_pages,
549 EFI_ALLOCATE_ADDRESS, EFI_LOADER_DATA,
550 nr_pages, &efi_addr);
551 new_addr = efi_addr;
552 /*
553 * If preferred address allocation failed allocate as low as
554 * possible.
555 */
556 if (status != EFI_SUCCESS) {
557 status = efi_low_alloc(sys_table_arg, alloc_size, alignment,
558 &new_addr);
559 }
560 if (status != EFI_SUCCESS) {
561 efi_printk(sys_table_arg, "ERROR: Failed to allocate usable memory for kernel.\n");
562 return status;
563 }
564
565 /*
566 * We know source/dest won't overlap since both memory ranges
567 * have been allocated by UEFI, so we can safely use memcpy.
568 */
569 memcpy((void *)new_addr, (void *)cur_image_addr, image_size);
570 /* Zero any extra space we may have allocated for BSS. */
571 memset((void *)(new_addr + image_size), alloc_size - image_size, 0);
572
573 /* Return the new address of the relocated image. */
574 *image_addr = new_addr;
575
576 return status;
577}
578
579/*
580 * Convert the unicode UEFI command line to ASCII to pass to kernel.
581 * Size of memory allocated return in *cmd_line_len.
582 * Returns NULL on error.
583 */
584static char *efi_convert_cmdline_to_ascii(efi_system_table_t *sys_table_arg,
585 efi_loaded_image_t *image,
586 int *cmd_line_len)
587{
588 u16 *s2;
589 u8 *s1 = NULL;
590 unsigned long cmdline_addr = 0;
591 int load_options_size = image->load_options_size / 2; /* ASCII */
592 void *options = image->load_options;
593 int options_size = 0;
594 efi_status_t status;
595 int i;
596 u16 zero = 0;
597
598 if (options) {
599 s2 = options;
600 while (*s2 && *s2 != '\n' && options_size < load_options_size) {
601 s2++;
602 options_size++;
603 }
604 }
605
606 if (options_size == 0) {
607 /* No command line options, so return empty string*/
608 options_size = 1;
609 options = &zero;
610 }
611
612 options_size++; /* NUL termination */
613#ifdef CONFIG_ARM
614 /*
615 * For ARM, allocate at a high address to avoid reserved
616 * regions at low addresses that we don't know the specfics of
617 * at the time we are processing the command line.
618 */
619 status = efi_high_alloc(sys_table_arg, options_size, 0,
620 &cmdline_addr, 0xfffff000);
621#else
622 status = efi_low_alloc(sys_table_arg, options_size, 0,
623 &cmdline_addr);
624#endif
625 if (status != EFI_SUCCESS)
626 return NULL;
627
628 s1 = (u8 *)cmdline_addr;
629 s2 = (u16 *)options;
630
631 for (i = 0; i < options_size - 1; i++)
632 *s1++ = *s2++;
633
634 *s1 = '\0';
635
636 *cmd_line_len = options_size;
637 return (char *)cmdline_addr;
638}
diff --git a/include/linux/efi.h b/include/linux/efi.h
index c084b6d942c3..bc5687d0f315 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -39,6 +39,8 @@
39typedef unsigned long efi_status_t; 39typedef unsigned long efi_status_t;
40typedef u8 efi_bool_t; 40typedef u8 efi_bool_t;
41typedef u16 efi_char16_t; /* UNICODE character */ 41typedef u16 efi_char16_t; /* UNICODE character */
42typedef u64 efi_physical_addr_t;
43typedef void *efi_handle_t;
42 44
43 45
44typedef struct { 46typedef struct {
@@ -96,6 +98,7 @@ typedef struct {
96#define EFI_MEMORY_DESCRIPTOR_VERSION 1 98#define EFI_MEMORY_DESCRIPTOR_VERSION 1
97 99
98#define EFI_PAGE_SHIFT 12 100#define EFI_PAGE_SHIFT 12
101#define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)
99 102
100typedef struct { 103typedef struct {
101 u32 type; 104 u32 type;
@@ -157,11 +160,13 @@ typedef struct {
157 efi_table_hdr_t hdr; 160 efi_table_hdr_t hdr;
158 void *raise_tpl; 161 void *raise_tpl;
159 void *restore_tpl; 162 void *restore_tpl;
160 void *allocate_pages; 163 efi_status_t (*allocate_pages)(int, int, unsigned long,
161 void *free_pages; 164 efi_physical_addr_t *);
162 void *get_memory_map; 165 efi_status_t (*free_pages)(efi_physical_addr_t, unsigned long);
163 void *allocate_pool; 166 efi_status_t (*get_memory_map)(unsigned long *, void *, unsigned long *,
164 void *free_pool; 167 unsigned long *, u32 *);
168 efi_status_t (*allocate_pool)(int, unsigned long, void **);
169 efi_status_t (*free_pool)(void *);
165 void *create_event; 170 void *create_event;
166 void *set_timer; 171 void *set_timer;
167 void *wait_for_event; 172 void *wait_for_event;
@@ -171,7 +176,7 @@ typedef struct {
171 void *install_protocol_interface; 176 void *install_protocol_interface;
172 void *reinstall_protocol_interface; 177 void *reinstall_protocol_interface;
173 void *uninstall_protocol_interface; 178 void *uninstall_protocol_interface;
174 void *handle_protocol; 179 efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **);
175 void *__reserved; 180 void *__reserved;
176 void *register_protocol_notify; 181 void *register_protocol_notify;
177 void *locate_handle; 182 void *locate_handle;
@@ -181,7 +186,7 @@ typedef struct {
181 void *start_image; 186 void *start_image;
182 void *exit; 187 void *exit;
183 void *unload_image; 188 void *unload_image;
184 void *exit_boot_services; 189 efi_status_t (*exit_boot_services)(efi_handle_t, unsigned long);
185 void *get_next_monotonic_count; 190 void *get_next_monotonic_count;
186 void *stall; 191 void *stall;
187 void *set_watchdog_timer; 192 void *set_watchdog_timer;
@@ -494,10 +499,6 @@ typedef struct {
494 unsigned long unload; 499 unsigned long unload;
495} efi_loaded_image_t; 500} efi_loaded_image_t;
496 501
497typedef struct {
498 u64 revision;
499 void *open_volume;
500} efi_file_io_interface_t;
501 502
502typedef struct { 503typedef struct {
503 u64 size; 504 u64 size;
@@ -510,20 +511,30 @@ typedef struct {
510 efi_char16_t filename[1]; 511 efi_char16_t filename[1];
511} efi_file_info_t; 512} efi_file_info_t;
512 513
513typedef struct { 514typedef struct _efi_file_handle {
514 u64 revision; 515 u64 revision;
515 void *open; 516 efi_status_t (*open)(struct _efi_file_handle *,
516 void *close; 517 struct _efi_file_handle **,
518 efi_char16_t *, u64, u64);
519 efi_status_t (*close)(struct _efi_file_handle *);
517 void *delete; 520 void *delete;
518 void *read; 521 efi_status_t (*read)(struct _efi_file_handle *, unsigned long *,
522 void *);
519 void *write; 523 void *write;
520 void *get_position; 524 void *get_position;
521 void *set_position; 525 void *set_position;
522 void *get_info; 526 efi_status_t (*get_info)(struct _efi_file_handle *, efi_guid_t *,
527 unsigned long *, void *);
523 void *set_info; 528 void *set_info;
524 void *flush; 529 void *flush;
525} efi_file_handle_t; 530} efi_file_handle_t;
526 531
532typedef struct _efi_file_io_interface {
533 u64 revision;
534 int (*open_volume)(struct _efi_file_io_interface *,
535 efi_file_handle_t **);
536} efi_file_io_interface_t;
537
527#define EFI_FILE_MODE_READ 0x0000000000000001 538#define EFI_FILE_MODE_READ 0x0000000000000001
528#define EFI_FILE_MODE_WRITE 0x0000000000000002 539#define EFI_FILE_MODE_WRITE 0x0000000000000002
529#define EFI_FILE_MODE_CREATE 0x8000000000000000 540#define EFI_FILE_MODE_CREATE 0x8000000000000000
@@ -792,6 +803,13 @@ struct efivar_entry {
792 struct kobject kobj; 803 struct kobject kobj;
793}; 804};
794 805
806
807struct efi_simple_text_output_protocol {
808 void *reset;
809 efi_status_t (*output_string)(void *, void *);
810 void *test_string;
811};
812
795extern struct list_head efivar_sysfs_list; 813extern struct list_head efivar_sysfs_list;
796 814
797static inline void 815static inline void
generated by cgit v1.2.2 (git 2.25.0) at 2025-08-19 03:11:07 -0400