1 files changed, 194 insertions, 170 deletions

diff --git a/drivers/net/wireless/b43/main.c b/drivers/net/wireless/b43/main.c
index 20631ae2ddd7..eb4159686985 100644
--- a/drivers/net/wireless/b43/main.c
+++ b/drivers/net/wireless/b43/main.c
@@ -72,6 +72,7 @@ MODULE_FIRMWARE("b43/ucode11.fw");
 MODULE_FIRMWARE("b43/ucode13.fw");
 MODULE_FIRMWARE("b43/ucode14.fw");
 MODULE_FIRMWARE("b43/ucode15.fw");
+MODULE_FIRMWARE("b43/ucode16_mimo.fw");
 MODULE_FIRMWARE("b43/ucode5.fw");
 MODULE_FIRMWARE("b43/ucode9.fw");
 
@@ -322,59 +323,83 @@ static int b43_ratelimit(struct b43_wl *wl)
 
 void b43info(struct b43_wl *wl, const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         if (b43_modparam_verbose < B43_VERBOSITY_INFO)
                 return;
         if (!b43_ratelimit(wl))
                 return;
+
         va_start(args, fmt);
-        printk(KERN_INFO "b43-%s: ",
-               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan");
-        vprintk(fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        printk(KERN_INFO "b43-%s: %pV",
+               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
+
         va_end(args);
 }
 
 void b43err(struct b43_wl *wl, const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         if (b43_modparam_verbose < B43_VERBOSITY_ERROR)
                 return;
         if (!b43_ratelimit(wl))
                 return;
+
         va_start(args, fmt);
-        printk(KERN_ERR "b43-%s ERROR: ",
-               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan");
-        vprintk(fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        printk(KERN_ERR "b43-%s ERROR: %pV",
+               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
+
         va_end(args);
 }
 
 void b43warn(struct b43_wl *wl, const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         if (b43_modparam_verbose < B43_VERBOSITY_WARN)
                 return;
         if (!b43_ratelimit(wl))
                 return;
+
         va_start(args, fmt);
-        printk(KERN_WARNING "b43-%s warning: ",
-               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan");
-        vprintk(fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        printk(KERN_WARNING "b43-%s warning: %pV",
+               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
+
         va_end(args);
 }
 
 void b43dbg(struct b43_wl *wl, const char *fmt, ...)
 {
+        struct va_format vaf;
         va_list args;
 
         if (b43_modparam_verbose < B43_VERBOSITY_DEBUG)
                 return;
+
         va_start(args, fmt);
-        printk(KERN_DEBUG "b43-%s debug: ",
-               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan");
-        vprintk(fmt, args);
+
+        vaf.fmt = fmt;
+        vaf.va = &args;
+
+        printk(KERN_DEBUG "b43-%s debug: %pV",
+               (wl && wl->hw) ? wiphy_name(wl->hw->wiphy) : "wlan", &vaf);
+
         va_end(args);
 }
 
@@ -523,7 +548,7 @@ void b43_tsf_read(struct b43_wldev *dev, u64 *tsf)
 {
         u32 low, high;
 
-        B43_WARN_ON(dev->dev->id.revision < 3);
+        B43_WARN_ON(dev->sdev->id.revision < 3);
 
         /* The hardware guarantees us an atomic read, if we
          * read the low register first. */
@@ -561,7 +586,7 @@ static void b43_tsf_write_locked(struct b43_wldev *dev, u64 tsf)
 {
         u32 low, high;
 
-        B43_WARN_ON(dev->dev->id.revision < 3);
+        B43_WARN_ON(dev->sdev->id.revision < 3);
 
         low = tsf;
         high = (tsf >> 32);
@@ -689,7 +714,7 @@ void b43_dummy_transmission(struct b43_wldev *dev, bool ofdm, bool pa_on)
                 b43_ram_write(dev, i * 4, buffer[i]);
 
         b43_write16(dev, 0x0568, 0x0000);
-        if (dev->dev->id.revision < 11)
+        if (dev->sdev->id.revision < 11)
                 b43_write16(dev, 0x07C0, 0x0000);
         else
                 b43_write16(dev, 0x07C0, 0x0100);
@@ -1107,7 +1132,7 @@ void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags)
         b43_write32(dev, B43_MMIO_MACCTL, macctl);
         /* Commit write */
         b43_read32(dev, B43_MMIO_MACCTL);
-        if (awake && dev->dev->id.revision >= 5) {
+        if (awake && dev->sdev->id.revision >= 5) {
                 /* Wait for the microcode to wake up. */
                 for (i = 0; i < 100; i++) {
                         ucstat = b43_shm_read16(dev, B43_SHM_SHARED,
@@ -1119,27 +1144,35 @@ void b43_power_saving_ctl_bits(struct b43_wldev *dev, unsigned int ps_flags)
         }
 }
 
-void b43_wireless_core_reset(struct b43_wldev *dev, u32 flags)
+static void b43_ssb_wireless_core_reset(struct b43_wldev *dev, u32 flags)
 {
         u32 tmslow;
-        u32 macctl;
 
         flags |= B43_TMSLOW_PHYCLKEN;
         flags |= B43_TMSLOW_PHYRESET;
-        ssb_device_enable(dev->dev, flags);
+        if (dev->phy.type == B43_PHYTYPE_N)
+                flags |= B43_TMSLOW_PHY_BANDWIDTH_20MHZ; /* Make 20 MHz def */
+        ssb_device_enable(dev->sdev, flags);
         msleep(2);              /* Wait for the PLL to turn on. */
 
         /* Now take the PHY out of Reset again */
-        tmslow = ssb_read32(dev->dev, SSB_TMSLOW);
+        tmslow = ssb_read32(dev->sdev, SSB_TMSLOW);
         tmslow |= SSB_TMSLOW_FGC;
         tmslow &= ~B43_TMSLOW_PHYRESET;
-        ssb_write32(dev->dev, SSB_TMSLOW, tmslow);
-        ssb_read32(dev->dev, SSB_TMSLOW);       /* flush */
+        ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);
+        ssb_read32(dev->sdev, SSB_TMSLOW);      /* flush */
         msleep(1);
         tmslow &= ~SSB_TMSLOW_FGC;
-        ssb_write32(dev->dev, SSB_TMSLOW, tmslow);
-        ssb_read32(dev->dev, SSB_TMSLOW);       /* flush */
+        ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);
+        ssb_read32(dev->sdev, SSB_TMSLOW);      /* flush */
         msleep(1);
+}
+
+void b43_wireless_core_reset(struct b43_wldev *dev, u32 flags)
+{
+        u32 macctl;
+
+        b43_ssb_wireless_core_reset(dev, flags);
 
         /* Turn Analog ON, but only if we already know the PHY-type.
          * This protects against very early setup where we don't know the
@@ -1188,7 +1221,7 @@ static void drain_txstatus_queue(struct b43_wldev *dev)
 {
         u32 dummy;
 
-        if (dev->dev->id.revision < 5)
+        if (dev->sdev->id.revision < 5)
                 return;
         /* Read all entries from the microcode TXstatus FIFO
          * and throw them away.
@@ -1394,9 +1427,9 @@ u8 b43_ieee80211_antenna_sanitize(struct b43_wldev *dev,
 
         /* Get the mask of available antennas. */
         if (dev->phy.gmode)
-                antenna_mask = dev->dev->bus->sprom.ant_available_bg;
+                antenna_mask = dev->sdev->bus->sprom.ant_available_bg;
         else
-                antenna_mask = dev->dev->bus->sprom.ant_available_a;
+                antenna_mask = dev->sdev->bus->sprom.ant_available_a;
 
         if (!(antenna_mask & (1 << (antenna_nr - 1)))) {
                 /* This antenna is not available. Fall back to default. */
@@ -1611,7 +1644,7 @@ static void b43_beacon_update_trigger_work(struct work_struct *work)
         mutex_lock(&wl->mutex);
         dev = wl->current_dev;
         if (likely(dev && (b43_status(dev) >= B43_STAT_INITIALIZED))) {
-                if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {
+                if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {
                         /* wl->mutex is enough. */
                         b43_do_beacon_update_trigger_work(dev);
                         mmiowb();
@@ -1656,7 +1689,7 @@ static void b43_update_templates(struct b43_wl *wl)
 static void b43_set_beacon_int(struct b43_wldev *dev, u16 beacon_int)
 {
         b43_time_lock(dev);
-        if (dev->dev->id.revision >= 3) {
+        if (dev->sdev->id.revision >= 3) {
                 b43_write32(dev, B43_MMIO_TSF_CFP_REP, (beacon_int << 16));
                 b43_write32(dev, B43_MMIO_TSF_CFP_START, (beacon_int << 10));
         } else {
@@ -2030,7 +2063,7 @@ int b43_do_request_fw(struct b43_request_fw_context *ctx,
                 B43_WARN_ON(1);
                 return -ENOSYS;
         }
-        err = request_firmware(&blob, ctx->fwname, ctx->dev->dev->dev);
+        err = request_firmware(&blob, ctx->fwname, ctx->dev->sdev->dev);
         if (err == -ENOENT) {
                 snprintf(ctx->errors[ctx->req_type],
                          sizeof(ctx->errors[ctx->req_type]),
@@ -2080,13 +2113,12 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
 {
         struct b43_wldev *dev = ctx->dev;
         struct b43_firmware *fw = &ctx->dev->fw;
-        const u8 rev = ctx->dev->dev->id.revision;
+        const u8 rev = ctx->dev->sdev->id.revision;
         const char *filename;
         u32 tmshigh;
         int err;
 
         /* Get microcode */
-        tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH);
         if ((rev >= 5) && (rev <= 10))
                 filename = "ucode5";
         else if ((rev >= 11) && (rev <= 12))
@@ -2095,8 +2127,10 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
                 filename = "ucode13";
         else if (rev == 14)
                 filename = "ucode14";
-        else if (rev >= 15)
+        else if (rev == 15)
                 filename = "ucode15";
+        else if ((rev >= 16) && (rev <= 20))
+                filename = "ucode16_mimo";
         else
                 goto err_no_ucode;
         err = b43_do_request_fw(ctx, filename, &fw->ucode);
@@ -2123,6 +2157,7 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
         switch (dev->phy.type) {
         case B43_PHYTYPE_A:
                 if ((rev >= 5) && (rev <= 10)) {
+                        tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH);
                         if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
                                 filename = "a0g1initvals5";
                         else
@@ -2139,7 +2174,9 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
                         goto err_no_initvals;
                 break;
         case B43_PHYTYPE_N:
-                if ((rev >= 11) && (rev <= 12))
+                if (rev >= 16)
+                        filename = "n0initvals16";
+                else if ((rev >= 11) && (rev <= 12))
                         filename = "n0initvals11";
                 else
                         goto err_no_initvals;
@@ -2165,6 +2202,7 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
         switch (dev->phy.type) {
         case B43_PHYTYPE_A:
                 if ((rev >= 5) && (rev <= 10)) {
+                        tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH);
                         if (tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY)
                                 filename = "a0g1bsinitvals5";
                         else
@@ -2183,7 +2221,9 @@ static int b43_try_request_fw(struct b43_request_fw_context *ctx)
                         goto err_no_initvals;
                 break;
         case B43_PHYTYPE_N:
-                if ((rev >= 11) && (rev <= 12))
+                if (rev >= 16)
+                        filename = "n0bsinitvals16";
+                else if ((rev >= 11) && (rev <= 12))
                         filename = "n0bsinitvals11";
                 else
                         goto err_no_initvals;
@@ -2280,6 +2320,7 @@ out:
 
 static int b43_upload_microcode(struct b43_wldev *dev)
 {
+        struct wiphy *wiphy = dev->wl->hw->wiphy;
         const size_t hdr_len = sizeof(struct b43_fw_header);
         const __be32 *data;
         unsigned int i, len;
@@ -2405,6 +2446,10 @@ static int b43_upload_microcode(struct b43_wldev *dev)
                 }
         }
 
+        snprintf(wiphy->fw_version, sizeof(wiphy->fw_version), "%u.%u",
+                        dev->fw.rev, dev->fw.patch);
+        wiphy->hw_version = dev->sdev->id.coreid;
+
         if (b43_is_old_txhdr_format(dev)) {
                 /* We're over the deadline, but we keep support for old fw
                  * until it turns out to be in major conflict with something new. */
@@ -2519,10 +2564,20 @@ out:
 /* Initialize the GPIOs
  * http://bcm-specs.sipsolutions.net/GPIO
  */
+static struct ssb_device *b43_ssb_gpio_dev(struct b43_wldev *dev)
+{
+        struct ssb_bus *bus = dev->sdev->bus;
+
+#ifdef CONFIG_SSB_DRIVER_PCICORE
+        return (bus->chipco.dev ? bus->chipco.dev : bus->pcicore.dev);
+#else
+        return bus->chipco.dev;
+#endif
+}
+
 static int b43_gpio_init(struct b43_wldev *dev)
 {
-        struct ssb_bus *bus = dev->dev->bus;
-        struct ssb_device *gpiodev, *pcidev = NULL;
+        struct ssb_device *gpiodev;
         u32 mask, set;
 
         b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
@@ -2533,7 +2588,7 @@ static int b43_gpio_init(struct b43_wldev *dev)
 
         mask = 0x0000001F;
         set = 0x0000000F;
-        if (dev->dev->bus->chip_id == 0x4301) {
+        if (dev->sdev->bus->chip_id == 0x4301) {
                 mask |= 0x0060;
                 set |= 0x0060;
         }
@@ -2544,25 +2599,21 @@ static int b43_gpio_init(struct b43_wldev *dev)
                 mask |= 0x0180;
                 set |= 0x0180;
         }
-        if (dev->dev->bus->sprom.boardflags_lo & B43_BFL_PACTRL) {
+        if (dev->sdev->bus->sprom.boardflags_lo & B43_BFL_PACTRL) {
                 b43_write16(dev, B43_MMIO_GPIO_MASK,
                             b43_read16(dev, B43_MMIO_GPIO_MASK)
                             | 0x0200);
                 mask |= 0x0200;
                 set |= 0x0200;
         }
-        if (dev->dev->id.revision >= 2)
+        if (dev->sdev->id.revision >= 2)
                 mask |= 0x0010; /* FIXME: This is redundant. */
 
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-        pcidev = bus->pcicore.dev;
-#endif
-        gpiodev = bus->chipco.dev ? : pcidev;
-        if (!gpiodev)
-                return 0;
-        ssb_write32(gpiodev, B43_GPIO_CONTROL,
-                    (ssb_read32(gpiodev, B43_GPIO_CONTROL)
-                     & mask) | set);
+        gpiodev = b43_ssb_gpio_dev(dev);
+        if (gpiodev)
+                ssb_write32(gpiodev, B43_GPIO_CONTROL,
+                            (ssb_read32(gpiodev, B43_GPIO_CONTROL)
+                             & mask) | set);
 
         return 0;
 }
@@ -2570,16 +2621,11 @@ static int b43_gpio_init(struct b43_wldev *dev)
 /* Turn off all GPIO stuff. Call this on module unload, for example. */
 static void b43_gpio_cleanup(struct b43_wldev *dev)
 {
-        struct ssb_bus *bus = dev->dev->bus;
-        struct ssb_device *gpiodev, *pcidev = NULL;
+        struct ssb_device *gpiodev;
 
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-        pcidev = bus->pcicore.dev;
-#endif
-        gpiodev = bus->chipco.dev ? : pcidev;
-        if (!gpiodev)
-                return;
-        ssb_write32(gpiodev, B43_GPIO_CONTROL, 0);
+        gpiodev = b43_ssb_gpio_dev(dev);
+        if (gpiodev)
+                ssb_write32(gpiodev, B43_GPIO_CONTROL, 0);
 }
 
 /* http://bcm-specs.sipsolutions.net/EnableMac */
@@ -2648,6 +2694,17 @@ out:
         dev->mac_suspended++;
 }
 
+/* http://bcm-v4.sipsolutions.net/802.11/PHY/N/MacPhyClkSet */
+void b43_mac_phy_clock_set(struct b43_wldev *dev, bool on)
+{
+        u32 tmslow = ssb_read32(dev->sdev, SSB_TMSLOW);
+        if (on)
+                tmslow |= B43_TMSLOW_MACPHYCLKEN;
+        else
+                tmslow &= ~B43_TMSLOW_MACPHYCLKEN;
+        ssb_write32(dev->sdev, SSB_TMSLOW, tmslow);
+}
+
 static void b43_adjust_opmode(struct b43_wldev *dev)
 {
         struct b43_wl *wl = dev->wl;
@@ -2684,15 +2741,15 @@ static void b43_adjust_opmode(struct b43_wldev *dev)
         /* Workaround: On old hardware the HW-MAC-address-filter
          * doesn't work properly, so always run promisc in filter
          * it in software. */
-        if (dev->dev->id.revision <= 4)
+        if (dev->sdev->id.revision <= 4)
                 ctl |= B43_MACCTL_PROMISC;
 
         b43_write32(dev, B43_MMIO_MACCTL, ctl);
 
         cfp_pretbtt = 2;
         if ((ctl & B43_MACCTL_INFRA) && !(ctl & B43_MACCTL_AP)) {
-                if (dev->dev->bus->chip_id == 0x4306 &&
-                    dev->dev->bus->chip_rev == 3)
+                if (dev->sdev->bus->chip_id == 0x4306 &&
+                    dev->sdev->bus->chip_rev == 3)
                         cfp_pretbtt = 100;
                 else
                         cfp_pretbtt = 50;
@@ -2804,7 +2861,7 @@ static int b43_chip_init(struct b43_wldev *dev)
 {
         struct b43_phy *phy = &dev->phy;
         int err;
-        u32 value32, macctl;
+        u32 macctl;
         u16 value16;
 
         /* Initialize the MAC control */
@@ -2850,7 +2907,7 @@ static int b43_chip_init(struct b43_wldev *dev)
                 b43_write16(dev, 0x005E, value16);
         }
         b43_write32(dev, 0x0100, 0x01000000);
-        if (dev->dev->id.revision < 5)
+        if (dev->sdev->id.revision < 5)
                 b43_write32(dev, 0x010C, 0x01000000);
 
         b43_write32(dev, B43_MMIO_MACCTL, b43_read32(dev, B43_MMIO_MACCTL)
@@ -2865,7 +2922,7 @@ static int b43_chip_init(struct b43_wldev *dev)
         /* Initially set the wireless operation mode. */
         b43_adjust_opmode(dev);
 
-        if (dev->dev->id.revision < 3) {
+        if (dev->sdev->id.revision < 3) {
                 b43_write16(dev, 0x060E, 0x0000);
                 b43_write16(dev, 0x0610, 0x8000);
                 b43_write16(dev, 0x0604, 0x0000);
@@ -2882,12 +2939,10 @@ static int b43_chip_init(struct b43_wldev *dev)
         b43_write32(dev, B43_MMIO_DMA4_IRQ_MASK, 0x0000DC00);
         b43_write32(dev, B43_MMIO_DMA5_IRQ_MASK, 0x0000DC00);
 
-        value32 = ssb_read32(dev->dev, SSB_TMSLOW);
-        value32 |= 0x00100000;
-        ssb_write32(dev->dev, SSB_TMSLOW, value32);
+        b43_mac_phy_clock_set(dev, true);
 
         b43_write16(dev, B43_MMIO_POWERUP_DELAY,
-                    dev->dev->bus->chipco.fast_pwrup_delay);
+                    dev->sdev->bus->chipco.fast_pwrup_delay);
 
         err = 0;
         b43dbg(dev->wl, "Chip initialized\n");
@@ -3050,7 +3105,7 @@ static int b43_validate_chipaccess(struct b43_wldev *dev)
         b43_shm_write32(dev, B43_SHM_SHARED, 0, backup0);
         b43_shm_write32(dev, B43_SHM_SHARED, 4, backup4);
 
-        if ((dev->dev->id.revision >= 3) && (dev->dev->id.revision <= 10)) {
+        if ((dev->sdev->id.revision >= 3) && (dev->sdev->id.revision <= 10)) {
                 /* The 32bit register shadows the two 16bit registers
                  * with update sideeffects. Validate this. */
                 b43_write16(dev, B43_MMIO_TSF_CFP_START, 0xAAAA);
@@ -3166,7 +3221,7 @@ static void b43_tx_work(struct work_struct *work)
         mutex_unlock(&wl->mutex);
 }
 
-static int b43_op_tx(struct ieee80211_hw *hw,
+static void b43_op_tx(struct ieee80211_hw *hw,
                      struct sk_buff *skb)
 {
         struct b43_wl *wl = hw_to_b43_wl(hw);
@@ -3174,14 +3229,12 @@ static int b43_op_tx(struct ieee80211_hw *hw,
         if (unlikely(skb->len < 2 + 2 + 6)) {
                 /* Too short, this can't be a valid frame. */
                 dev_kfree_skb_any(skb);
-                return NETDEV_TX_OK;
+                return;
         }
         B43_WARN_ON(skb_shinfo(skb)->nr_frags);
 
         skb_queue_tail(&wl->tx_queue, skb);
         ieee80211_queue_work(wl->hw, &wl->tx_work);
-
-        return NETDEV_TX_OK;
 }
 
 static void b43_qos_params_upload(struct b43_wldev *dev,
@@ -3405,7 +3458,7 @@ static void b43_op_set_tsf(struct ieee80211_hw *hw, u64 tsf)
 
 static void b43_put_phy_into_reset(struct b43_wldev *dev)
 {
-        struct ssb_device *sdev = dev->dev;
+        struct ssb_device *sdev = dev->sdev;
         u32 tmslow;
 
         tmslow = ssb_read32(sdev, SSB_TMSLOW);
@@ -3754,17 +3807,17 @@ static int b43_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
         }
 
         err = -EINVAL;
-        switch (key->alg) {
-        case ALG_WEP:
-                if (key->keylen == WLAN_KEY_LEN_WEP40)
-                        algorithm = B43_SEC_ALGO_WEP40;
-                else
-                        algorithm = B43_SEC_ALGO_WEP104;
+        switch (key->cipher) {
+        case WLAN_CIPHER_SUITE_WEP40:
+                algorithm = B43_SEC_ALGO_WEP40;
+                break;
+        case WLAN_CIPHER_SUITE_WEP104:
+                algorithm = B43_SEC_ALGO_WEP104;
                 break;
-        case ALG_TKIP:
+        case WLAN_CIPHER_SUITE_TKIP:
                 algorithm = B43_SEC_ALGO_TKIP;
                 break;
-        case ALG_CCMP:
+        case WLAN_CIPHER_SUITE_CCMP:
                 algorithm = B43_SEC_ALGO_AES;
                 break;
         default:
@@ -3901,7 +3954,7 @@ redo:
 
         /* Disable interrupts on the device. */
         b43_set_status(dev, B43_STAT_INITIALIZED);
-        if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {
+        if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {
                 /* wl->mutex is locked. That is enough. */
                 b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, 0);
                 b43_read32(dev, B43_MMIO_GEN_IRQ_MASK); /* Flush */
@@ -3914,11 +3967,11 @@ redo:
         /* Synchronize and free the interrupt handlers. Unlock to avoid deadlocks. */
         orig_dev = dev;
         mutex_unlock(&wl->mutex);
-        if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {
+        if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {
                 b43_sdio_free_irq(dev);
         } else {
-                synchronize_irq(dev->dev->irq);
-                free_irq(dev->dev->irq, dev);
+                synchronize_irq(dev->sdev->irq);
+                free_irq(dev->sdev->irq, dev);
         }
         mutex_lock(&wl->mutex);
         dev = wl->current_dev;
@@ -3951,18 +4004,19 @@ static int b43_wireless_core_start(struct b43_wldev *dev)
         B43_WARN_ON(b43_status(dev) != B43_STAT_INITIALIZED);
 
         drain_txstatus_queue(dev);
-        if (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) {
+        if (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) {
                 err = b43_sdio_request_irq(dev, b43_sdio_interrupt_handler);
                 if (err) {
                         b43err(dev->wl, "Cannot request SDIO IRQ\n");
                         goto out;
                 }
         } else {
-                err = request_threaded_irq(dev->dev->irq, b43_interrupt_handler,
+                err = request_threaded_irq(dev->sdev->irq, b43_interrupt_handler,
                                            b43_interrupt_thread_handler,
                                            IRQF_SHARED, KBUILD_MODNAME, dev);
                 if (err) {
-                        b43err(dev->wl, "Cannot request IRQ-%d\n", dev->dev->irq);
+                        b43err(dev->wl, "Cannot request IRQ-%d\n",
+                               dev->sdev->irq);
                         goto out;
                 }
         }
@@ -3975,7 +4029,7 @@ static int b43_wireless_core_start(struct b43_wldev *dev)
         b43_mac_enable(dev);
         b43_write32(dev, B43_MMIO_GEN_IRQ_MASK, dev->irq_mask);
 
-        /* Start maintainance work */
+        /* Start maintenance work */
         b43_periodic_tasks_setup(dev);
 
         b43_leds_init(dev);
@@ -4017,9 +4071,9 @@ static int b43_phy_versioning(struct b43_wldev *dev)
                 if (phy_rev > 9)
                         unsupported = 1;
                 break;
-#ifdef CONFIG_B43_NPHY
+#ifdef CONFIG_B43_PHY_N
         case B43_PHYTYPE_N:
-                if (phy_rev > 4)
+                if (phy_rev > 9)
                         unsupported = 1;
                 break;
 #endif
@@ -4042,10 +4096,10 @@ static int b43_phy_versioning(struct b43_wldev *dev)
                analog_type, phy_type, phy_rev);
 
         /* Get RADIO versioning */
-        if (dev->dev->bus->chip_id == 0x4317) {
-                if (dev->dev->bus->chip_rev == 0)
+        if (dev->sdev->bus->chip_id == 0x4317) {
+                if (dev->sdev->bus->chip_rev == 0)
                         tmp = 0x3205017F;
-                else if (dev->dev->bus->chip_rev == 1)
+                else if (dev->sdev->bus->chip_rev == 1)
                         tmp = 0x4205017F;
                 else
                         tmp = 0x5205017F;
@@ -4150,7 +4204,7 @@ static void setup_struct_wldev_for_init(struct b43_wldev *dev)
 
 static void b43_bluetooth_coext_enable(struct b43_wldev *dev)
 {
-        struct ssb_sprom *sprom = &dev->dev->bus->sprom;
+        struct ssb_sprom *sprom = &dev->sdev->bus->sprom;
         u64 hf;
 
         if (!modparam_btcoex)
@@ -4177,33 +4231,18 @@ static void b43_bluetooth_coext_disable(struct b43_wldev *dev)
 
 static void b43_imcfglo_timeouts_workaround(struct b43_wldev *dev)
 {
-#ifdef CONFIG_SSB_DRIVER_PCICORE
-        struct ssb_bus *bus = dev->dev->bus;
+        struct ssb_bus *bus = dev->sdev->bus;
         u32 tmp;
 
-        if (bus->pcicore.dev &&
-            bus->pcicore.dev->id.coreid == SSB_DEV_PCI &&
-            bus->pcicore.dev->id.revision <= 5) {
-                /* IMCFGLO timeouts workaround. */
-                tmp = ssb_read32(dev->dev, SSB_IMCFGLO);
-                switch (bus->bustype) {
-                case SSB_BUSTYPE_PCI:
-                case SSB_BUSTYPE_PCMCIA:
-                        tmp &= ~SSB_IMCFGLO_REQTO;
-                        tmp &= ~SSB_IMCFGLO_SERTO;
-                        tmp |= 0x32;
-                        break;
-                case SSB_BUSTYPE_SSB:
-                        tmp &= ~SSB_IMCFGLO_REQTO;
-                        tmp &= ~SSB_IMCFGLO_SERTO;
-                        tmp |= 0x53;
-                        break;
-                default:
-                        break;
-                }
-                ssb_write32(dev->dev, SSB_IMCFGLO, tmp);
+        if ((bus->chip_id == 0x4311 && bus->chip_rev == 2) ||
+            (bus->chip_id == 0x4312)) {
+                tmp = ssb_read32(dev->sdev, SSB_IMCFGLO);
+                tmp &= ~SSB_IMCFGLO_REQTO;
+                tmp &= ~SSB_IMCFGLO_SERTO;
+                tmp |= 0x3;
+                ssb_write32(dev->sdev, SSB_IMCFGLO, tmp);
+                ssb_commit_settings(bus);
         }
-#endif /* CONFIG_SSB_DRIVER_PCICORE */
 }
 
 static void b43_set_synth_pu_delay(struct b43_wldev *dev, bool idle)
@@ -4250,6 +4289,10 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
         B43_WARN_ON(dev && b43_status(dev) > B43_STAT_INITIALIZED);
         if (!dev || b43_status(dev) != B43_STAT_INITIALIZED)
                 return;
+
+        /* Unregister HW RNG driver */
+        b43_rng_exit(dev->wl);
+
         b43_set_status(dev, B43_STAT_UNINIT);
 
         /* Stop the microcode PSM. */
@@ -4267,14 +4310,14 @@ static void b43_wireless_core_exit(struct b43_wldev *dev)
                 dev->wl->current_beacon = NULL;
         }
 
-        ssb_device_disable(dev->dev, 0);
-        ssb_bus_may_powerdown(dev->dev->bus);
+        ssb_device_disable(dev->sdev, 0);
+        ssb_bus_may_powerdown(dev->sdev->bus);
 }
 
 /* Initialize a wireless core */
 static int b43_wireless_core_init(struct b43_wldev *dev)
 {
-        struct ssb_bus *bus = dev->dev->bus;
+        struct ssb_bus *bus = dev->sdev->bus;
         struct ssb_sprom *sprom = &bus->sprom;
         struct b43_phy *phy = &dev->phy;
         int err;
@@ -4286,7 +4329,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
         err = ssb_bus_powerup(bus, 0);
         if (err)
                 goto out;
-        if (!ssb_device_is_enabled(dev->dev)) {
+        if (!ssb_device_is_enabled(dev->sdev)) {
                 tmp = phy->gmode ? B43_TMSLOW_GMODE : 0;
                 b43_wireless_core_reset(dev, tmp);
         }
@@ -4296,7 +4339,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
         phy->ops->prepare_structs(dev);
 
         /* Enable IRQ routing to this device. */
-        ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->dev);
+        ssb_pcicore_dev_irqvecs_enable(&bus->pcicore, dev->sdev);
 
         b43_imcfglo_timeouts_workaround(dev);
         b43_bluetooth_coext_disable(dev);
@@ -4309,7 +4352,7 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
         if (err)
                 goto err_busdown;
         b43_shm_write16(dev, B43_SHM_SHARED,
-                        B43_SHM_SH_WLCOREREV, dev->dev->id.revision);
+                        B43_SHM_SH_WLCOREREV, dev->sdev->id.revision);
         hf = b43_hf_read(dev);
         if (phy->type == B43_PHYTYPE_G) {
                 hf |= B43_HF_SYMW;
@@ -4356,8 +4399,8 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
         /* Maximum Contention Window */
         b43_shm_write16(dev, B43_SHM_SCRATCH, B43_SHM_SC_MAXCONT, 0x3FF);
 
-        if ((dev->dev->bus->bustype == SSB_BUSTYPE_PCMCIA) ||
-            (dev->dev->bus->bustype == SSB_BUSTYPE_SDIO) ||
+        if ((dev->sdev->bus->bustype == SSB_BUSTYPE_PCMCIA) ||
+            (dev->sdev->bus->bustype == SSB_BUSTYPE_SDIO) ||
             dev->use_pio) {
                 dev->__using_pio_transfers = 1;
                 err = b43_pio_init(dev);
@@ -4379,6 +4422,9 @@ static int b43_wireless_core_init(struct b43_wldev *dev)
 
         b43_set_status(dev, B43_STAT_INITIALIZED);
 
+        /* Register HW RNG driver */
+        b43_rng_init(dev->wl);
+
 out:
         return err;
 
@@ -4691,7 +4737,7 @@ static void b43_wireless_core_detach(struct b43_wldev *dev)
 static int b43_wireless_core_attach(struct b43_wldev *dev)
 {
         struct b43_wl *wl = dev->wl;
-        struct ssb_bus *bus = dev->dev->bus;
+        struct ssb_bus *bus = dev->sdev->bus;
         struct pci_dev *pdev = (bus->bustype == SSB_BUSTYPE_PCI) ? bus->host_pci : NULL;
         int err;
         bool have_2ghz_phy = 0, have_5ghz_phy = 0;
@@ -4710,10 +4756,10 @@ static int b43_wireless_core_attach(struct b43_wldev *dev)
                 goto out;
         }
         /* Get the PHY type. */
-        if (dev->dev->id.revision >= 5) {
+        if (dev->sdev->id.revision >= 5) {
                 u32 tmshigh;
 
-                tmshigh = ssb_read32(dev->dev, SSB_TMSHIGH);
+                tmshigh = ssb_read32(dev->sdev, SSB_TMSHIGH);
                 have_2ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_2GHZ_PHY);
                 have_5ghz_phy = !!(tmshigh & B43_TMSHIGH_HAVE_5GHZ_PHY);
         } else
@@ -4786,7 +4832,7 @@ static int b43_wireless_core_attach(struct b43_wldev *dev)
         INIT_WORK(&dev->restart_work, b43_chip_reset);
 
         dev->phy.ops->switch_analog(dev, 0);
-        ssb_device_disable(dev->dev, 0);
+        ssb_device_disable(dev->sdev, 0);
         ssb_bus_may_powerdown(bus);
 
 out:
@@ -4820,31 +4866,14 @@ static void b43_one_core_detach(struct ssb_device *dev)
 static int b43_one_core_attach(struct ssb_device *dev, struct b43_wl *wl)
 {
         struct b43_wldev *wldev;
-        struct pci_dev *pdev;
         int err = -ENOMEM;
 
-        if (!list_empty(&wl->devlist)) {
-                /* We are not the first core on this chip. */
-                pdev = (dev->bus->bustype == SSB_BUSTYPE_PCI) ? dev->bus->host_pci : NULL;
-                /* Only special chips support more than one wireless
-                 * core, although some of the other chips have more than
-                 * one wireless core as well. Check for this and
-                 * bail out early.
-                 */
-                if (!pdev ||
-                    ((pdev->device != 0x4321) &&
-                     (pdev->device != 0x4313) && (pdev->device != 0x431A))) {
-                        b43dbg(wl, "Ignoring unconnected 802.11 core\n");
-                        return -ENODEV;
-                }
-        }
-
         wldev = kzalloc(sizeof(*wldev), GFP_KERNEL);
         if (!wldev)
                 goto out;
 
         wldev->use_pio = b43_modparam_pio;
-        wldev->dev = dev;
+        wldev->sdev = dev;
         wldev->wl = wl;
         b43_set_status(wldev, B43_STAT_UNINIT);
         wldev->bad_frames_preempt = modparam_bad_frames_preempt;
@@ -4905,19 +4934,16 @@ static void b43_wireless_exit(struct ssb_device *dev, struct b43_wl *wl)
         ieee80211_free_hw(hw);
 }
 
-static int b43_wireless_init(struct ssb_device *dev)
+static struct b43_wl *b43_wireless_init(struct ssb_device *dev)
 {
         struct ssb_sprom *sprom = &dev->bus->sprom;
         struct ieee80211_hw *hw;
         struct b43_wl *wl;
-        int err = -ENOMEM;
-
-        b43_sprom_fixup(dev->bus);
 
         hw = ieee80211_alloc_hw(sizeof(*wl), &b43_hw_ops);
         if (!hw) {
                 b43err(NULL, "Could not allocate ieee80211 device\n");
-                goto out;
+                return ERR_PTR(-ENOMEM);
         }
         wl = hw_to_b43_wl(hw);
 
@@ -4951,15 +4977,12 @@ static int b43_wireless_init(struct ssb_device *dev)
         INIT_WORK(&wl->tx_work, b43_tx_work);
         skb_queue_head_init(&wl->tx_queue);
 
-        ssb_set_devtypedata(dev, wl);
         b43info(wl, "Broadcom %04X WLAN found (core revision %u)\n",
                 dev->bus->chip_id, dev->id.revision);
-        err = 0;
-out:
-        return err;
+        return wl;
 }
 
-static int b43_probe(struct ssb_device *dev, const struct ssb_device_id *id)
+static int b43_ssb_probe(struct ssb_device *dev, const struct ssb_device_id *id)
 {
         struct b43_wl *wl;
         int err;
@@ -4969,11 +4992,14 @@ static int b43_probe(struct ssb_device *dev, const struct ssb_device_id *id)
         if (!wl) {
                 /* Probing the first core. Must setup common struct b43_wl */
                 first = 1;
-                err = b43_wireless_init(dev);
-                if (err)
+                b43_sprom_fixup(dev->bus);
+                wl = b43_wireless_init(dev);
+                if (IS_ERR(wl)) {
+                        err = PTR_ERR(wl);
                         goto out;
-                wl = ssb_get_devtypedata(dev);
-                B43_WARN_ON(!wl);
+                }
+                ssb_set_devtypedata(dev, wl);
+                B43_WARN_ON(ssb_get_devtypedata(dev) != wl);
         }
         err = b43_one_core_attach(dev, wl);
         if (err)
@@ -4984,7 +5010,6 @@ static int b43_probe(struct ssb_device *dev, const struct ssb_device_id *id)
                 if (err)
                         goto err_one_core_detach;
                 b43_leds_register(wl->current_dev);
-                b43_rng_init(wl);
         }
 
       out:
@@ -4998,7 +5023,7 @@ static int b43_probe(struct ssb_device *dev, const struct ssb_device_id *id)
         return err;
 }
 
-static void b43_remove(struct ssb_device *dev)
+static void b43_ssb_remove(struct ssb_device *dev)
 {
         struct b43_wl *wl = ssb_get_devtypedata(dev);
         struct b43_wldev *wldev = ssb_get_drvdata(dev);
@@ -5020,7 +5045,6 @@ static void b43_remove(struct ssb_device *dev)
         b43_one_core_detach(dev);
 
         if (list_empty(&wl->devlist)) {
-                b43_rng_exit(wl);
                 b43_leds_unregister(wl);
                 /* Last core on the chip unregistered.
                  * We can destroy common struct b43_wl.
@@ -5042,8 +5066,8 @@ void b43_controller_restart(struct b43_wldev *dev, const char *reason)
 static struct ssb_driver b43_ssb_driver = {
         .name           = KBUILD_MODNAME,
         .id_table       = b43_ssb_tbl,
-        .probe          = b43_probe,
-        .remove         = b43_remove,
+        .probe          = b43_ssb_probe,
+        .remove         = b43_ssb_remove,
 };
 
 static void b43_print_driverinfo(void)
@@ -5057,7 +5081,7 @@ static void b43_print_driverinfo(void)
 #ifdef CONFIG_B43_PCMCIA
         feat_pcmcia = "M";
 #endif
-#ifdef CONFIG_B43_NPHY
+#ifdef CONFIG_B43_PHY_N
         feat_nphy = "N";
 #endif
 #ifdef CONFIG_B43_LEDS