ssb: Implement SDIO host bus support
Albert Herranz [Tue, 8 Sep 2009 17:30:12 +0000 (19:30 +0200)]
Add support for communicating with a Sonics Silicon Backplane through a
SDIO interface, as found in the Nintendo Wii WLAN daughter card.

The Nintendo Wii WLAN card includes a custom Broadcom 4318 chip with
a SDIO host interface.

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

drivers/ssb/Kconfig
drivers/ssb/Makefile
drivers/ssb/main.c
drivers/ssb/scan.c
drivers/ssb/sdio.c [new file with mode: 0644]
drivers/ssb/ssb_private.h
include/linux/ssb/ssb.h

index 540a294..2d8cc45 100644 (file)
@@ -66,6 +66,20 @@ config SSB_PCMCIAHOST
 
          If unsure, say N
 
+config SSB_SDIOHOST_POSSIBLE
+       bool
+       depends on SSB && (MMC = y || MMC = SSB)
+       default y
+
+config SSB_SDIOHOST
+       bool "Support for SSB on SDIO-bus host"
+       depends on SSB_SDIOHOST_POSSIBLE
+       help
+         Support for a Sonics Silicon Backplane on top
+         of a SDIO device.
+
+         If unsure, say N
+
 config SSB_SILENT
        bool "No SSB kernel messages"
        depends on SSB && EMBEDDED
index cfbb74f..656e58b 100644 (file)
@@ -6,6 +6,7 @@ ssb-$(CONFIG_SSB_SPROM)                 += sprom.o
 # host support
 ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o
 ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o
+ssb-$(CONFIG_SSB_SDIOHOST)             += sdio.o
 
 # built-in drivers
 ssb-y                                  += driver_chipcommon.o
index 8d16cb2..579b114 100644 (file)
@@ -17,6 +17,7 @@
 #include <linux/ssb/ssb_driver_gige.h>
 #include <linux/dma-mapping.h>
 #include <linux/pci.h>
+#include <linux/mmc/sdio_func.h>
 
 #include <pcmcia/cs_types.h>
 #include <pcmcia/cs.h>
@@ -88,6 +89,25 @@ found:
 }
 #endif /* CONFIG_SSB_PCMCIAHOST */
 
+#ifdef CONFIG_SSB_SDIOHOST
+struct ssb_bus *ssb_sdio_func_to_bus(struct sdio_func *func)
+{
+       struct ssb_bus *bus;
+
+       ssb_buses_lock();
+       list_for_each_entry(bus, &buses, list) {
+               if (bus->bustype == SSB_BUSTYPE_SDIO &&
+                   bus->host_sdio == func)
+                       goto found;
+       }
+       bus = NULL;
+found:
+       ssb_buses_unlock();
+
+       return bus;
+}
+#endif /* CONFIG_SSB_SDIOHOST */
+
 int ssb_for_each_bus_call(unsigned long data,
                          int (*func)(struct ssb_bus *bus, unsigned long data))
 {
@@ -469,6 +489,12 @@ static int ssb_devices_register(struct ssb_bus *bus)
                        dev->parent = &bus->host_pcmcia->dev;
 #endif
                        break;
+               case SSB_BUSTYPE_SDIO:
+#ifdef CONFIG_SSB_SDIO
+                       sdev->irq = bus->host_sdio->dev.irq;
+                       dev->parent = &bus->host_sdio->dev;
+#endif
+                       break;
                case SSB_BUSTYPE_SSB:
                        dev->dma_mask = &dev->coherent_dma_mask;
                        break;
@@ -724,12 +750,18 @@ static int ssb_bus_register(struct ssb_bus *bus,
        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1);
        if (err)
                goto out;
+
+       /* Init SDIO-host device (if any), before the scan */
+       err = ssb_sdio_init(bus);
+       if (err)
+               goto err_disable_xtal;
+
        ssb_buses_lock();
        bus->busnumber = next_busnumber;
        /* Scan for devices (cores) */
        err = ssb_bus_scan(bus, baseaddr);
        if (err)
-               goto err_disable_xtal;
+               goto err_sdio_exit;
 
        /* Init PCI-host device (if any) */
        err = ssb_pci_init(bus);
@@ -776,6 +808,8 @@ err_pci_exit:
        ssb_pci_exit(bus);
 err_unmap:
        ssb_iounmap(bus);
+err_sdio_exit:
+       ssb_sdio_exit(bus);
 err_disable_xtal:
        ssb_buses_unlock();
        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0);
