xref: /linux-6.15/include/linux/iommu.h (revision ca138a7a)
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/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_DMA_USE_FLUSH_QUEUE,
128 	DOMAIN_ATTR_MAX,
129 };
130 
131 /* These are the possible reserved region types */
132 enum iommu_resv_type {
133 	/* Memory regions which must be mapped 1:1 at all times */
134 	IOMMU_RESV_DIRECT,
135 	/* Arbitrary "never map this or give it to a device" address ranges */
136 	IOMMU_RESV_RESERVED,
137 	/* Hardware MSI region (untranslated) */
138 	IOMMU_RESV_MSI,
139 	/* Software-managed MSI translation window */
140 	IOMMU_RESV_SW_MSI,
141 };
142 
143 /**
144  * struct iommu_resv_region - descriptor for a reserved memory region
145  * @list: Linked list pointers
146  * @start: System physical start address of the region
147  * @length: Length of the region in bytes
148  * @prot: IOMMU Protection flags (READ/WRITE/...)
149  * @type: Type of the reserved region
150  */
151 struct iommu_resv_region {
152 	struct list_head	list;
153 	phys_addr_t		start;
154 	size_t			length;
155 	int			prot;
156 	enum iommu_resv_type	type;
157 };
158 
159 #ifdef CONFIG_IOMMU_API
160 
161 /**
162  * struct iommu_ops - iommu ops and capabilities
163  * @capable: check capability
164  * @domain_alloc: allocate iommu domain
165  * @domain_free: free iommu domain
166  * @attach_dev: attach device to an iommu domain
167  * @detach_dev: detach device from an iommu domain
168  * @map: map a physically contiguous memory region to an iommu domain
169  * @unmap: unmap a physically contiguous memory region from an iommu domain
170  * @flush_iotlb_all: Synchronously flush all hardware TLBs for this domain
171  * @iotlb_range_add: Add a given iova range to the flush queue for this domain
172  * @iotlb_sync_map: Sync mappings created recently using @map to the hardware
173  * @iotlb_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  * @of_xlate: add OF master IDs to iommu grouping
187  * @is_attach_deferred: Check if domain attach should be deferred from iommu
188  *                      driver init to device driver init (default no)
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 	void (*flush_iotlb_all)(struct iommu_domain *domain);
205 	void (*iotlb_range_add)(struct iommu_domain *domain,
206 				unsigned long iova, size_t size);
207 	void (*iotlb_sync_map)(struct iommu_domain *domain);
208 	void (*iotlb_sync)(struct iommu_domain *domain);
209 	phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
210 	int (*add_device)(struct device *dev);
211 	void (*remove_device)(struct device *dev);
212 	struct iommu_group *(*device_group)(struct device *dev);
213 	int (*domain_get_attr)(struct iommu_domain *domain,
214 			       enum iommu_attr attr, void *data);
215 	int (*domain_set_attr)(struct iommu_domain *domain,
216 			       enum iommu_attr attr, void *data);
217 
218 	/* Request/Free a list of reserved regions for a device */
219 	void (*get_resv_regions)(struct device *dev, struct list_head *list);
220 	void (*put_resv_regions)(struct device *dev, struct list_head *list);
221 	void (*apply_resv_region)(struct device *dev,
222 				  struct iommu_domain *domain,
223 				  struct iommu_resv_region *region);
224 
225 	/* Window handling functions */
226 	int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
227 				    phys_addr_t paddr, u64 size, int prot);
228 	void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
229 
230 	int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
231 	bool (*is_attach_deferred)(struct iommu_domain *domain, struct device *dev);
232 
233 	unsigned long pgsize_bitmap;
234 };
235 
236 /**
237  * struct iommu_device - IOMMU core representation of one IOMMU hardware
238  *			 instance
239  * @list: Used by the iommu-core to keep a list of registered iommus
240  * @ops: iommu-ops for talking to this iommu
241  * @dev: struct device for sysfs handling
242  */
243 struct iommu_device {
244 	struct list_head list;
245 	const struct iommu_ops *ops;
246 	struct fwnode_handle *fwnode;
247 	struct device *dev;
248 };
249 
250 int  iommu_device_register(struct iommu_device *iommu);
251 void iommu_device_unregister(struct iommu_device *iommu);
252 int  iommu_device_sysfs_add(struct iommu_device *iommu,
253 			    struct device *parent,
254 			    const struct attribute_group **groups,
255 			    const char *fmt, ...) __printf(4, 5);
256 void iommu_device_sysfs_remove(struct iommu_device *iommu);
257 int  iommu_device_link(struct iommu_device   *iommu, struct device *link);
258 void iommu_device_unlink(struct iommu_device *iommu, struct device *link);
259 
260 static inline void iommu_device_set_ops(struct iommu_device *iommu,
261 					const struct iommu_ops *ops)
262 {
263 	iommu->ops = ops;
264 }
265 
266 static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
267 					   struct fwnode_handle *fwnode)
268 {
269 	iommu->fwnode = fwnode;
270 }
271 
272 static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
273 {
274 	return (struct iommu_device *)dev_get_drvdata(dev);
275 }
276 
277 #define IOMMU_GROUP_NOTIFY_ADD_DEVICE		1 /* Device added */
278 #define IOMMU_GROUP_NOTIFY_DEL_DEVICE		2 /* Pre Device removed */
279 #define IOMMU_GROUP_NOTIFY_BIND_DRIVER		3 /* Pre Driver bind */
280 #define IOMMU_GROUP_NOTIFY_BOUND_DRIVER		4 /* Post Driver bind */
281 #define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER	5 /* Pre Driver unbind */
282 #define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER	6 /* Post Driver unbind */
283 
284 extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
285 extern bool iommu_present(struct bus_type *bus);
286 extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
287 extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
288 extern struct iommu_group *iommu_group_get_by_id(int id);
289 extern void iommu_domain_free(struct iommu_domain *domain);
290 extern int iommu_attach_device(struct iommu_domain *domain,
291 			       struct device *dev);
292 extern void iommu_detach_device(struct iommu_domain *domain,
293 				struct device *dev);
294 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
295 extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
296 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
297 		     phys_addr_t paddr, size_t size, int prot);
298 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
299 			  size_t size);
300 extern size_t iommu_unmap_fast(struct iommu_domain *domain,
301 			       unsigned long iova, size_t size);
302 extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
303 			   struct scatterlist *sg,unsigned int nents, int prot);
304 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
305 extern void iommu_set_fault_handler(struct iommu_domain *domain,
306 			iommu_fault_handler_t handler, void *token);
307 
308 extern void iommu_get_resv_regions(struct device *dev, struct list_head *list);
309 extern void iommu_put_resv_regions(struct device *dev, struct list_head *list);
310 extern int iommu_request_dm_for_dev(struct device *dev);
311 extern struct iommu_resv_region *
312 iommu_alloc_resv_region(phys_addr_t start, size_t length, int prot,
313 			enum iommu_resv_type type);
314 extern int iommu_get_group_resv_regions(struct iommu_group *group,
315 					struct list_head *head);
316 
317 extern int iommu_attach_group(struct iommu_domain *domain,
318 			      struct iommu_group *group);
319 extern void iommu_detach_group(struct iommu_domain *domain,
320 			       struct iommu_group *group);
321 extern struct iommu_group *iommu_group_alloc(void);
322 extern void *iommu_group_get_iommudata(struct iommu_group *group);
323 extern void iommu_group_set_iommudata(struct iommu_group *group,
324 				      void *iommu_data,
325 				      void (*release)(void *iommu_data));
326 extern int iommu_group_set_name(struct iommu_group *group, const char *name);
327 extern int iommu_group_add_device(struct iommu_group *group,
328 				  struct device *dev);
329 extern void iommu_group_remove_device(struct device *dev);
330 extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
331 				    int (*fn)(struct device *, void *));
332 extern struct iommu_group *iommu_group_get(struct device *dev);
333 extern struct iommu_group *iommu_group_ref_get(struct iommu_group *group);
334 extern void iommu_group_put(struct iommu_group *group);
335 extern int iommu_group_register_notifier(struct iommu_group *group,
336 					 struct notifier_block *nb);
337 extern int iommu_group_unregister_notifier(struct iommu_group *group,
338 					   struct notifier_block *nb);
339 extern int iommu_group_id(struct iommu_group *group);
340 extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
341 extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
342 
343 extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
344 				 void *data);
345 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
346 				 void *data);
347 
348 /* Window handling function prototypes */
349 extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
350 				      phys_addr_t offset, u64 size,
351 				      int prot);
352 extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
353 
354 extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
355 			      unsigned long iova, int flags);
356 
357 static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
358 {
359 	if (domain->ops->flush_iotlb_all)
360 		domain->ops->flush_iotlb_all(domain);
361 }
362 
363 static inline void iommu_tlb_range_add(struct iommu_domain *domain,
364 				       unsigned long iova, size_t size)
365 {
366 	if (domain->ops->iotlb_range_add)
367 		domain->ops->iotlb_range_add(domain, iova, size);
368 }
369 
370 static inline void iommu_tlb_sync(struct iommu_domain *domain)
371 {
372 	if (domain->ops->iotlb_sync)
373 		domain->ops->iotlb_sync(domain);
374 }
375 
376 /* PCI device grouping function */
377 extern struct iommu_group *pci_device_group(struct device *dev);
378 /* Generic device grouping function */
379 extern struct iommu_group *generic_device_group(struct device *dev);
380 /* FSL-MC device grouping function */
381 struct iommu_group *fsl_mc_device_group(struct device *dev);
382 
383 /**
384  * struct iommu_fwspec - per-device IOMMU instance data
385  * @ops: ops for this device's IOMMU
386  * @iommu_fwnode: firmware handle for this device's IOMMU
387  * @iommu_priv: IOMMU driver private data for this device
388  * @num_ids: number of associated device IDs
389  * @ids: IDs which this device may present to the IOMMU
390  */
391 struct iommu_fwspec {
392 	const struct iommu_ops	*ops;
393 	struct fwnode_handle	*iommu_fwnode;
394 	void			*iommu_priv;
395 	unsigned int		num_ids;
396 	u32			ids[1];
397 };
398 
399 int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
400 		      const struct iommu_ops *ops);
401 void iommu_fwspec_free(struct device *dev);
402 int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids);
403 const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode);
404 
405 static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
406 {
407 	return dev->iommu_fwspec;
408 }
409 
410 static inline void dev_iommu_fwspec_set(struct device *dev,
411 					struct iommu_fwspec *fwspec)
412 {
413 	dev->iommu_fwspec = fwspec;
414 }
415 
416 int iommu_probe_device(struct device *dev);
417 void iommu_release_device(struct device *dev);
418 
419 #else /* CONFIG_IOMMU_API */
420 
421 struct iommu_ops {};
422 struct iommu_group {};
423 struct iommu_fwspec {};
424 struct iommu_device {};
425 
426 static inline bool iommu_present(struct bus_type *bus)
427 {
428 	return false;
429 }
430 
431 static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
432 {
433 	return false;
434 }
435 
436 static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
437 {
438 	return NULL;
439 }
440 
441 static inline struct iommu_group *iommu_group_get_by_id(int id)
442 {
443 	return NULL;
444 }
445 
446 static inline void iommu_domain_free(struct iommu_domain *domain)
447 {
448 }
449 
450 static inline int iommu_attach_device(struct iommu_domain *domain,
451 				      struct device *dev)
452 {
453 	return -ENODEV;
454 }
455 
456 static inline void iommu_detach_device(struct iommu_domain *domain,
457 				       struct device *dev)
458 {
459 }
460 
461 static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
462 {
463 	return NULL;
464 }
465 
466 static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
467 			    phys_addr_t paddr, size_t size, int prot)
468 {
469 	return -ENODEV;
470 }
471 
472 static inline size_t iommu_unmap(struct iommu_domain *domain,
473 				 unsigned long iova, size_t size)
474 {
475 	return 0;
476 }
477 
478 static inline size_t iommu_unmap_fast(struct iommu_domain *domain,
479 				      unsigned long iova, int gfp_order)
480 {
481 	return 0;
482 }
483 
484 static inline size_t iommu_map_sg(struct iommu_domain *domain,
485 				  unsigned long iova, struct scatterlist *sg,
486 				  unsigned int nents, int prot)
487 {
488 	return 0;
489 }
490 
491 static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
492 {
493 }
494 
495 static inline void iommu_tlb_range_add(struct iommu_domain *domain,
496 				       unsigned long iova, size_t size)
497 {
498 }
499 
500 static inline void iommu_tlb_sync(struct iommu_domain *domain)
501 {
502 }
503 
504 static inline int iommu_domain_window_enable(struct iommu_domain *domain,
505 					     u32 wnd_nr, phys_addr_t paddr,
506 					     u64 size, int prot)
507 {
508 	return -ENODEV;
509 }
510 
511 static inline void iommu_domain_window_disable(struct iommu_domain *domain,
512 					       u32 wnd_nr)
513 {
514 }
515 
516 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
517 {
518 	return 0;
519 }
520 
521 static inline void iommu_set_fault_handler(struct iommu_domain *domain,
522 				iommu_fault_handler_t handler, void *token)
523 {
524 }
525 
526 static inline void iommu_get_resv_regions(struct device *dev,
527 					struct list_head *list)
528 {
529 }
530 
531 static inline void iommu_put_resv_regions(struct device *dev,
532 					struct list_head *list)
533 {
534 }
535 
536 static inline int iommu_get_group_resv_regions(struct iommu_group *group,
537 					       struct list_head *head)
538 {
539 	return -ENODEV;
540 }
541 
542 static inline int iommu_request_dm_for_dev(struct device *dev)
543 {
544 	return -ENODEV;
545 }
546 
547 static inline int iommu_attach_group(struct iommu_domain *domain,
548 				     struct iommu_group *group)
549 {
550 	return -ENODEV;
551 }
552 
553 static inline void iommu_detach_group(struct iommu_domain *domain,
554 				      struct iommu_group *group)
555 {
556 }
557 
558 static inline struct iommu_group *iommu_group_alloc(void)
559 {
560 	return ERR_PTR(-ENODEV);
561 }
562 
563 static inline void *iommu_group_get_iommudata(struct iommu_group *group)
564 {
565 	return NULL;
566 }
567 
568 static inline void iommu_group_set_iommudata(struct iommu_group *group,
569 					     void *iommu_data,
570 					     void (*release)(void *iommu_data))
571 {
572 }
573 
574 static inline int iommu_group_set_name(struct iommu_group *group,
575 				       const char *name)
576 {
577 	return -ENODEV;
578 }
579 
580 static inline int iommu_group_add_device(struct iommu_group *group,
581 					 struct device *dev)
582 {
583 	return -ENODEV;
584 }
585 
586 static inline void iommu_group_remove_device(struct device *dev)
587 {
588 }
589 
590 static inline int iommu_group_for_each_dev(struct iommu_group *group,
591 					   void *data,
592 					   int (*fn)(struct device *, void *))
593 {
594 	return -ENODEV;
595 }
596 
597 static inline struct iommu_group *iommu_group_get(struct device *dev)
598 {
599 	return NULL;
600 }
601 
602 static inline void iommu_group_put(struct iommu_group *group)
603 {
604 }
605 
606 static inline int iommu_group_register_notifier(struct iommu_group *group,
607 						struct notifier_block *nb)
608 {
609 	return -ENODEV;
610 }
611 
612 static inline int iommu_group_unregister_notifier(struct iommu_group *group,
613 						  struct notifier_block *nb)
614 {
615 	return 0;
616 }
617 
618 static inline int iommu_group_id(struct iommu_group *group)
619 {
620 	return -ENODEV;
621 }
622 
623 static inline int iommu_domain_get_attr(struct iommu_domain *domain,
624 					enum iommu_attr attr, void *data)
625 {
626 	return -EINVAL;
627 }
628 
629 static inline int iommu_domain_set_attr(struct iommu_domain *domain,
630 					enum iommu_attr attr, void *data)
631 {
632 	return -EINVAL;
633 }
634 
635 static inline int  iommu_device_register(struct iommu_device *iommu)
636 {
637 	return -ENODEV;
638 }
639 
640 static inline void iommu_device_set_ops(struct iommu_device *iommu,
641 					const struct iommu_ops *ops)
642 {
643 }
644 
645 static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
646 					   struct fwnode_handle *fwnode)
647 {
648 }
649 
650 static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
651 {
652 	return NULL;
653 }
654 
655 static inline void iommu_device_unregister(struct iommu_device *iommu)
656 {
657 }
658 
659 static inline int  iommu_device_sysfs_add(struct iommu_device *iommu,
660 					  struct device *parent,
661 					  const struct attribute_group **groups,
662 					  const char *fmt, ...)
663 {
664 	return -ENODEV;
665 }
666 
667 static inline void iommu_device_sysfs_remove(struct iommu_device *iommu)
668 {
669 }
670 
671 static inline int iommu_device_link(struct device *dev, struct device *link)
672 {
673 	return -EINVAL;
674 }
675 
676 static inline void iommu_device_unlink(struct device *dev, struct device *link)
677 {
678 }
679 
680 static inline int iommu_fwspec_init(struct device *dev,
681 				    struct fwnode_handle *iommu_fwnode,
682 				    const struct iommu_ops *ops)
683 {
684 	return -ENODEV;
685 }
686 
687 static inline void iommu_fwspec_free(struct device *dev)
688 {
689 }
690 
691 static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,
692 				       int num_ids)
693 {
694 	return -ENODEV;
695 }
696 
697 static inline
698 const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
699 {
700 	return NULL;
701 }
702 
703 #endif /* CONFIG_IOMMU_API */
704 
705 #ifdef CONFIG_IOMMU_DEBUGFS
706 extern	struct dentry *iommu_debugfs_dir;
707 void iommu_debugfs_setup(void);
708 #else
709 static inline void iommu_debugfs_setup(void) {}
710 #endif
711 
712 #endif /* __LINUX_IOMMU_H */
713