linux/include/linux/iommu.h
<<
>>
Prefs
   1/*
   2 * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
   3 * Author: Joerg Roedel <joerg.roedel@amd.com>
   4 *
   5 * This program is free software; you can redistribute it and/or modify it
   6 * under the terms of the GNU General Public License version 2 as published
   7 * by the Free Software Foundation.
   8 *
   9 * This program is distributed in the hope that it will be useful,
  10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 * GNU General Public License for more details.
  13 *
  14 * You should have received a copy of the GNU General Public License
  15 * along with this program; if not, write to the Free Software
  16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 */
  18
  19#ifndef __LINUX_IOMMU_H
  20#define __LINUX_IOMMU_H
  21
  22#include <linux/errno.h>
  23#include <linux/types.h>
  24
  25#define IOMMU_READ      (1)
  26#define IOMMU_WRITE     (2)
  27#define IOMMU_CACHE     (4) /* DMA cache coherency */
  28
  29struct iommu_ops;
  30struct iommu_group;
  31struct bus_type;
  32struct device;
  33struct iommu_domain;
  34struct notifier_block;
  35
  36/* iommu fault flags */
  37#define IOMMU_FAULT_READ        0x0
  38#define IOMMU_FAULT_WRITE       0x1
  39
  40typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
  41                        struct device *, unsigned long, int, void *);
  42
  43struct iommu_domain_geometry {
  44        dma_addr_t aperture_start; /* First address that can be mapped    */
  45        dma_addr_t aperture_end;   /* Last address that can be mapped     */
  46        bool force_aperture;       /* DMA only allowed in mappable range? */
  47};
  48
  49struct iommu_domain {
  50        struct iommu_ops *ops;
  51        void *priv;
  52        iommu_fault_handler_t handler;
  53        void *handler_token;
  54        struct iommu_domain_geometry geometry;
  55};
  56
  57#define IOMMU_CAP_CACHE_COHERENCY       0x1
  58#define IOMMU_CAP_INTR_REMAP            0x2     /* isolates device intrs */
  59
  60enum iommu_attr {
  61        DOMAIN_ATTR_GEOMETRY,
  62        DOMAIN_ATTR_PAGING,
  63        DOMAIN_ATTR_WINDOWS,
  64        DOMAIN_ATTR_MAX,
  65};
  66
  67#ifdef CONFIG_IOMMU_API
  68
  69/**
  70 * struct iommu_ops - iommu ops and capabilities
  71 * @domain_init: init iommu domain
  72 * @domain_destroy: destroy iommu domain
  73 * @attach_dev: attach device to an iommu domain
  74 * @detach_dev: detach device from an iommu domain
  75 * @map: map a physically contiguous memory region to an iommu domain
  76 * @unmap: unmap a physically contiguous memory region from an iommu domain
  77 * @iova_to_phys: translate iova to physical address
  78 * @domain_has_cap: domain capabilities query
  79 * @add_device: add device to iommu grouping
  80 * @remove_device: remove device from iommu grouping
  81 * @domain_get_attr: Query domain attributes
  82 * @domain_set_attr: Change domain attributes
  83 * @pgsize_bitmap: bitmap of supported page sizes
  84 */
  85struct iommu_ops {
  86        int (*domain_init)(struct iommu_domain *domain);
  87        void (*domain_destroy)(struct iommu_domain *domain);
  88        int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
  89        void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
  90        int (*map)(struct iommu_domain *domain, unsigned long iova,
  91                   phys_addr_t paddr, size_t size, int prot);
  92        size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
  93                     size_t size);
  94        phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
  95                                    unsigned long iova);
  96        int (*domain_has_cap)(struct iommu_domain *domain,
  97                              unsigned long cap);
  98        int (*add_device)(struct device *dev);
  99        void (*remove_device)(struct device *dev);
 100        int (*device_group)(struct device *dev, unsigned int *groupid);
 101        int (*domain_get_attr)(struct iommu_domain *domain,
 102                               enum iommu_attr attr, void *data);
 103        int (*domain_set_attr)(struct iommu_domain *domain,
 104                               enum iommu_attr attr, void *data);
 105
 106        /* Window handling functions */
 107        int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
 108                                    phys_addr_t paddr, u64 size);
 109        void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
 110        /* Set the numer of window per domain */
 111        int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
 112        /* Get the numer of window per domain */
 113        u32 (*domain_get_windows)(struct iommu_domain *domain);
 114
 115        unsigned long pgsize_bitmap;
 116};
 117
 118#define IOMMU_GROUP_NOTIFY_ADD_DEVICE           1 /* Device added */
 119#define IOMMU_GROUP_NOTIFY_DEL_DEVICE           2 /* Pre Device removed */
 120#define IOMMU_GROUP_NOTIFY_BIND_DRIVER          3 /* Pre Driver bind */
 121#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER         4 /* Post Driver bind */
 122#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER        5 /* Pre Driver unbind */
 123#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER       6 /* Post Driver unbind */
 124
 125extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops);
 126extern bool iommu_present(struct bus_type *bus);
 127extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
 128extern void iommu_domain_free(struct iommu_domain *domain);
 129extern int iommu_attach_device(struct iommu_domain *domain,
 130                               struct device *dev);
 131extern void iommu_detach_device(struct iommu_domain *domain,
 132                                struct device *dev);
 133extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
 134                     phys_addr_t paddr, size_t size, int prot);
 135extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
 136                       size_t size);
 137extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
 138                                      unsigned long iova);
 139extern int iommu_domain_has_cap(struct iommu_domain *domain,
 140                                unsigned long cap);
 141extern void iommu_set_fault_handler(struct iommu_domain *domain,
 142                        iommu_fault_handler_t handler, void *token);
 143
 144extern int iommu_attach_group(struct iommu_domain *domain,
 145                              struct iommu_group *group);
 146extern void iommu_detach_group(struct iommu_domain *domain,
 147                               struct iommu_group *group);
 148extern struct iommu_group *iommu_group_alloc(void);
 149extern void *iommu_group_get_iommudata(struct iommu_group *group);
 150extern void iommu_group_set_iommudata(struct iommu_group *group,
 151                                      void *iommu_data,
 152                                      void (*release)(void *iommu_data));
 153extern int iommu_group_set_name(struct iommu_group *group, const char *name);
 154extern int iommu_group_add_device(struct iommu_group *group,
 155                                  struct device *dev);
 156extern void iommu_group_remove_device(struct device *dev);
 157extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
 158                                    int (*fn)(struct device *, void *));
 159extern struct iommu_group *iommu_group_get(struct device *dev);
 160extern void iommu_group_put(struct iommu_group *group);
 161extern int iommu_group_register_notifier(struct iommu_group *group,
 162                                         struct notifier_block *nb);
 163extern int iommu_group_unregister_notifier(struct iommu_group *group,
 164                                           struct notifier_block *nb);
 165extern int iommu_group_id(struct iommu_group *group);
 166
 167extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
 168                                 void *data);
 169extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
 170                                 void *data);
 171
 172/* Window handling function prototypes */
 173extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
 174                                      phys_addr_t offset, u64 size);
 175extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
 176/**
 177 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
 178 * @domain: the iommu domain where the fault has happened
 179 * @dev: the device where the fault has happened
 180 * @iova: the faulting address
 181 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
 182 *
 183 * This function should be called by the low-level IOMMU implementations
 184 * whenever IOMMU faults happen, to allow high-level users, that are
 185 * interested in such events, to know about them.
 186 *
 187 * This event may be useful for several possible use cases:
 188 * - mere logging of the event
 189 * - dynamic TLB/PTE loading
 190 * - if restarting of the faulting device is required
 191 *
 192 * Returns 0 on success and an appropriate error code otherwise (if dynamic
 193 * PTE/TLB loading will one day be supported, implementations will be able
 194 * to tell whether it succeeded or not according to this return value).
 195 *
 196 * Specifically, -ENOSYS is returned if a fault handler isn't installed
 197 * (though fault handlers can also return -ENOSYS, in case they want to
 198 * elicit the default behavior of the IOMMU drivers).
 199 */
 200static inline int report_iommu_fault(struct iommu_domain *domain,
 201                struct device *dev, unsigned long iova, int flags)
 202{
 203        int ret = -ENOSYS;
 204
 205        /*
 206         * if upper layers showed interest and installed a fault handler,
 207         * invoke it.
 208         */
 209        if (domain->handler)
 210                ret = domain->handler(domain, dev, iova, flags,
 211                                                domain->handler_token);
 212
 213        return ret;
 214}
 215
 216#else /* CONFIG_IOMMU_API */
 217
 218struct iommu_ops {};
 219struct iommu_group {};
 220
 221static inline bool iommu_present(struct bus_type *bus)
 222{
 223        return false;
 224}
 225
 226static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
 227{
 228        return NULL;
 229}
 230
 231static inline void iommu_domain_free(struct iommu_domain *domain)
 232{
 233}
 234
 235static inline int iommu_attach_device(struct iommu_domain *domain,
 236                                      struct device *dev)
 237{
 238        return -ENODEV;
 239}
 240
 241static inline void iommu_detach_device(struct iommu_domain *domain,
 242                                       struct device *dev)
 243{
 244}
 245
 246static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
 247                            phys_addr_t paddr, int gfp_order, int prot)
 248{
 249        return -ENODEV;
 250}
 251
 252static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
 253                              int gfp_order)
 254{
 255        return -ENODEV;
 256}
 257
 258static inline int iommu_domain_window_enable(struct iommu_domain *domain,
 259                                             u32 wnd_nr, phys_addr_t paddr,
 260                                             u64 size)
 261{
 262        return -ENODEV;
 263}
 264
 265static inline void iommu_domain_window_disable(struct iommu_domain *domain,
 266                                               u32 wnd_nr)
 267{
 268}
 269
 270static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
 271                                             unsigned long iova)
 272{
 273        return 0;
 274}
 275
 276static inline int domain_has_cap(struct iommu_domain *domain,
 277                                 unsigned long cap)
 278{
 279        return 0;
 280}
 281
 282static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 283                                iommu_fault_handler_t handler, void *token)
 284{
 285}
 286
 287static inline int iommu_attach_group(struct iommu_domain *domain,
 288                                     struct iommu_group *group)
 289{
 290        return -ENODEV;
 291}
 292
 293static inline void iommu_detach_group(struct iommu_domain *domain,
 294                                      struct iommu_group *group)
 295{
 296}
 297
 298static inline struct iommu_group *iommu_group_alloc(void)
 299{
 300        return ERR_PTR(-ENODEV);
 301}
 302
 303static inline void *iommu_group_get_iommudata(struct iommu_group *group)
 304{
 305        return NULL;
 306}
 307
 308static inline void iommu_group_set_iommudata(struct iommu_group *group,
 309                                             void *iommu_data,
 310                                             void (*release)(void *iommu_data))
 311{
 312}
 313
 314static inline int iommu_group_set_name(struct iommu_group *group,
 315                                       const char *name)
 316{
 317        return -ENODEV;
 318}
 319
 320static inline int iommu_group_add_device(struct iommu_group *group,
 321                                         struct device *dev)
 322{
 323        return -ENODEV;
 324}
 325
 326static inline void iommu_group_remove_device(struct device *dev)
 327{
 328}
 329
 330static inline int iommu_group_for_each_dev(struct iommu_group *group,
 331                                           void *data,
 332                                           int (*fn)(struct device *, void *))
 333{
 334        return -ENODEV;
 335}
 336
 337static inline struct iommu_group *iommu_group_get(struct device *dev)
 338{
 339        return NULL;
 340}
 341
 342static inline void iommu_group_put(struct iommu_group *group)
 343{
 344}
 345
 346static inline int iommu_group_register_notifier(struct iommu_group *group,
 347                                                struct notifier_block *nb)
 348{
 349        return -ENODEV;
 350}
 351
 352static inline int iommu_group_unregister_notifier(struct iommu_group *group,
 353                                                  struct notifier_block *nb)
 354{
 355        return 0;
 356}
 357
 358static inline int iommu_group_id(struct iommu_group *group)
 359{
 360        return -ENODEV;
 361}
 362
 363static inline int iommu_domain_get_attr(struct iommu_domain *domain,
 364                                        enum iommu_attr attr, void *data)
 365{
 366        return -EINVAL;
 367}
 368
 369static inline int iommu_domain_set_attr(struct iommu_domain *domain,
 370                                        enum iommu_attr attr, void *data)
 371{
 372        return -EINVAL;
 373}
 374
 375#endif /* CONFIG_IOMMU_API */
 376
 377#endif /* __LINUX_IOMMU_H */
 378
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.