ecam.c File Reference

PCI Enhanced Configuration Access Mechanism (ECAM) More...

#include <string.h>
#include <errno.h>
#include <ipxe/ecam.h>

Go to the source code of this file.

Functions
	FILE_LICENCE (GPL2_OR_LATER_OR_UBDL)
static int	ecam_find (uint32_t busdevfn, struct pci_range *range, struct ecam_allocation *alloc)
	Find lowest ECAM allocation not below a given PCI bus:dev.fn address.
static void	ecam_discover (uint32_t busdevfn, struct pci_range *range)
	Find next PCI bus:dev.fn address range in system.
static int	ecam_access (struct pci_device *pci)
	Access configuration space for PCI device.
int	ecam_read (struct pci_device *pci, unsigned int location, void *value)
	Read from PCI configuration space.
int	ecam_write (struct pci_device *pci, unsigned int location, unsigned long value)
	Write to PCI configuration space.
	PROVIDE_PCIAPI_INLINE (ecam, pci_can_probe)
	PROVIDE_PCIAPI (ecam, pci_discover, ecam_discover)
	PROVIDE_PCIAPI_INLINE (ecam, pci_read_config_byte)
	PROVIDE_PCIAPI_INLINE (ecam, pci_read_config_word)
	PROVIDE_PCIAPI_INLINE (ecam, pci_read_config_dword)
	PROVIDE_PCIAPI_INLINE (ecam, pci_write_config_byte)
	PROVIDE_PCIAPI_INLINE (ecam, pci_write_config_word)
	PROVIDE_PCIAPI_INLINE (ecam, pci_write_config_dword)
	PROVIDE_PCIAPI_INLINE (ecam, pci_ioremap)
	PROVIDE_PCIAPI_RUNTIME (ecam, PCIAPI_PRIORITY_ECAM)

Variables
static struct ecam_mapping	ecam
	Cached mapped ECAM allocation.

Detailed Description

PCI Enhanced Configuration Access Mechanism (ECAM)

Definition in file ecam.c.

Function Documentation

FILE_LICENCE()

FILE_LICENCE

(

GPL2_OR_LATER_OR_UBDL

)

ecam_find()

int ecam_find ( uint32_t busdevfn, struct pci_range * range, struct ecam_allocation * alloc )

static

Find lowest ECAM allocation not below a given PCI bus:dev.fn address.

Parameters

busdevfn	PCI bus:dev.fn address
range	PCI device address range to fill in
alloc	ECAM allocation to fill in, or NULL

Return values

rc	Return status code

Definition at line 47 of file ecam.c.

                                                       {
        struct ecam_table *mcfg;
        struct ecam_allocation *tmp;
        unsigned int best = 0;
        unsigned int count;
        unsigned int index;
        unsigned int i;
        uint32_t start;
 
        /* Return empty range on error */
        range->count = 0;
 
        /* Locate MCFG table */
        mcfg = container_of ( acpi_table ( ECAM_SIGNATURE, 0 ),
                              struct ecam_table, acpi );
        if ( ! mcfg ) {
                DBGC ( &ecam, "ECAM found no MCFG table\n" );
                return -ENOTSUP;
        }
 
        /* Iterate over allocations */
        for ( i = 0 ; ( offsetof ( typeof ( *mcfg ), alloc[ i + 1 ] ) <=
                        le32_to_cpu ( mcfg->acpi.length ) ) ; i++ ) {
 
                /* Read allocation */
                tmp = &mcfg->alloc[i];
                DBGC2 ( &ecam, "ECAM %04x:[%02x-%02x] has base %08llx\n",
                        le16_to_cpu ( tmp->segment ), tmp->start, tmp->end,
                        ( ( unsigned long long ) le64_to_cpu ( tmp->base ) ) );
                start = PCI_BUSDEVFN ( le16_to_cpu ( tmp->segment ),
                                       tmp->start, 0, 0 );
                count = PCI_BUSDEVFN ( 0, ( tmp->end - tmp->start + 1 ), 0, 0 );
 
                /* Check for a matching or new closest allocation */
                index = ( busdevfn - start );
                if ( ( index < count ) || ( index > best ) ) {
                        if ( alloc )
                                memcpy ( alloc, tmp, sizeof ( *alloc ) );
                        range->start = start;
                        range->count = count;
                        best = index;
                }
 
                /* Stop if this range contains the target bus:dev.fn address */
                if ( index < count )
                        return 0;
        }
 
        return ( best ? 0 : -ENOENT );
}

