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 #define LOG_CATEGORY LOGC_EFI
   9
  10 #include <common.h>
  11 #include <efi_loader.h>
  12 #include <efi_variable.h>
  13 #include <log.h>
  14
  15 #define OBJ_LIST_NOT_INITIALIZED 1
  16
  17 efi_status_t efi_obj_list_initialized = OBJ_LIST_NOT_INITIALIZED;
  18
  19 /*
  20  * Allow unaligned memory access.
  21  *
  22  * This routine is overridden by architectures providing this feature.
  23  */
  24 void __weak allow_unaligned(void)
  25 {
  26 }
  27
  28 /**
  29  * efi_init_platform_lang() - define supported languages
  30  *
  31  * Set the PlatformLangCodes and PlatformLang variables.
  32  *
  33  * Return:      status code
  34  */
  35 static efi_status_t efi_init_platform_lang(void)
  36 {
  37         efi_status_t ret;
  38         efi_uintn_t data_size = 0;
  39         char *lang = CONFIG_EFI_PLATFORM_LANG_CODES;
  40         char *pos;
  41
  42         /*
  43          * Variable PlatformLangCodes defines the language codes that the
  44          * machine can support.
  45          */
  46         ret = efi_set_variable_int(L"PlatformLangCodes",
  47                                    &efi_global_variable_guid,
  48                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
  49                                    EFI_VARIABLE_RUNTIME_ACCESS |
  50                                    EFI_VARIABLE_READ_ONLY,
  51                                    sizeof(CONFIG_EFI_PLATFORM_LANG_CODES),
  52                                    CONFIG_EFI_PLATFORM_LANG_CODES, false);
  53         if (ret != EFI_SUCCESS)
  54                 goto out;
  55
  56         /*
  57          * Variable PlatformLang defines the language that the machine has been
  58          * configured for.
  59          */
  60         ret = efi_get_variable_int(L"PlatformLang",
  61                                    &efi_global_variable_guid,
  62                                    NULL, &data_size, &pos, NULL);
  63         if (ret == EFI_BUFFER_TOO_SMALL) {
  64                 /* The variable is already set. Do not change it. */
  65                 ret = EFI_SUCCESS;
  66                 goto out;
  67         }
  68
  69         /*
  70          * The list of supported languages is semicolon separated. Use the first
  71          * language to initialize PlatformLang.
  72          */
  73         pos = strchr(lang, ';');
  74         if (pos)
  75                 *pos = 0;
  76
  77         ret = efi_set_variable_int(L"PlatformLang",
  78                                    &efi_global_variable_guid,
  79                                    EFI_VARIABLE_NON_VOLATILE |
  80                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
  81                                    EFI_VARIABLE_RUNTIME_ACCESS,
  82                                    1 + strlen(lang), lang, false);
  83 out:
  84         if (ret != EFI_SUCCESS)
  85                 printf("EFI: cannot initialize platform language settings\n");
  86         return ret;
  87 }
  88
  89 #ifdef CONFIG_EFI_SECURE_BOOT
  90 /**
  91  * efi_init_secure_boot - initialize secure boot state
  92  *
  93  * Return:      status code
  94  */
  95 static efi_status_t efi_init_secure_boot(void)
  96 {
  97         efi_guid_t signature_types[] = {
  98                 EFI_CERT_SHA256_GUID,
  99                 EFI_CERT_X509_GUID,
 100         };
 101         efi_status_t ret;
 102
 103         ret = efi_set_variable_int(L"SignatureSupport",
 104                                    &efi_global_variable_guid,
 105                                    EFI_VARIABLE_READ_ONLY |
 106                                    EFI_VARIABLE_BOOTSERVICE_ACCESS |
 107                                    EFI_VARIABLE_RUNTIME_ACCESS,
 108                                    sizeof(signature_types),
 109                                    &signature_types, false);
 110         if (ret != EFI_SUCCESS)
 111                 printf("EFI: cannot initialize SignatureSupport variable\n");
 112
 113         return ret;
 114 }
 115 #else
 116 static efi_status_t efi_init_secure_boot(void)
 117 {
 118         return EFI_SUCCESS;
 119 }
 120 #endif /* CONFIG_EFI_SECURE_BOOT */
 121
 122 /**
 123  * efi_init_capsule - initialize capsule update state
 124  *
 125  * Return:      status code
 126  */
 127 static efi_status_t efi_init_capsule(void)
 128 {
 129         efi_status_t ret = EFI_SUCCESS;
 130
 131         if (IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_UPDATE)) {
 132                 ret = efi_set_variable_int(L"CapsuleMax",
 133                                            &efi_guid_capsule_report,
 134                                            EFI_VARIABLE_READ_ONLY |
 135                                            EFI_VARIABLE_BOOTSERVICE_ACCESS |
 136                                            EFI_VARIABLE_RUNTIME_ACCESS,
 137                                            22, L"CapsuleFFFF", false);
 138                 if (ret != EFI_SUCCESS)
 139                         printf("EFI: cannot initialize CapsuleMax variable\n");
 140         }
 141
 142         return ret;
 143 }
 144
 145 /**
 146  * efi_init_os_indications() - indicate supported features for OS requests
 147  *
 148  * Set the OsIndicationsSupported variable.
 149  *
 150  * Return:      status code
 151  */
 152 static efi_status_t efi_init_os_indications(void)
 153 {
 154         u64 os_indications_supported = 0;
 155
 156         if (IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT))
 157                 os_indications_supported |=
 158                         EFI_OS_INDICATIONS_CAPSULE_RESULT_VAR_SUPPORTED;
 159
 160         if (IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK))
 161                 os_indications_supported |=
 162                         EFI_OS_INDICATIONS_FILE_CAPSULE_DELIVERY_SUPPORTED;
 163
 164         if (IS_ENABLED(CONFIG_EFI_CAPSULE_FIRMWARE_MANAGEMENT))
 165                 os_indications_supported |=
 166                         EFI_OS_INDICATIONS_FMP_CAPSULE_SUPPORTED;
 167
 168         return efi_set_variable_int(L"OsIndicationsSupported",
 169                                     &efi_global_variable_guid,
 170                                     EFI_VARIABLE_BOOTSERVICE_ACCESS |
 171                                     EFI_VARIABLE_RUNTIME_ACCESS |
 172                                     EFI_VARIABLE_READ_ONLY,
 173                                     sizeof(os_indications_supported),
 174                                     &os_indications_supported, false);
 175 }
 176
 177
 178 /**
 179  * efi_init_obj_list() - Initialize and populate EFI object list
 180  *
 181  * Return:      status code
 182  */
 183 efi_status_t efi_init_obj_list(void)
 184 {
 185         efi_status_t ret = EFI_SUCCESS;
 186
 187         /* Initialize once only */
 188         if (efi_obj_list_initialized != OBJ_LIST_NOT_INITIALIZED)
 189                 return efi_obj_list_initialized;
 190
 191         /* Allow unaligned memory access */
 192         allow_unaligned();
 193
 194         /* Initialize root node */
 195         ret = efi_root_node_register();
 196         if (ret != EFI_SUCCESS)
 197                 goto out;
 198
 199         ret = efi_console_register();
 200         if (ret != EFI_SUCCESS)
 201                 goto out;
 202
 203 #ifdef CONFIG_PARTITIONS
 204         ret = efi_disk_register();
 205         if (ret != EFI_SUCCESS)
 206                 goto out;
 207 #endif
 208         if (IS_ENABLED(CONFIG_EFI_RNG_PROTOCOL)) {
 209                 ret = efi_rng_register();
 210                 if (ret != EFI_SUCCESS)
 211                         goto out;
 212         }
 213
 214         /* Initialize variable services */
 215         ret = efi_init_variables();
 216         if (ret != EFI_SUCCESS)
 217                 goto out;
 218
 219         /* Define supported languages */
 220         ret = efi_init_platform_lang();
 221         if (ret != EFI_SUCCESS)
 222                 goto out;
 223
 224         /* Indicate supported features */
 225         ret = efi_init_os_indications();
 226         if (ret != EFI_SUCCESS)
 227                 goto out;
 228
 229         /* Initialize system table */
 230         ret = efi_initialize_system_table();
 231         if (ret != EFI_SUCCESS)
 232                 goto out;
 233
 234         if (IS_ENABLED(CONFIG_EFI_ESRT)) {
 235                 ret = efi_esrt_register();
 236                 if (ret != EFI_SUCCESS)
 237                         goto out;
 238         }
 239
 240         if (IS_ENABLED(CONFIG_EFI_TCG2_PROTOCOL)) {
 241                 ret = efi_tcg2_register();
 242                 if (ret != EFI_SUCCESS)
 243                         goto out;
 244
 245                 ret = efi_tcg2_do_initial_measurement();
 246                 if (ret == EFI_SECURITY_VIOLATION)
 247                         goto out;
 248         }
 249
 250         if (IS_ENABLED(CONFIG_EFI_RISCV_BOOT_PROTOCOL)) {
 251                 ret = efi_riscv_register();
 252                 if (ret != EFI_SUCCESS)
 253                         goto out;
 254         }
 255
 256         /* Secure boot */
 257         ret = efi_init_secure_boot();
 258         if (ret != EFI_SUCCESS)
 259                 goto out;
 260
 261         /* Indicate supported runtime services */
 262         ret = efi_init_runtime_supported();
 263         if (ret != EFI_SUCCESS)
 264                 goto out;
 265
 266         /* Initialize EFI driver uclass */
 267         ret = efi_driver_init();
 268         if (ret != EFI_SUCCESS)
 269                 goto out;
 270
 271         if (IS_ENABLED(CONFIG_EFI_HAVE_CAPSULE_SUPPORT)) {
 272                 ret = efi_load_capsule_drivers();
 273                 if (ret != EFI_SUCCESS)
 274                         goto out;
 275         }
 276
 277 #if defined(CONFIG_LCD) || defined(CONFIG_DM_VIDEO)
 278         ret = efi_gop_register();
 279         if (ret != EFI_SUCCESS)
 280                 goto out;
 281 #endif
 282 #ifdef CONFIG_NET
 283         ret = efi_net_register();
 284         if (ret != EFI_SUCCESS)
 285                 goto out;
 286 #endif
 287 #ifdef CONFIG_GENERATE_ACPI_TABLE
 288         ret = efi_acpi_register();
 289         if (ret != EFI_SUCCESS)
 290                 goto out;
 291 #endif
 292 #ifdef CONFIG_GENERATE_SMBIOS_TABLE
 293         ret = efi_smbios_register();
 294         if (ret != EFI_SUCCESS)
 295                 goto out;
 296 #endif
 297         ret = efi_watchdog_register();
 298         if (ret != EFI_SUCCESS)
 299                 goto out;
 300
 301         ret = efi_init_capsule();
 302         if (ret != EFI_SUCCESS)
 303                 goto out;
 304
 305         /* Initialize EFI runtime services */
 306         ret = efi_reset_system_init();
 307         if (ret != EFI_SUCCESS)
 308                 goto out;
 309
 310         /* Execute capsules after reboot */
 311         if (IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK) &&
 312             !IS_ENABLED(CONFIG_EFI_CAPSULE_ON_DISK_EARLY))
 313                 ret = efi_launch_capsules();
 314 out:
 315         efi_obj_list_initialized = ret;
 316         return ret;
 317 }