iommu.h 17.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * Copyright (C) 2007-2008 Advanced Micro Devices, Inc.
 * Author: Joerg Roedel <joerg.roedel@amd.com>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
 */

#ifndef __LINUX_IOMMU_H
#define __LINUX_IOMMU_H

22
#include <linux/errno.h>
Wang YanQing's avatar
Wang YanQing committed
23
#include <linux/err.h>
24
#include <linux/of.h>
Thierry Reding's avatar
Thierry Reding committed
25
#include <linux/types.h>
26
#include <linux/scatterlist.h>
27
#include <trace/events/iommu.h>
28

29
30
31
#define IOMMU_READ	(1 << 0)
#define IOMMU_WRITE	(1 << 1)
#define IOMMU_CACHE	(1 << 2) /* DMA cache coherency */
32
#define IOMMU_NOEXEC	(1 << 3)
33

34
struct iommu_ops;
Alex Williamson's avatar
Alex Williamson committed
35
struct iommu_group;
36
struct bus_type;
37
struct device;
38
struct iommu_domain;
39
struct notifier_block;
40
41
42
43
44
45

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

typedef int (*iommu_fault_handler_t)(struct iommu_domain *,
46
			struct device *, unsigned long, int, void *);
47

48
49
50
51
52
53
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? */
};

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
/* 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)

78
struct iommu_domain {
79
	unsigned type;
80
	const struct iommu_ops *ops;
81
	iommu_fault_handler_t handler;
82
	void *handler_token;
83
	struct iommu_domain_geometry geometry;
84
	void *iova_cookie;
85
86
};

87
88
89
90
enum iommu_cap {
	IOMMU_CAP_CACHE_COHERENCY,	/* IOMMU can enforce cache coherent DMA
					   transactions */
	IOMMU_CAP_INTR_REMAP,		/* IOMMU supports interrupt isolation */
91
	IOMMU_CAP_NOEXEC,		/* IOMMU_NOEXEC flag */
92
};
93

94
95
96
97
98
99
100
101
102
103
104
105
106
/*
 * 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.
 */

107
enum iommu_attr {
108
	DOMAIN_ATTR_GEOMETRY,
109
	DOMAIN_ATTR_PAGING,
110
	DOMAIN_ATTR_WINDOWS,
111
112
113
	DOMAIN_ATTR_FSL_PAMU_STASH,
	DOMAIN_ATTR_FSL_PAMU_ENABLE,
	DOMAIN_ATTR_FSL_PAMUV1,
114
	DOMAIN_ATTR_NESTING,	/* two stages of translation */
115
	DOMAIN_ATTR_MAX,
116
117
};

118
119
120
121
122
123
124
125
126
127
128
129
130
131
/**
 * struct iommu_dm_region - descriptor for a direct mapped memory region
 * @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/...)
 */
struct iommu_dm_region {
	struct list_head	list;
	phys_addr_t		start;
	size_t			length;
	int			prot;
};

132
133
#ifdef CONFIG_IOMMU_API

134
135
/**
 * struct iommu_ops - iommu ops and capabilities
136
137
138
 * @capable: check capability
 * @domain_alloc: allocate iommu domain
 * @domain_free: free iommu domain
139
140
141
142
 * @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
143
144
 * @map_sg: map a scatter-gather list of physically contiguous memory chunks
 * to an iommu domain
145
 * @iova_to_phys: translate iova to physical address
Alex Williamson's avatar
Alex Williamson committed
146
147
 * @add_device: add device to iommu grouping
 * @remove_device: remove device from iommu grouping
148
 * @device_group: find iommu group for a particular device
149
150
 * @domain_get_attr: Query domain attributes
 * @domain_set_attr: Change domain attributes
151
152
153
154
155
156
 * @get_dm_regions: Request list of direct mapping requirements for a device
 * @put_dm_regions: Free list of direct mapping requirements for a device
 * @domain_window_enable: Configure and enable a particular window for a domain
 * @domain_window_disable: Disable a particular window for a domain
 * @domain_set_windows: Set the number of windows for a domain
 * @domain_get_windows: Return the number of windows for a domain
157
 * @of_xlate: add OF master IDs to iommu grouping
158
 * @pgsize_bitmap: bitmap of supported page sizes
159
 * @priv: per-instance data private to the iommu driver
160
 */
