Back to home page

OSCL-LXR
 
 

     

0001 /* SPDX-License-Identifier: GPL-2.0 */
0002 #ifndef _LINUX_EFI_H
0003 #define _LINUX_EFI_H
0004 
0005 /*
0006  * Extensible Firmware Interface
0007  * Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999
0008  *
0009  * Copyright (C) 1999 VA Linux Systems
0010  * Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
0011  * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
0012  *  David Mosberger-Tang <davidm@hpl.hp.com>
0013  *  Stephane Eranian <eranian@hpl.hp.com>
0014  */
0015 #include <linux/init.h>
0016 #include <linux/string.h>
0017 #include <linux/time.h>
0018 #include <linux/types.h>
0019 #include <linux/proc_fs.h>
0020 #include <linux/rtc.h>
0021 #include <linux/ioport.h>
0022 #include <linux/pfn.h>
0023 #include <linux/pstore.h>
0024 #include <linux/range.h>
0025 #include <linux/reboot.h>
0026 #include <linux/uuid.h>
0027 #include <linux/screen_info.h>
0028 
0029 #include <asm/page.h>
0030 
0031 #define EFI_SUCCESS     0
0032 #define EFI_LOAD_ERROR      ( 1 | (1UL << (BITS_PER_LONG-1)))
0033 #define EFI_INVALID_PARAMETER   ( 2 | (1UL << (BITS_PER_LONG-1)))
0034 #define EFI_UNSUPPORTED     ( 3 | (1UL << (BITS_PER_LONG-1)))
0035 #define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))
0036 #define EFI_BUFFER_TOO_SMALL    ( 5 | (1UL << (BITS_PER_LONG-1)))
0037 #define EFI_NOT_READY       ( 6 | (1UL << (BITS_PER_LONG-1)))
0038 #define EFI_DEVICE_ERROR    ( 7 | (1UL << (BITS_PER_LONG-1)))
0039 #define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))
0040 #define EFI_OUT_OF_RESOURCES    ( 9 | (1UL << (BITS_PER_LONG-1)))
0041 #define EFI_NOT_FOUND       (14 | (1UL << (BITS_PER_LONG-1)))
0042 #define EFI_TIMEOUT     (18 | (1UL << (BITS_PER_LONG-1)))
0043 #define EFI_ABORTED     (21 | (1UL << (BITS_PER_LONG-1)))
0044 #define EFI_SECURITY_VIOLATION  (26 | (1UL << (BITS_PER_LONG-1)))
0045 
0046 typedef unsigned long efi_status_t;
0047 typedef u8 efi_bool_t;
0048 typedef u16 efi_char16_t;       /* UNICODE character */
0049 typedef u64 efi_physical_addr_t;
0050 typedef void *efi_handle_t;
0051 
0052 #if defined(CONFIG_X86_64)
0053 #define __efiapi __attribute__((ms_abi))
0054 #elif defined(CONFIG_X86_32)
0055 #define __efiapi __attribute__((regparm(0)))
0056 #else
0057 #define __efiapi
0058 #endif
0059 
0060 /*
0061  * The UEFI spec and EDK2 reference implementation both define EFI_GUID as
0062  * struct { u32 a; u16; b; u16 c; u8 d[8]; }; and so the implied alignment
0063  * is 32 bits not 8 bits like our guid_t. In some cases (i.e., on 32-bit ARM),
0064  * this means that firmware services invoked by the kernel may assume that
0065  * efi_guid_t* arguments are 32-bit aligned, and use memory accessors that
0066  * do not tolerate misalignment. So let's set the minimum alignment to 32 bits.
0067  *
0068  * Note that the UEFI spec as well as some comments in the EDK2 code base
0069  * suggest that EFI_GUID should be 64-bit aligned, but this appears to be
0070  * a mistake, given that no code seems to exist that actually enforces that
0071  * or relies on it.
0072  */
0073 typedef guid_t efi_guid_t __aligned(__alignof__(u32));
0074 
0075 #define EFI_GUID(a, b, c, d...) (efi_guid_t){ {                 \
0076     (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff,  \
0077     (b) & 0xff, ((b) >> 8) & 0xff,                      \
0078     (c) & 0xff, ((c) >> 8) & 0xff, d } }
0079 
0080 /*
0081  * Generic EFI table header
0082  */
0083 typedef struct {
0084     u64 signature;
0085     u32 revision;
0086     u32 headersize;
0087     u32 crc32;
0088     u32 reserved;
0089 } efi_table_hdr_t;
0090 
0091 /*
0092  * Memory map descriptor:
0093  */
0094 
0095 /* Memory types: */
0096 #define EFI_RESERVED_TYPE        0
0097 #define EFI_LOADER_CODE          1
0098 #define EFI_LOADER_DATA          2
0099 #define EFI_BOOT_SERVICES_CODE       3
0100 #define EFI_BOOT_SERVICES_DATA       4
0101 #define EFI_RUNTIME_SERVICES_CODE    5
0102 #define EFI_RUNTIME_SERVICES_DATA    6
0103 #define EFI_CONVENTIONAL_MEMORY      7
0104 #define EFI_UNUSABLE_MEMORY      8
0105 #define EFI_ACPI_RECLAIM_MEMORY      9
0106 #define EFI_ACPI_MEMORY_NVS     10
0107 #define EFI_MEMORY_MAPPED_IO        11
0108 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
0109 #define EFI_PAL_CODE            13
0110 #define EFI_PERSISTENT_MEMORY       14
0111 #define EFI_MAX_MEMORY_TYPE     15
0112 
0113 /* Attribute values: */
0114 #define EFI_MEMORY_UC       ((u64)0x0000000000000001ULL)    /* uncached */
0115 #define EFI_MEMORY_WC       ((u64)0x0000000000000002ULL)    /* write-coalescing */
0116 #define EFI_MEMORY_WT       ((u64)0x0000000000000004ULL)    /* write-through */
0117 #define EFI_MEMORY_WB       ((u64)0x0000000000000008ULL)    /* write-back */
0118 #define EFI_MEMORY_UCE      ((u64)0x0000000000000010ULL)    /* uncached, exported */
0119 #define EFI_MEMORY_WP       ((u64)0x0000000000001000ULL)    /* write-protect */
0120 #define EFI_MEMORY_RP       ((u64)0x0000000000002000ULL)    /* read-protect */
0121 #define EFI_MEMORY_XP       ((u64)0x0000000000004000ULL)    /* execute-protect */
0122 #define EFI_MEMORY_NV       ((u64)0x0000000000008000ULL)    /* non-volatile */
0123 #define EFI_MEMORY_MORE_RELIABLE \
0124                 ((u64)0x0000000000010000ULL)    /* higher reliability */
0125 #define EFI_MEMORY_RO       ((u64)0x0000000000020000ULL)    /* read-only */
0126 #define EFI_MEMORY_SP       ((u64)0x0000000000040000ULL)    /* soft reserved */
0127 #define EFI_MEMORY_CPU_CRYPTO   ((u64)0x0000000000080000ULL)    /* supports encryption */
0128 #define EFI_MEMORY_RUNTIME  ((u64)0x8000000000000000ULL)    /* range requires runtime mapping */
0129 #define EFI_MEMORY_DESCRIPTOR_VERSION   1
0130 
0131 #define EFI_PAGE_SHIFT      12
0132 #define EFI_PAGE_SIZE       (1UL << EFI_PAGE_SHIFT)
0133 #define EFI_PAGES_MAX       (U64_MAX >> EFI_PAGE_SHIFT)
0134 
0135 typedef struct {
0136     u32 type;
0137     u32 pad;
0138     u64 phys_addr;
0139     u64 virt_addr;
0140     u64 num_pages;
0141     u64 attribute;
0142 } efi_memory_desc_t;
0143 
0144 typedef struct {
0145     efi_guid_t guid;
0146     u32 headersize;
0147     u32 flags;
0148     u32 imagesize;
0149 } efi_capsule_header_t;
0150 
0151 /* EFI_FIRMWARE_MANAGEMENT_CAPSULE_HEADER */
0152 struct efi_manage_capsule_header {
0153     u32 ver;
0154     u16 emb_drv_cnt;
0155     u16 payload_cnt;
0156     /*
0157      * Variable-size array of the size given by the sum of
0158      * emb_drv_cnt and payload_cnt.
0159      */
0160     u64 offset_list[];
0161 } __packed;
0162 
0163 /* EFI_FIRMWARE_MANAGEMENT_CAPSULE_IMAGE_HEADER */
0164 struct efi_manage_capsule_image_header {
0165     u32 ver;
0166     efi_guid_t image_type_id;
0167     u8 image_index;
0168     u8 reserved_bytes[3];
0169     u32 image_size;
0170     u32 vendor_code_size;
0171     /* hw_ins was introduced in version 2 */
0172     u64 hw_ins;
0173     /* capsule_support was introduced in version 3 */
0174     u64 capsule_support;
0175 } __packed;
0176 
0177 /* WIN_CERTIFICATE */
0178 struct win_cert {
0179     u32 len;
0180     u16 rev;
0181     u16 cert_type;
0182 };
0183 
0184 /* WIN_CERTIFICATE_UEFI_GUID */
0185 struct win_cert_uefi_guid {
0186     struct win_cert hdr;
0187     efi_guid_t cert_type;
0188     u8 cert_data[];
0189 };
0190 
0191 /* EFI_FIRMWARE_IMAGE_AUTHENTICATION */
0192 struct efi_image_auth {
0193     u64 mon_count;
0194     struct win_cert_uefi_guid auth_info;
0195 };
0196 
0197 /*
0198  * EFI capsule flags
0199  */
0200 #define EFI_CAPSULE_PERSIST_ACROSS_RESET    0x00010000
0201 #define EFI_CAPSULE_POPULATE_SYSTEM_TABLE   0x00020000
0202 #define EFI_CAPSULE_INITIATE_RESET      0x00040000
0203 
0204 struct capsule_info {
0205     efi_capsule_header_t    header;
0206     efi_capsule_header_t    *capsule;
0207     int         reset_type;
0208     long            index;
0209     size_t          count;
0210     size_t          total_size;
0211     struct page     **pages;
0212     phys_addr_t     *phys;
0213     size_t          page_bytes_remain;
0214 };
0215 
0216 int efi_capsule_setup_info(struct capsule_info *cap_info, void *kbuff,
0217                            size_t hdr_bytes);
0218 int __efi_capsule_setup_info(struct capsule_info *cap_info);
0219 
0220 /*
0221  * Types and defines for Time Services
0222  */
0223 #define EFI_TIME_ADJUST_DAYLIGHT 0x1
0224 #define EFI_TIME_IN_DAYLIGHT     0x2
0225 #define EFI_UNSPECIFIED_TIMEZONE 0x07ff
0226 
0227 typedef struct {
0228     u16 year;
0229     u8 month;
0230     u8 day;
0231     u8 hour;
0232     u8 minute;
0233     u8 second;
0234     u8 pad1;
0235     u32 nanosecond;
0236     s16 timezone;
0237     u8 daylight;
0238     u8 pad2;
0239 } efi_time_t;
0240 
0241 typedef struct {
0242     u32 resolution;
0243     u32 accuracy;
0244     u8 sets_to_zero;
0245 } efi_time_cap_t;
0246 
0247 typedef union efi_boot_services efi_boot_services_t;
0248 
0249 /*
0250  * Types and defines for EFI ResetSystem
0251  */
0252 #define EFI_RESET_COLD 0
0253 #define EFI_RESET_WARM 1
0254 #define EFI_RESET_SHUTDOWN 2
0255 
0256 /*
0257  * EFI Runtime Services table
0258  */
0259 #define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)
0260 #define EFI_RUNTIME_SERVICES_REVISION  0x00010000
0261 
0262 typedef struct {
0263     efi_table_hdr_t hdr;
0264     u32 get_time;
0265     u32 set_time;
0266     u32 get_wakeup_time;
0267     u32 set_wakeup_time;
0268     u32 set_virtual_address_map;
0269     u32 convert_pointer;
0270     u32 get_variable;
0271     u32 get_next_variable;
0272     u32 set_variable;
0273     u32 get_next_high_mono_count;
0274     u32 reset_system;
0275     u32 update_capsule;
0276     u32 query_capsule_caps;
0277     u32 query_variable_info;
0278 } efi_runtime_services_32_t;
0279 
0280 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
0281 typedef efi_status_t efi_set_time_t (efi_time_t *tm);
0282 typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
0283                         efi_time_t *tm);
0284 typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
0285 typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
0286                      unsigned long *data_size, void *data);
0287 typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
0288                           efi_guid_t *vendor);
0289 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 
0290                      u32 attr, unsigned long data_size,
0291                      void *data);
0292 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
0293 typedef void efi_reset_system_t (int reset_type, efi_status_t status,
0294                  unsigned long data_size, efi_char16_t *data);
0295 typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
0296                         unsigned long descriptor_size,
0297                         u32 descriptor_version,
0298                         efi_memory_desc_t *virtual_map);
0299 typedef efi_status_t efi_query_variable_info_t(u32 attr,
0300                            u64 *storage_space,
0301                            u64 *remaining_space,
0302                            u64 *max_variable_size);
0303 typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
0304                       unsigned long count,
0305                       unsigned long sg_list);
0306 typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
0307                           unsigned long count,
0308                           u64 *max_size,
0309                           int *reset_type);
0310 typedef efi_status_t efi_query_variable_store_t(u32 attributes,
0311                         unsigned long size,
0312                         bool nonblocking);
0313 
0314 typedef union {
0315     struct {
0316         efi_table_hdr_t             hdr;
0317         efi_get_time_t __efiapi         *get_time;
0318         efi_set_time_t __efiapi         *set_time;
0319         efi_get_wakeup_time_t __efiapi      *get_wakeup_time;
0320         efi_set_wakeup_time_t __efiapi      *set_wakeup_time;
0321         efi_set_virtual_address_map_t __efiapi  *set_virtual_address_map;
0322         void                    *convert_pointer;
0323         efi_get_variable_t __efiapi     *get_variable;
0324         efi_get_next_variable_t __efiapi    *get_next_variable;
0325         efi_set_variable_t __efiapi     *set_variable;
0326         efi_get_next_high_mono_count_t __efiapi *get_next_high_mono_count;
0327         efi_reset_system_t __efiapi     *reset_system;
0328         efi_update_capsule_t __efiapi       *update_capsule;
0329         efi_query_capsule_caps_t __efiapi   *query_capsule_caps;
0330         efi_query_variable_info_t __efiapi  *query_variable_info;
0331     };
0332     efi_runtime_services_32_t mixed_mode;
0333 } efi_runtime_services_t;
0334 
0335 void efi_native_runtime_setup(void);
0336 
0337 /*
0338  * EFI Configuration Table and GUID definitions
0339  *
0340  * These are all defined in a single line to make them easier to
0341  * grep for and to see them at a glance - while still having a
0342  * similar structure to the definitions in the spec.
0343  *
0344  * Here's how they are structured:
0345  *
0346  * GUID: 12345678-1234-1234-1234-123456789012
0347  * Spec:
0348  *      #define EFI_SOME_PROTOCOL_GUID \
0349  *        {0x12345678,0x1234,0x1234,\
0350  *          {0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x12}}
0351  * Here:
0352  *  #define SOME_PROTOCOL_GUID      EFI_GUID(0x12345678, 0x1234, 0x1234,  0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12)
0353  *                  ^ tabs                      ^extra space
0354  *
0355  * Note that the 'extra space' separates the values at the same place
0356  * where the UEFI SPEC breaks the line.
0357  */
0358 #define NULL_GUID               EFI_GUID(0x00000000, 0x0000, 0x0000,  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00)
0359 #define MPS_TABLE_GUID              EFI_GUID(0xeb9d2d2f, 0x2d88, 0x11d3,  0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
0360 #define ACPI_TABLE_GUID             EFI_GUID(0xeb9d2d30, 0x2d88, 0x11d3,  0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
0361 #define ACPI_20_TABLE_GUID          EFI_GUID(0x8868e871, 0xe4f1, 0x11d3,  0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81)
0362 #define SMBIOS_TABLE_GUID           EFI_GUID(0xeb9d2d31, 0x2d88, 0x11d3,  0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
0363 #define SMBIOS3_TABLE_GUID          EFI_GUID(0xf2fd1544, 0x9794, 0x4a2c,  0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94)
0364 #define SAL_SYSTEM_TABLE_GUID           EFI_GUID(0xeb9d2d32, 0x2d88, 0x11d3,  0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
0365 #define HCDP_TABLE_GUID             EFI_GUID(0xf951938d, 0x620b, 0x42ef,  0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98)
0366 #define UGA_IO_PROTOCOL_GUID            EFI_GUID(0x61a4d49e, 0x6f68, 0x4f1b,  0xb9, 0x22, 0xa8, 0x6e, 0xed, 0x0b, 0x07, 0xa2)
0367 #define EFI_GLOBAL_VARIABLE_GUID        EFI_GUID(0x8be4df61, 0x93ca, 0x11d2,  0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c)
0368 #define UV_SYSTEM_TABLE_GUID            EFI_GUID(0x3b13a7d4, 0x633e, 0x11dd,  0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93)
0369 #define LINUX_EFI_CRASH_GUID            EFI_GUID(0xcfc8fc79, 0xbe2e, 0x4ddc,  0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0)
0370 #define LOADED_IMAGE_PROTOCOL_GUID      EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2,  0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
0371 #define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID   EFI_GUID(0x9042a9de, 0x23dc, 0x4a38,  0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a)
0372 #define EFI_UGA_PROTOCOL_GUID           EFI_GUID(0x982c298b, 0xf4fa, 0x41cb,  0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39)
0373 #define EFI_PCI_IO_PROTOCOL_GUID        EFI_GUID(0x4cf5b200, 0x68b8, 0x4ca5,  0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a)
0374 #define EFI_FILE_INFO_ID            EFI_GUID(0x09576e92, 0x6d3f, 0x11d2,  0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
0375 #define EFI_SYSTEM_RESOURCE_TABLE_GUID      EFI_GUID(0xb122a263, 0x3661, 0x4f68,  0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80)
0376 #define EFI_FILE_SYSTEM_GUID            EFI_GUID(0x964e5b22, 0x6459, 0x11d2,  0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
0377 #define DEVICE_TREE_GUID            EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5,  0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0)
0378 #define EFI_PROPERTIES_TABLE_GUID       EFI_GUID(0x880aaca3, 0x4adc, 0x4a04,  0x90, 0x79, 0xb7, 0x47, 0x34, 0x08, 0x25, 0xe5)
0379 #define EFI_RNG_PROTOCOL_GUID           EFI_GUID(0x3152bca5, 0xeade, 0x433d,  0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44)
0380 #define EFI_RNG_ALGORITHM_RAW           EFI_GUID(0xe43176d7, 0xb6e8, 0x4827,  0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61)
0381 #define EFI_MEMORY_ATTRIBUTES_TABLE_GUID    EFI_GUID(0xdcfa911d, 0x26eb, 0x469f,  0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20)
0382 #define EFI_CONSOLE_OUT_DEVICE_GUID     EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4,  0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d)
0383 #define APPLE_PROPERTIES_PROTOCOL_GUID      EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb,  0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0)
0384 #define EFI_TCG2_PROTOCOL_GUID          EFI_GUID(0x607f766c, 0x7455, 0x42be,  0x93, 0x0b, 0xe4, 0xd7, 0x6d, 0xb2, 0x72, 0x0f)
0385 #define EFI_LOAD_FILE_PROTOCOL_GUID     EFI_GUID(0x56ec3091, 0x954c, 0x11d2,  0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b)
0386 #define EFI_LOAD_FILE2_PROTOCOL_GUID        EFI_GUID(0x4006c0c1, 0xfcb3, 0x403e,  0x99, 0x6d, 0x4a, 0x6c, 0x87, 0x24, 0xe0, 0x6d)
0387 #define EFI_RT_PROPERTIES_TABLE_GUID        EFI_GUID(0xeb66918a, 0x7eef, 0x402a,  0x84, 0x2e, 0x93, 0x1d, 0x21, 0xc3, 0x8a, 0xe9)
0388 #define EFI_DXE_SERVICES_TABLE_GUID     EFI_GUID(0x05ad34ba, 0x6f02, 0x4214,  0x95, 0x2e, 0x4d, 0xa0, 0x39, 0x8e, 0x2b, 0xb9)
0389 
0390 #define EFI_IMAGE_SECURITY_DATABASE_GUID    EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596,  0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f)
0391 #define EFI_SHIM_LOCK_GUID          EFI_GUID(0x605dab50, 0xe046, 0x4300,  0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23)
0392 
0393 #define EFI_CERT_SHA256_GUID            EFI_GUID(0xc1c41626, 0x504c, 0x4092, 0xac, 0xa9, 0x41, 0xf9, 0x36, 0x93, 0x43, 0x28)
0394 #define EFI_CERT_X509_GUID          EFI_GUID(0xa5c059a1, 0x94e4, 0x4aa7, 0x87, 0xb5, 0xab, 0x15, 0x5c, 0x2b, 0xf0, 0x72)
0395 #define EFI_CERT_X509_SHA256_GUID       EFI_GUID(0x3bd2a492, 0x96c0, 0x4079, 0xb4, 0x20, 0xfc, 0xf9, 0x8e, 0xf1, 0x03, 0xed)
0396 #define EFI_CC_BLOB_GUID            EFI_GUID(0x067b1f5f, 0xcf26, 0x44c5, 0x85, 0x54, 0x93, 0xd7, 0x77, 0x91, 0x2d, 0x42)
0397 
0398 /*
0399  * This GUID is used to pass to the kernel proper the struct screen_info
0400  * structure that was populated by the stub based on the GOP protocol instance
0401  * associated with ConOut
0402  */
0403 #define LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID    EFI_GUID(0xe03fc20a, 0x85dc, 0x406e,  0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95)
0404 #define LINUX_EFI_ARM_CPU_STATE_TABLE_GUID  EFI_GUID(0xef79e4aa, 0x3c3d, 0x4989,  0xb9, 0x02, 0x07, 0xa9, 0x43, 0xe5, 0x50, 0xd2)
0405 #define LINUX_EFI_LOADER_ENTRY_GUID     EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf,  0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)
0406 #define LINUX_EFI_RANDOM_SEED_TABLE_GUID    EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2,  0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)
0407 #define LINUX_EFI_TPM_EVENT_LOG_GUID        EFI_GUID(0xb7799cb0, 0xeca2, 0x4943,  0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)
0408 #define LINUX_EFI_TPM_FINAL_LOG_GUID        EFI_GUID(0x1e2ed096, 0x30e2, 0x4254,  0xbd, 0x89, 0x86, 0x3b, 0xbe, 0xf8, 0x23, 0x25)
0409 #define LINUX_EFI_MEMRESERVE_TABLE_GUID     EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5,  0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)
0410 #define LINUX_EFI_INITRD_MEDIA_GUID     EFI_GUID(0x5568e427, 0x68fc, 0x4f3d,  0xac, 0x74, 0xca, 0x55, 0x52, 0x31, 0xcc, 0x68)
0411 #define LINUX_EFI_MOK_VARIABLE_TABLE_GUID   EFI_GUID(0xc451ed2b, 0x9694, 0x45d3,  0xba, 0xba, 0xed, 0x9f, 0x89, 0x88, 0xa3, 0x89)
0412 #define LINUX_EFI_COCO_SECRET_AREA_GUID     EFI_GUID(0xadf956ad, 0xe98c, 0x484c,  0xae, 0x11, 0xb5, 0x1c, 0x7d, 0x33, 0x64, 0x47)
0413 
0414 #define RISCV_EFI_BOOT_PROTOCOL_GUID        EFI_GUID(0xccd15fec, 0x6f73, 0x4eec,  0x83, 0x95, 0x3e, 0x69, 0xe4, 0xb9, 0x40, 0xbf)
0415 
0416 /*
0417  * This GUID may be installed onto the kernel image's handle as a NULL protocol
0418  * to signal to the stub that the placement of the image should be respected,
0419  * and moving the image in physical memory is undesirable. To ensure
0420  * compatibility with 64k pages kernels with virtually mapped stacks, and to
0421  * avoid defeating physical randomization, this protocol should only be
0422  * installed if the image was placed at a randomized 128k aligned address in
0423  * memory.
0424  */
0425 #define LINUX_EFI_LOADED_IMAGE_FIXED_GUID   EFI_GUID(0xf5a37b6d, 0x3344, 0x42a5,  0xb6, 0xbb, 0x97, 0x86, 0x48, 0xc1, 0x89, 0x0a)
0426 
0427 /* OEM GUIDs */
0428 #define DELLEMC_EFI_RCI2_TABLE_GUID     EFI_GUID(0x2d9f28a2, 0xa886, 0x456a,  0x97, 0xa8, 0xf1, 0x1e, 0xf2, 0x4f, 0xf4, 0x55)
0429 #define AMD_SEV_MEM_ENCRYPT_GUID        EFI_GUID(0x0cf29b71, 0x9e51, 0x433a,  0xa3, 0xb7, 0x81, 0xf3, 0xab, 0x16, 0xb8, 0x75)
0430 
0431 typedef struct {
0432     efi_guid_t guid;
0433     u64 table;
0434 } efi_config_table_64_t;
0435 
0436 typedef struct {
0437     efi_guid_t guid;
0438     u32 table;
0439 } efi_config_table_32_t;
0440 
0441 typedef union {
0442     struct {
0443         efi_guid_t guid;
0444         void *table;
0445     };
0446     efi_config_table_32_t mixed_mode;
0447 } efi_config_table_t;
0448 
0449 typedef struct {
0450     efi_guid_t guid;
0451     unsigned long *ptr;
0452     const char name[16];
0453 } efi_config_table_type_t;
0454 
0455 #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
0456 #define EFI_DXE_SERVICES_TABLE_SIGNATURE ((u64)0x565245535f455844ULL)
0457 
0458 #define EFI_2_30_SYSTEM_TABLE_REVISION  ((2 << 16) | (30))
0459 #define EFI_2_20_SYSTEM_TABLE_REVISION  ((2 << 16) | (20))
0460 #define EFI_2_10_SYSTEM_TABLE_REVISION  ((2 << 16) | (10))
0461 #define EFI_2_00_SYSTEM_TABLE_REVISION  ((2 << 16) | (00))
0462 #define EFI_1_10_SYSTEM_TABLE_REVISION  ((1 << 16) | (10))
0463 #define EFI_1_02_SYSTEM_TABLE_REVISION  ((1 << 16) | (02))
0464 
0465 typedef struct {
0466     efi_table_hdr_t hdr;
0467     u64 fw_vendor;  /* physical addr of CHAR16 vendor string */
0468     u32 fw_revision;
0469     u32 __pad1;
0470     u64 con_in_handle;
0471     u64 con_in;
0472     u64 con_out_handle;
0473     u64 con_out;
0474     u64 stderr_handle;
0475     u64 stderr;
0476     u64 runtime;
0477     u64 boottime;
0478     u32 nr_tables;
0479     u32 __pad2;
0480     u64 tables;
0481 } efi_system_table_64_t;
0482 
0483 typedef struct {
0484     efi_table_hdr_t hdr;
0485     u32 fw_vendor;  /* physical addr of CHAR16 vendor string */
0486     u32 fw_revision;
0487     u32 con_in_handle;
0488     u32 con_in;
0489     u32 con_out_handle;
0490     u32 con_out;
0491     u32 stderr_handle;
0492     u32 stderr;
0493     u32 runtime;
0494     u32 boottime;
0495     u32 nr_tables;
0496     u32 tables;
0497 } efi_system_table_32_t;
0498 
0499 typedef union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;
0500 typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;
0501 
0502 typedef union {
0503     struct {
0504         efi_table_hdr_t hdr;
0505         unsigned long fw_vendor;    /* physical addr of CHAR16 vendor string */
0506         u32 fw_revision;
0507         unsigned long con_in_handle;
0508         efi_simple_text_input_protocol_t *con_in;
0509         unsigned long con_out_handle;
0510         efi_simple_text_output_protocol_t *con_out;
0511         unsigned long stderr_handle;
0512         unsigned long stderr;
0513         efi_runtime_services_t *runtime;
0514         efi_boot_services_t *boottime;
0515         unsigned long nr_tables;
0516         unsigned long tables;
0517     };
0518     efi_system_table_32_t mixed_mode;
0519 } efi_system_table_t;
0520 
0521 /*
0522  * Architecture independent structure for describing a memory map for the
0523  * benefit of efi_memmap_init_early(), and for passing context between
0524  * efi_memmap_alloc() and efi_memmap_install().
0525  */
0526 struct efi_memory_map_data {
0527     phys_addr_t phys_map;
0528     unsigned long size;
0529     unsigned long desc_version;
0530     unsigned long desc_size;
0531     unsigned long flags;
0532 };
0533 
0534 struct efi_memory_map {
0535     phys_addr_t phys_map;
0536     void *map;
0537     void *map_end;
0538     int nr_map;
0539     unsigned long desc_version;
0540     unsigned long desc_size;
0541 #define EFI_MEMMAP_LATE (1UL << 0)
0542 #define EFI_MEMMAP_MEMBLOCK (1UL << 1)
0543 #define EFI_MEMMAP_SLAB (1UL << 2)
0544     unsigned long flags;
0545 };
0546 
0547 struct efi_mem_range {
0548     struct range range;
0549     u64 attribute;
0550 };
0551 
0552 typedef struct {
0553     u32 version;
0554     u32 length;
0555     u64 memory_protection_attribute;
0556 } efi_properties_table_t;
0557 
0558 #define EFI_PROPERTIES_TABLE_VERSION    0x00010000
0559 #define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA 0x1
0560 
0561 typedef struct {
0562     u16 version;
0563     u16 length;
0564     u32 runtime_services_supported;
0565 } efi_rt_properties_table_t;
0566 
0567 #define EFI_RT_PROPERTIES_TABLE_VERSION 0x1
0568 
0569 #define EFI_INVALID_TABLE_ADDR      (~0UL)
0570 
0571 typedef struct {
0572     u32 version;
0573     u32 num_entries;
0574     u32 desc_size;
0575     u32 reserved;
0576     efi_memory_desc_t entry[0];
0577 } efi_memory_attributes_table_t;
0578 
0579 typedef struct {
0580     efi_guid_t signature_owner;
0581     u8 signature_data[];
0582 } efi_signature_data_t;
0583 
0584 typedef struct {
0585     efi_guid_t signature_type;
0586     u32 signature_list_size;
0587     u32 signature_header_size;
0588     u32 signature_size;
0589     u8 signature_header[];
0590     /* efi_signature_data_t signatures[][] */
0591 } efi_signature_list_t;
0592 
0593 typedef u8 efi_sha256_hash_t[32];
0594 
0595 typedef struct {
0596     efi_sha256_hash_t to_be_signed_hash;
0597     efi_time_t time_of_revocation;
0598 } efi_cert_x509_sha256_t;
0599 
0600 extern unsigned long __ro_after_init efi_rng_seed;      /* RNG Seed table */
0601 
0602 /*
0603  * All runtime access to EFI goes through this structure:
0604  */
0605 extern struct efi {
0606     const efi_runtime_services_t    *runtime;       /* EFI runtime services table */
0607     unsigned int            runtime_version;    /* Runtime services version */
0608     unsigned int            runtime_supported_mask;
0609 
0610     unsigned long           acpi;           /* ACPI table  (IA64 ext 0.71) */
0611     unsigned long           acpi20;         /* ACPI table  (ACPI 2.0) */
0612     unsigned long           smbios;         /* SMBIOS table (32 bit entry point) */
0613     unsigned long           smbios3;        /* SMBIOS table (64 bit entry point) */
0614     unsigned long           esrt;           /* ESRT table */
0615     unsigned long           tpm_log;        /* TPM2 Event Log table */
0616     unsigned long           tpm_final_log;      /* TPM2 Final Events Log table */
0617     unsigned long           mokvar_table;       /* MOK variable config table */
0618     unsigned long           coco_secret;        /* Confidential computing secret table */
0619 
0620     efi_get_time_t          *get_time;
0621     efi_set_time_t          *set_time;
0622     efi_get_wakeup_time_t       *get_wakeup_time;
0623     efi_set_wakeup_time_t       *set_wakeup_time;
0624     efi_get_variable_t      *get_variable;
0625     efi_get_next_variable_t     *get_next_variable;
0626     efi_set_variable_t      *set_variable;
0627     efi_set_variable_t      *set_variable_nonblocking;
0628     efi_query_variable_info_t   *query_variable_info;
0629     efi_query_variable_info_t   *query_variable_info_nonblocking;
0630     efi_update_capsule_t        *update_capsule;
0631     efi_query_capsule_caps_t    *query_capsule_caps;
0632     efi_get_next_high_mono_count_t  *get_next_high_mono_count;
0633     efi_reset_system_t      *reset_system;
0634 
0635     struct efi_memory_map       memmap;
0636     unsigned long           flags;
0637 } efi;
0638 
0639 #define EFI_RT_SUPPORTED_GET_TIME               0x0001
0640 #define EFI_RT_SUPPORTED_SET_TIME               0x0002
0641 #define EFI_RT_SUPPORTED_GET_WAKEUP_TIME            0x0004
0642 #define EFI_RT_SUPPORTED_SET_WAKEUP_TIME            0x0008
0643 #define EFI_RT_SUPPORTED_GET_VARIABLE               0x0010
0644 #define EFI_RT_SUPPORTED_GET_NEXT_VARIABLE_NAME         0x0020
0645 #define EFI_RT_SUPPORTED_SET_VARIABLE               0x0040
0646 #define EFI_RT_SUPPORTED_SET_VIRTUAL_ADDRESS_MAP        0x0080
0647 #define EFI_RT_SUPPORTED_CONVERT_POINTER            0x0100
0648 #define EFI_RT_SUPPORTED_GET_NEXT_HIGH_MONOTONIC_COUNT      0x0200
0649 #define EFI_RT_SUPPORTED_RESET_SYSTEM               0x0400
0650 #define EFI_RT_SUPPORTED_UPDATE_CAPSULE             0x0800
0651 #define EFI_RT_SUPPORTED_QUERY_CAPSULE_CAPABILITIES     0x1000
0652 #define EFI_RT_SUPPORTED_QUERY_VARIABLE_INFO            0x2000
0653 
0654 #define EFI_RT_SUPPORTED_ALL                    0x3fff
0655 
0656 #define EFI_RT_SUPPORTED_TIME_SERVICES              0x000f
0657 #define EFI_RT_SUPPORTED_VARIABLE_SERVICES          0x0070
0658 
0659 extern struct mm_struct efi_mm;
0660 
0661 static inline int
0662 efi_guidcmp (efi_guid_t left, efi_guid_t right)
0663 {
0664     return memcmp(&left, &right, sizeof (efi_guid_t));
0665 }
0666 
0667 static inline char *
0668 efi_guid_to_str(efi_guid_t *guid, char *out)
0669 {
0670     sprintf(out, "%pUl", guid->b);
0671         return out;
0672 }
0673 
0674 extern void efi_init (void);
0675 #ifdef CONFIG_EFI
0676 extern void efi_enter_virtual_mode (void);  /* switch EFI to virtual mode, if possible */
0677 #else
0678 static inline void efi_enter_virtual_mode (void) {}
0679 #endif
0680 #ifdef CONFIG_X86
0681 extern efi_status_t efi_query_variable_store(u32 attributes,
0682                          unsigned long size,
0683                          bool nonblocking);
0684 #else
0685 
0686 static inline efi_status_t efi_query_variable_store(u32 attributes,
0687                             unsigned long size,
0688                             bool nonblocking)
0689 {
0690     return EFI_SUCCESS;
0691 }
0692 #endif
0693 extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
0694 
0695 extern int __init efi_memmap_alloc(unsigned int num_entries,
0696                    struct efi_memory_map_data *data);
0697 extern void __efi_memmap_free(u64 phys, unsigned long size,
0698                   unsigned long flags);
0699 extern int __init efi_memmap_init_early(struct efi_memory_map_data *data);
0700 extern int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size);
0701 extern void __init efi_memmap_unmap(void);
0702 extern int __init efi_memmap_install(struct efi_memory_map_data *data);
0703 extern int __init efi_memmap_split_count(efi_memory_desc_t *md,
0704                      struct range *range);
0705 extern void __init efi_memmap_insert(struct efi_memory_map *old_memmap,
0706                      void *buf, struct efi_mem_range *mem);
0707 
0708 #ifdef CONFIG_EFI_ESRT
0709 extern void __init efi_esrt_init(void);
0710 #else
0711 static inline void efi_esrt_init(void) { }
0712 #endif
0713 extern int efi_config_parse_tables(const efi_config_table_t *config_tables,
0714                    int count,
0715                    const efi_config_table_type_t *arch_tables);
0716 extern int efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
0717                    int min_major_version);
0718 extern void efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
0719                      unsigned long fw_vendor);
0720 extern u64 efi_get_iobase (void);
0721 extern int efi_mem_type(unsigned long phys_addr);
0722 extern u64 efi_mem_attributes (unsigned long phys_addr);
0723 extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
0724 extern int __init efi_uart_console_only (void);
0725 extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
0726 extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
0727 extern void efi_mem_reserve(phys_addr_t addr, u64 size);
0728 extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);
0729 extern void efi_initialize_iomem_resources(struct resource *code_resource,
0730         struct resource *data_resource, struct resource *bss_resource);
0731 extern u64 efi_get_fdt_params(struct efi_memory_map_data *data);
0732 extern struct kobject *efi_kobj;
0733 
0734 extern int efi_reboot_quirk_mode;
0735 extern bool efi_poweroff_required(void);
0736 
0737 #ifdef CONFIG_EFI_FAKE_MEMMAP
0738 extern void __init efi_fake_memmap(void);
0739 #else
0740 static inline void efi_fake_memmap(void) { }
0741 #endif
0742 
0743 extern unsigned long efi_mem_attr_table;
0744 
0745 /*
0746  * efi_memattr_perm_setter - arch specific callback function passed into
0747  *                           efi_memattr_apply_permissions() that updates the
0748  *                           mapping permissions described by the second
0749  *                           argument in the page tables referred to by the
0750  *                           first argument.
0751  */
0752 typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *);
0753 
0754 extern int efi_memattr_init(void);
0755 extern int efi_memattr_apply_permissions(struct mm_struct *mm,
0756                      efi_memattr_perm_setter fn);
0757 
0758 /*
0759  * efi_early_memdesc_ptr - get the n-th EFI memmap descriptor
0760  * @map: the start of efi memmap
0761  * @desc_size: the size of space for each EFI memmap descriptor
0762  * @n: the index of efi memmap descriptor
0763  *
0764  * EFI boot service provides the GetMemoryMap() function to get a copy of the
0765  * current memory map which is an array of memory descriptors, each of
0766  * which describes a contiguous block of memory. It also gets the size of the
0767  * map, and the size of each descriptor, etc.
0768  *
0769  * Note that per section 6.2 of UEFI Spec 2.6 Errata A, the returned size of
0770  * each descriptor might not be equal to sizeof(efi_memory_memdesc_t),
0771  * since efi_memory_memdesc_t may be extended in the future. Thus the OS
0772  * MUST use the returned size of the descriptor to find the start of each
0773  * efi_memory_memdesc_t in the memory map array. This should only be used
0774  * during bootup since for_each_efi_memory_desc_xxx() is available after the
0775  * kernel initializes the EFI subsystem to set up struct efi_memory_map.
0776  */
0777 #define efi_early_memdesc_ptr(map, desc_size, n)            \
0778     (efi_memory_desc_t *)((void *)(map) + ((n) * (desc_size)))
0779 
0780 /* Iterate through an efi_memory_map */
0781 #define for_each_efi_memory_desc_in_map(m, md)                 \
0782     for ((md) = (m)->map;                          \
0783          (md) && ((void *)(md) + (m)->desc_size) <= (m)->map_end;      \
0784          (md) = (void *)(md) + (m)->desc_size)
0785 
0786 /**
0787  * for_each_efi_memory_desc - iterate over descriptors in efi.memmap
0788  * @md: the efi_memory_desc_t * iterator
0789  *
0790  * Once the loop finishes @md must not be accessed.
0791  */
0792 #define for_each_efi_memory_desc(md) \
0793     for_each_efi_memory_desc_in_map(&efi.memmap, md)
0794 
0795 /*
0796  * Format an EFI memory descriptor's type and attributes to a user-provided
0797  * character buffer, as per snprintf(), and return the buffer.
0798  */
0799 char * __init efi_md_typeattr_format(char *buf, size_t size,
0800                      const efi_memory_desc_t *md);
0801 
0802 
0803 typedef void (*efi_element_handler_t)(const char *source,
0804                       const void *element_data,
0805                       size_t element_size);
0806 extern int __init parse_efi_signature_list(
0807     const char *source,
0808     const void *data, size_t size,
0809     efi_element_handler_t (*get_handler_for_guid)(const efi_guid_t *));
0810 
0811 /**
0812  * efi_range_is_wc - check the WC bit on an address range
0813  * @start: starting kvirt address
0814  * @len: length of range
0815  *
0816  * Consult the EFI memory map and make sure it's ok to set this range WC.
0817  * Returns true or false.
0818  */
0819 static inline int efi_range_is_wc(unsigned long start, unsigned long len)
0820 {
0821     unsigned long i;
0822 
0823     for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
0824         unsigned long paddr = __pa(start + i);
0825         if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))
0826             return 0;
0827     }
0828     /* The range checked out */
0829     return 1;
0830 }
0831 
0832 #ifdef CONFIG_EFI_PCDP
0833 extern int __init efi_setup_pcdp_console(char *);
0834 #endif
0835 
0836 /*
0837  * We play games with efi_enabled so that the compiler will, if
0838  * possible, remove EFI-related code altogether.
0839  */
0840 #define EFI_BOOT        0   /* Were we booted from EFI? */
0841 #define EFI_CONFIG_TABLES   2   /* Can we use EFI config tables? */
0842 #define EFI_RUNTIME_SERVICES    3   /* Can we use runtime services? */
0843 #define EFI_MEMMAP      4   /* Can we use EFI memory map? */
0844 #define EFI_64BIT       5   /* Is the firmware 64-bit? */
0845 #define EFI_PARAVIRT        6   /* Access is via a paravirt interface */
0846 #define EFI_ARCH_1      7   /* First arch-specific bit */
0847 #define EFI_DBG         8   /* Print additional debug info at runtime */
0848 #define EFI_NX_PE_DATA      9   /* Can runtime data regions be mapped non-executable? */
0849 #define EFI_MEM_ATTR        10  /* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */
0850 #define EFI_MEM_NO_SOFT_RESERVE 11  /* Is the kernel configured to ignore soft reservations? */
0851 #define EFI_PRESERVE_BS_REGIONS 12  /* Are EFI boot-services memory segments available? */
0852 
0853 #ifdef CONFIG_EFI
0854 /*
0855  * Test whether the above EFI_* bits are enabled.
0856  */
0857 static inline bool efi_enabled(int feature)
0858 {
0859     return test_bit(feature, &efi.flags) != 0;
0860 }
0861 extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
0862 
0863 bool __pure __efi_soft_reserve_enabled(void);
0864 
0865 static inline bool __pure efi_soft_reserve_enabled(void)
0866 {
0867     return IS_ENABLED(CONFIG_EFI_SOFT_RESERVE)
0868         && __efi_soft_reserve_enabled();
0869 }
0870 
0871 static inline bool efi_rt_services_supported(unsigned int mask)
0872 {
0873     return (efi.runtime_supported_mask & mask) == mask;
0874 }
0875 extern void efi_find_mirror(void);
0876 #else
0877 static inline bool efi_enabled(int feature)
0878 {
0879     return false;
0880 }
0881 static inline void
0882 efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {}
0883 
0884 static inline bool efi_soft_reserve_enabled(void)
0885 {
0886     return false;
0887 }
0888 
0889 static inline bool efi_rt_services_supported(unsigned int mask)
0890 {
0891     return false;
0892 }
0893 
0894 static inline void efi_find_mirror(void) {}
0895 #endif
0896 
0897 extern int efi_status_to_err(efi_status_t status);
0898 
0899 /*
0900  * Variable Attributes
0901  */
0902 #define EFI_VARIABLE_NON_VOLATILE       0x0000000000000001
0903 #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002
0904 #define EFI_VARIABLE_RUNTIME_ACCESS     0x0000000000000004
0905 #define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008
0906 #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010
0907 #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020
0908 #define EFI_VARIABLE_APPEND_WRITE   0x0000000000000040
0909 
0910 #define EFI_VARIABLE_MASK   (EFI_VARIABLE_NON_VOLATILE | \
0911                 EFI_VARIABLE_BOOTSERVICE_ACCESS | \
0912                 EFI_VARIABLE_RUNTIME_ACCESS | \
0913                 EFI_VARIABLE_HARDWARE_ERROR_RECORD | \
0914                 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \
0915                 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \
0916                 EFI_VARIABLE_APPEND_WRITE)
0917 /*
0918  * Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
0919  * not including trailing NUL
0920  */
0921 #define EFI_VARIABLE_GUID_LEN   UUID_STRING_LEN
0922 
0923 /*
0924  * EFI Device Path information
0925  */
0926 #define EFI_DEV_HW          0x01
0927 #define  EFI_DEV_PCI                 1
0928 #define  EFI_DEV_PCCARD              2
0929 #define  EFI_DEV_MEM_MAPPED          3
0930 #define  EFI_DEV_VENDOR              4
0931 #define  EFI_DEV_CONTROLLER          5
0932 #define EFI_DEV_ACPI            0x02
0933 #define   EFI_DEV_BASIC_ACPI             1
0934 #define   EFI_DEV_EXPANDED_ACPI          2
0935 #define EFI_DEV_MSG         0x03
0936 #define   EFI_DEV_MSG_ATAPI          1
0937 #define   EFI_DEV_MSG_SCSI           2
0938 #define   EFI_DEV_MSG_FC             3
0939 #define   EFI_DEV_MSG_1394           4
0940 #define   EFI_DEV_MSG_USB            5
0941 #define   EFI_DEV_MSG_USB_CLASS         15
0942 #define   EFI_DEV_MSG_I20            6
0943 #define   EFI_DEV_MSG_MAC           11
0944 #define   EFI_DEV_MSG_IPV4          12
0945 #define   EFI_DEV_MSG_IPV6          13
0946 #define   EFI_DEV_MSG_INFINIBAND         9
0947 #define   EFI_DEV_MSG_UART          14
0948 #define   EFI_DEV_MSG_VENDOR            10
0949 #define EFI_DEV_MEDIA           0x04
0950 #define   EFI_DEV_MEDIA_HARD_DRIVE       1
0951 #define   EFI_DEV_MEDIA_CDROM            2
0952 #define   EFI_DEV_MEDIA_VENDOR           3
0953 #define   EFI_DEV_MEDIA_FILE             4
0954 #define   EFI_DEV_MEDIA_PROTOCOL         5
0955 #define EFI_DEV_BIOS_BOOT       0x05
0956 #define EFI_DEV_END_PATH        0x7F
0957 #define EFI_DEV_END_PATH2       0xFF
0958 #define   EFI_DEV_END_INSTANCE          0x01
0959 #define   EFI_DEV_END_ENTIRE            0xFF
0960 
0961 struct efi_generic_dev_path {
0962     u8              type;
0963     u8              sub_type;
0964     u16             length;
0965 } __packed;
0966 
0967 struct efi_acpi_dev_path {
0968     struct efi_generic_dev_path header;
0969     u32             hid;
0970     u32             uid;
0971 } __packed;
0972 
0973 struct efi_pci_dev_path {
0974     struct efi_generic_dev_path header;
0975     u8              fn;
0976     u8              dev;
0977 } __packed;
0978 
0979 struct efi_vendor_dev_path {
0980     struct efi_generic_dev_path header;
0981     efi_guid_t          vendorguid;
0982     u8              vendordata[];
0983 } __packed;
0984 
0985 struct efi_dev_path {
0986     union {
0987         struct efi_generic_dev_path header;
0988         struct efi_acpi_dev_path    acpi;
0989         struct efi_pci_dev_path     pci;
0990         struct efi_vendor_dev_path  vendor;
0991     };
0992 } __packed;
0993 
0994 struct device *efi_get_device_by_path(const struct efi_dev_path **node,
0995                       size_t *len);
0996 
0997 static inline void memrange_efi_to_native(u64 *addr, u64 *npages)
0998 {
0999     *npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr);
1000     *addr &= PAGE_MASK;
1001 }
1002 
1003 /*
1004  * EFI Variable support.
1005  *
1006  * Different firmware drivers can expose their EFI-like variables using
1007  * the following.
1008  */
1009 
1010 struct efivar_operations {
1011     efi_get_variable_t *get_variable;
1012     efi_get_next_variable_t *get_next_variable;
1013     efi_set_variable_t *set_variable;
1014     efi_set_variable_t *set_variable_nonblocking;
1015     efi_query_variable_store_t *query_variable_store;
1016 };
1017 
1018 struct efivars {
1019     struct kset *kset;
1020     struct kobject *kobject;
1021     const struct efivar_operations *ops;
1022 };
1023 
1024 /*
1025  * The maximum size of VariableName + Data = 1024
1026  * Therefore, it's reasonable to save that much
1027  * space in each part of the structure,
1028  * and we use a page for reading/writing.
1029  */
1030 
1031 #define EFI_VAR_NAME_LEN    1024
1032 
1033 int efivars_register(struct efivars *efivars,
1034              const struct efivar_operations *ops,
1035              struct kobject *kobject);
1036 int efivars_unregister(struct efivars *efivars);
1037 struct kobject *efivars_kobject(void);
1038 
1039 int efivar_supports_writes(void);
1040 
1041 int efivar_lock(void);
1042 int efivar_trylock(void);
1043 void efivar_unlock(void);
1044 
1045 efi_status_t efivar_get_variable(efi_char16_t *name, efi_guid_t *vendor,
1046                  u32 *attr, unsigned long *size, void *data);
1047 
1048 efi_status_t efivar_get_next_variable(unsigned long *name_size,
1049                       efi_char16_t *name, efi_guid_t *vendor);
1050 
1051 efi_status_t efivar_set_variable_locked(efi_char16_t *name, efi_guid_t *vendor,
1052                     u32 attr, unsigned long data_size,
1053                     void *data, bool nonblocking);
1054 
1055 efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor,
1056                  u32 attr, unsigned long data_size, void *data);
1057 
1058 efi_status_t check_var_size(u32 attributes, unsigned long size);
1059 efi_status_t check_var_size_nonblocking(u32 attributes, unsigned long size);
1060 
1061 #if IS_ENABLED(CONFIG_EFI_CAPSULE_LOADER)
1062 extern bool efi_capsule_pending(int *reset_type);
1063 
1064 extern int efi_capsule_supported(efi_guid_t guid, u32 flags,
1065                  size_t size, int *reset);
1066 
1067 extern int efi_capsule_update(efi_capsule_header_t *capsule,
1068                   phys_addr_t *pages);
1069 #else
1070 static inline bool efi_capsule_pending(int *reset_type) { return false; }
1071 #endif
1072 
1073 #ifdef CONFIG_EFI_RUNTIME_MAP
1074 int efi_runtime_map_init(struct kobject *);
1075 int efi_get_runtime_map_size(void);
1076 int efi_get_runtime_map_desc_size(void);
1077 int efi_runtime_map_copy(void *buf, size_t bufsz);
1078 #else
1079 static inline int efi_runtime_map_init(struct kobject *kobj)
1080 {
1081     return 0;
1082 }
1083 
1084 static inline int efi_get_runtime_map_size(void)
1085 {
1086     return 0;
1087 }
1088 
1089 static inline int efi_get_runtime_map_desc_size(void)
1090 {
1091     return 0;
1092 }
1093 
1094 static inline int efi_runtime_map_copy(void *buf, size_t bufsz)
1095 {
1096     return 0;
1097 }
1098 
1099 #endif
1100 
1101 #ifdef CONFIG_EFI
1102 extern bool efi_runtime_disabled(void);
1103 #else
1104 static inline bool efi_runtime_disabled(void) { return true; }
1105 #endif
1106 
1107 extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
1108 extern unsigned long efi_call_virt_save_flags(void);
1109 
1110 enum efi_secureboot_mode {
1111     efi_secureboot_mode_unset,
1112     efi_secureboot_mode_unknown,
1113     efi_secureboot_mode_disabled,
1114     efi_secureboot_mode_enabled,
1115 };
1116 
1117 static inline
1118 enum efi_secureboot_mode efi_get_secureboot_mode(efi_get_variable_t *get_var)
1119 {
1120     u8 secboot, setupmode = 0;
1121     efi_status_t status;
1122     unsigned long size;
1123 
1124     size = sizeof(secboot);
1125     status = get_var(L"SecureBoot", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size,
1126              &secboot);
1127     if (status == EFI_NOT_FOUND)
1128         return efi_secureboot_mode_disabled;
1129     if (status != EFI_SUCCESS)
1130         return efi_secureboot_mode_unknown;
1131 
1132     size = sizeof(setupmode);
1133     get_var(L"SetupMode", &EFI_GLOBAL_VARIABLE_GUID, NULL, &size, &setupmode);
1134     if (secboot == 0 || setupmode == 1)
1135         return efi_secureboot_mode_disabled;
1136     return efi_secureboot_mode_enabled;
1137 }
1138 
1139 #ifdef CONFIG_EFI_EMBEDDED_FIRMWARE
1140 void efi_check_for_embedded_firmwares(void);
1141 #else
1142 static inline void efi_check_for_embedded_firmwares(void) { }
1143 #endif
1144 
1145 efi_status_t efi_random_get_seed(void);
1146 
1147 #define arch_efi_call_virt(p, f, args...)   ((p)->f(args))
1148 
1149 /*
1150  * Arch code can implement the following three template macros, avoiding
1151  * reptition for the void/non-void return cases of {__,}efi_call_virt():
1152  *
1153  *  * arch_efi_call_virt_setup()
1154  *
1155  *    Sets up the environment for the call (e.g. switching page tables,
1156  *    allowing kernel-mode use of floating point, if required).
1157  *
1158  *  * arch_efi_call_virt()
1159  *
1160  *    Performs the call. The last expression in the macro must be the call
1161  *    itself, allowing the logic to be shared by the void and non-void
1162  *    cases.
1163  *
1164  *  * arch_efi_call_virt_teardown()
1165  *
1166  *    Restores the usual kernel environment once the call has returned.
1167  */
1168 
1169 #define efi_call_virt_pointer(p, f, args...)                \
1170 ({                                  \
1171     efi_status_t __s;                       \
1172     unsigned long __flags;                      \
1173                                     \
1174     arch_efi_call_virt_setup();                 \
1175                                     \
1176     __flags = efi_call_virt_save_flags();               \
1177     __s = arch_efi_call_virt(p, f, args);               \
1178     efi_call_virt_check_flags(__flags, __stringify(f));     \
1179                                     \
1180     arch_efi_call_virt_teardown();                  \
1181                                     \
1182     __s;                                \
1183 })
1184 
1185 #define __efi_call_virt_pointer(p, f, args...)              \
1186 ({                                  \
1187     unsigned long __flags;                      \
1188                                     \
1189     arch_efi_call_virt_setup();                 \
1190                                     \
1191     __flags = efi_call_virt_save_flags();               \
1192     arch_efi_call_virt(p, f, args);                 \
1193     efi_call_virt_check_flags(__flags, __stringify(f));     \
1194                                     \
1195     arch_efi_call_virt_teardown();                  \
1196 })
1197 
1198 #define EFI_RANDOM_SEED_SIZE        64U
1199 
1200 struct linux_efi_random_seed {
1201     u32 size;
1202     u8  bits[];
1203 };
1204 
1205 struct linux_efi_tpm_eventlog {
1206     u32 size;
1207     u32 final_events_preboot_size;
1208     u8  version;
1209     u8  log[];
1210 };
1211 
1212 extern int efi_tpm_eventlog_init(void);
1213 
1214 struct efi_tcg2_final_events_table {
1215     u64 version;
1216     u64 nr_events;
1217     u8 events[];
1218 };
1219 extern int efi_tpm_final_log_size;
1220 
1221 extern unsigned long rci2_table_phys;
1222 
1223 /*
1224  * efi_runtime_service() function identifiers.
1225  * "NONE" is used by efi_recover_from_page_fault() to check if the page
1226  * fault happened while executing an efi runtime service.
1227  */
1228 enum efi_rts_ids {
1229     EFI_NONE,
1230     EFI_GET_TIME,
1231     EFI_SET_TIME,
1232     EFI_GET_WAKEUP_TIME,
1233     EFI_SET_WAKEUP_TIME,
1234     EFI_GET_VARIABLE,
1235     EFI_GET_NEXT_VARIABLE,
1236     EFI_SET_VARIABLE,
1237     EFI_QUERY_VARIABLE_INFO,
1238     EFI_GET_NEXT_HIGH_MONO_COUNT,
1239     EFI_RESET_SYSTEM,
1240     EFI_UPDATE_CAPSULE,
1241     EFI_QUERY_CAPSULE_CAPS,
1242 };
1243 
1244 /*
1245  * efi_runtime_work:    Details of EFI Runtime Service work
1246  * @arg<1-5>:       EFI Runtime Service function arguments
1247  * @status:     Status of executing EFI Runtime Service
1248  * @efi_rts_id:     EFI Runtime Service function identifier
1249  * @efi_rts_comp:   Struct used for handling completions
1250  */
1251 struct efi_runtime_work {
1252     void *arg1;
1253     void *arg2;
1254     void *arg3;
1255     void *arg4;
1256     void *arg5;
1257     efi_status_t status;
1258     struct work_struct work;
1259     enum efi_rts_ids efi_rts_id;
1260     struct completion efi_rts_comp;
1261 };
1262 
1263 extern struct efi_runtime_work efi_rts_work;
1264 
1265 /* Workqueue to queue EFI Runtime Services */
1266 extern struct workqueue_struct *efi_rts_wq;
1267 
1268 struct linux_efi_memreserve {
1269     int     size;           // allocated size of the array
1270     atomic_t    count;          // number of entries used
1271     phys_addr_t next;           // pa of next struct instance
1272     struct {
1273         phys_addr_t base;
1274         phys_addr_t size;
1275     } entry[];
1276 };
1277 
1278 #define EFI_MEMRESERVE_COUNT(size) (((size) - sizeof(struct linux_efi_memreserve)) \
1279     / sizeof_field(struct linux_efi_memreserve, entry[0]))
1280 
1281 void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size);
1282 
1283 char *efi_systab_show_arch(char *str);
1284 
1285 /*
1286  * The LINUX_EFI_MOK_VARIABLE_TABLE_GUID config table can be provided
1287  * to the kernel by an EFI boot loader. The table contains a packed
1288  * sequence of these entries, one for each named MOK variable.
1289  * The sequence is terminated by an entry with a completely NULL
1290  * name and 0 data size.
1291  */
1292 struct efi_mokvar_table_entry {
1293     char name[256];
1294     u64 data_size;
1295     u8 data[];
1296 } __attribute((packed));
1297 
1298 #ifdef CONFIG_LOAD_UEFI_KEYS
1299 extern void __init efi_mokvar_table_init(void);
1300 extern struct efi_mokvar_table_entry *efi_mokvar_entry_next(
1301             struct efi_mokvar_table_entry **mokvar_entry);
1302 extern struct efi_mokvar_table_entry *efi_mokvar_entry_find(const char *name);
1303 #else
1304 static inline void efi_mokvar_table_init(void) { }
1305 static inline struct efi_mokvar_table_entry *efi_mokvar_entry_next(
1306             struct efi_mokvar_table_entry **mokvar_entry)
1307 {
1308     return NULL;
1309 }
1310 static inline struct efi_mokvar_table_entry *efi_mokvar_entry_find(
1311             const char *name)
1312 {
1313     return NULL;
1314 }
1315 #endif
1316 
1317 extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);
1318 
1319 struct linux_efi_coco_secret_area {
1320     u64 base_pa;
1321     u64 size;
1322 };
1323 
1324 /* Header of a populated EFI secret area */
1325 #define EFI_SECRET_TABLE_HEADER_GUID    EFI_GUID(0x1e74f542, 0x71dd, 0x4d66,  0x96, 0x3e, 0xef, 0x42, 0x87, 0xff, 0x17, 0x3b)
1326 
1327 #endif /* _LINUX_EFI_H */
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!