Merge tag 'for_linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mst/vhost
[linux-2.6-microblaze.git] / include / linux / iommu.h
1 /*
2  * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
3  * Author: Joerg Roedel <joerg.roedel@amd.com>
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/scatterlist.h>
23 #include <linux/device.h>
24 #include <linux/types.h>
25 #include <linux/errno.h>
26 #include <linux/err.h>
27 #include <linux/of.h>
28
29 #define IOMMU_READ      (1 << 0)
30 #define IOMMU_WRITE     (1 << 1)
31 #define IOMMU_CACHE     (1 << 2) /* DMA cache coherency */
32 #define IOMMU_NOEXEC    (1 << 3)
33 #define IOMMU_MMIO      (1 << 4) /* e.g. things like MSI doorbells */
34 /*
35  * Where the bus hardware includes a privilege level as part of its access type
36  * markings, and certain devices are capable of issuing transactions marked as
37  * either 'supervisor' or 'user', the IOMMU_PRIV flag requests that the other
38  * given permission flags only apply to accesses at the higher privilege level,
39  * and that unprivileged transactions should have as little access as possible.
40  * This would usually imply the same permissions as kernel mappings on the CPU,
41  * if the IOMMU page table format is equivalent.
42  */
43 #define IOMMU_PRIV      (1 << 5)
44
45 struct iommu_ops;
46 struct iommu_group;
47 struct bus_type;
48 struct device;
49 struct iommu_domain;
50 struct notifier_block;
51
52 /* iommu fault flags */
53 #define IOMMU_FAULT_READ        0x0
54 #define IOMMU_FAULT_WRITE       0x1
55
56 typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
57                         struct device *, unsigned long, int, void *);
58
59 struct iommu_domain_geometry {
60         dma_addr_t aperture_start; /* First address that can be mapped    */
61         dma_addr_t aperture_end;   /* Last address that can be mapped     */
62         bool force_aperture;       /* DMA only allowed in mappable range? */
63 };
64
65 /* Domain feature flags */
66 #define __IOMMU_DOMAIN_PAGING   (1U << 0)  /* Support for iommu_map/unmap */
67 #define __IOMMU_DOMAIN_DMA_API  (1U << 1)  /* Domain for use in DMA-API
68                                               implementation              */
69 #define __IOMMU_DOMAIN_PT       (1U << 2)  /* Domain is identity mapped   */
70
71 /*
72  * This are the possible domain-types
73  *
74  *      IOMMU_DOMAIN_BLOCKED    - All DMA is blocked, can be used to isolate
75  *                                devices
76  *      IOMMU_DOMAIN_IDENTITY   - DMA addresses are system physical addresses
77  *      IOMMU_DOMAIN_UNMANAGED  - DMA mappings managed by IOMMU-API user, used
78  *                                for VMs
79  *      IOMMU_DOMAIN_DMA        - Internally used for DMA-API implementations.
80  *                                This flag allows IOMMU drivers to implement
81  *                                certain optimizations for these domains
82  */
83 #define IOMMU_DOMAIN_BLOCKED    (0U)
84 #define IOMMU_DOMAIN_IDENTITY   (__IOMMU_DOMAIN_PT)
85 #define IOMMU_DOMAIN_UNMANAGED  (__IOMMU_DOMAIN_PAGING)
86 #define IOMMU_DOMAIN_DMA        (__IOMMU_DOMAIN_PAGING |        \
87                                  __IOMMU_DOMAIN_DMA_API)
88
89 struct iommu_domain {
90         unsigned type;
91         const struct iommu_ops *ops;
92         unsigned long pgsize_bitmap;    /* Bitmap of page sizes in use */
93         iommu_fault_handler_t handler;
94         void *handler_token;
95         struct iommu_domain_geometry geometry;
96         void *iova_cookie;
97 };
98
99 enum iommu_cap {
100         IOMMU_CAP_CACHE_COHERENCY,      /* IOMMU can enforce cache coherent DMA
101                                            transactions */
102         IOMMU_CAP_INTR_REMAP,           /* IOMMU supports interrupt isolation */
103         IOMMU_CAP_NOEXEC,               /* IOMMU_NOEXEC flag */
104 };
105
106 /*
107  * Following constraints are specifc to FSL_PAMUV1:
108  *  -aperture must be power of 2, and naturally aligned
109  *  -number of windows must be power of 2, and address space size
110  *   of each window is determined by aperture size / # of windows
111  *  -the actual size of the mapped region of a window must be power
112  *   of 2 starting with 4KB and physical address must be naturally
113  *   aligned.
114  * DOMAIN_ATTR_FSL_PAMUV1 corresponds to the above mentioned contraints.
115  * The caller can invoke iommu_domain_get_attr to check if the underlying
116  * iommu implementation supports these constraints.
117  */
118
119 enum iommu_attr {
120         DOMAIN_ATTR_GEOMETRY,
121         DOMAIN_ATTR_PAGING,
122         DOMAIN_ATTR_WINDOWS,
123         DOMAIN_ATTR_FSL_PAMU_STASH,
124         DOMAIN_ATTR_FSL_PAMU_ENABLE,
125         DOMAIN_ATTR_FSL_PAMUV1,
126         DOMAIN_ATTR_NESTING,    /* two stages of translation */
127         DOMAIN_ATTR_MAX,
128 };
129
130 /* These are the possible reserved region types */
131 enum iommu_resv_type {
132         /* Memory regions which must be mapped 1:1 at all times */
133         IOMMU_RESV_DIRECT,
134         /* Arbitrary "never map this or give it to a device" address ranges */
135         IOMMU_RESV_RESERVED,
136         /* Hardware MSI region (untranslated) */
137         IOMMU_RESV_MSI,
138         /* Software-managed MSI translation window */
139         IOMMU_RESV_SW_MSI,
140 };
141
142 /**
143  * struct iommu_resv_region - descriptor for a reserved memory region
144  * @list: Linked list pointers
145  * @start: System physical start address of the region
146  * @length: Length of the region in bytes
147  * @prot: IOMMU Protection flags (READ/WRITE/...)
148  * @type: Type of the reserved region
149  */
150 struct iommu_resv_region {
151         struct list_head        list;
152         phys_addr_t             start;
153         size_t                  length;
154         int                     prot;
155         enum iommu_resv_type    type;
156 };
157
158 #ifdef CONFIG_IOMMU_API
159
160 /**
161  * struct iommu_ops - iommu ops and capabilities
162  * @capable: check capability
163  * @domain_alloc: allocate iommu domain
164  * @domain_free: free iommu domain
165  * @attach_dev: attach device to an iommu domain
166  * @detach_dev: detach device from an iommu domain
167  * @map: map a physically contiguous memory region to an iommu domain
168  * @unmap: unmap a physically contiguous memory region from an iommu domain
169  * @map_sg: map a scatter-gather list of physically contiguous memory chunks
170  *          to an iommu domain
171  * @flush_tlb_all: Synchronously flush all hardware TLBs for this domain
172  * @tlb_range_add: Add a given iova range to the flush queue for this domain
173  * @tlb_sync: Flush all queued ranges from the hardware TLBs and empty flush
174  *            queue
175  * @iova_to_phys: translate iova to physical address
176  * @add_device: add device to iommu grouping
177  * @remove_device: remove device from iommu grouping
178  * @device_group: find iommu group for a particular device
179  * @domain_get_attr: Query domain attributes
180  * @domain_set_attr: Change domain attributes
181  * @get_resv_regions: Request list of reserved regions for a device
182  * @put_resv_regions: Free list of reserved regions for a device
183  * @apply_resv_region: Temporary helper call-back for iova reserved ranges
184  * @domain_window_enable: Configure and enable a particular window for a domain
185  * @domain_window_disable: Disable a particular window for a domain
186  * @domain_set_windows: Set the number of windows for a domain
187  * @domain_get_windows: Return the number of windows for a domain
188  * @of_xlate: add OF master IDs to iommu grouping
189  * @pgsize_bitmap: bitmap of all possible supported page sizes
190  */
191 struct iommu_ops {
192         bool (*capable)(enum iommu_cap);
193
194         /* Domain allocation and freeing by the iommu driver */
195         struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
196         void (*domain_free)(struct iommu_domain *);
197
198         int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
199         void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
200         int (*map)(struct iommu_domain *domain, unsigned long iova,
201                    phys_addr_t paddr, size_t size, int prot);
202         size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
203                      size_t size);
204         size_t (*map_sg)(struct iommu_domain *domain, unsigned long iova,
205                          struct scatterlist *sg, unsigned int nents, int prot);
206         void (*flush_iotlb_all)(struct iommu_domain *domain);
207         void (*iotlb_range_add)(struct iommu_domain *domain,
208                                 unsigned long iova, size_t size);
209         void (*iotlb_sync)(struct iommu_domain *domain);
210         phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
211         int (*add_device)(struct device *dev);
212         void (*remove_device)(struct device *dev);
213         struct iommu_group *(*device_group)(struct device *dev);
214         int (*domain_get_attr)(struct iommu_domain *domain,
215                                enum iommu_attr attr, void *data);
216         int (*domain_set_attr)(struct iommu_domain *domain,
217                                enum iommu_attr attr, void *data);
218
219         /* Request/Free a list of reserved regions for a device */
220         void (*get_resv_regions)(struct device *dev, struct list_head *list);
221         void (*put_resv_regions)(struct device *dev, struct list_head *list);
222         void (*apply_resv_region)(struct device *dev,
223                                   struct iommu_domain *domain,
224                                   struct iommu_resv_region *region);
225
226         /* Window handling functions */
227         int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
228                                     phys_addr_t paddr, u64 size, int prot);
229         void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
230         /* Set the number of windows per domain */
231         int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
232         /* Get the number of windows per domain */
233         u32 (*domain_get_windows)(struct iommu_domain *domain);
234
235         int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
236         bool (*is_attach_deferred)(struct iommu_domain *domain, struct device *dev);
237
238         unsigned long pgsize_bitmap;
239 };
240
241 /**
242  * struct iommu_device - IOMMU core representation of one IOMMU hardware
243  *                       instance
244  * @list: Used by the iommu-core to keep a list of registered iommus
245  * @ops: iommu-ops for talking to this iommu
246  * @dev: struct device for sysfs handling
247  */
248 struct iommu_device {
249         struct list_head list;
250         const struct iommu_ops *ops;
251         struct fwnode_handle *fwnode;
252         struct device *dev;
253 };
254
255 int  iommu_device_register(struct iommu_device *iommu);
256 void iommu_device_unregister(struct iommu_device *iommu);
257 int  iommu_device_sysfs_add(struct iommu_device *iommu,
258                             struct device *parent,
259                             const struct attribute_group **groups,
260                             const char *fmt, ...) __printf(4, 5);
261 void iommu_device_sysfs_remove(struct iommu_device *iommu);
262 int  iommu_device_link(struct iommu_device   *iommu, struct device *link);
263 void iommu_device_unlink(struct iommu_device *iommu, struct device *link);
264
265 static inline void iommu_device_set_ops(struct iommu_device *iommu,
266                                         const struct iommu_ops *ops)
267 {
268         iommu->ops = ops;
269 }
270
271 static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
272                                            struct fwnode_handle *fwnode)
273 {
274         iommu->fwnode = fwnode;
275 }
276
277 static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
278 {
279         return (struct iommu_device *)dev_get_drvdata(dev);
280 }
281
282 #define IOMMU_GROUP_NOTIFY_ADD_DEVICE           1 /* Device added */
283 #define IOMMU_GROUP_NOTIFY_DEL_DEVICE           2 /* Pre Device removed */
284 #define IOMMU_GROUP_NOTIFY_BIND_DRIVER          3 /* Pre Driver bind */
285 #define IOMMU_GROUP_NOTIFY_BOUND_DRIVER         4 /* Post Driver bind */
286 #define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER        5 /* Pre Driver unbind */
287 #define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER       6 /* Post Driver unbind */
288
289 extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
290 extern bool iommu_present(struct bus_type *bus);
291 extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
292 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
293 extern struct iommu_group *iommu_group_get_by_id(int id);
294 extern void iommu_domain_free(struct iommu_domain *domain);
295 extern int iommu_attach_device(struct iommu_domain *domain,
296                                struct device *dev);
297 extern void iommu_detach_device(struct iommu_domain *domain,
298                                 struct device *dev);
299 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
300 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
301                      phys_addr_t paddr, size_t size, int prot);
302 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
303                           size_t size);
304 extern size_t iommu_unmap_fast(struct iommu_domain *domain,
305                                unsigned long iova, size_t size);
306 extern size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
307                                 struct scatterlist *sg,unsigned int nents,
308                                 int prot);
309 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
310 extern void iommu_set_fault_handler(struct iommu_domain *domain,
311                         iommu_fault_handler_t handler, void *token);
312
313 extern void iommu_get_resv_regions(struct device *dev, struct list_head *list);
314 extern void iommu_put_resv_regions(struct device *dev, struct list_head *list);
315 extern int iommu_request_dm_for_dev(struct device *dev);
316 extern struct iommu_resv_region *
317 iommu_alloc_resv_region(phys_addr_t start, size_t length, int prot,
318                         enum iommu_resv_type type);
319 extern int iommu_get_group_resv_regions(struct iommu_group *group,
320                                         struct list_head *head);
321
322 extern int iommu_attach_group(struct iommu_domain *domain,
323                               struct iommu_group *group);
324 extern void iommu_detach_group(struct iommu_domain *domain,
325                                struct iommu_group *group);
326 extern struct iommu_group *iommu_group_alloc(void);
327 extern void *iommu_group_get_iommudata(struct iommu_group *group);
328 extern void iommu_group_set_iommudata(struct iommu_group *group,
329                                       void *iommu_data,
330                                       void (*release)(void *iommu_data));
331 extern int iommu_group_set_name(struct iommu_group *group, const char *name);
332 extern int iommu_group_add_device(struct iommu_group *group,
333                                   struct device *dev);
334 extern void iommu_group_remove_device(struct device *dev);
335 extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
336                                     int (*fn)(struct device *, void *));
337 extern struct iommu_group *iommu_group_get(struct device *dev);
338 extern struct iommu_group *iommu_group_ref_get(struct iommu_group *group);
339 extern void iommu_group_put(struct iommu_group *group);
340 extern int iommu_group_register_notifier(struct iommu_group *group,
341                                          struct notifier_block *nb);
342 extern int iommu_group_unregister_notifier(struct iommu_group *group,
343                                            struct notifier_block *nb);
344 extern int iommu_group_id(struct iommu_group *group);
345 extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
346 extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
347
348 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
349                                  void *data);
350 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
351                                  void *data);
352
353 /* Window handling function prototypes */
354 extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
355                                       phys_addr_t offset, u64 size,
356                                       int prot);
357 extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
358
359 extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
360                               unsigned long iova, int flags);
361
362 static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
363 {
364         if (domain->ops->flush_iotlb_all)
365                 domain->ops->flush_iotlb_all(domain);
366 }
367
368 static inline void iommu_tlb_range_add(struct iommu_domain *domain,
369                                        unsigned long iova, size_t size)
370 {
371         if (domain->ops->iotlb_range_add)
372                 domain->ops->iotlb_range_add(domain, iova, size);
373 }
374
375 static inline void iommu_tlb_sync(struct iommu_domain *domain)
376 {
377         if (domain->ops->iotlb_sync)
378                 domain->ops->iotlb_sync(domain);
379 }
380
381 static inline size_t iommu_map_sg(struct iommu_domain *domain,
382                                   unsigned long iova, struct scatterlist *sg,
383                                   unsigned int nents, int prot)
384 {
385         return domain->ops->map_sg(domain, iova, sg, nents, prot);
386 }
387
388 /* PCI device grouping function */
389 extern struct iommu_group *pci_device_group(struct device *dev);
390 /* Generic device grouping function */
391 extern struct iommu_group *generic_device_group(struct device *dev);
392
393 /**
394  * struct iommu_fwspec - per-device IOMMU instance data
395  * @ops: ops for this device's IOMMU
396  * @iommu_fwnode: firmware handle for this device's IOMMU
397  * @iommu_priv: IOMMU driver private data for this device
398  * @num_ids: number of associated device IDs
399  * @ids: IDs which this device may present to the IOMMU
400  */
401 struct iommu_fwspec {
402         const struct iommu_ops  *ops;
403         struct fwnode_handle    *iommu_fwnode;
404         void                    *iommu_priv;
405         unsigned int            num_ids;
406         u32                     ids[1];
407 };
408
409 int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
410                       const struct iommu_ops *ops);
411 void iommu_fwspec_free(struct device *dev);
412 int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids);
413 const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode);
414
415 #else /* CONFIG_IOMMU_API */
416
417 struct iommu_ops {};
418 struct iommu_group {};
419 struct iommu_fwspec {};
420 struct iommu_device {};
421
422 static inline bool iommu_present(struct bus_type *bus)
423 {
424         return false;
425 }
426
427 static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
428 {
429         return false;
430 }
431
432 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
433 {
434         return NULL;
435 }
436
437 static inline struct iommu_group *iommu_group_get_by_id(int id)
438 {
439         return NULL;
440 }
441
442 static inline void iommu_domain_free(struct iommu_domain *domain)
443 {
444 }
445
446 static inline int iommu_attach_device(struct iommu_domain *domain,
447                                       struct device *dev)
448 {
449         return -ENODEV;
450 }
451
452 static inline void iommu_detach_device(struct iommu_domain *domain,
453                                        struct device *dev)
454 {
455 }
456
457 static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
458 {
459         return NULL;
460 }
461
462 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
463                             phys_addr_t paddr, size_t size, int prot)
464 {
465         return -ENODEV;
466 }
467
468 static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
469                               size_t size)
470 {
471         return -ENODEV;
472 }
473
474 static inline int iommu_unmap_fast(struct iommu_domain *domain, unsigned long iova,
475                                    int gfp_order)
476 {
477         return -ENODEV;
478 }
479
480 static inline size_t iommu_map_sg(struct iommu_domain *domain,
481                                   unsigned long iova, struct scatterlist *sg,
482                                   unsigned int nents, int prot)
483 {
484         return -ENODEV;
485 }
486
487 static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
488 {
489 }
490
491 static inline void iommu_tlb_range_add(struct iommu_domain *domain,
492                                        unsigned long iova, size_t size)
493 {
494 }
495
496 static inline void iommu_tlb_sync(struct iommu_domain *domain)
497 {
498 }
499
500 static inline int iommu_domain_window_enable(struct iommu_domain *domain,
501                                              u32 wnd_nr, phys_addr_t paddr,
502                                              u64 size, int prot)
503 {
504         return -ENODEV;
505 }
506
507 static inline void iommu_domain_window_disable(struct iommu_domain *domain,
508                                                u32 wnd_nr)
509 {
510 }
511
512 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
513 {
514         return 0;
515 }
516
517 static inline void iommu_set_fault_handler(struct iommu_domain *domain,
518                                 iommu_fault_handler_t handler, void *token)
519 {
520 }
521
522 static inline void iommu_get_resv_regions(struct device *dev,
523                                         struct list_head *list)
524 {
525 }
526
527 static inline void iommu_put_resv_regions(struct device *dev,
528                                         struct list_head *list)
529 {
530 }
531
532 static inline int iommu_get_group_resv_regions(struct iommu_group *group,
533                                                struct list_head *head)
534 {
535         return -ENODEV;
536 }
537
538 static inline int iommu_request_dm_for_dev(struct device *dev)
539 {
540         return -ENODEV;
541 }
542
543 static inline int iommu_attach_group(struct iommu_domain *domain,
544                                      struct iommu_group *group)
545 {
546         return -ENODEV;
547 }
548
549 static inline void iommu_detach_group(struct iommu_domain *domain,
550                                       struct iommu_group *group)
551 {
552 }
553
554 static inline struct iommu_group *iommu_group_alloc(void)
555 {
556         return ERR_PTR(-ENODEV);
557 }
558
559 static inline void *iommu_group_get_iommudata(struct iommu_group *group)
560 {
561         return NULL;
562 }
563
564 static inline void iommu_group_set_iommudata(struct iommu_group *group,
565                                              void *iommu_data,
566                                              void (*release)(void *iommu_data))
567 {
568 }
569
570 static inline int iommu_group_set_name(struct iommu_group *group,
571                                        const char *name)
572 {
573         return -ENODEV;
574 }
575
576 static inline int iommu_group_add_device(struct iommu_group *group,
577                                          struct device *dev)
578 {
579         return -ENODEV;
580 }
581
582 static inline void iommu_group_remove_device(struct device *dev)
583 {
584 }
585
586 static inline int iommu_group_for_each_dev(struct iommu_group *group,
587                                            void *data,
588                                            int (*fn)(struct device *, void *))
589 {
590         return -ENODEV;
591 }
592
593 static inline struct iommu_group *iommu_group_get(struct device *dev)
594 {
595         return NULL;
596 }
597
598 static inline void iommu_group_put(struct iommu_group *group)
599 {
600 }
601
602 static inline int iommu_group_register_notifier(struct iommu_group *group,
603                                                 struct notifier_block *nb)
604 {
605         return -ENODEV;
606 }
607
608 static inline int iommu_group_unregister_notifier(struct iommu_group *group,
609                                                   struct notifier_block *nb)
610 {
611         return 0;
612 }
613
614 static inline int iommu_group_id(struct iommu_group *group)
615 {
616         return -ENODEV;
617 }
618
619 static inline int iommu_domain_get_attr(struct iommu_domain *domain,
620                                         enum iommu_attr attr, void *data)
621 {
622         return -EINVAL;
623 }
624
625 static inline int iommu_domain_set_attr(struct iommu_domain *domain,
626                                         enum iommu_attr attr, void *data)
627 {
628         return -EINVAL;
629 }
630
631 static inline int  iommu_device_register(struct iommu_device *iommu)
632 {
633         return -ENODEV;
634 }
635
636 static inline void iommu_device_set_ops(struct iommu_device *iommu,
637                                         const struct iommu_ops *ops)
638 {
639 }
640
641 static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
642                                            struct fwnode_handle *fwnode)
643 {
644 }
645
646 static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
647 {
648         return NULL;
649 }
650
651 static inline void iommu_device_unregister(struct iommu_device *iommu)
652 {
653 }
654
655 static inline int  iommu_device_sysfs_add(struct iommu_device *iommu,
656                                           struct device *parent,
657                                           const struct attribute_group **groups,
658                                           const char *fmt, ...)
659 {
660         return -ENODEV;
661 }
662
663 static inline void iommu_device_sysfs_remove(struct iommu_device *iommu)
664 {
665 }
666
667 static inline int iommu_device_link(struct device *dev, struct device *link)
668 {
669         return -EINVAL;
670 }
671
672 static inline void iommu_device_unlink(struct device *dev, struct device *link)
673 {
674 }
675
676 static inline int iommu_fwspec_init(struct device *dev,
677                                     struct fwnode_handle *iommu_fwnode,
678                                     const struct iommu_ops *ops)
679 {
680         return -ENODEV;
681 }
682
683 static inline void iommu_fwspec_free(struct device *dev)
684 {
685 }
686
687 static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,
688                                        int num_ids)
689 {
690         return -ENODEV;
691 }
692
693 static inline
694 const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
695 {
696         return NULL;
697 }
698
699 #endif /* CONFIG_IOMMU_API */
700
701 #endif /* __LINUX_IOMMU_H */