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