intel_vtd.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Intel Corporation
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef ZEPHYR_INCLUDE_DRIVERS_INTEL_VTD_H_
#define ZEPHYR_INCLUDE_DRIVERS_INTEL_VTD_H_
 
#include <zephyr/drivers/pcie/msi.h>
 
typedef int (*vtd_alloc_entries_f)(const struct device *dev,
                                   uint8_t n_entries);
 
typedef uint32_t (*vtd_remap_msi_f)(const struct device *dev,
                                    msi_vector_t *vector,
                                    uint8_t n_vector);
 
typedef int (*vtd_remap_f)(const struct device *dev,
                           uint8_t irte_idx,
                           uint16_t vector,
                           uint32_t flags,
                           uint16_t src_id);
 
typedef int (*vtd_set_irte_vector_f)(const struct device *dev,
                                     uint8_t irte_idx,
                                     uint16_t vector);
 
typedef int (*vtd_get_irte_by_vector_f)(const struct device *dev,
                                        uint16_t vector);
 
typedef uint16_t (*vtd_get_irte_vector_f)(const struct device *dev,
                                          uint8_t irte_idx);
 
typedef int (*vtd_set_irte_irq_f)(const struct device *dev,
                                  uint8_t irte_idx,
                                  unsigned int irq);
 
typedef int (*vtd_get_irte_by_irq_f)(const struct device *dev,
                                     unsigned int irq);
 
typedef void (*vtd_set_irte_msi_f)(const struct device *dev,
                                   uint8_t irte_idx,
                                   bool msi);
 
typedef bool (*vtd_irte_is_msi_f)(const struct device *dev,
                                  uint8_t irte_idx);
 
__subsystem struct vtd_driver_api {
        vtd_alloc_entries_f allocate_entries;
        vtd_remap_msi_f remap_msi;
        vtd_remap_f remap;
        vtd_set_irte_vector_f set_irte_vector;
        vtd_get_irte_by_vector_f get_irte_by_vector;
        vtd_get_irte_vector_f get_irte_vector;
        vtd_set_irte_irq_f set_irte_irq;
        vtd_get_irte_by_irq_f get_irte_by_irq;
        vtd_set_irte_msi_f set_irte_msi;
        vtd_irte_is_msi_f irte_is_msi;
};
 
static inline int vtd_allocate_entries(const struct device *dev,
                                       uint8_t n_entries)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->allocate_entries(dev, n_entries);
}
 
static inline uint32_t vtd_remap_msi(const struct device *dev,
                                     msi_vector_t *vector,
                                     uint8_t n_vector)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->remap_msi(dev, vector, n_vector);
}
 
static inline int vtd_remap(const struct device *dev,
                            uint8_t irte_idx,
                            uint16_t vector,
                            uint32_t flags,
                            uint16_t src_id)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->remap(dev, irte_idx, vector, flags, src_id);
}
 
static inline int vtd_set_irte_vector(const struct device *dev,
                                      uint8_t irte_idx,
                                      uint16_t vector)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->set_irte_vector(dev, irte_idx, vector);
}
 
static inline int vtd_get_irte_by_vector(const struct device *dev,
                                         uint16_t vector)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->get_irte_by_vector(dev, vector);
}
 
static inline uint16_t vtd_get_irte_vector(const struct device *dev,
                                           uint8_t irte_idx)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->get_irte_vector(dev, irte_idx);
}
 
static inline int vtd_set_irte_irq(const struct device *dev,
                                   uint8_t irte_idx,
                                   unsigned int irq)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->set_irte_irq(dev, irte_idx, irq);
}
 
static inline int vtd_get_irte_by_irq(const struct device *dev,
                                      unsigned int irq)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->get_irte_by_irq(dev, irq);
}
 
static inline void vtd_set_irte_msi(const struct device *dev,
                                    uint8_t irte_idx,
                                    bool msi)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        api->set_irte_msi(dev, irte_idx, msi);
}
 
static inline bool vtd_irte_is_msi(const struct device *dev,
                                   uint8_t irte_idx)
{
        const struct vtd_driver_api *api =
                (const struct vtd_driver_api *)dev->api;
 
        return api->irte_is_msi(dev, irte_idx);
}
 
 
#endif /* ZEPHYR_INCLUDE_DRIVERS_INTEL_VTD_H_ */