ssb, b43, b43legacy, b44: Rewrite SSB DMA API

This is a rewrite of the DMA API for SSB devices.
This is needed, because the old (non-existing) "API" made too many bad
assumptions on the API of the host-bus (PCI).
This introduces an almost complete SSB-DMA-API that maps to the lowlevel
bus-API based on the bustype.

Signed-off-by: Michael Buesch <mb@bu3sch.de>
Signed-off-by: John W. Linville <linville@tuxdriver.com>

1 files changed, 59 insertions, 16 deletions

diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
index d184f2aea78d..d831a2beff39 100644
--- a/drivers/ssb/main.c
+++ b/drivers/ssb/main.c
@@ -462,18 +462,15 @@ static int ssb_devices_register(struct ssb_bus *bus)
 #ifdef CONFIG_SSB_PCIHOST
                         sdev->irq = bus->host_pci->irq;
                         dev->parent = &bus->host_pci->dev;
-                        sdev->dma_dev = &bus->host_pci->dev;
 #endif
                         break;
                 case SSB_BUSTYPE_PCMCIA:
 #ifdef CONFIG_SSB_PCMCIAHOST
                         sdev->irq = bus->host_pcmcia->irq.AssignedIRQ;
                         dev->parent = &bus->host_pcmcia->dev;
-                        sdev->dma_dev = &bus->host_pcmcia->dev;
 #endif
                         break;
                 case SSB_BUSTYPE_SSB:
-                        sdev->dma_dev = dev;
                         break;
                 }
 
@@ -1156,36 +1153,82 @@ u32 ssb_dma_translation(struct ssb_device *dev)
 {
         switch (dev->bus->bustype) {
         case SSB_BUSTYPE_SSB:
-        case SSB_BUSTYPE_PCMCIA:
                 return 0;
         case SSB_BUSTYPE_PCI:
                 return SSB_PCI_DMA;
+        default:
+                __ssb_dma_not_implemented(dev);
         }
         return 0;
 }
 EXPORT_SYMBOL(ssb_dma_translation);
 
-int ssb_dma_set_mask(struct ssb_device *ssb_dev, u64 mask)
+int ssb_dma_set_mask(struct ssb_device *dev, u64 mask)
 {
-        struct device *dma_dev = ssb_dev->dma_dev;
-        int err = 0;
+        int err;
 
-#ifdef CONFIG_SSB_PCIHOST
-        if (ssb_dev->bus->bustype == SSB_BUSTYPE_PCI) {
-                err = pci_set_dma_mask(ssb_dev->bus->host_pci, mask);
+        switch (dev->bus->bustype) {
+        case SSB_BUSTYPE_PCI:
+                err = pci_set_dma_mask(dev->bus->host_pci, mask);
                 if (err)
                         return err;
-                err = pci_set_consistent_dma_mask(ssb_dev->bus->host_pci, mask);
+                err = pci_set_consistent_dma_mask(dev->bus->host_pci, mask);
                 return err;
+        case SSB_BUSTYPE_SSB:
+                return dma_set_mask(dev->dev, mask);
+        default:
+                __ssb_dma_not_implemented(dev);
         }
-#endif
-        dma_dev->coherent_dma_mask = mask;
-        dma_dev->dma_mask = &dma_dev->coherent_dma_mask;
-
-        return err;
+        return -ENOSYS;
 }
 EXPORT_SYMBOL(ssb_dma_set_mask);
 
+void * ssb_dma_alloc_consistent(struct ssb_device *dev, size_t size,
+                                dma_addr_t *dma_handle, gfp_t gfp_flags)
+{
+        switch (dev->bus->bustype) {
+        case SSB_BUSTYPE_PCI:
+                if (gfp_flags & GFP_DMA) {
+                        /* Workaround: The PCI API does not support passing
+                         * a GFP flag. */
+                        return dma_alloc_coherent(&dev->bus->host_pci->dev,
+                                                  size, dma_handle, gfp_flags);
+                }
+                return pci_alloc_consistent(dev->bus->host_pci, size, dma_handle);
+        case SSB_BUSTYPE_SSB:
+                return dma_alloc_coherent(dev->dev, size, dma_handle, gfp_flags);
+        default:
+                __ssb_dma_not_implemented(dev);
+        }
+        return NULL;
+}
+EXPORT_SYMBOL(ssb_dma_alloc_consistent);
+
+void ssb_dma_free_consistent(struct ssb_device *dev, size_t size,
+                             void *vaddr, dma_addr_t dma_handle,
+                             gfp_t gfp_flags)
+{
+        switch (dev->bus->bustype) {
+        case SSB_BUSTYPE_PCI:
+                if (gfp_flags & GFP_DMA) {
+                        /* Workaround: The PCI API does not support passing
+                         * a GFP flag. */
+                        dma_free_coherent(&dev->bus->host_pci->dev,
+                                          size, vaddr, dma_handle);
+                        return;
+                }
+                pci_free_consistent(dev->bus->host_pci, size,
+                                    vaddr, dma_handle);
+                return;
+        case SSB_BUSTYPE_SSB:
+                dma_free_coherent(dev->dev, size, vaddr, dma_handle);
+                return;
+        default:
+                __ssb_dma_not_implemented(dev);
+        }
+}
+EXPORT_SYMBOL(ssb_dma_free_consistent);
+
 int ssb_bus_may_powerdown(struct ssb_bus *bus)
 {
         struct ssb_chipcommon *cc;