@@ -825,6 +859,28 @@ int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
 EXPORT_SYMBOL(ssb_bus_pcmciabus_register);
 #endif /* CONFIG_SSB_PCMCIAHOST */
 
+#ifdef CONFIG_SSB_SDIOHOST
+int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func,
+                            unsigned int quirks)
+{
+       int err;
+
+       bus->bustype = SSB_BUSTYPE_SDIO;
+       bus->host_sdio = func;
+       bus->ops = &ssb_sdio_ops;
+       bus->quirks = quirks;
+
+       err = ssb_bus_register(bus, ssb_sdio_get_invariants, ~0);
+       if (!err) {
+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on "
+                          "SDIO device %s\n", sdio_func_id(func));
+       }
+
+       return err;
+}
+EXPORT_SYMBOL(ssb_bus_sdiobus_register);
+#endif /* CONFIG_SSB_PCMCIAHOST */
+
 int ssb_bus_ssbbus_register(struct ssb_bus *bus,
                            unsigned long baseaddr,
                            ssb_invariants_func_t get_invariants)
index 63ee5cf..b74212d 100644 (file)
@@ -175,6 +175,9 @@ static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx,
                } else
                        ssb_pcmcia_switch_segment(bus, 0);
                break;
+       case SSB_BUSTYPE_SDIO:
+               offset += current_coreidx * SSB_CORE_SIZE;
+               return ssb_sdio_scan_read32(bus, offset);
        }
        return readl(bus->mmio + offset);
 }
@@ -188,6 +191,8 @@ static int scan_switchcore(struct ssb_bus *bus, u8 coreidx)
                return ssb_pci_switch_coreidx(bus, coreidx);
        case SSB_BUSTYPE_PCMCIA:
                return ssb_pcmcia_switch_coreidx(bus, coreidx);
+       case SSB_BUSTYPE_SDIO:
+               return ssb_sdio_scan_switch_coreidx(bus, coreidx);
        }
        return 0;
 }
@@ -206,6 +211,8 @@ void ssb_iounmap(struct ssb_bus *bus)
                SSB_BUG_ON(1); /* Can't reach this code. */
 #endif
                break;
+       case SSB_BUSTYPE_SDIO:
+               break;
        }
        bus->mmio = NULL;
        bus->mapped_device = NULL;
@@ -230,6 +237,10 @@ static void __iomem *ssb_ioremap(struct ssb_bus *bus,
                SSB_BUG_ON(1); /* Can't reach this code. */
 #endif
                break;
+       case SSB_BUSTYPE_SDIO:
+               /* Nothing to ioremap in the SDIO case, just fake it */
+               mmio = (void __iomem *)baseaddr;
+               break;
        }
 
        return mmio;
