]> git.proxmox.com Git - mirror_ubuntu-eoan-kernel.git/blame - include/linux/iommu.h
iommu: Make iommu_device_link/unlink take a struct iommu_device
[mirror_ubuntu-eoan-kernel.git] / include / linux / iommu.h
CommitLineData
4a77a6cf
JR
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
74315ccc 22#include <linux/errno.h>
9a08d376 23#include <linux/err.h>
d0f60a44 24#include <linux/of.h>
76582d0a 25#include <linux/types.h>
315786eb 26#include <linux/scatterlist.h>
56fa4849 27#include <trace/events/iommu.h>
74315ccc 28
ca13bb3d
WD
29#define IOMMU_READ (1 << 0)
30#define IOMMU_WRITE (1 << 1)
31#define IOMMU_CACHE (1 << 2) /* DMA cache coherency */
a720b41c 32#define IOMMU_NOEXEC (1 << 3)
31e6850e 33#define IOMMU_MMIO (1 << 4) /* e.g. things like MSI doorbells */
4a77a6cf 34
905d66c1 35struct iommu_ops;
d72e31c9 36struct iommu_group;
ff21776d 37struct bus_type;
4a77a6cf 38struct device;
4f3f8d9d 39struct iommu_domain;
ba1eabfa 40struct notifier_block;
4f3f8d9d
OBC
41
42/* iommu fault flags */
43#define IOMMU_FAULT_READ 0x0
44#define IOMMU_FAULT_WRITE 0x1
45
46typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
77ca2332 47 struct device *, unsigned long, int, void *);
4a77a6cf 48
0ff64f80
JR
49struct iommu_domain_geometry {
50 dma_addr_t aperture_start; /* First address that can be mapped */
51 dma_addr_t aperture_end; /* Last address that can be mapped */
52 bool force_aperture; /* DMA only allowed in mappable range? */
53};
54
8539c7c1
JR
55/* Domain feature flags */
56#define __IOMMU_DOMAIN_PAGING (1U << 0) /* Support for iommu_map/unmap */
57#define __IOMMU_DOMAIN_DMA_API (1U << 1) /* Domain for use in DMA-API
58 implementation */
59#define __IOMMU_DOMAIN_PT (1U << 2) /* Domain is identity mapped */
60
61/*
62 * This are the possible domain-types
63 *
64 * IOMMU_DOMAIN_BLOCKED - All DMA is blocked, can be used to isolate
65 * devices
66 * IOMMU_DOMAIN_IDENTITY - DMA addresses are system physical addresses
67 * IOMMU_DOMAIN_UNMANAGED - DMA mappings managed by IOMMU-API user, used
68 * for VMs
69 * IOMMU_DOMAIN_DMA - Internally used for DMA-API implementations.
70 * This flag allows IOMMU drivers to implement
71 * certain optimizations for these domains
72 */
73#define IOMMU_DOMAIN_BLOCKED (0U)
74#define IOMMU_DOMAIN_IDENTITY (__IOMMU_DOMAIN_PT)
75#define IOMMU_DOMAIN_UNMANAGED (__IOMMU_DOMAIN_PAGING)
76#define IOMMU_DOMAIN_DMA (__IOMMU_DOMAIN_PAGING | \
77 __IOMMU_DOMAIN_DMA_API)
78
4a77a6cf 79struct iommu_domain {
8539c7c1 80 unsigned type;
b22f6434 81 const struct iommu_ops *ops;
d16e0faa 82 unsigned long pgsize_bitmap; /* Bitmap of page sizes in use */
4f3f8d9d 83 iommu_fault_handler_t handler;
77ca2332 84 void *handler_token;
0ff64f80 85 struct iommu_domain_geometry geometry;
0db2e5d1 86 void *iova_cookie;
4a77a6cf
JR
87};
88
1aed0748
JR
89enum iommu_cap {
90 IOMMU_CAP_CACHE_COHERENCY, /* IOMMU can enforce cache coherent DMA
91 transactions */
92 IOMMU_CAP_INTR_REMAP, /* IOMMU supports interrupt isolation */
c4986649 93 IOMMU_CAP_NOEXEC, /* IOMMU_NOEXEC flag */
1aed0748 94};
dbb9fd86 95
7cabf491
VS
96/*
97 * Following constraints are specifc to FSL_PAMUV1:
98 * -aperture must be power of 2, and naturally aligned
99 * -number of windows must be power of 2, and address space size
100 * of each window is determined by aperture size / # of windows
101 * -the actual size of the mapped region of a window must be power
102 * of 2 starting with 4KB and physical address must be naturally
103 * aligned.
104 * DOMAIN_ATTR_FSL_PAMUV1 corresponds to the above mentioned contraints.
105 * The caller can invoke iommu_domain_get_attr to check if the underlying
106 * iommu implementation supports these constraints.
107 */
108
0cd76dd1 109enum iommu_attr {
0ff64f80 110 DOMAIN_ATTR_GEOMETRY,
d2e12160 111 DOMAIN_ATTR_PAGING,
69356712 112 DOMAIN_ATTR_WINDOWS,
7cabf491
VS
113 DOMAIN_ATTR_FSL_PAMU_STASH,
114 DOMAIN_ATTR_FSL_PAMU_ENABLE,
115 DOMAIN_ATTR_FSL_PAMUV1,
c02607aa 116 DOMAIN_ATTR_NESTING, /* two stages of translation */
a8b8a88a 117 DOMAIN_ATTR_MAX,
0cd76dd1
JR
118};
119
a1015c2b
JR
120/**
121 * struct iommu_dm_region - descriptor for a direct mapped memory region
122 * @list: Linked list pointers
123 * @start: System physical start address of the region
124 * @length: Length of the region in bytes
125 * @prot: IOMMU Protection flags (READ/WRITE/...)
126 */
127struct iommu_dm_region {
128 struct list_head list;
129 phys_addr_t start;
130 size_t length;
131 int prot;
132};
133
39d4ebb9
JR
134#ifdef CONFIG_IOMMU_API
135
7d3002cc
OBC
136/**
137 * struct iommu_ops - iommu ops and capabilities
0d9bacb6
MD
138 * @capable: check capability
139 * @domain_alloc: allocate iommu domain
140 * @domain_free: free iommu domain
7d3002cc
OBC
141 * @attach_dev: attach device to an iommu domain
142 * @detach_dev: detach device from an iommu domain
143 * @map: map a physically contiguous memory region to an iommu domain
144 * @unmap: unmap a physically contiguous memory region from an iommu domain
315786eb
OH
145 * @map_sg: map a scatter-gather list of physically contiguous memory chunks
146 * to an iommu domain
7d3002cc 147 * @iova_to_phys: translate iova to physical address
d72e31c9
AW
148 * @add_device: add device to iommu grouping
149 * @remove_device: remove device from iommu grouping
0d9bacb6 150 * @device_group: find iommu group for a particular device
0cd76dd1
JR
151 * @domain_get_attr: Query domain attributes
152 * @domain_set_attr: Change domain attributes
0d9bacb6
MD
153 * @get_dm_regions: Request list of direct mapping requirements for a device
154 * @put_dm_regions: Free list of direct mapping requirements for a device
33b21a6b 155 * @apply_dm_region: Temporary helper call-back for iova reserved ranges
0d9bacb6
MD
156 * @domain_window_enable: Configure and enable a particular window for a domain
157 * @domain_window_disable: Disable a particular window for a domain
158 * @domain_set_windows: Set the number of windows for a domain
159 * @domain_get_windows: Return the number of windows for a domain
d0f60a44 160 * @of_xlate: add OF master IDs to iommu grouping
d16e0faa 161 * @pgsize_bitmap: bitmap of all possible supported page sizes
7d3002cc 162 */
4a77a6cf 163struct iommu_ops {
3c0e0ca0 164 bool (*capable)(enum iommu_cap);
938c4709
JR
165
166 /* Domain allocation and freeing by the iommu driver */
8539c7c1 167 struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
938c4709
JR
168 void (*domain_free)(struct iommu_domain *);
169
4a77a6cf
JR
170 int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
171 void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
67651786 172 int (*map)(struct iommu_domain *domain, unsigned long iova,
5009065d
OBC
173 phys_addr_t paddr, size_t size, int prot);
174 size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
175 size_t size);
315786eb
OH
176 size_t (*map_sg)(struct iommu_domain *domain, unsigned long iova,
177 struct scatterlist *sg, unsigned int nents, int prot);
bb5547ac 178 phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
d72e31c9
AW
179 int (*add_device)(struct device *dev);
180 void (*remove_device)(struct device *dev);
46c6b2bc 181 struct iommu_group *(*device_group)(struct device *dev);
0cd76dd1
JR
182 int (*domain_get_attr)(struct iommu_domain *domain,
183 enum iommu_attr attr, void *data);
184 int (*domain_set_attr)(struct iommu_domain *domain,
185 enum iommu_attr attr, void *data);
d7787d57 186
a1015c2b
JR
187 /* Request/Free a list of direct mapping requirements for a device */
188 void (*get_dm_regions)(struct device *dev, struct list_head *list);
189 void (*put_dm_regions)(struct device *dev, struct list_head *list);
33b21a6b
JR
190 void (*apply_dm_region)(struct device *dev, struct iommu_domain *domain,
191 struct iommu_dm_region *region);
a1015c2b 192
d7787d57
JR
193 /* Window handling functions */
194 int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
80f97f0f 195 phys_addr_t paddr, u64 size, int prot);
d7787d57 196 void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
0d9bacb6 197 /* Set the number of windows per domain */
69356712 198 int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
0d9bacb6 199 /* Get the number of windows per domain */
69356712 200 u32 (*domain_get_windows)(struct iommu_domain *domain);
d7787d57 201
d0f60a44 202 int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
d0f60a44 203
7d3002cc 204 unsigned long pgsize_bitmap;
4a77a6cf
JR
205};
206
b0119e87
JR
207/**
208 * struct iommu_device - IOMMU core representation of one IOMMU hardware
209 * instance
210 * @list: Used by the iommu-core to keep a list of registered iommus
211 * @ops: iommu-ops for talking to this iommu
39ab9555 212 * @dev: struct device for sysfs handling
b0119e87
JR
213 */
214struct iommu_device {
215 struct list_head list;
216 const struct iommu_ops *ops;
39ab9555 217 struct device dev;
b0119e87
JR
218};
219
220int iommu_device_register(struct iommu_device *iommu);
221void iommu_device_unregister(struct iommu_device *iommu);
39ab9555
JR
222int iommu_device_sysfs_add(struct iommu_device *iommu,
223 struct device *parent,
224 const struct attribute_group **groups,
225 const char *fmt, ...) __printf(4, 5);
226void iommu_device_sysfs_remove(struct iommu_device *iommu);
e3d10af1
JR
227int iommu_device_link(struct iommu_device *iommu, struct device *link);
228void iommu_device_unlink(struct iommu_device *iommu, struct device *link);
b0119e87
JR
229
230static inline void iommu_device_set_ops(struct iommu_device *iommu,
231 const struct iommu_ops *ops)
232{
233 iommu->ops = ops;
234}
235
d72e31c9
AW
236#define IOMMU_GROUP_NOTIFY_ADD_DEVICE 1 /* Device added */
237#define IOMMU_GROUP_NOTIFY_DEL_DEVICE 2 /* Pre Device removed */
238#define IOMMU_GROUP_NOTIFY_BIND_DRIVER 3 /* Pre Driver bind */
239#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER 4 /* Post Driver bind */
240#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER 5 /* Pre Driver unbind */
241#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER 6 /* Post Driver unbind */
242
b22f6434 243extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
a1b60c1c 244extern bool iommu_present(struct bus_type *bus);
3c0e0ca0 245extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
905d66c1 246extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
aa16bea9 247extern struct iommu_group *iommu_group_get_by_id(int id);
4a77a6cf
JR
248extern void iommu_domain_free(struct iommu_domain *domain);
249extern int iommu_attach_device(struct iommu_domain *domain,
250 struct device *dev);
251extern void iommu_detach_device(struct iommu_domain *domain,
252 struct device *dev);
2c1296d9 253extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
cefc53c7 254extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
7d3002cc
OBC
255 phys_addr_t paddr, size_t size, int prot);
256extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
257 size_t size);
315786eb
OH
258extern size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
259 struct scatterlist *sg,unsigned int nents,
260 int prot);
bb5547ac 261extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
4f3f8d9d 262extern void iommu_set_fault_handler(struct iommu_domain *domain,
77ca2332 263 iommu_fault_handler_t handler, void *token);
d72e31c9 264
a1015c2b
JR
265extern void iommu_get_dm_regions(struct device *dev, struct list_head *list);
266extern void iommu_put_dm_regions(struct device *dev, struct list_head *list);
d290f1e7 267extern int iommu_request_dm_for_dev(struct device *dev);
a1015c2b 268
d72e31c9
AW
269extern int iommu_attach_group(struct iommu_domain *domain,
270 struct iommu_group *group);
271extern void iommu_detach_group(struct iommu_domain *domain,
272 struct iommu_group *group);
273extern struct iommu_group *iommu_group_alloc(void);
274extern void *iommu_group_get_iommudata(struct iommu_group *group);
275extern void iommu_group_set_iommudata(struct iommu_group *group,
276 void *iommu_data,
277 void (*release)(void *iommu_data));
278extern int iommu_group_set_name(struct iommu_group *group, const char *name);
279extern int iommu_group_add_device(struct iommu_group *group,
280 struct device *dev);
281extern void iommu_group_remove_device(struct device *dev);
282extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
283 int (*fn)(struct device *, void *));
284extern struct iommu_group *iommu_group_get(struct device *dev);
13f59a78 285extern struct iommu_group *iommu_group_ref_get(struct iommu_group *group);
d72e31c9
AW
286extern void iommu_group_put(struct iommu_group *group);
287extern int iommu_group_register_notifier(struct iommu_group *group,
288 struct notifier_block *nb);
289extern int iommu_group_unregister_notifier(struct iommu_group *group,
290 struct notifier_block *nb);
291extern int iommu_group_id(struct iommu_group *group);
104a1c13 292extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
6827ca83 293extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
4f3f8d9d 294
0cd76dd1
JR
295extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
296 void *data);
297extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
298 void *data);
4f3f8d9d 299
d7787d57
JR
300/* Window handling function prototypes */
301extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
80f97f0f
VS
302 phys_addr_t offset, u64 size,
303 int prot);
d7787d57 304extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
4f3f8d9d
OBC
305/**
306 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
307 * @domain: the iommu domain where the fault has happened
308 * @dev: the device where the fault has happened
309 * @iova: the faulting address
310 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
311 *
312 * This function should be called by the low-level IOMMU implementations
313 * whenever IOMMU faults happen, to allow high-level users, that are
314 * interested in such events, to know about them.
315 *
316 * This event may be useful for several possible use cases:
317 * - mere logging of the event
318 * - dynamic TLB/PTE loading
319 * - if restarting of the faulting device is required
320 *
321 * Returns 0 on success and an appropriate error code otherwise (if dynamic
322 * PTE/TLB loading will one day be supported, implementations will be able
323 * to tell whether it succeeded or not according to this return value).
0ed6d2d2
OBC
324 *
325 * Specifically, -ENOSYS is returned if a fault handler isn't installed
326 * (though fault handlers can also return -ENOSYS, in case they want to
327 * elicit the default behavior of the IOMMU drivers).
4f3f8d9d
OBC
328 */
329static inline int report_iommu_fault(struct iommu_domain *domain,
330 struct device *dev, unsigned long iova, int flags)
331{
0ed6d2d2 332 int ret = -ENOSYS;
4a77a6cf 333
4f3f8d9d
OBC
334 /*
335 * if upper layers showed interest and installed a fault handler,
336 * invoke it.
337 */
338 if (domain->handler)
77ca2332
OBC
339 ret = domain->handler(domain, dev, iova, flags,
340 domain->handler_token);
4a77a6cf 341
56fa4849 342 trace_io_page_fault(dev, iova, flags);
4f3f8d9d 343 return ret;
4a77a6cf
JR
344}
345
315786eb
OH
346static inline size_t iommu_map_sg(struct iommu_domain *domain,
347 unsigned long iova, struct scatterlist *sg,
348 unsigned int nents, int prot)
349{
350 return domain->ops->map_sg(domain, iova, sg, nents, prot);
351}
352
5e62292b
JR
353/* PCI device grouping function */
354extern struct iommu_group *pci_device_group(struct device *dev);
6eab556a
JR
355/* Generic device grouping function */
356extern struct iommu_group *generic_device_group(struct device *dev);
5e62292b 357
57f98d2f
RM
358/**
359 * struct iommu_fwspec - per-device IOMMU instance data
360 * @ops: ops for this device's IOMMU
361 * @iommu_fwnode: firmware handle for this device's IOMMU
362 * @iommu_priv: IOMMU driver private data for this device
363 * @num_ids: number of associated device IDs
364 * @ids: IDs which this device may present to the IOMMU
365 */
366struct iommu_fwspec {
367 const struct iommu_ops *ops;
368 struct fwnode_handle *iommu_fwnode;
369 void *iommu_priv;
370 unsigned int num_ids;
371 u32 ids[1];
372};
373
374int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
375 const struct iommu_ops *ops);
376void iommu_fwspec_free(struct device *dev);
377int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids);
e4f10ffe
LP
378void iommu_register_instance(struct fwnode_handle *fwnode,
379 const struct iommu_ops *ops);
534766df 380const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode);
57f98d2f 381
4a77a6cf
JR
382#else /* CONFIG_IOMMU_API */
383
39d4ebb9 384struct iommu_ops {};
d72e31c9 385struct iommu_group {};
57f98d2f 386struct iommu_fwspec {};
b0119e87 387struct iommu_device {};
4a77a6cf 388
a1b60c1c 389static inline bool iommu_present(struct bus_type *bus)
4a77a6cf
JR
390{
391 return false;
392}
393
3c0e0ca0
JR
394static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
395{
396 return false;
397}
398
905d66c1 399static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
4a77a6cf
JR
400{
401 return NULL;
402}
403
b62dfd29
AK
404static inline struct iommu_group *iommu_group_get_by_id(int id)
405{
406 return NULL;
407}
408
4a77a6cf
JR
409static inline void iommu_domain_free(struct iommu_domain *domain)
410{
411}
412
413static inline int iommu_attach_device(struct iommu_domain *domain,
414 struct device *dev)
415{
416 return -ENODEV;
417}
418
419static inline void iommu_detach_device(struct iommu_domain *domain,
420 struct device *dev)
421{
422}
423
2c1296d9
JR
424static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
425{
426 return NULL;
427}
428
cefc53c7
JR
429static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
430 phys_addr_t paddr, int gfp_order, int prot)
431{
432 return -ENODEV;
433}
434
435static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
436 int gfp_order)
437{
438 return -ENODEV;
439}
440
315786eb
OH
441static inline size_t iommu_map_sg(struct iommu_domain *domain,
442 unsigned long iova, struct scatterlist *sg,
443 unsigned int nents, int prot)
444{
445 return -ENODEV;
446}
447
d7787d57
JR
448static inline int iommu_domain_window_enable(struct iommu_domain *domain,
449 u32 wnd_nr, phys_addr_t paddr,
80f97f0f 450 u64 size, int prot)
d7787d57
JR
451{
452 return -ENODEV;
453}
454
455static inline void iommu_domain_window_disable(struct iommu_domain *domain,
456 u32 wnd_nr)
457{
458}
459
bb5547ac 460static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
4a77a6cf
JR
461{
462 return 0;
463}
464
4f3f8d9d 465static inline void iommu_set_fault_handler(struct iommu_domain *domain,
77ca2332 466 iommu_fault_handler_t handler, void *token)
4f3f8d9d
OBC
467{
468}
469
a1015c2b
JR
470static inline void iommu_get_dm_regions(struct device *dev,
471 struct list_head *list)
472{
473}
474
475static inline void iommu_put_dm_regions(struct device *dev,
476 struct list_head *list)
477{
478}
479
d290f1e7
JR
480static inline int iommu_request_dm_for_dev(struct device *dev)
481{
482 return -ENODEV;
483}
484
bef83de5
AW
485static inline int iommu_attach_group(struct iommu_domain *domain,
486 struct iommu_group *group)
d72e31c9
AW
487{
488 return -ENODEV;
489}
490
bef83de5
AW
491static inline void iommu_detach_group(struct iommu_domain *domain,
492 struct iommu_group *group)
d72e31c9
AW
493{
494}
495
bef83de5 496static inline struct iommu_group *iommu_group_alloc(void)
d72e31c9
AW
497{
498 return ERR_PTR(-ENODEV);
499}
500
bef83de5 501static inline void *iommu_group_get_iommudata(struct iommu_group *group)
d72e31c9
AW
502{
503 return NULL;
504}
505
bef83de5
AW
506static inline void iommu_group_set_iommudata(struct iommu_group *group,
507 void *iommu_data,
508 void (*release)(void *iommu_data))
d72e31c9
AW
509{
510}
511
bef83de5
AW
512static inline int iommu_group_set_name(struct iommu_group *group,
513 const char *name)
d72e31c9
AW
514{
515 return -ENODEV;
516}
517
bef83de5
AW
518static inline int iommu_group_add_device(struct iommu_group *group,
519 struct device *dev)
d72e31c9
AW
520{
521 return -ENODEV;
522}
523
bef83de5 524static inline void iommu_group_remove_device(struct device *dev)
d72e31c9
AW
525{
526}
527
bef83de5
AW
528static inline int iommu_group_for_each_dev(struct iommu_group *group,
529 void *data,
530 int (*fn)(struct device *, void *))
d72e31c9
AW
531{
532 return -ENODEV;
533}
534
bef83de5 535static inline struct iommu_group *iommu_group_get(struct device *dev)
d72e31c9
AW
536{
537 return NULL;
538}
539
bef83de5 540static inline void iommu_group_put(struct iommu_group *group)
d72e31c9
AW
541{
542}
543
bef83de5
AW
544static inline int iommu_group_register_notifier(struct iommu_group *group,
545 struct notifier_block *nb)
1460432c
AW
546{
547 return -ENODEV;
548}
549
bef83de5
AW
550static inline int iommu_group_unregister_notifier(struct iommu_group *group,
551 struct notifier_block *nb)
d72e31c9
AW
552{
553 return 0;
554}
555
bef83de5 556static inline int iommu_group_id(struct iommu_group *group)
d72e31c9
AW
557{
558 return -ENODEV;
559}
1460432c 560
0cd76dd1
JR
561static inline int iommu_domain_get_attr(struct iommu_domain *domain,
562 enum iommu_attr attr, void *data)
563{
564 return -EINVAL;
565}
566
567static inline int iommu_domain_set_attr(struct iommu_domain *domain,
568 enum iommu_attr attr, void *data)
569{
570 return -EINVAL;
571}
572
39ab9555 573static inline int iommu_device_register(struct iommu_device *iommu)
c61959ec 574{
39ab9555 575 return -ENODEV;
c61959ec
AW
576}
577
39ab9555
JR
578static inline void iommu_device_set_ops(struct iommu_device *iommu,
579 const struct iommu_ops *ops)
c61959ec
AW
580{
581}
582
39ab9555 583static inline void iommu_device_unregister(struct iommu_device *iommu)
b0119e87 584{
b0119e87
JR
585}
586
39ab9555
JR
587static inline int iommu_device_sysfs_add(struct iommu_device *iommu,
588 struct device *parent,
589 const struct attribute_group **groups,
590 const char *fmt, ...)
b0119e87 591{
39ab9555 592 return -ENODEV;
b0119e87
JR
593}
594
39ab9555 595static inline void iommu_device_sysfs_remove(struct iommu_device *iommu)
b0119e87
JR
596{
597}
598
e09f8ea5 599static inline int iommu_device_link(struct device *dev, struct device *link)
c61959ec
AW
600{
601 return -EINVAL;
602}
603
e09f8ea5 604static inline void iommu_device_unlink(struct device *dev, struct device *link)
c61959ec
AW
605{
606}
607
57f98d2f
RM
608static inline int iommu_fwspec_init(struct device *dev,
609 struct fwnode_handle *iommu_fwnode,
610 const struct iommu_ops *ops)
611{
612 return -ENODEV;
613}
614
615static inline void iommu_fwspec_free(struct device *dev)
616{
617}
618
619static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,
620 int num_ids)
621{
622 return -ENODEV;
623}
624
e4f10ffe
LP
625static inline void iommu_register_instance(struct fwnode_handle *fwnode,
626 const struct iommu_ops *ops)
627{
628}
629
630static inline
534766df 631const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
e4f10ffe
LP
632{
633 return NULL;
634}
635
4a77a6cf
JR
636#endif /* CONFIG_IOMMU_API */
637
638#endif /* __LINUX_IOMMU_H */