rte_pci.h

Go to the documentation of this file.

/*-
 *   BSD LICENSE
 *
 *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
 *   Copyright 2013-2014 6WIND S.A.
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following conditions
 *   are met:
 *
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in
 *       the documentation and/or other materials provided with the
 *       distribution.
 *     * Neither the name of Intel Corporation nor the names of its
 *       contributors may be used to endorse or promote products derived
 *       from this software without specific prior written permission.
 *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef _RTE_PCI_H_
#define _RTE_PCI_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <errno.h>
#include <sys/queue.h>
#include <stdint.h>
#include <inttypes.h>

#include <rte_debug.h>
#include <rte_interrupts.h>
#include <rte_dev.h>
#include <rte_bus.h>

const char *pci_get_sysfs_path(void);

#define PCI_PRI_FMT "%.4" PRIx16 ":%.2" PRIx8 ":%.2" PRIx8 ".%" PRIx8
#define PCI_PRI_STR_SIZE sizeof("XXXXXXXX:XX:XX.X")

#define PCI_SHORT_PRI_FMT "%.2" PRIx8 ":%.2" PRIx8 ".%" PRIx8

#define PCI_FMT_NVAL 4

#define PCI_RESOURCE_FMT_NVAL 3

#define PCI_MAX_RESOURCE 6

/* Forward declarations */
struct rte_pci_device;
struct rte_pci_driver;

TAILQ_HEAD(rte_pci_device_list, rte_pci_device);
TAILQ_HEAD(rte_pci_driver_list, rte_pci_driver);

/* PCI Bus iterators */
#define FOREACH_DEVICE_ON_PCIBUS(p)     \
                TAILQ_FOREACH(p, &(rte_pci_bus.device_list), next)

#define FOREACH_DRIVER_ON_PCIBUS(p)     \
                TAILQ_FOREACH(p, &(rte_pci_bus.driver_list), next)

struct rte_pci_id {
        uint32_t class_id;            
        uint16_t vendor_id;           
        uint16_t device_id;           
        uint16_t subsystem_vendor_id; 
        uint16_t subsystem_device_id; 
};

struct rte_pci_addr {
        uint32_t domain;                
        uint8_t bus;                    
        uint8_t devid;                  
        uint8_t function;               
};

struct rte_devargs;

struct rte_pci_device {
        TAILQ_ENTRY(rte_pci_device) next;       
        struct rte_device device;               
        struct rte_pci_addr addr;               
        struct rte_pci_id id;                   
        struct rte_mem_resource mem_resource[PCI_MAX_RESOURCE];
        struct rte_intr_handle intr_handle;     
        struct rte_pci_driver *driver;          
        uint16_t max_vfs;                       
        enum rte_kernel_driver kdrv;            
        char name[PCI_PRI_STR_SIZE+1];          
};

#define RTE_DEV_TO_PCI(ptr) container_of(ptr, struct rte_pci_device, device)

#define PCI_ANY_ID (0xffff)
#define RTE_CLASS_ANY_ID (0xffffff)

#ifdef __cplusplus

#define RTE_PCI_DEVICE(vend, dev) \
        RTE_CLASS_ANY_ID,         \
        (vend),                   \
        (dev),                    \
        PCI_ANY_ID,               \
        PCI_ANY_ID
#else

#define RTE_PCI_DEVICE(vend, dev)          \
        .class_id = RTE_CLASS_ANY_ID,      \
        .vendor_id = (vend),               \
        .device_id = (dev),                \
        .subsystem_vendor_id = PCI_ANY_ID, \
        .subsystem_device_id = PCI_ANY_ID
#endif

typedef int (pci_probe_t)(struct rte_pci_driver *, struct rte_pci_device *);

typedef int (pci_remove_t)(struct rte_pci_device *);

struct rte_pci_driver {
        TAILQ_ENTRY(rte_pci_driver) next;       
        struct rte_driver driver;               
        struct rte_pci_bus *bus;                
        pci_probe_t *probe;                     
        pci_remove_t *remove;                   
        const struct rte_pci_id *id_table;      
        uint32_t drv_flags;                     
};

struct rte_pci_bus {
        struct rte_bus bus;               
        struct rte_pci_device_list device_list;  
        struct rte_pci_driver_list driver_list;  
};

#define RTE_PCI_DRV_NEED_MAPPING 0x0001

#define RTE_PCI_DRV_INTR_LSC    0x0008

#define RTE_PCI_DRV_INTR_RMV 0x0010

#define RTE_PCI_DRV_KEEP_MAPPED_RES 0x0020

struct pci_map {
        void *addr;
        char *path;
        uint64_t offset;
        uint64_t size;
        uint64_t phaddr;
};

struct mapped_pci_resource {
        TAILQ_ENTRY(mapped_pci_resource) next;

