iommu.h 32.9 KB
Newer Older
1
/* SPDX-License-Identifier: GPL-2.0-only */
2 3 4 5 6 7 8 9
/*
 * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
 * Author: Joerg Roedel <joerg.roedel@amd.com>
 */

#ifndef __LINUX_IOMMU_H
#define __LINUX_IOMMU_H

10 11 12
#include <linux/scatterlist.h>
#include <linux/device.h>
#include <linux/types.h>
13
#include <linux/errno.h>
W
Wang YanQing 已提交
14
#include <linux/err.h>
15
#include <linux/of.h>
16
#include <linux/ioasid.h>
17
#include <uapi/linux/iommu.h>
18

19 20 21
#define IOMMU_READ	(1 << 0)
#define IOMMU_WRITE	(1 << 1)
#define IOMMU_CACHE	(1 << 2) /* DMA cache coherency */
22
#define IOMMU_NOEXEC	(1 << 3)
23
#define IOMMU_MMIO	(1 << 4) /* e.g. things like MSI doorbells */
24
/*
25 26 27 28 29 30 31
 * Where the bus hardware includes a privilege level as part of its access type
 * markings, and certain devices are capable of issuing transactions marked as
 * either 'supervisor' or 'user', the IOMMU_PRIV flag requests that the other
 * given permission flags only apply to accesses at the higher privilege level,
 * and that unprivileged transactions should have as little access as possible.
 * This would usually imply the same permissions as kernel mappings on the CPU,
 * if the IOMMU page table format is equivalent.
32 33
 */
#define IOMMU_PRIV	(1 << 5)
34

35
struct iommu_ops;
A
Alex Williamson 已提交
36
struct iommu_group;
37
struct bus_type;
38
struct device;
39
struct iommu_domain;
40
struct notifier_block;
41
struct iommu_sva;
42
struct iommu_fault_event;
43 44 45 46 47 48

/* iommu fault flags */
#define IOMMU_FAULT_READ	0x0
#define IOMMU_FAULT_WRITE	0x1

typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
49
			struct device *, unsigned long, int, void *);
50
typedef int (*iommu_dev_fault_handler_t)(struct iommu_fault *, void *);
51

52 53 54 55 56 57
struct iommu_domain_geometry {
	dma_addr_t aperture_start; /* First address that can be mapped    */
	dma_addr_t aperture_end;   /* Last address that can be mapped     */
	bool force_aperture;       /* DMA only allowed in mappable range? */
};

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
/* Domain feature flags */
#define __IOMMU_DOMAIN_PAGING	(1U << 0)  /* Support for iommu_map/unmap */
#define __IOMMU_DOMAIN_DMA_API	(1U << 1)  /* Domain for use in DMA-API
					      implementation              */
#define __IOMMU_DOMAIN_PT	(1U << 2)  /* Domain is identity mapped   */

/*
 * This are the possible domain-types
 *
 *	IOMMU_DOMAIN_BLOCKED	- All DMA is blocked, can be used to isolate
 *				  devices
 *	IOMMU_DOMAIN_IDENTITY	- DMA addresses are system physical addresses
 *	IOMMU_DOMAIN_UNMANAGED	- DMA mappings managed by IOMMU-API user, used
 *				  for VMs
 *	IOMMU_DOMAIN_DMA	- Internally used for DMA-API implementations.
 *				  This flag allows IOMMU drivers to implement
 *				  certain optimizations for these domains
 */
#define IOMMU_DOMAIN_BLOCKED	(0U)
#define IOMMU_DOMAIN_IDENTITY	(__IOMMU_DOMAIN_PT)
#define IOMMU_DOMAIN_UNMANAGED	(__IOMMU_DOMAIN_PAGING)
#define IOMMU_DOMAIN_DMA	(__IOMMU_DOMAIN_PAGING |	\
				 __IOMMU_DOMAIN_DMA_API)

82
struct iommu_domain {
83
	unsigned type;
84
	const struct iommu_ops *ops;
85
	unsigned long pgsize_bitmap;	/* Bitmap of page sizes in use */
86
	iommu_fault_handler_t handler;
87
	void *handler_token;
88
	struct iommu_domain_geometry geometry;
89
	void *iova_cookie;
90 91
};

92 93 94 95
enum iommu_cap {
	IOMMU_CAP_CACHE_COHERENCY,	/* IOMMU can enforce cache coherent DMA
					   transactions */
	IOMMU_CAP_INTR_REMAP,		/* IOMMU supports interrupt isolation */
96
	IOMMU_CAP_NOEXEC,		/* IOMMU_NOEXEC flag */
97
};
98

99 100 101 102 103 104 105 106 107 108 109 110 111
/*
 * Following constraints are specifc to FSL_PAMUV1:
 *  -aperture must be power of 2, and naturally aligned
 *  -number of windows must be power of 2, and address space size
 *   of each window is determined by aperture size / # of windows
 *  -the actual size of the mapped region of a window must be power
 *   of 2 starting with 4KB and physical address must be naturally
 *   aligned.
 * DOMAIN_ATTR_FSL_PAMUV1 corresponds to the above mentioned contraints.
 * The caller can invoke iommu_domain_get_attr to check if the underlying
 * iommu implementation supports these constraints.
 */

