Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net

Pull more networking updates from David Miller:
 "Ok, everything from here on out will be bug fixes."

1) One final sync of wireless and bluetooth stuff from John Linville.
   These changes have all been in his tree for more than a week, and
   therefore have had the necessary -next exposure.  John was just away
   on a trip and didn't have a change to send the pull request until a
   day or two ago.

2) Put back some defines in user exposed header file areas that were
   removed during the tokenring purge.  From Stephen Hemminger and Paul
   Gortmaker.

3) A bug fix for UDP hash table allocation got lost in the pile due to
   one of those "you got it..  no I've got it.." situations.  :-)

   From Tim Bird.

4) SKB coalescing in TCP needs to have stricter checks, otherwise we'll
   try to coalesce overlapping frags and crash.  Fix from Eric Dumazet.

5) RCU routing table lookups can race with free_fib_info(), causing
   crashes when we deref the device pointers in the route.  Fix by
   releasing the net device in the RCU callback.  From Yanmin Zhang.

* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net: (293 commits)
  tcp: take care of overlaps in tcp_try_coalesce()
  ipv4: fix the rcu race between free_fib_info and ip_route_output_slow
  mm: add a low limit to alloc_large_system_hash
  ipx: restore token ring define to include/linux/ipx.h
  if: restore token ring ARP type to header
  xen: do not disable netfront in dom0
  phy/micrel: Fix ID of KSZ9021
  mISDN: Add X-Tensions USB ISDN TA XC-525
  gianfar:don't add FCB length to hard_header_len
  Bluetooth: Report proper error number in disconnection
  Bluetooth: Create flags for bt_sk()
  Bluetooth: report the right security level in getsockopt
  Bluetooth: Lock the L2CAP channel when sending
  Bluetooth: Restore locking semantics when looking up L2CAP channels
  Bluetooth: Fix a redundant and problematic incoming MTU check
  Bluetooth: Add support for Foxconn/Hon Hai AR5BBU22 0489:E03C
  Bluetooth: Fix EIR data generation for mgmt_device_found
  Bluetooth: Fix Inquiry with RSSI event mask
  Bluetooth: improve readability of l2cap_seq_list code
  Bluetooth: Fix skb length calculation
  ...

6 files changed, 251 insertions, 25 deletions

diff --git a/drivers/bcma/core.c b/drivers/bcma/core.c
index 893f6e0c759f..bc6e89212ad3 100644
--- a/drivers/bcma/core.c
+++ b/drivers/bcma/core.c
@@ -30,6 +30,7 @@ void bcma_core_disable(struct bcma_device *core, u32 flags)
         udelay(10);
 
         bcma_awrite32(core, BCMA_RESET_CTL, BCMA_RESET_CTL_RESET);
+        bcma_aread32(core, BCMA_RESET_CTL);
         udelay(1);
 }
 EXPORT_SYMBOL_GPL(bcma_core_disable);
@@ -77,7 +78,7 @@ void bcma_core_set_clockmode(struct bcma_device *core,
                         pr_err("HT force timeout\n");
                 break;
         case BCMA_CLKMODE_DYNAMIC:
-                pr_warn("Dynamic clockmode not supported yet!\n");
+                bcma_set32(core, BCMA_CLKCTLST, ~BCMA_CLKCTLST_FORCEHT);
                 break;
         }
 }
diff --git a/drivers/bcma/driver_pci.c b/drivers/bcma/driver_pci.c
index 4d38ae179b48..9a96f14c8f47 100644
--- a/drivers/bcma/driver_pci.c
+++ b/drivers/bcma/driver_pci.c
@@ -24,14 +24,12 @@ u32 bcma_pcie_read(struct bcma_drv_pci *pc, u32 address)
         return pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_DATA);
 }
 
-#if 0
 static void bcma_pcie_write(struct bcma_drv_pci *pc, u32 address, u32 data)
 {
         pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_ADDR, address);
         pcicore_read32(pc, BCMA_CORE_PCI_PCIEIND_ADDR);
         pcicore_write32(pc, BCMA_CORE_PCI_PCIEIND_DATA, data);
 }
