Merge commit 'origin/master' into next

Conflicts:
	include/linux/kvm.h

6 files changed, 215 insertions, 191 deletions

diff --git a/drivers/ssb/driver_pcicore.c b/drivers/ssb/driver_pcicore.c
index 538c570df337..f1dcd7969a5c 100644
--- a/drivers/ssb/driver_pcicore.c
+++ b/drivers/ssb/driver_pcicore.c
@@ -551,13 +551,13 @@ int ssb_pcicore_dev_irqvecs_enable(struct ssb_pcicore *pc,
         might_sleep_if(pdev->id.coreid != SSB_DEV_PCI);
 
         /* Enable interrupts for this device. */
-        if (bus->host_pci &&
-            ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE))) {
+        if ((pdev->id.revision >= 6) || (pdev->id.coreid == SSB_DEV_PCIE)) {
                 u32 coremask;
 
                 /* Calculate the "coremask" for the device. */
                 coremask = (1 << dev->core_index);
 
+                SSB_WARN_ON(bus->bustype != SSB_BUSTYPE_PCI);
                 err = pci_read_config_dword(bus->host_pci, SSB_PCI_IRQMASK, &tmp);
                 if (err)
                         goto out;
diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
index 579b114be412..5681ebed9c65 100644
--- a/drivers/ssb/main.c
+++ b/drivers/ssb/main.c
@@ -140,6 +140,19 @@ static void ssb_device_put(struct ssb_device *dev)
                 put_device(dev->dev);
 }
 
+static inline struct ssb_driver *ssb_driver_get(struct ssb_driver *drv)
+{
+        if (drv)
+                get_driver(&drv->drv);
+        return drv;
+}
+
+static inline void ssb_driver_put(struct ssb_driver *drv)
+{
+        if (drv)
+                put_driver(&drv->drv);
+}
+
 static int ssb_device_resume(struct device *dev)
 {
         struct ssb_device *ssb_dev = dev_to_ssb_dev(dev);
@@ -210,90 +223,81 @@ int ssb_bus_suspend(struct ssb_bus *bus)
 EXPORT_SYMBOL(ssb_bus_suspend);
 
 #ifdef CONFIG_SSB_SPROM
-int ssb_devices_freeze(struct ssb_bus *bus)
+/** ssb_devices_freeze - Freeze all devices on the bus.
+ *
+ * After freezing no device driver will be handling a device
+ * on this bus anymore. ssb_devices_thaw() must be called after
+ * a successful freeze to reactivate the devices.
+ *
+ * @bus: The bus.
+ * @ctx: Context structure. Pass this to ssb_devices_thaw().
+ */
+int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx)
 {
-        struct ssb_device *dev;
-        struct ssb_driver *drv;
-        int err = 0;
-        int i;
-        pm_message_t state = PMSG_FREEZE;
+        struct ssb_device *sdev;
+        struct ssb_driver *sdrv;
+        unsigned int i;
+
+        memset(ctx, 0, sizeof(*ctx));
+        ctx->bus = bus;
+        SSB_WARN_ON(bus->nr_devices > ARRAY_SIZE(ctx->device_frozen));
 
-        /* First check that we are capable to freeze all devices. */
         for (i = 0; i < bus->nr_devices; i++) {
-                dev = &(bus->devices[i]);
-                if (!dev->dev ||
-                    !dev->dev->driver ||
-                    !device_is_registered(dev->dev))
-                        continue;
-                drv = drv_to_ssb_drv(dev->dev->driver);
-                if (!drv)
+                sdev = ssb_device_get(&bus->devices[i]);
+
+                if (!sdev->dev || !sdev->dev->driver ||
+                    !device_is_registered(sdev->dev)) {
+                        ssb_device_put(sdev);
                         continue;
-                if (!drv->suspend) {
-                        /* Nope, can't suspend this one. */
-                        return -EOPNOTSUPP;
                 }
-        }
-        /* Now suspend all devices */
-        for (i = 0; i < bus->nr_devices; i++) {
-                dev = &(bus->devices[i]);
-                if (!dev->dev ||
-                    !dev->dev->driver ||
-                    !device_is_registered(dev->dev))
-                        continue;
-                drv = drv_to_ssb_drv(dev->dev->driver);
-                if (!drv)
+                sdrv = ssb_driver_get(drv_to_ssb_drv(sdev->dev->driver));
+                if (!sdrv || SSB_WARN_ON(!sdrv->remove)) {
+                        ssb_device_put(sdev);
                         continue;
-                err = drv->suspend(dev, state);
-                if (err) {
-                        ssb_printk(KERN_ERR PFX "Failed to freeze device %s\n",
-                                   dev_name(dev->dev));
-                        goto err_unwind;
                 }
+                sdrv->remove(sdev);
+                ctx->device_frozen[i] = 1;
         }
 
         return 0;
-err_unwind:
-        for (i--; i >= 0; i--) {
-                dev = &(bus->devices[i]);
-                if (!dev->dev ||
-                    !dev->dev->driver ||
-                    !device_is_registered(dev->dev))
-                        continue;
-                drv = drv_to_ssb_drv(dev->dev->driver);
-                if (!drv)
-                        continue;
-                if (drv->resume)
-                        drv->resume(dev);
-        }
-        return err;
 }
 
-int ssb_devices_thaw(struct ssb_bus *bus)
+/** ssb_devices_thaw - Unfreeze all devices on the bus.
+ *
+ * This will re-attach the device drivers and re-init the devices.
+ *
+ * @ctx: The context structure from ssb_devices_freeze()
+ */
+int ssb_devices_thaw(struct ssb_freeze_context *ctx)
 {
-        struct ssb_device *dev;
-        struct ssb_driver *drv;
-        int err;
-        int i;
+        struct ssb_bus *bus = ctx->bus;
+        struct ssb_device *sdev;
+        struct ssb_driver *sdrv;
+        unsigned int i;
+        int err, result = 0;
 
         for (i = 0; i < bus->nr_devices; i++) {
-                dev = &(bus->devices[i]);
-                if (!dev->dev ||
-                    !dev->dev->driver ||
-                    !device_is_registered(dev->dev))
+                if (!ctx->device_frozen[i])
                         continue;
-                drv = drv_to_ssb_drv(dev->dev->driver);
-                if (!drv)
+                sdev = &bus->devices[i];
+
+                if (SSB_WARN_ON(!sdev->dev || !sdev->dev->driver))
                         continue;
-                if (SSB_WARN_ON(!drv->resume))
+                sdrv = drv_to_ssb_drv(sdev->dev->driver);
+                if (SSB_WARN_ON(!sdrv || !sdrv->probe))
                         continue;
-                err = drv->resume(dev);
+
+                err = sdrv->probe(sdev, &sdev->id);
                 if (err) {
                         ssb_printk(KERN_ERR PFX "Failed to thaw device %s\n",
-                                   dev_name(dev->dev));
+                                   dev_name(sdev->dev));
+                        result = err;
                 }
+                ssb_driver_put(sdrv);
+                ssb_device_put(sdev);
         }
 
-        return 0;
+        return result;
 }
 #endif /* CONFIG_SSB_SPROM */
 
diff --git a/drivers/ssb/pcmcia.c b/drivers/ssb/pcmcia.c
index 100e7a5c5ea1..e72f4046a5e0 100644
--- a/drivers/ssb/pcmcia.c
+++ b/drivers/ssb/pcmcia.c
@@ -617,136 +617,140 @@ static int ssb_pcmcia_sprom_check_crc(const u16 *sprom, size_t size)
         }                                               \
   } while (0)
 
