efi_pci.c File Reference

iPXE PCI I/O API for EFI More...

#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ipxe/pci.h>
#include <ipxe/acpi.h>
#include <ipxe/efi/efi.h>
#include <ipxe/efi/efi_pci.h>
#include <ipxe/efi/efi_driver.h>
#include <ipxe/efi/Protocol/PciIo.h>
#include <ipxe/efi/Protocol/PciRootBridgeIo.h>

Go to the source code of this file.

Macros
#define	EINFO_EEFI_PCI
#define	EINFO_EEFI_PCI_NOT_PCI
#define	EEFI_PCI_NOT_PCI   __einfo_error ( EINFO_EEFI_PCI_NOT_PCI )
#define	EINFO_EEFI_PCI_IN_USE
#define	EEFI_PCI_IN_USE   __einfo_error ( EINFO_EEFI_PCI_IN_USE )
#define	EEFI_PCI(efirc)

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
	FILE_SECBOOT (PERMITTED)
static int	efipci_discover_one (struct pci_device *pci, EFI_HANDLE handle, struct pci_range *range)
	Find closest bus:dev.fn address range within a root bridge.
static int	efipci_discover_any (struct pci_device *pci, struct pci_range *range, EFI_HANDLE *handle)
	Find closest bus:dev.fn address range within any root bridge.
static void	efipci_discover (uint32_t busdevfn, struct pci_range *range)
	Find next PCI bus:dev.fn address range in system.
static int	efipci_root_open (struct pci_device *pci, EFI_HANDLE *handle, EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL **root)
	Open EFI PCI root bridge I/O protocol for ephemeral use.
static unsigned long	efipci_address (struct pci_device *pci, unsigned long location)
	Calculate EFI PCI configuration space address.
int	efipci_read (struct pci_device *pci, unsigned long location, void *value)
	Read from PCI configuration space.
int	efipci_write (struct pci_device *pci, unsigned long location, unsigned long value)
	Write to PCI configuration space.
void *	efipci_ioremap (struct pci_device *pci, unsigned long bus_addr, size_t len)
	Map PCI bus address as an I/O address.
	PROVIDE_PCIAPI_INLINE (efi, pci_can_probe)
	PROVIDE_PCIAPI (efi, pci_discover, efipci_discover)
	PROVIDE_PCIAPI_INLINE (efi, pci_read_config_byte)
	PROVIDE_PCIAPI_INLINE (efi, pci_read_config_word)
	PROVIDE_PCIAPI_INLINE (efi, pci_read_config_dword)
	PROVIDE_PCIAPI_INLINE (efi, pci_write_config_byte)
	PROVIDE_PCIAPI_INLINE (efi, pci_write_config_word)
	PROVIDE_PCIAPI_INLINE (efi, pci_write_config_dword)
	PROVIDE_PCIAPI (efi, pci_ioremap, efipci_ioremap)
	PROVIDE_PCIAPI_RUNTIME (efi, PCIAPI_PRIORITY_EFI)
static int	efipci_dma_map (struct dma_device *dma, struct dma_mapping *map, void *addr, size_t len, int flags)
	Map buffer for DMA.
static void	efipci_dma_unmap (struct dma_device *dma, struct dma_mapping *map, size_t len __unused)
	Unmap buffer.
static void *	efipci_dma_alloc (struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align __unused)
	Allocate and map DMA-coherent buffer.
static void	efipci_dma_free (struct dma_device *dma, struct dma_mapping *map, void *addr, size_t len)
	Unmap and free DMA-coherent buffer.
static void	efipci_dma_set_mask (struct dma_device *dma, physaddr_t mask)
	Set addressable space mask.
int	efipci_info (EFI_HANDLE device, struct efi_pci_device *efipci)
	Get EFI PCI device information.
static int	efipci_supported (EFI_HANDLE device)
	Check to see if driver supports a device.
static int	efipci_exclude (EFI_HANDLE device)
	Exclude existing drivers.
static int	efipci_start (struct efi_device *efidev)
	Attach driver to device.
static void	efipci_stop (struct efi_device *efidev)
	Detach driver from device.
struct efi_driver efipci_driver	__efi_driver (EFI_DRIVER_HARDWARE)
	EFI PCI driver.

Variables
static struct dma_operations	efipci_dma_operations
	EFI PCI DMA operations.

Detailed Description

iPXE PCI I/O API for EFI

Definition in file efi_pci.c.

Macro Definition Documentation

EINFO_EEFI_PCI

#define EINFO_EEFI_PCI

Value:

        __einfo_uniqify ( EINFO_EPLATFORM, 0x01,                  \
                          "Could not open PCI I/O protocol" )

Definition at line 45 of file efi_pci.c.

#define EINFO_EEFI_PCI                                                  \
        __einfo_uniqify ( EINFO_EPLATFORM, 0x01,                        \
                          "Could not open PCI I/O protocol" )

EINFO_EEFI_PCI_NOT_PCI

#define EINFO_EEFI_PCI_NOT_PCI

Value:

        __einfo_platformify ( EINFO_EEFI_PCI, EFI_UNSUPPORTED,          \
                              "Not a PCI device" )

Definition at line 48 of file efi_pci.c.

#define EINFO_EEFI_PCI_NOT_PCI                                          \
        __einfo_platformify ( EINFO_EEFI_PCI, EFI_UNSUPPORTED,          \
                              "Not a PCI device" )

EEFI_PCI_NOT_PCI

#define EEFI_PCI_NOT_PCI   __einfo_error ( EINFO_EEFI_PCI_NOT_PCI )

Definition at line 51 of file efi_pci.c.

EINFO_EEFI_PCI_IN_USE

#define EINFO_EEFI_PCI_IN_USE

