tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1#ifndef _ASM_IA64_DMA_MAPPING_H
2#define _ASM_IA64_DMA_MAPPING_H
3
4/*
5 * Copyright (C) 2003-2004 Hewlett-Packard Co
6 * David Mosberger-Tang <davidm@hpl.hp.com>
7 */
8#include <asm/machvec.h>
9#include <linux/scatterlist.h>
10#include <asm/swiotlb.h>
11
12#define ARCH_HAS_DMA_GET_REQUIRED_MASK
13
14extern struct dma_map_ops *dma_ops;
15extern struct ia64_machine_vector ia64_mv;
16extern void set_iommu_machvec(void);
17
18extern void machvec_dma_sync_single(struct device *, dma_addr_t, size_t,
19 enum dma_data_direction);
20extern void machvec_dma_sync_sg(struct device *, struct scatterlist *, int,
21 enum dma_data_direction);
22
23static inline void *dma_alloc_coherent(struct device *dev, size_t size,
24 dma_addr_t *daddr, gfp_t gfp)
25{
26 struct dma_map_ops *ops = platform_dma_get_ops(dev);
27 return ops->alloc_coherent(dev, size, daddr, gfp);
28}
29
30static inline void dma_free_coherent(struct device *dev, size_t size,
31 void *caddr, dma_addr_t daddr)
32{
33 struct dma_map_ops *ops = platform_dma_get_ops(dev);
34 ops->free_coherent(dev, size, caddr, daddr);
35}
36
37#define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
38#define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
39
40static inline dma_addr_t dma_map_single_attrs(struct device *dev,
41 void *caddr, size_t size,
42 enum dma_data_direction dir,
43 struct dma_attrs *attrs)
44{
45 struct dma_map_ops *ops = platform_dma_get_ops(dev);
46 return ops->map_page(dev, virt_to_page(caddr),
47 (unsigned long)caddr & ~PAGE_MASK, size,
48 dir, attrs);
49}
50
51static inline void dma_unmap_single_attrs(struct device *dev, dma_addr_t daddr,
52 size_t size,
53 enum dma_data_direction dir,
54 struct dma_attrs *attrs)
55{
56 struct dma_map_ops *ops = platform_dma_get_ops(dev);
57 ops->unmap_page(dev, daddr, size, dir, attrs);
58}
59
60#define dma_map_single(d, a, s, r) dma_map_single_attrs(d, a, s, r, NULL)
61#define dma_unmap_single(d, a, s, r) dma_unmap_single_attrs(d, a, s, r, NULL)
62
63static inline int dma_map_sg_attrs(struct device *dev, struct scatterlist *sgl,
64 int nents, enum dma_data_direction dir,
65 struct dma_attrs *attrs)
66{
67 struct dma_map_ops *ops = platform_dma_get_ops(dev);
68 return ops->map_sg(dev, sgl, nents, dir, attrs);
69}
70
71static inline void dma_unmap_sg_attrs(struct device *dev,
72 struct scatterlist *sgl, int nents,
73 enum dma_data_direction dir,
74 struct dma_attrs *attrs)
75{
76 struct dma_map_ops *ops = platform_dma_get_ops(dev);
77 ops->unmap_sg(dev, sgl, nents, dir, attrs);
78}
79
80#define dma_map_sg(d, s, n, r) dma_map_sg_attrs(d, s, n, r, NULL)
81#define dma_unmap_sg(d, s, n, r) dma_unmap_sg_attrs(d, s, n, r, NULL)
82
83static inline void dma_sync_single_for_cpu(struct device *dev, dma_addr_t daddr,
84 size_t size,
85 enum dma_data_direction dir)
86{
87 struct dma_map_ops *ops = platform_dma_get_ops(dev);
88 ops->sync_single_for_cpu(dev, daddr, size, dir);
89}
90
91static inline void dma_sync_sg_for_cpu(struct device *dev,
92 struct scatterlist *sgl,
93 int nents, enum dma_data_direction dir)
94{
95 struct dma_map_ops *ops = platform_dma_get_ops(dev);
96 ops->sync_sg_for_cpu(dev, sgl, nents, dir);
97}
98
99static inline void dma_sync_single_for_device(struct device *dev,
100 dma_addr_t daddr,
101 size_t size,
102 enum dma_data_direction dir)
103{
104 struct dma_map_ops *ops = platform_dma_get_ops(dev);
105 ops->sync_single_for_device(dev, daddr, size, dir);
106}
107
108static inline void dma_sync_sg_for_device(struct device *dev,
109 struct scatterlist *sgl,
110 int nents,
111 enum dma_data_direction dir)
112{
113 struct dma_map_ops *ops = platform_dma_get_ops(dev);
114 ops->sync_sg_for_device(dev, sgl, nents, dir);
115}
116
117static inline int dma_mapping_error(struct device *dev, dma_addr_t daddr)
118{
119 struct dma_map_ops *ops = platform_dma_get_ops(dev);
120 return ops->mapping_error(dev, daddr);
121}
122
123static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,
124 size_t offset, size_t size,
125 enum dma_data_direction dir)
126{
127 struct dma_map_ops *ops = platform_dma_get_ops(dev);
128 return ops->map_page(dev, page, offset, size, dir, NULL);
129}
130
131static inline void dma_unmap_page(struct device *dev, dma_addr_t addr,
132 size_t size, enum dma_data_direction dir)
133{
134 dma_unmap_single(dev, addr, size, dir);
135}
136
137/*
138 * Rest of this file is part of the "Advanced DMA API". Use at your own risk.
139 * See Documentation/DMA-API.txt for details.
140 */
141
142#define dma_sync_single_range_for_cpu(dev, dma_handle, offset, size, dir) \
143 dma_sync_single_for_cpu(dev, dma_handle, size, dir)
144#define dma_sync_single_range_for_device(dev, dma_handle, offset, size, dir) \
145 dma_sync_single_for_device(dev, dma_handle, size, dir)
146
147static inline int dma_supported(struct device *dev, u64 mask)
148{
149 struct dma_map_ops *ops = platform_dma_get_ops(dev);
150 return ops->dma_supported(dev, mask);
151}
152
153static inline int
154dma_set_mask (struct device *dev, u64 mask)
155{
156 if (!dev->dma_mask || !dma_supported(dev, mask))
157 return -EIO;
158 *dev->dma_mask = mask;
159 return 0;
160}
161
162extern int dma_get_cache_alignment(void);
163
164static inline void
165dma_cache_sync (struct device *dev, void *vaddr, size_t size,
166 enum dma_data_direction dir)
167{
168 /*
169 * IA-64 is cache-coherent, so this is mostly a no-op. However, we do need to
170 * ensure that dma_cache_sync() enforces order, hence the mb().
171 */
172 mb();
173}
174
175#define dma_is_consistent(d, h) (1) /* all we do is coherent memory... */
176
177#endif /* _ASM_IA64_DMA_MAPPING_H */