cmd/efidebug.c

   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_dt_fixup.h>
  12 #include <efi_loader.h>
  13 #include <efi_rng.h>
  14 #include <exports.h>
  15 #include <hexdump.h>
  16 #include <log.h>
  17 #include <malloc.h>
  18 #include <mapmem.h>
  19 #include <part.h>
  20 #include <search.h>
  21 #include <linux/ctype.h>
  22
  23 #define BS systab.boottime
  24 #define RT systab.runtime
  25
  26 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
  27 /**
  28  * do_efi_capsule_update() - process a capsule update
  29  *
  30  * @cmdtp:      Command table
  31  * @flag:       Command flag
  32  * @argc:       Number of arguments
  33  * @argv:       Argument array
  34  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
  35  *
  36  * Implement efidebug "capsule update" sub-command.
  37  * process a capsule update.
  38  *
  39  *     efidebug capsule update [-v] <capsule address>
  40  */
  41 static int do_efi_capsule_update(struct cmd_tbl *cmdtp, int flag,
  42                                  int argc, char * const argv[])
  43 {
  44         struct efi_capsule_header *capsule;
  45         int verbose = 0;
  46         char *endp;
  47         efi_status_t ret;
  48
  49         if (argc != 2 && argc != 3)
  50                 return CMD_RET_USAGE;
  51
  52         if (argc == 3) {
  53                 if (strcmp(argv[1], "-v"))
  54                         return CMD_RET_USAGE;
  55
  56                 verbose = 1;
  57                 argc--;
  58                 argv++;
  59         }
  60
  61         capsule = (typeof(capsule))simple_strtoul(argv[1], &endp, 16);
  62         if (endp == argv[1]) {
  63                 printf("Invalid address: %s", argv[1]);
  64                 return CMD_RET_FAILURE;
  65         }
  66
  67         if (verbose) {
  68                 printf("Capsule guid: %pUl\n", &capsule->capsule_guid);
  69                 printf("Capsule flags: 0x%x\n", capsule->flags);
  70                 printf("Capsule header size: 0x%x\n", capsule->header_size);
  71                 printf("Capsule image size: 0x%x\n",
  72                        capsule->capsule_image_size);
  73         }
  74
  75         ret = EFI_CALL(RT->update_capsule(&capsule, 1, 0));
  76         if (ret) {
  77                 printf("Cannot handle a capsule at %p", capsule);
  78                 return CMD_RET_FAILURE;
  79         }
  80
  81         return CMD_RET_SUCCESS;
  82 }
  83
  84 static int do_efi_capsule_on_disk_update(struct cmd_tbl *cmdtp, int flag,
  85                                          int argc, char * const argv[])
  86 {
  87         efi_status_t ret;
  88
  89         ret = efi_launch_capsules();
  90
  91         return ret == EFI_SUCCESS ? CMD_RET_SUCCESS : CMD_RET_FAILURE;
  92 }
  93
  94 /**
  95  * do_efi_capsule_show() - show capsule information
  96  *
  97  * @cmdtp:      Command table
  98  * @flag:       Command flag
  99  * @argc:       Number of arguments
 100  * @argv:       Argument array
 101  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 102  *
 103  * Implement efidebug "capsule show" sub-command.
 104  * show capsule information.
 105  *
 106  *     efidebug capsule show <capsule address>
 107  */
 108 static int do_efi_capsule_show(struct cmd_tbl *cmdtp, int flag,
 109                                int argc, char * const argv[])
 110 {
 111         struct efi_capsule_header *capsule;
 112         char *endp;
 113
 114         if (argc != 2)
 115                 return CMD_RET_USAGE;
 116
 117         capsule = (typeof(capsule))simple_strtoul(argv[1], &endp, 16);
 118         if (endp == argv[1]) {
 119                 printf("Invalid address: %s", argv[1]);
 120                 return CMD_RET_FAILURE;
 121         }
 122
 123         printf("Capsule guid: %pUl\n", &capsule->capsule_guid);
 124         printf("Capsule flags: 0x%x\n", capsule->flags);
 125         printf("Capsule header size: 0x%x\n", capsule->header_size);
 126         printf("Capsule image size: 0x%x\n",
 127                capsule->capsule_image_size);
 128
 129         return CMD_RET_SUCCESS;
 130 }
 131
 132 /**
 133  * do_efi_capsule_res() - show a capsule update result
 134  *
 135  * @cmdtp:      Command table
 136  * @flag:       Command flag
 137  * @argc:       Number of arguments
 138  * @argv:       Argument array
 139  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 140  *
 141  * Implement efidebug "capsule result" sub-command.
 142  * show a capsule update result.
 143  * If result number is not specified, CapsuleLast will be shown.
 144  *
 145  *     efidebug capsule result [<capsule result number>]
 146  */
 147 static int do_efi_capsule_res(struct cmd_tbl *cmdtp, int flag,
 148                               int argc, char * const argv[])
 149 {
 150         int capsule_id;
 151         char *endp;
 152         char var_name[12];
 153         u16 var_name16[12], *p;
 154         efi_guid_t guid;
 155         struct efi_capsule_result_variable_header *result = NULL;
 156         efi_uintn_t size;
 157         efi_status_t ret;
 158
 159         if (argc != 1 && argc != 2)
 160                 return CMD_RET_USAGE;
 161
 162         guid = efi_guid_capsule_report;
 163         if (argc == 1) {
 164                 size = sizeof(var_name16);
 165                 ret = EFI_CALL(RT->get_variable(L"CapsuleLast", &guid, NULL,
 166                                                 &size, var_name16));
 167                 if (ret != EFI_SUCCESS) {
 168                         if (ret == EFI_NOT_FOUND)
 169                                 printf("CapsuleLast doesn't exist\n");
 170                         else
 171                                 printf("Failed to get CapsuleLast\n");
 172
 173                         return CMD_RET_FAILURE;
 174                 }
 175                 printf("CapsuleLast is %ls\n", var_name16);
 176         } else {
 177                 argc--;
 178                 argv++;
 179
 180                 capsule_id = simple_strtoul(argv[0], &endp, 16);
 181                 if (capsule_id < 0 || capsule_id > 0xffff)
 182                         return CMD_RET_USAGE;
 183
 184                 sprintf(var_name, "Capsule%04X", capsule_id);
 185                 p = var_name16;
 186                 utf8_utf16_strncpy(&p, var_name, 9);
 187         }
 188
 189         size = 0;
 190         ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size, NULL));
 191         if (ret == EFI_BUFFER_TOO_SMALL) {
 192                 result = malloc(size);
 193                 if (!result)
 194                         return CMD_RET_FAILURE;
 195                 ret = EFI_CALL(RT->get_variable(var_name16, &guid, NULL, &size,
 196                                                 result));
 197         }
 198         if (ret != EFI_SUCCESS) {
 199                 free(result);
 200                 printf("Failed to get %ls\n", var_name16);
 201
 202                 return CMD_RET_FAILURE;
 203         }
 204
 205         printf("Result total size: 0x%x\n", result->variable_total_size);
 206         printf("Capsule guid: %pUl\n", &result->capsule_guid);
 207         printf("Time processed: %04d-%02d-%02d %02d:%02d:%02d\n",
 208                result->capsule_processed.year, result->capsule_processed.month,
 209                result->capsule_processed.day, result->capsule_processed.hour,
 210                result->capsule_processed.minute,
 211                result->capsule_processed.second);
 212         printf("Capsule status: 0x%lx\n", result->capsule_status);
 213
 214         free(result);
 215
 216         return CMD_RET_SUCCESS;
 217 }
 218
 219 static struct cmd_tbl cmd_efidebug_capsule_sub[] = {
 220         U_BOOT_CMD_MKENT(update, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_update,
 221                          "", ""),
 222         U_BOOT_CMD_MKENT(show, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_show,
 223                          "", ""),
 224         U_BOOT_CMD_MKENT(disk-update, 0, 0, do_efi_capsule_on_disk_update,
 225                          "", ""),
 226         U_BOOT_CMD_MKENT(result, CONFIG_SYS_MAXARGS, 1, do_efi_capsule_res,
 227                          "", ""),
 228 };
 229
 230 /**
 231  * do_efi_capsule() - manage UEFI capsules
 232  *
 233  * @cmdtp:      Command table
 234  * @flag:       Command flag
 235  * @argc:       Number of arguments
 236  * @argv:       Argument array
 237  * Return:      CMD_RET_SUCCESS on success,
 238  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
 239  *
 240  * Implement efidebug "capsule" sub-command.
 241  */
 242 static int do_efi_capsule(struct cmd_tbl *cmdtp, int flag,
 243                           int argc, char * const argv[])
 244 {
 245         struct cmd_tbl *cp;
 246
 247         if (argc < 2)
 248                 return CMD_RET_USAGE;
 249
 250         argc--; argv++;
 251
 252         cp = find_cmd_tbl(argv[0], cmd_efidebug_capsule_sub,
 253                           ARRAY_SIZE(cmd_efidebug_capsule_sub));
 254         if (!cp)
 255                 return CMD_RET_USAGE;
 256
 257         return cp->cmd(cmdtp, flag, argc, argv);
 258 }
 259 #endif /* CONFIG_EFI_HAVE_CAPSULE_SUPPORT */
 260
 261 /**
 262  * efi_get_device_handle_info() - get information of UEFI device
 263  *
 264  * @handle:             Handle of UEFI device
 265  * @dev_path_text:      Pointer to text of device path
 266  * Return:              0 on success, -1 on failure
 267  *
 268  * Currently return a formatted text of device path.
 269  */
 270 static int efi_get_device_handle_info(efi_handle_t handle, u16 **dev_path_text)
 271 {
 272         struct efi_device_path *dp;
 273         efi_status_t ret;
 274
 275         ret = EFI_CALL(BS->open_protocol(handle, &efi_guid_device_path,
 276                                          (void **)&dp, NULL /* FIXME */, NULL,
 277                                          EFI_OPEN_PROTOCOL_GET_PROTOCOL));
 278         if (ret == EFI_SUCCESS) {
 279                 *dev_path_text = efi_dp_str(dp);
 280                 return 0;
 281         } else {
 282                 return -1;
 283         }
 284 }
 285
 286 #define EFI_HANDLE_WIDTH ((int)sizeof(efi_handle_t) * 2)
 287
 288 static const char spc[] = "                ";
 289 static const char sep[] = "================";
 290
 291 /**
 292  * do_efi_show_devices() - show UEFI devices
 293  *
 294  * @cmdtp:      Command table
 295  * @flag:       Command flag
 296  * @argc:       Number of arguments
 297  * @argv:       Argument array
 298  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 299  *
 300  * Implement efidebug "devices" sub-command.
 301  * Show all UEFI devices and their information.
 302  */
 303 static int do_efi_show_devices(struct cmd_tbl *cmdtp, int flag,
 304                                int argc, char *const argv[])
 305 {
 306         efi_handle_t *handles;
 307         efi_uintn_t num, i;
 308         u16 *dev_path_text;
 309         efi_status_t ret;
 310
 311         ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
 312                                                 &num, &handles));
 313         if (ret != EFI_SUCCESS)
 314                 return CMD_RET_FAILURE;
 315
 316         if (!num)
 317                 return CMD_RET_SUCCESS;
 318
 319         printf("Device%.*s Device Path\n", EFI_HANDLE_WIDTH - 6, spc);
 320         printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
 321         for (i = 0; i < num; i++) {
 322                 if (!efi_get_device_handle_info(handles[i], &dev_path_text)) {
 323                         printf("%p %ls\n", handles[i], dev_path_text);
 324                         efi_free_pool(dev_path_text);
 325                 }
 326         }
 327
 328         efi_free_pool(handles);
 329
 330         return CMD_RET_SUCCESS;
 331 }
 332
 333 /**
 334  * efi_get_driver_handle_info() - get information of UEFI driver
 335  *
 336  * @handle:             Handle of UEFI device
 337  * @driver_name:        Driver name
 338  * @image_path:         Pointer to text of device path
 339  * Return:              0 on success, -1 on failure
 340  *
 341  * Currently return no useful information as all UEFI drivers are
 342  * built-in..
 343  */
 344 static int efi_get_driver_handle_info(efi_handle_t handle, u16 **driver_name,
 345                                       u16 **image_path)
 346 {
 347         struct efi_handler *handler;
 348         struct efi_loaded_image *image;
 349         efi_status_t ret;
 350
 351         /*
 352          * driver name
 353          * TODO: support EFI_COMPONENT_NAME2_PROTOCOL
 354          */
 355         *driver_name = NULL;
 356
 357         /* image name */
 358         ret = efi_search_protocol(handle, &efi_guid_loaded_image, &handler);
 359         if (ret != EFI_SUCCESS) {
 360                 *image_path = NULL;
 361                 return 0;
 362         }
 363
 364         image = handler->protocol_interface;
 365         *image_path = efi_dp_str(image->file_path);
 366
 367         return 0;
 368 }
 369
 370 /**
 371  * do_efi_show_drivers() - show UEFI drivers
 372  *
 373  * @cmdtp:      Command table
 374  * @flag:       Command flag
 375  * @argc:       Number of arguments
 376  * @argv:       Argument array
 377  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 378  *
 379  * Implement efidebug "drivers" sub-command.
 380  * Show all UEFI drivers and their information.
 381  */
 382 static int do_efi_show_drivers(struct cmd_tbl *cmdtp, int flag,
 383                                int argc, char *const argv[])
 384 {
 385         efi_handle_t *handles;
 386         efi_uintn_t num, i;
 387         u16 *driver_name, *image_path_text;
 388         efi_status_t ret;
 389
 390         ret = EFI_CALL(efi_locate_handle_buffer(
 391                                 BY_PROTOCOL, &efi_guid_driver_binding_protocol,
 392                                 NULL, &num, &handles));
 393         if (ret != EFI_SUCCESS)
 394                 return CMD_RET_FAILURE;
 395
 396         if (!num)
 397                 return CMD_RET_SUCCESS;
 398
 399         printf("Driver%.*s Name                 Image Path\n",
 400                EFI_HANDLE_WIDTH - 6, spc);
 401         printf("%.*s ==================== ====================\n",
 402                EFI_HANDLE_WIDTH, sep);
 403         for (i = 0; i < num; i++) {
 404                 if (!efi_get_driver_handle_info(handles[i], &driver_name,
 405                                                 &image_path_text)) {
 406                         if (image_path_text)
 407                                 printf("%p %-20ls %ls\n", handles[i],
 408                                        driver_name, image_path_text);
 409                         else
 410                                 printf("%p %-20ls <built-in>\n",
 411                                        handles[i], driver_name);
 412                         efi_free_pool(driver_name);
 413                         efi_free_pool(image_path_text);
 414                 }
 415         }
 416
 417         efi_free_pool(handles);
 418
 419         return CMD_RET_SUCCESS;
 420 }
 421
 422 static const struct {
 423         const char *text;
 424         const efi_guid_t guid;
 425 } guid_list[] = {
 426         {
 427                 "Device Path",
 428                 EFI_DEVICE_PATH_PROTOCOL_GUID,
 429         },
 430         {
 431                 "Device Path To Text",
 432                 EFI_DEVICE_PATH_TO_TEXT_PROTOCOL_GUID,
 433         },
 434         {
 435                 "Device Path Utilities",
 436                 EFI_DEVICE_PATH_UTILITIES_PROTOCOL_GUID,
 437         },
 438         {
 439                 "Unicode Collation 2",
 440                 EFI_UNICODE_COLLATION_PROTOCOL2_GUID,
 441         },
 442         {
 443                 "Driver Binding",
 444                 EFI_DRIVER_BINDING_PROTOCOL_GUID,
 445         },
 446         {
 447                 "Simple Text Input",
 448                 EFI_SIMPLE_TEXT_INPUT_PROTOCOL_GUID,
 449         },
 450         {
 451                 "Simple Text Input Ex",
 452                 EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID,
 453         },
 454         {
 455                 "Simple Text Output",
 456                 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL_GUID,
 457         },
 458         {
 459                 "Block IO",
 460                 EFI_BLOCK_IO_PROTOCOL_GUID,
 461         },
 462         {
 463                 "Simple File System",
 464                 EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID,
 465         },
 466         {
 467                 "Loaded Image",
 468                 EFI_LOADED_IMAGE_PROTOCOL_GUID,
 469         },
 470         {
 471                 "Graphics Output",
 472                 EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID,
 473         },
 474         {
 475                 "HII String",
 476                 EFI_HII_STRING_PROTOCOL_GUID,
 477         },
 478         {
 479                 "HII Database",
 480                 EFI_HII_DATABASE_PROTOCOL_GUID,
 481         },
 482         {
 483                 "HII Config Routing",
 484                 EFI_HII_CONFIG_ROUTING_PROTOCOL_GUID,
 485         },
 486         {
 487                 "Load File2",
 488                 EFI_LOAD_FILE2_PROTOCOL_GUID,
 489         },
 490         {
 491                 "Random Number Generator",
 492                 EFI_RNG_PROTOCOL_GUID,
 493         },
 494         {
 495                 "Simple Network",
 496                 EFI_SIMPLE_NETWORK_PROTOCOL_GUID,
 497         },
 498         {
 499                 "PXE Base Code",
 500                 EFI_PXE_BASE_CODE_PROTOCOL_GUID,
 501         },
 502         {
 503                 "Device-Tree Fixup",
 504                 EFI_DT_FIXUP_PROTOCOL_GUID,
 505         },
 506         {
 507                 "System Partition",
 508                 PARTITION_SYSTEM_GUID
 509         },
 510         {
 511                 "Firmware Management",
 512                 EFI_FIRMWARE_MANAGEMENT_PROTOCOL_GUID
 513         },
 514         /* Configuration table GUIDs */
 515         {
 516                 "ACPI table",
 517                 EFI_ACPI_TABLE_GUID,
 518         },
 519         {
 520                 "device tree",
 521                 EFI_FDT_GUID,
 522         },
 523         {
 524                 "SMBIOS table",
 525                 SMBIOS_TABLE_GUID,
 526         },
 527         {
 528                 "Runtime properties",
 529                 EFI_RT_PROPERTIES_TABLE_GUID,
 530         },
 531         {
 532                 "TCG2 Final Events Table",
 533                 EFI_TCG2_FINAL_EVENTS_TABLE_GUID,
 534         },
 535 };
 536
 537 /**
 538  * get_guid_text - get string of GUID
 539  *
 540  * Return description of GUID.
 541  *
 542  * @guid:       GUID
 543  * Return:      description of GUID or NULL
 544  */
 545 static const char *get_guid_text(const void *guid)
 546 {
 547         int i;
 548
 549         for (i = 0; i < ARRAY_SIZE(guid_list); i++) {
 550                 /*
 551                  * As guidcmp uses memcmp() we can safely accept unaligned
 552                  * GUIDs.
 553                  */
 554                 if (!guidcmp(&guid_list[i].guid, guid))
 555                         return guid_list[i].text;
 556         }
 557
 558         return NULL;
 559 }
 560
 561 /**
 562  * do_efi_show_handles() - show UEFI handles
 563  *
 564  * @cmdtp:      Command table
 565  * @flag:       Command flag
 566  * @argc:       Number of arguments
 567  * @argv:       Argument array
 568  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 569  *
 570  * Implement efidebug "dh" sub-command.
 571  * Show all UEFI handles and their information, currently all protocols
 572  * added to handle.
 573  */
 574 static int do_efi_show_handles(struct cmd_tbl *cmdtp, int flag,
 575                                int argc, char *const argv[])
 576 {
 577         efi_handle_t *handles;
 578         efi_guid_t **guid;
 579         efi_uintn_t num, count, i, j;
 580         const char *guid_text;
 581         efi_status_t ret;
 582
 583         ret = EFI_CALL(efi_locate_handle_buffer(ALL_HANDLES, NULL, NULL,
 584                                                 &num, &handles));
 585         if (ret != EFI_SUCCESS)
 586                 return CMD_RET_FAILURE;
 587
 588         if (!num)
 589                 return CMD_RET_SUCCESS;
 590
 591         printf("Handle%.*s Protocols\n", EFI_HANDLE_WIDTH - 6, spc);
 592         printf("%.*s ====================\n", EFI_HANDLE_WIDTH, sep);
 593         for (i = 0; i < num; i++) {
 594                 printf("%p", handles[i]);
 595                 ret = EFI_CALL(BS->protocols_per_handle(handles[i], &guid,
 596                                                         &count));
 597                 if (ret || !count) {
 598                         putc('\n');
 599                         continue;
 600                 }
 601
 602                 for (j = 0; j < count; j++) {
 603                         if (j)
 604                                 printf(", ");
 605                         else
 606                                 putc(' ');
 607
 608                         guid_text = get_guid_text(guid[j]);
 609                         if (guid_text)
 610                                 puts(guid_text);
 611                         else
 612                                 printf("%pUl", guid[j]);
 613                 }
 614                 putc('\n');
 615         }
 616
 617         efi_free_pool(handles);
 618
 619         return CMD_RET_SUCCESS;
 620 }
 621
 622 /**
 623  * do_efi_show_images() - show UEFI images
 624  *
 625  * @cmdtp:      Command table
 626  * @flag:       Command flag
 627  * @argc:       Number of arguments
 628  * @argv:       Argument array
 629  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 630  *
 631  * Implement efidebug "images" sub-command.
 632  * Show all UEFI loaded images and their information.
 633  */
 634 static int do_efi_show_images(struct cmd_tbl *cmdtp, int flag,
 635                               int argc, char *const argv[])
 636 {
 637         efi_print_image_infos(NULL);
 638
 639         return CMD_RET_SUCCESS;
 640 }
 641
 642 static const char * const efi_mem_type_string[] = {
 643         [EFI_RESERVED_MEMORY_TYPE] = "RESERVED",
 644         [EFI_LOADER_CODE] = "LOADER CODE",
 645         [EFI_LOADER_DATA] = "LOADER DATA",
 646         [EFI_BOOT_SERVICES_CODE] = "BOOT CODE",
 647         [EFI_BOOT_SERVICES_DATA] = "BOOT DATA",
 648         [EFI_RUNTIME_SERVICES_CODE] = "RUNTIME CODE",
 649         [EFI_RUNTIME_SERVICES_DATA] = "RUNTIME DATA",
 650         [EFI_CONVENTIONAL_MEMORY] = "CONVENTIONAL",
 651         [EFI_UNUSABLE_MEMORY] = "UNUSABLE MEM",
 652         [EFI_ACPI_RECLAIM_MEMORY] = "ACPI RECLAIM MEM",
 653         [EFI_ACPI_MEMORY_NVS] = "ACPI NVS",
 654         [EFI_MMAP_IO] = "IO",
 655         [EFI_MMAP_IO_PORT] = "IO PORT",
 656         [EFI_PAL_CODE] = "PAL",
 657         [EFI_PERSISTENT_MEMORY_TYPE] = "PERSISTENT",
 658 };
 659
 660 static const struct efi_mem_attrs {
 661         const u64 bit;
 662         const char *text;
 663 } efi_mem_attrs[] = {
 664         {EFI_MEMORY_UC, "UC"},
 665         {EFI_MEMORY_UC, "UC"},
 666         {EFI_MEMORY_WC, "WC"},
 667         {EFI_MEMORY_WT, "WT"},
 668         {EFI_MEMORY_WB, "WB"},
 669         {EFI_MEMORY_UCE, "UCE"},
 670         {EFI_MEMORY_WP, "WP"},
 671         {EFI_MEMORY_RP, "RP"},
 672         {EFI_MEMORY_XP, "WP"},
 673         {EFI_MEMORY_NV, "NV"},
 674         {EFI_MEMORY_MORE_RELIABLE, "REL"},
 675         {EFI_MEMORY_RO, "RO"},
 676         {EFI_MEMORY_SP, "SP"},
 677         {EFI_MEMORY_RUNTIME, "RT"},
 678 };
 679
 680 /**
 681  * print_memory_attributes() - print memory map attributes
 682  *
 683  * @attributes: Attribute value
 684  *
 685  * Print memory map attributes
 686  */
 687 static void print_memory_attributes(u64 attributes)
 688 {
 689         int sep, i;
 690
 691         for (sep = 0, i = 0; i < ARRAY_SIZE(efi_mem_attrs); i++)
 692                 if (attributes & efi_mem_attrs[i].bit) {
 693                         if (sep) {
 694                                 putc('|');
 695                         } else {
 696                                 putc(' ');
 697                                 sep = 1;
 698                         }
 699                         puts(efi_mem_attrs[i].text);
 700                 }
 701 }
 702
 703 #define EFI_PHYS_ADDR_WIDTH (int)(sizeof(efi_physical_addr_t) * 2)
 704
 705 /**
 706  * do_efi_show_memmap() - show UEFI memory map
 707  *
 708  * @cmdtp:      Command table
 709  * @flag:       Command flag
 710  * @argc:       Number of arguments
 711  * @argv:       Argument array
 712  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 713  *
 714  * Implement efidebug "memmap" sub-command.
 715  * Show UEFI memory map.
 716  */
 717 static int do_efi_show_memmap(struct cmd_tbl *cmdtp, int flag,
 718                               int argc, char *const argv[])
 719 {
 720         struct efi_mem_desc *memmap = NULL, *map;
 721         efi_uintn_t map_size = 0;
 722         const char *type;
 723         int i;
 724         efi_status_t ret;
 725
 726         ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
 727         if (ret == EFI_BUFFER_TOO_SMALL) {
 728                 map_size += sizeof(struct efi_mem_desc); /* for my own */
 729                 ret = efi_allocate_pool(EFI_LOADER_DATA, map_size,
 730                                         (void *)&memmap);
 731                 if (ret != EFI_SUCCESS)
 732                         return CMD_RET_FAILURE;
 733                 ret = efi_get_memory_map(&map_size, memmap, NULL, NULL, NULL);
 734         }
 735         if (ret != EFI_SUCCESS) {
 736                 efi_free_pool(memmap);
 737                 return CMD_RET_FAILURE;
 738         }
 739
 740         printf("Type             Start%.*s End%.*s Attributes\n",
 741                EFI_PHYS_ADDR_WIDTH - 5, spc, EFI_PHYS_ADDR_WIDTH - 3, spc);
 742         printf("================ %.*s %.*s ==========\n",
 743                EFI_PHYS_ADDR_WIDTH, sep, EFI_PHYS_ADDR_WIDTH, sep);
 744         /*
 745          * Coverity check: dereferencing null pointer "map."
 746          * This is a false positive as memmap will always be
 747          * populated by allocate_pool() above.
 748          */
 749         for (i = 0, map = memmap; i < map_size / sizeof(*map); map++, i++) {
 750                 if (map->type < ARRAY_SIZE(efi_mem_type_string))
 751                         type = efi_mem_type_string[map->type];
 752                 else
 753                         type = "(unknown)";
 754
 755                 printf("%-16s %.*llx-%.*llx", type,
 756                        EFI_PHYS_ADDR_WIDTH,
 757                        (u64)map_to_sysmem((void *)(uintptr_t)
 758                                           map->physical_start),
 759                        EFI_PHYS_ADDR_WIDTH,
 760                        (u64)map_to_sysmem((void *)(uintptr_t)
 761                                           (map->physical_start +
 762                                            map->num_pages * EFI_PAGE_SIZE)));
 763
 764                 print_memory_attributes(map->attribute);
 765                 putc('\n');
 766         }
 767
 768         efi_free_pool(memmap);
 769
 770         return CMD_RET_SUCCESS;
 771 }
 772
 773 /**
 774  * do_efi_show_tables() - show UEFI configuration tables
 775  *
 776  * @cmdtp:      Command table
 777  * @flag:       Command flag
 778  * @argc:       Number of arguments
 779  * @argv:       Argument array
 780  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 781  *
 782  * Implement efidebug "tables" sub-command.
 783  * Show UEFI configuration tables.
 784  */
 785 static int do_efi_show_tables(struct cmd_tbl *cmdtp, int flag,
 786                               int argc, char *const argv[])
 787 {
 788         efi_uintn_t i;
 789         const char *guid_str;
 790
 791         for (i = 0; i < systab.nr_tables; ++i) {
 792                 guid_str = get_guid_text(&systab.tables[i].guid);
 793                 if (!guid_str)
 794                         guid_str = "";
 795                 printf("%pUl %s\n", &systab.tables[i].guid, guid_str);
 796         }
 797
 798         return CMD_RET_SUCCESS;
 799 }
 800
 801 /**
 802  * do_efi_boot_add() - set UEFI load option
 803  *
 804  * @cmdtp:      Command table
 805  * @flag:       Command flag
 806  * @argc:       Number of arguments
 807  * @argv:       Argument array
 808  * Return:      CMD_RET_SUCCESS on success,
 809  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
 810  *
 811  * Implement efidebug "boot add" sub-command. Create or change UEFI load option.
 812  *
 813  *     efidebug boot add <id> <label> <interface> <devnum>[:<part>] <file> <options>
 814  */
 815 static int do_efi_boot_add(struct cmd_tbl *cmdtp, int flag,
 816                            int argc, char *const argv[])
 817 {
 818         int id;
 819         char *endp;
 820         char var_name[9];
 821         u16 var_name16[9], *p;
 822         efi_guid_t guid;
 823         size_t label_len, label_len16;
 824         u16 *label;
 825         struct efi_device_path *device_path = NULL, *file_path = NULL;
 826         struct efi_load_option lo;
 827         void *data = NULL;
 828         efi_uintn_t size;
 829         efi_status_t ret;
 830         int r = CMD_RET_SUCCESS;
 831
 832         if (argc < 6 || argc > 7)
 833                 return CMD_RET_USAGE;
 834
 835         id = (int)simple_strtoul(argv[1], &endp, 16);
 836         if (*endp != '\0' || id > 0xffff)
 837                 return CMD_RET_USAGE;
 838
 839         sprintf(var_name, "Boot%04X", id);
 840         p = var_name16;
 841         utf8_utf16_strncpy(&p, var_name, 9);
 842
 843         guid = efi_global_variable_guid;
 844
 845         /* attributes */
 846         lo.attributes = LOAD_OPTION_ACTIVE; /* always ACTIVE */
 847
 848         /* label */
 849         label_len = strlen(argv[2]);
 850         label_len16 = utf8_utf16_strnlen(argv[2], label_len);
 851         label = malloc((label_len16 + 1) * sizeof(u16));
 852         if (!label)
 853                 return CMD_RET_FAILURE;
 854         lo.label = label; /* label will be changed below */
 855         utf8_utf16_strncpy(&label, argv[2], label_len);
 856
 857         /* file path */
 858         ret = efi_dp_from_name(argv[3], argv[4], argv[5], &device_path,
 859                                &file_path);
 860         if (ret != EFI_SUCCESS) {
 861                 printf("Cannot create device path for \"%s %s\"\n",
 862                        argv[3], argv[4]);
 863                 r = CMD_RET_FAILURE;
 864                 goto out;
 865         }
 866         lo.file_path = file_path;
 867         lo.file_path_length = efi_dp_size(file_path)
 868                                 + sizeof(struct efi_device_path); /* for END */
 869
 870         /* optional data */
 871         if (argc == 6)
 872                 lo.optional_data = NULL;
 873         else
 874                 lo.optional_data = (const u8 *)argv[6];
 875
 876         size = efi_serialize_load_option(&lo, (u8 **)&data);
 877         if (!size) {
 878                 r = CMD_RET_FAILURE;
 879                 goto out;
 880         }
 881
 882         ret = EFI_CALL(efi_set_variable(var_name16, &guid,
 883                                         EFI_VARIABLE_NON_VOLATILE |
 884                                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
 885                                         EFI_VARIABLE_RUNTIME_ACCESS,
 886                                         size, data));
 887         if (ret != EFI_SUCCESS) {
 888                 printf("Cannot set %ls\n", var_name16);
 889                 r = CMD_RET_FAILURE;
 890         }
 891 out:
 892         free(data);
 893         efi_free_pool(device_path);
 894         efi_free_pool(file_path);
 895         free(lo.label);
 896
 897         return r;
 898 }
 899
 900 /**
 901  * do_efi_boot_rm() - delete UEFI load options
 902  *
 903  * @cmdtp:      Command table
 904  * @flag:       Command flag
 905  * @argc:       Number of arguments
 906  * @argv:       Argument array
 907  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
 908  *
 909  * Implement efidebug "boot rm" sub-command.
 910  * Delete UEFI load options.
 911  *
 912  *     efidebug boot rm <id> ...
 913  */
 914 static int do_efi_boot_rm(struct cmd_tbl *cmdtp, int flag,
 915                           int argc, char *const argv[])
 916 {
 917         efi_guid_t guid;
 918         int id, i;
 919         char *endp;
 920         char var_name[9];
 921         u16 var_name16[9], *p;
 922         efi_status_t ret;
 923
 924         if (argc == 1)
 925                 return CMD_RET_USAGE;
 926
 927         guid = efi_global_variable_guid;
 928         for (i = 1; i < argc; i++, argv++) {
 929                 id = (int)simple_strtoul(argv[1], &endp, 16);
 930                 if (*endp != '\0' || id > 0xffff)
 931                         return CMD_RET_FAILURE;
 932
 933                 sprintf(var_name, "Boot%04X", id);
 934                 p = var_name16;
 935                 utf8_utf16_strncpy(&p, var_name, 9);
 936
 937                 ret = EFI_CALL(efi_set_variable(var_name16, &guid, 0, 0, NULL));
 938                 if (ret) {
 939                         printf("Cannot remove %ls\n", var_name16);
 940                         return CMD_RET_FAILURE;
 941                 }
 942         }
 943
 944         return CMD_RET_SUCCESS;
 945 }
 946
 947 /**
 948  * show_efi_boot_opt_data() - dump UEFI load option
 949  *
 950  * @varname16:  variable name
 951  * @data:       value of UEFI load option variable
 952  * @size:       size of the boot option
 953  *
 954  * Decode the value of UEFI load option variable and print information.
 955  */
 956 static void show_efi_boot_opt_data(u16 *varname16, void *data, size_t *size)
 957 {
 958         struct efi_load_option lo;
 959         char *label, *p;
 960         size_t label_len16, label_len;
 961         u16 *dp_str;
 962         efi_status_t ret;
 963
 964         ret = efi_deserialize_load_option(&lo, data, size);
 965         if (ret != EFI_SUCCESS) {
 966                 printf("%ls: invalid load option\n", varname16);
 967                 return;
 968         }
 969
 970         label_len16 = u16_strlen(lo.label);
 971         label_len = utf16_utf8_strnlen(lo.label, label_len16);
 972         label = malloc(label_len + 1);
 973         if (!label)
 974                 return;
 975         p = label;
 976         utf16_utf8_strncpy(&p, lo.label, label_len16);
 977
 978         printf("%ls:\nattributes: %c%c%c (0x%08x)\n",
 979                varname16,
 980                /* ACTIVE */
 981                lo.attributes & LOAD_OPTION_ACTIVE ? 'A' : '-',
 982                /* FORCE RECONNECT */
 983                lo.attributes & LOAD_OPTION_FORCE_RECONNECT ? 'R' : '-',
 984                /* HIDDEN */
 985                lo.attributes & LOAD_OPTION_HIDDEN ? 'H' : '-',
 986                lo.attributes);
 987         printf("  label: %s\n", label);
 988
 989         dp_str = efi_dp_str(lo.file_path);
 990         printf("  file_path: %ls\n", dp_str);
 991         efi_free_pool(dp_str);
 992
 993         printf("  data:\n");
 994         print_hex_dump("    ", DUMP_PREFIX_OFFSET, 16, 1,
 995                        lo.optional_data, *size, true);
 996         free(label);
 997 }
 998
 999 /**
1000  * show_efi_boot_opt() - dump UEFI load option
1001  *
1002  * @varname16:  variable name
1003  *
1004  * Dump information defined by UEFI load option.
1005  */
1006 static void show_efi_boot_opt(u16 *varname16)
1007 {
1008         void *data;
1009         efi_uintn_t size;
1010         efi_status_t ret;
1011
1012         size = 0;
1013         ret = EFI_CALL(efi_get_variable(varname16, &efi_global_variable_guid,
1014                                         NULL, &size, NULL));
1015         if (ret == EFI_BUFFER_TOO_SMALL) {
1016                 data = malloc(size);
1017                 if (!data) {
1018                         printf("ERROR: Out of memory\n");
1019                         return;
1020                 }
1021                 ret = EFI_CALL(efi_get_variable(varname16,
1022                                                 &efi_global_variable_guid,
1023                                                 NULL, &size, data));
1024                 if (ret == EFI_SUCCESS)
1025                         show_efi_boot_opt_data(varname16, data, &size);
1026                 free(data);
1027         }
1028 }
1029
1030 static int u16_tohex(u16 c)
1031 {
1032         if (c >= '0' && c <= '9')
1033                 return c - '0';
1034         if (c >= 'A' && c <= 'F')
1035                 return c - 'A' + 10;
1036
1037         /* not hexadecimal */
1038         return -1;
1039 }
1040
1041 /**
1042  * show_efi_boot_dump() - dump all UEFI load options
1043  *
1044  * @cmdtp:      Command table
1045  * @flag:       Command flag
1046  * @argc:       Number of arguments
1047  * @argv:       Argument array
1048  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1049  *
1050  * Implement efidebug "boot dump" sub-command.
1051  * Dump information of all UEFI load options defined.
1052  *
1053  *     efidebug boot dump
1054  */
1055 static int do_efi_boot_dump(struct cmd_tbl *cmdtp, int flag,
1056                             int argc, char *const argv[])
1057 {
1058         u16 *var_name16, *p;
1059         efi_uintn_t buf_size, size;
1060         efi_guid_t guid;
1061         int id, i, digit;
1062         efi_status_t ret;
1063
1064         if (argc > 1)
1065                 return CMD_RET_USAGE;
1066
1067         buf_size = 128;
1068         var_name16 = malloc(buf_size);
1069         if (!var_name16)
1070                 return CMD_RET_FAILURE;
1071
1072         var_name16[0] = 0;
1073         for (;;) {
1074                 size = buf_size;
1075                 ret = EFI_CALL(efi_get_next_variable_name(&size, var_name16,
1076                                                           &guid));
1077                 if (ret == EFI_NOT_FOUND)
1078                         break;
1079                 if (ret == EFI_BUFFER_TOO_SMALL) {
1080                         buf_size = size;
1081                         p = realloc(var_name16, buf_size);
1082                         if (!p) {
1083                                 free(var_name16);
1084                                 return CMD_RET_FAILURE;
1085                         }
1086                         var_name16 = p;
1087                         ret = EFI_CALL(efi_get_next_variable_name(&size,
1088                                                                   var_name16,
1089                                                                   &guid));
1090                 }
1091                 if (ret != EFI_SUCCESS) {
1092                         free(var_name16);
1093                         return CMD_RET_FAILURE;
1094                 }
1095
1096                 if (memcmp(var_name16, L"Boot", 8))
1097                         continue;
1098
1099                 for (id = 0, i = 0; i < 4; i++) {
1100                         digit = u16_tohex(var_name16[4 + i]);
1101                         if (digit < 0)
1102                                 break;
1103                         id = (id << 4) + digit;
1104                 }
1105                 if (i == 4 && !var_name16[8])
1106                         show_efi_boot_opt(var_name16);
1107         }
1108
1109         free(var_name16);
1110
1111         return CMD_RET_SUCCESS;
1112 }
1113
1114 /**
1115  * show_efi_boot_order() - show order of UEFI load options
1116  *
1117  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1118  *
1119  * Show order of UEFI load options defined by BootOrder variable.
1120  */
1121 static int show_efi_boot_order(void)
1122 {
1123         u16 *bootorder;
1124         efi_uintn_t size;
1125         int num, i;
1126         char var_name[9];
1127         u16 var_name16[9], *p16;
1128         void *data;
1129         struct efi_load_option lo;
1130         char *label, *p;
1131         size_t label_len16, label_len;
1132         efi_status_t ret;
1133
1134         size = 0;
1135         ret = EFI_CALL(efi_get_variable(L"BootOrder", &efi_global_variable_guid,
1136                                         NULL, &size, NULL));
1137         if (ret != EFI_BUFFER_TOO_SMALL) {
1138                 if (ret == EFI_NOT_FOUND) {
1139                         printf("BootOrder not defined\n");
1140                         return CMD_RET_SUCCESS;
1141                 } else {
1142                         return CMD_RET_FAILURE;
1143                 }
1144         }
1145         bootorder = malloc(size);
1146         if (!bootorder) {
1147                 printf("ERROR: Out of memory\n");
1148                 return CMD_RET_FAILURE;
1149         }
1150         ret = EFI_CALL(efi_get_variable(L"BootOrder", &efi_global_variable_guid,
1151                                         NULL, &size, bootorder));
1152         if (ret != EFI_SUCCESS) {
1153                 ret = CMD_RET_FAILURE;
1154                 goto out;
1155         }
1156
1157         num = size / sizeof(u16);
1158         for (i = 0; i < num; i++) {
1159                 sprintf(var_name, "Boot%04X", bootorder[i]);
1160                 p16 = var_name16;
1161                 utf8_utf16_strncpy(&p16, var_name, 9);
1162
1163                 size = 0;
1164                 ret = EFI_CALL(efi_get_variable(var_name16,
1165                                                 &efi_global_variable_guid, NULL,
1166                                                 &size, NULL));
1167                 if (ret != EFI_BUFFER_TOO_SMALL) {
1168                         printf("%2d: %s: (not defined)\n", i + 1, var_name);
1169                         continue;
1170                 }
1171
1172                 data = malloc(size);
1173                 if (!data) {
1174                         ret = CMD_RET_FAILURE;
1175                         goto out;
1176                 }
1177                 ret = EFI_CALL(efi_get_variable(var_name16,
1178                                                 &efi_global_variable_guid, NULL,
1179                                                 &size, data));
1180                 if (ret != EFI_SUCCESS) {
1181                         free(data);
1182                         ret = CMD_RET_FAILURE;
1183                         goto out;
1184                 }
1185
1186                 ret = efi_deserialize_load_option(&lo, data, &size);
1187                 if (ret != EFI_SUCCESS) {
1188                         printf("%ls: invalid load option\n", var_name16);
1189                         ret = CMD_RET_FAILURE;
1190                         goto out;
1191                 }
1192
1193                 label_len16 = u16_strlen(lo.label);
1194                 label_len = utf16_utf8_strnlen(lo.label, label_len16);
1195                 label = malloc(label_len + 1);
1196                 if (!label) {
1197                         free(data);
1198                         ret = CMD_RET_FAILURE;
1199                         goto out;
1200                 }
1201                 p = label;
1202                 utf16_utf8_strncpy(&p, lo.label, label_len16);
1203                 printf("%2d: %s: %s\n", i + 1, var_name, label);
1204                 free(label);
1205
1206                 free(data);
1207         }
1208 out:
1209         free(bootorder);
1210
1211         return ret;
1212 }
1213
1214 /**
1215  * do_efi_boot_next() - manage UEFI BootNext variable
1216  *
1217  * @cmdtp:      Command table
1218  * @flag:       Command flag
1219  * @argc:       Number of arguments
1220  * @argv:       Argument array
1221  * Return:      CMD_RET_SUCCESS on success,
1222  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1223  *
1224  * Implement efidebug "boot next" sub-command.
1225  * Set BootNext variable.
1226  *
1227  *     efidebug boot next <id>
1228  */
1229 static int do_efi_boot_next(struct cmd_tbl *cmdtp, int flag,
1230                             int argc, char *const argv[])
1231 {
1232         u16 bootnext;
1233         efi_uintn_t size;
1234         char *endp;
1235         efi_guid_t guid;
1236         efi_status_t ret;
1237         int r = CMD_RET_SUCCESS;
1238
1239         if (argc != 2)
1240                 return CMD_RET_USAGE;
1241
1242         bootnext = (u16)simple_strtoul(argv[1], &endp, 16);
1243         if (*endp) {
1244                 printf("invalid value: %s\n", argv[1]);
1245                 r = CMD_RET_FAILURE;
1246                 goto out;
1247         }
1248
1249         guid = efi_global_variable_guid;
1250         size = sizeof(u16);
1251         ret = EFI_CALL(efi_set_variable(L"BootNext", &guid,
1252                                         EFI_VARIABLE_NON_VOLATILE |
1253                                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
1254                                         EFI_VARIABLE_RUNTIME_ACCESS,
1255                                         size, &bootnext));
1256         if (ret != EFI_SUCCESS) {
1257                 printf("Cannot set BootNext\n");
1258                 r = CMD_RET_FAILURE;
1259         }
1260 out:
1261         return r;
1262 }
1263
1264 /**
1265  * do_efi_boot_order() - manage UEFI BootOrder variable
1266  *
1267  * @cmdtp:      Command table
1268  * @flag:       Command flag
1269  * @argc:       Number of arguments
1270  * @argv:       Argument array
1271  * Return:      CMD_RET_SUCCESS on success, CMD_RET_RET_FAILURE on failure
1272  *
1273  * Implement efidebug "boot order" sub-command.
1274  * Show order of UEFI load options, or change it in BootOrder variable.
1275  *
1276  *     efidebug boot order [<id> ...]
1277  */
1278 static int do_efi_boot_order(struct cmd_tbl *cmdtp, int flag,
1279                              int argc, char *const argv[])
1280 {
1281         u16 *bootorder = NULL;
1282         efi_uintn_t size;
1283         int id, i;
1284         char *endp;
1285         efi_guid_t guid;
1286         efi_status_t ret;
1287         int r = CMD_RET_SUCCESS;
1288
1289         if (argc == 1)
1290                 return show_efi_boot_order();
1291
1292         argc--;
1293         argv++;
1294
1295         size = argc * sizeof(u16);
1296         bootorder = malloc(size);
1297         if (!bootorder)
1298                 return CMD_RET_FAILURE;
1299
1300         for (i = 0; i < argc; i++) {
1301                 id = (int)simple_strtoul(argv[i], &endp, 16);
1302                 if (*endp != '\0' || id > 0xffff) {
1303                         printf("invalid value: %s\n", argv[i]);
1304                         r = CMD_RET_FAILURE;
1305                         goto out;
1306                 }
1307
1308                 bootorder[i] = (u16)id;
1309         }
1310
1311         guid = efi_global_variable_guid;
1312         ret = EFI_CALL(efi_set_variable(L"BootOrder", &guid,
1313                                         EFI_VARIABLE_NON_VOLATILE |
1314                                         EFI_VARIABLE_BOOTSERVICE_ACCESS |
1315                                         EFI_VARIABLE_RUNTIME_ACCESS,
1316                                         size, bootorder));
1317         if (ret != EFI_SUCCESS) {
1318                 printf("Cannot set BootOrder\n");
1319                 r = CMD_RET_FAILURE;
1320         }
1321 out:
1322         free(bootorder);
1323
1324         return r;
1325 }
1326
1327 static struct cmd_tbl cmd_efidebug_boot_sub[] = {
1328         U_BOOT_CMD_MKENT(add, CONFIG_SYS_MAXARGS, 1, do_efi_boot_add, "", ""),
1329         U_BOOT_CMD_MKENT(rm, CONFIG_SYS_MAXARGS, 1, do_efi_boot_rm, "", ""),
1330         U_BOOT_CMD_MKENT(dump, CONFIG_SYS_MAXARGS, 1, do_efi_boot_dump, "", ""),
1331         U_BOOT_CMD_MKENT(next, CONFIG_SYS_MAXARGS, 1, do_efi_boot_next, "", ""),
1332         U_BOOT_CMD_MKENT(order, CONFIG_SYS_MAXARGS, 1, do_efi_boot_order,
1333                          "", ""),
1334 };
1335
1336 /**
1337  * do_efi_boot_opt() - manage UEFI load options
1338  *
1339  * @cmdtp:      Command table
1340  * @flag:       Command flag
1341  * @argc:       Number of arguments
1342  * @argv:       Argument array
1343  * Return:      CMD_RET_SUCCESS on success,
1344  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1345  *
1346  * Implement efidebug "boot" sub-command.
1347  */
1348 static int do_efi_boot_opt(struct cmd_tbl *cmdtp, int flag,
1349                            int argc, char *const argv[])
1350 {
1351         struct cmd_tbl *cp;
1352
1353         if (argc < 2)
1354                 return CMD_RET_USAGE;
1355
1356         argc--; argv++;
1357
1358         cp = find_cmd_tbl(argv[0], cmd_efidebug_boot_sub,
1359                           ARRAY_SIZE(cmd_efidebug_boot_sub));
1360         if (!cp)
1361                 return CMD_RET_USAGE;
1362
1363         return cp->cmd(cmdtp, flag, argc, argv);
1364 }
1365
1366 /**
1367  * do_efi_test_bootmgr() - run simple bootmgr for test
1368  *
1369  * @cmdtp:      Command table
1370  * @flag:       Command flag
1371  * @argc:       Number of arguments
1372  * @argv:       Argument array
1373  * Return:      CMD_RET_SUCCESS on success,
1374  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1375  *
1376  * Implement efidebug "test bootmgr" sub-command.
1377  * Run simple bootmgr for test.
1378  *
1379  *     efidebug test bootmgr
1380  */
1381 static __maybe_unused int do_efi_test_bootmgr(struct cmd_tbl *cmdtp, int flag,
1382                                               int argc, char * const argv[])
1383 {
1384         efi_handle_t image;
1385         efi_uintn_t exit_data_size = 0;
1386         u16 *exit_data = NULL;
1387         efi_status_t ret;
1388         void *load_options = NULL;
1389
1390         ret = efi_bootmgr_load(&image, &load_options);
1391         printf("efi_bootmgr_load() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1392
1393         /* We call efi_start_image() even if error for test purpose. */
1394         ret = EFI_CALL(efi_start_image(image, &exit_data_size, &exit_data));
1395         printf("efi_start_image() returned: %ld\n", ret & ~EFI_ERROR_MASK);
1396         if (ret && exit_data)
1397                 efi_free_pool(exit_data);
1398
1399         efi_restore_gd();
1400
1401         free(load_options);
1402         return CMD_RET_SUCCESS;
1403 }
1404
1405 static struct cmd_tbl cmd_efidebug_test_sub[] = {
1406 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1407         U_BOOT_CMD_MKENT(bootmgr, CONFIG_SYS_MAXARGS, 1, do_efi_test_bootmgr,
1408                          "", ""),
1409 #endif
1410 };
1411
1412 /**
1413  * do_efi_test() - manage UEFI load options
1414  *
1415  * @cmdtp:      Command table
1416  * @flag:       Command flag
1417  * @argc:       Number of arguments
1418  * @argv:       Argument array
1419  * Return:      CMD_RET_SUCCESS on success,
1420  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1421  *
1422  * Implement efidebug "test" sub-command.
1423  */
1424 static int do_efi_test(struct cmd_tbl *cmdtp, int flag,
1425                        int argc, char * const argv[])
1426 {
1427         struct cmd_tbl *cp;
1428
1429         if (argc < 2)
1430                 return CMD_RET_USAGE;
1431
1432         argc--; argv++;
1433
1434         cp = find_cmd_tbl(argv[0], cmd_efidebug_test_sub,
1435                           ARRAY_SIZE(cmd_efidebug_test_sub));
1436         if (!cp)
1437                 return CMD_RET_USAGE;
1438
1439         return cp->cmd(cmdtp, flag, argc, argv);
1440 }
1441
1442 /**
1443  * do_efi_query_info() - QueryVariableInfo EFI service
1444  *
1445  * @cmdtp:      Command table
1446  * @flag:       Command flag
1447  * @argc:       Number of arguments
1448  * @argv:       Argument array
1449  * Return:      CMD_RET_SUCCESS on success,
1450  *              CMD_RET_USAGE or CMD_RET_FAILURE on failure
1451  *
1452  * Implement efidebug "test" sub-command.
1453  */
1454
1455 static int do_efi_query_info(struct cmd_tbl *cmdtp, int flag,
1456                              int argc, char * const argv[])
1457 {
1458         efi_status_t ret;
1459         u32 attr = 0;
1460         u64 max_variable_storage_size;
1461         u64 remain_variable_storage_size;
1462         u64 max_variable_size;
1463         int i;
1464
1465         for (i = 1; i < argc; i++) {
1466                 if (!strcmp(argv[i], "-bs"))
1467                         attr |= EFI_VARIABLE_BOOTSERVICE_ACCESS;
1468                 else if (!strcmp(argv[i], "-rt"))
1469                         attr |= EFI_VARIABLE_RUNTIME_ACCESS;
1470                 else if (!strcmp(argv[i], "-nv"))
1471                         attr |= EFI_VARIABLE_NON_VOLATILE;
1472                 else if (!strcmp(argv[i], "-at"))
1473                         attr |=
1474                                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS;
1475         }
1476
1477         ret = EFI_CALL(efi_query_variable_info(attr,
1478                                                &max_variable_storage_size,
1479                                                &remain_variable_storage_size,
1480                                                &max_variable_size));
1481         if (ret != EFI_SUCCESS) {
1482                 printf("Error: Cannot query UEFI variables, r = %lu\n",
1483                        ret & ~EFI_ERROR_MASK);
1484                 return CMD_RET_FAILURE;
1485         }
1486
1487         printf("Max storage size %llu\n", max_variable_storage_size);
1488         printf("Remaining storage size %llu\n", remain_variable_storage_size);
1489         printf("Max variable size %llu\n", max_variable_size);
1490
1491         return CMD_RET_SUCCESS;
1492 }
1493
1494 static struct cmd_tbl cmd_efidebug_sub[] = {
1495         U_BOOT_CMD_MKENT(boot, CONFIG_SYS_MAXARGS, 1, do_efi_boot_opt, "", ""),
1496 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1497         U_BOOT_CMD_MKENT(capsule, CONFIG_SYS_MAXARGS, 1, do_efi_capsule,
1498                          "", ""),
1499 #endif
1500         U_BOOT_CMD_MKENT(devices, CONFIG_SYS_MAXARGS, 1, do_efi_show_devices,
1501                          "", ""),
1502         U_BOOT_CMD_MKENT(drivers, CONFIG_SYS_MAXARGS, 1, do_efi_show_drivers,
1503                          "", ""),
1504         U_BOOT_CMD_MKENT(dh, CONFIG_SYS_MAXARGS, 1, do_efi_show_handles,
1505                          "", ""),
1506         U_BOOT_CMD_MKENT(images, CONFIG_SYS_MAXARGS, 1, do_efi_show_images,
1507                          "", ""),
1508         U_BOOT_CMD_MKENT(memmap, CONFIG_SYS_MAXARGS, 1, do_efi_show_memmap,
1509                          "", ""),
1510         U_BOOT_CMD_MKENT(tables, CONFIG_SYS_MAXARGS, 1, do_efi_show_tables,
1511                          "", ""),
1512         U_BOOT_CMD_MKENT(test, CONFIG_SYS_MAXARGS, 1, do_efi_test,
1513                          "", ""),
1514         U_BOOT_CMD_MKENT(query, CONFIG_SYS_MAXARGS, 1, do_efi_query_info,
1515                          "", ""),
1516 };
1517
1518 /**
1519  * do_efidebug() - display and configure UEFI environment
1520  *
1521  * @cmdtp:      Command table
1522  * @flag:       Command flag
1523  * @argc:       Number of arguments
1524  * @argv:       Argument array
1525  * Return:      CMD_RET_SUCCESS on success,
1526  *              CMD_RET_USAGE or CMD_RET_RET_FAILURE on failure
1527  *
1528  * Implement efidebug command which allows us to display and
1529  * configure UEFI environment.
1530  */
1531 static int do_efidebug(struct cmd_tbl *cmdtp, int flag,
1532                        int argc, char *const argv[])
1533 {
1534         struct cmd_tbl *cp;
1535         efi_status_t r;
1536
1537         if (argc < 2)
1538                 return CMD_RET_USAGE;
1539
1540         argc--; argv++;
1541
1542         /* Initialize UEFI drivers */
1543         r = efi_init_obj_list();
1544         if (r != EFI_SUCCESS) {
1545                 printf("Error: Cannot initialize UEFI sub-system, r = %lu\n",
1546                        r & ~EFI_ERROR_MASK);
1547                 return CMD_RET_FAILURE;
1548         }
1549
1550         cp = find_cmd_tbl(argv[0], cmd_efidebug_sub,
1551                           ARRAY_SIZE(cmd_efidebug_sub));
1552         if (!cp)
1553                 return CMD_RET_USAGE;
1554
1555         return cp->cmd(cmdtp, flag, argc, argv);
1556 }
1557
1558 #ifdef CONFIG_SYS_LONGHELP
1559 static char efidebug_help_text[] =
1560         "  - UEFI Shell-like interface to configure UEFI environment\n"
1561         "\n"
1562         "efidebug boot add <bootid> <label> <interface> <devnum>[:<part>] <file path> [<load options>]\n"
1563         "  - set UEFI BootXXXX variable\n"
1564         "    <load options> will be passed to UEFI application\n"
1565         "efidebug boot rm <bootid#1> [<bootid#2> [<bootid#3> [...]]]\n"
1566         "  - delete UEFI BootXXXX variables\n"
1567         "efidebug boot dump\n"
1568         "  - dump all UEFI BootXXXX variables\n"
1569         "efidebug boot next <bootid>\n"
1570         "  - set UEFI BootNext variable\n"
1571         "efidebug boot order [<bootid#1> [<bootid#2> [<bootid#3> [...]]]]\n"
1572         "  - set/show UEFI boot order\n"
1573         "\n"
1574 #ifdef CONFIG_EFI_HAVE_CAPSULE_SUPPORT
1575         "efidebug capsule update [-v] <capsule address>\n"
1576         "  - process a capsule\n"
1577         "efidebug capsule disk-update\n"
1578         "  - update a capsule from disk\n"
1579         "efidebug capsule show <capsule address>\n"
1580         "  - show capsule information\n"
1581         "efidebug capsule result [<capsule result var>]\n"
1582         "  - show a capsule update result\n"
1583         "\n"
1584 #endif
1585         "efidebug devices\n"
1586         "  - show UEFI devices\n"
1587         "efidebug drivers\n"
1588         "  - show UEFI drivers\n"
1589         "efidebug dh\n"
1590         "  - show UEFI handles\n"
1591         "efidebug images\n"
1592         "  - show loaded images\n"
1593         "efidebug memmap\n"
1594         "  - show UEFI memory map\n"
1595         "efidebug tables\n"
1596         "  - show UEFI configuration tables\n"
1597 #ifdef CONFIG_CMD_BOOTEFI_BOOTMGR
1598         "efidebug test bootmgr\n"
1599         "  - run simple bootmgr for test\n"
1600 #endif
1601         "efidebug query [-nv][-bs][-rt][-at]\n"
1602         "  - show size of UEFI variables store\n";
1603 #endif
1604
1605 U_BOOT_CMD(
1606         efidebug, 10, 0, do_efidebug,
1607         "Configure UEFI environment",
1608         efidebug_help_text
1609 );