efi_pci.c File Reference

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

#include <stdlib.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)
static int	efipci_root_match (struct pci_device *pci, EFI_HANDLE handle, EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root)
	Check for a matching PCI root bridge I/O protocol. More...
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. More...
static void	efipci_root_close (EFI_HANDLE handle)
	Close EFI PCI root bridge I/O protocol. More...
static unsigned long	efipci_address (struct pci_device *pci, unsigned long location)
	Calculate EFI PCI configuration space address. More...
int	efipci_read (struct pci_device *pci, unsigned long location, void *value)
	Read from PCI configuration space. More...
int	efipci_write (struct pci_device *pci, unsigned long location, unsigned long value)
	Write to PCI configuration space. More...
void *	efipci_ioremap (struct pci_device *pci, unsigned long bus_addr, size_t len)
	Map PCI bus address as an I/O address. More...
	PROVIDE_PCIAPI_INLINE (efi, pci_num_bus)
	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)
static int	efipci_dma_map (struct dma_device *dma, struct dma_mapping *map, physaddr_t addr, size_t len, int flags)
	Map buffer for DMA. More...
static void	efipci_dma_unmap (struct dma_device *dma, struct dma_mapping *map)
	Unmap buffer. More...
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. More...
static void	efipci_dma_free (struct dma_device *dma, struct dma_mapping *map, void *addr, size_t len)
	Unmap and free DMA-coherent buffer. More...
static userptr_t	efipci_dma_umalloc (struct dma_device *dma, struct dma_mapping *map, size_t len, size_t align)
	Allocate and map DMA-coherent buffer from external (user) memory. More...
static void	efipci_dma_ufree (struct dma_device *dma, struct dma_mapping *map, userptr_t addr, size_t len)
	Unmap and free DMA-coherent buffer from external (user) memory. More...
static void	efipci_dma_set_mask (struct dma_device *dma, physaddr_t mask)
	Set addressable space mask. More...
int	efipci_open (EFI_HANDLE device, UINT32 attributes, struct efi_pci_device *efipci)
	Open EFI PCI device. More...
void	efipci_close (EFI_HANDLE device)
	Close EFI PCI device. More...
int	efipci_info (EFI_HANDLE device, struct efi_pci_device *efipci)
	Get EFI PCI device information. More...
static int	efipci_supported (EFI_HANDLE device)
	Check to see if driver supports a device. More...
static int	efipci_start (struct efi_device *efidev)
	Attach driver to device. More...
static void	efipci_stop (struct efi_device *efidev)
	Detach driver from device. More...
struct efi_driver efipci_driver	__efi_driver (EFI_DRIVER_NORMAL)
	EFI PCI driver. More...

Variables
static struct dma_operations	efipci_dma_operations
	EFI PCI DMA operations. More...

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 43 of file efi_pci.c.

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 46 of file efi_pci.c.

EEFI_PCI_NOT_PCI

#define EEFI_PCI_NOT_PCI   __einfo_error ( EINFO_EEFI_PCI_NOT_PCI )

Definition at line 49 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 50 of file efi_pci.c.

EEFI_PCI_IN_USE

#define EEFI_PCI_IN_USE   __einfo_error ( EINFO_EEFI_PCI_IN_USE )

Definition at line 53 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 54 of file efi_pci.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

efipci_root_match()

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

static

Check for a matching PCI root bridge I/O protocol.

Parameters

pci	PCI device
handle	EFI PCI root bridge handle
root	EFI PCI root bridge I/O protocol

Return values

rc	Return status code

