/*
 * Copyright (C) 2020 Michael Brown <mbrown@fensystems.co.uk>.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 */

FILE_LICENCE ( GPL2_OR_LATER );
FILE_SECBOOT ( PERMITTED );

#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <errno.h>
#include <byteswap.h>
#include <ipxe/netdevice.h>
#include <ipxe/vlan.h>
#include <ipxe/uuid.h>
#include <ipxe/tcpip.h>
#include <ipxe/uri.h>
#include <ipxe/iscsi.h>
#include <ipxe/aoe.h>
#include <ipxe/fcp.h>
#include <ipxe/ib_srp.h>
#include <ipxe/usb.h>
#include <ipxe/settings.h>
#include <ipxe/dhcp.h>
#include <ipxe/ndp.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/efi_strings.h>
#include <ipxe/efi/efi_path.h>

/** @file
 *
 * EFI device paths
 *
 */

/** Dummy parent device path
 *
 * This is used as the parent device path when we need to construct a
 * path for a device that has no EFI parent device.
 */
static struct {
	BBS_BBS_DEVICE_PATH bbs;
	CHAR8 tring[4];
	EFI_DEVICE_PATH_PROTOCOL end;
} __attribute__ (( packed )) efi_dummy_parent_path = {
	.bbs = {
		.Header = {
			.Type = BBS_DEVICE_PATH,
			.SubType = BBS_BBS_DP,
			.Length[0] = ( sizeof ( efi_dummy_parent_path.bbs ) +
				       sizeof ( efi_dummy_parent_path.tring )),
		},
		.DeviceType = BBS_TYPE_UNKNOWN,
		.String[0] = 'i',
	},
	.tring = "PXE",
	.end = {
		.Type = END_DEVICE_PATH_TYPE,
		.SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE,
		.Length[0] = sizeof ( efi_dummy_parent_path.end ),
	},
};

/** An EFI device path settings block */
struct efi_path_settings {
	/** Settings interface */
	struct settings settings;
	/** Device path */
	EFI_DEVICE_PATH_PROTOCOL *path;
};

/** An EFI device path setting */
struct efi_path_setting {
	/** Setting */
	const struct setting *setting;
	/**
	 * Fetch setting
	 *
	 * @v pathset		Path setting
	 * @v path		Device path
	 * @v data		Buffer to fill with setting data
	 * @v len		Length of buffer
	 * @ret len		Length of setting data, or negative error
	 */
	int ( * fetch ) ( struct efi_path_setting *pathset,
			  EFI_DEVICE_PATH_PROTOCOL *path,
			  void *data, size_t len );
	/** Path type */
	uint8_t type;
	/** Path subtype */
	uint8_t subtype;
	/** Offset within device path */
	uint8_t offset;
	/** Length (if fixed) */
	uint8_t len;
};

/**
 * Find next element in device path
 *
 * @v path		Device path, or NULL
 * @v next		Next element in device path, or NULL if at end
 */
EFI_DEVICE_PATH_PROTOCOL * efi_path_next ( EFI_DEVICE_PATH_PROTOCOL *path ) {

	/* Check for non-existent device path */
	if ( ! path )
		return NULL;

	/* Check for end of device path */
	if ( path->Type == END_DEVICE_PATH_TYPE )
		return NULL;

	/* Move to next component of the device path */
	path = ( ( ( void * ) path ) +
		 /* There's this amazing new-fangled thing known as
		  * a UINT16, but who wants to use one of those? */
		 ( ( path->Length[1] << 8 ) | path->Length[0] ) );

	return path;
}

/**
 * Find previous element of device path
 *
 * @v path		Device path, or NULL for no path
 * @v curr		Current element in device path, or NULL for end of path
 * @ret prev		Previous element in device path, or NULL
 */
EFI_DEVICE_PATH_PROTOCOL * efi_path_prev ( EFI_DEVICE_PATH_PROTOCOL *path,
					   EFI_DEVICE_PATH_PROTOCOL *curr ) {
	EFI_DEVICE_PATH_PROTOCOL *tmp;

	/* Find immediately preceding element */
	while ( ( tmp = efi_path_next ( path ) ) != curr ) {
		path = tmp;
	}

	return path;
}

/**
 * Find end of device path
 *
 * @v path		Device path, or NULL
 * @ret path_end	End of device path, or NULL
 */
EFI_DEVICE_PATH_PROTOCOL * efi_path_end ( EFI_DEVICE_PATH_PROTOCOL *path ) {

	return efi_path_prev ( path, NULL );
}

/**
 * Find length of device path (excluding terminator)
 *
 * @v path		Device path, or NULL
 * @ret path_len	Length of device path
 */
size_t efi_path_len ( EFI_DEVICE_PATH_PROTOCOL *path ) {
	EFI_DEVICE_PATH_PROTOCOL *end = efi_path_end ( path );

	return ( ( ( void * ) end ) - ( ( void * ) path ) );
}