-#endif
 
 static void bcma_pcie_mdio_set_phy(struct bcma_drv_pci *pc, u8 phy)
 {
@@ -170,13 +168,50 @@ static void bcma_pcicore_serdes_workaround(struct bcma_drv_pci *pc)
                                      tmp & ~BCMA_CORE_PCI_PLL_CTRL_FREQDET_EN);
 }
 
+static void bcma_core_pci_fixcfg(struct bcma_drv_pci *pc)
+{
+        struct bcma_device *core = pc->core;
+        u16 val16, core_index;
+        uint regoff;
+
+        regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_PI_OFFSET);
+        core_index = (u16)core->core_index;
+
+        val16 = pcicore_read16(pc, regoff);
+        if (((val16 & BCMA_CORE_PCI_SPROM_PI_MASK) >> BCMA_CORE_PCI_SPROM_PI_SHIFT)
+             != core_index) {
+                val16 = (core_index << BCMA_CORE_PCI_SPROM_PI_SHIFT) |
+                        (val16 & ~BCMA_CORE_PCI_SPROM_PI_MASK);
+                pcicore_write16(pc, regoff, val16);
+        }
+}
+
+/* Fix MISC config to allow coming out of L2/L3-Ready state w/o PRST */
+/* Needs to happen when coming out of 'standby'/'hibernate' */
+static void bcma_core_pci_config_fixup(struct bcma_drv_pci *pc)
+{
+        u16 val16;
+        uint regoff;
+
+        regoff = BCMA_CORE_PCI_SPROM(BCMA_CORE_PCI_SPROM_MISC_CONFIG);
+
+        val16 = pcicore_read16(pc, regoff);
+
+        if (!(val16 & BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST)) {
+                val16 |= BCMA_CORE_PCI_SPROM_L23READY_EXIT_NOPERST;
+                pcicore_write16(pc, regoff, val16);
+        }
+}
+
 /**************************************************
  * Init.
  **************************************************/
 
 static void __devinit bcma_core_pci_clientmode_init(struct bcma_drv_pci *pc)
 {
+        bcma_core_pci_fixcfg(pc);
         bcma_pcicore_serdes_workaround(pc);
+        bcma_core_pci_config_fixup(pc);
 }
 
 void __devinit bcma_core_pci_init(struct bcma_drv_pci *pc)
@@ -224,3 +259,17 @@ out:
         return err;
 }
 EXPORT_SYMBOL_GPL(bcma_core_pci_irq_ctl);
