]>
Commit | Line | Data |
---|---|---|
59df7e7e AT |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * UEFI Shell-like command | |
4 | * | |
5 | * Copyright (c) 2018 AKASHI Takahiro, Linaro Limited | |
6 | */ | |
7 | ||
8 | #include <charset.h> | |
9 | #include <common.h> | |
10 | #include <command.h> | |
11 | #include <efi_loader.h> | |
59df7e7e | 12 | #include <exports.h> |
39a1ff8c | 13 | #include <hexdump.h> |
59df7e7e | 14 | #include <malloc.h> |
a415d61e | 15 | #include <mapmem.h> |
59df7e7e AT |
16 | #include <search.h> |
17 | #include <linux/ctype.h> | |
18 | ||
355cdb5a | 19 | #define BS systab.boottime |
59df7e7e AT |
20 | #define RT systab.runtime |
21 | ||
355cdb5a AT |
22 | /** |
23 | * efi_get_device_handle_info() - get information of UEFI device | |
24 | * | |
25 | * @handle: Handle of UEFI device | |
26 | * @dev_path_text: Pointer to text of device path | |
27 | * Return: 0 on success, -1 on failure | |
28 | * | |
29 | * Currently return a formatted text of device path. | |
30 | */ | |
31 | static int efi_get_device_handle_info(efi_handle_t handle, u16 **dev_path_text) | |
32 | { | |
33 | struct efi_device_path *dp; | |
34 | efi_status_t ret; | |
35 | ||
36 | ret = EFI_CALL(BS->open_protocol(handle, &efi_guid_device_path, | |
37 | (void **)&dp, NULL /* FIXME */, NULL, | |
38 | EFI_OPEN_PROTOCOL_GET_PROTOCOL)); | |
39 | if (ret == EFI_SUCCESS) { | |
40 | *dev_path_text = efi_dp_str(dp); | |
41 | return 0; | |
42 | } else { | |
43 | return -1; | |
44 | } | |
45 | } | |
46 | ||
47 | #define EFI_HANDLE_WIDTH ((int)sizeof(efi_handle_t) * 2) | |
48 | ||
49 | static const char spc[] = " "; | |
50 | static const char sep[] = "================"; | |
51 | ||
52 | /** | |
53 | * do_efi_show_devices() - show UEFI devices | |
54 | * | |
55 | * @cmdtp: Command table | |
56 | * @flag: Command flag | |
57 | * @argc: Number of arguments | |
58 | * @argv: Argument array | |
59 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
60 | * | |
61 | * Implement efidebug "devices" sub-command. | |
62 | * Show all UEFI devices and their information. | |
63 | */ | |
64 | static int do_efi_show_devices(cmd_tbl_t *cmdtp, int flag, | |
65 | int argc, char * const argv[]) | |
66 | { | |
67 | efi_handle_t *handles; | |
68 | efi_uintn_t num, i; | |
69 | u16 *dev_path_text; | |
70 | efi_status_t ret; | |
71 | ||
72 | ret = EFI_CALL(BS->locate_handle_buffer(ALL_HANDLES, NULL, NULL, | |
73 | &num, &handles)); | |
74 | if (ret != EFI_SUCCESS) | |
75 | return CMD_RET_FAILURE; | |
76 | ||
77 | if (!num) | |
78 | return CMD_RET_SUCCESS; | |
79 | ||
80 | printf("Device%.*s Device Path\n", EFI_HANDLE_WIDTH - 6, spc); | |
81 | printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep); | |
82 | for (i = 0; i < num; i++) { | |
83 | if (!efi_get_device_handle_info(handles[i], &dev_path_text)) { | |
84 | printf("%p %ls\n", handles[i], dev_path_text); | |
85 | efi_free_pool(dev_path_text); | |
86 | } | |
87 | } | |
88 | ||
89 | EFI_CALL(BS->free_pool(handles)); | |
90 | ||
91 | return CMD_RET_SUCCESS; | |
92 | } | |
93 | ||
66eaf566 AT |
94 | /** |
95 | * efi_get_driver_handle_info() - get information of UEFI driver | |
96 | * | |
97 | * @handle: Handle of UEFI device | |
98 | * @driver_name: Driver name | |
99 | * @image_path: Pointer to text of device path | |
100 | * Return: 0 on success, -1 on failure | |
101 | * | |
102 | * Currently return no useful information as all UEFI drivers are | |
103 | * built-in.. | |
104 | */ | |
105 | static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name, | |
106 | u16 **image_path) | |
107 | { | |
108 | struct efi_handler *handler; | |
109 | struct efi_loaded_image *image; | |
110 | efi_status_t ret; | |
111 | ||
112 | /* | |
113 | * driver name | |
114 | * TODO: support EFI_COMPONENT_NAME2_PROTOCOL | |
115 | */ | |
116 | *driver_name = NULL; | |
117 | ||
118 | /* image name */ | |
119 | ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler); | |
120 | if (ret != EFI_SUCCESS) { | |
121 | *image_path = NULL; | |
122 | return 0; | |
123 | } | |
124 | ||
125 | image = handler->protocol_interface; | |
126 | *image_path = efi_dp_str(image->file_path); | |
127 | ||
128 | return 0; | |
129 | } | |
130 | ||
131 | /** | |
132 | * do_efi_show_drivers() - show UEFI drivers | |
133 | * | |
134 | * @cmdtp: Command table | |
135 | * @flag: Command flag | |
136 | * @argc: Number of arguments | |
137 | * @argv: Argument array | |
138 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
139 | * | |
140 | * Implement efidebug "drivers" sub-command. | |
141 | * Show all UEFI drivers and their information. | |
142 | */ | |
143 | static int do_efi_show_drivers(cmd_tbl_t *cmdtp, int flag, | |
144 | int argc, char * const argv[]) | |
145 | { | |
146 | efi_handle_t *handles; | |
147 | efi_uintn_t num, i; | |
148 | u16 *driver_name, *image_path_text; | |
149 | efi_status_t ret; | |
150 | ||
151 | ret = EFI_CALL(BS->locate_handle_buffer( | |
152 | BY_PROTOCOL, &efi_guid_driver_binding_protocol, | |
153 | NULL, &num, &handles)); | |
154 | if (ret != EFI_SUCCESS) | |
155 | return CMD_RET_FAILURE; | |
156 | ||
157 | if (!num) | |
158 | return CMD_RET_SUCCESS; | |
159 | ||
160 | printf("Driver%.*s Name Image Path\n", | |
161 | EFI_HANDLE_WIDTH - 6, spc); | |
162 | printf("%.*s ==================== ====================\n", | |
163 | EFI_HANDLE_WIDTH, sep); | |
164 | for (i = 0; i < num; i++) { | |
165 | if (!efi_get_driver_handle_info(handles[i], &driver_name, | |
166 | &image_path_text)) { | |
167 | if (image_path_text) | |
168 | printf("%p %-20ls %ls\n", handles[i], | |
169 | driver_name, image_path_text); | |
170 | else | |
171 | printf("%p %-20ls <built-in>\n", | |
172 | handles[i], driver_name); | |
173 | EFI_CALL(BS->free_pool(driver_name)); | |
174 | EFI_CALL(BS->free_pool(image_path_text)); | |
175 | } | |
176 | } | |
177 | ||
178 | EFI_CALL(BS->free_pool(handles)); | |
179 | ||
180 | return CMD_RET_SUCCESS; | |
181 | } | |
182 | ||
a8014620 AT |
183 | static const struct { |
184 | const char *text; | |
185 | const efi_guid_t guid; | |
186 | } guid_list[] = { | |
187 | { | |
188 | "Device Path", | |
dec88e41 | 189 | EFI_DEVICE_PATH_PROTOCOL_GUID, |
a8014620 AT |
190 | }, |
191 | { | |
192 | "Device Path To Text", | |
193 | EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID, | |
194 | }, | |
195 | { | |
196 | "Device Path Utilities", | |
197 | EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID, | |
198 | }, | |
199 | { | |
200 | "Unicode Collation 2", | |
201 | EFI_UNICODE_COLLATION_PROTOCOL2_GUID, | |
202 | }, | |
203 | { | |
204 | "Driver Binding", | |
205 | EFI_DRIVER_BINDING_PROTOCOL_GUID, | |
206 | }, | |
207 | { | |
208 | "Simple Text Input", | |
209 | EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID, | |
210 | }, | |
211 | { | |
212 | "Simple Text Input Ex", | |
213 | EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID, | |
214 | }, | |
215 | { | |
216 | "Simple Text Output", | |
217 | EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID, | |
218 | }, | |
219 | { | |
220 | "Block IO", | |
dec88e41 | 221 | EFI_BLOCK_IO_PROTOCOL_GUID, |
a8014620 AT |
222 | }, |
223 | { | |
224 | "Simple File System", | |
225 | EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, | |
226 | }, | |
227 | { | |
228 | "Loaded Image", | |
dec88e41 | 229 | EFI_LOADED_IMAGE_PROTOCOL_GUID, |
a8014620 AT |
230 | }, |
231 | { | |
dec88e41 HS |
232 | "Graphics Output", |
233 | EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID, | |
a8014620 | 234 | }, |
391bc8a9 HS |
235 | { |
236 | "HII String", | |
237 | EFI_HII_STRING_PROTOCOL_GUID, | |
238 | }, | |
239 | { | |
240 | "HII Database", | |
241 | EFI_HII_DATABASE_PROTOCOL_GUID, | |
242 | }, | |
243 | { | |
244 | "HII Config Routing", | |
245 | EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID, | |
246 | }, | |
ec80b473 IA |
247 | { |
248 | "Load File2", | |
249 | EFI_LOAD_FILE2_PROTOCOL_GUID, | |
250 | }, | |
391bc8a9 HS |
251 | { |
252 | "Simple Network", | |
253 | EFI_SIMPLE_NETWORK_PROTOCOL_GUID, | |
254 | }, | |
255 | { | |
256 | "PXE Base Code", | |
257 | EFI_PXE_BASE_CODE_PROTOCOL_GUID, | |
258 | }, | |
986e0648 HS |
259 | /* Configuration table GUIDs */ |
260 | { | |
261 | "ACPI table", | |
262 | EFI_ACPI_TABLE_GUID, | |
263 | }, | |
264 | { | |
265 | "device tree", | |
266 | EFI_FDT_GUID, | |
267 | }, | |
268 | { | |
269 | "SMBIOS table", | |
270 | SMBIOS_TABLE_GUID, | |
271 | }, | |
76be6872 HS |
272 | { |
273 | "Runtime properties", | |
274 | EFI_RT_PROPERTIES_TABLE_GUID, | |
275 | }, | |
a8014620 AT |
276 | }; |
277 | ||
278 | /** | |
173cd9e7 | 279 | * get_guid_text - get string of GUID |
a8014620 | 280 | * |
173cd9e7 HS |
281 | * Return description of GUID. |
282 | * | |
283 | * @guid: GUID | |
284 | * Return: description of GUID or NULL | |
a8014620 | 285 | */ |
173cd9e7 | 286 | static const char *get_guid_text(const void *guid) |
a8014620 AT |
287 | { |
288 | int i; | |
289 | ||
173cd9e7 HS |
290 | for (i = 0; i < ARRAY_SIZE(guid_list); i++) { |
291 | /* | |
292 | * As guidcmp uses memcmp() we can safely accept unaligned | |
293 | * GUIDs. | |
294 | */ | |
a8014620 | 295 | if (!guidcmp(&guid_list[i].guid, guid)) |
173cd9e7 HS |
296 | return guid_list[i].text; |
297 | } | |
a8014620 | 298 | |
173cd9e7 | 299 | return NULL; |
a8014620 AT |
300 | } |
301 | ||
302 | /** | |
303 | * do_efi_show_handles() - show UEFI handles | |
304 | * | |
305 | * @cmdtp: Command table | |
306 | * @flag: Command flag | |
307 | * @argc: Number of arguments | |
308 | * @argv: Argument array | |
309 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
310 | * | |
311 | * Implement efidebug "dh" sub-command. | |
312 | * Show all UEFI handles and their information, currently all protocols | |
313 | * added to handle. | |
314 | */ | |
315 | static int do_efi_show_handles(cmd_tbl_t *cmdtp, int flag, | |
316 | int argc, char * const argv[]) | |
317 | { | |
318 | efi_handle_t *handles; | |
319 | efi_guid_t **guid; | |
320 | efi_uintn_t num, count, i, j; | |
321 | const char *guid_text; | |
322 | efi_status_t ret; | |
323 | ||
324 | ret = EFI_CALL(BS->locate_handle_buffer(ALL_HANDLES, NULL, NULL, | |
325 | &num, &handles)); | |
326 | if (ret != EFI_SUCCESS) | |
327 | return CMD_RET_FAILURE; | |
328 | ||
329 | if (!num) | |
330 | return CMD_RET_SUCCESS; | |
331 | ||
332 | printf("Handle%.*s Protocols\n", EFI_HANDLE_WIDTH - 6, spc); | |
333 | printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep); | |
334 | for (i = 0; i < num; i++) { | |
335 | printf("%p", handles[i]); | |
336 | ret = EFI_CALL(BS->protocols_per_handle(handles[i], &guid, | |
337 | &count)); | |
338 | if (ret || !count) { | |
339 | putc('\n'); | |
340 | continue; | |
341 | } | |
342 | ||
343 | for (j = 0; j < count; j++) { | |
344 | if (j) | |
345 | printf(", "); | |
346 | else | |
347 | putc(' '); | |
348 | ||
349 | guid_text = get_guid_text(guid[j]); | |
350 | if (guid_text) | |
351 | puts(guid_text); | |
352 | else | |
353 | printf("%pUl", guid[j]); | |
354 | } | |
355 | putc('\n'); | |
356 | } | |
357 | ||
358 | EFI_CALL(BS->free_pool(handles)); | |
359 | ||
360 | return CMD_RET_SUCCESS; | |
361 | } | |
362 | ||
fa536734 AT |
363 | /** |
364 | * do_efi_show_images() - show UEFI images | |
365 | * | |
366 | * @cmdtp: Command table | |
367 | * @flag: Command flag | |
368 | * @argc: Number of arguments | |
369 | * @argv: Argument array | |
370 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
371 | * | |
372 | * Implement efidebug "images" sub-command. | |
373 | * Show all UEFI loaded images and their information. | |
374 | */ | |
375 | static int do_efi_show_images(cmd_tbl_t *cmdtp, int flag, | |
376 | int argc, char * const argv[]) | |
377 | { | |
378 | efi_print_image_infos(NULL); | |
379 | ||
380 | return CMD_RET_SUCCESS; | |
381 | } | |
382 | ||
00358bb8 AT |
383 | static const char * const efi_mem_type_string[] = { |
384 | [EFI_RESERVED_MEMORY_TYPE] = "RESERVED", | |
385 | [EFI_LOADER_CODE] = "LOADER CODE", | |
386 | [EFI_LOADER_DATA] = "LOADER DATA", | |
387 | [EFI_BOOT_SERVICES_CODE] = "BOOT CODE", | |
388 | [EFI_BOOT_SERVICES_DATA] = "BOOT DATA", | |
389 | [EFI_RUNTIME_SERVICES_CODE] = "RUNTIME CODE", | |
390 | [EFI_RUNTIME_SERVICES_DATA] = "RUNTIME DATA", | |
391 | [EFI_CONVENTIONAL_MEMORY] = "CONVENTIONAL", | |
392 | [EFI_UNUSABLE_MEMORY] = "UNUSABLE MEM", | |
393 | [EFI_ACPI_RECLAIM_MEMORY] = "ACPI RECLAIM MEM", | |
394 | [EFI_ACPI_MEMORY_NVS] = "ACPI NVS", | |
395 | [EFI_MMAP_IO] = "IO", | |
396 | [EFI_MMAP_IO_PORT] = "IO PORT", | |
397 | [EFI_PAL_CODE] = "PAL", | |
398 | }; | |
399 | ||
400 | static const struct efi_mem_attrs { | |
401 | const u64 bit; | |
402 | const char *text; | |
403 | } efi_mem_attrs[] = { | |
404 | {EFI_MEMORY_UC, "UC"}, | |
405 | {EFI_MEMORY_UC, "UC"}, | |
406 | {EFI_MEMORY_WC, "WC"}, | |
407 | {EFI_MEMORY_WT, "WT"}, | |
408 | {EFI_MEMORY_WB, "WB"}, | |
409 | {EFI_MEMORY_UCE, "UCE"}, | |
410 | {EFI_MEMORY_WP, "WP"}, | |
411 | {EFI_MEMORY_RP, "RP"}, | |
412 | {EFI_MEMORY_XP, "WP"}, | |
413 | {EFI_MEMORY_NV, "NV"}, | |
414 | {EFI_MEMORY_MORE_RELIABLE, "REL"}, | |
415 | {EFI_MEMORY_RO, "RO"}, | |
416 | {EFI_MEMORY_RUNTIME, "RT"}, | |
417 | }; | |
418 | ||
419 | /** | |
420 | * print_memory_attributes() - print memory map attributes | |
0b016569 | 421 | * |
00358bb8 AT |
422 | * @attributes: Attribute value |
423 | * | |
424 | * Print memory map attributes | |
425 | */ | |
426 | static void print_memory_attributes(u64 attributes) | |
427 | { | |
428 | int sep, i; | |
429 | ||
430 | for (sep = 0, i = 0; i < ARRAY_SIZE(efi_mem_attrs); i++) | |
431 | if (attributes & efi_mem_attrs[i].bit) { | |
432 | if (sep) { | |
433 | putc('|'); | |
434 | } else { | |
435 | putc(' '); | |
436 | sep = 1; | |
437 | } | |
438 | puts(efi_mem_attrs[i].text); | |
439 | } | |
440 | } | |
441 | ||
442 | #define EFI_PHYS_ADDR_WIDTH (int)(sizeof(efi_physical_addr_t) * 2) | |
443 | ||
444 | /** | |
445 | * do_efi_show_memmap() - show UEFI memory map | |
446 | * | |
447 | * @cmdtp: Command table | |
448 | * @flag: Command flag | |
449 | * @argc: Number of arguments | |
450 | * @argv: Argument array | |
451 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
452 | * | |
453 | * Implement efidebug "memmap" sub-command. | |
454 | * Show UEFI memory map. | |
455 | */ | |
456 | static int do_efi_show_memmap(cmd_tbl_t *cmdtp, int flag, | |
457 | int argc, char * const argv[]) | |
458 | { | |
459 | struct efi_mem_desc *memmap = NULL, *map; | |
460 | efi_uintn_t map_size = 0; | |
461 | const char *type; | |
462 | int i; | |
463 | efi_status_t ret; | |
464 | ||
465 | ret = EFI_CALL(BS->get_memory_map(&map_size, memmap, NULL, NULL, NULL)); | |
466 | if (ret == EFI_BUFFER_TOO_SMALL) { | |
467 | map_size += sizeof(struct efi_mem_desc); /* for my own */ | |
468 | ret = EFI_CALL(BS->allocate_pool(EFI_LOADER_DATA, | |
469 | map_size, (void *)&memmap)); | |
470 | if (ret != EFI_SUCCESS) | |
471 | return CMD_RET_FAILURE; | |
472 | ret = EFI_CALL(BS->get_memory_map(&map_size, memmap, | |
473 | NULL, NULL, NULL)); | |
474 | } | |
475 | if (ret != EFI_SUCCESS) { | |
476 | EFI_CALL(BS->free_pool(memmap)); | |
477 | return CMD_RET_FAILURE; | |
478 | } | |
479 | ||
480 | printf("Type Start%.*s End%.*s Attributes\n", | |
481 | EFI_PHYS_ADDR_WIDTH - 5, spc, EFI_PHYS_ADDR_WIDTH - 3, spc); | |
482 | printf("================ %.*s %.*s ==========\n", | |
483 | EFI_PHYS_ADDR_WIDTH, sep, EFI_PHYS_ADDR_WIDTH, sep); | |
484 | for (i = 0, map = memmap; i < map_size / sizeof(*map); map++, i++) { | |
485 | if (map->type < EFI_MAX_MEMORY_TYPE) | |
486 | type = efi_mem_type_string[map->type]; | |
487 | else | |
488 | type = "(unknown)"; | |
489 | ||
490 | printf("%-16s %.*llx-%.*llx", type, | |
491 | EFI_PHYS_ADDR_WIDTH, | |
6c0ef35c HS |
492 | (u64)map_to_sysmem((void *)(uintptr_t) |
493 | map->physical_start), | |
00358bb8 | 494 | EFI_PHYS_ADDR_WIDTH, |
6c0ef35c HS |
495 | (u64)map_to_sysmem((void *)(uintptr_t) |
496 | (map->physical_start + | |
497 | map->num_pages * EFI_PAGE_SIZE))); | |
00358bb8 AT |
498 | |
499 | print_memory_attributes(map->attribute); | |
500 | putc('\n'); | |
501 | } | |
502 | ||
503 | EFI_CALL(BS->free_pool(memmap)); | |
504 | ||
505 | return CMD_RET_SUCCESS; | |
506 | } | |
507 | ||
986e0648 HS |
508 | /** |
509 | * do_efi_show_tables() - show UEFI configuration tables | |
510 | * | |
511 | * @cmdtp: Command table | |
512 | * @flag: Command flag | |
513 | * @argc: Number of arguments | |
514 | * @argv: Argument array | |
515 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
516 | * | |
517 | * Implement efidebug "tables" sub-command. | |
518 | * Show UEFI configuration tables. | |
519 | */ | |
520 | static int do_efi_show_tables(cmd_tbl_t *cmdtp, int flag, | |
521 | int argc, char * const argv[]) | |
522 | { | |
523 | efi_uintn_t i; | |
524 | const char *guid_str; | |
525 | ||
526 | for (i = 0; i < systab.nr_tables; ++i) { | |
527 | guid_str = get_guid_text(&systab.tables[i].guid); | |
528 | if (!guid_str) | |
529 | guid_str = ""; | |
530 | printf("%pUl %s\n", &systab.tables[i].guid, guid_str); | |
531 | } | |
532 | ||
533 | return CMD_RET_SUCCESS; | |
534 | } | |
535 | ||
59df7e7e AT |
536 | /** |
537 | * do_efi_boot_add() - set UEFI load option | |
538 | * | |
539 | * @cmdtp: Command table | |
540 | * @flag: Command flag | |
541 | * @argc: Number of arguments | |
542 | * @argv: Argument array | |
543 | * Return: CMD_RET_SUCCESS on success, | |
544 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
545 | * | |
0b016569 HS |
546 | * Implement efidebug "boot add" sub-command. Create or change UEFI load option. |
547 | * | |
548 | * efidebug boot add <id> <label> <interface> <devnum>[:<part>] <file> <options> | |
59df7e7e AT |
549 | */ |
550 | static int do_efi_boot_add(cmd_tbl_t *cmdtp, int flag, | |
551 | int argc, char * const argv[]) | |
552 | { | |
553 | int id; | |
554 | char *endp; | |
555 | char var_name[9]; | |
556 | u16 var_name16[9], *p; | |
557 | efi_guid_t guid; | |
558 | size_t label_len, label_len16; | |
559 | u16 *label; | |
560 | struct efi_device_path *device_path = NULL, *file_path = NULL; | |
561 | struct efi_load_option lo; | |
562 | void *data = NULL; | |
563 | efi_uintn_t size; | |
428a470a | 564 | efi_status_t ret; |
a332f251 | 565 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
566 | |
567 | if (argc < 6 || argc > 7) | |
568 | return CMD_RET_USAGE; | |
569 | ||
570 | id = (int)simple_strtoul(argv[1], &endp, 16); | |
571 | if (*endp != '\0' || id > 0xffff) | |
1fa442ed | 572 | return CMD_RET_USAGE; |
59df7e7e AT |
573 | |
574 | sprintf(var_name, "Boot%04X", id); | |
575 | p = var_name16; | |
576 | utf8_utf16_strncpy(&p, var_name, 9); | |
577 | ||
578 | guid = efi_global_variable_guid; | |
579 | ||
580 | /* attributes */ | |
581 | lo.attributes = LOAD_OPTION_ACTIVE; /* always ACTIVE */ | |
582 | ||
583 | /* label */ | |
584 | label_len = strlen(argv[2]); | |
585 | label_len16 = utf8_utf16_strnlen(argv[2], label_len); | |
586 | label = malloc((label_len16 + 1) * sizeof(u16)); | |
587 | if (!label) | |
588 | return CMD_RET_FAILURE; | |
589 | lo.label = label; /* label will be changed below */ | |
590 | utf8_utf16_strncpy(&label, argv[2], label_len); | |
591 | ||
592 | /* file path */ | |
593 | ret = efi_dp_from_name(argv[3], argv[4], argv[5], &device_path, | |
594 | &file_path); | |
595 | if (ret != EFI_SUCCESS) { | |
596 | printf("Cannot create device path for \"%s %s\"\n", | |
597 | argv[3], argv[4]); | |
428a470a | 598 | r = CMD_RET_FAILURE; |
59df7e7e AT |
599 | goto out; |
600 | } | |
601 | lo.file_path = file_path; | |
602 | lo.file_path_length = efi_dp_size(file_path) | |
603 | + sizeof(struct efi_device_path); /* for END */ | |
604 | ||
605 | /* optional data */ | |
39a1ff8c HS |
606 | if (argc < 6) |
607 | lo.optional_data = NULL; | |
608 | else | |
609 | lo.optional_data = (const u8 *)argv[6]; | |
59df7e7e AT |
610 | |
611 | size = efi_serialize_load_option(&lo, (u8 **)&data); | |
612 | if (!size) { | |
428a470a | 613 | r = CMD_RET_FAILURE; |
59df7e7e AT |
614 | goto out; |
615 | } | |
616 | ||
617 | ret = EFI_CALL(RT->set_variable(var_name16, &guid, | |
f658c2e1 | 618 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
619 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
620 | EFI_VARIABLE_RUNTIME_ACCESS, | |
621 | size, data)); | |
a332f251 HS |
622 | if (ret != EFI_SUCCESS) { |
623 | printf("Cannot set %ls\n", var_name16); | |
624 | r = CMD_RET_FAILURE; | |
625 | } | |
59df7e7e AT |
626 | out: |
627 | free(data); | |
628 | efi_free_pool(device_path); | |
629 | efi_free_pool(file_path); | |
630 | free(lo.label); | |
631 | ||
428a470a | 632 | return r; |
59df7e7e AT |
633 | } |
634 | ||
635 | /** | |
636 | * do_efi_boot_rm() - delete UEFI load options | |
637 | * | |
638 | * @cmdtp: Command table | |
639 | * @flag: Command flag | |
640 | * @argc: Number of arguments | |
641 | * @argv: Argument array | |
642 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
643 | * | |
644 | * Implement efidebug "boot rm" sub-command. | |
645 | * Delete UEFI load options. | |
0b016569 HS |
646 | * |
647 | * efidebug boot rm <id> ... | |
59df7e7e AT |
648 | */ |
649 | static int do_efi_boot_rm(cmd_tbl_t *cmdtp, int flag, | |
650 | int argc, char * const argv[]) | |
651 | { | |
652 | efi_guid_t guid; | |
653 | int id, i; | |
654 | char *endp; | |
655 | char var_name[9]; | |
e8bced62 | 656 | u16 var_name16[9], *p; |
59df7e7e AT |
657 | efi_status_t ret; |
658 | ||
659 | if (argc == 1) | |
660 | return CMD_RET_USAGE; | |
661 | ||
662 | guid = efi_global_variable_guid; | |
663 | for (i = 1; i < argc; i++, argv++) { | |
664 | id = (int)simple_strtoul(argv[1], &endp, 16); | |
665 | if (*endp != '\0' || id > 0xffff) | |
666 | return CMD_RET_FAILURE; | |
667 | ||
668 | sprintf(var_name, "Boot%04X", id); | |
e8bced62 AT |
669 | p = var_name16; |
670 | utf8_utf16_strncpy(&p, var_name, 9); | |
59df7e7e AT |
671 | |
672 | ret = EFI_CALL(RT->set_variable(var_name16, &guid, 0, 0, NULL)); | |
673 | if (ret) { | |
30efb5dd | 674 | printf("Cannot remove %ls\n", var_name16); |
59df7e7e AT |
675 | return CMD_RET_FAILURE; |
676 | } | |
677 | } | |
678 | ||
679 | return CMD_RET_SUCCESS; | |
680 | } | |
681 | ||
682 | /** | |
683 | * show_efi_boot_opt_data() - dump UEFI load option | |
684 | * | |
39a1ff8c HS |
685 | * @id: load option number |
686 | * @data: value of UEFI load option variable | |
687 | * @size: size of the boot option | |
59df7e7e AT |
688 | * |
689 | * Decode the value of UEFI load option variable and print information. | |
690 | */ | |
39a1ff8c | 691 | static void show_efi_boot_opt_data(int id, void *data, size_t size) |
59df7e7e AT |
692 | { |
693 | struct efi_load_option lo; | |
694 | char *label, *p; | |
695 | size_t label_len16, label_len; | |
696 | u16 *dp_str; | |
697 | ||
698 | efi_deserialize_load_option(&lo, data); | |
699 | ||
700 | label_len16 = u16_strlen(lo.label); | |
701 | label_len = utf16_utf8_strnlen(lo.label, label_len16); | |
702 | label = malloc(label_len + 1); | |
703 | if (!label) | |
704 | return; | |
705 | p = label; | |
706 | utf16_utf8_strncpy(&p, lo.label, label_len16); | |
707 | ||
708 | printf("Boot%04X:\n", id); | |
39a1ff8c | 709 | printf(" attributes: %c%c%c (0x%08x)\n", |
59df7e7e AT |
710 | /* ACTIVE */ |
711 | lo.attributes & LOAD_OPTION_ACTIVE ? 'A' : '-', | |
712 | /* FORCE RECONNECT */ | |
713 | lo.attributes & LOAD_OPTION_FORCE_RECONNECT ? 'R' : '-', | |
714 | /* HIDDEN */ | |
715 | lo.attributes & LOAD_OPTION_HIDDEN ? 'H' : '-', | |
716 | lo.attributes); | |
39a1ff8c | 717 | printf(" label: %s\n", label); |
59df7e7e AT |
718 | |
719 | dp_str = efi_dp_str(lo.file_path); | |
39a1ff8c | 720 | printf(" file_path: %ls\n", dp_str); |
59df7e7e AT |
721 | efi_free_pool(dp_str); |
722 | ||
39a1ff8c HS |
723 | printf(" data:\n"); |
724 | print_hex_dump(" ", DUMP_PREFIX_OFFSET, 16, 1, | |
725 | lo.optional_data, size + (u8 *)data - | |
726 | (u8 *)lo.optional_data, true); | |
59df7e7e AT |
727 | free(label); |
728 | } | |
729 | ||
730 | /** | |
731 | * show_efi_boot_opt() - dump UEFI load option | |
732 | * | |
733 | * @id: Load option number | |
734 | * | |
735 | * Dump information defined by UEFI load option. | |
736 | */ | |
737 | static void show_efi_boot_opt(int id) | |
738 | { | |
739 | char var_name[9]; | |
740 | u16 var_name16[9], *p; | |
741 | efi_guid_t guid; | |
742 | void *data = NULL; | |
743 | efi_uintn_t size; | |
0bffb8c4 | 744 | efi_status_t ret; |
59df7e7e AT |
745 | |
746 | sprintf(var_name, "Boot%04X", id); | |
747 | p = var_name16; | |
748 | utf8_utf16_strncpy(&p, var_name, 9); | |
749 | guid = efi_global_variable_guid; | |
750 | ||
751 | size = 0; | |
752 | ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size, NULL)); | |
0bffb8c4 | 753 | if (ret == EFI_BUFFER_TOO_SMALL) { |
59df7e7e AT |
754 | data = malloc(size); |
755 | ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size, | |
756 | data)); | |
757 | } | |
758 | if (ret == EFI_SUCCESS) | |
39a1ff8c | 759 | show_efi_boot_opt_data(id, data, size); |
59df7e7e AT |
760 | else if (ret == EFI_NOT_FOUND) |
761 | printf("Boot%04X: not found\n", id); | |
762 | ||
763 | free(data); | |
764 | } | |
765 | ||
ffe21574 AT |
766 | static int u16_tohex(u16 c) |
767 | { | |
768 | if (c >= '0' && c <= '9') | |
769 | return c - '0'; | |
770 | if (c >= 'A' && c <= 'F') | |
771 | return c - 'A' + 10; | |
772 | ||
773 | /* not hexadecimal */ | |
774 | return -1; | |
775 | } | |
776 | ||
59df7e7e AT |
777 | /** |
778 | * show_efi_boot_dump() - dump all UEFI load options | |
779 | * | |
780 | * @cmdtp: Command table | |
781 | * @flag: Command flag | |
782 | * @argc: Number of arguments | |
783 | * @argv: Argument array | |
784 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
785 | * | |
786 | * Implement efidebug "boot dump" sub-command. | |
787 | * Dump information of all UEFI load options defined. | |
a6ccba0c HS |
788 | * |
789 | * efidebug boot dump | |
59df7e7e AT |
790 | */ |
791 | static int do_efi_boot_dump(cmd_tbl_t *cmdtp, int flag, | |
792 | int argc, char * const argv[]) | |
793 | { | |
ffe21574 AT |
794 | u16 *var_name16, *p; |
795 | efi_uintn_t buf_size, size; | |
796 | efi_guid_t guid; | |
797 | int id, i, digit; | |
798 | efi_status_t ret; | |
59df7e7e AT |
799 | |
800 | if (argc > 1) | |
801 | return CMD_RET_USAGE; | |
802 | ||
ffe21574 AT |
803 | buf_size = 128; |
804 | var_name16 = malloc(buf_size); | |
805 | if (!var_name16) | |
59df7e7e AT |
806 | return CMD_RET_FAILURE; |
807 | ||
ffe21574 AT |
808 | var_name16[0] = 0; |
809 | for (;;) { | |
810 | size = buf_size; | |
811 | ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16, | |
812 | &guid)); | |
813 | if (ret == EFI_NOT_FOUND) | |
59df7e7e | 814 | break; |
ffe21574 AT |
815 | if (ret == EFI_BUFFER_TOO_SMALL) { |
816 | buf_size = size; | |
817 | p = realloc(var_name16, buf_size); | |
818 | if (!p) { | |
819 | free(var_name16); | |
820 | return CMD_RET_FAILURE; | |
821 | } | |
822 | var_name16 = p; | |
823 | ret = EFI_CALL(efi_get_next_variable_name(&size, | |
824 | var_name16, | |
825 | &guid)); | |
826 | } | |
827 | if (ret != EFI_SUCCESS) { | |
828 | free(var_name16); | |
829 | return CMD_RET_FAILURE; | |
830 | } | |
831 | ||
832 | if (memcmp(var_name16, L"Boot", 8)) | |
833 | continue; | |
834 | ||
835 | for (id = 0, i = 0; i < 4; i++) { | |
836 | digit = u16_tohex(var_name16[4 + i]); | |
837 | if (digit < 0) | |
838 | break; | |
839 | id = (id << 4) + digit; | |
840 | } | |
841 | if (i == 4 && !var_name16[8]) | |
842 | show_efi_boot_opt(id); | |
59df7e7e | 843 | } |
ffe21574 AT |
844 | |
845 | free(var_name16); | |
59df7e7e AT |
846 | |
847 | return CMD_RET_SUCCESS; | |
848 | } | |
849 | ||
850 | /** | |
851 | * show_efi_boot_order() - show order of UEFI load options | |
852 | * | |
853 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
854 | * | |
855 | * Show order of UEFI load options defined by BootOrder variable. | |
856 | */ | |
857 | static int show_efi_boot_order(void) | |
858 | { | |
859 | efi_guid_t guid; | |
860 | u16 *bootorder = NULL; | |
861 | efi_uintn_t size; | |
862 | int num, i; | |
863 | char var_name[9]; | |
864 | u16 var_name16[9], *p16; | |
865 | void *data; | |
866 | struct efi_load_option lo; | |
867 | char *label, *p; | |
868 | size_t label_len16, label_len; | |
869 | efi_status_t ret; | |
870 | ||
871 | guid = efi_global_variable_guid; | |
872 | size = 0; | |
873 | ret = EFI_CALL(RT->get_variable(L"BootOrder", &guid, NULL, &size, | |
874 | NULL)); | |
875 | if (ret == EFI_BUFFER_TOO_SMALL) { | |
876 | bootorder = malloc(size); | |
877 | ret = EFI_CALL(RT->get_variable(L"BootOrder", &guid, NULL, | |
878 | &size, bootorder)); | |
879 | } | |
880 | if (ret == EFI_NOT_FOUND) { | |
881 | printf("BootOrder not defined\n"); | |
882 | ret = CMD_RET_SUCCESS; | |
883 | goto out; | |
884 | } else if (ret != EFI_SUCCESS) { | |
885 | ret = CMD_RET_FAILURE; | |
886 | goto out; | |
887 | } | |
888 | ||
889 | num = size / sizeof(u16); | |
890 | for (i = 0; i < num; i++) { | |
891 | sprintf(var_name, "Boot%04X", bootorder[i]); | |
892 | p16 = var_name16; | |
893 | utf8_utf16_strncpy(&p16, var_name, 9); | |
894 | ||
895 | size = 0; | |
896 | ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size, | |
897 | NULL)); | |
898 | if (ret != EFI_BUFFER_TOO_SMALL) { | |
899 | printf("%2d: Boot%04X: (not defined)\n", | |
900 | i + 1, bootorder[i]); | |
901 | continue; | |
902 | } | |
903 | ||
904 | data = malloc(size); | |
905 | if (!data) { | |
906 | ret = CMD_RET_FAILURE; | |
907 | goto out; | |
908 | } | |
909 | ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size, | |
910 | data)); | |
911 | if (ret != EFI_SUCCESS) { | |
912 | free(data); | |
913 | ret = CMD_RET_FAILURE; | |
914 | goto out; | |
915 | } | |
916 | ||
917 | efi_deserialize_load_option(&lo, data); | |
918 | ||
919 | label_len16 = u16_strlen(lo.label); | |
920 | label_len = utf16_utf8_strnlen(lo.label, label_len16); | |
921 | label = malloc(label_len + 1); | |
922 | if (!label) { | |
923 | free(data); | |
924 | ret = CMD_RET_FAILURE; | |
925 | goto out; | |
926 | } | |
927 | p = label; | |
928 | utf16_utf8_strncpy(&p, lo.label, label_len16); | |
929 | printf("%2d: Boot%04X: %s\n", i + 1, bootorder[i], label); | |
930 | free(label); | |
931 | ||
932 | free(data); | |
933 | } | |
934 | out: | |
935 | free(bootorder); | |
936 | ||
937 | return ret; | |
938 | } | |
939 | ||
940 | /** | |
941 | * do_efi_boot_next() - manage UEFI BootNext variable | |
942 | * | |
943 | * @cmdtp: Command table | |
944 | * @flag: Command flag | |
945 | * @argc: Number of arguments | |
946 | * @argv: Argument array | |
947 | * Return: CMD_RET_SUCCESS on success, | |
948 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
949 | * | |
950 | * Implement efidebug "boot next" sub-command. | |
951 | * Set BootNext variable. | |
0b016569 HS |
952 | * |
953 | * efidebug boot next <id> | |
59df7e7e AT |
954 | */ |
955 | static int do_efi_boot_next(cmd_tbl_t *cmdtp, int flag, | |
956 | int argc, char * const argv[]) | |
957 | { | |
958 | u16 bootnext; | |
959 | efi_uintn_t size; | |
960 | char *endp; | |
961 | efi_guid_t guid; | |
962 | efi_status_t ret; | |
a332f251 | 963 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
964 | |
965 | if (argc != 2) | |
966 | return CMD_RET_USAGE; | |
967 | ||
968 | bootnext = (u16)simple_strtoul(argv[1], &endp, 16); | |
969 | if (*endp != '\0' || bootnext > 0xffff) { | |
970 | printf("invalid value: %s\n", argv[1]); | |
428a470a | 971 | r = CMD_RET_FAILURE; |
59df7e7e AT |
972 | goto out; |
973 | } | |
974 | ||
975 | guid = efi_global_variable_guid; | |
976 | size = sizeof(u16); | |
977 | ret = EFI_CALL(RT->set_variable(L"BootNext", &guid, | |
f658c2e1 | 978 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
979 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
980 | EFI_VARIABLE_RUNTIME_ACCESS, | |
981 | size, &bootnext)); | |
a332f251 HS |
982 | if (ret != EFI_SUCCESS) { |
983 | printf("Cannot set BootNext\n"); | |
984 | r = CMD_RET_FAILURE; | |
985 | } | |
59df7e7e | 986 | out: |
428a470a | 987 | return r; |
59df7e7e AT |
988 | } |
989 | ||
990 | /** | |
991 | * do_efi_boot_order() - manage UEFI BootOrder variable | |
992 | * | |
993 | * @cmdtp: Command table | |
994 | * @flag: Command flag | |
995 | * @argc: Number of arguments | |
996 | * @argv: Argument array | |
997 | * Return: CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure | |
998 | * | |
999 | * Implement efidebug "boot order" sub-command. | |
1000 | * Show order of UEFI load options, or change it in BootOrder variable. | |
0b016569 HS |
1001 | * |
1002 | * efidebug boot order [<id> ...] | |
59df7e7e AT |
1003 | */ |
1004 | static int do_efi_boot_order(cmd_tbl_t *cmdtp, int flag, | |
1005 | int argc, char * const argv[]) | |
1006 | { | |
1007 | u16 *bootorder = NULL; | |
1008 | efi_uintn_t size; | |
1009 | int id, i; | |
1010 | char *endp; | |
1011 | efi_guid_t guid; | |
1012 | efi_status_t ret; | |
a332f251 | 1013 | int r = CMD_RET_SUCCESS; |
59df7e7e AT |
1014 | |
1015 | if (argc == 1) | |
1016 | return show_efi_boot_order(); | |
1017 | ||
1018 | argc--; | |
1019 | argv++; | |
1020 | ||
1021 | size = argc * sizeof(u16); | |
1022 | bootorder = malloc(size); | |
1023 | if (!bootorder) | |
1024 | return CMD_RET_FAILURE; | |
1025 | ||
1026 | for (i = 0; i < argc; i++) { | |
1027 | id = (int)simple_strtoul(argv[i], &endp, 16); | |
1028 | if (*endp != '\0' || id > 0xffff) { | |
1029 | printf("invalid value: %s\n", argv[i]); | |
428a470a | 1030 | r = CMD_RET_FAILURE; |
59df7e7e AT |
1031 | goto out; |
1032 | } | |
1033 | ||
1034 | bootorder[i] = (u16)id; | |
1035 | } | |
1036 | ||
1037 | guid = efi_global_variable_guid; | |
1038 | ret = EFI_CALL(RT->set_variable(L"BootOrder", &guid, | |
f658c2e1 | 1039 | EFI_VARIABLE_NON_VOLATILE | |
59df7e7e AT |
1040 | EFI_VARIABLE_BOOTSERVICE_ACCESS | |
1041 | EFI_VARIABLE_RUNTIME_ACCESS, | |
1042 | size, bootorder)); | |
a332f251 HS |
1043 | if (ret != EFI_SUCCESS) { |
1044 | printf("Cannot set BootOrder\n"); | |
1045 | r = CMD_RET_FAILURE; | |
1046 | } | |
59df7e7e AT |
1047 | out: |
1048 | free(bootorder); | |
1049 | ||
428a470a | 1050 | return r; |
59df7e7e AT |
1051 | } |
1052 | ||
1053 | static cmd_tbl_t cmd_efidebug_boot_sub[] = { | |
1054 | U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""), | |
1055 | U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""), | |
1056 | U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""), | |
1057 | U_BOOT_CMD_MKENT(next, CONFIG_SYS_MAXARGS, 1, do_efi_boot_next, "", ""), | |
1058 | U_BOOT_CMD_MKENT(order, CONFIG_SYS_MAXARGS, 1, do_efi_boot_order, | |
1059 | "", ""), | |
1060 | }; | |
1061 | ||
1062 | /** | |
1063 | * do_efi_boot_opt() - manage UEFI load options | |
1064 | * | |
1065 | * @cmdtp: Command table | |
1066 | * @flag: Command flag | |
1067 | * @argc: Number of arguments | |
1068 | * @argv: Argument array | |
1069 | * Return: CMD_RET_SUCCESS on success, | |
1070 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1071 | * | |
1072 | * Implement efidebug "boot" sub-command. | |
59df7e7e AT |
1073 | */ |
1074 | static int do_efi_boot_opt(cmd_tbl_t *cmdtp, int flag, | |
1075 | int argc, char * const argv[]) | |
1076 | { | |
1077 | cmd_tbl_t *cp; | |
1078 | ||
1079 | if (argc < 2) | |
1080 | return CMD_RET_USAGE; | |
1081 | ||
1082 | argc--; argv++; | |
1083 | ||
1084 | cp = find_cmd_tbl(argv[0], cmd_efidebug_boot_sub, | |
1085 | ARRAY_SIZE(cmd_efidebug_boot_sub)); | |
1086 | if (!cp) | |
1087 | return CMD_RET_USAGE; | |
1088 | ||
1089 | return cp->cmd(cmdtp, flag, argc, argv); | |
1090 | } | |
1091 | ||
525fc067 AT |
1092 | /** |
1093 | * do_efi_test_bootmgr() - run simple bootmgr for test | |
1094 | * | |
1095 | * @cmdtp: Command table | |
1096 | * @flag: Command flag | |
1097 | * @argc: Number of arguments | |
1098 | * @argv: Argument array | |
1099 | * Return: CMD_RET_SUCCESS on success, | |
1100 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1101 | * | |
1102 | * Implement efidebug "test bootmgr" sub-command. | |
1103 | * Run simple bootmgr for test. | |
1104 | * | |
1105 | * efidebug test bootmgr | |
1106 | */ | |
1107 | static int do_efi_test_bootmgr(cmd_tbl_t *cmdtp, int flag, | |
1108 | int argc, char * const argv[]) | |
1109 | { | |
1110 | efi_handle_t image; | |
1111 | efi_uintn_t exit_data_size = 0; | |
1112 | u16 *exit_data = NULL; | |
1113 | efi_status_t ret; | |
1114 | ||
1115 | ret = efi_bootmgr_load(&image); | |
1116 | printf("efi_bootmgr_load() returned: %ld\n", ret & ~EFI_ERROR_MASK); | |
1117 | ||
1118 | /* We call efi_start_image() even if error for test purpose. */ | |
1119 | ret = EFI_CALL(efi_start_image(image, &exit_data_size, &exit_data)); | |
1120 | printf("efi_start_image() returned: %ld\n", ret & ~EFI_ERROR_MASK); | |
1121 | if (ret && exit_data) | |
1122 | efi_free_pool(exit_data); | |
1123 | ||
1124 | efi_restore_gd(); | |
1125 | ||
1126 | return CMD_RET_SUCCESS; | |
1127 | } | |
1128 | ||
1129 | static cmd_tbl_t cmd_efidebug_test_sub[] = { | |
1130 | U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr, | |
1131 | "", ""), | |
1132 | }; | |
1133 | ||
1134 | /** | |
1135 | * do_efi_test() - manage UEFI load options | |
1136 | * | |
1137 | * @cmdtp: Command table | |
1138 | * @flag: Command flag | |
1139 | * @argc: Number of arguments | |
1140 | * @argv: Argument array | |
1141 | * Return: CMD_RET_SUCCESS on success, | |
1142 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1143 | * | |
1144 | * Implement efidebug "test" sub-command. | |
1145 | */ | |
1146 | static int do_efi_test(cmd_tbl_t *cmdtp, int flag, | |
1147 | int argc, char * const argv[]) | |
1148 | { | |
1149 | cmd_tbl_t *cp; | |
1150 | ||
1151 | if (argc < 2) | |
1152 | return CMD_RET_USAGE; | |
1153 | ||
1154 | argc--; argv++; | |
1155 | ||
1156 | cp = find_cmd_tbl(argv[0], cmd_efidebug_test_sub, | |
1157 | ARRAY_SIZE(cmd_efidebug_test_sub)); | |
1158 | if (!cp) | |
1159 | return CMD_RET_USAGE; | |
1160 | ||
1161 | return cp->cmd(cmdtp, flag, argc, argv); | |
1162 | } | |
1163 | ||
59df7e7e AT |
1164 | static cmd_tbl_t cmd_efidebug_sub[] = { |
1165 | U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""), | |
355cdb5a AT |
1166 | U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices, |
1167 | "", ""), | |
66eaf566 AT |
1168 | U_BOOT_CMD_MKENT(drivers, CONFIG_SYS_MAXARGS, 1, do_efi_show_drivers, |
1169 | "", ""), | |
a8014620 AT |
1170 | U_BOOT_CMD_MKENT(dh, CONFIG_SYS_MAXARGS, 1, do_efi_show_handles, |
1171 | "", ""), | |
fa536734 AT |
1172 | U_BOOT_CMD_MKENT(images, CONFIG_SYS_MAXARGS, 1, do_efi_show_images, |
1173 | "", ""), | |
00358bb8 AT |
1174 | U_BOOT_CMD_MKENT(memmap, CONFIG_SYS_MAXARGS, 1, do_efi_show_memmap, |
1175 | "", ""), | |
986e0648 HS |
1176 | U_BOOT_CMD_MKENT(tables, CONFIG_SYS_MAXARGS, 1, do_efi_show_tables, |
1177 | "", ""), | |
525fc067 AT |
1178 | U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_efi_test, |
1179 | "", ""), | |
59df7e7e AT |
1180 | }; |
1181 | ||
1182 | /** | |
1183 | * do_efidebug() - display and configure UEFI environment | |
1184 | * | |
1185 | * @cmdtp: Command table | |
1186 | * @flag: Command flag | |
1187 | * @argc: Number of arguments | |
1188 | * @argv: Argument array | |
1189 | * Return: CMD_RET_SUCCESS on success, | |
1190 | * CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure | |
1191 | * | |
1192 | * Implement efidebug command which allows us to display and | |
1193 | * configure UEFI environment. | |
59df7e7e AT |
1194 | */ |
1195 | static int do_efidebug(cmd_tbl_t *cmdtp, int flag, | |
1196 | int argc, char * const argv[]) | |
1197 | { | |
1198 | cmd_tbl_t *cp; | |
1199 | efi_status_t r; | |
1200 | ||
1201 | if (argc < 2) | |
1202 | return CMD_RET_USAGE; | |
1203 | ||
1204 | argc--; argv++; | |
1205 | ||
1206 | /* Initialize UEFI drivers */ | |
1207 | r = efi_init_obj_list(); | |
1208 | if (r != EFI_SUCCESS) { | |
1209 | printf("Error: Cannot initialize UEFI sub-system, r = %lu\n", | |
1210 | r & ~EFI_ERROR_MASK); | |
1211 | return CMD_RET_FAILURE; | |
1212 | } | |
1213 | ||
1214 | cp = find_cmd_tbl(argv[0], cmd_efidebug_sub, | |
1215 | ARRAY_SIZE(cmd_efidebug_sub)); | |
1216 | if (!cp) | |
1217 | return CMD_RET_USAGE; | |
1218 | ||
1219 | return cp->cmd(cmdtp, flag, argc, argv); | |
1220 | } | |
1221 | ||
1222 | #ifdef CONFIG_SYS_LONGHELP | |
1223 | static char efidebug_help_text[] = | |
1224 | " - UEFI Shell-like interface to configure UEFI environment\n" | |
1225 | "\n" | |
1226 | "efidebug boot add <bootid> <label> <interface> <devnum>[:<part>] <file path> [<load options>]\n" | |
1227 | " - set UEFI BootXXXX variable\n" | |
1228 | " <load options> will be passed to UEFI application\n" | |
1229 | "efidebug boot rm <bootid#1> [<bootid#2> [<bootid#3> [...]]]\n" | |
1230 | " - delete UEFI BootXXXX variables\n" | |
1231 | "efidebug boot dump\n" | |
1232 | " - dump all UEFI BootXXXX variables\n" | |
1233 | "efidebug boot next <bootid>\n" | |
1234 | " - set UEFI BootNext variable\n" | |
1235 | "efidebug boot order [<bootid#1> [<bootid#2> [<bootid#3> [...]]]]\n" | |
1236 | " - set/show UEFI boot order\n" | |
355cdb5a AT |
1237 | "\n" |
1238 | "efidebug devices\n" | |
07e2fe79 | 1239 | " - show UEFI devices\n" |
66eaf566 | 1240 | "efidebug drivers\n" |
07e2fe79 | 1241 | " - show UEFI drivers\n" |
a8014620 | 1242 | "efidebug dh\n" |
07e2fe79 | 1243 | " - show UEFI handles\n" |
fa536734 | 1244 | "efidebug images\n" |
00358bb8 AT |
1245 | " - show loaded images\n" |
1246 | "efidebug memmap\n" | |
07e2fe79 | 1247 | " - show UEFI memory map\n" |
986e0648 | 1248 | "efidebug tables\n" |
525fc067 AT |
1249 | " - show UEFI configuration tables\n" |
1250 | "efidebug test bootmgr\n" | |
1251 | " - run simple bootmgr for test\n"; | |
59df7e7e AT |
1252 | #endif |
1253 | ||
1254 | U_BOOT_CMD( | |
1255 | efidebug, 10, 0, do_efidebug, | |
1256 | "Configure UEFI environment", | |
1257 | efidebug_help_text | |
1258 | ); |