/**
 * Check that device path is well-formed
 *
 * @v path		Device path, or NULL
 * @v max		Maximum device path length
 * @ret rc		Return status code
 */
int efi_path_check ( EFI_DEVICE_PATH_PROTOCOL *path, size_t max ) {
	EFI_DEVICE_PATH_PROTOCOL *next;
	size_t remaining = max;
	size_t len;

	/* Check that path terminates within maximum length */
	for ( ; ; path = next ) {
		if ( remaining < sizeof ( *path ) )
			return -EINVAL;
		next = efi_path_next ( path );
		if ( ! next )
			break;
		len = ( ( ( void * ) next ) - ( ( void * ) path ) );
		if ( remaining < len )
			return -EINVAL;
	}

	return 0;
}

/**
 * Get MAC address from device path
 *
 * @v path		Device path
 * @ret mac		MAC address, or NULL if not found
 */
void * efi_path_mac ( EFI_DEVICE_PATH_PROTOCOL *path ) {
	EFI_DEVICE_PATH_PROTOCOL *next;
	MAC_ADDR_DEVICE_PATH *mac;

	/* Search for MAC address path */
	for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
		if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
		     ( path->SubType == MSG_MAC_ADDR_DP ) ) {
			mac = container_of ( path, MAC_ADDR_DEVICE_PATH,
					     Header );
			return &mac->MacAddress;
		}
	}

	/* No MAC address found */
	return NULL;
}

/**
 * Get VLAN tag from device path
 *
 * @v path		Device path
 * @ret tag		VLAN tag, or 0 if not a VLAN
 */
unsigned int efi_path_vlan ( EFI_DEVICE_PATH_PROTOCOL *path ) {
	EFI_DEVICE_PATH_PROTOCOL *next;
	VLAN_DEVICE_PATH *vlan;

	/* Search for VLAN device path */
	for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
		if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
		     ( path->SubType == MSG_VLAN_DP ) ) {
			vlan = container_of ( path, VLAN_DEVICE_PATH, Header );
			return vlan->VlanId;
		}
	}

	/* No VLAN device path found */
	return 0;
}

/**
 * Get IP address family from device path
 *
 * @v path		Device path
 * @ret family		Address family, or 0 if not recognised
 */
unsigned int efi_path_family ( EFI_DEVICE_PATH_PROTOCOL *path ) {
	EFI_DEVICE_PATH_PROTOCOL *next;

	/* Search for IP address device path */
	for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
		if ( path->Type == MESSAGING_DEVICE_PATH ) {
			if ( path->SubType == MSG_IPv4_DP ) {
				return AF_INET;
			} else if ( path->SubType == MSG_IPv6_DP ) {
				return AF_INET6;
			}
		}
	}

	/* No IP address device path found */
	return 0;
}

/**
 * Get partition GUID from device path
 *
 * @v path		Device path
 * @v guid		Partition GUID to fill in
 * @ret rc		Return status code
 */
int efi_path_guid ( EFI_DEVICE_PATH_PROTOCOL *path, union uuid *guid ) {
	EFI_DEVICE_PATH_PROTOCOL *next;
	HARDDRIVE_DEVICE_PATH *hd;
	int rc;

	/* Search for most specific partition device path */
	rc = -ENOENT;
	for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {

		/* Skip non-harddrive device paths */
		if ( path->Type != MEDIA_DEVICE_PATH )
			continue;
		if ( path->SubType != MEDIA_HARDDRIVE_DP )
			continue;

		/* Skip non-GUID signatures */
		hd = container_of ( path, HARDDRIVE_DEVICE_PATH, Header );
		if ( hd->SignatureType != SIGNATURE_TYPE_GUID )
			continue;

		/* Extract GUID */
		memcpy ( guid, hd->Signature, sizeof ( *guid ) );
		uuid_mangle ( guid );

		/* Record success, but continue searching in case
		 * there exists a more specific GUID (e.g. a partition
		 * GUID rather than a disk GUID).
		 */
		rc = 0;
	}

	return rc;
}

/**
 * Parse URI from device path
 *
 * @v path		Device path
 * @ret uri		URI, or NULL if not a URI
 */
struct uri * efi_path_uri ( EFI_DEVICE_PATH_PROTOCOL *path ) {
	EFI_DEVICE_PATH_PROTOCOL *next;
	URI_DEVICE_PATH *uripath;
	char *uristring;
	struct uri *uri;
	size_t len;

	/* Search for URI device path */
	for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {
		if ( ( path->Type == MESSAGING_DEVICE_PATH ) &&
		     ( path->SubType == MSG_URI_DP ) ) {

			/* Calculate path length */
			uripath = container_of ( path, URI_DEVICE_PATH,
						 Header );
			len = ( ( ( path->Length[1] << 8 ) | path->Length[0] )
				- offsetof ( typeof ( *uripath ), Uri ) );

			/* Parse URI */
			uristring = zalloc ( len + 1 /* NUL */ );
			if ( ! uristring )
				return NULL;
			memcpy ( uristring, uripath->Uri, len );
			uri = parse_uri ( uristring );
			free ( uristring );

			return uri;
		}
	}