112
enum iommu_attr {
113
	DOMAIN_ATTR_GEOMETRY,
114
	DOMAIN_ATTR_PAGING,
115
	DOMAIN_ATTR_WINDOWS,
116 117 118
	DOMAIN_ATTR_FSL_PAMU_STASH,
	DOMAIN_ATTR_FSL_PAMU_ENABLE,
	DOMAIN_ATTR_FSL_PAMUV1,
119
	DOMAIN_ATTR_NESTING,	/* two stages of translation */
120
	DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE,
121
	DOMAIN_ATTR_MAX,
122 123
};

124
/* These are the possible reserved region types */
125 126 127
enum iommu_resv_type {
	/* Memory regions which must be mapped 1:1 at all times */
	IOMMU_RESV_DIRECT,
128 129 130 131 132 133
	/*
	 * Memory regions which are advertised to be 1:1 but are
	 * commonly considered relaxable in some conditions,
	 * for instance in device assignment use case (USB, Graphics)
	 */
	IOMMU_RESV_DIRECT_RELAXABLE,
134 135 136 137 138 139 140
	/* Arbitrary "never map this or give it to a device" address ranges */
	IOMMU_RESV_RESERVED,
	/* Hardware MSI region (untranslated) */
	IOMMU_RESV_MSI,
	/* Software-managed MSI translation window */
	IOMMU_RESV_SW_MSI,
};
141

142
/**
143
 * struct iommu_resv_region - descriptor for a reserved memory region
144 145 146 147
 * @list: Linked list pointers
 * @start: System physical start address of the region
 * @length: Length of the region in bytes
 * @prot: IOMMU Protection flags (READ/WRITE/...)
148
 * @type: Type of the reserved region
149
 */
150
struct iommu_resv_region {
151 152 153 154
	struct list_head	list;
	phys_addr_t		start;
	size_t			length;
	int			prot;
155
	enum iommu_resv_type	type;
156 157
};

158 159 160
/* Per device IOMMU features */
enum iommu_dev_features {
	IOMMU_DEV_FEAT_AUX,	/* Aux-domain feature */
161 162 163 164 165
	IOMMU_DEV_FEAT_SVA,	/* Shared Virtual Addresses */
};

#define IOMMU_PASID_INVALID	(-1U)

166 167
#ifdef CONFIG_IOMMU_API

168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184
/**
 * struct iommu_iotlb_gather - Range information for a pending IOTLB flush
 *
 * @start: IOVA representing the start of the range to be flushed
 * @end: IOVA representing the end of the range to be flushed (exclusive)
 * @pgsize: The interval at which to perform the flush
 *
 * This structure is intended to be updated by multiple calls to the
 * ->unmap() function in struct iommu_ops before eventually being passed
 * into ->iotlb_sync().
 */
struct iommu_iotlb_gather {
	unsigned long		start;
	unsigned long		end;
	size_t			pgsize;
};

185 186
/**
 * struct iommu_ops - iommu ops and capabilities
187 188 189
 * @capable: check capability
 * @domain_alloc: allocate iommu domain
 * @domain_free: free iommu domain
190 191 192 193
 * @attach_dev: attach device to an iommu domain
 * @detach_dev: detach device from an iommu domain
 * @map: map a physically contiguous memory region to an iommu domain
 * @unmap: unmap a physically contiguous memory region from an iommu domain
194
 * @flush_iotlb_all: Synchronously flush all hardware TLBs for this domain
195
 * @iotlb_sync_map: Sync mappings created recently using @map to the hardware
196
 * @iotlb_sync: Flush all queued ranges from the hardware TLBs and empty flush
197
 *            queue
198
 * @iova_to_phys: translate iova to physical address
199 200 201 202
 * @probe_device: Add device to iommu driver handling
 * @release_device: Remove device from iommu driver handling
 * @probe_finalize: Do final setup work after the device is added to an IOMMU
 *                  group and attached to the groups domain
203
 * @device_group: find iommu group for a particular device
204 205
 * @domain_get_attr: Query domain attributes
 * @domain_set_attr: Change domain attributes
206 207 208
 * @get_resv_regions: Request list of reserved regions for a device
 * @put_resv_regions: Free list of reserved regions for a device
 * @apply_resv_region: Temporary helper call-back for iova reserved ranges
209 210
 * @domain_window_enable: Configure and enable a particular window for a domain
 * @domain_window_disable: Disable a particular window for a domain
211
 * @of_xlate: add OF master IDs to iommu grouping
212 213
 * @is_attach_deferred: Check if domain attach should be deferred from iommu
 *                      driver init to device driver init (default no)
214 215 216 217 218
 * @dev_has/enable/disable_feat: per device entries to check/enable/disable
 *                               iommu specific features.
 * @dev_feat_enabled: check enabled feature
 * @aux_attach/detach_dev: aux-domain specific attach/detach entries.
 * @aux_get_pasid: get the pasid given an aux-domain
219 220 221
 * @sva_bind: Bind process address space to device
 * @sva_unbind: Unbind process address space from device
 * @sva_get_pasid: Get PASID associated to a SVA handle
222
 * @page_response: handle page request response
223
 * @cache_invalidate: invalidate translation caches
224 225
 * @sva_bind_gpasid: bind guest pasid and mm
 * @sva_unbind_gpasid: unbind guest pasid and mm
226 227 228 229
 * @def_domain_type: device default domain type, return value:
 *		- IOMMU_DOMAIN_IDENTITY: must use an identity domain
 *		- IOMMU_DOMAIN_DMA: must use a dma domain
 *		- 0: use the default setting
230 231
 * @pgsize_bitmap: bitmap of all possible supported page sizes
 * @owner: Driver module providing these ops
232
 */