References acpi, ecam_table::acpi, acpi_table(), ecam_table::alloc, busdevfn, container_of, count, DBGC, DBGC2, ecam, ECAM_SIGNATURE, ENOENT, ENOTSUP, index, le16_to_cpu, le32_to_cpu, le64_to_cpu, acpi_header::length, memcpy(), offsetof, PCI_BUSDEVFN, range, start, tmp, and typeof().

Referenced by ecam_access(), and ecam_discover().

ecam_discover()

void ecam_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 105 of file ecam.c.

                                                                         {
 
        /* Find new range, if any */
        ecam_find ( busdevfn, range, NULL );
}

References busdevfn, ecam_find(), NULL, and range.

Referenced by PROVIDE_PCIAPI().

ecam_access()

int ecam_access ( struct pci_device * pci )

static

Access configuration space for PCI device.

Parameters

pci	PCI device

Return values

rc	Return status code

Definition at line 117 of file ecam.c.

                                                  {
        uint64_t base;
        size_t len;
        int rc;
 
        /* Reuse mapping if possible */
        if ( ( pci->busdevfn - ecam.range.start ) < ecam.range.count )
                return ecam.rc;
 
        /* Clear any existing mapping */
        if ( ecam.regs ) {
                iounmap ( ecam.regs );
                ecam.regs = NULL;
        }
 
        /* Find allocation for this PCI device */
        if ( ( rc = ecam_find ( pci->busdevfn, &ecam.range,
                                &ecam.alloc ) ) != 0 ) {
                DBGC ( &ecam, "ECAM found no allocation for " PCI_FMT ": %s\n",
                       PCI_ARGS ( pci ), strerror ( rc ) );
                goto err_find;
        }
        if ( ecam.range.start > pci->busdevfn ) {
                DBGC ( &ecam, "ECAM found no allocation for " PCI_FMT "\n",
                       PCI_ARGS ( pci ) );
                rc = -ENOENT;
                goto err_find;
        }
 
        /* Map configuration space for this allocation */
        base = le64_to_cpu ( ecam.alloc.base );
        base += ( ecam.alloc.start * ECAM_SIZE * PCI_BUSDEVFN ( 0, 1, 0, 0 ) );
        len = ( ecam.range.count * ECAM_SIZE );
        if ( base != ( ( unsigned long ) base ) ) {
                DBGC ( &ecam, "ECAM %04x:[%02x-%02x] could not map "
                       "[%08llx,%08llx) outside CPU range\n",
                       le16_to_cpu ( ecam.alloc.segment ), ecam.alloc.start,
                       ecam.alloc.end, base, ( base + len ) );
                rc = -ERANGE;
                goto err_range;
        }
        ecam.regs = ioremap ( base, len );
        if ( ! ecam.regs ) {
                DBGC ( &ecam, "ECAM %04x:[%02x-%02x] could not map "
                       "[%08llx,%08llx)\n", le16_to_cpu ( ecam.alloc.segment ),
                       ecam.alloc.start, ecam.alloc.end, base, ( base + len ) );
                rc = -ENODEV;
                goto err_ioremap;
        }
 
        /* Populate cached mapping */
        DBGC ( &ecam, "ECAM %04x:[%02x-%02x] mapped [%08llx,%08llx) -> %p\n",
               le16_to_cpu ( ecam.alloc.segment ), ecam.alloc.start,
               ecam.alloc.end, base, ( base + len ), ecam.regs );
        ecam.rc = 0;
        return 0;
 
        iounmap ( ecam.regs );
 err_ioremap:
 err_range:
 err_find:
        ecam.rc = rc;
        return rc;
}

References base, pci_device::busdevfn, DBGC, ecam, ecam_find(), ECAM_SIZE, ENODEV, ENOENT, ERANGE, ioremap(), iounmap(), le16_to_cpu, le64_to_cpu, len, NULL, PCI_ARGS, PCI_BUSDEVFN, PCI_FMT, rc, and strerror().

Referenced by ecam_read(), and ecam_write().

ecam_read()

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

Read from PCI configuration space.

Parameters

pci	PCI device
location	Offset and length within PCI configuration space
value	Value read

Return values

rc	Return status code

