Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 1 | /* |
| 2 | * EFI application loader |
| 3 | * |
| 4 | * Copyright (c) 2016 Alexander Graf |
| 5 | * |
| 6 | * SPDX-License-Identifier: GPL-2.0+ |
| 7 | */ |
| 8 | |
| 9 | #include <common.h> |
| 10 | #include <command.h> |
Simon Glass | 9d92245 | 2017-05-17 17:18:03 -0600 | [diff] [blame] | 11 | #include <dm.h> |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 12 | #include <efi_loader.h> |
| 13 | #include <errno.h> |
| 14 | #include <libfdt.h> |
| 15 | #include <libfdt_env.h> |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 16 | #include <memalign.h> |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 17 | #include <asm/global_data.h> |
Simon Glass | e275458 | 2016-09-25 15:27:32 -0600 | [diff] [blame] | 18 | #include <asm-generic/sections.h> |
| 19 | #include <linux/linkage.h> |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 20 | |
| 21 | DECLARE_GLOBAL_DATA_PTR; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 22 | |
| 23 | /* |
| 24 | * When booting using the "bootefi" command, we don't know which |
| 25 | * physical device the file came from. So we create a pseudo-device |
| 26 | * called "bootefi" with the device path /bootefi. |
| 27 | * |
| 28 | * In addition to the originating device we also declare the file path |
| 29 | * of "bootefi" based loads to be /bootefi. |
| 30 | */ |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 31 | static struct efi_device_path_file_path bootefi_image_path[] = { |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 32 | { |
| 33 | .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, |
| 34 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 35 | .dp.length = sizeof(bootefi_image_path[0]), |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 36 | .str = { 'b','o','o','t','e','f','i' }, |
| 37 | }, { |
| 38 | .dp.type = DEVICE_PATH_TYPE_END, |
| 39 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_END, |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 40 | .dp.length = sizeof(bootefi_image_path[0]), |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 41 | } |
| 42 | }; |
| 43 | |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 44 | static struct efi_device_path_file_path bootefi_device_path[] = { |
| 45 | { |
| 46 | .dp.type = DEVICE_PATH_TYPE_MEDIA_DEVICE, |
| 47 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_FILE_PATH, |
| 48 | .dp.length = sizeof(bootefi_image_path[0]), |
| 49 | .str = { 'b','o','o','t','e','f','i' }, |
| 50 | }, { |
| 51 | .dp.type = DEVICE_PATH_TYPE_END, |
| 52 | .dp.sub_type = DEVICE_PATH_SUB_TYPE_END, |
| 53 | .dp.length = sizeof(bootefi_image_path[0]), |
| 54 | } |
| 55 | }; |
| 56 | |
Simon Glass | e275458 | 2016-09-25 15:27:32 -0600 | [diff] [blame] | 57 | static efi_status_t EFIAPI bootefi_open_dp(void *handle, efi_guid_t *protocol, |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 58 | void **protocol_interface, void *agent_handle, |
| 59 | void *controller_handle, uint32_t attributes) |
| 60 | { |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 61 | *protocol_interface = bootefi_device_path; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 62 | return EFI_SUCCESS; |
| 63 | } |
| 64 | |
| 65 | /* The EFI loaded_image interface for the image executed via "bootefi" */ |
| 66 | static struct efi_loaded_image loaded_image_info = { |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 67 | .device_handle = bootefi_device_path, |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 68 | .file_path = bootefi_image_path, |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 69 | }; |
| 70 | |
| 71 | /* The EFI object struct for the image executed via "bootefi" */ |
| 72 | static struct efi_object loaded_image_info_obj = { |
| 73 | .handle = &loaded_image_info, |
| 74 | .protocols = { |
| 75 | { |
| 76 | /* |
| 77 | * When asking for the loaded_image interface, just |
| 78 | * return handle which points to loaded_image_info |
| 79 | */ |
| 80 | .guid = &efi_guid_loaded_image, |
| 81 | .open = &efi_return_handle, |
| 82 | }, |
| 83 | { |
| 84 | /* |
| 85 | * When asking for the device path interface, return |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 86 | * bootefi_device_path |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 87 | */ |
| 88 | .guid = &efi_guid_device_path, |
| 89 | .open = &bootefi_open_dp, |
| 90 | }, |
| 91 | }, |
| 92 | }; |
| 93 | |
| 94 | /* The EFI object struct for the device the "bootefi" image was loaded from */ |
| 95 | static struct efi_object bootefi_device_obj = { |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 96 | .handle = bootefi_device_path, |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 97 | .protocols = { |
| 98 | { |
| 99 | /* When asking for the device path interface, return |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 100 | * bootefi_device_path */ |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 101 | .guid = &efi_guid_device_path, |
| 102 | .open = &bootefi_open_dp, |
| 103 | } |
| 104 | }, |
| 105 | }; |
| 106 | |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 107 | static void *copy_fdt(void *fdt) |
| 108 | { |
| 109 | u64 fdt_size = fdt_totalsize(fdt); |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 110 | unsigned long fdt_ram_start = -1L, fdt_pages; |
| 111 | u64 new_fdt_addr; |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 112 | void *new_fdt; |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 113 | int i; |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 114 | |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 115 | for (i = 0; i < CONFIG_NR_DRAM_BANKS; i++) { |
| 116 | u64 ram_start = gd->bd->bi_dram[i].start; |
| 117 | u64 ram_size = gd->bd->bi_dram[i].size; |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 118 | |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 119 | if (!ram_size) |
| 120 | continue; |
| 121 | |
| 122 | if (ram_start < fdt_ram_start) |
| 123 | fdt_ram_start = ram_start; |
| 124 | } |
| 125 | |
| 126 | /* Give us at least 4kb breathing room */ |
| 127 | fdt_size = ALIGN(fdt_size + 4096, 4096); |
| 128 | fdt_pages = fdt_size >> EFI_PAGE_SHIFT; |
| 129 | |
| 130 | /* Safe fdt location is at 128MB */ |
| 131 | new_fdt_addr = fdt_ram_start + (128 * 1024 * 1024) + fdt_size; |
| 132 | if (efi_allocate_pages(1, EFI_BOOT_SERVICES_DATA, fdt_pages, |
| 133 | &new_fdt_addr) != EFI_SUCCESS) { |
| 134 | /* If we can't put it there, put it somewhere */ |
| 135 | new_fdt_addr = (ulong)memalign(4096, fdt_size); |
Alexander Graf | 85a6e9b | 2017-07-03 13:32:35 +0200 | [diff] [blame] | 136 | if (efi_allocate_pages(1, EFI_BOOT_SERVICES_DATA, fdt_pages, |
| 137 | &new_fdt_addr) != EFI_SUCCESS) { |
| 138 | printf("ERROR: Failed to reserve space for FDT\n"); |
| 139 | return NULL; |
| 140 | } |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 141 | } |
Alexander Graf | 85a6e9b | 2017-07-03 13:32:35 +0200 | [diff] [blame] | 142 | |
Alexander Graf | ad0c1a3 | 2016-04-11 23:51:01 +0200 | [diff] [blame] | 143 | new_fdt = (void*)(ulong)new_fdt_addr; |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 144 | memcpy(new_fdt, fdt, fdt_totalsize(fdt)); |
| 145 | fdt_set_totalsize(new_fdt, fdt_size); |
| 146 | |
| 147 | return new_fdt; |
| 148 | } |
| 149 | |
Alison Wang | ec6617c | 2016-11-10 10:49:03 +0800 | [diff] [blame] | 150 | #ifdef CONFIG_ARM64 |
| 151 | static unsigned long efi_run_in_el2(ulong (*entry)(void *image_handle, |
| 152 | struct efi_system_table *st), void *image_handle, |
| 153 | struct efi_system_table *st) |
| 154 | { |
| 155 | /* Enable caches again */ |
| 156 | dcache_enable(); |
| 157 | |
| 158 | return entry(image_handle, st); |
| 159 | } |
| 160 | #endif |
| 161 | |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 162 | /* |
| 163 | * Load an EFI payload into a newly allocated piece of memory, register all |
| 164 | * EFI objects it would want to access and jump to it. |
| 165 | */ |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 166 | static unsigned long do_bootefi_exec(void *efi, void *fdt) |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 167 | { |
Simon Glass | e275458 | 2016-09-25 15:27:32 -0600 | [diff] [blame] | 168 | ulong (*entry)(void *image_handle, struct efi_system_table *st) |
| 169 | asmlinkage; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 170 | ulong fdt_pages, fdt_size, fdt_start, fdt_end; |
Alexander Graf | dea2174 | 2016-03-04 01:10:13 +0100 | [diff] [blame] | 171 | bootm_headers_t img = { 0 }; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 172 | |
| 173 | /* |
| 174 | * gd lives in a fixed register which may get clobbered while we execute |
| 175 | * the payload. So save it here and restore it on every callback entry |
| 176 | */ |
| 177 | efi_save_gd(); |
| 178 | |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 179 | if (fdt && !fdt_check_header(fdt)) { |
Alexander Graf | dea2174 | 2016-03-04 01:10:13 +0100 | [diff] [blame] | 180 | /* Prepare fdt for payload */ |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 181 | fdt = copy_fdt(fdt); |
| 182 | |
| 183 | if (image_setup_libfdt(&img, fdt, 0, NULL)) { |
Alexander Graf | dea2174 | 2016-03-04 01:10:13 +0100 | [diff] [blame] | 184 | printf("ERROR: Failed to process device tree\n"); |
| 185 | return -EINVAL; |
| 186 | } |
| 187 | |
| 188 | /* Link to it in the efi tables */ |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 189 | systab.tables[0].guid = EFI_FDT_GUID; |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 190 | systab.tables[0].table = fdt; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 191 | systab.nr_tables = 1; |
| 192 | |
| 193 | /* And reserve the space in the memory map */ |
Alexander Graf | 0d9d501 | 2016-04-11 16:55:26 +0200 | [diff] [blame] | 194 | fdt_start = ((ulong)fdt) & ~EFI_PAGE_MASK; |
| 195 | fdt_end = ((ulong)fdt) + fdt_totalsize(fdt); |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 196 | fdt_size = (fdt_end - fdt_start) + EFI_PAGE_MASK; |
| 197 | fdt_pages = fdt_size >> EFI_PAGE_SHIFT; |
| 198 | /* Give a bootloader the chance to modify the device tree */ |
| 199 | fdt_pages += 2; |
| 200 | efi_add_memory_map(fdt_start, fdt_pages, |
| 201 | EFI_BOOT_SERVICES_DATA, true); |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 202 | } else { |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 203 | printf("WARNING: Invalid device tree, expect boot to fail\n"); |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 204 | systab.nr_tables = 0; |
| 205 | } |
| 206 | |
| 207 | /* Load the EFI payload */ |
| 208 | entry = efi_load_pe(efi, &loaded_image_info); |
| 209 | if (!entry) |
| 210 | return -ENOENT; |
| 211 | |
| 212 | /* Initialize and populate EFI object list */ |
| 213 | INIT_LIST_HEAD(&efi_obj_list); |
| 214 | list_add_tail(&loaded_image_info_obj.link, &efi_obj_list); |
| 215 | list_add_tail(&bootefi_device_obj.link, &efi_obj_list); |
| 216 | #ifdef CONFIG_PARTITIONS |
| 217 | efi_disk_register(); |
| 218 | #endif |
Alexander Graf | be8d324 | 2016-03-15 18:38:21 +0100 | [diff] [blame] | 219 | #ifdef CONFIG_LCD |
| 220 | efi_gop_register(); |
| 221 | #endif |
Alexander Graf | 0efe1bc | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 222 | #ifdef CONFIG_NET |
| 223 | void *nethandle = loaded_image_info.device_handle; |
| 224 | efi_net_register(&nethandle); |
| 225 | |
| 226 | if (!memcmp(bootefi_device_path[0].str, "N\0e\0t", 6)) |
| 227 | loaded_image_info.device_handle = nethandle; |
Alexander Graf | 3fb97e2 | 2016-10-18 15:49:40 +0200 | [diff] [blame] | 228 | else |
| 229 | loaded_image_info.device_handle = bootefi_device_path; |
Alexander Graf | 0efe1bc | 2016-05-06 21:01:01 +0200 | [diff] [blame] | 230 | #endif |
Alexander Graf | e663b35 | 2016-08-19 01:23:29 +0200 | [diff] [blame] | 231 | #ifdef CONFIG_GENERATE_SMBIOS_TABLE |
| 232 | efi_smbios_register(); |
| 233 | #endif |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 234 | |
Alexander Graf | 80a4800 | 2016-08-16 21:08:45 +0200 | [diff] [blame] | 235 | /* Initialize EFI runtime services */ |
| 236 | efi_reset_system_init(); |
| 237 | efi_get_time_init(); |
| 238 | |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 239 | /* Call our payload! */ |
Alexander Graf | edcef3b | 2016-06-02 11:38:27 +0200 | [diff] [blame] | 240 | debug("%s:%d Jumping to 0x%lx\n", __func__, __LINE__, (long)entry); |
Alexander Graf | a86aeaf | 2016-05-20 23:28:23 +0200 | [diff] [blame] | 241 | |
| 242 | if (setjmp(&loaded_image_info.exit_jmp)) { |
| 243 | efi_status_t status = loaded_image_info.exit_status; |
| 244 | return status == EFI_SUCCESS ? 0 : -EINVAL; |
| 245 | } |
| 246 | |
Alexander Graf | 69bd459 | 2016-11-17 01:02:58 +0100 | [diff] [blame] | 247 | #ifdef CONFIG_ARM64 |
| 248 | /* On AArch64 we need to make sure we call our payload in < EL3 */ |
| 249 | if (current_el() == 3) { |
| 250 | smp_kick_all_cpus(); |
| 251 | dcache_disable(); /* flush cache before switch to EL2 */ |
Alison Wang | ec6617c | 2016-11-10 10:49:03 +0800 | [diff] [blame] | 252 | |
| 253 | /* Move into EL2 and keep running there */ |
| 254 | armv8_switch_to_el2((ulong)entry, (ulong)&loaded_image_info, |
Alison Wang | 7c5e1fe | 2017-01-17 09:39:17 +0800 | [diff] [blame] | 255 | (ulong)&systab, 0, (ulong)efi_run_in_el2, |
Alison Wang | ec6617c | 2016-11-10 10:49:03 +0800 | [diff] [blame] | 256 | ES_TO_AARCH64); |
| 257 | |
| 258 | /* Should never reach here, efi exits with longjmp */ |
| 259 | while (1) { } |
Alexander Graf | 69bd459 | 2016-11-17 01:02:58 +0100 | [diff] [blame] | 260 | } |
| 261 | #endif |
| 262 | |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 263 | return entry(&loaded_image_info, &systab); |
| 264 | } |
| 265 | |
| 266 | |
| 267 | /* Interpreter command to boot an arbitrary EFI image from memory */ |
| 268 | static int do_bootefi(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]) |
| 269 | { |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 270 | char *saddr, *sfdt; |
| 271 | unsigned long addr, fdt_addr = 0; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 272 | int r = 0; |
| 273 | |
| 274 | if (argc < 2) |
Bin Meng | 3c1dcef | 2016-08-13 04:02:06 -0700 | [diff] [blame] | 275 | return CMD_RET_USAGE; |
Simon Glass | c7ae3df | 2016-11-07 08:47:08 -0700 | [diff] [blame] | 276 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
| 277 | if (!strcmp(argv[1], "hello")) { |
| 278 | ulong size = __efi_hello_world_end - __efi_hello_world_begin; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 279 | |
Simon Glass | c7ae3df | 2016-11-07 08:47:08 -0700 | [diff] [blame] | 280 | addr = CONFIG_SYS_LOAD_ADDR; |
| 281 | memcpy((char *)addr, __efi_hello_world_begin, size); |
| 282 | } else |
| 283 | #endif |
| 284 | { |
| 285 | saddr = argv[1]; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 286 | |
Simon Glass | c7ae3df | 2016-11-07 08:47:08 -0700 | [diff] [blame] | 287 | addr = simple_strtoul(saddr, NULL, 16); |
| 288 | |
| 289 | if (argc > 2) { |
| 290 | sfdt = argv[2]; |
| 291 | fdt_addr = simple_strtoul(sfdt, NULL, 16); |
| 292 | } |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 293 | } |
| 294 | |
Simon Glass | 5ee31ba | 2016-11-07 08:47:05 -0700 | [diff] [blame] | 295 | printf("## Starting EFI application at %08lx ...\n", addr); |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 296 | r = do_bootefi_exec((void *)addr, (void*)fdt_addr); |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 297 | printf("## Application terminated, r = %d\n", r); |
| 298 | |
| 299 | if (r != 0) |
| 300 | r = 1; |
| 301 | |
| 302 | return r; |
| 303 | } |
| 304 | |
| 305 | #ifdef CONFIG_SYS_LONGHELP |
| 306 | static char bootefi_help_text[] = |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 307 | "<image address> [fdt address]\n" |
| 308 | " - boot EFI payload stored at address <image address>.\n" |
| 309 | " If specified, the device tree located at <fdt address> gets\n" |
Simon Glass | c7ae3df | 2016-11-07 08:47:08 -0700 | [diff] [blame] | 310 | " exposed as EFI configuration table.\n" |
| 311 | #ifdef CONFIG_CMD_BOOTEFI_HELLO |
| 312 | "hello\n" |
| 313 | " - boot a sample Hello World application stored within U-Boot" |
| 314 | #endif |
| 315 | ; |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 316 | #endif |
| 317 | |
| 318 | U_BOOT_CMD( |
Alexander Graf | 1c39809 | 2016-04-14 16:07:53 +0200 | [diff] [blame] | 319 | bootefi, 3, 0, do_bootefi, |
Sergey Kubushyn | 92dfd92 | 2016-06-07 11:14:31 -0700 | [diff] [blame] | 320 | "Boots an EFI payload from memory", |
Alexander Graf | b993933 | 2016-03-10 00:27:20 +0100 | [diff] [blame] | 321 | bootefi_help_text |
| 322 | ); |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 323 | |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 324 | void efi_set_bootdev(const char *dev, const char *devnr, const char *path) |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 325 | { |
Alexander Graf | 8c3df0b | 2016-04-11 16:16:18 +0200 | [diff] [blame] | 326 | __maybe_unused struct blk_desc *desc; |
Alexander Graf | ecbe1a0 | 2016-04-11 16:16:20 +0200 | [diff] [blame] | 327 | char devname[32] = { 0 }; /* dp->str is u16[32] long */ |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 328 | char *colon; |
| 329 | |
Patrick Delaunay | 1acc008 | 2017-01-27 11:00:38 +0100 | [diff] [blame] | 330 | #if defined(CONFIG_BLK) || CONFIG_IS_ENABLED(ISO_PARTITION) |
Alexander Graf | f9d334b | 2016-08-05 14:49:53 +0200 | [diff] [blame] | 331 | desc = blk_get_dev(dev, simple_strtol(devnr, NULL, 10)); |
| 332 | #endif |
| 333 | |
| 334 | #ifdef CONFIG_BLK |
| 335 | if (desc) { |
| 336 | snprintf(devname, sizeof(devname), "%s", desc->bdev->name); |
| 337 | } else |
| 338 | #endif |
| 339 | |
| 340 | { |
| 341 | /* Assemble the condensed device name we use in efi_disk.c */ |
| 342 | snprintf(devname, sizeof(devname), "%s%s", dev, devnr); |
| 343 | } |
| 344 | |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 345 | colon = strchr(devname, ':'); |
Alexander Graf | 8c3df0b | 2016-04-11 16:16:18 +0200 | [diff] [blame] | 346 | |
Patrick Delaunay | 1acc008 | 2017-01-27 11:00:38 +0100 | [diff] [blame] | 347 | #if CONFIG_IS_ENABLED(ISO_PARTITION) |
Alexander Graf | 8c3df0b | 2016-04-11 16:16:18 +0200 | [diff] [blame] | 348 | /* For ISOs we create partition block devices */ |
Alexander Graf | 8c3df0b | 2016-04-11 16:16:18 +0200 | [diff] [blame] | 349 | if (desc && (desc->type != DEV_TYPE_UNKNOWN) && |
| 350 | (desc->part_type == PART_TYPE_ISO)) { |
| 351 | if (!colon) |
Alexander Graf | f9d334b | 2016-08-05 14:49:53 +0200 | [diff] [blame] | 352 | snprintf(devname, sizeof(devname), "%s:1", devname); |
| 353 | |
Alexander Graf | 8c3df0b | 2016-04-11 16:16:18 +0200 | [diff] [blame] | 354 | colon = NULL; |
| 355 | } |
| 356 | #endif |
| 357 | |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 358 | if (colon) |
| 359 | *colon = '\0'; |
| 360 | |
Alexander Graf | c07ad7c | 2016-04-11 16:16:19 +0200 | [diff] [blame] | 361 | /* Patch bootefi_device_path to the target device */ |
| 362 | memset(bootefi_device_path[0].str, 0, sizeof(bootefi_device_path[0].str)); |
| 363 | ascii2unicode(bootefi_device_path[0].str, devname); |
| 364 | |
| 365 | /* Patch bootefi_image_path to the target file path */ |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 366 | memset(bootefi_image_path[0].str, 0, sizeof(bootefi_image_path[0].str)); |
Alexander Graf | 4927166 | 2016-07-21 01:44:46 +0200 | [diff] [blame] | 367 | if (strcmp(dev, "Net")) { |
| 368 | /* Add leading / to fs paths, because they're absolute */ |
| 369 | snprintf(devname, sizeof(devname), "/%s", path); |
| 370 | } else { |
| 371 | snprintf(devname, sizeof(devname), "%s", path); |
| 372 | } |
Alexander Graf | 0f4060e | 2016-03-04 01:10:14 +0100 | [diff] [blame] | 373 | ascii2unicode(bootefi_image_path[0].str, devname); |
| 374 | } |