diff --git a/drivers/ssb/sdio.c b/drivers/ssb/sdio.c
new file mode 100644 (file)
index 0000000..1140510
--- /dev/null
@@ -0,0 +1,610 @@
+/*
+ * Sonics Silicon Backplane
+ * SDIO-Hostbus related functions
+ *
+ * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es>
+ *
+ * Based on drivers/ssb/pcmcia.c
+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
+ * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de>
+ *
+ * Licensed under the GNU/GPL. See COPYING for details.
+ *
+ */
+
+#include <linux/ssb/ssb.h>
+#include <linux/delay.h>
+#include <linux/io.h>
+#include <linux/etherdevice.h>
+#include <linux/mmc/sdio_func.h>
+
+#include "ssb_private.h"
+
+/* Define the following to 1 to enable a printk on each coreswitch. */
+#define SSB_VERBOSE_SDIOCORESWITCH_DEBUG               1
+
+
+/* Hardware invariants CIS tuples */
+#define SSB_SDIO_CIS                   0x80
+#define  SSB_SDIO_CIS_SROMREV          0x00
+#define  SSB_SDIO_CIS_ID               0x01
+#define  SSB_SDIO_CIS_BOARDREV         0x02
+#define  SSB_SDIO_CIS_PA               0x03
+#define   SSB_SDIO_CIS_PA_PA0B0_LO     0
+#define   SSB_SDIO_CIS_PA_PA0B0_HI     1
+#define   SSB_SDIO_CIS_PA_PA0B1_LO     2
+#define   SSB_SDIO_CIS_PA_PA0B1_HI     3
+#define   SSB_SDIO_CIS_PA_PA0B2_LO     4
+#define   SSB_SDIO_CIS_PA_PA0B2_HI     5
+#define   SSB_SDIO_CIS_PA_ITSSI                6
+#define   SSB_SDIO_CIS_PA_MAXPOW       7
+#define  SSB_SDIO_CIS_OEMNAME          0x04
+#define  SSB_SDIO_CIS_CCODE            0x05
+#define  SSB_SDIO_CIS_ANTENNA          0x06
+#define  SSB_SDIO_CIS_ANTGAIN          0x07
+#define  SSB_SDIO_CIS_BFLAGS           0x08
+#define  SSB_SDIO_CIS_LEDS             0x09
+
+#define CISTPL_FUNCE_LAN_NODE_ID        0x04   /* same as in PCMCIA */
+
+
+/*
+ * Function 1 miscellaneous registers.
+ *
+ * Definitions match src/include/sbsdio.h from the
+ * Android Open Source Project
+ * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git
+ *
+ */
+#define SBSDIO_FUNC1_SBADDRLOW 0x1000a /* SB Address window Low (b15) */
+#define SBSDIO_FUNC1_SBADDRMID 0x1000b /* SB Address window Mid (b23-b16) */
+#define SBSDIO_FUNC1_SBADDRHIGH        0x1000c /* SB Address window High (b24-b31) */
+
+/* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */
+#define SBSDIO_SBADDRLOW_MASK  0x80    /* Valid address bits in SBADDRLOW */
+#define SBSDIO_SBADDRMID_MASK  0xff    /* Valid address bits in SBADDRMID */
+#define SBSDIO_SBADDRHIGH_MASK 0xff    /* Valid address bits in SBADDRHIGH */
+
+#define SBSDIO_SB_OFT_ADDR_MASK        0x7FFF  /* sb offset addr is <= 15 bits, 32k */
+
+/* REVISIT: this flag doesn't seem to matter */
+#define SBSDIO_SB_ACCESS_2_4B_FLAG     0x8000  /* forces 32-bit SB access */
+
+
+/*
+ * Address map within the SDIO function address space (128K).
+ *
+ *   Start   End     Description
+ *   ------- ------- ------------------------------------------
+ *   0x00000 0x0ffff selected backplane address window (64K)
+ *   0x10000 0x1ffff backplane control registers (max 64K)
+ *
+ * The current address window is configured by writing to registers
+ * SBADDRLOW, SBADDRMID and SBADDRHIGH.
+ *
+ * In order to access the contents of a 32-bit Silicon Backplane address
+ * the backplane address window must be first loaded with the highest
+ * 16 bits of the target address. Then, an access must be done to the
+ * SDIO function address space using the lower 15 bits of the address.
+ * Bit 15 of the address must be set when doing 32 bit accesses.
+ *
+ * 10987654321098765432109876543210
+ * WWWWWWWWWWWWWWWWW                 SB Address Window
+ *                 OOOOOOOOOOOOOOOO  Offset within SB Address Window
+ *                 a                 32-bit access flag
+ */
+
+
+/*
+ * SSB I/O via SDIO.
+ *
+ * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K).
+ */
+
+static inline struct device *ssb_sdio_dev(struct ssb_bus *bus)
+{
+       return &bus->host_sdio->dev;
+}
+
+/* host claimed */
+static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val)
+{
+       int error = 0;
+
+       sdio_writeb(bus->host_sdio, val, addr, &error);
+       if (unlikely(error)) {
+               dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n",
+                       addr, val, error);
+       }
+
+       return error;
+}
+
+#if 0
+static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr)
+{
+       u8 val;
+       int error = 0;
+
+       val = sdio_readb(bus->host_sdio, addr, &error);
+       if (unlikely(error)) {
+               dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n",
+                       addr, val, error);
+       }
+
+       return val;
+}
+#endif
+
+/* host claimed */
+static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address)
+{
+       int error;
+
+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW,
+                               (address >> 8) & SBSDIO_SBADDRLOW_MASK);
+       if (error)
+               goto out;
+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID,
+                               (address >> 16) & SBSDIO_SBADDRMID_MASK);
+       if (error)
+               goto out;
+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH,
+                               (address >> 24) & SBSDIO_SBADDRHIGH_MASK);
+       if (error)
+               goto out;
+       bus->sdio_sbaddr = address;
+out:
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "failed to set address window"
+                       " to 0x%08x, error %d\n", address, error);
+       }
+
+       return error;
+}
+
+/* for enumeration use only */
+u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset)
+{
+       u32 val;
+       int error;
+
+       sdio_claim_host(bus->host_sdio);
+       val = sdio_readl(bus->host_sdio, offset, &error);
+       sdio_release_host(bus->host_sdio);
+       if (unlikely(error)) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+
+       return val;
+}
+
+/* for enumeration use only */
+int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
+{
+       u32 sbaddr;
+       int error;
+
+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
+       sdio_claim_host(bus->host_sdio);
+       error = ssb_sdio_set_sbaddr_window(bus, sbaddr);
+       sdio_release_host(bus->host_sdio);
+       if (error) {
+               dev_err(ssb_sdio_dev(bus), "failed to switch to core %u,"
+                       " error %d\n", coreidx, error);
+               goto out;
+       }
+out:
+       return error;
+}
+
+/* host must be already claimed */
+int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev)
+{
+       u8 coreidx = dev->core_index;
+       u32 sbaddr;
+       int error = 0;
+
+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE;
+       if (unlikely(bus->sdio_sbaddr != sbaddr)) {
+#if SSB_VERBOSE_SDIOCORESWITCH_DEBUG
+               dev_info(ssb_sdio_dev(bus),
+                          "switching to %s core, index %d\n",
+                          ssb_core_name(dev->id.coreid), coreidx);
+#endif
+               error = ssb_sdio_set_sbaddr_window(bus, sbaddr);
+               if (error) {
+                       dev_dbg(ssb_sdio_dev(bus), "failed to switch to"
+                               " core %u, error %d\n", coreidx, error);
+                       goto out;
+               }
+               bus->mapped_device = dev;
+       }
+
+out:
+       return error;
+}
+
+static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       u8 val = 0xff;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       val = sdio_readb(bus->host_sdio, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+out:
+       sdio_release_host(bus->host_sdio);
+
+       return val;
+}
+
+static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       u16 val = 0xffff;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       val = sdio_readw(bus->host_sdio, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+out:
+       sdio_release_host(bus->host_sdio);
+
+       return val;
+}
+
+static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset)
+{
+       struct ssb_bus *bus = dev->bus;
+       u32 val = 0xffffffff;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
+       val = sdio_readl(bus->host_sdio, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+out:
+       sdio_release_host(bus->host_sdio);
+
+       return val;
+}
+
+#ifdef CONFIG_SSB_BLOCKIO
+static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer,
+                                 size_t count, u16 offset, u8 reg_width)
+{
+       size_t saved_count = count;
+       struct ssb_bus *bus = dev->bus;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev))) {
+               error = -EIO;
+               memset(buffer, 0xff, count);
+               goto err_out;
+       }
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+
+       switch (reg_width) {
+       case sizeof(u8): {
+               error = sdio_readsb(bus->host_sdio, buffer, offset, count);
+               break;
+       }
+       case sizeof(u16): {
+               SSB_WARN_ON(count & 1);
+               error = sdio_readsb(bus->host_sdio, buffer, offset, count);
+               break;
+       }
+       case sizeof(u32): {
+               SSB_WARN_ON(count & 3);
+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
+               error = sdio_readsb(bus->host_sdio, buffer, offset, count);
+               break;
+       }
+       default:
+               SSB_WARN_ON(1);
+       }
+       if (!error)
+               goto out;
+
+err_out:
+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%u), error %d\n",
+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error);
+out:
+       sdio_release_host(bus->host_sdio);
+}
+#endif /* CONFIG_SSB_BLOCKIO */
+
+static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val)
+{
+       struct ssb_bus *bus = dev->bus;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       sdio_writeb(bus->host_sdio, val, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+out:
+       sdio_release_host(bus->host_sdio);
+}
+
+static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val)
+{
+       struct ssb_bus *bus = dev->bus;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       sdio_writew(bus->host_sdio, val, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+out:
+       sdio_release_host(bus->host_sdio);
+}
+
+static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val)
+{
+       struct ssb_bus *bus = dev->bus;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev)))
+               goto out;
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
+       sdio_writel(bus->host_sdio, val, offset, &error);
+       if (error) {
+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n",
+                       bus->sdio_sbaddr >> 16, offset, val, error);
+       }
+       if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32)
+               sdio_readl(bus->host_sdio, 0, &error);
+out:
+       sdio_release_host(bus->host_sdio);
+}
+
+#ifdef CONFIG_SSB_BLOCKIO
+static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer,
+                                  size_t count, u16 offset, u8 reg_width)
+{
+       size_t saved_count = count;
+       struct ssb_bus *bus = dev->bus;
+       int error = 0;
+
+       sdio_claim_host(bus->host_sdio);
+       if (unlikely(ssb_sdio_switch_core(bus, dev))) {
+               error = -EIO;
+               memset((void *)buffer, 0xff, count);
+               goto err_out;
+       }
+       offset |= bus->sdio_sbaddr & 0xffff;
+       offset &= SBSDIO_SB_OFT_ADDR_MASK;
+
+       switch (reg_width) {
+       case sizeof(u8):
+               error = sdio_writesb(bus->host_sdio, offset,
+                                    (void *)buffer, count);
+               break;
+       case sizeof(u16):
+               SSB_WARN_ON(count & 1);
+               error = sdio_writesb(bus->host_sdio, offset,
+                                    (void *)buffer, count);
+               break;
+       case sizeof(u32):
+               SSB_WARN_ON(count & 3);
+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */
+               error = sdio_writesb(bus->host_sdio, offset,
+                                    (void *)buffer, count);
+               break;
+       default:
+               SSB_WARN_ON(1);
+       }
+       if (!error)
+               goto out;
+
+err_out:
+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%u), error %d\n",
+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error);
+out:
+       sdio_release_host(bus->host_sdio);
+}
+
+#endif /* CONFIG_SSB_BLOCKIO */
+
+/* Not "static", as it's used in main.c */
+const struct ssb_bus_ops ssb_sdio_ops = {
+       .read8          = ssb_sdio_read8,
+       .read16         = ssb_sdio_read16,
+       .read32         = ssb_sdio_read32,
+       .write8         = ssb_sdio_write8,
+       .write16        = ssb_sdio_write16,
+       .write32        = ssb_sdio_write32,
+#ifdef CONFIG_SSB_BLOCKIO
+       .block_read     = ssb_sdio_block_read,
+       .block_write    = ssb_sdio_block_write,
+#endif
+};
+
+#define GOTO_ERROR_ON(condition, description) do {     \
+       if (unlikely(condition)) {                      \
+               error_description = description;        \
+               goto error;                             \
+       }                                               \
+  } while (0)
+
+int ssb_sdio_get_invariants(struct ssb_bus *bus,
+                           struct ssb_init_invariants *iv)
+{
+       struct ssb_sprom *sprom = &iv->sprom;
+       struct ssb_boardinfo *bi = &iv->boardinfo;
+       const char *error_description = "none";
+       struct sdio_func_tuple *tuple;
+       void *mac;
+
+       memset(sprom, 0xFF, sizeof(*sprom));
+       sprom->boardflags_lo = 0;
+       sprom->boardflags_hi = 0;
+
+       tuple = bus->host_sdio->tuples;
+       while (tuple) {
+               switch (tuple->code) {
+               case 0x22: /* extended function */
+                       switch (tuple->data[0]) {
+                       case CISTPL_FUNCE_LAN_NODE_ID:
+                               GOTO_ERROR_ON((tuple->size != 7) &&
+                                             (tuple->data[1] != 6),
+                                             "mac tpl size");
+                               /* fetch the MAC address. */
+                               mac = tuple->data + 2;
+                               memcpy(sprom->il0mac, mac, ETH_ALEN);
+                               memcpy(sprom->et1mac, mac, ETH_ALEN);
+                               break;
+                       default:
+                               break;
+                       }
+                       break;
+               case 0x80: /* vendor specific tuple */
+                       switch (tuple->data[0]) {
+                       case SSB_SDIO_CIS_SROMREV:
+                               GOTO_ERROR_ON(tuple->size != 2,
+                                             "sromrev tpl size");
+                               sprom->revision = tuple->data[1];
+                               break;
+                       case SSB_SDIO_CIS_ID:
+                               GOTO_ERROR_ON((tuple->size != 5) &&
+                                             (tuple->size != 7),
+                                             "id tpl size");
+                               bi->vendor = tuple->data[1] |
+                                            (tuple->data[2]<<8);
+                               break;
+                       case SSB_SDIO_CIS_BOARDREV:
+                               GOTO_ERROR_ON(tuple->size != 2,
+                                             "boardrev tpl size");
+                               sprom->board_rev = tuple->data[1];
+                               break;
+                       case SSB_SDIO_CIS_PA:
+                               GOTO_ERROR_ON((tuple->size != 9) &&
+                                             (tuple->size != 10),
+                                             "pa tpl size");
+                               sprom->pa0b0 = tuple->data[1] |
+                                        ((u16)tuple->data[2] << 8);
+                               sprom->pa0b1 = tuple->data[3] |
+                                        ((u16)tuple->data[4] << 8);
+                               sprom->pa0b2 = tuple->data[5] |
+                                        ((u16)tuple->data[6] << 8);
+                               sprom->itssi_a = tuple->data[7];
+                               sprom->itssi_bg = tuple->data[7];
+                               sprom->maxpwr_a = tuple->data[8];
+                               sprom->maxpwr_bg = tuple->data[8];
+                               break;
+                       case SSB_SDIO_CIS_OEMNAME:
+                               /* Not present */
+                               break;
+                       case SSB_SDIO_CIS_CCODE:
+                               GOTO_ERROR_ON(tuple->size != 2,
+                                             "ccode tpl size");
+                               sprom->country_code = tuple->data[1];
+                               break;
+                       case SSB_SDIO_CIS_ANTENNA:
+                               GOTO_ERROR_ON(tuple->size != 2,
+                                             "ant tpl size");
+                               sprom->ant_available_a = tuple->data[1];
+                               sprom->ant_available_bg = tuple->data[1];
+                               break;
+                       case SSB_SDIO_CIS_ANTGAIN:
+                               GOTO_ERROR_ON(tuple->size != 2,
+                                             "antg tpl size");
+                               sprom->antenna_gain.ghz24.a0 = tuple->data[1];
+                               sprom->antenna_gain.ghz24.a1 = tuple->data[1];
+                               sprom->antenna_gain.ghz24.a2 = tuple->data[1];
+                               sprom->antenna_gain.ghz24.a3 = tuple->data[1];
+                               sprom->antenna_gain.ghz5.a0 = tuple->data[1];
+                               sprom->antenna_gain.ghz5.a1 = tuple->data[1];
+                               sprom->antenna_gain.ghz5.a2 = tuple->data[1];
+                               sprom->antenna_gain.ghz5.a3 = tuple->data[1];
+                               break;
+                       case SSB_SDIO_CIS_BFLAGS:
+                               GOTO_ERROR_ON((tuple->size != 3) &&
+                                             (tuple->size != 5),
+                                             "bfl tpl size");
+                               sprom->boardflags_lo = tuple->data[1] |
+                                                ((u16)tuple->data[2] << 8);
+                               break;
+                       case SSB_SDIO_CIS_LEDS:
+                               GOTO_ERROR_ON(tuple->size != 5,
+                                             "leds tpl size");
+                               sprom->gpio0 = tuple->data[1];
+                               sprom->gpio1 = tuple->data[2];
+                               sprom->gpio2 = tuple->data[3];
+                               sprom->gpio3 = tuple->data[4];
+                               break;
+                       default:
+                               break;
+                       }
+                       break;
+               default:
+                       break;
+               }
+               tuple = tuple->next;
+       }
+
+       return 0;
+error:
+       dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n",
+               error_description);
+       return -ENODEV;
+}
+
+void ssb_sdio_exit(struct ssb_bus *bus)
+{
+       if (bus->bustype != SSB_BUSTYPE_SDIO)
+               return;
+       /* Nothing to do here. */
+}
+
+int ssb_sdio_init(struct ssb_bus *bus)
+{
+       if (bus->bustype != SSB_BUSTYPE_SDIO)
+               return 0;
+
+       bus->sdio_sbaddr = ~0;
+
+       return 0;
+}
index 57fa482..2543356 100644 (file)
@@ -114,6 +114,46 @@ static inline int ssb_pcmcia_init(struct ssb_bus *bus)
 }
 #endif /* CONFIG_SSB_PCMCIAHOST */
 