161
struct iommu_ops {
162
	bool (*capable)(enum iommu_cap);
163
164

	/* Domain allocation and freeing by the iommu driver */
165
	struct iommu_domain *(*domain_alloc)(unsigned iommu_domain_type);
166
167
	void (*domain_free)(struct iommu_domain *);

168
169
	int (*attach_dev)(struct iommu_domain *domain, struct device *dev);
	void (*detach_dev)(struct iommu_domain *domain, struct device *dev);
170
	int (*map)(struct iommu_domain *domain, unsigned long iova,
171
172
173
		   phys_addr_t paddr, size_t size, int prot);
	size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
		     size_t size);
174
175
	size_t (*map_sg)(struct iommu_domain *domain, unsigned long iova,
			 struct scatterlist *sg, unsigned int nents, int prot);
176
	phys_addr_t (*iova_to_phys)(struct iommu_domain *domain, dma_addr_t iova);
Alex Williamson's avatar
Alex Williamson committed
177
178
	int (*add_device)(struct device *dev);
	void (*remove_device)(struct device *dev);
179
	struct iommu_group *(*device_group)(struct device *dev);
180
181
182
183
	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);
184

185
186
187
188
	/* Request/Free a list of direct mapping requirements for a device */
	void (*get_dm_regions)(struct device *dev, struct list_head *list);
	void (*put_dm_regions)(struct device *dev, struct list_head *list);

189
190
	/* Window handling functions */
	int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
191
				    phys_addr_t paddr, u64 size, int prot);
192
	void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
193
	/* Set the number of windows per domain */
194
	int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
195
	/* Get the number of windows per domain */
196
	u32 (*domain_get_windows)(struct iommu_domain *domain);
197

198
199
	int (*of_xlate)(struct device *dev, struct of_phandle_args *args);

200
	unsigned long pgsize_bitmap;
201
	void *priv;
202
203
};

Alex Williamson's avatar
Alex Williamson committed
204
205
206
207
208
209
210
#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 */

211
extern int bus_set_iommu(struct bus_type *bus, const struct iommu_ops *ops);
212
extern bool iommu_present(struct bus_type *bus);
213
extern bool iommu_capable(struct bus_type *bus, enum iommu_cap cap);
214
extern struct iommu_domain *iommu_domain_alloc(struct bus_type *bus);
215
extern struct iommu_group *iommu_group_get_by_id(int id);
216
217
218
219
220
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);
221
extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
222
extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
223
224
225
		     phys_addr_t paddr, size_t size, int prot);
extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
		       size_t size);
226
227
228
extern size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
				struct scatterlist *sg,unsigned int nents,
				int prot);
229
extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
230
extern void iommu_set_fault_handler(struct iommu_domain *domain,
231
			iommu_fault_handler_t handler, void *token);
Alex Williamson's avatar
Alex Williamson committed
232

233
234
extern void iommu_get_dm_regions(struct device *dev, struct list_head *list);
extern void iommu_put_dm_regions(struct device *dev, struct list_head *list);
235
extern int iommu_request_dm_for_dev(struct device *dev);
236

Alex Williamson's avatar
Alex Williamson committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
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);
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);
extern int iommu_group_id(struct iommu_group *group);
259
extern struct iommu_group *iommu_group_get_for_dev(struct device *dev);
260
extern struct iommu_domain *iommu_group_default_domain(struct iommu_group *);
261

262
263
264
265
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);
266
267
struct device *iommu_device_create(struct device *parent, void *drvdata,
				   const struct attribute_group **groups,
268
				   const char *fmt, ...) __printf(4, 5);
269
270
271
void iommu_device_destroy(struct device *dev);
int iommu_device_link(struct device *dev, struct device *link);
void iommu_device_unlink(struct device *dev, struct device *link);
272

