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


typedef int (*pcie_ep_api_conf_read)(const struct device *dev, uint32_t offset,
                                     uint32_t *data);

typedef void (*pcie_ep_api_conf_write)(const struct device *dev, uint32_t offset,
                                       uint32_t data);

typedef int (*pcie_ep_api_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);

typedef void (*pcie_ep_api_unmap_addr)(const struct device *dev, uint64_t mapped_addr);

typedef int (*pcie_ep_api_raise_irq)(const struct device *dev,
                                     enum pci_ep_irq_type irq_type,
                                     uint32_t irq_num);

typedef int (*pcie_ep_api_register_reset_cb)(const struct device *dev,
                                             enum pcie_reset reset,
                                             pcie_ep_reset_callback_t cb, void *arg);

typedef int (*pcie_ep_api_dma_xfer)(const struct device *dev, uint64_t mapped_addr,
                                    uintptr_t local_addr, uint32_t size,
                                    enum xfer_direction dir);

__subsystem struct pcie_ep_driver_api {
        pcie_ep_api_conf_read conf_read;
        pcie_ep_api_conf_write conf_write;
        pcie_ep_api_map_addr map_addr;
        pcie_ep_api_unmap_addr unmap_addr;
        pcie_ep_api_raise_irq raise_irq;
        pcie_ep_api_register_reset_cb register_reset_cb;
        pcie_ep_api_dma_xfer dma_xfer;
};


 
static inline int pcie_ep_conf_read(const struct device *dev,
                                    uint32_t offset, uint32_t *data)
{
        return DEVICE_API_GET(pcie_ep, dev)->conf_read(dev, offset, data);
}

 
static inline void pcie_ep_conf_write(const struct device *dev,
                                      uint32_t offset, uint32_t data)
{
        DEVICE_API_GET(pcie_ep, dev)->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)
{
        return DEVICE_API_GET(pcie_ep, dev)->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)
{
        DEVICE_API_GET(pcie_ep, dev)->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)
{
        return DEVICE_API_GET(pcie_ep, dev)->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 = DEVICE_API_GET(pcie_ep, dev);
 
        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 = DEVICE_API_GET(pcie_ep, dev);
 
        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_ */