efi_path.h File Reference

EFI device paths. More...

#include <ipxe/interface.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/Protocol/DevicePath.h>

Go to the source code of this file.

Macros
#define	efi_describe_TYPE(object_type)   typeof ( EFI_DEVICE_PATH_PROTOCOL * ( object_type ) )

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
EFI_DEVICE_PATH_PROTOCOL *	efi_path_end (EFI_DEVICE_PATH_PROTOCOL *path)
	Find end of device path. More...
size_t	efi_path_len (EFI_DEVICE_PATH_PROTOCOL *path)
	Find length of device path (excluding terminator) More...
EFI_DEVICE_PATH_PROTOCOL *	efi_paths (EFI_DEVICE_PATH_PROTOCOL *first,...)
	Concatenate EFI device paths. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_netdev_path (struct net_device *netdev)
	Construct EFI device path for network device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_uri_path (struct uri *uri)
	Construct EFI device path for URI. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_iscsi_path (struct iscsi_session *iscsi)
	Construct EFI device path for iSCSI device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_aoe_path (struct aoe_device *aoedev)
	Construct EFI device path for AoE device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_fcp_path (struct fcp_description *desc)
	Construct EFI device path for Fibre Channel device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_ib_srp_path (struct ib_srp_device *ib_srp)
	Construct EFI device path for Infiniband SRP device. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_usb_path (struct usb_function *func)
	Construct EFI device path for USB function. More...
EFI_DEVICE_PATH_PROTOCOL *	efi_describe (struct interface *interface)
	Describe object as an EFI device path. More...

Detailed Description

EFI device paths.

Definition in file efi_path.h.

Macro Definition Documentation

efi_describe_TYPE

#define efi_describe_TYPE

(

object_type

)

typeof ( EFI_DEVICE_PATH_PROTOCOL * ( object_type ) )

Definition at line 40 of file efi_path.h.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

efi_path_end()

EFI_DEVICE_PATH_PROTOCOL* efi_path_end

(

EFI_DEVICE_PATH_PROTOCOL *

path

)

Find end of device path.

Parameters

path	Path to device

Return values

path_end

End of device path

Definition at line 49 of file efi_path.c.

                                                                           {

        while ( path->Type != END_DEVICE_PATH_TYPE ) {
                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;
}

References END_DEVICE_PATH_TYPE, EFI_DEVICE_PATH_PROTOCOL::Length, and EFI_DEVICE_PATH_PROTOCOL::Type.

Referenced by efi_block_boot_image(), efi_path_len(), and usbio_open().

efi_path_len()

size_t efi_path_len

(

EFI_DEVICE_PATH_PROTOCOL *

path

)

Find length of device path (excluding terminator)

Parameters

path	Path to device

Return values

path_len

Length of device path

Definition at line 67 of file efi_path.c.

                                                       {
        EFI_DEVICE_PATH_PROTOCOL *end = efi_path_end ( path );

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

References efi_path_end(), and end.

Referenced by efi_block_boot_image(), efi_devpath_text(), efi_driver_start(), efi_ib_srp_path(), efi_image_path(), efi_init(), efi_iscsi_path(), efi_local_open_path(), efi_netdev_path(), efi_paths(), efi_snp_hii_install(), efi_usb_path(), and usbio_path().

efi_paths()

EFI_DEVICE_PATH_PROTOCOL* efi_paths	(	EFI_DEVICE_PATH_PROTOCOL *	first,
			...
	)

Concatenate EFI device paths.

Parameters

...	List of device paths (NULL terminated)

Return values

path	Concatenated device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 82 of file efi_path.c.

                                                                              {
        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;
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );

        return path;
}

References efi_path_len(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, first, len, memcpy(), NULL, src, va_arg, va_end, va_start, and zalloc().

Referenced by efi_aoe_path().

efi_netdev_path()

EFI_DEVICE_PATH_PROTOCOL* efi_netdev_path

(

struct net_device *

netdev

)

Construct EFI device path for network device.

Parameters

netdev

Network device

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 133 of file efi_path.c.

                                                                         {
        struct efi_device *efidev;
        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;

        /* Find parent EFI device */
        efidev = efidev_parent ( netdev->dev );
        if ( ! efidev )
                return NULL;

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

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

        /* Construct device path */
        memcpy ( path, efidev->path, 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 ) );
        }
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );

        return path;
}

