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