2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _LINUX_EFI_H
|
|
|
|
#define _LINUX_EFI_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Extensible Firmware Interface
|
|
|
|
* Based on 'Extensible Firmware Interface Specification' version 0.9, April 30, 1999
|
|
|
|
*
|
|
|
|
* Copyright (C) 1999 VA Linux Systems
|
|
|
|
* Copyright (C) 1999 Walt Drummond <drummond@valinux.com>
|
|
|
|
* Copyright (C) 1999, 2002-2003 Hewlett-Packard Co.
|
|
|
|
* David Mosberger-Tang <davidm@hpl.hp.com>
|
|
|
|
* Stephane Eranian <eranian@hpl.hp.com>
|
|
|
|
*/
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/time.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/rtc.h>
|
|
|
|
#include <linux/ioport.h>
|
2008-02-25 07:18:37 +00:00
|
|
|
#include <linux/pfn.h>
|
2011-07-21 20:57:56 +00:00
|
|
|
#include <linux/pstore.h>
|
2014-06-13 11:22:22 +00:00
|
|
|
#include <linux/reboot.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#include <asm/page.h>
|
|
|
|
|
|
|
|
#define EFI_SUCCESS 0
|
|
|
|
#define EFI_LOAD_ERROR ( 1 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_INVALID_PARAMETER ( 2 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_UNSUPPORTED ( 3 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_BAD_BUFFER_SIZE ( 4 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_BUFFER_TOO_SMALL ( 5 | (1UL << (BITS_PER_LONG-1)))
|
2012-10-05 05:54:56 +00:00
|
|
|
#define EFI_NOT_READY ( 6 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_DEVICE_ERROR ( 7 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_WRITE_PROTECTED ( 8 | (1UL << (BITS_PER_LONG-1)))
|
|
|
|
#define EFI_OUT_OF_RESOURCES ( 9 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EFI_NOT_FOUND (14 | (1UL << (BITS_PER_LONG-1)))
|
2012-10-05 05:54:56 +00:00
|
|
|
#define EFI_SECURITY_VIOLATION (26 | (1UL << (BITS_PER_LONG-1)))
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
typedef unsigned long efi_status_t;
|
|
|
|
typedef u8 efi_bool_t;
|
|
|
|
typedef u16 efi_char16_t; /* UNICODE character */
|
2013-09-22 22:45:26 +00:00
|
|
|
typedef u64 efi_physical_addr_t;
|
|
|
|
typedef void *efi_handle_t;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u8 b[16];
|
|
|
|
} efi_guid_t;
|
|
|
|
|
|
|
|
#define EFI_GUID(a,b,c,d0,d1,d2,d3,d4,d5,d6,d7) \
|
|
|
|
((efi_guid_t) \
|
|
|
|
{{ (a) & 0xff, ((a) >> 8) & 0xff, ((a) >> 16) & 0xff, ((a) >> 24) & 0xff, \
|
|
|
|
(b) & 0xff, ((b) >> 8) & 0xff, \
|
|
|
|
(c) & 0xff, ((c) >> 8) & 0xff, \
|
|
|
|
(d0), (d1), (d2), (d3), (d4), (d5), (d6), (d7) }})
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Generic EFI table header
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
u64 signature;
|
|
|
|
u32 revision;
|
|
|
|
u32 headersize;
|
|
|
|
u32 crc32;
|
|
|
|
u32 reserved;
|
|
|
|
} efi_table_hdr_t;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Memory map descriptor:
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* Memory types: */
|
|
|
|
#define EFI_RESERVED_TYPE 0
|
|
|
|
#define EFI_LOADER_CODE 1
|
|
|
|
#define EFI_LOADER_DATA 2
|
|
|
|
#define EFI_BOOT_SERVICES_CODE 3
|
|
|
|
#define EFI_BOOT_SERVICES_DATA 4
|
|
|
|
#define EFI_RUNTIME_SERVICES_CODE 5
|
|
|
|
#define EFI_RUNTIME_SERVICES_DATA 6
|
|
|
|
#define EFI_CONVENTIONAL_MEMORY 7
|
|
|
|
#define EFI_UNUSABLE_MEMORY 8
|
|
|
|
#define EFI_ACPI_RECLAIM_MEMORY 9
|
|
|
|
#define EFI_ACPI_MEMORY_NVS 10
|
|
|
|
#define EFI_MEMORY_MAPPED_IO 11
|
|
|
|
#define EFI_MEMORY_MAPPED_IO_PORT_SPACE 12
|
|
|
|
#define EFI_PAL_CODE 13
|
2015-04-03 16:05:28 +00:00
|
|
|
#define EFI_PERSISTENT_MEMORY 14
|
|
|
|
#define EFI_MAX_MEMORY_TYPE 15
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Attribute values: */
|
|
|
|
#define EFI_MEMORY_UC ((u64)0x0000000000000001ULL) /* uncached */
|
|
|
|
#define EFI_MEMORY_WC ((u64)0x0000000000000002ULL) /* write-coalescing */
|
|
|
|
#define EFI_MEMORY_WT ((u64)0x0000000000000004ULL) /* write-through */
|
|
|
|
#define EFI_MEMORY_WB ((u64)0x0000000000000008ULL) /* write-back */
|
2014-09-03 11:32:19 +00:00
|
|
|
#define EFI_MEMORY_UCE ((u64)0x0000000000000010ULL) /* uncached, exported */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EFI_MEMORY_WP ((u64)0x0000000000001000ULL) /* write-protect */
|
|
|
|
#define EFI_MEMORY_RP ((u64)0x0000000000002000ULL) /* read-protect */
|
|
|
|
#define EFI_MEMORY_XP ((u64)0x0000000000004000ULL) /* execute-protect */
|
2015-06-24 23:58:15 +00:00
|
|
|
#define EFI_MEMORY_MORE_RELIABLE \
|
|
|
|
((u64)0x0000000000010000ULL) /* higher reliability */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EFI_MEMORY_RUNTIME ((u64)0x8000000000000000ULL) /* range requires runtime mapping */
|
|
|
|
#define EFI_MEMORY_DESCRIPTOR_VERSION 1
|
|
|
|
|
|
|
|
#define EFI_PAGE_SHIFT 12
|
2013-09-22 22:45:26 +00:00
|
|
|
#define EFI_PAGE_SIZE (1UL << EFI_PAGE_SHIFT)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 type;
|
|
|
|
u32 pad;
|
|
|
|
u64 phys_addr;
|
|
|
|
u64 virt_addr;
|
|
|
|
u64 num_pages;
|
|
|
|
u64 attribute;
|
|
|
|
} efi_memory_desc_t;
|
|
|
|
|
2011-06-06 19:36:25 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u32 headersize;
|
|
|
|
u32 flags;
|
|
|
|
u32 imagesize;
|
|
|
|
} efi_capsule_header_t;
|
|
|
|
|
2011-11-15 12:57:03 +00:00
|
|
|
/*
|
|
|
|
* Allocation types for calls to boottime->allocate_pages.
|
|
|
|
*/
|
|
|
|
#define EFI_ALLOCATE_ANY_PAGES 0
|
|
|
|
#define EFI_ALLOCATE_MAX_ADDRESS 1
|
|
|
|
#define EFI_ALLOCATE_ADDRESS 2
|
|
|
|
#define EFI_MAX_ALLOCATE_TYPE 3
|
|
|
|
|
2009-05-22 20:49:49 +00:00
|
|
|
typedef int (*efi_freemem_callback_t) (u64 start, u64 end, void *arg);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Types and defines for Time Services
|
|
|
|
*/
|
|
|
|
#define EFI_TIME_ADJUST_DAYLIGHT 0x1
|
|
|
|
#define EFI_TIME_IN_DAYLIGHT 0x2
|
|
|
|
#define EFI_UNSPECIFIED_TIMEZONE 0x07ff
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u16 year;
|
|
|
|
u8 month;
|
|
|
|
u8 day;
|
|
|
|
u8 hour;
|
|
|
|
u8 minute;
|
|
|
|
u8 second;
|
|
|
|
u8 pad1;
|
|
|
|
u32 nanosecond;
|
|
|
|
s16 timezone;
|
|
|
|
u8 daylight;
|
|
|
|
u8 pad2;
|
|
|
|
} efi_time_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 resolution;
|
|
|
|
u32 accuracy;
|
|
|
|
u8 sets_to_zero;
|
|
|
|
} efi_time_cap_t;
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u32 raise_tpl;
|
|
|
|
u32 restore_tpl;
|
|
|
|
u32 allocate_pages;
|
|
|
|
u32 free_pages;
|
|
|
|
u32 get_memory_map;
|
|
|
|
u32 allocate_pool;
|
|
|
|
u32 free_pool;
|
|
|
|
u32 create_event;
|
|
|
|
u32 set_timer;
|
|
|
|
u32 wait_for_event;
|
|
|
|
u32 signal_event;
|
|
|
|
u32 close_event;
|
|
|
|
u32 check_event;
|
|
|
|
u32 install_protocol_interface;
|
|
|
|
u32 reinstall_protocol_interface;
|
|
|
|
u32 uninstall_protocol_interface;
|
|
|
|
u32 handle_protocol;
|
|
|
|
u32 __reserved;
|
|
|
|
u32 register_protocol_notify;
|
|
|
|
u32 locate_handle;
|
|
|
|
u32 locate_device_path;
|
|
|
|
u32 install_configuration_table;
|
|
|
|
u32 load_image;
|
|
|
|
u32 start_image;
|
|
|
|
u32 exit;
|
|
|
|
u32 unload_image;
|
|
|
|
u32 exit_boot_services;
|
|
|
|
u32 get_next_monotonic_count;
|
|
|
|
u32 stall;
|
|
|
|
u32 set_watchdog_timer;
|
|
|
|
u32 connect_controller;
|
|
|
|
u32 disconnect_controller;
|
|
|
|
u32 open_protocol;
|
|
|
|
u32 close_protocol;
|
|
|
|
u32 open_protocol_information;
|
|
|
|
u32 protocols_per_handle;
|
|
|
|
u32 locate_handle_buffer;
|
|
|
|
u32 locate_protocol;
|
|
|
|
u32 install_multiple_protocol_interfaces;
|
|
|
|
u32 uninstall_multiple_protocol_interfaces;
|
|
|
|
u32 calculate_crc32;
|
|
|
|
u32 copy_mem;
|
|
|
|
u32 set_mem;
|
|
|
|
u32 create_event_ex;
|
|
|
|
} __packed efi_boot_services_32_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u64 raise_tpl;
|
|
|
|
u64 restore_tpl;
|
|
|
|
u64 allocate_pages;
|
|
|
|
u64 free_pages;
|
|
|
|
u64 get_memory_map;
|
|
|
|
u64 allocate_pool;
|
|
|
|
u64 free_pool;
|
|
|
|
u64 create_event;
|
|
|
|
u64 set_timer;
|
|
|
|
u64 wait_for_event;
|
|
|
|
u64 signal_event;
|
|
|
|
u64 close_event;
|
|
|
|
u64 check_event;
|
|
|
|
u64 install_protocol_interface;
|
|
|
|
u64 reinstall_protocol_interface;
|
|
|
|
u64 uninstall_protocol_interface;
|
|
|
|
u64 handle_protocol;
|
|
|
|
u64 __reserved;
|
|
|
|
u64 register_protocol_notify;
|
|
|
|
u64 locate_handle;
|
|
|
|
u64 locate_device_path;
|
|
|
|
u64 install_configuration_table;
|
|
|
|
u64 load_image;
|
|
|
|
u64 start_image;
|
|
|
|
u64 exit;
|
|
|
|
u64 unload_image;
|
|
|
|
u64 exit_boot_services;
|
|
|
|
u64 get_next_monotonic_count;
|
|
|
|
u64 stall;
|
|
|
|
u64 set_watchdog_timer;
|
|
|
|
u64 connect_controller;
|
|
|
|
u64 disconnect_controller;
|
|
|
|
u64 open_protocol;
|
|
|
|
u64 close_protocol;
|
|
|
|
u64 open_protocol_information;
|
|
|
|
u64 protocols_per_handle;
|
|
|
|
u64 locate_handle_buffer;
|
|
|
|
u64 locate_protocol;
|
|
|
|
u64 install_multiple_protocol_interfaces;
|
|
|
|
u64 uninstall_multiple_protocol_interfaces;
|
|
|
|
u64 calculate_crc32;
|
|
|
|
u64 copy_mem;
|
|
|
|
u64 set_mem;
|
|
|
|
u64 create_event_ex;
|
|
|
|
} __packed efi_boot_services_64_t;
|
|
|
|
|
2011-11-15 12:56:32 +00:00
|
|
|
/*
|
|
|
|
* EFI Boot Services table
|
|
|
|
*/
|
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
void *raise_tpl;
|
|
|
|
void *restore_tpl;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*allocate_pages)(int, int, unsigned long,
|
|
|
|
efi_physical_addr_t *);
|
|
|
|
efi_status_t (*free_pages)(efi_physical_addr_t, unsigned long);
|
|
|
|
efi_status_t (*get_memory_map)(unsigned long *, void *, unsigned long *,
|
|
|
|
unsigned long *, u32 *);
|
|
|
|
efi_status_t (*allocate_pool)(int, unsigned long, void **);
|
|
|
|
efi_status_t (*free_pool)(void *);
|
2011-11-15 12:56:32 +00:00
|
|
|
void *create_event;
|
|
|
|
void *set_timer;
|
|
|
|
void *wait_for_event;
|
|
|
|
void *signal_event;
|
|
|
|
void *close_event;
|
|
|
|
void *check_event;
|
|
|
|
void *install_protocol_interface;
|
|
|
|
void *reinstall_protocol_interface;
|
|
|
|
void *uninstall_protocol_interface;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*handle_protocol)(efi_handle_t, efi_guid_t *, void **);
|
2011-11-15 12:56:32 +00:00
|
|
|
void *__reserved;
|
|
|
|
void *register_protocol_notify;
|
|
|
|
void *locate_handle;
|
|
|
|
void *locate_device_path;
|
|
|
|
void *install_configuration_table;
|
|
|
|
void *load_image;
|
|
|
|
void *start_image;
|
|
|
|
void *exit;
|
|
|
|
void *unload_image;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*exit_boot_services)(efi_handle_t, unsigned long);
|
2011-11-15 12:56:32 +00:00
|
|
|
void *get_next_monotonic_count;
|
|
|
|
void *stall;
|
|
|
|
void *set_watchdog_timer;
|
|
|
|
void *connect_controller;
|
|
|
|
void *disconnect_controller;
|
|
|
|
void *open_protocol;
|
|
|
|
void *close_protocol;
|
|
|
|
void *open_protocol_information;
|
|
|
|
void *protocols_per_handle;
|
|
|
|
void *locate_handle_buffer;
|
|
|
|
void *locate_protocol;
|
|
|
|
void *install_multiple_protocol_interfaces;
|
|
|
|
void *uninstall_multiple_protocol_interfaces;
|
|
|
|
void *calculate_crc32;
|
|
|
|
void *copy_mem;
|
|
|
|
void *set_mem;
|
|
|
|
void *create_event_ex;
|
|
|
|
} efi_boot_services_t;
|
|
|
|
|
2012-12-05 21:33:26 +00:00
|
|
|
typedef enum {
|
|
|
|
EfiPciIoWidthUint8,
|
|
|
|
EfiPciIoWidthUint16,
|
|
|
|
EfiPciIoWidthUint32,
|
|
|
|
EfiPciIoWidthUint64,
|
|
|
|
EfiPciIoWidthFifoUint8,
|
|
|
|
EfiPciIoWidthFifoUint16,
|
|
|
|
EfiPciIoWidthFifoUint32,
|
|
|
|
EfiPciIoWidthFifoUint64,
|
|
|
|
EfiPciIoWidthFillUint8,
|
|
|
|
EfiPciIoWidthFillUint16,
|
|
|
|
EfiPciIoWidthFillUint32,
|
|
|
|
EfiPciIoWidthFillUint64,
|
|
|
|
EfiPciIoWidthMaximum
|
|
|
|
} EFI_PCI_IO_PROTOCOL_WIDTH;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
EfiPciIoAttributeOperationGet,
|
|
|
|
EfiPciIoAttributeOperationSet,
|
|
|
|
EfiPciIoAttributeOperationEnable,
|
|
|
|
EfiPciIoAttributeOperationDisable,
|
|
|
|
EfiPciIoAttributeOperationSupported,
|
|
|
|
EfiPciIoAttributeOperationMaximum
|
|
|
|
} EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION;
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
u32 read;
|
|
|
|
u32 write;
|
|
|
|
} efi_pci_io_protocol_access_32_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u64 read;
|
|
|
|
u64 write;
|
|
|
|
} efi_pci_io_protocol_access_64_t;
|
2012-12-05 21:33:26 +00:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
void *read;
|
|
|
|
void *write;
|
|
|
|
} efi_pci_io_protocol_access_t;
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
u32 poll_mem;
|
|
|
|
u32 poll_io;
|
|
|
|
efi_pci_io_protocol_access_32_t mem;
|
|
|
|
efi_pci_io_protocol_access_32_t io;
|
|
|
|
efi_pci_io_protocol_access_32_t pci;
|
|
|
|
u32 copy_mem;
|
|
|
|
u32 map;
|
|
|
|
u32 unmap;
|
|
|
|
u32 allocate_buffer;
|
|
|
|
u32 free_buffer;
|
|
|
|
u32 flush;
|
|
|
|
u32 get_location;
|
|
|
|
u32 attributes;
|
|
|
|
u32 get_bar_attributes;
|
|
|
|
u32 set_bar_attributes;
|
|
|
|
uint64_t romsize;
|
|
|
|
void *romimage;
|
|
|
|
} efi_pci_io_protocol_32;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u64 poll_mem;
|
|
|
|
u64 poll_io;
|
|
|
|
efi_pci_io_protocol_access_64_t mem;
|
|
|
|
efi_pci_io_protocol_access_64_t io;
|
|
|
|
efi_pci_io_protocol_access_64_t pci;
|
|
|
|
u64 copy_mem;
|
|
|
|
u64 map;
|
|
|
|
u64 unmap;
|
|
|
|
u64 allocate_buffer;
|
|
|
|
u64 free_buffer;
|
|
|
|
u64 flush;
|
|
|
|
u64 get_location;
|
|
|
|
u64 attributes;
|
|
|
|
u64 get_bar_attributes;
|
|
|
|
u64 set_bar_attributes;
|
|
|
|
uint64_t romsize;
|
|
|
|
void *romimage;
|
|
|
|
} efi_pci_io_protocol_64;
|
|
|
|
|
2012-12-05 21:33:26 +00:00
|
|
|
typedef struct {
|
|
|
|
void *poll_mem;
|
|
|
|
void *poll_io;
|
|
|
|
efi_pci_io_protocol_access_t mem;
|
|
|
|
efi_pci_io_protocol_access_t io;
|
|
|
|
efi_pci_io_protocol_access_t pci;
|
|
|
|
void *copy_mem;
|
|
|
|
void *map;
|
|
|
|
void *unmap;
|
|
|
|
void *allocate_buffer;
|
|
|
|
void *free_buffer;
|
|
|
|
void *flush;
|
|
|
|
void *get_location;
|
|
|
|
void *attributes;
|
|
|
|
void *get_bar_attributes;
|
|
|
|
void *set_bar_attributes;
|
|
|
|
uint64_t romsize;
|
|
|
|
void *romimage;
|
|
|
|
} efi_pci_io_protocol;
|
|
|
|
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_ISA_MOTHERBOARD_IO 0x0001
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_ISA_IO 0x0002
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO 0x0004
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_VGA_MEMORY 0x0008
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_VGA_IO 0x0010
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_IDE_PRIMARY_IO 0x0020
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_IDE_SECONDARY_IO 0x0040
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_MEMORY_WRITE_COMBINE 0x0080
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_IO 0x0100
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_MEMORY 0x0200
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_BUS_MASTER 0x0400
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_MEMORY_CACHED 0x0800
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_MEMORY_DISABLE 0x1000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_DEVICE 0x2000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_EMBEDDED_ROM 0x4000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE 0x8000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_ISA_IO_16 0x10000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_VGA_PALETTE_IO_16 0x20000
|
|
|
|
#define EFI_PCI_IO_ATTRIBUTE_VGA_IO_16 0x40000
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* Types and defines for EFI ResetSystem
|
|
|
|
*/
|
|
|
|
#define EFI_RESET_COLD 0
|
|
|
|
#define EFI_RESET_WARM 1
|
|
|
|
#define EFI_RESET_SHUTDOWN 2
|
|
|
|
|
|
|
|
/*
|
|
|
|
* EFI Runtime Services table
|
|
|
|
*/
|
|
|
|
#define EFI_RUNTIME_SERVICES_SIGNATURE ((u64)0x5652453544e5552ULL)
|
|
|
|
#define EFI_RUNTIME_SERVICES_REVISION 0x00010000
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u32 get_time;
|
|
|
|
u32 set_time;
|
|
|
|
u32 get_wakeup_time;
|
|
|
|
u32 set_wakeup_time;
|
|
|
|
u32 set_virtual_address_map;
|
|
|
|
u32 convert_pointer;
|
|
|
|
u32 get_variable;
|
|
|
|
u32 get_next_variable;
|
|
|
|
u32 set_variable;
|
|
|
|
u32 get_next_high_mono_count;
|
|
|
|
u32 reset_system;
|
|
|
|
u32 update_capsule;
|
|
|
|
u32 query_capsule_caps;
|
|
|
|
u32 query_variable_info;
|
|
|
|
} efi_runtime_services_32_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u64 get_time;
|
|
|
|
u64 set_time;
|
|
|
|
u64 get_wakeup_time;
|
|
|
|
u64 set_wakeup_time;
|
|
|
|
u64 set_virtual_address_map;
|
|
|
|
u64 convert_pointer;
|
|
|
|
u64 get_variable;
|
|
|
|
u64 get_next_variable;
|
|
|
|
u64 set_variable;
|
|
|
|
u64 get_next_high_mono_count;
|
|
|
|
u64 reset_system;
|
|
|
|
u64 update_capsule;
|
|
|
|
u64 query_capsule_caps;
|
|
|
|
u64 query_variable_info;
|
|
|
|
} efi_runtime_services_64_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
2013-06-02 12:56:07 +00:00
|
|
|
void *get_time;
|
|
|
|
void *set_time;
|
|
|
|
void *get_wakeup_time;
|
|
|
|
void *set_wakeup_time;
|
|
|
|
void *set_virtual_address_map;
|
|
|
|
void *convert_pointer;
|
|
|
|
void *get_variable;
|
|
|
|
void *get_next_variable;
|
|
|
|
void *set_variable;
|
|
|
|
void *get_next_high_mono_count;
|
|
|
|
void *reset_system;
|
|
|
|
void *update_capsule;
|
|
|
|
void *query_capsule_caps;
|
|
|
|
void *query_variable_info;
|
2005-04-16 22:20:36 +00:00
|
|
|
} efi_runtime_services_t;
|
|
|
|
|
|
|
|
typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
|
|
|
|
typedef efi_status_t efi_set_time_t (efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
|
|
|
|
efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
|
|
|
|
typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
|
|
|
|
unsigned long *data_size, void *data);
|
|
|
|
typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
|
|
|
|
efi_guid_t *vendor);
|
|
|
|
typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor,
|
2011-06-06 19:36:24 +00:00
|
|
|
u32 attr, unsigned long data_size,
|
2005-04-16 22:20:36 +00:00
|
|
|
void *data);
|
2014-09-30 20:58:52 +00:00
|
|
|
typedef efi_status_t
|
|
|
|
efi_set_variable_nonblocking_t(efi_char16_t *name, efi_guid_t *vendor,
|
|
|
|
u32 attr, unsigned long data_size, void *data);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
|
|
|
|
typedef void efi_reset_system_t (int reset_type, efi_status_t status,
|
|
|
|
unsigned long data_size, efi_char16_t *data);
|
|
|
|
typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
|
|
|
|
unsigned long descriptor_size,
|
|
|
|
u32 descriptor_version,
|
|
|
|
efi_memory_desc_t *virtual_map);
|
2011-06-06 19:36:25 +00:00
|
|
|
typedef efi_status_t efi_query_variable_info_t(u32 attr,
|
|
|
|
u64 *storage_space,
|
|
|
|
u64 *remaining_space,
|
|
|
|
u64 *max_variable_size);
|
|
|
|
typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
unsigned long sg_list);
|
|
|
|
typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
|
|
|
|
unsigned long count,
|
|
|
|
u64 *max_size,
|
|
|
|
int *reset_type);
|
2013-03-25 09:14:30 +00:00
|
|
|
typedef efi_status_t efi_query_variable_store_t(u32 attributes, unsigned long size);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-26 10:09:05 +00:00
|
|
|
void efi_native_runtime_setup(void);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* EFI Configuration Table and GUID definitions
|
|
|
|
*/
|
|
|
|
#define NULL_GUID \
|
|
|
|
EFI_GUID( 0x00000000, 0x0000, 0x0000, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 )
|
|
|
|
|
|
|
|
#define MPS_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xeb9d2d2f, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
|
|
|
|
|
|
|
|
#define ACPI_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xeb9d2d30, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
|
|
|
|
|
|
|
|
#define ACPI_20_TABLE_GUID \
|
|
|
|
EFI_GUID( 0x8868e871, 0xe4f1, 0x11d3, 0xbc, 0x22, 0x0, 0x80, 0xc7, 0x3c, 0x88, 0x81 )
|
|
|
|
|
|
|
|
#define SMBIOS_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xeb9d2d31, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
|
|
|
|
|
2014-10-14 14:34:47 +00:00
|
|
|
#define SMBIOS3_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xf2fd1544, 0x9794, 0x4a2c, 0x99, 0x2e, 0xe5, 0xbb, 0xcf, 0x20, 0xe3, 0x94 )
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define SAL_SYSTEM_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xeb9d2d32, 0x2d88, 0x11d3, 0x9a, 0x16, 0x0, 0x90, 0x27, 0x3f, 0xc1, 0x4d )
|
|
|
|
|
|
|
|
#define HCDP_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xf951938d, 0x620b, 0x42ef, 0x82, 0x79, 0xa8, 0x4b, 0x79, 0x61, 0x78, 0x98 )
|
|
|
|
|
|
|
|
#define UGA_IO_PROTOCOL_GUID \
|
|
|
|
EFI_GUID( 0x61a4d49e, 0x6f68, 0x4f1b, 0xb9, 0x22, 0xa8, 0x6e, 0xed, 0xb, 0x7, 0xa2 )
|
|
|
|
|
|
|
|
#define EFI_GLOBAL_VARIABLE_GUID \
|
|
|
|
EFI_GUID( 0x8be4df61, 0x93ca, 0x11d2, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c )
|
|
|
|
|
2008-10-03 16:58:54 +00:00
|
|
|
#define UV_SYSTEM_TABLE_GUID \
|
|
|
|
EFI_GUID( 0x3b13a7d4, 0x633e, 0x11dd, 0x93, 0xec, 0xda, 0x25, 0x56, 0xd8, 0x95, 0x93 )
|
|
|
|
|
2011-07-21 20:57:56 +00:00
|
|
|
#define LINUX_EFI_CRASH_GUID \
|
|
|
|
EFI_GUID( 0xcfc8fc79, 0xbe2e, 0x4ddc, 0x97, 0xf0, 0x9f, 0x98, 0xbf, 0xe2, 0x98, 0xa0 )
|
|
|
|
|
2011-11-15 12:56:50 +00:00
|
|
|
#define LOADED_IMAGE_PROTOCOL_GUID \
|
|
|
|
EFI_GUID( 0x5b1b31a1, 0x9562, 0x11d2, 0x8e, 0x3f, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
|
|
|
|
|
2011-11-15 12:57:16 +00:00
|
|
|
#define EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID \
|
|
|
|
EFI_GUID( 0x9042a9de, 0x23dc, 0x4a38, 0x96, 0xfb, 0x7a, 0xde, 0xd0, 0x80, 0x51, 0x6a )
|
|
|
|
|
|
|
|
#define EFI_UGA_PROTOCOL_GUID \
|
|
|
|
EFI_GUID( 0x982c298b, 0xf4fa, 0x41cb, 0xb8, 0x38, 0x77, 0xaa, 0x68, 0x8f, 0xb8, 0x39 )
|
|
|
|
|
|
|
|
#define EFI_PCI_IO_PROTOCOL_GUID \
|
|
|
|
EFI_GUID( 0x4cf5b200, 0x68b8, 0x4ca5, 0x9e, 0xec, 0xb2, 0x3e, 0x3f, 0x50, 0x2, 0x9a )
|
|
|
|
|
2011-08-11 09:28:06 +00:00
|
|
|
#define EFI_FILE_INFO_ID \
|
|
|
|
EFI_GUID( 0x9576e92, 0x6d3f, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
|
|
|
|
|
2015-04-28 22:44:31 +00:00
|
|
|
#define EFI_SYSTEM_RESOURCE_TABLE_GUID \
|
|
|
|
EFI_GUID( 0xb122a263, 0x3661, 0x4f68, 0x99, 0x29, 0x78, 0xf8, 0xb0, 0xd6, 0x21, 0x80 )
|
|
|
|
|
2011-08-11 09:28:06 +00:00
|
|
|
#define EFI_FILE_SYSTEM_GUID \
|
|
|
|
EFI_GUID( 0x964e5b22, 0x6459, 0x11d2, 0x8e, 0x39, 0x00, 0xa0, 0xc9, 0x69, 0x72, 0x3b )
|
|
|
|
|
2014-01-09 01:54:19 +00:00
|
|
|
#define DEVICE_TREE_GUID \
|
|
|
|
EFI_GUID( 0xb1b621d5, 0xf19c, 0x41a5, 0x83, 0x0b, 0xd9, 0x15, 0x2c, 0x69, 0xaa, 0xe0 )
|
|
|
|
|
2012-02-12 21:24:29 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u64 table;
|
|
|
|
} efi_config_table_64_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
u32 table;
|
|
|
|
} efi_config_table_32_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
unsigned long table;
|
|
|
|
} efi_config_table_t;
|
|
|
|
|
2013-09-05 10:34:54 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_guid_t guid;
|
|
|
|
const char *name;
|
|
|
|
unsigned long *ptr;
|
|
|
|
} efi_config_table_type_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define EFI_SYSTEM_TABLE_SIGNATURE ((u64)0x5453595320494249ULL)
|
|
|
|
|
2011-06-06 19:36:25 +00:00
|
|
|
#define EFI_2_30_SYSTEM_TABLE_REVISION ((2 << 16) | (30))
|
|
|
|
#define EFI_2_20_SYSTEM_TABLE_REVISION ((2 << 16) | (20))
|
|
|
|
#define EFI_2_10_SYSTEM_TABLE_REVISION ((2 << 16) | (10))
|
|
|
|
#define EFI_2_00_SYSTEM_TABLE_REVISION ((2 << 16) | (00))
|
|
|
|
#define EFI_1_10_SYSTEM_TABLE_REVISION ((1 << 16) | (10))
|
|
|
|
#define EFI_1_02_SYSTEM_TABLE_REVISION ((1 << 16) | (02))
|
|
|
|
|
2012-02-12 21:24:29 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u64 fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
u32 __pad1;
|
|
|
|
u64 con_in_handle;
|
|
|
|
u64 con_in;
|
|
|
|
u64 con_out_handle;
|
|
|
|
u64 con_out;
|
|
|
|
u64 stderr_handle;
|
|
|
|
u64 stderr;
|
|
|
|
u64 runtime;
|
|
|
|
u64 boottime;
|
|
|
|
u32 nr_tables;
|
|
|
|
u32 __pad2;
|
|
|
|
u64 tables;
|
|
|
|
} efi_system_table_64_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
u32 fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
u32 con_in_handle;
|
|
|
|
u32 con_in;
|
|
|
|
u32 con_out_handle;
|
|
|
|
u32 con_out;
|
|
|
|
u32 stderr_handle;
|
|
|
|
u32 stderr;
|
|
|
|
u32 runtime;
|
|
|
|
u32 boottime;
|
|
|
|
u32 nr_tables;
|
|
|
|
u32 tables;
|
|
|
|
} efi_system_table_32_t;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
typedef struct {
|
|
|
|
efi_table_hdr_t hdr;
|
|
|
|
unsigned long fw_vendor; /* physical addr of CHAR16 vendor string */
|
|
|
|
u32 fw_revision;
|
|
|
|
unsigned long con_in_handle;
|
|
|
|
unsigned long con_in;
|
|
|
|
unsigned long con_out_handle;
|
|
|
|
unsigned long con_out;
|
|
|
|
unsigned long stderr_handle;
|
|
|
|
unsigned long stderr;
|
|
|
|
efi_runtime_services_t *runtime;
|
2011-11-15 12:56:32 +00:00
|
|
|
efi_boot_services_t *boottime;
|
2005-04-16 22:20:36 +00:00
|
|
|
unsigned long nr_tables;
|
|
|
|
unsigned long tables;
|
|
|
|
} efi_system_table_t;
|
|
|
|
|
|
|
|
struct efi_memory_map {
|
2005-09-03 22:56:27 +00:00
|
|
|
void *phys_map;
|
|
|
|
void *map;
|
|
|
|
void *map_end;
|
2005-04-16 22:20:36 +00:00
|
|
|
int nr_map;
|
|
|
|
unsigned long desc_version;
|
2005-09-03 22:56:27 +00:00
|
|
|
unsigned long desc_size;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
2013-12-30 17:12:12 +00:00
|
|
|
struct efi_fdt_params {
|
|
|
|
u64 system_table;
|
|
|
|
u64 mmap;
|
|
|
|
u32 mmap_size;
|
|
|
|
u32 desc_size;
|
|
|
|
u32 desc_ver;
|
|
|
|
};
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
u32 revision;
|
|
|
|
u32 parent_handle;
|
|
|
|
u32 system_table;
|
|
|
|
u32 device_handle;
|
|
|
|
u32 file_path;
|
|
|
|
u32 reserved;
|
|
|
|
u32 load_options_size;
|
|
|
|
u32 load_options;
|
|
|
|
u32 image_base;
|
|
|
|
__aligned_u64 image_size;
|
|
|
|
unsigned int image_code_type;
|
|
|
|
unsigned int image_data_type;
|
|
|
|
unsigned long unload;
|
|
|
|
} efi_loaded_image_32_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u32 revision;
|
|
|
|
u64 parent_handle;
|
|
|
|
u64 system_table;
|
|
|
|
u64 device_handle;
|
|
|
|
u64 file_path;
|
|
|
|
u64 reserved;
|
|
|
|
u32 load_options_size;
|
|
|
|
u64 load_options;
|
|
|
|
u64 image_base;
|
|
|
|
__aligned_u64 image_size;
|
|
|
|
unsigned int image_code_type;
|
|
|
|
unsigned int image_data_type;
|
|
|
|
unsigned long unload;
|
|
|
|
} efi_loaded_image_64_t;
|
|
|
|
|
2011-11-15 12:56:50 +00:00
|
|
|
typedef struct {
|
|
|
|
u32 revision;
|
|
|
|
void *parent_handle;
|
|
|
|
efi_system_table_t *system_table;
|
|
|
|
void *device_handle;
|
|
|
|
void *file_path;
|
|
|
|
void *reserved;
|
|
|
|
u32 load_options_size;
|
|
|
|
void *load_options;
|
|
|
|
void *image_base;
|
|
|
|
__aligned_u64 image_size;
|
|
|
|
unsigned int image_code_type;
|
|
|
|
unsigned int image_data_type;
|
|
|
|
unsigned long unload;
|
|
|
|
} efi_loaded_image_t;
|
|
|
|
|
2011-08-11 09:28:06 +00:00
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u64 size;
|
|
|
|
u64 file_size;
|
|
|
|
u64 phys_size;
|
|
|
|
efi_time_t create_time;
|
|
|
|
efi_time_t last_access_time;
|
|
|
|
efi_time_t modification_time;
|
|
|
|
__aligned_u64 attribute;
|
|
|
|
efi_char16_t filename[1];
|
|
|
|
} efi_file_info_t;
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
typedef struct {
|
|
|
|
u64 revision;
|
|
|
|
u32 open;
|
|
|
|
u32 close;
|
|
|
|
u32 delete;
|
|
|
|
u32 read;
|
|
|
|
u32 write;
|
|
|
|
u32 get_position;
|
|
|
|
u32 set_position;
|
|
|
|
u32 get_info;
|
|
|
|
u32 set_info;
|
|
|
|
u32 flush;
|
|
|
|
} efi_file_handle_32_t;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
u64 revision;
|
|
|
|
u64 open;
|
|
|
|
u64 close;
|
|
|
|
u64 delete;
|
|
|
|
u64 read;
|
|
|
|
u64 write;
|
|
|
|
u64 get_position;
|
|
|
|
u64 set_position;
|
|
|
|
u64 get_info;
|
|
|
|
u64 set_info;
|
|
|
|
u64 flush;
|
|
|
|
} efi_file_handle_64_t;
|
|
|
|
|
2013-09-22 22:45:26 +00:00
|
|
|
typedef struct _efi_file_handle {
|
2011-08-11 09:28:06 +00:00
|
|
|
u64 revision;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*open)(struct _efi_file_handle *,
|
|
|
|
struct _efi_file_handle **,
|
|
|
|
efi_char16_t *, u64, u64);
|
|
|
|
efi_status_t (*close)(struct _efi_file_handle *);
|
2011-08-11 09:28:06 +00:00
|
|
|
void *delete;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*read)(struct _efi_file_handle *, unsigned long *,
|
|
|
|
void *);
|
2011-08-11 09:28:06 +00:00
|
|
|
void *write;
|
|
|
|
void *get_position;
|
|
|
|
void *set_position;
|
2013-09-22 22:45:26 +00:00
|
|
|
efi_status_t (*get_info)(struct _efi_file_handle *, efi_guid_t *,
|
|
|
|
unsigned long *, void *);
|
2011-08-11 09:28:06 +00:00
|
|
|
void *set_info;
|
|
|
|
void *flush;
|
|
|
|
} efi_file_handle_t;
|
|
|
|
|
2013-09-22 22:45:26 +00:00
|
|
|
typedef struct _efi_file_io_interface {
|
|
|
|
u64 revision;
|
|
|
|
int (*open_volume)(struct _efi_file_io_interface *,
|
|
|
|
efi_file_handle_t **);
|
|
|
|
} efi_file_io_interface_t;
|
|
|
|
|
2011-08-11 09:28:06 +00:00
|
|
|
#define EFI_FILE_MODE_READ 0x0000000000000001
|
|
|
|
#define EFI_FILE_MODE_WRITE 0x0000000000000002
|
|
|
|
#define EFI_FILE_MODE_CREATE 0x8000000000000000
|
|
|
|
|
2006-03-26 09:37:08 +00:00
|
|
|
#define EFI_INVALID_TABLE_ADDR (~0UL)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* All runtime access to EFI goes through this structure:
|
|
|
|
*/
|
|
|
|
extern struct efi {
|
|
|
|
efi_system_table_t *systab; /* EFI system table */
|
2011-06-06 19:36:25 +00:00
|
|
|
unsigned int runtime_version; /* Runtime services version */
|
2006-03-26 09:37:08 +00:00
|
|
|
unsigned long mps; /* MPS table */
|
|
|
|
unsigned long acpi; /* ACPI table (IA64 ext 0.71) */
|
|
|
|
unsigned long acpi20; /* ACPI table (ACPI 2.0) */
|
2014-10-14 14:34:47 +00:00
|
|
|
unsigned long smbios; /* SMBIOS table (32 bit entry point) */
|
|
|
|
unsigned long smbios3; /* SMBIOS table (64 bit entry point) */
|
2006-03-26 09:37:08 +00:00
|
|
|
unsigned long sal_systab; /* SAL system table */
|
|
|
|
unsigned long boot_info; /* boot info table */
|
|
|
|
unsigned long hcdp; /* HCDP table */
|
|
|
|
unsigned long uga; /* UGA table */
|
2008-10-03 16:58:54 +00:00
|
|
|
unsigned long uv_systab; /* UV system table */
|
2013-12-20 10:02:17 +00:00
|
|
|
unsigned long fw_vendor; /* fw_vendor */
|
|
|
|
unsigned long runtime; /* runtime table */
|
|
|
|
unsigned long config_table; /* config tables */
|
2015-04-28 22:44:31 +00:00
|
|
|
unsigned long esrt; /* ESRT table */
|
2005-04-16 22:20:36 +00:00
|
|
|
efi_get_time_t *get_time;
|
|
|
|
efi_set_time_t *set_time;
|
|
|
|
efi_get_wakeup_time_t *get_wakeup_time;
|
|
|
|
efi_set_wakeup_time_t *set_wakeup_time;
|
|
|
|
efi_get_variable_t *get_variable;
|
|
|
|
efi_get_next_variable_t *get_next_variable;
|
|
|
|
efi_set_variable_t *set_variable;
|
2014-09-30 20:58:52 +00:00
|
|
|
efi_set_variable_nonblocking_t *set_variable_nonblocking;
|
2011-06-06 19:36:25 +00:00
|
|
|
efi_query_variable_info_t *query_variable_info;
|
|
|
|
efi_update_capsule_t *update_capsule;
|
|
|
|
efi_query_capsule_caps_t *query_capsule_caps;
|
2005-04-16 22:20:36 +00:00
|
|
|
efi_get_next_high_mono_count_t *get_next_high_mono_count;
|
|
|
|
efi_reset_system_t *reset_system;
|
|
|
|
efi_set_virtual_address_map_t *set_virtual_address_map;
|
2013-09-05 10:34:55 +00:00
|
|
|
struct efi_memory_map *memmap;
|
2014-01-15 13:21:22 +00:00
|
|
|
unsigned long flags;
|
2005-04-16 22:20:36 +00:00
|
|
|
} efi;
|
|
|
|
|
|
|
|
static inline int
|
|
|
|
efi_guidcmp (efi_guid_t left, efi_guid_t right)
|
|
|
|
{
|
|
|
|
return memcmp(&left, &right, sizeof (efi_guid_t));
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline char *
|
2014-12-18 15:02:17 +00:00
|
|
|
efi_guid_to_str(efi_guid_t *guid, char *out)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2009-12-15 02:01:14 +00:00
|
|
|
sprintf(out, "%pUl", guid->b);
|
2005-04-16 22:20:36 +00:00
|
|
|
return out;
|
|
|
|
}
|
|
|
|
|
|
|
|
extern void efi_init (void);
|
|
|
|
extern void *efi_get_pal_addr (void);
|
|
|
|
extern void efi_map_pal_code (void);
|
|
|
|
extern void efi_memmap_walk (efi_freemem_callback_t callback, void *arg);
|
|
|
|
extern void efi_gettimeofday (struct timespec *ts);
|
|
|
|
extern void efi_enter_virtual_mode (void); /* switch EFI to virtual mode, if possible */
|
2012-09-29 00:55:44 +00:00
|
|
|
#ifdef CONFIG_X86
|
2012-09-29 00:57:05 +00:00
|
|
|
extern void efi_late_init(void);
|
2012-09-29 00:55:44 +00:00
|
|
|
extern void efi_free_boot_services(void);
|
2013-03-25 09:14:30 +00:00
|
|
|
extern efi_status_t efi_query_variable_store(u32 attributes, unsigned long size);
|
2015-06-24 23:58:15 +00:00
|
|
|
extern void efi_find_mirror(void);
|
2012-09-29 00:55:44 +00:00
|
|
|
#else
|
2012-09-29 00:57:05 +00:00
|
|
|
static inline void efi_late_init(void) {}
|
2012-09-29 00:55:44 +00:00
|
|
|
static inline void efi_free_boot_services(void) {}
|
2013-03-25 09:14:30 +00:00
|
|
|
|
|
|
|
static inline efi_status_t efi_query_variable_store(u32 attributes, unsigned long size)
|
|
|
|
{
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
2012-09-29 00:55:44 +00:00
|
|
|
#endif
|
2012-09-29 00:56:08 +00:00
|
|
|
extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
|
2013-09-05 10:34:54 +00:00
|
|
|
extern int efi_config_init(efi_config_table_type_t *arch_tables);
|
efi: Work around ia64 build problem with ESRT driver
So, I'm told this problem exists in the world:
> Subject: Build error in -next due to 'efi: Add esrt support'
>
> Building ia64:defconfig ... failed
> --------------
> Error log:
>
> drivers/firmware/efi/esrt.c:28:31: fatal error: asm/early_ioremap.h: No such file or directory
>
I'm not really sure how it's okay that we have things in asm-generic on
some platforms but not others - is having it the same everywhere not the
whole point of asm-generic?
That said, ia64 doesn't have early_ioremap.h . So instead, since it's
difficult to imagine new IA64 machines with UEFI 2.5, just don't build
this code there.
To me this looks like a workaround - doing something like:
generic-y += early_ioremap.h
in arch/ia64/include/asm/Kbuild would appear to be more correct, but
ia64 has its own early_memremap() decl in arch/ia64/include/asm/io.h ,
and it's a macro. So adding the above /and/ requiring that asm/io.h be
included /after/ asm/early_ioremap.h in all cases would fix it, but
that's pretty ugly as well. Since I'm not going to spend the rest of my
life rectifying ia64 headers vs "generic" headers that aren't generic,
it's much simpler to just not build there.
Note that I've only actually tried to build this patch on x86_64, but
esrt.o still gets built there, and that would seem to demonstrate that
the conditional building is working correctly at all the places the code
built before. I no longer have any ia64 machines handy to test that the
exclusion actually works there.
Signed-off-by: Peter Jones <pjones@redhat.com>
Acked-by: Tony Luck <tony.luck@intel.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
(Compile-)Tested-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2015-06-05 19:14:54 +00:00
|
|
|
#ifdef CONFIG_EFI_ESRT
|
2015-04-28 22:44:31 +00:00
|
|
|
extern void __init efi_esrt_init(void);
|
efi: Work around ia64 build problem with ESRT driver
So, I'm told this problem exists in the world:
> Subject: Build error in -next due to 'efi: Add esrt support'
>
> Building ia64:defconfig ... failed
> --------------
> Error log:
>
> drivers/firmware/efi/esrt.c:28:31: fatal error: asm/early_ioremap.h: No such file or directory
>
I'm not really sure how it's okay that we have things in asm-generic on
some platforms but not others - is having it the same everywhere not the
whole point of asm-generic?
That said, ia64 doesn't have early_ioremap.h . So instead, since it's
difficult to imagine new IA64 machines with UEFI 2.5, just don't build
this code there.
To me this looks like a workaround - doing something like:
generic-y += early_ioremap.h
in arch/ia64/include/asm/Kbuild would appear to be more correct, but
ia64 has its own early_memremap() decl in arch/ia64/include/asm/io.h ,
and it's a macro. So adding the above /and/ requiring that asm/io.h be
included /after/ asm/early_ioremap.h in all cases would fix it, but
that's pretty ugly as well. Since I'm not going to spend the rest of my
life rectifying ia64 headers vs "generic" headers that aren't generic,
it's much simpler to just not build there.
Note that I've only actually tried to build this patch on x86_64, but
esrt.o still gets built there, and that would seem to demonstrate that
the conditional building is working correctly at all the places the code
built before. I no longer have any ia64 machines handy to test that the
exclusion actually works there.
Signed-off-by: Peter Jones <pjones@redhat.com>
Acked-by: Tony Luck <tony.luck@intel.com>
Reviewed-by: Guenter Roeck <linux@roeck-us.net>
(Compile-)Tested-by: Guenter Roeck <linux@roeck-us.net>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2015-06-05 19:14:54 +00:00
|
|
|
#else
|
|
|
|
static inline void efi_esrt_init(void) { }
|
|
|
|
#endif
|
2014-10-18 13:04:15 +00:00
|
|
|
extern int efi_config_parse_tables(void *config_tables, int count, int sz,
|
|
|
|
efi_config_table_type_t *arch_tables);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern u64 efi_get_iobase (void);
|
|
|
|
extern u32 efi_mem_type (unsigned long phys_addr);
|
|
|
|
extern u64 efi_mem_attributes (unsigned long phys_addr);
|
2006-05-05 23:19:50 +00:00
|
|
|
extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern int __init efi_uart_console_only (void);
|
2015-04-28 22:44:31 +00:00
|
|
|
extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
|
|
|
|
extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern void efi_initialize_iomem_resources(struct resource *code_resource,
|
2007-10-21 23:42:01 +00:00
|
|
|
struct resource *data_resource, struct resource *bss_resource);
|
2013-05-13 17:56:06 +00:00
|
|
|
extern void efi_get_time(struct timespec *now);
|
x86, efi: Retain boot service code until after switching to virtual mode
UEFI stands for "Unified Extensible Firmware Interface", where "Firmware"
is an ancient African word meaning "Why do something right when you can
do it so wrong that children will weep and brave adults will cower before
you", and "UEI" is Celtic for "We missed DOS so we burned it into your
ROMs". The UEFI specification provides for runtime services (ie, another
way for the operating system to be forced to depend on the firmware) and
we rely on these for certain trivial tasks such as setting up the
bootloader. But some hardware fails to work if we attempt to use these
runtime services from physical mode, and so we have to switch into virtual
mode. So far so dreadful.
The specification makes it clear that the operating system is free to do
whatever it wants with boot services code after ExitBootServices() has been
called. SetVirtualAddressMap() can't be called until ExitBootServices() has
been. So, obviously, a whole bunch of EFI implementations call into boot
services code when we do that. Since we've been charmingly naive and
trusted that the specification may be somehow relevant to the real world,
we've already stuffed a picture of a penguin or something in that address
space. And just to make things more entertaining, we've also marked it
non-executable.
This patch allocates the boot services regions during EFI init and makes
sure that they're executable. Then, after SetVirtualAddressMap(), it
discards them and everyone lives happily ever after. Except for the ones
who have to work on EFI, who live sad lives haunted by the knowledge that
someone's eventually going to write yet another firmware specification.
[ hpa: adding this to urgent with a stable tag since it fixes currently-broken
hardware. However, I do not know what the dependencies are and so I do
not know which -stable versions this may be a candidate for. ]
Signed-off-by: Matthew Garrett <mjg@redhat.com>
Link: http://lkml.kernel.org/r/1306331593-28715-1-git-send-email-mjg@redhat.com
Signed-off-by: H. Peter Anvin <hpa@linux.intel.com>
Cc: Tony Luck <tony.luck@intel.com>
Cc: <stable@kernel.org>
2011-05-25 13:53:13 +00:00
|
|
|
extern void efi_reserve_boot_services(void);
|
2013-12-30 17:12:12 +00:00
|
|
|
extern int efi_get_fdt_params(struct efi_fdt_params *params, int verbose);
|
2005-04-16 22:20:36 +00:00
|
|
|
extern struct efi_memory_map memmap;
|
2015-04-28 22:44:31 +00:00
|
|
|
extern struct kobject *efi_kobj;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2014-06-13 11:39:55 +00:00
|
|
|
extern int efi_reboot_quirk_mode;
|
efi/reboot: Allow powering off machines using EFI
Not only can EfiResetSystem() be used to reboot, it can also be used to
power down machines.
By and large, this functionality doesn't work very well across the range
of EFI machines in the wild, so it should definitely only be used as a
last resort. In an ideal world, this wouldn't be needed at all.
Unfortunately, we're starting to see machines where EFI is the *only*
reliable way to power down, and nothing else, not PCI, not ACPI, works.
efi_poweroff_required() should be implemented on a per-architecture
basis, since exactly when we should be using EFI runtime services is a
platform-specific decision. There's no analogue for reboot because each
architecture handles reboot very differently - the x86 code in
particular is pretty complex.
Patches to enable this for specific classes of hardware will be
submitted separately.
Tested-by: Mark Salter <msalter@redhat.com>
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2014-06-13 11:35:21 +00:00
|
|
|
extern bool efi_poweroff_required(void);
|
|
|
|
|
2014-01-10 19:26:06 +00:00
|
|
|
/* Iterate through an efi_memory_map */
|
|
|
|
#define for_each_efi_memory_desc(m, md) \
|
|
|
|
for ((md) = (m)->map; \
|
|
|
|
(md) <= (efi_memory_desc_t *)((m)->map_end - (m)->desc_size); \
|
|
|
|
(md) = (void *)(md) + (m)->desc_size)
|
|
|
|
|
2014-09-03 11:32:20 +00:00
|
|
|
/*
|
|
|
|
* Format an EFI memory descriptor's type and attributes to a user-provided
|
|
|
|
* character buffer, as per snprintf(), and return the buffer.
|
|
|
|
*/
|
|
|
|
char * __init efi_md_typeattr_format(char *buf, size_t size,
|
|
|
|
const efi_memory_desc_t *md);
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/**
|
|
|
|
* efi_range_is_wc - check the WC bit on an address range
|
|
|
|
* @start: starting kvirt address
|
|
|
|
* @len: length of range
|
|
|
|
*
|
|
|
|
* Consult the EFI memory map and make sure it's ok to set this range WC.
|
|
|
|
* Returns true or false.
|
|
|
|
*/
|
|
|
|
static inline int efi_range_is_wc(unsigned long start, unsigned long len)
|
|
|
|
{
|
2005-06-16 22:14:00 +00:00
|
|
|
unsigned long i;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
for (i = 0; i < len; i += (1UL << EFI_PAGE_SHIFT)) {
|
|
|
|
unsigned long paddr = __pa(start + i);
|
|
|
|
if (!(efi_mem_attributes(paddr) & EFI_MEMORY_WC))
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* The range checked out */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_EFI_PCDP
|
|
|
|
extern int __init efi_setup_pcdp_console(char *);
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
2012-11-14 09:42:35 +00:00
|
|
|
* We play games with efi_enabled so that the compiler will, if
|
|
|
|
* possible, remove EFI-related code altogether.
|
2005-04-16 22:20:36 +00:00
|
|
|
*/
|
2012-11-14 09:42:35 +00:00
|
|
|
#define EFI_BOOT 0 /* Were we booted from EFI? */
|
|
|
|
#define EFI_SYSTEM_TABLES 1 /* Can we use EFI system tables? */
|
|
|
|
#define EFI_CONFIG_TABLES 2 /* Can we use EFI config tables? */
|
|
|
|
#define EFI_RUNTIME_SERVICES 3 /* Can we use runtime services? */
|
|
|
|
#define EFI_MEMMAP 4 /* Can we use EFI memory map? */
|
|
|
|
#define EFI_64BIT 5 /* Is the firmware 64-bit? */
|
2014-06-30 17:52:58 +00:00
|
|
|
#define EFI_PARAVIRT 6 /* Access is via a paravirt interface */
|
|
|
|
#define EFI_ARCH_1 7 /* First arch-specific bit */
|
2015-02-05 10:44:41 +00:00
|
|
|
#define EFI_DBG 8 /* Print additional debug info at runtime */
|
2012-11-14 09:42:35 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#ifdef CONFIG_EFI
|
2014-01-15 13:21:22 +00:00
|
|
|
/*
|
|
|
|
* Test whether the above EFI_* bits are enabled.
|
|
|
|
*/
|
|
|
|
static inline bool efi_enabled(int feature)
|
|
|
|
{
|
|
|
|
return test_bit(feature, &efi.flags) != 0;
|
|
|
|
}
|
2014-06-13 11:22:22 +00:00
|
|
|
extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
|
2005-04-16 22:20:36 +00:00
|
|
|
#else
|
2014-01-15 13:21:22 +00:00
|
|
|
static inline bool efi_enabled(int feature)
|
2012-11-14 09:42:35 +00:00
|
|
|
{
|
2014-01-15 13:21:22 +00:00
|
|
|
return false;
|
2012-11-14 09:42:35 +00:00
|
|
|
}
|
2014-06-13 11:22:22 +00:00
|
|
|
static inline void
|
|
|
|
efi_reboot(enum reboot_mode reboot_mode, const char *__unused) {}
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Variable Attributes
|
|
|
|
*/
|
|
|
|
#define EFI_VARIABLE_NON_VOLATILE 0x0000000000000001
|
|
|
|
#define EFI_VARIABLE_BOOTSERVICE_ACCESS 0x0000000000000002
|
|
|
|
#define EFI_VARIABLE_RUNTIME_ACCESS 0x0000000000000004
|
2012-04-30 20:11:29 +00:00
|
|
|
#define EFI_VARIABLE_HARDWARE_ERROR_RECORD 0x0000000000000008
|
|
|
|
#define EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS 0x0000000000000010
|
|
|
|
#define EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS 0x0000000000000020
|
|
|
|
#define EFI_VARIABLE_APPEND_WRITE 0x0000000000000040
|
|
|
|
|
|
|
|
#define EFI_VARIABLE_MASK (EFI_VARIABLE_NON_VOLATILE | \
|
|
|
|
EFI_VARIABLE_BOOTSERVICE_ACCESS | \
|
|
|
|
EFI_VARIABLE_RUNTIME_ACCESS | \
|
|
|
|
EFI_VARIABLE_HARDWARE_ERROR_RECORD | \
|
|
|
|
EFI_VARIABLE_AUTHENTICATED_WRITE_ACCESS | \
|
|
|
|
EFI_VARIABLE_TIME_BASED_AUTHENTICATED_WRITE_ACCESS | \
|
|
|
|
EFI_VARIABLE_APPEND_WRITE)
|
2013-02-03 20:16:40 +00:00
|
|
|
/*
|
|
|
|
* Length of a GUID string (strlen("aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"))
|
|
|
|
* not including trailing NUL
|
|
|
|
*/
|
|
|
|
#define EFI_VARIABLE_GUID_LEN 36
|
|
|
|
|
2011-11-15 12:57:26 +00:00
|
|
|
/*
|
|
|
|
* The type of search to perform when calling boottime->locate_handle
|
|
|
|
*/
|
|
|
|
#define EFI_LOCATE_ALL_HANDLES 0
|
|
|
|
#define EFI_LOCATE_BY_REGISTER_NOTIFY 1
|
|
|
|
#define EFI_LOCATE_BY_PROTOCOL 2
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/*
|
|
|
|
* EFI Device Path information
|
|
|
|
*/
|
|
|
|
#define EFI_DEV_HW 0x01
|
|
|
|
#define EFI_DEV_PCI 1
|
|
|
|
#define EFI_DEV_PCCARD 2
|
|
|
|
#define EFI_DEV_MEM_MAPPED 3
|
|
|
|
#define EFI_DEV_VENDOR 4
|
|
|
|
#define EFI_DEV_CONTROLLER 5
|
|
|
|
#define EFI_DEV_ACPI 0x02
|
|
|
|
#define EFI_DEV_BASIC_ACPI 1
|
|
|
|
#define EFI_DEV_EXPANDED_ACPI 2
|
|
|
|
#define EFI_DEV_MSG 0x03
|
|
|
|
#define EFI_DEV_MSG_ATAPI 1
|
|
|
|
#define EFI_DEV_MSG_SCSI 2
|
|
|
|
#define EFI_DEV_MSG_FC 3
|
|
|
|
#define EFI_DEV_MSG_1394 4
|
|
|
|
#define EFI_DEV_MSG_USB 5
|
|
|
|
#define EFI_DEV_MSG_USB_CLASS 15
|
|
|
|
#define EFI_DEV_MSG_I20 6
|
|
|
|
#define EFI_DEV_MSG_MAC 11
|
|
|
|
#define EFI_DEV_MSG_IPV4 12
|
|
|
|
#define EFI_DEV_MSG_IPV6 13
|
|
|
|
#define EFI_DEV_MSG_INFINIBAND 9
|
|
|
|
#define EFI_DEV_MSG_UART 14
|
|
|
|
#define EFI_DEV_MSG_VENDOR 10
|
|
|
|
#define EFI_DEV_MEDIA 0x04
|
|
|
|
#define EFI_DEV_MEDIA_HARD_DRIVE 1
|
|
|
|
#define EFI_DEV_MEDIA_CDROM 2
|
|
|
|
#define EFI_DEV_MEDIA_VENDOR 3
|
|
|
|
#define EFI_DEV_MEDIA_FILE 4
|
|
|
|
#define EFI_DEV_MEDIA_PROTOCOL 5
|
|
|
|
#define EFI_DEV_BIOS_BOOT 0x05
|
|
|
|
#define EFI_DEV_END_PATH 0x7F
|
|
|
|
#define EFI_DEV_END_PATH2 0xFF
|
|
|
|
#define EFI_DEV_END_INSTANCE 0x01
|
|
|
|
#define EFI_DEV_END_ENTIRE 0xFF
|
|
|
|
|
|
|
|
struct efi_generic_dev_path {
|
|
|
|
u8 type;
|
|
|
|
u8 sub_type;
|
|
|
|
u16 length;
|
|
|
|
} __attribute ((packed));
|
|
|
|
|
2008-02-25 07:18:37 +00:00
|
|
|
static inline void memrange_efi_to_native(u64 *addr, u64 *npages)
|
|
|
|
{
|
|
|
|
*npages = PFN_UP(*addr + (*npages<<EFI_PAGE_SHIFT)) - PFN_DOWN(*addr);
|
|
|
|
*addr &= PAGE_MASK;
|
|
|
|
}
|
|
|
|
|
2011-03-12 01:43:27 +00:00
|
|
|
/*
|
|
|
|
* EFI Variable support.
|
|
|
|
*
|
|
|
|
* Different firmware drivers can expose their EFI-like variables using
|
|
|
|
* the following.
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct efivar_operations {
|
|
|
|
efi_get_variable_t *get_variable;
|
|
|
|
efi_get_next_variable_t *get_next_variable;
|
|
|
|
efi_set_variable_t *set_variable;
|
2014-09-30 20:58:52 +00:00
|
|
|
efi_set_variable_nonblocking_t *set_variable_nonblocking;
|
2013-03-25 09:14:30 +00:00
|
|
|
efi_query_variable_store_t *query_variable_store;
|
2011-03-12 01:43:27 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct efivars {
|
|
|
|
/*
|
|
|
|
* ->lock protects two things:
|
2014-07-08 11:28:33 +00:00
|
|
|
* 1) efivarfs_list and efivars_sysfs_list
|
|
|
|
* 2) ->ops calls
|
2011-03-12 01:43:27 +00:00
|
|
|
*/
|
|
|
|
spinlock_t lock;
|
|
|
|
struct kset *kset;
|
2012-10-05 05:54:56 +00:00
|
|
|
struct kobject *kobject;
|
2011-03-12 01:43:27 +00:00
|
|
|
const struct efivar_operations *ops;
|
|
|
|
};
|
|
|
|
|
2013-02-03 20:16:40 +00:00
|
|
|
/*
|
|
|
|
* The maximum size of VariableName + Data = 1024
|
|
|
|
* Therefore, it's reasonable to save that much
|
|
|
|
* space in each part of the structure,
|
|
|
|
* and we use a page for reading/writing.
|
|
|
|
*/
|
|
|
|
|
2014-03-17 10:57:00 +00:00
|
|
|
#define EFI_VAR_NAME_LEN 1024
|
|
|
|
|
2013-02-03 20:16:40 +00:00
|
|
|
struct efi_variable {
|
2014-03-17 10:57:00 +00:00
|
|
|
efi_char16_t VariableName[EFI_VAR_NAME_LEN/sizeof(efi_char16_t)];
|
2013-02-03 20:16:40 +00:00
|
|
|
efi_guid_t VendorGuid;
|
|
|
|
unsigned long DataSize;
|
|
|
|
__u8 Data[1024];
|
|
|
|
efi_status_t Status;
|
|
|
|
__u32 Attributes;
|
|
|
|
} __attribute__((packed));
|
|
|
|
|
|
|
|
struct efivar_entry {
|
|
|
|
struct efi_variable var;
|
|
|
|
struct list_head list;
|
|
|
|
struct kobject kobj;
|
efivars, efi-pstore: Hold off deletion of sysfs entry until the scan is completed
Currently, when mounting pstore file system, a read callback of
efi_pstore driver runs mutiple times as below.
- In the first read callback, scan efivar_sysfs_list from head and pass
a kmsg buffer of a entry to an upper pstore layer.
- In the second read callback, rescan efivar_sysfs_list from the entry
and pass another kmsg buffer to it.
- Repeat the scan and pass until the end of efivar_sysfs_list.
In this process, an entry is read across the multiple read function
calls. To avoid race between the read and erasion, the whole process
above is protected by a spinlock, holding in open() and releasing in
close().
At the same time, kmemdup() is called to pass the buffer to pstore
filesystem during it. And then, it causes a following lockdep warning.
To make the dynamic memory allocation runnable without taking spinlock,
holding off a deletion of sysfs entry if it happens while scanning it
via efi_pstore, and deleting it after the scan is completed.
To implement it, this patch introduces two flags, scanning and deleting,
to efivar_entry.
On the code basis, it seems that all the scanning and deleting logic is
not needed because __efivars->lock are not dropped when reading from the
EFI variable store.
But, the scanning and deleting logic is still needed because an
efi-pstore and a pstore filesystem works as follows.
In case an entry(A) is found, the pointer is saved to psi->data. And
efi_pstore_read() passes the entry(A) to a pstore filesystem by
releasing __efivars->lock.
And then, the pstore filesystem calls efi_pstore_read() again and the
same entry(A), which is saved to psi->data, is used for resuming to scan
a sysfs-list.
So, to protect the entry(A), the logic is needed.
[ 1.143710] ------------[ cut here ]------------
[ 1.144058] WARNING: CPU: 1 PID: 1 at kernel/lockdep.c:2740 lockdep_trace_alloc+0x104/0x110()
[ 1.144058] DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags))
[ 1.144058] Modules linked in:
[ 1.144058] CPU: 1 PID: 1 Comm: systemd Not tainted 3.11.0-rc5 #2
[ 1.144058] 0000000000000009 ffff8800797e9ae0 ffffffff816614a5 ffff8800797e9b28
[ 1.144058] ffff8800797e9b18 ffffffff8105510d 0000000000000080 0000000000000046
[ 1.144058] 00000000000000d0 00000000000003af ffffffff81ccd0c0 ffff8800797e9b78
[ 1.144058] Call Trace:
[ 1.144058] [<ffffffff816614a5>] dump_stack+0x54/0x74
[ 1.144058] [<ffffffff8105510d>] warn_slowpath_common+0x7d/0xa0
[ 1.144058] [<ffffffff8105517c>] warn_slowpath_fmt+0x4c/0x50
[ 1.144058] [<ffffffff8131290f>] ? vsscanf+0x57f/0x7b0
[ 1.144058] [<ffffffff810bbd74>] lockdep_trace_alloc+0x104/0x110
[ 1.144058] [<ffffffff81192da0>] __kmalloc_track_caller+0x50/0x280
[ 1.144058] [<ffffffff815147bb>] ? efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff8115b260>] kmemdup+0x20/0x50
[ 1.144058] [<ffffffff815147bb>] efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff81514800>] ? efi_pstore_read_func.part.1+0x170/0x170
[ 1.144058] [<ffffffff815148b4>] efi_pstore_read_func+0xb4/0xe0
[ 1.144058] [<ffffffff81512b7b>] __efivar_entry_iter+0xfb/0x120
[ 1.144058] [<ffffffff8151428f>] efi_pstore_read+0x3f/0x50
[ 1.144058] [<ffffffff8128d7ba>] pstore_get_records+0x9a/0x150
[ 1.158207] [<ffffffff812af25c>] ? selinux_d_instantiate+0x1c/0x20
[ 1.158207] [<ffffffff8128ce30>] ? parse_options+0x80/0x80
[ 1.158207] [<ffffffff8128ced5>] pstore_fill_super+0xa5/0xc0
[ 1.158207] [<ffffffff811ae7d2>] mount_single+0xa2/0xd0
[ 1.158207] [<ffffffff8128ccf8>] pstore_mount+0x18/0x20
[ 1.158207] [<ffffffff811ae8b9>] mount_fs+0x39/0x1b0
[ 1.158207] [<ffffffff81160550>] ? __alloc_percpu+0x10/0x20
[ 1.158207] [<ffffffff811c9493>] vfs_kern_mount+0x63/0xf0
[ 1.158207] [<ffffffff811cbb0e>] do_mount+0x23e/0xa20
[ 1.158207] [<ffffffff8115b51b>] ? strndup_user+0x4b/0xf0
[ 1.158207] [<ffffffff811cc373>] SyS_mount+0x83/0xc0
[ 1.158207] [<ffffffff81673cc2>] system_call_fastpath+0x16/0x1b
[ 1.158207] ---[ end trace 61981bc62de9f6f4 ]---
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Tested-by: Madper Xie <cxie@redhat.com>
Cc: stable@kernel.org
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2013-10-30 19:27:26 +00:00
|
|
|
bool scanning;
|
|
|
|
bool deleting;
|
2013-02-03 20:16:40 +00:00
|
|
|
};
|
|
|
|
|
2014-01-10 13:47:37 +00:00
|
|
|
struct efi_simple_text_output_protocol_32 {
|
|
|
|
u32 reset;
|
|
|
|
u32 output_string;
|
|
|
|
u32 test_string;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct efi_simple_text_output_protocol_64 {
|
|
|
|
u64 reset;
|
|
|
|
u64 output_string;
|
|
|
|
u64 test_string;
|
|
|
|
};
|
2013-09-22 22:45:26 +00:00
|
|
|
|
|
|
|
struct efi_simple_text_output_protocol {
|
|
|
|
void *reset;
|
|
|
|
efi_status_t (*output_string)(void *, void *);
|
|
|
|
void *test_string;
|
|
|
|
};
|
|
|
|
|
2013-02-08 15:48:51 +00:00
|
|
|
extern struct list_head efivar_sysfs_list;
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
efivar_unregister(struct efivar_entry *var)
|
|
|
|
{
|
|
|
|
kobject_put(&var->kobj);
|
|
|
|
}
|
|
|
|
|
2013-02-03 20:16:40 +00:00
|
|
|
int efivars_register(struct efivars *efivars,
|
2011-03-12 01:43:27 +00:00
|
|
|
const struct efivar_operations *ops,
|
2013-02-03 20:16:40 +00:00
|
|
|
struct kobject *kobject);
|
|
|
|
int efivars_unregister(struct efivars *efivars);
|
|
|
|
struct kobject *efivars_kobject(void);
|
|
|
|
|
|
|
|
int efivar_init(int (*func)(efi_char16_t *, efi_guid_t, unsigned long, void *),
|
|
|
|
void *data, bool atomic, bool duplicates,
|
|
|
|
struct list_head *head);
|
|
|
|
|
|
|
|
void efivar_entry_add(struct efivar_entry *entry, struct list_head *head);
|
|
|
|
void efivar_entry_remove(struct efivar_entry *entry);
|
|
|
|
|
|
|
|
int __efivar_entry_delete(struct efivar_entry *entry);
|
|
|
|
int efivar_entry_delete(struct efivar_entry *entry);
|
|
|
|
|
|
|
|
int efivar_entry_size(struct efivar_entry *entry, unsigned long *size);
|
2013-04-29 19:08:02 +00:00
|
|
|
int __efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
|
|
|
unsigned long *size, void *data);
|
2013-02-03 20:16:40 +00:00
|
|
|
int efivar_entry_get(struct efivar_entry *entry, u32 *attributes,
|
|
|
|
unsigned long *size, void *data);
|
|
|
|
int efivar_entry_set(struct efivar_entry *entry, u32 attributes,
|
|
|
|
unsigned long size, void *data, struct list_head *head);
|
|
|
|
int efivar_entry_set_get_size(struct efivar_entry *entry, u32 attributes,
|
|
|
|
unsigned long *size, void *data, bool *set);
|
|
|
|
int efivar_entry_set_safe(efi_char16_t *name, efi_guid_t vendor, u32 attributes,
|
|
|
|
bool block, unsigned long size, void *data);
|
|
|
|
|
|
|
|
void efivar_entry_iter_begin(void);
|
|
|
|
void efivar_entry_iter_end(void);
|
|
|
|
|
|
|
|
int __efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
|
|
|
|
struct list_head *head, void *data,
|
|
|
|
struct efivar_entry **prev);
|
|
|
|
int efivar_entry_iter(int (*func)(struct efivar_entry *, void *),
|
|
|
|
struct list_head *head, void *data);
|
|
|
|
|
|
|
|
struct efivar_entry *efivar_entry_find(efi_char16_t *name, efi_guid_t guid,
|
|
|
|
struct list_head *head, bool remove);
|
|
|
|
|
2014-03-17 10:57:00 +00:00
|
|
|
bool efivar_validate(efi_char16_t *var_name, u8 *data, unsigned long len);
|
2013-02-03 20:16:40 +00:00
|
|
|
|
2013-02-08 15:37:06 +00:00
|
|
|
extern struct work_struct efivar_work;
|
2013-02-08 15:48:51 +00:00
|
|
|
void efivar_run_worker(void);
|
|
|
|
|
2013-02-08 15:37:06 +00:00
|
|
|
#if defined(CONFIG_EFI_VARS) || defined(CONFIG_EFI_VARS_MODULE)
|
2013-02-03 20:16:40 +00:00
|
|
|
int efivars_sysfs_init(void);
|
2011-03-12 01:43:27 +00:00
|
|
|
|
efivars, efi-pstore: Hold off deletion of sysfs entry until the scan is completed
Currently, when mounting pstore file system, a read callback of
efi_pstore driver runs mutiple times as below.
- In the first read callback, scan efivar_sysfs_list from head and pass
a kmsg buffer of a entry to an upper pstore layer.
- In the second read callback, rescan efivar_sysfs_list from the entry
and pass another kmsg buffer to it.
- Repeat the scan and pass until the end of efivar_sysfs_list.
In this process, an entry is read across the multiple read function
calls. To avoid race between the read and erasion, the whole process
above is protected by a spinlock, holding in open() and releasing in
close().
At the same time, kmemdup() is called to pass the buffer to pstore
filesystem during it. And then, it causes a following lockdep warning.
To make the dynamic memory allocation runnable without taking spinlock,
holding off a deletion of sysfs entry if it happens while scanning it
via efi_pstore, and deleting it after the scan is completed.
To implement it, this patch introduces two flags, scanning and deleting,
to efivar_entry.
On the code basis, it seems that all the scanning and deleting logic is
not needed because __efivars->lock are not dropped when reading from the
EFI variable store.
But, the scanning and deleting logic is still needed because an
efi-pstore and a pstore filesystem works as follows.
In case an entry(A) is found, the pointer is saved to psi->data. And
efi_pstore_read() passes the entry(A) to a pstore filesystem by
releasing __efivars->lock.
And then, the pstore filesystem calls efi_pstore_read() again and the
same entry(A), which is saved to psi->data, is used for resuming to scan
a sysfs-list.
So, to protect the entry(A), the logic is needed.
[ 1.143710] ------------[ cut here ]------------
[ 1.144058] WARNING: CPU: 1 PID: 1 at kernel/lockdep.c:2740 lockdep_trace_alloc+0x104/0x110()
[ 1.144058] DEBUG_LOCKS_WARN_ON(irqs_disabled_flags(flags))
[ 1.144058] Modules linked in:
[ 1.144058] CPU: 1 PID: 1 Comm: systemd Not tainted 3.11.0-rc5 #2
[ 1.144058] 0000000000000009 ffff8800797e9ae0 ffffffff816614a5 ffff8800797e9b28
[ 1.144058] ffff8800797e9b18 ffffffff8105510d 0000000000000080 0000000000000046
[ 1.144058] 00000000000000d0 00000000000003af ffffffff81ccd0c0 ffff8800797e9b78
[ 1.144058] Call Trace:
[ 1.144058] [<ffffffff816614a5>] dump_stack+0x54/0x74
[ 1.144058] [<ffffffff8105510d>] warn_slowpath_common+0x7d/0xa0
[ 1.144058] [<ffffffff8105517c>] warn_slowpath_fmt+0x4c/0x50
[ 1.144058] [<ffffffff8131290f>] ? vsscanf+0x57f/0x7b0
[ 1.144058] [<ffffffff810bbd74>] lockdep_trace_alloc+0x104/0x110
[ 1.144058] [<ffffffff81192da0>] __kmalloc_track_caller+0x50/0x280
[ 1.144058] [<ffffffff815147bb>] ? efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff8115b260>] kmemdup+0x20/0x50
[ 1.144058] [<ffffffff815147bb>] efi_pstore_read_func.part.1+0x12b/0x170
[ 1.144058] [<ffffffff81514800>] ? efi_pstore_read_func.part.1+0x170/0x170
[ 1.144058] [<ffffffff815148b4>] efi_pstore_read_func+0xb4/0xe0
[ 1.144058] [<ffffffff81512b7b>] __efivar_entry_iter+0xfb/0x120
[ 1.144058] [<ffffffff8151428f>] efi_pstore_read+0x3f/0x50
[ 1.144058] [<ffffffff8128d7ba>] pstore_get_records+0x9a/0x150
[ 1.158207] [<ffffffff812af25c>] ? selinux_d_instantiate+0x1c/0x20
[ 1.158207] [<ffffffff8128ce30>] ? parse_options+0x80/0x80
[ 1.158207] [<ffffffff8128ced5>] pstore_fill_super+0xa5/0xc0
[ 1.158207] [<ffffffff811ae7d2>] mount_single+0xa2/0xd0
[ 1.158207] [<ffffffff8128ccf8>] pstore_mount+0x18/0x20
[ 1.158207] [<ffffffff811ae8b9>] mount_fs+0x39/0x1b0
[ 1.158207] [<ffffffff81160550>] ? __alloc_percpu+0x10/0x20
[ 1.158207] [<ffffffff811c9493>] vfs_kern_mount+0x63/0xf0
[ 1.158207] [<ffffffff811cbb0e>] do_mount+0x23e/0xa20
[ 1.158207] [<ffffffff8115b51b>] ? strndup_user+0x4b/0xf0
[ 1.158207] [<ffffffff811cc373>] SyS_mount+0x83/0xc0
[ 1.158207] [<ffffffff81673cc2>] system_call_fastpath+0x16/0x1b
[ 1.158207] ---[ end trace 61981bc62de9f6f4 ]---
Signed-off-by: Seiji Aguchi <seiji.aguchi@hds.com>
Tested-by: Madper Xie <cxie@redhat.com>
Cc: stable@kernel.org
Signed-off-by: Matt Fleming <matt.fleming@intel.com>
2013-10-30 19:27:26 +00:00
|
|
|
#define EFIVARS_DATA_SIZE_MAX 1024
|
|
|
|
|
2011-03-12 01:43:27 +00:00
|
|
|
#endif /* CONFIG_EFI_VARS */
|
|
|
|
|
2013-12-20 10:02:18 +00:00
|
|
|
#ifdef CONFIG_EFI_RUNTIME_MAP
|
|
|
|
int efi_runtime_map_init(struct kobject *);
|
|
|
|
void efi_runtime_map_setup(void *, int, u32);
|
2014-08-08 21:26:11 +00:00
|
|
|
int efi_get_runtime_map_size(void);
|
|
|
|
int efi_get_runtime_map_desc_size(void);
|
|
|
|
int efi_runtime_map_copy(void *buf, size_t bufsz);
|
2013-12-20 10:02:18 +00:00
|
|
|
#else
|
|
|
|
static inline int efi_runtime_map_init(struct kobject *kobj)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void
|
|
|
|
efi_runtime_map_setup(void *map, int nr_entries, u32 desc_size) {}
|
2014-08-08 21:26:11 +00:00
|
|
|
|
|
|
|
static inline int efi_get_runtime_map_size(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int efi_get_runtime_map_desc_size(void)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int efi_runtime_map_copy(void *buf, size_t bufsz)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-12-20 10:02:18 +00:00
|
|
|
#endif
|
|
|
|
|
2014-07-02 12:54:42 +00:00
|
|
|
/* prototypes shared between arch specific and generic stub code */
|
|
|
|
|
|
|
|
#define pr_efi(sys_table, msg) efi_printk(sys_table, "EFI stub: "msg)
|
|
|
|
#define pr_efi_err(sys_table, msg) efi_printk(sys_table, "EFI stub: ERROR: "msg)
|
|
|
|
|
|
|
|
void efi_printk(efi_system_table_t *sys_table_arg, char *str);
|
|
|
|
|
|
|
|
void efi_free(efi_system_table_t *sys_table_arg, unsigned long size,
|
|
|
|
unsigned long addr);
|
|
|
|
|
|
|
|
char *efi_convert_cmdline(efi_system_table_t *sys_table_arg,
|
|
|
|
efi_loaded_image_t *image, int *cmd_line_len);
|
|
|
|
|
|
|
|
efi_status_t efi_get_memory_map(efi_system_table_t *sys_table_arg,
|
|
|
|
efi_memory_desc_t **map,
|
|
|
|
unsigned long *map_size,
|
|
|
|
unsigned long *desc_size,
|
|
|
|
u32 *desc_ver,
|
|
|
|
unsigned long *key_ptr);
|
|
|
|
|
|
|
|
efi_status_t efi_low_alloc(efi_system_table_t *sys_table_arg,
|
|
|
|
unsigned long size, unsigned long align,
|
|
|
|
unsigned long *addr);
|
|
|
|
|
|
|
|
efi_status_t efi_high_alloc(efi_system_table_t *sys_table_arg,
|
|
|
|
unsigned long size, unsigned long align,
|
|
|
|
unsigned long *addr, unsigned long max);
|
|
|
|
|
|
|
|
efi_status_t efi_relocate_kernel(efi_system_table_t *sys_table_arg,
|
|
|
|
unsigned long *image_addr,
|
|
|
|
unsigned long image_size,
|
|
|
|
unsigned long alloc_size,
|
|
|
|
unsigned long preferred_addr,
|
|
|
|
unsigned long alignment);
|
|
|
|
|
|
|
|
efi_status_t handle_cmdline_files(efi_system_table_t *sys_table_arg,
|
|
|
|
efi_loaded_image_t *image,
|
|
|
|
char *cmd_line, char *option_string,
|
|
|
|
unsigned long max_addr,
|
|
|
|
unsigned long *load_addr,
|
|
|
|
unsigned long *load_size);
|
|
|
|
|
2014-08-05 10:52:11 +00:00
|
|
|
efi_status_t efi_parse_options(char *cmdline);
|
|
|
|
|
2014-08-14 09:15:26 +00:00
|
|
|
bool efi_runtime_disabled(void);
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif /* _LINUX_EFI_H */
|