Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-2.6.git] / drivers / net / wireless / b43 / dma.c
index aa986bf..83cba22 100644 (file)
@@ -174,7 +174,7 @@ static void op64_fill_descriptor(struct b43_dmaring *ring,
        addrhi = (((u64) dmaaddr >> 32) & ~SSB_DMA_TRANSLATION_MASK);
        addrext = (((u64) dmaaddr >> 32) & SSB_DMA_TRANSLATION_MASK)
            >> SSB_DMA_TRANSLATION_SHIFT;
-       addrhi |= (ring->dev->dma.translation << 1);
+       addrhi |= ring->dev->dma.translation;
        if (slot == ring->nr_slots - 1)
                ctl0 |= B43_DMA64_DCTL0_DTABLEEND;
        if (start)
@@ -333,10 +333,10 @@ static inline
        dma_addr_t dmaaddr;
 
        if (tx) {
-               dmaaddr = dma_map_single(ring->dev->sdev->dma_dev,
+               dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
                                         buf, len, DMA_TO_DEVICE);
        } else {
-               dmaaddr = dma_map_single(ring->dev->sdev->dma_dev,
+               dmaaddr = dma_map_single(ring->dev->dev->dma_dev,
                                         buf, len, DMA_FROM_DEVICE);
        }
 
@@ -348,10 +348,10 @@ static inline
                          dma_addr_t addr, size_t len, int tx)
 {
        if (tx) {
-               dma_unmap_single(ring->dev->sdev->dma_dev,
+               dma_unmap_single(ring->dev->dev->dma_dev,
                                 addr, len, DMA_TO_DEVICE);
        } else {
-               dma_unmap_single(ring->dev->sdev->dma_dev,
+               dma_unmap_single(ring->dev->dev->dma_dev,
                                 addr, len, DMA_FROM_DEVICE);
        }
 }
@@ -361,7 +361,7 @@ static inline
                                 dma_addr_t addr, size_t len)
 {
        B43_WARN_ON(ring->tx);
-       dma_sync_single_for_cpu(ring->dev->sdev->dma_dev,
+       dma_sync_single_for_cpu(ring->dev->dev->dma_dev,
                                    addr, len, DMA_FROM_DEVICE);
 }
 
@@ -370,7 +370,7 @@ static inline
                                    dma_addr_t addr, size_t len)
 {
        B43_WARN_ON(ring->tx);
-       dma_sync_single_for_device(ring->dev->sdev->dma_dev,
+       dma_sync_single_for_device(ring->dev->dev->dma_dev,
                                   addr, len, DMA_FROM_DEVICE);
 }
 
@@ -401,7 +401,7 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
         */
        if (ring->type == B43_DMA_64BIT)
                flags |= GFP_DMA;
-       ring->descbase = dma_alloc_coherent(ring->dev->sdev->dma_dev,
+       ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,
                                            B43_DMA_RINGMEMSIZE,
                                            &(ring->dmabase), flags);
        if (!ring->descbase) {
@@ -415,7 +415,7 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
 
 static void free_ringmemory(struct b43_dmaring *ring)
 {
-       dma_free_coherent(ring->dev->sdev->dma_dev, B43_DMA_RINGMEMSIZE,
+       dma_free_coherent(ring->dev->dev->dma_dev, B43_DMA_RINGMEMSIZE,
                          ring->descbase, ring->dmabase);
 }
 
@@ -523,7 +523,7 @@ static bool b43_dma_mapping_error(struct b43_dmaring *ring,
                                  dma_addr_t addr,
                                  size_t buffersize, bool dma_to_device)
 {
-       if (unlikely(dma_mapping_error(ring->dev->sdev->dma_dev, addr)))
+       if (unlikely(dma_mapping_error(ring->dev->dev->dma_dev, addr)))
                return 1;
 
        switch (ring->type) {
@@ -659,6 +659,7 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
        u32 value;
        u32 addrext;
        u32 trans = ring->dev->dma.translation;
+       bool parity = ring->dev->dma.parity;
 
        if (ring->tx) {
                if (ring->type == B43_DMA_64BIT) {
@@ -669,13 +670,15 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        value = B43_DMA64_TXENABLE;
                        value |= (addrext << B43_DMA64_TXADDREXT_SHIFT)
                            & B43_DMA64_TXADDREXT_MASK;
+                       if (!parity)
+                               value |= B43_DMA64_TXPARITYDISABLE;
                        b43_dma_write(ring, B43_DMA64_TXCTL, value);
                        b43_dma_write(ring, B43_DMA64_TXRINGLO,
                                      (ringbase & 0xFFFFFFFF));
                        b43_dma_write(ring, B43_DMA64_TXRINGHI,
                                      ((ringbase >> 32) &
                                       ~SSB_DMA_TRANSLATION_MASK)
-                                     | (trans << 1));
+                                     | trans);
                } else {
                        u32 ringbase = (u32) (ring->dmabase);
 
@@ -684,6 +687,8 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        value = B43_DMA32_TXENABLE;
                        value |= (addrext << B43_DMA32_TXADDREXT_SHIFT)
                            & B43_DMA32_TXADDREXT_MASK;
+                       if (!parity)
+                               value |= B43_DMA32_TXPARITYDISABLE;
                        b43_dma_write(ring, B43_DMA32_TXCTL, value);
                        b43_dma_write(ring, B43_DMA32_TXRING,
                                      (ringbase & ~SSB_DMA_TRANSLATION_MASK)
@@ -702,13 +707,15 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        value |= B43_DMA64_RXENABLE;
                        value |= (addrext << B43_DMA64_RXADDREXT_SHIFT)
                            & B43_DMA64_RXADDREXT_MASK;
+                       if (!parity)
+                               value |= B43_DMA64_RXPARITYDISABLE;
                        b43_dma_write(ring, B43_DMA64_RXCTL, value);
                        b43_dma_write(ring, B43_DMA64_RXRINGLO,
                                      (ringbase & 0xFFFFFFFF));
                        b43_dma_write(ring, B43_DMA64_RXRINGHI,
                                      ((ringbase >> 32) &
                                       ~SSB_DMA_TRANSLATION_MASK)
-                                     | (trans << 1));
+                                     | trans);
                        b43_dma_write(ring, B43_DMA64_RXINDEX, ring->nr_slots *
                                      sizeof(struct b43_dmadesc64));
                } else {
@@ -720,6 +727,8 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        value |= B43_DMA32_RXENABLE;
                        value |= (addrext << B43_DMA32_RXADDREXT_SHIFT)
                            & B43_DMA32_RXADDREXT_MASK;
+                       if (!parity)
+                               value |= B43_DMA32_RXPARITYDISABLE;
                        b43_dma_write(ring, B43_DMA32_RXCTL, value);
                        b43_dma_write(ring, B43_DMA32_RXRING,
                                      (ringbase & ~SSB_DMA_TRANSLATION_MASK)
@@ -757,14 +766,14 @@ static void dmacontroller_cleanup(struct b43_dmaring *ring)
 
 static void free_all_descbuffers(struct b43_dmaring *ring)
 {
-       struct b43_dmadesc_generic *desc;
        struct b43_dmadesc_meta *meta;
        int i;
 
        if (!ring->used_slots)
                return;
        for (i = 0; i < ring->nr_slots; i++) {
-               desc = ring->ops->idx2desc(ring, i, &meta);
+               /* get meta - ignore returned value */
+               ring->ops->idx2desc(ring, i, &meta);
 
                if (!meta->skb || b43_dma_ptr_is_poisoned(meta->skb)) {
                        B43_WARN_ON(!ring->tx);
@@ -869,7 +878,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
                        goto err_kfree_meta;
 
                /* test for ability to dma to txhdr_cache */
-               dma_test = dma_map_single(dev->sdev->dma_dev,
+               dma_test = dma_map_single(dev->dev->dma_dev,
                                          ring->txhdr_cache,
                                          b43_txhdr_size(dev),
                                          DMA_TO_DEVICE);
@@ -884,7 +893,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
                        if (!ring->txhdr_cache)
                                goto err_kfree_meta;
 
-                       dma_test = dma_map_single(dev->sdev->dma_dev,
+                       dma_test = dma_map_single(dev->dev->dma_dev,
                                                  ring->txhdr_cache,
                                                  b43_txhdr_size(dev),
                                                  DMA_TO_DEVICE);
@@ -898,7 +907,7 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
                        }
                }
 
-               dma_unmap_single(dev->sdev->dma_dev,
+               dma_unmap_single(dev->dev->dma_dev,
                                 dma_test, b43_txhdr_size(dev),
                                 DMA_TO_DEVICE);
        }
@@ -1013,9 +1022,9 @@ static int b43_dma_set_mask(struct b43_wldev *dev, u64 mask)
        /* Try to set the DMA mask. If it fails, try falling back to a
         * lower mask, as we can always also support a lower one. */
        while (1) {
-               err = dma_set_mask(dev->sdev->dma_dev, mask);
+               err = dma_set_mask(dev->dev->dma_dev, mask);
                if (!err) {
-                       err = dma_set_coherent_mask(dev->sdev->dma_dev, mask);
+                       err = dma_set_coherent_mask(dev->dev->dma_dev, mask);
                        if (!err)
                                break;
                }
@@ -1055,7 +1064,26 @@ int b43_dma_init(struct b43_wldev *dev)
        err = b43_dma_set_mask(dev, dmamask);
        if (err)
                return err;
-       dma->translation = ssb_dma_translation(dev->sdev);
+
+       switch (dev->dev->bus_type) {
+#ifdef CONFIG_B43_BCMA
+       case B43_BUS_BCMA:
+               dma->translation = bcma_core_dma_translation(dev->dev->bdev);
+               break;
+#endif
+#ifdef CONFIG_B43_SSB
+       case B43_BUS_SSB:
+               dma->translation = ssb_dma_translation(dev->dev->sdev);
+               break;
+#endif
+       }
+
+       dma->parity = true;
+#ifdef CONFIG_B43_BCMA
+       /* TODO: find out which SSB devices need disabling parity */
+       if (dev->dev->bus_type == B43_BUS_BCMA)
+               dma->parity = false;
+#endif
 
        err = -ENOMEM;
        /* setup TX DMA channels. */
@@ -1085,7 +1113,7 @@ int b43_dma_init(struct b43_wldev *dev)
                goto err_destroy_mcast;
 
        /* No support for the TX status DMA ring. */
-       B43_WARN_ON(dev->sdev->id.revision < 5);
+       B43_WARN_ON(dev->dev->core_rev < 5);
 
        b43dbg(dev->wl, "%u-bit DMA initialized\n",
               (unsigned int)type);
@@ -1388,7 +1416,6 @@ void b43_dma_handle_txstatus(struct b43_wldev *dev,
 {
        const struct b43_dma_ops *ops;
        struct b43_dmaring *ring;
-       struct b43_dmadesc_generic *desc;
        struct b43_dmadesc_meta *meta;
        int slot, firstused;
        bool frame_succeed;
@@ -1416,7 +1443,8 @@ void b43_dma_handle_txstatus(struct b43_wldev *dev,
        ops = ring->ops;
        while (1) {
                B43_WARN_ON(slot < 0 || slot >= ring->nr_slots);
-               desc = ops->idx2desc(ring, slot, &meta);
+               /* get meta - ignore returned value */
+               ops->idx2desc(ring, slot, &meta);
 
                if (b43_dma_ptr_is_poisoned(meta->skb)) {
                        b43dbg(dev->wl, "Poisoned TX slot %d (first=%d) "
@@ -1600,6 +1628,7 @@ void b43_dma_rx(struct b43_dmaring *ring)
                dma_rx(ring, &slot);
                update_max_used_slots(ring, ++used_slots);
        }
+       wmb();
        ops->set_current_rxslot(ring, slot);
        ring->current_slot = slot;
 }