233
struct iommu_ops {
234
	bool (*capable)(enum iommu_cap);
235 236

	/* Domain allocation and freeing by the iommu driver */
237
	struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
238 239
	void (*domain_free)(struct iommu_domain *);

240 241
	int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
	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 249
	void (*iotlb_sync)(struct iommu_domain *domain,
			   struct iommu_iotlb_gather *iotlb_gather);
250
	phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
251 252 253
	struct iommu_device *(*probe_device)(struct device *dev);
	void (*release_device)(struct device *dev);
	void (*probe_finalize)(struct device *dev);
254
	struct iommu_group *(*device_group)(struct device *dev);
255 256 257 258
	int (*domain_get_attr)(struct iommu_domain *domain,
			       enum iommu_attr attr, void *data);
	int (*domain_set_attr)(struct iommu_domain *domain,
			       enum iommu_attr attr, void *data);
259

260 261 262 263 264 265
	/* Request/Free a list of reserved regions for a device */
	void (*get_resv_regions)(struct device *dev, struct list_head *list);
	void (*put_resv_regions)(struct device *dev, struct list_head *list);
	void (*apply_resv_region)(struct device *dev,
				  struct iommu_domain *domain,
				  struct iommu_resv_region *region);
266

267 268
	/* Window handling functions */
	int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
269
				    phys_addr_t paddr, u64 size, int prot);
270 271
	void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);

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 277 278 279 280 281 282 283 284 285
	/* Per device IOMMU features */
	bool (*dev_has_feat)(struct device *dev, enum iommu_dev_features f);
	bool (*dev_feat_enabled)(struct device *dev, enum iommu_dev_features f);
	int (*dev_enable_feat)(struct device *dev, enum iommu_dev_features f);
	int (*dev_disable_feat)(struct device *dev, enum iommu_dev_features f);

	/* Aux-domain specific attach/detach entries */
	int (*aux_attach_dev)(struct iommu_domain *domain, struct device *dev);
	void (*aux_detach_dev)(struct iommu_domain *domain, struct device *dev);
	int (*aux_get_pasid)(struct iommu_domain *domain, struct device *dev);

286 287 288 289 290
	struct iommu_sva *(*sva_bind)(struct device *dev, struct mm_struct *mm,
				      void *drvdata);
	void (*sva_unbind)(struct iommu_sva *handle);
	int (*sva_get_pasid)(struct iommu_sva *handle);

291 292 293
	int (*page_response)(struct device *dev,
			     struct iommu_fault_event *evt,
			     struct iommu_page_response *msg);
294 295
	int (*cache_invalidate)(struct iommu_domain *domain, struct device *dev,
				struct iommu_cache_invalidate_info *inv_info);
296 297 298 299
	int (*sva_bind_gpasid)(struct iommu_domain *domain,
			struct device *dev, struct iommu_gpasid_bind_data *data);

	int (*sva_unbind_gpasid)(struct device *dev, int pasid);
300

301 302
	int (*def_domain_type)(struct device *dev);

303
	unsigned long pgsize_bitmap;
304
	struct module *owner;
305 306
};

307 308 309 310 311
/**
 * struct iommu_device - IOMMU core representation of one IOMMU hardware
 *			 instance
 * @list: Used by the iommu-core to keep a list of registered iommus
 * @ops: iommu-ops for talking to this iommu
312
 * @dev: struct device for sysfs handling
313 314 315 316
 */
struct iommu_device {
	struct list_head list;
	const struct iommu_ops *ops;
317
	struct fwnode_handle *fwnode;
318
	struct device *dev;
319 320
};

321 322 323 324 325 326 327
/**
 * struct iommu_fault_event - Generic fault event
 *
 * Can represent recoverable faults such as a page requests or
 * unrecoverable faults such as DMA or IRQ remapping faults.
 *
 * @fault: fault descriptor
328
 * @list: pending fault event list, used for tracking responses
329 330 331
 */
struct iommu_fault_event {
	struct iommu_fault fault;
332
	struct list_head list;
333 334 335 336 337 338
};

/**
 * struct iommu_fault_param - per-device IOMMU fault data
 * @handler: Callback function to handle IOMMU faults at device level
 * @data: handler private data
339 340
 * @faults: holds the pending faults which needs response
 * @lock: protect pending faults list
341 342 343 344
 */