Definition at line 190 of file ecam.c.

                                                                             {
        unsigned int where = ECAM_WHERE ( location );
        unsigned int len = ECAM_LEN ( location );
        unsigned int index;
        void *addr;
        int rc;
 
        /* Return all-ones on error */
        memset ( value, 0xff, len );
 
        /* Access configuration space */
        if ( ( rc = ecam_access ( pci ) ) != 0 )
                return rc;
 
        /* Read from address */
        index = ( pci->busdevfn - ecam.range.start );
        addr = ( ecam.regs + ( index * ECAM_SIZE ) + where );
        switch ( len ) {
        case 4:
                *( ( uint32_t *) value ) = readl ( addr );
                break;
        case 2:
                *( ( uint16_t *) value ) = readw ( addr );
                break;
        case 1:
                *( ( uint8_t *) value ) = readb ( addr );
                break;
        default:
                assert ( 0 );
        }
 
        return 0;
}

References addr, assert, pci_device::busdevfn, ecam, ecam_access(), ECAM_LEN, ECAM_SIZE, ECAM_WHERE, index, len, memset(), rc, readb, readl, readw, value, and where.

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

ecam_write()

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

Write to PCI configuration space.

Parameters

pci	PCI device
location	Offset and length within PCI configuration space
value	Value to write

Return values

rc	Return status code

Definition at line 232 of file ecam.c.

                                       {
        unsigned int where = ECAM_WHERE ( location );
        unsigned int len = ECAM_LEN ( location );
        unsigned int index;
        void *addr;
        int rc;
 
        /* Access configuration space */
        if ( ( rc = ecam_access ( pci ) ) != 0 )
                return rc;
 
        /* Write to address */
        index = ( pci->busdevfn - ecam.range.start );
        addr = ( ecam.regs + ( index * ECAM_SIZE ) + where );
        switch ( len ) {
        case 4:
                writel ( value, addr );
                break;
        case 2:
                writew ( value, addr );
                break;
        case 1:
                writeb ( value, addr );
                break;
        default:
                assert ( 0 );
        }
 
        /* Read from address, to guarantee completion of the write
         *
         * PCIe configuration space registers may not have read side
         * effects.  Reading back is therefore always safe to do, and
         * guarantees that the write has reached the device.
         */
        mb();
        ecam_read ( pci, location, &value );
 
        return 0;
}

References addr, assert, pci_device::busdevfn, ecam, ecam_access(), ECAM_LEN, ecam_read(), ECAM_SIZE, ECAM_WHERE, index, len, mb(), rc, value, where, writeb, writel, and writew.

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

PROVIDE_PCIAPI_INLINE() [1/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_can_probe	)

References ecam, and pci_can_probe().

PROVIDE_PCIAPI()

PROVIDE_PCIAPI	(	ecam	,
		pci_discover	,
		ecam_discover	)

References ecam, ecam_discover(), and pci_discover().

PROVIDE_PCIAPI_INLINE() [2/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_byte	)

References ecam, and pci_read_config_byte().

PROVIDE_PCIAPI_INLINE() [3/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_word	)

References ecam, and pci_read_config_word().

PROVIDE_PCIAPI_INLINE() [4/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_dword	)

References ecam, and pci_read_config_dword().

PROVIDE_PCIAPI_INLINE() [5/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_byte	)

References ecam, and pci_write_config_byte().

PROVIDE_PCIAPI_INLINE() [6/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_word	)

References ecam, and pci_write_config_word().

PROVIDE_PCIAPI_INLINE() [7/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_dword	)

References ecam, and pci_write_config_dword().

PROVIDE_PCIAPI_INLINE() [8/8]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_ioremap	)

References ecam, and pci_ioremap().

PROVIDE_PCIAPI_RUNTIME()

PROVIDE_PCIAPI_RUNTIME	(	ecam	,
		PCIAPI_PRIORITY_ECAM	)

References ecam, and PCIAPI_PRIORITY_ECAM.

Variable Documentation

ecam

struct ecam_mapping ecam

static

Cached mapped ECAM allocation.

Definition at line 37 of file ecam.c.

Referenced by ecam_access(), ecam_find(), ecam_read(), ecam_write(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PCIAPI_INLINE(), PROVIDE_PCIAPI(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_INLINE(), PROVIDE_PCIAPI_RUNTIME(), and PROVIDE_REQUIRING_SYMBOL().