+/* sdio.c */
+#ifdef CONFIG_SSB_SDIOHOST
+extern int ssb_sdio_get_invariants(struct ssb_bus *bus,
+                                    struct ssb_init_invariants *iv);
+
+extern u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset);
+extern int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev);
+extern int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx);
+extern int ssb_sdio_hardware_setup(struct ssb_bus *bus);
+extern void ssb_sdio_exit(struct ssb_bus *bus);
+extern int ssb_sdio_init(struct ssb_bus *bus);
+
+extern const struct ssb_bus_ops ssb_sdio_ops;
+#else /* CONFIG_SSB_SDIOHOST */
+static inline u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset)
+{
+       return 0;
+}
+static inline int ssb_sdio_switch_core(struct ssb_bus *bus,
+                                        struct ssb_device *dev)
+{
+       return 0;
+}
+static inline int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx)
+{
+       return 0;
+}
+static inline int ssb_sdio_hardware_setup(struct ssb_bus *bus)
+{
+       return 0;
+}
+static inline void ssb_sdio_exit(struct ssb_bus *bus)
+{
+}
+static inline int ssb_sdio_init(struct ssb_bus *bus)
+{
+       return 0;
+}
+#endif /* CONFIG_SSB_SDIOHOST */
+
 
 /* scan.c */
 extern const char *ssb_core_name(u16 coreid);