	/* No URI path found */
	return NULL;
}

/**
 * Concatenate EFI device paths
 *
 * @v ...		List of device paths (NULL terminated)
 * @ret path		Concatenated device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_paths ( EFI_DEVICE_PATH_PROTOCOL *first, ... ) {
	EFI_DEVICE_PATH_PROTOCOL *path;
	EFI_DEVICE_PATH_PROTOCOL *src;
	EFI_DEVICE_PATH_PROTOCOL *dst;
	EFI_DEVICE_PATH_PROTOCOL *end;
	va_list args;
	size_t len;

	/* Calculate device path length */
	va_start ( args, first );
	len = 0;
	src = first;
	while ( src ) {
		len += efi_path_len ( src );
		src = va_arg ( args, EFI_DEVICE_PATH_PROTOCOL * );
	}
	va_end ( args );

	/* Allocate device path */
	path = zalloc ( len + sizeof ( *end ) );
	if ( ! path )
		return NULL;

	/* Populate device path */
	va_start ( args, first );
	dst = path;
	src = first;
	while ( src ) {
		len = efi_path_len ( src );
		memcpy ( dst, src, len );
		dst = ( ( ( void * ) dst ) + len );
		src = va_arg ( args, EFI_DEVICE_PATH_PROTOCOL * );
	}
	va_end ( args );
	end = dst;
	efi_path_terminate ( end );

	return path;
}

/**
 * Construct EFI parent device path
 *
 * @v dev		Generic device
 * @ret path		Parent (or dummy) device path
 */
static EFI_DEVICE_PATH_PROTOCOL * efi_parent_path ( struct device *dev ) {
	struct efi_device *efidev;

	/* Use EFI parent device's path, if possible */
	efidev = efidev_parent ( dev );
	if ( efidev )
		return efidev->path;

	/* Otherwise, use a dummy parent device path */
	return &efi_dummy_parent_path.bbs.Header;
}

/**
 * Construct EFI device path for network device
 *
 * @v netdev		Network device
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_netdev_path ( struct net_device *netdev ) {
	EFI_DEVICE_PATH_PROTOCOL *parent;
	EFI_DEVICE_PATH_PROTOCOL *path;
	MAC_ADDR_DEVICE_PATH *macpath;
	VLAN_DEVICE_PATH *vlanpath;
	EFI_DEVICE_PATH_PROTOCOL *end;
	unsigned int tag;
	size_t prefix_len;
	size_t len;

	/* Get parent EFI device path */
	parent = efi_parent_path ( netdev->dev );

	/* Calculate device path length */
	prefix_len = efi_path_len ( parent );
	len = ( prefix_len + sizeof ( *macpath ) + sizeof ( *vlanpath ) +
		sizeof ( *end ) );

	/* Allocate device path */
	path = zalloc ( len );
	if ( ! path )
		return NULL;

	/* Construct device path */
	memcpy ( path, parent, prefix_len );
	macpath = ( ( ( void * ) path ) + prefix_len );
	macpath->Header.Type = MESSAGING_DEVICE_PATH;
	macpath->Header.SubType = MSG_MAC_ADDR_DP;
	macpath->Header.Length[0] = sizeof ( *macpath );
	assert ( netdev->ll_protocol->ll_addr_len <
		 sizeof ( macpath->MacAddress ) );
	memcpy ( &macpath->MacAddress, netdev->ll_addr,
		 netdev->ll_protocol->ll_addr_len );
	macpath->IfType = ntohs ( netdev->ll_protocol->ll_proto );
	if ( ( tag = vlan_tag ( netdev ) ) ) {
		vlanpath = ( ( ( void * ) macpath ) + sizeof ( *macpath ) );
		vlanpath->Header.Type = MESSAGING_DEVICE_PATH;
		vlanpath->Header.SubType = MSG_VLAN_DP;
		vlanpath->Header.Length[0] = sizeof ( *vlanpath );
		vlanpath->VlanId = tag;
		end = ( ( ( void * ) vlanpath ) + sizeof ( *vlanpath ) );
	} else {
		end = ( ( ( void * ) macpath ) + sizeof ( *macpath ) );
	}
	efi_path_terminate ( end );

	return path;
}