Value:

        __einfo_platformify ( EINFO_EEFI_PCI, EFI_ACCESS_DENIED,      \
                              "PCI device already has a driver" )

Definition at line 52 of file efi_pci.c.

#define EINFO_EEFI_PCI_IN_USE                                           \
        __einfo_platformify ( EINFO_EEFI_PCI, EFI_ACCESS_DENIED,        \
                              "PCI device already has a driver" )

EEFI_PCI_IN_USE

#define EEFI_PCI_IN_USE   __einfo_error ( EINFO_EEFI_PCI_IN_USE )

Definition at line 55 of file efi_pci.c.

EEFI_PCI

#define EEFI_PCI

(

efirc

)

Value:

        EPLATFORM ( EINFO_EEFI_PCI, efirc,                               \
                    EEFI_PCI_NOT_PCI, EEFI_PCI_IN_USE )

Definition at line 56 of file efi_pci.c.

#define EEFI_PCI( efirc )                                               \
        EPLATFORM ( EINFO_EEFI_PCI, efirc,                              \
                    EEFI_PCI_NOT_PCI, EEFI_PCI_IN_USE )

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

FILE_SECBOOT()

FILE_SECBOOT

(

PERMITTED

)

efipci_discover_one()

int efipci_discover_one ( struct pci_device * pci, EFI_HANDLE handle, struct pci_range * range )

static

Find closest bus:dev.fn address range within a root bridge.

Parameters

pci	Starting PCI device
handle	EFI PCI root bridge handle
range	PCI bus:dev.fn address range to fill in

Return values

rc	Return status code

