Merge remote-tracking branch 'wireless/master'

[karo-tx-linux.git] / drivers / net / wireless / b43 / dma.c

diff --git a/drivers/net/wireless/b43/dma.c b/drivers/net/wireless/b43/dma.c
index 481e534534eb3a437a732509c80bba6db73ff2e1..c5d890e74a1e426e80bc8379afa3b49a4617cb8c 100644 (file)
--- a/drivers/net/wireless/b43/dma.c
+++ b/drivers/net/wireless/b43/dma.c
@@ -47,6 +47,38 @@
  * into separate slots. */
 #define TX_SLOTS_PER_FRAME     2
 
+static u32 b43_dma_address(struct b43_dma *dma, dma_addr_t dmaaddr,
+                          enum b43_addrtype addrtype)
+{
+       u32 uninitialized_var(addr);
+
+       switch (addrtype) {
+       case B43_DMA_ADDR_LOW:
+               addr = lower_32_bits(dmaaddr);
+               if (dma->translation_in_low) {
+                       addr &= ~SSB_DMA_TRANSLATION_MASK;
+                       addr |= dma->translation;
+               }
+               break;
+       case B43_DMA_ADDR_HIGH:
+               addr = upper_32_bits(dmaaddr);
+               if (!dma->translation_in_low) {
+                       addr &= ~SSB_DMA_TRANSLATION_MASK;
+                       addr |= dma->translation;
+               }
+               break;
+       case B43_DMA_ADDR_EXT:
+               if (dma->translation_in_low)
+                       addr = lower_32_bits(dmaaddr);
+               else
+                       addr = upper_32_bits(dmaaddr);
+               addr &= SSB_DMA_TRANSLATION_MASK;
+               addr >>= SSB_DMA_TRANSLATION_SHIFT;
+               break;
+       }
+
+       return addr;
+}
 
 /* 32bit DMA ops. */
 static
@@ -77,10 +109,9 @@ static void op32_fill_descriptor(struct b43_dmaring *ring,
        slot = (int)(&(desc->dma32) - descbase);
        B43_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
 
-       addr = (u32) (dmaaddr & ~SSB_DMA_TRANSLATION_MASK);
-       addrext = (u32) (dmaaddr & SSB_DMA_TRANSLATION_MASK)
-           >> SSB_DMA_TRANSLATION_SHIFT;
-       addr |= ring->dev->dma.translation;
+       addr = b43_dma_address(&ring->dev->dma, dmaaddr, B43_DMA_ADDR_LOW);
+       addrext = b43_dma_address(&ring->dev->dma, dmaaddr, B43_DMA_ADDR_EXT);
+
        ctl = bufsize & B43_DMA32_DCTL_BYTECNT;
        if (slot == ring->nr_slots - 1)
                ctl |= B43_DMA32_DCTL_DTABLEEND;
@@ -170,11 +201,10 @@ static void op64_fill_descriptor(struct b43_dmaring *ring,
        slot = (int)(&(desc->dma64) - descbase);
        B43_WARN_ON(!(slot >= 0 && slot < ring->nr_slots));
 
-       addrlo = (u32) (dmaaddr & 0xFFFFFFFF);
-       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;
+       addrlo = b43_dma_address(&ring->dev->dma, dmaaddr, B43_DMA_ADDR_LOW);
+       addrhi = b43_dma_address(&ring->dev->dma, dmaaddr, B43_DMA_ADDR_HIGH);
+       addrext = b43_dma_address(&ring->dev->dma, dmaaddr, B43_DMA_ADDR_EXT);
+
        if (slot == ring->nr_slots - 1)
                ctl0 |= B43_DMA64_DCTL0_DTABLEEND;
        if (start)
@@ -658,41 +688,37 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
        int err = 0;
        u32 value;
        u32 addrext;
-       u32 trans = ring->dev->dma.translation;
        bool parity = ring->dev->dma.parity;
+       u32 addrlo;
+       u32 addrhi;
 
        if (ring->tx) {
                if (ring->type == B43_DMA_64BIT) {
                        u64 ringbase = (u64) (ring->dmabase);
+                       addrext = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_EXT);
+                       addrlo = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_LOW);
+                       addrhi = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_HIGH);
 
-                       addrext = ((ringbase >> 32) & SSB_DMA_TRANSLATION_MASK)
-                           >> SSB_DMA_TRANSLATION_SHIFT;
                        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);
+                       b43_dma_write(ring, B43_DMA64_TXRINGLO, addrlo);
+                       b43_dma_write(ring, B43_DMA64_TXRINGHI, addrhi);
                } else {
                        u32 ringbase = (u32) (ring->dmabase);
+                       addrext = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_EXT);
+                       addrlo = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_LOW);
 
