a57143ae1d91046bdab750653e42068db18b6794
[openwrt/svn-archive/archive.git] / package / mac80211 / patches-old / 002-ssb-backport.patch
1 This patch backports the interface of the b43 and b43legacy driver from
2 the new to the old ssb API. This patch is needed as long the old ssb
3 version is used in the kernel for broadcom devices. After upgrading to
4 ssb version out of kernel 2.6.27 or later this patch is not needed any more.
5
6 diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c
7 index 098f886..8a09a1d 100644
8 --- a/drivers/net/wireless/b43/dma.c
9 +++ b/drivers/net/wireless/b43/dma.c
10 @@ -328,11 +328,11 @@ static inline
11 dma_addr_t dmaaddr;
12
13 if (tx) {
14 - dmaaddr = ssb_dma_map_single(ring->dev->dev,
15 - buf, len, DMA_TO_DEVICE);
16 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
17 + buf, len, DMA_TO_DEVICE);
18 } else {
19 - dmaaddr = ssb_dma_map_single(ring->dev->dev,
20 - buf, len, DMA_FROM_DEVICE);
21 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
22 + buf, len, DMA_FROM_DEVICE);
23 }
24
25 return dmaaddr;
26 @@ -343,11 +343,11 @@ static inline
27 dma_addr_t addr, size_t len, int tx)
28 {
29 if (tx) {
30 - ssb_dma_unmap_single(ring->dev->dev,
31 - addr, len, DMA_TO_DEVICE);
32 + dma_unmap_single(ring->dev->dev->dma_dev,
33 + addr, len, DMA_TO_DEVICE);
34 } else {
35 - ssb_dma_unmap_single(ring->dev->dev,
36 - addr, len, DMA_FROM_DEVICE);
37 + dma_unmap_single(ring->dev->dev->dma_dev,
38 + addr, len, DMA_FROM_DEVICE);
39 }
40 }
41
42 @@ -356,8 +356,8 @@ static inline
43 dma_addr_t addr, size_t len)
44 {
45 B43_WARN_ON(ring->tx);
46 - ssb_dma_sync_single_for_cpu(ring->dev->dev,
47 - addr, len, DMA_FROM_DEVICE);
48 + dma_sync_single_for_cpu(ring->dev->dev->dma_dev,
49 + addr, len, DMA_FROM_DEVICE);
50 }
51
52 static inline
53 @@ -365,8 +365,8 @@ static inline
54 dma_addr_t addr, size_t len)
55 {
56 B43_WARN_ON(ring->tx);
57 - ssb_dma_sync_single_for_device(ring->dev->dev,
58 - addr, len, DMA_FROM_DEVICE);
59 + dma_sync_single_for_device(ring->dev->dev->dma_dev,
60 + addr, len, DMA_FROM_DEVICE);
61 }
62
63 static inline
64 @@ -381,6 +381,7 @@ static inline
65
66 static int alloc_ringmemory(struct b43_dmaring *ring)
67 {
68 + struct device *dma_dev = ring->dev->dev->dma_dev;
69 gfp_t flags = GFP_KERNEL;
70
71 /* The specs call for 4K buffers for 30- and 32-bit DMA with 4K
72 @@ -391,14 +392,11 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
73 * For unknown reasons - possibly a hardware error - the BCM4311 rev
74 * 02, which uses 64-bit DMA, needs the ring buffer in very low memory,
75 * which accounts for the GFP_DMA flag below.
76 - *
77 - * The flags here must match the flags in free_ringmemory below!
78 */
79 if (ring->type == B43_DMA_64BIT)
80 flags |= GFP_DMA;
81 - ring->descbase = ssb_dma_alloc_consistent(ring->dev->dev,
82 - B43_DMA_RINGMEMSIZE,
83 - &(ring->dmabase), flags);
84 + ring->descbase = dma_alloc_coherent(dma_dev, B43_DMA_RINGMEMSIZE,
85 + &(ring->dmabase), flags);
86 if (!ring->descbase) {
87 b43err(ring->dev->wl, "DMA ringmemory allocation failed\n");
88 return -ENOMEM;
89 @@ -410,13 +408,10 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
90
91 static void free_ringmemory(struct b43_dmaring *ring)
92 {
93 - gfp_t flags = GFP_KERNEL;
94 -
95 - if (ring->type == B43_DMA_64BIT)
96 - flags |= GFP_DMA;
97 + struct device *dma_dev = ring->dev->dev->dma_dev;
98
99 - ssb_dma_free_consistent(ring->dev->dev, B43_DMA_RINGMEMSIZE,
100 - ring->descbase, ring->dmabase, flags);
101 + dma_free_coherent(dma_dev, B43_DMA_RINGMEMSIZE,
102 + ring->descbase, ring->dmabase);
103 }
104
105 /* Reset the RX DMA channel */
106 @@ -523,7 +518,7 @@ static bool b43_dma_mapping_error(struct b43_dmaring *ring,
107 dma_addr_t addr,
108 size_t buffersize, bool dma_to_device)
109 {
110 - if (unlikely(ssb_dma_mapping_error(ring->dev->dev, addr)))
111 + if (unlikely(dma_mapping_error(addr)))
112 return 1;
113
114 switch (ring->type) {
115 @@ -849,10 +844,10 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
116 goto err_kfree_meta;
117
118 /* test for ability to dma to txhdr_cache */
119 - dma_test = ssb_dma_map_single(dev->dev,
120 - ring->txhdr_cache,
121 - b43_txhdr_size(dev),
122 - DMA_TO_DEVICE);
123 + dma_test = dma_map_single(dev->dev->dma_dev,
124 + ring->txhdr_cache,
125 + b43_txhdr_size(dev),
126 + DMA_TO_DEVICE);
127
128 if (b43_dma_mapping_error(ring, dma_test,
129 b43_txhdr_size(dev), 1)) {
130 @@ -864,10 +859,10 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
131 if (!ring->txhdr_cache)
132 goto err_kfree_meta;
133
134 - dma_test = ssb_dma_map_single(dev->dev,
135 - ring->txhdr_cache,
136 - b43_txhdr_size(dev),
137 - DMA_TO_DEVICE);
138 + dma_test = dma_map_single(dev->dev->dma_dev,
139 + ring->txhdr_cache,
140 + b43_txhdr_size(dev),
141 + DMA_TO_DEVICE);
142
143 if (b43_dma_mapping_error(ring, dma_test,
144 b43_txhdr_size(dev), 1)) {
145 @@ -878,9 +873,9 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
146 }
147 }
148
149 - ssb_dma_unmap_single(dev->dev,
150 - dma_test, b43_txhdr_size(dev),
151 - DMA_TO_DEVICE);
152 + dma_unmap_single(dev->dev->dma_dev,
153 + dma_test, b43_txhdr_size(dev),
154 + DMA_TO_DEVICE);
155 }
156
157 err = alloc_ringmemory(ring);
158 diff --git a/drivers/net/wireless/b43legacy/dma.c b/drivers/net/wireless/b43legacy/dma.c
159 index fb6819e..87b1049 100644
160 --- a/drivers/net/wireless/b43legacy/dma.c
161 +++ b/drivers/net/wireless/b43legacy/dma.c
162 @@ -393,13 +393,13 @@ dma_addr_t map_descbuffer(struct b43legacy_dmaring *ring,
163 dma_addr_t dmaaddr;
164
165 if (tx)
166 - dmaaddr = ssb_dma_map_single(ring->dev->dev,
167 - buf, len,
168 - DMA_TO_DEVICE);
169 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
170 + buf, len,
171 + DMA_TO_DEVICE);
172 else
173 - dmaaddr = ssb_dma_map_single(ring->dev->dev,
174 - buf, len,
175 - DMA_FROM_DEVICE);
176 + dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
177 + buf, len,
178 + DMA_FROM_DEVICE);
179
180 return dmaaddr;
181 }
182 @@ -411,13 +411,13 @@ void unmap_descbuffer(struct b43legacy_dmaring *ring,
183 int tx)
184 {
185 if (tx)
186 - ssb_dma_unmap_single(ring->dev->dev,
187 - addr, len,
188 - DMA_TO_DEVICE);
189 + dma_unmap_single(ring->dev->dev->dma_dev,
190 + addr, len,
191 + DMA_TO_DEVICE);
192 else
193 - ssb_dma_unmap_single(ring->dev->dev,
194 - addr, len,
195 - DMA_FROM_DEVICE);
196 + dma_unmap_single(ring->dev->dev->dma_dev,
197 + addr, len,
198 + DMA_FROM_DEVICE);
199 }
200
201 static inline
202 @@ -427,8 +427,8 @@ void sync_descbuffer_for_cpu(struct b43legacy_dmaring *ring,
203 {
204 B43legacy_WARN_ON(ring->tx);
205
206 - ssb_dma_sync_single_for_cpu(ring->dev->dev,
207 - addr, len, DMA_FROM_DEVICE);
208 + dma_sync_single_for_cpu(ring->dev->dev->dma_dev,
209 + addr, len, DMA_FROM_DEVICE);
210 }
211
212 static inline
213 @@ -438,8 +438,8 @@ void sync_descbuffer_for_device(struct b43legacy_dmaring *ring,
214 {
215 B43legacy_WARN_ON(ring->tx);
216
217 - ssb_dma_sync_single_for_device(ring->dev->dev,
218 - addr, len, DMA_FROM_DEVICE);
219 + dma_sync_single_for_device(ring->dev->dev->dma_dev,
220 + addr, len, DMA_FROM_DEVICE);
221 }
222
223 static inline
224 @@ -458,11 +458,10 @@ void free_descriptor_buffer(struct b43legacy_dmaring *ring,
225
226 static int alloc_ringmemory(struct b43legacy_dmaring *ring)
227 {
228 - /* GFP flags must match the flags in free_ringmemory()! */
229 - ring->descbase = ssb_dma_alloc_consistent(ring->dev->dev,
230 - B43legacy_DMA_RINGMEMSIZE,
231 - &(ring->dmabase),
232 - GFP_KERNEL);
233 + struct device *dma_dev = ring->dev->dev->dma_dev;
234 +
235 + ring->descbase = dma_alloc_coherent(dma_dev, B43legacy_DMA_RINGMEMSIZE,
236 + &(ring->dmabase), GFP_KERNEL);
237 if (!ring->descbase) {
238 b43legacyerr(ring->dev->wl, "DMA ringmemory allocation"
239 " failed\n");
240 @@ -475,8 +474,10 @@ static int alloc_ringmemory(struct b43legacy_dmaring *ring)
241
242 static void free_ringmemory(struct b43legacy_dmaring *ring)
243 {
244 - ssb_dma_free_consistent(ring->dev->dev, B43legacy_DMA_RINGMEMSIZE,
245 - ring->descbase, ring->dmabase, GFP_KERNEL);
246 + struct device *dma_dev = ring->dev->dev->dma_dev;
247 +
248 + dma_free_coherent(dma_dev, B43legacy_DMA_RINGMEMSIZE,
249 + ring->descbase, ring->dmabase);
250 }
251
252 /* Reset the RX DMA channel */
253 @@ -588,7 +589,7 @@ static bool b43legacy_dma_mapping_error(struct b43legacy_dmaring *ring,
254 size_t buffersize,
255 bool dma_to_device)
256 {
257 - if (unlikely(ssb_dma_mapping_error(ring->dev->dev, addr)))
258 + if (unlikely(dma_mapping_error(addr)))
259 return 1;
260
261 switch (ring->type) {
262 @@ -905,9 +906,9 @@ struct b43legacy_dmaring *b43legacy_setup_dmaring(struct b43legacy_wldev *dev,
263 goto err_kfree_meta;
264
265 /* test for ability to dma to txhdr_cache */
266 - dma_test = ssb_dma_map_single(dev->dev, ring->txhdr_cache,
267 - sizeof(struct b43legacy_txhdr_fw3),
268 - DMA_TO_DEVICE);
269 + dma_test = dma_map_single(dev->dev->dma_dev, ring->txhdr_cache,
270 + sizeof(struct b43legacy_txhdr_fw3),
271 + DMA_TO_DEVICE);
272
273 if (b43legacy_dma_mapping_error(ring, dma_test,
274 sizeof(struct b43legacy_txhdr_fw3), 1)) {
275 @@ -919,7 +920,7 @@ struct b43legacy_dmaring *b43legacy_setup_dmaring(struct b43legacy_wldev *dev,
276 if (!ring->txhdr_cache)
277 goto err_kfree_meta;
278
279 - dma_test = ssb_dma_map_single(dev->dev,
280 + dma_test = dma_map_single(dev->dev->dma_dev,
281 ring->txhdr_cache,
282 sizeof(struct b43legacy_txhdr_fw3),
283 DMA_TO_DEVICE);
284 @@ -929,9 +930,9 @@ struct b43legacy_dmaring *b43legacy_setup_dmaring(struct b43legacy_wldev *dev,
285 goto err_kfree_txhdr_cache;
286 }
287
288 - ssb_dma_unmap_single(dev->dev, dma_test,
289 - sizeof(struct b43legacy_txhdr_fw3),
290 - DMA_TO_DEVICE);
291 + dma_unmap_single(dev->dev->dma_dev,
292 + dma_test, sizeof(struct b43legacy_txhdr_fw3),
293 + DMA_TO_DEVICE);
294 }
295
296 ring->nr_slots = nr_slots;