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_MAX,
  62        DOMAIN_ATTR_GEOMETRY,
  63};
  64
  65#ifdef CONFIG_IOMMU_API
  66
  67/**
  68 * struct iommu_ops - iommu ops and capabilities
  69 * @domain_init: init iommu domain
  70 * @domain_destroy: destroy iommu domain
  71 * @attach_dev: attach device to an iommu domain
  72 * @detach_dev: detach device from an iommu domain
  73 * @map: map a physically contiguous memory region to an iommu domain
  74 * @unmap: unmap a physically contiguous memory region from an iommu domain
  75 * @iova_to_phys: translate iova to physical address
  76 * @domain_has_cap: domain capabilities query
  77 * @add_device: add device to iommu grouping
  78 * @remove_device: remove device from iommu grouping
  79 * @domain_get_attr: Query domain attributes
  80 * @domain_set_attr: Change domain attributes
  81 * @pgsize_bitmap: bitmap of supported page sizes
  82 */
  83struct iommu_ops {
  84        int (*domain_init)(struct iommu_domain *domain);
  85        void (*domain_destroy)(struct iommu_domain *domain);
  86        int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
  87        void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
  88        int (*map)(struct iommu_domain *domain, unsigned long iova,
  89                   phys_addr_t paddr, size_t size, int prot);
  90        size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
  91                     size_t size);
  92        phys_addr_t (*iova_to_phys)(struct iommu_domain *domain,
  93                                    unsigned long iova);
  94        int (*domain_has_cap)(struct iommu_domain *domain,
  95                              unsigned long cap);
  96        int (*add_device)(struct device *dev);
  97        void (*remove_device)(struct device *dev);
  98        int (*device_group)(struct device *dev, unsigned int *groupid);
  99        int (*domain_get_attr)(struct iommu_domain *domain,
 100                               enum iommu_attr attr, void *data);
 101        int (*domain_set_attr)(struct iommu_domain *domain,
 102                               enum iommu_attr attr, void *data);
 103        unsigned long pgsize_bitmap;
 104};
 105
 106#define IOMMU_GROUP_NOTIFY_ADD_DEVICE           1 /* Device added */
 107#define IOMMU_GROUP_NOTIFY_DEL_DEVICE           2 /* Pre Device removed */
 108#define IOMMU_GROUP_NOTIFY_BIND_DRIVER          3 /* Pre Driver bind */
 109#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER         4 /* Post Driver bind */
 110#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER        5 /* Pre Driver unbind */
 111#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER       6 /* Post Driver unbind */
 112
 113extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops);
 114extern bool iommu_present(struct bus_type *bus);
 115extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
 116extern void iommu_domain_free(struct iommu_domain *domain);
 117extern int iommu_attach_device(struct iommu_domain *domain,
 118                               struct device *dev);
 119extern void iommu_detach_device(struct iommu_domain *domain,
 120                                struct device *dev);
 121extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
 122                     phys_addr_t paddr, size_t size, int prot);
 123extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
 124                       size_t size);
 125extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
 126                                      unsigned long iova);
 127extern int iommu_domain_has_cap(struct iommu_domain *domain,
 128                                unsigned long cap);
 129extern void iommu_set_fault_handler(struct iommu_domain *domain,
 130                        iommu_fault_handler_t handler, void *token);
 131
 132extern int iommu_attach_group(struct iommu_domain *domain,
 133                              struct iommu_group *group);
 134extern void iommu_detach_group(struct iommu_domain *domain,
 135                               struct iommu_group *group);
 136extern struct iommu_group *iommu_group_alloc(void);
 137extern void *iommu_group_get_iommudata(struct iommu_group *group);
 138extern void iommu_group_set_iommudata(struct iommu_group *group,
 139                                      void *iommu_data,
 140                                      void (*release)(void *iommu_data));
 141extern int iommu_group_set_name(struct iommu_group *group, const char *name);
 142extern int iommu_group_add_device(struct iommu_group *group,
 143                                  struct device *dev);
 144extern void iommu_group_remove_device(struct device *dev);
 145extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
 146                                    int (*fn)(struct device *, void *));
 147extern struct iommu_group *iommu_group_get(struct device *dev);
 148extern void iommu_group_put(struct iommu_group *group);
 149extern int iommu_group_register_notifier(struct iommu_group *group,
 150                                         struct notifier_block *nb);
 151extern int iommu_group_unregister_notifier(struct iommu_group *group,
 152                                           struct notifier_block *nb);
 153extern int iommu_group_id(struct iommu_group *group);
 154
 155extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
 156                                 void *data);
 157extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
 158                                 void *data);
 159
 160/**
 161 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
 162 * @domain: the iommu domain where the fault has happened
 163 * @dev: the device where the fault has happened
 164 * @iova: the faulting address
 165 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
 166 *
 167 * This function should be called by the low-level IOMMU implementations
 168 * whenever IOMMU faults happen, to allow high-level users, that are
 169 * interested in such events, to know about them.
 170 *
 171 * This event may be useful for several possible use cases:
 172 * - mere logging of the event
 173 * - dynamic TLB/PTE loading
 174 * - if restarting of the faulting device is required
 175 *
 176 * Returns 0 on success and an appropriate error code otherwise (if dynamic
 177 * PTE/TLB loading will one day be supported, implementations will be able
 178 * to tell whether it succeeded or not according to this return value).
 179 *
 180 * Specifically, -ENOSYS is returned if a fault handler isn't installed
 181 * (though fault handlers can also return -ENOSYS, in case they want to
 182 * elicit the default behavior of the IOMMU drivers).
 183 */
 184static inline int report_iommu_fault(struct iommu_domain *domain,
 185                struct device *dev, unsigned long iova, int flags)
 186{
 187        int ret = -ENOSYS;
 188
 189        /*
 190         * if upper layers showed interest and installed a fault handler,
 191         * invoke it.
 192         */
 193        if (domain->handler)
 194                ret = domain->handler(domain, dev, iova, flags,
 195                                                domain->handler_token);
 196
 197        return ret;
 198}
 199
 200#else /* CONFIG_IOMMU_API */
 201
 202struct iommu_ops {};
 203struct iommu_group {};
 204
 205static inline bool iommu_present(struct bus_type *bus)
 206{
 207        return false;
 208}
 209
 210static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
 211{
 212        return NULL;
 213}
 214
 215static inline void iommu_domain_free(struct iommu_domain *domain)
 216{
 217}
 218
 219static inline int iommu_attach_device(struct iommu_domain *domain,
 220                                      struct device *dev)
 221{
 222        return -ENODEV;
 223}
 224
 225static inline void iommu_detach_device(struct iommu_domain *domain,
 226                                       struct device *dev)
 227{
 228}
 229
 230static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
 231                            phys_addr_t paddr, int gfp_order, int prot)
 232{
 233        return -ENODEV;
 234}
 235
 236static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
 237                              int gfp_order)
 238{
 239        return -ENODEV;
 240}
 241
 242static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
 243                                             unsigned long iova)
 244{
 245        return 0;
 246}
 247
 248static inline int domain_has_cap(struct iommu_domain *domain,
 249                                 unsigned long cap)
 250{
 251        return 0;
 252}
 253
 254static inline void iommu_set_fault_handler(struct iommu_domain *domain,
 255                                iommu_fault_handler_t handler, void *token)
 256{
 257}
 258
 259static inline int iommu_attach_group(struct iommu_domain *domain,
 260                                     struct iommu_group *group)
 261{
 262        return -ENODEV;
 263}
 264
 265static inline void iommu_detach_group(struct iommu_domain *domain,
 266                                      struct iommu_group *group)
 267{
 268}
 269
 270static inline struct iommu_group *iommu_group_alloc(void)
 271{
 272        return ERR_PTR(-ENODEV);
 273}
 274
 275static inline void *iommu_group_get_iommudata(struct iommu_group *group)
 276{
 277        return NULL;
 278}
 279
 280static inline void iommu_group_set_iommudata(struct iommu_group *group,
 281                                             void *iommu_data,
 282                                             void (*release)(void *iommu_data))
 283{
 284}
 285
 286static inline int iommu_group_set_name(struct iommu_group *group,
 287                                       const char *name)
 288{
 289        return -ENODEV;
 290}
 291
 292static inline int iommu_group_add_device(struct iommu_group *group,
 293                                         struct device *dev)
 294{
 295        return -ENODEV;
 296}
 297
 298static inline void iommu_group_remove_device(struct device *dev)
 299{
 300}
 301
 302static inline int iommu_group_for_each_dev(struct iommu_group *group,
 303                                           void *data,
 304                                           int (*fn)(struct device *, void *))
 305{
 306        return -ENODEV;
 307}
 308
 309static inline struct iommu_group *iommu_group_get(struct device *dev)
 310{
 311        return NULL;
 312}
 313
 314static inline void iommu_group_put(struct iommu_group *group)
 315{
 316}
 317
 318static inline int iommu_group_register_notifier(struct iommu_group *group,
 319                                                struct notifier_block *nb)
 320{
 321        return -ENODEV;
 322}
 323
 324static inline int iommu_group_unregister_notifier(struct iommu_group *group,
 325                                                  struct notifier_block *nb)
 326{
 327        return 0;
 328}
 329
 330static inline int iommu_group_id(struct iommu_group *group)
 331{
 332        return -ENODEV;
 333}
 334
 335static inline int iommu_domain_get_attr(struct iommu_domain *domain,
 336                                        enum iommu_attr attr, void *data)
 337{
 338        return -EINVAL;
 339}
 340
 341static inline int iommu_domain_set_attr(struct iommu_domain *domain,
 342                                        enum iommu_attr attr, void *data)
 343{
 344        return -EINVAL;
 345}
 346
 347#endif /* CONFIG_IOMMU_API */
 348
 349#endif /* __LINUX_IOMMU_H */
 350
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.