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