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/types.h> 24 25 #define IOMMU_READ (1) 26 #define IOMMU_WRITE (2) 27 #define IOMMU_CACHE (4) /* DMA cache coherency */ 28 29 struct iommu_ops; 30 struct iommu_group; 31 struct bus_type; 32 struct device; 33 struct iommu_domain; 34 struct notifier_block; 35 36 /* iommu fault flags */ 37 #define IOMMU_FAULT_READ 0x0 38 #define IOMMU_FAULT_WRITE 0x1 39 40 typedef int (*iommu_fault_handler_t)(struct iommu_domain *, 41 struct device *, unsigned long, int, void *); 42 43 struct 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 49 struct 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 60 enum 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 */ 83 struct 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 113 extern int bus_set_iommu(struct bus_type *bus, struct iommu_ops *ops); 114 extern bool iommu_present(struct bus_type *bus); 115 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus); 116 extern void iommu_domain_free(struct iommu_domain *domain); 117 extern int iommu_attach_device(struct iommu_domain *domain, 118 struct device *dev); 119 extern void iommu_detach_device(struct iommu_domain *domain, 120 struct device *dev); 121 extern int iommu_map(struct iommu_domain *domain, unsigned long iova, 122 phys_addr_t paddr, size_t size, int prot); 123 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova, 124 size_t size); 125 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, 126 unsigned long iova); 127 extern int iommu_domain_has_cap(struct iommu_domain *domain, 128 unsigned long cap); 129 extern void iommu_set_fault_handler(struct iommu_domain *domain, 130 iommu_fault_handler_t handler, void *token); 131 132 extern int iommu_attach_group(struct iommu_domain *domain, 133 struct iommu_group *group); 134 extern void iommu_detach_group(struct iommu_domain *domain, 135 struct iommu_group *group); 136 extern struct iommu_group *iommu_group_alloc(void); 137 extern void *iommu_group_get_iommudata(struct iommu_group *group); 138 extern void iommu_group_set_iommudata(struct iommu_group *group, 139 void *iommu_data, 140 void (*release)(void *iommu_data)); 141 extern int iommu_group_set_name(struct iommu_group *group, const char *name); 142 extern int iommu_group_add_device(struct iommu_group *group, 143 struct device *dev); 144 extern void iommu_group_remove_device(struct device *dev); 145 extern int iommu_group_for_each_dev(struct iommu_group *group, void *data, 146 int (*fn)(struct device *, void *)); 147 extern struct iommu_group *iommu_group_get(struct device *dev); 148 extern void iommu_group_put(struct iommu_group *group); 149 extern int iommu_group_register_notifier(struct iommu_group *group, 150 struct notifier_block *nb); 151 extern int iommu_group_unregister_notifier(struct iommu_group *group, 152 struct notifier_block *nb); 153 extern int iommu_group_id(struct iommu_group *group); 154 155 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr, 156 void *data); 157 extern 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 */ 184 static 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 202 struct iommu_ops {}; 203 struct iommu_group {}; 204 205 static inline bool iommu_present(struct bus_type *bus) 206 { 207 return false; 208 } 209 210 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus) 211 { 212 return NULL; 213 } 214 215 static inline void iommu_domain_free(struct iommu_domain *domain) 216 { 217 } 218 219 static inline int iommu_attach_device(struct iommu_domain *domain, 220 struct device *dev) 221 { 222 return -ENODEV; 223 } 224 225 static inline void iommu_detach_device(struct iommu_domain *domain, 226 struct device *dev) 227 { 228 } 229 230 static 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 236 static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova, 237 int gfp_order) 238 { 239 return -ENODEV; 240 } 241 242 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, 243 unsigned long iova) 244 { 245 return 0; 246 } 247 248 static inline int domain_has_cap(struct iommu_domain *domain, 249 unsigned long cap) 250 { 251 return 0; 252 } 253 254 static inline void iommu_set_fault_handler(struct iommu_domain *domain, 255 iommu_fault_handler_t handler, void *token) 256 { 257 } 258 259 static inline int iommu_attach_group(struct iommu_domain *domain, 260 struct iommu_group *group) 261 { 262 return -ENODEV; 263 } 264 265 static inline void iommu_detach_group(struct iommu_domain *domain, 266 struct iommu_group *group) 267 { 268 } 269 270 static inline struct iommu_group *iommu_group_alloc(void) 271 { 272 return ERR_PTR(-ENODEV); 273 } 274 275 static inline void *iommu_group_get_iommudata(struct iommu_group *group) 276 { 277 return NULL; 278 } 279 280 static inline void iommu_group_set_iommudata(struct iommu_group *group, 281 void *iommu_data, 282 void (*release)(void *iommu_data)) 283 { 284 } 285 286 static inline int iommu_group_set_name(struct iommu_group *group, 287 const char *name) 288 { 289 return -ENODEV; 290 } 291 292 static inline int iommu_group_add_device(struct iommu_group *group, 293 struct device *dev) 294 { 295 return -ENODEV; 296 } 297 298 static inline void iommu_group_remove_device(struct device *dev) 299 { 300 } 301 302 static 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 309 static inline struct iommu_group *iommu_group_get(struct device *dev) 310 { 311 return NULL; 312 } 313 314 static inline void iommu_group_put(struct iommu_group *group) 315 { 316 } 317 318 static inline int iommu_group_register_notifier(struct iommu_group *group, 319 struct notifier_block *nb) 320 { 321 return -ENODEV; 322 } 323 324 static inline int iommu_group_unregister_notifier(struct iommu_group *group, 325 struct notifier_block *nb) 326 { 327 return 0; 328 } 329 330 static inline int iommu_group_id(struct iommu_group *group) 331 { 332 return -ENODEV; 333 } 334 335 static inline int iommu_domain_get_attr(struct iommu_domain *domain, 336 enum iommu_attr attr, void *data) 337 { 338 return -EINVAL; 339 } 340 341 static 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