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/err.h> 24#include <linux/types.h> 25#include <trace/events/iommu.h> 26 27#define IOMMU_READ (1 << 0) 28#define IOMMU_WRITE (1 << 1) 29#define IOMMU_CACHE (1 << 2) /* DMA cache coherency */ 30#define IOMMU_EXEC (1 << 3) 31 32struct iommu_ops; 33struct iommu_group; 34struct bus_type; 35struct device; 36struct iommu_domain; 37struct notifier_block; 38 39/* iommu fault flags */ 40#define IOMMU_FAULT_READ 0x0 41#define IOMMU_FAULT_WRITE 0x1 42 43typedef int (*iommu_fault_handler_t)(struct iommu_domain *, 44 struct device *, unsigned long, int, void *); 45 46struct iommu_domain_geometry { 47 dma_addr_t aperture_start; /* First address that can be mapped */ 48 dma_addr_t aperture_end; /* Last address that can be mapped */ 49 bool force_aperture; /* DMA only allowed in mappable range? */ 50}; 51 52struct iommu_domain { 53 const struct iommu_ops *ops; 54 void *priv; 55 iommu_fault_handler_t handler; 56 void *handler_token; 57 struct iommu_domain_geometry geometry; 58}; 59 60enum iommu_cap { 61 IOMMU_CAP_CACHE_COHERENCY, /* IOMMU can enforce cache coherent DMA 62 transactions */ 63 IOMMU_CAP_INTR_REMAP, /* IOMMU supports interrupt isolation */ 64}; 65 66/* 67 * Following constraints are specifc to FSL_PAMUV1: 68 * -aperture must be power of 2, and naturally aligned 69 * -number of windows must be power of 2, and address space size 70 * of each window is determined by aperture size / # of windows 71 * -the actual size of the mapped region of a window must be power 72 * of 2 starting with 4KB and physical address must be naturally 73 * aligned. 74 * DOMAIN_ATTR_FSL_PAMUV1 corresponds to the above mentioned contraints. 75 * The caller can invoke iommu_domain_get_attr to check if the underlying 76 * iommu implementation supports these constraints. 77 */ 78 79enum iommu_attr { 80 DOMAIN_ATTR_GEOMETRY, 81 DOMAIN_ATTR_PAGING, 82 DOMAIN_ATTR_WINDOWS, 83 DOMAIN_ATTR_FSL_PAMU_STASH, 84 DOMAIN_ATTR_FSL_PAMU_ENABLE, 85 DOMAIN_ATTR_FSL_PAMUV1, 86 DOMAIN_ATTR_NESTING, /* two stages of translation */ 87 DOMAIN_ATTR_MAX, 88}; 89 90#ifdef CONFIG_IOMMU_API 91 92/** 93 * struct iommu_ops - iommu ops and capabilities 94 * @domain_init: init iommu domain 95 * @domain_destroy: destroy iommu domain 96 * @attach_dev: attach device to an iommu domain 97 * @detach_dev: detach device from an iommu domain 98 * @map: map a physically contiguous memory region to an iommu domain 99 * @unmap: unmap a physically contiguous memory region from an iommu domain 100 * @iova_to_phys: translate iova to physical address 101 * @add_device: add device to iommu grouping 102 * @remove_device: remove device from iommu grouping 103 * @domain_get_attr: Query domain attributes 104 * @domain_set_attr: Change domain attributes 105 * @pgsize_bitmap: bitmap of supported page sizes 106 */ 107struct iommu_ops { 108 bool (*capable)(enum iommu_cap); 109 int (*domain_init)(struct iommu_domain *domain); 110 void (*domain_destroy)(struct iommu_domain *domain); 111 int (*attach_dev)(struct iommu_domain *domain, struct device *dev); 112 void (*detach_dev)(struct iommu_domain *domain, struct device *dev); 113 int (*map)(struct iommu_domain *domain, unsigned long iova, 114 phys_addr_t paddr, size_t size, int prot); 115 size_t (*unmap)(struct iommu_domain *domain, unsigned long iova, 116 size_t size); 117 phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova); 118 int (*add_device)(struct device *dev); 119 void (*remove_device)(struct device *dev); 120 int (*device_group)(struct device *dev, unsigned int *groupid); 121 int (*domain_get_attr)(struct iommu_domain *domain, 122 enum iommu_attr attr, void *data); 123 int (*domain_set_attr)(struct iommu_domain *domain, 124 enum iommu_attr attr, void *data); 125 126 /* Window handling functions */ 127 int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr, 128 phys_addr_t paddr, u64 size, int prot); 129 void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr); 130 /* Set the numer of window per domain */ 131 int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count); 132 /* Get the numer of window per domain */ 133 u32 (*domain_get_windows)(struct iommu_domain *domain); 134 135 unsigned long pgsize_bitmap; 136}; 137 138#define IOMMU_GROUP_NOTIFY_ADD_DEVICE 1 /* Device added */ 139#define IOMMU_GROUP_NOTIFY_DEL_DEVICE 2 /* Pre Device removed */ 140#define IOMMU_GROUP_NOTIFY_BIND_DRIVER 3 /* Pre Driver bind */ 141#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER 4 /* Post Driver bind */ 142#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER 5 /* Pre Driver unbind */ 143#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER 6 /* Post Driver unbind */ 144 145extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops); 146extern bool iommu_present(struct bus_type *bus); 147extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap); 148extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus); 149extern struct iommu_group *iommu_group_get_by_id(int id); 150extern void iommu_domain_free(struct iommu_domain *domain); 151extern int iommu_attach_device(struct iommu_domain *domain, 152 struct device *dev); 153extern void iommu_detach_device(struct iommu_domain *domain, 154 struct device *dev); 155extern int iommu_map(struct iommu_domain *domain, unsigned long iova, 156 phys_addr_t paddr, size_t size, int prot); 157extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, 158 size_t size); 159extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova); 160extern void iommu_set_fault_handler(struct iommu_domain *domain, 161 iommu_fault_handler_t handler, void *token); 162 163extern int iommu_attach_group(struct iommu_domain *domain, 164 struct iommu_group *group); 165extern void iommu_detach_group(struct iommu_domain *domain, 166 struct iommu_group *group); 167extern struct iommu_group *iommu_group_alloc(void); 168extern void *iommu_group_get_iommudata(struct iommu_group *group); 169extern void iommu_group_set_iommudata(struct iommu_group *group, 170 void *iommu_data, 171 void (*release)(void *iommu_data)); 172extern int iommu_group_set_name(struct iommu_group *group, const char *name); 173extern int iommu_group_add_device(struct iommu_group *group, 174 struct device *dev); 175extern void iommu_group_remove_device(struct device *dev); 176extern int iommu_group_for_each_dev(struct iommu_group *group, void *data, 177 int (*fn)(struct device *, void *)); 178extern struct iommu_group *iommu_group_get(struct device *dev); 179extern void iommu_group_put(struct iommu_group *group); 180extern int iommu_group_register_notifier(struct iommu_group *group, 181 struct notifier_block *nb); 182extern int iommu_group_unregister_notifier(struct iommu_group *group, 183 struct notifier_block *nb); 184extern int iommu_group_id(struct iommu_group *group); 185extern struct iommu_group *iommu_group_get_for_dev(struct device *dev); 186 187extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr, 188 void *data); 189extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr, 190 void *data); 191struct device *iommu_device_create(struct device *parent, void *drvdata, 192 const struct attribute_group **groups, 193 const char *fmt, ...); 194void iommu_device_destroy(struct device *dev); 195int iommu_device_link(struct device *dev, struct device *link); 196void iommu_device_unlink(struct device *dev, struct device *link); 197 198/* Window handling function prototypes */ 199extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr, 200 phys_addr_t offset, u64 size, 201 int prot); 202extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr); 203/** 204 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework 205 * @domain: the iommu domain where the fault has happened 206 * @dev: the device where the fault has happened 207 * @iova: the faulting address 208 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...) 209 * 210 * This function should be called by the low-level IOMMU implementations 211 * whenever IOMMU faults happen, to allow high-level users, that are 212 * interested in such events, to know about them. 213 * 214 * This event may be useful for several possible use cases: 215 * - mere logging of the event 216 * - dynamic TLB/PTE loading 217 * - if restarting of the faulting device is required 218 * 219 * Returns 0 on success and an appropriate error code otherwise (if dynamic 220 * PTE/TLB loading will one day be supported, implementations will be able 221 * to tell whether it succeeded or not according to this return value). 222 * 223 * Specifically, -ENOSYS is returned if a fault handler isn't installed 224 * (though fault handlers can also return -ENOSYS, in case they want to 225 * elicit the default behavior of the IOMMU drivers). 226 */ 227static inline int report_iommu_fault(struct iommu_domain *domain, 228 struct device *dev, unsigned long iova, int flags) 229{ 230 int ret = -ENOSYS; 231 232 /* 233 * if upper layers showed interest and installed a fault handler, 234 * invoke it. 235 */ 236 if (domain->handler) 237 ret = domain->handler(domain, dev, iova, flags, 238 domain->handler_token); 239 240 trace_io_page_fault(dev, iova, flags); 241 return ret; 242} 243 244#else /* CONFIG_IOMMU_API */ 245 246struct iommu_ops {}; 247struct iommu_group {}; 248 249static inline bool iommu_present(struct bus_type *bus) 250{ 251 return false; 252} 253 254static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap) 255{ 256 return false; 257} 258 259static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus) 260{ 261 return NULL; 262} 263 264static inline struct iommu_group *iommu_group_get_by_id(int id) 265{ 266 return NULL; 267} 268 269static inline void iommu_domain_free(struct iommu_domain *domain) 270{ 271} 272 273static inline int iommu_attach_device(struct iommu_domain *domain, 274 struct device *dev) 275{ 276 return -ENODEV; 277} 278 279static inline void iommu_detach_device(struct iommu_domain *domain, 280 struct device *dev) 281{ 282} 283 284static inline int iommu_map(struct iommu_domain *domain, unsigned long iova, 285 phys_addr_t paddr, int gfp_order, int prot) 286{ 287 return -ENODEV; 288} 289 290static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova, 291 int gfp_order) 292{ 293 return -ENODEV; 294} 295 296static inline int iommu_domain_window_enable(struct iommu_domain *domain, 297 u32 wnd_nr, phys_addr_t paddr, 298 u64 size, int prot) 299{ 300 return -ENODEV; 301} 302 303static inline void iommu_domain_window_disable(struct iommu_domain *domain, 304 u32 wnd_nr) 305{ 306} 307 308static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova) 309{ 310 return 0; 311} 312 313static inline void iommu_set_fault_handler(struct iommu_domain *domain, 314 iommu_fault_handler_t handler, void *token) 315{ 316} 317 318static inline int iommu_attach_group(struct iommu_domain *domain, 319 struct iommu_group *group) 320{ 321 return -ENODEV; 322} 323 324static inline void iommu_detach_group(struct iommu_domain *domain, 325 struct iommu_group *group) 326{ 327} 328 329static inline struct iommu_group *iommu_group_alloc(void) 330{ 331 return ERR_PTR(-ENODEV); 332} 333 334static inline void *iommu_group_get_iommudata(struct iommu_group *group) 335{ 336 return NULL; 337} 338 339static inline void iommu_group_set_iommudata(struct iommu_group *group, 340 void *iommu_data, 341 void (*release)(void *iommu_data)) 342{ 343} 344 345static inline int iommu_group_set_name(struct iommu_group *group, 346 const char *name) 347{ 348 return -ENODEV; 349} 350 351static inline int iommu_group_add_device(struct iommu_group *group, 352 struct device *dev) 353{ 354 return -ENODEV; 355} 356 357static inline void iommu_group_remove_device(struct device *dev) 358{ 359} 360 361static inline int iommu_group_for_each_dev(struct iommu_group *group, 362 void *data, 363 int (*fn)(struct device *, void *)) 364{ 365 return -ENODEV; 366} 367 368static inline struct iommu_group *iommu_group_get(struct device *dev) 369{ 370 return NULL; 371} 372 373static inline void iommu_group_put(struct iommu_group *group) 374{ 375} 376 377static inline int iommu_group_register_notifier(struct iommu_group *group, 378 struct notifier_block *nb) 379{ 380 return -ENODEV; 381} 382 383static inline int iommu_group_unregister_notifier(struct iommu_group *group, 384 struct notifier_block *nb) 385{ 386 return 0; 387} 388 389static inline int iommu_group_id(struct iommu_group *group) 390{ 391 return -ENODEV; 392} 393 394static inline int iommu_domain_get_attr(struct iommu_domain *domain, 395 enum iommu_attr attr, void *data) 396{ 397 return -EINVAL; 398} 399 400static inline int iommu_domain_set_attr(struct iommu_domain *domain, 401 enum iommu_attr attr, void *data) 402{ 403 return -EINVAL; 404} 405 406static inline struct device *iommu_device_create(struct device *parent, 407 void *drvdata, 408 const struct attribute_group **groups, 409 const char *fmt, ...) 410{ 411 return ERR_PTR(-ENODEV); 412} 413 414static inline void iommu_device_destroy(struct device *dev) 415{ 416} 417 418static inline int iommu_device_link(struct device *dev, struct device *link) 419{ 420 return -EINVAL; 421} 422 423static inline void iommu_device_unlink(struct device *dev, struct device *link) 424{ 425} 426 427#endif /* CONFIG_IOMMU_API */ 428 429#endif /* __LINUX_IOMMU_H */ 430