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