/**
 * Construct EFI device path for URI
 *
 * @v uri		URI
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_uri_path ( struct uri *uri ) {
	EFI_DEVICE_PATH_PROTOCOL *path;
	EFI_DEVICE_PATH_PROTOCOL *end;
	URI_DEVICE_PATH *uripath;
	size_t uri_len;
	size_t uripath_len;
	size_t len;

	/* Calculate device path length */
	uri_len = ( format_uri ( uri, NULL, 0 ) + 1 /* NUL */ );
	uripath_len = ( sizeof ( *uripath ) + uri_len );
	len = ( uripath_len + sizeof ( *end ) );

	/* Allocate device path */
	path = zalloc ( len );
	if ( ! path )
		return NULL;

	/* Construct device path */
	uripath = ( ( void * ) path );
	uripath->Header.Type = MESSAGING_DEVICE_PATH;
	uripath->Header.SubType = MSG_URI_DP;
	uripath->Header.Length[0] = ( uripath_len & 0xff );
	uripath->Header.Length[1] = ( uripath_len >> 8 );
	format_uri ( uri, uripath->Uri, uri_len );
	end = ( ( ( void * ) path ) + uripath_len );
	efi_path_terminate ( end );

	return path;
}

/**
 * Construct EFI device path for iSCSI device
 *
 * @v iscsi		iSCSI session
 * @ret path		EFI device path, or NULL on error
 */
EFI_DEVICE_PATH_PROTOCOL * efi_iscsi_path ( struct iscsi_session *iscsi ) {
	struct sockaddr_tcpip *st_target;
	struct net_device *netdev;
	EFI_DEVICE_PATH_PROTOCOL *netpath;
	EFI_DEVICE_PATH_PROTOCOL *path;
	EFI_DEVICE_PATH_PROTOCOL *end;
	ISCSI_DEVICE_PATH *iscsipath;
	char *name;
	size_t prefix_len;
	size_t name_len;
	size_t iscsi_len;
	size_t len;

	/* Get network device associated with target address */
	st_target = ( ( struct sockaddr_tcpip * ) &iscsi->target_sockaddr );
	netdev = tcpip_netdev ( st_target );
	if ( ! netdev )
		goto err_netdev;

	/* Get network device path */
	netpath = efi_netdev_path ( netdev );
	if ( ! netpath )
		goto err_netpath;

	/* Calculate device path length */
	prefix_len = efi_path_len ( netpath );
	name_len = ( strlen ( iscsi->target_iqn ) + 1 /* NUL */ );
	iscsi_len = ( sizeof ( *iscsipath ) + name_len );
	len = ( prefix_len + iscsi_len + sizeof ( *end ) );

	/* Allocate device path */
	path = zalloc ( len );
	if ( ! path )
		goto err_alloc;

	/* Construct device path */
	memcpy ( path, netpath, prefix_len );
	iscsipath = ( ( ( void * ) path ) + prefix_len );
	iscsipath->Header.Type = MESSAGING_DEVICE_PATH;
	iscsipath->Header.SubType = MSG_ISCSI_DP;
	iscsipath->Header.Length[0] = iscsi_len;
	iscsipath->LoginOption = ISCSI_LOGIN_OPTION_AUTHMETHOD_NON;
	memcpy ( &iscsipath->Lun, &iscsi->lun, sizeof ( iscsipath->Lun ) );
	name = ( ( ( void * ) iscsipath ) + sizeof ( *iscsipath ) );
	memcpy ( name, iscsi->target_iqn, name_len );
	end = ( ( ( void * ) name ) + name_len );
	efi_path_terminate ( end );

	/* Free temporary paths */
	free ( netpath );

	return path;

 err_alloc:
	free ( netpath );
 err_netpath:
 err_netdev:
	return NULL;
}

/**
 * Construct EFI device path for AoE device
 *
 * @v aoedev		AoE device
 * @ret path		EFI device path, or NULL on error
 */
EFI_DEVICE_PATH_PROTOCOL * efi_aoe_path ( struct aoe_device *aoedev ) {
	struct {
		SATA_DEVICE_PATH sata;
		EFI_DEVICE_PATH_PROTOCOL end;
	} satapath;
	EFI_DEVICE_PATH_PROTOCOL *netpath;
	EFI_DEVICE_PATH_PROTOCOL *path;

	/* Get network device path */
	netpath = efi_netdev_path ( aoedev->netdev );
	if ( ! netpath )
		goto err_netdev;

	/* Construct SATA path */
	memset ( &satapath, 0, sizeof ( satapath ) );
	satapath.sata.Header.Type = MESSAGING_DEVICE_PATH;
	satapath.sata.Header.SubType = MSG_SATA_DP;
	satapath.sata.Header.Length[0] = sizeof ( satapath.sata );
	satapath.sata.HBAPortNumber = aoedev->major;
	satapath.sata.PortMultiplierPortNumber = aoedev->minor;
	efi_path_terminate ( &satapath.end );

	/* Construct overall device path */
	path = efi_paths ( netpath, &satapath, NULL );
	if ( ! path )
		goto err_paths;

	/* Free temporary paths */
	free ( netpath );

	return path;

 err_paths:
	free ( netpath );
 err_netdev:
	return NULL;
}

