Changeset 26127


Ignore:
Timestamp:
2011-03-13T18:24:28+01:00 (7 years ago)
Author:
hauke
Message:

ssb: update ssb to version from linux-next-20110311

Location:
trunk/target/linux
Files:
3 added
7 deleted
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/brcm47xx/patches-2.6.34/220-bcm5354.patch

    r22296 r26127  
    3232--- a/drivers/ssb/main.c 
    3333+++ b/drivers/ssb/main.c 
    34 @@ -1075,6 +1075,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
     34@@ -1105,6 +1105,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
    3535  
    3636        if (bus->chip_id == 0x5365) { 
  • trunk/target/linux/brcm47xx/patches-2.6.34/951-brcm4716-defines.patch

    r21269 r26127  
    2626--- a/include/linux/ssb/ssb.h 
    2727+++ b/include/linux/ssb/ssb.h 
    28 @@ -151,9 +151,16 @@ struct ssb_bus_ops { 
     28@@ -155,9 +155,16 @@ struct ssb_bus_ops { 
    2929 #define SSB_DEV_MINI_MACPHY    0x823 
    3030 #define SSB_DEV_ARM_1176       0x824 
     
    6161 /* Enumeration space constants */ 
    6262 #define SSB_CORE_SIZE          0x1000  /* Size of a core MMIO area */ 
    63 @@ -453,5 +455,41 @@ enum { 
     63@@ -499,5 +501,41 @@ enum { 
    6464 #define SSB_ADM_BASE2                  0xFFFF0000      /* Type2 base address for the core */ 
    6565 #define SSB_ADM_BASE2_SHIFT            16 
  • trunk/target/linux/brcm47xx/patches-2.6.34/977-ssb_export_fallback_sprom.patch

    r26125 r26127  
    1111--- a/include/linux/ssb/ssb.h 
    1212+++ b/include/linux/ssb/ssb.h 
    13 @@ -408,6 +408,7 @@ extern bool ssb_is_sprom_available(struc 
     13@@ -412,6 +412,7 @@ extern bool ssb_is_sprom_available(struc 
    1414 /* Set a fallback SPROM. 
    1515  * See kdoc at the function definition for complete documentation. */ 
  • trunk/target/linux/brcm47xx/patches-2.6.36/220-bcm5354.patch

    r23278 r26127  
    3232--- a/drivers/ssb/main.c 
    3333+++ b/drivers/ssb/main.c 
    34 @@ -1074,6 +1074,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
     34@@ -1104,6 +1104,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
    3535  
    3636        if (bus->chip_id == 0x5365) { 
  • trunk/target/linux/brcm47xx/patches-2.6.36/951-brcm4716-defines.patch

    r23278 r26127  
    2626--- a/include/linux/ssb/ssb.h 
    2727+++ b/include/linux/ssb/ssb.h 
    28 @@ -151,9 +151,16 @@ struct ssb_bus_ops { 
     28@@ -155,9 +155,16 @@ struct ssb_bus_ops { 
    2929 #define SSB_DEV_MINI_MACPHY    0x823 
    3030 #define SSB_DEV_ARM_1176       0x824 
     
    6161 /* Enumeration space constants */ 
    6262 #define SSB_CORE_SIZE          0x1000  /* Size of a core MMIO area */ 
    63 @@ -453,5 +455,41 @@ enum { 
     63@@ -499,5 +501,41 @@ enum { 
    6464 #define SSB_ADM_BASE2                  0xFFFF0000      /* Type2 base address for the core */ 
    6565 #define SSB_ADM_BASE2_SHIFT            16 
  • trunk/target/linux/brcm47xx/patches-2.6.36/977-ssb_export_fallback_sprom.patch

    r25085 r26127  
    1111--- a/include/linux/ssb/ssb.h 
    1212+++ b/include/linux/ssb/ssb.h 
    13 @@ -401,6 +401,7 @@ extern bool ssb_is_sprom_available(struc 
     13@@ -412,6 +412,7 @@ extern bool ssb_is_sprom_available(struc 
    1414 /* Set a fallback SPROM. 
    1515  * See kdoc at the function definition for complete documentation. */ 
  • trunk/target/linux/brcm47xx/patches-2.6.37/220-bcm5354.patch

    r23945 r26127  
    3232--- a/drivers/ssb/main.c 
    3333+++ b/drivers/ssb/main.c 
    34 @@ -1073,6 +1073,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
     34@@ -1103,6 +1103,8 @@ u32 ssb_clockspeed(struct ssb_bus *bus) 
    3535  
    3636        if (bus->chip_id == 0x5365) { 
  • trunk/target/linux/brcm47xx/patches-2.6.37/951-brcm4716-defines.patch

    r23945 r26127  
    2626--- a/include/linux/ssb/ssb.h 
    2727+++ b/include/linux/ssb/ssb.h 
    28 @@ -151,9 +151,16 @@ struct ssb_bus_ops { 
     28@@ -155,9 +155,16 @@ struct ssb_bus_ops { 
    2929 #define SSB_DEV_MINI_MACPHY    0x823 
    3030 #define SSB_DEV_ARM_1176       0x824 
     
    6161 /* Enumeration space constants */ 
    6262 #define SSB_CORE_SIZE          0x1000  /* Size of a core MMIO area */ 
    63 @@ -454,5 +456,41 @@ enum { 
     63@@ -499,5 +501,41 @@ enum { 
    6464 #define SSB_ADM_BASE2                  0xFFFF0000      /* Type2 base address for the core */ 
    6565 #define SSB_ADM_BASE2_SHIFT            16 
  • trunk/target/linux/brcm47xx/patches-2.6.37/977-ssb_export_fallback_sprom.patch

    r26126 r26127  
    1111--- a/include/linux/ssb/ssb.h 
    1212+++ b/include/linux/ssb/ssb.h 
    13 @@ -408,6 +408,7 @@ extern bool ssb_is_sprom_available(struc 
     13@@ -412,6 +412,7 @@ extern bool ssb_is_sprom_available(struc 
    1414 /* Set a fallback SPROM. 
    1515  * See kdoc at the function definition for complete documentation. */ 
  • trunk/target/linux/generic/patches-2.6.30/941-ssb_update.patch

    r21952 r26127  
     1--- a/drivers/ssb/Kconfig 
     2+++ b/drivers/ssb/Kconfig 
     3@@ -66,6 +66,20 @@ config SSB_PCMCIAHOST 
     4  
     5          If unsure, say N 
     6  
     7+config SSB_SDIOHOST_POSSIBLE 
     8+       bool 
     9+       depends on SSB && (MMC = y || MMC = SSB) 
     10+       default y 
     11+ 
     12+config SSB_SDIOHOST 
     13+       bool "Support for SSB on SDIO-bus host" 
     14+       depends on SSB_SDIOHOST_POSSIBLE 
     15+       help 
     16+         Support for a Sonics Silicon Backplane on top 
     17+         of a SDIO device. 
     18+ 
     19+         If unsure, say N 
     20+ 
     21 config SSB_SILENT 
     22        bool "No SSB kernel messages" 
     23        depends on SSB && EMBEDDED 
     24--- a/drivers/ssb/Makefile 
     25+++ b/drivers/ssb/Makefile 
     26@@ -6,6 +6,7 @@ ssb-$(CONFIG_SSB_SPROM)                 += sprom.o 
     27 # host support 
     28 ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o 
     29 ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o 
     30+ssb-$(CONFIG_SSB_SDIOHOST)             += sdio.o 
     31  
     32 # built-in drivers 
     33 ssb-y                                  += driver_chipcommon.o 
     34--- a/drivers/ssb/b43_pci_bridge.c 
     35+++ b/drivers/ssb/b43_pci_bridge.c 
     36@@ -24,6 +24,7 @@ static const struct pci_device_id b43_pc 
     37        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) }, 
     38        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4315) }, 
     39        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) }, 
     40+       { PCI_DEVICE(PCI_VENDOR_ID_BCM_GVC,  0x4318) }, 
     41        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) }, 
     42        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) }, 
     43        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) }, 
     44--- a/drivers/ssb/driver_chipcommon.c 
     45+++ b/drivers/ssb/driver_chipcommon.c 
     46@@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     47        } 
     48 } 
     49  
     50+/* http://bcm-v4.sipsolutions.net/802.11/PmuFastPwrupDelay */ 
     51+static u16 pmu_fast_powerup_delay(struct ssb_chipcommon *cc) 
     52+{ 
     53+       struct ssb_bus *bus = cc->dev->bus; 
     54+ 
     55+       switch (bus->chip_id) { 
     56+       case 0x4312: 
     57+       case 0x4322: 
     58+       case 0x4328: 
     59+               return 7000; 
     60+       case 0x4325: 
     61+               /* TODO: */ 
     62+       default: 
     63+               return 15000; 
     64+       } 
     65+} 
     66+ 
     67+/* http://bcm-v4.sipsolutions.net/802.11/ClkctlFastPwrupDelay */ 
     68 static void calc_fast_powerup_delay(struct ssb_chipcommon *cc) 
     69 { 
     70        struct ssb_bus *bus = cc->dev->bus; 
     71@@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     72  
     73        if (bus->bustype != SSB_BUSTYPE_PCI) 
     74                return; 
     75+ 
     76+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) { 
     77+               cc->fast_pwrup_delay = pmu_fast_powerup_delay(cc); 
     78+               return; 
     79+       } 
     80+ 
     81        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     82                return; 
     83  
     84@@ -233,6 +257,9 @@ void ssb_chipcommon_init(struct ssb_chip 
     85 { 
     86        if (!cc->dev) 
     87                return; /* We don't have a ChipCommon */ 
     88+       if (cc->dev->id.revision >= 11) 
     89+               cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
     90+       ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     91        ssb_pmu_init(cc); 
     92        chipco_powercontrol_init(cc); 
     93        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
     94@@ -370,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     95 { 
     96        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     97 } 
     98+EXPORT_SYMBOL(ssb_chipco_gpio_control); 
     99  
     100 u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     101 { 
    1102--- a/drivers/ssb/driver_chipcommon_pmu.c 
    2103+++ b/drivers/ssb/driver_chipcommon_pmu.c 
    3 @@ -28,6 +28,21 @@ static void ssb_chipco_pll_write(struct  
     104@@ -28,6 +28,21 @@ static void ssb_chipco_pll_write(struct 
    4105        chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, value); 
    5106 } 
     
    44145                 * min_msk = 0xCBB 
    45146                 * max_msk = 0x7FFFF 
    46 @@ -506,3 +528,82 @@ void ssb_pmu_init(struct ssb_chipcommon  
     147@@ -480,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     148                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
     149 } 
     150  
     151+/* http://bcm-v4.sipsolutions.net/802.11/SSB/PmuInit */ 
     152 void ssb_pmu_init(struct ssb_chipcommon *cc) 
     153 { 
     154-       struct ssb_bus *bus = cc->dev->bus; 
     155        u32 pmucap; 
     156  
     157        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
     158@@ -494,15 +516,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
     159        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
     160                    cc->pmu.rev, pmucap); 
     161  
     162-       if (cc->pmu.rev >= 1) { 
     163-               if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) { 
     164-                       chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     165-                                     ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     166-               } else { 
     167-                       chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     168-                                    SSB_CHIPCO_PMU_CTL_NOILPONW); 
     169-               } 
     170-       } 
     171+       if (cc->pmu.rev == 1) 
     172+               chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     173+                             ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     174+       else 
     175+               chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     176+                            SSB_CHIPCO_PMU_CTL_NOILPONW); 
    47177        ssb_pmu_pll_init(cc); 
    48178        ssb_pmu_resources_init(cc); 
     
    127257+EXPORT_SYMBOL(ssb_pmu_set_ldo_voltage); 
    128258+EXPORT_SYMBOL(ssb_pmu_set_ldo_paref); 
     259--- a/drivers/ssb/driver_gige.c 
     260+++ b/drivers/ssb/driver_gige.c 
     261@@ -12,6 +12,7 @@ 
     262 #include <linux/ssb/ssb_driver_gige.h> 
     263 #include <linux/pci.h> 
     264 #include <linux/pci_regs.h> 
     265+#include <linux/slab.h> 
     266  
     267  
     268 /* 
     269--- a/drivers/ssb/driver_mipscore.c 
     270+++ b/drivers/ssb/driver_mipscore.c 
     271@@ -49,29 +49,54 @@ static const u32 ipsflag_irq_shift[] = { 
     272  
     273 static inline u32 ssb_irqflag(struct ssb_device *dev) 
     274 { 
     275-       return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
     276+       u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG); 
     277+       if (tpsflag) 
     278+               return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
     279+       else 
     280+               /* not irq supported */ 
     281+               return 0x3f; 
     282+} 
     283+ 
     284+static struct ssb_device *find_device(struct ssb_device *rdev, int irqflag) 
     285+{ 
     286+       struct ssb_bus *bus = rdev->bus; 
     287+       int i; 
     288+       for (i = 0; i < bus->nr_devices; i++) { 
     289+               struct ssb_device *dev; 
     290+               dev = &(bus->devices[i]); 
     291+               if (ssb_irqflag(dev) == irqflag) 
     292+                       return dev; 
     293+       } 
     294+       return NULL; 
     295 } 
     296  
     297 /* Get the MIPS IRQ assignment for a specified device. 
     298  * If unassigned, 0 is returned. 
     299+ * If disabled, 5 is returned. 
     300+ * If not supported, 6 is returned. 
     301  */ 
     302 unsigned int ssb_mips_irq(struct ssb_device *dev) 
     303 { 
     304        struct ssb_bus *bus = dev->bus; 
     305+       struct ssb_device *mdev = bus->mipscore.dev; 
     306        u32 irqflag; 
     307        u32 ipsflag; 
     308        u32 tmp; 
     309        unsigned int irq; 
     310  
     311        irqflag = ssb_irqflag(dev); 
     312+       if (irqflag == 0x3f) 
     313+               return 6; 
     314        ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG); 
     315        for (irq = 1; irq <= 4; irq++) { 
     316                tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]); 
     317                if (tmp == irqflag) 
     318                        break; 
     319        } 
     320-       if (irq == 5) 
     321-               irq = 0; 
     322+       if (irq == 5) { 
     323+               if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)) 
     324+                       irq = 0; 
     325+       } 
     326  
     327        return irq; 
     328 } 
     329@@ -97,25 +122,56 @@ static void set_irq(struct ssb_device *d 
     330        struct ssb_device *mdev = bus->mipscore.dev; 
     331        u32 irqflag = ssb_irqflag(dev); 
     332  
     333+       BUG_ON(oldirq == 6); 
     334+ 
     335        dev->irq = irq + 2; 
     336  
     337-       ssb_dprintk(KERN_INFO PFX 
     338-                   "set_irq: core 0x%04x, irq %d => %d\n", 
     339-                   dev->id.coreid, oldirq, irq); 
     340        /* clear the old irq */ 
     341        if (oldirq == 0) 
     342                ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC))); 
     343-       else 
     344+       else if (oldirq != 5) 
     345                clear_irq(bus, oldirq); 
     346  
     347        /* assign the new one */ 
     348        if (irq == 0) { 
     349                ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC))); 
     350        } else { 
     351+               u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG); 
     352+               if ((ipsflag & ipsflag_irq_mask[irq]) != ipsflag_irq_mask[irq]) { 
     353+                       u32 oldipsflag = (ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]; 
     354+                       struct ssb_device *olddev = find_device(dev, oldipsflag); 
     355+                       if (olddev) 
     356+                               set_irq(olddev, 0); 
     357+               } 
     358                irqflag <<= ipsflag_irq_shift[irq]; 
     359-               irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]); 
     360+               irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]); 
     361                ssb_write32(mdev, SSB_IPSFLAG, irqflag); 
     362        } 
     363+       ssb_dprintk(KERN_INFO PFX 
     364+                   "set_irq: core 0x%04x, irq %d => %d\n", 
     365+                   dev->id.coreid, oldirq+2, irq+2); 
     366+} 
     367+ 
     368+static void print_irq(struct ssb_device *dev, unsigned int irq) 
     369+{ 
     370+       int i; 
     371+       static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"}; 
     372+       ssb_dprintk(KERN_INFO PFX 
     373+               "core 0x%04x, irq :", dev->id.coreid); 
     374+       for (i = 0; i <= 6; i++) { 
     375+               ssb_dprintk(" %s%s", irq_name[i], i==irq?"*":" "); 
     376+       } 
     377+       ssb_dprintk("\n"); 
     378+} 
     379+ 
     380+static void dump_irq(struct ssb_bus *bus) 
     381+{ 
     382+       int i; 
     383+       for (i = 0; i < bus->nr_devices; i++) { 
     384+               struct ssb_device *dev; 
     385+               dev = &(bus->devices[i]); 
     386+               print_irq(dev, ssb_mips_irq(dev)); 
     387+       } 
     388 } 
     389  
     390 static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
     391@@ -197,17 +253,23 @@ void ssb_mipscore_init(struct ssb_mipsco 
     392  
     393        /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */ 
     394        for (irq = 2, i = 0; i < bus->nr_devices; i++) { 
     395+               int mips_irq; 
     396                dev = &(bus->devices[i]); 
     397-               dev->irq = ssb_mips_irq(dev) + 2; 
     398+               mips_irq = ssb_mips_irq(dev); 
     399+               if (mips_irq > 4) 
     400+                       dev->irq = 0; 
     401+               else 
     402+                       dev->irq = mips_irq + 2; 
     403+               if (dev->irq > 5) 
     404+                       continue; 
     405                switch (dev->id.coreid) { 
     406                case SSB_DEV_USB11_HOST: 
     407                        /* shouldn't need a separate irq line for non-4710, most of them have a proper 
     408                         * external usb controller on the pci */ 
     409                        if ((bus->chip_id == 0x4710) && (irq <= 4)) { 
     410                                set_irq(dev, irq++); 
     411-                               break; 
     412                        } 
     413-                       /* fallthrough */ 
     414+                       break; 
     415                case SSB_DEV_PCI: 
     416                case SSB_DEV_ETHERNET: 
     417                case SSB_DEV_ETHERNET_GBIT: 
     418@@ -218,8 +280,14 @@ void ssb_mipscore_init(struct ssb_mipsco 
     419                                set_irq(dev, irq++); 
     420                                break; 
     421                        } 
     422+                       /* fallthrough */ 
     423+               case SSB_DEV_EXTIF: 
     424+                       set_irq(dev, 0); 
     425+                       break; 
     426                } 
     427        } 
     428+       ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n"); 
     429+       dump_irq(bus); 
     430  
     431        ssb_mips_serial_init(mcore); 
     432        ssb_mips_flash_detect(mcore); 
     433--- a/drivers/ssb/driver_pcicore.c 
     434+++ b/drivers/ssb/driver_pcicore.c 
     435@@ -246,20 +246,12 @@ static struct pci_controller ssb_pcicore 
     436        .pci_ops        = &ssb_pcicore_pciops, 
     437        .io_resource    = &ssb_pcicore_io_resource, 
     438        .mem_resource   = &ssb_pcicore_mem_resource, 
     439-       .mem_offset     = 0x24000000, 
     440 }; 
     441  
     442-static u32 ssb_pcicore_pcibus_iobase = 0x100; 
     443-static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA; 
     444- 
     445 /* This function is called when doing a pci_enable_device(). 
     446  * We must first check if the device is a device on the PCI-core bridge. */ 
     447 int ssb_pcicore_plat_dev_init(struct pci_dev *d) 
     448 { 
     449-       struct resource *res; 
     450-       int pos, size; 
     451-       u32 *base; 
     452- 
     453        if (d->bus->ops != &ssb_pcicore_pciops) { 
     454                /* This is not a device on the PCI-core bridge. */ 
     455                return -ENODEV; 
     456@@ -268,27 +260,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
     457        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
     458                   pci_name(d)); 
     459  
     460-       /* Fix up resource bases */ 
     461-       for (pos = 0; pos < 6; pos++) { 
     462-               res = &d->resource[pos]; 
     463-               if (res->flags & IORESOURCE_IO) 
     464-                       base = &ssb_pcicore_pcibus_iobase; 
     465-               else 
     466-                       base = &ssb_pcicore_pcibus_membase; 
     467-               res->flags |= IORESOURCE_PCI_FIXED; 
     468-               if (res->end) { 
     469-                       size = res->end - res->start + 1; 
     470-                       if (*base & (size - 1)) 
     471-                               *base = (*base + size) & ~(size - 1); 
     472-                       res->start = *base; 
     473-                       res->end = res->start + size - 1; 
     474-                       *base += size; 
     475-                       pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start); 
     476-               } 
     477-               /* Fix up PCI bridge BAR0 only */ 
     478-               if (d->bus->number == 0 && PCI_SLOT(d->devfn) == 0) 
     479-                       break; 
     480-       } 
     481        /* Fix up interrupt lines */ 
     482        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
     483        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
     484@@ -551,13 +522,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     485        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
     486  
     487        /* Enable interrupts for this device. */ 
     488-       if (bus->host_pci && 
     489-           ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) { 
     490+       if ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE)) { 
     491                u32 coremask; 
     492  
     493                /* Calculate the "coremask" for the device. */ 
     494                coremask = (1 << dev->core_index); 
     495  
     496+               SSB_WARN_ON(bus->bustype != SSB_BUSTYPE_PCI); 
     497                err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp); 
     498                if (err) 
     499                        goto out; 
    129500--- a/drivers/ssb/main.c 
    130501+++ b/drivers/ssb/main.c 
    131 @@ -120,6 +120,19 @@ static void ssb_device_put(struct ssb_de 
     502@@ -17,6 +17,8 @@ 
     503 #include <linux/ssb/ssb_driver_gige.h> 
     504 #include <linux/dma-mapping.h> 
     505 #include <linux/pci.h> 
     506+#include <linux/mmc/sdio_func.h> 
     507+#include <linux/slab.h> 
     508  
     509 #include <pcmcia/cs_types.h> 
     510 #include <pcmcia/cs.h> 
     511@@ -88,6 +90,25 @@ found: 
     512 } 
     513 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     514  
     515+#ifdef CONFIG_SSB_SDIOHOST 
     516+struct ssb_bus *ssb_sdio_func_to_bus(struct sdio_func *func) 
     517+{ 
     518+       struct ssb_bus *bus; 
     519+ 
     520+       ssb_buses_lock(); 
     521+       list_for_each_entry(bus, &buses, list) { 
     522+               if (bus->bustype == SSB_BUSTYPE_SDIO && 
     523+                   bus->host_sdio == func) 
     524+                       goto found; 
     525+       } 
     526+       bus = NULL; 
     527+found: 
     528+       ssb_buses_unlock(); 
     529+ 
     530+       return bus; 
     531+} 
     532+#endif /* CONFIG_SSB_SDIOHOST */ 
     533+ 
     534 int ssb_for_each_bus_call(unsigned long data, 
     535                          int (*func)(struct ssb_bus *bus, unsigned long data)) 
     536 { 
     537@@ -120,6 +141,19 @@ static void ssb_device_put(struct ssb_de 
    132538                put_device(dev->dev); 
    133539 } 
     
    149555 { 
    150556        struct ssb_device *ssb_dev = dev_to_ssb_dev(dev); 
    151 @@ -190,90 +203,81 @@ int ssb_bus_suspend(struct ssb_bus *bus) 
     557@@ -190,90 +224,81 @@ int ssb_bus_suspend(struct ssb_bus *bus) 
    152558 EXPORT_SYMBOL(ssb_bus_suspend); 
    153559  
     
    204610-                   !dev->dev->driver || 
    205611-                   !device_is_registered(dev->dev)) 
    206 -                       continue; 
    207 -               drv = drv_to_ssb_drv(dev->dev->driver); 
    208 -               if (!drv) 
    209612+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
    210613+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
    211614+                       ssb_device_put(sdev); 
    212615                        continue; 
     616-               drv = drv_to_ssb_drv(dev->dev->driver); 
     617-               if (!drv) 
     618-                       continue; 
    213619-               err = drv->suspend(dev, state); 
    214620-               if (err) { 
     
    292698 #endif /* CONFIG_SSB_SPROM */ 
    293699  
    294 @@ -472,6 +476,8 @@ static int ssb_devices_register(struct s 
     700@@ -360,6 +385,35 @@ static int ssb_device_uevent(struct devi 
     701                             ssb_dev->id.revision); 
     702 } 
     703  
     704+#define ssb_config_attr(attrib, field, format_string) \ 
     705+static ssize_t \ 
     706+attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 
     707+{ \ 
     708+       return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \ 
     709+} 
     710+ 
     711+ssb_config_attr(core_num, core_index, "%u\n") 
     712+ssb_config_attr(coreid, id.coreid, "0x%04x\n") 
     713+ssb_config_attr(vendor, id.vendor, "0x%04x\n") 
     714+ssb_config_attr(revision, id.revision, "%u\n") 
     715+ssb_config_attr(irq, irq, "%u\n") 
     716+static ssize_t 
     717+name_show(struct device *dev, struct device_attribute *attr, char *buf) 
     718+{ 
     719+       return sprintf(buf, "%s\n", 
     720+                      ssb_core_name(dev_to_ssb_dev(dev)->id.coreid)); 
     721+} 
     722+ 
     723+static struct device_attribute ssb_device_attrs[] = { 
     724+       __ATTR_RO(name), 
     725+       __ATTR_RO(core_num), 
     726+       __ATTR_RO(coreid), 
     727+       __ATTR_RO(vendor), 
     728+       __ATTR_RO(revision), 
     729+       __ATTR_RO(irq), 
     730+       __ATTR_NULL, 
     731+}; 
     732+ 
     733 static struct bus_type ssb_bustype = { 
     734        .name           = "ssb", 
     735        .match          = ssb_bus_match, 
     736@@ -369,6 +423,7 @@ static struct bus_type ssb_bustype = { 
     737        .suspend        = ssb_device_suspend, 
     738        .resume         = ssb_device_resume, 
     739        .uevent         = ssb_device_uevent, 
     740+       .dev_attrs      = ssb_device_attrs, 
     741 }; 
     742  
     743 static void ssb_buses_lock(void) 
     744@@ -461,6 +516,7 @@ static int ssb_devices_register(struct s 
     745 #ifdef CONFIG_SSB_PCIHOST 
     746                        sdev->irq = bus->host_pci->irq; 
     747                        dev->parent = &bus->host_pci->dev; 
     748+                       sdev->dma_dev = dev->parent; 
     749 #endif 
     750                        break; 
     751                case SSB_BUSTYPE_PCMCIA: 
     752@@ -469,8 +525,14 @@ static int ssb_devices_register(struct s 
     753                        dev->parent = &bus->host_pcmcia->dev; 
     754 #endif 
     755                        break; 
     756+               case SSB_BUSTYPE_SDIO: 
     757+#ifdef CONFIG_SSB_SDIOHOST 
     758+                       dev->parent = &bus->host_sdio->dev; 
     759+#endif 
     760+                       break; 
    295761                case SSB_BUSTYPE_SSB: 
    296762                        dev->dma_mask = &dev->coherent_dma_mask; 
     763+                       sdev->dma_dev = dev; 
    297764                        break; 
    298 +               default: 
    299 +                       break; 
    300765                } 
    301766  
    302                 sdev->dev = dev; 
    303 @@ -1358,8 +1364,10 @@ static int __init ssb_modinit(void) 
     767@@ -724,12 +786,18 @@ static int ssb_bus_register(struct ssb_b 
     768        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     769        if (err) 
     770                goto out; 
     771+ 
     772+       /* Init SDIO-host device (if any), before the scan */ 
     773+       err = ssb_sdio_init(bus); 
     774+       if (err) 
     775+               goto err_disable_xtal; 
     776+ 
     777        ssb_buses_lock(); 
     778        bus->busnumber = next_busnumber; 
     779        /* Scan for devices (cores) */ 
     780        err = ssb_bus_scan(bus, baseaddr); 
     781        if (err) 
     782-               goto err_disable_xtal; 
     783+               goto err_sdio_exit; 
     784  
     785        /* Init PCI-host device (if any) */ 
     786        err = ssb_pci_init(bus); 
     787@@ -776,6 +844,8 @@ err_pci_exit: 
     788        ssb_pci_exit(bus); 
     789 err_unmap: 
     790        ssb_iounmap(bus); 
     791+err_sdio_exit: 
     792+       ssb_sdio_exit(bus); 
     793 err_disable_xtal: 
     794        ssb_buses_unlock(); 
     795        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     796@@ -796,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
     797        if (!err) { 
     798                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     799                           "PCI device %s\n", dev_name(&host_pci->dev)); 
     800+       } else { 
     801+               ssb_printk(KERN_ERR PFX "Failed to register PCI version" 
     802+                          " of SSB with error %d\n", err); 
     803        } 
     804  
     805        return err; 
     806@@ -825,6 +898,28 @@ int ssb_bus_pcmciabus_register(struct ss 
     807 EXPORT_SYMBOL(ssb_bus_pcmciabus_register); 
     808 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     809  
     810+#ifdef CONFIG_SSB_SDIOHOST 
     811+int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
     812+                            unsigned int quirks) 
     813+{ 
     814+       int err; 
     815+ 
     816+       bus->bustype = SSB_BUSTYPE_SDIO; 
     817+       bus->host_sdio = func; 
     818+       bus->ops = &ssb_sdio_ops; 
     819+       bus->quirks = quirks; 
     820+ 
     821+       err = ssb_bus_register(bus, ssb_sdio_get_invariants, ~0); 
     822+       if (!err) { 
     823+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     824+                          "SDIO device %s\n", sdio_func_id(func)); 
     825+       } 
     826+ 
     827+       return err; 
     828+} 
     829+EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
     830+#endif /* CONFIG_SSB_PCMCIAHOST */ 
     831+ 
     832 int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     833                            unsigned long baseaddr, 
     834                            ssb_invariants_func_t get_invariants) 
     835@@ -1099,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
     836 } 
     837 EXPORT_SYMBOL(ssb_device_enable); 
     838  
     839-/* Wait for a bit in a register to get set or unset. 
     840+/* Wait for bitmask in a register to get set or cleared. 
     841  * timeout is in units of ten-microseconds */ 
     842-static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
     843-                       int timeout, int set) 
     844+static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     845+                        int timeout, int set) 
     846 { 
     847        int i; 
     848        u32 val; 
     849@@ -1110,7 +1205,7 @@ static int ssb_wait_bit(struct ssb_devic 
     850        for (i = 0; i < timeout; i++) { 
     851                val = ssb_read32(dev, reg); 
     852                if (set) { 
     853-                       if (val & bitmask) 
     854+                       if ((val & bitmask) == bitmask) 
     855                                return 0; 
     856                } else { 
     857                        if (!(val & bitmask)) 
     858@@ -1127,20 +1222,38 @@ static int ssb_wait_bit(struct ssb_devic 
     859  
     860 void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
     861 { 
     862-       u32 reject; 
     863+       u32 reject, val; 
     864  
     865        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
     866                return; 
     867  
     868        reject = ssb_tmslow_reject_bitmask(dev); 
     869-       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     870-       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
     871-       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     872-       ssb_write32(dev, SSB_TMSLOW, 
     873-                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     874-                   reject | SSB_TMSLOW_RESET | 
     875-                   core_specific_flags); 
     876-       ssb_flush_tmslow(dev); 
     877+ 
     878+       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) { 
     879+               ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     880+               ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1); 
     881+               ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     882+ 
     883+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     884+                       val = ssb_read32(dev, SSB_IMSTATE); 
     885+                       val |= SSB_IMSTATE_REJECT; 
     886+                       ssb_write32(dev, SSB_IMSTATE, val); 
     887+                       ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000, 
     888+                                     0); 
     889+               } 
     890+ 
     891+               ssb_write32(dev, SSB_TMSLOW, 
     892+                       SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     893+                       reject | SSB_TMSLOW_RESET | 
     894+                       core_specific_flags); 
     895+               ssb_flush_tmslow(dev); 
     896+ 
     897+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     898+                       val = ssb_read32(dev, SSB_IMSTATE); 
     899+                       val &= ~SSB_IMSTATE_REJECT; 
     900+                       ssb_write32(dev, SSB_IMSTATE, val); 
     901+               } 
     902+       } 
     903  
     904        ssb_write32(dev, SSB_TMSLOW, 
     905                    reject | SSB_TMSLOW_RESET | 
     906@@ -1358,8 +1471,10 @@ static int __init ssb_modinit(void) 
    304907        ssb_buses_lock(); 
    305908        err = ssb_attach_queued_buses(); 
     
    313916        err = b43_pci_ssb_bridge_init(); 
    314917        if (err) { 
    315 @@ -1375,7 +1383,7 @@ static int __init ssb_modinit(void) 
     918@@ -1375,7 +1490,7 @@ static int __init ssb_modinit(void) 
    316919                /* don't fail SSB init because of this */ 
    317920                err = 0; 
     
    324927--- a/drivers/ssb/pci.c 
    325928+++ b/drivers/ssb/pci.c 
    326 @@ -167,10 +167,16 @@ err_pci: 
     929@@ -17,6 +17,7 @@ 
     930  
     931 #include <linux/ssb/ssb.h> 
     932 #include <linux/ssb/ssb_regs.h> 
     933+#include <linux/slab.h> 
     934 #include <linux/pci.h> 
     935 #include <linux/delay.h> 
     936  
     937@@ -167,10 +168,16 @@ err_pci: 
    327938 } 
    328939  
     
    343954 static inline u8 ssb_crc8(u8 crc, u8 data) 
    344955 { 
    345 @@ -247,7 +253,7 @@ static int sprom_do_read(struct ssb_bus  
     956@@ -247,7 +254,7 @@ static int sprom_do_read(struct ssb_bus 
    346957        int i; 
    347958  
     
    352963        return 0; 
    353964 } 
    354 @@ -278,7 +284,7 @@ static int sprom_do_write(struct ssb_bus 
     965@@ -278,7 +285,7 @@ static int sprom_do_write(struct ssb_bus 
    355966                        ssb_printk("75%%"); 
    356967                else if (i % 2) 
     
    361972                msleep(20); 
    362973        } 
    363 @@ -474,12 +480,14 @@ static void sprom_extract_r8(struct ssb_ 
     974@@ -399,6 +406,46 @@ static void sprom_extract_r123(struct ss 
     975        out->antenna_gain.ghz5.a3 = gain; 
     976 } 
     977  
     978+/* Revs 4 5 and 8 have partially shared layout */ 
     979+static void sprom_extract_r458(struct ssb_sprom *out, const u16 *in) 
     980+{ 
     981+       SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01, 
     982+            SSB_SPROM4_TXPID2G0, SSB_SPROM4_TXPID2G0_SHIFT); 
     983+       SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01, 
     984+            SSB_SPROM4_TXPID2G1, SSB_SPROM4_TXPID2G1_SHIFT); 
     985+       SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23, 
     986+            SSB_SPROM4_TXPID2G2, SSB_SPROM4_TXPID2G2_SHIFT); 
     987+       SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23, 
     988+            SSB_SPROM4_TXPID2G3, SSB_SPROM4_TXPID2G3_SHIFT); 
     989+ 
     990+       SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01, 
     991+            SSB_SPROM4_TXPID5GL0, SSB_SPROM4_TXPID5GL0_SHIFT); 
     992+       SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01, 
     993+            SSB_SPROM4_TXPID5GL1, SSB_SPROM4_TXPID5GL1_SHIFT); 
     994+       SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23, 
     995+            SSB_SPROM4_TXPID5GL2, SSB_SPROM4_TXPID5GL2_SHIFT); 
     996+       SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23, 
     997+            SSB_SPROM4_TXPID5GL3, SSB_SPROM4_TXPID5GL3_SHIFT); 
     998+ 
     999+       SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01, 
     1000+            SSB_SPROM4_TXPID5G0, SSB_SPROM4_TXPID5G0_SHIFT); 
     1001+       SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01, 
     1002+            SSB_SPROM4_TXPID5G1, SSB_SPROM4_TXPID5G1_SHIFT); 
     1003+       SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23, 
     1004+            SSB_SPROM4_TXPID5G2, SSB_SPROM4_TXPID5G2_SHIFT); 
     1005+       SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23, 
     1006+            SSB_SPROM4_TXPID5G3, SSB_SPROM4_TXPID5G3_SHIFT); 
     1007+ 
     1008+       SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01, 
     1009+            SSB_SPROM4_TXPID5GH0, SSB_SPROM4_TXPID5GH0_SHIFT); 
     1010+       SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01, 
     1011+            SSB_SPROM4_TXPID5GH1, SSB_SPROM4_TXPID5GH1_SHIFT); 
     1012+       SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23, 
     1013+            SSB_SPROM4_TXPID5GH2, SSB_SPROM4_TXPID5GH2_SHIFT); 
     1014+       SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23, 
     1015+            SSB_SPROM4_TXPID5GH3, SSB_SPROM4_TXPID5GH3_SHIFT); 
     1016+} 
     1017+ 
     1018 static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in) 
     1019 { 
     1020        int i; 
     1021@@ -421,10 +468,14 @@ static void sprom_extract_r45(struct ssb 
     1022                SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0); 
     1023                SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0); 
     1024                SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0); 
     1025+               SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0); 
     1026+               SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0); 
     1027        } else { 
     1028                SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0); 
     1029                SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0); 
     1030                SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0); 
     1031+               SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0); 
     1032+               SPEX(boardflags2_hi, SSB_SPROM5_BFL2HI, 0xFFFF, 0); 
     1033        } 
     1034        SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A, 
     1035             SSB_SPROM4_ANTAVAIL_A_SHIFT); 
     1036@@ -464,6 +515,8 @@ static void sprom_extract_r45(struct ssb 
     1037        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
     1038               sizeof(out->antenna_gain.ghz5)); 
     1039  
     1040+       sprom_extract_r458(out, in); 
     1041+ 
     1042        /* TODO - get remaining rev 4 stuff needed */ 
     1043 } 
     1044  
     1045@@ -474,12 +527,14 @@ static void sprom_extract_r8(struct ssb_ 
    3641046  
    3651047        /* extract the MAC address */ 
     
    3771059             SSB_SPROM8_ANTAVAIL_A_SHIFT); 
    3781060        SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG, 
    379 @@ -490,12 +498,55 @@ static void sprom_extract_r8(struct ssb_ 
     1061@@ -490,12 +545,55 @@ static void sprom_extract_r8(struct ssb_ 
    3801062        SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0); 
    3811063        SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A, 
     
    4331115        /* Extract the antenna gain values. */ 
    4341116        SPEX(antenna_gain.ghz24.a0, SSB_SPROM8_AGAIN01, 
    435 @@ -549,6 +600,7 @@ static int sprom_extract(struct ssb_bus  
    436                         ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    437                                    "  revision %d detected. Will extract" 
    438                                    " v1\n", out->revision); 
    439 +                       out->revision = 1; 
    440                         sprom_extract_r123(out, in); 
    441                 } 
     1117@@ -509,6 +607,8 @@ static void sprom_extract_r8(struct ssb_ 
     1118        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
     1119               sizeof(out->antenna_gain.ghz5)); 
     1120  
     1121+       sprom_extract_r458(out, in); 
     1122+ 
     1123        /* TODO - get remaining rev 8 stuff needed */ 
     1124 } 
     1125  
     1126@@ -521,36 +621,34 @@ static int sprom_extract(struct ssb_bus 
     1127        ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision); 
     1128        memset(out->et0mac, 0xFF, 6);           /* preset et0 and et1 mac */ 
     1129        memset(out->et1mac, 0xFF, 6); 
     1130+ 
     1131        if ((bus->chip_id & 0xFF00) == 0x4400) { 
     1132                /* Workaround: The BCM44XX chip has a stupid revision 
     1133                 * number stored in the SPROM. 
     1134                 * Always extract r1. */ 
     1135                out->revision = 1; 
     1136+               ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision); 
     1137+       } 
     1138+ 
     1139+       switch (out->revision) { 
     1140+       case 1: 
     1141+       case 2: 
     1142+       case 3: 
     1143                sprom_extract_r123(out, in); 
     1144-       } else if (bus->chip_id == 0x4321) { 
     1145-               /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */ 
     1146-               out->revision = 4; 
     1147+               break; 
     1148+       case 4: 
     1149+       case 5: 
     1150                sprom_extract_r45(out, in); 
     1151-       } else { 
     1152-               switch (out->revision) { 
     1153-               case 1: 
     1154-               case 2: 
     1155-               case 3: 
     1156-                       sprom_extract_r123(out, in); 
     1157-                       break; 
     1158-               case 4: 
     1159-               case 5: 
     1160-                       sprom_extract_r45(out, in); 
     1161-                       break; 
     1162-               case 8: 
     1163-                       sprom_extract_r8(out, in); 
     1164-                       break; 
     1165-               default: 
     1166-                       ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     1167-                                  "  revision %d detected. Will extract" 
     1168-                                  " v1\n", out->revision); 
     1169-                       sprom_extract_r123(out, in); 
     1170-               } 
     1171+               break; 
     1172+       case 8: 
     1173+               sprom_extract_r8(out, in); 
     1174+               break; 
     1175+       default: 
     1176+               ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     1177+                          " revision %d detected. Will extract" 
     1178+                          " v1\n", out->revision); 
     1179+               out->revision = 1; 
     1180+               sprom_extract_r123(out, in); 
    4421181        } 
    443 @@ -568,6 +620,14 @@ static int ssb_pci_sprom_get(struct ssb_ 
    444         int err = -ENOMEM; 
     1182  
     1183        if (out->boardflags_lo == 0xFFFF) 
     1184@@ -565,12 +663,34 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1185                             struct ssb_sprom *sprom) 
     1186 { 
     1187        const struct ssb_sprom *fallback; 
     1188-       int err = -ENOMEM; 
     1189+       int err; 
    4451190        u16 *buf; 
    4461191  
     
    4491194+               return -ENODEV; 
    4501195+       } 
    451 + 
    452 +       bus->sprom_offset = (bus->chipco.dev->id.revision < 31) ? 
    453 +               SSB_SPROM_BASE1 : SSB_SPROM_BASE31; 
     1196+       if (bus->chipco.dev) {  /* can be unavailible! */ 
     1197+               /* 
     1198+                * get SPROM offset: SSB_SPROM_BASE1 except for 
     1199+                * chipcommon rev >= 31 or chip ID is 0x4312 and 
     1200+                * chipcommon status & 3 == 2 
     1201+                */ 
     1202+               if (bus->chipco.dev->id.revision >= 31) 
     1203+                       bus->sprom_offset = SSB_SPROM_BASE31; 
     1204+               else if (bus->chip_id == 0x4312 && 
     1205+                        (bus->chipco.status & 0x03) == 2) 
     1206+                       bus->sprom_offset = SSB_SPROM_BASE31; 
     1207+               else 
     1208+                       bus->sprom_offset = SSB_SPROM_BASE1; 
     1209+       } else { 
     1210+               bus->sprom_offset = SSB_SPROM_BASE1; 
     1211+       } 
     1212+       ssb_dprintk(KERN_INFO PFX "SPROM offset is 0x%x\n", bus->sprom_offset); 
    4541213+ 
    4551214        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
    4561215        if (!buf) 
    457                 goto out; 
     1216-               goto out; 
     1217+               return -ENOMEM; 
     1218        bus->sprom_size = SSB_SPROMSIZE_WORDS_R123; 
     1219        sprom_do_read(bus, buf); 
     1220        err = sprom_check_crc(buf, bus->sprom_size); 
     1221@@ -580,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1222                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
     1223                              GFP_KERNEL); 
     1224                if (!buf) 
     1225-                       goto out; 
     1226+                       return -ENOMEM; 
     1227                bus->sprom_size = SSB_SPROMSIZE_WORDS_R4; 
     1228                sprom_do_read(bus, buf); 
     1229                err = sprom_check_crc(buf, bus->sprom_size); 
     1230@@ -602,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1231  
     1232 out_free: 
     1233        kfree(buf); 
     1234-out: 
     1235        return err; 
     1236 } 
     1237  
     1238--- a/drivers/ssb/pcihost_wrapper.c 
     1239+++ b/drivers/ssb/pcihost_wrapper.c 
     1240@@ -12,6 +12,7 @@ 
     1241  */ 
     1242  
     1243 #include <linux/pci.h> 
     1244+#include <linux/slab.h> 
     1245 #include <linux/ssb/ssb.h> 
     1246  
     1247  
     1248@@ -58,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     1249        struct ssb_bus *ssb; 
     1250        int err = -ENOMEM; 
     1251        const char *name; 
     1252+       u32 val; 
     1253  
     1254        ssb = kzalloc(sizeof(*ssb), GFP_KERNEL); 
     1255        if (!ssb) 
     1256@@ -73,6 +75,12 @@ static int ssb_pcihost_probe(struct pci_ 
     1257                goto err_pci_disable; 
     1258        pci_set_master(dev); 
     1259  
     1260+       /* Disable the RETRY_TIMEOUT register (0x41) to keep 
     1261+        * PCI Tx retries from interfering with C3 CPU state */ 
     1262+       pci_read_config_dword(dev, 0x40, &val); 
     1263+       if ((val & 0x0000ff00) != 0) 
     1264+               pci_write_config_dword(dev, 0x40, val & 0xffff00ff); 
     1265+ 
     1266        err = ssb_bus_pcibus_register(ssb, dev); 
     1267        if (err) 
     1268                goto err_pci_release_regions; 
    4581269--- a/drivers/ssb/pcmcia.c 
    4591270+++ b/drivers/ssb/pcmcia.c 
     
    7161527-       } 
    7171528+       res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, 
    718 +                               ssb_pcmcia_do_get_invariants, sprom); 
     1529+                               ssb_pcmcia_do_get_invariants, iv); 
    7191530+       if ((res == 0) || (res == -ENOSPC)) 
    7201531+               return 0; 
     
    7291540 } 
    7301541  
     1542--- a/drivers/ssb/scan.c 
     1543+++ b/drivers/ssb/scan.c 
     1544@@ -162,6 +162,8 @@ static u8 chipid_to_nrcores(u16 chipid) 
     1545 static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx, 
     1546                       u16 offset) 
     1547 { 
     1548+       u32 lo, hi; 
     1549+ 
     1550        switch (bus->bustype) { 
     1551        case SSB_BUSTYPE_SSB: 
     1552                offset += current_coreidx * SSB_CORE_SIZE; 
     1553@@ -174,7 +176,12 @@ static u32 scan_read32(struct ssb_bus *b 
     1554                        offset -= 0x800; 
     1555                } else 
     1556                        ssb_pcmcia_switch_segment(bus, 0); 
     1557-               break; 
     1558+               lo = readw(bus->mmio + offset); 
     1559+               hi = readw(bus->mmio + offset + 2); 
     1560+               return lo | (hi << 16); 
     1561+       case SSB_BUSTYPE_SDIO: 
     1562+               offset += current_coreidx * SSB_CORE_SIZE; 
     1563+               return ssb_sdio_scan_read32(bus, offset); 
     1564        } 
     1565        return readl(bus->mmio + offset); 
     1566 } 
     1567@@ -188,6 +195,8 @@ static int scan_switchcore(struct ssb_bu 
     1568                return ssb_pci_switch_coreidx(bus, coreidx); 
     1569        case SSB_BUSTYPE_PCMCIA: 
     1570                return ssb_pcmcia_switch_coreidx(bus, coreidx); 
     1571+       case SSB_BUSTYPE_SDIO: 
     1572+               return ssb_sdio_scan_switch_coreidx(bus, coreidx); 
     1573        } 
     1574        return 0; 
     1575 } 
     1576@@ -206,6 +215,8 @@ void ssb_iounmap(struct ssb_bus *bus) 
     1577                SSB_BUG_ON(1); /* Can't reach this code. */ 
     1578 #endif 
     1579                break; 
     1580+       case SSB_BUSTYPE_SDIO: 
     1581+               break; 
     1582        } 
     1583        bus->mmio = NULL; 
     1584        bus->mapped_device = NULL; 
     1585@@ -230,6 +241,10 @@ static void __iomem *ssb_ioremap(struct 
     1586                SSB_BUG_ON(1); /* Can't reach this code. */ 
     1587 #endif 
     1588                break; 
     1589+       case SSB_BUSTYPE_SDIO: 
     1590+               /* Nothing to ioremap in the SDIO case, just fake it */ 
     1591+               mmio = (void __iomem *)baseaddr; 
     1592+               break; 
     1593        } 
     1594  
     1595        return mmio; 
     1596@@ -339,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1597                dev->bus = bus; 
     1598                dev->ops = bus->ops; 
     1599  
     1600-               ssb_dprintk(KERN_INFO PFX 
     1601+               printk(KERN_DEBUG PFX 
     1602                            "Core %d found: %s " 
     1603                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
     1604                            i, ssb_core_name(dev->id.coreid), 
     1605@@ -407,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1606                        bus->pcicore.dev = dev; 
     1607 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     1608                        break; 
     1609+               case SSB_DEV_ETHERNET: 
     1610+                       if (bus->bustype == SSB_BUSTYPE_PCI) { 
     1611+                               if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     1612+                                   (bus->host_pci->device & 0xFF00) == 0x4300) { 
     1613+                                       /* This is a dangling ethernet core on a 
     1614+                                        * wireless device. Ignore it. */ 
     1615+                                       continue; 
     1616+                               } 
     1617+                       } 
     1618+                       break; 
     1619                default: 
     1620                        break; 
     1621                } 
     1622--- /dev/null 
     1623+++ b/drivers/ssb/sdio.c 
     1624@@ -0,0 +1,610 @@ 
     1625+/* 
     1626+ * Sonics Silicon Backplane 
     1627+ * SDIO-Hostbus related functions 
     1628+ * 
     1629+ * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es> 
     1630+ * 
     1631+ * Based on drivers/ssb/pcmcia.c 
     1632+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 
     1633+ * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de> 
     1634+ * 
     1635+ * Licensed under the GNU/GPL. See COPYING for details. 
     1636+ * 
     1637+ */ 
     1638+ 
     1639+#include <linux/ssb/ssb.h> 
     1640+#include <linux/delay.h> 
     1641+#include <linux/io.h> 
     1642+#include <linux/etherdevice.h> 
     1643+#include <linux/mmc/sdio_func.h> 
     1644+ 
     1645+#include "ssb_private.h" 
     1646+ 
     1647+/* Define the following to 1 to enable a printk on each coreswitch. */ 
     1648+#define SSB_VERBOSE_SDIOCORESWITCH_DEBUG               0 
     1649+ 
     1650+ 
     1651+/* Hardware invariants CIS tuples */ 
     1652+#define SSB_SDIO_CIS                   0x80 
     1653+#define  SSB_SDIO_CIS_SROMREV          0x00 
     1654+#define  SSB_SDIO_CIS_ID               0x01 
     1655+#define  SSB_SDIO_CIS_BOARDREV         0x02 
     1656+#define  SSB_SDIO_CIS_PA               0x03 
     1657+#define   SSB_SDIO_CIS_PA_PA0B0_LO     0 
     1658+#define   SSB_SDIO_CIS_PA_PA0B0_HI     1 
     1659+#define   SSB_SDIO_CIS_PA_PA0B1_LO     2 
     1660+#define   SSB_SDIO_CIS_PA_PA0B1_HI     3 
     1661+#define   SSB_SDIO_CIS_PA_PA0B2_LO     4 
     1662+#define   SSB_SDIO_CIS_PA_PA0B2_HI     5 
     1663+#define   SSB_SDIO_CIS_PA_ITSSI                6 
     1664+#define   SSB_SDIO_CIS_PA_MAXPOW       7 
     1665+#define  SSB_SDIO_CIS_OEMNAME          0x04 
     1666+#define  SSB_SDIO_CIS_CCODE            0x05 
     1667+#define  SSB_SDIO_CIS_ANTENNA          0x06 
     1668+#define  SSB_SDIO_CIS_ANTGAIN          0x07 
     1669+#define  SSB_SDIO_CIS_BFLAGS           0x08 
     1670+#define  SSB_SDIO_CIS_LEDS             0x09 
     1671+ 
     1672+#define CISTPL_FUNCE_LAN_NODE_ID        0x04   /* same as in PCMCIA */ 
     1673+ 
     1674+ 
     1675+/* 
     1676+ * Function 1 miscellaneous registers. 
     1677+ * 
     1678+ * Definitions match src/include/sbsdio.h from the 
     1679+ * Android Open Source Project 
     1680+ * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git 
     1681+ * 
     1682+ */ 
     1683+#define SBSDIO_FUNC1_SBADDRLOW 0x1000a /* SB Address window Low (b15) */ 
     1684+#define SBSDIO_FUNC1_SBADDRMID 0x1000b /* SB Address window Mid (b23-b16) */ 
     1685+#define SBSDIO_FUNC1_SBADDRHIGH        0x1000c /* SB Address window High (b24-b31) */ 
     1686+ 
     1687+/* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */ 
     1688+#define SBSDIO_SBADDRLOW_MASK  0x80    /* Valid address bits in SBADDRLOW */ 
     1689+#define SBSDIO_SBADDRMID_MASK  0xff    /* Valid address bits in SBADDRMID */ 
     1690+#define SBSDIO_SBADDRHIGH_MASK 0xff    /* Valid address bits in SBADDRHIGH */ 
     1691+ 
     1692+#define SBSDIO_SB_OFT_ADDR_MASK        0x7FFF  /* sb offset addr is <= 15 bits, 32k */ 
     1693+ 
     1694+/* REVISIT: this flag doesn't seem to matter */ 
     1695+#define SBSDIO_SB_ACCESS_2_4B_FLAG     0x8000  /* forces 32-bit SB access */ 
     1696+ 
     1697+ 
     1698+/* 
     1699+ * Address map within the SDIO function address space (128K). 
     1700+ * 
     1701+ *   Start   End     Description 
     1702+ *   ------- ------- ------------------------------------------ 
     1703+ *   0x00000 0x0ffff selected backplane address window (64K) 
     1704+ *   0x10000 0x1ffff backplane control registers (max 64K) 
     1705+ * 
     1706+ * The current address window is configured by writing to registers 
     1707+ * SBADDRLOW, SBADDRMID and SBADDRHIGH. 
     1708+ * 
     1709+ * In order to access the contents of a 32-bit Silicon Backplane address 
     1710+ * the backplane address window must be first loaded with the highest 
     1711+ * 16 bits of the target address. Then, an access must be done to the 
     1712+ * SDIO function address space using the lower 15 bits of the address. 
     1713+ * Bit 15 of the address must be set when doing 32 bit accesses. 
     1714+ * 
     1715+ * 10987654321098765432109876543210 
     1716+ * WWWWWWWWWWWWWWWWW                 SB Address Window 
     1717+ *                 OOOOOOOOOOOOOOOO  Offset within SB Address Window 
     1718+ *                 a                 32-bit access flag 
     1719+ */ 
     1720+ 
     1721+ 
     1722+/* 
     1723+ * SSB I/O via SDIO. 
     1724+ * 
     1725+ * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K). 
     1726+ */ 
     1727+ 
     1728+static inline struct device *ssb_sdio_dev(struct ssb_bus *bus) 
     1729+{ 
     1730+       return &bus->host_sdio->dev; 
     1731+} 
     1732+ 
     1733+/* host claimed */ 
     1734+static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val) 
     1735+{ 
     1736+       int error = 0; 
     1737+ 
     1738+       sdio_writeb(bus->host_sdio, val, addr, &error); 
     1739+       if (unlikely(error)) { 
     1740+               dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n", 
     1741+                       addr, val, error); 
     1742+       } 
     1743+ 
     1744+       return error; 
     1745+} 
     1746+ 
     1747+#if 0 
     1748+static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr) 
     1749+{ 
     1750+       u8 val; 
     1751+       int error = 0; 
     1752+ 
     1753+       val = sdio_readb(bus->host_sdio, addr, &error); 
     1754+       if (unlikely(error)) { 
     1755+               dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n", 
     1756+                       addr, val, error); 
     1757+       } 
     1758+ 
     1759+       return val; 
     1760+} 
     1761+#endif 
     1762+ 
     1763+/* host claimed */ 
     1764+static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address) 
     1765+{ 
     1766+       int error; 
     1767+ 
     1768+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW, 
     1769+                               (address >> 8) & SBSDIO_SBADDRLOW_MASK); 
     1770+       if (error) 
     1771+               goto out; 
     1772+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID, 
     1773+                               (address >> 16) & SBSDIO_SBADDRMID_MASK); 
     1774+       if (error) 
     1775+               goto out; 
     1776+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH, 
     1777+                               (address >> 24) & SBSDIO_SBADDRHIGH_MASK); 
     1778+       if (error) 
     1779+               goto out; 
     1780+       bus->sdio_sbaddr = address; 
     1781+out: 
     1782+       if (error) { 
     1783+               dev_dbg(ssb_sdio_dev(bus), "failed to set address window" 
     1784+                       " to 0x%08x, error %d\n", address, error); 
     1785+       } 
     1786+ 
     1787+       return error; 
     1788+} 
     1789+ 
     1790+/* for enumeration use only */ 
     1791+u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) 
     1792+{ 
     1793+       u32 val; 
     1794+       int error; 
     1795+ 
     1796+       sdio_claim_host(bus->host_sdio); 
     1797+       val = sdio_readl(bus->host_sdio, offset, &error); 
     1798+       sdio_release_host(bus->host_sdio); 
     1799+       if (unlikely(error)) { 
     1800+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 
     1801+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1802+       } 
     1803+ 
     1804+       return val; 
     1805+} 
     1806+ 
     1807+/* for enumeration use only */ 
     1808+int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 
     1809+{ 
     1810+       u32 sbaddr; 
     1811+       int error; 
     1812+ 
     1813+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 
     1814+       sdio_claim_host(bus->host_sdio); 
     1815+       error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 
     1816+       sdio_release_host(bus->host_sdio); 
     1817+       if (error) { 
     1818+               dev_err(ssb_sdio_dev(bus), "failed to switch to core %u," 
     1819+                       " error %d\n", coreidx, error); 
     1820+               goto out; 
     1821+       } 
     1822+out: 
     1823+       return error; 
     1824+} 
     1825+ 
     1826+/* host must be already claimed */ 
     1827+int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev) 
     1828+{ 
     1829+       u8 coreidx = dev->core_index; 
     1830+       u32 sbaddr; 
     1831+       int error = 0; 
     1832+ 
     1833+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 
     1834+       if (unlikely(bus->sdio_sbaddr != sbaddr)) { 
     1835+#if SSB_VERBOSE_SDIOCORESWITCH_DEBUG 
     1836+               dev_info(ssb_sdio_dev(bus), 
     1837+                          "switching to %s core, index %d\n", 
     1838+                          ssb_core_name(dev->id.coreid), coreidx); 
     1839+#endif 
     1840+               error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 
     1841+               if (error) { 
     1842+                       dev_dbg(ssb_sdio_dev(bus), "failed to switch to" 
     1843+                               " core %u, error %d\n", coreidx, error); 
     1844+                       goto out; 
     1845+               } 
     1846+               bus->mapped_device = dev; 
     1847+       } 
     1848+ 
     1849+out: 
     1850+       return error; 
     1851+} 
     1852+ 
     1853+static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset) 
     1854+{ 
     1855+       struct ssb_bus *bus = dev->bus; 
     1856+       u8 val = 0xff; 
     1857+       int error = 0; 
     1858+ 
     1859+       sdio_claim_host(bus->host_sdio); 
     1860+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1861+               goto out; 
     1862+       offset |= bus->sdio_sbaddr & 0xffff; 
     1863+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1864+       val = sdio_readb(bus->host_sdio, offset, &error); 
     1865+       if (error) { 
     1866+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n", 
     1867+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1868+       } 
     1869+out: 
     1870+       sdio_release_host(bus->host_sdio); 
     1871+ 
     1872+       return val; 
     1873+} 
     1874+ 
     1875+static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset) 
     1876+{ 
     1877+       struct ssb_bus *bus = dev->bus; 
     1878+       u16 val = 0xffff; 
     1879+       int error = 0; 
     1880+ 
     1881+       sdio_claim_host(bus->host_sdio); 
     1882+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1883+               goto out; 
     1884+       offset |= bus->sdio_sbaddr & 0xffff; 
     1885+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1886+       val = sdio_readw(bus->host_sdio, offset, &error); 
     1887+       if (error) { 
     1888+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n", 
     1889+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1890+       } 
     1891+out: 
     1892+       sdio_release_host(bus->host_sdio); 
     1893+ 
     1894+       return val; 
     1895+} 
     1896+ 
     1897+static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset) 
     1898+{ 
     1899+       struct ssb_bus *bus = dev->bus; 
     1900+       u32 val = 0xffffffff; 
     1901+       int error = 0; 
     1902+ 
     1903+       sdio_claim_host(bus->host_sdio); 
     1904+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1905+               goto out; 
     1906+       offset |= bus->sdio_sbaddr & 0xffff; 
     1907+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1908+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1909+       val = sdio_readl(bus->host_sdio, offset, &error); 
     1910+       if (error) { 
     1911+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 
     1912+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1913+       } 
     1914+out: 
     1915+       sdio_release_host(bus->host_sdio); 
     1916+ 
     1917+       return val; 
     1918+} 
     1919+ 
     1920+#ifdef CONFIG_SSB_BLOCKIO 
     1921+static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer, 
     1922+                                 size_t count, u16 offset, u8 reg_width) 
     1923+{ 
     1924+       size_t saved_count = count; 
     1925+       struct ssb_bus *bus = dev->bus; 
     1926+       int error = 0; 
     1927+ 
     1928+       sdio_claim_host(bus->host_sdio); 
     1929+       if (unlikely(ssb_sdio_switch_core(bus, dev))) { 
     1930+               error = -EIO; 
     1931+               memset(buffer, 0xff, count); 
     1932+               goto err_out; 
     1933+       } 
     1934+       offset |= bus->sdio_sbaddr & 0xffff; 
     1935+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1936+ 
     1937+       switch (reg_width) { 
     1938+       case sizeof(u8): { 
     1939+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1940+               break; 
     1941+       } 
     1942+       case sizeof(u16): { 
     1943+               SSB_WARN_ON(count & 1); 
     1944+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1945+               break; 
     1946+       } 
     1947+       case sizeof(u32): { 
     1948+               SSB_WARN_ON(count & 3); 
     1949+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1950+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1951+               break; 
     1952+       } 
     1953+       default: 
     1954+               SSB_WARN_ON(1); 
     1955+       } 
     1956+       if (!error) 
     1957+               goto out; 
     1958+ 
     1959+err_out: 
     1960+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 
     1961+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 
     1962+out: 
     1963+       sdio_release_host(bus->host_sdio); 
     1964+} 
     1965+#endif /* CONFIG_SSB_BLOCKIO */ 
     1966+ 
     1967+static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val) 
     1968+{ 
     1969+       struct ssb_bus *bus = dev->bus; 
     1970+       int error = 0; 
     1971+ 
     1972+       sdio_claim_host(bus->host_sdio); 
     1973+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1974+               goto out; 
     1975+       offset |= bus->sdio_sbaddr & 0xffff; 
     1976+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1977+       sdio_writeb(bus->host_sdio, val, offset, &error); 
     1978+       if (error) { 
     1979+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n", 
     1980+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1981+       } 
     1982+out: 
     1983+       sdio_release_host(bus->host_sdio); 
     1984+} 
     1985+ 
     1986+static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val) 
     1987+{ 
     1988+       struct ssb_bus *bus = dev->bus; 
     1989+       int error = 0; 
     1990+ 
     1991+       sdio_claim_host(bus->host_sdio); 
     1992+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1993+               goto out; 
     1994+       offset |= bus->sdio_sbaddr & 0xffff; 
     1995+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1996+       sdio_writew(bus->host_sdio, val, offset, &error); 
     1997+       if (error) { 
     1998+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n", 
     1999+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     2000+       } 
     2001+out: 
     2002+       sdio_release_host(bus->host_sdio); 
     2003+} 
     2004+ 
     2005+static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val) 
     2006+{ 
     2007+       struct ssb_bus *bus = dev->bus; 
     2008+       int error = 0; 
     2009+ 
     2010+       sdio_claim_host(bus->host_sdio); 
     2011+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     2012+               goto out; 
     2013+       offset |= bus->sdio_sbaddr & 0xffff; 
     2014+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     2015+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     2016+       sdio_writel(bus->host_sdio, val, offset, &error); 
     2017+       if (error) { 
     2018+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n", 
     2019+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     2020+       } 
     2021+       if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32) 
     2022+               sdio_readl(bus->host_sdio, 0, &error); 
     2023+out: 
     2024+       sdio_release_host(bus->host_sdio); 
     2025+} 
     2026+ 
     2027+#ifdef CONFIG_SSB_BLOCKIO 
     2028+static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer, 
     2029+                                  size_t count, u16 offset, u8 reg_width) 
     2030+{ 
     2031+       size_t saved_count = count; 
     2032+       struct ssb_bus *bus = dev->bus; 
     2033+       int error = 0; 
     2034+ 
     2035+       sdio_claim_host(bus->host_sdio); 
     2036+       if (unlikely(ssb_sdio_switch_core(bus, dev))) { 
     2037+               error = -EIO; 
     2038+               memset((void *)buffer, 0xff, count); 
     2039+               goto err_out; 
     2040+       } 
     2041+       offset |= bus->sdio_sbaddr & 0xffff; 
     2042+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     2043+ 
     2044+       switch (reg_width) { 
     2045+       case sizeof(u8): 
     2046+               error = sdio_writesb(bus->host_sdio, offset, 
     2047+                                    (void *)buffer, count); 
     2048+               break; 
     2049+       case sizeof(u16): 
     2050+               SSB_WARN_ON(count & 1); 
     2051+               error = sdio_writesb(bus->host_sdio, offset, 
     2052+                                    (void *)buffer, count); 
     2053+               break; 
     2054+       case sizeof(u32): 
     2055+               SSB_WARN_ON(count & 3); 
     2056+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     2057+               error = sdio_writesb(bus->host_sdio, offset, 
     2058+                                    (void *)buffer, count); 
     2059+               break; 
     2060+       default: 
     2061+               SSB_WARN_ON(1); 
     2062+       } 
     2063+       if (!error) 
     2064+               goto out; 
     2065+ 
     2066+err_out: 
     2067+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 
     2068+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 
     2069+out: 
     2070+       sdio_release_host(bus->host_sdio); 
     2071+} 
     2072+ 
     2073+#endif /* CONFIG_SSB_BLOCKIO */ 
     2074+ 
     2075+/* Not "static", as it's used in main.c */ 
     2076+const struct ssb_bus_ops ssb_sdio_ops = { 
     2077+       .read8          = ssb_sdio_read8, 
     2078+       .read16         = ssb_sdio_read16, 
     2079+       .read32         = ssb_sdio_read32, 
     2080+       .write8         = ssb_sdio_write8, 
     2081+       .write16        = ssb_sdio_write16, 
     2082+       .write32        = ssb_sdio_write32, 
     2083+#ifdef CONFIG_SSB_BLOCKIO 
     2084+       .block_read     = ssb_sdio_block_read, 
     2085+       .block_write    = ssb_sdio_block_write, 
     2086+#endif 
     2087+}; 
     2088+ 
     2089+#define GOTO_ERROR_ON(condition, description) do {     \ 
     2090+       if (unlikely(condition)) {                      \ 
     2091+               error_description = description;        \ 
     2092+               goto error;                             \ 
     2093+       }                                               \ 
     2094+  } while (0) 
     2095+ 
     2096+int ssb_sdio_get_invariants(struct ssb_bus *bus, 
     2097+                           struct ssb_init_invariants *iv) 
     2098+{ 
     2099+       struct ssb_sprom *sprom = &iv->sprom; 
     2100+       struct ssb_boardinfo *bi = &iv->boardinfo; 
     2101+       const char *error_description = "none"; 
     2102+       struct sdio_func_tuple *tuple; 
     2103+       void *mac; 
     2104+ 
     2105+       memset(sprom, 0xFF, sizeof(*sprom)); 
     2106+       sprom->boardflags_lo = 0; 
     2107+       sprom->boardflags_hi = 0; 
     2108+ 
     2109+       tuple = bus->host_sdio->tuples; 
     2110+       while (tuple) { 
     2111+               switch (tuple->code) { 
     2112+               case 0x22: /* extended function */ 
     2113+                       switch (tuple->data[0]) { 
     2114+                       case CISTPL_FUNCE_LAN_NODE_ID: 
     2115+                               GOTO_ERROR_ON((tuple->size != 7) && 
     2116+                                             (tuple->data[1] != 6), 
     2117+                                             "mac tpl size"); 
     2118+                               /* fetch the MAC address. */ 
     2119+                               mac = tuple->data + 2; 
     2120+                               memcpy(sprom->il0mac, mac, ETH_ALEN); 
     2121+                               memcpy(sprom->et1mac, mac, ETH_ALEN); 
     2122+                               break; 
     2123+                       default: 
     2124+                               break; 
     2125+                       } 
     2126+                       break; 
     2127+               case 0x80: /* vendor specific tuple */ 
     2128+                       switch (tuple->data[0]) { 
     2129+                       case SSB_SDIO_CIS_SROMREV: 
     2130+                               GOTO_ERROR_ON(tuple->size != 2, 
     2131+                                             "sromrev tpl size"); 
     2132+                               sprom->revision = tuple->data[1]; 
     2133+                               break; 
     2134+                       case SSB_SDIO_CIS_ID: 
     2135+                               GOTO_ERROR_ON((tuple->size != 5) && 
     2136+                                             (tuple->size != 7), 
     2137+                                             "id tpl size"); 
     2138+                               bi->vendor = tuple->data[1] | 
     2139+                                            (tuple->data[2]<<8); 
     2140+                               break; 
     2141+                       case SSB_SDIO_CIS_BOARDREV: 
     2142+                               GOTO_ERROR_ON(tuple->size != 2, 
     2143+                                             "boardrev tpl size"); 
     2144+                               sprom->board_rev = tuple->data[1]; 
     2145+                               break; 
     2146+                       case SSB_SDIO_CIS_PA: 
     2147+                               GOTO_ERROR_ON((tuple->size != 9) && 
     2148+                                             (tuple->size != 10), 
     2149+                                             "pa tpl size"); 
     2150+                               sprom->pa0b0 = tuple->data[1] | 
     2151+                                        ((u16)tuple->data[2] << 8); 
     2152+                               sprom->pa0b1 = tuple->data[3] | 
     2153+                                        ((u16)tuple->data[4] << 8); 
     2154+                               sprom->pa0b2 = tuple->data[5] | 
     2155+                                        ((u16)tuple->data[6] << 8); 
     2156+                               sprom->itssi_a = tuple->data[7]; 
     2157+                               sprom->itssi_bg = tuple->data[7]; 
     2158+                               sprom->maxpwr_a = tuple->data[8]; 
     2159+                               sprom->maxpwr_bg = tuple->data[8]; 
     2160+                               break; 
     2161+                       case SSB_SDIO_CIS_OEMNAME: 
     2162+                               /* Not present */ 
     2163+                               break; 
     2164+                       case SSB_SDIO_CIS_CCODE: 
     2165+                               GOTO_ERROR_ON(tuple->size != 2, 
     2166+                                             "ccode tpl size"); 
     2167+                               sprom->country_code = tuple->data[1]; 
     2168+                               break; 
     2169+                       case SSB_SDIO_CIS_ANTENNA: 
     2170+                               GOTO_ERROR_ON(tuple->size != 2, 
     2171+                                             "ant tpl size"); 
     2172+                               sprom->ant_available_a = tuple->data[1]; 
     2173+                               sprom->ant_available_bg = tuple->data[1]; 
     2174+                               break; 
     2175+                       case SSB_SDIO_CIS_ANTGAIN: 
     2176+                               GOTO_ERROR_ON(tuple->size != 2, 
     2177+                                             "antg tpl size"); 
     2178+                               sprom->antenna_gain.ghz24.a0 = tuple->data[1]; 
     2179+                               sprom->antenna_gain.ghz24.a1 = tuple->data[1]; 
     2180+                               sprom->antenna_gain.ghz24.a2 = tuple->data[1]; 
     2181+                               sprom->antenna_gain.ghz24.a3 = tuple->data[1]; 
     2182+                               sprom->antenna_gain.ghz5.a0 = tuple->data[1]; 
     2183+                               sprom->antenna_gain.ghz5.a1 = tuple->data[1]; 
     2184+                               sprom->antenna_gain.ghz5.a2 = tuple->data[1]; 
     2185+                               sprom->antenna_gain.ghz5.a3 = tuple->data[1]; 
     2186+                               break; 
     2187+                       case SSB_SDIO_CIS_BFLAGS: 
     2188+                               GOTO_ERROR_ON((tuple->size != 3) && 
     2189+                                             (tuple->size != 5), 
     2190+                                             "bfl tpl size"); 
     2191+                               sprom->boardflags_lo = tuple->data[1] | 
     2192+                                                ((u16)tuple->data[2] << 8); 
     2193+                               break; 
     2194+                       case SSB_SDIO_CIS_LEDS: 
     2195+                               GOTO_ERROR_ON(tuple->size != 5, 
     2196+                                             "leds tpl size"); 
     2197+                               sprom->gpio0 = tuple->data[1]; 
     2198+                               sprom->gpio1 = tuple->data[2]; 
     2199+                               sprom->gpio2 = tuple->data[3]; 
     2200+                               sprom->gpio3 = tuple->data[4]; 
     2201+                               break; 
     2202+                       default: 
     2203+                               break; 
     2204+                       } 
     2205+                       break; 
     2206+               default: 
     2207+                       break; 
     2208+               } 
     2209+               tuple = tuple->next; 
     2210+       } 
     2211+ 
     2212+       return 0; 
     2213+error: 
     2214+       dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n", 
     2215+               error_description); 
     2216+       return -ENODEV; 
     2217+} 
     2218+ 
     2219+void ssb_sdio_exit(struct ssb_bus *bus) 
     2220+{ 
     2221+       if (bus->bustype != SSB_BUSTYPE_SDIO) 
     2222+               return; 
     2223+       /* Nothing to do here. */ 
     2224+} 
     2225+ 
     2226+int ssb_sdio_init(struct ssb_bus *bus) 
     2227+{ 
     2228+       if (bus->bustype != SSB_BUSTYPE_SDIO) 
     2229+               return 0; 
     2230+ 
     2231+       bus->sdio_sbaddr = ~0; 
     2232+ 
     2233+       return 0; 
     2234+} 
     2235--- a/drivers/ssb/sprom.c 
     2236+++ b/drivers/ssb/sprom.c 
     2237@@ -13,6 +13,9 @@ 
     2238  
     2239 #include "ssb_private.h" 
     2240  
     2241+#include <linux/ctype.h> 
     2242+#include <linux/slab.h> 
     2243+ 
     2244  
     2245 static const struct ssb_sprom *fallback_sprom; 
     2246  
     2247@@ -33,17 +36,27 @@ static int sprom2hex(const u16 *sprom, c 
     2248 static int hex2sprom(u16 *sprom, const char *dump, size_t len, 
     2249                     size_t sprom_size_words) 
     2250 { 
     2251-       char tmp[5] = { 0 }; 
     2252-       int cnt = 0; 
     2253+       char c, tmp[5] = { 0 }; 
     2254+       int err, cnt = 0; 
     2255        unsigned long parsed; 
     2256  
     2257-       if (len < sprom_size_words * 2) 
     2258+       /* Strip whitespace at the end. */ 
     2259+       while (len) { 
     2260+               c = dump[len - 1]; 
     2261+               if (!isspace(c) && c != '\0') 
     2262+                       break; 
     2263+               len--; 
     2264+       } 
     2265+       /* Length must match exactly. */ 
     2266+       if (len != sprom_size_words * 4) 
     2267                return -EINVAL; 
     2268  
     2269        while (cnt < sprom_size_words) { 
     2270                memcpy(tmp, dump, 4); 
     2271                dump += 4; 
     2272-               parsed = simple_strtoul(tmp, NULL, 16); 
     2273+               err = strict_strtoul(tmp, 16, &parsed); 
     2274+               if (err) 
     2275+                       return err; 
     2276                sprom[cnt++] = swab16((u16)parsed); 
     2277        } 
     2278  
     2279@@ -90,6 +103,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     2280        u16 *sprom; 
     2281        int res = 0, err = -ENOMEM; 
     2282        size_t sprom_size_words = bus->sprom_size; 
     2283+       struct ssb_freeze_context freeze; 
     2284  
     2285        sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 
     2286        if (!sprom) 
     2287@@ -111,18 +125,13 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     2288        err = -ERESTARTSYS; 
     2289        if (mutex_lock_interruptible(&bus->sprom_mutex)) 
     2290                goto out_kfree; 
     2291-       err = ssb_devices_freeze(bus); 
     2292-       if (err == -EOPNOTSUPP) { 
     2293-               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
     2294-                          "No suspend support. Is CONFIG_PM enabled?\n"); 
     2295-               goto out_unlock; 
     2296-       } 
     2297+       err = ssb_devices_freeze(bus, &freeze); 
     2298        if (err) { 
     2299                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
     2300                goto out_unlock; 
     2301        } 
     2302        res = sprom_write(bus, sprom); 
     2303-       err = ssb_devices_thaw(bus); 
     2304+       err = ssb_devices_thaw(&freeze); 
     2305        if (err) 
     2306                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
     2307 out_unlock: 
     2308@@ -167,3 +176,18 @@ const struct ssb_sprom *ssb_get_fallback 
     2309 { 
     2310        return fallback_sprom; 
     2311 } 
     2312+ 
     2313+/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     2314+bool ssb_is_sprom_available(struct ssb_bus *bus) 
     2315+{ 
     2316+       /* status register only exists on chipcomon rev >= 11 and we need check 
     2317+          for >= 31 only */ 
     2318+       /* this routine differs from specs as we do not access SPROM directly 
     2319+          on PCMCIA */ 
     2320+       if (bus->bustype == SSB_BUSTYPE_PCI && 
     2321+           bus->chipco.dev &&  /* can be unavailible! */ 
     2322+           bus->chipco.dev->id.revision >= 31) 
     2323+               return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
     2324+ 
     2325+       return true; 
     2326+} 
     2327--- a/drivers/ssb/ssb_private.h 
     2328+++ b/drivers/ssb/ssb_private.h 
     2329@@ -114,6 +114,46 @@ static inline int ssb_pcmcia_init(struct 
     2330 } 
     2331 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     2332  
     2333+/* sdio.c */ 
     2334+#ifdef CONFIG_SSB_SDIOHOST 
     2335+extern int ssb_sdio_get_invariants(struct ssb_bus *bus, 
     2336+                                    struct ssb_init_invariants *iv); 
     2337+ 
     2338+extern u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset); 
     2339+extern int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev); 
     2340+extern int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx); 
     2341+extern int ssb_sdio_hardware_setup(struct ssb_bus *bus); 
     2342+extern void ssb_sdio_exit(struct ssb_bus *bus); 
     2343+extern int ssb_sdio_init(struct ssb_bus *bus); 
     2344+ 
     2345+extern const struct ssb_bus_ops ssb_sdio_ops; 
     2346+#else /* CONFIG_SSB_SDIOHOST */ 
     2347+static inline u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) 
     2348+{ 
     2349+       return 0; 
     2350+} 
     2351+static inline int ssb_sdio_switch_core(struct ssb_bus *bus, 
     2352+                                        struct ssb_device *dev) 
     2353+{ 
     2354+       return 0; 
     2355+} 
     2356+static inline int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 
     2357+{ 
     2358+       return 0; 
     2359+} 
     2360+static inline int ssb_sdio_hardware_setup(struct ssb_bus *bus) 
     2361+{ 
     2362+       return 0; 
     2363+} 
     2364+static inline void ssb_sdio_exit(struct ssb_bus *bus) 
     2365+{ 
     2366+} 
     2367+static inline int ssb_sdio_init(struct ssb_bus *bus) 
     2368+{ 
     2369+       return 0; 
     2370+} 
     2371+#endif /* CONFIG_SSB_SDIOHOST */ 
     2372+ 
     2373  
     2374 /* scan.c */ 
     2375 extern const char *ssb_core_name(u16 coreid); 
     2376@@ -136,19 +176,27 @@ extern const struct ssb_sprom *ssb_get_f 
     2377  
     2378 /* core.c */ 
     2379 extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
     2380-extern int ssb_devices_freeze(struct ssb_bus *bus); 
     2381-extern int ssb_devices_thaw(struct ssb_bus *bus); 
     2382 extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
     2383 int ssb_for_each_bus_call(unsigned long data, 
     2384                          int (*func)(struct ssb_bus *bus, unsigned long data)); 
     2385 extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev); 
     2386  
     2387+struct ssb_freeze_context { 
     2388+       /* Pointer to the bus */ 
     2389+       struct ssb_bus *bus; 
     2390+       /* Boolean list to indicate whether a device is frozen on this bus. */ 
     2391+       bool device_frozen[SSB_MAX_NR_CORES]; 
     2392+}; 
     2393+extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx); 
     2394+extern int ssb_devices_thaw(struct ssb_freeze_context *ctx); 
     2395+ 
     2396+ 
     2397  
     2398 /* b43_pci_bridge.c */ 
     2399 #ifdef CONFIG_SSB_B43_PCI_BRIDGE 
     2400 extern int __init b43_pci_ssb_bridge_init(void); 
     2401 extern void __exit b43_pci_ssb_bridge_exit(void); 
     2402-#else /* CONFIG_SSB_B43_PCI_BRIDGR */ 
     2403+#else /* CONFIG_SSB_B43_PCI_BRIDGE */ 
     2404 static inline int b43_pci_ssb_bridge_init(void) 
     2405 { 
     2406        return 0; 
     2407@@ -156,6 +204,6 @@ static inline int b43_pci_ssb_bridge_ini 
     2408 static inline void b43_pci_ssb_bridge_exit(void) 
     2409 { 
     2410 } 
     2411-#endif /* CONFIG_SSB_PCIHOST */ 
     2412+#endif /* CONFIG_SSB_B43_PCI_BRIDGE */ 
     2413  
     2414 #endif /* LINUX_SSB_PRIVATE_H_ */ 
     2415--- a/include/linux/pci_ids.h 
     2416+++ b/include/linux/pci_ids.h 
     2417@@ -2034,6 +2034,7 @@ 
     2418 #define PCI_DEVICE_ID_AFAVLAB_P030     0x2182 
     2419 #define PCI_SUBDEVICE_ID_AFAVLAB_P061          0x2150 
     2420  
     2421+#define PCI_VENDOR_ID_BCM_GVC          0x14a4 
     2422 #define PCI_VENDOR_ID_BROADCOM         0x14e4 
     2423 #define PCI_DEVICE_ID_TIGON3_5752      0x1600 
     2424 #define PCI_DEVICE_ID_TIGON3_5752M     0x1601 
    7312425--- a/include/linux/ssb/ssb.h 
    7322426+++ b/include/linux/ssb/ssb.h 
    733 @@ -27,24 +27,54 @@ struct ssb_sprom { 
     2427@@ -27,24 +27,58 @@ struct ssb_sprom { 
    7342428        u8 et1mdcport;          /* MDIO for enet1 */ 
    7352429        u8 board_rev;           /* Board revision number from SPROM. */ 
     
    7692463+       u8 tri5g;               /* 5.3GHz TX isolation */ 
    7702464+       u8 tri5gh;              /* 5.8GHz TX isolation */ 
     2465+       u8 txpid2g[4];          /* 2GHz TX power index */ 
     2466+       u8 txpid5gl[4];         /* 4.9 - 5.1GHz TX power index */ 
     2467+       u8 txpid5g[4];          /* 5.1 - 5.5GHz TX power index */ 
     2468+       u8 txpid5gh[4];         /* 5.5 - ...GHz TX power index */ 
    7712469+       u8 rxpo2g;              /* 2GHz RX power offset */ 
    7722470+       u8 rxpo5g;              /* 5GHz RX power offset */ 
     
    7922490        /* Antenna gain values for up to 4 antennas 
    7932491         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    794 @@ -58,7 +88,7 @@ struct ssb_sprom { 
     2492@@ -58,7 +92,7 @@ struct ssb_sprom { 
    7952493                } ghz5;         /* 5GHz band */ 
    7962494        } antenna_gain; 
     
    8012499  
    8022500 /* Information about the PCB the circuitry is soldered on. */ 
    803 @@ -208,6 +238,7 @@ enum ssb_bustype { 
     2501@@ -137,7 +171,7 @@ struct ssb_device { 
     2502         * is an optimization. */ 
     2503        const struct ssb_bus_ops *ops; 
     2504  
     2505-       struct device *dev; 
     2506+       struct device *dev, *dma_dev; 
     2507  
     2508        struct ssb_bus *bus; 
     2509        struct ssb_device_id id; 
     2510@@ -208,6 +242,7 @@ enum ssb_bustype { 
    8042511        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */ 
    8052512        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
     
    8092516  
    8102517 /* board_vendor */ 
    811 @@ -238,20 +269,33 @@ struct ssb_bus { 
     2518@@ -238,20 +273,33 @@ struct ssb_bus { 
    8122519  
    8132520        const struct ssb_bus_ops *ops; 
     
    8512558 #ifdef CONFIG_SSB_SPROM 
    8522559        /* Mutex to protect the SPROM writing. */ 
    853 @@ -261,6 +305,7 @@ struct ssb_bus { 
     2560@@ -261,6 +309,7 @@ struct ssb_bus { 
    8542561        /* ID information about the Chip. */ 
    8552562        u16 chip_id; 
     
    8592566        u8 chip_package; 
    8602567  
    861 @@ -306,6 +351,11 @@ struct ssb_bus { 
     2568@@ -306,6 +355,11 @@ struct ssb_bus { 
    8622569 #endif /* DEBUG */ 
    8632570 }; 
     
    8712578 struct ssb_init_invariants { 
    8722579        /* Versioning information about the PCB. */ 
    873 @@ -336,9 +386,18 @@ extern int ssb_bus_pcmciabus_register(st 
     2580@@ -336,9 +390,18 @@ extern int ssb_bus_pcmciabus_register(st 
    8742581                                      struct pcmcia_device *pcmcia_dev, 
    8752582                                      unsigned long baseaddr); 
     
    9532660--- a/include/linux/ssb/ssb_regs.h 
    9542661+++ b/include/linux/ssb/ssb_regs.h 
    955 @@ -162,7 +162,7 @@ 
     2662@@ -85,6 +85,8 @@ 
     2663 #define  SSB_IMSTATE_AP_RSV    0x00000030 /* Reserved */ 
     2664 #define  SSB_IMSTATE_IBE       0x00020000 /* In Band Error */ 
     2665 #define  SSB_IMSTATE_TO                0x00040000 /* Timeout */ 
     2666+#define  SSB_IMSTATE_BUSY      0x01800000 /* Busy (Backplane rev >= 2.3 only) */ 
     2667+#define  SSB_IMSTATE_REJECT    0x02000000 /* Reject (Backplane rev >= 2.3 only) */ 
     2668 #define SSB_INTVEC             0x0F94     /* SB Interrupt Mask */ 
     2669 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
     2670 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     2671@@ -162,7 +164,7 @@ 
    9562672  
    9572673 /* SPROM shadow area. If not otherwise noted, fields are 
     
    9622678 #define SSB_SPROMSIZE_WORDS            64 
    9632679 #define SSB_SPROMSIZE_BYTES            (SSB_SPROMSIZE_WORDS * sizeof(u16)) 
    964 @@ -170,26 +170,27 @@ 
     2680@@ -170,26 +172,27 @@ 
    9652681 #define SSB_SPROMSIZE_WORDS_R4         220 
    9662682 #define SSB_SPROMSIZE_BYTES_R123       (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16)) 
     
    10002716 #define  SSB_SPROM1_BINF_CCODE         0x0F00  /* Country Code */ 
    10012717 #define  SSB_SPROM1_BINF_CCODE_SHIFT   8 
    1002 @@ -197,63 +198,63 @@ 
     2718@@ -197,63 +200,63 @@ 
    10032719 #define  SSB_SPROM1_BINF_ANTBG_SHIFT   12 
    10042720 #define  SSB_SPROM1_BINF_ANTA          0xC000  /* Available A-PHY antennas */ 
     
    10922808 #define  SSB_SPROM3_CCKPO_2M           0x00F0  /* 2M Rate PO */ 
    10932809 #define  SSB_SPROM3_CCKPO_2M_SHIFT     4 
    1094 @@ -264,104 +265,156 @@ 
     2810@@ -264,104 +267,200 @@ 
    10952811 #define  SSB_SPROM3_OFDMGPO            0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */ 
    10962812  
     
    11002816+#define SSB_SPROM4_BFLLO               0x0044  /* Boardflags (low 16 bits) */ 
    11012817+#define SSB_SPROM4_BFLHI               0x0046  /* Board Flags Hi */ 
     2818+#define SSB_SPROM4_BFL2LO              0x0048  /* Board flags 2 (low 16 bits) */ 
     2819+#define SSB_SPROM4_BFL2HI              0x004A  /* Board flags 2 Hi */ 
    11022820+#define SSB_SPROM4_IL0MAC              0x004C  /* 6 byte MAC address for a/b/g/n */ 
    11032821+#define SSB_SPROM4_CCODE               0x0052  /* Country Code (2 bytes) */ 
     
    11422860-#define SSB_SPROM4_BFLHI               0x1046  /* Board Flags Hi */ 
    11432861-#define SSB_SPROM4_MAXP_BG             0x1080  /* Max Power BG in path 1 */ 
     2862+#define SSB_SPROM4_TXPID2G01           0x0062  /* TX Power Index 2GHz */ 
     2863+#define  SSB_SPROM4_TXPID2G0           0x00FF 
     2864+#define  SSB_SPROM4_TXPID2G0_SHIFT     0 
     2865+#define  SSB_SPROM4_TXPID2G1           0xFF00 
     2866+#define  SSB_SPROM4_TXPID2G1_SHIFT     8 
     2867+#define SSB_SPROM4_TXPID2G23           0x0064  /* TX Power Index 2GHz */ 
     2868+#define  SSB_SPROM4_TXPID2G2           0x00FF 
     2869+#define  SSB_SPROM4_TXPID2G2_SHIFT     0 
     2870+#define  SSB_SPROM4_TXPID2G3           0xFF00 
     2871+#define  SSB_SPROM4_TXPID2G3_SHIFT     8 
     2872+#define SSB_SPROM4_TXPID5G01           0x0066  /* TX Power Index 5GHz middle subband */ 
     2873+#define  SSB_SPROM4_TXPID5G0           0x00FF 
     2874+#define  SSB_SPROM4_TXPID5G0_SHIFT     0 
     2875+#define  SSB_SPROM4_TXPID5G1           0xFF00 
     2876+#define  SSB_SPROM4_TXPID5G1_SHIFT     8 
     2877+#define SSB_SPROM4_TXPID5G23           0x0068  /* TX Power Index 5GHz middle subband */ 
     2878+#define  SSB_SPROM4_TXPID5G2           0x00FF 
     2879+#define  SSB_SPROM4_TXPID5G2_SHIFT     0 
     2880+#define  SSB_SPROM4_TXPID5G3           0xFF00 
     2881+#define  SSB_SPROM4_TXPID5G3_SHIFT     8 
     2882+#define SSB_SPROM4_TXPID5GL01          0x006A  /* TX Power Index 5GHz low subband */ 
     2883+#define  SSB_SPROM4_TXPID5GL0          0x00FF 
     2884+#define  SSB_SPROM4_TXPID5GL0_SHIFT    0 
     2885+#define  SSB_SPROM4_TXPID5GL1          0xFF00 
     2886+#define  SSB_SPROM4_TXPID5GL1_SHIFT    8 
     2887+#define SSB_SPROM4_TXPID5GL23          0x006C  /* TX Power Index 5GHz low subband */ 
     2888+#define  SSB_SPROM4_TXPID5GL2          0x00FF 
     2889+#define  SSB_SPROM4_TXPID5GL2_SHIFT    0 
     2890+#define  SSB_SPROM4_TXPID5GL3          0xFF00 
     2891+#define  SSB_SPROM4_TXPID5GL3_SHIFT    8 
     2892+#define SSB_SPROM4_TXPID5GH01          0x006E  /* TX Power Index 5GHz high subband */ 
     2893+#define  SSB_SPROM4_TXPID5GH0          0x00FF 
     2894+#define  SSB_SPROM4_TXPID5GH0_SHIFT    0 
     2895+#define  SSB_SPROM4_TXPID5GH1          0xFF00 
     2896+#define  SSB_SPROM4_TXPID5GH1_SHIFT    8 
     2897+#define SSB_SPROM4_TXPID5GH23          0x0070  /* TX Power Index 5GHz high subband */ 
     2898+#define  SSB_SPROM4_TXPID5GH2          0x00FF 
     2899+#define  SSB_SPROM4_TXPID5GH2_SHIFT    0 
     2900+#define  SSB_SPROM4_TXPID5GH3          0xFF00 
     2901+#define  SSB_SPROM4_TXPID5GH3_SHIFT    8 
    11442902+#define SSB_SPROM4_MAXP_BG             0x0080  /* Max Power BG in path 1 */ 
    11452903 #define  SSB_SPROM4_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */ 
     
    11812939+#define SSB_SPROM5_BFLLO               0x004A  /* Boardflags (low 16 bits) */ 
    11822940+#define SSB_SPROM5_BFLHI               0x004C  /* Board Flags Hi */ 
     2941+#define SSB_SPROM5_BFL2LO              0x004E  /* Board flags 2 (low 16 bits) */ 
     2942+#define SSB_SPROM5_BFL2HI              0x0050  /* Board flags 2 Hi */ 
    11832943+#define SSB_SPROM5_IL0MAC              0x0052  /* 6 byte MAC address for a/b/g/n */ 
    11842944+#define SSB_SPROM5_GPIOA               0x0076  /* Gen. Purpose IO # 0 and 1 */ 
     
    13063066 /* Values for SSB_SPROM1_BINF_CCODE */ 
    13073067 enum { 
    1308 --- a/drivers/ssb/scan.c 
    1309 +++ b/drivers/ssb/scan.c 
    1310 @@ -162,6 +162,8 @@ static u8 chipid_to_nrcores(u16 chipid) 
    1311  static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx, 
    1312                        u16 offset) 
    1313  { 
    1314 +       u32 lo, hi; 
    1315 + 
    1316         switch (bus->bustype) { 
    1317         case SSB_BUSTYPE_SSB: 
    1318                 offset += current_coreidx * SSB_CORE_SIZE; 
    1319 @@ -174,6 +176,10 @@ static u32 scan_read32(struct ssb_bus *b 
    1320                         offset -= 0x800; 
    1321                 } else 
    1322                         ssb_pcmcia_switch_segment(bus, 0); 
    1323 +               lo = readw(bus->mmio + offset); 
    1324 +               hi = readw(bus->mmio + offset + 2); 
    1325 +               return lo | (hi << 16); 
    1326 +       default: 
    1327                 break; 
    1328         } 
    1329         return readl(bus->mmio + offset); 
    1330 @@ -188,6 +194,8 @@ static int scan_switchcore(struct ssb_bu 
    1331                 return ssb_pci_switch_coreidx(bus, coreidx); 
    1332         case SSB_BUSTYPE_PCMCIA: 
    1333                 return ssb_pcmcia_switch_coreidx(bus, coreidx); 
    1334 +       default: 
    1335 +               break; 
    1336         } 
    1337         return 0; 
    1338  } 
    1339 @@ -206,6 +214,8 @@ void ssb_iounmap(struct ssb_bus *bus) 
    1340                 SSB_BUG_ON(1); /* Can't reach this code. */ 
    1341  #endif 
    1342                 break; 
    1343 +       default: 
    1344 +               break; 
    1345         } 
    1346         bus->mmio = NULL; 
    1347         bus->mapped_device = NULL; 
    1348 @@ -230,6 +240,8 @@ static void __iomem *ssb_ioremap(struct  
    1349                 SSB_BUG_ON(1); /* Can't reach this code. */ 
    1350  #endif 
    1351                 break; 
    1352 +       default: 
    1353 +               break; 
    1354         } 
    1355   
    1356         return mmio; 
    1357 @@ -339,7 +351,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    1358                 dev->bus = bus; 
    1359                 dev->ops = bus->ops; 
    1360   
    1361 -               ssb_dprintk(KERN_INFO PFX 
    1362 +               printk(KERN_DEBUG PFX 
    1363                             "Core %d found: %s " 
    1364                             "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    1365                             i, ssb_core_name(dev->id.coreid), 
    1366 --- a/drivers/ssb/driver_chipcommon.c 
    1367 +++ b/drivers/ssb/driver_chipcommon.c 
    1368 @@ -233,6 +233,8 @@ void ssb_chipcommon_init(struct ssb_chip 
    1369  { 
    1370         if (!cc->dev) 
    1371                 return; /* We don't have a ChipCommon */ 
    1372 +       if (cc->dev->id.revision >= 11) 
    1373 +               cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    1374         ssb_pmu_init(cc); 
    1375         chipco_powercontrol_init(cc); 
    1376         ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    1377 @@ -370,6 +372,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
    1378  { 
    1379         return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
    1380  } 
    1381 +EXPORT_SYMBOL(ssb_chipco_gpio_control); 
    1382   
    1383  u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value) 
    1384  { 
    1385 --- a/drivers/ssb/driver_mipscore.c 
    1386 +++ b/drivers/ssb/driver_mipscore.c 
    1387 @@ -49,29 +49,54 @@ static const u32 ipsflag_irq_shift[] = { 
    1388   
    1389  static inline u32 ssb_irqflag(struct ssb_device *dev) 
    1390  { 
    1391 -       return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
    1392 +       u32 tpsflag = ssb_read32(dev, SSB_TPSFLAG); 
    1393 +       if (tpsflag) 
    1394 +               return ssb_read32(dev, SSB_TPSFLAG) & SSB_TPSFLAG_BPFLAG; 
    1395 +       else 
    1396 +               /* not irq supported */ 
    1397 +               return 0x3f; 
    1398 +} 
    1399 + 
    1400 +static struct ssb_device *find_device(struct ssb_device *rdev, int irqflag) 
    1401 +{ 
    1402 +       struct ssb_bus *bus = rdev->bus; 
    1403 +       int i; 
    1404 +       for (i = 0; i < bus->nr_devices; i++) { 
    1405 +               struct ssb_device *dev; 
    1406 +               dev = &(bus->devices[i]); 
    1407 +               if (ssb_irqflag(dev) == irqflag) 
    1408 +                       return dev; 
    1409 +       } 
    1410 +       return NULL; 
    1411  } 
    1412   
    1413  /* Get the MIPS IRQ assignment for a specified device. 
    1414   * If unassigned, 0 is returned. 
    1415 + * If disabled, 5 is returned. 
    1416 + * If not supported, 6 is returned. 
    1417   */ 
    1418  unsigned int ssb_mips_irq(struct ssb_device *dev) 
    1419  { 
    1420         struct ssb_bus *bus = dev->bus; 
    1421 +       struct ssb_device *mdev = bus->mipscore.dev; 
    1422         u32 irqflag; 
    1423         u32 ipsflag; 
    1424         u32 tmp; 
    1425         unsigned int irq; 
    1426   
    1427         irqflag = ssb_irqflag(dev); 
    1428 +       if (irqflag == 0x3f) 
    1429 +               return 6; 
    1430         ipsflag = ssb_read32(bus->mipscore.dev, SSB_IPSFLAG); 
    1431         for (irq = 1; irq <= 4; irq++) { 
    1432                 tmp = ((ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]); 
    1433                 if (tmp == irqflag) 
    1434                         break; 
    1435         } 
    1436 -       if (irq == 5) 
    1437 -               irq = 0; 
    1438 +       if (irq == 5) { 
    1439 +               if ((1 << irqflag) & ssb_read32(mdev, SSB_INTVEC)) 
    1440 +                       irq = 0; 
    1441 +       } 
    1442   
    1443         return irq; 
    1444  } 
    1445 @@ -97,25 +122,56 @@ static void set_irq(struct ssb_device *d 
    1446         struct ssb_device *mdev = bus->mipscore.dev; 
    1447         u32 irqflag = ssb_irqflag(dev); 
    1448   
    1449 +       BUG_ON(oldirq == 6); 
    1450 + 
    1451         dev->irq = irq + 2; 
    1452   
    1453 -       ssb_dprintk(KERN_INFO PFX 
    1454 -                   "set_irq: core 0x%04x, irq %d => %d\n", 
    1455 -                   dev->id.coreid, oldirq, irq); 
    1456         /* clear the old irq */ 
    1457         if (oldirq == 0) 
    1458                 ssb_write32(mdev, SSB_INTVEC, (~(1 << irqflag) & ssb_read32(mdev, SSB_INTVEC))); 
    1459 -       else 
    1460 +       else if (oldirq != 5) 
    1461                 clear_irq(bus, oldirq); 
    1462   
    1463         /* assign the new one */ 
    1464         if (irq == 0) { 
    1465                 ssb_write32(mdev, SSB_INTVEC, ((1 << irqflag) | ssb_read32(mdev, SSB_INTVEC))); 
    1466         } else { 
    1467 +               u32 ipsflag = ssb_read32(mdev, SSB_IPSFLAG); 
    1468 +               if ((ipsflag & ipsflag_irq_mask[irq]) != ipsflag_irq_mask[irq]) { 
    1469 +                       u32 oldipsflag = (ipsflag & ipsflag_irq_mask[irq]) >> ipsflag_irq_shift[irq]; 
    1470 +                       struct ssb_device *olddev = find_device(dev, oldipsflag); 
    1471 +                       if (olddev) 
    1472 +                               set_irq(olddev, 0); 
    1473 +               } 
    1474                 irqflag <<= ipsflag_irq_shift[irq]; 
    1475 -               irqflag |= (ssb_read32(mdev, SSB_IPSFLAG) & ~ipsflag_irq_mask[irq]); 
    1476 +               irqflag |= (ipsflag & ~ipsflag_irq_mask[irq]); 
    1477                 ssb_write32(mdev, SSB_IPSFLAG, irqflag); 
    1478         } 
    1479 +       ssb_dprintk(KERN_INFO PFX 
    1480 +                   "set_irq: core 0x%04x, irq %d => %d\n", 
    1481 +                   dev->id.coreid, oldirq+2, irq+2); 
    1482 +} 
    1483 + 
    1484 +static void print_irq(struct ssb_device *dev, unsigned int irq) 
    1485 +{ 
    1486 +       int i; 
    1487 +       static const char *irq_name[] = {"2(S)", "3", "4", "5", "6", "D", "I"}; 
    1488 +       ssb_dprintk(KERN_INFO PFX 
    1489 +               "core 0x%04x, irq :", dev->id.coreid); 
    1490 +       for (i = 0; i <= 6; i++) { 
    1491 +               ssb_dprintk(" %s%s", irq_name[i], i==irq?"*":" "); 
    1492 +       } 
    1493 +       ssb_dprintk("\n"); 
    1494 +} 
    1495 + 
    1496 +static void dump_irq(struct ssb_bus *bus) 
    1497 +{ 
    1498 +       int i; 
    1499 +       for (i = 0; i < bus->nr_devices; i++) { 
    1500 +               struct ssb_device *dev; 
    1501 +               dev = &(bus->devices[i]); 
    1502 +               print_irq(dev, ssb_mips_irq(dev)); 
    1503 +       } 
    1504  } 
    1505   
    1506  static void ssb_mips_serial_init(struct ssb_mipscore *mcore) 
    1507 @@ -197,17 +253,23 @@ void ssb_mipscore_init(struct ssb_mipsco 
    1508   
    1509         /* Assign IRQs to all cores on the bus, start with irq line 2, because serial usually takes 1 */ 
    1510         for (irq = 2, i = 0; i < bus->nr_devices; i++) { 
    1511 +               int mips_irq; 
    1512                 dev = &(bus->devices[i]); 
    1513 -               dev->irq = ssb_mips_irq(dev) + 2; 
    1514 +               mips_irq = ssb_mips_irq(dev); 
    1515 +               if (mips_irq > 4) 
    1516 +                       dev->irq = 0; 
    1517 +               else 
    1518 +                       dev->irq = mips_irq + 2; 
    1519 +               if (dev->irq > 5) 
    1520 +                       continue; 
    1521                 switch (dev->id.coreid) { 
    1522                 case SSB_DEV_USB11_HOST: 
    1523                         /* shouldn't need a separate irq line for non-4710, most of them have a proper 
    1524                          * external usb controller on the pci */ 
    1525                         if ((bus->chip_id == 0x4710) && (irq <= 4)) { 
    1526                                 set_irq(dev, irq++); 
    1527 -                               break; 
    1528                         } 
    1529 -                       /* fallthrough */ 
    1530 +                       break; 
    1531                 case SSB_DEV_PCI: 
    1532                 case SSB_DEV_ETHERNET: 
    1533                 case SSB_DEV_ETHERNET_GBIT: 
    1534 @@ -218,8 +280,14 @@ void ssb_mipscore_init(struct ssb_mipsco 
    1535                                 set_irq(dev, irq++); 
    1536                                 break; 
    1537                         } 
    1538 +                       /* fallthrough */ 
    1539 +               case SSB_DEV_EXTIF: 
    1540 +                       set_irq(dev, 0); 
    1541 +                       break; 
    1542                 } 
    1543         } 
    1544 +       ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n"); 
    1545 +       dump_irq(bus); 
    1546   
    1547         ssb_mips_serial_init(mcore); 
    1548         ssb_mips_flash_detect(mcore); 
    1549 --- a/drivers/ssb/sprom.c 
    1550 +++ b/drivers/ssb/sprom.c 
    1551 @@ -13,6 +13,9 @@ 
    1552   
    1553  #include "ssb_private.h" 
    1554   
    1555 +#include <linux/ctype.h> 
    1556 +#include <linux/slab.h> 
    1557 + 
    1558   
    1559  static const struct ssb_sprom *fallback_sprom; 
    1560   
    1561 @@ -33,17 +36,27 @@ static int sprom2hex(const u16 *sprom, c 
    1562  static int hex2sprom(u16 *sprom, const char *dump, size_t len, 
    1563                      size_t sprom_size_words) 
    1564  { 
    1565 -       char tmp[5] = { 0 }; 
    1566 -       int cnt = 0; 
    1567 +       char c, tmp[5] = { 0 }; 
    1568 +       int err, cnt = 0; 
    1569         unsigned long parsed; 
    1570   
    1571 -       if (len < sprom_size_words * 2) 
    1572 +       /* Strip whitespace at the end. */ 
    1573 +       while (len) { 
    1574 +               c = dump[len - 1]; 
    1575 +               if (!isspace(c) && c != '\0') 
    1576 +                       break; 
    1577 +               len--; 
    1578 +       } 
    1579 +       /* Length must match exactly. */ 
    1580 +       if (len != sprom_size_words * 4) 
    1581                 return -EINVAL; 
    1582   
    1583         while (cnt < sprom_size_words) { 
    1584                 memcpy(tmp, dump, 4); 
    1585                 dump += 4; 
    1586 -               parsed = simple_strtoul(tmp, NULL, 16); 
    1587 +               err = strict_strtoul(tmp, 16, &parsed); 
    1588 +               if (err) 
    1589 +                       return err; 
    1590                 sprom[cnt++] = swab16((u16)parsed); 
    1591         } 
    1592   
    1593 @@ -90,6 +103,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
    1594         u16 *sprom; 
    1595         int res = 0, err = -ENOMEM; 
    1596         size_t sprom_size_words = bus->sprom_size; 
    1597 +       struct ssb_freeze_context freeze; 
    1598   
    1599         sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 
    1600         if (!sprom) 
    1601 @@ -111,18 +125,13 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
    1602         err = -ERESTARTSYS; 
    1603         if (mutex_lock_interruptible(&bus->sprom_mutex)) 
    1604                 goto out_kfree; 
    1605 -       err = ssb_devices_freeze(bus); 
    1606 -       if (err == -EOPNOTSUPP) { 
    1607 -               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
    1608 -                          "No suspend support. Is CONFIG_PM enabled?\n"); 
    1609 -               goto out_unlock; 
    1610 -       } 
    1611 +       err = ssb_devices_freeze(bus, &freeze); 
    1612         if (err) { 
    1613                 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
    1614                 goto out_unlock; 
    1615         } 
    1616         res = sprom_write(bus, sprom); 
    1617 -       err = ssb_devices_thaw(bus); 
    1618 +       err = ssb_devices_thaw(&freeze); 
    1619         if (err) 
    1620                 ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    1621  out_unlock: 
    1622 @@ -167,3 +176,17 @@ const struct ssb_sprom *ssb_get_fallback 
    1623  { 
    1624         return fallback_sprom; 
    1625  } 
    1626 + 
    1627 +/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
    1628 +bool ssb_is_sprom_available(struct ssb_bus *bus) 
    1629 +{ 
    1630 +       /* status register only exists on chipcomon rev >= 11 and we need check 
    1631 +          for >= 31 only */ 
    1632 +       /* this routine differs from specs as we do not access SPROM directly 
    1633 +          on PCMCIA */ 
    1634 +       if (bus->bustype == SSB_BUSTYPE_PCI && 
    1635 +           bus->chipco.dev->id.revision >= 31) 
    1636 +               return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
    1637 + 
    1638 +       return true; 
    1639 +} 
    1640 --- a/drivers/ssb/ssb_private.h 
    1641 +++ b/drivers/ssb/ssb_private.h 
    1642 @@ -136,19 +136,27 @@ extern const struct ssb_sprom *ssb_get_f 
    1643   
    1644  /* core.c */ 
    1645  extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
    1646 -extern int ssb_devices_freeze(struct ssb_bus *bus); 
    1647 -extern int ssb_devices_thaw(struct ssb_bus *bus); 
    1648  extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
    1649  int ssb_for_each_bus_call(unsigned long data, 
    1650                           int (*func)(struct ssb_bus *bus, unsigned long data)); 
    1651  extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev); 
    1652   
    1653 +struct ssb_freeze_context { 
    1654 +       /* Pointer to the bus */ 
    1655 +       struct ssb_bus *bus; 
    1656 +       /* Boolean list to indicate whether a device is frozen on this bus. */ 
    1657 +       bool device_frozen[SSB_MAX_NR_CORES]; 
    1658 +}; 
    1659 +extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx); 
    1660 +extern int ssb_devices_thaw(struct ssb_freeze_context *ctx); 
    1661 + 
    1662 + 
    1663   
    1664  /* b43_pci_bridge.c */ 
    1665  #ifdef CONFIG_SSB_B43_PCI_BRIDGE 
    1666  extern int __init b43_pci_ssb_bridge_init(void); 
    1667  extern void __exit b43_pci_ssb_bridge_exit(void); 
    1668 -#else /* CONFIG_SSB_B43_PCI_BRIDGR */ 
    1669 +#else /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    1670  static inline int b43_pci_ssb_bridge_init(void) 
    1671  { 
    1672         return 0; 
    1673 @@ -156,6 +164,6 @@ static inline int b43_pci_ssb_bridge_ini 
    1674  static inline void b43_pci_ssb_bridge_exit(void) 
    1675  { 
    1676  } 
    1677 -#endif /* CONFIG_SSB_PCIHOST */ 
    1678 +#endif /* CONFIG_SSB_B43_PCI_BRIDGE */ 
    1679   
    1680  #endif /* LINUX_SSB_PRIVATE_H_ */ 
  • trunk/target/linux/generic/patches-2.6.31/941-ssb_update.patch

    r21952 r26127  
     1--- a/drivers/ssb/Kconfig 
     2+++ b/drivers/ssb/Kconfig 
     3@@ -66,6 +66,20 @@ config SSB_PCMCIAHOST 
     4  
     5          If unsure, say N 
     6  
     7+config SSB_SDIOHOST_POSSIBLE 
     8+       bool 
     9+       depends on SSB && (MMC = y || MMC = SSB) 
     10+       default y 
     11+ 
     12+config SSB_SDIOHOST 
     13+       bool "Support for SSB on SDIO-bus host" 
     14+       depends on SSB_SDIOHOST_POSSIBLE 
     15+       help 
     16+         Support for a Sonics Silicon Backplane on top 
     17+         of a SDIO device. 
     18+ 
     19+         If unsure, say N 
     20+ 
     21 config SSB_SILENT 
     22        bool "No SSB kernel messages" 
     23        depends on SSB && EMBEDDED 
     24--- a/drivers/ssb/Makefile 
     25+++ b/drivers/ssb/Makefile 
     26@@ -6,6 +6,7 @@ ssb-$(CONFIG_SSB_SPROM)                 += sprom.o 
     27 # host support 
     28 ssb-$(CONFIG_SSB_PCIHOST)              += pci.o pcihost_wrapper.o 
     29 ssb-$(CONFIG_SSB_PCMCIAHOST)           += pcmcia.o 
     30+ssb-$(CONFIG_SSB_SDIOHOST)             += sdio.o 
     31  
     32 # built-in drivers 
     33 ssb-y                                  += driver_chipcommon.o 
     34--- a/drivers/ssb/b43_pci_bridge.c 
     35+++ b/drivers/ssb/b43_pci_bridge.c 
     36@@ -24,6 +24,7 @@ static const struct pci_device_id b43_pc 
     37        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4312) }, 
     38        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4315) }, 
     39        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4318) }, 
     40+       { PCI_DEVICE(PCI_VENDOR_ID_BCM_GVC,  0x4318) }, 
     41        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4319) }, 
     42        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4320) }, 
     43        { PCI_DEVICE(PCI_VENDOR_ID_BROADCOM, 0x4321) }, 
     44--- a/drivers/ssb/driver_chipcommon.c 
     45+++ b/drivers/ssb/driver_chipcommon.c 
     46@@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     47        } 
     48 } 
     49  
     50+/* http://bcm-v4.sipsolutions.net/802.11/PmuFastPwrupDelay */ 
     51+static u16 pmu_fast_powerup_delay(struct ssb_chipcommon *cc) 
     52+{ 
     53+       struct ssb_bus *bus = cc->dev->bus; 
     54+ 
     55+       switch (bus->chip_id) { 
     56+       case 0x4312: 
     57+       case 0x4322: 
     58+       case 0x4328: 
     59+               return 7000; 
     60+       case 0x4325: 
     61+               /* TODO: */ 
     62+       default: 
     63+               return 15000; 
     64+       } 
     65+} 
     66+ 
     67+/* http://bcm-v4.sipsolutions.net/802.11/ClkctlFastPwrupDelay */ 
     68 static void calc_fast_powerup_delay(struct ssb_chipcommon *cc) 
     69 { 
     70        struct ssb_bus *bus = cc->dev->bus; 
     71@@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     72  
     73        if (bus->bustype != SSB_BUSTYPE_PCI) 
     74                return; 
     75+ 
     76+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) { 
     77+               cc->fast_pwrup_delay = pmu_fast_powerup_delay(cc); 
     78+               return; 
     79+       } 
     80+ 
     81        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     82                return; 
     83  
     84@@ -233,6 +257,9 @@ void ssb_chipcommon_init(struct ssb_chip 
     85 { 
     86        if (!cc->dev) 
     87                return; /* We don't have a ChipCommon */ 
     88+       if (cc->dev->id.revision >= 11) 
     89+               cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
     90+       ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     91        ssb_pmu_init(cc); 
     92        chipco_powercontrol_init(cc); 
     93        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
     94@@ -370,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     95 { 
     96        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     97 } 
     98+EXPORT_SYMBOL(ssb_chipco_gpio_control); 
     99  
     100 u32 ssb_chipco_gpio_intmask(struct ssb_chipcommon *cc, u32 mask, u32 value) 
     101 { 
    1102--- a/drivers/ssb/driver_chipcommon_pmu.c 
    2103+++ b/drivers/ssb/driver_chipcommon_pmu.c 
     
    23124        u16 freq;       /* Crystal frequency in kHz.*/ 
    24125        u8 xf;          /* Crystal frequency value for PMU control */ 
    25 @@ -506,3 +521,82 @@ void ssb_pmu_init(struct ssb_chipcommon 
     126@@ -317,6 +332,12 @@ static void ssb_pmu_pll_init(struct ssb_ 
     127        case 0x5354: 
     128                ssb_pmu0_pllinit_r0(cc, crystalfreq); 
     129                break; 
     130+       case 0x4322: 
     131+               if (cc->pmu.rev == 2) { 
     132+                       chipco_write32(cc, SSB_CHIPCO_PLLCTL_ADDR, 0x0000000A); 
     133+                       chipco_write32(cc, SSB_CHIPCO_PLLCTL_DATA, 0x380005C0); 
     134+               } 
     135+               break; 
     136        default: 
     137                ssb_printk(KERN_ERR PFX 
     138                           "ERROR: PLL init unknown for device %04X\n", 
     139@@ -402,6 +423,7 @@ static void ssb_pmu_resources_init(struc 
     140  
     141        switch (bus->chip_id) { 
     142        case 0x4312: 
     143+       case 0x4322: 
     144                /* We keep the default settings: 
     145                 * min_msk = 0xCBB 
     146                 * max_msk = 0x7FFFF 
     147@@ -480,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     148                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
     149 } 
     150  
     151+/* http://bcm-v4.sipsolutions.net/802.11/SSB/PmuInit */ 
     152 void ssb_pmu_init(struct ssb_chipcommon *cc) 
     153 { 
     154-       struct ssb_bus *bus = cc->dev->bus; 
     155        u32 pmucap; 
     156  
     157        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
     158@@ -494,15 +516,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
     159        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
     160                    cc->pmu.rev, pmucap); 
     161  
     162-       if (cc->pmu.rev >= 1) { 
     163-               if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) { 
     164-                       chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     165-                                     ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     166-               } else { 
     167-                       chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     168-                                    SSB_CHIPCO_PMU_CTL_NOILPONW); 
     169-               } 
     170-       } 
     171+       if (cc->pmu.rev == 1) 
     172+               chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     173+                             ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     174+       else 
     175+               chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     176+                            SSB_CHIPCO_PMU_CTL_NOILPONW); 
    26177        ssb_pmu_pll_init(cc); 
    27178        ssb_pmu_resources_init(cc); 
     
    106257+EXPORT_SYMBOL(ssb_pmu_set_ldo_voltage); 
    107258+EXPORT_SYMBOL(ssb_pmu_set_ldo_paref); 
     259--- a/drivers/ssb/driver_gige.c 
     260+++ b/drivers/ssb/driver_gige.c 
     261@@ -12,6 +12,7 @@ 
     262 #include <linux/ssb/ssb_driver_gige.h> 
     263 #include <linux/pci.h> 
     264 #include <linux/pci_regs.h> 
     265+#include <linux/slab.h> 
     266  
     267  
     268 /* 
     269--- a/drivers/ssb/driver_mipscore.c 
     270+++ b/drivers/ssb/driver_mipscore.c 
     271@@ -270,7 +270,6 @@ void ssb_mipscore_init(struct ssb_mipsco 
     272                                set_irq(dev, irq++); 
     273                        } 
     274                        break; 
     275-                       /* fallthrough */ 
     276                case SSB_DEV_PCI: 
     277                case SSB_DEV_ETHERNET: 
     278                case SSB_DEV_ETHERNET_GBIT: 
     279@@ -281,6 +280,10 @@ void ssb_mipscore_init(struct ssb_mipsco 
     280                                set_irq(dev, irq++); 
     281                                break; 
     282                        } 
     283+                       /* fallthrough */ 
     284+               case SSB_DEV_EXTIF: 
     285+                       set_irq(dev, 0); 
     286+                       break; 
     287                } 
     288        } 
     289        ssb_dprintk(KERN_INFO PFX "after irq reconfiguration\n"); 
     290--- a/drivers/ssb/driver_pcicore.c 
     291+++ b/drivers/ssb/driver_pcicore.c 
     292@@ -246,20 +246,12 @@ static struct pci_controller ssb_pcicore 
     293        .pci_ops        = &ssb_pcicore_pciops, 
     294        .io_resource    = &ssb_pcicore_io_resource, 
     295        .mem_resource   = &ssb_pcicore_mem_resource, 
     296-       .mem_offset     = 0x24000000, 
     297 }; 
     298  
     299-static u32 ssb_pcicore_pcibus_iobase = 0x100; 
     300-static u32 ssb_pcicore_pcibus_membase = SSB_PCI_DMA; 
     301- 
     302 /* This function is called when doing a pci_enable_device(). 
     303  * We must first check if the device is a device on the PCI-core bridge. */ 
     304 int ssb_pcicore_plat_dev_init(struct pci_dev *d) 
     305 { 
     306-       struct resource *res; 
     307-       int pos, size; 
     308-       u32 *base; 
     309- 
     310        if (d->bus->ops != &ssb_pcicore_pciops) { 
     311                /* This is not a device on the PCI-core bridge. */ 
     312                return -ENODEV; 
     313@@ -268,27 +260,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
     314        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
     315                   pci_name(d)); 
     316  
     317-       /* Fix up resource bases */ 
     318-       for (pos = 0; pos < 6; pos++) { 
     319-               res = &d->resource[pos]; 
     320-               if (res->flags & IORESOURCE_IO) 
     321-                       base = &ssb_pcicore_pcibus_iobase; 
     322-               else 
     323-                       base = &ssb_pcicore_pcibus_membase; 
     324-               res->flags |= IORESOURCE_PCI_FIXED; 
     325-               if (res->end) { 
     326-                       size = res->end - res->start + 1; 
     327-                       if (*base & (size - 1)) 
     328-                               *base = (*base + size) & ~(size - 1); 
     329-                       res->start = *base; 
     330-                       res->end = res->start + size - 1; 
     331-                       *base += size; 
     332-                       pci_write_config_dword(d, PCI_BASE_ADDRESS_0 + (pos << 2), res->start); 
     333-               } 
     334-               /* Fix up PCI bridge BAR0 only */ 
     335-               if (d->bus->number == 0 && PCI_SLOT(d->devfn) == 0) 
     336-                       break; 
     337-       } 
     338        /* Fix up interrupt lines */ 
     339        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
     340        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
     341@@ -551,13 +522,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     342        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
     343  
     344        /* Enable interrupts for this device. */ 
     345-       if (bus->host_pci && 
     346-           ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) { 
     347+       if ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE)) { 
     348                u32 coremask; 
     349  
     350                /* Calculate the "coremask" for the device. */ 
     351                coremask = (1 << dev->core_index); 
     352  
     353+               SSB_WARN_ON(bus->bustype != SSB_BUSTYPE_PCI); 
     354                err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp); 
     355                if (err) 
     356                        goto out; 
    108357--- a/drivers/ssb/main.c 
    109358+++ b/drivers/ssb/main.c 
    110 @@ -469,6 +469,8 @@ static int ssb_devices_register(struct s 
     359@@ -17,6 +17,8 @@ 
     360 #include <linux/ssb/ssb_driver_gige.h> 
     361 #include <linux/dma-mapping.h> 
     362 #include <linux/pci.h> 
     363+#include <linux/mmc/sdio_func.h> 
     364+#include <linux/slab.h> 
     365  
     366 #include <pcmcia/cs_types.h> 
     367 #include <pcmcia/cs.h> 
     368@@ -88,6 +90,25 @@ found: 
     369 } 
     370 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     371  
     372+#ifdef CONFIG_SSB_SDIOHOST 
     373+struct ssb_bus *ssb_sdio_func_to_bus(struct sdio_func *func) 
     374+{ 
     375+       struct ssb_bus *bus; 
     376+ 
     377+       ssb_buses_lock(); 
     378+       list_for_each_entry(bus, &buses, list) { 
     379+               if (bus->bustype == SSB_BUSTYPE_SDIO && 
     380+                   bus->host_sdio == func) 
     381+                       goto found; 
     382+       } 
     383+       bus = NULL; 
     384+found: 
     385+       ssb_buses_unlock(); 
     386+ 
     387+       return bus; 
     388+} 
     389+#endif /* CONFIG_SSB_SDIOHOST */ 
     390+ 
     391 int ssb_for_each_bus_call(unsigned long data, 
     392                          int (*func)(struct ssb_bus *bus, unsigned long data)) 
     393 { 
     394@@ -120,6 +141,19 @@ static void ssb_device_put(struct ssb_de 
     395                put_device(dev->dev); 
     396 } 
     397  
     398+static inline struct ssb_driver *ssb_driver_get(struct ssb_driver *drv) 
     399+{ 
     400+       if (drv) 
     401+               get_driver(&drv->drv); 
     402+       return drv; 
     403+} 
     404+ 
     405+static inline void ssb_driver_put(struct ssb_driver *drv) 
     406+{ 
     407+       if (drv) 
     408+               put_driver(&drv->drv); 
     409+} 
     410+ 
     411 static int ssb_device_resume(struct device *dev) 
     412 { 
     413        struct ssb_device *ssb_dev = dev_to_ssb_dev(dev); 
     414@@ -190,90 +224,81 @@ int ssb_bus_suspend(struct ssb_bus *bus) 
     415 EXPORT_SYMBOL(ssb_bus_suspend); 
     416  
     417 #ifdef CONFIG_SSB_SPROM 
     418-int ssb_devices_freeze(struct ssb_bus *bus) 
     419+/** ssb_devices_freeze - Freeze all devices on the bus. 
     420+ * 
     421+ * After freezing no device driver will be handling a device 
     422+ * on this bus anymore. ssb_devices_thaw() must be called after 
     423+ * a successful freeze to reactivate the devices. 
     424+ * 
     425+ * @bus: The bus. 
     426+ * @ctx: Context structure. Pass this to ssb_devices_thaw(). 
     427+ */ 
     428+int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx) 
     429 { 
     430-       struct ssb_device *dev; 
     431-       struct ssb_driver *drv; 
     432-       int err = 0; 
     433-       int i; 
     434-       pm_message_t state = PMSG_FREEZE; 
     435+       struct ssb_device *sdev; 
     436+       struct ssb_driver *sdrv; 
     437+       unsigned int i; 
     438+ 
     439+       memset(ctx, 0, sizeof(*ctx)); 
     440+       ctx->bus = bus; 
     441+       SSB_WARN_ON(bus->nr_devices > ARRAY_SIZE(ctx->device_frozen)); 
     442  
     443-       /* First check that we are capable to freeze all devices. */ 
     444        for (i = 0; i < bus->nr_devices; i++) { 
     445-               dev = &(bus->devices[i]); 
     446-               if (!dev->dev || 
     447-                   !dev->dev->driver || 
     448-                   !device_is_registered(dev->dev)) 
     449-                       continue; 
     450-               drv = drv_to_ssb_drv(dev->dev->driver); 
     451-               if (!drv) 
     452+               sdev = ssb_device_get(&bus->devices[i]); 
     453+ 
     454+               if (!sdev->dev || !sdev->dev->driver || 
     455+                   !device_is_registered(sdev->dev)) { 
     456+                       ssb_device_put(sdev); 
     457                        continue; 
     458-               if (!drv->suspend) { 
     459-                       /* Nope, can't suspend this one. */ 
     460-                       return -EOPNOTSUPP; 
     461                } 
     462-       } 
     463-       /* Now suspend all devices */ 
     464-       for (i = 0; i < bus->nr_devices; i++) { 
     465-               dev = &(bus->devices[i]); 
     466-               if (!dev->dev || 
     467-                   !dev->dev->driver || 
     468-                   !device_is_registered(dev->dev)) 
     469+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
     470+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
     471+                       ssb_device_put(sdev); 
     472                        continue; 
     473-               drv = drv_to_ssb_drv(dev->dev->driver); 
     474-               if (!drv) 
     475-                       continue; 
     476-               err = drv->suspend(dev, state); 
     477-               if (err) { 
     478-                       ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n", 
     479-                                  dev_name(dev->dev)); 
     480-                       goto err_unwind; 
     481                } 
     482+               sdrv->remove(sdev); 
     483+               ctx->device_frozen[i] = 1; 
     484        } 
     485  
     486        return 0; 
     487-err_unwind: 
     488-       for (i--; i >= 0; i--) { 
     489-               dev = &(bus->devices[i]); 
     490-               if (!dev->dev || 
     491-                   !dev->dev->driver || 
     492-                   !device_is_registered(dev->dev)) 
     493-                       continue; 
     494-               drv = drv_to_ssb_drv(dev->dev->driver); 
     495-               if (!drv) 
     496-                       continue; 
     497-               if (drv->resume) 
     498-                       drv->resume(dev); 
     499-       } 
     500-       return err; 
     501 } 
     502  
     503-int ssb_devices_thaw(struct ssb_bus *bus) 
     504+/** ssb_devices_thaw - Unfreeze all devices on the bus. 
     505+ * 
     506+ * This will re-attach the device drivers and re-init the devices. 
     507+ * 
     508+ * @ctx: The context structure from ssb_devices_freeze() 
     509+ */ 
     510+int ssb_devices_thaw(struct ssb_freeze_context *ctx) 
     511 { 
     512-       struct ssb_device *dev; 
     513-       struct ssb_driver *drv; 
     514-       int err; 
     515-       int i; 
     516+       struct ssb_bus *bus = ctx->bus; 
     517+       struct ssb_device *sdev; 
     518+       struct ssb_driver *sdrv; 
     519+       unsigned int i; 
     520+       int err, result = 0; 
     521  
     522        for (i = 0; i < bus->nr_devices; i++) { 
     523-               dev = &(bus->devices[i]); 
     524-               if (!dev->dev || 
     525-                   !dev->dev->driver || 
     526-                   !device_is_registered(dev->dev)) 
     527+               if (!ctx->device_frozen[i]) 
     528                        continue; 
     529-               drv = drv_to_ssb_drv(dev->dev->driver); 
     530-               if (!drv) 
     531+               sdev = &bus->devices[i]; 
     532+ 
     533+               if (SSB_WARN_ON(!sdev->dev || !sdev->dev->driver)) 
     534                        continue; 
     535-               if (SSB_WARN_ON(!drv->resume)) 
     536+               sdrv = drv_to_ssb_drv(sdev->dev->driver); 
     537+               if (SSB_WARN_ON(!sdrv || !sdrv->probe)) 
     538                        continue; 
     539-               err = drv->resume(dev); 
     540+ 
     541+               err = sdrv->probe(sdev, &sdev->id); 
     542                if (err) { 
     543                        ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n", 
     544-                                  dev_name(dev->dev)); 
     545+                                  dev_name(sdev->dev)); 
     546+                       result = err; 
     547                } 
     548+               ssb_driver_put(sdrv); 
     549+               ssb_device_put(sdev); 
     550        } 
     551  
     552-       return 0; 
     553+       return result; 
     554 } 
     555 #endif /* CONFIG_SSB_SPROM */ 
     556  
     557@@ -360,6 +385,35 @@ static int ssb_device_uevent(struct devi 
     558                             ssb_dev->id.revision); 
     559 } 
     560  
     561+#define ssb_config_attr(attrib, field, format_string) \ 
     562+static ssize_t \ 
     563+attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 
     564+{ \ 
     565+       return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \ 
     566+} 
     567+ 
     568+ssb_config_attr(core_num, core_index, "%u\n") 
     569+ssb_config_attr(coreid, id.coreid, "0x%04x\n") 
     570+ssb_config_attr(vendor, id.vendor, "0x%04x\n") 
     571+ssb_config_attr(revision, id.revision, "%u\n") 
     572+ssb_config_attr(irq, irq, "%u\n") 
     573+static ssize_t 
     574+name_show(struct device *dev, struct device_attribute *attr, char *buf) 
     575+{ 
     576+       return sprintf(buf, "%s\n", 
     577+                      ssb_core_name(dev_to_ssb_dev(dev)->id.coreid)); 
     578+} 
     579+ 
     580+static struct device_attribute ssb_device_attrs[] = { 
     581+       __ATTR_RO(name), 
     582+       __ATTR_RO(core_num), 
     583+       __ATTR_RO(coreid), 
     584+       __ATTR_RO(vendor), 
     585+       __ATTR_RO(revision), 
     586+       __ATTR_RO(irq), 
     587+       __ATTR_NULL, 
     588+}; 
     589+ 
     590 static struct bus_type ssb_bustype = { 
     591        .name           = "ssb", 
     592        .match          = ssb_bus_match, 
     593@@ -369,6 +423,7 @@ static struct bus_type ssb_bustype = { 
     594        .suspend        = ssb_device_suspend, 
     595        .resume         = ssb_device_resume, 
     596        .uevent         = ssb_device_uevent, 
     597+       .dev_attrs      = ssb_device_attrs, 
     598 }; 
     599  
     600 static void ssb_buses_lock(void) 
     601@@ -461,6 +516,7 @@ static int ssb_devices_register(struct s 
     602 #ifdef CONFIG_SSB_PCIHOST 
     603                        sdev->irq = bus->host_pci->irq; 
     604                        dev->parent = &bus->host_pci->dev; 
     605+                       sdev->dma_dev = dev->parent; 
     606 #endif 
     607                        break; 
     608                case SSB_BUSTYPE_PCMCIA: 
     609@@ -469,8 +525,14 @@ static int ssb_devices_register(struct s 
    111610                        dev->parent = &bus->host_pcmcia->dev; 
    112611 #endif 
    113612                        break; 
    114613+               case SSB_BUSTYPE_SDIO: 
     614+#ifdef CONFIG_SSB_SDIOHOST 
     615+                       dev->parent = &bus->host_sdio->dev; 
     616+#endif 
    115617+                       break; 
    116618                case SSB_BUSTYPE_SSB: 
    117619                        dev->dma_mask = &dev->coherent_dma_mask; 
     620+                       sdev->dma_dev = dev; 
    118621                        break; 
    119 @@ -1358,8 +1360,10 @@ static int __init ssb_modinit(void) 
     622                } 
     623  
     624@@ -724,12 +786,18 @@ static int ssb_bus_register(struct ssb_b 
     625        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     626        if (err) 
     627                goto out; 
     628+ 
     629+       /* Init SDIO-host device (if any), before the scan */ 
     630+       err = ssb_sdio_init(bus); 
     631+       if (err) 
     632+               goto err_disable_xtal; 
     633+ 
     634        ssb_buses_lock(); 
     635        bus->busnumber = next_busnumber; 
     636        /* Scan for devices (cores) */ 
     637        err = ssb_bus_scan(bus, baseaddr); 
     638        if (err) 
     639-               goto err_disable_xtal; 
     640+               goto err_sdio_exit; 
     641  
     642        /* Init PCI-host device (if any) */ 
     643        err = ssb_pci_init(bus); 
     644@@ -776,6 +844,8 @@ err_pci_exit: 
     645        ssb_pci_exit(bus); 
     646 err_unmap: 
     647        ssb_iounmap(bus); 
     648+err_sdio_exit: 
     649+       ssb_sdio_exit(bus); 
     650 err_disable_xtal: 
     651        ssb_buses_unlock(); 
     652        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     653@@ -796,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
     654        if (!err) { 
     655                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     656                           "PCI device %s\n", dev_name(&host_pci->dev)); 
     657+       } else { 
     658+               ssb_printk(KERN_ERR PFX "Failed to register PCI version" 
     659+                          " of SSB with error %d\n", err); 
     660        } 
     661  
     662        return err; 
     663@@ -825,6 +898,28 @@ int ssb_bus_pcmciabus_register(struct ss 
     664 EXPORT_SYMBOL(ssb_bus_pcmciabus_register); 
     665 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     666  
     667+#ifdef CONFIG_SSB_SDIOHOST 
     668+int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
     669+                            unsigned int quirks) 
     670+{ 
     671+       int err; 
     672+ 
     673+       bus->bustype = SSB_BUSTYPE_SDIO; 
     674+       bus->host_sdio = func; 
     675+       bus->ops = &ssb_sdio_ops; 
     676+       bus->quirks = quirks; 
     677+ 
     678+       err = ssb_bus_register(bus, ssb_sdio_get_invariants, ~0); 
     679+       if (!err) { 
     680+               ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     681+                          "SDIO device %s\n", sdio_func_id(func)); 
     682+       } 
     683+ 
     684+       return err; 
     685+} 
     686+EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
     687+#endif /* CONFIG_SSB_PCMCIAHOST */ 
     688+ 
     689 int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     690                            unsigned long baseaddr, 
     691                            ssb_invariants_func_t get_invariants) 
     692@@ -1099,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
     693 } 
     694 EXPORT_SYMBOL(ssb_device_enable); 
     695  
     696-/* Wait for a bit in a register to get set or unset. 
     697+/* Wait for bitmask in a register to get set or cleared. 
     698  * timeout is in units of ten-microseconds */ 
     699-static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
     700-                       int timeout, int set) 
     701+static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     702+                        int timeout, int set) 
     703 { 
     704        int i; 
     705        u32 val; 
     706@@ -1110,7 +1205,7 @@ static int ssb_wait_bit(struct ssb_devic 
     707        for (i = 0; i < timeout; i++) { 
     708                val = ssb_read32(dev, reg); 
     709                if (set) { 
     710-                       if (val & bitmask) 
     711+                       if ((val & bitmask) == bitmask) 
     712                                return 0; 
     713                } else { 
     714                        if (!(val & bitmask)) 
     715@@ -1127,20 +1222,38 @@ static int ssb_wait_bit(struct ssb_devic 
     716  
     717 void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
     718 { 
     719-       u32 reject; 
     720+       u32 reject, val; 
     721  
     722        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
     723                return; 
     724  
     725        reject = ssb_tmslow_reject_bitmask(dev); 
     726-       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     727-       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
     728-       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     729-       ssb_write32(dev, SSB_TMSLOW, 
     730-                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     731-                   reject | SSB_TMSLOW_RESET | 
     732-                   core_specific_flags); 
     733-       ssb_flush_tmslow(dev); 
     734+ 
     735+       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) { 
     736+               ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     737+               ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1); 
     738+               ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     739+ 
     740+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     741+                       val = ssb_read32(dev, SSB_IMSTATE); 
     742+                       val |= SSB_IMSTATE_REJECT; 
     743+                       ssb_write32(dev, SSB_IMSTATE, val); 
     744+                       ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000, 
     745+                                     0); 
     746+               } 
     747+ 
     748+               ssb_write32(dev, SSB_TMSLOW, 
     749+                       SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     750+                       reject | SSB_TMSLOW_RESET | 
     751+                       core_specific_flags); 
     752+               ssb_flush_tmslow(dev); 
     753+ 
     754+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     755+                       val = ssb_read32(dev, SSB_IMSTATE); 
     756+                       val &= ~SSB_IMSTATE_REJECT; 
     757+                       ssb_write32(dev, SSB_IMSTATE, val); 
     758+               } 
     759+       } 
     760  
     761        ssb_write32(dev, SSB_TMSLOW, 
     762                    reject | SSB_TMSLOW_RESET | 
     763@@ -1358,8 +1471,10 @@ static int __init ssb_modinit(void) 
    120764        ssb_buses_lock(); 
    121765        err = ssb_attach_queued_buses(); 
     
    129773        err = b43_pci_ssb_bridge_init(); 
    130774        if (err) { 
    131 @@ -1375,7 +1379,7 @@ static int __init ssb_modinit(void) 
     775@@ -1375,7 +1490,7 @@ static int __init ssb_modinit(void) 
    132776                /* don't fail SSB init because of this */ 
    133777                err = 0; 
     
    140784--- a/drivers/ssb/pci.c 
    141785+++ b/drivers/ssb/pci.c 
    142 @@ -169,8 +169,14 @@ err_pci: 
     786@@ -17,6 +17,7 @@ 
     787  
     788 #include <linux/ssb/ssb.h> 
     789 #include <linux/ssb/ssb_regs.h> 
     790+#include <linux/slab.h> 
     791 #include <linux/pci.h> 
     792 #include <linux/delay.h> 
     793  
     794@@ -167,10 +168,16 @@ err_pci: 
     795 } 
     796  
    143797 /* Get the word-offset for a SSB_SPROM_XXX define. */ 
    144  #define SPOFF(offset)  (((offset) - SSB_SPROM_BASE) / sizeof(u16)) 
     798-#define SPOFF(offset)  (((offset) - SSB_SPROM_BASE) / sizeof(u16)) 
     799+#define SPOFF(offset)  ((offset) / sizeof(u16)) 
    145800 /* Helper to extract some _offset, which is one of the SSB_SPROM_XXX defines. */ 
    146801-#define SPEX(_outvar, _offset, _mask, _shift)  \ 
     
    156811 static inline u8 ssb_crc8(u8 crc, u8 data) 
    157812 { 
    158 @@ -474,12 +480,14 @@ static void sprom_extract_r8(struct ssb_ 
     813@@ -247,7 +254,7 @@ static int sprom_do_read(struct ssb_bus 
     814        int i; 
     815  
     816        for (i = 0; i < bus->sprom_size; i++) 
     817-               sprom[i] = ioread16(bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     818+               sprom[i] = ioread16(bus->mmio + bus->sprom_offset + (i * 2)); 
     819  
     820        return 0; 
     821 } 
     822@@ -278,7 +285,7 @@ static int sprom_do_write(struct ssb_bus 
     823                        ssb_printk("75%%"); 
     824                else if (i % 2) 
     825                        ssb_printk("."); 
     826-               writew(sprom[i], bus->mmio + SSB_SPROM_BASE + (i * 2)); 
     827+               writew(sprom[i], bus->mmio + bus->sprom_offset + (i * 2)); 
     828                mmiowb(); 
     829                msleep(20); 
     830        } 
     831@@ -399,6 +406,46 @@ static void sprom_extract_r123(struct ss 
     832        out->antenna_gain.ghz5.a3 = gain; 
     833 } 
     834  
     835+/* Revs 4 5 and 8 have partially shared layout */ 
     836+static void sprom_extract_r458(struct ssb_sprom *out, const u16 *in) 
     837+{ 
     838+       SPEX(txpid2g[0], SSB_SPROM4_TXPID2G01, 
     839+            SSB_SPROM4_TXPID2G0, SSB_SPROM4_TXPID2G0_SHIFT); 
     840+       SPEX(txpid2g[1], SSB_SPROM4_TXPID2G01, 
     841+            SSB_SPROM4_TXPID2G1, SSB_SPROM4_TXPID2G1_SHIFT); 
     842+       SPEX(txpid2g[2], SSB_SPROM4_TXPID2G23, 
     843+            SSB_SPROM4_TXPID2G2, SSB_SPROM4_TXPID2G2_SHIFT); 
     844+       SPEX(txpid2g[3], SSB_SPROM4_TXPID2G23, 
     845+            SSB_SPROM4_TXPID2G3, SSB_SPROM4_TXPID2G3_SHIFT); 
     846+ 
     847+       SPEX(txpid5gl[0], SSB_SPROM4_TXPID5GL01, 
     848+            SSB_SPROM4_TXPID5GL0, SSB_SPROM4_TXPID5GL0_SHIFT); 
     849+       SPEX(txpid5gl[1], SSB_SPROM4_TXPID5GL01, 
     850+            SSB_SPROM4_TXPID5GL1, SSB_SPROM4_TXPID5GL1_SHIFT); 
     851+       SPEX(txpid5gl[2], SSB_SPROM4_TXPID5GL23, 
     852+            SSB_SPROM4_TXPID5GL2, SSB_SPROM4_TXPID5GL2_SHIFT); 
     853+       SPEX(txpid5gl[3], SSB_SPROM4_TXPID5GL23, 
     854+            SSB_SPROM4_TXPID5GL3, SSB_SPROM4_TXPID5GL3_SHIFT); 
     855+ 
     856+       SPEX(txpid5g[0], SSB_SPROM4_TXPID5G01, 
     857+            SSB_SPROM4_TXPID5G0, SSB_SPROM4_TXPID5G0_SHIFT); 
     858+       SPEX(txpid5g[1], SSB_SPROM4_TXPID5G01, 
     859+            SSB_SPROM4_TXPID5G1, SSB_SPROM4_TXPID5G1_SHIFT); 
     860+       SPEX(txpid5g[2], SSB_SPROM4_TXPID5G23, 
     861+            SSB_SPROM4_TXPID5G2, SSB_SPROM4_TXPID5G2_SHIFT); 
     862+       SPEX(txpid5g[3], SSB_SPROM4_TXPID5G23, 
     863+            SSB_SPROM4_TXPID5G3, SSB_SPROM4_TXPID5G3_SHIFT); 
     864+ 
     865+       SPEX(txpid5gh[0], SSB_SPROM4_TXPID5GH01, 
     866+            SSB_SPROM4_TXPID5GH0, SSB_SPROM4_TXPID5GH0_SHIFT); 
     867+       SPEX(txpid5gh[1], SSB_SPROM4_TXPID5GH01, 
     868+            SSB_SPROM4_TXPID5GH1, SSB_SPROM4_TXPID5GH1_SHIFT); 
     869+       SPEX(txpid5gh[2], SSB_SPROM4_TXPID5GH23, 
     870+            SSB_SPROM4_TXPID5GH2, SSB_SPROM4_TXPID5GH2_SHIFT); 
     871+       SPEX(txpid5gh[3], SSB_SPROM4_TXPID5GH23, 
     872+            SSB_SPROM4_TXPID5GH3, SSB_SPROM4_TXPID5GH3_SHIFT); 
     873+} 
     874+ 
     875 static void sprom_extract_r45(struct ssb_sprom *out, const u16 *in) 
     876 { 
     877        int i; 
     878@@ -421,10 +468,14 @@ static void sprom_extract_r45(struct ssb 
     879                SPEX(country_code, SSB_SPROM4_CCODE, 0xFFFF, 0); 
     880                SPEX(boardflags_lo, SSB_SPROM4_BFLLO, 0xFFFF, 0); 
     881                SPEX(boardflags_hi, SSB_SPROM4_BFLHI, 0xFFFF, 0); 
     882+               SPEX(boardflags2_lo, SSB_SPROM4_BFL2LO, 0xFFFF, 0); 
     883+               SPEX(boardflags2_hi, SSB_SPROM4_BFL2HI, 0xFFFF, 0); 
     884        } else { 
     885                SPEX(country_code, SSB_SPROM5_CCODE, 0xFFFF, 0); 
     886                SPEX(boardflags_lo, SSB_SPROM5_BFLLO, 0xFFFF, 0); 
     887                SPEX(boardflags_hi, SSB_SPROM5_BFLHI, 0xFFFF, 0); 
     888+               SPEX(boardflags2_lo, SSB_SPROM5_BFL2LO, 0xFFFF, 0); 
     889+               SPEX(boardflags2_hi, SSB_SPROM5_BFL2HI, 0xFFFF, 0); 
     890        } 
     891        SPEX(ant_available_a, SSB_SPROM4_ANTAVAIL, SSB_SPROM4_ANTAVAIL_A, 
     892             SSB_SPROM4_ANTAVAIL_A_SHIFT); 
     893@@ -464,6 +515,8 @@ static void sprom_extract_r45(struct ssb 
     894        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
     895               sizeof(out->antenna_gain.ghz5)); 
     896  
     897+       sprom_extract_r458(out, in); 
     898+ 
     899        /* TODO - get remaining rev 4 stuff needed */ 
     900 } 
     901  
     902@@ -474,12 +527,14 @@ static void sprom_extract_r8(struct ssb_ 
    159903  
    160904        /* extract the MAC address */ 
     
    172916             SSB_SPROM8_ANTAVAIL_A_SHIFT); 
    173917        SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG, 
    174 @@ -490,12 +498,55 @@ static void sprom_extract_r8(struct ssb_ 
     918@@ -490,12 +545,55 @@ static void sprom_extract_r8(struct ssb_ 
    175919        SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0); 
    176920        SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A, 
     
    228972        /* Extract the antenna gain values. */ 
    229973        SPEX(antenna_gain.ghz24.a0, SSB_SPROM8_AGAIN01, 
    230 @@ -549,6 +600,7 @@ static int sprom_extract(struct ssb_bus 
    231                         ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
    232                                    "  revision %d detected. Will extract" 
    233                                    " v1\n", out->revision); 
    234 +                       out->revision = 1; 
    235                         sprom_extract_r123(out, in); 
    236                 } 
     974@@ -509,6 +607,8 @@ static void sprom_extract_r8(struct ssb_ 
     975        memcpy(&out->antenna_gain.ghz5, &out->antenna_gain.ghz24, 
     976               sizeof(out->antenna_gain.ghz5)); 
     977  
     978+       sprom_extract_r458(out, in); 
     979+ 
     980        /* TODO - get remaining rev 8 stuff needed */ 
     981 } 
     982  
     983@@ -521,36 +621,34 @@ static int sprom_extract(struct ssb_bus 
     984        ssb_dprintk(KERN_DEBUG PFX "SPROM revision %d detected.\n", out->revision); 
     985        memset(out->et0mac, 0xFF, 6);           /* preset et0 and et1 mac */ 
     986        memset(out->et1mac, 0xFF, 6); 
     987+ 
     988        if ((bus->chip_id & 0xFF00) == 0x4400) { 
     989                /* Workaround: The BCM44XX chip has a stupid revision 
     990                 * number stored in the SPROM. 
     991                 * Always extract r1. */ 
     992                out->revision = 1; 
     993+               ssb_dprintk(KERN_DEBUG PFX "SPROM treated as revision %d\n", out->revision); 
     994+       } 
     995+ 
     996+       switch (out->revision) { 
     997+       case 1: 
     998+       case 2: 
     999+       case 3: 
     1000                sprom_extract_r123(out, in); 
     1001-       } else if (bus->chip_id == 0x4321) { 
     1002-               /* the BCM4328 has a chipid == 0x4321 and a rev 4 SPROM */ 
     1003-               out->revision = 4; 
     1004+               break; 
     1005+       case 4: 
     1006+       case 5: 
     1007                sprom_extract_r45(out, in); 
     1008-       } else { 
     1009-               switch (out->revision) { 
     1010-               case 1: 
     1011-               case 2: 
     1012-               case 3: 
     1013-                       sprom_extract_r123(out, in); 
     1014-                       break; 
     1015-               case 4: 
     1016-               case 5: 
     1017-                       sprom_extract_r45(out, in); 
     1018-                       break; 
     1019-               case 8: 
     1020-                       sprom_extract_r8(out, in); 
     1021-                       break; 
     1022-               default: 
     1023-                       ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     1024-                                  "  revision %d detected. Will extract" 
     1025-                                  " v1\n", out->revision); 
     1026-                       sprom_extract_r123(out, in); 
     1027-               } 
     1028+               break; 
     1029+       case 8: 
     1030+               sprom_extract_r8(out, in); 
     1031+               break; 
     1032+       default: 
     1033+               ssb_printk(KERN_WARNING PFX "Unsupported SPROM" 
     1034+                          " revision %d detected. Will extract" 
     1035+                          " v1\n", out->revision); 
     1036+               out->revision = 1; 
     1037+               sprom_extract_r123(out, in); 
    2371038        } 
     1039  
     1040        if (out->boardflags_lo == 0xFFFF) 
     1041@@ -565,12 +663,34 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1042                             struct ssb_sprom *sprom) 
     1043 { 
     1044        const struct ssb_sprom *fallback; 
     1045-       int err = -ENOMEM; 
     1046+       int err; 
     1047        u16 *buf; 
     1048  
     1049+       if (!ssb_is_sprom_available(bus)) { 
     1050+               ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
     1051+               return -ENODEV; 
     1052+       } 
     1053+       if (bus->chipco.dev) {  /* can be unavailible! */ 
     1054+               /* 
     1055+                * get SPROM offset: SSB_SPROM_BASE1 except for 
     1056+                * chipcommon rev >= 31 or chip ID is 0x4312 and 
     1057+                * chipcommon status & 3 == 2 
     1058+                */ 
     1059+               if (bus->chipco.dev->id.revision >= 31) 
     1060+                       bus->sprom_offset = SSB_SPROM_BASE31; 
     1061+               else if (bus->chip_id == 0x4312 && 
     1062+                        (bus->chipco.status & 0x03) == 2) 
     1063+                       bus->sprom_offset = SSB_SPROM_BASE31; 
     1064+               else 
     1065+                       bus->sprom_offset = SSB_SPROM_BASE1; 
     1066+       } else { 
     1067+               bus->sprom_offset = SSB_SPROM_BASE1; 
     1068+       } 
     1069+       ssb_dprintk(KERN_INFO PFX "SPROM offset is 0x%x\n", bus->sprom_offset); 
     1070+ 
     1071        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
     1072        if (!buf) 
     1073-               goto out; 
     1074+               return -ENOMEM; 
     1075        bus->sprom_size = SSB_SPROMSIZE_WORDS_R123; 
     1076        sprom_do_read(bus, buf); 
     1077        err = sprom_check_crc(buf, bus->sprom_size); 
     1078@@ -580,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1079                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
     1080                              GFP_KERNEL); 
     1081                if (!buf) 
     1082-                       goto out; 
     1083+                       return -ENOMEM; 
     1084                bus->sprom_size = SSB_SPROMSIZE_WORDS_R4; 
     1085                sprom_do_read(bus, buf); 
     1086                err = sprom_check_crc(buf, bus->sprom_size); 
     1087@@ -602,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1088  
     1089 out_free: 
     1090        kfree(buf); 
     1091-out: 
     1092        return err; 
     1093 } 
     1094  
     1095--- a/drivers/ssb/pcihost_wrapper.c 
     1096+++ b/drivers/ssb/pcihost_wrapper.c 
     1097@@ -12,6 +12,7 @@ 
     1098  */ 
     1099  
     1100 #include <linux/pci.h> 
     1101+#include <linux/slab.h> 
     1102 #include <linux/ssb/ssb.h> 
     1103  
     1104  
     1105@@ -58,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     1106        struct ssb_bus *ssb; 
     1107        int err = -ENOMEM; 
     1108        const char *name; 
     1109+       u32 val; 
     1110  
     1111        ssb = kzalloc(sizeof(*ssb), GFP_KERNEL); 
     1112        if (!ssb) 
     1113@@ -73,6 +75,12 @@ static int ssb_pcihost_probe(struct pci_ 
     1114                goto err_pci_disable; 
     1115        pci_set_master(dev); 
     1116  
     1117+       /* Disable the RETRY_TIMEOUT register (0x41) to keep 
     1118+        * PCI Tx retries from interfering with C3 CPU state */ 
     1119+       pci_read_config_dword(dev, 0x40, &val); 
     1120+       if ((val & 0x0000ff00) != 0) 
     1121+               pci_write_config_dword(dev, 0x40, val & 0xffff00ff); 
     1122+ 
     1123        err = ssb_bus_pcibus_register(ssb, dev); 
     1124        if (err) 
     1125                goto err_pci_release_regions; 
     1126--- a/drivers/ssb/pcmcia.c 
     1127+++ b/drivers/ssb/pcmcia.c 
     1128@@ -617,136 +617,140 @@ static int ssb_pcmcia_sprom_check_crc(co 
     1129        }                                               \ 
     1130   } while (0) 
     1131  
     1132-int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 
     1133-                             struct ssb_init_invariants *iv) 
     1134+static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev, 
     1135+                       tuple_t *tuple, 
     1136+                       void *priv) 
     1137 { 
     1138-       tuple_t tuple; 
     1139-       int res; 
     1140-       unsigned char buf[32]; 
     1141+       struct ssb_sprom *sprom = priv; 
     1142+ 
     1143+       if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID) 
     1144+               return -EINVAL; 
     1145+       if (tuple->TupleDataLen != ETH_ALEN + 2) 
     1146+               return -EINVAL; 
     1147+       if (tuple->TupleData[1] != ETH_ALEN) 
     1148+               return -EINVAL; 
     1149+       memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN); 
     1150+       return 0; 
     1151+}; 
     1152+ 
     1153+static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev, 
     1154+                                       tuple_t *tuple, 
     1155+                                       void *priv) 
     1156+{ 
     1157+       struct ssb_init_invariants *iv = priv; 
     1158        struct ssb_sprom *sprom = &iv->sprom; 
     1159        struct ssb_boardinfo *bi = &iv->boardinfo; 
     1160        const char *error_description; 
     1161  
     1162+       GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1"); 
     1163+       switch (tuple->TupleData[0]) { 
     1164+       case SSB_PCMCIA_CIS_ID: 
     1165+               GOTO_ERROR_ON((tuple->TupleDataLen != 5) && 
     1166+                             (tuple->TupleDataLen != 7), 
     1167+                             "id tpl size"); 
     1168+               bi->vendor = tuple->TupleData[1] | 
     1169+                       ((u16)tuple->TupleData[2] << 8); 
     1170+               break; 
     1171+       case SSB_PCMCIA_CIS_BOARDREV: 
     1172+               GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     1173+                       "boardrev tpl size"); 
     1174+               sprom->board_rev = tuple->TupleData[1]; 
     1175+               break; 
     1176+       case SSB_PCMCIA_CIS_PA: 
     1177+               GOTO_ERROR_ON((tuple->TupleDataLen != 9) && 
     1178+                       (tuple->TupleDataLen != 10), 
     1179+                       "pa tpl size"); 
     1180+               sprom->pa0b0 = tuple->TupleData[1] | 
     1181+                       ((u16)tuple->TupleData[2] << 8); 
     1182+               sprom->pa0b1 = tuple->TupleData[3] | 
     1183+                       ((u16)tuple->TupleData[4] << 8); 
     1184+               sprom->pa0b2 = tuple->TupleData[5] | 
     1185+                       ((u16)tuple->TupleData[6] << 8); 
     1186+               sprom->itssi_a = tuple->TupleData[7]; 
     1187+               sprom->itssi_bg = tuple->TupleData[7]; 
     1188+               sprom->maxpwr_a = tuple->TupleData[8]; 
     1189+               sprom->maxpwr_bg = tuple->TupleData[8]; 
     1190+               break; 
     1191+       case SSB_PCMCIA_CIS_OEMNAME: 
     1192+               /* We ignore this. */ 
     1193+               break; 
     1194+       case SSB_PCMCIA_CIS_CCODE: 
     1195+               GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     1196+                       "ccode tpl size"); 
     1197+               sprom->country_code = tuple->TupleData[1]; 
     1198+               break; 
     1199+       case SSB_PCMCIA_CIS_ANTENNA: 
     1200+               GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     1201+                       "ant tpl size"); 
     1202+               sprom->ant_available_a = tuple->TupleData[1]; 
     1203+               sprom->ant_available_bg = tuple->TupleData[1]; 
     1204+               break; 
     1205+       case SSB_PCMCIA_CIS_ANTGAIN: 
     1206+               GOTO_ERROR_ON(tuple->TupleDataLen != 2, 
     1207+                       "antg tpl size"); 
     1208+               sprom->antenna_gain.ghz24.a0 = tuple->TupleData[1]; 
     1209+               sprom->antenna_gain.ghz24.a1 = tuple->TupleData[1]; 
     1210+               sprom->antenna_gain.ghz24.a2 = tuple->TupleData[1]; 
     1211+               sprom->antenna_gain.ghz24.a3 = tuple->TupleData[1]; 
     1212+               sprom->antenna_gain.ghz5.a0 = tuple->TupleData[1]; 
     1213+               sprom->antenna_gain.ghz5.a1 = tuple->TupleData[1]; 
     1214+               sprom->antenna_gain.ghz5.a2 = tuple->TupleData[1]; 
     1215+               sprom->antenna_gain.ghz5.a3 = tuple->TupleData[1]; 
     1216+               break; 
     1217+       case SSB_PCMCIA_CIS_BFLAGS: 
     1218+               GOTO_ERROR_ON((tuple->TupleDataLen != 3) && 
     1219+                       (tuple->TupleDataLen != 5), 
     1220+                       "bfl tpl size"); 
     1221+               sprom->boardflags_lo = tuple->TupleData[1] | 
     1222+                       ((u16)tuple->TupleData[2] << 8); 
     1223+               break; 
     1224+       case SSB_PCMCIA_CIS_LEDS: 
     1225+               GOTO_ERROR_ON(tuple->TupleDataLen != 5, 
     1226+                       "leds tpl size"); 
     1227+               sprom->gpio0 = tuple->TupleData[1]; 
     1228+               sprom->gpio1 = tuple->TupleData[2]; 
     1229+               sprom->gpio2 = tuple->TupleData[3]; 
     1230+               sprom->gpio3 = tuple->TupleData[4]; 
     1231+               break; 
     1232+       } 
     1233+       return -ENOSPC; /* continue with next entry */ 
     1234+ 
     1235+error: 
     1236+       ssb_printk(KERN_ERR PFX 
     1237+                  "PCMCIA: Failed to fetch device invariants: %s\n", 
     1238+                  error_description); 
     1239+       return -ENODEV; 
     1240+} 
     1241+ 
     1242+ 
     1243+int ssb_pcmcia_get_invariants(struct ssb_bus *bus, 
     1244+                             struct ssb_init_invariants *iv) 
     1245+{ 
     1246+       struct ssb_sprom *sprom = &iv->sprom; 
     1247+       int res; 
     1248+ 
     1249        memset(sprom, 0xFF, sizeof(*sprom)); 
     1250        sprom->revision = 1; 
     1251        sprom->boardflags_lo = 0; 
     1252        sprom->boardflags_hi = 0; 
     1253  
     1254        /* First fetch the MAC address. */ 
     1255-       memset(&tuple, 0, sizeof(tuple)); 
     1256-       tuple.DesiredTuple = CISTPL_FUNCE; 
     1257-       tuple.TupleData = buf; 
     1258-       tuple.TupleDataMax = sizeof(buf); 
     1259-       res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 
     1260-       GOTO_ERROR_ON(res != 0, "MAC first tpl"); 
     1261-       res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
     1262-       GOTO_ERROR_ON(res != 0, "MAC first tpl data"); 
     1263-       while (1) { 
     1264-               GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1"); 
     1265-               if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID) 
     1266-                       break; 
     1267-               res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 
     1268-               GOTO_ERROR_ON(res != 0, "MAC next tpl"); 
     1269-               res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
     1270-               GOTO_ERROR_ON(res != 0, "MAC next tpl data"); 
     1271+       res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE, 
     1272+                               ssb_pcmcia_get_mac, sprom); 
     1273+       if (res != 0) { 
     1274+               ssb_printk(KERN_ERR PFX 
     1275+                       "PCMCIA: Failed to fetch MAC address\n"); 
     1276+               return -ENODEV; 
     1277        } 
     1278-       GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size"); 
     1279-       memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN); 
     1280  
     1281        /* Fetch the vendor specific tuples. */ 
     1282-       memset(&tuple, 0, sizeof(tuple)); 
     1283-       tuple.DesiredTuple = SSB_PCMCIA_CIS; 
     1284-       tuple.TupleData = buf; 
     1285-       tuple.TupleDataMax = sizeof(buf); 
     1286-       res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple); 
     1287-       GOTO_ERROR_ON(res != 0, "VEN first tpl"); 
     1288-       res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
     1289-       GOTO_ERROR_ON(res != 0, "VEN first tpl data"); 
     1290-       while (1) { 
     1291-               GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1"); 
     1292-               switch (tuple.TupleData[0]) { 
     1293-               case SSB_PCMCIA_CIS_ID: 
     1294-                       GOTO_ERROR_ON((tuple.TupleDataLen != 5) && 
     1295-                                     (tuple.TupleDataLen != 7), 
     1296-                                     "id tpl size"); 
     1297-                       bi->vendor = tuple.TupleData[1] | 
     1298-                              ((u16)tuple.TupleData[2] << 8); 
     1299-                       break; 
     1300-               case SSB_PCMCIA_CIS_BOARDREV: 
     1301-                       GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
     1302-                                     "boardrev tpl size"); 
     1303-                       sprom->board_rev = tuple.TupleData[1]; 
     1304-                       break; 
     1305-               case SSB_PCMCIA_CIS_PA: 
     1306-                       GOTO_ERROR_ON((tuple.TupleDataLen != 9) && 
     1307-                                     (tuple.TupleDataLen != 10), 
     1308-                                     "pa tpl size"); 
     1309-                       sprom->pa0b0 = tuple.TupleData[1] | 
     1310-                                ((u16)tuple.TupleData[2] << 8); 
     1311-                       sprom->pa0b1 = tuple.TupleData[3] | 
     1312-                                ((u16)tuple.TupleData[4] << 8); 
     1313-                       sprom->pa0b2 = tuple.TupleData[5] | 
     1314-                                ((u16)tuple.TupleData[6] << 8); 
     1315-                       sprom->itssi_a = tuple.TupleData[7]; 
     1316-                       sprom->itssi_bg = tuple.TupleData[7]; 
     1317-                       sprom->maxpwr_a = tuple.TupleData[8]; 
     1318-                       sprom->maxpwr_bg = tuple.TupleData[8]; 
     1319-                       break; 
     1320-               case SSB_PCMCIA_CIS_OEMNAME: 
     1321-                       /* We ignore this. */ 
     1322-                       break; 
     1323-               case SSB_PCMCIA_CIS_CCODE: 
     1324-                       GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
     1325-                                     "ccode tpl size"); 
     1326-                       sprom->country_code = tuple.TupleData[1]; 
     1327-                       break; 
     1328-               case SSB_PCMCIA_CIS_ANTENNA: 
     1329-                       GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
     1330-                                     "ant tpl size"); 
     1331-                       sprom->ant_available_a = tuple.TupleData[1]; 
     1332-                       sprom->ant_available_bg = tuple.TupleData[1]; 
     1333-                       break; 
     1334-               case SSB_PCMCIA_CIS_ANTGAIN: 
     1335-                       GOTO_ERROR_ON(tuple.TupleDataLen != 2, 
     1336-                                     "antg tpl size"); 
     1337-                       sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1]; 
     1338-                       sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1]; 
     1339-                       sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1]; 
     1340-                       sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1]; 
     1341-                       sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1]; 
     1342-                       sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1]; 
     1343-                       sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1]; 
     1344-                       sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1]; 
     1345-                       break; 
     1346-               case SSB_PCMCIA_CIS_BFLAGS: 
     1347-                       GOTO_ERROR_ON((tuple.TupleDataLen != 3) && 
     1348-                                     (tuple.TupleDataLen != 5), 
     1349-                                     "bfl tpl size"); 
     1350-                       sprom->boardflags_lo = tuple.TupleData[1] | 
     1351-                                        ((u16)tuple.TupleData[2] << 8); 
     1352-                       break; 
     1353-               case SSB_PCMCIA_CIS_LEDS: 
     1354-                       GOTO_ERROR_ON(tuple.TupleDataLen != 5, 
     1355-                                     "leds tpl size"); 
     1356-                       sprom->gpio0 = tuple.TupleData[1]; 
     1357-                       sprom->gpio1 = tuple.TupleData[2]; 
     1358-                       sprom->gpio2 = tuple.TupleData[3]; 
     1359-                       sprom->gpio3 = tuple.TupleData[4]; 
     1360-                       break; 
     1361-               } 
     1362-               res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple); 
     1363-               if (res == -ENOSPC) 
     1364-                       break; 
     1365-               GOTO_ERROR_ON(res != 0, "VEN next tpl"); 
     1366-               res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple); 
     1367-               GOTO_ERROR_ON(res != 0, "VEN next tpl data"); 
     1368-       } 
     1369+       res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS, 
     1370+                               ssb_pcmcia_do_get_invariants, iv); 
     1371+       if ((res == 0) || (res == -ENOSPC)) 
     1372+               return 0; 
     1373  
     1374-       return 0; 
     1375-error: 
     1376        ssb_printk(KERN_ERR PFX 
     1377-                  "PCMCIA: Failed to fetch device invariants: %s\n", 
     1378-                  error_description); 
     1379+                       "PCMCIA: Failed to fetch device invariants\n"); 
     1380        return -ENODEV; 
     1381 } 
     1382  
    2381383--- a/drivers/ssb/scan.c 
    2391384+++ b/drivers/ssb/scan.c 
    240 @@ -175,6 +175,8 @@ static u32 scan_read32(struct ssb_bus *b 
     1385@@ -162,6 +162,8 @@ static u8 chipid_to_nrcores(u16 chipid) 
     1386 static u32 scan_read32(struct ssb_bus *bus, u8 current_coreidx, 
     1387                       u16 offset) 
     1388 { 
     1389+       u32 lo, hi; 
     1390+ 
     1391        switch (bus->bustype) { 
     1392        case SSB_BUSTYPE_SSB: 
     1393                offset += current_coreidx * SSB_CORE_SIZE; 
     1394@@ -174,7 +176,12 @@ static u32 scan_read32(struct ssb_bus *b 
     1395                        offset -= 0x800; 
    2411396                } else 
    2421397                        ssb_pcmcia_switch_segment(bus, 0); 
    243                 break; 
     1398-               break; 
     1399+               lo = readw(bus->mmio + offset); 
     1400+               hi = readw(bus->mmio + offset + 2); 
     1401+               return lo | (hi << 16); 
    2441402+       case SSB_BUSTYPE_SDIO: 
    245 +               break; 
     1403+               offset += current_coreidx * SSB_CORE_SIZE; 
     1404+               return ssb_sdio_scan_read32(bus, offset); 
    2461405        } 
    2471406        return readl(bus->mmio + offset); 
    2481407 } 
    249 @@ -188,6 +190,8 @@ static int scan_switchcore(struct ssb_bu 
     1408@@ -188,6 +195,8 @@ static int scan_switchcore(struct ssb_bu 
    2501409                return ssb_pci_switch_coreidx(bus, coreidx); 
    2511410        case SSB_BUSTYPE_PCMCIA: 
    2521411                return ssb_pcmcia_switch_coreidx(bus, coreidx); 
    2531412+       case SSB_BUSTYPE_SDIO: 
    254 +               break; 
     1413+               return ssb_sdio_scan_switch_coreidx(bus, coreidx); 
    2551414        } 
    2561415        return 0; 
    2571416 } 
    258 @@ -206,6 +210,8 @@ void ssb_iounmap(struct ssb_bus *bus) 
     1417@@ -206,6 +215,8 @@ void ssb_iounmap(struct ssb_bus *bus) 
    2591418                SSB_BUG_ON(1); /* Can't reach this code. */ 
    2601419 #endif 
     
    2651424        bus->mmio = NULL; 
    2661425        bus->mapped_device = NULL; 
    267 @@ -230,6 +236,8 @@ static void __iomem *ssb_ioremap(struct 
     1426@@ -230,6 +241,10 @@ static void __iomem *ssb_ioremap(struct 
    2681427                SSB_BUG_ON(1); /* Can't reach this code. */ 
    2691428 #endif 
    2701429                break; 
    2711430+       case SSB_BUSTYPE_SDIO: 
     1431+               /* Nothing to ioremap in the SDIO case, just fake it */ 
     1432+               mmio = (void __iomem *)baseaddr; 
    2721433+               break; 
    2731434        } 
    2741435  
    2751436        return mmio; 
     1437@@ -339,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1438                dev->bus = bus; 
     1439                dev->ops = bus->ops; 
     1440  
     1441-               ssb_dprintk(KERN_INFO PFX 
     1442+               printk(KERN_DEBUG PFX 
     1443                            "Core %d found: %s " 
     1444                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
     1445                            i, ssb_core_name(dev->id.coreid), 
     1446@@ -407,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1447                        bus->pcicore.dev = dev; 
     1448 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     1449                        break; 
     1450+               case SSB_DEV_ETHERNET: 
     1451+                       if (bus->bustype == SSB_BUSTYPE_PCI) { 
     1452+                               if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     1453+                                   (bus->host_pci->device & 0xFF00) == 0x4300) { 
     1454+                                       /* This is a dangling ethernet core on a 
     1455+                                        * wireless device. Ignore it. */ 
     1456+                                       continue; 
     1457+                               } 
     1458+                       } 
     1459+                       break; 
     1460                default: 
     1461                        break; 
     1462                } 
     1463--- /dev/null 
     1464+++ b/drivers/ssb/sdio.c 
     1465@@ -0,0 +1,610 @@ 
     1466+/* 
     1467+ * Sonics Silicon Backplane 
     1468+ * SDIO-Hostbus related functions 
     1469+ * 
     1470+ * Copyright 2009 Albert Herranz <albert_herranz@yahoo.es> 
     1471+ * 
     1472+ * Based on drivers/ssb/pcmcia.c 
     1473+ * Copyright 2006 Johannes Berg <johannes@sipsolutions.net> 
     1474+ * Copyright 2007-2008 Michael Buesch <mb@bu3sch.de> 
     1475+ * 
     1476+ * Licensed under the GNU/GPL. See COPYING for details. 
     1477+ * 
     1478+ */ 
     1479+ 
     1480+#include <linux/ssb/ssb.h> 
     1481+#include <linux/delay.h> 
     1482+#include <linux/io.h> 
     1483+#include <linux/etherdevice.h> 
     1484+#include <linux/mmc/sdio_func.h> 
     1485+ 
     1486+#include "ssb_private.h" 
     1487+ 
     1488+/* Define the following to 1 to enable a printk on each coreswitch. */ 
     1489+#define SSB_VERBOSE_SDIOCORESWITCH_DEBUG               0 
     1490+ 
     1491+ 
     1492+/* Hardware invariants CIS tuples */ 
     1493+#define SSB_SDIO_CIS                   0x80 
     1494+#define  SSB_SDIO_CIS_SROMREV          0x00 
     1495+#define  SSB_SDIO_CIS_ID               0x01 
     1496+#define  SSB_SDIO_CIS_BOARDREV         0x02 
     1497+#define  SSB_SDIO_CIS_PA               0x03 
     1498+#define   SSB_SDIO_CIS_PA_PA0B0_LO     0 
     1499+#define   SSB_SDIO_CIS_PA_PA0B0_HI     1 
     1500+#define   SSB_SDIO_CIS_PA_PA0B1_LO     2 
     1501+#define   SSB_SDIO_CIS_PA_PA0B1_HI     3 
     1502+#define   SSB_SDIO_CIS_PA_PA0B2_LO     4 
     1503+#define   SSB_SDIO_CIS_PA_PA0B2_HI     5 
     1504+#define   SSB_SDIO_CIS_PA_ITSSI                6 
     1505+#define   SSB_SDIO_CIS_PA_MAXPOW       7 
     1506+#define  SSB_SDIO_CIS_OEMNAME          0x04 
     1507+#define  SSB_SDIO_CIS_CCODE            0x05 
     1508+#define  SSB_SDIO_CIS_ANTENNA          0x06 
     1509+#define  SSB_SDIO_CIS_ANTGAIN          0x07 
     1510+#define  SSB_SDIO_CIS_BFLAGS           0x08 
     1511+#define  SSB_SDIO_CIS_LEDS             0x09 
     1512+ 
     1513+#define CISTPL_FUNCE_LAN_NODE_ID        0x04   /* same as in PCMCIA */ 
     1514+ 
     1515+ 
     1516+/* 
     1517+ * Function 1 miscellaneous registers. 
     1518+ * 
     1519+ * Definitions match src/include/sbsdio.h from the 
     1520+ * Android Open Source Project 
     1521+ * http://android.git.kernel.org/?p=platform/system/wlan/broadcom.git 
     1522+ * 
     1523+ */ 
     1524+#define SBSDIO_FUNC1_SBADDRLOW 0x1000a /* SB Address window Low (b15) */ 
     1525+#define SBSDIO_FUNC1_SBADDRMID 0x1000b /* SB Address window Mid (b23-b16) */ 
     1526+#define SBSDIO_FUNC1_SBADDRHIGH        0x1000c /* SB Address window High (b24-b31) */ 
     1527+ 
     1528+/* valid bits in SBSDIO_FUNC1_SBADDRxxx regs */ 
     1529+#define SBSDIO_SBADDRLOW_MASK  0x80    /* Valid address bits in SBADDRLOW */ 
     1530+#define SBSDIO_SBADDRMID_MASK  0xff    /* Valid address bits in SBADDRMID */ 
     1531+#define SBSDIO_SBADDRHIGH_MASK 0xff    /* Valid address bits in SBADDRHIGH */ 
     1532+ 
     1533+#define SBSDIO_SB_OFT_ADDR_MASK        0x7FFF  /* sb offset addr is <= 15 bits, 32k */ 
     1534+ 
     1535+/* REVISIT: this flag doesn't seem to matter */ 
     1536+#define SBSDIO_SB_ACCESS_2_4B_FLAG     0x8000  /* forces 32-bit SB access */ 
     1537+ 
     1538+ 
     1539+/* 
     1540+ * Address map within the SDIO function address space (128K). 
     1541+ * 
     1542+ *   Start   End     Description 
     1543+ *   ------- ------- ------------------------------------------ 
     1544+ *   0x00000 0x0ffff selected backplane address window (64K) 
     1545+ *   0x10000 0x1ffff backplane control registers (max 64K) 
     1546+ * 
     1547+ * The current address window is configured by writing to registers 
     1548+ * SBADDRLOW, SBADDRMID and SBADDRHIGH. 
     1549+ * 
     1550+ * In order to access the contents of a 32-bit Silicon Backplane address 
     1551+ * the backplane address window must be first loaded with the highest 
     1552+ * 16 bits of the target address. Then, an access must be done to the 
     1553+ * SDIO function address space using the lower 15 bits of the address. 
     1554+ * Bit 15 of the address must be set when doing 32 bit accesses. 
     1555+ * 
     1556+ * 10987654321098765432109876543210 
     1557+ * WWWWWWWWWWWWWWWWW                 SB Address Window 
     1558+ *                 OOOOOOOOOOOOOOOO  Offset within SB Address Window 
     1559+ *                 a                 32-bit access flag 
     1560+ */ 
     1561+ 
     1562+ 
     1563+/* 
     1564+ * SSB I/O via SDIO. 
     1565+ * 
     1566+ * NOTE: SDIO address @addr is 17 bits long (SDIO address space is 128K). 
     1567+ */ 
     1568+ 
     1569+static inline struct device *ssb_sdio_dev(struct ssb_bus *bus) 
     1570+{ 
     1571+       return &bus->host_sdio->dev; 
     1572+} 
     1573+ 
     1574+/* host claimed */ 
     1575+static int ssb_sdio_writeb(struct ssb_bus *bus, unsigned int addr, u8 val) 
     1576+{ 
     1577+       int error = 0; 
     1578+ 
     1579+       sdio_writeb(bus->host_sdio, val, addr, &error); 
     1580+       if (unlikely(error)) { 
     1581+               dev_dbg(ssb_sdio_dev(bus), "%08X <- %02x, error %d\n", 
     1582+                       addr, val, error); 
     1583+       } 
     1584+ 
     1585+       return error; 
     1586+} 
     1587+ 
     1588+#if 0 
     1589+static u8 ssb_sdio_readb(struct ssb_bus *bus, unsigned int addr) 
     1590+{ 
     1591+       u8 val; 
     1592+       int error = 0; 
     1593+ 
     1594+       val = sdio_readb(bus->host_sdio, addr, &error); 
     1595+       if (unlikely(error)) { 
     1596+               dev_dbg(ssb_sdio_dev(bus), "%08X -> %02x, error %d\n", 
     1597+                       addr, val, error); 
     1598+       } 
     1599+ 
     1600+       return val; 
     1601+} 
     1602+#endif 
     1603+ 
     1604+/* host claimed */ 
     1605+static int ssb_sdio_set_sbaddr_window(struct ssb_bus *bus, u32 address) 
     1606+{ 
     1607+       int error; 
     1608+ 
     1609+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRLOW, 
     1610+                               (address >> 8) & SBSDIO_SBADDRLOW_MASK); 
     1611+       if (error) 
     1612+               goto out; 
     1613+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRMID, 
     1614+                               (address >> 16) & SBSDIO_SBADDRMID_MASK); 
     1615+       if (error) 
     1616+               goto out; 
     1617+       error = ssb_sdio_writeb(bus, SBSDIO_FUNC1_SBADDRHIGH, 
     1618+                               (address >> 24) & SBSDIO_SBADDRHIGH_MASK); 
     1619+       if (error) 
     1620+               goto out; 
     1621+       bus->sdio_sbaddr = address; 
     1622+out: 
     1623+       if (error) { 
     1624+               dev_dbg(ssb_sdio_dev(bus), "failed to set address window" 
     1625+                       " to 0x%08x, error %d\n", address, error); 
     1626+       } 
     1627+ 
     1628+       return error; 
     1629+} 
     1630+ 
     1631+/* for enumeration use only */ 
     1632+u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) 
     1633+{ 
     1634+       u32 val; 
     1635+       int error; 
     1636+ 
     1637+       sdio_claim_host(bus->host_sdio); 
     1638+       val = sdio_readl(bus->host_sdio, offset, &error); 
     1639+       sdio_release_host(bus->host_sdio); 
     1640+       if (unlikely(error)) { 
     1641+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 
     1642+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1643+       } 
     1644+ 
     1645+       return val; 
     1646+} 
     1647+ 
     1648+/* for enumeration use only */ 
     1649+int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 
     1650+{ 
     1651+       u32 sbaddr; 
     1652+       int error; 
     1653+ 
     1654+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 
     1655+       sdio_claim_host(bus->host_sdio); 
     1656+       error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 
     1657+       sdio_release_host(bus->host_sdio); 
     1658+       if (error) { 
     1659+               dev_err(ssb_sdio_dev(bus), "failed to switch to core %u," 
     1660+                       " error %d\n", coreidx, error); 
     1661+               goto out; 
     1662+       } 
     1663+out: 
     1664+       return error; 
     1665+} 
     1666+ 
     1667+/* host must be already claimed */ 
     1668+int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev) 
     1669+{ 
     1670+       u8 coreidx = dev->core_index; 
     1671+       u32 sbaddr; 
     1672+       int error = 0; 
     1673+ 
     1674+       sbaddr = (coreidx * SSB_CORE_SIZE) + SSB_ENUM_BASE; 
     1675+       if (unlikely(bus->sdio_sbaddr != sbaddr)) { 
     1676+#if SSB_VERBOSE_SDIOCORESWITCH_DEBUG 
     1677+               dev_info(ssb_sdio_dev(bus), 
     1678+                          "switching to %s core, index %d\n", 
     1679+                          ssb_core_name(dev->id.coreid), coreidx); 
     1680+#endif 
     1681+               error = ssb_sdio_set_sbaddr_window(bus, sbaddr); 
     1682+               if (error) { 
     1683+                       dev_dbg(ssb_sdio_dev(bus), "failed to switch to" 
     1684+                               " core %u, error %d\n", coreidx, error); 
     1685+                       goto out; 
     1686+               } 
     1687+               bus->mapped_device = dev; 
     1688+       } 
     1689+ 
     1690+out: 
     1691+       return error; 
     1692+} 
     1693+ 
     1694+static u8 ssb_sdio_read8(struct ssb_device *dev, u16 offset) 
     1695+{ 
     1696+       struct ssb_bus *bus = dev->bus; 
     1697+       u8 val = 0xff; 
     1698+       int error = 0; 
     1699+ 
     1700+       sdio_claim_host(bus->host_sdio); 
     1701+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1702+               goto out; 
     1703+       offset |= bus->sdio_sbaddr & 0xffff; 
     1704+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1705+       val = sdio_readb(bus->host_sdio, offset, &error); 
     1706+       if (error) { 
     1707+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %02x, error %d\n", 
     1708+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1709+       } 
     1710+out: 
     1711+       sdio_release_host(bus->host_sdio); 
     1712+ 
     1713+       return val; 
     1714+} 
     1715+ 
     1716+static u16 ssb_sdio_read16(struct ssb_device *dev, u16 offset) 
     1717+{ 
     1718+       struct ssb_bus *bus = dev->bus; 
     1719+       u16 val = 0xffff; 
     1720+       int error = 0; 
     1721+ 
     1722+       sdio_claim_host(bus->host_sdio); 
     1723+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1724+               goto out; 
     1725+       offset |= bus->sdio_sbaddr & 0xffff; 
     1726+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1727+       val = sdio_readw(bus->host_sdio, offset, &error); 
     1728+       if (error) { 
     1729+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %04x, error %d\n", 
     1730+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1731+       } 
     1732+out: 
     1733+       sdio_release_host(bus->host_sdio); 
     1734+ 
     1735+       return val; 
     1736+} 
     1737+ 
     1738+static u32 ssb_sdio_read32(struct ssb_device *dev, u16 offset) 
     1739+{ 
     1740+       struct ssb_bus *bus = dev->bus; 
     1741+       u32 val = 0xffffffff; 
     1742+       int error = 0; 
     1743+ 
     1744+       sdio_claim_host(bus->host_sdio); 
     1745+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1746+               goto out; 
     1747+       offset |= bus->sdio_sbaddr & 0xffff; 
     1748+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1749+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1750+       val = sdio_readl(bus->host_sdio, offset, &error); 
     1751+       if (error) { 
     1752+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X > %08x, error %d\n", 
     1753+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1754+       } 
     1755+out: 
     1756+       sdio_release_host(bus->host_sdio); 
     1757+ 
     1758+       return val; 
     1759+} 
     1760+ 
     1761+#ifdef CONFIG_SSB_BLOCKIO 
     1762+static void ssb_sdio_block_read(struct ssb_device *dev, void *buffer, 
     1763+                                 size_t count, u16 offset, u8 reg_width) 
     1764+{ 
     1765+       size_t saved_count = count; 
     1766+       struct ssb_bus *bus = dev->bus; 
     1767+       int error = 0; 
     1768+ 
     1769+       sdio_claim_host(bus->host_sdio); 
     1770+       if (unlikely(ssb_sdio_switch_core(bus, dev))) { 
     1771+               error = -EIO; 
     1772+               memset(buffer, 0xff, count); 
     1773+               goto err_out; 
     1774+       } 
     1775+       offset |= bus->sdio_sbaddr & 0xffff; 
     1776+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1777+ 
     1778+       switch (reg_width) { 
     1779+       case sizeof(u8): { 
     1780+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1781+               break; 
     1782+       } 
     1783+       case sizeof(u16): { 
     1784+               SSB_WARN_ON(count & 1); 
     1785+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1786+               break; 
     1787+       } 
     1788+       case sizeof(u32): { 
     1789+               SSB_WARN_ON(count & 3); 
     1790+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1791+               error = sdio_readsb(bus->host_sdio, buffer, offset, count); 
     1792+               break; 
     1793+       } 
     1794+       default: 
     1795+               SSB_WARN_ON(1); 
     1796+       } 
     1797+       if (!error) 
     1798+               goto out; 
     1799+ 
     1800+err_out: 
     1801+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 
     1802+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 
     1803+out: 
     1804+       sdio_release_host(bus->host_sdio); 
     1805+} 
     1806+#endif /* CONFIG_SSB_BLOCKIO */ 
     1807+ 
     1808+static void ssb_sdio_write8(struct ssb_device *dev, u16 offset, u8 val) 
     1809+{ 
     1810+       struct ssb_bus *bus = dev->bus; 
     1811+       int error = 0; 
     1812+ 
     1813+       sdio_claim_host(bus->host_sdio); 
     1814+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1815+               goto out; 
     1816+       offset |= bus->sdio_sbaddr & 0xffff; 
     1817+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1818+       sdio_writeb(bus->host_sdio, val, offset, &error); 
     1819+       if (error) { 
     1820+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %02x, error %d\n", 
     1821+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1822+       } 
     1823+out: 
     1824+       sdio_release_host(bus->host_sdio); 
     1825+} 
     1826+ 
     1827+static void ssb_sdio_write16(struct ssb_device *dev, u16 offset, u16 val) 
     1828+{ 
     1829+       struct ssb_bus *bus = dev->bus; 
     1830+       int error = 0; 
     1831+ 
     1832+       sdio_claim_host(bus->host_sdio); 
     1833+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1834+               goto out; 
     1835+       offset |= bus->sdio_sbaddr & 0xffff; 
     1836+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1837+       sdio_writew(bus->host_sdio, val, offset, &error); 
     1838+       if (error) { 
     1839+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %04x, error %d\n", 
     1840+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1841+       } 
     1842+out: 
     1843+       sdio_release_host(bus->host_sdio); 
     1844+} 
     1845+ 
     1846+static void ssb_sdio_write32(struct ssb_device *dev, u16 offset, u32 val) 
     1847+{ 
     1848+       struct ssb_bus *bus = dev->bus; 
     1849+       int error = 0; 
     1850+ 
     1851+       sdio_claim_host(bus->host_sdio); 
     1852+       if (unlikely(ssb_sdio_switch_core(bus, dev))) 
     1853+               goto out; 
     1854+       offset |= bus->sdio_sbaddr & 0xffff; 
     1855+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1856+       offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1857+       sdio_writel(bus->host_sdio, val, offset, &error); 
     1858+       if (error) { 
     1859+               dev_dbg(ssb_sdio_dev(bus), "%04X:%04X < %08x, error %d\n", 
     1860+                       bus->sdio_sbaddr >> 16, offset, val, error); 
     1861+       } 
     1862+       if (bus->quirks & SSB_QUIRK_SDIO_READ_AFTER_WRITE32) 
     1863+               sdio_readl(bus->host_sdio, 0, &error); 
     1864+out: 
     1865+       sdio_release_host(bus->host_sdio); 
     1866+} 
     1867+ 
     1868+#ifdef CONFIG_SSB_BLOCKIO 
     1869+static void ssb_sdio_block_write(struct ssb_device *dev, const void *buffer, 
     1870+                                  size_t count, u16 offset, u8 reg_width) 
     1871+{ 
     1872+       size_t saved_count = count; 
     1873+       struct ssb_bus *bus = dev->bus; 
     1874+       int error = 0; 
     1875+ 
     1876+       sdio_claim_host(bus->host_sdio); 
     1877+       if (unlikely(ssb_sdio_switch_core(bus, dev))) { 
     1878+               error = -EIO; 
     1879+               memset((void *)buffer, 0xff, count); 
     1880+               goto err_out; 
     1881+       } 
     1882+       offset |= bus->sdio_sbaddr & 0xffff; 
     1883+       offset &= SBSDIO_SB_OFT_ADDR_MASK; 
     1884+ 
     1885+       switch (reg_width) { 
     1886+       case sizeof(u8): 
     1887+               error = sdio_writesb(bus->host_sdio, offset, 
     1888+                                    (void *)buffer, count); 
     1889+               break; 
     1890+       case sizeof(u16): 
     1891+               SSB_WARN_ON(count & 1); 
     1892+               error = sdio_writesb(bus->host_sdio, offset, 
     1893+                                    (void *)buffer, count); 
     1894+               break; 
     1895+       case sizeof(u32): 
     1896+               SSB_WARN_ON(count & 3); 
     1897+               offset |= SBSDIO_SB_ACCESS_2_4B_FLAG;   /* 32 bit data access */ 
     1898+               error = sdio_writesb(bus->host_sdio, offset, 
     1899+                                    (void *)buffer, count); 
     1900+               break; 
     1901+       default: 
     1902+               SSB_WARN_ON(1); 
     1903+       } 
     1904+       if (!error) 
     1905+               goto out; 
     1906+ 
     1907+err_out: 
     1908+       dev_dbg(ssb_sdio_dev(bus), "%04X:%04X (width=%u, len=%zu), error %d\n", 
     1909+               bus->sdio_sbaddr >> 16, offset, reg_width, saved_count, error); 
     1910+out: 
     1911+       sdio_release_host(bus->host_sdio); 
     1912+} 
     1913+ 
     1914+#endif /* CONFIG_SSB_BLOCKIO */ 
     1915+ 
     1916+/* Not "static", as it's used in main.c */ 
     1917+const struct ssb_bus_ops ssb_sdio_ops = { 
     1918+       .read8          = ssb_sdio_read8, 
     1919+       .read16         = ssb_sdio_read16, 
     1920+       .read32         = ssb_sdio_read32, 
     1921+       .write8         = ssb_sdio_write8, 
     1922+       .write16        = ssb_sdio_write16, 
     1923+       .write32        = ssb_sdio_write32, 
     1924+#ifdef CONFIG_SSB_BLOCKIO 
     1925+       .block_read     = ssb_sdio_block_read, 
     1926+       .block_write    = ssb_sdio_block_write, 
     1927+#endif 
     1928+}; 
     1929+ 
     1930+#define GOTO_ERROR_ON(condition, description) do {     \ 
     1931+       if (unlikely(condition)) {                      \ 
     1932+               error_description = description;        \ 
     1933+               goto error;                             \ 
     1934+       }                                               \ 
     1935+  } while (0) 
     1936+ 
     1937+int ssb_sdio_get_invariants(struct ssb_bus *bus, 
     1938+                           struct ssb_init_invariants *iv) 
     1939+{ 
     1940+       struct ssb_sprom *sprom = &iv->sprom; 
     1941+       struct ssb_boardinfo *bi = &iv->boardinfo; 
     1942+       const char *error_description = "none"; 
     1943+       struct sdio_func_tuple *tuple; 
     1944+       void *mac; 
     1945+ 
     1946+       memset(sprom, 0xFF, sizeof(*sprom)); 
     1947+       sprom->boardflags_lo = 0; 
     1948+       sprom->boardflags_hi = 0; 
     1949+ 
     1950+       tuple = bus->host_sdio->tuples; 
     1951+       while (tuple) { 
     1952+               switch (tuple->code) { 
     1953+               case 0x22: /* extended function */ 
     1954+                       switch (tuple->data[0]) { 
     1955+                       case CISTPL_FUNCE_LAN_NODE_ID: 
     1956+                               GOTO_ERROR_ON((tuple->size != 7) && 
     1957+                                             (tuple->data[1] != 6), 
     1958+                                             "mac tpl size"); 
     1959+                               /* fetch the MAC address. */ 
     1960+                               mac = tuple->data + 2; 
     1961+                               memcpy(sprom->il0mac, mac, ETH_ALEN); 
     1962+                               memcpy(sprom->et1mac, mac, ETH_ALEN); 
     1963+                               break; 
     1964+                       default: 
     1965+                               break; 
     1966+                       } 
     1967+                       break; 
     1968+               case 0x80: /* vendor specific tuple */ 
     1969+                       switch (tuple->data[0]) { 
     1970+                       case SSB_SDIO_CIS_SROMREV: 
     1971+                               GOTO_ERROR_ON(tuple->size != 2, 
     1972+                                             "sromrev tpl size"); 
     1973+                               sprom->revision = tuple->data[1]; 
     1974+                               break; 
     1975+                       case SSB_SDIO_CIS_ID: 
     1976+                               GOTO_ERROR_ON((tuple->size != 5) && 
     1977+                                             (tuple->size != 7), 
     1978+                                             "id tpl size"); 
     1979+                               bi->vendor = tuple->data[1] | 
     1980+                                            (tuple->data[2]<<8); 
     1981+                               break; 
     1982+                       case SSB_SDIO_CIS_BOARDREV: 
     1983+                               GOTO_ERROR_ON(tuple->size != 2, 
     1984+                                             "boardrev tpl size"); 
     1985+                               sprom->board_rev = tuple->data[1]; 
     1986+                               break; 
     1987+                       case SSB_SDIO_CIS_PA: 
     1988+                               GOTO_ERROR_ON((tuple->size != 9) && 
     1989+                                             (tuple->size != 10), 
     1990+                                             "pa tpl size"); 
     1991+                               sprom->pa0b0 = tuple->data[1] | 
     1992+                                        ((u16)tuple->data[2] << 8); 
     1993+                               sprom->pa0b1 = tuple->data[3] | 
     1994+                                        ((u16)tuple->data[4] << 8); 
     1995+                               sprom->pa0b2 = tuple->data[5] | 
     1996+                                        ((u16)tuple->data[6] << 8); 
     1997+                               sprom->itssi_a = tuple->data[7]; 
     1998+                               sprom->itssi_bg = tuple->data[7]; 
     1999+                               sprom->maxpwr_a = tuple->data[8]; 
     2000+                               sprom->maxpwr_bg = tuple->data[8]; 
     2001+                               break; 
     2002+                       case SSB_SDIO_CIS_OEMNAME: 
     2003+                               /* Not present */ 
     2004+                               break; 
     2005+                       case SSB_SDIO_CIS_CCODE: 
     2006+                               GOTO_ERROR_ON(tuple->size != 2, 
     2007+                                             "ccode tpl size"); 
     2008+                               sprom->country_code = tuple->data[1]; 
     2009+                               break; 
     2010+                       case SSB_SDIO_CIS_ANTENNA: 
     2011+                               GOTO_ERROR_ON(tuple->size != 2, 
     2012+                                             "ant tpl size"); 
     2013+                               sprom->ant_available_a = tuple->data[1]; 
     2014+                               sprom->ant_available_bg = tuple->data[1]; 
     2015+                               break; 
     2016+                       case SSB_SDIO_CIS_ANTGAIN: 
     2017+                               GOTO_ERROR_ON(tuple->size != 2, 
     2018+                                             "antg tpl size"); 
     2019+                               sprom->antenna_gain.ghz24.a0 = tuple->data[1]; 
     2020+                               sprom->antenna_gain.ghz24.a1 = tuple->data[1]; 
     2021+                               sprom->antenna_gain.ghz24.a2 = tuple->data[1]; 
     2022+                               sprom->antenna_gain.ghz24.a3 = tuple->data[1]; 
     2023+                               sprom->antenna_gain.ghz5.a0 = tuple->data[1]; 
     2024+                               sprom->antenna_gain.ghz5.a1 = tuple->data[1]; 
     2025+                               sprom->antenna_gain.ghz5.a2 = tuple->data[1]; 
     2026+                               sprom->antenna_gain.ghz5.a3 = tuple->data[1]; 
     2027+                               break; 
     2028+                       case SSB_SDIO_CIS_BFLAGS: 
     2029+                               GOTO_ERROR_ON((tuple->size != 3) && 
     2030+                                             (tuple->size != 5), 
     2031+                                             "bfl tpl size"); 
     2032+                               sprom->boardflags_lo = tuple->data[1] | 
     2033+                                                ((u16)tuple->data[2] << 8); 
     2034+                               break; 
     2035+                       case SSB_SDIO_CIS_LEDS: 
     2036+                               GOTO_ERROR_ON(tuple->size != 5, 
     2037+                                             "leds tpl size"); 
     2038+                               sprom->gpio0 = tuple->data[1]; 
     2039+                               sprom->gpio1 = tuple->data[2]; 
     2040+                               sprom->gpio2 = tuple->data[3]; 
     2041+                               sprom->gpio3 = tuple->data[4]; 
     2042+                               break; 
     2043+                       default: 
     2044+                               break; 
     2045+                       } 
     2046+                       break; 
     2047+               default: 
     2048+                       break; 
     2049+               } 
     2050+               tuple = tuple->next; 
     2051+       } 
     2052+ 
     2053+       return 0; 
     2054+error: 
     2055+       dev_err(ssb_sdio_dev(bus), "failed to fetch device invariants: %s\n", 
     2056+               error_description); 
     2057+       return -ENODEV; 
     2058+} 
     2059+ 
     2060+void ssb_sdio_exit(struct ssb_bus *bus) 
     2061+{ 
     2062+       if (bus->bustype != SSB_BUSTYPE_SDIO) 
     2063+               return; 
     2064+       /* Nothing to do here. */ 
     2065+} 
     2066+ 
     2067+int ssb_sdio_init(struct ssb_bus *bus) 
     2068+{ 
     2069+       if (bus->bustype != SSB_BUSTYPE_SDIO) 
     2070+               return 0; 
     2071+ 
     2072+       bus->sdio_sbaddr = ~0; 
     2073+ 
     2074+       return 0; 
     2075+} 
     2076--- a/drivers/ssb/sprom.c 
     2077+++ b/drivers/ssb/sprom.c 
     2078@@ -14,6 +14,7 @@ 
     2079 #include "ssb_private.h" 
     2080  
     2081 #include <linux/ctype.h> 
     2082+#include <linux/slab.h> 
     2083  
     2084  
     2085 static const struct ssb_sprom *fallback_sprom; 
     2086@@ -102,6 +103,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     2087        u16 *sprom; 
     2088        int res = 0, err = -ENOMEM; 
     2089        size_t sprom_size_words = bus->sprom_size; 
     2090+       struct ssb_freeze_context freeze; 
     2091  
     2092        sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL); 
     2093        if (!sprom) 
     2094@@ -123,18 +125,13 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     2095        err = -ERESTARTSYS; 
     2096        if (mutex_lock_interruptible(&bus->sprom_mutex)) 
     2097                goto out_kfree; 
     2098-       err = ssb_devices_freeze(bus); 
     2099-       if (err == -EOPNOTSUPP) { 
     2100-               ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. " 
     2101-                          "No suspend support. Is CONFIG_PM enabled?\n"); 
     2102-               goto out_unlock; 
     2103-       } 
     2104+       err = ssb_devices_freeze(bus, &freeze); 
     2105        if (err) { 
     2106                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n"); 
     2107                goto out_unlock; 
     2108        } 
     2109        res = sprom_write(bus, sprom); 
     2110-       err = ssb_devices_thaw(bus); 
     2111+       err = ssb_devices_thaw(&freeze); 
     2112        if (err) 
     2113                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
     2114 out_unlock: 
     2115@@ -179,3 +176,18 @@ const struct ssb_sprom *ssb_get_fallback 
     2116 { 
     2117        return fallback_sprom; 
     2118 } 
     2119+ 
     2120+/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     2121+bool ssb_is_sprom_available(struct ssb_bus *bus) 
     2122+{ 
     2123+       /* status register only exists on chipcomon rev >= 11 and we need check 
     2124+          for >= 31 only */ 
     2125+       /* this routine differs from specs as we do not access SPROM directly 
     2126+          on PCMCIA */ 
     2127+       if (bus->bustype == SSB_BUSTYPE_PCI && 
     2128+           bus->chipco.dev &&  /* can be unavailible! */ 
     2129+           bus->chipco.dev->id.revision >= 31) 
     2130+               return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
     2131+ 
     2132+       return true; 
     2133+} 
     2134--- a/drivers/ssb/ssb_private.h 
     2135+++ b/drivers/ssb/ssb_private.h 
     2136@@ -114,6 +114,46 @@ static inline int ssb_pcmcia_init(struct 
     2137 } 
     2138 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     2139  
     2140+/* sdio.c */ 
     2141+#ifdef CONFIG_SSB_SDIOHOST 
     2142+extern int ssb_sdio_get_invariants(struct ssb_bus *bus, 
     2143+                                    struct ssb_init_invariants *iv); 
     2144+ 
     2145+extern u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset); 
     2146+extern int ssb_sdio_switch_core(struct ssb_bus *bus, struct ssb_device *dev); 
     2147+extern int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx); 
     2148+extern int ssb_sdio_hardware_setup(struct ssb_bus *bus); 
     2149+extern void ssb_sdio_exit(struct ssb_bus *bus); 
     2150+extern int ssb_sdio_init(struct ssb_bus *bus); 
     2151+ 
     2152+extern const struct ssb_bus_ops ssb_sdio_ops; 
     2153+#else /* CONFIG_SSB_SDIOHOST */ 
     2154+static inline u32 ssb_sdio_scan_read32(struct ssb_bus *bus, u16 offset) 
     2155+{ 
     2156+       return 0; 
     2157+} 
     2158+static inline int ssb_sdio_switch_core(struct ssb_bus *bus, 
     2159+                                        struct ssb_device *dev) 
     2160+{ 
     2161+       return 0; 
     2162+} 
     2163+static inline int ssb_sdio_scan_switch_coreidx(struct ssb_bus *bus, u8 coreidx) 
     2164+{ 
     2165+       return 0; 
     2166+} 
     2167+static inline int ssb_sdio_hardware_setup(struct ssb_bus *bus) 
     2168+{ 
     2169+       return 0; 
     2170+} 
     2171+static inline void ssb_sdio_exit(struct ssb_bus *bus) 
     2172+{ 
     2173+} 
     2174+static inline int ssb_sdio_init(struct ssb_bus *bus) 
     2175+{ 
     2176+       return 0; 
     2177+} 
     2178+#endif /* CONFIG_SSB_SDIOHOST */ 
     2179+ 
     2180  
     2181 /* scan.c */ 
     2182 extern const char *ssb_core_name(u16 coreid); 
     2183@@ -136,19 +176,27 @@ extern const struct ssb_sprom *ssb_get_f 
     2184  
     2185 /* core.c */ 
     2186 extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m); 
     2187-extern int ssb_devices_freeze(struct ssb_bus *bus); 
     2188-extern int ssb_devices_thaw(struct ssb_bus *bus); 
     2189 extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev); 
     2190 int ssb_for_each_bus_call(unsigned long data, 
     2191                          int (*func)(struct ssb_bus *bus, unsigned long data)); 
     2192 extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev); 
     2193  
     2194+struct ssb_freeze_context { 
     2195+       /* Pointer to the bus */ 
     2196+       struct ssb_bus *bus; 
     2197+       /* Boolean list to indicate whether a device is frozen on this bus. */ 
     2198+       bool device_frozen[SSB_MAX_NR_CORES]; 
     2199+}; 
     2200+extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx); 
     2201+extern int ssb_devices_thaw(struct ssb_freeze_context *ctx); 
     2202+ 
     2203+ 
     2204  
     2205 /* b43_pci_bridge.c */ 
     2206 #ifdef CONFIG_SSB_B43_PCI_BRIDGE 
     2207 extern int __init b43_pci_ssb_bridge_init(void); 
     2208 extern void __exit b43_pci_ssb_bridge_exit(void); 
     2209-#else /* CONFIG_SSB_B43_PCI_BRIDGR */ 
     2210+#else /* CONFIG_SSB_B43_PCI_BRIDGE */ 
     2211 static inline int b43_pci_ssb_bridge_init(void) 
     2212 { 
     2213        return 0; 
     2214@@ -156,6 +204,6 @@ static inline int b43_pci_ssb_bridge_ini 
     2215 static inline void b43_pci_ssb_bridge_exit(void) 
     2216 { 
     2217 } 
     2218-#endif /* CONFIG_SSB_PCIHOST */ 
     2219+#endif /* CONFIG_SSB_B43_PCI_BRIDGE */ 
     2220  
     2221 #endif /* LINUX_SSB_PRIVATE_H_ */ 
     2222--- a/include/linux/pci_ids.h 
     2223+++ b/include/linux/pci_ids.h 
     2224@@ -2017,6 +2017,7 @@ 
     2225 #define PCI_DEVICE_ID_AFAVLAB_P030     0x2182 
     2226 #define PCI_SUBDEVICE_ID_AFAVLAB_P061          0x2150 
     2227  
     2228+#define PCI_VENDOR_ID_BCM_GVC          0x14a4 
     2229 #define PCI_VENDOR_ID_BROADCOM         0x14e4 
     2230 #define PCI_DEVICE_ID_TIGON3_5752      0x1600 
     2231 #define PCI_DEVICE_ID_TIGON3_5752M     0x1601 
    2762232--- a/include/linux/ssb/ssb.h 
    2772233+++ b/include/linux/ssb/ssb.h 
    278 @@ -27,24 +27,54 @@ struct ssb_sprom { 
     2234@@ -27,24 +27,58 @@ struct ssb_sprom { 
    2792235        u8 et1mdcport;          /* MDIO for enet1 */ 
    2802236        u8 board_rev;           /* Board revision number from SPROM. */ 
     
    3142270+       u8 tri5g;               /* 5.3GHz TX isolation */ 
    3152271+       u8 tri5gh;              /* 5.8GHz TX isolation */ 
     2272+       u8 txpid2g[4];          /* 2GHz TX power index */ 
     2273+       u8 txpid5gl[4];         /* 4.9 - 5.1GHz TX power index */ 
     2274+       u8 txpid5g[4];          /* 5.1 - 5.5GHz TX power index */ 
     2275+       u8 txpid5gh[4];         /* 5.5 - ...GHz TX power index */ 
    3162276+       u8 rxpo2g;              /* 2GHz RX power offset */ 
    3172277+       u8 rxpo5g;              /* 5GHz RX power offset */ 
     
    3372297        /* Antenna gain values for up to 4 antennas 
    3382298         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    339 @@ -58,7 +88,7 @@ struct ssb_sprom { 
     2299@@ -58,7 +92,7 @@ struct ssb_sprom { 
    3402300                } ghz5;         /* 5GHz band */ 
    3412301        } antenna_gain; 
     
    3462306  
    3472307 /* Information about the PCB the circuitry is soldered on. */ 
    348 @@ -208,6 +238,7 @@ enum ssb_bustype { 
     2308@@ -137,7 +171,7 @@ struct ssb_device { 
     2309         * is an optimization. */ 
     2310        const struct ssb_bus_ops *ops; 
     2311  
     2312-       struct device *dev; 
     2313+       struct device *dev, *dma_dev; 
     2314  
     2315        struct ssb_bus *bus; 
     2316        struct ssb_device_id id; 
     2317@@ -208,6 +242,7 @@ enum ssb_bustype { 
    3492318        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */ 
    3502319        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
     
    3542323  
    3552324 /* board_vendor */ 
    356 @@ -240,8 +271,12 @@ struct ssb_bus { 
    357   
    358         /* The core in the basic address register window. (PCI bus only) */ 
     2325@@ -238,20 +273,33 @@ struct ssb_bus { 
     2326  
     2327        const struct ssb_bus_ops *ops; 
     2328  
     2329-       /* The core in the basic address register window. (PCI bus only) */ 
     2330+       /* The core currently mapped into the MMIO window. 
     2331+        * Not valid on all host-buses. So don't use outside of SSB. */ 
    3592332        struct ssb_device *mapped_device; 
    3602333-       /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
     
    3692342         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    3702343        spinlock_t bar_lock; 
    371 @@ -252,6 +287,11 @@ struct ssb_bus { 
    372         struct pci_dev *host_pci; 
    373         /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
    374         struct pcmcia_device *host_pcmcia; 
    375 +       /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
    376 +       struct sdio_func *host_sdio; 
     2344  
     2345-       /* The bus this backplane is running on. */ 
     2346+       /* The host-bus this backplane is running on. */ 
     2347        enum ssb_bustype bustype; 
     2348-       /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
     2349-       struct pci_dev *host_pci; 
     2350-       /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
     2351-       struct pcmcia_device *host_pcmcia; 
     2352+       /* Pointers to the host-bus. Check bustype before using any of these pointers. */ 
     2353+       union { 
     2354+               /* Pointer to the PCI bus (only valid if bustype == SSB_BUSTYPE_PCI). */ 
     2355+               struct pci_dev *host_pci; 
     2356+               /* Pointer to the PCMCIA device (only if bustype == SSB_BUSTYPE_PCMCIA). */ 
     2357+               struct pcmcia_device *host_pcmcia; 
     2358+               /* Pointer to the SDIO device (only if bustype == SSB_BUSTYPE_SDIO). */ 
     2359+               struct sdio_func *host_sdio; 
     2360+       }; 
    3772361+ 
    3782362+       /* See enum ssb_quirks */ 
     
    3812365 #ifdef CONFIG_SSB_SPROM 
    3822366        /* Mutex to protect the SPROM writing. */ 
    383 @@ -306,6 +346,11 @@ struct ssb_bus { 
     2367@@ -261,6 +309,7 @@ struct ssb_bus { 
     2368        /* ID information about the Chip. */ 
     2369        u16 chip_id; 
     2370        u16 chip_rev; 
     2371+       u16 sprom_offset; 
     2372        u16 sprom_size;         /* number of words in sprom */ 
     2373        u8 chip_package; 
     2374  
     2375@@ -306,6 +355,11 @@ struct ssb_bus { 
    3842376 #endif /* DEBUG */ 
    3852377 }; 
     
    3932385 struct ssb_init_invariants { 
    3942386        /* Versioning information about the PCB. */ 
     2387@@ -336,9 +390,18 @@ extern int ssb_bus_pcmciabus_register(st 
     2388                                      struct pcmcia_device *pcmcia_dev, 
     2389                                      unsigned long baseaddr); 
     2390 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     2391+#ifdef CONFIG_SSB_SDIOHOST 
     2392+extern int ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     2393+                                   struct sdio_func *sdio_func, 
     2394+                                   unsigned int quirks); 
     2395+#endif /* CONFIG_SSB_SDIOHOST */ 
     2396+ 
     2397  
     2398 extern void ssb_bus_unregister(struct ssb_bus *bus); 
     2399  
     2400+/* Does the device have an SPROM? */ 
     2401+extern bool ssb_is_sprom_available(struct ssb_bus *bus); 
     2402+ 
     2403 /* Set a fallback SPROM. 
     2404  * See kdoc at the function definition for complete documentation. */ 
     2405 extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
    3952406--- a/include/linux/ssb/ssb_driver_chipcommon.h 
    3962407+++ b/include/linux/ssb/ssb_driver_chipcommon.h 
    397 @@ -629,5 +629,15 @@ extern int ssb_chipco_serial_init(struct 
     2408@@ -53,6 +53,7 @@ 
     2409 #define  SSB_CHIPCO_CAP_64BIT          0x08000000      /* 64-bit Backplane */ 
     2410 #define  SSB_CHIPCO_CAP_PMU            0x10000000      /* PMU available (rev >= 20) */ 
     2411 #define  SSB_CHIPCO_CAP_ECI            0x20000000      /* ECI available (rev >= 20) */ 
     2412+#define  SSB_CHIPCO_CAP_SPROM          0x40000000      /* SPROM present */ 
     2413 #define SSB_CHIPCO_CORECTL             0x0008 
     2414 #define  SSB_CHIPCO_CORECTL_UARTCLK0   0x00000001      /* Drive UART with internal clock */ 
     2415 #define         SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */ 
     2416@@ -385,6 +386,7 @@ 
     2417  
     2418  
     2419 /** Chip specific Chip-Status register contents. */ 
     2420+#define SSB_CHIPCO_CHST_4322_SPROM_EXISTS      0x00000040 /* SPROM present */ 
     2421 #define SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL     0x00000003 
     2422 #define SSB_CHIPCO_CHST_4325_DEFCIS_SEL                0 /* OTP is powered up, use def. CIS, no SPROM */ 
     2423 #define SSB_CHIPCO_CHST_4325_SPROM_SEL         1 /* OTP is powered up, SPROM is present */ 
     2424@@ -398,6 +400,18 @@ 
     2425 #define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT  4 
     2426 #define SSB_CHIPCO_CHST_4325_PMUTOP_2B                 0x00000200 /* 1 for 2b, 0 for to 2a */ 
     2427  
     2428+/** Macros to determine SPROM presence based on Chip-Status register. */ 
     2429+#define SSB_CHIPCO_CHST_4312_SPROM_PRESENT(status) \ 
     2430+       ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     2431+               SSB_CHIPCO_CHST_4325_OTP_SEL) 
     2432+#define SSB_CHIPCO_CHST_4322_SPROM_PRESENT(status) \ 
     2433+       (status & SSB_CHIPCO_CHST_4322_SPROM_EXISTS) 
     2434+#define SSB_CHIPCO_CHST_4325_SPROM_PRESENT(status) \ 
     2435+       (((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     2436+               SSB_CHIPCO_CHST_4325_DEFCIS_SEL) && \ 
     2437+        ((status & SSB_CHIPCO_CHST_4325_SPROM_OTP_SEL) != \ 
     2438+               SSB_CHIPCO_CHST_4325_OTP_SEL)) 
     2439+ 
     2440  
     2441  
     2442 /** Clockcontrol masks and values **/ 
     2443@@ -564,6 +578,7 @@ struct ssb_chipcommon_pmu { 
     2444 struct ssb_chipcommon { 
     2445        struct ssb_device *dev; 
     2446        u32 capabilities; 
     2447+       u32 status; 
     2448        /* Fast Powerup Delay constant */ 
     2449        u16 fast_pwrup_delay; 
     2450        struct ssb_chipcommon_pmu pmu; 
     2451@@ -629,5 +644,15 @@ extern int ssb_chipco_serial_init(struct 
    3982452 /* PMU support */ 
    3992453 extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
     
    4132467--- a/include/linux/ssb/ssb_regs.h 
    4142468+++ b/include/linux/ssb/ssb_regs.h 
    415 @@ -162,7 +162,7 @@ 
     2469@@ -85,6 +85,8 @@ 
     2470 #define  SSB_IMSTATE_AP_RSV    0x00000030 /* Reserved */ 
     2471 #define  SSB_IMSTATE_IBE       0x00020000 /* In Band Error */ 
     2472 #define  SSB_IMSTATE_TO                0x00040000 /* Timeout */ 
     2473+#define  SSB_IMSTATE_BUSY      0x01800000 /* Busy (Backplane rev >= 2.3 only) */ 
     2474+#define  SSB_IMSTATE_REJECT    0x02000000 /* Reject (Backplane rev >= 2.3 only) */ 
     2475 #define SSB_INTVEC             0x0F94     /* SB Interrupt Mask */ 
     2476 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
     2477 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     2478@@ -162,7 +164,7 @@ 
    4162479  
    4172480 /* SPROM shadow area. If not otherwise noted, fields are 
     
    4222485 #define SSB_SPROMSIZE_WORDS            64 
    4232486 #define SSB_SPROMSIZE_BYTES            (SSB_SPROMSIZE_WORDS * sizeof(u16)) 
    424 @@ -327,8 +327,11 @@ 
     2487@@ -170,26 +172,27 @@ 
     2488 #define SSB_SPROMSIZE_WORDS_R4         220 
     2489 #define SSB_SPROMSIZE_BYTES_R123       (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16)) 
     2490 #define SSB_SPROMSIZE_BYTES_R4         (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16)) 
     2491-#define SSB_SPROM_BASE                 0x1000 
     2492-#define SSB_SPROM_REVISION             0x107E 
     2493+#define SSB_SPROM_BASE1                        0x1000 
     2494+#define SSB_SPROM_BASE31               0x0800 
     2495+#define SSB_SPROM_REVISION             0x007E 
     2496 #define  SSB_SPROM_REVISION_REV                0x00FF  /* SPROM Revision number */ 
     2497 #define  SSB_SPROM_REVISION_CRC                0xFF00  /* SPROM CRC8 value */ 
     2498 #define  SSB_SPROM_REVISION_CRC_SHIFT  8 
     2499  
     2500 /* SPROM Revision 1 */ 
     2501-#define SSB_SPROM1_SPID                        0x1004  /* Subsystem Product ID for PCI */ 
     2502-#define SSB_SPROM1_SVID                        0x1006  /* Subsystem Vendor ID for PCI */ 
     2503-#define SSB_SPROM1_PID                 0x1008  /* Product ID for PCI */ 
     2504-#define SSB_SPROM1_IL0MAC              0x1048  /* 6 bytes MAC address for 802.11b/g */ 
     2505-#define SSB_SPROM1_ET0MAC              0x104E  /* 6 bytes MAC address for Ethernet */ 
     2506-#define SSB_SPROM1_ET1MAC              0x1054  /* 6 bytes MAC address for 802.11a */ 
     2507-#define SSB_SPROM1_ETHPHY              0x105A  /* Ethernet PHY settings */ 
     2508+#define SSB_SPROM1_SPID                        0x0004  /* Subsystem Product ID for PCI */ 
     2509+#define SSB_SPROM1_SVID                        0x0006  /* Subsystem Vendor ID for PCI */ 
     2510+#define SSB_SPROM1_PID                 0x0008  /* Product ID for PCI */ 
     2511+#define SSB_SPROM1_IL0MAC              0x0048  /* 6 bytes MAC address for 802.11b/g */ 
     2512+#define SSB_SPROM1_ET0MAC              0x004E  /* 6 bytes MAC address for Ethernet */ 
     2513+#define SSB_SPROM1_ET1MAC              0x0054  /* 6 bytes MAC address for 802.11a */ 
     2514+#define SSB_SPROM1_ETHPHY              0x005A  /* Ethernet PHY settings */ 
     2515 #define  SSB_SPROM1_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */ 
     2516 #define  SSB_SPROM1_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */ 
     2517 #define  SSB_SPROM1_ETHPHY_ET1A_SHIFT  5 
     2518 #define  SSB_SPROM1_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */ 
     2519 #define  SSB_SPROM1_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */ 
     2520-#define SSB_SPROM1_BINF                        0x105C  /* Board info */ 
     2521+#define SSB_SPROM1_BINF                        0x005C  /* Board info */ 
     2522 #define  SSB_SPROM1_BINF_BREV          0x00FF  /* Board Revision */ 
     2523 #define  SSB_SPROM1_BINF_CCODE         0x0F00  /* Country Code */ 
     2524 #define  SSB_SPROM1_BINF_CCODE_SHIFT   8 
     2525@@ -197,63 +200,63 @@ 
     2526 #define  SSB_SPROM1_BINF_ANTBG_SHIFT   12 
     2527 #define  SSB_SPROM1_BINF_ANTA          0xC000  /* Available A-PHY antennas */ 
     2528 #define  SSB_SPROM1_BINF_ANTA_SHIFT    14 
     2529-#define SSB_SPROM1_PA0B0               0x105E 
     2530-#define SSB_SPROM1_PA0B1               0x1060 
     2531-#define SSB_SPROM1_PA0B2               0x1062 
     2532-#define SSB_SPROM1_GPIOA               0x1064  /* General Purpose IO pins 0 and 1 */ 
     2533+#define SSB_SPROM1_PA0B0               0x005E 
     2534+#define SSB_SPROM1_PA0B1               0x0060 
     2535+#define SSB_SPROM1_PA0B2               0x0062 
     2536+#define SSB_SPROM1_GPIOA               0x0064  /* General Purpose IO pins 0 and 1 */ 
     2537 #define  SSB_SPROM1_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2538 #define  SSB_SPROM1_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2539 #define  SSB_SPROM1_GPIOA_P1_SHIFT     8 
     2540-#define SSB_SPROM1_GPIOB               0x1066  /* General Purpuse IO pins 2 and 3 */ 
     2541+#define SSB_SPROM1_GPIOB               0x0066  /* General Purpuse IO pins 2 and 3 */ 
     2542 #define  SSB_SPROM1_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2543 #define  SSB_SPROM1_GPIOB_P3           0xFF00  /* Pin 3 */ 
     2544 #define  SSB_SPROM1_GPIOB_P3_SHIFT     8 
     2545-#define SSB_SPROM1_MAXPWR              0x1068  /* Power Amplifier Max Power */ 
     2546+#define SSB_SPROM1_MAXPWR              0x0068  /* Power Amplifier Max Power */ 
     2547 #define  SSB_SPROM1_MAXPWR_BG          0x00FF  /* B-PHY and G-PHY (in dBm Q5.2) */ 
     2548 #define  SSB_SPROM1_MAXPWR_A           0xFF00  /* A-PHY (in dBm Q5.2) */ 
     2549 #define  SSB_SPROM1_MAXPWR_A_SHIFT     8 
     2550-#define SSB_SPROM1_PA1B0               0x106A 
     2551-#define SSB_SPROM1_PA1B1               0x106C 
     2552-#define SSB_SPROM1_PA1B2               0x106E 
     2553-#define SSB_SPROM1_ITSSI               0x1070  /* Idle TSSI Target */ 
     2554+#define SSB_SPROM1_PA1B0               0x006A 
     2555+#define SSB_SPROM1_PA1B1               0x006C 
     2556+#define SSB_SPROM1_PA1B2               0x006E 
     2557+#define SSB_SPROM1_ITSSI               0x0070  /* Idle TSSI Target */ 
     2558 #define  SSB_SPROM1_ITSSI_BG           0x00FF  /* B-PHY and G-PHY*/ 
     2559 #define  SSB_SPROM1_ITSSI_A            0xFF00  /* A-PHY */ 
     2560 #define  SSB_SPROM1_ITSSI_A_SHIFT      8 
     2561-#define SSB_SPROM1_BFLLO               0x1072  /* Boardflags (low 16 bits) */ 
     2562-#define SSB_SPROM1_AGAIN               0x1074  /* Antenna Gain (in dBm Q5.2) */ 
     2563+#define SSB_SPROM1_BFLLO               0x0072  /* Boardflags (low 16 bits) */ 
     2564+#define SSB_SPROM1_AGAIN               0x0074  /* Antenna Gain (in dBm Q5.2) */ 
     2565 #define  SSB_SPROM1_AGAIN_BG           0x00FF  /* B-PHY and G-PHY */ 
     2566 #define  SSB_SPROM1_AGAIN_BG_SHIFT     0 
     2567 #define  SSB_SPROM1_AGAIN_A            0xFF00  /* A-PHY */ 
     2568 #define  SSB_SPROM1_AGAIN_A_SHIFT      8 
     2569  
     2570 /* SPROM Revision 2 (inherits from rev 1) */ 
     2571-#define SSB_SPROM2_BFLHI               0x1038  /* Boardflags (high 16 bits) */ 
     2572-#define SSB_SPROM2_MAXP_A              0x103A  /* A-PHY Max Power */ 
     2573+#define SSB_SPROM2_BFLHI               0x0038  /* Boardflags (high 16 bits) */ 
     2574+#define SSB_SPROM2_MAXP_A              0x003A  /* A-PHY Max Power */ 
     2575 #define  SSB_SPROM2_MAXP_A_HI          0x00FF  /* Max Power High */ 
     2576 #define  SSB_SPROM2_MAXP_A_LO          0xFF00  /* Max Power Low */ 
     2577 #define  SSB_SPROM2_MAXP_A_LO_SHIFT    8 
     2578-#define SSB_SPROM2_PA1LOB0             0x103C  /* A-PHY PowerAmplifier Low Settings */ 
     2579-#define SSB_SPROM2_PA1LOB1             0x103E  /* A-PHY PowerAmplifier Low Settings */ 
     2580-#define SSB_SPROM2_PA1LOB2             0x1040  /* A-PHY PowerAmplifier Low Settings */ 
     2581-#define SSB_SPROM2_PA1HIB0             0x1042  /* A-PHY PowerAmplifier High Settings */ 
     2582-#define SSB_SPROM2_PA1HIB1             0x1044  /* A-PHY PowerAmplifier High Settings */ 
     2583-#define SSB_SPROM2_PA1HIB2             0x1046  /* A-PHY PowerAmplifier High Settings */ 
     2584-#define SSB_SPROM2_OPO                 0x1078  /* OFDM Power Offset from CCK Level */ 
     2585+#define SSB_SPROM2_PA1LOB0             0x003C  /* A-PHY PowerAmplifier Low Settings */ 
     2586+#define SSB_SPROM2_PA1LOB1             0x003E  /* A-PHY PowerAmplifier Low Settings */ 
     2587+#define SSB_SPROM2_PA1LOB2             0x0040  /* A-PHY PowerAmplifier Low Settings */ 
     2588+#define SSB_SPROM2_PA1HIB0             0x0042  /* A-PHY PowerAmplifier High Settings */ 
     2589+#define SSB_SPROM2_PA1HIB1             0x0044  /* A-PHY PowerAmplifier High Settings */ 
     2590+#define SSB_SPROM2_PA1HIB2             0x0046  /* A-PHY PowerAmplifier High Settings */ 
     2591+#define SSB_SPROM2_OPO                 0x0078  /* OFDM Power Offset from CCK Level */ 
     2592 #define  SSB_SPROM2_OPO_VALUE          0x00FF 
     2593 #define  SSB_SPROM2_OPO_UNUSED         0xFF00 
     2594-#define SSB_SPROM2_CCODE               0x107C  /* Two char Country Code */ 
     2595+#define SSB_SPROM2_CCODE               0x007C  /* Two char Country Code */ 
     2596  
     2597 /* SPROM Revision 3 (inherits most data from rev 2) */ 
     2598-#define SSB_SPROM3_IL0MAC              0x104A  /* 6 bytes MAC address for 802.11b/g */ 
     2599-#define SSB_SPROM3_OFDMAPO             0x102C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
     2600-#define SSB_SPROM3_OFDMALPO            0x1030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
     2601-#define SSB_SPROM3_OFDMAHPO            0x1034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
     2602-#define SSB_SPROM3_GPIOLDC             0x1042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
     2603+#define SSB_SPROM3_OFDMAPO             0x002C  /* A-PHY OFDM Mid Power Offset (4 bytes, BigEndian) */ 
     2604+#define SSB_SPROM3_OFDMALPO            0x0030  /* A-PHY OFDM Low Power Offset (4 bytes, BigEndian) */ 
     2605+#define SSB_SPROM3_OFDMAHPO            0x0034  /* A-PHY OFDM High Power Offset (4 bytes, BigEndian) */ 
     2606+#define SSB_SPROM3_GPIOLDC             0x0042  /* GPIO LED Powersave Duty Cycle (4 bytes, BigEndian) */ 
     2607 #define  SSB_SPROM3_GPIOLDC_OFF                0x0000FF00      /* Off Count */ 
     2608 #define  SSB_SPROM3_GPIOLDC_OFF_SHIFT  8 
     2609 #define  SSB_SPROM3_GPIOLDC_ON         0x00FF0000      /* On Count */ 
     2610 #define  SSB_SPROM3_GPIOLDC_ON_SHIFT   16 
     2611-#define SSB_SPROM3_CCKPO               0x1078  /* CCK Power Offset */ 
     2612+#define SSB_SPROM3_IL0MAC              0x004A  /* 6 bytes MAC address for 802.11b/g */ 
     2613+#define SSB_SPROM3_CCKPO               0x0078  /* CCK Power Offset */ 
     2614 #define  SSB_SPROM3_CCKPO_1M           0x000F  /* 1M Rate PO */ 
     2615 #define  SSB_SPROM3_CCKPO_2M           0x00F0  /* 2M Rate PO */ 
     2616 #define  SSB_SPROM3_CCKPO_2M_SHIFT     4 
     2617@@ -264,104 +267,200 @@ 
     2618 #define  SSB_SPROM3_OFDMGPO            0x107A  /* G-PHY OFDM Power Offset (4 bytes, BigEndian) */ 
     2619  
     2620 /* SPROM Revision 4 */ 
     2621-#define SSB_SPROM4_IL0MAC              0x104C  /* 6 byte MAC address for a/b/g/n */ 
     2622-#define SSB_SPROM4_ETHPHY              0x105A  /* Ethernet PHY settings ?? */ 
     2623+#define SSB_SPROM4_BFLLO               0x0044  /* Boardflags (low 16 bits) */ 
     2624+#define SSB_SPROM4_BFLHI               0x0046  /* Board Flags Hi */ 
     2625+#define SSB_SPROM4_BFL2LO              0x0048  /* Board flags 2 (low 16 bits) */ 
     2626+#define SSB_SPROM4_BFL2HI              0x004A  /* Board flags 2 Hi */ 
     2627+#define SSB_SPROM4_IL0MAC              0x004C  /* 6 byte MAC address for a/b/g/n */ 
     2628+#define SSB_SPROM4_CCODE               0x0052  /* Country Code (2 bytes) */ 
     2629+#define SSB_SPROM4_GPIOA               0x0056  /* Gen. Purpose IO # 0 and 1 */ 
     2630+#define  SSB_SPROM4_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2631+#define  SSB_SPROM4_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2632+#define  SSB_SPROM4_GPIOA_P1_SHIFT     8 
     2633+#define SSB_SPROM4_GPIOB               0x0058  /* Gen. Purpose IO # 2 and 3 */ 
     2634+#define  SSB_SPROM4_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2635+#define  SSB_SPROM4_GPIOB_P3           0xFF00  /* Pin 3 */ 
     2636+#define  SSB_SPROM4_GPIOB_P3_SHIFT     8 
     2637+#define SSB_SPROM4_ETHPHY              0x005A  /* Ethernet PHY settings ?? */ 
     2638 #define  SSB_SPROM4_ETHPHY_ET0A                0x001F  /* MII Address for enet0 */ 
     2639 #define  SSB_SPROM4_ETHPHY_ET1A                0x03E0  /* MII Address for enet1 */ 
     2640 #define  SSB_SPROM4_ETHPHY_ET1A_SHIFT  5 
     2641 #define  SSB_SPROM4_ETHPHY_ET0M                (1<<14) /* MDIO for enet0 */ 
     2642 #define  SSB_SPROM4_ETHPHY_ET1M                (1<<15) /* MDIO for enet1 */ 
     2643-#define SSB_SPROM4_CCODE               0x1052  /* Country Code (2 bytes) */ 
     2644-#define SSB_SPROM4_ANTAVAIL            0x105D  /* Antenna available bitfields */ 
     2645-#define SSB_SPROM4_ANTAVAIL_A          0x00FF  /* A-PHY bitfield */ 
     2646-#define SSB_SPROM4_ANTAVAIL_A_SHIFT    0 
     2647-#define SSB_SPROM4_ANTAVAIL_BG         0xFF00  /* B-PHY and G-PHY bitfield */ 
     2648-#define SSB_SPROM4_ANTAVAIL_BG_SHIFT   8 
     2649-#define SSB_SPROM4_BFLLO               0x1044  /* Boardflags (low 16 bits) */ 
     2650-#define SSB_SPROM4_AGAIN01             0x105E  /* Antenna Gain (in dBm Q5.2) */ 
     2651+#define SSB_SPROM4_ANTAVAIL            0x005D  /* Antenna available bitfields */ 
     2652+#define  SSB_SPROM4_ANTAVAIL_A         0x00FF  /* A-PHY bitfield */ 
     2653+#define  SSB_SPROM4_ANTAVAIL_A_SHIFT   0 
     2654+#define  SSB_SPROM4_ANTAVAIL_BG                0xFF00  /* B-PHY and G-PHY bitfield */ 
     2655+#define  SSB_SPROM4_ANTAVAIL_BG_SHIFT  8 
     2656+#define SSB_SPROM4_AGAIN01             0x005E  /* Antenna Gain (in dBm Q5.2) */ 
     2657 #define  SSB_SPROM4_AGAIN0             0x00FF  /* Antenna 0 */ 
     2658 #define  SSB_SPROM4_AGAIN0_SHIFT       0 
     2659 #define  SSB_SPROM4_AGAIN1             0xFF00  /* Antenna 1 */ 
     2660 #define  SSB_SPROM4_AGAIN1_SHIFT       8 
     2661-#define SSB_SPROM4_AGAIN23             0x1060 
     2662+#define SSB_SPROM4_AGAIN23             0x0060 
     2663 #define  SSB_SPROM4_AGAIN2             0x00FF  /* Antenna 2 */ 
     2664 #define  SSB_SPROM4_AGAIN2_SHIFT       0 
     2665 #define  SSB_SPROM4_AGAIN3             0xFF00  /* Antenna 3 */ 
     2666 #define  SSB_SPROM4_AGAIN3_SHIFT       8 
     2667-#define SSB_SPROM4_BFLHI               0x1046  /* Board Flags Hi */ 
     2668-#define SSB_SPROM4_MAXP_BG             0x1080  /* Max Power BG in path 1 */ 
     2669+#define SSB_SPROM4_TXPID2G01           0x0062  /* TX Power Index 2GHz */ 
     2670+#define  SSB_SPROM4_TXPID2G0           0x00FF 
     2671+#define  SSB_SPROM4_TXPID2G0_SHIFT     0 
     2672+#define  SSB_SPROM4_TXPID2G1           0xFF00 
     2673+#define  SSB_SPROM4_TXPID2G1_SHIFT     8 
     2674+#define SSB_SPROM4_TXPID2G23           0x0064  /* TX Power Index 2GHz */ 
     2675+#define  SSB_SPROM4_TXPID2G2           0x00FF 
     2676+#define  SSB_SPROM4_TXPID2G2_SHIFT     0 
     2677+#define  SSB_SPROM4_TXPID2G3           0xFF00 
     2678+#define  SSB_SPROM4_TXPID2G3_SHIFT     8 
     2679+#define SSB_SPROM4_TXPID5G01           0x0066  /* TX Power Index 5GHz middle subband */ 
     2680+#define  SSB_SPROM4_TXPID5G0           0x00FF 
     2681+#define  SSB_SPROM4_TXPID5G0_SHIFT     0 
     2682+#define  SSB_SPROM4_TXPID5G1           0xFF00 
     2683+#define  SSB_SPROM4_TXPID5G1_SHIFT     8 
     2684+#define SSB_SPROM4_TXPID5G23           0x0068  /* TX Power Index 5GHz middle subband */ 
     2685+#define  SSB_SPROM4_TXPID5G2           0x00FF 
     2686+#define  SSB_SPROM4_TXPID5G2_SHIFT     0 
     2687+#define  SSB_SPROM4_TXPID5G3           0xFF00 
     2688+#define  SSB_SPROM4_TXPID5G3_SHIFT     8 
     2689+#define SSB_SPROM4_TXPID5GL01          0x006A  /* TX Power Index 5GHz low subband */ 
     2690+#define  SSB_SPROM4_TXPID5GL0          0x00FF 
     2691+#define  SSB_SPROM4_TXPID5GL0_SHIFT    0 
     2692+#define  SSB_SPROM4_TXPID5GL1          0xFF00 
     2693+#define  SSB_SPROM4_TXPID5GL1_SHIFT    8 
     2694+#define SSB_SPROM4_TXPID5GL23          0x006C  /* TX Power Index 5GHz low subband */ 
     2695+#define  SSB_SPROM4_TXPID5GL2          0x00FF 
     2696+#define  SSB_SPROM4_TXPID5GL2_SHIFT    0 
     2697+#define  SSB_SPROM4_TXPID5GL3          0xFF00 
     2698+#define  SSB_SPROM4_TXPID5GL3_SHIFT    8 
     2699+#define SSB_SPROM4_TXPID5GH01          0x006E  /* TX Power Index 5GHz high subband */ 
     2700+#define  SSB_SPROM4_TXPID5GH0          0x00FF 
     2701+#define  SSB_SPROM4_TXPID5GH0_SHIFT    0 
     2702+#define  SSB_SPROM4_TXPID5GH1          0xFF00 
     2703+#define  SSB_SPROM4_TXPID5GH1_SHIFT    8 
     2704+#define SSB_SPROM4_TXPID5GH23          0x0070  /* TX Power Index 5GHz high subband */ 
     2705+#define  SSB_SPROM4_TXPID5GH2          0x00FF 
     2706+#define  SSB_SPROM4_TXPID5GH2_SHIFT    0 
     2707+#define  SSB_SPROM4_TXPID5GH3          0xFF00 
     2708+#define  SSB_SPROM4_TXPID5GH3_SHIFT    8 
     2709+#define SSB_SPROM4_MAXP_BG             0x0080  /* Max Power BG in path 1 */ 
     2710 #define  SSB_SPROM4_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */ 
     2711 #define  SSB_SPROM4_ITSSI_BG           0xFF00  /* Mask for path 1 itssi_bg */ 
     2712 #define  SSB_SPROM4_ITSSI_BG_SHIFT     8 
     2713-#define SSB_SPROM4_MAXP_A              0x108A  /* Max Power A in path 1 */ 
     2714+#define SSB_SPROM4_MAXP_A              0x008A  /* Max Power A in path 1 */ 
     2715 #define  SSB_SPROM4_MAXP_A_MASK                0x00FF  /* Mask for Max Power A */ 
     2716 #define  SSB_SPROM4_ITSSI_A            0xFF00  /* Mask for path 1 itssi_a */ 
     2717 #define  SSB_SPROM4_ITSSI_A_SHIFT      8 
     2718-#define SSB_SPROM4_GPIOA               0x1056  /* Gen. Purpose IO # 0 and 1 */ 
     2719-#define  SSB_SPROM4_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2720-#define  SSB_SPROM4_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2721-#define  SSB_SPROM4_GPIOA_P1_SHIFT     8 
     2722-#define SSB_SPROM4_GPIOB               0x1058  /* Gen. Purpose IO # 2 and 3 */ 
     2723-#define  SSB_SPROM4_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2724-#define  SSB_SPROM4_GPIOB_P3           0xFF00  /* Pin 3 */ 
     2725-#define  SSB_SPROM4_GPIOB_P3_SHIFT     8 
     2726-#define SSB_SPROM4_PA0B0               0x1082  /* The paXbY locations are */ 
     2727-#define SSB_SPROM4_PA0B1               0x1084  /*   only guesses */ 
     2728-#define SSB_SPROM4_PA0B2               0x1086 
     2729-#define SSB_SPROM4_PA1B0               0x108E 
     2730-#define SSB_SPROM4_PA1B1               0x1090 
     2731-#define SSB_SPROM4_PA1B2               0x1092 
     2732+#define SSB_SPROM4_PA0B0               0x0082  /* The paXbY locations are */ 
     2733+#define SSB_SPROM4_PA0B1               0x0084  /*   only guesses */ 
     2734+#define SSB_SPROM4_PA0B2               0x0086 
     2735+#define SSB_SPROM4_PA1B0               0x008E 
     2736+#define SSB_SPROM4_PA1B1               0x0090 
     2737+#define SSB_SPROM4_PA1B2               0x0092 
     2738  
     2739 /* SPROM Revision 5 (inherits most data from rev 4) */ 
     2740-#define SSB_SPROM5_BFLLO               0x104A  /* Boardflags (low 16 bits) */ 
     2741-#define SSB_SPROM5_BFLHI               0x104C  /* Board Flags Hi */ 
     2742-#define SSB_SPROM5_IL0MAC              0x1052  /* 6 byte MAC address for a/b/g/n */ 
     2743-#define SSB_SPROM5_CCODE               0x1044  /* Country Code (2 bytes) */ 
     2744-#define SSB_SPROM5_GPIOA               0x1076  /* Gen. Purpose IO # 0 and 1 */ 
     2745+#define SSB_SPROM5_CCODE               0x0044  /* Country Code (2 bytes) */ 
     2746+#define SSB_SPROM5_BFLLO               0x004A  /* Boardflags (low 16 bits) */ 
     2747+#define SSB_SPROM5_BFLHI               0x004C  /* Board Flags Hi */ 
     2748+#define SSB_SPROM5_BFL2LO              0x004E  /* Board flags 2 (low 16 bits) */ 
     2749+#define SSB_SPROM5_BFL2HI              0x0050  /* Board flags 2 Hi */ 
     2750+#define SSB_SPROM5_IL0MAC              0x0052  /* 6 byte MAC address for a/b/g/n */ 
     2751+#define SSB_SPROM5_GPIOA               0x0076  /* Gen. Purpose IO # 0 and 1 */ 
     2752 #define  SSB_SPROM5_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2753 #define  SSB_SPROM5_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2754 #define  SSB_SPROM5_GPIOA_P1_SHIFT     8 
     2755-#define SSB_SPROM5_GPIOB               0x1078  /* Gen. Purpose IO # 2 and 3 */ 
     2756+#define SSB_SPROM5_GPIOB               0x0078  /* Gen. Purpose IO # 2 and 3 */ 
     2757 #define  SSB_SPROM5_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2758 #define  SSB_SPROM5_GPIOB_P3           0xFF00  /* Pin 3 */ 
    4252759 #define  SSB_SPROM5_GPIOB_P3_SHIFT     8 
    4262760  
     
    4282762-#define SSB_SPROM8_BFLLO               0x1084  /* Boardflags (low 16 bits) */ 
    4292763-#define SSB_SPROM8_BFLHI               0x1086  /* Boardflags Hi */ 
    430 +#define SSB_SPROM8_BOARDREV            0x1082  /* Board revision */ 
    431 +#define SSB_SPROM8_BFLLO               0x1084  /* Board flags (bits 0-15) */ 
    432 +#define SSB_SPROM8_BFLHI               0x1086  /* Board flags (bits 16-31) */ 
    433 +#define SSB_SPROM8_BFL2LO              0x1088  /* Board flags (bits 32-47) */ 
    434 +#define SSB_SPROM8_BFL2HI              0x108A  /* Board flags (bits 48-63) */ 
    435  #define SSB_SPROM8_IL0MAC              0x108C  /* 6 byte MAC address */ 
    436  #define SSB_SPROM8_CCODE               0x1092  /* 2 byte country code */ 
    437  #define SSB_SPROM8_ANTAVAIL            0x109C  /* Antenna available bitfields*/ 
    438 @@ -354,14 +357,63 @@ 
    439  #define  SSB_SPROM8_GPIOB_P2           0x00FF  /* Pin 2 */ 
    440  #define  SSB_SPROM8_GPIOB_P3           0xFF00  /* Pin 3 */ 
    441  #define  SSB_SPROM8_GPIOB_P3_SHIFT     8 
     2764-#define SSB_SPROM8_IL0MAC              0x108C  /* 6 byte MAC address */ 
     2765-#define SSB_SPROM8_CCODE               0x1092  /* 2 byte country code */ 
     2766-#define SSB_SPROM8_ANTAVAIL            0x109C  /* Antenna available bitfields*/ 
     2767-#define SSB_SPROM8_ANTAVAIL_A          0xFF00  /* A-PHY bitfield */ 
     2768-#define SSB_SPROM8_ANTAVAIL_A_SHIFT    8 
     2769-#define SSB_SPROM8_ANTAVAIL_BG         0x00FF  /* B-PHY and G-PHY bitfield */ 
     2770-#define SSB_SPROM8_ANTAVAIL_BG_SHIFT   0 
     2771-#define SSB_SPROM8_AGAIN01             0x109E  /* Antenna Gain (in dBm Q5.2) */ 
     2772+#define SSB_SPROM8_BOARDREV            0x0082  /* Board revision */ 
     2773+#define SSB_SPROM8_BFLLO               0x0084  /* Board flags (bits 0-15) */ 
     2774+#define SSB_SPROM8_BFLHI               0x0086  /* Board flags (bits 16-31) */ 
     2775+#define SSB_SPROM8_BFL2LO              0x0088  /* Board flags (bits 32-47) */ 
     2776+#define SSB_SPROM8_BFL2HI              0x008A  /* Board flags (bits 48-63) */ 
     2777+#define SSB_SPROM8_IL0MAC              0x008C  /* 6 byte MAC address */ 
     2778+#define SSB_SPROM8_CCODE               0x0092  /* 2 byte country code */ 
     2779+#define SSB_SPROM8_GPIOA               0x0096  /*Gen. Purpose IO # 0 and 1 */ 
     2780+#define  SSB_SPROM8_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2781+#define  SSB_SPROM8_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2782+#define  SSB_SPROM8_GPIOA_P1_SHIFT     8 
     2783+#define SSB_SPROM8_GPIOB               0x0098  /* Gen. Purpose IO # 2 and 3 */ 
     2784+#define  SSB_SPROM8_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2785+#define  SSB_SPROM8_GPIOB_P3           0xFF00  /* Pin 3 */ 
     2786+#define  SSB_SPROM8_GPIOB_P3_SHIFT     8 
     2787+#define SSB_SPROM8_ANTAVAIL            0x009C  /* Antenna available bitfields*/ 
     2788+#define  SSB_SPROM8_ANTAVAIL_A         0xFF00  /* A-PHY bitfield */ 
     2789+#define  SSB_SPROM8_ANTAVAIL_A_SHIFT   8 
     2790+#define  SSB_SPROM8_ANTAVAIL_BG                0x00FF  /* B-PHY and G-PHY bitfield */ 
     2791+#define  SSB_SPROM8_ANTAVAIL_BG_SHIFT  0 
     2792+#define SSB_SPROM8_AGAIN01             0x009E  /* Antenna Gain (in dBm Q5.2) */ 
     2793 #define  SSB_SPROM8_AGAIN0             0x00FF  /* Antenna 0 */ 
     2794 #define  SSB_SPROM8_AGAIN0_SHIFT       0 
     2795 #define  SSB_SPROM8_AGAIN1             0xFF00  /* Antenna 1 */ 
     2796 #define  SSB_SPROM8_AGAIN1_SHIFT       8 
     2797-#define SSB_SPROM8_AGAIN23             0x10A0 
     2798+#define SSB_SPROM8_AGAIN23             0x00A0 
     2799 #define  SSB_SPROM8_AGAIN2             0x00FF  /* Antenna 2 */ 
     2800 #define  SSB_SPROM8_AGAIN2_SHIFT       0 
     2801 #define  SSB_SPROM8_AGAIN3             0xFF00  /* Antenna 3 */ 
     2802 #define  SSB_SPROM8_AGAIN3_SHIFT       8 
     2803-#define SSB_SPROM8_GPIOA               0x1096  /*Gen. Purpose IO # 0 and 1 */ 
     2804-#define  SSB_SPROM8_GPIOA_P0           0x00FF  /* Pin 0 */ 
     2805-#define  SSB_SPROM8_GPIOA_P1           0xFF00  /* Pin 1 */ 
     2806-#define  SSB_SPROM8_GPIOA_P1_SHIFT     8 
     2807-#define SSB_SPROM8_GPIOB               0x1098  /* Gen. Purpose IO # 2 and 3 */ 
     2808-#define  SSB_SPROM8_GPIOB_P2           0x00FF  /* Pin 2 */ 
     2809-#define  SSB_SPROM8_GPIOB_P3           0xFF00  /* Pin 3 */ 
     2810-#define  SSB_SPROM8_GPIOB_P3_SHIFT     8 
    4422811-#define SSB_SPROM8_MAXP_BG             0x10C0  /* Max Power BG in path 1 */ 
    4432812-#define  SSB_SPROM8_MAXP_BG_MASK       0x00FF  /* Mask for Max Power BG */ 
    444 +#define SSB_SPROM8_RSSIPARM2G          0x10A4  /* RSSI params for 2GHz */ 
     2813+#define SSB_SPROM8_RSSIPARM2G          0x00A4  /* RSSI params for 2GHz */ 
    4452814+#define  SSB_SPROM8_RSSISMF2G          0x000F 
    4462815+#define  SSB_SPROM8_RSSISMC2G          0x00F0 
     
    4502819+#define  SSB_SPROM8_BXA2G              0x1800 
    4512820+#define  SSB_SPROM8_BXA2G_SHIFT                11 
    452 +#define SSB_SPROM8_RSSIPARM5G          0x10A6  /* RSSI params for 5GHz */ 
     2821+#define SSB_SPROM8_RSSIPARM5G          0x00A6  /* RSSI params for 5GHz */ 
    4532822+#define  SSB_SPROM8_RSSISMF5G          0x000F 
    4542823+#define  SSB_SPROM8_RSSISMC5G          0x00F0 
     
    4582827+#define  SSB_SPROM8_BXA5G              0x1800 
    4592828+#define  SSB_SPROM8_BXA5G_SHIFT                11 
    460 +#define SSB_SPROM8_TRI25G              0x10A8  /* TX isolation 2.4&5.3GHz */ 
     2829+#define SSB_SPROM8_TRI25G              0x00A8  /* TX isolation 2.4&5.3GHz */ 
    4612830+#define  SSB_SPROM8_TRI2G              0x00FF  /* TX isolation 2.4GHz */ 
    4622831+#define  SSB_SPROM8_TRI5G              0xFF00  /* TX isolation 5.3GHz */ 
    4632832+#define  SSB_SPROM8_TRI5G_SHIFT                8 
    464 +#define SSB_SPROM8_TRI5GHL             0x10AA  /* TX isolation 5.2/5.8GHz */ 
     2833+#define SSB_SPROM8_TRI5GHL             0x00AA  /* TX isolation 5.2/5.8GHz */ 
    4652834+#define  SSB_SPROM8_TRI5GL             0x00FF  /* TX isolation 5.2GHz */ 
    4662835+#define  SSB_SPROM8_TRI5GH             0xFF00  /* TX isolation 5.8GHz */ 
    4672836+#define  SSB_SPROM8_TRI5GH_SHIFT       8 
    468 +#define SSB_SPROM8_RXPO                        0x10AC  /* RX power offsets */ 
     2837+#define SSB_SPROM8_RXPO                        0x00AC  /* RX power offsets */ 
    4692838+#define  SSB_SPROM8_RXPO2G             0x00FF  /* 2GHz RX power offset */ 
    4702839+#define  SSB_SPROM8_RXPO5G             0xFF00  /* 5GHz RX power offset */ 
    4712840+#define  SSB_SPROM8_RXPO5G_SHIFT       8 
    472 +#define SSB_SPROM8_MAXP_BG             0x10C0  /* Max Power 2GHz in path 1 */ 
     2841+#define SSB_SPROM8_MAXP_BG             0x00C0  /* Max Power 2GHz in path 1 */ 
    4732842+#define  SSB_SPROM8_MAXP_BG_MASK       0x00FF  /* Mask for Max Power 2GHz */ 
    4742843 #define  SSB_SPROM8_ITSSI_BG           0xFF00  /* Mask for path 1 itssi_bg */ 
     
    4762845-#define SSB_SPROM8_MAXP_A              0x10C8  /* Max Power A in path 1 */ 
    4772846-#define  SSB_SPROM8_MAXP_A_MASK                0x00FF  /* Mask for Max Power A */ 
    478 +#define SSB_SPROM8_PA0B0               0x10C2  /* 2GHz power amp settings */ 
    479 +#define SSB_SPROM8_PA0B1               0x10C4 
    480 +#define SSB_SPROM8_PA0B2               0x10C6 
    481 +#define SSB_SPROM8_MAXP_A              0x10C8  /* Max Power 5.3GHz */ 
     2847+#define SSB_SPROM8_PA0B0               0x00C2  /* 2GHz power amp settings */ 
     2848+#define SSB_SPROM8_PA0B1               0x00C4 
     2849+#define SSB_SPROM8_PA0B2               0x00C6 
     2850+#define SSB_SPROM8_MAXP_A              0x00C8  /* Max Power 5.3GHz */ 
    4822851+#define  SSB_SPROM8_MAXP_A_MASK                0x00FF  /* Mask for Max Power 5.3GHz */ 
    4832852 #define  SSB_SPROM8_ITSSI_A            0xFF00  /* Mask for path 1 itssi_a */ 
    4842853 #define  SSB_SPROM8_ITSSI_A_SHIFT      8 
    485 +#define SSB_SPROM8_MAXP_AHL            0x10CA  /* Max Power 5.2/5.8GHz */ 
     2854+#define SSB_SPROM8_MAXP_AHL            0x00CA  /* Max Power 5.2/5.8GHz */ 
    4862855+#define  SSB_SPROM8_MAXP_AH_MASK       0x00FF  /* Mask for Max Power 5.8GHz */ 
    4872856+#define  SSB_SPROM8_MAXP_AL_MASK       0xFF00  /* Mask for Max Power 5.2GHz */ 
    4882857+#define  SSB_SPROM8_MAXP_AL_SHIFT      8 
    489 +#define SSB_SPROM8_PA1B0               0x10CC  /* 5.3GHz power amp settings */ 
    490 +#define SSB_SPROM8_PA1B1               0x10CE 
    491 +#define SSB_SPROM8_PA1B2               0x10D0 
    492 +#define SSB_SPROM8_PA1LOB0             0x10D2  /* 5.2GHz power amp settings */ 
    493 +#define SSB_SPROM8_PA1LOB1             0x10D4 
    494 +#define SSB_SPROM8_PA1LOB2             0x10D6 
    495 +#define SSB_SPROM8_PA1HIB0             0x10D8  /* 5.8GHz power amp settings */ 
    496 +#define SSB_SPROM8_PA1HIB1             0x10DA 
    497 +#define SSB_SPROM8_PA1HIB2             0x10DC 
    498 +#define SSB_SPROM8_CCK2GPO             0x1140  /* CCK power offset */ 
    499 +#define SSB_SPROM8_OFDM2GPO            0x1142  /* 2.4GHz OFDM power offset */ 
    500 +#define SSB_SPROM8_OFDM5GPO            0x1146  /* 5.3GHz OFDM power offset */ 
    501 +#define SSB_SPROM8_OFDM5GLPO           0x114A  /* 5.2GHz OFDM power offset */ 
    502 +#define SSB_SPROM8_OFDM5GHPO           0x114E  /* 5.8GHz OFDM power offset */ 
     2858+#define SSB_SPROM8_PA1B0               0x00CC  /* 5.3GHz power amp settings */ 
     2859+#define SSB_SPROM8_PA1B1               0x00CE 
     2860+#define SSB_SPROM8_PA1B2               0x00D0 
     2861+#define SSB_SPROM8_PA1LOB0             0x00D2  /* 5.2GHz power amp settings */ 
     2862+#define SSB_SPROM8_PA1LOB1             0x00D4 
     2863+#define SSB_SPROM8_PA1LOB2             0x00D6 
     2864+#define SSB_SPROM8_PA1HIB0             0x00D8  /* 5.8GHz power amp settings */ 
     2865+#define SSB_SPROM8_PA1HIB1             0x00DA 
     2866+#define SSB_SPROM8_PA1HIB2             0x00DC 
     2867+#define SSB_SPROM8_CCK2GPO             0x0140  /* CCK power offset */ 
     2868+#define SSB_SPROM8_OFDM2GPO            0x0142  /* 2.4GHz OFDM power offset */ 
     2869+#define SSB_SPROM8_OFDM5GPO            0x0146  /* 5.3GHz OFDM power offset */ 
     2870+#define SSB_SPROM8_OFDM5GLPO           0x014A  /* 5.2GHz OFDM power offset */ 
     2871+#define SSB_SPROM8_OFDM5GHPO           0x014E  /* 5.8GHz OFDM power offset */ 
    5032872  
    5042873 /* Values for SSB_SPROM1_BINF_CCODE */ 
  • trunk/target/linux/generic/patches-2.6.32/975-ssb_update.patch

    r26124 r26127  
    11--- a/drivers/ssb/driver_chipcommon.c 
    22+++ b/drivers/ssb/driver_chipcommon.c 
    3 @@ -373,6 +373,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     3@@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     4        } 
     5 } 
     6  
     7+/* http://bcm-v4.sipsolutions.net/802.11/PmuFastPwrupDelay */ 
     8+static u16 pmu_fast_powerup_delay(struct ssb_chipcommon *cc) 
     9+{ 
     10+       struct ssb_bus *bus = cc->dev->bus; 
     11+ 
     12+       switch (bus->chip_id) { 
     13+       case 0x4312: 
     14+       case 0x4322: 
     15+       case 0x4328: 
     16+               return 7000; 
     17+       case 0x4325: 
     18+               /* TODO: */ 
     19+       default: 
     20+               return 15000; 
     21+       } 
     22+} 
     23+ 
     24+/* http://bcm-v4.sipsolutions.net/802.11/ClkctlFastPwrupDelay */ 
     25 static void calc_fast_powerup_delay(struct ssb_chipcommon *cc) 
     26 { 
     27        struct ssb_bus *bus = cc->dev->bus; 
     28@@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     29  
     30        if (bus->bustype != SSB_BUSTYPE_PCI) 
     31                return; 
     32+ 
     33+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) { 
     34+               cc->fast_pwrup_delay = pmu_fast_powerup_delay(cc); 
     35+               return; 
     36+       } 
     37+ 
     38        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     39                return; 
     40  
     41@@ -373,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
    442 { 
    543        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     
    3270                 * min_msk = 0xCBB 
    3371                 * max_msk = 0x7FFFF 
     72@@ -495,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     73                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
     74 } 
     75  
     76+/* http://bcm-v4.sipsolutions.net/802.11/SSB/PmuInit */ 
     77 void ssb_pmu_init(struct ssb_chipcommon *cc) 
     78 { 
     79-       struct ssb_bus *bus = cc->dev->bus; 
     80        u32 pmucap; 
     81  
     82        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
     83@@ -509,15 +516,12 @@ void ssb_pmu_init(struct ssb_chipcommon 
     84        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
     85                    cc->pmu.rev, pmucap); 
     86  
     87-       if (cc->pmu.rev >= 1) { 
     88-               if ((bus->chip_id == 0x4325) && (bus->chip_rev < 2)) { 
     89-                       chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     90-                                     ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     91-               } else { 
     92-                       chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     93-                                    SSB_CHIPCO_PMU_CTL_NOILPONW); 
     94-               } 
     95-       } 
     96+       if (cc->pmu.rev == 1) 
     97+               chipco_mask32(cc, SSB_CHIPCO_PMU_CTL, 
     98+                             ~SSB_CHIPCO_PMU_CTL_NOILPONW); 
     99+       else 
     100+               chipco_set32(cc, SSB_CHIPCO_PMU_CTL, 
     101+                            SSB_CHIPCO_PMU_CTL_NOILPONW); 
     102        ssb_pmu_pll_init(cc); 
     103        ssb_pmu_resources_init(cc); 
     104 } 
    34105--- a/drivers/ssb/driver_gige.c 
    35106+++ b/drivers/ssb/driver_gige.c 
     
    215286-                   !dev->dev->driver || 
    216287-                   !device_is_registered(dev->dev)) 
     288-                       continue; 
     289-               drv = drv_to_ssb_drv(dev->dev->driver); 
     290-               if (!drv) 
    217291+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
    218292+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
    219293+                       ssb_device_put(sdev); 
    220294                        continue; 
    221 -               drv = drv_to_ssb_drv(dev->dev->driver); 
    222 -               if (!drv) 
    223 -                       continue; 
    224295-               err = drv->suspend(dev, state); 
    225296-               if (err) { 
     
    303374 #endif /* CONFIG_SSB_SPROM */ 
    304375  
    305 @@ -490,8 +495,7 @@ static int ssb_devices_register(struct s 
     376@@ -380,6 +385,35 @@ static int ssb_device_uevent(struct devi 
     377                             ssb_dev->id.revision); 
     378 } 
     379  
     380+#define ssb_config_attr(attrib, field, format_string) \ 
     381+static ssize_t \ 
     382+attrib##_show(struct device *dev, struct device_attribute *attr, char *buf) \ 
     383+{ \ 
     384+       return sprintf(buf, format_string, dev_to_ssb_dev(dev)->field); \ 
     385+} 
     386+ 
     387+ssb_config_attr(core_num, core_index, "%u\n") 
     388+ssb_config_attr(coreid, id.coreid, "0x%04x\n") 
     389+ssb_config_attr(vendor, id.vendor, "0x%04x\n") 
     390+ssb_config_attr(revision, id.revision, "%u\n") 
     391+ssb_config_attr(irq, irq, "%u\n") 
     392+static ssize_t 
     393+name_show(struct device *dev, struct device_attribute *attr, char *buf) 
     394+{ 
     395+       return sprintf(buf, "%s\n", 
     396+                      ssb_core_name(dev_to_ssb_dev(dev)->id.coreid)); 
     397+} 
     398+ 
     399+static struct device_attribute ssb_device_attrs[] = { 
     400+       __ATTR_RO(name), 
     401+       __ATTR_RO(core_num), 
     402+       __ATTR_RO(coreid), 
     403+       __ATTR_RO(vendor), 
     404+       __ATTR_RO(revision), 
     405+       __ATTR_RO(irq), 
     406+       __ATTR_NULL, 
     407+}; 
     408+ 
     409 static struct bus_type ssb_bustype = { 
     410        .name           = "ssb", 
     411        .match          = ssb_bus_match, 
     412@@ -389,6 +423,7 @@ static struct bus_type ssb_bustype = { 
     413        .suspend        = ssb_device_suspend, 
     414        .resume         = ssb_device_resume, 
     415        .uevent         = ssb_device_uevent, 
     416+       .dev_attrs      = ssb_device_attrs, 
     417 }; 
     418  
     419 static void ssb_buses_lock(void) 
     420@@ -481,6 +516,7 @@ static int ssb_devices_register(struct s 
     421 #ifdef CONFIG_SSB_PCIHOST 
     422                        sdev->irq = bus->host_pci->irq; 
     423                        dev->parent = &bus->host_pci->dev; 
     424+                       sdev->dma_dev = dev->parent; 
     425 #endif 
     426                        break; 
     427                case SSB_BUSTYPE_PCMCIA: 
     428@@ -490,13 +526,13 @@ static int ssb_devices_register(struct s 
    306429 #endif 
    307430                        break; 
     
    313436 #endif 
    314437                        break; 
    315 @@ -830,6 +834,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
     438                case SSB_BUSTYPE_SSB: 
     439                        dev->dma_mask = &dev->coherent_dma_mask; 
     440+                       sdev->dma_dev = dev; 
     441                        break; 
     442                } 
     443  
     444@@ -830,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
    316445        if (!err) { 
    317446                ssb_printk(KERN_INFO PFX "Sonics Silicon Backplane found on " 
     
    323452  
    324453        return err; 
     454@@ -1155,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
     455 } 
     456 EXPORT_SYMBOL(ssb_device_enable); 
     457  
     458-/* Wait for a bit in a register to get set or unset. 
     459+/* Wait for bitmask in a register to get set or cleared. 
     460  * timeout is in units of ten-microseconds */ 
     461-static int ssb_wait_bit(struct ssb_device *dev, u16 reg, u32 bitmask, 
     462-                       int timeout, int set) 
     463+static int ssb_wait_bits(struct ssb_device *dev, u16 reg, u32 bitmask, 
     464+                        int timeout, int set) 
     465 { 
     466        int i; 
     467        u32 val; 
     468@@ -1166,7 +1205,7 @@ static int ssb_wait_bit(struct ssb_devic 
     469        for (i = 0; i < timeout; i++) { 
     470                val = ssb_read32(dev, reg); 
     471                if (set) { 
     472-                       if (val & bitmask) 
     473+                       if ((val & bitmask) == bitmask) 
     474                                return 0; 
     475                } else { 
     476                        if (!(val & bitmask)) 
     477@@ -1183,20 +1222,38 @@ static int ssb_wait_bit(struct ssb_devic 
     478  
     479 void ssb_device_disable(struct ssb_device *dev, u32 core_specific_flags) 
     480 { 
     481-       u32 reject; 
     482+       u32 reject, val; 
     483  
     484        if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_RESET) 
     485                return; 
     486  
     487        reject = ssb_tmslow_reject_bitmask(dev); 
     488-       ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     489-       ssb_wait_bit(dev, SSB_TMSLOW, reject, 1000, 1); 
     490-       ssb_wait_bit(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     491-       ssb_write32(dev, SSB_TMSLOW, 
     492-                   SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     493-                   reject | SSB_TMSLOW_RESET | 
     494-                   core_specific_flags); 
     495-       ssb_flush_tmslow(dev); 
     496+ 
     497+       if (ssb_read32(dev, SSB_TMSLOW) & SSB_TMSLOW_CLOCK) { 
     498+               ssb_write32(dev, SSB_TMSLOW, reject | SSB_TMSLOW_CLOCK); 
     499+               ssb_wait_bits(dev, SSB_TMSLOW, reject, 1000, 1); 
     500+               ssb_wait_bits(dev, SSB_TMSHIGH, SSB_TMSHIGH_BUSY, 1000, 0); 
     501+ 
     502+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     503+                       val = ssb_read32(dev, SSB_IMSTATE); 
     504+                       val |= SSB_IMSTATE_REJECT; 
     505+                       ssb_write32(dev, SSB_IMSTATE, val); 
     506+                       ssb_wait_bits(dev, SSB_IMSTATE, SSB_IMSTATE_BUSY, 1000, 
     507+                                     0); 
     508+               } 
     509+ 
     510+               ssb_write32(dev, SSB_TMSLOW, 
     511+                       SSB_TMSLOW_FGC | SSB_TMSLOW_CLOCK | 
     512+                       reject | SSB_TMSLOW_RESET | 
     513+                       core_specific_flags); 
     514+               ssb_flush_tmslow(dev); 
     515+ 
     516+               if (ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_INITIATOR) { 
     517+                       val = ssb_read32(dev, SSB_IMSTATE); 
     518+                       val &= ~SSB_IMSTATE_REJECT; 
     519+                       ssb_write32(dev, SSB_IMSTATE, val); 
     520+               } 
     521+       } 
     522  
     523        ssb_write32(dev, SSB_TMSLOW, 
     524                    reject | SSB_TMSLOW_RESET | 
     525--- a/drivers/ssb/pci.c 
     526+++ b/drivers/ssb/pci.c 
     527@@ -17,6 +17,7 @@ 
     528  
     529 #include <linux/ssb/ssb.h>