273
274
/* Window handling function prototypes */
extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
275
276
				      phys_addr_t offset, u64 size,
				      int prot);
277
extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
/**
 * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
 * @domain: the iommu domain where the fault has happened
 * @dev: the device where the fault has happened
 * @iova: the faulting address
 * @flags: mmu fault flags (e.g. IOMMU_FAULT_READ/IOMMU_FAULT_WRITE/...)
 *
 * This function should be called by the low-level IOMMU implementations
 * whenever IOMMU faults happen, to allow high-level users, that are
 * interested in such events, to know about them.
 *
 * This event may be useful for several possible use cases:
 * - mere logging of the event
 * - dynamic TLB/PTE loading
 * - if restarting of the faulting device is required
 *
 * Returns 0 on success and an appropriate error code otherwise (if dynamic
 * PTE/TLB loading will one day be supported, implementations will be able
 * to tell whether it succeeded or not according to this return value).
297
298
299
300
 *
 * Specifically, -ENOSYS is returned if a fault handler isn't installed
 * (though fault handlers can also return -ENOSYS, in case they want to
 * elicit the default behavior of the IOMMU drivers).
301
302
303
304
 */
static inline int report_iommu_fault(struct iommu_domain *domain,
		struct device *dev, unsigned long iova, int flags)
{
305
	int ret = -ENOSYS;
306

307
308
309
310
311
	/*
	 * if upper layers showed interest and installed a fault handler,
	 * invoke it.
	 */
	if (domain->handler)
312
313
		ret = domain->handler(domain, dev, iova, flags,
						domain->handler_token);
314

315
	trace_io_page_fault(dev, iova, flags);
316
	return ret;
317
318
}

319
320
321
322
323
324
325
static inline size_t iommu_map_sg(struct iommu_domain *domain,
				  unsigned long iova, struct scatterlist *sg,
				  unsigned int nents, int prot)
{
	return domain->ops->map_sg(domain, iova, sg, nents, prot);
}

326
327
/* PCI device grouping function */
extern struct iommu_group *pci_device_group(struct device *dev);
328
329
/* Generic device grouping function */
extern struct iommu_group *generic_device_group(struct device *dev);
330

331
332
#else /* CONFIG_IOMMU_API */

333
struct iommu_ops {};
Alex Williamson's avatar
Alex Williamson committed
334
struct iommu_group {};
335

336
static inline bool iommu_present(struct bus_type *bus)
337
338
339
340
{
	return false;
}

341
342
343
344
345
static inline bool iommu_capable(struct bus_type *bus, enum iommu_cap cap)
{
	return false;
}

346
static inline struct iommu_domain *iommu_domain_alloc(struct bus_type *bus)
347
348
349
350
{
	return NULL;
}

351
352
353
354
355
static inline struct iommu_group *iommu_group_get_by_id(int id)
{
	return NULL;
}

356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
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)
{
}

371
372
373
374
375
static inline struct iommu_domain *iommu_get_domain_for_dev(struct device *dev)
{
	return NULL;
}

376
377
378
379
380
381
382
383
384
385
386
387
static inline int iommu_map(struct iommu_domain *domain, unsigned long iova,
			    phys_addr_t paddr, int gfp_order, int prot)
{
	return -ENODEV;
}

static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
			      int gfp_order)
{
	return -ENODEV;
}

388
389
390
391
392
393
394
static inline size_t iommu_map_sg(struct iommu_domain *domain,
				  unsigned long iova, struct scatterlist *sg,
				  unsigned int nents, int prot)
{
	return -ENODEV;
}

395
396
static inline int iommu_domain_window_enable(struct iommu_domain *domain,
					     u32 wnd_nr, phys_addr_t paddr,
397
					     u64 size, int prot)
398
399
400
401
402
403
404
405
406
{
	return -ENODEV;
}

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

407
static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova)
408
409
410
411
{
	return 0;
}

412
static inline void iommu_set_fault_handler(struct iommu_domain *domain,
413
				iommu_fault_handler_t handler, void *token)
414
415
416
{
}