-int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
-                              struct ssb_init_invariants *iv)
+static int ssb_pcmcia_get_mac(struct pcmcia_device *p_dev,
+                        tuple_t *tuple,
+                        void *priv)
 {
-        tuple_t tuple;
-        int res;
-        unsigned char buf[32];
+        struct ssb_sprom *sprom = priv;
+
+        if (tuple->TupleData[0] != CISTPL_FUNCE_LAN_NODE_ID)
+                return -EINVAL;
+        if (tuple->TupleDataLen != ETH_ALEN + 2)
+                return -EINVAL;
+        if (tuple->TupleData[1] != ETH_ALEN)
+                return -EINVAL;
+        memcpy(sprom->il0mac, &tuple->TupleData[2], ETH_ALEN);
+        return 0;
+};
+
+static int ssb_pcmcia_do_get_invariants(struct pcmcia_device *p_dev,
+                                        tuple_t *tuple,
+                                        void *priv)
+{
+        struct ssb_init_invariants *iv = priv;
         struct ssb_sprom *sprom = &iv->sprom;
         struct ssb_boardinfo *bi = &iv->boardinfo;
         const char *error_description;
 
+        GOTO_ERROR_ON(tuple->TupleDataLen < 1, "VEN tpl < 1");
+        switch (tuple->TupleData[0]) {
+        case SSB_PCMCIA_CIS_ID:
+                GOTO_ERROR_ON((tuple->TupleDataLen != 5) &&
+                              (tuple->TupleDataLen != 7),
+                              "id tpl size");
+                bi->vendor = tuple->TupleData[1] |
+                        ((u16)tuple->TupleData[2] << 8);
+                break;
+        case SSB_PCMCIA_CIS_BOARDREV:
+                GOTO_ERROR_ON(tuple->TupleDataLen != 2,
+                        "boardrev tpl size");
+                sprom->board_rev = tuple->TupleData[1];
+                break;
+        case SSB_PCMCIA_CIS_PA:
+                GOTO_ERROR_ON((tuple->TupleDataLen != 9) &&
+                        (tuple->TupleDataLen != 10),
+                        "pa tpl size");
+                sprom->pa0b0 = tuple->TupleData[1] |
+                        ((u16)tuple->TupleData[2] << 8);
+                sprom->pa0b1 = tuple->TupleData[3] |
+                        ((u16)tuple->TupleData[4] << 8);
+                sprom->pa0b2 = tuple->TupleData[5] |
+                        ((u16)tuple->TupleData[6] << 8);
+                sprom->itssi_a = tuple->TupleData[7];
+                sprom->itssi_bg = tuple->TupleData[7];
+                sprom->maxpwr_a = tuple->TupleData[8];
+                sprom->maxpwr_bg = tuple->TupleData[8];
+                break;
+        case SSB_PCMCIA_CIS_OEMNAME:
+                /* We ignore this. */
+                break;
+        case SSB_PCMCIA_CIS_CCODE:
+                GOTO_ERROR_ON(tuple->TupleDataLen != 2,
+                        "ccode tpl size");
+                sprom->country_code = tuple->TupleData[1];
+                break;
+        case SSB_PCMCIA_CIS_ANTENNA:
+                GOTO_ERROR_ON(tuple->TupleDataLen != 2,
+                        "ant tpl size");
+                sprom->ant_available_a = tuple->TupleData[1];
+                sprom->ant_available_bg = tuple->TupleData[1];
+                break;
+        case SSB_PCMCIA_CIS_ANTGAIN:
+                GOTO_ERROR_ON(tuple->TupleDataLen != 2,
+                        "antg tpl size");
+                sprom->antenna_gain.ghz24.a0 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz24.a1 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz24.a2 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz24.a3 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz5.a0 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz5.a1 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz5.a2 = tuple->TupleData[1];
+                sprom->antenna_gain.ghz5.a3 = tuple->TupleData[1];
+                break;
+        case SSB_PCMCIA_CIS_BFLAGS:
+                GOTO_ERROR_ON((tuple->TupleDataLen != 3) &&
+                        (tuple->TupleDataLen != 5),
+                        "bfl tpl size");
+                sprom->boardflags_lo = tuple->TupleData[1] |
+                        ((u16)tuple->TupleData[2] << 8);
+                break;
+        case SSB_PCMCIA_CIS_LEDS:
+                GOTO_ERROR_ON(tuple->TupleDataLen != 5,
+                        "leds tpl size");
+                sprom->gpio0 = tuple->TupleData[1];
+                sprom->gpio1 = tuple->TupleData[2];
+                sprom->gpio2 = tuple->TupleData[3];
+                sprom->gpio3 = tuple->TupleData[4];
+                break;
+        }
+        return -ENOSPC; /* continue with next entry */
+
+error:
+        ssb_printk(KERN_ERR PFX
+                   "PCMCIA: Failed to fetch device invariants: %s\n",
+                   error_description);
+        return -ENODEV;
+}
+
+
+int ssb_pcmcia_get_invariants(struct ssb_bus *bus,
+                              struct ssb_init_invariants *iv)
+{
+        struct ssb_sprom *sprom = &iv->sprom;
+        int res;
+
         memset(sprom, 0xFF, sizeof(*sprom));
         sprom->revision = 1;
         sprom->boardflags_lo = 0;
         sprom->boardflags_hi = 0;
 
         /* First fetch the MAC address. */
-        memset(&tuple, 0, sizeof(tuple));
-        tuple.DesiredTuple = CISTPL_FUNCE;
-        tuple.TupleData = buf;
-        tuple.TupleDataMax = sizeof(buf);
-        res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
-        GOTO_ERROR_ON(res != 0, "MAC first tpl");
-        res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-        GOTO_ERROR_ON(res != 0, "MAC first tpl data");
-        while (1) {
-                GOTO_ERROR_ON(tuple.TupleDataLen < 1, "MAC tpl < 1");
-                if (tuple.TupleData[0] == CISTPL_FUNCE_LAN_NODE_ID)
-                        break;
-                res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
-                GOTO_ERROR_ON(res != 0, "MAC next tpl");
-                res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-                GOTO_ERROR_ON(res != 0, "MAC next tpl data");
+        res = pcmcia_loop_tuple(bus->host_pcmcia, CISTPL_FUNCE,
+                                ssb_pcmcia_get_mac, sprom);
+        if (res != 0) {
+                ssb_printk(KERN_ERR PFX
+                        "PCMCIA: Failed to fetch MAC address\n");
+                return -ENODEV;
         }
-        GOTO_ERROR_ON(tuple.TupleDataLen != ETH_ALEN + 2, "MAC tpl size");
-        memcpy(sprom->il0mac, &tuple.TupleData[2], ETH_ALEN);
 
         /* Fetch the vendor specific tuples. */
-        memset(&tuple, 0, sizeof(tuple));
-        tuple.DesiredTuple = SSB_PCMCIA_CIS;
-        tuple.TupleData = buf;
-        tuple.TupleDataMax = sizeof(buf);
-        res = pcmcia_get_first_tuple(bus->host_pcmcia, &tuple);
-        GOTO_ERROR_ON(res != 0, "VEN first tpl");
-        res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-        GOTO_ERROR_ON(res != 0, "VEN first tpl data");
-        while (1) {
-                GOTO_ERROR_ON(tuple.TupleDataLen < 1, "VEN tpl < 1");
-                switch (tuple.TupleData[0]) {
-                case SSB_PCMCIA_CIS_ID:
-                        GOTO_ERROR_ON((tuple.TupleDataLen != 5) &&
-                                      (tuple.TupleDataLen != 7),
-                                      "id tpl size");
-                        bi->vendor = tuple.TupleData[1] |
-                               ((u16)tuple.TupleData[2] << 8);
-                        break;
-                case SSB_PCMCIA_CIS_BOARDREV:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 2,
-                                      "boardrev tpl size");
-                        sprom->board_rev = tuple.TupleData[1];
-                        break;
-                case SSB_PCMCIA_CIS_PA:
-                        GOTO_ERROR_ON((tuple.TupleDataLen != 9) &&
-                                      (tuple.TupleDataLen != 10),
-                                      "pa tpl size");
-                        sprom->pa0b0 = tuple.TupleData[1] |
-                                 ((u16)tuple.TupleData[2] << 8);
-                        sprom->pa0b1 = tuple.TupleData[3] |
-                                 ((u16)tuple.TupleData[4] << 8);
-                        sprom->pa0b2 = tuple.TupleData[5] |
-                                 ((u16)tuple.TupleData[6] << 8);
-                        sprom->itssi_a = tuple.TupleData[7];
-                        sprom->itssi_bg = tuple.TupleData[7];
-                        sprom->maxpwr_a = tuple.TupleData[8];
-                        sprom->maxpwr_bg = tuple.TupleData[8];
-                        break;
-                case SSB_PCMCIA_CIS_OEMNAME:
-                        /* We ignore this. */
-                        break;
-                case SSB_PCMCIA_CIS_CCODE:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 2,
-                                      "ccode tpl size");
-                        sprom->country_code = tuple.TupleData[1];
-                        break;
-                case SSB_PCMCIA_CIS_ANTENNA:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 2,
-                                      "ant tpl size");
-                        sprom->ant_available_a = tuple.TupleData[1];
-                        sprom->ant_available_bg = tuple.TupleData[1];
-                        break;
-                case SSB_PCMCIA_CIS_ANTGAIN:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 2,
-                                      "antg tpl size");
-                        sprom->antenna_gain.ghz24.a0 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz24.a1 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz24.a2 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz24.a3 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz5.a0 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz5.a1 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz5.a2 = tuple.TupleData[1];
-                        sprom->antenna_gain.ghz5.a3 = tuple.TupleData[1];
-                        break;
-                case SSB_PCMCIA_CIS_BFLAGS:
-                        GOTO_ERROR_ON((tuple.TupleDataLen != 3) &&
-                                      (tuple.TupleDataLen != 5),
-                                      "bfl tpl size");
-                        sprom->boardflags_lo = tuple.TupleData[1] |
-                                         ((u16)tuple.TupleData[2] << 8);
-                        break;
-                case SSB_PCMCIA_CIS_LEDS:
-                        GOTO_ERROR_ON(tuple.TupleDataLen != 5,
-                                      "leds tpl size");
-                        sprom->gpio0 = tuple.TupleData[1];
-                        sprom->gpio1 = tuple.TupleData[2];
-                        sprom->gpio2 = tuple.TupleData[3];
-                        sprom->gpio3 = tuple.TupleData[4];
-                        break;
-                }
-                res = pcmcia_get_next_tuple(bus->host_pcmcia, &tuple);
-                if (res == -ENOSPC)
-                        break;
-                GOTO_ERROR_ON(res != 0, "VEN next tpl");
-                res = pcmcia_get_tuple_data(bus->host_pcmcia, &tuple);
-                GOTO_ERROR_ON(res != 0, "VEN next tpl data");
-        }
+        res = pcmcia_loop_tuple(bus->host_pcmcia, SSB_PCMCIA_CIS,
+                                ssb_pcmcia_do_get_invariants, sprom);
+        if ((res == 0) || (res == -ENOSPC))
+                return 0;
 