+
+void bcma_core_pci_extend_L1timer(struct bcma_drv_pci *pc, bool extend)
+{
+        u32 w;
+
+        w = bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
+        if (extend)
+                w |= BCMA_CORE_PCI_ASPMTIMER_EXTEND;
+        else
+                w &= ~BCMA_CORE_PCI_ASPMTIMER_EXTEND;
+        bcma_pcie_write(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG, w);
+        bcma_pcie_read(pc, BCMA_CORE_PCI_DLLP_PMTHRESHREG);
+}
+EXPORT_SYMBOL_GPL(bcma_core_pci_extend_L1timer);
diff --git a/drivers/bcma/driver_pci_host.c b/drivers/bcma/driver_pci_host.c
index d2097a11c3c7..b9a86edfec39 100644
--- a/drivers/bcma/driver_pci_host.c
+++ b/drivers/bcma/driver_pci_host.c
@@ -119,7 +119,7 @@ static int bcma_extpci_read_config(struct bcma_drv_pci *pc, unsigned int dev,
                 if (unlikely(!addr))
                         goto out;
                 err = -ENOMEM;
-                mmio = ioremap_nocache(addr, len);
+                mmio = ioremap_nocache(addr, sizeof(val));
                 if (!mmio)
                         goto out;
 
@@ -171,7 +171,7 @@ static int bcma_extpci_write_config(struct bcma_drv_pci *pc, unsigned int dev,
                         addr = pc->core->addr + BCMA_CORE_PCI_PCICFG0;
                         addr |= (func << 8);
                         addr |= (off & 0xfc);
-                        mmio = ioremap_nocache(addr, len);
+                        mmio = ioremap_nocache(addr, sizeof(val));
                         if (!mmio)
                                 goto out;
                 }
@@ -180,7 +180,7 @@ static int bcma_extpci_write_config(struct bcma_drv_pci *pc, unsigned int dev,
                 if (unlikely(!addr))
                         goto out;
                 err = -ENOMEM;
-                mmio = ioremap_nocache(addr, len);
+                mmio = ioremap_nocache(addr, sizeof(val));
                 if (!mmio)
                         goto out;
 
@@ -491,8 +491,8 @@ void __devinit bcma_core_pci_hostmode_init(struct bcma_drv_pci *pc)
         /* Ok, ready to run, register it to the system.
          * The following needs change, if we want to port hostmode
          * to non-MIPS platform. */
-        io_map_base = (unsigned long)ioremap_nocache(BCMA_SOC_PCI_MEM,
-                                                     0x04000000);
+        io_map_base = (unsigned long)ioremap_nocache(pc_host->mem_resource.start,
+                                                     resource_size(&pc_host->mem_resource));
         pc_host->pci_controller.io_map_base = io_map_base;
         set_io_port_base(pc_host->pci_controller.io_map_base);
         /* Give some time to the PCI controller to configure itself with the new
diff --git a/drivers/bcma/host_pci.c b/drivers/bcma/host_pci.c
index e3928d68802b..6c05cf470f96 100644
--- a/drivers/bcma/host_pci.c
+++ b/drivers/bcma/host_pci.c
@@ -201,6 +201,9 @@ static int __devinit bcma_host_pci_probe(struct pci_dev *dev,
         bus->hosttype = BCMA_HOSTTYPE_PCI;
         bus->ops = &bcma_host_pci_ops;
 
+        bus->boardinfo.vendor = bus->host_pci->subsystem_vendor;
+        bus->boardinfo.type = bus->host_pci->subsystem_device;
+
         /* Register */
         err = bcma_bus_register(bus);
         if (err)
@@ -222,7 +225,7 @@ err_kfree_bus:
         return err;
 }
 
-static void bcma_host_pci_remove(struct pci_dev *dev)
+static void __devexit bcma_host_pci_remove(struct pci_dev *dev)
 {
         struct bcma_bus *bus = pci_get_drvdata(dev);
 
@@ -277,7 +280,7 @@ static struct pci_driver bcma_pci_bridge_driver = {
         .name = "bcma-pci-bridge",
         .id_table = bcma_pci_bridge_tbl,
         .probe = bcma_host_pci_probe,
-        .remove = bcma_host_pci_remove,
+        .remove = __devexit_p(bcma_host_pci_remove),
         .driver.pm = BCMA_PM_OPS,
 };
 
diff --git a/drivers/bcma/scan.c b/drivers/bcma/scan.c
index 3bea7fe25b20..5ed0718fc660 100644
--- a/drivers/bcma/scan.c
+++ b/drivers/bcma/scan.c
@@ -19,7 +19,14 @@ struct bcma_device_id_name {
         u16 id;
         const char *name;
 };
-struct bcma_device_id_name bcma_device_names[] = {
+
+static const struct bcma_device_id_name bcma_arm_device_names[] = {
+        { BCMA_CORE_ARM_1176, "ARM 1176" },
+        { BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
+        { BCMA_CORE_ARM_CM3, "ARM CM3" },
+};
+
+static const struct bcma_device_id_name bcma_bcm_device_names[] = {
         { BCMA_CORE_OOB_ROUTER, "OOB Router" },
         { BCMA_CORE_INVALID, "Invalid" },
         { BCMA_CORE_CHIPCOMMON, "ChipCommon" },
@@ -27,7 +34,6 @@ struct bcma_device_id_name bcma_device_names[] = {
         { BCMA_CORE_SRAM, "SRAM" },
         { BCMA_CORE_SDRAM, "SDRAM" },
         { BCMA_CORE_PCI, "PCI" },
-        { BCMA_CORE_MIPS, "MIPS" },
         { BCMA_CORE_ETHERNET, "Fast Ethernet" },
         { BCMA_CORE_V90, "V90" },
         { BCMA_CORE_USB11_HOSTDEV, "USB 1.1 Hostdev" },
@@ -44,7 +50,6 @@ struct bcma_device_id_name bcma_device_names[] = {
         { BCMA_CORE_PHY_A, "PHY A" },
         { BCMA_CORE_PHY_B, "PHY B" },
         { BCMA_CORE_PHY_G, "PHY G" },
-        { BCMA_CORE_MIPS_3302, "MIPS 3302" },
         { BCMA_CORE_USB11_HOST, "USB 1.1 Host" },
         { BCMA_CORE_USB11_DEV, "USB 1.1 Device" },
         { BCMA_CORE_USB20_HOST, "USB 2.0 Host" },
@@ -58,15 +63,11 @@ struct bcma_device_id_name bcma_device_names[] = {
         { BCMA_CORE_PHY_N, "PHY N" },
         { BCMA_CORE_SRAM_CTL, "SRAM Controller" },
         { BCMA_CORE_MINI_MACPHY, "Mini MACPHY" },
-        { BCMA_CORE_ARM_1176, "ARM 1176" },
-        { BCMA_CORE_ARM_7TDMI, "ARM 7TDMI" },
         { BCMA_CORE_PHY_LP, "PHY LP" },
         { BCMA_CORE_PMU, "PMU" },
         { BCMA_CORE_PHY_SSN, "PHY SSN" },
         { BCMA_CORE_SDIO_DEV, "SDIO Device" },
-        { BCMA_CORE_ARM_CM3, "ARM CM3" },
         { BCMA_CORE_PHY_HT, "PHY HT" },
-        { BCMA_CORE_MIPS_74K, "MIPS 74K" },
         { BCMA_CORE_MAC_GBIT, "GBit MAC" },
         { BCMA_CORE_DDR12_MEM_CTL, "DDR1/DDR2 Memory Controller" },
         { BCMA_CORE_PCIE_RC, "PCIe Root Complex" },
@@ -79,16 +80,41 @@ struct bcma_device_id_name bcma_device_names[] = {
         { BCMA_CORE_SHIM, "SHIM" },
         { BCMA_CORE_DEFAULT, "Default" },
 };
-const char *bcma_device_name(struct bcma_device_id *id)
+
+static const struct bcma_device_id_name bcma_mips_device_names[] = {
+        { BCMA_CORE_MIPS, "MIPS" },
+        { BCMA_CORE_MIPS_3302, "MIPS 3302" },
+        { BCMA_CORE_MIPS_74K, "MIPS 74K" },
+};
+
+static const char *bcma_device_name(const struct bcma_device_id *id)
 {
-        int i;
+        const struct bcma_device_id_name *names;
+        int size, i;
+
+        /* search manufacturer specific names */
+        switch (id->manuf) {
+        case BCMA_MANUF_ARM:
+                names = bcma_arm_device_names;
+                size = ARRAY_SIZE(bcma_arm_device_names);
+                break;
+        case BCMA_MANUF_BCM:
+                names = bcma_bcm_device_names;
+                size = ARRAY_SIZE(bcma_bcm_device_names);
+                break;
+        case BCMA_MANUF_MIPS:
+                names = bcma_mips_device_names;
+                size = ARRAY_SIZE(bcma_mips_device_names);
+                break;
+        default:
+                return "UNKNOWN";
+        }
 
-        if (id->manuf == BCMA_MANUF_BCM) {
-                for (i = 0; i < ARRAY_SIZE(bcma_device_names); i++) {
-                        if (bcma_device_names[i].id == id->id)
-                                return bcma_device_names[i].name;
-                }
+        for (i = 0; i < size; i++) {
+                if (names[i].id == id->id)
+                        return names[i].name;
         }
+
         return "UNKNOWN";
 }
 
diff --git a/drivers/bcma/sprom.c b/drivers/bcma/sprom.c
index 3e2a6002aae6..c7f93359acb0 100644
--- a/drivers/bcma/sprom.c
+++ b/drivers/bcma/sprom.c
@@ -181,6 +181,22 @@ static int bcma_sprom_valid(const u16 *sprom)
 #define SPEX(_field, _offset, _mask, _shift)    \
         bus->sprom._field = ((sprom[SPOFF(_offset)] & (_mask)) >> (_shift))
 
+#define SPEX32(_field, _offset, _mask, _shift)  \
+        bus->sprom._field = ((((u32)sprom[SPOFF((_offset)+2)] << 16 | \
+                                sprom[SPOFF(_offset)]) & (_mask)) >> (_shift))
+
+#define SPEX_ARRAY8(_field, _offset, _mask, _shift)     \
+        do {    \
+                SPEX(_field[0], _offset +  0, _mask, _shift);   \
+                SPEX(_field[1], _offset +  2, _mask, _shift);   \
+                SPEX(_field[2], _offset +  4, _mask, _shift);   \
+                SPEX(_field[3], _offset +  6, _mask, _shift);   \
+                SPEX(_field[4], _offset +  8, _mask, _shift);   \
+                SPEX(_field[5], _offset + 10, _mask, _shift);   \
+                SPEX(_field[6], _offset + 12, _mask, _shift);   \
+                SPEX(_field[7], _offset + 14, _mask, _shift);   \
+        } while (0)
+
 static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
 {
         u16 v, o;
@@ -243,7 +259,8 @@ static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
         SPEX(boardflags2_lo, SSB_SPROM8_BFL2LO, ~0, 0);
         SPEX(boardflags2_hi, SSB_SPROM8_BFL2HI, ~0, 0);
 
-        SPEX(country_code, SSB_SPROM8_CCODE, ~0, 0);
+        SPEX(alpha2[0], SSB_SPROM8_CCODE, 0xff00, 8);
+        SPEX(alpha2[1], SSB_SPROM8_CCODE, 0x00ff, 0);
 
         /* Extract cores power info info */
         for (i = 0; i < ARRAY_SIZE(pwr_info_offset); i++) {
@@ -298,6 +315,136 @@ static void bcma_sprom_extract_r8(struct bcma_bus *bus, const u16 *sprom)
              SSB_SROM8_FEM_TR_ISO_SHIFT);
         SPEX(fem.ghz5.antswlut, SSB_SPROM8_FEM5G, SSB_SROM8_FEM_ANTSWLUT,
              SSB_SROM8_FEM_ANTSWLUT_SHIFT);
+
+        SPEX(ant_available_a, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_A,
+             SSB_SPROM8_ANTAVAIL_A_SHIFT);
+        SPEX(ant_available_bg, SSB_SPROM8_ANTAVAIL, SSB_SPROM8_ANTAVAIL_BG,
+             SSB_SPROM8_ANTAVAIL_BG_SHIFT);
+        SPEX(maxpwr_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_MAXP_BG_MASK, 0);
+        SPEX(itssi_bg, SSB_SPROM8_MAXP_BG, SSB_SPROM8_ITSSI_BG,
+             SSB_SPROM8_ITSSI_BG_SHIFT);
+        SPEX(maxpwr_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_MAXP_A_MASK, 0);
+        SPEX(itssi_a, SSB_SPROM8_MAXP_A, SSB_SPROM8_ITSSI_A,
+             SSB_SPROM8_ITSSI_A_SHIFT);
+        SPEX(maxpwr_ah, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AH_MASK, 0);
+        SPEX(maxpwr_al, SSB_SPROM8_MAXP_AHL, SSB_SPROM8_MAXP_AL_MASK,
+             SSB_SPROM8_MAXP_AL_SHIFT);
+        SPEX(gpio0, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P0, 0);
+        SPEX(gpio1, SSB_SPROM8_GPIOA, SSB_SPROM8_GPIOA_P1,
+             SSB_SPROM8_GPIOA_P1_SHIFT);
+        SPEX(gpio2, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P2, 0);
+        SPEX(gpio3, SSB_SPROM8_GPIOB, SSB_SPROM8_GPIOB_P3,
+             SSB_SPROM8_GPIOB_P3_SHIFT);
+        SPEX(tri2g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI2G, 0);
+        SPEX(tri5g, SSB_SPROM8_TRI25G, SSB_SPROM8_TRI5G,
+             SSB_SPROM8_TRI5G_SHIFT);
+        SPEX(tri5gl, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GL, 0);
+        SPEX(tri5gh, SSB_SPROM8_TRI5GHL, SSB_SPROM8_TRI5GH,
+             SSB_SPROM8_TRI5GH_SHIFT);
+        SPEX(rxpo2g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO2G,
+             SSB_SPROM8_RXPO2G_SHIFT);
+        SPEX(rxpo5g, SSB_SPROM8_RXPO, SSB_SPROM8_RXPO5G,
+             SSB_SPROM8_RXPO5G_SHIFT);
+        SPEX(rssismf2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMF2G, 0);
+        SPEX(rssismc2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISMC2G,
+             SSB_SPROM8_RSSISMC2G_SHIFT);
+        SPEX(rssisav2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_RSSISAV2G,
+             SSB_SPROM8_RSSISAV2G_SHIFT);
+        SPEX(bxa2g, SSB_SPROM8_RSSIPARM2G, SSB_SPROM8_BXA2G,
+             SSB_SPROM8_BXA2G_SHIFT);
+        SPEX(rssismf5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMF5G, 0);
+        SPEX(rssismc5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISMC5G,
+             SSB_SPROM8_RSSISMC5G_SHIFT);
+        SPEX(rssisav5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_RSSISAV5G,
+             SSB_SPROM8_RSSISAV5G_SHIFT);
+        SPEX(bxa5g, SSB_SPROM8_RSSIPARM5G, SSB_SPROM8_BXA5G,
+             SSB_SPROM8_BXA5G_SHIFT);
+
+        SPEX(pa0b0, SSB_SPROM8_PA0B0, ~0, 0);
+        SPEX(pa0b1, SSB_SPROM8_PA0B1, ~0, 0);
+        SPEX(pa0b2, SSB_SPROM8_PA0B2, ~0, 0);
+        SPEX(pa1b0, SSB_SPROM8_PA1B0, ~0, 0);
+        SPEX(pa1b1, SSB_SPROM8_PA1B1, ~0, 0);
+        SPEX(pa1b2, SSB_SPROM8_PA1B2, ~0, 0);
+        SPEX(pa1lob0, SSB_SPROM8_PA1LOB0, ~0, 0);
+        SPEX(pa1lob1, SSB_SPROM8_PA1LOB1, ~0, 0);
+        SPEX(pa1lob2, SSB_SPROM8_PA1LOB2, ~0, 0);
+        SPEX(pa1hib0, SSB_SPROM8_PA1HIB0, ~0, 0);
+        SPEX(pa1hib1, SSB_SPROM8_PA1HIB1, ~0, 0);
+        SPEX(pa1hib2, SSB_SPROM8_PA1HIB2, ~0, 0);
+        SPEX(cck2gpo, SSB_SPROM8_CCK2GPO, ~0, 0);
+        SPEX32(ofdm2gpo, SSB_SPROM8_OFDM2GPO, ~0, 0);
+        SPEX32(ofdm5glpo, SSB_SPROM8_OFDM5GLPO, ~0, 0);
+        SPEX32(ofdm5gpo, SSB_SPROM8_OFDM5GPO, ~0, 0);
+        SPEX32(ofdm5ghpo, SSB_SPROM8_OFDM5GHPO, ~0, 0);
+
+        /* Extract the antenna gain values. */
+        SPEX(antenna_gain.a0, SSB_SPROM8_AGAIN01,
+             SSB_SPROM8_AGAIN0, SSB_SPROM8_AGAIN0_SHIFT);
+        SPEX(antenna_gain.a1, SSB_SPROM8_AGAIN01,
+             SSB_SPROM8_AGAIN1, SSB_SPROM8_AGAIN1_SHIFT);
+        SPEX(antenna_gain.a2, SSB_SPROM8_AGAIN23,
+             SSB_SPROM8_AGAIN2, SSB_SPROM8_AGAIN2_SHIFT);
+        SPEX(antenna_gain.a3, SSB_SPROM8_AGAIN23,
+             SSB_SPROM8_AGAIN3, SSB_SPROM8_AGAIN3_SHIFT);
+
+        SPEX(leddc_on_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_ON,
+             SSB_SPROM8_LEDDC_ON_SHIFT);
+        SPEX(leddc_off_time, SSB_SPROM8_LEDDC, SSB_SPROM8_LEDDC_OFF,
+             SSB_SPROM8_LEDDC_OFF_SHIFT);
+
+        SPEX(txchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_TXCHAIN,
+             SSB_SPROM8_TXRXC_TXCHAIN_SHIFT);
+        SPEX(rxchain, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_RXCHAIN,
+             SSB_SPROM8_TXRXC_RXCHAIN_SHIFT);
+        SPEX(antswitch, SSB_SPROM8_TXRXC, SSB_SPROM8_TXRXC_SWITCH,
+             SSB_SPROM8_TXRXC_SWITCH_SHIFT);
+
+        SPEX(opo, SSB_SPROM8_OFDM2GPO, 0x00ff, 0);
+
+        SPEX_ARRAY8(mcs2gpo, SSB_SPROM8_2G_MCSPO, ~0, 0);
+        SPEX_ARRAY8(mcs5gpo, SSB_SPROM8_5G_MCSPO, ~0, 0);
+        SPEX_ARRAY8(mcs5glpo, SSB_SPROM8_5GL_MCSPO, ~0, 0);
+        SPEX_ARRAY8(mcs5ghpo, SSB_SPROM8_5GH_MCSPO, ~0, 0);
+
+        SPEX(rawtempsense, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_RAWTEMP,
+             SSB_SPROM8_RAWTS_RAWTEMP_SHIFT);
+        SPEX(measpower, SSB_SPROM8_RAWTS, SSB_SPROM8_RAWTS_MEASPOWER,
+             SSB_SPROM8_RAWTS_MEASPOWER_SHIFT);
+        SPEX(tempsense_slope, SSB_SPROM8_OPT_CORRX,
+             SSB_SPROM8_OPT_CORRX_TEMP_SLOPE,
+             SSB_SPROM8_OPT_CORRX_TEMP_SLOPE_SHIFT);
+        SPEX(tempcorrx, SSB_SPROM8_OPT_CORRX, SSB_SPROM8_OPT_CORRX_TEMPCORRX,
+             SSB_SPROM8_OPT_CORRX_TEMPCORRX_SHIFT);
+        SPEX(tempsense_option, SSB_SPROM8_OPT_CORRX,
+             SSB_SPROM8_OPT_CORRX_TEMP_OPTION,
+             SSB_SPROM8_OPT_CORRX_TEMP_OPTION_SHIFT);
+        SPEX(freqoffset_corr, SSB_SPROM8_HWIQ_IQSWP,
+             SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR,
+             SSB_SPROM8_HWIQ_IQSWP_FREQ_CORR_SHIFT);
+        SPEX(iqcal_swp_dis, SSB_SPROM8_HWIQ_IQSWP,
+             SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP,
+             SSB_SPROM8_HWIQ_IQSWP_IQCAL_SWP_SHIFT);
+        SPEX(hw_iqcal_en, SSB_SPROM8_HWIQ_IQSWP, SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL,
+             SSB_SPROM8_HWIQ_IQSWP_HW_IQCAL_SHIFT);
+
+        SPEX(bw40po, SSB_SPROM8_BW40PO, ~0, 0);
+        SPEX(cddpo, SSB_SPROM8_CDDPO, ~0, 0);
+        SPEX(stbcpo, SSB_SPROM8_STBCPO, ~0, 0);
+        SPEX(bwduppo, SSB_SPROM8_BWDUPPO, ~0, 0);
+
+        SPEX(tempthresh, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_TRESH,
+             SSB_SPROM8_THERMAL_TRESH_SHIFT);
+        SPEX(tempoffset, SSB_SPROM8_THERMAL, SSB_SPROM8_THERMAL_OFFSET,
+             SSB_SPROM8_THERMAL_OFFSET_SHIFT);
+        SPEX(phycal_tempdelta, SSB_SPROM8_TEMPDELTA,
+             SSB_SPROM8_TEMPDELTA_PHYCAL,
+             SSB_SPROM8_TEMPDELTA_PHYCAL_SHIFT);
+        SPEX(temps_period, SSB_SPROM8_TEMPDELTA, SSB_SPROM8_TEMPDELTA_PERIOD,
+             SSB_SPROM8_TEMPDELTA_PERIOD_SHIFT);
+        SPEX(temps_hysteresis, SSB_SPROM8_TEMPDELTA,
+             SSB_SPROM8_TEMPDELTA_HYSTERESIS,
+             SSB_SPROM8_TEMPDELTA_HYSTERESIS_SHIFT);
 }
 
 /*