struct iommu_fault_param {
	iommu_dev_fault_handler_t handler;
	void *data;
345 346
	struct list_head faults;
	struct mutex lock;
347 348 349
};

/**
350
 * struct dev_iommu - Collection of per-device IOMMU data
351 352
 *
 * @fault_param: IOMMU detected device fault reporting data
353
 * @fwspec:	 IOMMU fwspec data
354
 * @iommu_dev:	 IOMMU device this device is linked to
355
 * @priv:	 IOMMU Driver private data
356 357 358 359
 *
 * TODO: migrate other per device data pointers under iommu_dev_data, e.g.
 *	struct iommu_group	*iommu_group;
 */
360
struct dev_iommu {
361
	struct mutex lock;
362 363
	struct iommu_fault_param	*fault_param;
	struct iommu_fwspec		*fwspec;
364
	struct iommu_device		*iommu_dev;
365
	void				*priv;
366 367
};

368 369
int  iommu_device_register(struct iommu_device *iommu);
void iommu_device_unregister(struct iommu_device *iommu);
370 371 372 373 374
int  iommu_device_sysfs_add(struct iommu_device *iommu,
			    struct device *parent,
			    const struct attribute_group **groups,
			    const char *fmt, ...) __printf(4, 5);
void iommu_device_sysfs_remove(struct iommu_device *iommu);
375 376
int  iommu_device_link(struct iommu_device   *iommu, struct device *link);
void iommu_device_unlink(struct iommu_device *iommu, struct device *link);
377

378 379
static inline void __iommu_device_set_ops(struct iommu_device *iommu,
					  const struct iommu_ops *ops)
380 381 382 383
{
	iommu->ops = ops;
}

384 385 386 387 388 389 390
#define iommu_device_set_ops(iommu, ops)				\
do {									\
	struct iommu_ops *__ops = (struct iommu_ops *)(ops);		\
	__ops->owner = THIS_MODULE;					\
	__iommu_device_set_ops(iommu, __ops);				\
} while (0)

391 392 393 394 395 396
static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
					   struct fwnode_handle *fwnode)
{
	iommu->fwnode = fwnode;
}

397 398 399 400 401
static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
{
	return (struct iommu_device *)dev_get_drvdata(dev);
}

402 403 404 405 406 407 408
static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather)
{
	*gather = (struct iommu_iotlb_gather) {
		.start	= ULONG_MAX,
	};
}

A
Alex Williamson 已提交
409 410 411 412 413 414 415
#define IOMMU_GROUP_NOTIFY_ADD_DEVICE		1 /* Device added */
#define IOMMU_GROUP_NOTIFY_DEL_DEVICE		2 /* Pre Device removed */
#define IOMMU_GROUP_NOTIFY_BIND_DRIVER		3 /* Pre Driver bind */
#define IOMMU_GROUP_NOTIFY_BOUND_DRIVER		4 /* Post Driver bind */
#define IOMMU_GROUP_NOTIFY_UNBIND_DRIVER	5 /* Pre Driver unbind */
#define IOMMU_GROUP_NOTIFY_UNBOUND_DRIVER	6 /* Post Driver unbind */

416
extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
417
extern int bus_iommu_probe(struct bus_type *bus);
418
extern bool iommu_present(struct bus_type *bus);
419
extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
420
extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
421
extern struct iommu_group *iommu_group_get_by_id(int id);
422 423 424 425 426
extern void iommu_domain_free(struct iommu_domain *domain);
extern int iommu_attach_device(struct iommu_domain *domain,
			       struct device *dev);
extern void iommu_detach_device(struct iommu_domain *domain,
				struct device *dev);
427 428
extern int iommu_uapi_cache_invalidate(struct iommu_domain *domain,
				       struct device *dev,
429 430
				       void __user *uinfo);

431
extern int iommu_uapi_sva_bind_gpasid(struct iommu_domain *domain,
432
				      struct device *dev, void __user *udata);
433
extern int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
434 435 436
					struct device *dev, void __user *udata);
extern int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
				   struct device *dev, ioasid_t pasid);
437
extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
438
extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
439
extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
440
		     phys_addr_t paddr, size_t size, int prot);
441 442
extern int iommu_map_atomic(struct iommu_domain *domain, unsigned long iova,
			    phys_addr_t paddr, size_t size, int prot);
443
extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
444 445
			  size_t size);
extern size_t iommu_unmap_fast(struct iommu_domain *domain,
446 447
			       unsigned long iova, size_t size,
			       struct iommu_iotlb_gather *iotlb_gather);
448 449
extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
			   struct scatterlist *sg,unsigned int nents, int prot);
450 451 452
extern size_t iommu_map_sg_atomic(struct iommu_domain *domain,
				  unsigned long iova, struct scatterlist *sg,
				  unsigned int nents, int prot);
453
extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
454
extern void iommu_set_fault_handler(struct iommu_domain *domain,
455
			iommu_fault_handler_t handler, void *token);
A
Alex Williamson 已提交
456

