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 26 #define IOMMU_READ (1) 27 #define IOMMU_WRITE (2) 28 #define IOMMU_CACHE (4) /* DMA cache coherency */ 29 30 struct iommu_ops; 31 struct iommu_group; 32 struct bus_type; 33 struct device; 34 struct iommu_domain; 35 struct notifier_block; 36 37 /* iommu fault flags */ 38 #define IOMMU_FAULT_READ 0x0 39 #define IOMMU_FAULT_WRITE 0x1 40 41 typedef int (*iommu_fault_handler_t)(struct iommu_domain *, 42 struct device *, unsigned long, int, void *); 43 44 struct iommu_domain_geometry { 45 dma_addr_t aperture_start; /* First address that can be mapped */ 46 dma_addr_t aperture_end; /* Last address that can be mapped */ 47 bool force_aperture; /* DMA only allowed in mappable range? */ 48 }; 49 50 struct iommu_domain { 51 struct iommu_ops *ops; 52 void *priv; 53 iommu_fault_handler_t handler; 54 void *handler_token; 55 struct iommu_domain_geometry geometry; 56 }; 57 58 #define IOMMU_CAP_CACHE_COHERENCY 0x1 59 #define IOMMU_CAP_INTR_REMAP 0x2 /* isolates device intrs */ 60 61 enum iommu_attr { 62 DOMAIN_ATTR_GEOMETRY, 63 DOMAIN_ATTR_PAGING, 64 DOMAIN_ATTR_WINDOWS, 65 DOMAIN_ATTR_MAX, 66 }; 67 68 #ifdef CONFIG_IOMMU_API 69 70 /** 71 * struct iommu_ops - iommu ops and capabilities 72 * @domain_init: init iommu domain 73 * @domain_destroy: destroy iommu domain 74 * @attach_dev: attach device to an iommu domain 75 * @detach_dev: detach device from an iommu domain 76 * @map: map a physically contiguous memory region to an iommu domain 77 * @unmap: unmap a physically contiguous memory region from an iommu domain 78 * @iova_to_phys: translate iova to physical address 79 * @domain_has_cap: domain capabilities query 80 * @add_device: add device to iommu grouping 81 * @remove_device: remove device from iommu grouping 82 * @domain_get_attr: Query domain attributes 83 * @domain_set_attr: Change domain attributes 84 * @pgsize_bitmap: bitmap of supported page sizes 85 */ 86 struct iommu_ops { 87 int (*domain_init)(struct iommu_domain *domain); 88 void (*domain_destroy)(struct iommu_domain *domain); 89 int (*attach_dev)(struct iommu_domain *domain, struct device *dev); 90 void (*detach_dev)(struct iommu_domain *domain, struct device *dev); 91 int (*map)(struct iommu_domain *domain, unsigned long iova, 92 phys_addr_t paddr, size_t size, int prot); 93 size_t (*unmap)(struct iommu_domain *domain, unsigned long iova, 94 size_t size); 95 phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t 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, int prot); 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 125 extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops); 126 extern bool iommu_present(struct bus_type *bus); 127 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus); 128 extern struct iommu_group *iommu_group_get_by_id(int id); 129 extern void iommu_domain_free(struct iommu_domain *domain); 130 extern int iommu_attach_device(struct iommu_domain *domain, 131 struct device *dev); 132 extern void iommu_detach_device(struct iommu_domain *domain, 133 struct device *dev); 134 extern int iommu_map(struct iommu_domain *domain, unsigned long iova, 135 phys_addr_t paddr, size_t size, int prot); 136 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, 137 size_t size); 138 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova); 139 extern int iommu_domain_has_cap(struct iommu_domain *domain, 140 unsigned long cap); 141 extern void iommu_set_fault_handler(struct iommu_domain *domain, 142 iommu_fault_handler_t handler, void *token); 143 144 extern int iommu_attach_group(struct iommu_domain *domain, 145 struct iommu_group *group); 146 extern void iommu_detach_group(struct iommu_domain *domain, 147 struct iommu_group *group); 148 extern struct iommu_group *iommu_group_alloc(void); 149 extern void *iommu_group_get_iommudata(struct iommu_group *group); 150 extern void iommu_group_set_iommudata(struct iommu_group *group, 151 void *iommu_data, 152 void (*release)(void *iommu_data)); 153 extern int iommu_group_set_name(struct iommu_group *group, const char *name); 154 extern int iommu_group_add_device(struct iommu_group *group, 155 struct device *dev); 156 extern void iommu_group_remove_device(struct device *dev); 157 extern int iommu_group_for_each_dev(struct iommu_group *group, void *data, 158 int (*fn)(struct device *, void *)); 159 extern struct iommu_group *iommu_group_get(struct device *dev); 160 extern void iommu_group_put(struct iommu_group *group); 161 extern int iommu_group_register_notifier(struct iommu_group *group, 162 struct notifier_block *nb); 163 extern int iommu_group_unregister_notifier(struct iommu_group *group, 164 struct notifier_block *nb); 165 extern int iommu_group_id(struct iommu_group *group); 166 167 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr, 168 void *data); 169 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr, 170 void *data); 171 172 /* Window handling function prototypes */ 173 extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr, 174 phys_addr_t offset, u64 size, 175 int prot); 176 extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr); 177 /** 178 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework 179 * @domain: the iommu domain where the fault has happened 180 * @dev: the device where the fault has happened 181 * @iova: the faulting address 182 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...) 183 * 184 * This function should be called by the low-level IOMMU implementations 185 * whenever IOMMU faults happen, to allow high-level users, that are 186 * interested in such events, to know about them. 187 * 188 * This event may be useful for several possible use cases: 189 * - mere logging of the event 190 * - dynamic TLB/PTE loading 191 * - if restarting of the faulting device is required 192 * 193 * Returns 0 on success and an appropriate error code otherwise (if dynamic 194 * PTE/TLB loading will one day be supported, implementations will be able 195 * to tell whether it succeeded or not according to this return value). 196 * 197 * Specifically, -ENOSYS is returned if a fault handler isn't installed 198 * (though fault handlers can also return -ENOSYS, in case they want to 199 * elicit the default behavior of the IOMMU drivers). 200 */ 201 static inline int report_iommu_fault(struct iommu_domain *domain, 202 struct device *dev, unsigned long iova, int flags) 203 { 204 int ret = -ENOSYS; 205 206 /* 207 * if upper layers showed interest and installed a fault handler, 208 * invoke it. 209 */ 210 if (domain->handler) 211 ret = domain->handler(domain, dev, iova, flags, 212 domain->handler_token); 213 214 return ret; 215 } 216 217 #else /* CONFIG_IOMMU_API */ 218 219 struct iommu_ops {}; 220 struct iommu_group {}; 221 222 static inline bool iommu_present(struct bus_type *bus) 223 { 224 return false; 225 } 226 227 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus) 228 { 229 return NULL; 230 } 231 232 static inline void iommu_domain_free(struct iommu_domain *domain) 233 { 234 } 235 236 static inline int iommu_attach_device(struct iommu_domain *domain, 237 struct device *dev) 238 { 239 return -ENODEV; 240 } 241 242 static inline void iommu_detach_device(struct iommu_domain *domain, 243 struct device *dev) 244 { 245 } 246 247 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova, 248 phys_addr_t paddr, int gfp_order, int prot) 249 { 250 return -ENODEV; 251 } 252 253 static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova, 254 int gfp_order) 255 { 256 return -ENODEV; 257 } 258 259 static inline int iommu_domain_window_enable(struct iommu_domain *domain, 260 u32 wnd_nr, phys_addr_t paddr, 261 u64 size, int prot) 262 { 263 return -ENODEV; 264 } 265 266 static inline void iommu_domain_window_disable(struct iommu_domain *domain, 267 u32 wnd_nr) 268 { 269 } 270 271 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova) 272 { 273 return 0; 274 } 275 276 static inline int domain_has_cap(struct iommu_domain *domain, 277 unsigned long cap) 278 { 279 return 0; 280 } 281 282 static inline void iommu_set_fault_handler(struct iommu_domain *domain, 283 iommu_fault_handler_t handler, void *token) 284 { 285 } 286 287 static inline int iommu_attach_group(struct iommu_domain *domain, 288 struct iommu_group *group) 289 { 290 return -ENODEV; 291 } 292 293 static inline void iommu_detach_group(struct iommu_domain *domain, 294 struct iommu_group *group) 295 { 296 } 297 298 static inline struct iommu_group *iommu_group_alloc(void) 299 { 300 return ERR_PTR(-ENODEV); 301 } 302 303 static inline void *iommu_group_get_iommudata(struct iommu_group *group) 304 { 305 return NULL; 306 } 307 308 static inline void iommu_group_set_iommudata(struct iommu_group *group, 309 void *iommu_data, 310 void (*release)(void *iommu_data)) 311 { 312 } 313 314 static inline int iommu_group_set_name(struct iommu_group *group, 315 const char *name) 316 { 317 return -ENODEV; 318 } 319 320 static inline int iommu_group_add_device(struct iommu_group *group, 321 struct device *dev) 322 { 323 return -ENODEV; 324 } 325 326 static inline void iommu_group_remove_device(struct device *dev) 327 { 328 } 329 330 static 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 337 static inline struct iommu_group *iommu_group_get(struct device *dev) 338 { 339 return NULL; 340 } 341 342 static inline void iommu_group_put(struct iommu_group *group) 343 { 344 } 345 346 static inline int iommu_group_register_notifier(struct iommu_group *group, 347 struct notifier_block *nb) 348 { 349 return -ENODEV; 350 } 351 352 static inline int iommu_group_unregister_notifier(struct iommu_group *group, 353 struct notifier_block *nb) 354 { 355 return 0; 356 } 357 358 static inline int iommu_group_id(struct iommu_group *group) 359 { 360 return -ENODEV; 361 } 362 363 static inline int iommu_domain_get_attr(struct iommu_domain *domain, 364 enum iommu_attr attr, void *data) 365 { 366 return -EINVAL; 367 } 368 369 static 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