ecam.c File Reference

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

#include <errno.h>
#include <ipxe/uaccess.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. More...
static void	ecam_discover (uint32_t busdevfn, struct pci_range *range)
	Find next PCI bus:dev.fn address range in system. More...
static int	ecam_access (struct pci_device *pci)
	Access configuration space for PCI device. More...
int	ecam_read (struct pci_device *pci, unsigned int location, void *value)
	Read from PCI configuration space. More...
int	ecam_write (struct pci_device *pci, unsigned int location, unsigned long value)
	Write to PCI configuration space. More...
	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)

Variables
static struct ecam_mapping	ecam
	Cached mapped ECAM allocation. More...
struct pci_api	ecam_api = PCIAPI_RUNTIME ( ecam )

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()

static 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_allocation tmp;
        unsigned int best = 0;
        unsigned int offset;
        unsigned int count;
        unsigned int index;
        userptr_t mcfg;
        uint32_t length;
        uint32_t start;

        /* Return empty range on error */
        range->count = 0;

        /* Locate MCFG table */
        mcfg = acpi_table ( ECAM_SIGNATURE, 0 );
        if ( ! mcfg ) {
                DBGC ( &ecam, "ECAM found no MCFG table\n" );
                return -ENOTSUP;
        }

        /* Get length of table */
        copy_from_user ( &length, mcfg,
                         offsetof ( struct ecam_table, acpi.length ),
                         sizeof ( length ) );

        /* Iterate over allocations */
        for ( offset = offsetof ( struct ecam_table, alloc ) ;
              ( offset + sizeof ( tmp ) ) <= le32_to_cpu ( length ) ;
              offset += sizeof ( tmp ) ) {

                /* Read allocation */
                copy_from_user ( &tmp, mcfg, offset, sizeof ( tmp ) );
                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, acpi_table(), busdevfn, copy_from_user(), count, pci_range::count, DBGC, DBGC2, ecam, ECAM_SIGNATURE, ENOENT, ENOTSUP, index, le16_to_cpu, le32_to_cpu, le64_to_cpu, length, memcpy(), offset, offsetof, PCI_BUSDEVFN, range, start, pci_range::start, and tmp.

Referenced by ecam_access(), and ecam_discover().

ecam_discover()

static 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 111 of file ecam.c.

                                                                         {

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

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

ecam_access()

static 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 123 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 ecam_mapping::alloc, ecam_allocation::base, base, pci_device::busdevfn, pci_range::count, DBGC, ecam, ecam_find(), ECAM_SIZE, ecam_allocation::end, ENODEV, ENOENT, ERANGE, ioremap(), iounmap(), le16_to_cpu, le64_to_cpu, len, NULL, PCI_ARGS, PCI_BUSDEVFN, PCI_FMT, ecam_mapping::range, ecam_mapping::rc, rc, ecam_mapping::regs, ecam_allocation::segment, pci_range::start, ecam_allocation::start, 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 196 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(), ecam_mapping::range, rc, readb(), readl(), readw(), ecam_mapping::regs, pci_range::start, value, and where.

Referenced by ecam_write().

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 238 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(), ecam_mapping::range, rc, ecam_mapping::regs, pci_range::start, value, where, writeb(), writel(), and writew.

PROVIDE_PCIAPI()

PROVIDE_PCIAPI	(	ecam	,
		pci_discover	,
		ecam_discover
	)

PROVIDE_PCIAPI_INLINE() [1/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_byte
	)

PROVIDE_PCIAPI_INLINE() [2/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_word
	)

PROVIDE_PCIAPI_INLINE() [3/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_read_config_dword
	)

PROVIDE_PCIAPI_INLINE() [4/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_byte
	)

PROVIDE_PCIAPI_INLINE() [5/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_word
	)

PROVIDE_PCIAPI_INLINE() [6/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_write_config_dword
	)

PROVIDE_PCIAPI_INLINE() [7/7]

PROVIDE_PCIAPI_INLINE	(	ecam	,
		pci_ioremap
	)

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(), and ecam_write().

ecam_api

struct pci_api ecam_api = PCIAPI_RUNTIME ( ecam )

Definition at line 288 of file ecam.c.

Referenced by pcicloud_init().