417
418
419
420
421
422
423
424
425
426
static inline void iommu_get_dm_regions(struct device *dev,
					struct list_head *list)
{
}

static inline void iommu_put_dm_regions(struct device *dev,
					struct list_head *list)
{
}

427
428
429
430
431
static inline int iommu_request_dm_for_dev(struct device *dev)
{
	return -ENODEV;
}

432
433
static inline int iommu_attach_group(struct iommu_domain *domain,
				     struct iommu_group *group)
Alex Williamson's avatar
Alex Williamson committed
434
435
436
437
{
	return -ENODEV;
}

438
439
static inline void iommu_detach_group(struct iommu_domain *domain,
				      struct iommu_group *group)
Alex Williamson's avatar
Alex Williamson committed
440
441
442
{
}

443
static inline struct iommu_group *iommu_group_alloc(void)
Alex Williamson's avatar
Alex Williamson committed
444
445
446
447
{
	return ERR_PTR(-ENODEV);
}

448
static inline void *iommu_group_get_iommudata(struct iommu_group *group)
Alex Williamson's avatar
Alex Williamson committed
449
450
451
452
{
	return NULL;
}

453
454
455
static inline void iommu_group_set_iommudata(struct iommu_group *group,
					     void *iommu_data,
					     void (*release)(void *iommu_data))
Alex Williamson's avatar
Alex Williamson committed
456
457
458
{
}

459
460
static inline int iommu_group_set_name(struct iommu_group *group,
				       const char *name)
Alex Williamson's avatar
Alex Williamson committed
461
462
463
464
{
	return -ENODEV;
}

465
466
static inline int iommu_group_add_device(struct iommu_group *group,
					 struct device *dev)
Alex Williamson's avatar
Alex Williamson committed
467
468
469
470
{
	return -ENODEV;
}

471
static inline void iommu_group_remove_device(struct device *dev)
Alex Williamson's avatar
Alex Williamson committed
472
473
474
{
}

475
476
477
static inline int iommu_group_for_each_dev(struct iommu_group *group,
					   void *data,
					   int (*fn)(struct device *, void *))
Alex Williamson's avatar
Alex Williamson committed
478
479
480
481
{
	return -ENODEV;
}

482
static inline struct iommu_group *iommu_group_get(struct device *dev)
Alex Williamson's avatar
Alex Williamson committed
483
484
485
486
{
	return NULL;
}

487
static inline void iommu_group_put(struct iommu_group *group)
Alex Williamson's avatar
Alex Williamson committed
488
489
490
{
}

491
492
static inline int iommu_group_register_notifier(struct iommu_group *group,
						struct notifier_block *nb)
493
494
495
496
{
	return -ENODEV;
}

497
498
static inline int iommu_group_unregister_notifier(struct iommu_group *group,
						  struct notifier_block *nb)
Alex Williamson's avatar
Alex Williamson committed
499
500
501
502
{
	return 0;
}

503
static inline int iommu_group_id(struct iommu_group *group)
Alex Williamson's avatar
Alex Williamson committed
504
505
506
{
	return -ENODEV;
}
507

508
509
510
511
512
513
514
515
516
517
518
519
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;
}

Alex Williamson's avatar
Alex Williamson committed
520
521
522
523
static inline struct device *iommu_device_create(struct device *parent,
					void *drvdata,
					const struct attribute_group **groups,
					const char *fmt, ...)
524
525
526
527
{
	return ERR_PTR(-ENODEV);
}

Alex Williamson's avatar
Alex Williamson committed
528
static inline void iommu_device_destroy(struct device *dev)
529
530
531
{
}

Alex Williamson's avatar
Alex Williamson committed
532
static inline int iommu_device_link(struct device *dev, struct device *link)
533
534
535
536
{
	return -EINVAL;
}

Alex Williamson's avatar
Alex Williamson committed
537
static inline void iommu_device_unlink(struct device *dev, struct device *link)
538
539
540
{
}

541
542
543
#endif /* CONFIG_IOMMU_API */

#endif /* __LINUX_IOMMU_H */