diff options
author | Sascha Hauer <s.hauer@pengutronix.de> | 2014-08-07 06:14:56 +0200 |
---|---|---|
committer | Sascha Hauer <s.hauer@pengutronix.de> | 2014-08-07 06:14:56 +0200 |
commit | 8a11a59b379b641423a6ed655aae36ec00404403 (patch) | |
tree | a10f059d0bdcf9ba043cef744d605f9260991b18 /common | |
parent | e3ff4dfa41b4e8afc26b69e5c3d8c127f0f37c39 (diff) | |
parent | 9183a8c683014f7f6dae004009556c9c0d4d2a15 (diff) | |
download | barebox-8a11a59b379b641423a6ed655aae36ec00404403.tar.gz barebox-8a11a59b379b641423a6ed655aae36ec00404403.tar.xz |
Merge branch 'for-next/efi'
Conflicts:
.gitignore
Makefile
drivers/serial/Makefile
Diffstat (limited to 'common')
-rw-r--r-- | common/Kconfig | 8 | ||||
-rw-r--r-- | common/Makefile | 4 | ||||
-rw-r--r-- | common/block.c | 3 | ||||
-rw-r--r-- | common/console.c | 29 | ||||
-rw-r--r-- | common/efi-devicepath.c | 1370 | ||||
-rw-r--r-- | common/efi-guid.c | 84 | ||||
-rw-r--r-- | common/filetype.c | 4 | ||||
-rw-r--r-- | common/memory.c | 2 | ||||
-rw-r--r-- | common/partitions/efi.c | 2 | ||||
-rw-r--r-- | common/partitions/efi.h | 2 |
10 files changed, 1504 insertions, 4 deletions
diff --git a/common/Kconfig b/common/Kconfig index bba7f159c1..8b361260c0 100644 --- a/common/Kconfig +++ b/common/Kconfig @@ -64,6 +64,14 @@ config MENUTREE select GLOB select GLOB_SORT +config EFI_GUID + bool + help + With this option a table of EFI guids is compiled in. + +config EFI_DEVICEPATH + bool + menu "General Settings" config LOCALVERSION diff --git a/common/Makefile b/common/Makefile index 204241c919..4220e15127 100644 --- a/common/Makefile +++ b/common/Makefile @@ -43,7 +43,9 @@ obj-$(CONFIG_RESET_SOURCE) += reset_source.o obj-$(CONFIG_SHELL_HUSH) += hush.o obj-$(CONFIG_SHELL_SIMPLE) += parser.o obj-$(CONFIG_UIMAGE) += image.o uimage.o -obj-$(CONFIG_MENUTREE) += menutree.o +obj-$(CONFIG_MENUTREE) += menutree.o +obj-$(CONFIG_EFI_GUID) += efi-guid.o +obj-$(CONFIG_EFI_DEVICEPATH) += efi-devicepath.o quiet_cmd_pwd_h = PWDH $@ ifdef CONFIG_PASSWORD diff --git a/common/block.c b/common/block.c index e522ee425a..0edc8619ef 100644 --- a/common/block.c +++ b/common/block.c @@ -55,6 +55,9 @@ static int writebuffer_flush(struct block_device *blk) } } + if (blk->ops->flush) + return blk->ops->flush(blk); + return 0; } diff --git a/common/console.c b/common/console.c index f9823661f0..e5f4267cbd 100644 --- a/common/console.c +++ b/common/console.c @@ -162,6 +162,22 @@ static void console_set_stdoutpath(struct console_device *cdev) free(str); } +static int __console_puts(struct console_device *cdev, const char *s) +{ + int n = 0; + + while (*s) { + if (*s == '\n') { + cdev->putc(cdev, '\r'); + n++; + } + cdev->putc(cdev, *s); + n++; + s++; + } + return n; +} + int console_register(struct console_device *newcdev) { struct device_d *dev = &newcdev->class_dev; @@ -188,6 +204,9 @@ int console_register(struct console_device *newcdev) NULL, &newcdev->baudrate, "%u", newcdev); } + if (newcdev->putc && !newcdev->puts) + newcdev->puts = __console_puts; + dev_add_param(dev, "active", console_std_set, NULL, 0); if (IS_ENABLED(CONFIG_CONSOLE_ACTIVATE_FIRST)) { @@ -348,9 +367,19 @@ EXPORT_SYMBOL(console_putc); int console_puts(unsigned int ch, const char *str) { + struct console_device *cdev; const char *s = str; int n = 0; + if (initialized == CONSOLE_INIT_FULL) { + for_each_console(cdev) { + if (cdev->f_active & ch) { + n = cdev->puts(cdev, str); + } + } + return n; + } + while (*s) { if (*s == '\n') { console_putc(ch, '\r'); diff --git a/common/efi-devicepath.c b/common/efi-devicepath.c new file mode 100644 index 0000000000..2b1d916768 --- /dev/null +++ b/common/efi-devicepath.c @@ -0,0 +1,1370 @@ +#include <common.h> +#include <efi.h> +#include <malloc.h> +#include <string.h> +#include <wchar.h> + +struct string { + char *str; + int len; +}; + +char *cprintf(struct string *str, const char *fmt, ...) + __attribute__ ((format(__printf__, 2, 3))); + +char *cprintf(struct string *str, const char *fmt, ...) +{ + va_list args; + int len; + + va_start(args, fmt); + if (str->str) + len = vsprintf(str->str + str->len, fmt, args); + else + len = vsnprintf(NULL, 0, fmt, args); + va_end(args); + + str->len += len; + + return NULL; +} + +#define MIN_ALIGNMENT_SIZE 8 /* FIXME: X86_64 specific */ +#define ALIGN_SIZE(a) ((a % MIN_ALIGNMENT_SIZE) ? MIN_ALIGNMENT_SIZE - (a % MIN_ALIGNMENT_SIZE) : 0) + +#define EFI_DP_TYPE_MASK 0x7f +#define EFI_DP_TYPE_UNPACKED 0x80 + +#define END_DEVICE_PATH_TYPE 0x7f + +#define END_ENTIRE_DEVICE_PATH_SUBTYPE 0xff +#define END_INSTANCE_DEVICE_PATH_SUBTYPE 0x01 +#define END_DEVICE_PATH_LENGTH (sizeof(struct efi_device_path)) + +#define DP_IS_END_TYPE(a) +#define DP_IS_END_SUBTYPE(a) ( ((a)->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE ) + +#define device_path_type(a) ( ((a)->type) & EFI_DP_TYPE_MASK ) +#define next_device_path_node(a) ( (struct efi_device_path *) ( ((u8 *) (a)) + (a)->length)) +#define is_device_path_end_type(a) ( device_path_type(a) == END_DEVICE_PATH_TYPE ) +#define is_device_path_end_sub_type(a) ( (a)->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE ) +#define is_device_path_end(a) ( is_device_path_end_type(a) && is_device_path_end_sub_type(a) ) +#define is_device_path_unpacked(a) ( (a)->type & EFI_DP_TYPE_UNPACKED ) + +#define set_device_path_end_node(a) { \ + (a)->type = END_DEVICE_PATH_TYPE; \ + (a)->sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE; \ + (a)->length = sizeof(struct efi_device_path); \ + } + +/* + * Hardware Device Path (UEFI 2.4 specification, version 2.4 § 9.3.2.) + */ + +#define HARDWARE_DEVICE_PATH 0x01 + +#define HW_PCI_DP 0x01 +struct pci_device_path { + struct efi_device_path header; + u8 Function; + u8 Device; +}; + +#define HW_PCCARD_DP 0x02 +struct pccard_device_path { + struct efi_device_path header; + u8 function_number; +}; + +#define HW_MEMMAP_DP 0x03 +struct memmap_device_path { + struct efi_device_path header; + u32 memory_type; + efi_physical_addr_t starting_address; + efi_physical_addr_t ending_address; +}; + +#define HW_VENDOR_DP 0x04 +struct vendor_device_path { + struct efi_device_path header; + efi_guid_t Guid; +}; + +struct unknown_device_vendor_device_path { + struct vendor_device_path device_path; + u8 legacy_drive_letter; +}; + +#define HW_CONTROLLER_DP 0x05 +struct controller_device_path { + struct efi_device_path header; + u32 Controller; +}; + +/* + * ACPI Device Path (UEFI 2.4 specification, version 2.4 § 9.3.3 and 9.3.4.) + */ +#define ACPI_DEVICE_PATH 0x02 + +#define ACPI_DP 0x01 +struct acpi_hid_device_path { + struct efi_device_path header; + u32 HID; + u32 UID; +}; + +#define EXPANDED_ACPI_DP 0x02 +struct expanded_acpi_hid_device_path { + struct efi_device_path header; + u32 HID; + u32 UID; + u32 CID; + u8 hid_str[1]; +}; + +#define ACPI_ADR_DP 3 +struct acpi_adr_device_path { + struct efi_device_path header; + u32 ADR; +}; + +/* + * EISA ID Macro + * EISA ID Definition 32-bits + * bits[15:0] - three character compressed ASCII EISA ID. + * bits[31:16] - binary number + * Compressed ASCII is 5 bits per character 0b00001 = 'A' 0b11010 = 'Z' + */ +#define PNP_EISA_ID_CONST 0x41d0 +#define EISA_ID(_Name, _Num) ((u32) ((_Name) | (_Num) << 16)) +#define EISA_PNP_ID(_PNPId) (EISA_ID(PNP_EISA_ID_CONST, (_PNPId))) + +#define PNP_EISA_ID_MASK 0xffff +#define EISA_ID_TO_NUM(_Id) ((_Id) >> 16) + +/* + * Messaging Device Path (UEFI 2.4 specification, version 2.4 § 9.3.5.) + */ +#define MESSAGING_DEVICE_PATH 0x03 + +#define MSG_ATAPI_DP 0x01 +struct atapi_device_path { + struct efi_device_path header; + u8 primary_secondary; + u8 slave_master; + u16 Lun; +}; + +#define MSG_SCSI_DP 0x02 +struct scsi_device_path { + struct efi_device_path header; + u16 Pun; + u16 Lun; +}; + +#define MSG_FIBRECHANNEL_DP 0x03 +struct fibrechannel_device_path { + struct efi_device_path header; + u32 Reserved; + u64 WWN; + u64 Lun; +}; + +/** + * Fibre Channel Ex sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.5.6. + */ +#define MSG_FIBRECHANNELEX_DP 21 +struct fibrechannelex_device_path { + struct efi_device_path header; + u32 Reserved; + u8 WWN[8]; /* World Wide Name */ + u8 Lun[8]; /* Logical unit, T-10 SCSI Architecture Model 4 specification */ +}; + +#define MSG_1394_DP 0x04 +struct f1394_device_path { + struct efi_device_path header; + u32 Reserved; + u64 Guid; +}; + +#define MSG_USB_DP 0x05 +struct usb_device_path { + struct efi_device_path header; + u8 Port; + u8 Endpoint; +}; + +/** + * SATA Device Path sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.5.6. + */ +#define MSG_SATA_DP 18 +struct sata_device_path { + struct efi_device_path header; + u16 HBAPort_number; + u16 port_multiplier_port_number; + u16 Lun; /* Logical Unit Number */ +}; + +/** + * USB WWID Device Path sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.5.7. + */ +#define MSG_USB_WWID_DP 16 +struct usb_wwid_device_path { + struct efi_device_path header; + u16 interface_number; + u16 vendor_id; + u16 product_id; + s16 serial_number[1]; /* UTF-16 characters of the USB serial number */ +}; + +/** + * Device Logical Unit sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.5.8. + */ +#define MSG_DEVICE_LOGICAL_UNIT_DP 17 +struct device_logical_unit_device_path { + struct efi_device_path header; + u8 Lun; /* Logical Unit Number */ +}; + +#define MSG_USB_CLASS_DP 0x0_f +struct usb_class_device_path { + struct efi_device_path header; + u16 vendor_id; + u16 product_id; + u8 device_class; + u8 device_subclass; + u8 device_protocol; +}; + +#define MSG_I2_o_DP 0x06 +struct i2_o_device_path { + struct efi_device_path header; + u32 Tid; +}; + +#define MSG_MAC_ADDR_DP 0x0b +struct mac_addr_device_path { + struct efi_device_path header; + efi_mac_address mac_address; + u8 if_type; +}; + +#define MSG_IPv4_DP 0x0c +struct ipv4_device_path { + struct efi_device_path header; + efi_ipv4_address local_ip_address; + efi_ipv4_address remote_ip_address; + u16 local_port; + u16 remote_port; + u16 Protocol; + bool static_ip_address; + /* new from UEFI version 2, code must check length field in header */ + efi_ipv4_address gateway_ip_address; + efi_ipv4_address subnet_mask; +}; + +#define MSG_IPv6_DP 0x0d +struct ipv6_device_path { + struct efi_device_path header; + efi_ipv6_address local_ip_address; + efi_ipv6_address remote_ip_address; + u16 local_port; + u16 remote_port; + u16 Protocol; + bool IPAddress_origin; + /* new from UEFI version 2, code must check length field in header */ + u8 prefix_length; + efi_ipv6_address gateway_ip_address; +}; + +/** + * Device Logical Unit sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.5.8. + */ +#define MSG_VLAN_DP 20 +struct vlan_device_path { + struct efi_device_path header; + u16 vlan_id; +}; + +#define MSG_INFINIBAND_DP 0x09 +struct infiniband_device_path { + struct efi_device_path header; + u32 resource_flags; + efi_guid_t port_gid; + u64 service_id; + u64 target_port_id; + u64 device_id; +}; + +#define MSG_UART_DP 0x0e +struct uart_device_path { + struct efi_device_path header; + u32 Reserved; + u64 baud_rate; + u8 data_bits; + u8 Parity; + u8 stop_bits; +}; + +#define MSG_VENDOR_DP 0x0a +/* Use VENDOR_DEVICE_PATH struct */ + +#define DEVICE_PATH_MESSAGING_PC_ANSI \ + { 0xe0c14753, 0xf9be, 0x11d2, {0x9a, 0x0c, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define DEVICE_PATH_MESSAGING_VT_100 \ + { 0xdfa66065, 0xb419, 0x11d3, {0x9a, 0x2d, 0x00, 0x90, 0x27, 0x3f, 0xc1, 0x4d} } + +#define DEVICE_PATH_MESSAGING_VT_100_PLUS \ + { 0x7baec70b , 0x57e0 , 0x4c76 , { 0x8e , 0x87 , 0x2f , 0x9e , 0x28 , 0x08 , 0x83 , 0x43 } } + +#define DEVICE_PATH_MESSAGING_VT_UTF8 \ + { 0xad15a0d6 , 0x8bec , 0x4acf , { 0xa0 , 0x73 , 0xd0 , 0x1d , 0xe7 , 0x7e , 0x2d , 0x88 } } + +#define EFI_PC_ANSI_GUID \ + { 0xe0c14753 , 0xf9be , 0x11d2 , 0x9a , 0x0c , 0x00 , 0x90 , 0x27 , 0x3f , 0xc1 , 0x4d } + +#define EFI_VT_100_GUID \ + { 0xdfa66065 , 0xb419 , 0x11d3 , 0x9a , 0x2d , 0x00 , 0x90 , 0x27 , 0x3f , 0xc1 , 0x4d } + +#define EFI_VT_100_PLUS_GUID \ + { 0x7baec70b , 0x57e0 , 0x4c76 , 0x8e , 0x87 , 0x2f , 0x9e , 0x28 , 0x08 , 0x83 , 0x43 } + +#define EFI_VT_UTF8_GUID \ + { 0xad15a0d6 , 0x8bec , 0x4acf , 0xa0 , 0x73 , 0xd0 , 0x1d , 0xe7 , 0x7e , 0x2d , 0x88 } + +/* + * Media Device Path (UEFI 2.4 specification, version 2.4 § 9.3.6.) + */ +#define MEDIA_DEVICE_PATH 0x04 + +#define MEDIA_HARDDRIVE_DP 0x01 +struct harddrive_device_path { + struct efi_device_path header; + u32 partition_number; + u64 partition_start; + u64 partition_size; + u8 signature[16]; + u8 mbr_type; + u8 signature_type; +}; + +#define MBR_TYPE_PCAT 0x01 +#define MBR_TYPE_EFI_PARTITION_TABLE_HEADER 0x02 + +#define SIGNATURE_TYPE_MBR 0x01 +#define SIGNATURE_TYPE_GUID 0x02 + +#define MEDIA_CDROM_DP 0x02 +struct cdrom_device_path { + struct efi_device_path header; + u32 boot_entry; + u64 partition_start; + u64 partition_size; +}; + +#define MEDIA_VENDOR_DP 0x03 +/* Use VENDOR_DEVICE_PATH struct */ + +#define MEDIA_FILEPATH_DP 0x04 +struct filepath_device_path { + struct efi_device_path header; + s16 path_name[1]; +}; + +#define SIZE_OF_FILEPATH_DEVICE_PATH offsetof(FILEPATH_DEVICE_PATH,path_name) + +#define MEDIA_PROTOCOL_DP 0x05 +struct media_protocol_device_path { + struct efi_device_path header; + efi_guid_t Protocol; +}; + +/** + * PIWG Firmware File sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.6.6. + */ +#define MEDIA_PIWG_FW_FILE_DP 6 +struct media_fw_vol_filepath_device_path { + struct efi_device_path header; + efi_guid_t fv_file_name; +}; + +/** + * PIWG Firmware Volume Device Path sub_type. + * UEFI 2.0 specification version 2.4 § 9.3.6.7. + */ +#define MEDIA_PIWG_FW_VOL_DP 7 +struct media_fw_vol_device_path { + struct efi_device_path header; + efi_guid_t fv_name; +}; + +/** + * Media relative offset range device path. + * UEFI 2.0 specification version 2.4 § 9.3.6.8. + */ +#define MEDIA_RELATIVE_OFFSET_RANGE_DP 8 +struct media_relative_offset_range_device_path { + struct efi_device_path header; + u32 Reserved; + u64 starting_offset; + u64 ending_offset; +}; + +/* + * BIOS Boot Specification Device Path (UEFI 2.4 specification, version 2.4 § 9.3.7.) + */ +#define BBS_DEVICE_PATH 0x05 + +#define BBS_BBS_DP 0x01 +struct bbs_bbs_device_path { + struct efi_device_path header; + u16 device_type; + u16 status_flag; + s8 String[1]; +}; + +/* device_type definitions - from BBS specification */ +#define BBS_TYPE_FLOPPY 0x01 +#define BBS_TYPE_HARDDRIVE 0x02 +#define BBS_TYPE_CDROM 0x03 +#define BBS_TYPE_PCMCIA 0x04 +#define BBS_TYPE_USB 0x05 +#define BBS_TYPE_EMBEDDED_NETWORK 0x06 +#define BBS_TYPE_DEV 0x80 +#define BBS_TYPE_UNKNOWN 0x_fF + +struct efi_device_path end_device_path = { + .type = END_DEVICE_PATH_TYPE, + .sub_type = END_ENTIRE_DEVICE_PATH_SUBTYPE, + .length = END_DEVICE_PATH_LENGTH, +}; + +struct efi_device_path end_instance_device_path = { + .type = END_DEVICE_PATH_TYPE, + .sub_type = END_INSTANCE_DEVICE_PATH_SUBTYPE, + .length = END_DEVICE_PATH_LENGTH, +}; + +unsigned long +device_path_size(struct efi_device_path *dev_path) +{ + struct efi_device_path *Start; + + Start = dev_path; + while (!is_device_path_end(dev_path)) + dev_path = next_device_path_node(dev_path); + + return ((unsigned long) dev_path - (unsigned long) Start) + + sizeof (struct efi_device_path); +} + +struct efi_device_path * +duplicate_device_path(struct efi_device_path *dev_path) +{ + struct efi_device_path *new_dev_path; + unsigned long Size; + + Size = device_path_size(dev_path); + + new_dev_path = malloc(Size); + if (new_dev_path) + memcpy(new_dev_path, dev_path, Size); + + return new_dev_path; +} + +struct efi_device_path * +device_path_from_handle(efi_handle_t Handle) +{ + efi_status_t Status; + struct efi_device_path *device_path; + + Status = BS->handle_protocol(Handle, &efi_device_path_protocol_guid, + (void *) &device_path); + if (EFI_ERROR(Status)) + device_path = NULL; + + return device_path; +} + +struct efi_device_path * +device_path_instance(struct efi_device_path **device_path, unsigned long *Size) +{ + struct efi_device_path *Start, *Next, *dev_path; + unsigned long Count; + + dev_path = *device_path; + Start = dev_path; + + if (!dev_path) + return NULL; + + for (Count = 0;; Count++) { + Next = next_device_path_node(dev_path); + + if (is_device_path_end_type(dev_path)) + break; + + dev_path = Next; + } + + if (dev_path->sub_type == END_ENTIRE_DEVICE_PATH_SUBTYPE) + Next = NULL; + + *device_path = Next; + + *Size = ((u8 *) dev_path) - ((u8 *) Start); + + return Start; +} + +unsigned long +device_path_instance_count(struct efi_device_path *device_path) +{ + unsigned long Count, Size; + + Count = 0; + while (device_path_instance(&device_path, &Size)) { + Count += 1; + } + + return Count; +} + +struct efi_device_path * +append_device_path(struct efi_device_path *Src1, struct efi_device_path *Src2) +/* + * Src1 may have multiple "instances" and each instance is appended + * Src2 is appended to each instance is Src1. (E.g., it's possible + * to append a new instance to the complete device path by passing + * it in Src2) + */ +{ + unsigned long src1_size, src1_inst, src2_size, Size; + struct efi_device_path *Dst, *Inst; + u8 *dst_pos; + + if (!Src1) + return duplicate_device_path(Src2); + + if (!Src2) { + return duplicate_device_path(Src1); + } + + src1_size = device_path_size(Src1); + src1_inst = device_path_instance_count(Src1); + src2_size = device_path_size(Src2); + Size = src1_size * src1_inst + src2_size; + + Dst = malloc(Size); + if (Dst) { + dst_pos = (u8 *) Dst; + + /* Copy all device path instances */ + + while ((Inst = device_path_instance(&Src1, &Size))) { + + memcpy(dst_pos, Inst, Size); + dst_pos += Size; + + memcpy(dst_pos, Src2, src2_size); + dst_pos += src2_size; + + memcpy(dst_pos, &end_instance_device_path, + sizeof (struct efi_device_path)); + dst_pos += sizeof (struct efi_device_path); + } + + /* Change last end marker */ + dst_pos -= sizeof (struct efi_device_path); + memcpy(dst_pos, &end_device_path, + sizeof (struct efi_device_path)); + } + + return Dst; +} + +struct efi_device_path * +append_device_path_node(struct efi_device_path *Src1, + struct efi_device_path *Src2) +/* + * Src1 may have multiple "instances" and each instance is appended + * Src2 is a signal device path node (without a terminator) that is + * appended to each instance is Src1. + */ +{ + struct efi_device_path *Temp, *Eop; + unsigned long length; + + /* Build a Src2 that has a terminator on it */ + + length = Src2->length; + Temp = malloc(length + sizeof (struct efi_device_path)); + if (!Temp) + return NULL; + + memcpy(Temp, Src2, length); + Eop = next_device_path_node(Temp); + set_device_path_end_node(Eop); + + /* Append device paths */ + + Src1 = append_device_path(Src1, Temp); + free(Temp); + return Src1; +} + +struct efi_device_path * +unpack_device_path(struct efi_device_path *dev_path) +{ + struct efi_device_path *Src, *Dest, *new_path; + unsigned long Size; + + /* Walk device path and round sizes to valid boundries */ + + Src = dev_path; + Size = 0; + for (;;) { + Size += Src->length; + Size += ALIGN_SIZE(Size); + + if (is_device_path_end(Src)) { + break; + } + + Src = next_device_path_node(Src); + } + + new_path = xzalloc(Size); + + Src = dev_path; + Dest = new_path; + for (;;) { + Size = Src->length; + memcpy(Dest, Src, Size); + Size += ALIGN_SIZE(Size); + Dest->length = Size; + Dest->type |= EFI_DP_TYPE_UNPACKED; + Dest = + (struct efi_device_path *) (((u8 *) Dest) + Size); + + if (is_device_path_end(Src)) + break; + + Src = next_device_path_node(Src); + } + + return new_path; +} + +struct efi_device_path * +append_device_path_instance(struct efi_device_path *Src, + struct efi_device_path *Instance) +{ + u8 *Ptr; + struct efi_device_path *dev_path; + unsigned long src_size; + unsigned long instance_size; + + if (Src == NULL) + return duplicate_device_path(Instance); + + src_size = device_path_size(Src); + instance_size = device_path_size(Instance); + Ptr = malloc(src_size + instance_size); + dev_path = (struct efi_device_path *) Ptr; + + memcpy(Ptr, Src, src_size); + + while (!is_device_path_end(dev_path)) + dev_path = next_device_path_node(dev_path); + + /* + * Convert the End to an End Instance, since we are + * appending another instacne after this one its a good + * idea. + */ + dev_path->sub_type = END_INSTANCE_DEVICE_PATH_SUBTYPE; + + dev_path = next_device_path_node(dev_path); + memcpy(dev_path, Instance, instance_size); + + return (struct efi_device_path *) Ptr; +} + +efi_status_t +lib_device_path_to_interface(efi_guid_t * Protocol, + struct efi_device_path *file_path, + void **Interface) +{ + efi_status_t Status; + efi_handle_t Device; + + Status = BS->locate_device_path(Protocol, &file_path, &Device); + + if (!EFI_ERROR(Status)) { + + /* If we didn't get a direct match return not found */ + Status = EFI_NOT_FOUND; + + if (is_device_path_end(file_path)) { + + /* It was a direct match, lookup the protocol interface */ + + Status = + BS->handle_protocol(Device, Protocol, Interface); + } + } + + if (EFI_ERROR(Status)) + *Interface = NULL; + + return Status; +} + +static void +dev_path_pci(struct string *str, void *dev_path) +{ + struct pci_device_path *Pci; + + Pci = dev_path; + cprintf(str, "Pci(0x%x,0x%x)", Pci->Device, Pci->Function); +} + +static void +dev_path_pccard(struct string *str, void *dev_path) +{ + struct pccard_device_path *Pccard; + + Pccard = dev_path; + cprintf(str, "Pccard(0x%x)", Pccard->function_number); +} + +static void +dev_path_mem_map(struct string *str, void *dev_path) +{ + struct memmap_device_path *mem_map; + + mem_map = dev_path; + cprintf(str, "mem_map(%d,0x%llx,0x%llx)", + mem_map->memory_type, + mem_map->starting_address, mem_map->ending_address); +} + +static void +dev_path_controller(struct string *str, void *dev_path) +{ + struct controller_device_path *Controller; + + Controller = dev_path; + cprintf(str, "Ctrl(%d)", Controller->Controller); +} + +static void +dev_path_vendor(struct string *str, void *dev_path) +{ + struct vendor_device_path *Vendor; + char *type; + struct unknown_device_vendor_device_path *unknown_dev_path; + + Vendor = dev_path; + switch (device_path_type(&Vendor->header)) { + case HARDWARE_DEVICE_PATH: + type = "Hw"; + break; + case MESSAGING_DEVICE_PATH: + type = "Msg"; + break; + case MEDIA_DEVICE_PATH: + type = "Media"; + break; + default: + type = "?"; + break; + } + + cprintf(str, "Ven%s(%pU", type, &Vendor->Guid); + if (efi_compare_guid(&Vendor->Guid, &efi_unknown_device_guid) == 0) { + /* GUID used by EFI to enumerate an EDD 1.1 device */ + unknown_dev_path = + (struct unknown_device_vendor_device_path *) Vendor; + cprintf(str, ":%02x)", unknown_dev_path->legacy_drive_letter); + } else { + cprintf(str, ")"); + } +} + +/* + type: 2 (ACPI Device Path) sub_type: 1 (ACPI Device Path) + */ +static void +dev_path_acpi(struct string *str, void *dev_path) +{ + struct acpi_hid_device_path *Acpi; + + Acpi = dev_path; + if ((Acpi->HID & PNP_EISA_ID_MASK) == PNP_EISA_ID_CONST) { + switch (EISA_ID_TO_NUM(Acpi->HID)) { + case 0x301: + cprintf(str, "Keyboard(%d)", Acpi->UID); + break; + + case 0x401: + cprintf(str, "parallel_port(%d)", Acpi->UID); + break; + case 0x501: + cprintf(str, "Serial(%d)", Acpi->UID); + break; + case 0x604: + cprintf(str, "Floppy(%d)", Acpi->UID); + break; + case 0xa03: + cprintf(str, "pci_root(%d)", Acpi->UID); + break; + case 0xa08: + cprintf(str, "pcie_root(%d)", Acpi->UID); + break; + default: + cprintf(str, "Acpi(PNP%04x", + EISA_ID_TO_NUM(Acpi->HID)); + if (Acpi->UID) + cprintf(str, ",%d", Acpi->UID); + cprintf(str, ")"); + break; + } + } else { + cprintf(str, "Acpi(0x%X", Acpi->HID); + if (Acpi->UID) + cprintf(str, ",%d", Acpi->UID); + cprintf(str, ")"); + } +} + +static void +dev_path_atapi(struct string *str, void *dev_path) +{ + struct atapi_device_path *Atapi; + + Atapi = dev_path; + cprintf(str, "Ata(%s,%s)", + Atapi->primary_secondary ? "Secondary" : "Primary", + Atapi->slave_master ? "Slave" : "Master"); +} + +static void +dev_path_scsi(struct string *str, void *dev_path) +{ + struct scsi_device_path *Scsi; + + Scsi = dev_path; + cprintf(str, "Scsi(%d,%d)", Scsi->Pun, Scsi->Lun); +} + +static void +dev_path_fibre(struct string *str, void *dev_path) +{ + struct fibrechannel_device_path *Fibre; + + Fibre = dev_path; + cprintf(str, "Fibre%s(0x%016llx,0x%016llx)", + device_path_type(&Fibre->header) == + MSG_FIBRECHANNEL_DP ? "" : "Ex", Fibre->WWN, Fibre->Lun); +} + +static void +dev_path1394(struct string *str, void *dev_path) +{ + struct f1394_device_path *F1394; + + F1394 = dev_path; + cprintf(str, "1394(%pU)", &F1394->Guid); +} + +static void +dev_path_usb(struct string *str, void *dev_path) +{ + struct usb_device_path *Usb; + + Usb = dev_path; + cprintf(str, "Usb(0x%x,0x%x)", Usb->Port, Usb->Endpoint); +} + +static void +dev_path_i2_o(struct string *str, void *dev_path) +{ + struct i2_o_device_path *i2_o; + + i2_o = dev_path; + cprintf(str, "i2_o(0x%X)", i2_o->Tid); +} + +static void +dev_path_mac_addr(struct string *str, void *dev_path) +{ + struct mac_addr_device_path *MAC; + unsigned long hw_address_size; + unsigned long Index; + + MAC = dev_path; + + /* hw_address_size = sizeof(EFI_MAC_ADDRESS); */ + hw_address_size = MAC->header.length; + hw_address_size -= sizeof (MAC->header); + hw_address_size -= sizeof (MAC->if_type); + if (MAC->if_type == 0x01 || MAC->if_type == 0x00) + hw_address_size = 6; + + cprintf(str, "Mac("); + + for (Index = 0; Index < hw_address_size; Index++) + cprintf(str, "%02x", MAC->mac_address.Addr[Index]); + + if (MAC->if_type != 0) + cprintf(str, ",%d", MAC->if_type); + + cprintf(str, ")"); +} + +static void +cat_print_iPv4(struct string *str, efi_ipv4_address * address) +{ + cprintf(str, "%d.%d.%d.%d", address->Addr[0], address->Addr[1], + address->Addr[2], address->Addr[3]); +} + +static bool +is_not_null_iPv4(efi_ipv4_address * address) +{ + u8 val; + + val = address->Addr[0] | address->Addr[1]; + val |= address->Addr[2] | address->Addr[3]; + + return val != 0; +} + +static void +cat_print_network_protocol(struct string *str, u16 Proto) +{ + if (Proto == 6) + cprintf(str, "TCP"); + else if (Proto == 17) + cprintf(str, "UDP"); + else + cprintf(str, "%d", Proto); +} + +static void +dev_path_iPv4(struct string *str, void *dev_path) +{ + struct ipv4_device_path *ip; + bool show; + + ip = dev_path; + cprintf(str, "IPv4("); + cat_print_iPv4(str, &ip->remote_ip_address); + cprintf(str, ","); + cat_print_network_protocol(str, ip->Protocol); + cprintf(str, ",%s", ip->static_ip_address ? "Static" : "DHCP"); + show = is_not_null_iPv4(&ip->local_ip_address); + if (!show + && ip->header.length == + sizeof (struct ipv4_device_path)) { + /* only version 2 includes gateway and netmask */ + show |= is_not_null_iPv4(&ip->gateway_ip_address); + show |= is_not_null_iPv4(&ip->subnet_mask); + } + if (show) { + cprintf(str, ","); + cat_print_iPv4(str, &ip->local_ip_address); + if (ip->header.length == + sizeof (struct ipv4_device_path)) { + /* only version 2 includes gateway and netmask */ + show = is_not_null_iPv4(&ip->gateway_ip_address); + show |= is_not_null_iPv4(&ip->subnet_mask); + if (show) { + cprintf(str, ","); + cat_print_iPv4(str, &ip->gateway_ip_address); + if (is_not_null_iPv4(&ip->subnet_mask)) { + cprintf(str, ","); + cat_print_iPv4(str, &ip->subnet_mask); + } + } + } + } + cprintf(str, ")"); +} + +#define cat_print_iPv6_ADD( x , y ) ( ( (u16) ( x ) ) << 8 | ( y ) ) +static void +cat_print_ipv6(struct string *str, efi_ipv6_address * address) +{ + cprintf(str, "%x:%x:%x:%x:%x:%x:%x:%x", + cat_print_iPv6_ADD(address->Addr[0], address->Addr[1]), + cat_print_iPv6_ADD(address->Addr[2], address->Addr[3]), + cat_print_iPv6_ADD(address->Addr[4], address->Addr[5]), + cat_print_iPv6_ADD(address->Addr[6], address->Addr[7]), + cat_print_iPv6_ADD(address->Addr[8], address->Addr[9]), + cat_print_iPv6_ADD(address->Addr[10], address->Addr[11]), + cat_print_iPv6_ADD(address->Addr[12], address->Addr[13]), + cat_print_iPv6_ADD(address->Addr[14], address->Addr[15])); +} + +static void +dev_path_iPv6(struct string *str, void *dev_path) +{ + struct ipv6_device_path *ip; + + ip = dev_path; + cprintf(str, "IPv6("); + cat_print_ipv6(str, &ip->remote_ip_address); + cprintf(str, ","); + cat_print_network_protocol(str, ip->Protocol); + cprintf(str, ",%s,", ip->IPAddress_origin ? + (ip->IPAddress_origin == 1 ? "stateless_auto_configure" : + "stateful_auto_configure") : "Static"); + cat_print_ipv6(str, &ip->local_ip_address); + if (ip->header.length == + sizeof (struct ipv6_device_path)) { + cprintf(str, ","); + cat_print_ipv6(str, &ip->gateway_ip_address); + cprintf(str, ","); + cprintf(str, "%d", ip->prefix_length); + } + cprintf(str, ")"); +} + +static void +dev_path_infini_band(struct string *str, void *dev_path) +{ + struct infiniband_device_path *infini_band; + + infini_band = dev_path; + cprintf(str, "Infiniband(0x%x,%pU,0x%llx,0x%llx,0x%llx)", + infini_band->resource_flags, &infini_band->port_gid, + infini_band->service_id, infini_band->target_port_id, + infini_band->device_id); +} + +static void +dev_path_uart(struct string *str, void *dev_path) +{ + struct uart_device_path *Uart; + s8 Parity; + + Uart = dev_path; + switch (Uart->Parity) { + case 0: + Parity = 'D'; + break; + case 1: + Parity = 'N'; + break; + case 2: + Parity = 'E'; + break; + case 3: + Parity = 'O'; + break; + case 4: + Parity = 'M'; + break; + case 5: + Parity = 'S'; + break; + default: + Parity = 'x'; + break; + } + + if (Uart->baud_rate == 0) + cprintf(str, "Uart(DEFAULT %c", Parity); + else + cprintf(str, "Uart(%lld %c", Uart->baud_rate, Parity); + + if (Uart->data_bits == 0) + cprintf(str, "D"); + else + cprintf(str, "%d", Uart->data_bits); + + switch (Uart->stop_bits) { + case 0: + cprintf(str, "D)"); + break; + case 1: + cprintf(str, "1)"); + break; + case 2: + cprintf(str, "1.5)"); + break; + case 3: + cprintf(str, "2)"); + break; + default: + cprintf(str, "x)"); + break; + } +} + +static void +dev_path_sata(struct string *str, void *dev_path) +{ + struct sata_device_path *sata; + + sata = dev_path; + cprintf(str, "Sata(0x%x,0x%x,0x%x)", sata->HBAPort_number, + sata->port_multiplier_port_number, sata->Lun); +} + +static void +dev_path_hard_drive(struct string *str, void *dev_path) +{ + struct harddrive_device_path *hd; + + hd = dev_path; + switch (hd->signature_type) { + case SIGNATURE_TYPE_MBR: + cprintf(str, "HD(Part%d,Sig%08x)", + hd->partition_number, *((u32 *) (&(hd->signature[0]))) + ); + break; + case SIGNATURE_TYPE_GUID: + cprintf(str, "HD(Part%d,Sig%pU)", + hd->partition_number, + (efi_guid_t *) & (hd->signature[0]) + ); + break; + default: + cprintf(str, "HD(Part%d,mbr_type=%02x,sig_type=%02x)", + hd->partition_number, hd->mbr_type, hd->signature_type); + break; + } +} + +static void +dev_path_cdrom(struct string *str, void *dev_path) +{ + struct cdrom_device_path *cd; + + cd = dev_path; + cprintf(str, "CDROM(0x%x)", cd->boot_entry); +} + +static void +dev_path_file_path(struct string *str, void *dev_path) +{ + struct filepath_device_path *Fp; + char *dst; + + Fp = dev_path; + + dst = strdup_wchar_to_char(Fp->path_name); + + cprintf(str, "%s", dst); + + free(dst); +} + +static void +dev_path_media_protocol(struct string *str, void *dev_path) +{ + struct media_protocol_device_path *media_prot; + + media_prot = dev_path; + cprintf(str, "%pU", &media_prot->Protocol); +} + +static void +dev_path_bss_bss(struct string *str, void *dev_path) +{ + struct bbs_bbs_device_path *Bss; + char *type; + + Bss = dev_path; + switch (Bss->device_type) { + case BBS_TYPE_FLOPPY: + type = "Floppy"; + break; + case BBS_TYPE_HARDDRIVE: + type = "Harddrive"; + break; + case BBS_TYPE_CDROM: + type = "CDROM"; + break; + case BBS_TYPE_PCMCIA: + type = "PCMCIA"; + break; + case BBS_TYPE_USB: + type = "Usb"; + break; + case BBS_TYPE_EMBEDDED_NETWORK: + type = "Net"; + break; + default: + type = "?"; + break; + } + + cprintf(str, "Bss-%s(%s)", type, Bss->String); +} + +static void +dev_path_end_instance(struct string *str, void *dev_path) +{ + cprintf(str, ","); +} + +/** + * Print unknown device node. + * UEFI 2.4 § 9.6.1.6 table 89. + */ + +static void +dev_path_node_unknown(struct string *str, void *dev_path) +{ + struct efi_device_path *Path; + u8 *value; + int length, index; + Path = dev_path; + value = dev_path; + value += 4; + switch (Path->type) { + case HARDWARE_DEVICE_PATH:{ + /* Unknown Hardware Device Path */ + cprintf(str, "hardware_path(%d", Path->sub_type); + break; + } + case ACPI_DEVICE_PATH:{/* Unknown ACPI Device Path */ + cprintf(str, "acpi_path(%d", Path->sub_type); + break; + } + case MESSAGING_DEVICE_PATH:{ + /* Unknown Messaging Device Path */ + cprintf(str, "Msg(%d", Path->sub_type); + break; + } + case MEDIA_DEVICE_PATH:{ + /* Unknown Media Device Path */ + cprintf(str, "media_path(%d", Path->sub_type); + break; + } + case BBS_DEVICE_PATH:{ /* Unknown BIOS Boot Specification Device Path */ + cprintf(str, "bbs_path(%d", Path->sub_type); + break; + } + default:{ /* Unknown Device Path */ + cprintf(str, "Path(%d,%d", Path->type, Path->sub_type); + break; + } + } + length = Path->length; + for (index = 0; index < length; index++) { + if (index == 0) + cprintf(str, ",0x"); + cprintf(str, "%02x", *value); + value++; + } + cprintf(str, ")"); +} + +/* + * Table to convert "type" and "sub_type" to a "convert to text" function/ + * Entries hold "type" and "sub_type" for know values. + * Special "sub_type" 0 is used as default for known type with unknown subtype. + */ +struct { + u8 type; + u8 sub_type; + void (*Function) (struct string *, void *); +} dev_path_table[] = { + { + HARDWARE_DEVICE_PATH, HW_PCI_DP, dev_path_pci}, { + HARDWARE_DEVICE_PATH, HW_PCCARD_DP, dev_path_pccard}, { + HARDWARE_DEVICE_PATH, HW_MEMMAP_DP, dev_path_mem_map}, { + HARDWARE_DEVICE_PATH, HW_VENDOR_DP, dev_path_vendor}, { + HARDWARE_DEVICE_PATH, HW_CONTROLLER_DP, dev_path_controller}, { + ACPI_DEVICE_PATH, ACPI_DP, dev_path_acpi}, { + MESSAGING_DEVICE_PATH, MSG_ATAPI_DP, dev_path_atapi}, { + MESSAGING_DEVICE_PATH, MSG_SCSI_DP, dev_path_scsi}, { + MESSAGING_DEVICE_PATH, MSG_FIBRECHANNEL_DP, dev_path_fibre}, { + MESSAGING_DEVICE_PATH, MSG_1394_DP, dev_path1394}, { + MESSAGING_DEVICE_PATH, MSG_USB_DP, dev_path_usb}, { + MESSAGING_DEVICE_PATH, MSG_I2_o_DP, dev_path_i2_o}, { + MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, dev_path_mac_addr}, { + MESSAGING_DEVICE_PATH, MSG_IPv4_DP, dev_path_iPv4}, { + MESSAGING_DEVICE_PATH, MSG_IPv6_DP, dev_path_iPv6}, { + MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, dev_path_infini_band}, { + MESSAGING_DEVICE_PATH, MSG_UART_DP, dev_path_uart}, { + MESSAGING_DEVICE_PATH, MSG_SATA_DP, dev_path_sata}, { + MESSAGING_DEVICE_PATH, MSG_VENDOR_DP, dev_path_vendor}, { + MEDIA_DEVICE_PATH, MEDIA_HARDDRIVE_DP, dev_path_hard_drive}, { + MEDIA_DEVICE_PATH, MEDIA_CDROM_DP, dev_path_cdrom}, { + MEDIA_DEVICE_PATH, MEDIA_VENDOR_DP, dev_path_vendor}, { + MEDIA_DEVICE_PATH, MEDIA_FILEPATH_DP, dev_path_file_path}, { + MEDIA_DEVICE_PATH, MEDIA_PROTOCOL_DP, dev_path_media_protocol}, { + BBS_DEVICE_PATH, BBS_BBS_DP, dev_path_bss_bss}, { + END_DEVICE_PATH_TYPE, END_INSTANCE_DEVICE_PATH_SUBTYPE, + dev_path_end_instance}, { + 0, 0, NULL} +}; + +static int __device_path_to_str(struct string *str, struct efi_device_path *dev_path) +{ + struct efi_device_path *dev_path_node; + void (*dump_node) (struct string *, void *); + int i; + + dev_path = unpack_device_path(dev_path); + + dev_path_node = dev_path; + while (!is_device_path_end(dev_path_node)) { + dump_node = NULL; + for (i = 0; dev_path_table[i].Function; i += 1) { + + if (device_path_type(dev_path_node) == + dev_path_table[i].type + && dev_path_node->sub_type == + dev_path_table[i].sub_type) { + dump_node = dev_path_table[i].Function; + break; + } + } + + if (!dump_node) + dump_node = dev_path_node_unknown; + + if (str->len && dump_node != dev_path_end_instance) + cprintf(str, "/"); + + dump_node(str, dev_path_node); + + dev_path_node = next_device_path_node(dev_path_node); + } + + return 0; +} + +char *device_path_to_str(struct efi_device_path *dev_path) +{ + struct string str = {}; + + __device_path_to_str(&str, dev_path); + + str.str = malloc(str.len + 1); + if (!str.str) + return NULL; + + str.len = 0; + + __device_path_to_str(&str, dev_path); + + return str.str; +} diff --git a/common/efi-guid.c b/common/efi-guid.c new file mode 100644 index 0000000000..f6b0404105 --- /dev/null +++ b/common/efi-guid.c @@ -0,0 +1,84 @@ +#include <common.h> +#include <efi.h> + +efi_guid_t efi_file_info_id = EFI_FILE_INFO_GUID; +efi_guid_t efi_simple_file_system_protocol_guid = EFI_SIMPLE_FILE_SYSTEM_GUID; +efi_guid_t efi_device_path_protocol_guid = EFI_DEVICE_PATH_PROTOCOL_GUID; +efi_guid_t efi_loaded_image_protocol_guid = EFI_LOADED_IMAGE_PROTOCOL_GUID; +efi_guid_t efi_unknown_device_guid = EFI_UNKNOWN_DEVICE_GUID; +efi_guid_t efi_null_guid = EFI_NULL_GUID; +efi_guid_t efi_global_variable_guid = EFI_GLOBAL_VARIABLE_GUID; +efi_guid_t efi_block_io_protocol_guid = EFI_BLOCK_IO_PROTOCOL_GUID; + +#define EFI_GUID_STRING(guid, short, long) do { \ + if (!efi_guidcmp(guid, *g)) \ + return long; \ + } while(0) + +const char *efi_guid_string(efi_guid_t *g) +{ + EFI_GUID_STRING(EFI_NULL_GUID, "NULL", "NULL GUID"); + EFI_GUID_STRING(EFI_MPS_TABLE_GUID, "MPS Table", "MPS Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_ACPI_TABLE_GUID, "ACPI Table", "ACPI 1.0 Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_ACPI_20_TABLE_GUID, "ACPI 2.0 Table", "ACPI 2.0 Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_SMBIOS_TABLE_GUID, "SMBIOS Table", "SMBIOS Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_SAL_SYSTEM_TABLE_GUID, "SAL System Table", "SAL System Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_HCDP_TABLE_GUID, "HDCP Table", "HDCP Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_UGA_IO_PROTOCOL_GUID, "UGA Protocol", "EFI 1.1 UGA Protocol"); + EFI_GUID_STRING(EFI_GLOBAL_VARIABLE_GUID, "Efi", "Efi Variable GUID"); + EFI_GUID_STRING(EFI_UV_SYSTEM_TABLE_GUID, "SAL System Table", "SAL System Table GUID in EFI System Table"); + EFI_GUID_STRING(EFI_LINUX_EFI_CRASH_GUID, "Linux EFI Crash", "Linux EFI Crash GUID"); + EFI_GUID_STRING(EFI_LOADED_IMAGE_PROTOCOL_GUID, "LoadedImage Protocol", "EFI 1.0 Loaded Image Protocol"); + EFI_GUID_STRING(EFI_GRAPHICS_OUTPUT_PROTOCOL_GUID, "EFI Graphics Output Protocol", "UEFI Graphics Output Protocol"); + EFI_GUID_STRING(EFI_UGA_PROTOCOL_GUID, "UGA Draw Protocol", "EFI 1.1 UGA Draw Protocol"); + EFI_GUID_STRING(EFI_UGA_IO_PROTOCOL_GUID, "UGA Protocol", "EFI 1.1 UGA Protocol"); + EFI_GUID_STRING(EFI_PCI_IO_PROTOCOL_GUID, "PCI IO Protocol", "EFI 1.1 PCI IO Protocol"); + EFI_GUID_STRING(EFI_FILE_INFO_GUID, "File Info", "EFI File Infom"); + EFI_GUID_STRING(EFI_SIMPLE_FILE_SYSTEM_GUID, "Filesystem", "EFI 1.0 Simple FileSystem"); + EFI_GUID_STRING(EFI_DEVICE_TREE_GUID, "Device Tree", "EFI Device Tree GUID"); + EFI_GUID_STRING(EFI_DEVICE_PATH_PROTOCOL_GUID, "Device Path Protocol", "EFI 1.0 Device Path protocol"); + EFI_GUID_STRING(EFI_SIMPLE_NETWORK_PROTOCOL_GUID, "Simple Network Protocol", "EFI 1.0 Simple Network Protocol"); + EFI_GUID_STRING(EFI_SIMPLE_FILE_SYSTEM_PROTOCOL_GUID, "Filesystem Protocol", "EFI 1.0 Simple FileSystem Protocol"); + EFI_GUID_STRING(EFI_UNKNOWN_DEVICE_GUID, "Efi Unknown Device", "Efi Unknown Device GUID"); + EFI_GUID_STRING(EFI_BLOCK_IO_PROTOCOL_GUID, "BlockIo Protocol", "EFI 1.0 Block IO protocol"); + + EFI_GUID_STRING(EFI_FIRMWARE_VOLUME2_PROTOCOL_GUID, "FirmwareVolume2Protocol", "Efi FirmwareVolume2Protocol"); + EFI_GUID_STRING(EFI_FIRMWARE_VOLUME_BLOCK_PROTOCOL_GUID, "FirmwareVolumeBlock Protocol", "Firmware Volume Block protocol"); + EFI_GUID_STRING(EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL_GUID, "PciRootBridgeIo Protocol", "EFI 1.1 Pci Root Bridge IO Protocol"); + EFI_GUID_STRING(EFI_ISA_ACPI_PROTOCOL_GUID, "ISA Acpi Protocol", "ISA Acpi Protocol"); + EFI_GUID_STRING(EFI_ISA_IO_PROTOCOL_GUID, "ISA IO Protocol", "ISA IO Protocol"); + EFI_GUID_STRING(EFI_STANDARD_ERROR_DEVICE_GUID, "Standard Error Device Guid", "EFI Standard Error Device Guid"); + EFI_GUID_STRING(EFI_CONSOLE_OUT_DEVICE_GUID, "Console Out Device Guid", "EFI Console Out Device Guid"); + EFI_GUID_STRING(EFI_CONSOLE_IN_DEVICE_GUID, "Console In Device Guid", "EFI Conosle In Device Guid"); + EFI_GUID_STRING(EFI_SIMPLE_TEXT_OUT_PROTOCOL_GUID, "Simple Text Out Protocol", "EFI 1.0 Simple Text Out Protocol"); + EFI_GUID_STRING(EFI_SIMPLE_TEXT_INPUT_EX_PROTOCOL_GUID, "Simple Text Input Ex Protocol", "UEFI 2.1 Simple Text Input Ex Protocol"); + EFI_GUID_STRING(EFI_SIMPLE_TEXT_IN_PROTOCOL_GUID, "Simple Text In Protocol", "EFI 1.0 Simple Text In Protocol"); + EFI_GUID_STRING(EFI_DISK_IO_PROTOCOL_GUID, "DiskIo Protocol", "EFI 1.0 Disk IO Protocol"); + EFI_GUID_STRING(EFI_IDE_CONTROLLER_INIT_PROTOCOL_GUID, "IDE Controller Init Protocol", "Platform IDE Init Protocol"); + EFI_GUID_STRING(EFI_DISK_INFO_PROTOCOL_GUID, "Disk Info Protocol", "Disk Info Protocol"); + EFI_GUID_STRING(EFI_SERIAL_IO_PROTOCOL_GUID, "SerialIo Protocol", "EFI 1.0 Serial IO Protocol"); + EFI_GUID_STRING(EFI_BUS_SPECIFIC_DRIVER_OVERRIDE_PROTOCOL_GUID, "Bus Specific Driver Override Protocol", "EFI 1.1 Bus Specific Driver Override Protocol"); + EFI_GUID_STRING(EFI_LOAD_FILE2_PROTOCOL_GUID, "LoadFile2 Protocol", "EFI Load File 2 Protocol"); + EFI_GUID_STRING(EFI_MTFTP4_SERVICE_BINDING_PROTOCOL_GUID, "MTFTP4 Service Binding Protocol", "MTFTP4 Service Binding Protocol"); + EFI_GUID_STRING(EFI_DHCP4_PROTOCOL_GUID, "DHCP4 Protocol", "DHCP4 Protocol"); + EFI_GUID_STRING(EFI_UDP4_SERVICE_BINDING_PROTOCOL_GUID, "UDP4 Service Binding Protocol", "UDP4 Service Binding Protocol"); + EFI_GUID_STRING(EFI_TCP4_SERVICE_BINDING_PROTOCOL_GUID, "TCP4 Service Binding Protocol", "TCP4 Service Binding Protocol"); + EFI_GUID_STRING(EFI_IP4_SERVICE_BINDING_PROTOCOL_GUID, "IP4 Service Binding Protocol", "IP4 Service Binding Protocol"); + EFI_GUID_STRING(EFI_IP4_CONFIG_PROTOCOL_GUID, "Ip4Config Protocol", "Ip4Config Protocol"); + EFI_GUID_STRING(EFI_ARP_SERVICE_BINDING_PROTOCOL_GUID, "ARP Service Binding Protocol", "ARP Service Binding Protocol"); + EFI_GUID_STRING(EFI_MANAGED_NETWORK_SERVICE_BINDING_PROTOCOL_GUID, "Managed Network Service Binding Protocol", "Managed Network Service Binding Protocol"); + EFI_GUID_STRING(EFI_VLAN_CONFIG_PROTOCOL_GUID, "VlanConfig Protocol", "VlanConfig Protocol"); + EFI_GUID_STRING(EFI_HII_CONFIG_ACCESS_PROTOCOL_GUID, "HII Config Access Protocol", "HII Config Access 2.1 protocol"); + EFI_GUID_STRING(LOAD_FILE_PROTOCOL_GUID, "LoadFile Protocol", "EFI 1.0 Load File Protocol"); + EFI_GUID_STRING(EFI_COMPONENT_NAME2_PROTOCOL_GUID, "Component Name2 Protocol", "UEFI 2.0 Component Name2 Protocol"); + EFI_GUID_STRING(EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID_31, "Network Interface Identifier Protocol_31", "EFI1.1 Network Interface Identifier Protocol"); + EFI_GUID_STRING(EFI_NETWORK_INTERFACE_IDENTIFIER_PROTOCOL_GUID, "Network Interface Identifier Protocol", "EFI Network Interface Identifier Protocol"); + + /* File */ + EFI_GUID_STRING(EFI_IDEBUSDXE_INF_GUID, "IdeBusDxe.inf", "EFI IdeBusDxe.inf File GUID"); + EFI_GUID_STRING(EFI_TERMINALDXE_INF_GUID, "TerminalDxe.inf", "EFI TerminalDxe.inf File GUID"); + EFI_GUID_STRING(EFI_ISCSIDXE_INF_GUID, "IScsiDxe.inf", "EFI IScsiDxe.inf File GUID"); + EFI_GUID_STRING(EFI_VLANCONFIGDXE_INF_GUID, "VlanConfigDxe.inf", "EFI VlanConfigDxe.inf File GUID"); + + return "unknown"; +} diff --git a/common/filetype.c b/common/filetype.c index 86e544ae58..c8f3582cd1 100644 --- a/common/filetype.c +++ b/common/filetype.c @@ -57,6 +57,7 @@ static const struct filetype_str filetype_str[] = { [filetype_ch_image] = { "TI OMAP CH boot image", "ch-image" }, [filetype_ch_image_be] = { "TI OMAP CH boot image (big endian)", "ch-image-be" }, + [filetype_exe] = { "MS-DOS executable", "exe" }, }; const char *file_type_to_string(enum filetype f) @@ -237,6 +238,9 @@ enum filetype file_detect_type(const void *_buf, size_t bufsize) if (bufsize < 64) return filetype_unknown; + if (buf8[0] == 'M' && buf8[1] == 'Z') + return filetype_exe; + if (is_barebox_arm_head(_buf)) return filetype_arm_barebox; if (buf[9] == 0x016f2818 || buf[9] == 0x18286f01) diff --git a/common/memory.c b/common/memory.c index 7dbd7f4399..4a8fe283f2 100644 --- a/common/memory.c +++ b/common/memory.c @@ -58,7 +58,7 @@ void mem_malloc_init(void *start, void *end) #endif } -#ifndef __SANDBOX__ +#if !defined __SANDBOX__ && !defined CONFIG_ARCH_EFI static int mem_malloc_resource(void) { /* diff --git a/common/partitions/efi.c b/common/partitions/efi.c index ee1326e622..dcb95414f6 100644 --- a/common/partitions/efi.c +++ b/common/partitions/efi.c @@ -232,7 +232,7 @@ static int is_gpt_valid(struct block_device *blk, u64 lba, static inline int is_pte_valid(const gpt_entry *pte, const u64 lastlba) { - if ((!efi_guidcmp(pte->partition_type_guid, NULL_GUID)) || + if ((!efi_guidcmp(pte->partition_type_guid, EFI_NULL_GUID)) || le64_to_cpu(pte->starting_lba) > lastlba || le64_to_cpu(pte->ending_lba) > lastlba) return 0; diff --git a/common/partitions/efi.h b/common/partitions/efi.h index 703ecca2f2..a9b10c1266 100644 --- a/common/partitions/efi.h +++ b/common/partitions/efi.h @@ -21,7 +21,7 @@ #ifndef FS_PART_EFI_H_INCLUDED #define FS_PART_EFI_H_INCLUDED -#include <linux/efi.h> +#include <efi.h> #define MSDOS_MBR_SIGNATURE 0xaa55 #define EFI_PMBR_OSTYPE_EFI 0xEF |