Changeset 27731


Ignore:
Timestamp:
2011-07-23T13:17:00+02:00 (7 years ago)
Author:
hauke
Message:

kernel: update bcma and ssb to version master-2011-07-22 from wireless-testing

Location:
trunk/target/linux/generic
Files:
6 added
6 deleted
18 edited

Legend:

Unmodified
Added
Removed
  • trunk/target/linux/generic/config-2.6.30

    r26570 r27731  
    146146CONFIG_BCM43XX_PIO=y 
    147147# CONFIG_BCM43XX_PIO_MODE is not set 
     148# CONFIG_BCMA is not set 
    148149# CONFIG_BDI_SWITCH is not set 
    149150# CONFIG_BEFS_FS is not set 
  • trunk/target/linux/generic/config-2.6.31

    r26570 r27731  
    151151CONFIG_BCM43XX_PIO=y 
    152152# CONFIG_BCM43XX_PIO_MODE is not set 
     153# CONFIG_BCMA is not set 
    153154# CONFIG_BEFS_FS is not set 
    154155# CONFIG_BFS_FS is not set 
  • trunk/target/linux/generic/config-2.6.32

    r26570 r27731  
    156156CONFIG_BCM43XX_PIO=y 
    157157# CONFIG_BCM43XX_PIO_MODE is not set 
     158# CONFIG_BCMA is not set 
    158159# CONFIG_BE2ISCSI is not set 
    159160# CONFIG_BEFS_FS is not set 
  • trunk/target/linux/generic/config-2.6.36

    r26570 r27731  
    167167# CONFIG_BCM47XX is not set 
    168168# CONFIG_BCM63XX is not set 
     169# CONFIG_BCMA is not set 
    169170# CONFIG_BDI_SWITCH is not set 
    170171# CONFIG_BE2ISCSI is not set 
  • trunk/target/linux/generic/config-2.6.37

    r26570 r27731  
    172172# CONFIG_BCM63XX is not set 
    173173# CONFIG_BCM63XX_PHY is not set 
     174# CONFIG_BCMA is not set 
    174175# CONFIG_BCM_WIMAX is not set 
    175176# CONFIG_BDI_SWITCH is not set 
  • trunk/target/linux/generic/config-2.6.38

    r27181 r27731  
    178178# CONFIG_BCM63XX is not set 
    179179# CONFIG_BCM63XX_PHY is not set 
     180# CONFIG_BCMA is not set 
    180181# CONFIG_BCM_WIMAX is not set 
    181182# CONFIG_BDI_SWITCH is not set 
  • trunk/target/linux/generic/patches-2.6.30/941-ssb_update.patch

    r26127 r27731  
    4444--- a/drivers/ssb/driver_chipcommon.c 
    4545+++ b/drivers/ssb/driver_chipcommon.c 
    46 @@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     46@@ -46,40 +46,66 @@ void ssb_chipco_set_clockmode(struct ssb 
     47        if (!ccdev) 
     48                return; 
     49        bus = ccdev->bus; 
     50+ 
     51+       /* We support SLOW only on 6..9 */ 
     52+       if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW) 
     53+               mode = SSB_CLKMODE_DYNAMIC; 
     54+ 
     55+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) 
     56+               return; /* PMU controls clockmode, separated function needed */ 
     57+       SSB_WARN_ON(ccdev->id.revision >= 20); 
     58+ 
     59        /* chipcommon cores prior to rev6 don't support dynamic clock control */ 
     60        if (ccdev->id.revision < 6) 
     61                return; 
     62-       /* chipcommon cores rev10 are a whole new ball game */ 
     63+ 
     64+       /* ChipCommon cores rev10+ need testing */ 
     65        if (ccdev->id.revision >= 10) 
     66                return; 
     67+ 
     68        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     69                return; 
     70  
     71        switch (mode) { 
     72-       case SSB_CLKMODE_SLOW: 
     73+       case SSB_CLKMODE_SLOW: /* For revs 6..9 only */ 
     74                tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     75                tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     76                chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     77                break; 
     78        case SSB_CLKMODE_FAST: 
     79-               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     80-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     81-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     82-               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     83-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     84+               if (ccdev->id.revision < 10) { 
     85+                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     86+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     87+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     88+                       tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     89+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     90+               } else { 
     91+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     92+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) | 
     93+                                SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     94+                       /* udelay(150); TODO: not available in early init */ 
     95+               } 
     96                break; 
     97        case SSB_CLKMODE_DYNAMIC: 
     98-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     99-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     100-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     101-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     102-               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     103-                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     104-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     105- 
     106-               /* for dynamic control, we have to release our xtal_pu "force on" */ 
     107-               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     108-                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     109+               if (ccdev->id.revision < 10) { 
     110+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     111+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     112+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     113+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     114+                       if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != 
     115+                           SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     116+                               tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     117+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     118+ 
     119+                       /* For dynamic control, we have to release our xtal_pu 
     120+                        * "force on" */ 
     121+                       if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     122+                               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     123+               } else { 
     124+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     125+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) & 
     126+                                ~SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     127+               } 
     128                break; 
     129        default: 
     130                SSB_WARN_ON(1); 
     131@@ -209,6 +235,24 @@ static void chipco_powercontrol_init(str 
    47132        } 
    48133 } 
     
    69154 { 
    70155        struct ssb_bus *bus = cc->dev->bus; 
    71 @@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     156@@ -218,6 +262,12 @@ static void calc_fast_powerup_delay(stru 
    72157  
    73158        if (bus->bustype != SSB_BUSTYPE_PCI) 
     
    82167                return; 
    83168  
    84 @@ -233,6 +257,9 @@ void ssb_chipcommon_init(struct ssb_chip 
     169@@ -233,6 +283,15 @@ void ssb_chipcommon_init(struct ssb_chip 
    85170 { 
    86171        if (!cc->dev) 
     
    89174+               cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    90175+       ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     176+ 
     177+       if (cc->dev->id.revision >= 20) { 
     178+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0); 
     179+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0); 
     180+       } 
     181+ 
    91182        ssb_pmu_init(cc); 
    92183        chipco_powercontrol_init(cc); 
    93184        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    94 @@ -370,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     185@@ -370,6 +429,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
    95186 { 
    96187        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     
    137228                ssb_printk(KERN_ERR PFX 
    138229                           "ERROR: PLL init unknown for device %04X\n", 
    139 @@ -402,6 +423,7 @@ static void ssb_pmu_resources_init(struc 
     230@@ -396,12 +417,15 @@ static void ssb_pmu_resources_init(struc 
     231        u32 min_msk = 0, max_msk = 0; 
     232        unsigned int i; 
     233        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
     234-       unsigned int updown_tab_size; 
     235+       unsigned int updown_tab_size = 0; 
     236        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
     237-       unsigned int depend_tab_size; 
     238+       unsigned int depend_tab_size = 0; 
    140239  
    141240        switch (bus->chip_id) { 
    142241        case 0x4312: 
     242+                min_msk = 0xCBB; 
     243+                break; 
    143244+       case 0x4322: 
    144245                /* We keep the default settings: 
    145246                 * min_msk = 0xCBB 
    146247                 * max_msk = 0x7FFFF 
    147 @@ -480,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     248@@ -480,9 +504,9 @@ static void ssb_pmu_resources_init(struc 
    148249                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
    149250 } 
     
    156257  
    157258        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
    158 @@ -494,15 +516,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
     259@@ -494,15 +518,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
    159260        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
    160261                    cc->pmu.rev, pmucap); 
     
    267368  
    268369 /* 
     370@@ -105,8 +106,9 @@ void gige_pcicfg_write32(struct ssb_gige 
     371        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
     372 } 
     373  
     374-static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
     375-                                   int reg, int size, u32 *val) 
     376+static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus, 
     377+                                             unsigned int devfn, int reg, 
     378+                                             int size, u32 *val) 
     379 { 
     380        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     381        unsigned long flags; 
     382@@ -135,8 +137,9 @@ static int ssb_gige_pci_read_config(stru 
     383        return PCIBIOS_SUCCESSFUL; 
     384 } 
     385  
     386-static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
     387-                                    int reg, int size, u32 val) 
     388+static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus, 
     389+                                              unsigned int devfn, int reg, 
     390+                                              int size, u32 val) 
     391 { 
     392        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     393        unsigned long flags; 
     394@@ -165,7 +168,8 @@ static int ssb_gige_pci_write_config(str 
     395        return PCIBIOS_SUCCESSFUL; 
     396 } 
     397  
     398-static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id) 
     399+static int __devinit ssb_gige_probe(struct ssb_device *sdev, 
     400+                                   const struct ssb_device_id *id) 
     401 { 
     402        struct ssb_gige *dev; 
     403        u32 base, tmslow, tmshigh; 
    269404--- a/drivers/ssb/driver_mipscore.c 
    270405+++ b/drivers/ssb/driver_mipscore.c 
     
    433568--- a/drivers/ssb/driver_pcicore.c 
    434569+++ b/drivers/ssb/driver_pcicore.c 
    435 @@ -246,20 +246,12 @@ static struct pci_controller ssb_pcicore 
     570@@ -15,6 +15,11 @@ 
     571  
     572 #include "ssb_private.h" 
     573  
     574+static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address); 
     575+static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data); 
     576+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address); 
     577+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     578+                               u8 address, u16 data); 
     579  
     580 static inline 
     581 u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset) 
     582@@ -246,20 +251,12 @@ static struct pci_controller ssb_pcicore 
    436583        .pci_ops        = &ssb_pcicore_pciops, 
    437584        .io_resource    = &ssb_pcicore_io_resource, 
     
    454601                /* This is not a device on the PCI-core bridge. */ 
    455602                return -ENODEV; 
    456 @@ -268,27 +260,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
     603@@ -268,27 +265,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
    457604        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
    458605                   pci_name(d)); 
     
    482629        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
    483630        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
    484 @@ -551,13 +522,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     631@@ -338,7 +314,7 @@ int ssb_pcicore_pcibios_map_irq(const st 
     632        return ssb_mips_irq(extpci_core->dev) + 2; 
     633 } 
     634  
     635-static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     636+static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     637 { 
     638        u32 val; 
     639  
     640@@ -403,7 +379,7 @@ static void ssb_pcicore_init_hostmode(st 
     641        register_pci_controller(&ssb_pcicore_controller); 
     642 } 
     643  
     644-static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     645+static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     646 { 
     647        struct ssb_bus *bus = pc->dev->bus; 
     648        u16 chipid_top; 
     649@@ -432,25 +408,133 @@ static int pcicore_is_in_hostmode(struct 
     650 } 
     651 #endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
     652  
     653+/************************************************** 
     654+ * Workarounds. 
     655+ **************************************************/ 
     656+ 
     657+static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc) 
     658+{ 
     659+       u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0)); 
     660+       if (((tmp & 0xF000) >> 12) != pc->dev->core_index) { 
     661+               tmp &= ~0xF000; 
     662+               tmp |= (pc->dev->core_index << 12); 
     663+               pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp); 
     664+       } 
     665+} 
     666+ 
     667+static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc) 
     668+{ 
     669+       return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80; 
     670+} 
     671+ 
     672+static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc) 
     673+{ 
     674+       const u8 serdes_pll_device = 0x1D; 
     675+       const u8 serdes_rx_device = 0x1F; 
     676+       u16 tmp; 
     677+ 
     678+       ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */, 
     679+                           ssb_pcicore_polarity_workaround(pc)); 
     680+       tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */); 
     681+       if (tmp & 0x4000) 
     682+               ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000); 
     683+} 
     684+ 
     685+static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc) 
     686+{ 
     687+       struct ssb_device *pdev = pc->dev; 
     688+       struct ssb_bus *bus = pdev->bus; 
     689+       u32 tmp; 
     690+ 
     691+       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     692+       tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     693+       tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     694+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     695+ 
     696+       if (pdev->id.revision < 5) { 
     697+               tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     698+               tmp &= ~SSB_IMCFGLO_SERTO; 
     699+               tmp |= 2; 
     700+               tmp &= ~SSB_IMCFGLO_REQTO; 
     701+               tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     702+               ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     703+               ssb_commit_settings(bus); 
     704+       } else if (pdev->id.revision >= 11) { 
     705+               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     706+               tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     707+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     708+       } 
     709+} 
     710+ 
     711+static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc) 
     712+{ 
     713+       u32 tmp; 
     714+       u8 rev = pc->dev->id.revision; 
     715+ 
     716+       if (rev == 0 || rev == 1) { 
     717+               /* TLP Workaround register. */ 
     718+               tmp = ssb_pcie_read(pc, 0x4); 
     719+               tmp |= 0x8; 
     720+               ssb_pcie_write(pc, 0x4, tmp); 
     721+       } 
     722+       if (rev == 1) { 
     723+               /* DLLP Link Control register. */ 
     724+               tmp = ssb_pcie_read(pc, 0x100); 
     725+               tmp |= 0x40; 
     726+               ssb_pcie_write(pc, 0x100, tmp); 
     727+       } 
     728+ 
     729+       if (rev == 0) { 
     730+               const u8 serdes_rx_device = 0x1F; 
     731+ 
     732+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     733+                                       2 /* Timer */, 0x8128); 
     734+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     735+                                       6 /* CDR */, 0x0100); 
     736+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     737+                                       7 /* CDR BW */, 0x1466); 
     738+       } else if (rev == 3 || rev == 4 || rev == 5) { 
     739+               /* TODO: DLLP Power Management Threshold */ 
     740+               ssb_pcicore_serdes_workaround(pc); 
     741+               /* TODO: ASPM */ 
     742+       } else if (rev == 7) { 
     743+               /* TODO: No PLL down */ 
     744+       } 
     745+ 
     746+       if (rev >= 6) { 
     747+               /* Miscellaneous Configuration Fixup */ 
     748+               tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5)); 
     749+               if (!(tmp & 0x8000)) 
     750+                       pcicore_write16(pc, SSB_PCICORE_SPROM(5), 
     751+                                       tmp | 0x8000); 
     752+       } 
     753+} 
     754  
     755 /************************************************** 
     756  * Generic and Clientmode operation code. 
     757  **************************************************/ 
     758  
     759-static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     760+static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     761 { 
     762+       ssb_pcicore_fix_sprom_core_index(pc); 
     763+ 
     764        /* Disable PCI interrupts. */ 
     765        ssb_write32(pc->dev, SSB_INTVEC, 0); 
     766+ 
     767+       /* Additional PCIe always once-executed workarounds */ 
     768+       if (pc->dev->id.coreid == SSB_DEV_PCIE) { 
     769+               ssb_pcicore_serdes_workaround(pc); 
     770+               /* TODO: ASPM */ 
     771+               /* TODO: Clock Request Update */ 
     772+       } 
     773 } 
     774  
     775-void ssb_pcicore_init(struct ssb_pcicore *pc) 
     776+void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
     777 { 
     778        struct ssb_device *dev = pc->dev; 
     779-       struct ssb_bus *bus; 
     780  
     781        if (!dev) 
     782                return; 
     783-       bus = dev->bus; 
     784        if (!ssb_device_is_enabled(dev)) 
     785                ssb_device_enable(dev, 0); 
     786  
     787@@ -475,58 +559,104 @@ static void ssb_pcie_write(struct ssb_pc 
     788        pcicore_write32(pc, 0x134, data); 
     789 } 
     790  
     791-static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     792-                               u8 address, u16 data) 
     793+static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
     794 { 
     795        const u16 mdio_control = 0x128; 
     796        const u16 mdio_data = 0x12C; 
     797        u32 v; 
     798        int i; 
     799  
     800+       v = (1 << 30); /* Start of Transaction */ 
     801+       v |= (1 << 28); /* Write Transaction */ 
     802+       v |= (1 << 17); /* Turnaround */ 
     803+       v |= (0x1F << 18); 
     804+       v |= (phy << 4); 
     805+       pcicore_write32(pc, mdio_data, v); 
     806+ 
     807+       udelay(10); 
     808+       for (i = 0; i < 200; i++) { 
     809+               v = pcicore_read32(pc, mdio_control); 
     810+               if (v & 0x100 /* Trans complete */) 
     811+                       break; 
     812+               msleep(1); 
     813+       } 
     814+} 
     815+ 
     816+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address) 
     817+{ 
     818+       const u16 mdio_control = 0x128; 
     819+       const u16 mdio_data = 0x12C; 
     820+       int max_retries = 10; 
     821+       u16 ret = 0; 
     822+       u32 v; 
     823+       int i; 
     824+ 
     825        v = 0x80; /* Enable Preamble Sequence */ 
     826        v |= 0x2; /* MDIO Clock Divisor */ 
     827        pcicore_write32(pc, mdio_control, v); 
     828  
     829+       if (pc->dev->id.revision >= 10) { 
     830+               max_retries = 200; 
     831+               ssb_pcie_mdio_set_phy(pc, device); 
     832+       } 
     833+ 
     834        v = (1 << 30); /* Start of Transaction */ 
     835-       v |= (1 << 28); /* Write Transaction */ 
     836+       v |= (1 << 29); /* Read Transaction */ 
     837        v |= (1 << 17); /* Turnaround */ 
     838-       v |= (u32)device << 22; 
     839+       if (pc->dev->id.revision < 10) 
     840+               v |= (u32)device << 22; 
     841        v |= (u32)address << 18; 
     842-       v |= data; 
     843        pcicore_write32(pc, mdio_data, v); 
     844        /* Wait for the device to complete the transaction */ 
     845        udelay(10); 
     846-       for (i = 0; i < 10; i++) { 
     847+       for (i = 0; i < max_retries; i++) { 
     848                v = pcicore_read32(pc, mdio_control); 
     849-               if (v & 0x100 /* Trans complete */) 
     850+               if (v & 0x100 /* Trans complete */) { 
     851+                       udelay(10); 
     852+                       ret = pcicore_read32(pc, mdio_data); 
     853                        break; 
     854+               } 
     855                msleep(1); 
     856        } 
     857        pcicore_write32(pc, mdio_control, 0); 
     858+       return ret; 
     859 } 
     860  
     861-static void ssb_broadcast_value(struct ssb_device *dev, 
     862-                               u32 address, u32 data) 
     863+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     864+                               u8 address, u16 data) 
     865 { 
     866-       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     867-       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     868-       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     869+       const u16 mdio_control = 0x128; 
     870+       const u16 mdio_data = 0x12C; 
     871+       int max_retries = 10; 
     872+       u32 v; 
     873+       int i; 
     874  
     875-       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
     876-       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
     877-       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
     878-       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
     879-} 
     880+       v = 0x80; /* Enable Preamble Sequence */ 
     881+       v |= 0x2; /* MDIO Clock Divisor */ 
     882+       pcicore_write32(pc, mdio_control, v); 
     883  
     884-static void ssb_commit_settings(struct ssb_bus *bus) 
     885-{ 
     886-       struct ssb_device *dev; 
     887+       if (pc->dev->id.revision >= 10) { 
     888+               max_retries = 200; 
     889+               ssb_pcie_mdio_set_phy(pc, device); 
     890+       } 
     891  
     892-       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     893-       if (WARN_ON(!dev)) 
     894-               return; 
     895-       /* This forces an update of the cached registers. */ 
     896-       ssb_broadcast_value(dev, 0xFD8, 0); 
     897+       v = (1 << 30); /* Start of Transaction */ 
     898+       v |= (1 << 28); /* Write Transaction */ 
     899+       v |= (1 << 17); /* Turnaround */ 
     900+       if (pc->dev->id.revision < 10) 
     901+               v |= (u32)device << 22; 
     902+       v |= (u32)address << 18; 
     903+       v |= data; 
     904+       pcicore_write32(pc, mdio_data, v); 
     905+       /* Wait for the device to complete the transaction */ 
     906+       udelay(10); 
     907+       for (i = 0; i < max_retries; i++) { 
     908+               v = pcicore_read32(pc, mdio_control); 
     909+               if (v & 0x100 /* Trans complete */) 
     910+                       break; 
     911+               msleep(1); 
     912+       } 
     913+       pcicore_write32(pc, mdio_control, 0); 
     914 } 
     915  
     916 int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
     917@@ -551,13 +681,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
    485918        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
    486919  
     
    498931                if (err) 
    499932                        goto out; 
     933@@ -579,48 +709,10 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     934        if (pc->setup_done) 
     935                goto out; 
     936        if (pdev->id.coreid == SSB_DEV_PCI) { 
     937-               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     938-               tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     939-               tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     940-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     941- 
     942-               if (pdev->id.revision < 5) { 
     943-                       tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     944-                       tmp &= ~SSB_IMCFGLO_SERTO; 
     945-                       tmp |= 2; 
     946-                       tmp &= ~SSB_IMCFGLO_REQTO; 
     947-                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     948-                       ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     949-                       ssb_commit_settings(bus); 
     950-               } else if (pdev->id.revision >= 11) { 
     951-                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     952-                       tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     953-                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     954-               } 
     955+               ssb_pcicore_pci_setup_workarounds(pc); 
     956        } else { 
     957                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
     958-               //TODO: Better make defines for all these magic PCIE values. 
     959-               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
     960-                       /* TLP Workaround register. */ 
     961-                       tmp = ssb_pcie_read(pc, 0x4); 
     962-                       tmp |= 0x8; 
     963-                       ssb_pcie_write(pc, 0x4, tmp); 
     964-               } 
     965-               if (pdev->id.revision == 0) { 
     966-                       const u8 serdes_rx_device = 0x1F; 
     967- 
     968-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     969-                                           2 /* Timer */, 0x8128); 
     970-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     971-                                           6 /* CDR */, 0x0100); 
     972-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     973-                                           7 /* CDR BW */, 0x1466); 
     974-               } else if (pdev->id.revision == 1) { 
     975-                       /* DLLP Link Control register. */ 
     976-                       tmp = ssb_pcie_read(pc, 0x100); 
     977-                       tmp |= 0x40; 
     978-                       ssb_pcie_write(pc, 0x100, tmp); 
     979-               } 
     980+               ssb_pcicore_pcie_setup_workarounds(pc); 
     981        } 
     982        pc->setup_done = 1; 
     983 out: 
    500984--- a/drivers/ssb/main.c 
    501985+++ b/drivers/ssb/main.c 
     
    6101094-                   !dev->dev->driver || 
    6111095-                   !device_is_registered(dev->dev)) 
     1096-                       continue; 
     1097-               drv = drv_to_ssb_drv(dev->dev->driver); 
     1098-               if (!drv) 
    6121099+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
    6131100+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
    6141101+                       ssb_device_put(sdev); 
    6151102                        continue; 
    616 -               drv = drv_to_ssb_drv(dev->dev->driver); 
    617 -               if (!drv) 
    618 -                       continue; 
    6191103-               err = drv->suspend(dev, state); 
    6201104-               if (err) { 
     
    7651249                } 
    7661250  
     1251@@ -497,7 +559,7 @@ error: 
     1252 } 
     1253  
     1254 /* Needs ssb_buses_lock() */ 
     1255-static int ssb_attach_queued_buses(void) 
     1256+static int __devinit ssb_attach_queued_buses(void) 
     1257 { 
     1258        struct ssb_bus *bus, *n; 
     1259        int err = 0; 
     1260@@ -708,9 +770,9 @@ out: 
     1261        return err; 
     1262 } 
     1263  
     1264-static int ssb_bus_register(struct ssb_bus *bus, 
     1265-                           ssb_invariants_func_t get_invariants, 
     1266-                           unsigned long baseaddr) 
     1267+static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     1268+                                     ssb_invariants_func_t get_invariants, 
     1269+                                     unsigned long baseaddr) 
     1270 { 
     1271        int err; 
     1272  
    7671273@@ -724,12 +786,18 @@ static int ssb_bus_register(struct ssb_b 
    7681274        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     
    7941300        ssb_buses_unlock(); 
    7951301        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     1302@@ -783,8 +853,8 @@ err_disable_xtal: 
     1303 } 
     1304  
     1305 #ifdef CONFIG_SSB_PCIHOST 
     1306-int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     1307-                           struct pci_dev *host_pci) 
     1308+int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     1309+                                     struct pci_dev *host_pci) 
     1310 { 
     1311        int err; 
     1312  
    7961313@@ -796,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
    7971314        if (!err) { 
     
    8041321  
    8051322        return err; 
    806 @@ -825,6 +898,28 @@ int ssb_bus_pcmciabus_register(struct ss 
     1323@@ -804,9 +877,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register); 
     1324 #endif /* CONFIG_SSB_PCIHOST */ 
     1325  
     1326 #ifdef CONFIG_SSB_PCMCIAHOST 
     1327-int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     1328-                              struct pcmcia_device *pcmcia_dev, 
     1329-                              unsigned long baseaddr) 
     1330+int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     1331+                                        struct pcmcia_device *pcmcia_dev, 
     1332+                                        unsigned long baseaddr) 
     1333 { 
     1334        int err; 
     1335  
     1336@@ -825,9 +898,32 @@ int ssb_bus_pcmciabus_register(struct ss 
    8071337 EXPORT_SYMBOL(ssb_bus_pcmciabus_register); 
    8081338 #endif /* CONFIG_SSB_PCMCIAHOST */ 
    8091339  
     1340-int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1341-                           unsigned long baseaddr, 
     1342-                           ssb_invariants_func_t get_invariants) 
    8101343+#ifdef CONFIG_SSB_SDIOHOST 
    811 +int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
    812 +                            unsigned int quirks) 
     1344+int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     1345+                                      struct sdio_func *func, 
     1346+                                      unsigned int quirks) 
    8131347+{ 
    8141348+       int err; 
     
    8301364+#endif /* CONFIG_SSB_PCMCIAHOST */ 
    8311365+ 
    832  int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    833                             unsigned long baseaddr, 
    834                             ssb_invariants_func_t get_invariants) 
     1366+int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1367+                                     unsigned long baseaddr, 
     1368+                                     ssb_invariants_func_t get_invariants) 
     1369 { 
     1370        int err; 
     1371  
     1372@@ -908,8 +1004,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32 
     1373        switch (plltype) { 
     1374        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
     1375                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
     1376-                       return SSB_CHIPCO_CLK_T6_M0; 
     1377-               return SSB_CHIPCO_CLK_T6_M1; 
     1378+                       return SSB_CHIPCO_CLK_T6_M1; 
     1379+               return SSB_CHIPCO_CLK_T6_M0; 
     1380        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
     1381        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
     1382        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
     1383@@ -1024,23 +1120,22 @@ static u32 ssb_tmslow_reject_bitmask(str 
     1384 { 
     1385        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
     1386  
     1387-       /* The REJECT bit changed position in TMSLOW between 
     1388-        * Backplane revisions. */ 
     1389+       /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
     1390        switch (rev) { 
     1391        case SSB_IDLOW_SSBREV_22: 
     1392-               return SSB_TMSLOW_REJECT_22; 
     1393+       case SSB_IDLOW_SSBREV_24: 
     1394+       case SSB_IDLOW_SSBREV_26: 
     1395+               return SSB_TMSLOW_REJECT; 
     1396        case SSB_IDLOW_SSBREV_23: 
     1397                return SSB_TMSLOW_REJECT_23; 
     1398-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
     1399-       case SSB_IDLOW_SSBREV_25:     /* same here */ 
     1400-       case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1401+       case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
     1402        case SSB_IDLOW_SSBREV_27:     /* same here */ 
     1403-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1404+               return SSB_TMSLOW_REJECT;       /* this is a guess */ 
     1405        default: 
     1406                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
     1407                WARN_ON(1); 
     1408        } 
     1409-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1410+       return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
     1411 } 
     1412  
     1413 int ssb_device_is_enabled(struct ssb_device *dev) 
    8351414@@ -1099,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
    8361415 } 
     
    9041483        ssb_write32(dev, SSB_TMSLOW, 
    9051484                    reject | SSB_TMSLOW_RESET | 
    906 @@ -1358,8 +1471,10 @@ static int __init ssb_modinit(void) 
     1485@@ -1155,7 +1268,10 @@ u32 ssb_dma_translation(struct ssb_devic 
     1486        case SSB_BUSTYPE_SSB: 
     1487                return 0; 
     1488        case SSB_BUSTYPE_PCI: 
     1489-               return SSB_PCI_DMA; 
     1490+               if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) 
     1491+                       return SSB_PCIE_DMA_H32; 
     1492+               else 
     1493+                       return SSB_PCI_DMA; 
     1494        default: 
     1495                __ssb_dma_not_implemented(dev); 
     1496        } 
     1497@@ -1272,20 +1388,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     1498  
     1499 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
     1500 { 
     1501-       struct ssb_chipcommon *cc; 
     1502        int err; 
     1503        enum ssb_clkmode mode; 
     1504  
     1505        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     1506        if (err) 
     1507                goto error; 
     1508-       cc = &bus->chipco; 
     1509-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1510-       ssb_chipco_set_clockmode(cc, mode); 
     1511  
     1512 #ifdef CONFIG_SSB_DEBUG 
     1513        bus->powered_up = 1; 
     1514 #endif 
     1515+ 
     1516+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1517+       ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1518+ 
     1519        return 0; 
     1520 error: 
     1521        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     1522@@ -1293,6 +1409,37 @@ error: 
     1523 } 
     1524 EXPORT_SYMBOL(ssb_bus_powerup); 
     1525  
     1526+static void ssb_broadcast_value(struct ssb_device *dev, 
     1527+                               u32 address, u32 data) 
     1528+{ 
     1529+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1530+       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1531+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1532+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1533+#endif 
     1534+ 
     1535+       ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     1536+       ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     1537+       ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     1538+       ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     1539+} 
     1540+ 
     1541+void ssb_commit_settings(struct ssb_bus *bus) 
     1542+{ 
     1543+       struct ssb_device *dev; 
     1544+ 
     1545+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1546+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1547+#else 
     1548+       dev = bus->chipco.dev; 
     1549+#endif 
     1550+       if (WARN_ON(!dev)) 
     1551+               return; 
     1552+       /* This forces an update of the cached registers. */ 
     1553+       ssb_broadcast_value(dev, 0xFD8, 0); 
     1554+} 
     1555+EXPORT_SYMBOL(ssb_commit_settings); 
     1556+ 
     1557 u32 ssb_admatch_base(u32 adm) 
     1558 { 
     1559        u32 base = 0; 
     1560@@ -1358,8 +1505,10 @@ static int __init ssb_modinit(void) 
    9071561        ssb_buses_lock(); 
    9081562        err = ssb_attach_queued_buses(); 
     
    9161570        err = b43_pci_ssb_bridge_init(); 
    9171571        if (err) { 
    918 @@ -1375,7 +1490,7 @@ static int __init ssb_modinit(void) 
     1572@@ -1375,7 +1524,7 @@ static int __init ssb_modinit(void) 
    9191573                /* don't fail SSB init because of this */ 
    9201574                err = 0; 
     
    11821836  
    11831837        if (out->boardflags_lo == 0xFFFF) 
    1184 @@ -565,12 +663,34 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1838@@ -564,13 +662,34 @@ static int sprom_extract(struct ssb_bus 
     1839 static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    11851840                             struct ssb_sprom *sprom) 
    11861841 { 
    1187         const struct ssb_sprom *fallback; 
     1842-       const struct ssb_sprom *fallback; 
    11881843-       int err = -ENOMEM; 
    11891844+       int err; 
     
    11941849+               return -ENODEV; 
    11951850+       } 
    1196 +       if (bus->chipco.dev) {  /* can be unavailible! */ 
     1851+       if (bus->chipco.dev) {  /* can be unavailable! */ 
    11971852+               /* 
    11981853+                * get SPROM offset: SSB_SPROM_BASE1 except for 
     
    12191874        sprom_do_read(bus, buf); 
    12201875        err = sprom_check_crc(buf, bus->sprom_size); 
    1221 @@ -580,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1876@@ -580,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_ 
    12221877                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    12231878                              GFP_KERNEL); 
     
    12281883                sprom_do_read(bus, buf); 
    12291884                err = sprom_check_crc(buf, bus->sprom_size); 
    1230 @@ -602,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1885                if (err) { 
     1886                        /* All CRC attempts failed. 
     1887                         * Maybe there is no SPROM on the device? 
     1888-                        * If we have a fallback, use that. */ 
     1889-                       fallback = ssb_get_fallback_sprom(); 
     1890-                       if (fallback) { 
     1891-                               memcpy(sprom, fallback, sizeof(*sprom)); 
     1892+                        * Now we ask the arch code if there is some sprom 
     1893+                        * available for this device in some other storage */ 
     1894+                       err = ssb_fill_sprom_with_fallback(bus, sprom); 
     1895+                       if (err) { 
     1896+                               ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     1897+                                          " fallback SPROM failed (err %d)\n", 
     1898+                                          err); 
     1899+                       } else { 
     1900+                               ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     1901+                                           " revision %d provided by" 
     1902+                                           " platform.\n", sprom->revision); 
     1903                                err = 0; 
     1904                                goto out_free; 
     1905                        } 
     1906@@ -602,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_ 
    12311907  
    12321908 out_free: 
     
    12361912 } 
    12371913  
     1914 static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
     1915                                  struct ssb_boardinfo *bi) 
     1916 { 
     1917-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
     1918-                            &bi->vendor); 
     1919-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
     1920-                            &bi->type); 
     1921-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     1922-                            &bi->rev); 
     1923+       bi->vendor = bus->host_pci->subsystem_vendor; 
     1924+       bi->type = bus->host_pci->subsystem_device; 
     1925+       bi->rev = bus->host_pci->revision; 
     1926 } 
     1927  
     1928 int ssb_pci_get_invariants(struct ssb_bus *bus, 
    12381929--- a/drivers/ssb/pcihost_wrapper.c 
    12391930+++ b/drivers/ssb/pcihost_wrapper.c 
     
    12461937  
    12471938  
    1248 @@ -58,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     1939@@ -52,12 +53,13 @@ static int ssb_pcihost_resume(struct pci 
     1940 # define ssb_pcihost_resume    NULL 
     1941 #endif /* CONFIG_PM */ 
     1942  
     1943-static int ssb_pcihost_probe(struct pci_dev *dev, 
     1944-                            const struct pci_device_id *id) 
     1945+static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     1946+                                      const struct pci_device_id *id) 
     1947 { 
    12491948        struct ssb_bus *ssb; 
    12501949        int err = -ENOMEM; 
     
    12671966        if (err) 
    12681967                goto err_pci_release_regions; 
     1968@@ -102,7 +110,7 @@ static void ssb_pcihost_remove(struct pc 
     1969        pci_set_drvdata(dev, NULL); 
     1970 } 
     1971  
     1972-int ssb_pcihost_register(struct pci_driver *driver) 
     1973+int __devinit ssb_pcihost_register(struct pci_driver *driver) 
     1974 { 
     1975        driver->probe = ssb_pcihost_probe; 
     1976        driver->remove = ssb_pcihost_remove; 
    12691977--- a/drivers/ssb/pcmcia.c 
    12701978+++ b/drivers/ssb/pcmcia.c 
     
    15942302  
    15952303        return mmio; 
    1596 @@ -339,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2304@@ -245,7 +260,10 @@ static int we_support_multiple_80211_cor 
     2305 #ifdef CONFIG_SSB_PCIHOST 
     2306        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     2307                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     2308-                   bus->host_pci->device == 0x4324) 
     2309+                   ((bus->host_pci->device == 0x4313) || 
     2310+                    (bus->host_pci->device == 0x431A) || 
     2311+                    (bus->host_pci->device == 0x4321) || 
     2312+                    (bus->host_pci->device == 0x4324))) 
     2313                        return 1; 
     2314        } 
     2315 #endif /* CONFIG_SSB_PCIHOST */ 
     2316@@ -294,8 +312,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2317        } else { 
     2318                if (bus->bustype == SSB_BUSTYPE_PCI) { 
     2319                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
     2320-                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     2321-                                            &bus->chip_rev); 
     2322+                       bus->chip_rev = bus->host_pci->revision; 
     2323                        bus->chip_package = 0; 
     2324                } else { 
     2325                        bus->chip_id = 0x4710; 
     2326@@ -339,7 +356,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    15972327                dev->bus = bus; 
    15982328                dev->ops = bus->ops; 
     
    16032333                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    16042334                            i, ssb_core_name(dev->id.coreid), 
    1605 @@ -407,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2335@@ -407,6 +424,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    16062336                        bus->pcicore.dev = dev; 
    16072337 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     
    22352965--- a/drivers/ssb/sprom.c 
    22362966+++ b/drivers/ssb/sprom.c 
    2237 @@ -13,6 +13,9 @@ 
     2967@@ -13,8 +13,11 @@ 
    22382968  
    22392969 #include "ssb_private.h" 
     
    22412971+#include <linux/ctype.h> 
    22422972+#include <linux/slab.h> 
    2243 + 
    2244   
    2245  static const struct ssb_sprom *fallback_sprom; 
    2246   
     2973  
     2974-static const struct ssb_sprom *fallback_sprom; 
     2975+ 
     2976+static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
     2977  
     2978  
     2979 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
    22472980@@ -33,17 +36,27 @@ static int sprom2hex(const u16 *sprom, c 
    22482981 static int hex2sprom(u16 *sprom, const char *dump, size_t len, 
     
    23063039                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    23073040 out_unlock: 
    2308 @@ -167,3 +176,18 @@ const struct ssb_sprom *ssb_get_fallback 
    2309  { 
    2310         return fallback_sprom; 
    2311  } 
     3041@@ -136,34 +145,56 @@ out: 
     3042 } 
     3043  
     3044 /** 
     3045- * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
     3046+ * ssb_arch_register_fallback_sprom - Registers a method providing a 
     3047+ * fallback SPROM if no SPROM is found. 
     3048  * 
     3049- * @sprom: The SPROM data structure to register. 
     3050+ * @sprom_callback: The callback function. 
     3051  * 
     3052- * With this function the architecture implementation may register a fallback 
     3053- * SPROM data structure. The fallback is only used for PCI based SSB devices, 
     3054- * where no valid SPROM can be found in the shadow registers. 
     3055+ * With this function the architecture implementation may register a 
     3056+ * callback handler which fills the SPROM data structure. The fallback is 
     3057+ * only used for PCI based SSB devices, where no valid SPROM can be found 
     3058+ * in the shadow registers. 
     3059  * 
     3060- * This function is useful for weird architectures that have a half-assed SSB device 
     3061- * hardwired to their PCI bus. 
     3062+ * This function is useful for weird architectures that have a half-assed 
     3063+ * SSB device hardwired to their PCI bus. 
     3064  * 
     3065- * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
     3066- * don't use this fallback. 
     3067- * Architectures must provide the SPROM for native SSB devices anyway, 
     3068- * so the fallback also isn't used for native devices. 
     3069+ * Note that it does only work with PCI attached SSB devices. PCMCIA 
     3070+ * devices currently don't use this fallback. 
     3071+ * Architectures must provide the SPROM for native SSB devices anyway, so 
     3072+ * the fallback also isn't used for native devices. 
     3073  * 
     3074- * This function is available for architecture code, only. So it is not exported. 
     3075+ * This function is available for architecture code, only. So it is not 
     3076+ * exported. 
     3077  */ 
     3078-int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 
     3079+int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus, 
     3080+                                    struct ssb_sprom *out)) 
     3081 { 
     3082-       if (fallback_sprom) 
     3083+       if (get_fallback_sprom) 
     3084                return -EEXIST; 
     3085-       fallback_sprom = sprom; 
     3086+       get_fallback_sprom = sprom_callback; 
     3087  
     3088        return 0; 
     3089 } 
     3090  
     3091-const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     3092+int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
     3093 { 
     3094-       return fallback_sprom; 
     3095+       if (!get_fallback_sprom) 
     3096+               return -ENOENT; 
     3097+ 
     3098+       return get_fallback_sprom(bus, out); 
     3099+} 
    23123100+ 
    23133101+/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     
    23193107+          on PCMCIA */ 
    23203108+       if (bus->bustype == SSB_BUSTYPE_PCI && 
    2321 +           bus->chipco.dev &&  /* can be unavailible! */ 
     3109+           bus->chipco.dev &&  /* can be unavailable! */ 
    23223110+           bus->chipco.dev->id.revision >= 31) 
    23233111+               return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
    23243112+ 
    23253113+       return true; 
    2326 +} 
     3114 } 
    23273115--- a/drivers/ssb/ssb_private.h 
    23283116+++ b/drivers/ssb/ssb_private.h 
     
    23743162 /* scan.c */ 
    23753163 extern const char *ssb_core_name(u16 coreid); 
    2376 @@ -136,19 +176,27 @@ extern const struct ssb_sprom *ssb_get_f 
     3164@@ -131,24 +171,33 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     3165                             const char *buf, size_t count, 
     3166                             int (*sprom_check_crc)(const u16 *sprom, size_t size), 
     3167                             int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)); 
     3168-extern const struct ssb_sprom *ssb_get_fallback_sprom(void); 
     3169+extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, 
     3170+                                       struct ssb_sprom *out); 
     3171  
    23773172  
    23783173 /* core.c */ 
     
    24053200 { 
    24063201        return 0; 
    2407 @@ -156,6 +204,6 @@ static inline int b43_pci_ssb_bridge_ini 
     3202@@ -156,6 +205,6 @@ static inline int b43_pci_ssb_bridge_ini 
    24083203 static inline void b43_pci_ssb_bridge_exit(void) 
    24093204 { 
     
    24253220--- a/include/linux/ssb/ssb.h 
    24263221+++ b/include/linux/ssb/ssb.h 
    2427 @@ -27,24 +27,58 @@ struct ssb_sprom { 
     3222@@ -27,24 +27,60 @@ struct ssb_sprom { 
    24283223        u8 et1mdcport;          /* MDIO for enet1 */ 
    24293224        u8 board_rev;           /* Board revision number from SPROM. */ 
     
    24313226-       u8 ant_available_a;     /* A-PHY antenna available bits (up to 4) */ 
    24323227-       u8 ant_available_bg;    /* B/G-PHY antenna available bits (up to 4) */ 
     3228+       u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */ 
     3229+       u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */ 
    24333230+       u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
    24343231+       u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
     
    24903287        /* Antenna gain values for up to 4 antennas 
    24913288         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    2492 @@ -58,7 +92,7 @@ struct ssb_sprom { 
     3289@@ -58,14 +94,14 @@ struct ssb_sprom { 
    24933290                } ghz5;         /* 5GHz band */ 
    24943291        } antenna_gain; 
     
    24993296  
    25003297 /* Information about the PCB the circuitry is soldered on. */ 
    2501 @@ -137,7 +171,7 @@ struct ssb_device { 
     3298 struct ssb_boardinfo { 
     3299        u16 vendor; 
     3300        u16 type; 
     3301-       u16 rev; 
     3302+       u8  rev; 
     3303 }; 
     3304  
     3305  
     3306@@ -137,7 +173,7 @@ struct ssb_device { 
    25023307         * is an optimization. */ 
    25033308        const struct ssb_bus_ops *ops; 
     
    25083313        struct ssb_bus *bus; 
    25093314        struct ssb_device_id id; 
    2510 @@ -208,6 +242,7 @@ enum ssb_bustype { 
     3315@@ -208,6 +244,7 @@ enum ssb_bustype { 
    25113316        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */ 
    25123317        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
     
    25163321  
    25173322 /* board_vendor */ 
    2518 @@ -238,20 +273,33 @@ struct ssb_bus { 
     3323@@ -238,20 +275,33 @@ struct ssb_bus { 
    25193324  
    25203325        const struct ssb_bus_ops *ops; 
     
    25583363 #ifdef CONFIG_SSB_SPROM 
    25593364        /* Mutex to protect the SPROM writing. */ 
    2560 @@ -261,6 +309,7 @@ struct ssb_bus { 
     3365@@ -260,7 +310,8 @@ struct ssb_bus { 
     3366  
    25613367        /* ID information about the Chip. */ 
    25623368        u16 chip_id; 
    2563         u16 chip_rev; 
     3369-       u16 chip_rev; 
     3370+       u8 chip_rev; 
    25643371+       u16 sprom_offset; 
    25653372        u16 sprom_size;         /* number of words in sprom */ 
    25663373        u8 chip_package; 
    25673374  
    2568 @@ -306,6 +355,11 @@ struct ssb_bus { 
     3375@@ -306,6 +357,11 @@ struct ssb_bus { 
    25693376 #endif /* DEBUG */ 
    25703377 }; 
     
    25783385 struct ssb_init_invariants { 
    25793386        /* Versioning information about the PCB. */ 
    2580 @@ -336,9 +390,18 @@ extern int ssb_bus_pcmciabus_register(st 
     3387@@ -336,12 +392,23 @@ extern int ssb_bus_pcmciabus_register(st 
    25813388                                      struct pcmcia_device *pcmcia_dev, 
    25823389                                      unsigned long baseaddr); 
     
    25963403 /* Set a fallback SPROM. 
    25973404  * See kdoc at the function definition for complete documentation. */ 
    2598  extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     3405-extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     3406+extern int ssb_arch_register_fallback_sprom( 
     3407+               int (*sprom_callback)(struct ssb_bus *bus, 
     3408+               struct ssb_sprom *out)); 
     3409  
     3410 /* Suspend a SSB bus. 
     3411  * Call this from the parent bus suspend routine. */ 
     3412@@ -612,6 +679,7 @@ extern int ssb_bus_may_powerdown(struct 
     3413  * Otherwise static always-on powercontrol will be used. */ 
     3414 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
     3415  
     3416+extern void ssb_commit_settings(struct ssb_bus *bus); 
     3417  
     3418 /* Various helper functions */ 
     3419 extern u32 ssb_admatch_base(u32 adm); 
    25993420--- a/include/linux/ssb/ssb_driver_chipcommon.h 
    26003421+++ b/include/linux/ssb/ssb_driver_chipcommon.h 
     
    26073428 #define  SSB_CHIPCO_CORECTL_UARTCLK0   0x00000001      /* Drive UART with internal clock */ 
    26083429 #define         SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */ 
    2609 @@ -385,6 +386,7 @@ 
     3430@@ -122,6 +123,8 @@ 
     3431 #define SSB_CHIPCO_FLASHDATA           0x0048 
     3432 #define SSB_CHIPCO_BCAST_ADDR          0x0050 
     3433 #define SSB_CHIPCO_BCAST_DATA          0x0054 
     3434+#define SSB_CHIPCO_GPIOPULLUP          0x0058          /* Rev >= 20 only */ 
     3435+#define SSB_CHIPCO_GPIOPULLDOWN                0x005C          /* Rev >= 20 only */ 
     3436 #define SSB_CHIPCO_GPIOIN              0x0060 
     3437 #define SSB_CHIPCO_GPIOOUT             0x0064 
     3438 #define SSB_CHIPCO_GPIOOUTEN           0x0068 
     3439@@ -130,6 +133,9 @@ 
     3440 #define SSB_CHIPCO_GPIOIRQ             0x0074 
     3441 #define SSB_CHIPCO_WATCHDOG            0x0080 
     3442 #define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */ 
     3443+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME  0x0000FFFF 
     3444+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT    0 
     3445+#define  SSB_CHIPCO_GPIOTIMER_ONTIME   0xFFFF0000 
     3446 #define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16 
     3447 #define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */ 
     3448 #define SSB_CHIPCO_CLOCK_N             0x0090 
     3449@@ -188,8 +194,10 @@ 
     3450 #define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ        0x00000008 /* ALP available request */ 
     3451 #define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */ 
     3452 #define  SSB_CHIPCO_CLKCTLST_HWCROFF   0x00000020 /* Force HW clock request off */ 
     3453-#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00010000 /* HT available */ 
     3454-#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00020000 /* APL available */ 
     3455+#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00010000 /* ALP available */ 
     3456+#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00020000 /* HT available */ 
     3457+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT     0x00010000 /* 4328a0 has reversed bits */ 
     3458+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP    0x00020000 /* 4328a0 has reversed bits */ 
     3459 #define SSB_CHIPCO_HW_WORKAROUND       0x01E4 /* Hardware workaround (rev >= 20) */ 
     3460 #define SSB_CHIPCO_UART0_DATA          0x0300 
     3461 #define SSB_CHIPCO_UART0_IMR           0x0304 
     3462@@ -385,6 +393,7 @@ 
    26103463  
    26113464  
     
    26153468 #define SSB_CHIPCO_CHST_4325_DEFCIS_SEL                0 /* OTP is powered up, use def. CIS, no SPROM */ 
    26163469 #define SSB_CHIPCO_CHST_4325_SPROM_SEL         1 /* OTP is powered up, SPROM is present */ 
    2617 @@ -398,6 +400,18 @@ 
     3470@@ -398,6 +407,18 @@ 
    26183471 #define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT  4 
    26193472 #define SSB_CHIPCO_CHST_4325_PMUTOP_2B                 0x00000200 /* 1 for 2b, 0 for to 2a */ 
     
    26343487  
    26353488 /** Clockcontrol masks and values **/ 
    2636 @@ -564,6 +578,7 @@ struct ssb_chipcommon_pmu { 
     3489@@ -564,6 +585,7 @@ struct ssb_chipcommon_pmu { 
    26373490 struct ssb_chipcommon { 
    26383491        struct ssb_device *dev; 
     
    26423495        u16 fast_pwrup_delay; 
    26433496        struct ssb_chipcommon_pmu pmu; 
    2644 @@ -629,5 +644,15 @@ extern int ssb_chipco_serial_init(struct 
     3497@@ -629,5 +651,15 @@ extern int ssb_chipco_serial_init(struct 
    26453498 /* PMU support */ 
    26463499 extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
     
    26693522 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
    26703523 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     3524@@ -95,7 +97,7 @@ 
     3525 #define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */ 
     3526 #define SSB_TMSLOW             0x0F98     /* SB Target State Low */ 
     3527 #define  SSB_TMSLOW_RESET      0x00000001 /* Reset */ 
     3528-#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */ 
     3529+#define  SSB_TMSLOW_REJECT     0x00000002 /* Reject (Standard Backplane) */ 
     3530 #define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */ 
     3531 #define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */ 
     3532 #define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */ 
    26713533@@ -162,7 +164,7 @@ 
    26723534  
  • trunk/target/linux/generic/patches-2.6.30/974-ssb_b43_default_on.patch

    r21952 r27731  
    1818 config SSB_PCMCIAHOST_POSSIBLE 
    1919        bool 
     20--- a/drivers/bcma/Kconfig 
     21+++ b/drivers/bcma/Kconfig 
     22@@ -17,6 +17,7 @@ config BCMA 
     23 config BCMA_BLOCKIO 
     24        bool 
     25        depends on BCMA 
     26+       default y 
     27  
     28 config BCMA_HOST_PCI_POSSIBLE 
     29        bool 
  • trunk/target/linux/generic/patches-2.6.31/941-ssb_update.patch

    r26127 r27731  
    4444--- a/drivers/ssb/driver_chipcommon.c 
    4545+++ b/drivers/ssb/driver_chipcommon.c 
    46 @@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     46@@ -46,40 +46,66 @@ void ssb_chipco_set_clockmode(struct ssb 
     47        if (!ccdev) 
     48                return; 
     49        bus = ccdev->bus; 
     50+ 
     51+       /* We support SLOW only on 6..9 */ 
     52+       if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW) 
     53+               mode = SSB_CLKMODE_DYNAMIC; 
     54+ 
     55+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) 
     56+               return; /* PMU controls clockmode, separated function needed */ 
     57+       SSB_WARN_ON(ccdev->id.revision >= 20); 
     58+ 
     59        /* chipcommon cores prior to rev6 don't support dynamic clock control */ 
     60        if (ccdev->id.revision < 6) 
     61                return; 
     62-       /* chipcommon cores rev10 are a whole new ball game */ 
     63+ 
     64+       /* ChipCommon cores rev10+ need testing */ 
     65        if (ccdev->id.revision >= 10) 
     66                return; 
     67+ 
     68        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     69                return; 
     70  
     71        switch (mode) { 
     72-       case SSB_CLKMODE_SLOW: 
     73+       case SSB_CLKMODE_SLOW: /* For revs 6..9 only */ 
     74                tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     75                tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     76                chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     77                break; 
     78        case SSB_CLKMODE_FAST: 
     79-               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     80-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     81-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     82-               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     83-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     84+               if (ccdev->id.revision < 10) { 
     85+                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     86+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     87+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     88+                       tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     89+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     90+               } else { 
     91+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     92+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) | 
     93+                                SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     94+                       /* udelay(150); TODO: not available in early init */ 
     95+               } 
     96                break; 
     97        case SSB_CLKMODE_DYNAMIC: 
     98-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     99-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     100-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     101-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     102-               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     103-                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     104-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     105- 
     106-               /* for dynamic control, we have to release our xtal_pu "force on" */ 
     107-               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     108-                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     109+               if (ccdev->id.revision < 10) { 
     110+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     111+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     112+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     113+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     114+                       if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != 
     115+                           SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     116+                               tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     117+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     118+ 
     119+                       /* For dynamic control, we have to release our xtal_pu 
     120+                        * "force on" */ 
     121+                       if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     122+                               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     123+               } else { 
     124+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     125+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) & 
     126+                                ~SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     127+               } 
     128                break; 
     129        default: 
     130                SSB_WARN_ON(1); 
     131@@ -209,6 +235,24 @@ static void chipco_powercontrol_init(str 
    47132        } 
    48133 } 
     
    69154 { 
    70155        struct ssb_bus *bus = cc->dev->bus; 
    71 @@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     156@@ -218,6 +262,12 @@ static void calc_fast_powerup_delay(stru 
    72157  
    73158        if (bus->bustype != SSB_BUSTYPE_PCI) 
     
    82167                return; 
    83168  
    84 @@ -233,6 +257,9 @@ void ssb_chipcommon_init(struct ssb_chip 
     169@@ -233,6 +283,15 @@ void ssb_chipcommon_init(struct ssb_chip 
    85170 { 
    86171        if (!cc->dev) 
     
    89174+               cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
    90175+       ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     176+ 
     177+       if (cc->dev->id.revision >= 20) { 
     178+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0); 
     179+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0); 
     180+       } 
     181+ 
    91182        ssb_pmu_init(cc); 
    92183        chipco_powercontrol_init(cc); 
    93184        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
    94 @@ -370,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     185@@ -370,6 +429,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
    95186 { 
    96187        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     
    137228                ssb_printk(KERN_ERR PFX 
    138229                           "ERROR: PLL init unknown for device %04X\n", 
    139 @@ -402,6 +423,7 @@ static void ssb_pmu_resources_init(struc 
     230@@ -396,12 +417,15 @@ static void ssb_pmu_resources_init(struc 
     231        u32 min_msk = 0, max_msk = 0; 
     232        unsigned int i; 
     233        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
     234-       unsigned int updown_tab_size; 
     235+       unsigned int updown_tab_size = 0; 
     236        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
     237-       unsigned int depend_tab_size; 
     238+       unsigned int depend_tab_size = 0; 
    140239  
    141240        switch (bus->chip_id) { 
    142241        case 0x4312: 
     242+                min_msk = 0xCBB; 
     243+                break; 
    143244+       case 0x4322: 
    144245                /* We keep the default settings: 
    145246                 * min_msk = 0xCBB 
    146247                 * max_msk = 0x7FFFF 
    147 @@ -480,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     248@@ -480,9 +504,9 @@ static void ssb_pmu_resources_init(struc 
    148249                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
    149250 } 
     
    156257  
    157258        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
    158 @@ -494,15 +516,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
     259@@ -494,15 +518,91 @@ void ssb_pmu_init(struct ssb_chipcommon 
    159260        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
    160261                    cc->pmu.rev, pmucap); 
     
    267368  
    268369 /* 
     370@@ -105,8 +106,9 @@ void gige_pcicfg_write32(struct ssb_gige 
     371        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
     372 } 
     373  
     374-static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
     375-                                   int reg, int size, u32 *val) 
     376+static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus, 
     377+                                             unsigned int devfn, int reg, 
     378+                                             int size, u32 *val) 
     379 { 
     380        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     381        unsigned long flags; 
     382@@ -135,8 +137,9 @@ static int ssb_gige_pci_read_config(stru 
     383        return PCIBIOS_SUCCESSFUL; 
     384 } 
     385  
     386-static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
     387-                                    int reg, int size, u32 val) 
     388+static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus, 
     389+                                              unsigned int devfn, int reg, 
     390+                                              int size, u32 val) 
     391 { 
     392        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     393        unsigned long flags; 
     394@@ -165,7 +168,8 @@ static int ssb_gige_pci_write_config(str 
     395        return PCIBIOS_SUCCESSFUL; 
     396 } 
     397  
     398-static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id) 
     399+static int __devinit ssb_gige_probe(struct ssb_device *sdev, 
     400+                                   const struct ssb_device_id *id) 
     401 { 
     402        struct ssb_gige *dev; 
     403        u32 base, tmslow, tmshigh; 
    269404--- a/drivers/ssb/driver_mipscore.c 
    270405+++ b/drivers/ssb/driver_mipscore.c 
     
    290425--- a/drivers/ssb/driver_pcicore.c 
    291426+++ b/drivers/ssb/driver_pcicore.c 
    292 @@ -246,20 +246,12 @@ static struct pci_controller ssb_pcicore 
     427@@ -15,6 +15,11 @@ 
     428  
     429 #include "ssb_private.h" 
     430  
     431+static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address); 
     432+static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data); 
     433+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address); 
     434+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     435+                               u8 address, u16 data); 
     436  
     437 static inline 
     438 u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset) 
     439@@ -246,20 +251,12 @@ static struct pci_controller ssb_pcicore 
    293440        .pci_ops        = &ssb_pcicore_pciops, 
    294441        .io_resource    = &ssb_pcicore_io_resource, 
     
    311458                /* This is not a device on the PCI-core bridge. */ 
    312459                return -ENODEV; 
    313 @@ -268,27 +260,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
     460@@ -268,27 +265,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
    314461        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
    315462                   pci_name(d)); 
     
    339486        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
    340487        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
    341 @@ -551,13 +522,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     488@@ -338,7 +314,7 @@ int ssb_pcicore_pcibios_map_irq(const st 
     489        return ssb_mips_irq(extpci_core->dev) + 2; 
     490 } 
     491  
     492-static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     493+static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     494 { 
     495        u32 val; 
     496  
     497@@ -403,7 +379,7 @@ static void ssb_pcicore_init_hostmode(st 
     498        register_pci_controller(&ssb_pcicore_controller); 
     499 } 
     500  
     501-static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     502+static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     503 { 
     504        struct ssb_bus *bus = pc->dev->bus; 
     505        u16 chipid_top; 
     506@@ -432,25 +408,133 @@ static int pcicore_is_in_hostmode(struct 
     507 } 
     508 #endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
     509  
     510+/************************************************** 
     511+ * Workarounds. 
     512+ **************************************************/ 
     513+ 
     514+static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc) 
     515+{ 
     516+       u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0)); 
     517+       if (((tmp & 0xF000) >> 12) != pc->dev->core_index) { 
     518+               tmp &= ~0xF000; 
     519+               tmp |= (pc->dev->core_index << 12); 
     520+               pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp); 
     521+       } 
     522+} 
     523+ 
     524+static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc) 
     525+{ 
     526+       return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80; 
     527+} 
     528+ 
     529+static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc) 
     530+{ 
     531+       const u8 serdes_pll_device = 0x1D; 
     532+       const u8 serdes_rx_device = 0x1F; 
     533+       u16 tmp; 
     534+ 
     535+       ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */, 
     536+                           ssb_pcicore_polarity_workaround(pc)); 
     537+       tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */); 
     538+       if (tmp & 0x4000) 
     539+               ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000); 
     540+} 
     541+ 
     542+static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc) 
     543+{ 
     544+       struct ssb_device *pdev = pc->dev; 
     545+       struct ssb_bus *bus = pdev->bus; 
     546+       u32 tmp; 
     547+ 
     548+       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     549+       tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     550+       tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     551+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     552+ 
     553+       if (pdev->id.revision < 5) { 
     554+               tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     555+               tmp &= ~SSB_IMCFGLO_SERTO; 
     556+               tmp |= 2; 
     557+               tmp &= ~SSB_IMCFGLO_REQTO; 
     558+               tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     559+               ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     560+               ssb_commit_settings(bus); 
     561+       } else if (pdev->id.revision >= 11) { 
     562+               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     563+               tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     564+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     565+       } 
     566+} 
     567+ 
     568+static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc) 
     569+{ 
     570+       u32 tmp; 
     571+       u8 rev = pc->dev->id.revision; 
     572+ 
     573+       if (rev == 0 || rev == 1) { 
     574+               /* TLP Workaround register. */ 
     575+               tmp = ssb_pcie_read(pc, 0x4); 
     576+               tmp |= 0x8; 
     577+               ssb_pcie_write(pc, 0x4, tmp); 
     578+       } 
     579+       if (rev == 1) { 
     580+               /* DLLP Link Control register. */ 
     581+               tmp = ssb_pcie_read(pc, 0x100); 
     582+               tmp |= 0x40; 
     583+               ssb_pcie_write(pc, 0x100, tmp); 
     584+       } 
     585+ 
     586+       if (rev == 0) { 
     587+               const u8 serdes_rx_device = 0x1F; 
     588+ 
     589+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     590+                                       2 /* Timer */, 0x8128); 
     591+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     592+                                       6 /* CDR */, 0x0100); 
     593+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     594+                                       7 /* CDR BW */, 0x1466); 
     595+       } else if (rev == 3 || rev == 4 || rev == 5) { 
     596+               /* TODO: DLLP Power Management Threshold */ 
     597+               ssb_pcicore_serdes_workaround(pc); 
     598+               /* TODO: ASPM */ 
     599+       } else if (rev == 7) { 
     600+               /* TODO: No PLL down */ 
     601+       } 
     602+ 
     603+       if (rev >= 6) { 
     604+               /* Miscellaneous Configuration Fixup */ 
     605+               tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5)); 
     606+               if (!(tmp & 0x8000)) 
     607+                       pcicore_write16(pc, SSB_PCICORE_SPROM(5), 
     608+                                       tmp | 0x8000); 
     609+       } 
     610+} 
     611  
     612 /************************************************** 
     613  * Generic and Clientmode operation code. 
     614  **************************************************/ 
     615  
     616-static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     617+static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     618 { 
     619+       ssb_pcicore_fix_sprom_core_index(pc); 
     620+ 
     621        /* Disable PCI interrupts. */ 
     622        ssb_write32(pc->dev, SSB_INTVEC, 0); 
     623+ 
     624+       /* Additional PCIe always once-executed workarounds */ 
     625+       if (pc->dev->id.coreid == SSB_DEV_PCIE) { 
     626+               ssb_pcicore_serdes_workaround(pc); 
     627+               /* TODO: ASPM */ 
     628+               /* TODO: Clock Request Update */ 
     629+       } 
     630 } 
     631  
     632-void ssb_pcicore_init(struct ssb_pcicore *pc) 
     633+void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
     634 { 
     635        struct ssb_device *dev = pc->dev; 
     636-       struct ssb_bus *bus; 
     637  
     638        if (!dev) 
     639                return; 
     640-       bus = dev->bus; 
     641        if (!ssb_device_is_enabled(dev)) 
     642                ssb_device_enable(dev, 0); 
     643  
     644@@ -475,58 +559,104 @@ static void ssb_pcie_write(struct ssb_pc 
     645        pcicore_write32(pc, 0x134, data); 
     646 } 
     647  
     648-static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     649-                               u8 address, u16 data) 
     650+static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
     651 { 
     652        const u16 mdio_control = 0x128; 
     653        const u16 mdio_data = 0x12C; 
     654        u32 v; 
     655        int i; 
     656  
     657+       v = (1 << 30); /* Start of Transaction */ 
     658+       v |= (1 << 28); /* Write Transaction */ 
     659+       v |= (1 << 17); /* Turnaround */ 
     660+       v |= (0x1F << 18); 
     661+       v |= (phy << 4); 
     662+       pcicore_write32(pc, mdio_data, v); 
     663+ 
     664+       udelay(10); 
     665+       for (i = 0; i < 200; i++) { 
     666+               v = pcicore_read32(pc, mdio_control); 
     667+               if (v & 0x100 /* Trans complete */) 
     668+                       break; 
     669+               msleep(1); 
     670+       } 
     671+} 
     672+ 
     673+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address) 
     674+{ 
     675+       const u16 mdio_control = 0x128; 
     676+       const u16 mdio_data = 0x12C; 
     677+       int max_retries = 10; 
     678+       u16 ret = 0; 
     679+       u32 v; 
     680+       int i; 
     681+ 
     682        v = 0x80; /* Enable Preamble Sequence */ 
     683        v |= 0x2; /* MDIO Clock Divisor */ 
     684        pcicore_write32(pc, mdio_control, v); 
     685  
     686+       if (pc->dev->id.revision >= 10) { 
     687+               max_retries = 200; 
     688+               ssb_pcie_mdio_set_phy(pc, device); 
     689+       } 
     690+ 
     691        v = (1 << 30); /* Start of Transaction */ 
     692-       v |= (1 << 28); /* Write Transaction */ 
     693+       v |= (1 << 29); /* Read Transaction */ 
     694        v |= (1 << 17); /* Turnaround */ 
     695-       v |= (u32)device << 22; 
     696+       if (pc->dev->id.revision < 10) 
     697+               v |= (u32)device << 22; 
     698        v |= (u32)address << 18; 
     699-       v |= data; 
     700        pcicore_write32(pc, mdio_data, v); 
     701        /* Wait for the device to complete the transaction */ 
     702        udelay(10); 
     703-       for (i = 0; i < 10; i++) { 
     704+       for (i = 0; i < max_retries; i++) { 
     705                v = pcicore_read32(pc, mdio_control); 
     706-               if (v & 0x100 /* Trans complete */) 
     707+               if (v & 0x100 /* Trans complete */) { 
     708+                       udelay(10); 
     709+                       ret = pcicore_read32(pc, mdio_data); 
     710                        break; 
     711+               } 
     712                msleep(1); 
     713        } 
     714        pcicore_write32(pc, mdio_control, 0); 
     715+       return ret; 
     716 } 
     717  
     718-static void ssb_broadcast_value(struct ssb_device *dev, 
     719-                               u32 address, u32 data) 
     720+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     721+                               u8 address, u16 data) 
     722 { 
     723-       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     724-       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     725-       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     726+       const u16 mdio_control = 0x128; 
     727+       const u16 mdio_data = 0x12C; 
     728+       int max_retries = 10; 
     729+       u32 v; 
     730+       int i; 
     731  
     732-       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
     733-       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
     734-       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
     735-       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
     736-} 
     737+       v = 0x80; /* Enable Preamble Sequence */ 
     738+       v |= 0x2; /* MDIO Clock Divisor */ 
     739+       pcicore_write32(pc, mdio_control, v); 
     740  
     741-static void ssb_commit_settings(struct ssb_bus *bus) 
     742-{ 
     743-       struct ssb_device *dev; 
     744+       if (pc->dev->id.revision >= 10) { 
     745+               max_retries = 200; 
     746+               ssb_pcie_mdio_set_phy(pc, device); 
     747+       } 
     748  
     749-       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     750-       if (WARN_ON(!dev)) 
     751-               return; 
     752-       /* This forces an update of the cached registers. */ 
     753-       ssb_broadcast_value(dev, 0xFD8, 0); 
     754+       v = (1 << 30); /* Start of Transaction */ 
     755+       v |= (1 << 28); /* Write Transaction */ 
     756+       v |= (1 << 17); /* Turnaround */ 
     757+       if (pc->dev->id.revision < 10) 
     758+               v |= (u32)device << 22; 
     759+       v |= (u32)address << 18; 
     760+       v |= data; 
     761+       pcicore_write32(pc, mdio_data, v); 
     762+       /* Wait for the device to complete the transaction */ 
     763+       udelay(10); 
     764+       for (i = 0; i < max_retries; i++) { 
     765+               v = pcicore_read32(pc, mdio_control); 
     766+               if (v & 0x100 /* Trans complete */) 
     767+                       break; 
     768+               msleep(1); 
     769+       } 
     770+       pcicore_write32(pc, mdio_control, 0); 
     771 } 
     772  
     773 int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
     774@@ -551,13 +681,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
    342775        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
    343776  
     
    355788                if (err) 
    356789                        goto out; 
     790@@ -579,48 +709,10 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     791        if (pc->setup_done) 
     792                goto out; 
     793        if (pdev->id.coreid == SSB_DEV_PCI) { 
     794-               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     795-               tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     796-               tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     797-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     798- 
     799-               if (pdev->id.revision < 5) { 
     800-                       tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     801-                       tmp &= ~SSB_IMCFGLO_SERTO; 
     802-                       tmp |= 2; 
     803-                       tmp &= ~SSB_IMCFGLO_REQTO; 
     804-                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     805-                       ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     806-                       ssb_commit_settings(bus); 
     807-               } else if (pdev->id.revision >= 11) { 
     808-                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     809-                       tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     810-                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     811-               } 
     812+               ssb_pcicore_pci_setup_workarounds(pc); 
     813        } else { 
     814                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
     815-               //TODO: Better make defines for all these magic PCIE values. 
     816-               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
     817-                       /* TLP Workaround register. */ 
     818-                       tmp = ssb_pcie_read(pc, 0x4); 
     819-                       tmp |= 0x8; 
     820-                       ssb_pcie_write(pc, 0x4, tmp); 
     821-               } 
     822-               if (pdev->id.revision == 0) { 
     823-                       const u8 serdes_rx_device = 0x1F; 
     824- 
     825-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     826-                                           2 /* Timer */, 0x8128); 
     827-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     828-                                           6 /* CDR */, 0x0100); 
     829-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     830-                                           7 /* CDR BW */, 0x1466); 
     831-               } else if (pdev->id.revision == 1) { 
     832-                       /* DLLP Link Control register. */ 
     833-                       tmp = ssb_pcie_read(pc, 0x100); 
     834-                       tmp |= 0x40; 
     835-                       ssb_pcie_write(pc, 0x100, tmp); 
     836-               } 
     837+               ssb_pcicore_pcie_setup_workarounds(pc); 
     838        } 
     839        pc->setup_done = 1; 
     840 out: 
    357841--- a/drivers/ssb/main.c 
    358842+++ b/drivers/ssb/main.c 
     
    467951-                   !dev->dev->driver || 
    468952-                   !device_is_registered(dev->dev)) 
     953-                       continue; 
     954-               drv = drv_to_ssb_drv(dev->dev->driver); 
     955-               if (!drv) 
    469956+               sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver)); 
    470957+               if (!sdrv || SSB_WARN_ON(!sdrv->remove)) { 
    471958+                       ssb_device_put(sdev); 
    472959                        continue; 
    473 -               drv = drv_to_ssb_drv(dev->dev->driver); 
    474 -               if (!drv) 
    475 -                       continue; 
    476960-               err = drv->suspend(dev, state); 
    477961-               if (err) { 
     
    6221106                } 
    6231107  
     1108@@ -497,7 +559,7 @@ error: 
     1109 } 
     1110  
     1111 /* Needs ssb_buses_lock() */ 
     1112-static int ssb_attach_queued_buses(void) 
     1113+static int __devinit ssb_attach_queued_buses(void) 
     1114 { 
     1115        struct ssb_bus *bus, *n; 
     1116        int err = 0; 
     1117@@ -708,9 +770,9 @@ out: 
     1118        return err; 
     1119 } 
     1120  
     1121-static int ssb_bus_register(struct ssb_bus *bus, 
     1122-                           ssb_invariants_func_t get_invariants, 
     1123-                           unsigned long baseaddr) 
     1124+static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     1125+                                     ssb_invariants_func_t get_invariants, 
     1126+                                     unsigned long baseaddr) 
     1127 { 
     1128        int err; 
     1129  
    6241130@@ -724,12 +786,18 @@ static int ssb_bus_register(struct ssb_b 
    6251131        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     
    6511157        ssb_buses_unlock(); 
    6521158        ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 0); 
     1159@@ -783,8 +853,8 @@ err_disable_xtal: 
     1160 } 
     1161  
     1162 #ifdef CONFIG_SSB_PCIHOST 
     1163-int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     1164-                           struct pci_dev *host_pci) 
     1165+int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     1166+                                     struct pci_dev *host_pci) 
     1167 { 
     1168        int err; 
     1169  
    6531170@@ -796,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
    6541171        if (!err) { 
     
    6611178  
    6621179        return err; 
    663 @@ -825,6 +898,28 @@ int ssb_bus_pcmciabus_register(struct ss 
     1180@@ -804,9 +877,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register); 
     1181 #endif /* CONFIG_SSB_PCIHOST */ 
     1182  
     1183 #ifdef CONFIG_SSB_PCMCIAHOST 
     1184-int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     1185-                              struct pcmcia_device *pcmcia_dev, 
     1186-                              unsigned long baseaddr) 
     1187+int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     1188+                                        struct pcmcia_device *pcmcia_dev, 
     1189+                                        unsigned long baseaddr) 
     1190 { 
     1191        int err; 
     1192  
     1193@@ -825,9 +898,32 @@ int ssb_bus_pcmciabus_register(struct ss 
    6641194 EXPORT_SYMBOL(ssb_bus_pcmciabus_register); 
    6651195 #endif /* CONFIG_SSB_PCMCIAHOST */ 
    6661196  
     1197-int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1198-                           unsigned long baseaddr, 
     1199-                           ssb_invariants_func_t get_invariants) 
    6671200+#ifdef CONFIG_SSB_SDIOHOST 
    668 +int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
    669 +                            unsigned int quirks) 
     1201+int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     1202+                                      struct sdio_func *func, 
     1203+                                      unsigned int quirks) 
    6701204+{ 
    6711205+       int err; 
     
    6871221+#endif /* CONFIG_SSB_PCMCIAHOST */ 
    6881222+ 
    689  int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
    690                             unsigned long baseaddr, 
    691                             ssb_invariants_func_t get_invariants) 
     1223+int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1224+                                     unsigned long baseaddr, 
     1225+                                     ssb_invariants_func_t get_invariants) 
     1226 { 
     1227        int err; 
     1228  
     1229@@ -908,8 +1004,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32 
     1230        switch (plltype) { 
     1231        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
     1232                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
     1233-                       return SSB_CHIPCO_CLK_T6_M0; 
     1234-               return SSB_CHIPCO_CLK_T6_M1; 
     1235+                       return SSB_CHIPCO_CLK_T6_M1; 
     1236+               return SSB_CHIPCO_CLK_T6_M0; 
     1237        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
     1238        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
     1239        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
     1240@@ -1024,23 +1120,22 @@ static u32 ssb_tmslow_reject_bitmask(str 
     1241 { 
     1242        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
     1243  
     1244-       /* The REJECT bit changed position in TMSLOW between 
     1245-        * Backplane revisions. */ 
     1246+       /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
     1247        switch (rev) { 
     1248        case SSB_IDLOW_SSBREV_22: 
     1249-               return SSB_TMSLOW_REJECT_22; 
     1250+       case SSB_IDLOW_SSBREV_24: 
     1251+       case SSB_IDLOW_SSBREV_26: 
     1252+               return SSB_TMSLOW_REJECT; 
     1253        case SSB_IDLOW_SSBREV_23: 
     1254                return SSB_TMSLOW_REJECT_23; 
     1255-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
     1256-       case SSB_IDLOW_SSBREV_25:     /* same here */ 
     1257-       case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1258+       case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
     1259        case SSB_IDLOW_SSBREV_27:     /* same here */ 
     1260-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1261+               return SSB_TMSLOW_REJECT;       /* this is a guess */ 
     1262        default: 
     1263                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
     1264                WARN_ON(1); 
     1265        } 
     1266-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1267+       return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
     1268 } 
     1269  
     1270 int ssb_device_is_enabled(struct ssb_device *dev) 
    6921271@@ -1099,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
    6931272 } 
     
    7611340        ssb_write32(dev, SSB_TMSLOW, 
    7621341                    reject | SSB_TMSLOW_RESET | 
    763 @@ -1358,8 +1471,10 @@ static int __init ssb_modinit(void) 
     1342@@ -1155,7 +1268,10 @@ u32 ssb_dma_translation(struct ssb_devic 
     1343        case SSB_BUSTYPE_SSB: 
     1344                return 0; 
     1345        case SSB_BUSTYPE_PCI: 
     1346-               return SSB_PCI_DMA; 
     1347+               if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) 
     1348+                       return SSB_PCIE_DMA_H32; 
     1349+               else 
     1350+                       return SSB_PCI_DMA; 
     1351        default: 
     1352                __ssb_dma_not_implemented(dev); 
     1353        } 
     1354@@ -1272,20 +1388,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     1355  
     1356 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
     1357 { 
     1358-       struct ssb_chipcommon *cc; 
     1359        int err; 
     1360        enum ssb_clkmode mode; 
     1361  
     1362        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     1363        if (err) 
     1364                goto error; 
     1365-       cc = &bus->chipco; 
     1366-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1367-       ssb_chipco_set_clockmode(cc, mode); 
     1368  
     1369 #ifdef CONFIG_SSB_DEBUG 
     1370        bus->powered_up = 1; 
     1371 #endif 
     1372+ 
     1373+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1374+       ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1375+ 
     1376        return 0; 
     1377 error: 
     1378        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     1379@@ -1293,6 +1409,37 @@ error: 
     1380 } 
     1381 EXPORT_SYMBOL(ssb_bus_powerup); 
     1382  
     1383+static void ssb_broadcast_value(struct ssb_device *dev, 
     1384+                               u32 address, u32 data) 
     1385+{ 
     1386+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1387+       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1388+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1389+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1390+#endif 
     1391+ 
     1392+       ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     1393+       ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     1394+       ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     1395+       ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     1396+} 
     1397+ 
     1398+void ssb_commit_settings(struct ssb_bus *bus) 
     1399+{ 
     1400+       struct ssb_device *dev; 
     1401+ 
     1402+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1403+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1404+#else 
     1405+       dev = bus->chipco.dev; 
     1406+#endif 
     1407+       if (WARN_ON(!dev)) 
     1408+               return; 
     1409+       /* This forces an update of the cached registers. */ 
     1410+       ssb_broadcast_value(dev, 0xFD8, 0); 
     1411+} 
     1412+EXPORT_SYMBOL(ssb_commit_settings); 
     1413+ 
     1414 u32 ssb_admatch_base(u32 adm) 
     1415 { 
     1416        u32 base = 0; 
     1417@@ -1358,8 +1505,10 @@ static int __init ssb_modinit(void) 
    7641418        ssb_buses_lock(); 
    7651419        err = ssb_attach_queued_buses(); 
     
    7731427        err = b43_pci_ssb_bridge_init(); 
    7741428        if (err) { 
    775 @@ -1375,7 +1490,7 @@ static int __init ssb_modinit(void) 
     1429@@ -1375,7 +1524,7 @@ static int __init ssb_modinit(void) 
    7761430                /* don't fail SSB init because of this */ 
    7771431                err = 0; 
     
    10391693  
    10401694        if (out->boardflags_lo == 0xFFFF) 
    1041 @@ -565,12 +663,34 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1695@@ -564,13 +662,34 @@ static int sprom_extract(struct ssb_bus 
     1696 static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    10421697                             struct ssb_sprom *sprom) 
    10431698 { 
    1044         const struct ssb_sprom *fallback; 
     1699-       const struct ssb_sprom *fallback; 
    10451700-       int err = -ENOMEM; 
    10461701+       int err; 
     
    10511706+               return -ENODEV; 
    10521707+       } 
    1053 +       if (bus->chipco.dev) {  /* can be unavailible! */ 
     1708+       if (bus->chipco.dev) {  /* can be unavailable! */ 
    10541709+               /* 
    10551710+                * get SPROM offset: SSB_SPROM_BASE1 except for 
     
    10761731        sprom_do_read(bus, buf); 
    10771732        err = sprom_check_crc(buf, bus->sprom_size); 
    1078 @@ -580,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1733@@ -580,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_ 
    10791734                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    10801735                              GFP_KERNEL); 
     
    10851740                sprom_do_read(bus, buf); 
    10861741                err = sprom_check_crc(buf, bus->sprom_size); 
    1087 @@ -602,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1742                if (err) { 
     1743                        /* All CRC attempts failed. 
     1744                         * Maybe there is no SPROM on the device? 
     1745-                        * If we have a fallback, use that. */ 
     1746-                       fallback = ssb_get_fallback_sprom(); 
     1747-                       if (fallback) { 
     1748-                               memcpy(sprom, fallback, sizeof(*sprom)); 
     1749+                        * Now we ask the arch code if there is some sprom 
     1750+                        * available for this device in some other storage */ 
     1751+                       err = ssb_fill_sprom_with_fallback(bus, sprom); 
     1752+                       if (err) { 
     1753+                               ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     1754+                                          " fallback SPROM failed (err %d)\n", 
     1755+                                          err); 
     1756+                       } else { 
     1757+                               ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     1758+                                           " revision %d provided by" 
     1759+                                           " platform.\n", sprom->revision); 
     1760                                err = 0; 
     1761                                goto out_free; 
     1762                        } 
     1763@@ -602,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_ 
    10881764  
    10891765 out_free: 
     
    10931769 } 
    10941770  
     1771 static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
     1772                                  struct ssb_boardinfo *bi) 
     1773 { 
     1774-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
     1775-                            &bi->vendor); 
     1776-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
     1777-                            &bi->type); 
     1778-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     1779-                            &bi->rev); 
     1780+       bi->vendor = bus->host_pci->subsystem_vendor; 
     1781+       bi->type = bus->host_pci->subsystem_device; 
     1782+       bi->rev = bus->host_pci->revision; 
     1783 } 
     1784  
     1785 int ssb_pci_get_invariants(struct ssb_bus *bus, 
    10951786--- a/drivers/ssb/pcihost_wrapper.c 
    10961787+++ b/drivers/ssb/pcihost_wrapper.c 
     
    11031794  
    11041795  
    1105 @@ -58,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     1796@@ -52,12 +53,13 @@ static int ssb_pcihost_resume(struct pci 
     1797 # define ssb_pcihost_resume    NULL 
     1798 #endif /* CONFIG_PM */ 
     1799  
     1800-static int ssb_pcihost_probe(struct pci_dev *dev, 
     1801-                            const struct pci_device_id *id) 
     1802+static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     1803+                                      const struct pci_device_id *id) 
     1804 { 
    11061805        struct ssb_bus *ssb; 
    11071806        int err = -ENOMEM; 
     
    11241823        if (err) 
    11251824                goto err_pci_release_regions; 
     1825@@ -102,7 +110,7 @@ static void ssb_pcihost_remove(struct pc 
     1826        pci_set_drvdata(dev, NULL); 
     1827 } 
     1828  
     1829-int ssb_pcihost_register(struct pci_driver *driver) 
     1830+int __devinit ssb_pcihost_register(struct pci_driver *driver) 
     1831 { 
     1832        driver->probe = ssb_pcihost_probe; 
     1833        driver->remove = ssb_pcihost_remove; 
    11261834--- a/drivers/ssb/pcmcia.c 
    11271835+++ b/drivers/ssb/pcmcia.c 
     
    14352143  
    14362144        return mmio; 
    1437 @@ -339,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2145@@ -245,7 +260,10 @@ static int we_support_multiple_80211_cor 
     2146 #ifdef CONFIG_SSB_PCIHOST 
     2147        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     2148                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     2149-                   bus->host_pci->device == 0x4324) 
     2150+                   ((bus->host_pci->device == 0x4313) || 
     2151+                    (bus->host_pci->device == 0x431A) || 
     2152+                    (bus->host_pci->device == 0x4321) || 
     2153+                    (bus->host_pci->device == 0x4324))) 
     2154                        return 1; 
     2155        } 
     2156 #endif /* CONFIG_SSB_PCIHOST */ 
     2157@@ -294,8 +312,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2158        } else { 
     2159                if (bus->bustype == SSB_BUSTYPE_PCI) { 
     2160                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
     2161-                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     2162-                                            &bus->chip_rev); 
     2163+                       bus->chip_rev = bus->host_pci->revision; 
     2164                        bus->chip_package = 0; 
     2165                } else { 
     2166                        bus->chip_id = 0x4710; 
     2167@@ -339,7 +356,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    14382168                dev->bus = bus; 
    14392169                dev->ops = bus->ops; 
     
    14442174                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    14452175                            i, ssb_core_name(dev->id.coreid), 
    1446 @@ -407,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     2176@@ -407,6 +424,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    14472177                        bus->pcicore.dev = dev; 
    14482178 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     
    20762806--- a/drivers/ssb/sprom.c 
    20772807+++ b/drivers/ssb/sprom.c 
    2078 @@ -14,6 +14,7 @@ 
     2808@@ -14,9 +14,10 @@ 
    20792809 #include "ssb_private.h" 
    20802810  
     
    20832813  
    20842814  
    2085  static const struct ssb_sprom *fallback_sprom; 
     2815-static const struct ssb_sprom *fallback_sprom; 
     2816+static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
     2817  
     2818  
     2819 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
    20862820@@ -102,6 +103,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
    20872821        u16 *sprom; 
     
    21132847                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    21142848 out_unlock: 
    2115 @@ -179,3 +176,18 @@ const struct ssb_sprom *ssb_get_fallback 
    2116  { 
    2117         return fallback_sprom; 
    2118  } 
     2849@@ -148,34 +145,56 @@ out: 
     2850 } 
     2851  
     2852 /** 
     2853- * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
     2854+ * ssb_arch_register_fallback_sprom - Registers a method providing a 
     2855+ * fallback SPROM if no SPROM is found. 
     2856  * 
     2857- * @sprom: The SPROM data structure to register. 
     2858+ * @sprom_callback: The callback function. 
     2859  * 
     2860- * With this function the architecture implementation may register a fallback 
     2861- * SPROM data structure. The fallback is only used for PCI based SSB devices, 
     2862- * where no valid SPROM can be found in the shadow registers. 
     2863+ * With this function the architecture implementation may register a 
     2864+ * callback handler which fills the SPROM data structure. The fallback is 
     2865+ * only used for PCI based SSB devices, where no valid SPROM can be found 
     2866+ * in the shadow registers. 
     2867  * 
     2868- * This function is useful for weird architectures that have a half-assed SSB device 
     2869- * hardwired to their PCI bus. 
     2870+ * This function is useful for weird architectures that have a half-assed 
     2871+ * SSB device hardwired to their PCI bus. 
     2872  * 
     2873- * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
     2874- * don't use this fallback. 
     2875- * Architectures must provide the SPROM for native SSB devices anyway, 
     2876- * so the fallback also isn't used for native devices. 
     2877+ * Note that it does only work with PCI attached SSB devices. PCMCIA 
     2878+ * devices currently don't use this fallback. 
     2879+ * Architectures must provide the SPROM for native SSB devices anyway, so 
     2880+ * the fallback also isn't used for native devices. 
     2881  * 
     2882- * This function is available for architecture code, only. So it is not exported. 
     2883+ * This function is available for architecture code, only. So it is not 
     2884+ * exported. 
     2885  */ 
     2886-int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 
     2887+int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus, 
     2888+                                    struct ssb_sprom *out)) 
     2889 { 
     2890-       if (fallback_sprom) 
     2891+       if (get_fallback_sprom) 
     2892                return -EEXIST; 
     2893-       fallback_sprom = sprom; 
     2894+       get_fallback_sprom = sprom_callback; 
     2895  
     2896        return 0; 
     2897 } 
     2898  
     2899-const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     2900+int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
     2901 { 
     2902-       return fallback_sprom; 
     2903+       if (!get_fallback_sprom) 
     2904+               return -ENOENT; 
     2905+ 
     2906+       return get_fallback_sprom(bus, out); 
     2907+} 
    21192908+ 
    21202909+/* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     
    21262915+          on PCMCIA */ 
    21272916+       if (bus->bustype == SSB_BUSTYPE_PCI && 
    2128 +           bus->chipco.dev &&  /* can be unavailible! */ 
     2917+           bus->chipco.dev &&  /* can be unavailable! */ 
    21292918+           bus->chipco.dev->id.revision >= 31) 
    21302919+               return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
    21312920+ 
    21322921+       return true; 
    2133 +} 
     2922 } 
    21342923--- a/drivers/ssb/ssb_private.h 
    21352924+++ b/drivers/ssb/ssb_private.h 
     
    21812970 /* scan.c */ 
    21822971 extern const char *ssb_core_name(u16 coreid); 
    2183 @@ -136,19 +176,27 @@ extern const struct ssb_sprom *ssb_get_f 
     2972@@ -131,24 +171,33 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     2973                             const char *buf, size_t count, 
     2974                             int (*sprom_check_crc)(const u16 *sprom, size_t size), 
     2975                             int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)); 
     2976-extern const struct ssb_sprom *ssb_get_fallback_sprom(void); 
     2977+extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, 
     2978+                                       struct ssb_sprom *out); 
     2979  
    21842980  
    21852981 /* core.c */ 
     
    22123008 { 
    22133009        return 0; 
    2214 @@ -156,6 +204,6 @@ static inline int b43_pci_ssb_bridge_ini 
     3010@@ -156,6 +205,6 @@ static inline int b43_pci_ssb_bridge_ini 
    22153011 static inline void b43_pci_ssb_bridge_exit(void) 
    22163012 { 
     
    22323028--- a/include/linux/ssb/ssb.h 
    22333029+++ b/include/linux/ssb/ssb.h 
    2234 @@ -27,24 +27,58 @@ struct ssb_sprom { 
     3030@@ -27,24 +27,60 @@ struct ssb_sprom { 
    22353031        u8 et1mdcport;          /* MDIO for enet1 */ 
    22363032        u8 board_rev;           /* Board revision number from SPROM. */ 
     
    22383034-       u8 ant_available_a;     /* A-PHY antenna available bits (up to 4) */ 
    22393035-       u8 ant_available_bg;    /* B/G-PHY antenna available bits (up to 4) */ 
     3036+       u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */ 
     3037+       u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */ 
    22403038+       u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
    22413039+       u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
     
    22973095        /* Antenna gain values for up to 4 antennas 
    22983096         * on each band. Values in dBm/4 (Q5.2). Negative gain means the 
    2299 @@ -58,7 +92,7 @@ struct ssb_sprom { 
     3097@@ -58,14 +94,14 @@ struct ssb_sprom { 
    23003098                } ghz5;         /* 5GHz band */ 
    23013099        } antenna_gain; 
     
    23063104  
    23073105 /* Information about the PCB the circuitry is soldered on. */ 
    2308 @@ -137,7 +171,7 @@ struct ssb_device { 
     3106 struct ssb_boardinfo { 
     3107        u16 vendor; 
     3108        u16 type; 
     3109-       u16 rev; 
     3110+       u8  rev; 
     3111 }; 
     3112  
     3113  
     3114@@ -137,7 +173,7 @@ struct ssb_device { 
    23093115         * is an optimization. */ 
    23103116        const struct ssb_bus_ops *ops; 
     
    23153121        struct ssb_bus *bus; 
    23163122        struct ssb_device_id id; 
    2317 @@ -208,6 +242,7 @@ enum ssb_bustype { 
     3123@@ -208,6 +244,7 @@ enum ssb_bustype { 
    23183124        SSB_BUSTYPE_SSB,        /* This SSB bus is the system bus */ 
    23193125        SSB_BUSTYPE_PCI,        /* SSB is connected to PCI bus */ 
     
    23233129  
    23243130 /* board_vendor */ 
    2325 @@ -238,20 +273,33 @@ struct ssb_bus { 
     3131@@ -238,20 +275,33 @@ struct ssb_bus { 
    23263132  
    23273133        const struct ssb_bus_ops *ops; 
     
    23653171 #ifdef CONFIG_SSB_SPROM 
    23663172        /* Mutex to protect the SPROM writing. */ 
    2367 @@ -261,6 +309,7 @@ struct ssb_bus { 
     3173@@ -260,7 +310,8 @@ struct ssb_bus { 
     3174  
    23683175        /* ID information about the Chip. */ 
    23693176        u16 chip_id; 
    2370         u16 chip_rev; 
     3177-       u16 chip_rev; 
     3178+       u8 chip_rev; 
    23713179+       u16 sprom_offset; 
    23723180        u16 sprom_size;         /* number of words in sprom */ 
    23733181        u8 chip_package; 
    23743182  
    2375 @@ -306,6 +355,11 @@ struct ssb_bus { 
     3183@@ -306,6 +357,11 @@ struct ssb_bus { 
    23763184 #endif /* DEBUG */ 
    23773185 }; 
     
    23853193 struct ssb_init_invariants { 
    23863194        /* Versioning information about the PCB. */ 
    2387 @@ -336,9 +390,18 @@ extern int ssb_bus_pcmciabus_register(st 
     3195@@ -336,12 +392,23 @@ extern int ssb_bus_pcmciabus_register(st 
    23883196                                      struct pcmcia_device *pcmcia_dev, 
    23893197                                      unsigned long baseaddr); 
     
    24033211 /* Set a fallback SPROM. 
    24043212  * See kdoc at the function definition for complete documentation. */ 
    2405  extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     3213-extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     3214+extern int ssb_arch_register_fallback_sprom( 
     3215+               int (*sprom_callback)(struct ssb_bus *bus, 
     3216+               struct ssb_sprom *out)); 
     3217  
     3218 /* Suspend a SSB bus. 
     3219  * Call this from the parent bus suspend routine. */ 
     3220@@ -612,6 +679,7 @@ extern int ssb_bus_may_powerdown(struct 
     3221  * Otherwise static always-on powercontrol will be used. */ 
     3222 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
     3223  
     3224+extern void ssb_commit_settings(struct ssb_bus *bus); 
     3225  
     3226 /* Various helper functions */ 
     3227 extern u32 ssb_admatch_base(u32 adm); 
    24063228--- a/include/linux/ssb/ssb_driver_chipcommon.h 
    24073229+++ b/include/linux/ssb/ssb_driver_chipcommon.h 
     
    24143236 #define  SSB_CHIPCO_CORECTL_UARTCLK0   0x00000001      /* Drive UART with internal clock */ 
    24153237 #define         SSB_CHIPCO_CORECTL_SE          0x00000002      /* sync clk out enable (corerev >= 3) */ 
    2416 @@ -385,6 +386,7 @@ 
     3238@@ -122,6 +123,8 @@ 
     3239 #define SSB_CHIPCO_FLASHDATA           0x0048 
     3240 #define SSB_CHIPCO_BCAST_ADDR          0x0050 
     3241 #define SSB_CHIPCO_BCAST_DATA          0x0054 
     3242+#define SSB_CHIPCO_GPIOPULLUP          0x0058          /* Rev >= 20 only */ 
     3243+#define SSB_CHIPCO_GPIOPULLDOWN                0x005C          /* Rev >= 20 only */ 
     3244 #define SSB_CHIPCO_GPIOIN              0x0060 
     3245 #define SSB_CHIPCO_GPIOOUT             0x0064 
     3246 #define SSB_CHIPCO_GPIOOUTEN           0x0068 
     3247@@ -130,6 +133,9 @@ 
     3248 #define SSB_CHIPCO_GPIOIRQ             0x0074 
     3249 #define SSB_CHIPCO_WATCHDOG            0x0080 
     3250 #define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */ 
     3251+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME  0x0000FFFF 
     3252+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT    0 
     3253+#define  SSB_CHIPCO_GPIOTIMER_ONTIME   0xFFFF0000 
     3254 #define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16 
     3255 #define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */ 
     3256 #define SSB_CHIPCO_CLOCK_N             0x0090 
     3257@@ -188,8 +194,10 @@ 
     3258 #define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ        0x00000008 /* ALP available request */ 
     3259 #define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */ 
     3260 #define  SSB_CHIPCO_CLKCTLST_HWCROFF   0x00000020 /* Force HW clock request off */ 
     3261-#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00010000 /* HT available */ 
     3262-#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00020000 /* APL available */ 
     3263+#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00010000 /* ALP available */ 
     3264+#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00020000 /* HT available */ 
     3265+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT     0x00010000 /* 4328a0 has reversed bits */ 
     3266+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP    0x00020000 /* 4328a0 has reversed bits */ 
     3267 #define SSB_CHIPCO_HW_WORKAROUND       0x01E4 /* Hardware workaround (rev >= 20) */ 
     3268 #define SSB_CHIPCO_UART0_DATA          0x0300 
     3269 #define SSB_CHIPCO_UART0_IMR           0x0304 
     3270@@ -385,6 +393,7 @@ 
    24173271  
    24183272  
     
    24223276 #define SSB_CHIPCO_CHST_4325_DEFCIS_SEL                0 /* OTP is powered up, use def. CIS, no SPROM */ 
    24233277 #define SSB_CHIPCO_CHST_4325_SPROM_SEL         1 /* OTP is powered up, SPROM is present */ 
    2424 @@ -398,6 +400,18 @@ 
     3278@@ -398,6 +407,18 @@ 
    24253279 #define SSB_CHIPCO_CHST_4325_RCAL_VALUE_SHIFT  4 
    24263280 #define SSB_CHIPCO_CHST_4325_PMUTOP_2B                 0x00000200 /* 1 for 2b, 0 for to 2a */ 
     
    24413295  
    24423296 /** Clockcontrol masks and values **/ 
    2443 @@ -564,6 +578,7 @@ struct ssb_chipcommon_pmu { 
     3297@@ -564,6 +585,7 @@ struct ssb_chipcommon_pmu { 
    24443298 struct ssb_chipcommon { 
    24453299        struct ssb_device *dev; 
     
    24493303        u16 fast_pwrup_delay; 
    24503304        struct ssb_chipcommon_pmu pmu; 
    2451 @@ -629,5 +644,15 @@ extern int ssb_chipco_serial_init(struct 
     3305@@ -629,5 +651,15 @@ extern int ssb_chipco_serial_init(struct 
    24523306 /* PMU support */ 
    24533307 extern void ssb_pmu_init(struct ssb_chipcommon *cc); 
     
    24763330 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
    24773331 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     3332@@ -95,7 +97,7 @@ 
     3333 #define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */ 
     3334 #define SSB_TMSLOW             0x0F98     /* SB Target State Low */ 
     3335 #define  SSB_TMSLOW_RESET      0x00000001 /* Reset */ 
     3336-#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */ 
     3337+#define  SSB_TMSLOW_REJECT     0x00000002 /* Reject (Standard Backplane) */ 
     3338 #define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */ 
     3339 #define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */ 
     3340 #define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */ 
    24783341@@ -162,7 +164,7 @@ 
    24793342  
  • trunk/target/linux/generic/patches-2.6.31/974-ssb_b43_default_on.patch

    r21952 r27731  
    1818 config SSB_PCMCIAHOST_POSSIBLE 
    1919        bool 
     20--- a/drivers/bcma/Kconfig 
     21+++ b/drivers/bcma/Kconfig 
     22@@ -17,6 +17,7 @@ config BCMA 
     23 config BCMA_BLOCKIO 
     24        bool 
     25        depends on BCMA 
     26+       default y 
     27  
     28 config BCMA_HOST_PCI_POSSIBLE 
     29        bool 
  • trunk/target/linux/generic/patches-2.6.32/974-ssb_b43_default_on.patch

    r21952 r27731  
    1818 config SSB_PCMCIAHOST_POSSIBLE 
    1919        bool 
     20--- a/drivers/bcma/Kconfig 
     21+++ b/drivers/bcma/Kconfig 
     22@@ -17,6 +17,7 @@ config BCMA 
     23 config BCMA_BLOCKIO 
     24        bool 
     25        depends on BCMA 
     26+       default y 
     27  
     28 config BCMA_HOST_PCI_POSSIBLE 
     29        bool 
  • trunk/target/linux/generic/patches-2.6.32/975-ssb_update.patch

    r26127 r27731  
    11--- a/drivers/ssb/driver_chipcommon.c 
    22+++ b/drivers/ssb/driver_chipcommon.c 
    3 @@ -209,6 +209,24 @@ static void chipco_powercontrol_init(str 
     3@@ -46,40 +46,66 @@ void ssb_chipco_set_clockmode(struct ssb 
     4        if (!ccdev) 
     5                return; 
     6        bus = ccdev->bus; 
     7+ 
     8+       /* We support SLOW only on 6..9 */ 
     9+       if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW) 
     10+               mode = SSB_CLKMODE_DYNAMIC; 
     11+ 
     12+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) 
     13+               return; /* PMU controls clockmode, separated function needed */ 
     14+       SSB_WARN_ON(ccdev->id.revision >= 20); 
     15+ 
     16        /* chipcommon cores prior to rev6 don't support dynamic clock control */ 
     17        if (ccdev->id.revision < 6) 
     18                return; 
     19-       /* chipcommon cores rev10 are a whole new ball game */ 
     20+ 
     21+       /* ChipCommon cores rev10+ need testing */ 
     22        if (ccdev->id.revision >= 10) 
     23                return; 
     24+ 
     25        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     26                return; 
     27  
     28        switch (mode) { 
     29-       case SSB_CLKMODE_SLOW: 
     30+       case SSB_CLKMODE_SLOW: /* For revs 6..9 only */ 
     31                tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     32                tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     33                chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     34                break; 
     35        case SSB_CLKMODE_FAST: 
     36-               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     37-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     38-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     39-               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     40-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     41+               if (ccdev->id.revision < 10) { 
     42+                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     43+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     44+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     45+                       tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     46+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     47+               } else { 
     48+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     49+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) | 
     50+                                SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     51+                       /* udelay(150); TODO: not available in early init */ 
     52+               } 
     53                break; 
     54        case SSB_CLKMODE_DYNAMIC: 
     55-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     56-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     57-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     58-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     59-               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     60-                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     61-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     62- 
     63-               /* for dynamic control, we have to release our xtal_pu "force on" */ 
     64-               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     65-                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     66+               if (ccdev->id.revision < 10) { 
     67+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     68+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     69+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     70+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     71+                       if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != 
     72+                           SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     73+                               tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     74+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     75+ 
     76+                       /* For dynamic control, we have to release our xtal_pu 
     77+                        * "force on" */ 
     78+                       if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     79+                               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     80+               } else { 
     81+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     82+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) & 
     83+                                ~SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     84+               } 
     85                break; 
     86        default: 
     87                SSB_WARN_ON(1); 
     88@@ -209,6 +235,24 @@ static void chipco_powercontrol_init(str 
    489        } 
    590 } 
     
    26111 { 
    27112        struct ssb_bus *bus = cc->dev->bus; 
    28 @@ -218,6 +236,12 @@ static void calc_fast_powerup_delay(stru 
     113@@ -218,6 +262,12 @@ static void calc_fast_powerup_delay(stru 
    29114  
    30115        if (bus->bustype != SSB_BUSTYPE_PCI) 
     
    39124                return; 
    40125  
    41 @@ -373,6 +397,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
     126@@ -236,6 +286,12 @@ void ssb_chipcommon_init(struct ssb_chip 
     127        if (cc->dev->id.revision >= 11) 
     128                cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
     129        ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     130+ 
     131+       if (cc->dev->id.revision >= 20) { 
     132+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0); 
     133+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0); 
     134+       } 
     135+ 
     136        ssb_pmu_init(cc); 
     137        chipco_powercontrol_init(cc); 
     138        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
     139@@ -373,6 +429,7 @@ u32 ssb_chipco_gpio_control(struct ssb_c 
    42140 { 
    43141        return chipco_write32_masked(cc, SSB_CHIPCO_GPIOCTL, mask, value); 
     
    62160                ssb_printk(KERN_ERR PFX 
    63161                           "ERROR: PLL init unknown for device %04X\n", 
    64 @@ -417,6 +423,7 @@ static void ssb_pmu_resources_init(struc 
     162@@ -411,12 +417,15 @@ static void ssb_pmu_resources_init(struc 
     163        u32 min_msk = 0, max_msk = 0; 
     164        unsigned int i; 
     165        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
     166-       unsigned int updown_tab_size; 
     167+       unsigned int updown_tab_size = 0; 
     168        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
     169-       unsigned int depend_tab_size; 
     170+       unsigned int depend_tab_size = 0; 
    65171  
    66172        switch (bus->chip_id) { 
    67173        case 0x4312: 
     174+                min_msk = 0xCBB; 
     175+                break; 
    68176+       case 0x4322: 
    69177                /* We keep the default settings: 
    70178                 * min_msk = 0xCBB 
    71179                 * max_msk = 0x7FFFF 
    72 @@ -495,9 +502,9 @@ static void ssb_pmu_resources_init(struc 
     180@@ -495,9 +504,9 @@ static void ssb_pmu_resources_init(struc 
    73181                chipco_write32(cc, SSB_CHIPCO_PMU_MAXRES_MSK, max_msk); 
    74182 } 
     
    81189  
    82190        if (!(cc->capabilities & SSB_CHIPCO_CAP_PMU)) 
    83 @@ -509,15 +516,12 @@ void ssb_pmu_init(struct ssb_chipcommon 
     191@@ -509,15 +518,12 @@ void ssb_pmu_init(struct ssb_chipcommon 
    84192        ssb_dprintk(KERN_DEBUG PFX "Found rev %u PMU (capabilities 0x%08X)\n", 
    85193                    cc->pmu.rev, pmucap); 
     
    113221  
    114222 /* 
     223@@ -105,8 +106,9 @@ void gige_pcicfg_write32(struct ssb_gige 
     224        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
     225 } 
     226  
     227-static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
     228-                                   int reg, int size, u32 *val) 
     229+static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus, 
     230+                                             unsigned int devfn, int reg, 
     231+                                             int size, u32 *val) 
     232 { 
     233        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     234        unsigned long flags; 
     235@@ -135,8 +137,9 @@ static int ssb_gige_pci_read_config(stru 
     236        return PCIBIOS_SUCCESSFUL; 
     237 } 
     238  
     239-static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
     240-                                    int reg, int size, u32 val) 
     241+static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus, 
     242+                                              unsigned int devfn, int reg, 
     243+                                              int size, u32 val) 
     244 { 
     245        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     246        unsigned long flags; 
     247@@ -165,7 +168,8 @@ static int ssb_gige_pci_write_config(str 
     248        return PCIBIOS_SUCCESSFUL; 
     249 } 
     250  
     251-static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id) 
     252+static int __devinit ssb_gige_probe(struct ssb_device *sdev, 
     253+                                   const struct ssb_device_id *id) 
     254 { 
     255        struct ssb_gige *dev; 
     256        u32 base, tmslow, tmshigh; 
    115257--- a/drivers/ssb/driver_mipscore.c 
    116258+++ b/drivers/ssb/driver_mipscore.c 
     
    136278--- a/drivers/ssb/driver_pcicore.c 
    137279+++ b/drivers/ssb/driver_pcicore.c 
    138 @@ -246,20 +246,12 @@ static struct pci_controller ssb_pcicore 
     280@@ -15,6 +15,11 @@ 
     281  
     282 #include "ssb_private.h" 
     283  
     284+static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address); 
     285+static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data); 
     286+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address); 
     287+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     288+                               u8 address, u16 data); 
     289  
     290 static inline 
     291 u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset) 
     292@@ -246,20 +251,12 @@ static struct pci_controller ssb_pcicore 
    139293        .pci_ops        = &ssb_pcicore_pciops, 
    140294        .io_resource    = &ssb_pcicore_io_resource, 
     
    157311                /* This is not a device on the PCI-core bridge. */ 
    158312                return -ENODEV; 
    159 @@ -268,27 +260,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
     313@@ -268,27 +265,6 @@ int ssb_pcicore_plat_dev_init(struct pci 
    160314        ssb_printk(KERN_INFO "PCI: Fixing up device %s\n", 
    161315                   pci_name(d)); 
     
    185339        d->irq = ssb_mips_irq(extpci_core->dev) + 2; 
    186340        pci_write_config_byte(d, PCI_INTERRUPT_LINE, d->irq); 
    187 @@ -551,13 +522,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     341@@ -338,7 +314,7 @@ int ssb_pcicore_pcibios_map_irq(const st 
     342        return ssb_mips_irq(extpci_core->dev) + 2; 
     343 } 
     344  
     345-static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     346+static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     347 { 
     348        u32 val; 
     349  
     350@@ -403,7 +379,7 @@ static void ssb_pcicore_init_hostmode(st 
     351        register_pci_controller(&ssb_pcicore_controller); 
     352 } 
     353  
     354-static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     355+static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     356 { 
     357        struct ssb_bus *bus = pc->dev->bus; 
     358        u16 chipid_top; 
     359@@ -432,25 +408,133 @@ static int pcicore_is_in_hostmode(struct 
     360 } 
     361 #endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
     362  
     363+/************************************************** 
     364+ * Workarounds. 
     365+ **************************************************/ 
     366+ 
     367+static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc) 
     368+{ 
     369+       u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0)); 
     370+       if (((tmp & 0xF000) >> 12) != pc->dev->core_index) { 
     371+               tmp &= ~0xF000; 
     372+               tmp |= (pc->dev->core_index << 12); 
     373+               pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp); 
     374+       } 
     375+} 
     376+ 
     377+static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc) 
     378+{ 
     379+       return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80; 
     380+} 
     381+ 
     382+static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc) 
     383+{ 
     384+       const u8 serdes_pll_device = 0x1D; 
     385+       const u8 serdes_rx_device = 0x1F; 
     386+       u16 tmp; 
     387+ 
     388+       ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */, 
     389+                           ssb_pcicore_polarity_workaround(pc)); 
     390+       tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */); 
     391+       if (tmp & 0x4000) 
     392+               ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000); 
     393+} 
     394+ 
     395+static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc) 
     396+{ 
     397+       struct ssb_device *pdev = pc->dev; 
     398+       struct ssb_bus *bus = pdev->bus; 
     399+       u32 tmp; 
     400+ 
     401+       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     402+       tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     403+       tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     404+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     405+ 
     406+       if (pdev->id.revision < 5) { 
     407+               tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     408+               tmp &= ~SSB_IMCFGLO_SERTO; 
     409+               tmp |= 2; 
     410+               tmp &= ~SSB_IMCFGLO_REQTO; 
     411+               tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     412+               ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     413+               ssb_commit_settings(bus); 
     414+       } else if (pdev->id.revision >= 11) { 
     415+               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     416+               tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     417+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     418+       } 
     419+} 
     420+ 
     421+static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc) 
     422+{ 
     423+       u32 tmp; 
     424+       u8 rev = pc->dev->id.revision; 
     425+ 
     426+       if (rev == 0 || rev == 1) { 
     427+               /* TLP Workaround register. */ 
     428+               tmp = ssb_pcie_read(pc, 0x4); 
     429+               tmp |= 0x8; 
     430+               ssb_pcie_write(pc, 0x4, tmp); 
     431+       } 
     432+       if (rev == 1) { 
     433+               /* DLLP Link Control register. */ 
     434+               tmp = ssb_pcie_read(pc, 0x100); 
     435+               tmp |= 0x40; 
     436+               ssb_pcie_write(pc, 0x100, tmp); 
     437+       } 
     438+ 
     439+       if (rev == 0) { 
     440+               const u8 serdes_rx_device = 0x1F; 
     441+ 
     442+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     443+                                       2 /* Timer */, 0x8128); 
     444+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     445+                                       6 /* CDR */, 0x0100); 
     446+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     447+                                       7 /* CDR BW */, 0x1466); 
     448+       } else if (rev == 3 || rev == 4 || rev == 5) { 
     449+               /* TODO: DLLP Power Management Threshold */ 
     450+               ssb_pcicore_serdes_workaround(pc); 
     451+               /* TODO: ASPM */ 
     452+       } else if (rev == 7) { 
     453+               /* TODO: No PLL down */ 
     454+       } 
     455+ 
     456+       if (rev >= 6) { 
     457+               /* Miscellaneous Configuration Fixup */ 
     458+               tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5)); 
     459+               if (!(tmp & 0x8000)) 
     460+                       pcicore_write16(pc, SSB_PCICORE_SPROM(5), 
     461+                                       tmp | 0x8000); 
     462+       } 
     463+} 
     464  
     465 /************************************************** 
     466  * Generic and Clientmode operation code. 
     467  **************************************************/ 
     468  
     469-static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     470+static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     471 { 
     472+       ssb_pcicore_fix_sprom_core_index(pc); 
     473+ 
     474        /* Disable PCI interrupts. */ 
     475        ssb_write32(pc->dev, SSB_INTVEC, 0); 
     476+ 
     477+       /* Additional PCIe always once-executed workarounds */ 
     478+       if (pc->dev->id.coreid == SSB_DEV_PCIE) { 
     479+               ssb_pcicore_serdes_workaround(pc); 
     480+               /* TODO: ASPM */ 
     481+               /* TODO: Clock Request Update */ 
     482+       } 
     483 } 
     484  
     485-void ssb_pcicore_init(struct ssb_pcicore *pc) 
     486+void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
     487 { 
     488        struct ssb_device *dev = pc->dev; 
     489-       struct ssb_bus *bus; 
     490  
     491        if (!dev) 
     492                return; 
     493-       bus = dev->bus; 
     494        if (!ssb_device_is_enabled(dev)) 
     495                ssb_device_enable(dev, 0); 
     496  
     497@@ -475,58 +559,104 @@ static void ssb_pcie_write(struct ssb_pc 
     498        pcicore_write32(pc, 0x134, data); 
     499 } 
     500  
     501-static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     502-                               u8 address, u16 data) 
     503+static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
     504 { 
     505        const u16 mdio_control = 0x128; 
     506        const u16 mdio_data = 0x12C; 
     507        u32 v; 
     508        int i; 
     509  
     510+       v = (1 << 30); /* Start of Transaction */ 
     511+       v |= (1 << 28); /* Write Transaction */ 
     512+       v |= (1 << 17); /* Turnaround */ 
     513+       v |= (0x1F << 18); 
     514+       v |= (phy << 4); 
     515+       pcicore_write32(pc, mdio_data, v); 
     516+ 
     517+       udelay(10); 
     518+       for (i = 0; i < 200; i++) { 
     519+               v = pcicore_read32(pc, mdio_control); 
     520+               if (v & 0x100 /* Trans complete */) 
     521+                       break; 
     522+               msleep(1); 
     523+       } 
     524+} 
     525+ 
     526+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address) 
     527+{ 
     528+       const u16 mdio_control = 0x128; 
     529+       const u16 mdio_data = 0x12C; 
     530+       int max_retries = 10; 
     531+       u16 ret = 0; 
     532+       u32 v; 
     533+       int i; 
     534+ 
     535        v = 0x80; /* Enable Preamble Sequence */ 
     536        v |= 0x2; /* MDIO Clock Divisor */ 
     537        pcicore_write32(pc, mdio_control, v); 
     538  
     539+       if (pc->dev->id.revision >= 10) { 
     540+               max_retries = 200; 
     541+               ssb_pcie_mdio_set_phy(pc, device); 
     542+       } 
     543+ 
     544        v = (1 << 30); /* Start of Transaction */ 
     545-       v |= (1 << 28); /* Write Transaction */ 
     546+       v |= (1 << 29); /* Read Transaction */ 
     547        v |= (1 << 17); /* Turnaround */ 
     548-       v |= (u32)device << 22; 
     549+       if (pc->dev->id.revision < 10) 
     550+               v |= (u32)device << 22; 
     551        v |= (u32)address << 18; 
     552-       v |= data; 
     553        pcicore_write32(pc, mdio_data, v); 
     554        /* Wait for the device to complete the transaction */ 
     555        udelay(10); 
     556-       for (i = 0; i < 10; i++) { 
     557+       for (i = 0; i < max_retries; i++) { 
     558                v = pcicore_read32(pc, mdio_control); 
     559-               if (v & 0x100 /* Trans complete */) 
     560+               if (v & 0x100 /* Trans complete */) { 
     561+                       udelay(10); 
     562+                       ret = pcicore_read32(pc, mdio_data); 
     563                        break; 
     564+               } 
     565                msleep(1); 
     566        } 
     567        pcicore_write32(pc, mdio_control, 0); 
     568+       return ret; 
     569 } 
     570  
     571-static void ssb_broadcast_value(struct ssb_device *dev, 
     572-                               u32 address, u32 data) 
     573+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     574+                               u8 address, u16 data) 
     575 { 
     576-       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     577-       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     578-       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     579+       const u16 mdio_control = 0x128; 
     580+       const u16 mdio_data = 0x12C; 
     581+       int max_retries = 10; 
     582+       u32 v; 
     583+       int i; 
     584  
     585-       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
     586-       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
     587-       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
     588-       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
     589-} 
     590+       v = 0x80; /* Enable Preamble Sequence */ 
     591+       v |= 0x2; /* MDIO Clock Divisor */ 
     592+       pcicore_write32(pc, mdio_control, v); 
     593  
     594-static void ssb_commit_settings(struct ssb_bus *bus) 
     595-{ 
     596-       struct ssb_device *dev; 
     597+       if (pc->dev->id.revision >= 10) { 
     598+               max_retries = 200; 
     599+               ssb_pcie_mdio_set_phy(pc, device); 
     600+       } 
     601  
     602-       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     603-       if (WARN_ON(!dev)) 
     604-               return; 
     605-       /* This forces an update of the cached registers. */ 
     606-       ssb_broadcast_value(dev, 0xFD8, 0); 
     607+       v = (1 << 30); /* Start of Transaction */ 
     608+       v |= (1 << 28); /* Write Transaction */ 
     609+       v |= (1 << 17); /* Turnaround */ 
     610+       if (pc->dev->id.revision < 10) 
     611+               v |= (u32)device << 22; 
     612+       v |= (u32)address << 18; 
     613+       v |= data; 
     614+       pcicore_write32(pc, mdio_data, v); 
     615+       /* Wait for the device to complete the transaction */ 
     616+       udelay(10); 
     617+       for (i = 0; i < max_retries; i++) { 
     618+               v = pcicore_read32(pc, mdio_control); 
     619+               if (v & 0x100 /* Trans complete */) 
     620+                       break; 
     621+               msleep(1); 
     622+       } 
     623+       pcicore_write32(pc, mdio_control, 0); 
     624 } 
     625  
     626 int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
     627@@ -551,13 +681,13 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
    188628        might_sleep_if(pdev->id.coreid != SSB_DEV_PCI); 
    189629  
     
    201641                if (err) 
    202642                        goto out; 
     643@@ -579,48 +709,10 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     644        if (pc->setup_done) 
     645                goto out; 
     646        if (pdev->id.coreid == SSB_DEV_PCI) { 
     647-               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     648-               tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     649-               tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     650-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     651- 
     652-               if (pdev->id.revision < 5) { 
     653-                       tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     654-                       tmp &= ~SSB_IMCFGLO_SERTO; 
     655-                       tmp |= 2; 
     656-                       tmp &= ~SSB_IMCFGLO_REQTO; 
     657-                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     658-                       ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     659-                       ssb_commit_settings(bus); 
     660-               } else if (pdev->id.revision >= 11) { 
     661-                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     662-                       tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     663-                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     664-               } 
     665+               ssb_pcicore_pci_setup_workarounds(pc); 
     666        } else { 
     667                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
     668-               //TODO: Better make defines for all these magic PCIE values. 
     669-               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
     670-                       /* TLP Workaround register. */ 
     671-                       tmp = ssb_pcie_read(pc, 0x4); 
     672-                       tmp |= 0x8; 
     673-                       ssb_pcie_write(pc, 0x4, tmp); 
     674-               } 
     675-               if (pdev->id.revision == 0) { 
     676-                       const u8 serdes_rx_device = 0x1F; 
     677- 
     678-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     679-                                           2 /* Timer */, 0x8128); 
     680-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     681-                                           6 /* CDR */, 0x0100); 
     682-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     683-                                           7 /* CDR BW */, 0x1466); 
     684-               } else if (pdev->id.revision == 1) { 
     685-                       /* DLLP Link Control register. */ 
     686-                       tmp = ssb_pcie_read(pc, 0x100); 
     687-                       tmp |= 0x40; 
     688-                       ssb_pcie_write(pc, 0x100, tmp); 
     689-               } 
     690+               ssb_pcicore_pcie_setup_workarounds(pc); 
     691        } 
     692        pc->setup_done = 1; 
     693 out: 
    203694--- a/drivers/ssb/main.c 
    204695+++ b/drivers/ssb/main.c 
     
    442933                } 
    443934  
     935@@ -523,7 +559,7 @@ error: 
     936 } 
     937  
     938 /* Needs ssb_buses_lock() */ 
     939-static int ssb_attach_queued_buses(void) 
     940+static int __devinit ssb_attach_queued_buses(void) 
     941 { 
     942        struct ssb_bus *bus, *n; 
     943        int err = 0; 
     944@@ -734,9 +770,9 @@ out: 
     945        return err; 
     946 } 
     947  
     948-static int ssb_bus_register(struct ssb_bus *bus, 
     949-                           ssb_invariants_func_t get_invariants, 
     950-                           unsigned long baseaddr) 
     951+static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     952+                                     ssb_invariants_func_t get_invariants, 
     953+                                     unsigned long baseaddr) 
     954 { 
     955        int err; 
     956  
     957@@ -817,8 +853,8 @@ err_disable_xtal: 
     958 } 
     959  
     960 #ifdef CONFIG_SSB_PCIHOST 
     961-int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     962-                           struct pci_dev *host_pci) 
     963+int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     964+                                     struct pci_dev *host_pci) 
     965 { 
     966        int err; 
     967  
    444968@@ -830,6 +866,9 @@ int ssb_bus_pcibus_register(struct ssb_b 
    445969        if (!err) { 
     
    452976  
    453977        return err; 
     978@@ -838,9 +877,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register); 
     979 #endif /* CONFIG_SSB_PCIHOST */ 
     980  
     981 #ifdef CONFIG_SSB_PCMCIAHOST 
     982-int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     983-                              struct pcmcia_device *pcmcia_dev, 
     984-                              unsigned long baseaddr) 
     985+int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     986+                                        struct pcmcia_device *pcmcia_dev, 
     987+                                        unsigned long baseaddr) 
     988 { 
     989        int err; 
     990  
     991@@ -860,8 +899,9 @@ EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
     992 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     993  
     994 #ifdef CONFIG_SSB_SDIOHOST 
     995-int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
     996-                            unsigned int quirks) 
     997+int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     998+                                      struct sdio_func *func, 
     999+                                      unsigned int quirks) 
     1000 { 
     1001        int err; 
     1002  
     1003@@ -881,9 +921,9 @@ int ssb_bus_sdiobus_register(struct ssb_ 
     1004 EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
     1005 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     1006  
     1007-int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1008-                           unsigned long baseaddr, 
     1009-                           ssb_invariants_func_t get_invariants) 
     1010+int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     1011+                                     unsigned long baseaddr, 
     1012+                                     ssb_invariants_func_t get_invariants) 
     1013 { 
     1014        int err; 
     1015  
     1016@@ -964,8 +1004,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32 
     1017        switch (plltype) { 
     1018        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
     1019                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
     1020-                       return SSB_CHIPCO_CLK_T6_M0; 
     1021-               return SSB_CHIPCO_CLK_T6_M1; 
     1022+                       return SSB_CHIPCO_CLK_T6_M1; 
     1023+               return SSB_CHIPCO_CLK_T6_M0; 
     1024        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
     1025        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
     1026        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
     1027@@ -1080,23 +1120,22 @@ static u32 ssb_tmslow_reject_bitmask(str 
     1028 { 
     1029        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
     1030  
     1031-       /* The REJECT bit changed position in TMSLOW between 
     1032-        * Backplane revisions. */ 
     1033+       /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
     1034        switch (rev) { 
     1035        case SSB_IDLOW_SSBREV_22: 
     1036-               return SSB_TMSLOW_REJECT_22; 
     1037+       case SSB_IDLOW_SSBREV_24: 
     1038+       case SSB_IDLOW_SSBREV_26: 
     1039+               return SSB_TMSLOW_REJECT; 
     1040        case SSB_IDLOW_SSBREV_23: 
     1041                return SSB_TMSLOW_REJECT_23; 
     1042-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
     1043-       case SSB_IDLOW_SSBREV_25:     /* same here */ 
     1044-       case SSB_IDLOW_SSBREV_26:     /* same here */ 
     1045+       case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
     1046        case SSB_IDLOW_SSBREV_27:     /* same here */ 
     1047-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     1048+               return SSB_TMSLOW_REJECT;       /* this is a guess */ 
     1049        default: 
     1050                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
     1051                WARN_ON(1); 
     1052        } 
     1053-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     1054+       return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
     1055 } 
     1056  
     1057 int ssb_device_is_enabled(struct ssb_device *dev) 
    4541058@@ -1155,10 +1194,10 @@ void ssb_device_enable(struct ssb_device 
    4551059 } 
     
    5231127        ssb_write32(dev, SSB_TMSLOW, 
    5241128                    reject | SSB_TMSLOW_RESET | 
     1129@@ -1211,7 +1268,10 @@ u32 ssb_dma_translation(struct ssb_devic 
     1130        case SSB_BUSTYPE_SSB: 
     1131                return 0; 
     1132        case SSB_BUSTYPE_PCI: 
     1133-               return SSB_PCI_DMA; 
     1134+               if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) 
     1135+                       return SSB_PCIE_DMA_H32; 
     1136+               else 
     1137+                       return SSB_PCI_DMA; 
     1138        default: 
     1139                __ssb_dma_not_implemented(dev); 
     1140        } 
     1141@@ -1328,20 +1388,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     1142  
     1143 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
     1144 { 
     1145-       struct ssb_chipcommon *cc; 
     1146        int err; 
     1147        enum ssb_clkmode mode; 
     1148  
     1149        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     1150        if (err) 
     1151                goto error; 
     1152-       cc = &bus->chipco; 
     1153-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1154-       ssb_chipco_set_clockmode(cc, mode); 
     1155  
     1156 #ifdef CONFIG_SSB_DEBUG 
     1157        bus->powered_up = 1; 
     1158 #endif 
     1159+ 
     1160+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     1161+       ssb_chipco_set_clockmode(&bus->chipco, mode); 
     1162+ 
     1163        return 0; 
     1164 error: 
     1165        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     1166@@ -1349,6 +1409,37 @@ error: 
     1167 } 
     1168 EXPORT_SYMBOL(ssb_bus_powerup); 
     1169  
     1170+static void ssb_broadcast_value(struct ssb_device *dev, 
     1171+                               u32 address, u32 data) 
     1172+{ 
     1173+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1174+       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1175+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1176+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1177+#endif 
     1178+ 
     1179+       ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     1180+       ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     1181+       ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     1182+       ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     1183+} 
     1184+ 
     1185+void ssb_commit_settings(struct ssb_bus *bus) 
     1186+{ 
     1187+       struct ssb_device *dev; 
     1188+ 
     1189+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     1190+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1191+#else 
     1192+       dev = bus->chipco.dev; 
     1193+#endif 
     1194+       if (WARN_ON(!dev)) 
     1195+               return; 
     1196+       /* This forces an update of the cached registers. */ 
     1197+       ssb_broadcast_value(dev, 0xFD8, 0); 
     1198+} 
     1199+EXPORT_SYMBOL(ssb_commit_settings); 
     1200+ 
     1201 u32 ssb_admatch_base(u32 adm) 
     1202 { 
     1203        u32 base = 0; 
    5251204--- a/drivers/ssb/pci.c 
    5261205+++ b/drivers/ssb/pci.c 
     
    6811360  
    6821361        if (out->boardflags_lo == 0xFFFF) 
    683 @@ -617,7 +663,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1362@@ -616,15 +662,14 @@ static int sprom_extract(struct ssb_bus 
     1363 static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    6841364                             struct ssb_sprom *sprom) 
    6851365 { 
    686         const struct ssb_sprom *fallback; 
     1366-       const struct ssb_sprom *fallback; 
    6871367-       int err = -ENOMEM; 
    6881368+       int err; 
     
    6901370  
    6911371        if (!ssb_is_sprom_available(bus)) { 
    692 @@ -644,7 +690,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1372                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
     1373                return -ENODEV; 
     1374        } 
     1375-       if (bus->chipco.dev) {  /* can be unavailible! */ 
     1376+       if (bus->chipco.dev) {  /* can be unavailable! */ 
     1377                /* 
     1378                 * get SPROM offset: SSB_SPROM_BASE1 except for 
     1379                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
     1380@@ -644,7 +689,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
    6931381  
    6941382        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
     
    6991387        sprom_do_read(bus, buf); 
    7001388        err = sprom_check_crc(buf, bus->sprom_size); 
    701 @@ -654,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1389@@ -654,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_ 
    7021390                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    7031391                              GFP_KERNEL); 
     
    7081396                sprom_do_read(bus, buf); 
    7091397                err = sprom_check_crc(buf, bus->sprom_size); 
    710 @@ -676,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     1398                if (err) { 
     1399                        /* All CRC attempts failed. 
     1400                         * Maybe there is no SPROM on the device? 
     1401-                        * If we have a fallback, use that. */ 
     1402-                       fallback = ssb_get_fallback_sprom(); 
     1403-                       if (fallback) { 
     1404-                               memcpy(sprom, fallback, sizeof(*sprom)); 
     1405+                        * Now we ask the arch code if there is some sprom 
     1406+                        * available for this device in some other storage */ 
     1407+                       err = ssb_fill_sprom_with_fallback(bus, sprom); 
     1408+                       if (err) { 
     1409+                               ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     1410+                                          " fallback SPROM failed (err %d)\n", 
     1411+                                          err); 
     1412+                       } else { 
     1413+                               ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     1414+                                           " revision %d provided by" 
     1415+                                           " platform.\n", sprom->revision); 
     1416                                err = 0; 
     1417                                goto out_free; 
     1418                        } 
     1419@@ -676,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_ 
    7111420  
    7121421 out_free: 
     
    7161425 } 
    7171426  
     1427 static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
     1428                                  struct ssb_boardinfo *bi) 
     1429 { 
     1430-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
     1431-                            &bi->vendor); 
     1432-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
     1433-                            &bi->type); 
     1434-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     1435-                            &bi->rev); 
     1436+       bi->vendor = bus->host_pci->subsystem_vendor; 
     1437+       bi->type = bus->host_pci->subsystem_device; 
     1438+       bi->rev = bus->host_pci->revision; 
     1439 } 
     1440  
     1441 int ssb_pci_get_invariants(struct ssb_bus *bus, 
    7181442--- a/drivers/ssb/pcihost_wrapper.c 
    7191443+++ b/drivers/ssb/pcihost_wrapper.c 
     
    7261450  
    7271451  
    728 @@ -58,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     1452@@ -52,12 +53,13 @@ static int ssb_pcihost_resume(struct pci 
     1453 # define ssb_pcihost_resume    NULL 
     1454 #endif /* CONFIG_PM */ 
     1455  
     1456-static int ssb_pcihost_probe(struct pci_dev *dev, 
     1457-                            const struct pci_device_id *id) 
     1458+static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     1459+                                      const struct pci_device_id *id) 
     1460 { 
    7291461        struct ssb_bus *ssb; 
    7301462        int err = -ENOMEM; 
     
    7471479        if (err) 
    7481480                goto err_pci_release_regions; 
     1481@@ -102,7 +110,7 @@ static void ssb_pcihost_remove(struct pc 
     1482        pci_set_drvdata(dev, NULL); 
     1483 } 
     1484  
     1485-int ssb_pcihost_register(struct pci_driver *driver) 
     1486+int __devinit ssb_pcihost_register(struct pci_driver *driver) 
     1487 { 
     1488        driver->probe = ssb_pcihost_probe; 
     1489        driver->remove = ssb_pcihost_remove; 
    7491490--- a/drivers/ssb/pcmcia.c 
    7501491+++ b/drivers/ssb/pcmcia.c 
     
    10061747--- a/drivers/ssb/scan.c 
    10071748+++ b/drivers/ssb/scan.c 
    1008 @@ -354,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1749@@ -260,7 +260,10 @@ static int we_support_multiple_80211_cor 
     1750 #ifdef CONFIG_SSB_PCIHOST 
     1751        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     1752                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     1753-                   bus->host_pci->device == 0x4324) 
     1754+                   ((bus->host_pci->device == 0x4313) || 
     1755+                    (bus->host_pci->device == 0x431A) || 
     1756+                    (bus->host_pci->device == 0x4321) || 
     1757+                    (bus->host_pci->device == 0x4324))) 
     1758                        return 1; 
     1759        } 
     1760 #endif /* CONFIG_SSB_PCIHOST */ 
     1761@@ -309,8 +312,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1762        } else { 
     1763                if (bus->bustype == SSB_BUSTYPE_PCI) { 
     1764                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
     1765-                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     1766-                                            &bus->chip_rev); 
     1767+                       bus->chip_rev = bus->host_pci->revision; 
     1768                        bus->chip_package = 0; 
     1769                } else { 
     1770                        bus->chip_id = 0x4710; 
     1771@@ -354,7 +356,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    10091772                dev->bus = bus; 
    10101773                dev->ops = bus->ops; 
     
    10151778                            "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n", 
    10161779                            i, ssb_core_name(dev->id.coreid), 
    1017 @@ -422,6 +422,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     1780@@ -422,6 +424,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    10181781                        bus->pcicore.dev = dev; 
    10191782 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     
    10341797--- a/drivers/ssb/sprom.c 
    10351798+++ b/drivers/ssb/sprom.c 
    1036 @@ -14,6 +14,7 @@ 
     1799@@ -14,9 +14,10 @@ 
    10371800 #include "ssb_private.h" 
    10381801  
     
    10411804  
    10421805  
    1043  static const struct ssb_sprom *fallback_sprom; 
     1806-static const struct ssb_sprom *fallback_sprom; 
     1807+static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
     1808  
     1809  
     1810 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
    10441811@@ -102,6 +103,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
    10451812        u16 *sprom; 
     
    10711838                ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n"); 
    10721839 out_unlock: 
     1840@@ -148,36 +145,43 @@ out: 
     1841 } 
     1842  
     1843 /** 
     1844- * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
     1845+ * ssb_arch_register_fallback_sprom - Registers a method providing a 
     1846+ * fallback SPROM if no SPROM is found. 
     1847  * 
     1848- * @sprom: The SPROM data structure to register. 
     1849+ * @sprom_callback: The callback function. 
     1850  * 
     1851- * With this function the architecture implementation may register a fallback 
     1852- * SPROM data structure. The fallback is only used for PCI based SSB devices, 
     1853- * where no valid SPROM can be found in the shadow registers. 
     1854+ * With this function the architecture implementation may register a 
     1855+ * callback handler which fills the SPROM data structure. The fallback is 
     1856+ * only used for PCI based SSB devices, where no valid SPROM can be found 
     1857+ * in the shadow registers. 
     1858  * 
     1859- * This function is useful for weird architectures that have a half-assed SSB device 
     1860- * hardwired to their PCI bus. 
     1861+ * This function is useful for weird architectures that have a half-assed 
     1862+ * SSB device hardwired to their PCI bus. 
     1863  * 
     1864- * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
     1865- * don't use this fallback. 
     1866- * Architectures must provide the SPROM for native SSB devices anyway, 
     1867- * so the fallback also isn't used for native devices. 
     1868+ * Note that it does only work with PCI attached SSB devices. PCMCIA 
     1869+ * devices currently don't use this fallback. 
     1870+ * Architectures must provide the SPROM for native SSB devices anyway, so 
     1871+ * the fallback also isn't used for native devices. 
     1872  * 
     1873- * This function is available for architecture code, only. So it is not exported. 
     1874+ * This function is available for architecture code, only. So it is not 
     1875+ * exported. 
     1876  */ 
     1877-int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 
     1878+int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus, 
     1879+                                    struct ssb_sprom *out)) 
     1880 { 
     1881-       if (fallback_sprom) 
     1882+       if (get_fallback_sprom) 
     1883                return -EEXIST; 
     1884-       fallback_sprom = sprom; 
     1885+       get_fallback_sprom = sprom_callback; 
     1886  
     1887        return 0; 
     1888 } 
     1889  
     1890-const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     1891+int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
     1892 { 
     1893-       return fallback_sprom; 
     1894+       if (!get_fallback_sprom) 
     1895+               return -ENOENT; 
     1896+ 
     1897+       return get_fallback_sprom(bus, out); 
     1898 } 
     1899  
     1900 /* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     1901@@ -188,7 +192,7 @@ bool ssb_is_sprom_available(struct ssb_b 
     1902        /* this routine differs from specs as we do not access SPROM directly 
     1903           on PCMCIA */ 
     1904        if (bus->bustype == SSB_BUSTYPE_PCI && 
     1905-           bus->chipco.dev &&  /* can be unavailible! */ 
     1906+           bus->chipco.dev &&  /* can be unavailable! */ 
     1907            bus->chipco.dev->id.revision >= 31) 
     1908                return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
     1909  
    10731910--- a/drivers/ssb/ssb_private.h 
    10741911+++ b/drivers/ssb/ssb_private.h 
    1075 @@ -176,19 +176,27 @@ extern const struct ssb_sprom *ssb_get_f 
     1912@@ -171,24 +171,33 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     1913                             const char *buf, size_t count, 
     1914                             int (*sprom_check_crc)(const u16 *sprom, size_t size), 
     1915                             int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)); 
     1916-extern const struct ssb_sprom *ssb_get_fallback_sprom(void); 
     1917+extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, 
     1918+                                       struct ssb_sprom *out); 
     1919  
    10761920  
    10771921 /* core.c */ 
     
    11041948 { 
    11051949        return 0; 
    1106 @@ -196,6 +204,6 @@ static inline int b43_pci_ssb_bridge_ini 
     1950@@ -196,6 +205,6 @@ static inline int b43_pci_ssb_bridge_ini 
    11071951 static inline void b43_pci_ssb_bridge_exit(void) 
    11081952 { 
     
    11141958--- a/include/linux/ssb/ssb.h 
    11151959+++ b/include/linux/ssb/ssb.h 
    1116 @@ -55,6 +55,10 @@ struct ssb_sprom { 
     1960@@ -27,6 +27,8 @@ struct ssb_sprom { 
     1961        u8 et1mdcport;          /* MDIO for enet1 */ 
     1962        u8 board_rev;           /* Board revision number from SPROM. */ 
     1963        u8 country_code;        /* Country Code */ 
     1964+       u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */ 
     1965+       u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */ 
     1966        u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
     1967        u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
     1968        u16 pa0b0; 
     1969@@ -55,6 +57,10 @@ struct ssb_sprom { 
    11171970        u8 tri5gl;              /* 5.2GHz TX isolation */ 
    11181971        u8 tri5g;               /* 5.3GHz TX isolation */ 
     
    11251978        u8 rxpo5g;              /* 5GHz RX power offset */ 
    11261979        u8 rssisav2g;           /* 2GHz RSSI params */ 
    1127 @@ -167,7 +171,7 @@ struct ssb_device { 
     1980@@ -95,7 +101,7 @@ struct ssb_sprom { 
     1981 struct ssb_boardinfo { 
     1982        u16 vendor; 
     1983        u16 type; 
     1984-       u16 rev; 
     1985+       u8  rev; 
     1986 }; 
     1987  
     1988  
     1989@@ -167,7 +173,7 @@ struct ssb_device { 
    11281990         * is an optimization. */ 
    11291991        const struct ssb_bus_ops *ops; 
     
    11341996        struct ssb_bus *bus; 
    11351997        struct ssb_device_id id; 
    1136 @@ -269,7 +273,8 @@ struct ssb_bus { 
     1998@@ -269,7 +275,8 @@ struct ssb_bus { 
    11371999  
    11382000        const struct ssb_bus_ops *ops; 
     
    11442006        union { 
    11452007                /* Currently mapped PCMCIA segment. (bustype == SSB_BUSTYPE_PCMCIA only) */ 
    1146 @@ -281,14 +286,17 @@ struct ssb_bus { 
     2008@@ -281,14 +288,17 @@ struct ssb_bus { 
    11472009         * On PCMCIA-host busses this is used to protect the whole MMIO access. */ 
    11482010        spinlock_t bar_lock; 
     
    11692031        /* See enum ssb_quirks */ 
    11702032        unsigned int quirks; 
     2033@@ -300,7 +310,7 @@ struct ssb_bus { 
     2034  
     2035        /* ID information about the Chip. */ 
     2036        u16 chip_id; 
     2037-       u16 chip_rev; 
     2038+       u8 chip_rev; 
     2039        u16 sprom_offset; 
     2040        u16 sprom_size;         /* number of words in sprom */ 
     2041        u8 chip_package; 
     2042@@ -396,7 +406,9 @@ extern bool ssb_is_sprom_available(struc 
     2043  
     2044 /* Set a fallback SPROM. 
     2045  * See kdoc at the function definition for complete documentation. */ 
     2046-extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     2047+extern int ssb_arch_register_fallback_sprom( 
     2048+               int (*sprom_callback)(struct ssb_bus *bus, 
     2049+               struct ssb_sprom *out)); 
     2050  
     2051 /* Suspend a SSB bus. 
     2052  * Call this from the parent bus suspend routine. */ 
     2053@@ -667,6 +679,7 @@ extern int ssb_bus_may_powerdown(struct 
     2054  * Otherwise static always-on powercontrol will be used. */ 
     2055 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
     2056  
     2057+extern void ssb_commit_settings(struct ssb_bus *bus); 
     2058  
     2059 /* Various helper functions */ 
     2060 extern u32 ssb_admatch_base(u32 adm); 
    11712061--- a/include/linux/ssb/ssb_regs.h 
    11722062+++ b/include/linux/ssb/ssb_regs.h 
     
    11802070 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
    11812071 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     2072@@ -95,7 +97,7 @@ 
     2073 #define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */ 
     2074 #define SSB_TMSLOW             0x0F98     /* SB Target State Low */ 
     2075 #define  SSB_TMSLOW_RESET      0x00000001 /* Reset */ 
     2076-#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */ 
     2077+#define  SSB_TMSLOW_REJECT     0x00000002 /* Reject (Standard Backplane) */ 
     2078 #define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */ 
     2079 #define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */ 
     2080 #define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */ 
    11822081@@ -172,25 +174,25 @@ 
    11832082 #define SSB_SPROMSIZE_BYTES_R4         (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16)) 
     
    15892488 /* Values for SSB_SPROM1_BINF_CCODE */ 
    15902489 enum { 
     2490--- a/include/linux/ssb/ssb_driver_chipcommon.h 
     2491+++ b/include/linux/ssb/ssb_driver_chipcommon.h 
     2492@@ -123,6 +123,8 @@ 
     2493 #define SSB_CHIPCO_FLASHDATA           0x0048 
     2494 #define SSB_CHIPCO_BCAST_ADDR          0x0050 
     2495 #define SSB_CHIPCO_BCAST_DATA          0x0054 
     2496+#define SSB_CHIPCO_GPIOPULLUP          0x0058          /* Rev >= 20 only */ 
     2497+#define SSB_CHIPCO_GPIOPULLDOWN                0x005C          /* Rev >= 20 only */ 
     2498 #define SSB_CHIPCO_GPIOIN              0x0060 
     2499 #define SSB_CHIPCO_GPIOOUT             0x0064 
     2500 #define SSB_CHIPCO_GPIOOUTEN           0x0068 
     2501@@ -131,6 +133,9 @@ 
     2502 #define SSB_CHIPCO_GPIOIRQ             0x0074 
     2503 #define SSB_CHIPCO_WATCHDOG            0x0080 
     2504 #define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */ 
     2505+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME  0x0000FFFF 
     2506+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT    0 
     2507+#define  SSB_CHIPCO_GPIOTIMER_ONTIME   0xFFFF0000 
     2508 #define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16 
     2509 #define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */ 
     2510 #define SSB_CHIPCO_CLOCK_N             0x0090 
     2511@@ -189,8 +194,10 @@ 
     2512 #define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ        0x00000008 /* ALP available request */ 
     2513 #define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */ 
     2514 #define  SSB_CHIPCO_CLKCTLST_HWCROFF   0x00000020 /* Force HW clock request off */ 
     2515-#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00010000 /* HT available */ 
     2516-#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00020000 /* APL available */ 
     2517+#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00010000 /* ALP available */ 
     2518+#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00020000 /* HT available */ 
     2519+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT     0x00010000 /* 4328a0 has reversed bits */ 
     2520+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP    0x00020000 /* 4328a0 has reversed bits */ 
     2521 #define SSB_CHIPCO_HW_WORKAROUND       0x01E4 /* Hardware workaround (rev >= 20) */ 
     2522 #define SSB_CHIPCO_UART0_DATA          0x0300 
     2523 #define SSB_CHIPCO_UART0_IMR           0x0304 
  • trunk/target/linux/generic/patches-2.6.36/941-ssb_update.patch

    r26127 r27731  
    4545  
    4646 static void ssb_buses_lock(void) 
     47@@ -528,7 +558,7 @@ error: 
     48 } 
     49  
     50 /* Needs ssb_buses_lock() */ 
     51-static int ssb_attach_queued_buses(void) 
     52+static int __devinit ssb_attach_queued_buses(void) 
     53 { 
     54        struct ssb_bus *bus, *n; 
     55        int err = 0; 
     56@@ -739,9 +769,9 @@ out: 
     57        return err; 
     58 } 
     59  
     60-static int ssb_bus_register(struct ssb_bus *bus, 
     61-                           ssb_invariants_func_t get_invariants, 
     62-                           unsigned long baseaddr) 
     63+static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     64+                                     ssb_invariants_func_t get_invariants, 
     65+                                     unsigned long baseaddr) 
     66 { 
     67        int err; 
     68  
     69@@ -822,8 +852,8 @@ err_disable_xtal: 
     70 } 
     71  
     72 #ifdef CONFIG_SSB_PCIHOST 
     73-int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     74-                           struct pci_dev *host_pci) 
     75+int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     76+                                     struct pci_dev *host_pci) 
     77 { 
     78        int err; 
     79  
     80@@ -846,9 +876,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register); 
     81 #endif /* CONFIG_SSB_PCIHOST */ 
     82  
     83 #ifdef CONFIG_SSB_PCMCIAHOST 
     84-int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     85-                              struct pcmcia_device *pcmcia_dev, 
     86-                              unsigned long baseaddr) 
     87+int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     88+                                        struct pcmcia_device *pcmcia_dev, 
     89+                                        unsigned long baseaddr) 
     90 { 
     91        int err; 
     92  
     93@@ -868,8 +898,9 @@ EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
     94 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     95  
     96 #ifdef CONFIG_SSB_SDIOHOST 
     97-int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
     98-                            unsigned int quirks) 
     99+int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     100+                                      struct sdio_func *func, 
     101+                                      unsigned int quirks) 
     102 { 
     103        int err; 
     104  
     105@@ -889,9 +920,9 @@ int ssb_bus_sdiobus_register(struct ssb_ 
     106 EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
     107 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     108  
     109-int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     110-                           unsigned long baseaddr, 
     111-                           ssb_invariants_func_t get_invariants) 
     112+int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     113+                                     unsigned long baseaddr, 
     114+                                     ssb_invariants_func_t get_invariants) 
     115 { 
     116        int err; 
     117  
     118@@ -972,8 +1003,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32 
     119        switch (plltype) { 
     120        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
     121                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
     122-                       return SSB_CHIPCO_CLK_T6_M0; 
     123-               return SSB_CHIPCO_CLK_T6_M1; 
     124+                       return SSB_CHIPCO_CLK_T6_M1; 
     125+               return SSB_CHIPCO_CLK_T6_M0; 
     126        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
     127        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
     128        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
     129@@ -1088,23 +1119,22 @@ static u32 ssb_tmslow_reject_bitmask(str 
     130 { 
     131        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
     132  
     133-       /* The REJECT bit changed position in TMSLOW between 
     134-        * Backplane revisions. */ 
     135+       /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
     136        switch (rev) { 
     137        case SSB_IDLOW_SSBREV_22: 
     138-               return SSB_TMSLOW_REJECT_22; 
     139+       case SSB_IDLOW_SSBREV_24: 
     140+       case SSB_IDLOW_SSBREV_26: 
     141+               return SSB_TMSLOW_REJECT; 
     142        case SSB_IDLOW_SSBREV_23: 
     143                return SSB_TMSLOW_REJECT_23; 
     144-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
     145-       case SSB_IDLOW_SSBREV_25:     /* same here */ 
     146-       case SSB_IDLOW_SSBREV_26:     /* same here */ 
     147+       case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
     148        case SSB_IDLOW_SSBREV_27:     /* same here */ 
     149-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     150+               return SSB_TMSLOW_REJECT;       /* this is a guess */ 
     151        default: 
     152                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
     153                WARN_ON(1); 
     154        } 
     155-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     156+       return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
     157 } 
     158  
     159 int ssb_device_is_enabled(struct ssb_device *dev) 
    47160@@ -1163,10 +1193,10 @@ void ssb_device_enable(struct ssb_device 
    48161 } 
     
    116229        ssb_write32(dev, SSB_TMSLOW, 
    117230                    reject | SSB_TMSLOW_RESET | 
     231@@ -1219,7 +1267,10 @@ u32 ssb_dma_translation(struct ssb_devic 
     232        case SSB_BUSTYPE_SSB: 
     233                return 0; 
     234        case SSB_BUSTYPE_PCI: 
     235-               return SSB_PCI_DMA; 
     236+               if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) 
     237+                       return SSB_PCIE_DMA_H32; 
     238+               else 
     239+                       return SSB_PCI_DMA; 
     240        default: 
     241                __ssb_dma_not_implemented(dev); 
     242        } 
     243@@ -1262,20 +1313,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     244  
     245 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
     246 { 
     247-       struct ssb_chipcommon *cc; 
     248        int err; 
     249        enum ssb_clkmode mode; 
     250  
     251        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     252        if (err) 
     253                goto error; 
     254-       cc = &bus->chipco; 
     255-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     256-       ssb_chipco_set_clockmode(cc, mode); 
     257  
     258 #ifdef CONFIG_SSB_DEBUG 
     259        bus->powered_up = 1; 
     260 #endif 
     261+ 
     262+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     263+       ssb_chipco_set_clockmode(&bus->chipco, mode); 
     264+ 
     265        return 0; 
     266 error: 
     267        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     268@@ -1283,6 +1334,37 @@ error: 
     269 } 
     270 EXPORT_SYMBOL(ssb_bus_powerup); 
     271  
     272+static void ssb_broadcast_value(struct ssb_device *dev, 
     273+                               u32 address, u32 data) 
     274+{ 
     275+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     276+       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     277+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     278+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     279+#endif 
     280+ 
     281+       ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     282+       ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     283+       ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     284+       ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     285+} 
     286+ 
     287+void ssb_commit_settings(struct ssb_bus *bus) 
     288+{ 
     289+       struct ssb_device *dev; 
     290+ 
     291+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     292+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     293+#else 
     294+       dev = bus->chipco.dev; 
     295+#endif 
     296+       if (WARN_ON(!dev)) 
     297+               return; 
     298+       /* This forces an update of the cached registers. */ 
     299+       ssb_broadcast_value(dev, 0xFD8, 0); 
     300+} 
     301+EXPORT_SYMBOL(ssb_commit_settings); 
     302+ 
     303 u32 ssb_admatch_base(u32 adm) 
     304 { 
     305        u32 base = 0; 
    118306--- a/drivers/ssb/pci.c 
    119307+++ b/drivers/ssb/pci.c 
     
    257445  
    258446        if (out->boardflags_lo == 0xFFFF) 
    259 @@ -618,7 +663,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     447@@ -617,15 +662,14 @@ static int sprom_extract(struct ssb_bus 
     448 static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    260449                             struct ssb_sprom *sprom) 
    261450 { 
    262         const struct ssb_sprom *fallback; 
     451-       const struct ssb_sprom *fallback; 
    263452-       int err = -ENOMEM; 
    264453+       int err; 
     
    266455  
    267456        if (!ssb_is_sprom_available(bus)) { 
    268 @@ -645,7 +690,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     457                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
     458                return -ENODEV; 
     459        } 
     460-       if (bus->chipco.dev) {  /* can be unavailible! */ 
     461+       if (bus->chipco.dev) {  /* can be unavailable! */ 
     462                /* 
     463                 * get SPROM offset: SSB_SPROM_BASE1 except for 
     464                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
     465@@ -645,7 +689,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
    269466  
    270467        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
     
    275472        sprom_do_read(bus, buf); 
    276473        err = sprom_check_crc(buf, bus->sprom_size); 
    277 @@ -655,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     474@@ -655,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_ 
    278475                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    279476                              GFP_KERNEL); 
     
    284481                sprom_do_read(bus, buf); 
    285482                err = sprom_check_crc(buf, bus->sprom_size); 
    286 @@ -677,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     483                if (err) { 
     484                        /* All CRC attempts failed. 
     485                         * Maybe there is no SPROM on the device? 
     486-                        * If we have a fallback, use that. */ 
     487-                       fallback = ssb_get_fallback_sprom(); 
     488-                       if (fallback) { 
     489-                               memcpy(sprom, fallback, sizeof(*sprom)); 
     490+                        * Now we ask the arch code if there is some sprom 
     491+                        * available for this device in some other storage */ 
     492+                       err = ssb_fill_sprom_with_fallback(bus, sprom); 
     493+                       if (err) { 
     494+                               ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     495+                                          " fallback SPROM failed (err %d)\n", 
     496+                                          err); 
     497+                       } else { 
     498+                               ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     499+                                           " revision %d provided by" 
     500+                                           " platform.\n", sprom->revision); 
     501                                err = 0; 
     502                                goto out_free; 
     503                        } 
     504@@ -677,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_ 
    287505  
    288506 out_free: 
     
    292510 } 
    293511  
     512 static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
     513                                  struct ssb_boardinfo *bi) 
     514 { 
     515-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
     516-                            &bi->vendor); 
     517-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
     518-                            &bi->type); 
     519-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     520-                            &bi->rev); 
     521+       bi->vendor = bus->host_pci->subsystem_vendor; 
     522+       bi->type = bus->host_pci->subsystem_device; 
     523+       bi->rev = bus->host_pci->revision; 
     524 } 
     525  
     526 int ssb_pci_get_invariants(struct ssb_bus *bus, 
    294527--- a/drivers/ssb/pcihost_wrapper.c 
    295528+++ b/drivers/ssb/pcihost_wrapper.c 
    296 @@ -59,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     529@@ -53,12 +53,13 @@ static int ssb_pcihost_resume(struct pci 
     530 # define ssb_pcihost_resume    NULL 
     531 #endif /* CONFIG_PM */ 
     532  
     533-static int ssb_pcihost_probe(struct pci_dev *dev, 
     534-                            const struct pci_device_id *id) 
     535+static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     536+                                      const struct pci_device_id *id) 
     537 { 
    297538        struct ssb_bus *ssb; 
    298539        int err = -ENOMEM; 
     
    315556        if (err) 
    316557                goto err_pci_release_regions; 
     558@@ -103,7 +110,7 @@ static void ssb_pcihost_remove(struct pc 
     559        pci_set_drvdata(dev, NULL); 
     560 } 
     561  
     562-int ssb_pcihost_register(struct pci_driver *driver) 
     563+int __devinit ssb_pcihost_register(struct pci_driver *driver) 
     564 { 
     565        driver->probe = ssb_pcihost_probe; 
     566        driver->remove = ssb_pcihost_remove; 
    317567--- a/drivers/ssb/scan.c 
    318568+++ b/drivers/ssb/scan.c 
    319 @@ -406,10 +406,10 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     569@@ -259,7 +259,10 @@ static int we_support_multiple_80211_cor 
     570 #ifdef CONFIG_SSB_PCIHOST 
     571        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     572                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     573-                   bus->host_pci->device == 0x4324) 
     574+                   ((bus->host_pci->device == 0x4313) || 
     575+                    (bus->host_pci->device == 0x431A) || 
     576+                    (bus->host_pci->device == 0x4321) || 
     577+                    (bus->host_pci->device == 0x4324))) 
     578                        return 1; 
     579        } 
     580 #endif /* CONFIG_SSB_PCIHOST */ 
     581@@ -308,8 +311,7 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     582        } else { 
     583                if (bus->bustype == SSB_BUSTYPE_PCI) { 
     584                        bus->chip_id = pcidev_to_chipid(bus->host_pci); 
     585-                       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     586-                                            &bus->chip_rev); 
     587+                       bus->chip_rev = bus->host_pci->revision; 
     588                        bus->chip_package = 0; 
     589                } else { 
     590                        bus->chip_id = 0x4710; 
     591@@ -406,10 +408,10 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    320592                                /* Ignore PCI cores on PCI-E cards. 
    321593                                 * Ignore PCI-E cores on PCI cards. */ 
     
    330602                                } 
    331603                        } 
    332 @@ -421,6 +421,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     604@@ -421,6 +423,16 @@ int ssb_bus_scan(struct ssb_bus *bus, 
    333605                        bus->pcicore.dev = dev; 
    334606 #endif /* CONFIG_SSB_DRIVER_PCICORE */ 
     
    349621--- a/include/linux/ssb/ssb.h 
    350622+++ b/include/linux/ssb/ssb.h 
    351 @@ -55,6 +55,10 @@ struct ssb_sprom { 
     623@@ -27,6 +27,8 @@ struct ssb_sprom { 
     624        u8 et1mdcport;          /* MDIO for enet1 */ 
     625        u8 board_rev;           /* Board revision number from SPROM. */ 
     626        u8 country_code;        /* Country Code */ 
     627+       u16 leddc_on_time;      /* LED Powersave Duty Cycle On Count */ 
     628+       u16 leddc_off_time;     /* LED Powersave Duty Cycle Off Count */ 
     629        u8 ant_available_a;     /* 2GHz antenna available bits (up to 4) */ 
     630        u8 ant_available_bg;    /* 5GHz antenna available bits (up to 4) */ 
     631        u16 pa0b0; 
     632@@ -55,6 +57,10 @@ struct ssb_sprom { 
    352633        u8 tri5gl;              /* 5.2GHz TX isolation */ 
    353634        u8 tri5g;               /* 5.3GHz TX isolation */ 
     
    360641        u8 rxpo5g;              /* 5GHz RX power offset */ 
    361642        u8 rssisav2g;           /* 2GHz RSSI params */ 
     643@@ -95,7 +101,7 @@ struct ssb_sprom { 
     644 struct ssb_boardinfo { 
     645        u16 vendor; 
     646        u16 type; 
     647-       u16 rev; 
     648+       u8  rev; 
     649 }; 
     650  
     651  
     652@@ -304,7 +310,7 @@ struct ssb_bus { 
     653  
     654        /* ID information about the Chip. */ 
     655        u16 chip_id; 
     656-       u16 chip_rev; 
     657+       u8 chip_rev; 
     658        u16 sprom_offset; 
     659        u16 sprom_size;         /* number of words in sprom */ 
     660        u8 chip_package; 
     661@@ -400,7 +406,9 @@ extern bool ssb_is_sprom_available(struc 
     662  
     663 /* Set a fallback SPROM. 
     664  * See kdoc at the function definition for complete documentation. */ 
     665-extern int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom); 
     666+extern int ssb_arch_register_fallback_sprom( 
     667+               int (*sprom_callback)(struct ssb_bus *bus, 
     668+               struct ssb_sprom *out)); 
     669  
     670 /* Suspend a SSB bus. 
     671  * Call this from the parent bus suspend routine. */ 
     672@@ -514,6 +522,7 @@ extern int ssb_bus_may_powerdown(struct 
     673  * Otherwise static always-on powercontrol will be used. */ 
     674 extern int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl); 
     675  
     676+extern void ssb_commit_settings(struct ssb_bus *bus); 
     677  
     678 /* Various helper functions */ 
     679 extern u32 ssb_admatch_base(u32 adm); 
    362680--- a/include/linux/ssb/ssb_driver_gige.h 
    363681+++ b/include/linux/ssb/ssb_driver_gige.h 
     
    401719 #define  SSB_INTVEC_PCI                0x00000001 /* Enable interrupts for PCI */ 
    402720 #define  SSB_INTVEC_ENET0      0x00000002 /* Enable interrupts for enet 0 */ 
     721@@ -95,7 +97,7 @@ 
     722 #define  SSB_INTVEC_ENET1      0x00000040 /* Enable interrupts for enet 1 */ 
     723 #define SSB_TMSLOW             0x0F98     /* SB Target State Low */ 
     724 #define  SSB_TMSLOW_RESET      0x00000001 /* Reset */ 
     725-#define  SSB_TMSLOW_REJECT_22  0x00000002 /* Reject (Backplane rev 2.2) */ 
     726+#define  SSB_TMSLOW_REJECT     0x00000002 /* Reject (Standard Backplane) */ 
     727 #define  SSB_TMSLOW_REJECT_23  0x00000004 /* Reject (Backplane rev 2.3) */ 
     728 #define  SSB_TMSLOW_CLOCK      0x00010000 /* Clock Enable */ 
     729 #define  SSB_TMSLOW_FGC                0x00020000 /* Force Gated Clocks On */ 
    403730@@ -267,6 +269,8 @@ 
    404731 /* SPROM Revision 4 */ 
     
    466793 #define SSB_SPROM5_GPIOA               0x0076  /* Gen. Purpose IO # 0 and 1 */ 
    467794 #define  SSB_SPROM5_GPIOA_P0           0x00FF  /* Pin 0 */ 
     795--- a/drivers/ssb/driver_chipcommon.c 
     796+++ b/drivers/ssb/driver_chipcommon.c 
     797@@ -46,40 +46,66 @@ void ssb_chipco_set_clockmode(struct ssb 
     798        if (!ccdev) 
     799                return; 
     800        bus = ccdev->bus; 
     801+ 
     802+       /* We support SLOW only on 6..9 */ 
     803+       if (ccdev->id.revision >= 10 && mode == SSB_CLKMODE_SLOW) 
     804+               mode = SSB_CLKMODE_DYNAMIC; 
     805+ 
     806+       if (cc->capabilities & SSB_CHIPCO_CAP_PMU) 
     807+               return; /* PMU controls clockmode, separated function needed */ 
     808+       SSB_WARN_ON(ccdev->id.revision >= 20); 
     809+ 
     810        /* chipcommon cores prior to rev6 don't support dynamic clock control */ 
     811        if (ccdev->id.revision < 6) 
     812                return; 
     813-       /* chipcommon cores rev10 are a whole new ball game */ 
     814+ 
     815+       /* ChipCommon cores rev10+ need testing */ 
     816        if (ccdev->id.revision >= 10) 
     817                return; 
     818+ 
     819        if (!(cc->capabilities & SSB_CHIPCO_CAP_PCTL)) 
     820                return; 
     821  
     822        switch (mode) { 
     823-       case SSB_CLKMODE_SLOW: 
     824+       case SSB_CLKMODE_SLOW: /* For revs 6..9 only */ 
     825                tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     826                tmp |= SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     827                chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     828                break; 
     829        case SSB_CLKMODE_FAST: 
     830-               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     831-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     832-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     833-               tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     834-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     835+               if (ccdev->id.revision < 10) { 
     836+                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 1); /* Force crystal on */ 
     837+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     838+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     839+                       tmp |= SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     840+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     841+               } else { 
     842+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     843+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) | 
     844+                                SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     845+                       /* udelay(150); TODO: not available in early init */ 
     846+               } 
     847                break; 
     848        case SSB_CLKMODE_DYNAMIC: 
     849-               tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     850-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     851-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     852-               tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     853-               if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     854-                       tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     855-               chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     856- 
     857-               /* for dynamic control, we have to release our xtal_pu "force on" */ 
     858-               if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     859-                       ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     860+               if (ccdev->id.revision < 10) { 
     861+                       tmp = chipco_read32(cc, SSB_CHIPCO_SLOWCLKCTL); 
     862+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_FSLOW; 
     863+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_IPLL; 
     864+                       tmp &= ~SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     865+                       if ((tmp & SSB_CHIPCO_SLOWCLKCTL_SRC) != 
     866+                           SSB_CHIPCO_SLOWCLKCTL_SRC_XTAL) 
     867+                               tmp |= SSB_CHIPCO_SLOWCLKCTL_ENXTAL; 
     868+                       chipco_write32(cc, SSB_CHIPCO_SLOWCLKCTL, tmp); 
     869+ 
     870+                       /* For dynamic control, we have to release our xtal_pu 
     871+                        * "force on" */ 
     872+                       if (tmp & SSB_CHIPCO_SLOWCLKCTL_ENXTAL) 
     873+                               ssb_pci_xtal(bus, SSB_GPIO_XTAL, 0); 
     874+               } else { 
     875+                       chipco_write32(cc, SSB_CHIPCO_SYSCLKCTL, 
     876+                               (chipco_read32(cc, SSB_CHIPCO_SYSCLKCTL) & 
     877+                                ~SSB_CHIPCO_SYSCLKCTL_FORCEHT)); 
     878+               } 
     879                break; 
     880        default: 
     881                SSB_WARN_ON(1); 
     882@@ -260,6 +286,12 @@ void ssb_chipcommon_init(struct ssb_chip 
     883        if (cc->dev->id.revision >= 11) 
     884                cc->status = chipco_read32(cc, SSB_CHIPCO_CHIPSTAT); 
     885        ssb_dprintk(KERN_INFO PFX "chipcommon status is 0x%x\n", cc->status); 
     886+ 
     887+       if (cc->dev->id.revision >= 20) { 
     888+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLUP, 0); 
     889+               chipco_write32(cc, SSB_CHIPCO_GPIOPULLDOWN, 0); 
     890+       } 
     891+ 
     892        ssb_pmu_init(cc); 
     893        chipco_powercontrol_init(cc); 
     894        ssb_chipco_set_clockmode(cc, SSB_CLKMODE_FAST); 
     895--- a/drivers/ssb/driver_chipcommon_pmu.c 
     896+++ b/drivers/ssb/driver_chipcommon_pmu.c 
     897@@ -417,12 +417,14 @@ static void ssb_pmu_resources_init(struc 
     898        u32 min_msk = 0, max_msk = 0; 
     899        unsigned int i; 
     900        const struct pmu_res_updown_tab_entry *updown_tab = NULL; 
     901-       unsigned int updown_tab_size; 
     902+       unsigned int updown_tab_size = 0; 
     903        const struct pmu_res_depend_tab_entry *depend_tab = NULL; 
     904-       unsigned int depend_tab_size; 
     905+       unsigned int depend_tab_size = 0; 
     906  
     907        switch (bus->chip_id) { 
     908        case 0x4312: 
     909+                min_msk = 0xCBB; 
     910+                break; 
     911        case 0x4322: 
     912                /* We keep the default settings: 
     913                 * min_msk = 0xCBB 
     914--- a/drivers/ssb/driver_gige.c 
     915+++ b/drivers/ssb/driver_gige.c 
     916@@ -106,8 +106,9 @@ void gige_pcicfg_write32(struct ssb_gige 
     917        gige_write32(dev, SSB_GIGE_PCICFG + offset, value); 
     918 } 
     919  
     920-static int ssb_gige_pci_read_config(struct pci_bus *bus, unsigned int devfn, 
     921-                                   int reg, int size, u32 *val) 
     922+static int __devinit ssb_gige_pci_read_config(struct pci_bus *bus, 
     923+                                             unsigned int devfn, int reg, 
     924+                                             int size, u32 *val) 
     925 { 
     926        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     927        unsigned long flags; 
     928@@ -136,8 +137,9 @@ static int ssb_gige_pci_read_config(stru 
     929        return PCIBIOS_SUCCESSFUL; 
     930 } 
     931  
     932-static int ssb_gige_pci_write_config(struct pci_bus *bus, unsigned int devfn, 
     933-                                    int reg, int size, u32 val) 
     934+static int __devinit ssb_gige_pci_write_config(struct pci_bus *bus, 
     935+                                              unsigned int devfn, int reg, 
     936+                                              int size, u32 val) 
     937 { 
     938        struct ssb_gige *dev = container_of(bus->ops, struct ssb_gige, pci_ops); 
     939        unsigned long flags; 
     940@@ -166,7 +168,8 @@ static int ssb_gige_pci_write_config(str 
     941        return PCIBIOS_SUCCESSFUL; 
     942 } 
     943  
     944-static int ssb_gige_probe(struct ssb_device *sdev, const struct ssb_device_id *id) 
     945+static int __devinit ssb_gige_probe(struct ssb_device *sdev, 
     946+                                   const struct ssb_device_id *id) 
     947 { 
     948        struct ssb_gige *dev; 
     949        u32 base, tmslow, tmshigh; 
     950--- a/drivers/ssb/driver_pcicore.c 
     951+++ b/drivers/ssb/driver_pcicore.c 
     952@@ -15,6 +15,11 @@ 
     953  
     954 #include "ssb_private.h" 
     955  
     956+static u32 ssb_pcie_read(struct ssb_pcicore *pc, u32 address); 
     957+static void ssb_pcie_write(struct ssb_pcicore *pc, u32 address, u32 data); 
     958+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address); 
     959+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     960+                               u8 address, u16 data); 
     961  
     962 static inline 
     963 u32 pcicore_read32(struct ssb_pcicore *pc, u16 offset) 
     964@@ -309,7 +314,7 @@ int ssb_pcicore_pcibios_map_irq(const st 
     965        return ssb_mips_irq(extpci_core->dev) + 2; 
     966 } 
     967  
     968-static void ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     969+static void __devinit ssb_pcicore_init_hostmode(struct ssb_pcicore *pc) 
     970 { 
     971        u32 val; 
     972  
     973@@ -374,7 +379,7 @@ static void ssb_pcicore_init_hostmode(st 
     974        register_pci_controller(&ssb_pcicore_controller); 
     975 } 
     976  
     977-static int pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     978+static int __devinit pcicore_is_in_hostmode(struct ssb_pcicore *pc) 
     979 { 
     980        struct ssb_bus *bus = pc->dev->bus; 
     981        u16 chipid_top; 
     982@@ -403,25 +408,133 @@ static int pcicore_is_in_hostmode(struct 
     983 } 
     984 #endif /* CONFIG_SSB_PCICORE_HOSTMODE */ 
     985  
     986+/************************************************** 
     987+ * Workarounds. 
     988+ **************************************************/ 
     989+ 
     990+static void __devinit ssb_pcicore_fix_sprom_core_index(struct ssb_pcicore *pc) 
     991+{ 
     992+       u16 tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(0)); 
     993+       if (((tmp & 0xF000) >> 12) != pc->dev->core_index) { 
     994+               tmp &= ~0xF000; 
     995+               tmp |= (pc->dev->core_index << 12); 
     996+               pcicore_write16(pc, SSB_PCICORE_SPROM(0), tmp); 
     997+       } 
     998+} 
     999+ 
     1000+static u8 ssb_pcicore_polarity_workaround(struct ssb_pcicore *pc) 
     1001+{ 
     1002+       return (ssb_pcie_read(pc, 0x204) & 0x10) ? 0xC0 : 0x80; 
     1003+} 
     1004+ 
     1005+static void ssb_pcicore_serdes_workaround(struct ssb_pcicore *pc) 
     1006+{ 
     1007+       const u8 serdes_pll_device = 0x1D; 
     1008+       const u8 serdes_rx_device = 0x1F; 
     1009+       u16 tmp; 
     1010+ 
     1011+       ssb_pcie_mdio_write(pc, serdes_rx_device, 1 /* Control */, 
     1012+                           ssb_pcicore_polarity_workaround(pc)); 
     1013+       tmp = ssb_pcie_mdio_read(pc, serdes_pll_device, 1 /* Control */); 
     1014+       if (tmp & 0x4000) 
     1015+               ssb_pcie_mdio_write(pc, serdes_pll_device, 1, tmp & ~0x4000); 
     1016+} 
     1017+ 
     1018+static void ssb_pcicore_pci_setup_workarounds(struct ssb_pcicore *pc) 
     1019+{ 
     1020+       struct ssb_device *pdev = pc->dev; 
     1021+       struct ssb_bus *bus = pdev->bus; 
     1022+       u32 tmp; 
     1023+ 
     1024+       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     1025+       tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     1026+       tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     1027+       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     1028+ 
     1029+       if (pdev->id.revision < 5) { 
     1030+               tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     1031+               tmp &= ~SSB_IMCFGLO_SERTO; 
     1032+               tmp |= 2; 
     1033+               tmp &= ~SSB_IMCFGLO_REQTO; 
     1034+               tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     1035+               ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     1036+               ssb_commit_settings(bus); 
     1037+       } else if (pdev->id.revision >= 11) { 
     1038+               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     1039+               tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     1040+               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     1041+       } 
     1042+} 
     1043+ 
     1044+static void ssb_pcicore_pcie_setup_workarounds(struct ssb_pcicore *pc) 
     1045+{ 
     1046+       u32 tmp; 
     1047+       u8 rev = pc->dev->id.revision; 
     1048+ 
     1049+       if (rev == 0 || rev == 1) { 
     1050+               /* TLP Workaround register. */ 
     1051+               tmp = ssb_pcie_read(pc, 0x4); 
     1052+               tmp |= 0x8; 
     1053+               ssb_pcie_write(pc, 0x4, tmp); 
     1054+       } 
     1055+       if (rev == 1) { 
     1056+               /* DLLP Link Control register. */ 
     1057+               tmp = ssb_pcie_read(pc, 0x100); 
     1058+               tmp |= 0x40; 
     1059+               ssb_pcie_write(pc, 0x100, tmp); 
     1060+       } 
     1061+ 
     1062+       if (rev == 0) { 
     1063+               const u8 serdes_rx_device = 0x1F; 
     1064+ 
     1065+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1066+                                       2 /* Timer */, 0x8128); 
     1067+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1068+                                       6 /* CDR */, 0x0100); 
     1069+               ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1070+                                       7 /* CDR BW */, 0x1466); 
     1071+       } else if (rev == 3 || rev == 4 || rev == 5) { 
     1072+               /* TODO: DLLP Power Management Threshold */ 
     1073+               ssb_pcicore_serdes_workaround(pc); 
     1074+               /* TODO: ASPM */ 
     1075+       } else if (rev == 7) { 
     1076+               /* TODO: No PLL down */ 
     1077+       } 
     1078+ 
     1079+       if (rev >= 6) { 
     1080+               /* Miscellaneous Configuration Fixup */ 
     1081+               tmp = pcicore_read16(pc, SSB_PCICORE_SPROM(5)); 
     1082+               if (!(tmp & 0x8000)) 
     1083+                       pcicore_write16(pc, SSB_PCICORE_SPROM(5), 
     1084+                                       tmp | 0x8000); 
     1085+       } 
     1086+} 
     1087  
     1088 /************************************************** 
     1089  * Generic and Clientmode operation code. 
     1090  **************************************************/ 
     1091  
     1092-static void ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     1093+static void __devinit ssb_pcicore_init_clientmode(struct ssb_pcicore *pc) 
     1094 { 
     1095+       ssb_pcicore_fix_sprom_core_index(pc); 
     1096+ 
     1097        /* Disable PCI interrupts. */ 
     1098        ssb_write32(pc->dev, SSB_INTVEC, 0); 
     1099+ 
     1100+       /* Additional PCIe always once-executed workarounds */ 
     1101+       if (pc->dev->id.coreid == SSB_DEV_PCIE) { 
     1102+               ssb_pcicore_serdes_workaround(pc); 
     1103+               /* TODO: ASPM */ 
     1104+               /* TODO: Clock Request Update */ 
     1105+       } 
     1106 } 
     1107  
     1108-void ssb_pcicore_init(struct ssb_pcicore *pc) 
     1109+void __devinit ssb_pcicore_init(struct ssb_pcicore *pc) 
     1110 { 
     1111        struct ssb_device *dev = pc->dev; 
     1112-       struct ssb_bus *bus; 
     1113  
     1114        if (!dev) 
     1115                return; 
     1116-       bus = dev->bus; 
     1117        if (!ssb_device_is_enabled(dev)) 
     1118                ssb_device_enable(dev, 0); 
     1119  
     1120@@ -446,11 +559,35 @@ static void ssb_pcie_write(struct ssb_pc 
     1121        pcicore_write32(pc, 0x134, data); 
     1122 } 
     1123  
     1124-static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     1125-                               u8 address, u16 data) 
     1126+static void ssb_pcie_mdio_set_phy(struct ssb_pcicore *pc, u8 phy) 
     1127+{ 
     1128+       const u16 mdio_control = 0x128; 
     1129+       const u16 mdio_data = 0x12C; 
     1130+       u32 v; 
     1131+       int i; 
     1132+ 
     1133+       v = (1 << 30); /* Start of Transaction */ 
     1134+       v |= (1 << 28); /* Write Transaction */ 
     1135+       v |= (1 << 17); /* Turnaround */ 
     1136+       v |= (0x1F << 18); 
     1137+       v |= (phy << 4); 
     1138+       pcicore_write32(pc, mdio_data, v); 
     1139+ 
     1140+       udelay(10); 
     1141+       for (i = 0; i < 200; i++) { 
     1142+               v = pcicore_read32(pc, mdio_control); 
     1143+               if (v & 0x100 /* Trans complete */) 
     1144+                       break; 
     1145+               msleep(1); 
     1146+       } 
     1147+} 
     1148+ 
     1149+static u16 ssb_pcie_mdio_read(struct ssb_pcicore *pc, u8 device, u8 address) 
     1150 { 
     1151        const u16 mdio_control = 0x128; 
     1152        const u16 mdio_data = 0x12C; 
     1153+       int max_retries = 10; 
     1154+       u16 ret = 0; 
     1155        u32 v; 
     1156        int i; 
     1157  
     1158@@ -458,46 +595,68 @@ static void ssb_pcie_mdio_write(struct s 
     1159        v |= 0x2; /* MDIO Clock Divisor */ 
     1160        pcicore_write32(pc, mdio_control, v); 
     1161  
     1162+       if (pc->dev->id.revision >= 10) { 
     1163+               max_retries = 200; 
     1164+               ssb_pcie_mdio_set_phy(pc, device); 
     1165+       } 
     1166+ 
     1167        v = (1 << 30); /* Start of Transaction */ 
     1168-       v |= (1 << 28); /* Write Transaction */ 
     1169+       v |= (1 << 29); /* Read Transaction */ 
     1170        v |= (1 << 17); /* Turnaround */ 
     1171-       v |= (u32)device << 22; 
     1172+       if (pc->dev->id.revision < 10) 
     1173+               v |= (u32)device << 22; 
     1174        v |= (u32)address << 18; 
     1175-       v |= data; 
     1176        pcicore_write32(pc, mdio_data, v); 
     1177        /* Wait for the device to complete the transaction */ 
     1178        udelay(10); 
     1179-       for (i = 0; i < 10; i++) { 
     1180+       for (i = 0; i < max_retries; i++) { 
     1181                v = pcicore_read32(pc, mdio_control); 
     1182-               if (v & 0x100 /* Trans complete */) 
     1183+               if (v & 0x100 /* Trans complete */) { 
     1184+                       udelay(10); 
     1185+                       ret = pcicore_read32(pc, mdio_data); 
     1186                        break; 
     1187+               } 
     1188                msleep(1); 
     1189        } 
     1190        pcicore_write32(pc, mdio_control, 0); 
     1191+       return ret; 
     1192 } 
     1193  
     1194-static void ssb_broadcast_value(struct ssb_device *dev, 
     1195-                               u32 address, u32 data) 
     1196+static void ssb_pcie_mdio_write(struct ssb_pcicore *pc, u8 device, 
     1197+                               u8 address, u16 data) 
     1198 { 
     1199-       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     1200-       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     1201-       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     1202+       const u16 mdio_control = 0x128; 
     1203+       const u16 mdio_data = 0x12C; 
     1204+       int max_retries = 10; 
     1205+       u32 v; 
     1206+       int i; 
     1207  
     1208-       ssb_write32(dev, SSB_PCICORE_BCAST_ADDR, address); 
     1209-       ssb_read32(dev, SSB_PCICORE_BCAST_ADDR); /* flush */ 
     1210-       ssb_write32(dev, SSB_PCICORE_BCAST_DATA, data); 
     1211-       ssb_read32(dev, SSB_PCICORE_BCAST_DATA); /* flush */ 
     1212-} 
     1213+       v = 0x80; /* Enable Preamble Sequence */ 
     1214+       v |= 0x2; /* MDIO Clock Divisor */ 
     1215+       pcicore_write32(pc, mdio_control, v); 
     1216  
     1217-static void ssb_commit_settings(struct ssb_bus *bus) 
     1218-{ 
     1219-       struct ssb_device *dev; 
     1220+       if (pc->dev->id.revision >= 10) { 
     1221+               max_retries = 200; 
     1222+               ssb_pcie_mdio_set_phy(pc, device); 
     1223+       } 
     1224  
     1225-       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     1226-       if (WARN_ON(!dev)) 
     1227-               return; 
     1228-       /* This forces an update of the cached registers. */ 
     1229-       ssb_broadcast_value(dev, 0xFD8, 0); 
     1230+       v = (1 << 30); /* Start of Transaction */ 
     1231+       v |= (1 << 28); /* Write Transaction */ 
     1232+       v |= (1 << 17); /* Turnaround */ 
     1233+       if (pc->dev->id.revision < 10) 
     1234+               v |= (u32)device << 22; 
     1235+       v |= (u32)address << 18; 
     1236+       v |= data; 
     1237+       pcicore_write32(pc, mdio_data, v); 
     1238+       /* Wait for the device to complete the transaction */ 
     1239+       udelay(10); 
     1240+       for (i = 0; i < max_retries; i++) { 
     1241+               v = pcicore_read32(pc, mdio_control); 
     1242+               if (v & 0x100 /* Trans complete */) 
     1243+                       break; 
     1244+               msleep(1); 
     1245+       } 
     1246+       pcicore_write32(pc, mdio_control, 0); 
     1247 } 
     1248  
     1249 int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc, 
     1250@@ -550,48 +709,10 @@ int ssb_pcicore_dev_irqvecs_enable(struc 
     1251        if (pc->setup_done) 
     1252                goto out; 
     1253        if (pdev->id.coreid == SSB_DEV_PCI) { 
     1254-               tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     1255-               tmp |= SSB_PCICORE_SBTOPCI_PREF; 
     1256-               tmp |= SSB_PCICORE_SBTOPCI_BURST; 
     1257-               pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     1258- 
     1259-               if (pdev->id.revision < 5) { 
     1260-                       tmp = ssb_read32(pdev, SSB_IMCFGLO); 
     1261-                       tmp &= ~SSB_IMCFGLO_SERTO; 
     1262-                       tmp |= 2; 
     1263-                       tmp &= ~SSB_IMCFGLO_REQTO; 
     1264-                       tmp |= 3 << SSB_IMCFGLO_REQTO_SHIFT; 
     1265-                       ssb_write32(pdev, SSB_IMCFGLO, tmp); 
     1266-                       ssb_commit_settings(bus); 
     1267-               } else if (pdev->id.revision >= 11) { 
     1268-                       tmp = pcicore_read32(pc, SSB_PCICORE_SBTOPCI2); 
     1269-                       tmp |= SSB_PCICORE_SBTOPCI_MRM; 
     1270-                       pcicore_write32(pc, SSB_PCICORE_SBTOPCI2, tmp); 
     1271-               } 
     1272+               ssb_pcicore_pci_setup_workarounds(pc); 
     1273        } else { 
     1274                WARN_ON(pdev->id.coreid != SSB_DEV_PCIE); 
     1275-               //TODO: Better make defines for all these magic PCIE values. 
     1276-               if ((pdev->id.revision == 0) || (pdev->id.revision == 1)) { 
     1277-                       /* TLP Workaround register. */ 
     1278-                       tmp = ssb_pcie_read(pc, 0x4); 
     1279-                       tmp |= 0x8; 
     1280-                       ssb_pcie_write(pc, 0x4, tmp); 
     1281-               } 
     1282-               if (pdev->id.revision == 0) { 
     1283-                       const u8 serdes_rx_device = 0x1F; 
     1284- 
     1285-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1286-                                           2 /* Timer */, 0x8128); 
     1287-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1288-                                           6 /* CDR */, 0x0100); 
     1289-                       ssb_pcie_mdio_write(pc, serdes_rx_device, 
     1290-                                           7 /* CDR BW */, 0x1466); 
     1291-               } else if (pdev->id.revision == 1) { 
     1292-                       /* DLLP Link Control register. */ 
     1293-                       tmp = ssb_pcie_read(pc, 0x100); 
     1294-                       tmp |= 0x40; 
     1295-                       ssb_pcie_write(pc, 0x100, tmp); 
     1296-               } 
     1297+               ssb_pcicore_pcie_setup_workarounds(pc); 
     1298        } 
     1299        pc->setup_done = 1; 
     1300 out: 
     1301--- a/drivers/ssb/sprom.c 
     1302+++ b/drivers/ssb/sprom.c 
     1303@@ -17,7 +17,7 @@ 
     1304 #include <linux/slab.h> 
     1305  
     1306  
     1307-static const struct ssb_sprom *fallback_sprom; 
     1308+static int(*get_fallback_sprom)(struct ssb_bus *dev, struct ssb_sprom *out); 
     1309  
     1310  
     1311 static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len, 
     1312@@ -145,36 +145,43 @@ out: 
     1313 } 
     1314  
     1315 /** 
     1316- * ssb_arch_set_fallback_sprom - Set a fallback SPROM for use if no SPROM is found. 
     1317+ * ssb_arch_register_fallback_sprom - Registers a method providing a 
     1318+ * fallback SPROM if no SPROM is found. 
     1319  * 
     1320- * @sprom: The SPROM data structure to register. 
     1321+ * @sprom_callback: The callback function. 
     1322  * 
     1323- * With this function the architecture implementation may register a fallback 
     1324- * SPROM data structure. The fallback is only used for PCI based SSB devices, 
     1325- * where no valid SPROM can be found in the shadow registers. 
     1326+ * With this function the architecture implementation may register a 
     1327+ * callback handler which fills the SPROM data structure. The fallback is 
     1328+ * only used for PCI based SSB devices, where no valid SPROM can be found 
     1329+ * in the shadow registers. 
     1330  * 
     1331- * This function is useful for weird architectures that have a half-assed SSB device 
     1332- * hardwired to their PCI bus. 
     1333+ * This function is useful for weird architectures that have a half-assed 
     1334+ * SSB device hardwired to their PCI bus. 
     1335  * 
     1336- * Note that it does only work with PCI attached SSB devices. PCMCIA devices currently 
     1337- * don't use this fallback. 
     1338- * Architectures must provide the SPROM for native SSB devices anyway, 
     1339- * so the fallback also isn't used for native devices. 
     1340+ * Note that it does only work with PCI attached SSB devices. PCMCIA 
     1341+ * devices currently don't use this fallback. 
     1342+ * Architectures must provide the SPROM for native SSB devices anyway, so 
     1343+ * the fallback also isn't used for native devices. 
     1344  * 
     1345- * This function is available for architecture code, only. So it is not exported. 
     1346+ * This function is available for architecture code, only. So it is not 
     1347+ * exported. 
     1348  */ 
     1349-int ssb_arch_set_fallback_sprom(const struct ssb_sprom *sprom) 
     1350+int ssb_arch_register_fallback_sprom(int (*sprom_callback)(struct ssb_bus *bus, 
     1351+                                    struct ssb_sprom *out)) 
     1352 { 
     1353-       if (fallback_sprom) 
     1354+       if (get_fallback_sprom) 
     1355                return -EEXIST; 
     1356-       fallback_sprom = sprom; 
     1357+       get_fallback_sprom = sprom_callback; 
     1358  
     1359        return 0; 
     1360 } 
     1361  
     1362-const struct ssb_sprom *ssb_get_fallback_sprom(void) 
     1363+int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, struct ssb_sprom *out) 
     1364 { 
     1365-       return fallback_sprom; 
     1366+       if (!get_fallback_sprom) 
     1367+               return -ENOENT; 
     1368+ 
     1369+       return get_fallback_sprom(bus, out); 
     1370 } 
     1371  
     1372 /* http://bcm-v4.sipsolutions.net/802.11/IsSpromAvailable */ 
     1373@@ -185,7 +192,7 @@ bool ssb_is_sprom_available(struct ssb_b 
     1374        /* this routine differs from specs as we do not access SPROM directly 
     1375           on PCMCIA */ 
     1376        if (bus->bustype == SSB_BUSTYPE_PCI && 
     1377-           bus->chipco.dev &&  /* can be unavailible! */ 
     1378+           bus->chipco.dev &&  /* can be unavailable! */ 
     1379            bus->chipco.dev->id.revision >= 31) 
     1380                return bus->chipco.capabilities & SSB_CHIPCO_CAP_SPROM; 
     1381  
     1382--- a/drivers/ssb/ssb_private.h 
     1383+++ b/drivers/ssb/ssb_private.h 
     1384@@ -171,7 +171,8 @@ ssize_t ssb_attr_sprom_store(struct ssb_ 
     1385                             const char *buf, size_t count, 
     1386                             int (*sprom_check_crc)(const u16 *sprom, size_t size), 
     1387                             int (*sprom_write)(struct ssb_bus *bus, const u16 *sprom)); 
     1388-extern const struct ssb_sprom *ssb_get_fallback_sprom(void); 
     1389+extern int ssb_fill_sprom_with_fallback(struct ssb_bus *bus, 
     1390+                                       struct ssb_sprom *out); 
     1391  
     1392  
     1393 /* core.c */ 
     1394--- a/include/linux/ssb/ssb_driver_chipcommon.h 
     1395+++ b/include/linux/ssb/ssb_driver_chipcommon.h 
     1396@@ -123,6 +123,8 @@ 
     1397 #define SSB_CHIPCO_FLASHDATA           0x0048 
     1398 #define SSB_CHIPCO_BCAST_ADDR          0x0050 
     1399 #define SSB_CHIPCO_BCAST_DATA          0x0054 
     1400+#define SSB_CHIPCO_GPIOPULLUP          0x0058          /* Rev >= 20 only */ 
     1401+#define SSB_CHIPCO_GPIOPULLDOWN                0x005C          /* Rev >= 20 only */ 
     1402 #define SSB_CHIPCO_GPIOIN              0x0060 
     1403 #define SSB_CHIPCO_GPIOOUT             0x0064 
     1404 #define SSB_CHIPCO_GPIOOUTEN           0x0068 
     1405@@ -131,6 +133,9 @@ 
     1406 #define SSB_CHIPCO_GPIOIRQ             0x0074 
     1407 #define SSB_CHIPCO_WATCHDOG            0x0080 
     1408 #define SSB_CHIPCO_GPIOTIMER           0x0088          /* LED powersave (corerev >= 16) */ 
     1409+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME  0x0000FFFF 
     1410+#define  SSB_CHIPCO_GPIOTIMER_OFFTIME_SHIFT    0 
     1411+#define  SSB_CHIPCO_GPIOTIMER_ONTIME   0xFFFF0000 
     1412 #define  SSB_CHIPCO_GPIOTIMER_ONTIME_SHIFT     16 
     1413 #define SSB_CHIPCO_GPIOTOUTM           0x008C          /* LED powersave (corerev >= 16) */ 
     1414 #define SSB_CHIPCO_CLOCK_N             0x0090 
     1415@@ -189,8 +194,10 @@ 
     1416 #define  SSB_CHIPCO_CLKCTLST_HAVEALPREQ        0x00000008 /* ALP available request */ 
     1417 #define  SSB_CHIPCO_CLKCTLST_HAVEHTREQ 0x00000010 /* HT available request */ 
     1418 #define  SSB_CHIPCO_CLKCTLST_HWCROFF   0x00000020 /* Force HW clock request off */ 
     1419-#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00010000 /* HT available */ 
     1420-#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00020000 /* APL available */ 
     1421+#define  SSB_CHIPCO_CLKCTLST_HAVEALP   0x00010000 /* ALP available */ 
     1422+#define  SSB_CHIPCO_CLKCTLST_HAVEHT    0x00020000 /* HT available */ 
     1423+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEHT     0x00010000 /* 4328a0 has reversed bits */ 
     1424+#define  SSB_CHIPCO_CLKCTLST_4328A0_HAVEALP    0x00020000 /* 4328a0 has reversed bits */ 
     1425 #define SSB_CHIPCO_HW_WORKAROUND       0x01E4 /* Hardware workaround (rev >= 20) */ 
     1426 #define SSB_CHIPCO_UART0_DATA          0x0300 
     1427 #define SSB_CHIPCO_UART0_IMR           0x0304 
  • trunk/target/linux/generic/patches-2.6.36/974-ssb_b43_default_on.patch

    r21952 r27731  
    1818 config SSB_PCMCIAHOST_POSSIBLE 
    1919        bool 
     20--- a/drivers/bcma/Kconfig 
     21+++ b/drivers/bcma/Kconfig 
     22@@ -17,6 +17,7 @@ config BCMA 
     23 config BCMA_BLOCKIO 
     24        bool 
     25        depends on BCMA 
     26+       default y 
     27  
     28 config BCMA_HOST_PCI_POSSIBLE 
     29        bool 
  • trunk/target/linux/generic/patches-2.6.37/020-ssb_update.patch

    r26955 r27731  
    4545  
    4646 static void ssb_buses_lock(void) 
     47@@ -527,7 +557,7 @@ error: 
     48 } 
     49  
     50 /* Needs ssb_buses_lock() */ 
     51-static int ssb_attach_queued_buses(void) 
     52+static int __devinit ssb_attach_queued_buses(void) 
     53 { 
     54        struct ssb_bus *bus, *n; 
     55        int err = 0; 
     56@@ -738,9 +768,9 @@ out: 
     57        return err; 
     58 } 
     59  
     60-static int ssb_bus_register(struct ssb_bus *bus, 
     61-                           ssb_invariants_func_t get_invariants, 
     62-                           unsigned long baseaddr) 
     63+static int __devinit ssb_bus_register(struct ssb_bus *bus, 
     64+                                     ssb_invariants_func_t get_invariants, 
     65+                                     unsigned long baseaddr) 
     66 { 
     67        int err; 
     68  
     69@@ -821,8 +851,8 @@ err_disable_xtal: 
     70 } 
     71  
     72 #ifdef CONFIG_SSB_PCIHOST 
     73-int ssb_bus_pcibus_register(struct ssb_bus *bus, 
     74-                           struct pci_dev *host_pci) 
     75+int __devinit ssb_bus_pcibus_register(struct ssb_bus *bus, 
     76+                                     struct pci_dev *host_pci) 
     77 { 
     78        int err; 
     79  
     80@@ -845,9 +875,9 @@ EXPORT_SYMBOL(ssb_bus_pcibus_register); 
     81 #endif /* CONFIG_SSB_PCIHOST */ 
     82  
     83 #ifdef CONFIG_SSB_PCMCIAHOST 
     84-int ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     85-                              struct pcmcia_device *pcmcia_dev, 
     86-                              unsigned long baseaddr) 
     87+int __devinit ssb_bus_pcmciabus_register(struct ssb_bus *bus, 
     88+                                        struct pcmcia_device *pcmcia_dev, 
     89+                                        unsigned long baseaddr) 
     90 { 
     91        int err; 
     92  
     93@@ -867,8 +897,9 @@ EXPORT_SYMBOL(ssb_bus_pcmciabus_register 
     94 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     95  
     96 #ifdef CONFIG_SSB_SDIOHOST 
     97-int ssb_bus_sdiobus_register(struct ssb_bus *bus, struct sdio_func *func, 
     98-                            unsigned int quirks) 
     99+int __devinit ssb_bus_sdiobus_register(struct ssb_bus *bus, 
     100+                                      struct sdio_func *func, 
     101+                                      unsigned int quirks) 
     102 { 
     103        int err; 
     104  
     105@@ -888,9 +919,9 @@ int ssb_bus_sdiobus_register(struct ssb_ 
     106 EXPORT_SYMBOL(ssb_bus_sdiobus_register); 
     107 #endif /* CONFIG_SSB_PCMCIAHOST */ 
     108  
     109-int ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     110-                           unsigned long baseaddr, 
     111-                           ssb_invariants_func_t get_invariants) 
     112+int __devinit ssb_bus_ssbbus_register(struct ssb_bus *bus, 
     113+                                     unsigned long baseaddr, 
     114+                                     ssb_invariants_func_t get_invariants) 
     115 { 
     116        int err; 
     117  
     118@@ -971,8 +1002,8 @@ u32 ssb_calc_clock_rate(u32 plltype, u32 
     119        switch (plltype) { 
     120        case SSB_PLLTYPE_6: /* 100/200 or 120/240 only */ 
     121                if (m & SSB_CHIPCO_CLK_T6_MMASK) 
     122-                       return SSB_CHIPCO_CLK_T6_M0; 
     123-               return SSB_CHIPCO_CLK_T6_M1; 
     124+                       return SSB_CHIPCO_CLK_T6_M1; 
     125+               return SSB_CHIPCO_CLK_T6_M0; 
     126        case SSB_PLLTYPE_1: /* 48Mhz base, 3 dividers */ 
     127        case SSB_PLLTYPE_3: /* 25Mhz, 2 dividers */ 
     128        case SSB_PLLTYPE_4: /* 48Mhz, 4 dividers */ 
     129@@ -1087,23 +1118,22 @@ static u32 ssb_tmslow_reject_bitmask(str 
     130 { 
     131        u32 rev = ssb_read32(dev, SSB_IDLOW) & SSB_IDLOW_SSBREV; 
     132  
     133-       /* The REJECT bit changed position in TMSLOW between 
     134-        * Backplane revisions. */ 
     135+       /* The REJECT bit seems to be different for Backplane rev 2.3 */ 
     136        switch (rev) { 
     137        case SSB_IDLOW_SSBREV_22: 
     138-               return SSB_TMSLOW_REJECT_22; 
     139+       case SSB_IDLOW_SSBREV_24: 
     140+       case SSB_IDLOW_SSBREV_26: 
     141+               return SSB_TMSLOW_REJECT; 
     142        case SSB_IDLOW_SSBREV_23: 
     143                return SSB_TMSLOW_REJECT_23; 
     144-       case SSB_IDLOW_SSBREV_24:     /* TODO - find the proper REJECT bits */ 
     145-       case SSB_IDLOW_SSBREV_25:     /* same here */ 
     146-       case SSB_IDLOW_SSBREV_26:     /* same here */ 
     147+       case SSB_IDLOW_SSBREV_25:     /* TODO - find the proper REJECT bit */ 
     148        case SSB_IDLOW_SSBREV_27:     /* same here */ 
     149-               return SSB_TMSLOW_REJECT_23;    /* this is a guess */ 
     150+               return SSB_TMSLOW_REJECT;       /* this is a guess */ 
     151        default: 
     152                printk(KERN_INFO "ssb: Backplane Revision 0x%.8X\n", rev); 
     153                WARN_ON(1); 
     154        } 
     155-       return (SSB_TMSLOW_REJECT_22 | SSB_TMSLOW_REJECT_23); 
     156+       return (SSB_TMSLOW_REJECT | SSB_TMSLOW_REJECT_23); 
     157 } 
     158  
     159 int ssb_device_is_enabled(struct ssb_device *dev) 
    47160@@ -1162,10 +1192,10 @@ void ssb_device_enable(struct ssb_device 
    48161 } 
     
    116229        ssb_write32(dev, SSB_TMSLOW, 
    117230                    reject | SSB_TMSLOW_RESET | 
     231@@ -1218,7 +1266,10 @@ u32 ssb_dma_translation(struct ssb_devic 
     232        case SSB_BUSTYPE_SSB: 
     233                return 0; 
     234        case SSB_BUSTYPE_PCI: 
     235-               return SSB_PCI_DMA; 
     236+               if (ssb_read32(dev, SSB_TMSHIGH) & SSB_TMSHIGH_DMA64) 
     237+                       return SSB_PCIE_DMA_H32; 
     238+               else 
     239+                       return SSB_PCI_DMA; 
     240        default: 
     241                __ssb_dma_not_implemented(dev); 
     242        } 
     243@@ -1261,20 +1312,20 @@ EXPORT_SYMBOL(ssb_bus_may_powerdown); 
     244  
     245 int ssb_bus_powerup(struct ssb_bus *bus, bool dynamic_pctl) 
     246 { 
     247-       struct ssb_chipcommon *cc; 
     248        int err; 
     249        enum ssb_clkmode mode; 
     250  
     251        err = ssb_pci_xtal(bus, SSB_GPIO_XTAL | SSB_GPIO_PLL, 1); 
     252        if (err) 
     253                goto error; 
     254-       cc = &bus->chipco; 
     255-       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     256-       ssb_chipco_set_clockmode(cc, mode); 
     257  
     258 #ifdef CONFIG_SSB_DEBUG 
     259        bus->powered_up = 1; 
     260 #endif 
     261+ 
     262+       mode = dynamic_pctl ? SSB_CLKMODE_DYNAMIC : SSB_CLKMODE_FAST; 
     263+       ssb_chipco_set_clockmode(&bus->chipco, mode); 
     264+ 
     265        return 0; 
     266 error: 
     267        ssb_printk(KERN_ERR PFX "Bus powerup failed\n"); 
     268@@ -1282,6 +1333,37 @@ error: 
     269 } 
     270 EXPORT_SYMBOL(ssb_bus_powerup); 
     271  
     272+static void ssb_broadcast_value(struct ssb_device *dev, 
     273+                               u32 address, u32 data) 
     274+{ 
     275+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     276+       /* This is used for both, PCI and ChipCommon core, so be careful. */ 
     277+       BUILD_BUG_ON(SSB_PCICORE_BCAST_ADDR != SSB_CHIPCO_BCAST_ADDR); 
     278+       BUILD_BUG_ON(SSB_PCICORE_BCAST_DATA != SSB_CHIPCO_BCAST_DATA); 
     279+#endif 
     280+ 
     281+       ssb_write32(dev, SSB_CHIPCO_BCAST_ADDR, address); 
     282+       ssb_read32(dev, SSB_CHIPCO_BCAST_ADDR); /* flush */ 
     283+       ssb_write32(dev, SSB_CHIPCO_BCAST_DATA, data); 
     284+       ssb_read32(dev, SSB_CHIPCO_BCAST_DATA); /* flush */ 
     285+} 
     286+ 
     287+void ssb_commit_settings(struct ssb_bus *bus) 
     288+{ 
     289+       struct ssb_device *dev; 
     290+ 
     291+#ifdef CONFIG_SSB_DRIVER_PCICORE 
     292+       dev = bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev; 
     293+#else 
     294+       dev = bus->chipco.dev; 
     295+#endif 
     296+       if (WARN_ON(!dev)) 
     297+               return; 
     298+       /* This forces an update of the cached registers. */ 
     299+       ssb_broadcast_value(dev, 0xFD8, 0); 
     300+} 
     301+EXPORT_SYMBOL(ssb_commit_settings); 
     302+ 
     303 u32 ssb_admatch_base(u32 adm) 
     304 { 
     305        u32 base = 0; 
    118306--- a/drivers/ssb/pci.c 
    119307+++ b/drivers/ssb/pci.c 
     
    257445  
    258446        if (out->boardflags_lo == 0xFFFF) 
    259 @@ -618,7 +663,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     447@@ -617,15 +662,14 @@ static int sprom_extract(struct ssb_bus 
     448 static int ssb_pci_sprom_get(struct ssb_bus *bus, 
    260449                             struct ssb_sprom *sprom) 
    261450 { 
    262         const struct ssb_sprom *fallback; 
     451-       const struct ssb_sprom *fallback; 
    263452-       int err = -ENOMEM; 
    264453+       int err; 
     
    266455  
    267456        if (!ssb_is_sprom_available(bus)) { 
    268 @@ -645,7 +690,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     457                ssb_printk(KERN_ERR PFX "No SPROM available!\n"); 
     458                return -ENODEV; 
     459        } 
     460-       if (bus->chipco.dev) {  /* can be unavailible! */ 
     461+       if (bus->chipco.dev) {  /* can be unavailable! */ 
     462                /* 
     463                 * get SPROM offset: SSB_SPROM_BASE1 except for 
     464                 * chipcommon rev >= 31 or chip ID is 0x4312 and 
     465@@ -645,7 +689,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
    269466  
    270467        buf = kcalloc(SSB_SPROMSIZE_WORDS_R123, sizeof(u16), GFP_KERNEL); 
     
    275472        sprom_do_read(bus, buf); 
    276473        err = sprom_check_crc(buf, bus->sprom_size); 
    277 @@ -655,7 +700,7 @@ static int ssb_pci_sprom_get(struct ssb_ 
     474@@ -655,17 +699,24 @@ static int ssb_pci_sprom_get(struct ssb_ 
    278475                buf = kcalloc(SSB_SPROMSIZE_WORDS_R4, sizeof(u16), 
    279476                              GFP_KERNEL); 
     
    284481                sprom_do_read(bus, buf); 
    285482                err = sprom_check_crc(buf, bus->sprom_size); 
    286 @@ -677,7 +722,6 @@ static int ssb_pci_sprom_get(struct ssb_ 
     483                if (err) { 
     484                        /* All CRC attempts failed. 
     485                         * Maybe there is no SPROM on the device? 
     486-                        * If we have a fallback, use that. */ 
     487-                       fallback = ssb_get_fallback_sprom(); 
     488-                       if (fallback) { 
     489-                               memcpy(sprom, fallback, sizeof(*sprom)); 
     490+                        * Now we ask the arch code if there is some sprom 
     491+                        * available for this device in some other storage */ 
     492+                       err = ssb_fill_sprom_with_fallback(bus, sprom); 
     493+                       if (err) { 
     494+                               ssb_printk(KERN_WARNING PFX "WARNING: Using" 
     495+                                          " fallback SPROM failed (err %d)\n", 
     496+                                          err); 
     497+                       } else { 
     498+                               ssb_dprintk(KERN_DEBUG PFX "Using SPROM" 
     499+                                           " revision %d provided by" 
     500+                                           " platform.\n", sprom->revision); 
     501                                err = 0; 
     502                                goto out_free; 
     503                        } 
     504@@ -677,19 +728,15 @@ static int ssb_pci_sprom_get(struct ssb_ 
    287505  
    288506 out_free: 
     
    292510 } 
    293511  
     512 static void ssb_pci_get_boardinfo(struct ssb_bus *bus, 
     513                                  struct ssb_boardinfo *bi) 
     514 { 
     515-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_VENDOR_ID, 
     516-                            &bi->vendor); 
     517-       pci_read_config_word(bus->host_pci, PCI_SUBSYSTEM_ID, 
     518-                            &bi->type); 
     519-       pci_read_config_word(bus->host_pci, PCI_REVISION_ID, 
     520-                            &bi->rev); 
     521+       bi->vendor = bus->host_pci->subsystem_vendor; 
     522+       bi->type = bus->host_pci->subsystem_device; 
     523+       bi->rev = bus->host_pci->revision; 
     524 } 
     525  
     526 int ssb_pci_get_invariants(struct ssb_bus *bus, 
    294527--- a/drivers/ssb/pcihost_wrapper.c 
    295528+++ b/drivers/ssb/pcihost_wrapper.c 
    296 @@ -59,6 +59,7 @@ static int ssb_pcihost_probe(struct pci_ 
     529@@ -53,12 +53,13 @@ static int ssb_pcihost_resume(struct pci 
     530 # define ssb_pcihost_resume    NULL 
     531 #endif /* CONFIG_PM */ 
     532  
     533-static int ssb_pcihost_probe(struct pci_dev *dev, 
     534-                            const struct pci_device_id *id) 
     535+static int __devinit ssb_pcihost_probe(struct pci_dev *dev, 
     536+                                      const struct pci_device_id *id) 
     537 { 
    297538        struct ssb_bus *ssb; 
    298539        int err = -ENOMEM; 
     
    315556        if (err) 
    316557                goto err_pci_release_regions; 
     558@@ -103,7 +110,7 @@ static void ssb_pcihost_remove(struct pc 
     559        pci_set_drvdata(dev, NULL); 
     560 } 
     561  
     562-int ssb_pcihost_register(struct pci_driver *driver) 
     563+int __devinit ssb_pcihost_register(struct pci_driver *driver) 
     564 { 
     565        driver->probe = ssb_pcihost_probe; 
     566        driver->remove = ssb_pcihost_remove; 
    317567--- a/drivers/ssb/scan.c 
    318568+++ b/drivers/ssb/scan.c 
    319 @@ -405,10 +405,10 @@ int ssb_bus_scan(struct ssb_bus *bus, 
     569@@ -258,7 +258,10 @@ static int we_support_multiple_80211_cor 
     570 #ifdef CONFIG_SSB_PCIHOST 
     571        if (bus->bustype == SSB_BUSTYPE_PCI) { 
     572                if (bus->host_pci->vendor == PCI_VENDOR_ID_BROADCOM && 
     573-                   bus->host_pci->device == 0x4324) 
     574+                   ((bus->host_pci->device == 0x4313) || 
     575+                    (bus->host_pci->device == 0x431A) || 
     576+                    (bus->host_pci->device == 0x4321) || 
     577+                  &n