Definition at line 73 of file efi_pci.c.

                                                                       {
        union {
                union acpi_resource *res;
                void *raw;
        } u;
        unsigned int segment = PCI_SEG ( pci->busdevfn );
        unsigned int bus = PCI_BUS ( pci->busdevfn );
        unsigned int start;
        unsigned int end;
        unsigned int tag;
        EFI_STATUS efirc;
        int rc;

        /* Check segment number */
        if ( root->SegmentNumber != segment )
                return -ENOENT;

        /* Get ACPI resource descriptors */
        if ( ( efirc = root->Configuration ( root, &u.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;
        }

        /* Assume success if no bus number range descriptors are found */
        rc = 0;

        /* 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 bus number range descriptor */
                if ( tag != ACPI_QWORD_ADDRESS_SPACE_RESOURCE )
                        continue;
                if ( u.res->qword.type != ACPI_ADDRESS_TYPE_BUS )
                        continue;

                /* Check for a matching bus number */
                start = le64_to_cpu ( u.res->qword.min );
                end = ( start + le64_to_cpu ( u.res->qword.len ) );
                if ( ( bus >= start ) && ( bus < end ) )
                        return 0;

                /* We have seen at least one non-matching range
                 * descriptor, so assume failure unless we find a
                 * subsequent match.
                 */
                rc = -ENOENT;
        }

        return rc;
}

References ACPI_ADDRESS_TYPE_BUS, ACPI_END_RESOURCE, ACPI_QWORD_ADDRESS_SPACE_RESOURCE, acpi_resource_next(), acpi_resource_tag(), bus, pci_device::busdevfn, DBGC, EEFI, efi_handle_name(), end, ENOENT, handle, le64_to_cpu, PCI_ARGS, PCI_BUS, PCI_FMT, PCI_SEG, raw, rc, root, segment, start, strerror(), tag, and u.

Referenced by efipci_root_open().

efipci_root_open()

static 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.

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 137 of file efi_pci.c.

                                                                       {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        EFI_HANDLE *handles;
        UINTN num_handles;
        union {
                void *interface;
                EFI_PCI_ROOT_BRIDGE_IO_PROTOCOL *root;
        } u;
        EFI_STATUS efirc;
        UINTN i;
        int rc;

        /* Enumerate all 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;
        }

        /* Look for matching root bridge I/O protocol */
        for ( i = 0 ; i < num_handles ; i++ ) {
                *handle = handles[i];
                if ( ( efirc = bs->OpenProtocol ( *handle,
                                &efi_pci_root_bridge_io_protocol_guid,
                                &u.interface, efi_image_handle, *handle,
                                EFI_OPEN_PROTOCOL_GET_PROTOCOL ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( pci, "EFIPCI " PCI_FMT " cannot open %s: %s\n",
                               PCI_ARGS ( pci ), efi_handle_name ( *handle ),
                               strerror ( rc ) );
                        continue;
                }
                if ( efipci_root_match ( pci, *handle, u.root ) == 0 ) {
                        *root = u.root;
                        bs->FreePool ( handles );
                        return 0;
                }
                bs->CloseProtocol ( *handle,
                                    &efi_pci_root_bridge_io_protocol_guid,
                                    efi_image_handle, *handle );
        }
        DBGC ( pci, "EFIPCI " PCI_FMT " found no root bridge\n",
               PCI_ARGS ( pci ) );
        rc = -ENOENT;

        bs->FreePool ( handles );
 err_locate:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, ByProtocol, EFI_BOOT_SERVICES::CloseProtocol, DBGC, EEFI, efi_handle_name(), efi_image_handle, EFI_OPEN_PROTOCOL_GET_PROTOCOL, efi_pci_root_bridge_io_protocol_guid, efi_systab, efipci_root_match(), ENOENT, EFI_BOOT_SERVICES::FreePool, handle, EFI_BOOT_SERVICES::LocateHandleBuffer, NULL, EFI_BOOT_SERVICES::OpenProtocol, PCI_ARGS, PCI_FMT, rc, root, strerror(), and u.

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

efipci_root_close()

static void efipci_root_close ( EFI_HANDLE  handle )

static

Close EFI PCI root bridge I/O protocol.

Parameters

handle

EFI PCI root bridge handle

Definition at line 196 of file efi_pci.c.

                                                    {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;

        /* Close protocol */
        bs->CloseProtocol ( handle, &efi_pci_root_bridge_io_protocol_guid,
                            efi_image_handle, handle );
}

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, efi_image_handle, efi_pci_root_bridge_io_protocol_guid, efi_systab, and handle.

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

efipci_address()

static 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 211 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 228 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 )
                goto err_root;

        /* 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 ) );
                goto err_read;
        }

 err_read:
        efipci_root_close ( handle );
 err_root:
        return rc;
}

References DBGC, EEFI, efipci_address(), EFIPCI_OFFSET, efipci_root_close(), 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 264 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 )
                goto err_root;

        /* 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 ) );
                goto err_write;
        }

 err_write:
        efipci_root_close ( handle );
 err_root:
        return rc;
}

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

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 299 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:
        efipci_root_close ( handle );
 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, efipci_root_close(), efipci_root_open(), end, handle, ioremap(), le64_to_cpu, len, offset, PCI_ARGS, PCI_FMT, raw, rc, root, start, strerror(), tag, and u.

PROVIDE_PCIAPI_INLINE() [1/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_num_bus
	)

PROVIDE_PCIAPI_INLINE() [2/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_byte
	)

PROVIDE_PCIAPI_INLINE() [3/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_word
	)

PROVIDE_PCIAPI_INLINE() [4/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_read_config_dword
	)

PROVIDE_PCIAPI_INLINE() [5/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_byte
	)

PROVIDE_PCIAPI_INLINE() [6/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_word
	)

PROVIDE_PCIAPI_INLINE() [7/7]

PROVIDE_PCIAPI_INLINE	(	efi	,
		pci_write_config_dword
	)

PROVIDE_PCIAPI()

PROVIDE_PCIAPI	(	efi	,
		pci_ioremap	,
		efipci_ioremap
	)

efipci_dma_map()

static int efipci_dma_map ( struct dma_device *  dma, struct dma_mapping *  map, physaddr_t  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 391 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;
        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) */
        count = len;
        if ( len ) {
                if ( ( efirc = pci_io->Map ( pci_io, op, phys_to_virt ( addr ),
                                             &count, &bus, &mapping ) ) != 0 ) {
                        rc = -EEFI ( efirc );
                        DBGC ( pci, "EFIPCI " PCI_FMT " cannot map %08lx+%zx: "
                               "%s\n", PCI_ARGS ( pci ), addr, len,
                               strerror ( rc ) );
                        goto err_map;
                }
        } else {
                bus = addr;
                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 "
                       "%08lx+%zx\n", PCI_ARGS ( pci ), addr, len );
                rc = -ENOTSUP;
                goto err_len;
        }

        /* Populate mapping */
        map->dma = dma;
        map->offset = ( bus - addr );
        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_mapping::dma, pci_device::dma, dma(), DMA_RX, DMA_TX, EEFI, EfiPciIoOperationBusMasterCommonBuffer, EfiPciIoOperationBusMasterRead, EfiPciIoOperationBusMasterWrite, ENOTSUP, flags, efi_pci_device::io, len, map, _EFI_PCI_IO_PROTOCOL::Map, NULL, dma_mapping::offset, op, efi_pci_device::pci, PCI_ARGS, PCI_FMT, phys_to_virt(), rc, strerror(), dma_mapping::token, _EFI_PCI_IO_PROTOCOL::Unmap, and VOID.

Referenced by efipci_dma_alloc().

efipci_dma_unmap()

static void efipci_dma_unmap ( struct dma_device *  dma, struct dma_mapping *  map  )

static

Unmap buffer.

Parameters

dma	DMA device
map	DMA mapping

Definition at line 473 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 container_of, DBG_LOG, dma_mapping::dma, pci_device::dma, dma(), efi_pci_device::io, map, NULL, dma_mapping::offset, efi_pci_device::pci, dma_mapping::token, and _EFI_PCI_IO_PROTOCOL::Unmap.

Referenced by efipci_dma_alloc(), and efipci_dma_free().

efipci_dma_alloc()

static 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 502 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;
        }

        /* Map buffer */
        if ( ( rc = efipci_dma_map ( dma, map, virt_to_phys ( 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 );
 err_map:
        pci_io->FreeBuffer ( pci_io, pages, addr );
 err_alloc:
        return NULL;
}

References addr, AllocateAnyPages, _EFI_PCI_IO_PROTOCOL::AllocateBuffer, container_of, DBG_LOG, DBGC, pci_device::dma, 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, NULL, efi_pci_device::pci, PCI_ARGS, PCI_FMT, rc, strerror(), virt_to_phys(), and VOID.

Referenced by efipci_dma_umalloc().

efipci_dma_free()

static 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 554 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 );

        /* 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, pci_device::dma, dma(), EFI_PAGE_SIZE, efipci_dma_unmap(), _EFI_PCI_IO_PROTOCOL::FreeBuffer, efi_pci_device::io, len, map, and efi_pci_device::pci.

Referenced by efipci_dma_ufree().

efipci_dma_umalloc()

static userptr_t efipci_dma_umalloc ( struct dma_device *  dma, struct dma_mapping *  map, size_t  len, size_t  align  )

static

Allocate and map DMA-coherent buffer from external (user) memory.

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 584 of file efi_pci.c.

                                                                 {
        void *addr;

        addr = efipci_dma_alloc ( dma, map, len, align );
        return virt_to_user ( addr );
}

References addr, align, dma(), efipci_dma_alloc(), len, map, and virt_to_user().

efipci_dma_ufree()

static void efipci_dma_ufree ( struct dma_device *  dma, struct dma_mapping *  map, userptr_t  addr, size_t  len  )

static

Unmap and free DMA-coherent buffer from external (user) memory.

Parameters

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

Definition at line 601 of file efi_pci.c.

                                                            {

        efipci_dma_free ( dma, map, user_to_virt ( addr, 0 ), len );
}

References addr, dma(), efipci_dma_free(), len, map, and user_to_virt().

efipci_dma_set_mask()

static 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 613 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, attrs, container_of, DBGC, pci_device::dma, 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_open()

int efipci_open	(	EFI_HANDLE	device,
		UINT32	attributes,
		struct efi_pci_device *	efipci
	)

Open EFI PCI device.

Parameters

device	EFI device handle
attributes	Protocol opening attributes
efipci	EFI PCI device to fill in

Return values

rc	Return status code

Definition at line 665 of file efi_pci.c.

                                                  {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;
        union {
                EFI_PCI_IO_PROTOCOL *pci_io;
                void *interface;
        } 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 ( ( efirc = bs->OpenProtocol ( device, &efi_pci_io_protocol_guid,
                                          &pci_io.interface, efi_image_handle,
                                          device, attributes ) ) != 0 ) {
                rc = -EEFI_PCI ( efirc );
                DBGCP ( device, "EFIPCI %s cannot open PCI protocols: %s\n",
                        efi_handle_name ( device ), strerror ( rc ) );
                goto err_open_protocol;
        }
        efipci->io = pci_io.pci_io;

        /* Get PCI bus:dev.fn address */
        if ( ( efirc = pci_io.pci_io->GetLocation ( pci_io.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 ) );
                goto err_get_location;
        }
        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.pci_io->Attributes ( pci_io.pci_io,
                                    EfiPciIoAttributeOperationEnable,
                                    EFI_PCI_IO_ATTRIBUTE_IO, NULL );
        pci_io.pci_io->Attributes ( pci_io.pci_io,
                                    EfiPciIoAttributeOperationEnable,
                                    EFI_PCI_IO_ATTRIBUTE_MEMORY, NULL );
        pci_io.pci_io->Attributes ( pci_io.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 ) );
                goto err_pci_read_config;
        }

        return 0;

 err_pci_read_config:
 err_get_location:
        bs->CloseProtocol ( device, &efi_pci_io_protocol_guid,
                            efi_image_handle, device );
 err_open_protocol:
        return rc;
}

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, DBGC, DBGCP, pci_device::dma, dma_init(), EEFI, EEFI_PCI, efi_handle_name(), efi_image_handle, EFI_PCI_IO_ATTRIBUTE_BUS_MASTER, EFI_PCI_IO_ATTRIBUTE_IO, EFI_PCI_IO_ATTRIBUTE_MEMORY, efi_pci_io_protocol_guid, efi_systab, efipci_dma_operations, EfiPciIoAttributeOperationEnable, efi_pci_device::io, NULL, EFI_BOOT_SERVICES::OpenProtocol, efi_pci_device::pci, PCI_ARGS, PCI_BUSDEVFN, PCI_FMT, pci_init(), pci_read_config(), rc, and strerror().