        struct rte_pci_addr pci_addr;
        char path[PATH_MAX];
        int nb_maps;
        struct pci_map maps[PCI_MAX_RESOURCE];
};

TAILQ_HEAD(mapped_pci_res_list, mapped_pci_resource);

#define GET_PCIADDR_FIELD(in, fd, lim, dlm)                   \
do {                                                               \
        unsigned long val;                                      \
        char *end;                                              \
        errno = 0;                                              \
        val = strtoul((in), &end, 16);                          \
        if (errno != 0 || end[0] != (dlm) || val > (lim))       \
                return -EINVAL;                                 \
        (fd) = (typeof (fd))val;                                \
        (in) = end + 1;                                         \
} while(0)

static inline int
eal_parse_pci_BDF(const char *input, struct rte_pci_addr *dev_addr)
{
        dev_addr->domain = 0;
        GET_PCIADDR_FIELD(input, dev_addr->bus, UINT8_MAX, ':');
        GET_PCIADDR_FIELD(input, dev_addr->devid, UINT8_MAX, '.');
        GET_PCIADDR_FIELD(input, dev_addr->function, UINT8_MAX, 0);
        return 0;
}

static inline int
eal_parse_pci_DomBDF(const char *input, struct rte_pci_addr *dev_addr)
{
        GET_PCIADDR_FIELD(input, dev_addr->domain, UINT16_MAX, ':');
        GET_PCIADDR_FIELD(input, dev_addr->bus, UINT8_MAX, ':');
        GET_PCIADDR_FIELD(input, dev_addr->devid, UINT8_MAX, '.');
        GET_PCIADDR_FIELD(input, dev_addr->function, UINT8_MAX, 0);
        return 0;
}
#undef GET_PCIADDR_FIELD

static inline void
rte_pci_device_name(const struct rte_pci_addr *addr,
                char *output, size_t size)
{
        RTE_VERIFY(size >= PCI_PRI_STR_SIZE);
        RTE_VERIFY(snprintf(output, size, PCI_PRI_FMT,
                            addr->domain, addr->bus,
                            addr->devid, addr->function) >= 0);
}

/* Compare two PCI device addresses. */
static inline int
rte_eal_compare_pci_addr(const struct rte_pci_addr *addr,
                         const struct rte_pci_addr *addr2)
{
        uint64_t dev_addr, dev_addr2;

        if ((addr == NULL) || (addr2 == NULL))
                return -1;

        dev_addr = ((uint64_t)addr->domain << 24) |
                (addr->bus << 16) | (addr->devid << 8) | addr->function;
        dev_addr2 = ((uint64_t)addr2->domain << 24) |
                (addr2->bus << 16) | (addr2->devid << 8) | addr2->function;

        if (dev_addr > dev_addr2)
                return 1;
        else if (dev_addr < dev_addr2)
                return -1;
        else
                return 0;
}

int rte_pci_scan(void);

int
rte_pci_probe(void);

int rte_pci_map_device(struct rte_pci_device *dev);

void rte_pci_unmap_device(struct rte_pci_device *dev);

void *pci_map_resource(void *requested_addr, int fd, off_t offset,
                size_t size, int additional_flags);

void pci_unmap_resource(void *requested_addr, size_t size);

int rte_pci_probe_one(const struct rte_pci_addr *addr);

int rte_pci_detach(const struct rte_pci_addr *addr);

void rte_pci_dump(FILE *f);

void rte_pci_register(struct rte_pci_driver *driver);

#define RTE_PMD_REGISTER_PCI(nm, pci_drv) \
RTE_INIT(pciinitfn_ ##nm); \
static void pciinitfn_ ##nm(void) \
{\
        (pci_drv).driver.name = RTE_STR(nm);\
        rte_pci_register(&pci_drv); \
} \
RTE_PMD_EXPORT_NAME(nm, __COUNTER__)

void rte_pci_unregister(struct rte_pci_driver *driver);

int rte_pci_read_config(const struct rte_pci_device *device,
                void *buf, size_t len, off_t offset);

int rte_pci_write_config(const struct rte_pci_device *device,
                const void *buf, size_t len, off_t offset);

struct rte_pci_ioport {
        struct rte_pci_device *dev;
        uint64_t base;
        uint64_t len; /* only filled for memory mapped ports */
};

int rte_pci_ioport_map(struct rte_pci_device *dev, int bar,
                struct rte_pci_ioport *p);

int rte_pci_ioport_unmap(struct rte_pci_ioport *p);

void rte_pci_ioport_read(struct rte_pci_ioport *p,
                void *data, size_t len, off_t offset);

void rte_pci_ioport_write(struct rte_pci_ioport *p,
                const void *data, size_t len, off_t offset);

#ifdef __cplusplus
}
#endif

#endif /* _RTE_PCI_H_ */