References assert(), net_device::dev, efi_path_len(), efidev_parent(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, MAC_ADDR_DEVICE_PATH::Header, VLAN_DEVICE_PATH::Header, MAC_ADDR_DEVICE_PATH::IfType, len, EFI_DEVICE_PATH_PROTOCOL::Length, net_device::ll_addr, ll_protocol::ll_addr_len, ll_protocol::ll_proto, net_device::ll_protocol, MAC_ADDR_DEVICE_PATH::MacAddress, memcpy(), MESSAGING_DEVICE_PATH, MSG_MAC_ADDR_DP, MSG_VLAN_DP, netdev, ntohs, NULL, efi_device::path, EFI_DEVICE_PATH_PROTOCOL::SubType, tag, EFI_DEVICE_PATH_PROTOCOL::Type, vlan_tag(), VLAN_DEVICE_PATH::VlanId, and zalloc().

Referenced by efi_aoe_path(), efi_iscsi_path(), and efi_snp_probe().

efi_uri_path()

EFI_DEVICE_PATH_PROTOCOL* efi_uri_path

(

struct uri *

uri

)

Construct EFI device path for URI.

Parameters

uri

URI

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 195 of file efi_path.c.

                                                            {
        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 );
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );

        return path;
}

References end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, format_uri(), URI_DEVICE_PATH::Header, len, EFI_DEVICE_PATH_PROTOCOL::Length, MESSAGING_DEVICE_PATH, MSG_URI_DP, NULL, efi_device::path, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, URI_DEVICE_PATH::Uri, and zalloc().

Referenced by http_efi_describe().

efi_iscsi_path()

EFI_DEVICE_PATH_PROTOCOL* efi_iscsi_path

(

struct iscsi_session *

iscsi

)

Construct EFI device path for iSCSI device.

Parameters

iscsi

iSCSI session

Return values

path	EFI device path, or NULL on error

Definition at line 234 of file efi_path.c.

                                                                          {
        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 );
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );

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

        return path;

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

References efi_netdev_path(), efi_path_len(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, free, ISCSI_DEVICE_PATH::Header, ISCSI_LOGIN_OPTION_AUTHMETHOD_NON, len, EFI_DEVICE_PATH_PROTOCOL::Length, ISCSI_DEVICE_PATH::LoginOption, iscsi_session::lun, ISCSI_DEVICE_PATH::Lun, memcpy(), MESSAGING_DEVICE_PATH, MSG_ISCSI_DP, name, netdev, NULL, strlen(), EFI_DEVICE_PATH_PROTOCOL::SubType, iscsi_session::target_iqn, iscsi_session::target_sockaddr, tcpip_netdev(), EFI_DEVICE_PATH_PROTOCOL::Type, and zalloc().

efi_aoe_path()

EFI_DEVICE_PATH_PROTOCOL* efi_aoe_path

(

struct aoe_device *

aoedev

)

Construct EFI device path for AoE device.

Parameters

aoedev

AoE device

Return values

path	EFI device path, or NULL on error

Definition at line 302 of file efi_path.c.

                                                                      {
        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;
        satapath.end.Type = END_DEVICE_PATH_TYPE;
        satapath.end.SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        satapath.end.Length[0] = sizeof ( 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;
}

References efi_netdev_path(), efi_paths(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, free, aoe_device::major, memset(), MESSAGING_DEVICE_PATH, aoe_device::minor, MSG_SATA_DP, aoe_device::netdev, and NULL.

efi_fcp_path()

EFI_DEVICE_PATH_PROTOCOL* efi_fcp_path

(

struct fcp_description *

desc

)

Construct EFI device path for Fibre Channel device.

Parameters

desc	FCP device description

Return values

path	EFI device path, or NULL on error

Definition at line 348 of file efi_path.c.

                                                                         {
        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 ) );
        path->end.Type = END_DEVICE_PATH_TYPE;
        path->end.SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        path->end.Length[0] = sizeof ( path->end );

        return &path->fc.Header;
}

References __attribute__, end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, fc, fcp_description::lun, memcpy(), MESSAGING_DEVICE_PATH, MSG_FIBRECHANNELEX_DP, NULL, fcp_description::wwn, and zalloc().

Referenced by fcpdev_efi_describe().

efi_ib_srp_path()

EFI_DEVICE_PATH_PROTOCOL* efi_ib_srp_path

(

struct ib_srp_device *

ib_srp

)

Construct EFI device path for Infiniband SRP device.

Parameters

ib_srp

Infiniband SRP device

Return values

path	EFI device path, or NULL on error

Definition at line 378 of file efi_path.c.

                                                                            {
        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 );
        struct efi_device *efidev;
        EFI_DEVICE_PATH_PROTOCOL *path;
        INFINIBAND_DEVICE_PATH *ibpath;
        EFI_DEVICE_PATH_PROTOCOL *end;
        size_t prefix_len;
        size_t len;

        /* Find parent EFI device */
        efidev = efidev_parent ( ib_srp->ibdev->dev );
        if ( ! efidev )
                return NULL;

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

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

        /* Construct device path */
        memcpy ( path, efidev->path, 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 ) );
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *end );

        return path;
}