Referenced by efi_bofm_start(), efipci_info(), and efipci_start().

efipci_close()

void efipci_close

(

EFI_HANDLE

device

)

Close EFI PCI device.

Parameters

device

EFI device handle

Definition at line 742 of file efi_pci.c.

                                        {
        EFI_BOOT_SERVICES *bs = efi_systab->BootServices;

        bs->CloseProtocol ( device, &efi_pci_io_protocol_guid,
                            efi_image_handle, device );
}

References EFI_SYSTEM_TABLE::BootServices, EFI_BOOT_SERVICES::CloseProtocol, efi_image_handle, efi_pci_io_protocol_guid, and efi_systab.

Referenced by efi_bofm_start(), efipci_info(), efipci_start(), and efipci_stop().

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 756 of file efi_pci.c.

                                                                     {
        int rc;

        /* Open PCI device, if possible */
        if ( ( rc = efipci_open ( device, EFI_OPEN_PROTOCOL_GET_PROTOCOL,
                                  efipci ) ) != 0 )
                return rc;

        /* Close PCI device */
        efipci_close ( device );

        return 0;
}

References EFI_OPEN_PROTOCOL_GET_PROTOCOL, efipci_close(), efipci_open(), and rc.

Referenced by efi_bofm_supported(), efi_pci_info(), and efipci_supported().