/**
 * Construct EFI device path for Fibre Channel device
 *
 * @v desc		FCP device description
 * @ret path		EFI device path, or NULL on error
 */
EFI_DEVICE_PATH_PROTOCOL * efi_fcp_path ( struct fcp_description *desc ) {
	struct {
		FIBRECHANNELEX_DEVICE_PATH fc;
		EFI_DEVICE_PATH_PROTOCOL end;
	} __attribute__ (( packed )) *path;

	/* Allocate device path */
	path = zalloc ( sizeof ( *path ) );
	if ( ! path )
		return NULL;

	/* Construct device path */
	path->fc.Header.Type = MESSAGING_DEVICE_PATH;
	path->fc.Header.SubType = MSG_FIBRECHANNELEX_DP;
	path->fc.Header.Length[0] = sizeof ( path->fc );
	memcpy ( path->fc.WWN, &desc->wwn, sizeof ( path->fc.WWN ) );
	memcpy ( path->fc.Lun, &desc->lun, sizeof ( path->fc.Lun ) );
	efi_path_terminate ( &path->end );

	return &path->fc.Header;
}

/**
 * Construct EFI device path for Infiniband SRP device
 *
 * @v ib_srp		Infiniband SRP device
 * @ret path		EFI device path, or NULL on error
 */
EFI_DEVICE_PATH_PROTOCOL * efi_ib_srp_path ( struct ib_srp_device *ib_srp ) {
	const struct ipxe_ib_sbft *sbft = &ib_srp->sbft;
	union ib_srp_target_port_id *id =
		container_of ( &sbft->srp.target, union ib_srp_target_port_id,
			       srp );
	EFI_DEVICE_PATH_PROTOCOL *parent;
	EFI_DEVICE_PATH_PROTOCOL *path;
	INFINIBAND_DEVICE_PATH *ibpath;
	EFI_DEVICE_PATH_PROTOCOL *end;
	size_t prefix_len;
	size_t len;

	/* Get parent EFI device path */
	parent = efi_parent_path ( ib_srp->ibdev->dev );

	/* Calculate device path length */
	prefix_len = efi_path_len ( parent );
	len = ( prefix_len + sizeof ( *ibpath ) + sizeof ( *end ) );

	/* Allocate device path */
	path = zalloc ( len );
	if ( ! path )
		return NULL;

	/* Construct device path */
	memcpy ( path, parent, prefix_len );
	ibpath = ( ( ( void * ) path ) + prefix_len );
	ibpath->Header.Type = MESSAGING_DEVICE_PATH;
	ibpath->Header.SubType = MSG_INFINIBAND_DP;
	ibpath->Header.Length[0] = sizeof ( *ibpath );
	ibpath->ResourceFlags = INFINIBAND_RESOURCE_FLAG_STORAGE_PROTOCOL;
	memcpy ( ibpath->PortGid, &sbft->ib.dgid, sizeof ( ibpath->PortGid ) );
	memcpy ( &ibpath->ServiceId, &sbft->ib.service_id,
		 sizeof ( ibpath->ServiceId ) );
	memcpy ( &ibpath->TargetPortId, &id->ib.ioc_guid,
		 sizeof ( ibpath->TargetPortId ) );
	memcpy ( &ibpath->DeviceId, &id->ib.id_ext,
		 sizeof ( ibpath->DeviceId ) );
	end = ( ( ( void * ) ibpath ) + sizeof ( *ibpath ) );
	efi_path_terminate ( end );

	return path;
}

/**
 * Construct EFI device path for USB function
 *
 * @v func		USB function
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_usb_path ( struct usb_function *func ) {
	struct usb_device *usb = func->usb;
	EFI_DEVICE_PATH_PROTOCOL *parent;
	EFI_DEVICE_PATH_PROTOCOL *path;
	EFI_DEVICE_PATH_PROTOCOL *end;
	USB_DEVICE_PATH *usbpath;
	unsigned int count;
	size_t prefix_len;
	size_t len;

	/* Sanity check */
	assert ( func->desc.count >= 1 );

	/* Get parent EFI device path */
	parent = efi_parent_path ( &func->dev );

	/* Calculate device path length */
	count = ( usb_depth ( usb ) + 1 );
	prefix_len = efi_path_len ( parent );
	len = ( prefix_len + ( count * sizeof ( *usbpath ) ) +
		sizeof ( *end ) );

	/* Allocate device path */
	path = zalloc ( len );
	if ( ! path )
		return NULL;

	/* Construct device path */
	memcpy ( path, parent, prefix_len );
	end = ( ( ( void * ) path ) + len - sizeof ( *end ) );
	efi_path_terminate ( end );
	usbpath = ( ( ( void * ) end ) - sizeof ( *usbpath ) );
	usbpath->InterfaceNumber = func->interface[0];
	for ( ; usb ; usbpath--, usb = usb->port->hub->usb ) {
		usbpath->Header.Type = MESSAGING_DEVICE_PATH;
		usbpath->Header.SubType = MSG_USB_DP;
		usbpath->Header.Length[0] = sizeof ( *usbpath );
		usbpath->ParentPortNumber = ( usb->port->address - 1 );
	}

	return path;
}

