pcie_ep.h

Go to the documentation of this file.

 
/*
 * SPDX-License-Identifier: Apache-2.0
 *
 * Copyright 2020 Broadcom
 *
 */
#ifndef ZEPHYR_INCLUDE_DRIVERS_PCIE_EP_H_
#define ZEPHYR_INCLUDE_DRIVERS_PCIE_EP_H_
 
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/kernel.h>
#include <stdint.h>
 
enum pcie_ob_mem_type {
        PCIE_OB_ANYMEM,  
        PCIE_OB_LOWMEM,  
        PCIE_OB_HIGHMEM, 
};
 
enum pci_ep_irq_type {
        PCIE_EP_IRQ_LEGACY,     
        PCIE_EP_IRQ_MSI,        
        PCIE_EP_IRQ_MSIX,       
};
 
enum xfer_direction {
        HOST_TO_DEVICE,         
        DEVICE_TO_HOST,         
};
 
enum pcie_reset {
        PCIE_PERST,     
        PCIE_PERST_INB, 
        PCIE_FLR,       
        PCIE_RESET_MAX
};
 
typedef void (*pcie_ep_reset_callback_t)(void *arg);
 
__subsystem struct pcie_ep_driver_api {
        int (*conf_read)(const struct device *dev, uint32_t offset,
                         uint32_t *data);
        void (*conf_write)(const struct device *dev, uint32_t offset,
                           uint32_t data);
        int (*map_addr)(const struct device *dev, uint64_t pcie_addr,
                        uint64_t *mapped_addr, uint32_t size,
                        enum pcie_ob_mem_type ob_mem_type);
        void (*unmap_addr)(const struct device *dev, uint64_t mapped_addr);
        int (*raise_irq)(const struct device *dev,
                         enum pci_ep_irq_type irq_type,
                         uint32_t irq_num);
        int (*register_reset_cb)(const struct device *dev,
                                 enum pcie_reset reset,
                                 pcie_ep_reset_callback_t cb, void *arg);
        int (*dma_xfer)(const struct device *dev, uint64_t mapped_addr,
                        uintptr_t local_addr, uint32_t size,
                        enum xfer_direction dir);
};
 
static inline int pcie_ep_conf_read(const struct device *dev,
                                    uint32_t offset, uint32_t *data)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        return api->conf_read(dev, offset, data);
}
 
static inline void pcie_ep_conf_write(const struct device *dev,
                                      uint32_t offset, uint32_t data)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        api->conf_write(dev, offset, data);
}
 
static inline int pcie_ep_map_addr(const struct device *dev,
                                   uint64_t pcie_addr,
                                   uint64_t *mapped_addr, uint32_t size,
                                   enum pcie_ob_mem_type ob_mem_type)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        return api->map_addr(dev, pcie_addr, mapped_addr, size, ob_mem_type);
}
 
static inline void pcie_ep_unmap_addr(const struct device *dev,
                                      uint64_t mapped_addr)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        api->unmap_addr(dev, mapped_addr);
}
 
static inline int pcie_ep_raise_irq(const struct device *dev,
                                    enum pci_ep_irq_type irq_type,
                                    uint32_t irq_num)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
        return api->raise_irq(dev, irq_type, irq_num);
}
 
static inline int pcie_ep_register_reset_cb(const struct device *dev,
                                            enum pcie_reset reset,
                                            pcie_ep_reset_callback_t cb,
                                            void *arg)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        if (api->register_reset_cb) {
                return api->register_reset_cb(dev, reset, cb, arg);
        }
 
        return -ENOTSUP;
}
 
static inline int pcie_ep_dma_xfer(const struct device *dev,
                                   uint64_t mapped_addr,
                                   uintptr_t local_addr, uint32_t size,
                                   const enum xfer_direction dir)
{
        const struct pcie_ep_driver_api *api =
                        (const struct pcie_ep_driver_api *)dev->api;
 
        if (api->dma_xfer) {
                return api->dma_xfer(dev, mapped_addr, local_addr, size, dir);
        }
 
        return -ENOTSUP;
}
 
int pcie_ep_xfer_data_memcpy(const struct device *dev, uint64_t pcie_addr,
                             uintptr_t *local_addr, uint32_t size,
                             enum pcie_ob_mem_type ob_mem_type,
                             enum xfer_direction dir);
 
int pcie_ep_xfer_data_dma(const struct device *dev, uint64_t pcie_addr,
                          uintptr_t *local_addr, uint32_t size,
                          enum pcie_ob_mem_type ob_mem_type,
                          enum xfer_direction dir);
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_PCIE_EP_H_ */