References container_of, ib_device::dev, INFINIBAND_DEVICE_PATH::DeviceId, sbft_ib_subtable::dgid, efi_path_len(), efidev_parent(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, INFINIBAND_DEVICE_PATH::Header, ipxe_ib_sbft::ib, ib_srp_device::ibdev, id, INFINIBAND_RESOURCE_FLAG_STORAGE_PROTOCOL, len, EFI_DEVICE_PATH_PROTOCOL::Length, memcpy(), MESSAGING_DEVICE_PATH, MSG_INFINIBAND_DP, NULL, efi_device::path, INFINIBAND_DEVICE_PATH::PortGid, INFINIBAND_DEVICE_PATH::ResourceFlags, ib_srp_device::sbft, sbft_ib_subtable::service_id, INFINIBAND_DEVICE_PATH::ServiceId, ib_srp_target_port_id::srp, ipxe_ib_sbft::srp, EFI_DEVICE_PATH_PROTOCOL::SubType, sbft_srp_subtable::target, INFINIBAND_DEVICE_PATH::TargetPortId, EFI_DEVICE_PATH_PROTOCOL::Type, and zalloc().

efi_usb_path()

EFI_DEVICE_PATH_PROTOCOL* efi_usb_path

(

struct usb_function *

func

)

Construct EFI device path for USB function.

Parameters

func	USB function

Return values

path	EFI device path, or NULL on error

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 435 of file efi_path.c.

                                                                      {
        struct usb_device *usb = func->usb;
        struct efi_device *efidev;
        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 );

        /* Find parent EFI device */
        efidev = efidev_parent ( &func->dev );
        if ( ! efidev )
                return NULL;

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

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

        /* Construct device path */
        memcpy ( path, efidev->path, prefix_len );
        end = ( ( ( void * ) path ) + len - sizeof ( *end ) );
        end->Type = END_DEVICE_PATH_TYPE;
        end->SubType = END_ENTIRE_DEVICE_PATH_SUBTYPE;
        end->Length[0] = sizeof ( *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;
}

References assert(), count, usb_function_descriptor::count, usb_function::desc, usb_function::dev, efi_path_len(), efidev_parent(), end, END_DEVICE_PATH_TYPE, END_ENTIRE_DEVICE_PATH_SUBTYPE, USB_DEVICE_PATH::Header, usb_port::hub, usb_function::interface, USB_DEVICE_PATH::InterfaceNumber, len, EFI_DEVICE_PATH_PROTOCOL::Length, memcpy(), MESSAGING_DEVICE_PATH, MSG_USB_DP, NULL, USB_DEVICE_PATH::ParentPortNumber, efi_device::path, usb_device::port, EFI_DEVICE_PATH_PROTOCOL::SubType, EFI_DEVICE_PATH_PROTOCOL::Type, usb_function::usb, usb_hub::usb, usb_depth(), and zalloc().

Referenced by efi_usb_install(), and usbblk_efi_describe().

efi_describe()

EFI_DEVICE_PATH_PROTOCOL* efi_describe

(

struct interface *

intf

)

Describe object as an EFI device path.

Parameters

intf

Interface

Return values

path	EFI device path, or NULL

The caller is responsible for eventually calling free() on the allocated device path.

Definition at line 491 of file efi_path.c.

                                                                   {
        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;
}

References dest, efi_describe(), efi_describe_TYPE, intf_get_dest_op, intf_object(), intf_put(), NULL, and op.

Referenced by efi_block_hook(), and efi_describe().