Update b43 to work in AP mode

[openwrt/staging/wigyori.git] / package / b43 / patches / 002-ssb-backport.patch

diff --git a/package/b43/patches/002-ssb-backport.patch b/package/b43/patches/002-ssb-backport.patch
new file mode 100644 (file)
index 0000000..b1a7ad2
--- /dev/null
+++ b/package/b43/patches/002-ssb-backport.patch
@@ -0,0 +1,152 @@
+Index: b43/dma.c
+===================================================================
+--- b43.orig/dma.c     2008-07-27 13:56:25.000000000 +0200
++++ b43/dma.c  2008-07-27 14:02:26.000000000 +0200
+@@ -328,11 +328,11 @@ static inline
+       dma_addr_t dmaaddr;
+ 
+       if (tx) {
+-              dmaaddr = ssb_dma_map_single(ring->dev->dev,
+-                                           buf, len, DMA_TO_DEVICE);
++              dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
++                                       buf, len, DMA_TO_DEVICE);
+       } else {
+-              dmaaddr = ssb_dma_map_single(ring->dev->dev,
+-                                           buf, len, DMA_FROM_DEVICE);
++              dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
++                                       buf, len, DMA_FROM_DEVICE);
+       }
+ 
+       return dmaaddr;
+@@ -343,11 +343,11 @@ static inline
+                         dma_addr_t addr, size_t len, int tx)
+ {
+       if (tx) {
+-              ssb_dma_unmap_single(ring->dev->dev,
+-                                   addr, len, DMA_TO_DEVICE);
++              dma_unmap_single(ring->dev->dev->dma_dev,
++                               addr, len, DMA_TO_DEVICE);
+       } else {
+-              ssb_dma_unmap_single(ring->dev->dev,
+-                                   addr, len, DMA_FROM_DEVICE);
++              dma_unmap_single(ring->dev->dev->dma_dev,
++                               addr, len, DMA_FROM_DEVICE);
+       }
+ }
+ 
+@@ -356,8 +356,8 @@ static inline
+                                dma_addr_t addr, size_t len)
+ {
+       B43_WARN_ON(ring->tx);
+-      ssb_dma_sync_single_for_cpu(ring->dev->dev,
+-                                  addr, len, DMA_FROM_DEVICE);
++      dma_sync_single_for_cpu(ring->dev->dev->dma_dev,
++                              addr, len, DMA_FROM_DEVICE);
+ }
+ 
+ static inline
+@@ -365,8 +365,8 @@ static inline
+                                   dma_addr_t addr, size_t len)
+ {
+       B43_WARN_ON(ring->tx);
+-      ssb_dma_sync_single_for_device(ring->dev->dev,
+-                                     addr, len, DMA_FROM_DEVICE);
++      dma_sync_single_for_device(ring->dev->dev->dma_dev,
++                                 addr, len, DMA_FROM_DEVICE);
+ }
+ 
+ static inline
+@@ -381,6 +381,7 @@ static inline
+ 
+ static int alloc_ringmemory(struct b43_dmaring *ring)
+ {
++      struct device *dma_dev = ring->dev->dev->dma_dev;
+       gfp_t flags = GFP_KERNEL;
+ 
+       /* The specs call for 4K buffers for 30- and 32-bit DMA with 4K
+@@ -391,14 +392,11 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
+        * For unknown reasons - possibly a hardware error - the BCM4311 rev
+        * 02, which uses 64-bit DMA, needs the ring buffer in very low memory,
+        * which accounts for the GFP_DMA flag below.
+-       *
+-       * The flags here must match the flags in free_ringmemory below!
+        */
+       if (ring->type == B43_DMA_64BIT)
+               flags |= GFP_DMA;
+-      ring->descbase = ssb_dma_alloc_consistent(ring->dev->dev,
+-                                                B43_DMA_RINGMEMSIZE,
+-                                                &(ring->dmabase), flags);
++      ring->descbase = dma_alloc_coherent(dma_dev, B43_DMA_RINGMEMSIZE,
++                                          &(ring->dmabase), flags);
+       if (!ring->descbase) {
+               b43err(ring->dev->wl, "DMA ringmemory allocation failed\n");
+               return -ENOMEM;
+@@ -410,13 +408,10 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
+ 
+ static void free_ringmemory(struct b43_dmaring *ring)
+ {
+-      gfp_t flags = GFP_KERNEL;
+-
+-      if (ring->type == B43_DMA_64BIT)
+-              flags |= GFP_DMA;
++      struct device *dma_dev = ring->dev->dev->dma_dev;
+ 
+-      ssb_dma_free_consistent(ring->dev->dev, B43_DMA_RINGMEMSIZE,
+-                              ring->descbase, ring->dmabase, flags);
++      dma_free_coherent(dma_dev, B43_DMA_RINGMEMSIZE,
++                        ring->descbase, ring->dmabase);
+ }
+ 
+ /* Reset the RX DMA channel */
+@@ -523,7 +518,7 @@ static bool b43_dma_mapping_error(struct b43_dmaring *ring,
+                                 dma_addr_t addr,
+                                 size_t buffersize, bool dma_to_device)
+ {
+-      if (unlikely(ssb_dma_mapping_error(ring->dev->dev, addr)))
++      if (unlikely(dma_mapping_error(addr)))
+               return 1;
+ 
+       switch (ring->type) {
+@@ -849,10 +844,10 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
+                       goto err_kfree_meta;
+ 
+               /* test for ability to dma to txhdr_cache */
+-              dma_test = ssb_dma_map_single(dev->dev,
+-                                            ring->txhdr_cache,
+-                                            b43_txhdr_size(dev),
+-                                            DMA_TO_DEVICE);
++              dma_test = dma_map_single(dev->dev->dma_dev,
++                                        ring->txhdr_cache,
++                                        b43_txhdr_size(dev),
++                                        DMA_TO_DEVICE);
+ 
+               if (b43_dma_mapping_error(ring, dma_test,
+                                         b43_txhdr_size(dev), 1)) {
+@@ -864,10 +859,10 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
+                       if (!ring->txhdr_cache)
+                               goto err_kfree_meta;
+ 
+-                      dma_test = ssb_dma_map_single(dev->dev,
+-                                                    ring->txhdr_cache,
+-                                                    b43_txhdr_size(dev),
+-                                                    DMA_TO_DEVICE);
++                      dma_test = dma_map_single(dev->dev->dma_dev,
++                                                ring->txhdr_cache,
++                                                b43_txhdr_size(dev),
++                                                DMA_TO_DEVICE);
+ 
+                       if (b43_dma_mapping_error(ring, dma_test,
+                                                 b43_txhdr_size(dev), 1)) {
+@@ -878,9 +873,9 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
+                       }
+               }
+ 
+-              ssb_dma_unmap_single(dev->dev,
+-                                   dma_test, b43_txhdr_size(dev),
+-                                   DMA_TO_DEVICE);
++              dma_unmap_single(dev->dev->dma_dev,
++                               dma_test, b43_txhdr_size(dev),
++                               DMA_TO_DEVICE);
+       }
+ 
+       err = alloc_ringmemory(ring);