457 458
extern void iommu_get_resv_regions(struct device *dev, struct list_head *list);
extern void iommu_put_resv_regions(struct device *dev, struct list_head *list);
459 460
extern void generic_iommu_put_resv_regions(struct device *dev,
					   struct list_head *list);
461 462 463
extern void iommu_set_default_passthrough(bool cmd_line);
extern void iommu_set_default_translated(bool cmd_line);
extern bool iommu_default_passthrough(void);
464
extern struct iommu_resv_region *
465 466
iommu_alloc_resv_region(phys_addr_t start, size_t length, int prot,
			enum iommu_resv_type type);
467 468
extern int iommu_get_group_resv_regions(struct iommu_group *group,
					struct list_head *head);
469

A
Alex Williamson 已提交
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485
extern int iommu_attach_group(struct iommu_domain *domain,
			      struct iommu_group *group);
extern void iommu_detach_group(struct iommu_domain *domain,
			       struct iommu_group *group);
extern struct iommu_group *iommu_group_alloc(void);
extern void *iommu_group_get_iommudata(struct iommu_group *group);
extern void iommu_group_set_iommudata(struct iommu_group *group,
				      void *iommu_data,
				      void (*release)(void *iommu_data));
extern int iommu_group_set_name(struct iommu_group *group, const char *name);
extern int iommu_group_add_device(struct iommu_group *group,
				  struct device *dev);
extern void iommu_group_remove_device(struct device *dev);
extern int iommu_group_for_each_dev(struct iommu_group *group, void *data,
				    int (*fn)(struct device *, void *));
extern struct iommu_group *iommu_group_get(struct device *dev);
486
extern struct iommu_group *iommu_group_ref_get(struct iommu_group *group);
A
Alex Williamson 已提交
487 488 489 490 491
extern void iommu_group_put(struct iommu_group *group);
extern int iommu_group_register_notifier(struct iommu_group *group,
					 struct notifier_block *nb);
extern int iommu_group_unregister_notifier(struct iommu_group *group,
					   struct notifier_block *nb);
492 493 494 495 496 497 498 499
extern int iommu_register_device_fault_handler(struct device *dev,
					iommu_dev_fault_handler_t handler,
					void *data);

extern int iommu_unregister_device_fault_handler(struct device *dev);

extern int iommu_report_device_fault(struct device *dev,
				     struct iommu_fault_event *evt);
500 501
extern int iommu_page_response(struct device *dev,
			       struct iommu_page_response *msg);
502

A
Alex Williamson 已提交
503
extern int iommu_group_id(struct iommu_group *group);
504
extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
505

506 507 508 509
extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
				 void *data);
extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
				 void *data);
510

511 512
/* Window handling function prototypes */
extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
513 514
				      phys_addr_t offset, u64 size,
				      int prot);
515
extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
516 517 518

extern int report_iommu_fault(struct iommu_domain *domain, struct device *dev,
			      unsigned long iova, int flags);
519

520
static inline void iommu_flush_iotlb_all(struct iommu_domain *domain)
521 522 523 524 525
{
	if (domain->ops->flush_iotlb_all)
		domain->ops->flush_iotlb_all(domain);
}

526
static inline void iommu_iotlb_sync(struct iommu_domain *domain,
527
				  struct iommu_iotlb_gather *iotlb_gather)
528 529
{
	if (domain->ops->iotlb_sync)
530
		domain->ops->iotlb_sync(domain, iotlb_gather);
531 532

	iommu_iotlb_gather_init(iotlb_gather);
533 534
}

535 536 537 538 539 540 541 542 543 544 545 546 547 548
static inline void iommu_iotlb_gather_add_page(struct iommu_domain *domain,
					       struct iommu_iotlb_gather *gather,
					       unsigned long iova, size_t size)
{
	unsigned long start = iova, end = start + size;

	/*
	 * If the new page is disjoint from the current range or is mapped at
	 * a different granularity, then sync the TLB so that the gather
	 * structure can be rewritten.
	 */
	if (gather->pgsize != size ||
	    end < gather->start || start > gather->end) {
		if (gather->pgsize)
549
			iommu_iotlb_sync(domain, gather);
550 551 552 553 554 555 556 557 558 559
		gather->pgsize = size;
	}

	if (gather->end < end)
		gather->end = end;

	if (gather->start > start)
		gather->start = start;
}

560 561
/* PCI device grouping function */
extern struct iommu_group *pci_device_group(struct device *dev);
562 563
/* Generic device grouping function */
extern struct iommu_group *generic_device_group(struct device *dev);
564 565
/* FSL-MC device grouping function */
struct iommu_group *fsl_mc_device_group(struct device *dev);
566

567 568 569 570 571
/**
 * struct iommu_fwspec - per-device IOMMU instance data
 * @ops: ops for this device's IOMMU
 * @iommu_fwnode: firmware handle for this device's IOMMU
 * @iommu_priv: IOMMU driver private data for this device
572
 * @num_pasid_bits: number of PASID bits supported by this device
573 574 575 576 577 578
 * @num_ids: number of associated device IDs
 * @ids: IDs which this device may present to the IOMMU
 */