/**
 * Get EFI device path from load option
 *
 * @v load		EFI load option
 * @v len		Length of EFI load option
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_load_path ( EFI_LOAD_OPTION *load,
					   size_t len ) {
	EFI_DEVICE_PATH_PROTOCOL *path;
	EFI_DEVICE_PATH_PROTOCOL *copy;
	CHAR16 *wdesc;
	size_t path_max;
	size_t wmax;
	size_t wlen;

	/* Check basic structure size */
	if ( len < sizeof ( *load ) ) {
		DBGC ( load, "EFI load option too short for header:\n" );
		DBGC_HDA ( load, 0, load, len );
		return NULL;
	}

	/* Get length of description */
	wdesc = ( ( ( void * ) load ) + sizeof ( *load ) );
	wmax = ( ( len - sizeof ( *load ) ) / sizeof ( wdesc[0] ) );
	wlen = wcsnlen ( wdesc, wmax );
	if ( wlen == wmax ) {
		DBGC ( load, "EFI load option has unterminated "
		       "description:\n" );
		DBGC_HDA ( load, 0, load, len );
		return NULL;
	}

	/* Get inline device path */
	path = ( ( ( void * ) load ) + sizeof ( *load ) +
		 ( wlen * sizeof ( wdesc[0] ) ) + 2 /* wNUL */ );
	path_max = ( len - sizeof ( *load ) - ( wlen * sizeof ( wdesc[0] ) )
		     - 2 /* wNUL */ );
	if ( load->FilePathListLength > path_max ) {
		DBGC ( load, "EFI load option too short for path(s):\n" );
		DBGC_HDA ( load, 0, load, len );
		return NULL;
	}

	/* Check path length */
	if ( efi_path_check ( path, path_max ) != 0 ) {
		DBGC ( load, "EFI load option has unterminated device "
		       "path:\n" );
		DBGC_HDA ( load, 0, load, len );
		return NULL;
	}

	/* Allocate copy of path */
	copy = malloc ( path_max );
	if ( ! copy )
		return NULL;
	memcpy ( copy, path, path_max );

	return copy;
}

/**
 * Get EFI device path for numbered boot option
 *
 * @v number		Boot option number
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_boot_path ( unsigned int number ) {
	EFI_RUNTIME_SERVICES *rs = efi_systab->RuntimeServices;
	EFI_GUID *guid = &efi_global_variable;
	CHAR16 wname[ 9 /* "BootXXXX" + wNUL */ ];
	EFI_LOAD_OPTION *load;
	EFI_DEVICE_PATH *path;
	UINT32 attrs;
	UINTN size;
	EFI_STATUS efirc;
	int rc;

	/* Construct variable name */
	efi_snprintf ( wname, ( sizeof ( wname ) / sizeof ( wname[0] ) ),
		       "Boot%04X", number );

	/* Get variable length */
	size = 0;
	if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
					 NULL ) != EFI_BUFFER_TOO_SMALL ) ) {
		rc = -EEFI ( efirc );
		DBGC ( rs, "EFI could not get size of %ls: %s\n",
		       wname, strerror ( rc ) );
		goto err_size;
	}

	/* Allocate temporary buffer for EFI_LOAD_OPTION */
	load = malloc ( size );
	if ( ! load ) {
		rc = -ENOMEM;
		goto err_alloc;
	}

	/* Read variable */
	if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
					 load ) != 0 ) ) {
		rc = -EEFI ( efirc );
		DBGC ( rs, "EFI could not read %ls: %s\n",
		       wname, strerror ( rc ) );
		goto err_read;
	}
	DBGC2 ( rs, "EFI boot option %ls is:\n", wname );
	DBGC2_HDA ( rs, 0, load, size );

	/* Get device path from load option */
	path = efi_load_path ( load, size );
	if ( ! path ) {
		rc = -EINVAL;
		DBGC ( rs, "EFI could not parse %ls: %s\n",
		       wname, strerror ( rc ) );
		goto err_path;
	}

	/* Free temporary buffer */
	free ( load );

	return path;

 err_path:
 err_read:
	free ( load );
 err_alloc:
 err_size:
	return NULL;
}

