[PATCH] CRIS update: pci
[linux-2.6.git] / include / asm-cris / dma-mapping.h
1 /* DMA mapping. Nothing tricky here, just virt_to_phys */
2
3 #ifndef _ASM_CRIS_DMA_MAPPING_H
4 #define _ASM_CRIS_DMA_MAPPING_H
5
6 #include <linux/mm.h>
7 #include <linux/kernel.h>
8
9 #include <asm/cache.h>
10 #include <asm/io.h>
11 #include <asm/scatterlist.h>
12
13 #define dma_alloc_noncoherent(d, s, h, f) dma_alloc_coherent(d, s, h, f)
14 #define dma_free_noncoherent(d, s, v, h) dma_free_coherent(d, s, v, h)
15
16 #ifdef CONFIG_PCI
17 void *dma_alloc_coherent(struct device *dev, size_t size,
18                            dma_addr_t *dma_handle, int flag);
19
20 void dma_free_coherent(struct device *dev, size_t size,
21                          void *vaddr, dma_addr_t dma_handle);
22 #else
23 static inline void *
24 dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *dma_handle,
25                    int flag)
26 {
27         BUG();
28         return NULL;
29 }
30
31 static inline void
32 dma_free_coherent(struct device *dev, size_t size, void *cpu_addr,
33                     dma_addr_t dma_handle)
34 {
35         BUG();
36 }
37 #endif
38 static inline dma_addr_t
39 dma_map_single(struct device *dev, void *ptr, size_t size,
40                enum dma_data_direction direction)
41 {
42         BUG_ON(direction == DMA_NONE);
43         return virt_to_phys(ptr);
44 }
45
46 static inline void
47 dma_unmap_single(struct device *dev, dma_addr_t dma_addr, size_t size,
48                  enum dma_data_direction direction)
49 {
50         BUG_ON(direction == DMA_NONE);
51 }
52
53 static inline int
54 dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
55            enum dma_data_direction direction)
56 {
57         printk("Map sg\n");
58         return nents;
59 }
60
61 static inline dma_addr_t
62 dma_map_page(struct device *dev, struct page *page, unsigned long offset,
63              size_t size, enum dma_data_direction direction)
64 {
65         BUG_ON(direction == DMA_NONE);
66         return page_to_phys(page) + offset;
67 }
68
69 static inline void
70 dma_unmap_page(struct device *dev, dma_addr_t dma_address, size_t size,
71                enum dma_data_direction direction)
72 {
73         BUG_ON(direction == DMA_NONE);
74 }
75
76
77 static inline void
78 dma_unmap_sg(struct device *dev, struct scatterlist *sg, int nhwentries,
79              enum dma_data_direction direction)
80 {
81         BUG_ON(direction == DMA_NONE);
82 }
83
84 static inline void
85 dma_sync_single_for_cpu(struct device *dev, dma_addr_t dma_handle, size_t size,
86                         enum dma_data_direction direction)
87 {
88 }
89
90 static inline void
91 dma_sync_single_for_device(struct device *dev, dma_addr_t dma_handle, size_t size,
92                         enum dma_data_direction direction)
93 {
94 }
95
96 static inline void
97 dma_sync_single_range_for_cpu(struct device *dev, dma_addr_t dma_handle,
98                               unsigned long offset, size_t size,
99                               enum dma_data_direction direction)
100 {
101 }
102
103 static inline void
104 dma_sync_single_range_for_device(struct device *dev, dma_addr_t dma_handle,
105                                  unsigned long offset, size_t size,
106                                  enum dma_data_direction direction)
107 {
108 }
109
110 static inline void
111 dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg, int nelems,
112                     enum dma_data_direction direction)
113 {
114 }
115
116 static inline void
117 dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg, int nelems,
118                     enum dma_data_direction direction)
119 {
120 }
121
122 static inline int
123 dma_mapping_error(dma_addr_t dma_addr)
124 {
125         return 0;
126 }
127
128 static inline int
129 dma_supported(struct device *dev, u64 mask)
130 {
131         /*
132          * we fall back to GFP_DMA when the mask isn't all 1s,
133          * so we can't guarantee allocations that must be
134          * within a tighter range than GFP_DMA..
135          */
136         if(mask < 0x00ffffff)
137                 return 0;
138
139         return 1;
140 }
141
142 static inline int
143 dma_set_mask(struct device *dev, u64 mask)
144 {
145         if(!dev->dma_mask || !dma_supported(dev, mask))
146                 return -EIO;
147
148         *dev->dma_mask = mask;
149
150         return 0;
151 }
152
153 static inline int
154 dma_get_cache_alignment(void)
155 {
156         return (1 << L1_CACHE_SHIFT_MAX);
157 }
158
159 #define dma_is_consistent(d)    (1)
160
161 static inline void
162 dma_cache_sync(void *vaddr, size_t size,
163                enum dma_data_direction direction)
164 {
165 }
166
167 #define ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY
168 extern int
169 dma_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr,
170                             dma_addr_t device_addr, size_t size, int flags);
171
172 extern void
173 dma_release_declared_memory(struct device *dev);
174
175 extern void *
176 dma_mark_declared_memory_occupied(struct device *dev,
177                                   dma_addr_t device_addr, size_t size);
178
179 #endif