struct iommu_fwspec {
	const struct iommu_ops	*ops;
	struct fwnode_handle	*iommu_fwnode;
579
	u32			flags;
580
	u32			num_pasid_bits;
581
	unsigned int		num_ids;
582
	u32			ids[];
583 584
};

585 586 587
/* ATS is supported */
#define IOMMU_FWSPEC_PCI_RC_ATS			(1 << 0)

588 589 590 591 592 593 594
/**
 * struct iommu_sva - handle to a device-mm bond
 */
struct iommu_sva {
	struct device			*dev;
};

595 596 597 598
int iommu_fwspec_init(struct device *dev, struct fwnode_handle *iommu_fwnode,
		      const struct iommu_ops *ops);
void iommu_fwspec_free(struct device *dev);
int iommu_fwspec_add_ids(struct device *dev, u32 *ids, int num_ids);
599
const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode);
600

601 602
static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
{
603 604 605 606
	if (dev->iommu)
		return dev->iommu->fwspec;
	else
		return NULL;
607 608 609 610 611
}

static inline void dev_iommu_fwspec_set(struct device *dev,
					struct iommu_fwspec *fwspec)
{
612
	dev->iommu->fwspec = fwspec;
613 614
}

615 616
static inline void *dev_iommu_priv_get(struct device *dev)
{
617
	return dev->iommu->priv;
618 619 620 621
}

static inline void dev_iommu_priv_set(struct device *dev, void *priv)
{
622
	dev->iommu->priv = priv;
623 624
}

625 626 627
int iommu_probe_device(struct device *dev);
void iommu_release_device(struct device *dev);

628 629 630 631 632 633 634 635
bool iommu_dev_has_feature(struct device *dev, enum iommu_dev_features f);
int iommu_dev_enable_feature(struct device *dev, enum iommu_dev_features f);
int iommu_dev_disable_feature(struct device *dev, enum iommu_dev_features f);
bool iommu_dev_feature_enabled(struct device *dev, enum iommu_dev_features f);
int iommu_aux_attach_device(struct iommu_domain *domain, struct device *dev);
void iommu_aux_detach_device(struct iommu_domain *domain, struct device *dev);
int iommu_aux_get_pasid(struct iommu_domain *domain, struct device *dev);

636 637 638 639 640 641
struct iommu_sva *iommu_sva_bind_device(struct device *dev,
					struct mm_struct *mm,
					void *drvdata);
void iommu_sva_unbind_device(struct iommu_sva *handle);
int iommu_sva_get_pasid(struct iommu_sva *handle);

642 643
#else /* CONFIG_IOMMU_API */

644
struct iommu_ops {};
A
Alex Williamson 已提交
645
struct iommu_group {};
646
struct iommu_fwspec {};
647
struct iommu_device {};
648
struct iommu_fault_param {};
649
struct iommu_iotlb_gather {};
650

651
static inline bool iommu_present(struct bus_type *bus)
652 653 654 655
{
	return false;
}

656 657 658 659 660
static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
{
	return false;
}

661
static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
662 663 664 665
{
	return NULL;
}

666 667 668 669 670
static inline struct iommu_group *iommu_group_get_by_id(int id)
{
	return NULL;
}

671 672 673 674 675 676 677 678 679 680 681 682 683 684 685
static inline void iommu_domain_free(struct iommu_domain *domain)
{
}

static inline int iommu_attach_device(struct iommu_domain *domain,
				      struct device *dev)
{
	return -ENODEV;
}

static inline void iommu_detach_device(struct iommu_domain *domain,
				       struct device *dev)
{
}

686 687 688 689 690
static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
{
	return NULL;
}

691
static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
692
			    phys_addr_t paddr, size_t size, int prot)
693 694 695 696
{
	return -ENODEV;
}

697 698 699 700 701 702 703
static inline int iommu_map_atomic(struct iommu_domain *domain,
				   unsigned long iova, phys_addr_t paddr,
				   size_t size, int prot)
{
	return -ENODEV;
}

704 705
static inline size_t iommu_unmap(struct iommu_domain *domain,
				 unsigned long iova, size_t size)
706
{
707
	return 0;
708 709
}

710
static inline size_t iommu_unmap_fast(struct iommu_domain *domain,
711 712
				      unsigned long iova, int gfp_order,
				      struct iommu_iotlb_gather *iotlb_gather)
713
{
714
	return 0;
715 716
}

717 718 719 720
static inline size_t iommu_map_sg(struct iommu_domain *domain,
				  unsigned long iova, struct scatterlist *sg,
				  unsigned int nents, int prot)
{
721
	return 0;
722 723
}

724 725 726 727 728 729 730
static inline size_t iommu_map_sg_atomic(struct iommu_domain *domain,
				  unsigned long iova, struct scatterlist *sg,
				  unsigned int nents, int prot)
{
	return 0;
}

731
static inline void iommu_flush_iotlb_all(struct iommu_domain *domain)
732 733 734
{
}

735
static inline void iommu_iotlb_sync(struct iommu_domain *domain,
736
				  struct iommu_iotlb_gather *iotlb_gather)
