1 /* SPDX-License-Identifier: GPL-2.0 */ 2 #ifndef _LINUX_EFI_H 3 #define _LINUX_EFI_H 4 5 /* 6 * Extensible Firmware Interface 7 * Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999 8 * 9 * Copyright (C) 1999 VA Linux Systems 10 * Copyright (C) 1999 Walt Drummond <[email protected]> 11 * Copyright (C) 1999, 2002-2003 Hewlett-Packard Co. 12 * David Mosberger-Tang <[email protected]> 13 * Stephane Eranian <[email protected]> 14 */ 15 #include <linux/init.h> 16 #include <linux/string.h> 17 #include <linux/time.h> 18 #include <linux/types.h> 19 #include <linux/proc_fs.h> 20 #include <linux/rtc.h> 21 #include <linux/ioport.h> 22 #include <linux/pfn.h> 23 #include <linux/pstore.h> 24 #include <linux/range.h> 25 #include <linux/reboot.h> 26 #include <linux/uuid.h> 27 #include <linux/screen_info.h> 28 29 #include <asm/page.h> 30 31 #define EFI_SUCCESS 0 32 #define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1))) 33 #define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1))) 34 #define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1))) 35 #define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1))) 36 #define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1))) 37 #define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1))) 38 #define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1))) 39 #define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1))) 40 #define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1))) 41 #define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1))) 42 #define EFI_ABORTED (21 | (1UL << (BITS_PER_LONG-1))) 43 #define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1))) 44 45 typedef unsigned long efi_status_t; 46 typedef u8 efi_bool_t; 47 typedef u16 efi_char16_t; /* UNICODE character */ 48 typedef u64 efi_physical_addr_t; 49 typedef void *efi_handle_t; 50 51 typedef guid_t efi_guid_t; 52 53 #define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \ 54 GUID_INIT(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) 55 56 /* 57 * Generic EFI table header 58 */ 59 typedef struct { 60 u64 signature; 61 u32 revision; 62 u32 headersize; 63 u32 crc32; 64 u32 reserved; 65 } efi_table_hdr_t; 66 67 /* 68 * Memory map descriptor: 69 */ 70 71 /* Memory types: */ 72 #define EFI_RESERVED_TYPE 0 73 #define EFI_LOADER_CODE 1 74 #define EFI_LOADER_DATA 2 75 #define EFI_BOOT_SERVICES_CODE 3 76 #define EFI_BOOT_SERVICES_DATA 4 77 #define EFI_RUNTIME_SERVICES_CODE 5 78 #define EFI_RUNTIME_SERVICES_DATA 6 79 #define EFI_CONVENTIONAL_MEMORY 7 80 #define EFI_UNUSABLE_MEMORY 8 81 #define EFI_ACPI_RECLAIM_MEMORY 9 82 #define EFI_ACPI_MEMORY_NVS 10 83 #define EFI_MEMORY_MAPPED_IO 11 84 #define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12 85 #define EFI_PAL_CODE 13 86 #define EFI_PERSISTENT_MEMORY 14 87 #define EFI_MAX_MEMORY_TYPE 15 88 89 /* Attribute values: */ 90 #define EFI_MEMORY_UC ((u64)0x0000000000000001ULL) /* uncached */ 91 #define EFI_MEMORY_WC ((u64)0x0000000000000002ULL) /* write-coalescing */ 92 #define EFI_MEMORY_WT ((u64)0x0000000000000004ULL) /* write-through */ 93 #define EFI_MEMORY_WB ((u64)0x0000000000000008ULL) /* write-back */ 94 #define EFI_MEMORY_UCE ((u64)0x0000000000000010ULL) /* uncached, exported */ 95 #define EFI_MEMORY_WP ((u64)0x0000000000001000ULL) /* write-protect */ 96 #define EFI_MEMORY_RP ((u64)0x0000000000002000ULL) /* read-protect */ 97 #define EFI_MEMORY_XP ((u64)0x0000000000004000ULL) /* execute-protect */ 98 #define EFI_MEMORY_NV ((u64)0x0000000000008000ULL) /* non-volatile */ 99 #define EFI_MEMORY_MORE_RELIABLE \ 100 ((u64)0x0000000000010000ULL) /* higher reliability */ 101 #define EFI_MEMORY_RO ((u64)0x0000000000020000ULL) /* read-only */ 102 #define EFI_MEMORY_RUNTIME ((u64)0x8000000000000000ULL) /* range requires runtime mapping */ 103 #define EFI_MEMORY_DESCRIPTOR_VERSION 1 104 105 #define EFI_PAGE_SHIFT 12 106 #define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT) 107 #define EFI_PAGES_MAX (U64_MAX >> EFI_PAGE_SHIFT) 108 109 typedef struct { 110 u32 type; 111 u32 pad; 112 u64 phys_addr; 113 u64 virt_addr; 114 u64 num_pages; 115 u64 attribute; 116 } efi_memory_desc_t; 117 118 typedef struct { 119 efi_guid_t guid; 120 u32 headersize; 121 u32 flags; 122 u32 imagesize; 123 } efi_capsule_header_t; 124 125 struct efi_boot_memmap { 126 efi_memory_desc_t **map; 127 unsigned long *map_size; 128 unsigned long *desc_size; 129 u32 *desc_ver; 130 unsigned long *key_ptr; 131 unsigned long *buff_size; 132 }; 133 134 /* 135 * EFI capsule flags 136 */ 137 #define EFI_CAPSULE_PERSIST_ACROSS_RESET 0x00010000 138 #define EFI_CAPSULE_POPULATE_SYSTEM_TABLE 0x00020000 139 #define EFI_CAPSULE_INITIATE_RESET 0x00040000 140 141 struct capsule_info { 142 efi_capsule_header_t header; 143 int reset_type; 144 long index; 145 size_t count; 146 size_t total_size; 147 phys_addr_t *pages; 148 size_t page_bytes_remain; 149 }; 150 151 int __efi_capsule_setup_info(struct capsule_info *cap_info); 152 153 /* 154 * Allocation types for calls to boottime->allocate_pages. 155 */ 156 #define EFI_ALLOCATE_ANY_PAGES 0 157 #define EFI_ALLOCATE_MAX_ADDRESS 1 158 #define EFI_ALLOCATE_ADDRESS 2 159 #define EFI_MAX_ALLOCATE_TYPE 3 160 161 typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg); 162 163 /* 164 * Types and defines for Time Services 165 */ 166 #define EFI_TIME_ADJUST_DAYLIGHT 0x1 167 #define EFI_TIME_IN_DAYLIGHT 0x2 168 #define EFI_UNSPECIFIED_TIMEZONE 0x07ff 169 170 typedef struct { 171 u16 year; 172 u8 month; 173 u8 day; 174 u8 hour; 175 u8 minute; 176 u8 second; 177 u8 pad1; 178 u32 nanosecond; 179 s16 timezone; 180 u8 daylight; 181 u8 pad2; 182 } efi_time_t; 183 184 typedef struct { 185 u32 resolution; 186 u32 accuracy; 187 u8 sets_to_zero; 188 } efi_time_cap_t; 189 190 typedef struct { 191 efi_table_hdr_t hdr; 192 u32 raise_tpl; 193 u32 restore_tpl; 194 u32 allocate_pages; 195 u32 free_pages; 196 u32 get_memory_map; 197 u32 allocate_pool; 198 u32 free_pool; 199 u32 create_event; 200 u32 set_timer; 201 u32 wait_for_event; 202 u32 signal_event; 203 u32 close_event; 204 u32 check_event; 205 u32 install_protocol_interface; 206 u32 reinstall_protocol_interface; 207 u32 uninstall_protocol_interface; 208 u32 handle_protocol; 209 u32 __reserved; 210 u32 register_protocol_notify; 211 u32 locate_handle; 212 u32 locate_device_path; 213 u32 install_configuration_table; 214 u32 load_image; 215 u32 start_image; 216 u32 exit; 217 u32 unload_image; 218 u32 exit_boot_services; 219 u32 get_next_monotonic_count; 220 u32 stall; 221 u32 set_watchdog_timer; 222 u32 connect_controller; 223 u32 disconnect_controller; 224 u32 open_protocol; 225 u32 close_protocol; 226 u32 open_protocol_information; 227 u32 protocols_per_handle; 228 u32 locate_handle_buffer; 229 u32 locate_protocol; 230 u32 install_multiple_protocol_interfaces; 231 u32 uninstall_multiple_protocol_interfaces; 232 u32 calculate_crc32; 233 u32 copy_mem; 234 u32 set_mem; 235 u32 create_event_ex; 236 } __packed efi_boot_services_32_t; 237 238 typedef struct { 239 efi_table_hdr_t hdr; 240 u64 raise_tpl; 241 u64 restore_tpl; 242 u64 allocate_pages; 243 u64 free_pages; 244 u64 get_memory_map; 245 u64 allocate_pool; 246 u64 free_pool; 247 u64 create_event; 248 u64 set_timer; 249 u64 wait_for_event; 250 u64 signal_event; 251 u64 close_event; 252 u64 check_event; 253 u64 install_protocol_interface; 254 u64 reinstall_protocol_interface; 255 u64 uninstall_protocol_interface; 256 u64 handle_protocol; 257 u64 __reserved; 258 u64 register_protocol_notify; 259 u64 locate_handle; 260 u64 locate_device_path; 261 u64 install_configuration_table; 262 u64 load_image; 263 u64 start_image; 264 u64 exit; 265 u64 unload_image; 266 u64 exit_boot_services; 267 u64 get_next_monotonic_count; 268 u64 stall; 269 u64 set_watchdog_timer; 270 u64 connect_controller; 271 u64 disconnect_controller; 272 u64 open_protocol; 273 u64 close_protocol; 274 u64 open_protocol_information; 275 u64 protocols_per_handle; 276 u64 locate_handle_buffer; 277 u64 locate_protocol; 278 u64 install_multiple_protocol_interfaces; 279 u64 uninstall_multiple_protocol_interfaces; 280 u64 calculate_crc32; 281 u64 copy_mem; 282 u64 set_mem; 283 u64 create_event_ex; 284 } __packed efi_boot_services_64_t; 285 286 /* 287 * EFI Boot Services table 288 */ 289 typedef struct { 290 efi_table_hdr_t hdr; 291 void *raise_tpl; 292 void *restore_tpl; 293 efi_status_t (*allocate_pages)(int, int, unsigned long, 294 efi_physical_addr_t *); 295 efi_status_t (*free_pages)(efi_physical_addr_t, unsigned long); 296 efi_status_t (*get_memory_map)(unsigned long *, void *, unsigned long *, 297 unsigned long *, u32 *); 298 efi_status_t (*allocate_pool)(int, unsigned long, void **); 299 efi_status_t (*free_pool)(void *); 300 void *create_event; 301 void *set_timer; 302 void *wait_for_event; 303 void *signal_event; 304 void *close_event; 305 void *check_event; 306 void *install_protocol_interface; 307 void *reinstall_protocol_interface; 308 void *uninstall_protocol_interface; 309 efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **); 310 void *__reserved; 311 void *register_protocol_notify; 312 efi_status_t (*locate_handle)(int, efi_guid_t *, void *, 313 unsigned long *, efi_handle_t *); 314 void *locate_device_path; 315 efi_status_t (*install_configuration_table)(efi_guid_t *, void *); 316 void *load_image; 317 void *start_image; 318 void *exit; 319 void *unload_image; 320 efi_status_t (*exit_boot_services)(efi_handle_t, unsigned long); 321 void *get_next_monotonic_count; 322 void *stall; 323 void *set_watchdog_timer; 324 void *connect_controller; 325 void *disconnect_controller; 326 void *open_protocol; 327 void *close_protocol; 328 void *open_protocol_information; 329 void *protocols_per_handle; 330 void *locate_handle_buffer; 331 efi_status_t (*locate_protocol)(efi_guid_t *, void *, void **); 332 void *install_multiple_protocol_interfaces; 333 void *uninstall_multiple_protocol_interfaces; 334 void *calculate_crc32; 335 void *copy_mem; 336 void *set_mem; 337 void *create_event_ex; 338 } efi_boot_services_t; 339 340 typedef enum { 341 EfiPciIoWidthUint8, 342 EfiPciIoWidthUint16, 343 EfiPciIoWidthUint32, 344 EfiPciIoWidthUint64, 345 EfiPciIoWidthFifoUint8, 346 EfiPciIoWidthFifoUint16, 347 EfiPciIoWidthFifoUint32, 348 EfiPciIoWidthFifoUint64, 349 EfiPciIoWidthFillUint8, 350 EfiPciIoWidthFillUint16, 351 EfiPciIoWidthFillUint32, 352 EfiPciIoWidthFillUint64, 353 EfiPciIoWidthMaximum 354 } EFI_PCI_IO_PROTOCOL_WIDTH; 355 356 typedef enum { 357 EfiPciIoAttributeOperationGet, 358 EfiPciIoAttributeOperationSet, 359 EfiPciIoAttributeOperationEnable, 360 EfiPciIoAttributeOperationDisable, 361 EfiPciIoAttributeOperationSupported, 362 EfiPciIoAttributeOperationMaximum 363 } EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION; 364 365 typedef struct { 366 u32 read; 367 u32 write; 368 } efi_pci_io_protocol_access_32_t; 369 370 typedef struct { 371 u64 read; 372 u64 write; 373 } efi_pci_io_protocol_access_64_t; 374 375 typedef struct { 376 void *read; 377 void *write; 378 } efi_pci_io_protocol_access_t; 379 380 typedef struct { 381 u32 poll_mem; 382 u32 poll_io; 383 efi_pci_io_protocol_access_32_t mem; 384 efi_pci_io_protocol_access_32_t io; 385 efi_pci_io_protocol_access_32_t pci; 386 u32 copy_mem; 387 u32 map; 388 u32 unmap; 389 u32 allocate_buffer; 390 u32 free_buffer; 391 u32 flush; 392 u32 get_location; 393 u32 attributes; 394 u32 get_bar_attributes; 395 u32 set_bar_attributes; 396 uint64_t romsize; 397 void *romimage; 398 } efi_pci_io_protocol_32; 399 400 typedef struct { 401 u64 poll_mem; 402 u64 poll_io; 403 efi_pci_io_protocol_access_64_t mem; 404 efi_pci_io_protocol_access_64_t io; 405 efi_pci_io_protocol_access_64_t pci; 406 u64 copy_mem; 407 u64 map; 408 u64 unmap; 409 u64 allocate_buffer; 410 u64 free_buffer; 411 u64 flush; 412 u64 get_location; 413 u64 attributes; 414 u64 get_bar_attributes; 415 u64 set_bar_attributes; 416 uint64_t romsize; 417 void *romimage; 418 } efi_pci_io_protocol_64; 419 420 typedef struct { 421 void *poll_mem; 422 void *poll_io; 423 efi_pci_io_protocol_access_t mem; 424 efi_pci_io_protocol_access_t io; 425 efi_pci_io_protocol_access_t pci; 426 void *copy_mem; 427 void *map; 428 void *unmap; 429 void *allocate_buffer; 430 void *free_buffer; 431 void *flush; 432 void *get_location; 433 void *attributes; 434 void *get_bar_attributes; 435 void *set_bar_attributes; 436 uint64_t romsize; 437 void *romimage; 438 } efi_pci_io_protocol; 439 440 #define EFI_PCI_IO_ATTRIBUTE_ISA_MOTHERBOARD_IO 0x0001 441 #define EFI_PCI_IO_ATTRIBUTE_ISA_IO 0x0002 442 #define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO 0x0004 443 #define EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY 0x0008 444 #define EFI_PCI_IO_ATTRIBUTE_VGA_IO 0x0010 445 #define EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO 0x0020 446 #define EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO 0x0040 447 #define EFI_PCI_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE 0x0080 448 #define EFI_PCI_IO_ATTRIBUTE_IO 0x0100 449 #define EFI_PCI_IO_ATTRIBUTE_MEMORY 0x0200 450 #define EFI_PCI_IO_ATTRIBUTE_BUS_MASTER 0x0400 451 #define EFI_PCI_IO_ATTRIBUTE_MEMORY_CACHED 0x0800 452 #define EFI_PCI_IO_ATTRIBUTE_MEMORY_DISABLE 0x1000 453 #define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_DEVICE 0x2000 454 #define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_ROM 0x4000 455 #define EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE 0x8000 456 #define EFI_PCI_IO_ATTRIBUTE_ISA_IO_16 0x10000 457 #define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO_16 0x20000 458 #define EFI_PCI_IO_ATTRIBUTE_VGA_IO_16 0x40000 459 460 typedef struct { 461 u32 version; 462 u32 get; 463 u32 set; 464 u32 del; 465 u32 get_all; 466 } apple_properties_protocol_32_t; 467 468 typedef struct { 469 u64 version; 470 u64 get; 471 u64 set; 472 u64 del; 473 u64 get_all; 474 } apple_properties_protocol_64_t; 475 476 /* 477 * Types and defines for EFI ResetSystem 478 */ 479 #define EFI_RESET_COLD 0 480 #define EFI_RESET_WARM 1 481 #define EFI_RESET_SHUTDOWN 2 482 483 /* 484 * EFI Runtime Services table 485 */ 486 #define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL) 487 #define EFI_RUNTIME_SERVICES_REVISION 0x00010000 488 489 typedef struct { 490 efi_table_hdr_t hdr; 491 u32 get_time; 492 u32 set_time; 493 u32 get_wakeup_time; 494 u32 set_wakeup_time; 495 u32 set_virtual_address_map; 496 u32 convert_pointer; 497 u32 get_variable; 498 u32 get_next_variable; 499 u32 set_variable; 500 u32 get_next_high_mono_count; 501 u32 reset_system; 502 u32 update_capsule; 503 u32 query_capsule_caps; 504 u32 query_variable_info; 505 } efi_runtime_services_32_t; 506 507 typedef struct { 508 efi_table_hdr_t hdr; 509 u64 get_time; 510 u64 set_time; 511 u64 get_wakeup_time; 512 u64 set_wakeup_time; 513 u64 set_virtual_address_map; 514 u64 convert_pointer; 515 u64 get_variable; 516 u64 get_next_variable; 517 u64 set_variable; 518 u64 get_next_high_mono_count; 519 u64 reset_system; 520 u64 update_capsule; 521 u64 query_capsule_caps; 522 u64 query_variable_info; 523 } efi_runtime_services_64_t; 524 525 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc); 526 typedef efi_status_t efi_set_time_t (efi_time_t *tm); 527 typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending, 528 efi_time_t *tm); 529 typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm); 530 typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr, 531 unsigned long *data_size, void *data); 532 typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name, 533 efi_guid_t *vendor); 534 typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor, 535 u32 attr, unsigned long data_size, 536 void *data); 537 typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count); 538 typedef void efi_reset_system_t (int reset_type, efi_status_t status, 539 unsigned long data_size, efi_char16_t *data); 540 typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size, 541 unsigned long descriptor_size, 542 u32 descriptor_version, 543 efi_memory_desc_t *virtual_map); 544 typedef efi_status_t efi_query_variable_info_t(u32 attr, 545 u64 *storage_space, 546 u64 *remaining_space, 547 u64 *max_variable_size); 548 typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules, 549 unsigned long count, 550 unsigned long sg_list); 551 typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules, 552 unsigned long count, 553 u64 *max_size, 554 int *reset_type); 555 typedef efi_status_t efi_query_variable_store_t(u32 attributes, 556 unsigned long size, 557 bool nonblocking); 558 559 typedef struct { 560 efi_table_hdr_t hdr; 561 efi_get_time_t *get_time; 562 efi_set_time_t *set_time; 563 efi_get_wakeup_time_t *get_wakeup_time; 564 efi_set_wakeup_time_t *set_wakeup_time; 565 efi_set_virtual_address_map_t *set_virtual_address_map; 566 void *convert_pointer; 567 efi_get_variable_t *get_variable; 568 efi_get_next_variable_t *get_next_variable; 569 efi_set_variable_t *set_variable; 570 efi_get_next_high_mono_count_t *get_next_high_mono_count; 571 efi_reset_system_t *reset_system; 572 efi_update_capsule_t *update_capsule; 573 efi_query_capsule_caps_t *query_capsule_caps; 574 efi_query_variable_info_t *query_variable_info; 575 } efi_runtime_services_t; 576 577 void efi_native_runtime_setup(void); 578 579 /* 580 * EFI Configuration Table and GUID definitions 581 * 582 * These are all defined in a single line to make them easier to 583 * grep for and to see them at a glance - while still having a 584 * similar structure to the definitions in the spec. 585 * 586 * Here's how they are structured: 587 * 588 * GUID: 12345678-1234-1234-1234-123456789012 589 * Spec: 590 * #define EFI_SOME_PROTOCOL_GUID \ 591 * {0x12345678,0x1234,0x1234,\ 592 * {0x12,0x34,0x12,0x34,0x56,0x78,0x90,0x12}} 593 * Here: 594 * #define SOME_PROTOCOL_GUID EFI_GUID(0x12345678, 0x1234, 0x1234, 0x12, 0x34, 0x12, 0x34, 0x56, 0x78, 0x90, 0x12) 595 * ^ tabs ^extra space 596 * 597 * Note that the 'extra space' separates the values at the same place 598 * where the UEFI SPEC breaks the line. 599 */ 600 #define NULL_GUID EFI_GUID(0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00) 601 #define MPS_TABLE_GUID EFI_GUID(0xeb9d2d2f, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d) 602 #define ACPI_TABLE_GUID EFI_GUID(0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d) 603 #define ACPI_20_TABLE_GUID EFI_GUID(0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x00, 0x80, 0xc7, 0x3c, 0x88, 0x81) 604 #define SMBIOS_TABLE_GUID EFI_GUID(0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d) 605 #define SMBIOS3_TABLE_GUID EFI_GUID(0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94) 606 #define SAL_SYSTEM_TABLE_GUID EFI_GUID(0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d) 607 #define HCDP_TABLE_GUID EFI_GUID(0xf951938d, 0x620b, 0x42ef, 0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98) 608 #define UGA_IO_PROTOCOL_GUID EFI_GUID(0x61a4d49e, 0x6f68, 0x4f1b, 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0x0b, 0x07, 0xa2) 609 #define EFI_GLOBAL_VARIABLE_GUID EFI_GUID(0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c) 610 #define UV_SYSTEM_TABLE_GUID EFI_GUID(0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93) 611 #define LINUX_EFI_CRASH_GUID EFI_GUID(0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0) 612 #define LOADED_IMAGE_PROTOCOL_GUID EFI_GUID(0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) 613 #define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID EFI_GUID(0x9042a9de, 0x23dc, 0x4a38, 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a) 614 #define EFI_UGA_PROTOCOL_GUID EFI_GUID(0x982c298b, 0xf4fa, 0x41cb, 0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39) 615 #define EFI_PCI_IO_PROTOCOL_GUID EFI_GUID(0x4cf5b200, 0x68b8, 0x4ca5, 0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x02, 0x9a) 616 #define EFI_FILE_INFO_ID EFI_GUID(0x09576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) 617 #define EFI_SYSTEM_RESOURCE_TABLE_GUID EFI_GUID(0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80) 618 #define EFI_FILE_SYSTEM_GUID EFI_GUID(0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b) 619 #define DEVICE_TREE_GUID EFI_GUID(0xb1b621d5, 0xf19c, 0x41a5, 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0) 620 #define EFI_PROPERTIES_TABLE_GUID EFI_GUID(0x880aaca3, 0x4adc, 0x4a04, 0x90, 0x79, 0xb7, 0x47, 0x34, 0x08, 0x25, 0xe5) 621 #define EFI_RNG_PROTOCOL_GUID EFI_GUID(0x3152bca5, 0xeade, 0x433d, 0x86, 0x2e, 0xc0, 0x1c, 0xdc, 0x29, 0x1f, 0x44) 622 #define EFI_RNG_ALGORITHM_RAW EFI_GUID(0xe43176d7, 0xb6e8, 0x4827, 0xb7, 0x84, 0x7f, 0xfd, 0xc4, 0xb6, 0x85, 0x61) 623 #define EFI_MEMORY_ATTRIBUTES_TABLE_GUID EFI_GUID(0xdcfa911d, 0x26eb, 0x469f, 0xa2, 0x20, 0x38, 0xb7, 0xdc, 0x46, 0x12, 0x20) 624 #define EFI_CONSOLE_OUT_DEVICE_GUID EFI_GUID(0xd3b36f2c, 0xd551, 0x11d4, 0x9a, 0x46, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d) 625 #define APPLE_PROPERTIES_PROTOCOL_GUID EFI_GUID(0x91bd12fe, 0xf6c3, 0x44fb, 0xa5, 0xb7, 0x51, 0x22, 0xab, 0x30, 0x3a, 0xe0) 626 627 #define EFI_IMAGE_SECURITY_DATABASE_GUID EFI_GUID(0xd719b2cb, 0x3d3a, 0x4596, 0xa3, 0xbc, 0xda, 0xd0, 0x0e, 0x67, 0x65, 0x6f) 628 #define EFI_SHIM_LOCK_GUID EFI_GUID(0x605dab50, 0xe046, 0x4300, 0xab, 0xb6, 0x3d, 0xd8, 0x10, 0xdd, 0x8b, 0x23) 629 630 /* 631 * This GUID is used to pass to the kernel proper the struct screen_info 632 * structure that was populated by the stub based on the GOP protocol instance 633 * associated with ConOut 634 */ 635 #define LINUX_EFI_ARM_SCREEN_INFO_TABLE_GUID EFI_GUID(0xe03fc20a, 0x85dc, 0x406e, 0xb9, 0x0e, 0x4a, 0xb5, 0x02, 0x37, 0x1d, 0x95) 636 #define LINUX_EFI_LOADER_ENTRY_GUID EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf, 0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f) 637 #define LINUX_EFI_RANDOM_SEED_TABLE_GUID EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2, 0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b) 638 639 typedef struct { 640 efi_guid_t guid; 641 u64 table; 642 } efi_config_table_64_t; 643 644 typedef struct { 645 efi_guid_t guid; 646 u32 table; 647 } efi_config_table_32_t; 648 649 typedef struct { 650 efi_guid_t guid; 651 unsigned long table; 652 } efi_config_table_t; 653 654 typedef struct { 655 efi_guid_t guid; 656 const char *name; 657 unsigned long *ptr; 658 } efi_config_table_type_t; 659 660 #define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL) 661 662 #define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30)) 663 #define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20)) 664 #define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10)) 665 #define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00)) 666 #define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10)) 667 #define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02)) 668 669 typedef struct { 670 efi_table_hdr_t hdr; 671 u64 fw_vendor; /* physical addr of CHAR16 vendor string */ 672 u32 fw_revision; 673 u32 __pad1; 674 u64 con_in_handle; 675 u64 con_in; 676 u64 con_out_handle; 677 u64 con_out; 678 u64 stderr_handle; 679 u64 stderr; 680 u64 runtime; 681 u64 boottime; 682 u32 nr_tables; 683 u32 __pad2; 684 u64 tables; 685 } efi_system_table_64_t; 686 687 typedef struct { 688 efi_table_hdr_t hdr; 689 u32 fw_vendor; /* physical addr of CHAR16 vendor string */ 690 u32 fw_revision; 691 u32 con_in_handle; 692 u32 con_in; 693 u32 con_out_handle; 694 u32 con_out; 695 u32 stderr_handle; 696 u32 stderr; 697 u32 runtime; 698 u32 boottime; 699 u32 nr_tables; 700 u32 tables; 701 } efi_system_table_32_t; 702 703 typedef struct { 704 efi_table_hdr_t hdr; 705 unsigned long fw_vendor; /* physical addr of CHAR16 vendor string */ 706 u32 fw_revision; 707 unsigned long con_in_handle; 708 unsigned long con_in; 709 unsigned long con_out_handle; 710 unsigned long con_out; 711 unsigned long stderr_handle; 712 unsigned long stderr; 713 efi_runtime_services_t *runtime; 714 efi_boot_services_t *boottime; 715 unsigned long nr_tables; 716 unsigned long tables; 717 } efi_system_table_t; 718 719 /* 720 * Architecture independent structure for describing a memory map for the 721 * benefit of efi_memmap_init_early(), saving us the need to pass four 722 * parameters. 723 */ 724 struct efi_memory_map_data { 725 phys_addr_t phys_map; 726 unsigned long size; 727 unsigned long desc_version; 728 unsigned long desc_size; 729 }; 730 731 struct efi_memory_map { 732 phys_addr_t phys_map; 733 void *map; 734 void *map_end; 735 int nr_map; 736 unsigned long desc_version; 737 unsigned long desc_size; 738 bool late; 739 }; 740 741 struct efi_mem_range { 742 struct range range; 743 u64 attribute; 744 }; 745 746 struct efi_fdt_params { 747 u64 system_table; 748 u64 mmap; 749 u32 mmap_size; 750 u32 desc_size; 751 u32 desc_ver; 752 }; 753 754 typedef struct { 755 u32 revision; 756 u32 parent_handle; 757 u32 system_table; 758 u32 device_handle; 759 u32 file_path; 760 u32 reserved; 761 u32 load_options_size; 762 u32 load_options; 763 u32 image_base; 764 __aligned_u64 image_size; 765 unsigned int image_code_type; 766 unsigned int image_data_type; 767 unsigned long unload; 768 } efi_loaded_image_32_t; 769 770 typedef struct { 771 u32 revision; 772 u64 parent_handle; 773 u64 system_table; 774 u64 device_handle; 775 u64 file_path; 776 u64 reserved; 777 u32 load_options_size; 778 u64 load_options; 779 u64 image_base; 780 __aligned_u64 image_size; 781 unsigned int image_code_type; 782 unsigned int image_data_type; 783 unsigned long unload; 784 } efi_loaded_image_64_t; 785 786 typedef struct { 787 u32 revision; 788 void *parent_handle; 789 efi_system_table_t *system_table; 790 void *device_handle; 791 void *file_path; 792 void *reserved; 793 u32 load_options_size; 794 void *load_options; 795 void *image_base; 796 __aligned_u64 image_size; 797 unsigned int image_code_type; 798 unsigned int image_data_type; 799 unsigned long unload; 800 } efi_loaded_image_t; 801 802 803 typedef struct { 804 u64 size; 805 u64 file_size; 806 u64 phys_size; 807 efi_time_t create_time; 808 efi_time_t last_access_time; 809 efi_time_t modification_time; 810 __aligned_u64 attribute; 811 efi_char16_t filename[1]; 812 } efi_file_info_t; 813 814 typedef struct { 815 u64 revision; 816 u32 open; 817 u32 close; 818 u32 delete; 819 u32 read; 820 u32 write; 821 u32 get_position; 822 u32 set_position; 823 u32 get_info; 824 u32 set_info; 825 u32 flush; 826 } efi_file_handle_32_t; 827 828 typedef struct { 829 u64 revision; 830 u64 open; 831 u64 close; 832 u64 delete; 833 u64 read; 834 u64 write; 835 u64 get_position; 836 u64 set_position; 837 u64 get_info; 838 u64 set_info; 839 u64 flush; 840 } efi_file_handle_64_t; 841 842 typedef struct _efi_file_handle { 843 u64 revision; 844 efi_status_t (*open)(struct _efi_file_handle *, 845 struct _efi_file_handle **, 846 efi_char16_t *, u64, u64); 847 efi_status_t (*close)(struct _efi_file_handle *); 848 void *delete; 849 efi_status_t (*read)(struct _efi_file_handle *, unsigned long *, 850 void *); 851 void *write; 852 void *get_position; 853 void *set_position; 854 efi_status_t (*get_info)(struct _efi_file_handle *, efi_guid_t *, 855 unsigned long *, void *); 856 void *set_info; 857 void *flush; 858 } efi_file_handle_t; 859 860 typedef struct _efi_file_io_interface { 861 u64 revision; 862 int (*open_volume)(struct _efi_file_io_interface *, 863 efi_file_handle_t **); 864 } efi_file_io_interface_t; 865 866 #define EFI_FILE_MODE_READ 0x0000000000000001 867 #define EFI_FILE_MODE_WRITE 0x0000000000000002 868 #define EFI_FILE_MODE_CREATE 0x8000000000000000 869 870 typedef struct { 871 u32 version; 872 u32 length; 873 u64 memory_protection_attribute; 874 } efi_properties_table_t; 875 876 #define EFI_PROPERTIES_TABLE_VERSION 0x00010000 877 #define EFI_PROPERTIES_RUNTIME_MEMORY_PROTECTION_NON_EXECUTABLE_PE_DATA 0x1 878 879 #define EFI_INVALID_TABLE_ADDR (~0UL) 880 881 typedef struct { 882 u32 version; 883 u32 num_entries; 884 u32 desc_size; 885 u32 reserved; 886 efi_memory_desc_t entry[0]; 887 } efi_memory_attributes_table_t; 888 889 /* 890 * All runtime access to EFI goes through this structure: 891 */ 892 extern struct efi { 893 efi_system_table_t *systab; /* EFI system table */ 894 unsigned int runtime_version; /* Runtime services version */ 895 unsigned long mps; /* MPS table */ 896 unsigned long acpi; /* ACPI table (IA64 ext 0.71) */ 897 unsigned long acpi20; /* ACPI table (ACPI 2.0) */ 898 unsigned long smbios; /* SMBIOS table (32 bit entry point) */ 899 unsigned long smbios3; /* SMBIOS table (64 bit entry point) */ 900 unsigned long sal_systab; /* SAL system table */ 901 unsigned long boot_info; /* boot info table */ 902 unsigned long hcdp; /* HCDP table */ 903 unsigned long uga; /* UGA table */ 904 unsigned long uv_systab; /* UV system table */ 905 unsigned long fw_vendor; /* fw_vendor */ 906 unsigned long runtime; /* runtime table */ 907 unsigned long config_table; /* config tables */ 908 unsigned long esrt; /* ESRT table */ 909 unsigned long properties_table; /* properties table */ 910 unsigned long mem_attr_table; /* memory attributes table */ 911 unsigned long rng_seed; /* UEFI firmware random seed */ 912 efi_get_time_t *get_time; 913 efi_set_time_t *set_time; 914 efi_get_wakeup_time_t *get_wakeup_time; 915 efi_set_wakeup_time_t *set_wakeup_time; 916 efi_get_variable_t *get_variable; 917 efi_get_next_variable_t *get_next_variable; 918 efi_set_variable_t *set_variable; 919 efi_set_variable_t *set_variable_nonblocking; 920 efi_query_variable_info_t *query_variable_info; 921 efi_query_variable_info_t *query_variable_info_nonblocking; 922 efi_update_capsule_t *update_capsule; 923 efi_query_capsule_caps_t *query_capsule_caps; 924 efi_get_next_high_mono_count_t *get_next_high_mono_count; 925 efi_reset_system_t *reset_system; 926 efi_set_virtual_address_map_t *set_virtual_address_map; 927 struct efi_memory_map memmap; 928 unsigned long flags; 929 } efi; 930 931 static inline int 932 efi_guidcmp (efi_guid_t left, efi_guid_t right) 933 { 934 return memcmp(&left, &right, sizeof (efi_guid_t)); 935 } 936 937 static inline char * 938 efi_guid_to_str(efi_guid_t *guid, char *out) 939 { 940 sprintf(out, "%pUl", guid->b); 941 return out; 942 } 943 944 extern void efi_init (void); 945 extern void *efi_get_pal_addr (void); 946 extern void efi_map_pal_code (void); 947 extern void efi_memmap_walk (efi_freemem_callback_t callback, void *arg); 948 extern void efi_gettimeofday (struct timespec64 *ts); 949 extern void efi_enter_virtual_mode (void); /* switch EFI to virtual mode, if possible */ 950 #ifdef CONFIG_X86 951 extern void efi_late_init(void); 952 extern void efi_free_boot_services(void); 953 extern efi_status_t efi_query_variable_store(u32 attributes, 954 unsigned long size, 955 bool nonblocking); 956 extern void efi_find_mirror(void); 957 #else 958 static inline void efi_late_init(void) {} 959 static inline void efi_free_boot_services(void) {} 960 961 static inline efi_status_t efi_query_variable_store(u32 attributes, 962 unsigned long size, 963 bool nonblocking) 964 { 965 return EFI_SUCCESS; 966 } 967 #endif 968 extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr); 969 970 extern phys_addr_t __init efi_memmap_alloc(unsigned int num_entries); 971 extern int __init efi_memmap_init_early(struct efi_memory_map_data *data); 972 extern int __init efi_memmap_init_late(phys_addr_t addr, unsigned long size); 973 extern void __init efi_memmap_unmap(void); 974 extern int __init efi_memmap_install(phys_addr_t addr, unsigned int nr_map); 975 extern int __init efi_memmap_split_count(efi_memory_desc_t *md, 976 struct range *range); 977 extern void __init efi_memmap_insert(struct efi_memory_map *old_memmap, 978 void *buf, struct efi_mem_range *mem); 979 980 extern int efi_config_init(efi_config_table_type_t *arch_tables); 981 #ifdef CONFIG_EFI_ESRT 982 extern void __init efi_esrt_init(void); 983 #else 984 static inline void efi_esrt_init(void) { } 985 #endif 986 extern int efi_config_parse_tables(void *config_tables, int count, int sz, 987 efi_config_table_type_t *arch_tables); 988 extern u64 efi_get_iobase (void); 989 extern int efi_mem_type(unsigned long phys_addr); 990 extern u64 efi_mem_attributes (unsigned long phys_addr); 991 extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size); 992 extern int __init efi_uart_console_only (void); 993 extern u64 efi_mem_desc_end(efi_memory_desc_t *md); 994 extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md); 995 extern void efi_mem_reserve(phys_addr_t addr, u64 size); 996 extern void efi_initialize_iomem_resources(struct resource *code_resource, 997 struct resource *data_resource, struct resource *bss_resource); 998 extern void efi_reserve_boot_services(void); 999 extern int efi_get_fdt_params(struct efi_fdt_params *params); 1000 extern struct kobject *efi_kobj; 1001 1002 extern int efi_reboot_quirk_mode; 1003 extern bool efi_poweroff_required(void); 1004 1005 #ifdef CONFIG_EFI_FAKE_MEMMAP 1006 extern void __init efi_fake_memmap(void); 1007 #else 1008 static inline void efi_fake_memmap(void) { } 1009 #endif 1010 1011 /* 1012 * efi_memattr_perm_setter - arch specific callback function passed into 1013 * efi_memattr_apply_permissions() that updates the 1014 * mapping permissions described by the second 1015 * argument in the page tables referred to by the 1016 * first argument. 1017 */ 1018 typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *); 1019 1020 extern int efi_memattr_init(void); 1021 extern int efi_memattr_apply_permissions(struct mm_struct *mm, 1022 efi_memattr_perm_setter fn); 1023 1024 /* 1025 * efi_early_memdesc_ptr - get the n-th EFI memmap descriptor 1026 * @map: the start of efi memmap 1027 * @desc_size: the size of space for each EFI memmap descriptor 1028 * @n: the index of efi memmap descriptor 1029 * 1030 * EFI boot service provides the GetMemoryMap() function to get a copy of the 1031 * current memory map which is an array of memory descriptors, each of 1032 * which describes a contiguous block of memory. It also gets the size of the 1033 * map, and the size of each descriptor, etc. 1034 * 1035 * Note that per section 6.2 of UEFI Spec 2.6 Errata A, the returned size of 1036 * each descriptor might not be equal to sizeof(efi_memory_memdesc_t), 1037 * since efi_memory_memdesc_t may be extended in the future. Thus the OS 1038 * MUST use the returned size of the descriptor to find the start of each 1039 * efi_memory_memdesc_t in the memory map array. This should only be used 1040 * during bootup since for_each_efi_memory_desc_xxx() is available after the 1041 * kernel initializes the EFI subsystem to set up struct efi_memory_map. 1042 */ 1043 #define efi_early_memdesc_ptr(map, desc_size, n) \ 1044 (efi_memory_desc_t *)((void *)(map) + ((n) * (desc_size))) 1045 1046 /* Iterate through an efi_memory_map */ 1047 #define for_each_efi_memory_desc_in_map(m, md) \ 1048 for ((md) = (m)->map; \ 1049 (md) && ((void *)(md) + (m)->desc_size) <= (m)->map_end; \ 1050 (md) = (void *)(md) + (m)->desc_size) 1051 1052 /** 1053 * for_each_efi_memory_desc - iterate over descriptors in efi.memmap 1054 * @md: the efi_memory_desc_t * iterator 1055 * 1056 * Once the loop finishes @md must not be accessed. 1057 */ 1058 #define for_each_efi_memory_desc(md) \ 1059 for_each_efi_memory_desc_in_map(&efi.memmap, md) 1060 1061 /* 1062 * Format an EFI memory descriptor's type and attributes to a user-provided 1063 * character buffer, as per snprintf(), and return the buffer. 1064 */ 1065 char * __init efi_md_typeattr_format(char *buf, size_t size, 1066 const efi_memory_desc_t *md); 1067 1068 /** 1069 * efi_range_is_wc - check the WC bit on an address range 1070 * @start: starting kvirt address 1071 * @len: length of range 1072 * 1073 * Consult the EFI memory map and make sure it's ok to set this range WC. 1074 * Returns true or false. 1075 */ 1076 static inline int efi_range_is_wc(unsigned long start, unsigned long len) 1077 { 1078 unsigned long i; 1079 1080 for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) { 1081 unsigned long paddr = __pa(start + i); 1082 if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC)) 1083 return 0; 1084 } 1085 /* The range checked out */ 1086 return 1; 1087 } 1088 1089 #ifdef CONFIG_EFI_PCDP 1090 extern int __init efi_setup_pcdp_console(char *); 1091 #endif 1092 1093 /* 1094 * We play games with efi_enabled so that the compiler will, if 1095 * possible, remove EFI-related code altogether. 1096 */ 1097 #define EFI_BOOT 0 /* Were we booted from EFI? */ 1098 #define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */ 1099 #define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */ 1100 #define EFI_MEMMAP 4 /* Can we use EFI memory map? */ 1101 #define EFI_64BIT 5 /* Is the firmware 64-bit? */ 1102 #define EFI_PARAVIRT 6 /* Access is via a paravirt interface */ 1103 #define EFI_ARCH_1 7 /* First arch-specific bit */ 1104 #define EFI_DBG 8 /* Print additional debug info at runtime */ 1105 #define EFI_NX_PE_DATA 9 /* Can runtime data regions be mapped non-executable? */ 1106 #define EFI_MEM_ATTR 10 /* Did firmware publish an EFI_MEMORY_ATTRIBUTES table? */ 1107 1108 #ifdef CONFIG_EFI 1109 /* 1110 * Test whether the above EFI_* bits are enabled. 1111 */ 1112 static inline bool efi_enabled(int feature) 1113 { 1114 return test_bit(feature, &efi.flags) != 0; 1115 } 1116 extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused); 1117 1118 extern bool efi_is_table_address(unsigned long phys_addr); 1119 #else 1120 static inline bool efi_enabled(int feature) 1121 { 1122 return false; 1123 } 1124 static inline void 1125 efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {} 1126 1127 static inline bool 1128 efi_capsule_pending(int *reset_type) 1129 { 1130 return false; 1131 } 1132 1133 static inline bool efi_is_table_address(unsigned long phys_addr) 1134 { 1135 return false; 1136 } 1137 #endif 1138 1139 extern int efi_status_to_err(efi_status_t status); 1140 1141 /* 1142 * Variable Attributes 1143 */ 1144 #define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001 1145 #define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002 1146 #define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004 1147 #define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008 1148 #define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010 1149 #define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020 1150 #define EFI_VARIABLE_APPEND_WRITE 0x0000000000000040 1151 1152 #define EFI_VARIABLE_MASK (EFI_VARIABLE_NON_VOLATILE | \ 1153 EFI_VARIABLE_BOOTSERVICE_ACCESS | \ 1154 EFI_VARIABLE_RUNTIME_ACCESS | \ 1155 EFI_VARIABLE_HARDWARE_ERROR_RECORD | \ 1156 EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \ 1157 EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \ 1158 EFI_VARIABLE_APPEND_WRITE) 1159 /* 1160 * Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee")) 1161 * not including trailing NUL 1162 */ 1163 #define EFI_VARIABLE_GUID_LEN UUID_STRING_LEN 1164 1165 /* 1166 * The type of search to perform when calling boottime->locate_handle 1167 */ 1168 #define EFI_LOCATE_ALL_HANDLES 0 1169 #define EFI_LOCATE_BY_REGISTER_NOTIFY 1 1170 #define EFI_LOCATE_BY_PROTOCOL 2 1171 1172 /* 1173 * EFI Device Path information 1174 */ 1175 #define EFI_DEV_HW 0x01 1176 #define EFI_DEV_PCI 1 1177 #define EFI_DEV_PCCARD 2 1178 #define EFI_DEV_MEM_MAPPED 3 1179 #define EFI_DEV_VENDOR 4 1180 #define EFI_DEV_CONTROLLER 5 1181 #define EFI_DEV_ACPI 0x02 1182 #define EFI_DEV_BASIC_ACPI 1 1183 #define EFI_DEV_EXPANDED_ACPI 2 1184 #define EFI_DEV_MSG 0x03 1185 #define EFI_DEV_MSG_ATAPI 1 1186 #define EFI_DEV_MSG_SCSI 2 1187 #define EFI_DEV_MSG_FC 3 1188 #define EFI_DEV_MSG_1394 4 1189 #define EFI_DEV_MSG_USB 5 1190 #define EFI_DEV_MSG_USB_CLASS 15 1191 #define EFI_DEV_MSG_I20 6 1192 #define EFI_DEV_MSG_MAC 11 1193 #define EFI_DEV_MSG_IPV4 12 1194 #define EFI_DEV_MSG_IPV6 13 1195 #define EFI_DEV_MSG_INFINIBAND 9 1196 #define EFI_DEV_MSG_UART 14 1197 #define EFI_DEV_MSG_VENDOR 10 1198 #define EFI_DEV_MEDIA 0x04 1199 #define EFI_DEV_MEDIA_HARD_DRIVE 1 1200 #define EFI_DEV_MEDIA_CDROM 2 1201 #define EFI_DEV_MEDIA_VENDOR 3 1202 #define EFI_DEV_MEDIA_FILE 4 1203 #define EFI_DEV_MEDIA_PROTOCOL 5 1204 #define EFI_DEV_BIOS_BOOT 0x05 1205 #define EFI_DEV_END_PATH 0x7F 1206 #define EFI_DEV_END_PATH2 0xFF 1207 #define EFI_DEV_END_INSTANCE 0x01 1208 #define EFI_DEV_END_ENTIRE 0xFF 1209 1210 struct efi_generic_dev_path { 1211 u8 type; 1212 u8 sub_type; 1213 u16 length; 1214 } __attribute ((packed)); 1215 1216 struct efi_dev_path { 1217 u8 type; /* can be replaced with unnamed */ 1218 u8 sub_type; /* struct efi_generic_dev_path; */ 1219 u16 length; /* once we've moved to -std=c11 */ 1220 union { 1221 struct { 1222 u32 hid; 1223 u32 uid; 1224 } acpi; 1225 struct { 1226 u8 fn; 1227 u8 dev; 1228 } pci; 1229 }; 1230 } __attribute ((packed)); 1231 1232 #if IS_ENABLED(CONFIG_EFI_DEV_PATH_PARSER) 1233 struct device *efi_get_device_by_path(struct efi_dev_path **node, size_t *len); 1234 #endif 1235 1236 static inline void memrange_efi_to_native(u64 *addr, u64 *npages) 1237 { 1238 *npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr); 1239 *addr &= PAGE_MASK; 1240 } 1241 1242 /* 1243 * EFI Variable support. 1244 * 1245 * Different firmware drivers can expose their EFI-like variables using 1246 * the following. 1247 */ 1248 1249 struct efivar_operations { 1250 efi_get_variable_t *get_variable; 1251 efi_get_next_variable_t *get_next_variable; 1252 efi_set_variable_t *set_variable; 1253 efi_set_variable_t *set_variable_nonblocking; 1254 efi_query_variable_store_t *query_variable_store; 1255 }; 1256 1257 struct efivars { 1258 struct kset *kset; 1259 struct kobject *kobject; 1260 const struct efivar_operations *ops; 1261 }; 1262 1263 /* 1264 * The maximum size of VariableName + Data = 1024 1265 * Therefore, it's reasonable to save that much 1266 * space in each part of the structure, 1267 * and we use a page for reading/writing. 1268 */ 1269 1270 #define EFI_VAR_NAME_LEN 1024 1271 1272 struct efi_variable { 1273 efi_char16_t VariableName[EFI_VAR_NAME_LEN/sizeof(efi_char16_t)]; 1274 efi_guid_t VendorGuid; 1275 unsigned long DataSize; 1276 __u8 Data[1024]; 1277 efi_status_t Status; 1278 __u32 Attributes; 1279 } __attribute__((packed)); 1280 1281 struct efivar_entry { 1282 struct efi_variable var; 1283 struct list_head list; 1284 struct kobject kobj; 1285 bool scanning; 1286 bool deleting; 1287 }; 1288 1289 typedef struct { 1290 u32 reset; 1291 u32 output_string; 1292 u32 test_string; 1293 } efi_simple_text_output_protocol_32_t; 1294 1295 typedef struct { 1296 u64 reset; 1297 u64 output_string; 1298 u64 test_string; 1299 } efi_simple_text_output_protocol_64_t; 1300 1301 struct efi_simple_text_output_protocol { 1302 void *reset; 1303 efi_status_t (*output_string)(void *, void *); 1304 void *test_string; 1305 }; 1306 1307 #define PIXEL_RGB_RESERVED_8BIT_PER_COLOR 0 1308 #define PIXEL_BGR_RESERVED_8BIT_PER_COLOR 1 1309 #define PIXEL_BIT_MASK 2 1310 #define PIXEL_BLT_ONLY 3 1311 #define PIXEL_FORMAT_MAX 4 1312 1313 struct efi_pixel_bitmask { 1314 u32 red_mask; 1315 u32 green_mask; 1316 u32 blue_mask; 1317 u32 reserved_mask; 1318 }; 1319 1320 struct efi_graphics_output_mode_info { 1321 u32 version; 1322 u32 horizontal_resolution; 1323 u32 vertical_resolution; 1324 int pixel_format; 1325 struct efi_pixel_bitmask pixel_information; 1326 u32 pixels_per_scan_line; 1327 } __packed; 1328 1329 struct efi_graphics_output_protocol_mode_32 { 1330 u32 max_mode; 1331 u32 mode; 1332 u32 info; 1333 u32 size_of_info; 1334 u64 frame_buffer_base; 1335 u32 frame_buffer_size; 1336 } __packed; 1337 1338 struct efi_graphics_output_protocol_mode_64 { 1339 u32 max_mode; 1340 u32 mode; 1341 u64 info; 1342 u64 size_of_info; 1343 u64 frame_buffer_base; 1344 u64 frame_buffer_size; 1345 } __packed; 1346 1347 struct efi_graphics_output_protocol_mode { 1348 u32 max_mode; 1349 u32 mode; 1350 unsigned long info; 1351 unsigned long size_of_info; 1352 u64 frame_buffer_base; 1353 unsigned long frame_buffer_size; 1354 } __packed; 1355 1356 struct efi_graphics_output_protocol_32 { 1357 u32 query_mode; 1358 u32 set_mode; 1359 u32 blt; 1360 u32 mode; 1361 }; 1362 1363 struct efi_graphics_output_protocol_64 { 1364 u64 query_mode; 1365 u64 set_mode; 1366 u64 blt; 1367 u64 mode; 1368 }; 1369 1370 struct efi_graphics_output_protocol { 1371 unsigned long query_mode; 1372 unsigned long set_mode; 1373 unsigned long blt; 1374 struct efi_graphics_output_protocol_mode *mode; 1375 }; 1376 1377 typedef efi_status_t (*efi_graphics_output_protocol_query_mode)( 1378 struct efi_graphics_output_protocol *, u32, unsigned long *, 1379 struct efi_graphics_output_mode_info **); 1380 1381 extern struct list_head efivar_sysfs_list; 1382 1383 static inline void 1384 efivar_unregister(struct efivar_entry *var) 1385 { 1386 kobject_put(&var->kobj); 1387 } 1388 1389 int efivars_register(struct efivars *efivars, 1390 const struct efivar_operations *ops, 1391 struct kobject *kobject); 1392 int efivars_unregister(struct efivars *efivars); 1393 struct kobject *efivars_kobject(void); 1394 1395 int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *), 1396 void *data, bool duplicates, struct list_head *head); 1397 1398 int efivar_entry_add(struct efivar_entry *entry, struct list_head *head); 1399 int efivar_entry_remove(struct efivar_entry *entry); 1400 1401 int __efivar_entry_delete(struct efivar_entry *entry); 1402 int efivar_entry_delete(struct efivar_entry *entry); 1403 1404 int efivar_entry_size(struct efivar_entry *entry, unsigned long *size); 1405 int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes, 1406 unsigned long *size, void *data); 1407 int efivar_entry_get(struct efivar_entry *entry, u32 *attributes, 1408 unsigned long *size, void *data); 1409 int efivar_entry_set(struct efivar_entry *entry, u32 attributes, 1410 unsigned long size, void *data, struct list_head *head); 1411 int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes, 1412 unsigned long *size, void *data, bool *set); 1413 int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes, 1414 bool block, unsigned long size, void *data); 1415 1416 int efivar_entry_iter_begin(void); 1417 void efivar_entry_iter_end(void); 1418 1419 int __efivar_entry_iter(int (*func)(struct efivar_entry *, void *), 1420 struct list_head *head, void *data, 1421 struct efivar_entry **prev); 1422 int efivar_entry_iter(int (*func)(struct efivar_entry *, void *), 1423 struct list_head *head, void *data); 1424 1425 struct efivar_entry *efivar_entry_find(efi_char16_t *name, efi_guid_t guid, 1426 struct list_head *head, bool remove); 1427 1428 bool efivar_validate(efi_guid_t vendor, efi_char16_t *var_name, u8 *data, 1429 unsigned long data_size); 1430 bool efivar_variable_is_removable(efi_guid_t vendor, const char *name, 1431 size_t len); 1432 1433 extern struct work_struct efivar_work; 1434 void efivar_run_worker(void); 1435 1436 #if defined(CONFIG_EFI_VARS) || defined(CONFIG_EFI_VARS_MODULE) 1437 int efivars_sysfs_init(void); 1438 1439 #define EFIVARS_DATA_SIZE_MAX 1024 1440 1441 #endif /* CONFIG_EFI_VARS */ 1442 extern bool efi_capsule_pending(int *reset_type); 1443 1444 extern int efi_capsule_supported(efi_guid_t guid, u32 flags, 1445 size_t size, int *reset); 1446 1447 extern int efi_capsule_update(efi_capsule_header_t *capsule, 1448 phys_addr_t *pages); 1449 1450 #ifdef CONFIG_EFI_RUNTIME_MAP 1451 int efi_runtime_map_init(struct kobject *); 1452 int efi_get_runtime_map_size(void); 1453 int efi_get_runtime_map_desc_size(void); 1454 int efi_runtime_map_copy(void *buf, size_t bufsz); 1455 #else 1456 static inline int efi_runtime_map_init(struct kobject *kobj) 1457 { 1458 return 0; 1459 } 1460 1461 static inline int efi_get_runtime_map_size(void) 1462 { 1463 return 0; 1464 } 1465 1466 static inline int efi_get_runtime_map_desc_size(void) 1467 { 1468 return 0; 1469 } 1470 1471 static inline int efi_runtime_map_copy(void *buf, size_t bufsz) 1472 { 1473 return 0; 1474 } 1475 1476 #endif 1477 1478 /* prototypes shared between arch specific and generic stub code */ 1479 1480 void efi_printk(efi_system_table_t *sys_table_arg, char *str); 1481 1482 void efi_free(efi_system_table_t *sys_table_arg, unsigned long size, 1483 unsigned long addr); 1484 1485 char *efi_convert_cmdline(efi_system_table_t *sys_table_arg, 1486 efi_loaded_image_t *image, int *cmd_line_len); 1487 1488 efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg, 1489 struct efi_boot_memmap *map); 1490 1491 efi_status_t efi_low_alloc(efi_system_table_t *sys_table_arg, 1492 unsigned long size, unsigned long align, 1493 unsigned long *addr); 1494 1495 efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg, 1496 unsigned long size, unsigned long align, 1497 unsigned long *addr, unsigned long max); 1498 1499 efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg, 1500 unsigned long *image_addr, 1501 unsigned long image_size, 1502 unsigned long alloc_size, 1503 unsigned long preferred_addr, 1504 unsigned long alignment); 1505 1506 efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg, 1507 efi_loaded_image_t *image, 1508 char *cmd_line, char *option_string, 1509 unsigned long max_addr, 1510 unsigned long *load_addr, 1511 unsigned long *load_size); 1512 1513 efi_status_t efi_parse_options(char const *cmdline); 1514 1515 efi_status_t efi_setup_gop(efi_system_table_t *sys_table_arg, 1516 struct screen_info *si, efi_guid_t *proto, 1517 unsigned long size); 1518 1519 bool efi_runtime_disabled(void); 1520 extern void efi_call_virt_check_flags(unsigned long flags, const char *call); 1521 1522 enum efi_secureboot_mode { 1523 efi_secureboot_mode_unset, 1524 efi_secureboot_mode_unknown, 1525 efi_secureboot_mode_disabled, 1526 efi_secureboot_mode_enabled, 1527 }; 1528 enum efi_secureboot_mode efi_get_secureboot(efi_system_table_t *sys_table); 1529 1530 #ifdef CONFIG_RESET_ATTACK_MITIGATION 1531 void efi_enable_reset_attack_mitigation(efi_system_table_t *sys_table_arg); 1532 #else 1533 static inline void 1534 efi_enable_reset_attack_mitigation(efi_system_table_t *sys_table_arg) { } 1535 #endif 1536 1537 /* 1538 * Arch code can implement the following three template macros, avoiding 1539 * reptition for the void/non-void return cases of {__,}efi_call_virt(): 1540 * 1541 * * arch_efi_call_virt_setup() 1542 * 1543 * Sets up the environment for the call (e.g. switching page tables, 1544 * allowing kernel-mode use of floating point, if required). 1545 * 1546 * * arch_efi_call_virt() 1547 * 1548 * Performs the call. The last expression in the macro must be the call 1549 * itself, allowing the logic to be shared by the void and non-void 1550 * cases. 1551 * 1552 * * arch_efi_call_virt_teardown() 1553 * 1554 * Restores the usual kernel environment once the call has returned. 1555 */ 1556 1557 #define efi_call_virt_pointer(p, f, args...) \ 1558 ({ \ 1559 efi_status_t __s; \ 1560 unsigned long __flags; \ 1561 \ 1562 arch_efi_call_virt_setup(); \ 1563 \ 1564 local_save_flags(__flags); \ 1565 __s = arch_efi_call_virt(p, f, args); \ 1566 efi_call_virt_check_flags(__flags, __stringify(f)); \ 1567 \ 1568 arch_efi_call_virt_teardown(); \ 1569 \ 1570 __s; \ 1571 }) 1572 1573 #define __efi_call_virt_pointer(p, f, args...) \ 1574 ({ \ 1575 unsigned long __flags; \ 1576 \ 1577 arch_efi_call_virt_setup(); \ 1578 \ 1579 local_save_flags(__flags); \ 1580 arch_efi_call_virt(p, f, args); \ 1581 efi_call_virt_check_flags(__flags, __stringify(f)); \ 1582 \ 1583 arch_efi_call_virt_teardown(); \ 1584 }) 1585 1586 typedef efi_status_t (*efi_exit_boot_map_processing)( 1587 efi_system_table_t *sys_table_arg, 1588 struct efi_boot_memmap *map, 1589 void *priv); 1590 1591 efi_status_t efi_exit_boot_services(efi_system_table_t *sys_table, 1592 void *handle, 1593 struct efi_boot_memmap *map, 1594 void *priv, 1595 efi_exit_boot_map_processing priv_func); 1596 1597 #define EFI_RANDOM_SEED_SIZE 64U 1598 1599 struct linux_efi_random_seed { 1600 u32 size; 1601 u8 bits[]; 1602 }; 1603 1604 #endif /* _LINUX_EFI_H */ 1605