-                       addrext = (ringbase & SSB_DMA_TRANSLATION_MASK)
-                           >> SSB_DMA_TRANSLATION_SHIFT;
                        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)
-                                     | trans);
+                       b43_dma_write(ring, B43_DMA32_TXRING, addrlo);
                }
        } else {
                err = alloc_initial_descbuffers(ring);
@@ -700,9 +726,10 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        goto out;
                if (ring->type == B43_DMA_64BIT) {
                        u64 ringbase = (u64) (ring->dmabase);
+                       addrext = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_EXT);
+                       addrlo = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_LOW);
+                       addrhi = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_HIGH);
 
-                       addrext = ((ringbase >> 32) & SSB_DMA_TRANSLATION_MASK)
-                           >> SSB_DMA_TRANSLATION_SHIFT;
                        value = (ring->frameoffset << B43_DMA64_RXFROFF_SHIFT);
                        value |= B43_DMA64_RXENABLE;
                        value |= (addrext << B43_DMA64_RXADDREXT_SHIFT)
@@ -710,19 +737,15 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        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);
+                       b43_dma_write(ring, B43_DMA64_RXRINGLO, addrlo);
+                       b43_dma_write(ring, B43_DMA64_RXRINGHI, addrhi);
                        b43_dma_write(ring, B43_DMA64_RXINDEX, ring->nr_slots *
                                      sizeof(struct b43_dmadesc64));
                } else {
                        u32 ringbase = (u32) (ring->dmabase);
+                       addrext = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_EXT);
+                       addrlo = b43_dma_address(&ring->dev->dma, ringbase, B43_DMA_ADDR_LOW);
 
-                       addrext = (ringbase & SSB_DMA_TRANSLATION_MASK)
-                           >> SSB_DMA_TRANSLATION_SHIFT;
                        value = (ring->frameoffset << B43_DMA32_RXFROFF_SHIFT);
                        value |= B43_DMA32_RXENABLE;
                        value |= (addrext << B43_DMA32_RXADDREXT_SHIFT)
@@ -730,9 +753,7 @@ static int dmacontroller_setup(struct b43_dmaring *ring)
                        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)
-                                     | trans);
+                       b43_dma_write(ring, B43_DMA32_RXRING, addrlo);
                        b43_dma_write(ring, B43_DMA32_RXINDEX, ring->nr_slots *
                                      sizeof(struct b43_dmadesc32));
                }
@@ -872,8 +893,17 @@ struct b43_dmaring *b43_setup_dmaring(struct b43_wldev *dev,
                ring->current_slot = -1;
        } else {
                if (ring->index == 0) {
-                       ring->rx_buffersize = B43_DMA0_RX_BUFFERSIZE;
-                       ring->frameoffset = B43_DMA0_RX_FRAMEOFFSET;
+                       switch (dev->fw.hdr_format) {
+                       case B43_FW_HDR_598:
+                               ring->rx_buffersize = B43_DMA0_RX_FW598_BUFSIZE;
+                               ring->frameoffset = B43_DMA0_RX_FW598_FO;
+                               break;
+                       case B43_FW_HDR_410:
+                       case B43_FW_HDR_351:
+                               ring->rx_buffersize = B43_DMA0_RX_FW351_BUFSIZE;
+                               ring->frameoffset = B43_DMA0_RX_FW351_FO;
+                               break;
+                       }
                } else
                        B43_WARN_ON(1);
        }
@@ -1066,6 +1096,25 @@ static int b43_dma_set_mask(struct b43_wldev *dev, u64 mask)
        return 0;
 }
 
+/* Some hardware with 64-bit DMA seems to be bugged and looks for translation
+ * bit in low address word instead of high one.
+ */
+static bool b43_dma_translation_in_low_word(struct b43_wldev *dev,
+                                           enum b43_dmatype type)
+{
+       if (type != B43_DMA_64BIT)
+               return 1;
+
+#ifdef CONFIG_B43_SSB
+       if (dev->dev->bus_type == B43_BUS_SSB &&
+           dev->dev->sdev->bus->bustype == SSB_BUSTYPE_PCI &&
+           !(dev->dev->sdev->bus->host_pci->is_pcie &&
+             ssb_read32(dev->dev->sdev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64))
+                       return 1;
+#endif
+       return 0;
+}
+
 int b43_dma_init(struct b43_wldev *dev)
 {
        struct b43_dma *dma = &dev->dma;
@@ -1091,6 +1140,7 @@ int b43_dma_init(struct b43_wldev *dev)
                break;
 #endif
        }
+       dma->translation_in_low = b43_dma_translation_in_low_word(dev, type);
 
        dma->parity = true;
 #ifdef CONFIG_B43_BCMA