737 738 739
{
}

740 741
static inline int iommu_domain_window_enable(struct iommu_domain *domain,
					     u32 wnd_nr, phys_addr_t paddr,
742
					     u64 size, int prot)
743 744 745 746 747 748 749 750 751
{
	return -ENODEV;
}

static inline void iommu_domain_window_disable(struct iommu_domain *domain,
					       u32 wnd_nr)
{
}

752
static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
753 754 755 756
{
	return 0;
}

757
static inline void iommu_set_fault_handler(struct iommu_domain *domain,
758
				iommu_fault_handler_t handler, void *token)
759 760 761
{
}

762
static inline void iommu_get_resv_regions(struct device *dev,
763 764 765 766
					struct list_head *list)
{
}

767
static inline void iommu_put_resv_regions(struct device *dev,
768 769 770 771
					struct list_head *list)
{
}

772 773 774 775 776 777
static inline int iommu_get_group_resv_regions(struct iommu_group *group,
					       struct list_head *head)
{
	return -ENODEV;
}

778 779 780 781 782 783 784 785 786 787 788 789 790
static inline void iommu_set_default_passthrough(bool cmd_line)
{
}

static inline void iommu_set_default_translated(bool cmd_line)
{
}

static inline bool iommu_default_passthrough(void)
{
	return true;
}

791 792
static inline int iommu_attach_group(struct iommu_domain *domain,
				     struct iommu_group *group)
A
Alex Williamson 已提交
793 794 795 796
{
	return -ENODEV;
}

797 798
static inline void iommu_detach_group(struct iommu_domain *domain,
				      struct iommu_group *group)
A
Alex Williamson 已提交
799 800 801
{
}

802
static inline struct iommu_group *iommu_group_alloc(void)
A
Alex Williamson 已提交
803 804 805 806
{
	return ERR_PTR(-ENODEV);
}

807
static inline void *iommu_group_get_iommudata(struct iommu_group *group)
A
Alex Williamson 已提交
808 809 810 811
{
	return NULL;
}

812 813 814
static inline void iommu_group_set_iommudata(struct iommu_group *group,
					     void *iommu_data,
					     void (*release)(void *iommu_data))
A
Alex Williamson 已提交
815 816 817
{
}

818 819
static inline int iommu_group_set_name(struct iommu_group *group,
				       const char *name)
A
Alex Williamson 已提交
820 821 822 823
{
	return -ENODEV;
}

824 825
static inline int iommu_group_add_device(struct iommu_group *group,
					 struct device *dev)
A
Alex Williamson 已提交
826 827 828 829
{
	return -ENODEV;
}

830
static inline void iommu_group_remove_device(struct device *dev)
A
Alex Williamson 已提交
831 832 833
{
}

834 835 836
static inline int iommu_group_for_each_dev(struct iommu_group *group,
					   void *data,
					   int (*fn)(struct device *, void *))
A
Alex Williamson 已提交
837 838 839 840
{
	return -ENODEV;
}

841
static inline struct iommu_group *iommu_group_get(struct device *dev)
A
Alex Williamson 已提交
842 843 844 845
{
	return NULL;
}

846
static inline void iommu_group_put(struct iommu_group *group)
A
Alex Williamson 已提交
847 848 849
{
}

850 851
static inline int iommu_group_register_notifier(struct iommu_group *group,
						struct notifier_block *nb)
852 853 854 855
{
	return -ENODEV;
}

856 857
static inline int iommu_group_unregister_notifier(struct iommu_group *group,
						  struct notifier_block *nb)
A
Alex Williamson 已提交
858 859 860 861
{
	return 0;
}

862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880
static inline
int iommu_register_device_fault_handler(struct device *dev,
					iommu_dev_fault_handler_t handler,
					void *data)
{
	return -ENODEV;
}

static inline int iommu_unregister_device_fault_handler(struct device *dev)
{
	return 0;
}

static inline
int iommu_report_device_fault(struct device *dev, struct iommu_fault_event *evt)
{
	return -ENODEV;
}

881 882 883 884 885 886
static inline int iommu_page_response(struct device *dev,
				      struct iommu_page_response *msg)
{
	return -ENODEV;
}

887
static inline int iommu_group_id(struct iommu_group *group)
A
Alex Williamson 已提交
888 889 890
{
	return -ENODEV;
}
891

892 893 894 895 896 897 898 899 900 901 902 903
static inline int iommu_domain_get_attr(struct iommu_domain *domain,
					enum iommu_attr attr, void *data)
{
	return -EINVAL;
}

static inline int iommu_domain_set_attr(struct iommu_domain *domain,
					enum iommu_attr attr, void *data)
{
	return -EINVAL;
}

904
static inline int  iommu_device_register(struct iommu_device *iommu)
905
{
906
	return -ENODEV;
907 908
}

909 910
static inline void iommu_device_set_ops(struct iommu_device *iommu,
					const struct iommu_ops *ops)
911 912 913
{
}

914 915
static inline void iommu_device_set_fwnode(struct iommu_device *iommu,
					   struct fwnode_handle *fwnode)
916 917 918
{
}