/**
 * Get EFI device path for current boot option
 *
 * @ret path		EFI device path, or NULL on error
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_current_boot_path ( void ) {
	EFI_RUNTIME_SERVICES *rs = efi_systab->RuntimeServices;
	EFI_GUID *guid = &efi_global_variable;
	CHAR16 wname[] = L"BootCurrent";
	UINT16 current;
	UINT32 attrs;
	UINTN size;
	EFI_STATUS efirc;
	int rc;

	/* Read current boot option index */
	size = sizeof ( current );
	if ( ( efirc = rs->GetVariable ( wname, guid, &attrs, &size,
					 &current ) != 0 ) ) {
		rc = -EEFI ( efirc );
		DBGC ( rs, "EFI could not read %ls: %s\n",
		       wname, strerror ( rc ) );
		return NULL;
	}

	/* Get device path from this boot option */
	return efi_boot_path ( current );
}

/**
 * Describe object as an EFI device path
 *
 * @v intf		Interface
 * @ret path		EFI device path, or NULL
 *
 * The caller is responsible for eventually calling free() on the
 * allocated device path.
 */
EFI_DEVICE_PATH_PROTOCOL * efi_describe ( struct interface *intf ) {
	struct interface *dest;
	efi_describe_TYPE ( void * ) *op =
		intf_get_dest_op ( intf, efi_describe, &dest );
	void *object = intf_object ( dest );
	EFI_DEVICE_PATH_PROTOCOL *path;

	if ( op ) {
		path = op ( object );
	} else {
		path = NULL;
	}

	intf_put ( dest );
	return path;
}

/**
 * Fetch an EFI device path fixed-size setting
 *
 * @v pathset		Path setting
 * @v path		Device path
 * @v data		Buffer to fill with setting data
 * @v len		Length of buffer
 * @ret len		Length of setting data, or negative error
 */
static int efi_path_fetch_fixed ( struct efi_path_setting *pathset,
				  EFI_DEVICE_PATH_PROTOCOL *path,
				  void *data, size_t len ) {

	/* Copy data */
	if ( len > pathset->len )
		len = pathset->len;
	memcpy ( data, ( ( ( void * ) path ) + pathset->offset ), len );

	return pathset->len;
}

/**
 * Fetch an EFI device path DNS setting
 *
 * @v pathset		Path setting
 * @v path		Device path
 * @v data		Buffer to fill with setting data
 * @v len		Length of buffer
 * @ret len		Length of setting data, or negative error
 */
static int efi_path_fetch_dns ( struct efi_path_setting *pathset,
				EFI_DEVICE_PATH_PROTOCOL *path,
				void *data, size_t len ) {
	DNS_DEVICE_PATH *dns = container_of ( path, DNS_DEVICE_PATH, Header );
	unsigned int count;
	unsigned int i;
	size_t frag_len;

	/* Check applicability */
	if ( ( !! dns->IsIPv6 ) !=
	     ( pathset->setting->type == &setting_type_ipv6 ) )
		return -ENOENT;

	/* Calculate number of addresses */
	count = ( ( ( ( path->Length[1] << 8 ) | path->Length[0] ) -
		    pathset->offset ) / sizeof ( dns->DnsServerIp[0] ) );

	/* Copy data */
	for ( i = 0 ; i < count ; i++ ) {
		frag_len = len;
		if ( frag_len > pathset->len )
			frag_len = pathset->len;
		memcpy ( data, &dns->DnsServerIp[i], frag_len );
		data += frag_len;
		len -= frag_len;
	}

	return ( count * pathset->len );
}

/* Avoid dragging in IPv4, IPv6, and DNS support if not otherwise used */
extern const struct setting ip_setting __attribute__ (( weak ));
extern const struct setting netmask_setting __attribute__ (( weak ));
extern const struct setting gateway_setting __attribute__ (( weak ));
extern const struct setting ip6_setting __attribute__ (( weak ));
extern const struct setting len6_setting __attribute__ (( weak ));
extern const struct setting gateway6_setting __attribute__ (( weak ));
extern const struct setting dns_setting __attribute__ (( weak ));
extern const struct setting dns6_setting __attribute__ (( weak ));

/** EFI device path settings */
static struct efi_path_setting efi_path_settings[] = {
	{ &ip_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, LocalIpAddress ),
	  sizeof ( struct in_addr ) },
	{ &netmask_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, SubnetMask ),
	  sizeof ( struct in_addr ) },
	{ &gateway_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv4_DP, offsetof ( IPv4_DEVICE_PATH, GatewayIpAddress ),
	  sizeof ( struct in_addr ) },
	{ &ip6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, LocalIpAddress ),
	  sizeof ( struct in6_addr ) },
	{ &len6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, PrefixLength ),
	  sizeof ( uint8_t ) },
	{ &gateway6_setting, efi_path_fetch_fixed, MESSAGING_DEVICE_PATH,
	  MSG_IPv6_DP, offsetof ( IPv6_DEVICE_PATH, GatewayIpAddress ),
	  sizeof ( struct in6_addr ) },
	{ &dns_setting, efi_path_fetch_dns, MESSAGING_DEVICE_PATH,
	  MSG_DNS_DP, offsetof ( DNS_DEVICE_PATH, DnsServerIp ),
	  sizeof ( struct in_addr ) },
	{ &dns6_setting, efi_path_fetch_dns, MESSAGING_DEVICE_PATH,
	  MSG_DNS_DP, offsetof ( DNS_DEVICE_PATH, DnsServerIp ),
	  sizeof ( struct in6_addr ) },
};