-        return 0;
-error:
         ssb_printk(KERN_ERR PFX
-                   "PCMCIA: Failed to fetch device invariants: %s\n",
-                   error_description);
+                        "PCMCIA: Failed to fetch device invariants\n");
         return -ENODEV;
 }
 
diff --git a/drivers/ssb/scan.c b/drivers/ssb/scan.c
index e8b89e8ac9bd..0d6c0280eb34 100644
--- a/drivers/ssb/scan.c
+++ b/drivers/ssb/scan.c
@@ -354,7 +354,7 @@ int ssb_bus_scan(struct ssb_bus *bus,
                 dev->bus = bus;
                 dev->ops = bus->ops;
 
-                ssb_dprintk(KERN_INFO PFX
+                printk(KERN_DEBUG PFX
                             "Core %d found: %s "
                             "(cc 0x%03X, rev 0x%02X, vendor 0x%04X)\n",
                             i, ssb_core_name(dev->id.coreid),
diff --git a/drivers/ssb/sprom.c b/drivers/ssb/sprom.c
index 8943015a3eef..d0e6762fec50 100644
--- a/drivers/ssb/sprom.c
+++ b/drivers/ssb/sprom.c
@@ -13,6 +13,8 @@
 
 #include "ssb_private.h"
 
+#include <linux/ctype.h>
+
 
 static const struct ssb_sprom *fallback_sprom;
 
@@ -33,17 +35,27 @@ static int sprom2hex(const u16 *sprom, char *buf, size_t buf_len,
 static int hex2sprom(u16 *sprom, const char *dump, size_t len,
                      size_t sprom_size_words)
 {
-        char tmp[5] = { 0 };
-        int cnt = 0;
+        char c, tmp[5] = { 0 };
+        int err, cnt = 0;
         unsigned long parsed;
 
-        if (len < sprom_size_words * 2)
+        /* Strip whitespace at the end. */
+        while (len) {
+                c = dump[len - 1];
+                if (!isspace(c) && c != '\0')
+                        break;
+                len--;
+        }
+        /* Length must match exactly. */
+        if (len != sprom_size_words * 4)
                 return -EINVAL;
 
         while (cnt < sprom_size_words) {
                 memcpy(tmp, dump, 4);
                 dump += 4;
-                parsed = simple_strtoul(tmp, NULL, 16);
+                err = strict_strtoul(tmp, 16, &parsed);
+                if (err)
+                        return err;
                 sprom[cnt++] = swab16((u16)parsed);
         }
 
@@ -90,6 +102,7 @@ ssize_t ssb_attr_sprom_store(struct ssb_bus *bus,
         u16 *sprom;
         int res = 0, err = -ENOMEM;
         size_t sprom_size_words = bus->sprom_size;
+        struct ssb_freeze_context freeze;
 
         sprom = kcalloc(bus->sprom_size, sizeof(u16), GFP_KERNEL);
         if (!sprom)
@@ -111,18 +124,13 @@ ssize_t ssb_attr_sprom_store(struct ssb_bus *bus,
         err = -ERESTARTSYS;
         if (mutex_lock_interruptible(&bus->sprom_mutex))
                 goto out_kfree;
-        err = ssb_devices_freeze(bus);
-        if (err == -EOPNOTSUPP) {
-                ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze devices. "
-                           "No suspend support. Is CONFIG_PM enabled?\n");
-                goto out_unlock;
-        }
+        err = ssb_devices_freeze(bus, &freeze);
         if (err) {
                 ssb_printk(KERN_ERR PFX "SPROM write: Could not freeze all devices\n");
                 goto out_unlock;
         }
         res = sprom_write(bus, sprom);
-        err = ssb_devices_thaw(bus);
+        err = ssb_devices_thaw(&freeze);
         if (err)
                 ssb_printk(KERN_ERR PFX "SPROM write: Could not thaw all devices\n");
 out_unlock:
diff --git a/drivers/ssb/ssb_private.h b/drivers/ssb/ssb_private.h
index 25433565dfda..56054be4d113 100644
--- a/drivers/ssb/ssb_private.h
+++ b/drivers/ssb/ssb_private.h
@@ -176,13 +176,21 @@ extern const struct ssb_sprom *ssb_get_fallback_sprom(void);
 
 /* core.c */
 extern u32 ssb_calc_clock_rate(u32 plltype, u32 n, u32 m);
-extern int ssb_devices_freeze(struct ssb_bus *bus);
-extern int ssb_devices_thaw(struct ssb_bus *bus);
 extern struct ssb_bus *ssb_pci_dev_to_bus(struct pci_dev *pdev);
 int ssb_for_each_bus_call(unsigned long data,
                           int (*func)(struct ssb_bus *bus, unsigned long data));
 extern struct ssb_bus *ssb_pcmcia_dev_to_bus(struct pcmcia_device *pdev);
 
+struct ssb_freeze_context {
+        /* Pointer to the bus */
+        struct ssb_bus *bus;
+        /* Boolean list to indicate whether a device is frozen on this bus. */
+        bool device_frozen[SSB_MAX_NR_CORES];
+};
+extern int ssb_devices_freeze(struct ssb_bus *bus, struct ssb_freeze_context *ctx);
+extern int ssb_devices_thaw(struct ssb_freeze_context *ctx);
+
+
 
 /* b43_pci_bridge.c */
 #ifdef CONFIG_SSB_B43_PCI_BRIDGE