lib/efi_loader/efi_setup.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  *  EFI setup code
   4  *
   5  *  Copyright (c) 2016-2018 Alexander Graf et al.
   6  */
   7
   8 #include <common.h>
   9 #include <bootm.h>
  10 #include <efi_loader.h>
  11 #include <efi_variable.h>
  12
  13 #define OBJ_LIST_NOT_INITIALIZED 1
  14
  15 efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;
  16
  17 /*
  18  * Allow unaligned memory access.
  19  *
  20  * This routine is overridden by architectures providing this feature.
  21  */
  22 void __weak allow_unaligned(void)
  23 {
  24 }
  25
  26 /**
  27  * efi_init_platform_lang() - define supported languages
  28  *
  29  * Set the PlatformLangCodes and PlatformLang variables.
  30  *
  31  * Return:      status code
  32  */
  33 static efi_status_t efi_init_platform_lang(void)
  34 {
  35         efi_status_t ret;
  36         efi_uintn_t data_size = 0;
  37         char *lang = CONFIG_EFI_PLATFORM_LANG_CODES;
  38         char *pos;
  39
  40         /*
  41          * Variable PlatformLangCodes defines the language codes that the
  42          * machine can support.
  43          */
  44         ret = efi_set_variable_int(L"PlatformLangCodes",
  45                                    &efi_global_variable_guid,
  46                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
  47                                    EFI_VARIABLE_RUNTIME_ACCESS |
  48                                    EFI_VARIABLE_READ_ONLY,
  49                                    sizeof(CONFIG_EFI_PLATFORM_LANG_CODES),
  50                                    CONFIG_EFI_PLATFORM_LANG_CODES, false);
  51         if (ret != EFI_SUCCESS)
  52                 goto out;
  53
  54         /*
  55          * Variable PlatformLang defines the language that the machine has been
  56          * configured for.
  57          */
  58         ret = efi_get_variable_int(L"PlatformLang",
  59                                    &efi_global_variable_guid,
  60                                    NULL, &data_size, &pos, NULL);
  61         if (ret == EFI_BUFFER_TOO_SMALL) {
  62                 /* The variable is already set. Do not change it. */
  63                 ret = EFI_SUCCESS;
  64                 goto out;
  65         }
  66
  67         /*
  68          * The list of supported languages is semicolon separated. Use the first
  69          * language to initialize PlatformLang.
  70          */
  71         pos = strchr(lang, ';');
  72         if (pos)
  73                 *pos = 0;
  74
  75         ret = efi_set_variable_int(L"PlatformLang",
  76                                    &efi_global_variable_guid,
  77                                    EFI_VARIABLE_NON_VOLATILE |
  78                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
  79                                    EFI_VARIABLE_RUNTIME_ACCESS,
  80                                    1 + strlen(lang), lang, false);
  81 out:
  82         if (ret != EFI_SUCCESS)
  83                 printf("EFI: cannot initialize platform language settings\n");
  84         return ret;
  85 }
  86
  87 #ifdef CONFIG_EFI_SECURE_BOOT
  88 /**
  89  * efi_init_secure_boot - initialize secure boot state
  90  *
  91  * Return:      status code
  92  */
  93 static efi_status_t efi_init_secure_boot(void)
  94 {
  95         efi_guid_t signature_types[] = {
  96                 EFI_CERT_SHA256_GUID,
  97                 EFI_CERT_X509_GUID,
  98         };
  99         efi_status_t ret;
 100
 101         ret = efi_set_variable_int(L"SignatureSupport",
 102                                    &efi_global_variable_guid,
 103                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
 104                                    EFI_VARIABLE_RUNTIME_ACCESS |
 105                                    EFI_VARIABLE_READ_ONLY,
 106                                    sizeof(signature_types),
 107                                    &signature_types, false);
 108         if (ret != EFI_SUCCESS)
 109                 printf("EFI: cannot initialize SignatureSupport variable\n");
 110
 111         return ret;
 112 }
 113 #else
 114 static efi_status_t efi_init_secure_boot(void)
 115 {
 116         return EFI_SUCCESS;
 117 }
 118 #endif /* CONFIG_EFI_SECURE_BOOT */
 119
 120 /**
 121  * efi_init_obj_list() - Initialize and populate EFI object list
 122  *
 123  * Return:      status code
 124  */
 125 efi_status_t efi_init_obj_list(void)
 126 {
 127         u64 os_indications_supported = 0; /* None */
 128         efi_status_t ret = EFI_SUCCESS;
 129
 130         /* Initialize once only */
 131         if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
 132                 return efi_obj_list_initialized;
 133
 134         /* Allow unaligned memory access */
 135         allow_unaligned();
 136
 137         /* On ARM switch from EL3 or secure mode to EL2 or non-secure mode */
 138         switch_to_non_secure_mode();
 139
 140         /* Initialize root node */
 141         ret = efi_root_node_register();
 142         if (ret != EFI_SUCCESS)
 143                 goto out;
 144
 145         ret = efi_console_register();
 146         if (ret != EFI_SUCCESS)
 147                 goto out;
 148
 149 #ifdef CONFIG_PARTITIONS
 150         ret = efi_disk_register();
 151         if (ret != EFI_SUCCESS)
 152                 goto out;
 153 #endif
 154         if (IS_ENABLED(CONFIG_EFI_RNG_PROTOCOL)) {
 155                 ret = efi_rng_register();
 156                 if (ret != EFI_SUCCESS)
 157                         goto out;
 158         }
 159
 160         if (IS_ENABLED(CONFIG_EFI_TCG2_PROTOCOL)) {
 161                 ret = efi_tcg2_register();
 162                 if (ret != EFI_SUCCESS)
 163                         goto out;
 164         }
 165
 166         /* Initialize variable services */
 167         ret = efi_init_variables();
 168         if (ret != EFI_SUCCESS)
 169                 goto out;
 170
 171         /* Define supported languages */
 172         ret = efi_init_platform_lang();
 173         if (ret != EFI_SUCCESS)
 174                 goto out;
 175
 176         /* Indicate supported features */
 177         ret = efi_set_variable_int(L"OsIndicationsSupported",
 178                                    &efi_global_variable_guid,
 179                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
 180                                    EFI_VARIABLE_RUNTIME_ACCESS |
 181                                    EFI_VARIABLE_READ_ONLY,
 182                                    sizeof(os_indications_supported),
 183                                    &os_indications_supported, false);
 184         if (ret != EFI_SUCCESS)
 185                 goto out;
 186
 187         /* Initialize system table */
 188         ret = efi_initialize_system_table();
 189         if (ret != EFI_SUCCESS)
 190                 goto out;
 191
 192         /* Secure boot */
 193         ret = efi_init_secure_boot();
 194         if (ret != EFI_SUCCESS)
 195                 goto out;
 196
 197         /* Indicate supported runtime services */
 198         ret = efi_init_runtime_supported();
 199         if (ret != EFI_SUCCESS)
 200                 goto out;
 201
 202         /* Initialize EFI driver uclass */
 203         ret = efi_driver_init();
 204         if (ret != EFI_SUCCESS)
 205                 goto out;
 206
 207 #if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO)
 208         ret = efi_gop_register();
 209         if (ret != EFI_SUCCESS)
 210                 goto out;
 211 #endif
 212 #ifdef CONFIG_EFI_LOAD_FILE2_INITRD
 213         ret = efi_initrd_register();
 214         if (ret != EFI_SUCCESS)
 215                 goto out;
 216 #endif
 217 #ifdef CONFIG_NET
 218         ret = efi_net_register();
 219         if (ret != EFI_SUCCESS)
 220                 goto out;
 221 #endif
 222 #ifdef CONFIG_GENERATE_ACPI_TABLE
 223         ret = efi_acpi_register();
 224         if (ret != EFI_SUCCESS)
 225                 goto out;
 226 #endif
 227 #ifdef CONFIG_GENERATE_SMBIOS_TABLE
 228         ret = efi_smbios_register();
 229         if (ret != EFI_SUCCESS)
 230                 goto out;
 231 #endif
 232         ret = efi_watchdog_register();
 233         if (ret != EFI_SUCCESS)
 234                 goto out;
 235
 236         /* Initialize EFI runtime services */
 237         ret = efi_reset_system_init();
 238         if (ret != EFI_SUCCESS)
 239                 goto out;
 240
 241 out:
 242         efi_obj_list_initialized = ret;
 243         return ret;
 244 }