919 920 921 922 923
static inline struct iommu_device *dev_to_iommu_device(struct device *dev)
{
	return NULL;
}

924 925 926 927
static inline void iommu_iotlb_gather_init(struct iommu_iotlb_gather *gather)
{
}

928 929 930 931 932 933
static inline void iommu_iotlb_gather_add_page(struct iommu_domain *domain,
					       struct iommu_iotlb_gather *gather,
					       unsigned long iova, size_t size)
{
}

934
static inline void iommu_device_unregister(struct iommu_device *iommu)
935 936 937
{
}

938 939 940 941
static inline int  iommu_device_sysfs_add(struct iommu_device *iommu,
					  struct device *parent,
					  const struct attribute_group **groups,
					  const char *fmt, ...)
942
{
943
	return -ENODEV;
944 945
}

946
static inline void iommu_device_sysfs_remove(struct iommu_device *iommu)
947 948 949
{
}

950
static inline int iommu_device_link(struct device *dev, struct device *link)
951 952 953 954
{
	return -EINVAL;
}

955
static inline void iommu_device_unlink(struct device *dev, struct device *link)
956 957 958
{
}

959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975
static inline int iommu_fwspec_init(struct device *dev,
				    struct fwnode_handle *iommu_fwnode,
				    const struct iommu_ops *ops)
{
	return -ENODEV;
}

static inline void iommu_fwspec_free(struct device *dev)
{
}

static inline int iommu_fwspec_add_ids(struct device *dev, u32 *ids,
				       int num_ids)
{
	return -ENODEV;
}

976
static inline
977
const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
978 979 980 981
{
	return NULL;
}

982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022
static inline bool
iommu_dev_has_feature(struct device *dev, enum iommu_dev_features feat)
{
	return false;
}

static inline bool
iommu_dev_feature_enabled(struct device *dev, enum iommu_dev_features feat)
{
	return false;
}

static inline int
iommu_dev_enable_feature(struct device *dev, enum iommu_dev_features feat)
{
	return -ENODEV;
}

static inline int
iommu_dev_disable_feature(struct device *dev, enum iommu_dev_features feat)
{
	return -ENODEV;
}

static inline int
iommu_aux_attach_device(struct iommu_domain *domain, struct device *dev)
{
	return -ENODEV;
}

static inline void
iommu_aux_detach_device(struct iommu_domain *domain, struct device *dev)
{
}

static inline int
iommu_aux_get_pasid(struct iommu_domain *domain, struct device *dev)
{
	return -ENODEV;
}

1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
static inline struct iommu_sva *
iommu_sva_bind_device(struct device *dev, struct mm_struct *mm, void *drvdata)
{
	return NULL;
}

static inline void iommu_sva_unbind_device(struct iommu_sva *handle)
{
}

static inline int iommu_sva_get_pasid(struct iommu_sva *handle)
{
	return IOMMU_PASID_INVALID;
}

1038 1039 1040 1041
static inline int
iommu_uapi_cache_invalidate(struct iommu_domain *domain,
			    struct device *dev,
			    struct iommu_cache_invalidate_info *inv_info)
1042 1043 1044
{
	return -ENODEV;
}
1045 1046

static inline int iommu_uapi_sva_bind_gpasid(struct iommu_domain *domain,
1047
					     struct device *dev, void __user *udata)
1048 1049 1050 1051
{
	return -ENODEV;
}

1052
static inline int iommu_uapi_sva_unbind_gpasid(struct iommu_domain *domain,
1053 1054 1055 1056 1057 1058 1059 1060
					       struct device *dev, void __user *udata)
{
	return -ENODEV;
}

static inline int iommu_sva_unbind_gpasid(struct iommu_domain *domain,
					  struct device *dev,
					  ioasid_t pasid)
1061 1062 1063
{
	return -ENODEV;
}
1064

1065 1066 1067 1068
static inline struct iommu_fwspec *dev_iommu_fwspec_get(struct device *dev)
{
	return NULL;
}
1069 1070
#endif /* CONFIG_IOMMU_API */

1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086
/**
 * iommu_map_sgtable - Map the given buffer to the IOMMU domain
 * @domain:	The IOMMU domain to perform the mapping
 * @iova:	The start address to map the buffer
 * @sgt:	The sg_table object describing the buffer
 * @prot:	IOMMU protection bits
 *
 * Creates a mapping at @iova for the buffer described by a scatterlist
 * stored in the given sg_table object in the provided IOMMU domain.
 */
static inline size_t iommu_map_sgtable(struct iommu_domain *domain,
			unsigned long iova, struct sg_table *sgt, int prot)
{
	return iommu_map_sg(domain, iova, sgt->sgl, sgt->orig_nents, prot);
}

1087 1088 1089 1090 1091 1092 1093
#ifdef CONFIG_IOMMU_DEBUGFS
extern	struct dentry *iommu_debugfs_dir;
void iommu_debugfs_setup(void);
#else
static inline void iommu_debugfs_setup(void) {}
#endif

1094
#endif /* __LINUX_IOMMU_H */
新手
引导
客服 返回
顶部