1
2
3
4
5
6
7#ifndef __LINUX_IOMMU_H
8#define __LINUX_IOMMU_H
9
10#include <linux/scatterlist.h>
11#include <linux/device.h>
12#include <linux/types.h>
13#include <linux/errno.h>
14#include <linux/err.h>
15#include <linux/of.h>
16#include <linux/ioasid.h>
17#include <uapi/linux/iommu.h>
18
19#define IOMMU_READ (1 << 0)
20#define IOMMU_WRITE (1 << 1)
21#define IOMMU_CACHE (1 << 2)
22#define IOMMU_NOEXEC (1 << 3)
23#define IOMMU_MMIO (1 << 4)
24
25
26
27
28
29
30
31
32
33#define IOMMU_PRIV (1 << 5)
34
35struct iommu_ops;
36struct iommu_group;
37struct bus_type;
38struct device;
39struct iommu_domain;
40struct notifier_block;
41struct iommu_sva;
42struct iommu_fault_event;
43
44
45#define IOMMU_FAULT_READ 0x0
46#define IOMMU_FAULT_WRITE 0x1
47
48typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
49 struct device *, unsigned long, int, void *);
50typedef int (*iommu_dev_fault_handler_t)(struct iommu_fault *, void *);
51
52struct iommu_domain_geometry {
53 dma_addr_t aperture_start;
54 dma_addr_t aperture_end;
55 bool force_aperture;
56};
57
58
59#define __IOMMU_DOMAIN_PAGING (1U << 0)
60#define __IOMMU_DOMAIN_DMA_API (1U << 1)
61
62#define __IOMMU_DOMAIN_PT (1U << 2)
63
64
65
66
67
68
69
70
71
72
73
74
75
76#define IOMMU_DOMAIN_BLOCKED (0U)
77#define IOMMU_DOMAIN_IDENTITY (__IOMMU_DOMAIN_PT)
78#define IOMMU_DOMAIN_UNMANAGED (__IOMMU_DOMAIN_PAGING)
79#define IOMMU_DOMAIN_DMA (__IOMMU_DOMAIN_PAGING | \
80 __IOMMU_DOMAIN_DMA_API)
81
82struct iommu_domain {
83 unsigned type;
84 const struct iommu_ops *ops;
85 unsigned long pgsize_bitmap;
86 iommu_fault_handler_t handler;
87 void *handler_token;
88 struct iommu_domain_geometry geometry;
89 void *iova_cookie;
90};
91
92enum iommu_cap {
93 IOMMU_CAP_CACHE_COHERENCY,
94
95 IOMMU_CAP_INTR_REMAP,
96 IOMMU_CAP_NOEXEC,
97};
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112enum iommu_attr {
113 DOMAIN_ATTR_GEOMETRY,
114 DOMAIN_ATTR_PAGING,
115 DOMAIN_ATTR_WINDOWS,
116 DOMAIN_ATTR_FSL_PAMU_STASH,
117 DOMAIN_ATTR_FSL_PAMU_ENABLE,
118 DOMAIN_ATTR_FSL_PAMUV1,
119 DOMAIN_ATTR_NESTING,
120 DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE,
121 DOMAIN_ATTR_MAX,
122};
123
124
125enum iommu_resv_type {
126
127 IOMMU_RESV_DIRECT,
128
129
130
131
132
133 IOMMU_RESV_DIRECT_RELAXABLE,
134
135 IOMMU_RESV_RESERVED,
136
137 IOMMU_RESV_MSI,
138
139 IOMMU_RESV_SW_MSI,
140};
141
142
143
144
145
146
147
148
149
150struct 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
159enum iommu_dev_features {
160 IOMMU_DEV_FEAT_AUX,
161 IOMMU_DEV_FEAT_SVA,
162};
163
164#define IOMMU_PASID_INVALID (-1U)
165
166#ifdef CONFIG_IOMMU_API
167
168
169
170
171
172
173
174
175
176
177
178
179struct iommu_iotlb_gather {
180 unsigned long start;
181 unsigned long end;
182 size_t pgsize;
183};
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233struct iommu_ops {
234 bool (*capable)(enum iommu_cap);
235
236
237 struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
238 void (*domain_free)(struct iommu_domain *);
239
240 int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
241 void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
242 int (*map)(struct iommu_domain *domain, unsigned long iova,
243 phys_addr_t paddr, size_t size, int prot, gfp_t gfp);
244 size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
245 size_t size, struct iommu_iotlb_gather *iotlb_gather);
246 void (*flush_iotlb_all)(struct iommu_domain *domain);
247 void (*iotlb_sync_map)(struct iommu_domain *domain);
248 void (*iotlb_sync)(struct iommu_domain *domain,
249 struct iommu_iotlb_gather *iotlb_gather);
250 phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
251 struct iommu_device *(*probe_device)(struct device *dev);
252 void (*release_device)(struct device *dev);
253 void (*probe_finalize)(struct device *dev);
254 struct iommu_group *(*device_group)(struct device *dev);
255 int (*domain_get_attr)(struct iommu_domain *domain,
256 enum iommu_attr attr, void *data);
257 int (*domain_set_attr)(struct iommu_domain *domain,
258 enum iommu_attr attr, void *data);
259
260
261 void (*get_resv_regions)(struct device *dev, struct list_head *list);
262 void (*put_resv_regions)(struct device *dev, struct list_head *list);
263 void (*apply_resv_region)(struct device *dev,
264 struct iommu_domain *domain,
265 struct iommu_resv_region *region);
266
267
268 int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
269 phys_addr_t paddr, u64 size, int prot);
270 void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
271
272 int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
273 bool (*is_attach_deferred)(struct iommu_domain *domain, struct device *dev);
274
275
276 bool (*dev_has_feat)(struct device *dev, enum iommu_dev_features f);
277 bool (*dev_feat_enabled)(struct device *dev, enum iommu_dev_features f);
278 int (*dev_enable_feat)(struct device *dev, enum iommu_dev_features f);
279 int (*dev_disable_feat)(struct device *dev, enum iommu_dev_features f);
280
281
282 int (*aux_attach_dev)(struct iommu_domain *domain, struct device *dev);
283 void (*aux_detach_dev)(struct iommu_domain *domain, struct device *dev);
284 int (*aux_get_pasid)(struct iommu_domain *domain, struct device *dev);
285
286 struct iommu_sva *(*sva_bind)(struct device *dev, struct mm_struct *mm,
287 void *drvdata);
288 void (*sva_unbind)(struct iommu_sva *handle);
289 int (*sva_get_pasid)(struct iommu_sva *handle);
290
291 int (*page_response)(struct device *dev,
292 struct iommu_fault_event *evt,
293 struct iommu_page_response *msg);
294 int (*cache_invalidate)(struct iommu_domain *domain, struct device *dev,
295 struct iommu_cache_invalidate_info *inv_info);
296 int (*sva_bind_gpasid)(struct iommu_domain *domain,
297 struct device *dev, struct iommu_gpasid_bind_data *data);
298
299 int (*sva_unbind_gpasid)(struct device *dev, int pasid);
300
301 int (*def_domain_type)(struct device *dev);
302
303 unsigned long pgsize_bitmap;
304 struct module *owner;
305};
306
307
308
309
310
311
312
313
314struct iommu_device {
315 struct list_head list;
316 const struct iommu_ops *ops;
317 struct fwnode_handle *fwnode;
318 struct device *dev;
319};
320
321
322
323
324
325
326
327
328
329
330struct iommu_fault_event {
331 struct iommu_fault fault;
332 struct list_head list;
333};
334
335
336
337
338
339
340
341
342struct iommu_fault_param {
343 iommu_dev_fault_handler_t handler;
344 void *data;
345 struct list_head faults;
346 struct mutex lock;
347};
348
349
350
351
352
353
354
355
356
357
358
359
360struct dev_iommu {
361 struct mutex lock;
362 struct iommu_fault_param *fault_param;
363 struct iommu_fwspec *fwspec;
364 struct iommu_device *iommu_dev;
365 void *priv;
366};
367
368int iommu_device_register(struct iommu_device *iommu);
369void iommu_device_unregister(struct iommu_device *iommu);
370int iommu_device_sysfs_add(struct iommu_device *iommu,
371 struct device *parent,
372 const struct attribute_group **groups,
373 const char *fmt, ...) __printf(4, 5);
374void iommu_device_sysfs_remove(struct iommu_device *iommu);
375int iommu_device_link(struct iommu_device *iommu, struct device *link);
376void iommu_device_unlink(struct iommu_device *iommu, struct device *link);
377
378static inline void __iommu_device_set_ops(struct iommu_device *iommu,
379 const struct iommu_ops *ops)
380{
381 iommu->ops = ops;
382}
383
384#define iommu_device_set_ops(iommu, ops) \
385do { \
386 struct iommu_ops *__ops = (struct iommu_ops *)(ops); \
387 __ops->owner = THIS_MODULE; \
388 __iommu_device_set_ops(iommu, __ops); \
389} while (0)
390
391static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
392 struct fwnode_handle *fwnode)
393{
394 iommu->fwnode = fwnode;
395}
396
397static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
398{
399 return (struct iommu_device *)dev_get_drvdata(dev);
400}
401
402static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather)
403{
404 *gather = (struct iommu_iotlb_gather) {
405 .start = ULONG_MAX,
406 };
407}
408
409#define IOMMU_GROUP_NOTIFY_ADD_DEVICE 1
410#define IOMMU_GROUP_NOTIFY_DEL_DEVICE 2
411#define IOMMU_GROUP_NOTIFY_BIND_DRIVER 3
412#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER 4
413#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER 5
414#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER 6
415
416extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
417extern int bus_iommu_probe(struct bus_type *bus);
418extern bool iommu_present(struct bus_type *bus);
419extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
420extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
421extern struct iommu_group *iommu_group_get_by_id(int id);
422extern void iommu_domain_free(struct iommu_domain *domain);
423extern int iommu_attach_device(struct iommu_domain *domain,
424 struct device *dev);
425extern void iommu_detach_device(struct iommu_domain *domain,
426 struct device *dev);
427extern int iommu_cache_invalidate(struct iommu_domain *domain,
428 struct device *dev,
429 struct iommu_cache_invalidate_info *inv_info);
430extern int iommu_sva_bind_gpasid(struct iommu_domain *domain,
431 struct device *dev, struct iommu_gpasid_bind_data *data);
432extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
433 struct device *dev, ioasid_t pasid);
434extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
435extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
436extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
437 phys_addr_t paddr, size_t size, int prot);
438extern int iommu_map_atomic(struct iommu_domain *domain, unsigned long iova,
439 phys_addr_t paddr, size_t size, int prot);
440extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
441 size_t size);
442extern size_t iommu_unmap_fast(struct iommu_domain *domain,
443 unsigned long iova, size_t size,
444 struct iommu_iotlb_gather *iotlb_gather);
445extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
446 struct scatterlist *sg,unsigned int nents, int prot);
447extern size_t iommu_map_sg_atomic(struct iommu_domain *domain,
448 unsigned long iova, struct scatterlist *sg,
449 unsigned int nents, int prot);
450extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
451extern void iommu_set_fault_handler(struct iommu_domain *domain,
452 iommu_fault_handler_t handler, void *token);
453
454extern void iommu_get_resv_regions(struct device *dev, struct list_head *list);
455extern void iommu_put_resv_regions(struct device *dev, struct list_head *list);
456extern void generic_iommu_put_resv_regions(struct device *dev,
457 struct list_head *list);
458extern void iommu_set_default_passthrough(bool cmd_line);
459extern void iommu_set_default_translated(bool cmd_line);
460extern bool iommu_default_passthrough(void);
461extern struct iommu_resv_region *
462iommu_alloc_resv_region(phys_addr_t start, size_t length, int prot,
463 enum iommu_resv_type type);
464extern int iommu_get_group_resv_regions(struct iommu_group *group,
465 struct list_head *head);
466
467extern int iommu_attach_group(struct iommu_domain *domain,
468 struct iommu_group *group);
469extern void iommu_detach_group(struct iommu_domain *domain,
470 struct iommu_group *group);
471extern struct iommu_group *iommu_group_alloc(void);
472extern void *iommu_group_get_iommudata(struct iommu_group *group);
473extern void iommu_group_set_iommudata(struct iommu_group *group,
474 void *iommu_data,
475 void (*release)(void *iommu_data));
476extern int iommu_group_set_name(struct iommu_group *group, const char *name);
477extern int iommu_group_add_device(struct iommu_group *group,
478 struct device *dev);
479extern void iommu_group_remove_device(struct device *dev);
480extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
481 int (*fn)(struct device *, void *));
482extern struct iommu_group *iommu_group_get(struct device *dev);
483extern struct iommu_group *iommu_group_ref_get(struct iommu_group *group);
484extern void iommu_group_put(struct iommu_group *group);
485extern int iommu_group_register_notifier(struct iommu_group *group,
486 struct notifier_block *nb);
487extern int iommu_group_unregister_notifier(struct iommu_group *group,
488 struct notifier_block *nb);
489extern int iommu_register_device_fault_handler(struct device *dev,
490 iommu_dev_fault_handler_t handler,
491 void *data);
492
493extern int iommu_unregister_device_fault_handler(struct device *dev);
494
495extern int iommu_report_device_fault(struct device *dev,
496 struct iommu_fault_event *evt);
497extern int iommu_page_response(struct device *dev,
498 struct iommu_page_response *msg);
499
500extern int iommu_group_id(struct iommu_group *group);
501extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
502
503extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
504 void *data);
505extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
506 void *data);
507
508
509extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
510 phys_addr_t offset, u64 size,
511 int prot);
512extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
513
514extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
515 unsigned long iova, int flags);
516
517static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
518{
519 if (domain->ops->flush_iotlb_all)
520 domain->ops->flush_iotlb_all(domain);
521}
522
523static inline void iommu_tlb_sync(struct iommu_domain *domain,
524 struct iommu_iotlb_gather *iotlb_gather)
525{
526 if (domain->ops->iotlb_sync)
527 domain->ops->iotlb_sync(domain, iotlb_gather);
528
529 iommu_iotlb_gather_init(iotlb_gather);
530}
531
532static inline void iommu_iotlb_gather_add_page(struct iommu_domain *domain,
533 struct iommu_iotlb_gather *gather,
534 unsigned long iova, size_t size)
535{
536 unsigned long start = iova, end = start + size;
537
538
539
540
541
542
543 if (gather->pgsize != size ||
544 end < gather->start || start > gather->end) {
545 if (gather->pgsize)
546 iommu_tlb_sync(domain, gather);
547 gather->pgsize = size;
548 }
549
550 if (gather->end < end)
551 gather->end = end;
552
553 if (gather->start > start)
554 gather->start = start;
555}
556
557
558extern struct iommu_group *pci_device_group(struct device *dev);
559
560extern struct iommu_group *generic_device_group(struct device *dev);
561
562struct iommu_group *fsl_mc_device_group(struct device *dev);
563
564
565
566
567
568
569
570
571
572
573struct iommu_fwspec {
574 const struct iommu_ops *ops;
575 struct fwnode_handle *iommu_fwnode;
576 u32 flags;
577 u32 num_pasid_bits;
578 unsigned int num_ids;
579 u32 ids[];
580};
581
582
583#define IOMMU_FWSPEC_PCI_RC_ATS (1 << 0)
584
585
586
587
588struct iommu_sva {
589 struct device *dev;
590};
591
592int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
593 const struct iommu_ops *ops);
594void iommu_fwspec_free(struct device *dev);
595int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids);
596const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode);
597
598static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
599{
600 if (dev->iommu)
601 return dev->iommu->fwspec;
602 else
603 return NULL;
604}
605
606static inline void dev_iommu_fwspec_set(struct device *dev,
607 struct iommu_fwspec *fwspec)
608{
609 dev->iommu->fwspec = fwspec;
610}
611
612static inline void *dev_iommu_priv_get(struct device *dev)
613{
614 return dev->iommu->priv;
615}
616
617static inline void dev_iommu_priv_set(struct device *dev, void *priv)
618{
619 dev->iommu->priv = priv;
620}
621
622int iommu_probe_device(struct device *dev);
623void iommu_release_device(struct device *dev);
624
625bool iommu_dev_has_feature(struct device *dev, enum iommu_dev_features f);
626int iommu_dev_enable_feature(struct device *dev, enum iommu_dev_features f);
627int iommu_dev_disable_feature(struct device *dev, enum iommu_dev_features f);
628bool iommu_dev_feature_enabled(struct device *dev, enum iommu_dev_features f);
629int iommu_aux_attach_device(struct iommu_domain *domain, struct device *dev);
630void iommu_aux_detach_device(struct iommu_domain *domain, struct device *dev);
631int iommu_aux_get_pasid(struct iommu_domain *domain, struct device *dev);
632
633struct iommu_sva *iommu_sva_bind_device(struct device *dev,
634 struct mm_struct *mm,
635 void *drvdata);
636void iommu_sva_unbind_device(struct iommu_sva *handle);
637int iommu_sva_get_pasid(struct iommu_sva *handle);
638
639#else
640
641struct iommu_ops {};
642struct iommu_group {};
643struct iommu_fwspec {};
644struct iommu_device {};
645struct iommu_fault_param {};
646struct iommu_iotlb_gather {};
647
648static inline bool iommu_present(struct bus_type *bus)
649{
650 return false;
651}
652
653static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
654{
655 return false;
656}
657
658static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
659{
660 return NULL;
661}
662
663static inline struct iommu_group *iommu_group_get_by_id(int id)
664{
665 return NULL;
666}
667
668static inline void iommu_domain_free(struct iommu_domain *domain)
669{
670}
671
672static inline int iommu_attach_device(struct iommu_domain *domain,
673 struct device *dev)
674{
675 return -ENODEV;
676}
677
678static inline void iommu_detach_device(struct iommu_domain *domain,
679 struct device *dev)
680{
681}
682
683static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
684{
685 return NULL;
686}
687
688static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
689 phys_addr_t paddr, size_t size, int prot)
690{
691 return -ENODEV;
692}
693
694static inline int iommu_map_atomic(struct iommu_domain *domain,
695 unsigned long iova, phys_addr_t paddr,
696 size_t size, int prot)
697{
698 return -ENODEV;
699}
700
701static inline size_t iommu_unmap(struct iommu_domain *domain,
702 unsigned long iova, size_t size)
703{
704 return 0;
705}
706
707static inline size_t iommu_unmap_fast(struct iommu_domain *domain,
708 unsigned long iova, int gfp_order,
709 struct iommu_iotlb_gather *iotlb_gather)
710{
711 return 0;
712}
713
714static inline size_t iommu_map_sg(struct iommu_domain *domain,
715 unsigned long iova, struct scatterlist *sg,
716 unsigned int nents, int prot)
717{
718 return 0;
719}
720
721static inline size_t iommu_map_sg_atomic(struct iommu_domain *domain,
722 unsigned long iova, struct scatterlist *sg,
723 unsigned int nents, int prot)
724{
725 return 0;
726}
727
728static inline void iommu_flush_tlb_all(struct iommu_domain *domain)
729{
730}
731
732static inline void iommu_tlb_sync(struct iommu_domain *domain,
733 struct iommu_iotlb_gather *iotlb_gather)
734{
735}
736
737static inline int iommu_domain_window_enable(struct iommu_domain *domain,
738 u32 wnd_nr, phys_addr_t paddr,
739 u64 size, int prot)
740{
741 return -ENODEV;
742}
743
744static inline void iommu_domain_window_disable(struct iommu_domain *domain,
745 u32 wnd_nr)
746{
747}
748
749static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
750{
751 return 0;
752}
753
754static inline void iommu_set_fault_handler(struct iommu_domain *domain,
755 iommu_fault_handler_t handler, void *token)
756{
757}
758
759static inline void iommu_get_resv_regions(struct device *dev,
760 struct list_head *list)
761{
762}
763
764static inline void iommu_put_resv_regions(struct device *dev,
765 struct list_head *list)
766{
767}
768
769static inline int iommu_get_group_resv_regions(struct iommu_group *group,
770 struct list_head *head)
771{
772 return -ENODEV;
773}
774
775static inline void iommu_set_default_passthrough(bool cmd_line)
776{
777}
778
779static inline void iommu_set_default_translated(bool cmd_line)
780{
781}
782
783static inline bool iommu_default_passthrough(void)
784{
785 return true;
786}
787
788static inline int iommu_attach_group(struct iommu_domain *domain,
789 struct iommu_group *group)
790{
791 return -ENODEV;
792}
793
794static inline void iommu_detach_group(struct iommu_domain *domain,
795 struct iommu_group *group)
796{
797}
798
799static inline struct iommu_group *iommu_group_alloc(void)
800{
801 return ERR_PTR(-ENODEV);
802}
803
804static inline void *iommu_group_get_iommudata(struct iommu_group *group)
805{
806 return NULL;
807}
808
809static inline void iommu_group_set_iommudata(struct iommu_group *group,
810 void *iommu_data,
811 void (*release)(void *iommu_data))
812{
813}
814
815static inline int iommu_group_set_name(struct iommu_group *group,
816 const char *name)
817{
818 return -ENODEV;
819}
820
821static inline int iommu_group_add_device(struct iommu_group *group,
822 struct device *dev)
823{
824 return -ENODEV;
825}
826
827static inline void iommu_group_remove_device(struct device *dev)
828{
829}
830
831static inline int iommu_group_for_each_dev(struct iommu_group *group,
832 void *data,
833 int (*fn)(struct device *, void *))
834{
835 return -ENODEV;
836}
837
838static inline struct iommu_group *iommu_group_get(struct device *dev)
839{
840 return NULL;
841}
842
843static inline void iommu_group_put(struct iommu_group *group)
844{
845}
846
847static inline int iommu_group_register_notifier(struct iommu_group *group,
848 struct notifier_block *nb)
849{
850 return -ENODEV;
851}
852
853static inline int iommu_group_unregister_notifier(struct iommu_group *group,
854 struct notifier_block *nb)
855{
856 return 0;
857}
858
859static inline
860int iommu_register_device_fault_handler(struct device *dev,
861 iommu_dev_fault_handler_t handler,
862 void *data)
863{
864 return -ENODEV;
865}
866
867static inline int iommu_unregister_device_fault_handler(struct device *dev)
868{
869 return 0;
870}
871
872static inline
873int iommu_report_device_fault(struct device *dev, struct iommu_fault_event *evt)
874{
875 return -ENODEV;
876}
877
878static inline int iommu_page_response(struct device *dev,
879 struct iommu_page_response *msg)
880{
881 return -ENODEV;
882}
883
884static inline int iommu_group_id(struct iommu_group *group)
885{
886 return -ENODEV;
887}
888
889static inline int iommu_domain_get_attr(struct iommu_domain *domain,
890 enum iommu_attr attr, void *data)
891{
892 return -EINVAL;
893}
894
895static inline int iommu_domain_set_attr(struct iommu_domain *domain,
896 enum iommu_attr attr, void *data)
897{
898 return -EINVAL;
899}
900
901static inline int iommu_device_register(struct iommu_device *iommu)
902{
903 return -ENODEV;
904}
905
906static inline void iommu_device_set_ops(struct iommu_device *iommu,
907 const struct iommu_ops *ops)
908{
909}
910
911static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
912 struct fwnode_handle *fwnode)
913{
914}
915
916static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
917{
918 return NULL;
919}
920
921static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather)
922{
923}
924
925static inline void iommu_iotlb_gather_add_page(struct iommu_domain *domain,
926 struct iommu_iotlb_gather *gather,
927 unsigned long iova, size_t size)
928{
929}
930
931static inline void iommu_device_unregister(struct iommu_device *iommu)
932{
933}
934
935static inline int iommu_device_sysfs_add(struct iommu_device *iommu,
936 struct device *parent,
937 const struct attribute_group **groups,
938 const char *fmt, ...)
939{
940 return -ENODEV;
941}
942
943static inline void iommu_device_sysfs_remove(struct iommu_device *iommu)
944{
945}
946
947static inline int iommu_device_link(struct device *dev, struct device *link)
948{
949 return -EINVAL;
950}
951
952static inline void iommu_device_unlink(struct device *dev, struct device *link)
953{
954}
955
956static inline int iommu_fwspec_init(struct device *dev,
957 struct fwnode_handle *iommu_fwnode,
958 const struct iommu_ops *ops)
959{
960 return -ENODEV;
961}
962
963static inline void iommu_fwspec_free(struct device *dev)
964{
965}
966
967static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,
968 int num_ids)
969{
970 return -ENODEV;
971}
972
973static inline
974const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
975{
976 return NULL;
977}
978
979static inline bool
980iommu_dev_has_feature(struct device *dev, enum iommu_dev_features feat)
981{
982 return false;
983}
984
985static inline bool
986iommu_dev_feature_enabled(struct device *dev, enum iommu_dev_features feat)
987{
988 return false;
989}
990
991static inline int
992iommu_dev_enable_feature(struct device *dev, enum iommu_dev_features feat)
993{
994 return -ENODEV;
995}
996
997static inline int
998iommu_dev_disable_feature(struct device *dev, enum iommu_dev_features feat)
999{
1000 return -ENODEV;
1001}
1002
1003static inline int
1004iommu_aux_attach_device(struct iommu_domain *domain, struct device *dev)
1005{
1006 return -ENODEV;
1007}
1008
1009static inline void
1010iommu_aux_detach_device(struct iommu_domain *domain, struct device *dev)
1011{
1012}
1013
1014static inline int
1015iommu_aux_get_pasid(struct iommu_domain *domain, struct device *dev)
1016{
1017 return -ENODEV;
1018}
1019
1020static inline struct iommu_sva *
1021iommu_sva_bind_device(struct device *dev, struct mm_struct *mm, void *drvdata)
1022{
1023 return NULL;
1024}
1025
1026static inline void iommu_sva_unbind_device(struct iommu_sva *handle)
1027{
1028}
1029
1030static inline int iommu_sva_get_pasid(struct iommu_sva *handle)
1031{
1032 return IOMMU_PASID_INVALID;
1033}
1034
1035static inline int
1036iommu_cache_invalidate(struct iommu_domain *domain,
1037 struct device *dev,
1038 struct iommu_cache_invalidate_info *inv_info)
1039{
1040 return -ENODEV;
1041}
1042static inline int iommu_sva_bind_gpasid(struct iommu_domain *domain,
1043 struct device *dev, struct iommu_gpasid_bind_data *data)
1044{
1045 return -ENODEV;
1046}
1047
1048static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
1049 struct device *dev, int pasid)
1050{
1051 return -ENODEV;
1052}
1053
1054static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
1055{
1056 return NULL;
1057}
1058#endif
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070static inline size_t iommu_map_sgtable(struct iommu_domain *domain,
1071 unsigned long iova, struct sg_table *sgt, int prot)
1072{
1073 return iommu_map_sg(domain, iova, sgt->sgl, sgt->orig_nents, prot);
1074}
1075
1076#ifdef CONFIG_IOMMU_DEBUGFS
1077extern struct dentry *iommu_debugfs_dir;
1078void iommu_debugfs_setup(void);
1079#else
1080static inline void iommu_debugfs_setup(void) {}
1081#endif
1082
1083#endif
1084