Definition at line 75 of file efi_pci.c.

                                                           {
        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root;
        union {
                union acpi_resource *res;
                void *raw;
        } acpi;
        uint32_t best = 0;
        uint32_t start;
        uint32_t count;
        uint32_t index;
        unsigned int tag;
        EFI_STATUS efirc;
        int rc;
 
        /* Return empty range on error */
        range->start = 0;
        range->count = 0;
 
        /* Open root bridge I/O protocol */
        if ( ( rc = efi_open ( handle, &efi_pci_root_bridge_io_protocol_guid,
                               &root ) ) != 0 ) {
                DBGC ( pci, "EFIPCI " PCI_FMT " cannot open %s: %s\n",
                       PCI_ARGS ( pci ), efi_handle_name ( handle ),
                       strerror ( rc ) );
                return rc;
        }
 
        /* Get ACPI resource descriptors */
        if ( ( efirc = root->Configuration ( root, &acpi.raw ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " cannot get configuration for "
                       "%s: %s\n", PCI_ARGS ( pci ),
                       efi_handle_name ( handle ), strerror ( rc ) );
                return rc;
        }
 
        /* Parse resource descriptors */
        for ( ; ( ( tag = acpi_resource_tag ( acpi.res ) ) !=
                  ACPI_END_RESOURCE ) ;
              acpi.res = acpi_resource_next ( acpi.res ) ) {
 
                /* Ignore anything other than a bus number range descriptor */
                if ( tag != ACPI_QWORD_ADDRESS_SPACE_RESOURCE )
                        continue;
                if ( acpi.res->qword.type != ACPI_ADDRESS_TYPE_BUS )
                        continue;
 
                /* Get range for this descriptor */
                start = PCI_BUSDEVFN ( root->SegmentNumber,
                                       le64_to_cpu ( acpi.res->qword.min ),
                                       0, 0 );
                count = PCI_BUSDEVFN ( 0, le64_to_cpu ( acpi.res->qword.len ),
                                       0, 0 );
                DBGC2 ( pci, "EFIPCI " PCI_FMT " found %04x:[%02x-%02x] via "
                        "%s\n", PCI_ARGS ( pci ), root->SegmentNumber,
                        PCI_BUS ( start ), PCI_BUS ( start + count - 1 ),
                        efi_handle_name ( handle ) );
 
                /* Check for a matching or new closest range */
                index = ( pci->busdevfn - start );
                if ( ( index < count ) || ( index > best ) ) {
                        range->start = start;
                        range->count = count;
                        best = index;
                }
 
                /* Stop if this range contains the target bus:dev.fn address */
                if ( index < count )
                        break;
        }
 
        /* If no range descriptors were seen, assume that the root
         * bridge has a single bus.
         */
        if ( ! range->count ) {
                range->start = PCI_BUSDEVFN ( root->SegmentNumber, 0, 0, 0 );
                range->count = PCI_BUSDEVFN ( 0, 1, 0, 0 );
        }
 
        return 0;
}

References acpi, ACPI_ADDRESS_TYPE_BUS, ACPI_END_RESOURCE, ACPI_QWORD_ADDRESS_SPACE_RESOURCE, acpi_resource_next(), acpi_resource_tag(), pci_device::busdevfn, count, DBGC, DBGC2, EEFI, EFI_HANDLE, efi_handle_name(), efi_open, efi_pci_root_bridge_io_protocol_guid, handle, index, le64_to_cpu, PCI_ARGS, PCI_BUS, PCI_BUSDEVFN, PCI_FMT, range, raw, rc, root, start, strerror(), and tag.

Referenced by efipci_discover_any().

efipci_discover_any()

int efipci_discover_any ( struct pci_device * pci, struct pci_range * range, EFI_HANDLE * handle )

static

Find closest bus:dev.fn address range within any root bridge.

Parameters

pci	Starting PCI device
range	PCI bus:dev.fn address range to fill in
handle	PCI root bridge I/O handle to fill in

Return values

rc	Return status code

Definition at line 166 of file efi_pci.c.

                                                      {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        uint32_t best = 0;
        uint32_t index;
        struct pci_range tmp;
        EFI_HANDLE *handles;
        UINTN num_handles;
        UINTN i;
        EFI_STATUS efirc;
        int rc;
 
        /* Return an empty range and no handle on error */
        range->start = 0;
        range->count = 0;
        *handle = NULL;
 
        /* Enumerate all root bridge I/O protocol handles */
        if ( ( efirc = bs->LocateHandleBuffer ( ByProtocol,
                        &efi_pci_root_bridge_io_protocol_guid,
                        NULL, &num_handles, &handles ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " cannot locate root bridges: "
                       "%s\n", PCI_ARGS ( pci ), strerror ( rc ) );
                goto err_locate;
        }
 
        /* Iterate over all root bridge I/O protocols */
        for ( i = 0 ; i < num_handles ; i++ ) {
 
                /* Get matching or closest range for this root bridge */
                if ( ( rc = efipci_discover_one ( pci, handles[i],
                                                  &tmp ) ) != 0 )
                        continue;
 
                /* Check for a matching or new closest range */
                index = ( pci->busdevfn - tmp.start );
                if ( ( index < tmp.count ) || ( index > best ) ) {
                        range->start = tmp.start;
                        range->count = tmp.count;
                        best = index;
                }
 
                /* Stop if this range contains the target bus:dev.fn address */
                if ( index < tmp.count ) {
                        *handle = handles[i];
                        break;
                }
        }
 
        /* Check for a range containing the target bus:dev.fn address */
        if ( ! *handle ) {
                rc = -ENOENT;
                goto err_range;
        }
 
        /* Success */
        rc = 0;
 
 err_range:
        bs->FreePool ( handles );
 err_locate:
        return rc;
}

References pci_device::busdevfn, ByProtocol, DBGC, EEFI, EFI_HANDLE, efi_pci_root_bridge_io_protocol_guid, efi_systab, efipci_discover_one(), ENOENT, EFI_BOOT_SERVICES::FreePool, handle, index, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, PCI_ARGS, PCI_FMT, range, rc, strerror(), and tmp.

Referenced by efipci_discover(), and efipci_root_open().

efipci_discover()

void efipci_discover ( uint32_t busdevfn, struct pci_range * range )

static

Find next PCI bus:dev.fn address range in system.

Parameters

busdevfn	Starting PCI bus:dev.fn address
range	PCI bus:dev.fn address range to fill in

Definition at line 238 of file efi_pci.c.

                                                                           {
        struct pci_device pci;
        EFI_HANDLE handle;
 
        /* Find range */
        memset ( &pci, 0, sizeof ( pci ) );
        pci_init ( &pci, busdevfn );
        efipci_discover_any ( &pci, range, &handle );
}

References busdevfn, EFI_HANDLE, efipci_discover_any(), handle, memset(), pci_init(), and range.

Referenced by PROVIDE_PCIAPI().

efipci_root_open()

int efipci_root_open ( struct pci_device * pci, EFI_HANDLE * handle, EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL ** root )

static

Open EFI PCI root bridge I/O protocol for ephemeral use.

Parameters

pci	PCI device

Return values

handle	EFI PCI root bridge handle
root	EFI PCI root bridge I/O protocol, or NULL if not found
rc	Return status code

Definition at line 256 of file efi_pci.c.

                                                                       {
        static struct {
                struct pci_range range;
                EFI_HANDLE handle;
        } cache;
        int rc;
 
        /* Find and cache matching root bridge I/O protocol handle, if any */
        if ( ( pci->busdevfn - cache.range.start ) >= cache.range.count )
                efipci_discover_any ( pci, &cache.range, &cache.handle );
        if ( ! cache.handle )
                return -ENOENT;
        *handle = cache.handle;
 
        /* Open PCI root bridge I/O protocol */
        if ( ( rc = efi_open ( *handle, &efi_pci_root_bridge_io_protocol_guid,
                               root ) ) != 0 ) {
                DBGC ( pci, "EFIPCI " PCI_FMT " cannot open %s: %s\n",
                       PCI_ARGS ( pci ), efi_handle_name ( *handle ),
                       strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References pci_device::busdevfn, DBGC, EFI_HANDLE, efi_handle_name(), efi_open, efi_pci_root_bridge_io_protocol_guid, efipci_discover_any(), ENOENT, handle, PCI_ARGS, PCI_FMT, range, rc, root, and strerror().

Referenced by efipci_ioremap(), efipci_read(), and efipci_write().

efipci_address()

unsigned long efipci_address ( struct pci_device * pci, unsigned long location )

static

Calculate EFI PCI configuration space address.

Parameters

pci	PCI device
location	Encoded offset and width

Return values

address

EFI PCI address

Definition at line 290 of file efi_pci.c.

                                                               {
 
        return EFI_PCI_ADDRESS ( PCI_BUS ( pci->busdevfn ),
                                 PCI_SLOT ( pci->busdevfn ),
                                 PCI_FUNC ( pci->busdevfn ),
                                 EFIPCI_OFFSET ( location ) );
}

References pci_device::busdevfn, EFI_PCI_ADDRESS, EFIPCI_OFFSET, PCI_BUS, PCI_FUNC, and PCI_SLOT.

Referenced by efipci_read(), and efipci_write().

efipci_read()

int efipci_read	(	struct pci_device *	pci,
		unsigned long	location,
		void *	value )

Read from PCI configuration space.

Parameters

pci	PCI device
location	Encoded offset and width

Return values

value	Value
rc	Return status code

Definition at line 307 of file efi_pci.c.

                                {
        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root;
        EFI_HANDLE handle;
        EFI_STATUS efirc;
        int rc;
 
        /* Open root bridge */
        if ( ( rc = efipci_root_open ( pci, &handle, &root ) ) != 0 )
                return rc;
 
        /* Read from configuration space */
        if ( ( efirc = root->Pci.Read ( root, EFIPCI_WIDTH ( location ),
                                        efipci_address ( pci, location ), 1,
                                        value ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " config read from offset %02lx "
                       "failed: %s\n", PCI_ARGS ( pci ),
                       EFIPCI_OFFSET ( location ), strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, EEFI, EFI_HANDLE, efipci_address(), EFIPCI_OFFSET, efipci_root_open(), EFIPCI_WIDTH, handle, PCI_ARGS, PCI_FMT, rc, root, strerror(), and value.

efipci_write()

int efipci_write	(	struct pci_device *	pci,
		unsigned long	location,
		unsigned long	value )

Write to PCI configuration space.

Parameters

pci	PCI device
location	Encoded offset and width
value	Value

Return values

rc	Return status code

Definition at line 340 of file efi_pci.c.

                                         {
        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root;
        EFI_HANDLE handle;
        EFI_STATUS efirc;
        int rc;
 
        /* Open root bridge */
        if ( ( rc = efipci_root_open ( pci, &handle, &root ) ) != 0 )
                return rc;
 
        /* Read from configuration space */
        if ( ( efirc = root->Pci.Write ( root, EFIPCI_WIDTH ( location ),
                                         efipci_address ( pci, location ), 1,
                                         &value ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " config write to offset %02lx "
                       "failed: %s\n", PCI_ARGS ( pci ),
                       EFIPCI_OFFSET ( location ), strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, EEFI, EFI_HANDLE, efipci_address(), EFIPCI_OFFSET, efipci_root_open(), EFIPCI_WIDTH, handle, PCI_ARGS, PCI_FMT, rc, root, strerror(), and value.

Referenced by PCIAPI_INLINE(), PCIAPI_INLINE(), and PCIAPI_INLINE().

efipci_ioremap()

void * efipci_ioremap	(	struct pci_device *	pci,
		unsigned long	bus_addr,
		size_t	len )

Map PCI bus address as an I/O address.

Parameters

bus_addr	PCI bus address
len	Length of region

Return values

io_addr

I/O address, or NULL on error

Definition at line 372 of file efi_pci.c.

                                     {
        union {
                union acpi_resource *res;
                void *raw;
        } u;
        EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root;
        EFI_HANDLE handle;
        unsigned int tag;
        uint64_t offset;
        uint64_t start;
        uint64_t end;
        EFI_STATUS efirc;
        int rc;
 
        /* Open root bridge */
        if ( ( rc = efipci_root_open ( pci, &handle, &root ) ) != 0 )
                goto err_root;
 
        /* Get ACPI resource descriptors */
        if ( ( efirc = root->Configuration ( root, &u.raw ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " cannot get configuration: "
                       "%s\n", PCI_ARGS ( pci ), strerror ( rc ) );
                goto err_config;
        }
 
        /* Parse resource descriptors */
        for ( ; ( ( tag = acpi_resource_tag ( u.res ) ) != ACPI_END_RESOURCE ) ;
              u.res = acpi_resource_next ( u.res ) ) {
 
                /* Ignore anything other than a memory range descriptor */
                if ( tag != ACPI_QWORD_ADDRESS_SPACE_RESOURCE )
                        continue;
                if ( u.res->qword.type != ACPI_ADDRESS_TYPE_MEM )
                        continue;
 
                /* Ignore descriptors that do not cover this memory range */
                offset = le64_to_cpu ( u.res->qword.offset );
                start = ( offset + le64_to_cpu ( u.res->qword.min ) );
                end = ( start + le64_to_cpu ( u.res->qword.len ) );
                DBGC2 ( pci, "EFIPCI " PCI_FMT " found range [%08llx,%08llx) "
                        "-> [%08llx,%08llx)\n", PCI_ARGS ( pci ), start, end,
                        ( start - offset ), ( end - offset ) );
                if ( ( bus_addr < start ) || ( ( bus_addr + len ) > end ) )
                        continue;
 
                /* Use this address space descriptor */
                DBGC2 ( pci, "EFIPCI " PCI_FMT " %08lx+%zx -> ",
                        PCI_ARGS ( pci ), bus_addr, len );
                bus_addr -= offset;
                DBGC2 ( pci, "%08lx\n", bus_addr );
                break;
        }
        if ( tag == ACPI_END_RESOURCE ) {
                DBGC ( pci, "EFIPCI " PCI_FMT " %08lx+%zx is not within "
                       "root bridge address space\n",
                       PCI_ARGS ( pci ), bus_addr, len );
        }
 
 err_config:
 err_root:
        return ioremap ( bus_addr, len );
}

References ACPI_ADDRESS_TYPE_MEM, ACPI_END_RESOURCE, ACPI_QWORD_ADDRESS_SPACE_RESOURCE, acpi_resource_next(), acpi_resource_tag(), bus_addr, DBGC, DBGC2, EEFI, EFI_HANDLE, efipci_root_open(), end, handle, ioremap(), le64_to_cpu, len, offset, PCI_ARGS, PCI_FMT, raw, rc, root, start, strerror(), tag, and u.

Referenced by PROVIDE_PCIAPI().

PROVIDE_PCIAPI_INLINE() [1/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_can_probe	)

References pci_can_probe().

PROVIDE_PCIAPI() [1/2]

PROVIDE_PCIAPI	(	efi	,
		pci_discover	,
		efipci_discover	)

References efipci_discover(), and pci_discover().

PROVIDE_PCIAPI_INLINE() [2/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_byte	)

References pci_read_config_byte().

PROVIDE_PCIAPI_INLINE() [3/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_word	)

References pci_read_config_word().

PROVIDE_PCIAPI_INLINE() [4/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_dword	)

References pci_read_config_dword().

PROVIDE_PCIAPI_INLINE() [5/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_byte	)

References pci_write_config_byte().

PROVIDE_PCIAPI_INLINE() [6/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_word	)

References pci_write_config_word().

PROVIDE_PCIAPI_INLINE() [7/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_dword	)

References pci_write_config_dword().

PROVIDE_PCIAPI() [2/2]

PROVIDE_PCIAPI	(	efi	,
		pci_ioremap	,
		efipci_ioremap	)

References efipci_ioremap(), and pci_ioremap().

PROVIDE_PCIAPI_RUNTIME()

PROVIDE_PCIAPI_RUNTIME	(	efi	,
		PCIAPI_PRIORITY_EFI	)

References PCIAPI_PRIORITY_EFI.

efipci_dma_map()

int efipci_dma_map ( struct dma_device * dma, struct dma_mapping * map, void * addr, size_t len, int flags )

static

Map buffer for DMA.

Parameters

dma	DMA device
map	DMA mapping to fill in
addr	Buffer address
len	Length of buffer
flags	Mapping flags

Return values

rc	Return status code

Definition at line 465 of file efi_pci.c.

                                                                {
        struct efi_pci_device *efipci =
                container_of ( dma, struct efi_pci_device, pci.dma );
        struct pci_device *pci = &efipci->pci;
        EFI_PCI_IO_PROTOCOL *pci_io = efipci->io;
        EFI_PCI_IO_PROTOCOL_OPERATION op;
        EFI_PHYSICAL_ADDRESS bus;
        UINTN count;
        VOID *mapping;
        physaddr_t phys;
        EFI_STATUS efirc;
        int rc;
 
        /* Sanity check */
        assert ( map->dma == NULL );
        assert ( map->offset == 0 );
        assert ( map->token == NULL );
 
        /* Determine operation */
        switch ( flags ) {
        case DMA_TX:
                op = EfiPciIoOperationBusMasterRead;
                break;
        case DMA_RX:
                op = EfiPciIoOperationBusMasterWrite;
                break;
        default:
                op = EfiPciIoOperationBusMasterCommonBuffer;
                break;
        }
 
        /* Map buffer (if non-zero length) */
        phys = virt_to_phys ( addr );
        count = len;
        if ( len ) {
                if ( ( efirc = pci_io->Map ( pci_io, op, addr, &count, &bus,
                                             &mapping ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( pci, "EFIPCI " PCI_FMT " cannot map %p+%zx: "
                               "%s\n", PCI_ARGS ( pci ), addr, len,
                               strerror ( rc ) );
                        goto err_map;
                }
        } else {
                bus = phys;
                mapping = NULL;
        }
 
        /* Check that full length was mapped.  The UEFI specification
         * allows for multiple mappings to be required, but even the
         * EDK2 PCI device drivers will fail if a platform ever
         * requires this.
         */
        if ( count != len ) {
                DBGC ( pci, "EFIPCI " PCI_FMT " attempted split mapping for "
                       "%p+%zx\n", PCI_ARGS ( pci ), addr, len );
                rc = -ENOTSUP;
                goto err_len;
        }
 
        /* Populate mapping */
        map->dma = dma;
        map->offset = ( bus - phys );
        map->token = mapping;
 
        /* Increment mapping count (for debugging) */
        if ( DBG_LOG )
                dma->mapped++;
 
        return 0;
 
 err_len:
        pci_io->Unmap ( pci_io, mapping );
 err_map:
        return rc;
}

References addr, assert, bus, container_of, count, DBG_LOG, DBGC, dma(), pci_device::dma, DMA_RX, DMA_TX, EEFI, EfiPciIoOperationBusMasterCommonBuffer, EfiPciIoOperationBusMasterRead, EfiPciIoOperationBusMasterWrite, ENOTSUP, flags, efi_pci_device::io, len, _EFI_PCI_IO_PROTOCOL::Map, map, NULL, op, efi_pci_device::pci, PCI_ARGS, PCI_FMT, phys, rc, strerror(), _EFI_PCI_IO_PROTOCOL::Unmap, and VOID.

Referenced by efipci_dma_alloc().

efipci_dma_unmap()

void efipci_dma_unmap ( struct dma_device * dma, struct dma_mapping * map, size_t len __unused )

static

Unmap buffer.

Parameters

dma	DMA device
map	DMA mapping
len	Used length

Definition at line 550 of file efi_pci.c.

                                                                              {
        struct efi_pci_device *efipci =
                container_of ( dma, struct efi_pci_device, pci.dma );
        EFI_PCI_IO_PROTOCOL *pci_io = efipci->io;
 
        /* Unmap buffer (if non-zero length) */
        if ( map->token )
                pci_io->Unmap ( pci_io, map->token );
 
        /* Clear mapping */
        map->dma = NULL;
        map->offset = 0;
        map->token = NULL;
 
        /* Decrement mapping count (for debugging) */
        if ( DBG_LOG )
                dma->mapped--;
}

References __unused, container_of, DBG_LOG, dma(), pci_device::dma, efi_pci_device::io, len, map, NULL, efi_pci_device::pci, and _EFI_PCI_IO_PROTOCOL::Unmap.

Referenced by efipci_dma_alloc(), and efipci_dma_free().

efipci_dma_alloc()

void * efipci_dma_alloc ( struct dma_device * dma, struct dma_mapping * map, size_t len, size_t align __unused )

static

Allocate and map DMA-coherent buffer.

Parameters

dma	DMA device
map	DMA mapping to fill in
len	Length of buffer
align	Physical alignment

Return values

addr	Buffer address, or NULL on error

Definition at line 579 of file efi_pci.c.

                                                                     {
        struct efi_pci_device *efipci =
                container_of ( dma, struct efi_pci_device, pci.dma );
        struct pci_device *pci = &efipci->pci;
        EFI_PCI_IO_PROTOCOL *pci_io = efipci->io;
        unsigned int pages;
        VOID *addr;
        EFI_STATUS efirc;
        int rc;
 
        /* Calculate number of pages */
        pages = ( ( len + EFI_PAGE_SIZE - 1 ) / EFI_PAGE_SIZE );
 
        /* Allocate (page-aligned) buffer */
        if ( ( efirc = pci_io->AllocateBuffer ( pci_io, AllocateAnyPages,
                                                EfiBootServicesData, pages,
                                                &addr, 0 ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " could not allocate %zd bytes: "
                       "%s\n", PCI_ARGS ( pci ), len, strerror ( rc ) );
                goto err_alloc;
        }
 
        /* Clear buffer */
        memset ( addr, 0, ( pages * EFI_PAGE_SIZE ) );
 
        /* Map buffer */
        if ( ( rc = efipci_dma_map ( dma, map, addr, ( pages * EFI_PAGE_SIZE ),
                                     DMA_BI ) ) != 0 )
                goto err_map;
 
        /* Increment allocation count (for debugging) */
        if ( DBG_LOG )
                dma->allocated++;
 
        return addr;
 
        efipci_dma_unmap ( dma, map, len );
 err_map:
        pci_io->FreeBuffer ( pci_io, pages, addr );
 err_alloc:
        return NULL;
}

References __unused, addr, AllocateAnyPages, _EFI_PCI_IO_PROTOCOL::AllocateBuffer, container_of, DBG_LOG, DBGC, dma(), pci_device::dma, DMA_BI, EEFI, EFI_PAGE_SIZE, EfiBootServicesData, efipci_dma_map(), efipci_dma_unmap(), _EFI_PCI_IO_PROTOCOL::FreeBuffer, efi_pci_device::io, len, map, memset(), NULL, efi_pci_device::pci, PCI_ARGS, PCI_FMT, rc, strerror(), and VOID.

efipci_dma_free()

void efipci_dma_free ( struct dma_device * dma, struct dma_mapping * map, void * addr, size_t len )

static

Unmap and free DMA-coherent buffer.

Parameters

dma	DMA device
map	DMA mapping
addr	Buffer address
len	Length of buffer

Definition at line 633 of file efi_pci.c.

                                                       {
        struct efi_pci_device *efipci =
                container_of ( dma, struct efi_pci_device, pci.dma );
        EFI_PCI_IO_PROTOCOL *pci_io = efipci->io;
        unsigned int pages;
 
        /* Calculate number of pages */
        pages = ( ( len + EFI_PAGE_SIZE - 1 ) / EFI_PAGE_SIZE );
 
        /* Unmap buffer */
        efipci_dma_unmap ( dma, map, len );
 
        /* Free buffer */
        pci_io->FreeBuffer ( pci_io, pages, addr );
 
        /* Decrement allocation count (for debugging) */
        if ( DBG_LOG )
                dma->allocated--;
}

References addr, container_of, DBG_LOG, dma(), pci_device::dma, EFI_PAGE_SIZE, efipci_dma_unmap(), _EFI_PCI_IO_PROTOCOL::FreeBuffer, efi_pci_device::io, len, map, and efi_pci_device::pci.

efipci_dma_set_mask()

void efipci_dma_set_mask ( struct dma_device * dma, physaddr_t mask )

static

Set addressable space mask.

Parameters

dma	DMA device
mask	Addressable space mask

Definition at line 660 of file efi_pci.c.

                                                                            {
        struct efi_pci_device *efipci =
                container_of ( dma, struct efi_pci_device, pci.dma );
        struct pci_device *pci = &efipci->pci;
        EFI_PCI_IO_PROTOCOL *pci_io = efipci->io;
        EFI_PCI_IO_PROTOCOL_ATTRIBUTE_OPERATION op;
        UINT64 attrs;
        int is64;
        EFI_STATUS efirc;
        int rc;
 
        /* Set dual address cycle attribute for 64-bit capable devices */
        is64 = ( ( ( ( uint64_t ) mask ) + 1 ) == 0 );
        op = ( is64 ? EfiPciIoAttributeOperationEnable :
               EfiPciIoAttributeOperationDisable );
        attrs = EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE;
        if ( ( efirc = pci_io->Attributes ( pci_io, op, attrs, NULL ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( pci, "EFIPCI " PCI_FMT " could not %sable DAC: %s\n",
                       PCI_ARGS ( pci ), ( is64 ? "en" : "dis" ),
                       strerror ( rc ) );
                /* Ignore failure: errors will manifest in mapping attempts */
                return;
        }
}

References _EFI_PCI_IO_PROTOCOL::Attributes, container_of, DBGC, dma(), pci_device::dma, EEFI, EFI_PCI_IO_ATTRIBUTE_DUAL_ADDRESS_CYCLE, EfiPciIoAttributeOperationDisable, EfiPciIoAttributeOperationEnable, efi_pci_device::io, NULL, op, efi_pci_device::pci, PCI_ARGS, PCI_FMT, rc, and strerror().

efipci_info()

int efipci_info	(	EFI_HANDLE	device,
		struct efi_pci_device *	efipci )

Get EFI PCI device information.

Parameters

device	EFI device handle
efipci	EFI PCI device to fill in

Return values

rc	Return status code

Definition at line 711 of file efi_pci.c.

                                                                     {
        EFI_PCI_IO_PROTOCOL *pci_io;
        UINTN pci_segment, pci_bus, pci_dev, pci_fn;
        unsigned int busdevfn;
        EFI_STATUS efirc;
        int rc;
 
        /* See if device is a PCI device */
        if ( ( rc = efi_open ( device, &efi_pci_io_protocol_guid,
                               &pci_io ) ) != 0 ) {
                DBGCP ( device, "EFIPCI %s cannot open PCI protocols: %s\n",
                        efi_handle_name ( device ), strerror ( rc ) );
                return rc;
        }
        efipci->io = pci_io;
 
        /* Get PCI bus:dev.fn address */
        if ( ( efirc = pci_io->GetLocation ( pci_io, &pci_segment, &pci_bus,
                                             &pci_dev, &pci_fn ) ) != 0 ) {
                rc = -EEFI ( efirc );
                DBGC ( device, "EFIPCI %s could not get PCI location: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                return rc;
        }
        busdevfn = PCI_BUSDEVFN ( pci_segment, pci_bus, pci_dev, pci_fn );
        pci_init ( &efipci->pci, busdevfn );
        dma_init ( &efipci->pci.dma, &efipci_dma_operations );
        DBGCP ( device, "EFIPCI " PCI_FMT " is %s\n",
                PCI_ARGS ( &efipci->pci ), efi_handle_name ( device ) );
 
        /* Try to enable I/O cycles, memory cycles, and bus mastering.
         * Some platforms will 'helpfully' report errors if these bits
         * can't be enabled (for example, if the card doesn't actually
         * support I/O cycles).  Work around any such platforms by
         * enabling bits individually and simply ignoring any errors.
         */
        pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
                             EFI_PCI_IO_ATTRIBUTE_IO, NULL );
        pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
                             EFI_PCI_IO_ATTRIBUTE_MEMORY, NULL );
        pci_io->Attributes ( pci_io, EfiPciIoAttributeOperationEnable,
                             EFI_PCI_IO_ATTRIBUTE_BUS_MASTER, NULL );
 
        /* Populate PCI device */
        if ( ( rc = pci_read_config ( &efipci->pci ) ) != 0 ) {
                DBGC ( device, "EFIPCI " PCI_FMT " cannot read PCI "
                       "configuration: %s\n",
                       PCI_ARGS ( &efipci->pci ), strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References _EFI_PCI_IO_PROTOCOL::Attributes, busdevfn, DBGC, DBGCP, pci_device::dma, dma_init(), EEFI, EFI_HANDLE, efi_handle_name(), efi_open, EFI_PCI_IO_ATTRIBUTE_BUS_MASTER, EFI_PCI_IO_ATTRIBUTE_IO, EFI_PCI_IO_ATTRIBUTE_MEMORY, efi_pci_io_protocol_guid, efipci_dma_operations, EfiPciIoAttributeOperationEnable, _EFI_PCI_IO_PROTOCOL::GetLocation, efi_pci_device::io, NULL, efi_pci_device::pci, PCI_ARGS, PCI_BUSDEVFN, PCI_FMT, pci_init(), pci_read_config(), rc, and strerror().

Referenced by efi_bofm_start(), efi_bofm_supported(), efi_device_info_pci(), efipci_start(), and efipci_supported().

efipci_supported()

int efipci_supported ( EFI_HANDLE device )

static

Check to see if driver supports a device.

Parameters

device

EFI device handle

Return values

rc	Return status code

Definition at line 778 of file efi_pci.c.

                                                  {
        struct efi_pci_device efipci;
        uint8_t hdrtype;
        int rc;
 
        /* Get PCI device information */
        if ( ( rc = efipci_info ( device, &efipci ) ) != 0 )
                return rc;
 
        /* Do not attempt to drive bridges */
        hdrtype = efipci.pci.hdrtype;
        if ( ( hdrtype & PCI_HEADER_TYPE_MASK ) != PCI_HEADER_TYPE_NORMAL ) {
                DBGC ( device, "EFIPCI " PCI_FMT " type %02x is not type %02x\n",
                       PCI_ARGS ( &efipci.pci ), hdrtype,
                       PCI_HEADER_TYPE_NORMAL );
                return -ENOTTY;
        }
 
        /* Look for a driver */
        if ( ( rc = pci_find_driver ( &efipci.pci ) ) != 0 ) {
                DBGC ( device, "EFIPCI " PCI_FMT " (%04x:%04x class %06x) "
                       "has no driver\n", PCI_ARGS ( &efipci.pci ),
                       efipci.pci.vendor, efipci.pci.device,
                       efipci.pci.class );
                return rc;
        }
        DBGC ( device, "EFIPCI " PCI_FMT " (%04x:%04x class %06x) has driver "
               "\"%s\"\n", PCI_ARGS ( &efipci.pci ), efipci.pci.vendor,
               efipci.pci.device, efipci.pci.class, efipci.pci.id->name );
 
        return 0;
}

References pci_device::class, DBGC, pci_device::device, EFI_HANDLE, efipci_info(), ENOTTY, pci_device::hdrtype, pci_device::id, pci_device_id::name, efi_pci_device::pci, PCI_ARGS, pci_find_driver(), PCI_FMT, PCI_HEADER_TYPE_MASK, PCI_HEADER_TYPE_NORMAL, rc, and pci_device::vendor.

Referenced by __efi_driver().

efipci_exclude()

int efipci_exclude ( EFI_HANDLE device )

static

Exclude existing drivers.

Parameters

device

EFI device handle

Return values

rc	Return status code

Definition at line 817 of file efi_pci.c.

                                                {
        EFI_GUID *protocol = &efi_pci_io_protocol_guid;
        int rc;
 
        /* Exclude existing PCI I/O protocol drivers */
        if ( ( rc = efi_driver_exclude ( device, protocol ) ) != 0 ) {
                DBGC ( device, "EFIPCI %s could not exclude drivers: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                return rc;
        }
 
        return 0;
}

References DBGC, efi_driver_exclude(), EFI_HANDLE, efi_handle_name(), efi_pci_io_protocol_guid, protocol, rc, and strerror().

Referenced by __efi_driver().

efipci_start()

int efipci_start ( struct efi_device * efidev )

static

Attach driver to device.

Parameters

efidev

EFI device

Return values

rc	Return status code

Definition at line 837 of file efi_pci.c.

                                                      {
        EFI_HANDLE device = efidev->device;
        struct efi_pci_device *efipci;
        int rc;
 
        /* Allocate PCI device */
        efipci = zalloc ( sizeof ( *efipci ) );
        if ( ! efipci ) {
                rc = -ENOMEM;
                goto err_alloc;
        }
 
        /* Get PCI device information */
        if ( ( rc = efipci_info ( device, efipci ) ) != 0 )
                goto err_info;
 
        /* Open PCI I/O protocol */
        if ( ( rc = efi_open_by_driver ( device, &efi_pci_io_protocol_guid,
                                         &efipci->io ) ) != 0 ) {
                DBGC ( device, "EFIPCI %s could not open PCI device: %s\n",
                       efi_handle_name ( device ), strerror ( rc ) );
                DBGC_EFI_OPENERS ( device, device, &efi_pci_io_protocol_guid );
                goto err_open;
        }
 
        /* Find driver */
        if ( ( rc = pci_find_driver ( &efipci->pci ) ) != 0 ) {
                DBGC ( device, "EFIPCI " PCI_FMT " has no driver\n",
                       PCI_ARGS ( &efipci->pci ) );
                goto err_find_driver;
        }
 
        /* Mark PCI device as a child of the EFI device */
        efipci->pci.dev.parent = &efidev->dev;
        list_add ( &efipci->pci.dev.siblings, &efidev->dev.children );
 
        /* Probe driver */
        if ( ( rc = pci_probe ( &efipci->pci ) ) != 0 ) {
                DBGC ( device, "EFIPCI " PCI_FMT " could not probe driver "
                       "\"%s\": %s\n", PCI_ARGS ( &efipci->pci ),
                       efipci->pci.id->name, strerror ( rc ) );
                goto err_probe;
        }
        DBGC ( device, "EFIPCI " PCI_FMT " using driver \"%s\"\n",
               PCI_ARGS ( &efipci->pci ), efipci->pci.id->name );
 
        efidev_set_drvdata ( efidev, efipci );
        return 0;
 
        pci_remove ( &efipci->pci );
 err_probe:
        list_del ( &efipci->pci.dev.siblings );
 err_find_driver:
        efi_close_by_driver ( device, &efi_pci_io_protocol_guid );
 err_open:
 err_info:
        free ( efipci );
 err_alloc:
        return rc;
}

References device::children, DBGC, DBGC_EFI_OPENERS, efi_device::dev, pci_device::dev, efi_device::device, efi_close_by_driver(), EFI_HANDLE, efi_handle_name(), efi_open_by_driver, efi_pci_io_protocol_guid, efidev_set_drvdata(), efipci_info(), ENOMEM, free, pci_device::id, efi_pci_device::io, list_add, list_del, pci_device_id::name, device::parent, efi_pci_device::pci, PCI_ARGS, pci_find_driver(), PCI_FMT, pci_probe(), pci_remove(), rc, device::siblings, strerror(), and zalloc().

Referenced by __efi_driver().

efipci_stop()

void efipci_stop ( struct efi_device * efidev )

static

Detach driver from device.

Parameters

efidev

EFI device

Definition at line 903 of file efi_pci.c.

                                                      {
        struct efi_pci_device *efipci = efidev_get_drvdata ( efidev );
        EFI_HANDLE device = efidev->device;
 
        pci_remove ( &efipci->pci );
        list_del ( &efipci->pci.dev.siblings );
        assert ( efipci->pci.dma.mapped == 0 );
        assert ( efipci->pci.dma.allocated == 0 );
        efi_close_by_driver ( device, &efi_pci_io_protocol_guid );
        free ( efipci );
}

References dma_device::allocated, assert, pci_device::dev, efi_device::device, pci_device::dma, efi_close_by_driver(), EFI_HANDLE, efi_pci_io_protocol_guid, efidev_get_drvdata(), free, list_del, dma_device::mapped, efi_pci_device::pci, pci_remove(), and device::siblings.

Referenced by __efi_driver().

__efi_driver()

struct efi_driver efipci_driver __efi_driver

(

EFI_DRIVER_HARDWARE

)

EFI PCI driver.

References __efi_driver, EFI_DRIVER_HARDWARE, efipci_exclude(), efipci_start(), efipci_stop(), and efipci_supported().

Variable Documentation

efipci_dma_operations

struct dma_operations efipci_dma_operations

static

Initial value:

= {
        .map = efipci_dma_map,
        .unmap = efipci_dma_unmap,
        .alloc = efipci_dma_alloc,
        .free = efipci_dma_free,
        .umalloc = efipci_dma_alloc,
        .ufree = efipci_dma_free,
        .set_mask = efipci_dma_set_mask,
}

EFI PCI DMA operations.

Definition at line 687 of file efi_pci.c.

                                                     {
        .map = efipci_dma_map,
        .unmap = efipci_dma_unmap,
        .alloc = efipci_dma_alloc,
        .free = efipci_dma_free,
        .umalloc = efipci_dma_alloc,
        .ufree = efipci_dma_free,
        .set_mask = efipci_dma_set_mask,
};

Referenced by efipci_info().