Update from upstream with manual merge of Yasunori Goto's
[linux-2.6.git] / include / asm-x86_64 / dma-mapping.h
1 #ifndef _X8664_DMA_MAPPING_H
2 #define _X8664_DMA_MAPPING_H 1
3
4 /*
5  * IOMMU interface. See Documentation/DMA-mapping.txt and DMA-API.txt for
6  * documentation.
7  */
8
9 #include <linux/config.h>
10
11 #include <asm/scatterlist.h>
12 #include <asm/io.h>
13 #include <asm/swiotlb.h>
14
15 extern dma_addr_t bad_dma_address;
16 #define dma_mapping_error(x) \
17         (swiotlb ? swiotlb_dma_mapping_error(x) : ((x) == bad_dma_address))
18
19 void *dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
20                          unsigned gfp);
21 void dma_free_coherent(struct device *dev, size_t size, void *vaddr,
22                          dma_addr_t dma_handle);
23
24 #ifdef CONFIG_GART_IOMMU
25
26 extern dma_addr_t dma_map_single(struct device *hwdev, void *ptr, size_t size,
27                                  int direction);
28 extern void dma_unmap_single(struct device *dev, dma_addr_t addr,size_t size,
29                              int direction);
30
31 #else
32
33 /* No IOMMU */
34
35 static inline dma_addr_t dma_map_single(struct device *hwdev, void *ptr,
36                                         size_t size, int direction)
37 {
38         dma_addr_t addr;
39
40         if (direction == DMA_NONE)
41                 out_of_line_bug();
42         addr = virt_to_bus(ptr);
43
44         if ((addr+size) & ~*hwdev->dma_mask)
45                 out_of_line_bug();
46         return addr;
47 }
48
49 static inline void dma_unmap_single(struct device *hwdev, dma_addr_t dma_addr,
50                                     size_t size, int direction)
51 {
52         if (direction == DMA_NONE)
53                 out_of_line_bug();
54         /* Nothing to do */
55 }
56
57 #endif
58
59 #define dma_map_page(dev,page,offset,size,dir) \
60         dma_map_single((dev), page_address(page)+(offset), (size), (dir))
61
62 static inline void dma_sync_single_for_cpu(struct device *hwdev,
63                                                dma_addr_t dma_handle,
64                                                size_t size, int direction)
65 {
66         if (direction == DMA_NONE)
67                 out_of_line_bug();
68
69         if (swiotlb)
70                 return swiotlb_sync_single_for_cpu(hwdev,dma_handle,size,direction);
71
72         flush_write_buffers();
73 }
74
75 static inline void dma_sync_single_for_device(struct device *hwdev,
76                                                   dma_addr_t dma_handle,
77                                                   size_t size, int direction)
78 {
79         if (direction == DMA_NONE)
80                 out_of_line_bug();
81
82         if (swiotlb)
83                 return swiotlb_sync_single_for_device(hwdev,dma_handle,size,direction);
84
85         flush_write_buffers();
86 }
87
88 static inline void dma_sync_single_range_for_cpu(struct device *hwdev,
89                                                  dma_addr_t dma_handle,
90                                                  unsigned long offset,
91                                                  size_t size, int direction)
92 {
93         if (direction == DMA_NONE)
94                 out_of_line_bug();
95
96         if (swiotlb)
97                 return swiotlb_sync_single_range_for_cpu(hwdev,dma_handle,offset,size,direction);
98
99         flush_write_buffers();
100 }
101
102 static inline void dma_sync_single_range_for_device(struct device *hwdev,
103                                                     dma_addr_t dma_handle,
104                                                     unsigned long offset,
105                                                     size_t size, int direction)
106 {
107         if (direction == DMA_NONE)
108                 out_of_line_bug();
109
110         if (swiotlb)
111                 return swiotlb_sync_single_range_for_device(hwdev,dma_handle,offset,size,direction);
112
113         flush_write_buffers();
114 }
115
116 static inline void dma_sync_sg_for_cpu(struct device *hwdev,
117                                        struct scatterlist *sg,
118                                        int nelems, int direction)
119 {
120         if (direction == DMA_NONE)
121                 out_of_line_bug();
122
123         if (swiotlb)
124                 return swiotlb_sync_sg_for_cpu(hwdev,sg,nelems,direction);
125
126         flush_write_buffers();
127 }
128
129 static inline void dma_sync_sg_for_device(struct device *hwdev,
130                                           struct scatterlist *sg,
131                                           int nelems, int direction)
132 {
133         if (direction == DMA_NONE)
134                 out_of_line_bug();
135
136         if (swiotlb)
137                 return swiotlb_sync_sg_for_device(hwdev,sg,nelems,direction);
138
139         flush_write_buffers();
140 }
141
142 extern int dma_map_sg(struct device *hwdev, struct scatterlist *sg,
143                       int nents, int direction);
144 extern void dma_unmap_sg(struct device *hwdev, struct scatterlist *sg,
145                          int nents, int direction);
146
147 #define dma_unmap_page dma_unmap_single
148
149 extern int dma_supported(struct device *hwdev, u64 mask);
150 extern int dma_get_cache_alignment(void);
151 #define dma_is_consistent(h) 1
152
153 static inline int dma_set_mask(struct device *dev, u64 mask)
154 {
155         if (!dev->dma_mask || !dma_supported(dev, mask))
156                 return -EIO;
157         *dev->dma_mask = mask;
158         return 0;
159 }
160
161 static inline void dma_cache_sync(void *vaddr, size_t size, enum dma_data_direction dir)
162 {
163         flush_write_buffers();
164 }
165
166 #endif