index 17ffc1f..3d0a9ff 100644 (file)
@@ -238,6 +238,7 @@ enum ssb_bustype {
        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */
        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */
        SSB_BUSTYPE_PCMCIA,     /* SSB is connected to PCMCIA bus */
+       SSB_BUSTYPE_SDIO,       /* SSB is connected to SDIO bus */
 };
 
 /* board_vendor */
@@ -270,8 +271,12 @@ struct ssb_bus {
 
        /* The core in the basic address register window. (PCI bus only) */
        struct ssb_device *mapped_device;
-       /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */
-       u8 mapped_pcmcia_seg;
+       union {
+               /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */
+               u8 mapped_pcmcia_seg;
+               /* Current SSB base address window for SDIO. */
+               u32 sdio_sbaddr;
+       };
        /* Lock for core and segment switching.
         * On PCMCIA-host busses this is used to protect the whole MMIO access. */
        spinlock_t bar_lock;
@@ -282,6 +287,11 @@ struct ssb_bus {
        struct pci_dev *host_pci;
        /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */
        struct pcmcia_device *host_pcmcia;
+       /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */
+       struct sdio_func *host_sdio;
+
+       /* See enum ssb_quirks */
+       unsigned int quirks;
 
 #ifdef CONFIG_SSB_SPROM
        /* Mutex to protect the SPROM writing. */
@@ -336,6 +346,11 @@ struct ssb_bus {
 #endif /* DEBUG */
 };
 
+enum ssb_quirks {
+       /* SDIO connected card requires performing a read after writing a 32-bit value */
+       SSB_QUIRK_SDIO_READ_AFTER_WRITE32       = (1 << 0),
+};
+
 /* The initialization-invariants. */
 struct ssb_init_invariants {
        /* Versioning information about the PCB. */
@@ -366,6 +381,12 @@ extern int ssb_bus_pcmciabus_register(struct ssb_bus *bus,
                                      struct pcmcia_device *pcmcia_dev,
                                      unsigned long baseaddr);
 #endif /* CONFIG_SSB_PCMCIAHOST */
+#ifdef CONFIG_SSB_SDIOHOST
+extern int ssb_bus_sdiobus_register(struct ssb_bus *bus,
+                                   struct sdio_func *sdio_func,
+                                   unsigned int quirks);
+#endif /* CONFIG_SSB_SDIOHOST */
+
 
 extern void ssb_bus_unregister(struct ssb_bus *bus);