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 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, 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 185 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr, 186 void *data); 187 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr, 188 void *data); 189 190 /* Window handling function prototypes */ 191 extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr, 192 phys_addr_t offset, u64 size, 193 int prot); 194 extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr); 195 /** 196 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework 197 * @domain: the iommu domain where the fault has happened 198 * @dev: the device where the fault has happened 199 * @iova: the faulting address 200 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...) 201 * 202 * This function should be called by the low-level IOMMU implementations 203 * whenever IOMMU faults happen, to allow high-level users, that are 204 * interested in such events, to know about them. 205 * 206 * This event may be useful for several possible use cases: 207 * - mere logging of the event 208 * - dynamic TLB/PTE loading 209 * - if restarting of the faulting device is required 210 * 211 * Returns 0 on success and an appropriate error code otherwise (if dynamic 212 * PTE/TLB loading will one day be supported, implementations will be able 213 * to tell whether it succeeded or not according to this return value). 214 * 215 * Specifically, -ENOSYS is returned if a fault handler isn't installed 216 * (though fault handlers can also return -ENOSYS, in case they want to 217 * elicit the default behavior of the IOMMU drivers). 218 */ 219 static inline int report_iommu_fault(struct iommu_domain *domain, 220 struct device *dev, unsigned long iova, int flags) 221 { 222 int ret = -ENOSYS; 223 224 /* 225 * if upper layers showed interest and installed a fault handler, 226 * invoke it. 227 */ 228 if (domain->handler) 229 ret = domain->handler(domain, dev, iova, flags, 230 domain->handler_token); 231 232 trace_io_page_fault(dev, iova, flags); 233 return ret; 234 } 235 236 #else /* CONFIG_IOMMU_API */ 237 238 struct iommu_ops {}; 239 struct iommu_group {}; 240 241 static inline bool iommu_present(struct bus_type *bus) 242 { 243 return false; 244 } 245 246 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus) 247 { 248 return NULL; 249 } 250 251 static inline struct iommu_group *iommu_group_get_by_id(int id) 252 { 253 return NULL; 254 } 255 256 static inline void iommu_domain_free(struct iommu_domain *domain) 257 { 258 } 259 260 static inline int iommu_attach_device(struct iommu_domain *domain, 261 struct device *dev) 262 { 263 return -ENODEV; 264 } 265 266 static inline void iommu_detach_device(struct iommu_domain *domain, 267 struct device *dev) 268 { 269 } 270 271 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova, 272 phys_addr_t paddr, int gfp_order, int prot) 273 { 274 return -ENODEV; 275 } 276 277 static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova, 278 int gfp_order) 279 { 280 return -ENODEV; 281 } 282 283 static inline int iommu_domain_window_enable(struct iommu_domain *domain, 284 u32 wnd_nr, phys_addr_t paddr, 285 u64 size, int prot) 286 { 287 return -ENODEV; 288 } 289 290 static inline void iommu_domain_window_disable(struct iommu_domain *domain, 291 u32 wnd_nr) 292 { 293 } 294 295 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova) 296 { 297 return 0; 298 } 299 300 static inline int iommu_domain_has_cap(struct iommu_domain *domain, 301 unsigned long cap) 302 { 303 return 0; 304 } 305 306 static inline void iommu_set_fault_handler(struct iommu_domain *domain, 307 iommu_fault_handler_t handler, void *token) 308 { 309 } 310 311 static inline int iommu_attach_group(struct iommu_domain *domain, 312 struct iommu_group *group) 313 { 314 return -ENODEV; 315 } 316 317 static inline void iommu_detach_group(struct iommu_domain *domain, 318 struct iommu_group *group) 319 { 320 } 321 322 static inline struct iommu_group *iommu_group_alloc(void) 323 { 324 return ERR_PTR(-ENODEV); 325 } 326 327 static inline void *iommu_group_get_iommudata(struct iommu_group *group) 328 { 329 return NULL; 330 } 331 332 static inline void iommu_group_set_iommudata(struct iommu_group *group, 333 void *iommu_data, 334 void (*release)(void *iommu_data)) 335 { 336 } 337 338 static inline int iommu_group_set_name(struct iommu_group *group, 339 const char *name) 340 { 341 return -ENODEV; 342 } 343 344 static inline int iommu_group_add_device(struct iommu_group *group, 345 struct device *dev) 346 { 347 return -ENODEV; 348 } 349 350 static inline void iommu_group_remove_device(struct device *dev) 351 { 352 } 353 354 static inline int iommu_group_for_each_dev(struct iommu_group *group, 355 void *data, 356 int (*fn)(struct device *, void *)) 357 { 358 return -ENODEV; 359 } 360 361 static inline struct iommu_group *iommu_group_get(struct device *dev) 362 { 363 return NULL; 364 } 365 366 static inline void iommu_group_put(struct iommu_group *group) 367 { 368 } 369 370 static inline int iommu_group_register_notifier(struct iommu_group *group, 371 struct notifier_block *nb) 372 { 373 return -ENODEV; 374 } 375 376 static inline int iommu_group_unregister_notifier(struct iommu_group *group, 377 struct notifier_block *nb) 378 { 379 return 0; 380 } 381 382 static inline int iommu_group_id(struct iommu_group *group) 383 { 384 return -ENODEV; 385 } 386 387 static inline int iommu_domain_get_attr(struct iommu_domain *domain, 388 enum iommu_attr attr, void *data) 389 { 390 return -EINVAL; 391 } 392 393 static inline int iommu_domain_set_attr(struct iommu_domain *domain, 394 enum iommu_attr attr, void *data) 395 { 396 return -EINVAL; 397 } 398 399 #endif /* CONFIG_IOMMU_API */ 400 401 #endif /* __LINUX_IOMMU_H */ 402