efipci_supported()

static 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 783 of file efi_pci.c.

                                                  {
        struct efi_pci_device efipci;
        int rc;

        /* Get PCI device information */
        if ( ( rc = efipci_info ( device, &efipci ) ) != 0 )
                return rc;

        /* 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, efipci_info(), pci_device::id, pci_device_id::name, efi_pci_device::pci, PCI_ARGS, pci_find_driver(), PCI_FMT, rc, and pci_device::vendor.

efipci_start()

static 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 812 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;
        }

        /* Open PCI device */
        if ( ( rc = efipci_open ( device, ( EFI_OPEN_PROTOCOL_BY_DRIVER |
                                            EFI_OPEN_PROTOCOL_EXCLUSIVE ),
                                  efipci ) ) != 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:
        efipci_close ( device );
 err_open:
        free ( efipci );
 err_alloc:
        return rc;
}

References device::children, DBGC, DBGC_EFI_OPENERS, efi_device::dev, pci_device::dev, efi_device::device, efi_handle_name(), EFI_OPEN_PROTOCOL_BY_DRIVER, EFI_OPEN_PROTOCOL_EXCLUSIVE, efi_pci_io_protocol_guid, efidev_set_drvdata(), efipci_close(), efipci_open(), ENOMEM, free, pci_device::id, 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().

efipci_stop()

static void efipci_stop ( struct efi_device *  efidev )

static

Detach driver from device.

Parameters

efidev

EFI device

Definition at line 874 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 );
        efipci_close ( device );
        free ( efipci );
}

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

__efi_driver()

struct efi_driver efipci_driver __efi_driver

(

EFI_DRIVER_NORMAL

)

EFI PCI driver.

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_umalloc,
        .ufree = efipci_dma_ufree,
        .set_mask = efipci_dma_set_mask,
}

EFI PCI DMA operations.

Definition at line 640 of file efi_pci.c.

Referenced by efipci_open().