/**
 * Fetch value of EFI device path setting
 *
 * @v settings		Settings block
 * @v setting		Setting to fetch
 * @v data		Buffer to fill with setting data
 * @v len		Length of buffer
 * @ret len		Length of setting data, or negative error
 */
static int efi_path_fetch ( struct settings *settings, struct setting *setting,
			    void *data, size_t len ) {
	struct efi_path_settings *pathsets =
		container_of ( settings, struct efi_path_settings, settings );
	EFI_DEVICE_PATH_PROTOCOL *path = pathsets->path;
	EFI_DEVICE_PATH_PROTOCOL *next;
	struct efi_path_setting *pathset;
	unsigned int i;
	int ret;

	/* Find matching path setting, if any */
	for ( i = 0 ; i < ( sizeof ( efi_path_settings ) /
			    sizeof ( efi_path_settings[0] ) ) ; i++ ) {

		/* Check for a matching setting */
		pathset = &efi_path_settings[i];
		if ( ! pathset->setting )
			continue;
		if ( setting_cmp ( setting, pathset->setting ) != 0 )
			continue;

		/* Find matching device path element, if any */
		for ( ; ( next = efi_path_next ( path ) ) ; path = next ) {

			/* Check for a matching path type */
			if ( ( path->Type != pathset->type ) ||
			     ( path->SubType != pathset->subtype ) )
				continue;

			/* Fetch value */
			if ( ( ret = pathset->fetch ( pathset, path,
						      data, len ) ) < 0 )
				return ret;

			/* Apply default type, if not already set */
			if ( ! setting->type )
				setting->type = pathset->setting->type;

			return ret;
		}
		break;
	}

	return -ENOENT;
}

/** EFI device path settings operations */
static struct settings_operations efi_path_settings_operations = {
	.fetch = efi_path_fetch,
};

/**
 * Create per-netdevice EFI path settings
 *
 * @v netdev		Network device
 * @v priv		Private data
 * @ret rc		Return status code
 */
static int efi_path_net_probe ( struct net_device *netdev, void *priv ) {
	struct efi_path_settings *pathsets = priv;
	struct settings *settings = &pathsets->settings;
	EFI_DEVICE_PATH_PROTOCOL *path = efi_loaded_image_path;
	const char *name;
	unsigned int vlan;
	unsigned int family;
	void *mac;
	int rc;

	/* Check applicability */
	pathsets->path = path;
	mac = efi_path_mac ( path );
	vlan = efi_path_vlan ( path );
	family = efi_path_family ( path );
	if ( ( mac == NULL ) ||
	     ( memcmp ( mac, netdev->ll_addr,
			netdev->ll_protocol->ll_addr_len ) != 0 ) ||
	     ( vlan != vlan_tag ( netdev ) ) ) {
		DBGC ( settings, "EFI path %s does not apply to %s\n",
		       efi_devpath_text ( path ), netdev->name );
		return 0;
	}

	/* Mark network device to be opened automatically */
	netdev->state |= NETDEV_AUTO_OPEN;

	/* Determine settings block name */
	switch ( family ) {
	case AF_INET:
		name = DHCP_SETTINGS_NAME;
		break;
	case AF_INET6:
		name = NDP_SETTINGS_NAME;
		break;
	default:
		DBGC ( settings, "EFI path %s has no IP address\n",
		       efi_devpath_text ( path ) );
		return 0;
	}

	/* Never override a real settings block */
	if ( find_child_settings ( netdev_settings ( netdev ), name ) ) {
		DBGC ( settings, "EFI path %s not overriding %s.%s settings\n",
		       efi_devpath_text ( path ), netdev->name, name );
		return 0;
	}

	/* Initialise and register settings */
	settings_init ( settings, &efi_path_settings_operations,
			&netdev->refcnt, NULL );
	if ( ( rc = register_settings ( settings, netdev_settings ( netdev ),
					name ) ) != 0 ) {
		DBGC ( settings, "EFI path %s could not register %s.%s: %s\n",
		       efi_devpath_text ( path ), netdev->name, name,
		       strerror ( rc ) );
		return rc;
	}
	DBGC ( settings, "EFI path %s registered %s.%s\n",
	       efi_devpath_text ( path ), netdev->name, name );

	return 0;
}

/** EFI path settings per-netdevice driver */
struct net_driver efi_path_net_driver __net_driver = {
	.name = "EFI path",
	.priv_len = sizeof ( struct efi_path_settings ),
	.probe = efi_path_net_probe,
};