239 files changed, 12090 insertions, 7178 deletions

diff --git a/drivers/acpi/acpi_pad.c b/drivers/acpi/acpi_pad.c
index 6b115f6c4313..6afceb3d4034 100644
--- a/drivers/acpi/acpi_pad.c
+++ b/drivers/acpi/acpi_pad.c
@@ -30,18 +30,13 @@
 #include <linux/slab.h>
 #include <acpi/acpi_bus.h>
 #include <acpi/acpi_drivers.h>
+#include <asm/mwait.h>
 
 #define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"
 #define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
 #define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
 static DEFINE_MUTEX(isolated_cpus_lock);
 
-#define MWAIT_SUBSTATE_MASK     (0xf)
-#define MWAIT_CSTATE_MASK       (0xf)
-#define MWAIT_SUBSTATE_SIZE     (4)
-#define CPUID_MWAIT_LEAF (5)
-#define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
-#define CPUID5_ECX_INTERRUPT_BREAK      (0x2)
 static unsigned long power_saving_mwait_eax;
 
 static unsigned char tsc_detected_unstable;
diff --git a/drivers/acpi/blacklist.c b/drivers/acpi/blacklist.c
index f7619600270a..af308d03f492 100644
--- a/drivers/acpi/blacklist.c
+++ b/drivers/acpi/blacklist.c
@@ -204,6 +204,23 @@ static struct dmi_system_id acpi_osi_dmi_table[] __initdata = {
                 },
         },
         {
+        /*
+         * There have a NVIF method in MSI GX723 DSDT need call by Nvidia
+         * driver (e.g. nouveau) when user press brightness hotkey.
+         * Currently, nouveau driver didn't do the job and it causes there
+         * have a infinite while loop in DSDT when user press hotkey.
+         * We add MSI GX723's dmi information to this table for workaround
+         * this issue.
+         * Will remove MSI GX723 from the table after nouveau grows support.
+         */
+        .callback = dmi_disable_osi_vista,
+        .ident = "MSI GX723",
+        .matches = {
+                     DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star International"),
+                     DMI_MATCH(DMI_PRODUCT_NAME, "GX723"),
+                },
+        },
+        {
         .callback = dmi_disable_osi_vista,
         .ident = "Sony VGN-NS10J_S",
         .matches = {
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index b618f888d66b..bec561c14beb 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -346,4 +346,5 @@ void __init acpi_early_processor_set_pdc(void)
         acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
                             ACPI_UINT32_MAX,
                             early_init_pdc, NULL, NULL, NULL);
+        acpi_get_devices("ACPI0007", early_init_pdc, NULL, NULL);
 }
diff --git a/drivers/amba/bus.c b/drivers/amba/bus.c
index d31590e7011b..2737b9752205 100644
--- a/drivers/amba/bus.c
+++ b/drivers/amba/bus.c
@@ -298,7 +298,7 @@ int amba_device_register(struct amba_device *dev, struct resource *parent)
 
                 amba_put_disable_pclk(dev);
 
-                if (cid == 0xb105f00d)
+                if (cid == AMBA_CID)
                         dev->periphid = pid;
 
                 if (!dev->periphid)
diff --git a/drivers/ata/pata_pcmcia.c b/drivers/ata/pata_pcmcia.c
index e944aa0c5517..806292160b3f 100644
--- a/drivers/ata/pata_pcmcia.c
+++ b/drivers/ata/pata_pcmcia.c
@@ -34,7 +34,6 @@
 #include <linux/ata.h>
 #include <linux/libata.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/cisreg.h>
@@ -168,63 +167,26 @@ static struct ata_port_operations pcmcia_8bit_port_ops = {
 };
 
 
-struct pcmcia_config_check {
-        unsigned long ctl_base;
-        int skip_vcc;
-        int is_kme;
-};
-
-static int pcmcia_check_one_config(struct pcmcia_device *pdev,
-                                   cistpl_cftable_entry_t *cfg,
-                                   cistpl_cftable_entry_t *dflt,
-                                   unsigned int vcc,
-                                   void *priv_data)
+static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data)
 {
-        struct pcmcia_config_check *stk = priv_data;
-
-        /* Check for matching Vcc, unless we're desperate */
-        if (!stk->skip_vcc) {
-                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                }
+        int *is_kme = priv_data;
+
+        if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
+                pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
         }
+        pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                pdev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                pdev->resource[0]->start = io->win[0].base;
-                if (!(io->flags & CISTPL_IO_16BIT)) {
-                        pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                }
-                if (io->nwin == 2) {
-                        pdev->resource[0]->end = 8;
-                        pdev->resource[1]->start = io->win[1].base;
-                        pdev->resource[1]->end = (stk->is_kme) ? 2 : 1;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[1]->start;
-                } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
-                        pdev->resource[0]->end = io->win[0].len;
-                        pdev->resource[1]->end = 0;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[0]->start + 0x0e;
-                } else
+        if (pdev->resource[1]->end) {
+                pdev->resource[0]->end = 8;
+                pdev->resource[1]->end = (*is_kme) ? 2 : 1;
+        } else {
+                if (pdev->resource[0]->end < 16)
                         return -ENODEV;
-                /* If we've got this far, we're done */
-                return 0;
         }
-        return -ENODEV;
+
+        return pcmcia_request_io(pdev);
 }
 
 /**
@@ -239,7 +201,6 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
 {
         struct ata_host *host;
         struct ata_port *ap;
-        struct pcmcia_config_check *stk = NULL;
         int is_kme = 0, ret = -ENOMEM, p;
         unsigned long io_base, ctl_base;
         void __iomem *io_addr, *ctl_addr;
@@ -247,10 +208,8 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
         struct ata_port_operations *ops = &pcmcia_port_ops;
 
         /* Set up attributes in order to probe card and get resources */
-        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-        pdev->conf.Attributes = CONF_ENABLE_IRQ;
-        pdev->conf.IntType = INT_MEMORY_AND_IO;
+        pdev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO |
+                CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC;
 
         /* See if we have a manufacturer identifier. Use it to set is_kme for
            vendor quirks */
@@ -258,25 +217,21 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
                   ((pdev->card_id == PRODID_KME_KXLC005_A) ||
                    (pdev->card_id == PRODID_KME_KXLC005_B)));
 
-        /* Allocate resoure probing structures */
-
-        stk = kzalloc(sizeof(*stk), GFP_KERNEL);
-        if (!stk)
-                goto out1;
-        stk->is_kme = is_kme;
-        stk->skip_vcc = io_base = ctl_base = 0;
-
-        if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk)) {
-                stk->skip_vcc = 1;
-                if (pcmcia_loop_config(pdev, pcmcia_check_one_config, stk))
+        if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme)) {
+                pdev->config_flags &= ~CONF_AUTO_CHECK_VCC;
+                if (pcmcia_loop_config(pdev, pcmcia_check_one_config, &is_kme))
                         goto failed; /* No suitable config found */
         }
         io_base = pdev->resource[0]->start;
-        ctl_base = stk->ctl_base;
+        if (pdev->resource[1]->end)
+                ctl_base = pdev->resource[1]->start;
+        else
+                ctl_base = pdev->resource[0]->start + 0x0e;
+
         if (!pdev->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(pdev, &pdev->conf);
+        ret = pcmcia_enable_device(pdev);
         if (ret)
                 goto failed;
 
@@ -329,13 +284,10 @@ static int pcmcia_init_one(struct pcmcia_device *pdev)
                 goto failed;
 
         pdev->priv = host;
-        kfree(stk);
         return 0;
 
 failed:
-        kfree(stk);
         pcmcia_disable_device(pdev);
-out1:
         return ret;
 }
 
@@ -430,9 +382,7 @@ MODULE_DEVICE_TABLE(pcmcia, pcmcia_devices);
 
 static struct pcmcia_driver pcmcia_driver = {
         .owner          = THIS_MODULE,
-        .drv = {
-                .name           = DRV_NAME,
-        },
+        .name           = DRV_NAME,
         .id_table       = pcmcia_devices,
         .probe          = pcmcia_init_one,
         .remove         = pcmcia_remove_one,
diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c
index ee9ddeb53417..8cb0347dec28 100644
--- a/drivers/atm/iphase.c
+++ b/drivers/atm/iphase.c
@@ -3156,7 +3156,6 @@ static int __devinit ia_init_one(struct pci_dev *pdev,
 {  
         struct atm_dev *dev;  
         IADEV *iadev;  
-        unsigned long flags;
         int ret;
 
         iadev = kzalloc(sizeof(*iadev), GFP_KERNEL);
@@ -3188,19 +3187,14 @@ static int __devinit ia_init_one(struct pci_dev *pdev,
         ia_dev[iadev_count] = iadev;
         _ia_dev[iadev_count] = dev;
         iadev_count++;
-        spin_lock_init(&iadev->misc_lock);
-        /* First fixes first. I don't want to think about this now. */
-        spin_lock_irqsave(&iadev->misc_lock, flags); 
         if (ia_init(dev) || ia_start(dev)) {  
                 IF_INIT(printk("IA register failed!\n");)
                 iadev_count--;
                 ia_dev[iadev_count] = NULL;
                 _ia_dev[iadev_count] = NULL;
-                spin_unlock_irqrestore(&iadev->misc_lock, flags); 
                 ret = -EINVAL;
                 goto err_out_deregister_dev;
         }
-        spin_unlock_irqrestore(&iadev->misc_lock, flags); 
         IF_EVENT(printk("iadev_count = %d\n", iadev_count);)
 
         iadev->next_board = ia_boards;  
diff --git a/drivers/atm/iphase.h b/drivers/atm/iphase.h
index b2cd20f549cb..077735e0e04b 100644
--- a/drivers/atm/iphase.h
+++ b/drivers/atm/iphase.h
@@ -1022,7 +1022,7 @@ typedef struct iadev_t {
         struct dle_q rx_dle_q;  
         struct free_desc_q *rx_free_desc_qhead;  
         struct sk_buff_head rx_dma_q;  
-        spinlock_t rx_lock, misc_lock;
+        spinlock_t rx_lock;
         struct atm_vcc **rx_open;       /* list of all open VCs */  
         u16 num_rx_desc, rx_buf_sz, rxing;
         u32 rx_pkt_ram, rx_tmp_cnt;
diff --git a/drivers/atm/solos-pci.c b/drivers/atm/solos-pci.c
index f916ddf63938..f46138ab38b6 100644
--- a/drivers/atm/solos-pci.c
+++ b/drivers/atm/solos-pci.c
@@ -444,6 +444,7 @@ static ssize_t console_show(struct device *dev, struct device_attribute *attr,
         struct atm_dev *atmdev = container_of(dev, struct atm_dev, class_dev);
         struct solos_card *card = atmdev->dev_data;
         struct sk_buff *skb;
+        unsigned int len;
 
         spin_lock(&card->cli_queue_lock);
         skb = skb_dequeue(&card->cli_queue[SOLOS_CHAN(atmdev)]);
@@ -451,11 +452,12 @@ static ssize_t console_show(struct device *dev, struct device_attribute *attr,
         if(skb == NULL)
                 return sprintf(buf, "No data.\n");
 
-        memcpy(buf, skb->data, skb->len);
-        dev_dbg(&card->dev->dev, "len: %d\n", skb->len);
+        len = skb->len;
+        memcpy(buf, skb->data, len);
+        dev_dbg(&card->dev->dev, "len: %d\n", len);
 
         kfree_skb(skb);
-        return skb->len;
+        return len;
 }
 
 static int send_command(struct solos_card *card, int dev, const char *buf, size_t size)
diff --git a/drivers/base/power/Makefile b/drivers/base/power/Makefile
index cbccf9a3cee4..abe46edfe5b4 100644
--- a/drivers/base/power/Makefile
+++ b/drivers/base/power/Makefile
@@ -3,6 +3,7 @@ obj-$(CONFIG_PM_SLEEP)	+= main.o wakeup.o
 obj-$(CONFIG_PM_RUNTIME)        += runtime.o
 obj-$(CONFIG_PM_OPS)    += generic_ops.o
 obj-$(CONFIG_PM_TRACE_RTC)      += trace.o
+obj-$(CONFIG_PM_OPP)    += opp.o
 
 ccflags-$(CONFIG_DEBUG_DRIVER) := -DDEBUG
 ccflags-$(CONFIG_PM_VERBOSE)   += -DDEBUG
diff --git a/drivers/base/power/generic_ops.c b/drivers/base/power/generic_ops.c
index 4b29d4981253..81f2c84697f4 100644
--- a/drivers/base/power/generic_ops.c
+++ b/drivers/base/power/generic_ops.c
@@ -46,7 +46,7 @@ int pm_generic_runtime_suspend(struct device *dev)
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
         int ret;
 
-        ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : -EINVAL;
+        ret = pm && pm->runtime_suspend ? pm->runtime_suspend(dev) : 0;
 
         return ret;
 }
@@ -65,7 +65,7 @@ int pm_generic_runtime_resume(struct device *dev)
         const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;
         int ret;
 
-        ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : -EINVAL;
+        ret = pm && pm->runtime_resume ? pm->runtime_resume(dev) : 0;
 
         return ret;
 }
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 276d5a701dc3..31b526661ec4 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -51,6 +51,8 @@ static pm_message_t pm_transition;
  */
 static bool transition_started;
 
+static int async_error;
+
 /**
  * device_pm_init - Initialize the PM-related part of a device object.
  * @dev: Device object being initialized.
@@ -60,7 +62,8 @@ void device_pm_init(struct device *dev)
         dev->power.status = DPM_ON;
         init_completion(&dev->power.completion);
         complete_all(&dev->power.completion);
-        dev->power.wakeup_count = 0;
+        dev->power.wakeup = NULL;
+        spin_lock_init(&dev->power.lock);
         pm_runtime_init(dev);
 }
 
@@ -120,6 +123,7 @@ void device_pm_remove(struct device *dev)
         mutex_lock(&dpm_list_mtx);
         list_del_init(&dev->power.entry);
         mutex_unlock(&dpm_list_mtx);
+        device_wakeup_disable(dev);
         pm_runtime_remove(dev);
 }
 
@@ -407,7 +411,7 @@ static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
 static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
 {
         ktime_t calltime;
-        s64 usecs64;
+        u64 usecs64;
         int usecs;
 
         calltime = ktime_get();
@@ -600,6 +604,7 @@ static void dpm_resume(pm_message_t state)
         INIT_LIST_HEAD(&list);
         mutex_lock(&dpm_list_mtx);
         pm_transition = state;
+        async_error = 0;
 
         list_for_each_entry(dev, &dpm_list, power.entry) {
                 if (dev->power.status < DPM_OFF)
@@ -829,8 +834,6 @@ static int legacy_suspend(struct device *dev, pm_message_t state,
         return error;
 }
 
-static int async_error;
-
 /**
  * device_suspend - Execute "suspend" callbacks for given device.
  * @dev: Device to handle.
@@ -885,6 +888,9 @@ static int __device_suspend(struct device *dev, pm_message_t state, bool async)
         device_unlock(dev);
         complete_all(&dev->power.completion);
 
+        if (error)
+                async_error = error;
+
         return error;
 }
 
@@ -894,10 +900,8 @@ static void async_suspend(void *data, async_cookie_t cookie)
         int error;
 
         error = __device_suspend(dev, pm_transition, true);
-        if (error) {
+        if (error)
                 pm_dev_err(dev, pm_transition, " async", error);
-                async_error = error;
-        }
 
         put_device(dev);
 }
@@ -1085,8 +1089,9 @@ EXPORT_SYMBOL_GPL(__suspend_report_result);
  * @dev: Device to wait for.
  * @subordinate: Device that needs to wait for @dev.
  */
-void device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
+int device_pm_wait_for_dev(struct device *subordinate, struct device *dev)
 {
         dpm_wait(dev, subordinate->power.async_suspend);
+        return async_error;
 }
 EXPORT_SYMBOL_GPL(device_pm_wait_for_dev);
diff --git a/drivers/base/power/opp.c b/drivers/base/power/opp.c
new file mode 100644
index 000000000000..2bb9b4cf59d7
--- /dev/null
+++ b/drivers/base/power/opp.c
@@ -0,0 +1,628 @@
+/*
+ * Generic OPP Interface
+ *
+ * Copyright (C) 2009-2010 Texas Instruments Incorporated.
+ *      Nishanth Menon
+ *      Romit Dasgupta
+ *      Kevin Hilman
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/errno.h>
+#include <linux/err.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/cpufreq.h>
+#include <linux/list.h>
+#include <linux/rculist.h>
+#include <linux/rcupdate.h>
+#include <linux/opp.h>
+
+/*
+ * Internal data structure organization with the OPP layer library is as
+ * follows:
+ * dev_opp_list (root)
+ *      |- device 1 (represents voltage domain 1)
+ *      |       |- opp 1 (availability, freq, voltage)
+ *      |       |- opp 2 ..
+ *      ...     ...
+ *      |       `- opp n ..
+ *      |- device 2 (represents the next voltage domain)
+ *      ...
+ *      `- device m (represents mth voltage domain)
+ * device 1, 2.. are represented by dev_opp structure while each opp
+ * is represented by the opp structure.
+ */
+
+/**
+ * struct opp - Generic OPP description structure
+ * @node:       opp list node. The nodes are maintained throughout the lifetime
+ *              of boot. It is expected only an optimal set of OPPs are
+ *              added to the library by the SoC framework.
+ *              RCU usage: opp list is traversed with RCU locks. node
+ *              modification is possible realtime, hence the modifications
+ *              are protected by the dev_opp_list_lock for integrity.
+ *              IMPORTANT: the opp nodes should be maintained in increasing
+ *              order.
+ * @available:  true/false - marks if this OPP as available or not
+ * @rate:       Frequency in hertz
+ * @u_volt:     Nominal voltage in microvolts corresponding to this OPP
+ * @dev_opp:    points back to the device_opp struct this opp belongs to
+ *
+ * This structure stores the OPP information for a given device.
+ */
+struct opp {
+        struct list_head node;
+
+        bool available;
+        unsigned long rate;
+        unsigned long u_volt;
+
+        struct device_opp *dev_opp;
+};
+
+/**
+ * struct device_opp - Device opp structure
+ * @node:       list node - contains the devices with OPPs that
+ *              have been registered. Nodes once added are not modified in this
+ *              list.
+ *              RCU usage: nodes are not modified in the list of device_opp,
+ *              however addition is possible and is secured by dev_opp_list_lock
+ * @dev:        device pointer
+ * @opp_list:   list of opps
+ *
+ * This is an internal data structure maintaining the link to opps attached to
+ * a device. This structure is not meant to be shared to users as it is
+ * meant for book keeping and private to OPP library
+ */
+struct device_opp {
+        struct list_head node;
+
+        struct device *dev;
+        struct list_head opp_list;
+};
+
+/*
+ * The root of the list of all devices. All device_opp structures branch off
+ * from here, with each device_opp containing the list of opp it supports in
+ * various states of availability.
+ */
+static LIST_HEAD(dev_opp_list);
+/* Lock to allow exclusive modification to the device and opp lists */
+static DEFINE_MUTEX(dev_opp_list_lock);
+
+/**
+ * find_device_opp() - find device_opp struct using device pointer
+ * @dev:        device pointer used to lookup device OPPs
+ *
+ * Search list of device OPPs for one containing matching device. Does a RCU
+ * reader operation to grab the pointer needed.
+ *
+ * Returns pointer to 'struct device_opp' if found, otherwise -ENODEV or
+ * -EINVAL based on type of error.
+ *
+ * Locking: This function must be called under rcu_read_lock(). device_opp
+ * is a RCU protected pointer. This means that device_opp is valid as long
+ * as we are under RCU lock.
+ */
+static struct device_opp *find_device_opp(struct device *dev)
+{
+        struct device_opp *tmp_dev_opp, *dev_opp = ERR_PTR(-ENODEV);
+
+        if (unlikely(IS_ERR_OR_NULL(dev))) {
+                pr_err("%s: Invalid parameters\n", __func__);
+                return ERR_PTR(-EINVAL);
+        }
+
+        list_for_each_entry_rcu(tmp_dev_opp, &dev_opp_list, node) {
+                if (tmp_dev_opp->dev == dev) {
+                        dev_opp = tmp_dev_opp;
+                        break;
+                }
+        }
+
+        return dev_opp;
+}
+
+/**
+ * opp_get_voltage() - Gets the voltage corresponding to an available opp
+ * @opp:        opp for which voltage has to be returned for
+ *
+ * Return voltage in micro volt corresponding to the opp, else
+ * return 0
+ *
+ * Locking: This function must be called under rcu_read_lock(). opp is a rcu
+ * protected pointer. This means that opp which could have been fetched by
+ * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
+ * under RCU lock. The pointer returned by the opp_find_freq family must be
+ * used in the same section as the usage of this function with the pointer
+ * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
+ * pointer.
+ */
+unsigned long opp_get_voltage(struct opp *opp)
+{
+        struct opp *tmp_opp;
+        unsigned long v = 0;
+
+        tmp_opp = rcu_dereference(opp);
+        if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
+                pr_err("%s: Invalid parameters\n", __func__);
+        else
+                v = tmp_opp->u_volt;
+
+        return v;
+}
+
+/**
+ * opp_get_freq() - Gets the frequency corresponding to an available opp
+ * @opp:        opp for which frequency has to be returned for
+ *
+ * Return frequency in hertz corresponding to the opp, else
+ * return 0
+ *
+ * Locking: This function must be called under rcu_read_lock(). opp is a rcu
+ * protected pointer. This means that opp which could have been fetched by
+ * opp_find_freq_{exact,ceil,floor} functions is valid as long as we are
+ * under RCU lock. The pointer returned by the opp_find_freq family must be
+ * used in the same section as the usage of this function with the pointer
+ * prior to unlocking with rcu_read_unlock() to maintain the integrity of the
+ * pointer.
+ */
+unsigned long opp_get_freq(struct opp *opp)
+{
+        struct opp *tmp_opp;
+        unsigned long f = 0;
+
+        tmp_opp = rcu_dereference(opp);
+        if (unlikely(IS_ERR_OR_NULL(tmp_opp)) || !tmp_opp->available)
+                pr_err("%s: Invalid parameters\n", __func__);
+        else
+                f = tmp_opp->rate;
+
+        return f;
+}
+
+/**
+ * opp_get_opp_count() - Get number of opps available in the opp list
+ * @dev:        device for which we do this operation
+ *
+ * This function returns the number of available opps if there are any,
+ * else returns 0 if none or the corresponding error value.
+ *
+ * Locking: This function must be called under rcu_read_lock(). This function
+ * internally references two RCU protected structures: device_opp and opp which
+ * are safe as long as we are under a common RCU locked section.
+ */
+int opp_get_opp_count(struct device *dev)
+{
+        struct device_opp *dev_opp;
+        struct opp *temp_opp;
+        int count = 0;
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp)) {
+                int r = PTR_ERR(dev_opp);
+                dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
+                return r;
+        }
+
+        list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
+                if (temp_opp->available)
+                        count++;
+        }
+
+        return count;
+}
+
+/**
+ * opp_find_freq_exact() - search for an exact frequency
+ * @dev:                device for which we do this operation
+ * @freq:               frequency to search for
+ * @is_available:       true/false - match for available opp
+ *
+ * Searches for exact match in the opp list and returns pointer to the matching
+ * opp if found, else returns ERR_PTR in case of error and should be handled
+ * using IS_ERR.
+ *
+ * Note: available is a modifier for the search. if available=true, then the
+ * match is for exact matching frequency and is available in the stored OPP
+ * table. if false, the match is for exact frequency which is not available.
+ *
+ * This provides a mechanism to enable an opp which is not available currently
+ * or the opposite as well.
+ *
+ * Locking: This function must be called under rcu_read_lock(). opp is a rcu
+ * protected pointer. The reason for the same is that the opp pointer which is
+ * returned will remain valid for use with opp_get_{voltage, freq} only while
+ * under the locked area. The pointer returned must be used prior to unlocking
+ * with rcu_read_unlock() to maintain the integrity of the pointer.
+ */
+struct opp *opp_find_freq_exact(struct device *dev, unsigned long freq,
+                                bool available)
+{
+        struct device_opp *dev_opp;
+        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp)) {
+                int r = PTR_ERR(dev_opp);
+                dev_err(dev, "%s: device OPP not found (%d)\n", __func__, r);
+                return ERR_PTR(r);
+        }
+
+        list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
+                if (temp_opp->available == available &&
+                                temp_opp->rate == freq) {
+                        opp = temp_opp;
+                        break;
+                }
+        }
+
+        return opp;
+}
+
+/**
+ * opp_find_freq_ceil() - Search for an rounded ceil freq
+ * @dev:        device for which we do this operation
+ * @freq:       Start frequency
+ *
+ * Search for the matching ceil *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Locking: This function must be called under rcu_read_lock(). opp is a rcu
+ * protected pointer. The reason for the same is that the opp pointer which is
+ * returned will remain valid for use with opp_get_{voltage, freq} only while
+ * under the locked area. The pointer returned must be used prior to unlocking
+ * with rcu_read_unlock() to maintain the integrity of the pointer.
+ */
+struct opp *opp_find_freq_ceil(struct device *dev, unsigned long *freq)
+{
+        struct device_opp *dev_opp;
+        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+        if (!dev || !freq) {
+                dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
+                return ERR_PTR(-EINVAL);
+        }
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp))
+                return opp;
+
+        list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
+                if (temp_opp->available && temp_opp->rate >= *freq) {
+                        opp = temp_opp;
+                        *freq = opp->rate;
+                        break;
+                }
+        }
+
+        return opp;
+}
+
+/**
+ * opp_find_freq_floor() - Search for a rounded floor freq
+ * @dev:        device for which we do this operation
+ * @freq:       Start frequency
+ *
+ * Search for the matching floor *available* OPP from a starting freq
+ * for a device.
+ *
+ * Returns matching *opp and refreshes *freq accordingly, else returns
+ * ERR_PTR in case of error and should be handled using IS_ERR.
+ *
+ * Locking: This function must be called under rcu_read_lock(). opp is a rcu
+ * protected pointer. The reason for the same is that the opp pointer which is
+ * returned will remain valid for use with opp_get_{voltage, freq} only while
+ * under the locked area. The pointer returned must be used prior to unlocking
+ * with rcu_read_unlock() to maintain the integrity of the pointer.
+ */
+struct opp *opp_find_freq_floor(struct device *dev, unsigned long *freq)
+{
+        struct device_opp *dev_opp;
+        struct opp *temp_opp, *opp = ERR_PTR(-ENODEV);
+
+        if (!dev || !freq) {
+                dev_err(dev, "%s: Invalid argument freq=%p\n", __func__, freq);
+                return ERR_PTR(-EINVAL);
+        }
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp))
+                return opp;
+
+        list_for_each_entry_rcu(temp_opp, &dev_opp->opp_list, node) {
+                if (temp_opp->available) {
+                        /* go to the next node, before choosing prev */
+                        if (temp_opp->rate > *freq)
+                                break;
+                        else
+                                opp = temp_opp;
+                }
+        }
+        if (!IS_ERR(opp))
+                *freq = opp->rate;
+
+        return opp;
+}
+
+/**
+ * opp_add()  - Add an OPP table from a table definitions
+ * @dev:        device for which we do this operation
+ * @freq:       Frequency in Hz for this OPP
+ * @u_volt:     Voltage in uVolts for this OPP
+ *
+ * This function adds an opp definition to the opp list and returns status.
+ * The opp is made available by default and it can be controlled using
+ * opp_enable/disable functions.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Hence this function internally uses RCU updater strategy with mutex locks
+ * to keep the integrity of the internal data structures. Callers should ensure
+ * that this function is *NOT* called under RCU protection or in contexts where
+ * mutex cannot be locked.
+ */
+int opp_add(struct device *dev, unsigned long freq, unsigned long u_volt)
+{
+        struct device_opp *dev_opp = NULL;
+        struct opp *opp, *new_opp;
+        struct list_head *head;
+
+        /* allocate new OPP node */
+        new_opp = kzalloc(sizeof(struct opp), GFP_KERNEL);
+        if (!new_opp) {
+                dev_warn(dev, "%s: Unable to create new OPP node\n", __func__);
+                return -ENOMEM;
+        }
+
+        /* Hold our list modification lock here */
+        mutex_lock(&dev_opp_list_lock);
+
+        /* Check for existing list for 'dev' */
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp)) {
+                /*
+                 * Allocate a new device OPP table. In the infrequent case
+                 * where a new device is needed to be added, we pay this
+                 * penalty.
+                 */
+                dev_opp = kzalloc(sizeof(struct device_opp), GFP_KERNEL);
+                if (!dev_opp) {
+                        mutex_unlock(&dev_opp_list_lock);
+                        kfree(new_opp);
+                        dev_warn(dev,
+                                "%s: Unable to create device OPP structure\n",
+                                __func__);
+                        return -ENOMEM;
+                }
+
+                dev_opp->dev = dev;
+                INIT_LIST_HEAD(&dev_opp->opp_list);
+
+                /* Secure the device list modification */
+                list_add_rcu(&dev_opp->node, &dev_opp_list);
+        }
+
+        /* populate the opp table */
+        new_opp->dev_opp = dev_opp;
+        new_opp->rate = freq;
+        new_opp->u_volt = u_volt;
+        new_opp->available = true;
+
+        /* Insert new OPP in order of increasing frequency */
+        head = &dev_opp->opp_list;
+        list_for_each_entry_rcu(opp, &dev_opp->opp_list, node) {
+                if (new_opp->rate < opp->rate)
+                        break;
+                else
+                        head = &opp->node;
+        }
+
+        list_add_rcu(&new_opp->node, head);
+        mutex_unlock(&dev_opp_list_lock);
+
+        return 0;
+}
+
+/**
+ * opp_set_availability() - helper to set the availability of an opp
+ * @dev:                device for which we do this operation
+ * @freq:               OPP frequency to modify availability
+ * @availability_req:   availability status requested for this opp
+ *
+ * Set the availability of an OPP with an RCU operation, opp_{enable,disable}
+ * share a common logic which is isolated here.
+ *
+ * Returns -EINVAL for bad pointers, -ENOMEM if no memory available for the
+ * copy operation, returns 0 if no modifcation was done OR modification was
+ * successful.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Hence this function internally uses RCU updater strategy with mutex locks to
+ * keep the integrity of the internal data structures. Callers should ensure
+ * that this function is *NOT* called under RCU protection or in contexts where
+ * mutex locking or synchronize_rcu() blocking calls cannot be used.
+ */
+static int opp_set_availability(struct device *dev, unsigned long freq,
+                bool availability_req)
+{
+        struct device_opp *tmp_dev_opp, *dev_opp = NULL;
+        struct opp *new_opp, *tmp_opp, *opp = ERR_PTR(-ENODEV);
+        int r = 0;
+
+        /* keep the node allocated */
+        new_opp = kmalloc(sizeof(struct opp), GFP_KERNEL);
+        if (!new_opp) {
+                dev_warn(dev, "%s: Unable to create OPP\n", __func__);
+                return -ENOMEM;
+        }
+
+        mutex_lock(&dev_opp_list_lock);
+
+        /* Find the device_opp */
+        list_for_each_entry(tmp_dev_opp, &dev_opp_list, node) {
+                if (dev == tmp_dev_opp->dev) {
+                        dev_opp = tmp_dev_opp;
+                        break;
+                }
+        }
+        if (IS_ERR(dev_opp)) {
+                r = PTR_ERR(dev_opp);
+                dev_warn(dev, "%s: Device OPP not found (%d)\n", __func__, r);
+                goto unlock;
+        }
+
+        /* Do we have the frequency? */
+        list_for_each_entry(tmp_opp, &dev_opp->opp_list, node) {
+                if (tmp_opp->rate == freq) {
+                        opp = tmp_opp;
+                        break;
+                }
+        }
+        if (IS_ERR(opp)) {
+                r = PTR_ERR(opp);
+                goto unlock;
+        }
+
+        /* Is update really needed? */
+        if (opp->available == availability_req)
+                goto unlock;
+        /* copy the old data over */
+        *new_opp = *opp;
+
+        /* plug in new node */
+        new_opp->available = availability_req;
+
+        list_replace_rcu(&opp->node, &new_opp->node);
+        mutex_unlock(&dev_opp_list_lock);
+        synchronize_rcu();
+
+        /* clean up old opp */
+        new_opp = opp;
+        goto out;
+
+unlock:
+        mutex_unlock(&dev_opp_list_lock);
+out:
+        kfree(new_opp);
+        return r;
+}
+
+/**
+ * opp_enable() - Enable a specific OPP
+ * @dev:        device for which we do this operation
+ * @freq:       OPP frequency to enable
+ *
+ * Enables a provided opp. If the operation is valid, this returns 0, else the
+ * corresponding error value. It is meant to be used for users an OPP available
+ * after being temporarily made unavailable with opp_disable.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Hence this function indirectly uses RCU and mutex locks to keep the
+ * integrity of the internal data structures. Callers should ensure that
+ * this function is *NOT* called under RCU protection or in contexts where
+ * mutex locking or synchronize_rcu() blocking calls cannot be used.
+ */
+int opp_enable(struct device *dev, unsigned long freq)
+{
+        return opp_set_availability(dev, freq, true);
+}
+
+/**
+ * opp_disable() - Disable a specific OPP
+ * @dev:        device for which we do this operation
+ * @freq:       OPP frequency to disable
+ *
+ * Disables a provided opp. If the operation is valid, this returns
+ * 0, else the corresponding error value. It is meant to be a temporary
+ * control by users to make this OPP not available until the circumstances are
+ * right to make it available again (with a call to opp_enable).
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * Hence this function indirectly uses RCU and mutex locks to keep the
+ * integrity of the internal data structures. Callers should ensure that
+ * this function is *NOT* called under RCU protection or in contexts where
+ * mutex locking or synchronize_rcu() blocking calls cannot be used.
+ */
+int opp_disable(struct device *dev, unsigned long freq)
+{
+        return opp_set_availability(dev, freq, false);
+}
+
+#ifdef CONFIG_CPU_FREQ
+/**
+ * opp_init_cpufreq_table() - create a cpufreq table for a device
+ * @dev:        device for which we do this operation
+ * @table:      Cpufreq table returned back to caller
+ *
+ * Generate a cpufreq table for a provided device- this assumes that the
+ * opp list is already initialized and ready for usage.
+ *
+ * This function allocates required memory for the cpufreq table. It is
+ * expected that the caller does the required maintenance such as freeing
+ * the table as required.
+ *
+ * Returns -EINVAL for bad pointers, -ENODEV if the device is not found, -ENOMEM
+ * if no memory available for the operation (table is not populated), returns 0
+ * if successful and table is populated.
+ *
+ * WARNING: It is  important for the callers to ensure refreshing their copy of
+ * the table if any of the mentioned functions have been invoked in the interim.
+ *
+ * Locking: The internal device_opp and opp structures are RCU protected.
+ * To simplify the logic, we pretend we are updater and hold relevant mutex here
+ * Callers should ensure that this function is *NOT* called under RCU protection
+ * or in contexts where mutex locking cannot be used.
+ */
+int opp_init_cpufreq_table(struct device *dev,
+                            struct cpufreq_frequency_table **table)
+{
+        struct device_opp *dev_opp;
+        struct opp *opp;
+        struct cpufreq_frequency_table *freq_table;
+        int i = 0;
+
+        /* Pretend as if I am an updater */
+        mutex_lock(&dev_opp_list_lock);
+
+        dev_opp = find_device_opp(dev);
+        if (IS_ERR(dev_opp)) {
+                int r = PTR_ERR(dev_opp);
+                mutex_unlock(&dev_opp_list_lock);
+                dev_err(dev, "%s: Device OPP not found (%d)\n", __func__, r);
+                return r;
+        }
+
+        freq_table = kzalloc(sizeof(struct cpufreq_frequency_table) *
+                             (opp_get_opp_count(dev) + 1), GFP_KERNEL);
+        if (!freq_table) {
+                mutex_unlock(&dev_opp_list_lock);
+                dev_warn(dev, "%s: Unable to allocate frequency table\n",
+                        __func__);
+                return -ENOMEM;
+        }
+
+        list_for_each_entry(opp, &dev_opp->opp_list, node) {
+                if (opp->available) {
+                        freq_table[i].index = i;
+                        freq_table[i].frequency = opp->rate / 1000;
+                        i++;
+                }
+        }
+        mutex_unlock(&dev_opp_list_lock);
+
+        freq_table[i].index = i;
+        freq_table[i].frequency = CPUFREQ_TABLE_END;
+
+        *table = &freq_table[0];
+
+        return 0;
+}
+#endif          /* CONFIG_CPU_FREQ */
diff --git a/drivers/base/power/power.h b/drivers/base/power/power.h
index c0bd03c83b9c..698dde742587 100644
--- a/drivers/base/power/power.h
+++ b/drivers/base/power/power.h
@@ -34,6 +34,7 @@ extern void device_pm_move_last(struct device *);
 
 static inline void device_pm_init(struct device *dev)
 {
+        spin_lock_init(&dev->power.lock);
         pm_runtime_init(dev);
 }
 
@@ -59,6 +60,7 @@ static inline void device_pm_move_last(struct device *dev) {}
 
 extern int dpm_sysfs_add(struct device *);
 extern void dpm_sysfs_remove(struct device *);
+extern void rpm_sysfs_remove(struct device *);
 
 #else /* CONFIG_PM */
 
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index b78c401ffa73..1dd8676d7f55 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -2,17 +2,55 @@
  * drivers/base/power/runtime.c - Helper functions for device run-time PM
  *
  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
+ * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
  *
  * This file is released under the GPLv2.
  */
 
 #include <linux/sched.h>
 #include <linux/pm_runtime.h>
-#include <linux/jiffies.h>
+#include "power.h"
 
-static int __pm_runtime_resume(struct device *dev, bool from_wq);
-static int __pm_request_idle(struct device *dev);
-static int __pm_request_resume(struct device *dev);
+static int rpm_resume(struct device *dev, int rpmflags);
+static int rpm_suspend(struct device *dev, int rpmflags);
+
+/**
+ * update_pm_runtime_accounting - Update the time accounting of power states
+ * @dev: Device to update the accounting for
+ *
+ * In order to be able to have time accounting of the various power states
+ * (as used by programs such as PowerTOP to show the effectiveness of runtime
+ * PM), we need to track the time spent in each state.
+ * update_pm_runtime_accounting must be called each time before the
+ * runtime_status field is updated, to account the time in the old state
+ * correctly.
+ */
+void update_pm_runtime_accounting(struct device *dev)
+{
+        unsigned long now = jiffies;
+        int delta;
+
+        delta = now - dev->power.accounting_timestamp;
+
+        if (delta < 0)
+                delta = 0;
+
+        dev->power.accounting_timestamp = now;
+
+        if (dev->power.disable_depth > 0)
+                return;
+
+        if (dev->power.runtime_status == RPM_SUSPENDED)
+                dev->power.suspended_jiffies += delta;
+        else
+                dev->power.active_jiffies += delta;
+}
+
+static void __update_runtime_status(struct device *dev, enum rpm_status status)
+{
+        update_pm_runtime_accounting(dev);
+        dev->power.runtime_status = status;
+}
 
 /**
  * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
@@ -40,62 +78,154 @@ static void pm_runtime_cancel_pending(struct device *dev)
         dev->power.request = RPM_REQ_NONE;
 }
 
-/**
- * __pm_runtime_idle - Notify device bus type if the device can be suspended.
- * @dev: Device to notify the bus type about.
+/*
+ * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
+ * @dev: Device to handle.
  *
- * This function must be called under dev->power.lock with interrupts disabled.
+ * Compute the autosuspend-delay expiration time based on the device's
+ * power.last_busy time.  If the delay has already expired or is disabled
+ * (negative) or the power.use_autosuspend flag isn't set, return 0.
+ * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
+ *
+ * This function may be called either with or without dev->power.lock held.
+ * Either way it can be racy, since power.last_busy may be updated at any time.
  */
-static int __pm_runtime_idle(struct device *dev)
-        __releases(&dev->power.lock) __acquires(&dev->power.lock)
+unsigned long pm_runtime_autosuspend_expiration(struct device *dev)
+{
+        int autosuspend_delay;
+        long elapsed;
+        unsigned long last_busy;
+        unsigned long expires = 0;
+
+        if (!dev->power.use_autosuspend)
+                goto out;
+
+        autosuspend_delay = ACCESS_ONCE(dev->power.autosuspend_delay);
+        if (autosuspend_delay < 0)
+                goto out;
+
+        last_busy = ACCESS_ONCE(dev->power.last_busy);
+        elapsed = jiffies - last_busy;
+        if (elapsed < 0)
+                goto out;       /* jiffies has wrapped around. */
+
+        /*
+         * If the autosuspend_delay is >= 1 second, align the timer by rounding
+         * up to the nearest second.
+         */
+        expires = last_busy + msecs_to_jiffies(autosuspend_delay);
+        if (autosuspend_delay >= 1000)
+                expires = round_jiffies(expires);
+        expires += !expires;
+        if (elapsed >= expires - last_busy)
+                expires = 0;    /* Already expired. */
+
+ out:
+        return expires;
+}
+EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
+
+/**
+ * rpm_check_suspend_allowed - Test whether a device may be suspended.
+ * @dev: Device to test.
+ */
+static int rpm_check_suspend_allowed(struct device *dev)
 {
         int retval = 0;
 
         if (dev->power.runtime_error)
                 retval = -EINVAL;
-        else if (dev->power.idle_notification)
-                retval = -EINPROGRESS;
         else if (atomic_read(&dev->power.usage_count) > 0
-            || dev->power.disable_depth > 0
-            || dev->power.runtime_status != RPM_ACTIVE)
+            || dev->power.disable_depth > 0)
                 retval = -EAGAIN;
         else if (!pm_children_suspended(dev))
                 retval = -EBUSY;
+
+        /* Pending resume requests take precedence over suspends. */
+        else if ((dev->power.deferred_resume
+                        && dev->power.status == RPM_SUSPENDING)
+            || (dev->power.request_pending
+                        && dev->power.request == RPM_REQ_RESUME))
+                retval = -EAGAIN;
+        else if (dev->power.runtime_status == RPM_SUSPENDED)
+                retval = 1;
+
+        return retval;
+}
+
+/**
+ * rpm_idle - Notify device bus type if the device can be suspended.
+ * @dev: Device to notify the bus type about.
+ * @rpmflags: Flag bits.
+ *
+ * Check if the device's run-time PM status allows it to be suspended.  If
+ * another idle notification has been started earlier, return immediately.  If
+ * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
+ * run the ->runtime_idle() callback directly.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static int rpm_idle(struct device *dev, int rpmflags)
+{
+        int (*callback)(struct device *);
+        int retval;
+
+        retval = rpm_check_suspend_allowed(dev);
+        if (retval < 0)
+                ;       /* Conditions are wrong. */
+
+        /* Idle notifications are allowed only in the RPM_ACTIVE state. */
+        else if (dev->power.runtime_status != RPM_ACTIVE)
+                retval = -EAGAIN;
+
+        /*
+         * Any pending request other than an idle notification takes
+         * precedence over us, except that the timer may be running.
+         */
+        else if (dev->power.request_pending &&
+            dev->power.request > RPM_REQ_IDLE)
+                retval = -EAGAIN;
+
+        /* Act as though RPM_NOWAIT is always set. */
+        else if (dev->power.idle_notification)
+                retval = -EINPROGRESS;
         if (retval)
                 goto out;
 
-        if (dev->power.request_pending) {
-                /*
-                 * If an idle notification request is pending, cancel it.  Any
-                 * other pending request takes precedence over us.
-                 */
-                if (dev->power.request == RPM_REQ_IDLE) {
-                        dev->power.request = RPM_REQ_NONE;
-                } else if (dev->power.request != RPM_REQ_NONE) {
-                        retval = -EAGAIN;
-                        goto out;
+        /* Pending requests need to be canceled. */
+        dev->power.request = RPM_REQ_NONE;
+
+        if (dev->power.no_callbacks) {
+                /* Assume ->runtime_idle() callback would have suspended. */
+                retval = rpm_suspend(dev, rpmflags);
+                goto out;
+        }
+
+        /* Carry out an asynchronous or a synchronous idle notification. */
+        if (rpmflags & RPM_ASYNC) {
+                dev->power.request = RPM_REQ_IDLE;
+                if (!dev->power.request_pending) {
+                        dev->power.request_pending = true;
+                        queue_work(pm_wq, &dev->power.work);
                 }
+                goto out;
         }
 
         dev->power.idle_notification = true;
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {
-                spin_unlock_irq(&dev->power.lock);
-
-                dev->bus->pm->runtime_idle(dev);
-
-                spin_lock_irq(&dev->power.lock);
-        } else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
-                spin_unlock_irq(&dev->power.lock);
-
-                dev->type->pm->runtime_idle(dev);
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle)
+                callback = dev->bus->pm->runtime_idle;
+        else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle)
+                callback = dev->type->pm->runtime_idle;
+        else if (dev->class && dev->class->pm)
+                callback = dev->class->pm->runtime_idle;
+        else
+                callback = NULL;
 
-                spin_lock_irq(&dev->power.lock);
-        } else if (dev->class && dev->class->pm
-            && dev->class->pm->runtime_idle) {
+        if (callback) {
                 spin_unlock_irq(&dev->power.lock);
 
-                dev->class->pm->runtime_idle(dev);
+                callback(dev);
 
                 spin_lock_irq(&dev->power.lock);
         }
@@ -108,113 +238,99 @@ static int __pm_runtime_idle(struct device *dev)
 }
 
 /**
- * pm_runtime_idle - Notify device bus type if the device can be suspended.
- * @dev: Device to notify the bus type about.
+ * rpm_callback - Run a given runtime PM callback for a given device.
+ * @cb: Runtime PM callback to run.
+ * @dev: Device to run the callback for.
  */
-int pm_runtime_idle(struct device *dev)
+static int rpm_callback(int (*cb)(struct device *), struct device *dev)
+        __releases(&dev->power.lock) __acquires(&dev->power.lock)
 {
         int retval;
 
-        spin_lock_irq(&dev->power.lock);
-        retval = __pm_runtime_idle(dev);
-        spin_unlock_irq(&dev->power.lock);
+        if (!cb)
+                return -ENOSYS;
 
-        return retval;
-}
-EXPORT_SYMBOL_GPL(pm_runtime_idle);
-
-
-/**
- * update_pm_runtime_accounting - Update the time accounting of power states
- * @dev: Device to update the accounting for
- *
- * In order to be able to have time accounting of the various power states
- * (as used by programs such as PowerTOP to show the effectiveness of runtime
- * PM), we need to track the time spent in each state.
- * update_pm_runtime_accounting must be called each time before the
- * runtime_status field is updated, to account the time in the old state
- * correctly.
- */
-void update_pm_runtime_accounting(struct device *dev)
-{
-        unsigned long now = jiffies;
-        int delta;
-
-        delta = now - dev->power.accounting_timestamp;
-
-        if (delta < 0)
-                delta = 0;
+        spin_unlock_irq(&dev->power.lock);
 
-        dev->power.accounting_timestamp = now;
+        retval = cb(dev);
 
-        if (dev->power.disable_depth > 0)
-                return;
-
-        if (dev->power.runtime_status == RPM_SUSPENDED)
-                dev->power.suspended_jiffies += delta;
-        else
-                dev->power.active_jiffies += delta;
-}
+        spin_lock_irq(&dev->power.lock);
+        dev->power.runtime_error = retval;
 
-static void __update_runtime_status(struct device *dev, enum rpm_status status)
-{
-        update_pm_runtime_accounting(dev);
-        dev->power.runtime_status = status;
+        return retval;
 }
 
 /**
- * __pm_runtime_suspend - Carry out run-time suspend of given device.
+ * rpm_suspend - Carry out run-time suspend of given device.
  * @dev: Device to suspend.
- * @from_wq: If set, the function has been called via pm_wq.
+ * @rpmflags: Flag bits.
  *
- * Check if the device can be suspended and run the ->runtime_suspend() callback
- * provided by its bus type.  If another suspend has been started earlier, wait
- * for it to finish.  If an idle notification or suspend request is pending or
- * scheduled, cancel it.
+ * Check if the device's run-time PM status allows it to be suspended.  If
+ * another suspend has been started earlier, either return immediately or wait
+ * for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags.  Cancel a
+ * pending idle notification.  If the RPM_ASYNC flag is set then queue a
+ * suspend request; otherwise run the ->runtime_suspend() callback directly.
+ * If a deferred resume was requested while the callback was running then carry
+ * it out; otherwise send an idle notification for the device (if the suspend
+ * failed) or for its parent (if the suspend succeeded).
  *
  * This function must be called under dev->power.lock with interrupts disabled.
  */
-int __pm_runtime_suspend(struct device *dev, bool from_wq)
+static int rpm_suspend(struct device *dev, int rpmflags)
         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 {
+        int (*callback)(struct device *);
         struct device *parent = NULL;
-        bool notify = false;
-        int retval = 0;
+        int retval;
 
-        dev_dbg(dev, "__pm_runtime_suspend()%s!\n",
-                from_wq ? " from workqueue" : "");
+        dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
 
  repeat:
-        if (dev->power.runtime_error) {
-                retval = -EINVAL;
-                goto out;
-        }
+        retval = rpm_check_suspend_allowed(dev);
 
-        /* Pending resume requests take precedence over us. */
-        if (dev->power.request_pending
-            && dev->power.request == RPM_REQ_RESUME) {
+        if (retval < 0)
+                ;       /* Conditions are wrong. */
+
+        /* Synchronous suspends are not allowed in the RPM_RESUMING state. */
+        else if (dev->power.runtime_status == RPM_RESUMING &&
+            !(rpmflags & RPM_ASYNC))
                 retval = -EAGAIN;
+        if (retval)
                 goto out;
+
+        /* If the autosuspend_delay time hasn't expired yet, reschedule. */
+        if ((rpmflags & RPM_AUTO)
+            && dev->power.runtime_status != RPM_SUSPENDING) {
+                unsigned long expires = pm_runtime_autosuspend_expiration(dev);
+
+                if (expires != 0) {
+                        /* Pending requests need to be canceled. */
+                        dev->power.request = RPM_REQ_NONE;
+
+                        /*
+                         * Optimization: If the timer is already running and is
+                         * set to expire at or before the autosuspend delay,
+                         * avoid the overhead of resetting it.  Just let it
+                         * expire; pm_suspend_timer_fn() will take care of the
+                         * rest.
+                         */
+                        if (!(dev->power.timer_expires && time_before_eq(
+                            dev->power.timer_expires, expires))) {
+                                dev->power.timer_expires = expires;
+                                mod_timer(&dev->power.suspend_timer, expires);
+                        }
+                        dev->power.timer_autosuspends = 1;
+                        goto out;
+                }
         }
 
         /* Other scheduled or pending requests need to be canceled. */
         pm_runtime_cancel_pending(dev);
 
-        if (dev->power.runtime_status == RPM_SUSPENDED)
-                retval = 1;
-        else if (dev->power.runtime_status == RPM_RESUMING
-            || dev->power.disable_depth > 0
-            || atomic_read(&dev->power.usage_count) > 0)
-                retval = -EAGAIN;
-        else if (!pm_children_suspended(dev))
-                retval = -EBUSY;
-        if (retval)
-                goto out;
-
         if (dev->power.runtime_status == RPM_SUSPENDING) {
                 DEFINE_WAIT(wait);
 
-                if (from_wq) {
+                if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
                         retval = -EINPROGRESS;
                         goto out;
                 }
@@ -236,46 +352,42 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
                 goto repeat;
         }
 
-        __update_runtime_status(dev, RPM_SUSPENDING);
         dev->power.deferred_resume = false;
+        if (dev->power.no_callbacks)
+                goto no_callback;       /* Assume success. */
+
+        /* Carry out an asynchronous or a synchronous suspend. */
+        if (rpmflags & RPM_ASYNC) {
+                dev->power.request = (rpmflags & RPM_AUTO) ?
+                    RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
+                if (!dev->power.request_pending) {
+                        dev->power.request_pending = true;
+                        queue_work(pm_wq, &dev->power.work);
+                }
+                goto out;
+        }
 
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->bus->pm->runtime_suspend(dev);
-
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else if (dev->type && dev->type->pm
-            && dev->type->pm->runtime_suspend) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->type->pm->runtime_suspend(dev);
-
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else if (dev->class && dev->class->pm
-            && dev->class->pm->runtime_suspend) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->class->pm->runtime_suspend(dev);
+        __update_runtime_status(dev, RPM_SUSPENDING);
 
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else {
-                retval = -ENOSYS;
-        }
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend)
+                callback = dev->bus->pm->runtime_suspend;
+        else if (dev->type && dev->type->pm && dev->type->pm->runtime_suspend)
+                callback = dev->type->pm->runtime_suspend;
+        else if (dev->class && dev->class->pm)
+                callback = dev->class->pm->runtime_suspend;
+        else
+                callback = NULL;
 
+        retval = rpm_callback(callback, dev);
         if (retval) {
                 __update_runtime_status(dev, RPM_ACTIVE);
-                if (retval == -EAGAIN || retval == -EBUSY) {
-                        if (dev->power.timer_expires == 0)
-                                notify = true;
+                dev->power.deferred_resume = 0;
+                if (retval == -EAGAIN || retval == -EBUSY)
                         dev->power.runtime_error = 0;
-                } else {
+                else
                         pm_runtime_cancel_pending(dev);
-                }
         } else {
+ no_callback:
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_deactivate_timer(dev);
 
@@ -287,14 +399,11 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
         wake_up_all(&dev->power.wait_queue);
 
         if (dev->power.deferred_resume) {
-                __pm_runtime_resume(dev, false);
+                rpm_resume(dev, 0);
                 retval = -EAGAIN;
                 goto out;
         }
 
-        if (notify)
-                __pm_runtime_idle(dev);
-
         if (parent && !parent->power.ignore_children) {
                 spin_unlock_irq(&dev->power.lock);
 
@@ -304,72 +413,69 @@ int __pm_runtime_suspend(struct device *dev, bool from_wq)
         }
 
  out:
-        dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
-
-        return retval;
-}
-
-/**
- * pm_runtime_suspend - Carry out run-time suspend of given device.
- * @dev: Device to suspend.
- */
-int pm_runtime_suspend(struct device *dev)
-{
-        int retval;
-
-        spin_lock_irq(&dev->power.lock);
-        retval = __pm_runtime_suspend(dev, false);
-        spin_unlock_irq(&dev->power.lock);
+        dev_dbg(dev, "%s returns %d\n", __func__, retval);
 
         return retval;
 }
-EXPORT_SYMBOL_GPL(pm_runtime_suspend);
 
 /**
- * __pm_runtime_resume - Carry out run-time resume of given device.
+ * rpm_resume - Carry out run-time resume of given device.
  * @dev: Device to resume.
- * @from_wq: If set, the function has been called via pm_wq.
+ * @rpmflags: Flag bits.
  *
- * Check if the device can be woken up and run the ->runtime_resume() callback
- * provided by its bus type.  If another resume has been started earlier, wait
- * for it to finish.  If there's a suspend running in parallel with this
- * function, wait for it to finish and resume the device.  Cancel any scheduled
- * or pending requests.
+ * Check if the device's run-time PM status allows it to be resumed.  Cancel
+ * any scheduled or pending requests.  If another resume has been started
+ * earlier, either return imediately or wait for it to finish, depending on the
+ * RPM_NOWAIT and RPM_ASYNC flags.  Similarly, if there's a suspend running in
+ * parallel with this function, either tell the other process to resume after
+ * suspending (deferred_resume) or wait for it to finish.  If the RPM_ASYNC
+ * flag is set then queue a resume request; otherwise run the
+ * ->runtime_resume() callback directly.  Queue an idle notification for the
+ * device if the resume succeeded.
  *
  * This function must be called under dev->power.lock with interrupts disabled.
  */
-int __pm_runtime_resume(struct device *dev, bool from_wq)
+static int rpm_resume(struct device *dev, int rpmflags)
         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 {
+        int (*callback)(struct device *);
         struct device *parent = NULL;
         int retval = 0;
 
-        dev_dbg(dev, "__pm_runtime_resume()%s!\n",
-                from_wq ? " from workqueue" : "");
+        dev_dbg(dev, "%s flags 0x%x\n", __func__, rpmflags);
 
  repeat:
-        if (dev->power.runtime_error) {
+        if (dev->power.runtime_error)
                 retval = -EINVAL;
+        else if (dev->power.disable_depth > 0)
+                retval = -EAGAIN;
+        if (retval)
                 goto out;
-        }
 
-        pm_runtime_cancel_pending(dev);
+        /*
+         * Other scheduled or pending requests need to be canceled.  Small
+         * optimization: If an autosuspend timer is running, leave it running
+         * rather than cancelling it now only to restart it again in the near
+         * future.
+         */
+        dev->power.request = RPM_REQ_NONE;
+        if (!dev->power.timer_autosuspends)
+                pm_runtime_deactivate_timer(dev);
 
-        if (dev->power.runtime_status == RPM_ACTIVE)
+        if (dev->power.runtime_status == RPM_ACTIVE) {
                 retval = 1;
-        else if (dev->power.disable_depth > 0)
-                retval = -EAGAIN;
-        if (retval)
                 goto out;
+        }
 
         if (dev->power.runtime_status == RPM_RESUMING
             || dev->power.runtime_status == RPM_SUSPENDING) {
                 DEFINE_WAIT(wait);
 
-                if (from_wq) {
+                if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
                         if (dev->power.runtime_status == RPM_SUSPENDING)
                                 dev->power.deferred_resume = true;
-                        retval = -EINPROGRESS;
+                        else
+                                retval = -EINPROGRESS;
                         goto out;
                 }
 
@@ -391,6 +497,34 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
                 goto repeat;
         }
 
+        /*
+         * See if we can skip waking up the parent.  This is safe only if
+         * power.no_callbacks is set, because otherwise we don't know whether
+         * the resume will actually succeed.
+         */
+        if (dev->power.no_callbacks && !parent && dev->parent) {
+                spin_lock(&dev->parent->power.lock);
+                if (dev->parent->power.disable_depth > 0
+                    || dev->parent->power.ignore_children
+                    || dev->parent->power.runtime_status == RPM_ACTIVE) {
+                        atomic_inc(&dev->parent->power.child_count);
+                        spin_unlock(&dev->parent->power.lock);
+                        goto no_callback;       /* Assume success. */
+                }
+                spin_unlock(&dev->parent->power.lock);
+        }
+
+        /* Carry out an asynchronous or a synchronous resume. */
+        if (rpmflags & RPM_ASYNC) {
+                dev->power.request = RPM_REQ_RESUME;
+                if (!dev->power.request_pending) {
+                        dev->power.request_pending = true;
+                        queue_work(pm_wq, &dev->power.work);
+                }
+                retval = 0;
+                goto out;
+        }
+
         if (!parent && dev->parent) {
                 /*
                  * Increment the parent's resume counter and resume it if
@@ -408,7 +542,7 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
                  */
                 if (!parent->power.disable_depth
                     && !parent->power.ignore_children) {
-                        __pm_runtime_resume(parent, false);
+                        rpm_resume(parent, 0);
                         if (parent->power.runtime_status != RPM_ACTIVE)
                                 retval = -EBUSY;
                 }
@@ -420,39 +554,26 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
                 goto repeat;
         }
 
-        __update_runtime_status(dev, RPM_RESUMING);
-
-        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->bus->pm->runtime_resume(dev);
-
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else if (dev->type && dev->type->pm
-            && dev->type->pm->runtime_resume) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->type->pm->runtime_resume(dev);
+        if (dev->power.no_callbacks)
+                goto no_callback;       /* Assume success. */
 
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else if (dev->class && dev->class->pm
-            && dev->class->pm->runtime_resume) {
-                spin_unlock_irq(&dev->power.lock);
-
-                retval = dev->class->pm->runtime_resume(dev);
+        __update_runtime_status(dev, RPM_RESUMING);
 
-                spin_lock_irq(&dev->power.lock);
-                dev->power.runtime_error = retval;
-        } else {
-                retval = -ENOSYS;
-        }
+        if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume)
+                callback = dev->bus->pm->runtime_resume;
+        else if (dev->type && dev->type->pm && dev->type->pm->runtime_resume)
+                callback = dev->type->pm->runtime_resume;
+        else if (dev->class && dev->class->pm)
+                callback = dev->class->pm->runtime_resume;
+        else
+                callback = NULL;
 
+        retval = rpm_callback(callback, dev);
         if (retval) {
                 __update_runtime_status(dev, RPM_SUSPENDED);
                 pm_runtime_cancel_pending(dev);
         } else {
+ no_callback:
                 __update_runtime_status(dev, RPM_ACTIVE);
                 if (parent)
                         atomic_inc(&parent->power.child_count);
@@ -460,7 +581,7 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
         wake_up_all(&dev->power.wait_queue);
 
         if (!retval)
-                __pm_request_idle(dev);
+                rpm_idle(dev, RPM_ASYNC);
 
  out:
         if (parent) {
@@ -471,28 +592,12 @@ int __pm_runtime_resume(struct device *dev, bool from_wq)
                 spin_lock_irq(&dev->power.lock);
         }
 
-        dev_dbg(dev, "__pm_runtime_resume() returns %d!\n", retval);
+        dev_dbg(dev, "%s returns %d\n", __func__, retval);
 
         return retval;
 }
 
 /**
- * pm_runtime_resume - Carry out run-time resume of given device.
- * @dev: Device to suspend.
- */
-int pm_runtime_resume(struct device *dev)
-{
-        int retval;
-
-        spin_lock_irq(&dev->power.lock);
-        retval = __pm_runtime_resume(dev, false);
-        spin_unlock_irq(&dev->power.lock);
-
-        return retval;
-}
-EXPORT_SYMBOL_GPL(pm_runtime_resume);
-
-/**
  * pm_runtime_work - Universal run-time PM work function.
  * @work: Work structure used for scheduling the execution of this function.
  *
@@ -517,13 +622,16 @@ static void pm_runtime_work(struct work_struct *work)
         case RPM_REQ_NONE:
                 break;
         case RPM_REQ_IDLE:
-                __pm_runtime_idle(dev);
+                rpm_idle(dev, RPM_NOWAIT);
                 break;
         case RPM_REQ_SUSPEND:
-                __pm_runtime_suspend(dev, true);
+                rpm_suspend(dev, RPM_NOWAIT);
+                break;
+        case RPM_REQ_AUTOSUSPEND:
+                rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
                 break;
         case RPM_REQ_RESUME:
-                __pm_runtime_resume(dev, true);
+                rpm_resume(dev, RPM_NOWAIT);
                 break;
         }
 
@@ -532,117 +640,10 @@ static void pm_runtime_work(struct work_struct *work)
 }
 
 /**
- * __pm_request_idle - Submit an idle notification request for given device.
- * @dev: Device to handle.
- *
- * Check if the device's run-time PM status is correct for suspending the device
- * and queue up a request to run __pm_runtime_idle() for it.
- *
- * This function must be called under dev->power.lock with interrupts disabled.
- */
-static int __pm_request_idle(struct device *dev)
-{
-        int retval = 0;
-
-        if (dev->power.runtime_error)
-                retval = -EINVAL;
-        else if (atomic_read(&dev->power.usage_count) > 0
-            || dev->power.disable_depth > 0
-            || dev->power.runtime_status == RPM_SUSPENDED
-            || dev->power.runtime_status == RPM_SUSPENDING)
-                retval = -EAGAIN;
-        else if (!pm_children_suspended(dev))
-                retval = -EBUSY;
-        if (retval)
-                return retval;
-
-        if (dev->power.request_pending) {
-                /* Any requests other then RPM_REQ_IDLE take precedence. */
-                if (dev->power.request == RPM_REQ_NONE)
-                        dev->power.request = RPM_REQ_IDLE;
-                else if (dev->power.request != RPM_REQ_IDLE)
-                        retval = -EAGAIN;
-                return retval;
-        }
-
-        dev->power.request = RPM_REQ_IDLE;
-        dev->power.request_pending = true;
-        queue_work(pm_wq, &dev->power.work);
-
-        return retval;
-}
-
-/**
- * pm_request_idle - Submit an idle notification request for given device.
- * @dev: Device to handle.
- */
-int pm_request_idle(struct device *dev)
-{
-        unsigned long flags;
-        int retval;
-
-        spin_lock_irqsave(&dev->power.lock, flags);
-        retval = __pm_request_idle(dev);
-        spin_unlock_irqrestore(&dev->power.lock, flags);
-
-        return retval;
-}
-EXPORT_SYMBOL_GPL(pm_request_idle);
-
-/**
- * __pm_request_suspend - Submit a suspend request for given device.
- * @dev: Device to suspend.
- *
- * This function must be called under dev->power.lock with interrupts disabled.
- */
-static int __pm_request_suspend(struct device *dev)
-{
-        int retval = 0;
-
-        if (dev->power.runtime_error)
-                return -EINVAL;
-
-        if (dev->power.runtime_status == RPM_SUSPENDED)
-                retval = 1;
-        else if (atomic_read(&dev->power.usage_count) > 0
-            || dev->power.disable_depth > 0)
-                retval = -EAGAIN;
-        else if (dev->power.runtime_status == RPM_SUSPENDING)
-                retval = -EINPROGRESS;
-        else if (!pm_children_suspended(dev))
-                retval = -EBUSY;
-        if (retval < 0)
-                return retval;
-
-        pm_runtime_deactivate_timer(dev);
-
-        if (dev->power.request_pending) {
-                /*
-                 * Pending resume requests take precedence over us, but we can
-                 * overtake any other pending request.
-                 */
-                if (dev->power.request == RPM_REQ_RESUME)
-                        retval = -EAGAIN;
-                else if (dev->power.request != RPM_REQ_SUSPEND)
-                        dev->power.request = retval ?
-                                                RPM_REQ_NONE : RPM_REQ_SUSPEND;
-                return retval;
-        } else if (retval) {
-                return retval;
-        }
-
-        dev->power.request = RPM_REQ_SUSPEND;
-        dev->power.request_pending = true;
-        queue_work(pm_wq, &dev->power.work);
-
-        return 0;
-}
-
-/**
  * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
  * @data: Device pointer passed by pm_schedule_suspend().
  *
- * Check if the time is right and execute __pm_request_suspend() in that case.
+ * Check if the time is right and queue a suspend request.
  */
 static void pm_suspend_timer_fn(unsigned long data)
 {
@@ -656,7 +657,8 @@ static void pm_suspend_timer_fn(unsigned long data)
         /* If 'expire' is after 'jiffies' we've been called too early. */
         if (expires > 0 && !time_after(expires, jiffies)) {
                 dev->power.timer_expires = 0;
-                __pm_request_suspend(dev);
+                rpm_suspend(dev, dev->power.timer_autosuspends ?
+                    (RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
         }
 
         spin_unlock_irqrestore(&dev->power.lock, flags);
@@ -670,47 +672,25 @@ static void pm_suspend_timer_fn(unsigned long data)
 int pm_schedule_suspend(struct device *dev, unsigned int delay)
 {
         unsigned long flags;
-        int retval = 0;
+        int retval;
 
         spin_lock_irqsave(&dev->power.lock, flags);
 
-        if (dev->power.runtime_error) {
-                retval = -EINVAL;
-                goto out;
-        }
-
         if (!delay) {
-                retval = __pm_request_suspend(dev);
+                retval = rpm_suspend(dev, RPM_ASYNC);
                 goto out;
         }
 
-        pm_runtime_deactivate_timer(dev);
-
-        if (dev->power.request_pending) {
-                /*
-                 * Pending resume requests take precedence over us, but any
-                 * other pending requests have to be canceled.
-                 */
-                if (dev->power.request == RPM_REQ_RESUME) {
-                        retval = -EAGAIN;
-                        goto out;
-                }
-                dev->power.request = RPM_REQ_NONE;
-        }
-
-        if (dev->power.runtime_status == RPM_SUSPENDED)
-                retval = 1;
-        else if (atomic_read(&dev->power.usage_count) > 0
-            || dev->power.disable_depth > 0)
-                retval = -EAGAIN;
-        else if (!pm_children_suspended(dev))
-                retval = -EBUSY;
+        retval = rpm_check_suspend_allowed(dev);
         if (retval)
                 goto out;
 
+        /* Other scheduled or pending requests need to be canceled. */
+        pm_runtime_cancel_pending(dev);
+
         dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
-        if (!dev->power.timer_expires)
-                dev->power.timer_expires = 1;
+        dev->power.timer_expires += !dev->power.timer_expires;
+        dev->power.timer_autosuspends = 0;
         mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
 
  out:
@@ -721,103 +701,88 @@ int pm_schedule_suspend(struct device *dev, unsigned int delay)
 EXPORT_SYMBOL_GPL(pm_schedule_suspend);
 
 /**
- * pm_request_resume - Submit a resume request for given device.
- * @dev: Device to resume.
+ * __pm_runtime_idle - Entry point for run-time idle operations.
+ * @dev: Device to send idle notification for.
+ * @rpmflags: Flag bits.
  *
- * This function must be called under dev->power.lock with interrupts disabled.
+ * If the RPM_GET_PUT flag is set, decrement the device's usage count and
+ * return immediately if it is larger than zero.  Then carry out an idle
+ * notification, either synchronous or asynchronous.
+ *
+ * This routine may be called in atomic context if the RPM_ASYNC flag is set.
  */
-static int __pm_request_resume(struct device *dev)
+int __pm_runtime_idle(struct device *dev, int rpmflags)
 {
-        int retval = 0;
-
-        if (dev->power.runtime_error)
-                return -EINVAL;
-
-        if (dev->power.runtime_status == RPM_ACTIVE)
-                retval = 1;
-        else if (dev->power.runtime_status == RPM_RESUMING)
-                retval = -EINPROGRESS;
-        else if (dev->power.disable_depth > 0)
-                retval = -EAGAIN;
-        if (retval < 0)
-                return retval;
-
-        pm_runtime_deactivate_timer(dev);
+        unsigned long flags;
+        int retval;
 
-        if (dev->power.runtime_status == RPM_SUSPENDING) {
-                dev->power.deferred_resume = true;
-                return retval;
+        if (rpmflags & RPM_GET_PUT) {
+                if (!atomic_dec_and_test(&dev->power.usage_count))
+                        return 0;
         }
-        if (dev->power.request_pending) {
-                /* If non-resume request is pending, we can overtake it. */
-                dev->power.request = retval ? RPM_REQ_NONE : RPM_REQ_RESUME;
-                return retval;
-        }
-        if (retval)
-                return retval;
 
-        dev->power.request = RPM_REQ_RESUME;
-        dev->power.request_pending = true;
-        queue_work(pm_wq, &dev->power.work);
+        spin_lock_irqsave(&dev->power.lock, flags);
+        retval = rpm_idle(dev, rpmflags);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
 
         return retval;
 }
+EXPORT_SYMBOL_GPL(__pm_runtime_idle);
 
 /**
- * pm_request_resume - Submit a resume request for given device.
- * @dev: Device to resume.
+ * __pm_runtime_suspend - Entry point for run-time put/suspend operations.
+ * @dev: Device to suspend.
+ * @rpmflags: Flag bits.
+ *
+ * If the RPM_GET_PUT flag is set, decrement the device's usage count and
+ * return immediately if it is larger than zero.  Then carry out a suspend,
+ * either synchronous or asynchronous.
+ *
+ * This routine may be called in atomic context if the RPM_ASYNC flag is set.
  */
-int pm_request_resume(struct device *dev)
+int __pm_runtime_suspend(struct device *dev, int rpmflags)
 {
         unsigned long flags;
         int retval;
 
+        if (rpmflags & RPM_GET_PUT) {
+                if (!atomic_dec_and_test(&dev->power.usage_count))
+                        return 0;
+        }
+
         spin_lock_irqsave(&dev->power.lock, flags);
-        retval = __pm_request_resume(dev);
+        retval = rpm_suspend(dev, rpmflags);
         spin_unlock_irqrestore(&dev->power.lock, flags);
 
         return retval;
 }
-EXPORT_SYMBOL_GPL(pm_request_resume);
+EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
 
 /**
- * __pm_runtime_get - Reference count a device and wake it up, if necessary.
- * @dev: Device to handle.
- * @sync: If set and the device is suspended, resume it synchronously.
+ * __pm_runtime_resume - Entry point for run-time resume operations.
+ * @dev: Device to resume.
+ * @rpmflags: Flag bits.
+ *
+ * If the RPM_GET_PUT flag is set, increment the device's usage count.  Then
+ * carry out a resume, either synchronous or asynchronous.
  *
- * Increment the usage count of the device and resume it or submit a resume
- * request for it, depending on the value of @sync.
+ * This routine may be called in atomic context if the RPM_ASYNC flag is set.
  */
-int __pm_runtime_get(struct device *dev, bool sync)
+int __pm_runtime_resume(struct device *dev, int rpmflags)
 {
+        unsigned long flags;
         int retval;
 
-        atomic_inc(&dev->power.usage_count);
-        retval = sync ? pm_runtime_resume(dev) : pm_request_resume(dev);
+        if (rpmflags & RPM_GET_PUT)
+                atomic_inc(&dev->power.usage_count);
 
-        return retval;
-}
-EXPORT_SYMBOL_GPL(__pm_runtime_get);
-
-/**
- * __pm_runtime_put - Decrement the device's usage counter and notify its bus.
- * @dev: Device to handle.
- * @sync: If the device's bus type is to be notified, do that synchronously.
- *
- * Decrement the usage count of the device and if it reaches zero, carry out a
- * synchronous idle notification or submit an idle notification request for it,
- * depending on the value of @sync.
- */
-int __pm_runtime_put(struct device *dev, bool sync)
-{
-        int retval = 0;
-
-        if (atomic_dec_and_test(&dev->power.usage_count))
-                retval = sync ? pm_runtime_idle(dev) : pm_request_idle(dev);
+        spin_lock_irqsave(&dev->power.lock, flags);
+        retval = rpm_resume(dev, rpmflags);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
 
         return retval;
 }
-EXPORT_SYMBOL_GPL(__pm_runtime_put);
+EXPORT_SYMBOL_GPL(__pm_runtime_resume);
 
 /**
  * __pm_runtime_set_status - Set run-time PM status of a device.
@@ -968,7 +933,7 @@ int pm_runtime_barrier(struct device *dev)
 
         if (dev->power.request_pending
             && dev->power.request == RPM_REQ_RESUME) {
-                __pm_runtime_resume(dev, false);
+                rpm_resume(dev, 0);
                 retval = 1;
         }
 
@@ -1017,7 +982,7 @@ void __pm_runtime_disable(struct device *dev, bool check_resume)
                  */
                 pm_runtime_get_noresume(dev);
 
-                __pm_runtime_resume(dev, false);
+                rpm_resume(dev, 0);
 
                 pm_runtime_put_noidle(dev);
         }
@@ -1065,7 +1030,7 @@ void pm_runtime_forbid(struct device *dev)
 
         dev->power.runtime_auto = false;
         atomic_inc(&dev->power.usage_count);
-        __pm_runtime_resume(dev, false);
+        rpm_resume(dev, 0);
 
  out:
         spin_unlock_irq(&dev->power.lock);
@@ -1086,7 +1051,7 @@ void pm_runtime_allow(struct device *dev)
 
         dev->power.runtime_auto = true;
         if (atomic_dec_and_test(&dev->power.usage_count))
-                __pm_runtime_idle(dev);
+                rpm_idle(dev, RPM_AUTO);
 
  out:
         spin_unlock_irq(&dev->power.lock);
@@ -1094,13 +1059,110 @@ void pm_runtime_allow(struct device *dev)
 EXPORT_SYMBOL_GPL(pm_runtime_allow);
 
 /**
+ * pm_runtime_no_callbacks - Ignore run-time PM callbacks for a device.
+ * @dev: Device to handle.
+ *
+ * Set the power.no_callbacks flag, which tells the PM core that this
+ * device is power-managed through its parent and has no run-time PM
+ * callbacks of its own.  The run-time sysfs attributes will be removed.
+ *
+ */
+void pm_runtime_no_callbacks(struct device *dev)
+{
+        spin_lock_irq(&dev->power.lock);
+        dev->power.no_callbacks = 1;
+        spin_unlock_irq(&dev->power.lock);
+        if (device_is_registered(dev))
+                rpm_sysfs_remove(dev);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
+
+/**
+ * update_autosuspend - Handle a change to a device's autosuspend settings.
+ * @dev: Device to handle.
+ * @old_delay: The former autosuspend_delay value.
+ * @old_use: The former use_autosuspend value.
+ *
+ * Prevent runtime suspend if the new delay is negative and use_autosuspend is
+ * set; otherwise allow it.  Send an idle notification if suspends are allowed.
+ *
+ * This function must be called under dev->power.lock with interrupts disabled.
+ */
+static void update_autosuspend(struct device *dev, int old_delay, int old_use)
+{
+        int delay = dev->power.autosuspend_delay;
+
+        /* Should runtime suspend be prevented now? */
+        if (dev->power.use_autosuspend && delay < 0) {
+
+                /* If it used to be allowed then prevent it. */
+                if (!old_use || old_delay >= 0) {
+                        atomic_inc(&dev->power.usage_count);
+                        rpm_resume(dev, 0);
+                }
+        }
+
+        /* Runtime suspend should be allowed now. */
+        else {
+
+                /* If it used to be prevented then allow it. */
+                if (old_use && old_delay < 0)
+                        atomic_dec(&dev->power.usage_count);
+
+                /* Maybe we can autosuspend now. */
+                rpm_idle(dev, RPM_AUTO);
+        }
+}
+
+/**
+ * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
+ * @dev: Device to handle.
+ * @delay: Value of the new delay in milliseconds.
+ *
+ * Set the device's power.autosuspend_delay value.  If it changes to negative
+ * and the power.use_autosuspend flag is set, prevent run-time suspends.  If it
+ * changes the other way, allow run-time suspends.
+ */
+void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
+{
+        int old_delay, old_use;
+
+        spin_lock_irq(&dev->power.lock);
+        old_delay = dev->power.autosuspend_delay;
+        old_use = dev->power.use_autosuspend;
+        dev->power.autosuspend_delay = delay;
+        update_autosuspend(dev, old_delay, old_use);
+        spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
+
+/**
+ * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
+ * @dev: Device to handle.
+ * @use: New value for use_autosuspend.
+ *
+ * Set the device's power.use_autosuspend flag, and allow or prevent run-time
+ * suspends as needed.
+ */
+void __pm_runtime_use_autosuspend(struct device *dev, bool use)
+{
+        int old_delay, old_use;
+
+        spin_lock_irq(&dev->power.lock);
+        old_delay = dev->power.autosuspend_delay;
+        old_use = dev->power.use_autosuspend;
+        dev->power.use_autosuspend = use;
+        update_autosuspend(dev, old_delay, old_use);
+        spin_unlock_irq(&dev->power.lock);
+}
+EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
+
+/**
  * pm_runtime_init - Initialize run-time PM fields in given device object.
  * @dev: Device object to initialize.
  */
 void pm_runtime_init(struct device *dev)
 {
-        spin_lock_init(&dev->power.lock);
-
         dev->power.runtime_status = RPM_SUSPENDED;
         dev->power.idle_notification = false;
 
diff --git a/drivers/base/power/sysfs.c b/drivers/base/power/sysfs.c
index e56b4388fe61..0b1e46bf3e56 100644
--- a/drivers/base/power/sysfs.c
+++ b/drivers/base/power/sysfs.c
@@ -75,12 +75,27 @@
  *      attribute is set to "enabled" by bus type code or device drivers and in
  *      that cases it should be safe to leave the default value.
  *
+ *      autosuspend_delay_ms - Report/change a device's autosuspend_delay value
+ *
+ *      Some drivers don't want to carry out a runtime suspend as soon as a
+ *      device becomes idle; they want it always to remain idle for some period
+ *      of time before suspending it.  This period is the autosuspend_delay
+ *      value (expressed in milliseconds) and it can be controlled by the user.
+ *      If the value is negative then the device will never be runtime
+ *      suspended.
+ *
+ *      NOTE: The autosuspend_delay_ms attribute and the autosuspend_delay
+ *      value are used only if the driver calls pm_runtime_use_autosuspend().
+ *
  *      wakeup_count - Report the number of wakeup events related to the device
  */
 
 static const char enabled[] = "enabled";
 static const char disabled[] = "disabled";
 
+const char power_group_name[] = "power";
+EXPORT_SYMBOL_GPL(power_group_name);
+
 #ifdef CONFIG_PM_RUNTIME
 static const char ctrl_auto[] = "auto";
 static const char ctrl_on[] = "on";
@@ -170,6 +185,33 @@ static ssize_t rtpm_status_show(struct device *dev,
 }
 
 static DEVICE_ATTR(runtime_status, 0444, rtpm_status_show, NULL);
+
+static ssize_t autosuspend_delay_ms_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        if (!dev->power.use_autosuspend)
+                return -EIO;
+        return sprintf(buf, "%d\n", dev->power.autosuspend_delay);
+}
+
+static ssize_t autosuspend_delay_ms_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t n)
+{
+        long delay;
+
+        if (!dev->power.use_autosuspend)
+                return -EIO;
+
+        if (strict_strtol(buf, 10, &delay) != 0 || delay != (int) delay)
+                return -EINVAL;
+
+        pm_runtime_set_autosuspend_delay(dev, delay);
+        return n;
+}
+
+static DEVICE_ATTR(autosuspend_delay_ms, 0644, autosuspend_delay_ms_show,
+                autosuspend_delay_ms_store);
+
 #endif
 
 static ssize_t
@@ -210,11 +252,122 @@ static DEVICE_ATTR(wakeup, 0644, wake_show, wake_store);
 static ssize_t wakeup_count_show(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
-        return sprintf(buf, "%lu\n", dev->power.wakeup_count);
+        unsigned long count = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                count = dev->power.wakeup->event_count;
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
 }
 
 static DEVICE_ATTR(wakeup_count, 0444, wakeup_count_show, NULL);
-#endif
+
+static ssize_t wakeup_active_count_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        unsigned long count = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                count = dev->power.wakeup->active_count;
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_active_count, 0444, wakeup_active_count_show, NULL);
+
+static ssize_t wakeup_hit_count_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        unsigned long count = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                count = dev->power.wakeup->hit_count;
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lu\n", count) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_hit_count, 0444, wakeup_hit_count_show, NULL);
+
+static ssize_t wakeup_active_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        unsigned int active = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                active = dev->power.wakeup->active;
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%u\n", active) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_active, 0444, wakeup_active_show, NULL);
+
+static ssize_t wakeup_total_time_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        s64 msec = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                msec = ktime_to_ms(dev->power.wakeup->total_time);
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_total_time_ms, 0444, wakeup_total_time_show, NULL);
+
+static ssize_t wakeup_max_time_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        s64 msec = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                msec = ktime_to_ms(dev->power.wakeup->max_time);
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_max_time_ms, 0444, wakeup_max_time_show, NULL);
+
+static ssize_t wakeup_last_time_show(struct device *dev,
+                                struct device_attribute *attr, char *buf)
+{
+        s64 msec = 0;
+        bool enabled = false;
+
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                msec = ktime_to_ms(dev->power.wakeup->last_time);
+                enabled = true;
+        }
+        spin_unlock_irq(&dev->power.lock);
+        return enabled ? sprintf(buf, "%lld\n", msec) : sprintf(buf, "\n");
+}
+
+static DEVICE_ATTR(wakeup_last_time_ms, 0444, wakeup_last_time_show, NULL);
+#endif /* CONFIG_PM_SLEEP */
 
 #ifdef CONFIG_PM_ADVANCED_DEBUG
 #ifdef CONFIG_PM_RUNTIME
@@ -279,19 +432,20 @@ static DEVICE_ATTR(async, 0644, async_show, async_store);
 #endif /* CONFIG_PM_ADVANCED_DEBUG */
 
 static struct attribute * power_attrs[] = {
-#ifdef CONFIG_PM_RUNTIME
-        &dev_attr_control.attr,
-        &dev_attr_runtime_status.attr,
-        &dev_attr_runtime_suspended_time.attr,
-        &dev_attr_runtime_active_time.attr,
-#endif
         &dev_attr_wakeup.attr,
 #ifdef CONFIG_PM_SLEEP
         &dev_attr_wakeup_count.attr,
+        &dev_attr_wakeup_active_count.attr,
+        &dev_attr_wakeup_hit_count.attr,
+        &dev_attr_wakeup_active.attr,
+        &dev_attr_wakeup_total_time_ms.attr,
+        &dev_attr_wakeup_max_time_ms.attr,
+        &dev_attr_wakeup_last_time_ms.attr,
 #endif
 #ifdef CONFIG_PM_ADVANCED_DEBUG
         &dev_attr_async.attr,
 #ifdef CONFIG_PM_RUNTIME
+        &dev_attr_runtime_status.attr,
         &dev_attr_runtime_usage.attr,
         &dev_attr_runtime_active_kids.attr,
         &dev_attr_runtime_enabled.attr,
@@ -300,10 +454,53 @@ static struct attribute * power_attrs[] = {
         NULL,
 };
 static struct attribute_group pm_attr_group = {
-        .name   = "power",
+        .name   = power_group_name,
         .attrs  = power_attrs,
 };
 
+#ifdef CONFIG_PM_RUNTIME
+
+static struct attribute *runtime_attrs[] = {
+#ifndef CONFIG_PM_ADVANCED_DEBUG
+        &dev_attr_runtime_status.attr,
+#endif
+        &dev_attr_control.attr,
+        &dev_attr_runtime_suspended_time.attr,
+        &dev_attr_runtime_active_time.attr,
+        &dev_attr_autosuspend_delay_ms.attr,
+        NULL,
+};
+static struct attribute_group pm_runtime_attr_group = {
+        .name   = power_group_name,
+        .attrs  = runtime_attrs,
+};
+
+int dpm_sysfs_add(struct device *dev)
+{
+        int rc;
+
+        rc = sysfs_create_group(&dev->kobj, &pm_attr_group);
+        if (rc == 0 && !dev->power.no_callbacks) {
+                rc = sysfs_merge_group(&dev->kobj, &pm_runtime_attr_group);
+                if (rc)
+                        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+        }
+        return rc;
+}
+
+void rpm_sysfs_remove(struct device *dev)
+{
+        sysfs_unmerge_group(&dev->kobj, &pm_runtime_attr_group);
+}
+
+void dpm_sysfs_remove(struct device *dev)
+{
+        rpm_sysfs_remove(dev);
+        sysfs_remove_group(&dev->kobj, &pm_attr_group);
+}
+
+#else /* CONFIG_PM_RUNTIME */
+
 int dpm_sysfs_add(struct device * dev)
 {
         return sysfs_create_group(&dev->kobj, &pm_attr_group);
@@ -313,3 +510,5 @@ void dpm_sysfs_remove(struct device * dev)
 {
         sysfs_remove_group(&dev->kobj, &pm_attr_group);
 }
+
+#endif
diff --git a/drivers/base/power/trace.c b/drivers/base/power/trace.c
index 0a1a2c4dbc6e..9f4258df4cfd 100644
--- a/drivers/base/power/trace.c
+++ b/drivers/base/power/trace.c
@@ -188,8 +188,10 @@ static int show_file_hash(unsigned int value)
 static int show_dev_hash(unsigned int value)
 {
         int match = 0;
-        struct list_head *entry = dpm_list.prev;
+        struct list_head *entry;
 
+        device_pm_lock();
+        entry = dpm_list.prev;
         while (entry != &dpm_list) {
                 struct device * dev = to_device(entry);
                 unsigned int hash = hash_string(DEVSEED, dev_name(dev), DEVHASH);
@@ -199,11 +201,43 @@ static int show_dev_hash(unsigned int value)
                 }
                 entry = entry->prev;
         }
+        device_pm_unlock();
         return match;
 }
 
 static unsigned int hash_value_early_read;
 
+int show_trace_dev_match(char *buf, size_t size)
+{
+        unsigned int value = hash_value_early_read / (USERHASH * FILEHASH);
+        int ret = 0;
+        struct list_head *entry;
+
+        /*
+         * It's possible that multiple devices will match the hash and we can't
+         * tell which is the culprit, so it's best to output them all.
+         */
+        device_pm_lock();
+        entry = dpm_list.prev;
+        while (size && entry != &dpm_list) {
+                struct device *dev = to_device(entry);
+                unsigned int hash = hash_string(DEVSEED, dev_name(dev),
+                                                DEVHASH);
+                if (hash == value) {
+                        int len = snprintf(buf, size, "%s\n",
+                                            dev_driver_string(dev));
+                        if (len > size)
+                                len = size;
+                        buf += len;
+                        ret += len;
+                        size -= len;
+                }
+                entry = entry->prev;
+        }
+        device_pm_unlock();
+        return ret;
+}
+
 static int early_resume_init(void)
 {
         hash_value_early_read = read_magic_time();
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index eb594facfc3f..71c5528e1c35 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -11,7 +11,12 @@
 #include <linux/sched.h>
 #include <linux/capability.h>
 #include <linux/suspend.h>
-#include <linux/pm.h>
+#include <linux/seq_file.h>
+#include <linux/debugfs.h>
+
+#include "power.h"
+
+#define TIMEOUT         100
 
 /*
  * If set, the suspend/hibernate code will abort transitions to a sleep state
@@ -20,18 +25,244 @@
 bool events_check_enabled;
 
 /* The counter of registered wakeup events. */
-static unsigned long event_count;
+static atomic_t event_count = ATOMIC_INIT(0);
 /* A preserved old value of event_count. */
-static unsigned long saved_event_count;
+static unsigned int saved_count;
 /* The counter of wakeup events being processed. */
-static unsigned long events_in_progress;
+static atomic_t events_in_progress = ATOMIC_INIT(0);
 
 static DEFINE_SPINLOCK(events_lock);
 
 static void pm_wakeup_timer_fn(unsigned long data);
 
-static DEFINE_TIMER(events_timer, pm_wakeup_timer_fn, 0, 0);
-static unsigned long events_timer_expires;
+static LIST_HEAD(wakeup_sources);
+
+/**
+ * wakeup_source_create - Create a struct wakeup_source object.
+ * @name: Name of the new wakeup source.
+ */
+struct wakeup_source *wakeup_source_create(const char *name)
+{
+        struct wakeup_source *ws;
+
+        ws = kzalloc(sizeof(*ws), GFP_KERNEL);
+        if (!ws)
+                return NULL;
+
+        spin_lock_init(&ws->lock);
+        if (name)
+                ws->name = kstrdup(name, GFP_KERNEL);
+
+        return ws;
+}
+EXPORT_SYMBOL_GPL(wakeup_source_create);
+
+/**
+ * wakeup_source_destroy - Destroy a struct wakeup_source object.
+ * @ws: Wakeup source to destroy.
+ */
+void wakeup_source_destroy(struct wakeup_source *ws)
+{
+        if (!ws)
+                return;
+
+        spin_lock_irq(&ws->lock);
+        while (ws->active) {
+                spin_unlock_irq(&ws->lock);
+
+                schedule_timeout_interruptible(msecs_to_jiffies(TIMEOUT));
+
+                spin_lock_irq(&ws->lock);
+        }
+        spin_unlock_irq(&ws->lock);
+
+        kfree(ws->name);
+        kfree(ws);
+}
+EXPORT_SYMBOL_GPL(wakeup_source_destroy);
+
+/**
+ * wakeup_source_add - Add given object to the list of wakeup sources.
+ * @ws: Wakeup source object to add to the list.
+ */
+void wakeup_source_add(struct wakeup_source *ws)
+{
+        if (WARN_ON(!ws))
+                return;
+
+        setup_timer(&ws->timer, pm_wakeup_timer_fn, (unsigned long)ws);
+        ws->active = false;
+
+        spin_lock_irq(&events_lock);
+        list_add_rcu(&ws->entry, &wakeup_sources);
+        spin_unlock_irq(&events_lock);
+        synchronize_rcu();
+}
+EXPORT_SYMBOL_GPL(wakeup_source_add);
+
+/**
+ * wakeup_source_remove - Remove given object from the wakeup sources list.
+ * @ws: Wakeup source object to remove from the list.
+ */
+void wakeup_source_remove(struct wakeup_source *ws)
+{
+        if (WARN_ON(!ws))
+                return;
+
+        spin_lock_irq(&events_lock);
+        list_del_rcu(&ws->entry);
+        spin_unlock_irq(&events_lock);
+        synchronize_rcu();
+}
+EXPORT_SYMBOL_GPL(wakeup_source_remove);
+
+/**
+ * wakeup_source_register - Create wakeup source and add it to the list.
+ * @name: Name of the wakeup source to register.
+ */
+struct wakeup_source *wakeup_source_register(const char *name)
+{
+        struct wakeup_source *ws;
+
+        ws = wakeup_source_create(name);
+        if (ws)
+                wakeup_source_add(ws);
+
+        return ws;
+}
+EXPORT_SYMBOL_GPL(wakeup_source_register);
+
+/**
+ * wakeup_source_unregister - Remove wakeup source from the list and remove it.
+ * @ws: Wakeup source object to unregister.
+ */
+void wakeup_source_unregister(struct wakeup_source *ws)
+{
+        wakeup_source_remove(ws);
+        wakeup_source_destroy(ws);
+}
+EXPORT_SYMBOL_GPL(wakeup_source_unregister);
+
+/**
+ * device_wakeup_attach - Attach a wakeup source object to a device object.
+ * @dev: Device to handle.
+ * @ws: Wakeup source object to attach to @dev.
+ *
+ * This causes @dev to be treated as a wakeup device.
+ */
+static int device_wakeup_attach(struct device *dev, struct wakeup_source *ws)
+{
+        spin_lock_irq(&dev->power.lock);
+        if (dev->power.wakeup) {
+                spin_unlock_irq(&dev->power.lock);
+                return -EEXIST;
+        }
+        dev->power.wakeup = ws;
+        spin_unlock_irq(&dev->power.lock);
+        return 0;
+}
+
+/**
+ * device_wakeup_enable - Enable given device to be a wakeup source.
+ * @dev: Device to handle.
+ *
+ * Create a wakeup source object, register it and attach it to @dev.
+ */
+int device_wakeup_enable(struct device *dev)
+{
+        struct wakeup_source *ws;
+        int ret;
+
+        if (!dev || !dev->power.can_wakeup)
+                return -EINVAL;
+
+        ws = wakeup_source_register(dev_name(dev));
+        if (!ws)
+                return -ENOMEM;
+
+        ret = device_wakeup_attach(dev, ws);
+        if (ret)
+                wakeup_source_unregister(ws);
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(device_wakeup_enable);
+
+/**
+ * device_wakeup_detach - Detach a device's wakeup source object from it.
+ * @dev: Device to detach the wakeup source object from.
+ *
+ * After it returns, @dev will not be treated as a wakeup device any more.
+ */
+static struct wakeup_source *device_wakeup_detach(struct device *dev)
+{
+        struct wakeup_source *ws;
+
+        spin_lock_irq(&dev->power.lock);
+        ws = dev->power.wakeup;
+        dev->power.wakeup = NULL;
+        spin_unlock_irq(&dev->power.lock);
+        return ws;
+}
+
+/**
+ * device_wakeup_disable - Do not regard a device as a wakeup source any more.
+ * @dev: Device to handle.
+ *
+ * Detach the @dev's wakeup source object from it, unregister this wakeup source
+ * object and destroy it.
+ */
+int device_wakeup_disable(struct device *dev)
+{
+        struct wakeup_source *ws;
+
+        if (!dev || !dev->power.can_wakeup)
+                return -EINVAL;
+
+        ws = device_wakeup_detach(dev);
+        if (ws)
+                wakeup_source_unregister(ws);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(device_wakeup_disable);
+
+/**
+ * device_init_wakeup - Device wakeup initialization.
+ * @dev: Device to handle.
+ * @enable: Whether or not to enable @dev as a wakeup device.
+ *
+ * By default, most devices should leave wakeup disabled.  The exceptions are
+ * devices that everyone expects to be wakeup sources: keyboards, power buttons,
+ * possibly network interfaces, etc.
+ */
+int device_init_wakeup(struct device *dev, bool enable)
+{
+        int ret = 0;
+
+        if (enable) {
+                device_set_wakeup_capable(dev, true);
+                ret = device_wakeup_enable(dev);
+        } else {
+                device_set_wakeup_capable(dev, false);
+        }
+
+        return ret;
+}
+EXPORT_SYMBOL_GPL(device_init_wakeup);
+
+/**
+ * device_set_wakeup_enable - Enable or disable a device to wake up the system.
+ * @dev: Device to handle.
+ */
+int device_set_wakeup_enable(struct device *dev, bool enable)
+{
+        if (!dev || !dev->power.can_wakeup)
+                return -EINVAL;
+
+        return enable ? device_wakeup_enable(dev) : device_wakeup_disable(dev);
+}
+EXPORT_SYMBOL_GPL(device_set_wakeup_enable);
 
 /*
  * The functions below use the observation that each wakeup event starts a
@@ -55,118 +286,259 @@ static unsigned long events_timer_expires;
  * knowledge, however, may not be available to it, so it can simply specify time
  * to wait before the system can be suspended and pass it as the second
  * argument of pm_wakeup_event().
+ *
+ * It is valid to call pm_relax() after pm_wakeup_event(), in which case the
+ * "no suspend" period will be ended either by the pm_relax(), or by the timer
+ * function executed when the timer expires, whichever comes first.
  */
 
 /**
+ * wakup_source_activate - Mark given wakeup source as active.
+ * @ws: Wakeup source to handle.
+ *
+ * Update the @ws' statistics and, if @ws has just been activated, notify the PM
+ * core of the event by incrementing the counter of of wakeup events being
+ * processed.
+ */
+static void wakeup_source_activate(struct wakeup_source *ws)
+{
+        ws->active = true;
+        ws->active_count++;
+        ws->timer_expires = jiffies;
+        ws->last_time = ktime_get();
+
+        atomic_inc(&events_in_progress);
+}
+
+/**
+ * __pm_stay_awake - Notify the PM core of a wakeup event.
+ * @ws: Wakeup source object associated with the source of the event.
+ *
+ * It is safe to call this function from interrupt context.
+ */
+void __pm_stay_awake(struct wakeup_source *ws)
+{
+        unsigned long flags;
+
+        if (!ws)
+                return;
+
+        spin_lock_irqsave(&ws->lock, flags);
+        ws->event_count++;
+        if (!ws->active)
+                wakeup_source_activate(ws);
+        spin_unlock_irqrestore(&ws->lock, flags);
+}
+EXPORT_SYMBOL_GPL(__pm_stay_awake);
+
+/**
  * pm_stay_awake - Notify the PM core that a wakeup event is being processed.
  * @dev: Device the wakeup event is related to.
  *
- * Notify the PM core of a wakeup event (signaled by @dev) by incrementing the
- * counter of wakeup events being processed.  If @dev is not NULL, the counter
- * of wakeup events related to @dev is incremented too.
+ * Notify the PM core of a wakeup event (signaled by @dev) by calling
+ * __pm_stay_awake for the @dev's wakeup source object.
  *
  * Call this function after detecting of a wakeup event if pm_relax() is going
  * to be called directly after processing the event (and possibly passing it to
  * user space for further processing).
- *
- * It is safe to call this function from interrupt context.
  */
 void pm_stay_awake(struct device *dev)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&events_lock, flags);
-        if (dev)
-                dev->power.wakeup_count++;
+        if (!dev)
+                return;
 
-        events_in_progress++;
-        spin_unlock_irqrestore(&events_lock, flags);
+        spin_lock_irqsave(&dev->power.lock, flags);
+        __pm_stay_awake(dev->power.wakeup);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
 }
+EXPORT_SYMBOL_GPL(pm_stay_awake);
 
 /**
- * pm_relax - Notify the PM core that processing of a wakeup event has ended.
+ * wakup_source_deactivate - Mark given wakeup source as inactive.
+ * @ws: Wakeup source to handle.
  *
- * Notify the PM core that a wakeup event has been processed by decrementing
- * the counter of wakeup events being processed and incrementing the counter
- * of registered wakeup events.
+ * Update the @ws' statistics and notify the PM core that the wakeup source has
+ * become inactive by decrementing the counter of wakeup events being processed
+ * and incrementing the counter of registered wakeup events.
+ */
+static void wakeup_source_deactivate(struct wakeup_source *ws)
+{
+        ktime_t duration;
+        ktime_t now;
+
+        ws->relax_count++;
+        /*
+         * __pm_relax() may be called directly or from a timer function.
+         * If it is called directly right after the timer function has been
+         * started, but before the timer function calls __pm_relax(), it is
+         * possible that __pm_stay_awake() will be called in the meantime and
+         * will set ws->active.  Then, ws->active may be cleared immediately
+         * by the __pm_relax() called from the timer function, but in such a
+         * case ws->relax_count will be different from ws->active_count.
+         */
+        if (ws->relax_count != ws->active_count) {
+                ws->relax_count--;
+                return;
+        }
+
+        ws->active = false;
+
+        now = ktime_get();
+        duration = ktime_sub(now, ws->last_time);
+        ws->total_time = ktime_add(ws->total_time, duration);
+        if (ktime_to_ns(duration) > ktime_to_ns(ws->max_time))
+                ws->max_time = duration;
+
+        del_timer(&ws->timer);
+
+        /*
+         * event_count has to be incremented before events_in_progress is
+         * modified, so that the callers of pm_check_wakeup_events() and
+         * pm_save_wakeup_count() don't see the old value of event_count and
+         * events_in_progress equal to zero at the same time.
+         */
+        atomic_inc(&event_count);
+        smp_mb__before_atomic_dec();
+        atomic_dec(&events_in_progress);
+}
+
+/**
+ * __pm_relax - Notify the PM core that processing of a wakeup event has ended.
+ * @ws: Wakeup source object associated with the source of the event.
  *
  * Call this function for wakeup events whose processing started with calling
- * pm_stay_awake().
+ * __pm_stay_awake().
  *
  * It is safe to call it from interrupt context.
  */
-void pm_relax(void)
+void __pm_relax(struct wakeup_source *ws)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&events_lock, flags);
-        if (events_in_progress) {
-                events_in_progress--;
-                event_count++;
-        }
-        spin_unlock_irqrestore(&events_lock, flags);
+        if (!ws)
+                return;
+
+        spin_lock_irqsave(&ws->lock, flags);
+        if (ws->active)
+                wakeup_source_deactivate(ws);
+        spin_unlock_irqrestore(&ws->lock, flags);
+}
+EXPORT_SYMBOL_GPL(__pm_relax);
+
+/**
+ * pm_relax - Notify the PM core that processing of a wakeup event has ended.
+ * @dev: Device that signaled the event.
+ *
+ * Execute __pm_relax() for the @dev's wakeup source object.
+ */
+void pm_relax(struct device *dev)
+{
+        unsigned long flags;
+
+        if (!dev)
+                return;
+
+        spin_lock_irqsave(&dev->power.lock, flags);
+        __pm_relax(dev->power.wakeup);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
 }
+EXPORT_SYMBOL_GPL(pm_relax);
 
 /**
  * pm_wakeup_timer_fn - Delayed finalization of a wakeup event.
+ * @data: Address of the wakeup source object associated with the event source.
  *
- * Decrease the counter of wakeup events being processed after it was increased
- * by pm_wakeup_event().
+ * Call __pm_relax() for the wakeup source whose address is stored in @data.
  */
 static void pm_wakeup_timer_fn(unsigned long data)
 {
+        __pm_relax((struct wakeup_source *)data);
+}
+
+/**
+ * __pm_wakeup_event - Notify the PM core of a wakeup event.
+ * @ws: Wakeup source object associated with the event source.
+ * @msec: Anticipated event processing time (in milliseconds).
+ *
+ * Notify the PM core of a wakeup event whose source is @ws that will take
+ * approximately @msec milliseconds to be processed by the kernel.  If @ws is
+ * not active, activate it.  If @msec is nonzero, set up the @ws' timer to
+ * execute pm_wakeup_timer_fn() in future.
+ *
+ * It is safe to call this function from interrupt context.
+ */
+void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
+{
         unsigned long flags;
+        unsigned long expires;
 
-        spin_lock_irqsave(&events_lock, flags);
-        if (events_timer_expires
-            && time_before_eq(events_timer_expires, jiffies)) {
-                events_in_progress--;
-                events_timer_expires = 0;
+        if (!ws)
+                return;
+
+        spin_lock_irqsave(&ws->lock, flags);
+
+        ws->event_count++;
+        if (!ws->active)
+                wakeup_source_activate(ws);
+
+        if (!msec) {
+                wakeup_source_deactivate(ws);
+                goto unlock;
         }
-        spin_unlock_irqrestore(&events_lock, flags);
+
+        expires = jiffies + msecs_to_jiffies(msec);
+        if (!expires)
+                expires = 1;
+
+        if (time_after(expires, ws->timer_expires)) {
+                mod_timer(&ws->timer, expires);
+                ws->timer_expires = expires;
+        }
+
+ unlock:
+        spin_unlock_irqrestore(&ws->lock, flags);
 }
+EXPORT_SYMBOL_GPL(__pm_wakeup_event);
+
 
 /**
  * pm_wakeup_event - Notify the PM core of a wakeup event.
  * @dev: Device the wakeup event is related to.
  * @msec: Anticipated event processing time (in milliseconds).
  *
- * Notify the PM core of a wakeup event (signaled by @dev) that will take
- * approximately @msec milliseconds to be processed by the kernel.  Increment
- * the counter of registered wakeup events and (if @msec is nonzero) set up
- * the wakeup events timer to execute pm_wakeup_timer_fn() in future (if the
- * timer has not been set up already, increment the counter of wakeup events
- * being processed).  If @dev is not NULL, the counter of wakeup events related
- * to @dev is incremented too.
- *
- * It is safe to call this function from interrupt context.
+ * Call __pm_wakeup_event() for the @dev's wakeup source object.
  */
 void pm_wakeup_event(struct device *dev, unsigned int msec)
 {
         unsigned long flags;
 
-        spin_lock_irqsave(&events_lock, flags);
-        event_count++;
-        if (dev)
-                dev->power.wakeup_count++;
-
-        if (msec) {
-                unsigned long expires;
+        if (!dev)
+                return;
 
-                expires = jiffies + msecs_to_jiffies(msec);
-                if (!expires)
-                        expires = 1;
+        spin_lock_irqsave(&dev->power.lock, flags);
+        __pm_wakeup_event(dev->power.wakeup, msec);
+        spin_unlock_irqrestore(&dev->power.lock, flags);
+}
+EXPORT_SYMBOL_GPL(pm_wakeup_event);
 
-                if (!events_timer_expires
-                    || time_after(expires, events_timer_expires)) {
-                        if (!events_timer_expires)
-                                events_in_progress++;
+/**
+ * pm_wakeup_update_hit_counts - Update hit counts of all active wakeup sources.
+ */
+static void pm_wakeup_update_hit_counts(void)
+{
+        unsigned long flags;
+        struct wakeup_source *ws;
 
-                        mod_timer(&events_timer, expires);
-                        events_timer_expires = expires;
-                }
+        rcu_read_lock();
+        list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
+                spin_lock_irqsave(&ws->lock, flags);
+                if (ws->active)
+                        ws->hit_count++;
+                spin_unlock_irqrestore(&ws->lock, flags);
         }
-        spin_unlock_irqrestore(&events_lock, flags);
+        rcu_read_unlock();
 }
 
 /**
@@ -184,10 +556,13 @@ bool pm_check_wakeup_events(void)
 
         spin_lock_irqsave(&events_lock, flags);
         if (events_check_enabled) {
-                ret = (event_count == saved_event_count) && !events_in_progress;
+                ret = ((unsigned int)atomic_read(&event_count) == saved_count)
+                        && !atomic_read(&events_in_progress);
                 events_check_enabled = ret;
         }
         spin_unlock_irqrestore(&events_lock, flags);
+        if (!ret)
+                pm_wakeup_update_hit_counts();
         return ret;
 }
 
@@ -202,24 +577,20 @@ bool pm_check_wakeup_events(void)
  * drop down to zero has been interrupted by a signal (and the current number
  * of wakeup events being processed is still nonzero).  Otherwise return true.
  */
-bool pm_get_wakeup_count(unsigned long *count)
+bool pm_get_wakeup_count(unsigned int *count)
 {
         bool ret;
 
-        spin_lock_irq(&events_lock);
         if (capable(CAP_SYS_ADMIN))
                 events_check_enabled = false;
 
-        while (events_in_progress && !signal_pending(current)) {
-                spin_unlock_irq(&events_lock);
-
-                schedule_timeout_interruptible(msecs_to_jiffies(100));
-
-                spin_lock_irq(&events_lock);
+        while (atomic_read(&events_in_progress) && !signal_pending(current)) {
+                pm_wakeup_update_hit_counts();
+                schedule_timeout_interruptible(msecs_to_jiffies(TIMEOUT));
         }
-        *count = event_count;
-        ret = !events_in_progress;
-        spin_unlock_irq(&events_lock);
+
+        ret = !atomic_read(&events_in_progress);
+        *count = atomic_read(&event_count);
         return ret;
 }
 
@@ -232,16 +603,102 @@ bool pm_get_wakeup_count(unsigned long *count)
  * old number of registered wakeup events to be used by pm_check_wakeup_events()
  * and return true.  Otherwise return false.
  */
-bool pm_save_wakeup_count(unsigned long count)
+bool pm_save_wakeup_count(unsigned int count)
 {
         bool ret = false;
 
         spin_lock_irq(&events_lock);
-        if (count == event_count && !events_in_progress) {
-                saved_event_count = count;
+        if (count == (unsigned int)atomic_read(&event_count)
+            && !atomic_read(&events_in_progress)) {
+                saved_count = count;
                 events_check_enabled = true;
                 ret = true;
         }
         spin_unlock_irq(&events_lock);
+        if (!ret)
+                pm_wakeup_update_hit_counts();
+        return ret;
+}
+
+static struct dentry *wakeup_sources_stats_dentry;
+
+/**
+ * print_wakeup_source_stats - Print wakeup source statistics information.
+ * @m: seq_file to print the statistics into.
+ * @ws: Wakeup source object to print the statistics for.
+ */
+static int print_wakeup_source_stats(struct seq_file *m,
+                                     struct wakeup_source *ws)
+{
+        unsigned long flags;
+        ktime_t total_time;
+        ktime_t max_time;
+        unsigned long active_count;
+        ktime_t active_time;
+        int ret;
+
+        spin_lock_irqsave(&ws->lock, flags);
+
+        total_time = ws->total_time;
+        max_time = ws->max_time;
+        active_count = ws->active_count;
+        if (ws->active) {
+                active_time = ktime_sub(ktime_get(), ws->last_time);
+                total_time = ktime_add(total_time, active_time);
+                if (active_time.tv64 > max_time.tv64)
+                        max_time = active_time;
+        } else {
+                active_time = ktime_set(0, 0);
+        }
+
+        ret = seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t"
+                        "%lld\t\t%lld\t\t%lld\t\t%lld\n",
+                        ws->name, active_count, ws->event_count, ws->hit_count,
+                        ktime_to_ms(active_time), ktime_to_ms(total_time),
+                        ktime_to_ms(max_time), ktime_to_ms(ws->last_time));
+
+        spin_unlock_irqrestore(&ws->lock, flags);
+
         return ret;
 }
+
+/**
+ * wakeup_sources_stats_show - Print wakeup sources statistics information.
+ * @m: seq_file to print the statistics into.
+ */
+static int wakeup_sources_stats_show(struct seq_file *m, void *unused)
+{
+        struct wakeup_source *ws;
+
+        seq_puts(m, "name\t\tactive_count\tevent_count\thit_count\t"
+                "active_since\ttotal_time\tmax_time\tlast_change\n");
+
+        rcu_read_lock();
+        list_for_each_entry_rcu(ws, &wakeup_sources, entry)
+                print_wakeup_source_stats(m, ws);
+        rcu_read_unlock();
+
+        return 0;
+}
+
+static int wakeup_sources_stats_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, wakeup_sources_stats_show, NULL);
+}
+
+static const struct file_operations wakeup_sources_stats_fops = {
+        .owner = THIS_MODULE,
+        .open = wakeup_sources_stats_open,
+        .read = seq_read,
+        .llseek = seq_lseek,
+        .release = single_release,
+};
+
+static int __init wakeup_sources_debugfs_init(void)
+{
+        wakeup_sources_stats_dentry = debugfs_create_file("wakeup_sources",
+                        S_IRUGO, NULL, NULL, &wakeup_sources_stats_fops);
+        return 0;
+}
+
+postcore_initcall(wakeup_sources_debugfs_init);
diff --git a/drivers/base/topology.c b/drivers/base/topology.c
index 9fc630ce1ddb..f6f37a05a0c3 100644
--- a/drivers/base/topology.c
+++ b/drivers/base/topology.c
@@ -45,7 +45,8 @@ static ssize_t show_##name(struct sys_device *dev,		\
         return sprintf(buf, "%d\n", topology_##name(cpu));      \
 }
 
-#if defined(topology_thread_cpumask) || defined(topology_core_cpumask)
+#if defined(topology_thread_cpumask) || defined(topology_core_cpumask) || \
+    defined(topology_book_cpumask)
 static ssize_t show_cpumap(int type, const struct cpumask *mask, char *buf)
 {
         ptrdiff_t len = PTR_ALIGN(buf + PAGE_SIZE - 1, PAGE_SIZE) - buf;
@@ -114,6 +115,14 @@ define_siblings_show_func(core_cpumask);
 define_one_ro_named(core_siblings, show_core_cpumask);
 define_one_ro_named(core_siblings_list, show_core_cpumask_list);
 
+#ifdef CONFIG_SCHED_BOOK
+define_id_show_func(book_id);
+define_one_ro(book_id);
+define_siblings_show_func(book_cpumask);
+define_one_ro_named(book_siblings, show_book_cpumask);
+define_one_ro_named(book_siblings_list, show_book_cpumask_list);
+#endif
+
 static struct attribute *default_attrs[] = {
         &attr_physical_package_id.attr,
         &attr_core_id.attr,
@@ -121,6 +130,11 @@ static struct attribute *default_attrs[] = {
         &attr_thread_siblings_list.attr,
         &attr_core_siblings.attr,
         &attr_core_siblings_list.attr,
+#ifdef CONFIG_SCHED_BOOK
+        &attr_book_id.attr,
+        &attr_book_siblings.attr,
+        &attr_book_siblings_list.attr,
+#endif
         NULL
 };
 
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index de277689da61..4b9359a6f6ca 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -488,4 +488,21 @@ config BLK_DEV_HD
 
           If unsure, say N.
 
+config BLK_DEV_RBD
+        tristate "Rados block device (RBD)"
+        depends on INET && EXPERIMENTAL && BLOCK
+        select CEPH_LIB
+        select LIBCRC32C
+        select CRYPTO_AES
+        select CRYPTO
+        default n
+        help
+          Say Y here if you want include the Rados block device, which stripes
+          a block device over objects stored in the Ceph distributed object
+          store.
+
+          More information at http://ceph.newdream.net/.
+
+          If unsure, say N.
+
 endif # BLK_DEV
diff --git a/drivers/block/Makefile b/drivers/block/Makefile
index aff5ac925c34..d7f463d6312d 100644
--- a/drivers/block/Makefile
+++ b/drivers/block/Makefile
@@ -37,5 +37,6 @@ obj-$(CONFIG_BLK_DEV_HD)	+= hd.o
 
 obj-$(CONFIG_XEN_BLKDEV_FRONTEND)       += xen-blkfront.o
 obj-$(CONFIG_BLK_DEV_DRBD)     += drbd/
+obj-$(CONFIG_BLK_DEV_RBD)     += rbd.o
 
 swim_mod-objs   := swim.o swim_asm.o
diff --git a/drivers/block/ps3disk.c b/drivers/block/ps3disk.c
index e9da874d0419..03688c2da319 100644
--- a/drivers/block/ps3disk.c
+++ b/drivers/block/ps3disk.c
@@ -113,7 +113,7 @@ static void ps3disk_scatter_gather(struct ps3_storage_device *dev,
                         memcpy(buf, dev->bounce_buf+offset, size);
                 offset += size;
                 flush_kernel_dcache_page(bvec->bv_page);
-                bvec_kunmap_irq(bvec, &flags);
+                bvec_kunmap_irq(buf, &flags);
                 i++;
         }
 }
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
new file mode 100644
index 000000000000..6ec9d53806c5
--- /dev/null
+++ b/drivers/block/rbd.c
@@ -0,0 +1,1841 @@
+/*
+   rbd.c -- Export ceph rados objects as a Linux block device
+
+
+   based on drivers/block/osdblk.c:
+
+   Copyright 2009 Red Hat, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; see the file COPYING.  If not, write to
+   the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+
+
+
+   Instructions for use
+   --------------------
+
+   1) Map a Linux block device to an existing rbd image.
+
+      Usage: <mon ip addr> <options> <pool name> <rbd image name> [snap name]
+
+      $ echo "192.168.0.1 name=admin rbd foo" > /sys/class/rbd/add
+
+      The snapshot name can be "-" or omitted to map the image read/write.
+
+   2) List all active blkdev<->object mappings.
+
+      In this example, we have performed step #1 twice, creating two blkdevs,
+      mapped to two separate rados objects in the rados rbd pool
+
+      $ cat /sys/class/rbd/list
+      #id     major   client_name     pool    name    snap    KB
+      0       254     client4143      rbd     foo     -      1024000
+
+      The columns, in order, are:
+      - blkdev unique id
+      - blkdev assigned major
+      - rados client id
+      - rados pool name
+      - rados block device name
+      - mapped snapshot ("-" if none)
+      - device size in KB
+
+
+   3) Create a snapshot.
+
+      Usage: <blkdev id> <snapname>
+
+      $ echo "0 mysnap" > /sys/class/rbd/snap_create
+
+
+   4) Listing a snapshot.
+
+      $ cat /sys/class/rbd/snaps_list
+      #id     snap    KB
+      0       -       1024000 (*)
+      0       foo     1024000
+
+      The columns, in order, are:
+      - blkdev unique id
+      - snapshot name, '-' means none (active read/write version)
+      - size of device at time of snapshot
+      - the (*) indicates this is the active version
+
+   5) Rollback to snapshot.
+
+      Usage: <blkdev id> <snapname>
+
+      $ echo "0 mysnap" > /sys/class/rbd/snap_rollback
+
+
+   6) Mapping an image using snapshot.
+
+      A snapshot mapping is read-only. This is being done by passing
+      snap=<snapname> to the options when adding a device.
+
+      $ echo "192.168.0.1 name=admin,snap=mysnap rbd foo" > /sys/class/rbd/add
+
+
+   7) Remove an active blkdev<->rbd image mapping.
+
+      In this example, we remove the mapping with blkdev unique id 1.
+
+      $ echo 1 > /sys/class/rbd/remove
+
+
+   NOTE:  The actual creation and deletion of rados objects is outside the scope
+   of this driver.
+
+ */
+
+#include <linux/ceph/libceph.h>
+#include <linux/ceph/osd_client.h>
+#include <linux/ceph/mon_client.h>
+#include <linux/ceph/decode.h>
+
+#include <linux/kernel.h>
+#include <linux/device.h>
+#include <linux/module.h>
+#include <linux/fs.h>
+#include <linux/blkdev.h>
+
+#include "rbd_types.h"
+
+#define DRV_NAME "rbd"
+#define DRV_NAME_LONG "rbd (rados block device)"
+
+#define RBD_MINORS_PER_MAJOR    256             /* max minors per blkdev */
+
+#define RBD_MAX_MD_NAME_LEN     (96 + sizeof(RBD_SUFFIX))
+#define RBD_MAX_POOL_NAME_LEN   64
+#define RBD_MAX_SNAP_NAME_LEN   32
+#define RBD_MAX_OPT_LEN         1024
+
+#define RBD_SNAP_HEAD_NAME      "-"
+
+#define DEV_NAME_LEN            32
+
+/*
+ * block device image metadata (in-memory version)
+ */
+struct rbd_image_header {
+        u64 image_size;
+        char block_name[32];
+        __u8 obj_order;
+        __u8 crypt_type;
+        __u8 comp_type;
+        struct rw_semaphore snap_rwsem;
+        struct ceph_snap_context *snapc;
+        size_t snap_names_len;
+        u64 snap_seq;
+        u32 total_snaps;
+
+        char *snap_names;
+        u64 *snap_sizes;
+};
+
+/*
+ * an instance of the client.  multiple devices may share a client.
+ */
+struct rbd_client {
+        struct ceph_client      *client;
+        struct kref             kref;
+        struct list_head        node;
+};
+
+/*
+ * a single io request
+ */
+struct rbd_request {
+        struct request          *rq;            /* blk layer request */
+        struct bio              *bio;           /* cloned bio */
+        struct page             **pages;        /* list of used pages */
+        u64                     len;
+};
+
+/*
+ * a single device
+ */
+struct rbd_device {
+        int                     id;             /* blkdev unique id */
+
+        int                     major;          /* blkdev assigned major */
+        struct gendisk          *disk;          /* blkdev's gendisk and rq */
+        struct request_queue    *q;
+
+        struct ceph_client      *client;
+        struct rbd_client       *rbd_client;
+
+        char                    name[DEV_NAME_LEN]; /* blkdev name, e.g. rbd3 */
+
+        spinlock_t              lock;           /* queue lock */
+
+        struct rbd_image_header header;
+        char                    obj[RBD_MAX_OBJ_NAME_LEN]; /* rbd image name */
+        int                     obj_len;
+        char                    obj_md_name[RBD_MAX_MD_NAME_LEN]; /* hdr nm. */
+        char                    pool_name[RBD_MAX_POOL_NAME_LEN];
+        int                     poolid;
+
+        char                    snap_name[RBD_MAX_SNAP_NAME_LEN];
+        u32 cur_snap;   /* index+1 of current snapshot within snap context
+                           0 - for the head */
+        int read_only;
+
+        struct list_head        node;
+};
+
+static spinlock_t node_lock;      /* protects client get/put */
+
+static struct class *class_rbd;   /* /sys/class/rbd */
+static DEFINE_MUTEX(ctl_mutex);   /* Serialize open/close/setup/teardown */
+static LIST_HEAD(rbd_dev_list);    /* devices */
+static LIST_HEAD(rbd_client_list);      /* clients */
+
+
+static int rbd_open(struct block_device *bdev, fmode_t mode)
+{
+        struct gendisk *disk = bdev->bd_disk;
+        struct rbd_device *rbd_dev = disk->private_data;
+
+        set_device_ro(bdev, rbd_dev->read_only);
+
+        if ((mode & FMODE_WRITE) && rbd_dev->read_only)
+                return -EROFS;
+
+        return 0;
+}
+
+static const struct block_device_operations rbd_bd_ops = {
+        .owner                  = THIS_MODULE,
+        .open                   = rbd_open,
+};
+
+/*
+ * Initialize an rbd client instance.
+ * We own *opt.
+ */
+static struct rbd_client *rbd_client_create(struct ceph_options *opt)
+{
+        struct rbd_client *rbdc;
+        int ret = -ENOMEM;
+
+        dout("rbd_client_create\n");
+        rbdc = kmalloc(sizeof(struct rbd_client), GFP_KERNEL);
+        if (!rbdc)
+                goto out_opt;
+
+        kref_init(&rbdc->kref);
+        INIT_LIST_HEAD(&rbdc->node);
+
+        rbdc->client = ceph_create_client(opt, rbdc);
+        if (IS_ERR(rbdc->client))
+                goto out_rbdc;
+        opt = NULL; /* Now rbdc->client is responsible for opt */
+
+        ret = ceph_open_session(rbdc->client);
+        if (ret < 0)
+                goto out_err;
+
+        spin_lock(&node_lock);
+        list_add_tail(&rbdc->node, &rbd_client_list);
+        spin_unlock(&node_lock);
+
+        dout("rbd_client_create created %p\n", rbdc);
+        return rbdc;
+
+out_err:
+        ceph_destroy_client(rbdc->client);
+out_rbdc:
+        kfree(rbdc);
+out_opt:
+        if (opt)
+                ceph_destroy_options(opt);
+        return ERR_PTR(ret);
+}
+
+/*
+ * Find a ceph client with specific addr and configuration.
+ */
+static struct rbd_client *__rbd_client_find(struct ceph_options *opt)
+{
+        struct rbd_client *client_node;
+
+        if (opt->flags & CEPH_OPT_NOSHARE)
+                return NULL;
+
+        list_for_each_entry(client_node, &rbd_client_list, node)
+                if (ceph_compare_options(opt, client_node->client) == 0)
+                        return client_node;
+        return NULL;
+}
+
+/*
+ * Get a ceph client with specific addr and configuration, if one does
+ * not exist create it.
+ */
+static int rbd_get_client(struct rbd_device *rbd_dev, const char *mon_addr,
+                          char *options)
+{
+        struct rbd_client *rbdc;
+        struct ceph_options *opt;
+        int ret;
+
+        ret = ceph_parse_options(&opt, options, mon_addr,
+                                 mon_addr + strlen(mon_addr), NULL, NULL);
+        if (ret < 0)
+                return ret;
+
+        spin_lock(&node_lock);
+        rbdc = __rbd_client_find(opt);
+        if (rbdc) {
+                ceph_destroy_options(opt);
+
+                /* using an existing client */
+                kref_get(&rbdc->kref);
+                rbd_dev->rbd_client = rbdc;
+                rbd_dev->client = rbdc->client;
+                spin_unlock(&node_lock);
+                return 0;
+        }
+        spin_unlock(&node_lock);
+
+        rbdc = rbd_client_create(opt);
+        if (IS_ERR(rbdc))
+                return PTR_ERR(rbdc);
+
+        rbd_dev->rbd_client = rbdc;
+        rbd_dev->client = rbdc->client;
+        return 0;
+}
+
+/*
+ * Destroy ceph client
+ */
+static void rbd_client_release(struct kref *kref)
+{
+        struct rbd_client *rbdc = container_of(kref, struct rbd_client, kref);
+
+        dout("rbd_release_client %p\n", rbdc);
+        spin_lock(&node_lock);
+        list_del(&rbdc->node);
+        spin_unlock(&node_lock);
+
+        ceph_destroy_client(rbdc->client);
+        kfree(rbdc);
+}
+
+/*
+ * Drop reference to ceph client node. If it's not referenced anymore, release
+ * it.
+ */
+static void rbd_put_client(struct rbd_device *rbd_dev)
+{
+        kref_put(&rbd_dev->rbd_client->kref, rbd_client_release);
+        rbd_dev->rbd_client = NULL;
+        rbd_dev->client = NULL;
+}
+
+
+/*
+ * Create a new header structure, translate header format from the on-disk
+ * header.
+ */
+static int rbd_header_from_disk(struct rbd_image_header *header,
+                                 struct rbd_image_header_ondisk *ondisk,
+                                 int allocated_snaps,
+                                 gfp_t gfp_flags)
+{
+        int i;
+        u32 snap_count = le32_to_cpu(ondisk->snap_count);
+        int ret = -ENOMEM;
+
+        init_rwsem(&header->snap_rwsem);
+
+        header->snap_names_len = le64_to_cpu(ondisk->snap_names_len);
+        header->snapc = kmalloc(sizeof(struct ceph_snap_context) +
+                                snap_count *
+                                 sizeof(struct rbd_image_snap_ondisk),
+                                gfp_flags);
+        if (!header->snapc)
+                return -ENOMEM;
+        if (snap_count) {
+                header->snap_names = kmalloc(header->snap_names_len,
+                                             GFP_KERNEL);
+                if (!header->snap_names)
+                        goto err_snapc;
+                header->snap_sizes = kmalloc(snap_count * sizeof(u64),
+                                             GFP_KERNEL);
+                if (!header->snap_sizes)
+                        goto err_names;
+        } else {
+                header->snap_names = NULL;
+                header->snap_sizes = NULL;
+        }
+        memcpy(header->block_name, ondisk->block_name,
+               sizeof(ondisk->block_name));
+
+        header->image_size = le64_to_cpu(ondisk->image_size);
+        header->obj_order = ondisk->options.order;
+        header->crypt_type = ondisk->options.crypt_type;
+        header->comp_type = ondisk->options.comp_type;
+
+        atomic_set(&header->snapc->nref, 1);
+        header->snap_seq = le64_to_cpu(ondisk->snap_seq);
+        header->snapc->num_snaps = snap_count;
+        header->total_snaps = snap_count;
+
+        if (snap_count &&
+            allocated_snaps == snap_count) {
+                for (i = 0; i < snap_count; i++) {
+                        header->snapc->snaps[i] =
+                                le64_to_cpu(ondisk->snaps[i].id);
+                        header->snap_sizes[i] =
+                                le64_to_cpu(ondisk->snaps[i].image_size);
+                }
+
+                /* copy snapshot names */
+                memcpy(header->snap_names, &ondisk->snaps[i],
+                        header->snap_names_len);
+        }
+
+        return 0;
+
+err_names:
+        kfree(header->snap_names);
+err_snapc:
+        kfree(header->snapc);
+        return ret;
+}
+
+static int snap_index(struct rbd_image_header *header, int snap_num)
+{
+        return header->total_snaps - snap_num;
+}
+
+static u64 cur_snap_id(struct rbd_device *rbd_dev)
+{
+        struct rbd_image_header *header = &rbd_dev->header;
+
+        if (!rbd_dev->cur_snap)
+                return 0;
+
+        return header->snapc->snaps[snap_index(header, rbd_dev->cur_snap)];
+}
+
+static int snap_by_name(struct rbd_image_header *header, const char *snap_name,
+                        u64 *seq, u64 *size)
+{
+        int i;
+        char *p = header->snap_names;
+
+        for (i = 0; i < header->total_snaps; i++, p += strlen(p) + 1) {
+                if (strcmp(snap_name, p) == 0)
+                        break;
+        }
+        if (i == header->total_snaps)
+                return -ENOENT;
+        if (seq)
+                *seq = header->snapc->snaps[i];
+
+        if (size)
+                *size = header->snap_sizes[i];
+
+        return i;
+}
+
+static int rbd_header_set_snap(struct rbd_device *dev,
+                               const char *snap_name,
+                               u64 *size)
+{
+        struct rbd_image_header *header = &dev->header;
+        struct ceph_snap_context *snapc = header->snapc;
+        int ret = -ENOENT;
+
+        down_write(&header->snap_rwsem);
+
+        if (!snap_name ||
+            !*snap_name ||
+            strcmp(snap_name, "-") == 0 ||
+            strcmp(snap_name, RBD_SNAP_HEAD_NAME) == 0) {
+                if (header->total_snaps)
+                        snapc->seq = header->snap_seq;
+                else
+                        snapc->seq = 0;
+                dev->cur_snap = 0;
+                dev->read_only = 0;
+                if (size)
+                        *size = header->image_size;
+        } else {
+                ret = snap_by_name(header, snap_name, &snapc->seq, size);
+                if (ret < 0)
+                        goto done;
+
+                dev->cur_snap = header->total_snaps - ret;
+                dev->read_only = 1;
+        }
+
+        ret = 0;
+done:
+        up_write(&header->snap_rwsem);
+        return ret;
+}
+
+static void rbd_header_free(struct rbd_image_header *header)
+{
+        kfree(header->snapc);
+        kfree(header->snap_names);
+        kfree(header->snap_sizes);
+}
+
+/*
+ * get the actual striped segment name, offset and length
+ */
+static u64 rbd_get_segment(struct rbd_image_header *header,
+                           const char *block_name,
+                           u64 ofs, u64 len,
+                           char *seg_name, u64 *segofs)
+{
+        u64 seg = ofs >> header->obj_order;
+
+        if (seg_name)
+                snprintf(seg_name, RBD_MAX_SEG_NAME_LEN,
+                         "%s.%012llx", block_name, seg);
+
+        ofs = ofs & ((1 << header->obj_order) - 1);
+        len = min_t(u64, len, (1 << header->obj_order) - ofs);
+
+        if (segofs)
+                *segofs = ofs;
+
+        return len;
+}
+
+/*
+ * bio helpers
+ */
+
+static void bio_chain_put(struct bio *chain)
+{
+        struct bio *tmp;
+
+        while (chain) {
+                tmp = chain;
+                chain = chain->bi_next;
+                bio_put(tmp);
+        }
+}
+
+/*
+ * zeros a bio chain, starting at specific offset
+ */
+static void zero_bio_chain(struct bio *chain, int start_ofs)
+{
+        struct bio_vec *bv;
+        unsigned long flags;
+        void *buf;
+        int i;
+        int pos = 0;
+
+        while (chain) {
+                bio_for_each_segment(bv, chain, i) {
+                        if (pos + bv->bv_len > start_ofs) {
+                                int remainder = max(start_ofs - pos, 0);
+                                buf = bvec_kmap_irq(bv, &flags);
+                                memset(buf + remainder, 0,
+                                       bv->bv_len - remainder);
+                                bvec_kunmap_irq(buf, &flags);
+                        }
+                        pos += bv->bv_len;
+                }
+
+                chain = chain->bi_next;
+        }
+}
+
+/*
+ * bio_chain_clone - clone a chain of bios up to a certain length.
+ * might return a bio_pair that will need to be released.
+ */
+static struct bio *bio_chain_clone(struct bio **old, struct bio **next,
+                                   struct bio_pair **bp,
+                                   int len, gfp_t gfpmask)
+{
+        struct bio *tmp, *old_chain = *old, *new_chain = NULL, *tail = NULL;
+        int total = 0;
+
+        if (*bp) {
+                bio_pair_release(*bp);
+                *bp = NULL;
+        }
+
+        while (old_chain && (total < len)) {
+                tmp = bio_kmalloc(gfpmask, old_chain->bi_max_vecs);
+                if (!tmp)
+                        goto err_out;
+
+                if (total + old_chain->bi_size > len) {
+                        struct bio_pair *bp;
+
+                        /*
+                         * this split can only happen with a single paged bio,
+                         * split_bio will BUG_ON if this is not the case
+                         */
+                        dout("bio_chain_clone split! total=%d remaining=%d"
+                             "bi_size=%d\n",
+                             (int)total, (int)len-total,
+                             (int)old_chain->bi_size);
+
+                        /* split the bio. We'll release it either in the next
+                           call, or it will have to be released outside */
+                        bp = bio_split(old_chain, (len - total) / 512ULL);
+                        if (!bp)
+                                goto err_out;
+
+                        __bio_clone(tmp, &bp->bio1);
+
+                        *next = &bp->bio2;
+                } else {
+                        __bio_clone(tmp, old_chain);
+                        *next = old_chain->bi_next;
+                }
+
+                tmp->bi_bdev = NULL;
+                gfpmask &= ~__GFP_WAIT;
+                tmp->bi_next = NULL;
+
+                if (!new_chain) {
+                        new_chain = tail = tmp;
+                } else {
+                        tail->bi_next = tmp;
+                        tail = tmp;
+                }
+                old_chain = old_chain->bi_next;
+
+                total += tmp->bi_size;
+        }
+
+        BUG_ON(total < len);
+
+        if (tail)
+                tail->bi_next = NULL;
+
+        *old = old_chain;
+
+        return new_chain;
+
+err_out:
+        dout("bio_chain_clone with err\n");
+        bio_chain_put(new_chain);
+        return NULL;
+}
+
+/*
+ * helpers for osd request op vectors.
+ */
+static int rbd_create_rw_ops(struct ceph_osd_req_op **ops,
+                            int num_ops,
+                            int opcode,
+                            u32 payload_len)
+{
+        *ops = kzalloc(sizeof(struct ceph_osd_req_op) * (num_ops + 1),
+                       GFP_NOIO);
+        if (!*ops)
+                return -ENOMEM;
+        (*ops)[0].op = opcode;
+        /*
+         * op extent offset and length will be set later on
+         * in calc_raw_layout()
+         */
+        (*ops)[0].payload_len = payload_len;
+        return 0;
+}
+
+static void rbd_destroy_ops(struct ceph_osd_req_op *ops)
+{
+        kfree(ops);
+}
+
+/*
+ * Send ceph osd request
+ */
+static int rbd_do_request(struct request *rq,
+                          struct rbd_device *dev,
+                          struct ceph_snap_context *snapc,
+                          u64 snapid,
+                          const char *obj, u64 ofs, u64 len,
+                          struct bio *bio,
+                          struct page **pages,
+                          int num_pages,
+                          int flags,
+                          struct ceph_osd_req_op *ops,
+                          int num_reply,
+                          void (*rbd_cb)(struct ceph_osd_request *req,
+                                         struct ceph_msg *msg))
+{
+        struct ceph_osd_request *req;
+        struct ceph_file_layout *layout;
+        int ret;
+        u64 bno;
+        struct timespec mtime = CURRENT_TIME;
+        struct rbd_request *req_data;
+        struct ceph_osd_request_head *reqhead;
+        struct rbd_image_header *header = &dev->header;
+
+        ret = -ENOMEM;
+        req_data = kzalloc(sizeof(*req_data), GFP_NOIO);
+        if (!req_data)
+                goto done;
+
+        dout("rbd_do_request len=%lld ofs=%lld\n", len, ofs);
+
+        down_read(&header->snap_rwsem);
+
+        req = ceph_osdc_alloc_request(&dev->client->osdc, flags,
+                                      snapc,
+                                      ops,
+                                      false,
+                                      GFP_NOIO, pages, bio);
+        if (IS_ERR(req)) {
+                up_read(&header->snap_rwsem);
+                ret = PTR_ERR(req);
+                goto done_pages;
+        }
+
+        req->r_callback = rbd_cb;
+
+        req_data->rq = rq;
+        req_data->bio = bio;
+        req_data->pages = pages;
+        req_data->len = len;
+
+        req->r_priv = req_data;
+
+        reqhead = req->r_request->front.iov_base;
+        reqhead->snapid = cpu_to_le64(CEPH_NOSNAP);
+
+        strncpy(req->r_oid, obj, sizeof(req->r_oid));
+        req->r_oid_len = strlen(req->r_oid);
+
+        layout = &req->r_file_layout;
+        memset(layout, 0, sizeof(*layout));
+        layout->fl_stripe_unit = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
+        layout->fl_stripe_count = cpu_to_le32(1);
+        layout->fl_object_size = cpu_to_le32(1 << RBD_MAX_OBJ_ORDER);
+        layout->fl_pg_preferred = cpu_to_le32(-1);
+        layout->fl_pg_pool = cpu_to_le32(dev->poolid);
+        ceph_calc_raw_layout(&dev->client->osdc, layout, snapid,
+                             ofs, &len, &bno, req, ops);
+
+        ceph_osdc_build_request(req, ofs, &len,
+                                ops,
+                                snapc,
+                                &mtime,
+                                req->r_oid, req->r_oid_len);
+        up_read(&header->snap_rwsem);
+
+        ret = ceph_osdc_start_request(&dev->client->osdc, req, false);
+        if (ret < 0)
+                goto done_err;
+
+        if (!rbd_cb) {
+                ret = ceph_osdc_wait_request(&dev->client->osdc, req);
+                ceph_osdc_put_request(req);
+        }
+        return ret;
+
+done_err:
+        bio_chain_put(req_data->bio);
+        ceph_osdc_put_request(req);
+done_pages:
+        kfree(req_data);
+done:
+        if (rq)
+                blk_end_request(rq, ret, len);
+        return ret;
+}
+
+/*
+ * Ceph osd op callback
+ */
+static void rbd_req_cb(struct ceph_osd_request *req, struct ceph_msg *msg)
+{
+        struct rbd_request *req_data = req->r_priv;
+        struct ceph_osd_reply_head *replyhead;
+        struct ceph_osd_op *op;
+        __s32 rc;
+        u64 bytes;
+        int read_op;
+
+        /* parse reply */
+        replyhead = msg->front.iov_base;
+        WARN_ON(le32_to_cpu(replyhead->num_ops) == 0);
+        op = (void *)(replyhead + 1);
+        rc = le32_to_cpu(replyhead->result);
+        bytes = le64_to_cpu(op->extent.length);
+        read_op = (le32_to_cpu(op->op) == CEPH_OSD_OP_READ);
+
+        dout("rbd_req_cb bytes=%lld readop=%d rc=%d\n", bytes, read_op, rc);
+
+        if (rc == -ENOENT && read_op) {
+                zero_bio_chain(req_data->bio, 0);
+                rc = 0;
+        } else if (rc == 0 && read_op && bytes < req_data->len) {
+                zero_bio_chain(req_data->bio, bytes);
+                bytes = req_data->len;
+        }
+
+        blk_end_request(req_data->rq, rc, bytes);
+
+        if (req_data->bio)
+                bio_chain_put(req_data->bio);
+
+        ceph_osdc_put_request(req);
+        kfree(req_data);
+}
+
+/*
+ * Do a synchronous ceph osd operation
+ */
+static int rbd_req_sync_op(struct rbd_device *dev,
+                           struct ceph_snap_context *snapc,
+                           u64 snapid,
+                           int opcode,
+                           int flags,
+                           struct ceph_osd_req_op *orig_ops,
+                           int num_reply,
+                           const char *obj,
+                           u64 ofs, u64 len,
+                           char *buf)
+{
+        int ret;
+        struct page **pages;
+        int num_pages;
+        struct ceph_osd_req_op *ops = orig_ops;
+        u32 payload_len;
+
+        num_pages = calc_pages_for(ofs , len);
+        pages = ceph_alloc_page_vector(num_pages, GFP_KERNEL);
+        if (IS_ERR(pages))
+                return PTR_ERR(pages);
+
+        if (!orig_ops) {
+                payload_len = (flags & CEPH_OSD_FLAG_WRITE ? len : 0);
+                ret = rbd_create_rw_ops(&ops, 1, opcode, payload_len);
+                if (ret < 0)
+                        goto done;
+
+                if ((flags & CEPH_OSD_FLAG_WRITE) && buf) {
+                        ret = ceph_copy_to_page_vector(pages, buf, ofs, len);
+                        if (ret < 0)
+                                goto done_ops;
+                }
+        }
+
+        ret = rbd_do_request(NULL, dev, snapc, snapid,
+                          obj, ofs, len, NULL,
+                          pages, num_pages,
+                          flags,
+                          ops,
+                          2,
+                          NULL);
+        if (ret < 0)
+                goto done_ops;
+
+        if ((flags & CEPH_OSD_FLAG_READ) && buf)
+                ret = ceph_copy_from_page_vector(pages, buf, ofs, ret);
+
+done_ops:
+        if (!orig_ops)
+                rbd_destroy_ops(ops);
+done:
+        ceph_release_page_vector(pages, num_pages);
+        return ret;
+}
+
+/*
+ * Do an asynchronous ceph osd operation
+ */
+static int rbd_do_op(struct request *rq,
+                     struct rbd_device *rbd_dev ,
+                     struct ceph_snap_context *snapc,
+                     u64 snapid,
+                     int opcode, int flags, int num_reply,
+                     u64 ofs, u64 len,
+                     struct bio *bio)
+{
+        char *seg_name;
+        u64 seg_ofs;
+        u64 seg_len;
+        int ret;
+        struct ceph_osd_req_op *ops;
+        u32 payload_len;
+
+        seg_name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO);
+        if (!seg_name)
+                return -ENOMEM;
+
+        seg_len = rbd_get_segment(&rbd_dev->header,
+                                  rbd_dev->header.block_name,
+                                  ofs, len,
+                                  seg_name, &seg_ofs);
+
+        payload_len = (flags & CEPH_OSD_FLAG_WRITE ? seg_len : 0);
+
+        ret = rbd_create_rw_ops(&ops, 1, opcode, payload_len);
+        if (ret < 0)
+                goto done;
+
+        /* we've taken care of segment sizes earlier when we
+           cloned the bios. We should never have a segment
+           truncated at this point */
+        BUG_ON(seg_len < len);
+
+        ret = rbd_do_request(rq, rbd_dev, snapc, snapid,
+                             seg_name, seg_ofs, seg_len,
+                             bio,
+                             NULL, 0,
+                             flags,
+                             ops,
+                             num_reply,
+                             rbd_req_cb);
+done:
+        kfree(seg_name);
+        return ret;
+}
+
+/*
+ * Request async osd write
+ */
+static int rbd_req_write(struct request *rq,
+                         struct rbd_device *rbd_dev,
+                         struct ceph_snap_context *snapc,
+                         u64 ofs, u64 len,
+                         struct bio *bio)
+{
+        return rbd_do_op(rq, rbd_dev, snapc, CEPH_NOSNAP,
+                         CEPH_OSD_OP_WRITE,
+                         CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
+                         2,
+                         ofs, len, bio);
+}
+
+/*
+ * Request async osd read
+ */
+static int rbd_req_read(struct request *rq,
+                         struct rbd_device *rbd_dev,
+                         u64 snapid,
+                         u64 ofs, u64 len,
+                         struct bio *bio)
+{
+        return rbd_do_op(rq, rbd_dev, NULL,
+                         (snapid ? snapid : CEPH_NOSNAP),
+                         CEPH_OSD_OP_READ,
+                         CEPH_OSD_FLAG_READ,
+                         2,
+                         ofs, len, bio);
+}
+
+/*
+ * Request sync osd read
+ */
+static int rbd_req_sync_read(struct rbd_device *dev,
+                          struct ceph_snap_context *snapc,
+                          u64 snapid,
+                          const char *obj,
+                          u64 ofs, u64 len,
+                          char *buf)
+{
+        return rbd_req_sync_op(dev, NULL,
+                               (snapid ? snapid : CEPH_NOSNAP),
+                               CEPH_OSD_OP_READ,
+                               CEPH_OSD_FLAG_READ,
+                               NULL,
+                               1, obj, ofs, len, buf);
+}
+
+/*
+ * Request sync osd read
+ */
+static int rbd_req_sync_rollback_obj(struct rbd_device *dev,
+                                     u64 snapid,
+                                     const char *obj)
+{
+        struct ceph_osd_req_op *ops;
+        int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_ROLLBACK, 0);
+        if (ret < 0)
+                return ret;
+
+        ops[0].snap.snapid = snapid;
+
+        ret = rbd_req_sync_op(dev, NULL,
+                               CEPH_NOSNAP,
+                               0,
+                               CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
+                               ops,
+                               1, obj, 0, 0, NULL);
+
+        rbd_destroy_ops(ops);
+
+        if (ret < 0)
+                return ret;
+
+        return ret;
+}
+
+/*
+ * Request sync osd read
+ */
+static int rbd_req_sync_exec(struct rbd_device *dev,
+                             const char *obj,
+                             const char *cls,
+                             const char *method,
+                             const char *data,
+                             int len)
+{
+        struct ceph_osd_req_op *ops;
+        int cls_len = strlen(cls);
+        int method_len = strlen(method);
+        int ret = rbd_create_rw_ops(&ops, 1, CEPH_OSD_OP_CALL,
+                                    cls_len + method_len + len);
+        if (ret < 0)
+                return ret;
+
+        ops[0].cls.class_name = cls;
+        ops[0].cls.class_len = (__u8)cls_len;
+        ops[0].cls.method_name = method;
+        ops[0].cls.method_len = (__u8)method_len;
+        ops[0].cls.argc = 0;
+        ops[0].cls.indata = data;
+        ops[0].cls.indata_len = len;
+
+        ret = rbd_req_sync_op(dev, NULL,
+                               CEPH_NOSNAP,
+                               0,
+                               CEPH_OSD_FLAG_WRITE | CEPH_OSD_FLAG_ONDISK,
+                               ops,
+                               1, obj, 0, 0, NULL);
+
+        rbd_destroy_ops(ops);
+
+        dout("cls_exec returned %d\n", ret);
+        return ret;
+}
+
+/*
+ * block device queue callback
+ */
+static void rbd_rq_fn(struct request_queue *q)
+{
+        struct rbd_device *rbd_dev = q->queuedata;
+        struct request *rq;
+        struct bio_pair *bp = NULL;
+
+        rq = blk_fetch_request(q);
+
+        while (1) {
+                struct bio *bio;
+                struct bio *rq_bio, *next_bio = NULL;
+                bool do_write;
+                int size, op_size = 0;
+                u64 ofs;
+
+                /* peek at request from block layer */
+                if (!rq)
+                        break;
+
+                dout("fetched request\n");
+
+                /* filter out block requests we don't understand */
+                if ((rq->cmd_type != REQ_TYPE_FS)) {
+                        __blk_end_request_all(rq, 0);
+                        goto next;
+                }
+
+                /* deduce our operation (read, write) */
+                do_write = (rq_data_dir(rq) == WRITE);
+
+                size = blk_rq_bytes(rq);
+                ofs = blk_rq_pos(rq) * 512ULL;
+                rq_bio = rq->bio;
+                if (do_write && rbd_dev->read_only) {
+                        __blk_end_request_all(rq, -EROFS);
+                        goto next;
+                }
+
+                spin_unlock_irq(q->queue_lock);
+
+                dout("%s 0x%x bytes at 0x%llx\n",
+                     do_write ? "write" : "read",
+                     size, blk_rq_pos(rq) * 512ULL);
+
+                do {
+                        /* a bio clone to be passed down to OSD req */
+                        dout("rq->bio->bi_vcnt=%d\n", rq->bio->bi_vcnt);
+                        op_size = rbd_get_segment(&rbd_dev->header,
+                                                  rbd_dev->header.block_name,
+                                                  ofs, size,
+                                                  NULL, NULL);
+                        bio = bio_chain_clone(&rq_bio, &next_bio, &bp,
+                                              op_size, GFP_ATOMIC);
+                        if (!bio) {
+                                spin_lock_irq(q->queue_lock);
+                                __blk_end_request_all(rq, -ENOMEM);
+                                goto next;
+                        }
+
+                        /* init OSD command: write or read */
+                        if (do_write)
+                                rbd_req_write(rq, rbd_dev,
+                                              rbd_dev->header.snapc,
+                                              ofs,
+                                              op_size, bio);
+                        else
+                                rbd_req_read(rq, rbd_dev,
+                                             cur_snap_id(rbd_dev),
+                                             ofs,
+                                             op_size, bio);
+
+                        size -= op_size;
+                        ofs += op_size;
+
+                        rq_bio = next_bio;
+                } while (size > 0);
+
+                if (bp)
+                        bio_pair_release(bp);
+
+                spin_lock_irq(q->queue_lock);
+next:
+                rq = blk_fetch_request(q);
+        }
+}
+
+/*
+ * a queue callback. Makes sure that we don't create a bio that spans across
+ * multiple osd objects. One exception would be with a single page bios,
+ * which we handle later at bio_chain_clone
+ */
+static int rbd_merge_bvec(struct request_queue *q, struct bvec_merge_data *bmd,
+                          struct bio_vec *bvec)
+{
+        struct rbd_device *rbd_dev = q->queuedata;
+        unsigned int chunk_sectors = 1 << (rbd_dev->header.obj_order - 9);
+        sector_t sector = bmd->bi_sector + get_start_sect(bmd->bi_bdev);
+        unsigned int bio_sectors = bmd->bi_size >> 9;
+        int max;
+
+        max =  (chunk_sectors - ((sector & (chunk_sectors - 1))
+                                 + bio_sectors)) << 9;
+        if (max < 0)
+                max = 0; /* bio_add cannot handle a negative return */
+        if (max <= bvec->bv_len && bio_sectors == 0)
+                return bvec->bv_len;
+        return max;
+}
+
+static void rbd_free_disk(struct rbd_device *rbd_dev)
+{
+        struct gendisk *disk = rbd_dev->disk;
+
+        if (!disk)
+                return;
+
+        rbd_header_free(&rbd_dev->header);
+
+        if (disk->flags & GENHD_FL_UP)
+                del_gendisk(disk);
+        if (disk->queue)
+                blk_cleanup_queue(disk->queue);
+        put_disk(disk);
+}
+
+/*
+ * reload the ondisk the header 
+ */
+static int rbd_read_header(struct rbd_device *rbd_dev,
+                           struct rbd_image_header *header)
+{
+        ssize_t rc;
+        struct rbd_image_header_ondisk *dh;
+        int snap_count = 0;
+        u64 snap_names_len = 0;
+
+        while (1) {
+                int len = sizeof(*dh) +
+                          snap_count * sizeof(struct rbd_image_snap_ondisk) +
+                          snap_names_len;
+
+                rc = -ENOMEM;
+                dh = kmalloc(len, GFP_KERNEL);
+                if (!dh)
+                        return -ENOMEM;
+
+                rc = rbd_req_sync_read(rbd_dev,
+                                       NULL, CEPH_NOSNAP,
+                                       rbd_dev->obj_md_name,
+                                       0, len,
+                                       (char *)dh);
+                if (rc < 0)
+                        goto out_dh;
+
+                rc = rbd_header_from_disk(header, dh, snap_count, GFP_KERNEL);
+                if (rc < 0)
+                        goto out_dh;
+
+                if (snap_count != header->total_snaps) {
+                        snap_count = header->total_snaps;
+                        snap_names_len = header->snap_names_len;
+                        rbd_header_free(header);
+                        kfree(dh);
+                        continue;
+                }
+                break;
+        }
+
+out_dh:
+        kfree(dh);
+        return rc;
+}
+
+/*
+ * create a snapshot
+ */
+static int rbd_header_add_snap(struct rbd_device *dev,
+                               const char *snap_name,
+                               gfp_t gfp_flags)
+{
+        int name_len = strlen(snap_name);
+        u64 new_snapid;
+        int ret;
+        void *data, *data_start, *data_end;
+
+        /* we should create a snapshot only if we're pointing at the head */
+        if (dev->cur_snap)
+                return -EINVAL;
+
+        ret = ceph_monc_create_snapid(&dev->client->monc, dev->poolid,
+                                      &new_snapid);
+        dout("created snapid=%lld\n", new_snapid);
+        if (ret < 0)
+                return ret;
+
+        data = kmalloc(name_len + 16, gfp_flags);
+        if (!data)
+                return -ENOMEM;
+
+        data_start = data;
+        data_end = data + name_len + 16;
+
+        ceph_encode_string_safe(&data, data_end, snap_name, name_len, bad);
+        ceph_encode_64_safe(&data, data_end, new_snapid, bad);
+
+        ret = rbd_req_sync_exec(dev, dev->obj_md_name, "rbd", "snap_add",
+                                data_start, data - data_start);
+
+        kfree(data_start);
+
+        if (ret < 0)
+                return ret;
+
+        dev->header.snapc->seq =  new_snapid;
+
+        return 0;
+bad:
+        return -ERANGE;
+}
+
+/*
+ * only read the first part of the ondisk header, without the snaps info
+ */
+static int rbd_update_snaps(struct rbd_device *rbd_dev)
+{
+        int ret;
+        struct rbd_image_header h;
+        u64 snap_seq;
+
+        ret = rbd_read_header(rbd_dev, &h);
+        if (ret < 0)
+                return ret;
+
+        down_write(&rbd_dev->header.snap_rwsem);
+
+        snap_seq = rbd_dev->header.snapc->seq;
+
+        kfree(rbd_dev->header.snapc);
+        kfree(rbd_dev->header.snap_names);
+        kfree(rbd_dev->header.snap_sizes);
+
+        rbd_dev->header.total_snaps = h.total_snaps;
+        rbd_dev->header.snapc = h.snapc;
+        rbd_dev->header.snap_names = h.snap_names;
+        rbd_dev->header.snap_sizes = h.snap_sizes;
+        rbd_dev->header.snapc->seq = snap_seq;
+
+        up_write(&rbd_dev->header.snap_rwsem);
+
+        return 0;
+}
+
+static int rbd_init_disk(struct rbd_device *rbd_dev)
+{
+        struct gendisk *disk;
+        struct request_queue *q;
+        int rc;
+        u64 total_size = 0;
+
+        /* contact OSD, request size info about the object being mapped */
+        rc = rbd_read_header(rbd_dev, &rbd_dev->header);
+        if (rc)
+                return rc;
+
+        rc = rbd_header_set_snap(rbd_dev, rbd_dev->snap_name, &total_size);
+        if (rc)
+                return rc;
+
+        /* create gendisk info */
+        rc = -ENOMEM;
+        disk = alloc_disk(RBD_MINORS_PER_MAJOR);
+        if (!disk)
+                goto out;
+
+        sprintf(disk->disk_name, DRV_NAME "%d", rbd_dev->id);
+        disk->major = rbd_dev->major;
+        disk->first_minor = 0;
+        disk->fops = &rbd_bd_ops;
+        disk->private_data = rbd_dev;
+
+        /* init rq */
+        rc = -ENOMEM;
+        q = blk_init_queue(rbd_rq_fn, &rbd_dev->lock);
+        if (!q)
+                goto out_disk;
+        blk_queue_merge_bvec(q, rbd_merge_bvec);
+        disk->queue = q;
+
+        q->queuedata = rbd_dev;
+
+        rbd_dev->disk = disk;
+        rbd_dev->q = q;
+
+        /* finally, announce the disk to the world */
+        set_capacity(disk, total_size / 512ULL);
+        add_disk(disk);
+
+        pr_info("%s: added with size 0x%llx\n",
+                disk->disk_name, (unsigned long long)total_size);
+        return 0;
+
+out_disk:
+        put_disk(disk);
+out:
+        return rc;
+}
+
+/********************************************************************
+ * /sys/class/rbd/
+ *                   add        map rados objects to blkdev
+ *                   remove     unmap rados objects
+ *                   list       show mappings
+ *******************************************************************/
+
+static void class_rbd_release(struct class *cls)
+{
+        kfree(cls);
+}
+
+static ssize_t class_rbd_list(struct class *c,
+                              struct class_attribute *attr,
+                              char *data)
+{
+        int n = 0;
+        struct list_head *tmp;
+        int max = PAGE_SIZE;
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        n += snprintf(data, max,
+                      "#id\tmajor\tclient_name\tpool\tname\tsnap\tKB\n");
+
+        list_for_each(tmp, &rbd_dev_list) {
+                struct rbd_device *rbd_dev;
+
+                rbd_dev = list_entry(tmp, struct rbd_device, node);
+                n += snprintf(data+n, max-n,
+                              "%d\t%d\tclient%lld\t%s\t%s\t%s\t%lld\n",
+                              rbd_dev->id,
+                              rbd_dev->major,
+                              ceph_client_id(rbd_dev->client),
+                              rbd_dev->pool_name,
+                              rbd_dev->obj, rbd_dev->snap_name,
+                              rbd_dev->header.image_size >> 10);
+                if (n == max)
+                        break;
+        }
+
+        mutex_unlock(&ctl_mutex);
+        return n;
+}
+
+static ssize_t class_rbd_add(struct class *c,
+                             struct class_attribute *attr,
+                             const char *buf, size_t count)
+{
+        struct ceph_osd_client *osdc;
+        struct rbd_device *rbd_dev;
+        ssize_t rc = -ENOMEM;
+        int irc, new_id = 0;
+        struct list_head *tmp;
+        char *mon_dev_name;
+        char *options;
+
+        if (!try_module_get(THIS_MODULE))
+                return -ENODEV;
+
+        mon_dev_name = kmalloc(RBD_MAX_OPT_LEN, GFP_KERNEL);
+        if (!mon_dev_name)
+                goto err_out_mod;
+
+        options = kmalloc(RBD_MAX_OPT_LEN, GFP_KERNEL);
+        if (!options)
+                goto err_mon_dev;
+
+        /* new rbd_device object */
+        rbd_dev = kzalloc(sizeof(*rbd_dev), GFP_KERNEL);
+        if (!rbd_dev)
+                goto err_out_opt;
+
+        /* static rbd_device initialization */
+        spin_lock_init(&rbd_dev->lock);
+        INIT_LIST_HEAD(&rbd_dev->node);
+
+        /* generate unique id: find highest unique id, add one */
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        list_for_each(tmp, &rbd_dev_list) {
+                struct rbd_device *rbd_dev;
+
+                rbd_dev = list_entry(tmp, struct rbd_device, node);
+                if (rbd_dev->id >= new_id)
+                        new_id = rbd_dev->id + 1;
+        }
+
+        rbd_dev->id = new_id;
+
+        /* add to global list */
+        list_add_tail(&rbd_dev->node, &rbd_dev_list);
+
+        /* parse add command */
+        if (sscanf(buf, "%" __stringify(RBD_MAX_OPT_LEN) "s "
+                   "%" __stringify(RBD_MAX_OPT_LEN) "s "
+                   "%" __stringify(RBD_MAX_POOL_NAME_LEN) "s "
+                   "%" __stringify(RBD_MAX_OBJ_NAME_LEN) "s"
+                   "%" __stringify(RBD_MAX_SNAP_NAME_LEN) "s",
+                   mon_dev_name, options, rbd_dev->pool_name,
+                   rbd_dev->obj, rbd_dev->snap_name) < 4) {
+                rc = -EINVAL;
+                goto err_out_slot;
+        }
+
+        if (rbd_dev->snap_name[0] == 0)
+                rbd_dev->snap_name[0] = '-';
+
+        rbd_dev->obj_len = strlen(rbd_dev->obj);
+        snprintf(rbd_dev->obj_md_name, sizeof(rbd_dev->obj_md_name), "%s%s",
+                 rbd_dev->obj, RBD_SUFFIX);
+
+        /* initialize rest of new object */
+        snprintf(rbd_dev->name, DEV_NAME_LEN, DRV_NAME "%d", rbd_dev->id);
+        rc = rbd_get_client(rbd_dev, mon_dev_name, options);
+        if (rc < 0)
+                goto err_out_slot;
+
+        mutex_unlock(&ctl_mutex);
+
+        /* pick the pool */
+        osdc = &rbd_dev->client->osdc;
+        rc = ceph_pg_poolid_by_name(osdc->osdmap, rbd_dev->pool_name);
+        if (rc < 0)
+                goto err_out_client;
+        rbd_dev->poolid = rc;
+
+        /* register our block device */
+        irc = register_blkdev(0, rbd_dev->name);
+        if (irc < 0) {
+                rc = irc;
+                goto err_out_client;
+        }
+        rbd_dev->major = irc;
+
+        /* set up and announce blkdev mapping */
+        rc = rbd_init_disk(rbd_dev);
+        if (rc)
+                goto err_out_blkdev;
+
+        return count;
+
+err_out_blkdev:
+        unregister_blkdev(rbd_dev->major, rbd_dev->name);
+err_out_client:
+        rbd_put_client(rbd_dev);
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+err_out_slot:
+        list_del_init(&rbd_dev->node);
+        mutex_unlock(&ctl_mutex);
+
+        kfree(rbd_dev);
+err_out_opt:
+        kfree(options);
+err_mon_dev:
+        kfree(mon_dev_name);
+err_out_mod:
+        dout("Error adding device %s\n", buf);
+        module_put(THIS_MODULE);
+        return rc;
+}
+
+static struct rbd_device *__rbd_get_dev(unsigned long id)
+{
+        struct list_head *tmp;
+        struct rbd_device *rbd_dev;
+
+        list_for_each(tmp, &rbd_dev_list) {
+                rbd_dev = list_entry(tmp, struct rbd_device, node);
+                if (rbd_dev->id == id)
+                        return rbd_dev;
+        }
+        return NULL;
+}
+
+static ssize_t class_rbd_remove(struct class *c,
+                                struct class_attribute *attr,
+                                const char *buf,
+                                size_t count)
+{
+        struct rbd_device *rbd_dev = NULL;
+        int target_id, rc;
+        unsigned long ul;
+
+        rc = strict_strtoul(buf, 10, &ul);
+        if (rc)
+                return rc;
+
+        /* convert to int; abort if we lost anything in the conversion */
+        target_id = (int) ul;
+        if (target_id != ul)
+                return -EINVAL;
+
+        /* remove object from list immediately */
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        rbd_dev = __rbd_get_dev(target_id);
+        if (rbd_dev)
+                list_del_init(&rbd_dev->node);
+
+        mutex_unlock(&ctl_mutex);
+
+        if (!rbd_dev)
+                return -ENOENT;
+
+        rbd_put_client(rbd_dev);
+
+        /* clean up and free blkdev */
+        rbd_free_disk(rbd_dev);
+        unregister_blkdev(rbd_dev->major, rbd_dev->name);
+        kfree(rbd_dev);
+
+        /* release module ref */
+        module_put(THIS_MODULE);
+
+        return count;
+}
+
+static ssize_t class_rbd_snaps_list(struct class *c,
+                              struct class_attribute *attr,
+                              char *data)
+{
+        struct rbd_device *rbd_dev = NULL;
+        struct list_head *tmp;
+        struct rbd_image_header *header;
+        int i, n = 0, max = PAGE_SIZE;
+        int ret;
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        n += snprintf(data, max, "#id\tsnap\tKB\n");
+
+        list_for_each(tmp, &rbd_dev_list) {
+                char *names, *p;
+                struct ceph_snap_context *snapc;
+
+                rbd_dev = list_entry(tmp, struct rbd_device, node);
+                header = &rbd_dev->header;
+
+                down_read(&header->snap_rwsem);
+
+                names = header->snap_names;
+                snapc = header->snapc;
+
+                n += snprintf(data + n, max - n, "%d\t%s\t%lld%s\n",
+                              rbd_dev->id, RBD_SNAP_HEAD_NAME,
+                              header->image_size >> 10,
+                              (!rbd_dev->cur_snap ? " (*)" : ""));
+                if (n == max)
+                        break;
+
+                p = names;
+                for (i = 0; i < header->total_snaps; i++, p += strlen(p) + 1) {
+                        n += snprintf(data + n, max - n, "%d\t%s\t%lld%s\n",
+                              rbd_dev->id, p, header->snap_sizes[i] >> 10,
+                              (rbd_dev->cur_snap &&
+                               (snap_index(header, i) == rbd_dev->cur_snap) ?
+                               " (*)" : ""));
+                        if (n == max)
+                                break;
+                }
+
+                up_read(&header->snap_rwsem);
+        }
+
+
+        ret = n;
+        mutex_unlock(&ctl_mutex);
+        return ret;
+}
+
+static ssize_t class_rbd_snaps_refresh(struct class *c,
+                                struct class_attribute *attr,
+                                const char *buf,
+                                size_t count)
+{
+        struct rbd_device *rbd_dev = NULL;
+        int target_id, rc;
+        unsigned long ul;
+        int ret = count;
+
+        rc = strict_strtoul(buf, 10, &ul);
+        if (rc)
+                return rc;
+
+        /* convert to int; abort if we lost anything in the conversion */
+        target_id = (int) ul;
+        if (target_id != ul)
+                return -EINVAL;
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        rbd_dev = __rbd_get_dev(target_id);
+        if (!rbd_dev) {
+                ret = -ENOENT;
+                goto done;
+        }
+
+        rc = rbd_update_snaps(rbd_dev);
+        if (rc < 0)
+                ret = rc;
+
+done:
+        mutex_unlock(&ctl_mutex);
+        return ret;
+}
+
+static ssize_t class_rbd_snap_create(struct class *c,
+                                struct class_attribute *attr,
+                                const char *buf,
+                                size_t count)
+{
+        struct rbd_device *rbd_dev = NULL;
+        int target_id, ret;
+        char *name;
+
+        name = kmalloc(RBD_MAX_SNAP_NAME_LEN + 1, GFP_KERNEL);
+        if (!name)
+                return -ENOMEM;
+
+        /* parse snaps add command */
+        if (sscanf(buf, "%d "
+                   "%" __stringify(RBD_MAX_SNAP_NAME_LEN) "s",
+                   &target_id,
+                   name) != 2) {
+                ret = -EINVAL;
+                goto done;
+        }
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        rbd_dev = __rbd_get_dev(target_id);
+        if (!rbd_dev) {
+                ret = -ENOENT;
+                goto done_unlock;
+        }
+
+        ret = rbd_header_add_snap(rbd_dev,
+                                  name, GFP_KERNEL);
+        if (ret < 0)
+                goto done_unlock;
+
+        ret = rbd_update_snaps(rbd_dev);
+        if (ret < 0)
+                goto done_unlock;
+
+        ret = count;
+done_unlock:
+        mutex_unlock(&ctl_mutex);
+done:
+        kfree(name);
+        return ret;
+}
+
+static ssize_t class_rbd_rollback(struct class *c,
+                                struct class_attribute *attr,
+                                const char *buf,
+                                size_t count)
+{
+        struct rbd_device *rbd_dev = NULL;
+        int target_id, ret;
+        u64 snapid;
+        char snap_name[RBD_MAX_SNAP_NAME_LEN];
+        u64 cur_ofs;
+        char *seg_name;
+
+        /* parse snaps add command */
+        if (sscanf(buf, "%d "
+                   "%" __stringify(RBD_MAX_SNAP_NAME_LEN) "s",
+                   &target_id,
+                   snap_name) != 2) {
+                return -EINVAL;
+        }
+
+        ret = -ENOMEM;
+        seg_name = kmalloc(RBD_MAX_SEG_NAME_LEN + 1, GFP_NOIO);
+        if (!seg_name)
+                return ret;
+
+        mutex_lock_nested(&ctl_mutex, SINGLE_DEPTH_NESTING);
+
+        rbd_dev = __rbd_get_dev(target_id);
+        if (!rbd_dev) {
+                ret = -ENOENT;
+                goto done_unlock;
+        }
+
+        ret = snap_by_name(&rbd_dev->header, snap_name, &snapid, NULL);
+        if (ret < 0)
+                goto done_unlock;
+
+        dout("snapid=%lld\n", snapid);
+
+        cur_ofs = 0;
+        while (cur_ofs < rbd_dev->header.image_size) {
+                cur_ofs += rbd_get_segment(&rbd_dev->header,
+                                           rbd_dev->obj,
+                                           cur_ofs, (u64)-1,
+                                           seg_name, NULL);
+                dout("seg_name=%s\n", seg_name);
+
+                ret = rbd_req_sync_rollback_obj(rbd_dev, snapid, seg_name);
+                if (ret < 0)
+                        pr_warning("could not roll back obj %s err=%d\n",
+                                   seg_name, ret);
+        }
+
+        ret = rbd_update_snaps(rbd_dev);
+        if (ret < 0)
+                goto done_unlock;
+
+        ret = count;
+
+done_unlock:
+        mutex_unlock(&ctl_mutex);
+        kfree(seg_name);
+
+        return ret;
+}
+
+static struct class_attribute class_rbd_attrs[] = {
+        __ATTR(add,             0200, NULL, class_rbd_add),
+        __ATTR(remove,          0200, NULL, class_rbd_remove),
+        __ATTR(list,            0444, class_rbd_list, NULL),
+        __ATTR(snaps_refresh,   0200, NULL, class_rbd_snaps_refresh),
+        __ATTR(snap_create,     0200, NULL, class_rbd_snap_create),
+        __ATTR(snaps_list,      0444, class_rbd_snaps_list, NULL),
+        __ATTR(snap_rollback,   0200, NULL, class_rbd_rollback),
+        __ATTR_NULL
+};
+
+/*
+ * create control files in sysfs
+ * /sys/class/rbd/...
+ */
+static int rbd_sysfs_init(void)
+{
+        int ret = -ENOMEM;
+
+        class_rbd = kzalloc(sizeof(*class_rbd), GFP_KERNEL);
+        if (!class_rbd)
+                goto out;
+
+        class_rbd->name = DRV_NAME;
+        class_rbd->owner = THIS_MODULE;
+        class_rbd->class_release = class_rbd_release;
+        class_rbd->class_attrs = class_rbd_attrs;
+
+        ret = class_register(class_rbd);
+        if (ret)
+                goto out_class;
+        return 0;
+
+out_class:
+        kfree(class_rbd);
+        class_rbd = NULL;
+        pr_err(DRV_NAME ": failed to create class rbd\n");
+out:
+        return ret;
+}
+
+static void rbd_sysfs_cleanup(void)
+{
+        if (class_rbd)
+                class_destroy(class_rbd);
+        class_rbd = NULL;
+}
+
+int __init rbd_init(void)
+{
+        int rc;
+
+        rc = rbd_sysfs_init();
+        if (rc)
+                return rc;
+        spin_lock_init(&node_lock);
+        pr_info("loaded " DRV_NAME_LONG "\n");
+        return 0;
+}
+
+void __exit rbd_exit(void)
+{
+        rbd_sysfs_cleanup();
+}
+
+module_init(rbd_init);
+module_exit(rbd_exit);
+
+MODULE_AUTHOR("Sage Weil <sage@newdream.net>");
+MODULE_AUTHOR("Yehuda Sadeh <yehuda@hq.newdream.net>");
+MODULE_DESCRIPTION("rados block device");
+
+/* following authorship retained from original osdblk.c */
+MODULE_AUTHOR("Jeff Garzik <jeff@garzik.org>");
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/block/rbd_types.h b/drivers/block/rbd_types.h
new file mode 100644
index 000000000000..fc6c678aa2cb
--- /dev/null
+++ b/drivers/block/rbd_types.h
@@ -0,0 +1,73 @@
+/*
+ * Ceph - scalable distributed file system
+ *
+ * Copyright (C) 2004-2010 Sage Weil <sage@newdream.net>
+ *
+ * This is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License version 2.1, as published by the Free Software
+ * Foundation.  See file COPYING.
+ *
+ */
+
+#ifndef CEPH_RBD_TYPES_H
+#define CEPH_RBD_TYPES_H
+
+#include <linux/types.h>
+
+/*
+ * rbd image 'foo' consists of objects
+ *   foo.rbd      - image metadata
+ *   foo.00000000
+ *   foo.00000001
+ *   ...          - data
+ */
+
+#define RBD_SUFFIX              ".rbd"
+#define RBD_DIRECTORY           "rbd_directory"
+#define RBD_INFO                "rbd_info"
+
+#define RBD_DEFAULT_OBJ_ORDER   22   /* 4MB */
+#define RBD_MIN_OBJ_ORDER       16
+#define RBD_MAX_OBJ_ORDER       30
+
+#define RBD_MAX_OBJ_NAME_LEN    96
+#define RBD_MAX_SEG_NAME_LEN    128
+
+#define RBD_COMP_NONE           0
+#define RBD_CRYPT_NONE          0
+
+#define RBD_HEADER_TEXT         "<<< Rados Block Device Image >>>\n"
+#define RBD_HEADER_SIGNATURE    "RBD"
+#define RBD_HEADER_VERSION      "001.005"
+
+struct rbd_info {
+        __le64 max_id;
+} __attribute__ ((packed));
+
+struct rbd_image_snap_ondisk {
+        __le64 id;
+        __le64 image_size;
+} __attribute__((packed));
+
+struct rbd_image_header_ondisk {
+        char text[40];
+        char block_name[24];
+        char signature[4];
+        char version[8];
+        struct {
+                __u8 order;
+                __u8 crypt_type;
+                __u8 comp_type;
+                __u8 unused;
+        } __attribute__((packed)) options;
+        __le64 image_size;
+        __le64 snap_seq;
+        __le32 snap_count;
+        __le32 reserved;
+        __le64 snap_names_len;
+        struct rbd_image_snap_ondisk snaps[0];
+} __attribute__((packed));
+
+
+#endif
diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c
index 2aafafca2b13..8320490226b7 100644
--- a/drivers/block/virtio_blk.c
+++ b/drivers/block/virtio_blk.c
@@ -2,7 +2,6 @@
 #include <linux/spinlock.h>
 #include <linux/slab.h>
 #include <linux/blkdev.h>
-#include <linux/smp_lock.h>
 #include <linux/hdreg.h>
 #include <linux/virtio.h>
 #include <linux/virtio_blk.h>
@@ -202,6 +201,7 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
         struct virtio_blk *vblk = disk->private_data;
         struct request *req;
         struct bio *bio;
+        int err;
 
         bio = bio_map_kern(vblk->disk->queue, id_str, VIRTIO_BLK_ID_BYTES,
                            GFP_KERNEL);
@@ -215,11 +215,14 @@ static int virtblk_get_id(struct gendisk *disk, char *id_str)
         }
 
         req->cmd_type = REQ_TYPE_SPECIAL;
-        return blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
+        err = blk_execute_rq(vblk->disk->queue, vblk->disk, req, false);
+        blk_put_request(req);
+
+        return err;
 }
 
-static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
-                         unsigned cmd, unsigned long data)
+static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
+                             unsigned int cmd, unsigned long data)
 {
         struct gendisk *disk = bdev->bd_disk;
         struct virtio_blk *vblk = disk->private_data;
@@ -234,18 +237,6 @@ static int virtblk_locked_ioctl(struct block_device *bdev, fmode_t mode,
                               (void __user *)data);
 }
 
-static int virtblk_ioctl(struct block_device *bdev, fmode_t mode,
-                             unsigned int cmd, unsigned long param)
-{
-        int ret;
-
-        lock_kernel();
-        ret = virtblk_locked_ioctl(bdev, mode, cmd, param);
-        unlock_kernel();
-
-        return ret;
-}
-
 /* We provide getgeo only to please some old bootloader/partitioning tools */
 static int virtblk_getgeo(struct block_device *bd, struct hd_geometry *geo)
 {
diff --git a/drivers/bluetooth/bluecard_cs.c b/drivers/bluetooth/bluecard_cs.c
index d52e90a5a617..4104b7feae67 100644
--- a/drivers/bluetooth/bluecard_cs.c
+++ b/drivers/bluetooth/bluecard_cs.c
@@ -39,7 +39,6 @@
 #include <linux/skbuff.h>
 #include <linux/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -865,8 +864,7 @@ static int bluecard_probe(struct pcmcia_device *link)
         info->p_dev = link;
         link->priv = info;
 
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ;
 
         return bluecard_config(link);
 }
@@ -886,7 +884,7 @@ static int bluecard_config(struct pcmcia_device *link)
         bluecard_info_t *info = link->priv;
         int i, n;
 
-        link->conf.ConfigIndex = 0x20;
+        link->config_index = 0x20;
 
         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
         link->resource[0]->end = 64;
@@ -906,7 +904,7 @@ static int bluecard_config(struct pcmcia_device *link)
         if (i != 0)
                 goto failed;
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 goto failed;
 
@@ -942,9 +940,7 @@ MODULE_DEVICE_TABLE(pcmcia, bluecard_ids);
 
 static struct pcmcia_driver bluecard_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "bluecard_cs",
-        },
+        .name           = "bluecard_cs",
         .probe          = bluecard_probe,
         .remove         = bluecard_detach,
         .id_table       = bluecard_ids,
diff --git a/drivers/bluetooth/bt3c_cs.c b/drivers/bluetooth/bt3c_cs.c
index 7ab8f29d5e0d..0c8a65587491 100644
--- a/drivers/bluetooth/bt3c_cs.c
+++ b/drivers/bluetooth/bt3c_cs.c
@@ -45,7 +45,6 @@
 #include <linux/device.h>
 #include <linux/firmware.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -657,11 +656,8 @@ static int bt3c_probe(struct pcmcia_device *link)
         info->p_dev = link;
         link->priv = info;
 
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        link->resource[0]->end = 8;
-
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_SET_IO;
 
         return bt3c_config(link);
 }
@@ -675,43 +671,41 @@ static void bt3c_detach(struct pcmcia_device *link)
         kfree(info);
 }
 
-static int bt3c_check_config(struct pcmcia_device *p_dev,
-                             cistpl_cftable_entry_t *cf,
-                             cistpl_cftable_entry_t *dflt,
-                             unsigned int vcc,
-                             void *priv_data)
+static int bt3c_check_config(struct pcmcia_device *p_dev, void *priv_data)
 {
-        unsigned long try = (unsigned long) priv_data;
+        int *try = priv_data;
 
-        p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
+        if (try == 0)
+                p_dev->io_lines = 16;
 
-        if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
-            (cf->io.win[0].base != 0)) {
-                p_dev->resource[0]->start = cf->io.win[0].base;
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -ENODEV;
+        if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
+                return -EINVAL;
+
+        p_dev->resource[0]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int bt3c_check_config_notpicky(struct pcmcia_device *p_dev,
-                                      cistpl_cftable_entry_t *cf,
-                                      cistpl_cftable_entry_t *dflt,
-                                      unsigned int vcc,
                                       void *priv_data)
 {
         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
         int j;
 
-        if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
-                for (j = 0; j < 5; j++) {
-                        p_dev->resource[0]->start = base[j];
-                        p_dev->io_lines = base[j] ? 16 : 3;
-                        if (!pcmcia_request_io(p_dev))
-                                return 0;
-                }
+        if (p_dev->io_lines > 3)
+                return -ENODEV;
+
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[0]->end = 8;
+
+        for (j = 0; j < 5; j++) {
+                p_dev->resource[0]->start = base[j];
+                p_dev->io_lines = base[j] ? 16 : 3;
+                if (!pcmcia_request_io(p_dev))
+                        return 0;
         }
         return -ENODEV;
 }
@@ -742,7 +736,7 @@ found_port:
         if (i != 0)
                 goto failed;
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 goto failed;
 
@@ -775,9 +769,7 @@ MODULE_DEVICE_TABLE(pcmcia, bt3c_ids);
 
 static struct pcmcia_driver bt3c_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "bt3c_cs",
-        },
+        .name           = "bt3c_cs",
         .probe          = bt3c_probe,
         .remove         = bt3c_detach,
         .id_table       = bt3c_ids,
diff --git a/drivers/bluetooth/btuart_cs.c b/drivers/bluetooth/btuart_cs.c
index 1c4f5e863b03..f8a0708e2311 100644
--- a/drivers/bluetooth/btuart_cs.c
+++ b/drivers/bluetooth/btuart_cs.c
@@ -41,7 +41,6 @@
 #include <asm/system.h>
 #include <asm/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -586,11 +585,8 @@ static int btuart_probe(struct pcmcia_device *link)
         info->p_dev = link;
         link->priv = info;
 
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        link->resource[0]->end = 8;
-
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_SET_IO;
 
         return btuart_config(link);
 }
@@ -604,43 +600,41 @@ static void btuart_detach(struct pcmcia_device *link)
         kfree(info);
 }
 
-static int btuart_check_config(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cf,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int btuart_check_config(struct pcmcia_device *p_dev, void *priv_data)
 {
         int *try = priv_data;
 
-        p_dev->io_lines = (try == 0) ? 16 : cf->io.flags & CISTPL_IO_LINES_MASK;
+        if (try == 0)
+                p_dev->io_lines = 16;
 
-        if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        if ((cf->io.nwin > 0) && (cf->io.win[0].len == 8) &&
-            (cf->io.win[0].base != 0)) {
-                p_dev->resource[0]->start = cf->io.win[0].base;
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -ENODEV;
+        if ((p_dev->resource[0]->end != 8) || (p_dev->resource[0]->start == 0))
+                return -EINVAL;
+
+        p_dev->resource[0]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int btuart_check_config_notpicky(struct pcmcia_device *p_dev,
-                                        cistpl_cftable_entry_t *cf,
-                                        cistpl_cftable_entry_t *dflt,
-                                        unsigned int vcc,
                                         void *priv_data)
 {
         static unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
         int j;
 
-        if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
-                for (j = 0; j < 5; j++) {
-                        p_dev->resource[0]->start = base[j];
-                        p_dev->io_lines = base[j] ? 16 : 3;
-                        if (!pcmcia_request_io(p_dev))
-                                return 0;
-                }
+        if (p_dev->io_lines > 3)
+                return -ENODEV;
+
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[0]->end = 8;
+
+        for (j = 0; j < 5; j++) {
+                p_dev->resource[0]->start = base[j];
+                p_dev->io_lines = base[j] ? 16 : 3;
+                if (!pcmcia_request_io(p_dev))
+                        return 0;
         }
         return -ENODEV;
 }
@@ -671,7 +665,7 @@ found_port:
         if (i != 0)
                 goto failed;
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 goto failed;
 
@@ -703,9 +697,7 @@ MODULE_DEVICE_TABLE(pcmcia, btuart_ids);
 
 static struct pcmcia_driver btuart_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "btuart_cs",
-        },
+        .name           = "btuart_cs",
         .probe          = btuart_probe,
         .remove         = btuart_detach,
         .id_table       = btuart_ids,
diff --git a/drivers/bluetooth/dtl1_cs.c b/drivers/bluetooth/dtl1_cs.c
index db7c8db695fc..26ee0cf88d20 100644
--- a/drivers/bluetooth/dtl1_cs.c
+++ b/drivers/bluetooth/dtl1_cs.c
@@ -41,7 +41,6 @@
 #include <asm/system.h>
 #include <asm/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -572,11 +571,7 @@ static int dtl1_probe(struct pcmcia_device *link)
         info->p_dev = link;
         link->priv = info;
 
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        link->resource[0]->end = 8;
-
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
         return dtl1_config(link);
 }
@@ -591,18 +586,14 @@ static void dtl1_detach(struct pcmcia_device *link)
         kfree(info);
 }
 
-static int dtl1_confcheck(struct pcmcia_device *p_dev,
-                          cistpl_cftable_entry_t *cf,
-                          cistpl_cftable_entry_t *dflt,
-                          unsigned int vcc,
-                          void *priv_data)
+static int dtl1_confcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if ((cf->io.nwin != 1) || (cf->io.win[0].len <= 8))
+        if ((p_dev->resource[1]->end) || (p_dev->resource[1]->end < 8))
                 return -ENODEV;
 
-        p_dev->resource[0]->start = cf->io.win[0].base;
-        p_dev->resource[0]->end = cf->io.win[0].len;    /*yo */
-        p_dev->io_lines = cf->io.flags & CISTPL_IO_LINES_MASK;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+
         return pcmcia_request_io(p_dev);
 }
 
@@ -620,7 +611,7 @@ static int dtl1_config(struct pcmcia_device *link)
         if (i != 0)
                 goto failed;
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 goto failed;
 
@@ -656,9 +647,7 @@ MODULE_DEVICE_TABLE(pcmcia, dtl1_ids);
 
 static struct pcmcia_driver dtl1_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "dtl1_cs",
-        },
+        .name           = "dtl1_cs",
         .probe          = dtl1_probe,
         .remove         = dtl1_detach,
         .id_table       = dtl1_ids,
diff --git a/drivers/char/agp/Kconfig b/drivers/char/agp/Kconfig
index 4b66c69eaf57..5ddf67e76f8b 100644
--- a/drivers/char/agp/Kconfig
+++ b/drivers/char/agp/Kconfig
@@ -57,7 +57,7 @@ config AGP_AMD
 
 config AGP_AMD64
         tristate "AMD Opteron/Athlon64 on-CPU GART support"
-        depends on AGP && X86 && K8_NB
+        depends on AGP && X86 && AMD_NB
         help
           This option gives you AGP support for the GLX component of
           X using the on-CPU northbridge of the AMD Athlon64/Opteron CPUs.
diff --git a/drivers/char/agp/amd64-agp.c b/drivers/char/agp/amd64-agp.c
index 70312da4c968..42396df55556 100644
--- a/drivers/char/agp/amd64-agp.c
+++ b/drivers/char/agp/amd64-agp.c
@@ -15,7 +15,7 @@
 #include <linux/mmzone.h>
 #include <asm/page.h>           /* PAGE_SIZE */
 #include <asm/e820.h>
-#include <asm/k8.h>
+#include <asm/amd_nb.h>
 #include <asm/gart.h>
 #include "agp.h"
 
@@ -124,7 +124,7 @@ static int amd64_fetch_size(void)
         u32 temp;
         struct aper_size_info_32 *values;
 
-        dev = k8_northbridges[0];
+        dev = k8_northbridges.nb_misc[0];
         if (dev==NULL)
                 return 0;
 
@@ -181,10 +181,14 @@ static int amd_8151_configure(void)
         unsigned long gatt_bus = virt_to_phys(agp_bridge->gatt_table_real);
         int i;
 
+        if (!k8_northbridges.gart_supported)
+                return 0;
+
         /* Configure AGP regs in each x86-64 host bridge. */
-        for (i = 0; i < num_k8_northbridges; i++) {
+        for (i = 0; i < k8_northbridges.num; i++) {
                 agp_bridge->gart_bus_addr =
-                                amd64_configure(k8_northbridges[i], gatt_bus);
+                                amd64_configure(k8_northbridges.nb_misc[i],
+                                                gatt_bus);
         }
         k8_flush_garts();
         return 0;
@@ -195,11 +199,15 @@ static void amd64_cleanup(void)
 {
         u32 tmp;
         int i;
-        for (i = 0; i < num_k8_northbridges; i++) {
-                struct pci_dev *dev = k8_northbridges[i];
+
+        if (!k8_northbridges.gart_supported)
+                return;
+
+        for (i = 0; i < k8_northbridges.num; i++) {
+                struct pci_dev *dev = k8_northbridges.nb_misc[i];
                 /* disable gart translation */
                 pci_read_config_dword(dev, AMD64_GARTAPERTURECTL, &tmp);
-                tmp &= ~AMD64_GARTEN;
+                tmp &= ~GARTEN;
                 pci_write_config_dword(dev, AMD64_GARTAPERTURECTL, tmp);
         }
 }
@@ -313,22 +321,25 @@ static __devinit int fix_northbridge(struct pci_dev *nb, struct pci_dev *agp,
         if (order < 0 || !agp_aperture_valid(aper, (32*1024*1024)<<order))
                 return -1;
 
-        pci_write_config_dword(nb, AMD64_GARTAPERTURECTL, order << 1);
+        gart_set_size_and_enable(nb, order);
         pci_write_config_dword(nb, AMD64_GARTAPERTUREBASE, aper >> 25);
 
         return 0;
 }
 
-static __devinit int cache_nbs (struct pci_dev *pdev, u32 cap_ptr)
+static __devinit int cache_nbs(struct pci_dev *pdev, u32 cap_ptr)
 {
         int i;
 
         if (cache_k8_northbridges() < 0)
                 return -ENODEV;
 
+        if (!k8_northbridges.gart_supported)
+                return -ENODEV;
+
         i = 0;
-        for (i = 0; i < num_k8_northbridges; i++) {
-                struct pci_dev *dev = k8_northbridges[i];
+        for (i = 0; i < k8_northbridges.num; i++) {
+                struct pci_dev *dev = k8_northbridges.nb_misc[i];
                 if (fix_northbridge(dev, pdev, cap_ptr) < 0) {
                         dev_err(&dev->dev, "no usable aperture found\n");
 #ifdef __x86_64__
@@ -405,7 +416,8 @@ static int __devinit uli_agp_init(struct pci_dev *pdev)
         }
 
         /* shadow x86-64 registers into ULi registers */
-        pci_read_config_dword (k8_northbridges[0], AMD64_GARTAPERTUREBASE, &httfea);
+        pci_read_config_dword (k8_northbridges.nb_misc[0], AMD64_GARTAPERTUREBASE,
+                               &httfea);
 
         /* if x86-64 aperture base is beyond 4G, exit here */
         if ((httfea & 0x7fff) >> (32 - 25)) {
@@ -472,7 +484,8 @@ static int nforce3_agp_init(struct pci_dev *pdev)
         pci_write_config_dword(dev1, NVIDIA_X86_64_1_APSIZE, tmp);
 
         /* shadow x86-64 registers into NVIDIA registers */
-        pci_read_config_dword (k8_northbridges[0], AMD64_GARTAPERTUREBASE, &apbase);
+        pci_read_config_dword (k8_northbridges.nb_misc[0], AMD64_GARTAPERTUREBASE,
+                               &apbase);
 
         /* if x86-64 aperture base is beyond 4G, exit here */
         if ( (apbase & 0x7fff) >> (32 - 25) ) {
diff --git a/drivers/char/agp/generic.c b/drivers/char/agp/generic.c
index d2abf5143983..64255cef8a7d 100644
--- a/drivers/char/agp/generic.c
+++ b/drivers/char/agp/generic.c
@@ -984,7 +984,9 @@ int agp_generic_create_gatt_table(struct agp_bridge_data *bridge)
 
         bridge->driver->cache_flush();
 #ifdef CONFIG_X86
-        set_memory_uc((unsigned long)table, 1 << page_order);
+        if (set_memory_uc((unsigned long)table, 1 << page_order))
+                printk(KERN_WARNING "Could not set GATT table memory to UC!");
+
         bridge->gatt_table = (void *)table;
 #else
         bridge->gatt_table = ioremap_nocache(virt_to_phys(table),
diff --git a/drivers/char/pcmcia/cm4000_cs.c b/drivers/char/pcmcia/cm4000_cs.c
index ec73d9f6d9ed..c7b482d15e2a 100644
--- a/drivers/char/pcmcia/cm4000_cs.c
+++ b/drivers/char/pcmcia/cm4000_cs.c
@@ -34,7 +34,6 @@
 #include <linux/uaccess.h>
 #include <linux/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -55,8 +54,6 @@
                            __func__ , ## args);         \
         } while (0)
 
-static char *version = "cm4000_cs.c v2.4.0gm6 - All bugs added by Harald Welte";
-
 #define T_1SEC          (HZ)
 #define T_10MSEC        msecs_to_jiffies(10)
 #define T_20MSEC        msecs_to_jiffies(20)
@@ -1742,20 +1739,8 @@ static void cmm_cm4000_release(struct pcmcia_device * link)
 
 /*==== Interface to PCMCIA Layer =======================================*/
 
-static int cm4000_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cfg,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int cm4000_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (!cfg->io.nwin)
-                return -ENODEV;
-
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
-        p_dev->resource[0]->flags |= pcmcia_io_cfg_data_width(cfg->io.flags);
-        p_dev->io_lines = cfg->io.flags & CISTPL_IO_LINES_MASK;
-
         return pcmcia_request_io(p_dev);
 }
 
@@ -1763,13 +1748,13 @@ static int cm4000_config(struct pcmcia_device * link, int devno)
 {
         struct cm4000_dev *dev;
 
+        link->config_flags |= CONF_AUTO_SET_IO;
+
         /* read the config-tuples */
         if (pcmcia_loop_config(link, cm4000_config_check, NULL))
                 goto cs_release;
 
-        link->conf.IntType = 00000002;
-
-        if (pcmcia_request_configuration(link, &link->conf))
+        if (pcmcia_enable_device(link))
                 goto cs_release;
 
         dev = link->priv;
@@ -1829,7 +1814,6 @@ static int cm4000_probe(struct pcmcia_device *link)
 
         dev->p_dev = link;
         link->priv = dev;
-        link->conf.IntType = INT_MEMORY_AND_IO;
         dev_table[i] = link;
 
         init_waitqueue_head(&dev->devq);
@@ -1891,9 +1875,7 @@ MODULE_DEVICE_TABLE(pcmcia, cm4000_ids);
 
 static struct pcmcia_driver cm4000_driver = {
         .owner    = THIS_MODULE,
-        .drv      = {
-                .name = "cm4000_cs",
-                },
+        .name     = "cm4000_cs",
         .probe    = cm4000_probe,
         .remove   = cm4000_detach,
         .suspend  = cm4000_suspend,
@@ -1905,8 +1887,6 @@ static int __init cmm_init(void)
 {
         int rc;
 
-        printk(KERN_INFO "%s\n", version);
-
         cmm_class = class_create(THIS_MODULE, "cardman_4000");
         if (IS_ERR(cmm_class))
                 return PTR_ERR(cmm_class);
@@ -1931,7 +1911,6 @@ static int __init cmm_init(void)
 
 static void __exit cmm_exit(void)
 {
-        printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&cm4000_driver);
         unregister_chrdev(major, DEVICE_NAME);
         class_destroy(cmm_class);
diff --git a/drivers/char/pcmcia/cm4040_cs.c b/drivers/char/pcmcia/cm4040_cs.c
index 815cde1d0570..bf2f046fc2c1 100644
--- a/drivers/char/pcmcia/cm4040_cs.c
+++ b/drivers/char/pcmcia/cm4040_cs.c
@@ -29,7 +29,6 @@
 #include <asm/uaccess.h>
 #include <asm/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -49,9 +48,6 @@
                            __func__ , ## args);         \
         } while (0)
 
-static char *version =
-"OMNIKEY CardMan 4040 v1.1.0gm5 - All bugs added by Harald Welte";
-
 #define CCID_DRIVER_BULK_DEFAULT_TIMEOUT        (150*HZ)
 #define CCID_DRIVER_ASYNC_POWERUP_TIMEOUT       (35*HZ)
 #define CCID_DRIVER_MINIMUM_TIMEOUT             (3*HZ)
@@ -516,26 +512,9 @@ static void cm4040_reader_release(struct pcmcia_device *link)
         return;
 }
 
-static int cm4040_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cfg,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int cm4040_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        int rc;
-        if (!cfg->io.nwin)
-                return -ENODEV;
-
-        /* Get the IOaddr */
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
-        p_dev->resource[0]->flags |= pcmcia_io_cfg_data_width(cfg->io.flags);
-        p_dev->io_lines = cfg->io.flags & CISTPL_IO_LINES_MASK;
-        rc = pcmcia_request_io(p_dev);
-
-        dev_printk(KERN_INFO, &p_dev->dev,
-                   "pcmcia_request_io returned 0x%x\n", rc);
-        return rc;
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -544,15 +523,15 @@ static int reader_config(struct pcmcia_device *link, int devno)
         struct reader_dev *dev;
         int fail_rc;
 
+        link->config_flags |= CONF_AUTO_SET_IO;
+
         if (pcmcia_loop_config(link, cm4040_config_check, NULL))
                 goto cs_release;
 
-        link->conf.IntType = 00000002;
-
-        fail_rc = pcmcia_request_configuration(link, &link->conf);
+        fail_rc = pcmcia_enable_device(link);
         if (fail_rc != 0) {
                 dev_printk(KERN_INFO, &link->dev,
-                           "pcmcia_request_configuration failed 0x%x\n",
+                           "pcmcia_enable_device failed 0x%x\n",
                            fail_rc);
                 goto cs_release;
         }
@@ -599,7 +578,6 @@ static int reader_probe(struct pcmcia_device *link)
         link->priv = dev;
         dev->p_dev = link;
 
-        link->conf.IntType = INT_MEMORY_AND_IO;
         dev_table[i] = link;
 
         init_waitqueue_head(&dev->devq);
@@ -662,9 +640,7 @@ MODULE_DEVICE_TABLE(pcmcia, cm4040_ids);
 
 static struct pcmcia_driver reader_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "cm4040_cs",
-        },
+        .name           = "cm4040_cs",
         .probe          = reader_probe,
         .remove         = reader_detach,
         .id_table       = cm4040_ids,
@@ -674,7 +650,6 @@ static int __init cm4040_init(void)
 {
         int rc;
 
-        printk(KERN_INFO "%s\n", version);
         cmx_class = class_create(THIS_MODULE, "cardman_4040");
         if (IS_ERR(cmx_class))
                 return PTR_ERR(cmx_class);
@@ -699,7 +674,6 @@ static int __init cm4040_init(void)
 
 static void __exit cm4040_exit(void)
 {
-        printk(KERN_INFO MODULE_NAME ": unloading\n");
         pcmcia_unregister_driver(&reader_driver);
         unregister_chrdev(major, DEVICE_NAME);
         class_destroy(cmx_class);
diff --git a/drivers/char/pcmcia/ipwireless/main.c b/drivers/char/pcmcia/ipwireless/main.c
index 67bdb05798b1..94b8eb4d691d 100644
--- a/drivers/char/pcmcia/ipwireless/main.c
+++ b/drivers/char/pcmcia/ipwireless/main.c
@@ -32,7 +32,6 @@
 #include <pcmcia/device_id.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/ds.h>
-#include <pcmcia/cs.h>
 
 static struct pcmcia_device_id ipw_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x02f2, 0x0100),
@@ -76,23 +75,18 @@ static void signalled_reboot_callback(void *callback_data)
         schedule_work(&ipw->work_reboot);
 }
 
-static int ipwireless_probe(struct pcmcia_device *p_dev,
-                            cistpl_cftable_entry_t *cfg,
-                            cistpl_cftable_entry_t *dflt,
-                            unsigned int vcc,
-                            void *priv_data)
+static int ipwireless_probe(struct pcmcia_device *p_dev, void *priv_data)
 {
         struct ipw_dev *ipw = priv_data;
         struct resource *io_resource;
         int ret;
 
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
 
         /* 0x40 causes it to generate level mode interrupts. */
         /* 0x04 enables IREQ pin. */
-        p_dev->conf.ConfigIndex = cfg->index | 0x44;
+        p_dev->config_index |= 0x44;
         p_dev->io_lines = 16;
         ret = pcmcia_request_io(p_dev);
         if (ret)
@@ -102,65 +96,49 @@ static int ipwireless_probe(struct pcmcia_device *p_dev,
                                 resource_size(p_dev->resource[0]),
                                 IPWIRELESS_PCCARD_NAME);
 
-        if (cfg->mem.nwin == 0)
-                return 0;
-
-        ipw->request_common_memory.Attributes =
+        p_dev->resource[2]->flags |=
                 WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_CM | WIN_ENABLE;
-        ipw->request_common_memory.Base = cfg->mem.win[0].host_addr;
-        ipw->request_common_memory.Size = cfg->mem.win[0].len;
-        if (ipw->request_common_memory.Size < 0x1000)
-                ipw->request_common_memory.Size = 0x1000;
-        ipw->request_common_memory.AccessSpeed = 0;
-
-        ret = pcmcia_request_window(p_dev, &ipw->request_common_memory,
-                                &ipw->handle_common_memory);
 
+        ret = pcmcia_request_window(p_dev, p_dev->resource[2], 0);
         if (ret != 0)
                 goto exit1;
 
-        ret = pcmcia_map_mem_page(p_dev, ipw->handle_common_memory,
-                                cfg->mem.win[0].card_addr);
-
+        ret = pcmcia_map_mem_page(p_dev, p_dev->resource[2], p_dev->card_addr);
         if (ret != 0)
                 goto exit2;
 
-        ipw->is_v2_card = cfg->mem.win[0].len == 0x100;
+        ipw->is_v2_card = resource_size(p_dev->resource[2]) == 0x100;
 
-        ipw->common_memory = ioremap(ipw->request_common_memory.Base,
-                                ipw->request_common_memory.Size);
-        request_mem_region(ipw->request_common_memory.Base,
-                        ipw->request_common_memory.Size,
+        ipw->attr_memory = ioremap(p_dev->resource[2]->start,
+                                resource_size(p_dev->resource[2]));
+        request_mem_region(p_dev->resource[2]->start,
+                        resource_size(p_dev->resource[2]),
                         IPWIRELESS_PCCARD_NAME);
 
-        ipw->request_attr_memory.Attributes =
-                WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_AM | WIN_ENABLE;
-        ipw->request_attr_memory.Base = 0;
-        ipw->request_attr_memory.Size = 0;      /* this used to be 0x1000 */
-        ipw->request_attr_memory.AccessSpeed = 0;
-
-        ret = pcmcia_request_window(p_dev, &ipw->request_attr_memory,
-                                &ipw->handle_attr_memory);
-
+        p_dev->resource[3]->flags |= WIN_DATA_WIDTH_16 | WIN_MEMORY_TYPE_AM |
+                                        WIN_ENABLE;
+        p_dev->resource[3]->end = 0; /* this used to be 0x1000 */
+        ret = pcmcia_request_window(p_dev, p_dev->resource[3], 0);
         if (ret != 0)
                 goto exit2;
 
-        ret = pcmcia_map_mem_page(p_dev, ipw->handle_attr_memory, 0);
+        ret = pcmcia_map_mem_page(p_dev, p_dev->resource[3], 0);
         if (ret != 0)
                 goto exit3;
 
-        ipw->attr_memory = ioremap(ipw->request_attr_memory.Base,
-                                ipw->request_attr_memory.Size);
-        request_mem_region(ipw->request_attr_memory.Base,
-                        ipw->request_attr_memory.Size, IPWIRELESS_PCCARD_NAME);
+        ipw->attr_memory = ioremap(p_dev->resource[3]->start,
+                                resource_size(p_dev->resource[3]));
+        request_mem_region(p_dev->resource[3]->start,
+                        resource_size(p_dev->resource[3]),
+                        IPWIRELESS_PCCARD_NAME);
 
         return 0;
 
 exit3:
 exit2:
         if (ipw->common_memory) {
-                release_mem_region(ipw->request_common_memory.Base,
-                                ipw->request_common_memory.Size);
+                release_mem_region(p_dev->resource[2]->start,
+                                resource_size(p_dev->resource[2]));
                 iounmap(ipw->common_memory);
         }
 exit1:
@@ -175,14 +153,13 @@ static int config_ipwireless(struct ipw_dev *ipw)
         int ret = 0;
 
         ipw->is_v2_card = 0;
+        link->config_flags |= CONF_AUTO_SET_IO | CONF_AUTO_SET_IOMEM |
+                CONF_ENABLE_IRQ;
 
         ret = pcmcia_loop_config(link, ipwireless_probe, ipw);
         if (ret != 0)
                 return ret;
 
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         INIT_WORK(&ipw->work_reboot, signalled_reboot_work);
 
         ipwireless_init_hardware_v1(ipw->hardware, link->resource[0]->start,
@@ -201,13 +178,9 @@ static int config_ipwireless(struct ipw_dev *ipw)
                         (unsigned int) link->irq);
         if (ipw->attr_memory && ipw->common_memory)
                 printk(KERN_INFO IPWIRELESS_PCCARD_NAME
-                        ": attr memory 0x%08lx-0x%08lx, common memory 0x%08lx-0x%08lx\n",
-                        ipw->request_attr_memory.Base,
-                        ipw->request_attr_memory.Base
-                        + ipw->request_attr_memory.Size - 1,
-                        ipw->request_common_memory.Base,
-                        ipw->request_common_memory.Base
-                        + ipw->request_common_memory.Size - 1);
+                        ": attr memory %pR, common memory %pR\n",
+                        link->resource[3],
+                        link->resource[2]);
 
         ipw->network = ipwireless_network_create(ipw->hardware);
         if (!ipw->network)
@@ -223,25 +196,23 @@ static int config_ipwireless(struct ipw_dev *ipw)
          * Do the RequestConfiguration last, because it enables interrupts.
          * Then we don't get any interrupts before we're ready for them.
          */
-        ret = pcmcia_request_configuration(link, &link->conf);
-
+        ret = pcmcia_enable_device(link);
         if (ret != 0)
                 goto exit;
 
         return 0;
 
 exit:
-        if (ipw->attr_memory) {
-                release_mem_region(ipw->request_attr_memory.Base,
-                                ipw->request_attr_memory.Size);
-                iounmap(ipw->attr_memory);
-
-        }
         if (ipw->common_memory) {
-                release_mem_region(ipw->request_common_memory.Base,
-                                ipw->request_common_memory.Size);
+                release_mem_region(link->resource[2]->start,
+                                resource_size(link->resource[2]));
                 iounmap(ipw->common_memory);
         }
+        if (ipw->attr_memory) {
+                release_mem_region(link->resource[3]->start,
+                                resource_size(link->resource[3]));
+                iounmap(ipw->attr_memory);
+        }
         pcmcia_disable_device(link);
         return -1;
 }
@@ -249,13 +220,13 @@ exit:
 static void release_ipwireless(struct ipw_dev *ipw)
 {
         if (ipw->common_memory) {
-                release_mem_region(ipw->request_common_memory.Base,
-                                ipw->request_common_memory.Size);
+                release_mem_region(ipw->link->resource[2]->start,
+                                resource_size(ipw->link->resource[2]));
                 iounmap(ipw->common_memory);
         }
         if (ipw->attr_memory) {
-                release_mem_region(ipw->request_attr_memory.Base,
-                                ipw->request_attr_memory.Size);
+                release_mem_region(ipw->link->resource[3]->start,
+                                resource_size(ipw->link->resource[3]));
                 iounmap(ipw->attr_memory);
         }
         pcmcia_disable_device(ipw->link);
@@ -324,7 +295,7 @@ static struct pcmcia_driver me = {
         .owner          = THIS_MODULE,
         .probe          = ipwireless_attach,
         .remove         = ipwireless_detach,
-        .drv = { .name  = IPWIRELESS_PCCARD_NAME },
+        .name           = IPWIRELESS_PCCARD_NAME,
         .id_table       = ipw_ids
 };
 
@@ -336,9 +307,6 @@ static int __init init_ipwireless(void)
 {
         int ret;
 
-        printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
-               IPWIRELESS_PCMCIA_VERSION " by " IPWIRELESS_PCMCIA_AUTHOR "\n");
-
         ret = ipwireless_tty_init();
         if (ret != 0)
                 return ret;
@@ -355,9 +323,6 @@ static int __init init_ipwireless(void)
  */
 static void __exit exit_ipwireless(void)
 {
-        printk(KERN_INFO IPWIRELESS_PCCARD_NAME " "
-                        IPWIRELESS_PCMCIA_VERSION " removed\n");
-
         pcmcia_unregister_driver(&me);
         ipwireless_tty_release();
 }
diff --git a/drivers/char/pcmcia/ipwireless/main.h b/drivers/char/pcmcia/ipwireless/main.h
index c207be87b597..f2cbb116bccb 100644
--- a/drivers/char/pcmcia/ipwireless/main.h
+++ b/drivers/char/pcmcia/ipwireless/main.h
@@ -21,7 +21,6 @@
 #include <linux/sched.h>
 #include <linux/types.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -45,13 +44,9 @@ struct ipw_dev {
         struct pcmcia_device *link;
         int is_v2_card;
 
-        window_handle_t handle_attr_memory;
         void __iomem *attr_memory;
-        win_req_t request_attr_memory;
 
-        window_handle_t handle_common_memory;
         void __iomem *common_memory;
-        win_req_t request_common_memory;
 
         /* Reference to attribute memory, containing CIS data */
         void *attribute_memory;
diff --git a/drivers/char/pcmcia/ipwireless/tty.h b/drivers/char/pcmcia/ipwireless/tty.h
index 3e163d4cab15..747b2d637860 100644
--- a/drivers/char/pcmcia/ipwireless/tty.h
+++ b/drivers/char/pcmcia/ipwireless/tty.h
@@ -21,7 +21,6 @@
 #include <linux/types.h>
 #include <linux/sched.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
diff --git a/drivers/char/pcmcia/synclink_cs.c b/drivers/char/pcmcia/synclink_cs.c
index 9ecd6bef5d3b..be1810057607 100644
--- a/drivers/char/pcmcia/synclink_cs.c
+++ b/drivers/char/pcmcia/synclink_cs.c
@@ -70,7 +70,6 @@
 #include <linux/workqueue.h>
 #include <linux/hdlc.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -550,9 +549,6 @@ static int mgslpc_probe(struct pcmcia_device *link)
 
     /* Initialize the struct pcmcia_device structure */
 
-    link->conf.Attributes = 0;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-
     ret = mgslpc_config(link);
     if (ret)
             return ret;
@@ -565,20 +561,8 @@ static int mgslpc_probe(struct pcmcia_device *link)
 /* Card has been inserted.
  */
 
-static int mgslpc_ioprobe(struct pcmcia_device *p_dev,
-                          cistpl_cftable_entry_t *cfg,
-                          cistpl_cftable_entry_t *dflt,
-                          unsigned int vcc,
-                          void *priv_data)
+static int mgslpc_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (!cfg->io.nwin)
-                return -ENODEV;
-
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
-        p_dev->resource[0]->flags |= pcmcia_io_cfg_data_width(cfg->io.flags);
-        p_dev->io_lines = cfg->io.flags & CISTPL_IO_LINES_MASK;
-
         return pcmcia_request_io(p_dev);
 }
 
@@ -590,32 +574,24 @@ static int mgslpc_config(struct pcmcia_device *link)
     if (debug_level >= DEBUG_LEVEL_INFO)
             printk("mgslpc_config(0x%p)\n", link);
 
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
     ret = pcmcia_loop_config(link, mgslpc_ioprobe, NULL);
     if (ret != 0)
             goto failed;
 
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.ConfigIndex = 8;
-    link->conf.Present = PRESENT_OPTION;
+    link->config_index = 8;
+    link->config_regs = PRESENT_OPTION;
 
     ret = pcmcia_request_irq(link, mgslpc_isr);
     if (ret)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
     info->io_base = link->resource[0]->start;
     info->irq_level = link->irq;
-
-    dev_info(&link->dev, "index 0x%02x:",
-            link->conf.ConfigIndex);
-    if (link->conf.Attributes & CONF_ENABLE_IRQ)
-            printk(", irq %d", link->irq);
-    if (link->resource[0])
-            printk(", io %pR", link->resource[0]);
-    printk("\n");
     return 0;
 
 failed:
@@ -2797,9 +2773,7 @@ MODULE_DEVICE_TABLE(pcmcia, mgslpc_ids);
 
 static struct pcmcia_driver mgslpc_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "synclink_cs",
-        },
+        .name           = "synclink_cs",
         .probe          = mgslpc_probe,
         .remove         = mgslpc_detach,
         .id_table       = mgslpc_ids,
@@ -2835,8 +2809,6 @@ static void synclink_cs_cleanup(void)
 {
         int rc;
 
-        printk("Unloading %s: version %s\n", driver_name, driver_version);
-
         while(mgslpc_device_list)
                 mgslpc_remove_device(mgslpc_device_list);
 
@@ -2859,8 +2831,6 @@ static int __init synclink_cs_init(void)
             BREAKPOINT();
     }
 
-    printk("%s %s\n", driver_name, driver_version);
-
     if ((rc = pcmcia_register_driver(&mgslpc_driver)) < 0)
             return rc;
 
@@ -4127,6 +4097,8 @@ static int hdlcdev_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
         if (cmd != SIOCWANDEV)
                 return hdlc_ioctl(dev, ifr, cmd);
 
+        memset(&new_line, 0, size);
+
         switch(ifr->ifr_settings.type) {
         case IF_GET_IFACE: /* return current sync_serial_settings */
 
diff --git a/drivers/char/tpm/tpm.c b/drivers/char/tpm/tpm.c
index 05ad4a17a28f..7c4133582dba 100644
--- a/drivers/char/tpm/tpm.c
+++ b/drivers/char/tpm/tpm.c
@@ -47,6 +47,16 @@ enum tpm_duration {
 #define TPM_MAX_PROTECTED_ORDINAL 12
 #define TPM_PROTECTED_ORDINAL_MASK 0xFF
 
+/*
+ * Bug workaround - some TPM's don't flush the most
+ * recently changed pcr on suspend, so force the flush
+ * with an extend to the selected _unused_ non-volatile pcr.
+ */
+static int tpm_suspend_pcr;
+module_param_named(suspend_pcr, tpm_suspend_pcr, uint, 0644);
+MODULE_PARM_DESC(suspend_pcr,
+                 "PCR to use for dummy writes to faciltate flush on suspend.");
+
 static LIST_HEAD(tpm_chip_list);
 static DEFINE_SPINLOCK(driver_lock);
 static DECLARE_BITMAP(dev_mask, TPM_NUM_DEVICES);
@@ -1077,18 +1087,6 @@ static struct tpm_input_header savestate_header = {
         .ordinal = TPM_ORD_SAVESTATE
 };
 
-/* Bug workaround - some TPM's don't flush the most
- * recently changed pcr on suspend, so force the flush
- * with an extend to the selected _unused_ non-volatile pcr.
- */
-static int tpm_suspend_pcr;
-static int __init tpm_suspend_setup(char *str)
-{
-        get_option(&str, &tpm_suspend_pcr);
-        return 1;
-}
-__setup("tpm_suspend_pcr=", tpm_suspend_setup);
-
 /*
  * We are about to suspend. Save the TPM state
  * so that it can be restored.
diff --git a/drivers/char/virtio_console.c b/drivers/char/virtio_console.c
index c810481a5bc2..6c1b676643a9 100644
--- a/drivers/char/virtio_console.c
+++ b/drivers/char/virtio_console.c
@@ -48,6 +48,9 @@ struct ports_driver_data {
         /* Used for exporting per-port information to debugfs */
         struct dentry *debugfs_dir;
 
+        /* List of all the devices we're handling */
+        struct list_head portdevs;
+
         /* Number of devices this driver is handling */
         unsigned int index;
 
@@ -108,6 +111,9 @@ struct port_buffer {
  * ports for that device (vdev->priv).
  */
 struct ports_device {
+        /* Next portdev in the list, head is in the pdrvdata struct */
+        struct list_head list;
+
         /*
          * Workqueue handlers where we process deferred work after
          * notification
@@ -178,15 +184,21 @@ struct port {
         struct console cons;
 
         /* Each port associates with a separate char device */
-        struct cdev cdev;
+        struct cdev *cdev;
         struct device *dev;
 
+        /* Reference-counting to handle port hot-unplugs and file operations */
+        struct kref kref;
+
         /* A waitqueue for poll() or blocking read operations */
         wait_queue_head_t waitqueue;
 
         /* The 'name' of the port that we expose via sysfs properties */
         char *name;
 
+        /* We can notify apps of host connect / disconnect events via SIGIO */
+        struct fasync_struct *async_queue;
+
         /* The 'id' to identify the port with the Host */
         u32 id;
 
@@ -221,6 +233,41 @@ out:
         return port;
 }
 
+static struct port *find_port_by_devt_in_portdev(struct ports_device *portdev,
+                                                 dev_t dev)
+{
+        struct port *port;
+        unsigned long flags;
+
+        spin_lock_irqsave(&portdev->ports_lock, flags);
+        list_for_each_entry(port, &portdev->ports, list)
+                if (port->cdev->dev == dev)
+                        goto out;
+        port = NULL;
+out:
+        spin_unlock_irqrestore(&portdev->ports_lock, flags);
+
+        return port;
+}
+
+static struct port *find_port_by_devt(dev_t dev)
+{
+        struct ports_device *portdev;
+        struct port *port;
+        unsigned long flags;
+
+        spin_lock_irqsave(&pdrvdata_lock, flags);
+        list_for_each_entry(portdev, &pdrvdata.portdevs, list) {
+                port = find_port_by_devt_in_portdev(portdev, dev);
+                if (port)
+                        goto out;
+        }
+        port = NULL;
+out:
+        spin_unlock_irqrestore(&pdrvdata_lock, flags);
+        return port;
+}
+
 static struct port *find_port_by_id(struct ports_device *portdev, u32 id)
 {
         struct port *port;
@@ -410,7 +457,10 @@ static ssize_t __send_control_msg(struct ports_device *portdev, u32 port_id,
 static ssize_t send_control_msg(struct port *port, unsigned int event,
                                 unsigned int value)
 {
-        return __send_control_msg(port->portdev, port->id, event, value);
+        /* Did the port get unplugged before userspace closed it? */
+        if (port->portdev)
+                return __send_control_msg(port->portdev, port->id, event, value);
+        return 0;
 }
 
 /* Callers must take the port->outvq_lock */
@@ -459,9 +509,12 @@ static ssize_t send_buf(struct port *port, void *in_buf, size_t in_count,
 
         /*
          * Wait till the host acknowledges it pushed out the data we
-         * sent.  This is done for ports in blocking mode or for data
-         * from the hvc_console; the tty operations are performed with
-         * spinlocks held so we can't sleep here.
+         * sent.  This is done for data from the hvc_console; the tty
+         * operations are performed with spinlocks held so we can't
+         * sleep here.  An alternative would be to copy the data to a
+         * buffer and relax the spinning requirement.  The downside is
+         * we need to kmalloc a GFP_ATOMIC buffer each time the
+         * console driver writes something out.
          */
         while (!virtqueue_get_buf(out_vq, &len))
                 cpu_relax();
@@ -522,6 +575,10 @@ static ssize_t fill_readbuf(struct port *port, char *out_buf, size_t out_count,
 /* The condition that must be true for polling to end */
 static bool will_read_block(struct port *port)
 {
+        if (!port->guest_connected) {
+                /* Port got hot-unplugged. Let's exit. */
+                return false;
+        }
         return !port_has_data(port) && port->host_connected;
 }
 
@@ -572,6 +629,9 @@ static ssize_t port_fops_read(struct file *filp, char __user *ubuf,
                 if (ret < 0)
                         return ret;
         }
+        /* Port got hot-unplugged. */
+        if (!port->guest_connected)
+                return -ENODEV;
         /*
          * We could've received a disconnection message while we were
          * waiting for more data.
@@ -613,6 +673,9 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
                 if (ret < 0)
                         return ret;
         }
+        /* Port got hot-unplugged. */
+        if (!port->guest_connected)
+                return -ENODEV;
 
         count = min((size_t)(32 * 1024), count);
 
@@ -626,6 +689,14 @@ static ssize_t port_fops_write(struct file *filp, const char __user *ubuf,
                 goto free_buf;
         }
 
+        /*
+         * We now ask send_buf() to not spin for generic ports -- we
+         * can re-use the same code path that non-blocking file
+         * descriptors take for blocking file descriptors since the
+         * wait is already done and we're certain the write will go
+         * through to the host.
+         */
+        nonblock = true;
         ret = send_buf(port, buf, count, nonblock);
 
         if (nonblock && ret > 0)
@@ -645,6 +716,10 @@ static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
         port = filp->private_data;
         poll_wait(filp, &port->waitqueue, wait);
 
+        if (!port->guest_connected) {
+                /* Port got unplugged */
+                return POLLHUP;
+        }
         ret = 0;
         if (!will_read_block(port))
                 ret |= POLLIN | POLLRDNORM;
@@ -656,6 +731,8 @@ static unsigned int port_fops_poll(struct file *filp, poll_table *wait)
         return ret;
 }
 
+static void remove_port(struct kref *kref);
+
 static int port_fops_release(struct inode *inode, struct file *filp)
 {
         struct port *port;
@@ -676,6 +753,16 @@ static int port_fops_release(struct inode *inode, struct file *filp)
         reclaim_consumed_buffers(port);
         spin_unlock_irq(&port->outvq_lock);
 
+        /*
+         * Locks aren't necessary here as a port can't be opened after
+         * unplug, and if a port isn't unplugged, a kref would already
+         * exist for the port.  Plus, taking ports_lock here would
+         * create a dependency on other locks taken by functions
+         * inside remove_port if we're the last holder of the port,
+         * creating many problems.
+         */
+        kref_put(&port->kref, remove_port);
+
         return 0;
 }
 
@@ -683,22 +770,31 @@ static int port_fops_open(struct inode *inode, struct file *filp)
 {
         struct cdev *cdev = inode->i_cdev;
         struct port *port;
+        int ret;
 
-        port = container_of(cdev, struct port, cdev);
+        port = find_port_by_devt(cdev->dev);
         filp->private_data = port;
 
+        /* Prevent against a port getting hot-unplugged at the same time */
+        spin_lock_irq(&port->portdev->ports_lock);
+        kref_get(&port->kref);
+        spin_unlock_irq(&port->portdev->ports_lock);
+
         /*
          * Don't allow opening of console port devices -- that's done
          * via /dev/hvc
          */
-        if (is_console_port(port))
-                return -ENXIO;
+        if (is_console_port(port)) {
+                ret = -ENXIO;
+                goto out;
+        }
 
         /* Allow only one process to open a particular port at a time */
         spin_lock_irq(&port->inbuf_lock);
         if (port->guest_connected) {
                 spin_unlock_irq(&port->inbuf_lock);
-                return -EMFILE;
+                ret = -EMFILE;
+                goto out;
         }
 
         port->guest_connected = true;
@@ -713,10 +809,23 @@ static int port_fops_open(struct inode *inode, struct file *filp)
         reclaim_consumed_buffers(port);
         spin_unlock_irq(&port->outvq_lock);
 
+        nonseekable_open(inode, filp);
+
         /* Notify host of port being opened */
         send_control_msg(filp->private_data, VIRTIO_CONSOLE_PORT_OPEN, 1);
 
         return 0;
+out:
+        kref_put(&port->kref, remove_port);
+        return ret;
+}
+
+static int port_fops_fasync(int fd, struct file *filp, int mode)
+{
+        struct port *port;
+
+        port = filp->private_data;
+        return fasync_helper(fd, filp, mode, &port->async_queue);
 }
 
 /*
@@ -732,6 +841,8 @@ static const struct file_operations port_fops = {
         .write = port_fops_write,
         .poll  = port_fops_poll,
         .release = port_fops_release,
+        .fasync = port_fops_fasync,
+        .llseek = no_llseek,
 };
 
 /*
@@ -990,6 +1101,12 @@ static unsigned int fill_queue(struct virtqueue *vq, spinlock_t *lock)
         return nr_added_bufs;
 }
 
+static void send_sigio_to_port(struct port *port)
+{
+        if (port->async_queue && port->guest_connected)
+                kill_fasync(&port->async_queue, SIGIO, POLL_OUT);
+}
+
 static int add_port(struct ports_device *portdev, u32 id)
 {
         char debugfs_name[16];
@@ -1004,6 +1121,7 @@ static int add_port(struct ports_device *portdev, u32 id)
                 err = -ENOMEM;
                 goto fail;
         }
+        kref_init(&port->kref);
 
         port->portdev = portdev;
         port->id = id;
@@ -1011,6 +1129,7 @@ static int add_port(struct ports_device *portdev, u32 id)
         port->name = NULL;
         port->inbuf = NULL;
         port->cons.hvc = NULL;
+        port->async_queue = NULL;
 
         port->cons.ws.ws_row = port->cons.ws.ws_col = 0;
 
@@ -1021,14 +1140,20 @@ static int add_port(struct ports_device *portdev, u32 id)
         port->in_vq = portdev->in_vqs[port->id];
         port->out_vq = portdev->out_vqs[port->id];
 
-        cdev_init(&port->cdev, &port_fops);
+        port->cdev = cdev_alloc();
+        if (!port->cdev) {
+                dev_err(&port->portdev->vdev->dev, "Error allocating cdev\n");
+                err = -ENOMEM;
+                goto free_port;
+        }
+        port->cdev->ops = &port_fops;
 
         devt = MKDEV(portdev->chr_major, id);
-        err = cdev_add(&port->cdev, devt, 1);
+        err = cdev_add(port->cdev, devt, 1);
         if (err < 0) {
                 dev_err(&port->portdev->vdev->dev,
                         "Error %d adding cdev for port %u\n", err, id);
-                goto free_port;
+                goto free_cdev;
         }
         port->dev = device_create(pdrvdata.class, &port->portdev->vdev->dev,
                                   devt, port, "vport%up%u",
@@ -1093,7 +1218,7 @@ free_inbufs:
 free_device:
         device_destroy(pdrvdata.class, port->dev->devt);
 free_cdev:
-        cdev_del(&port->cdev);
+        cdev_del(port->cdev);
 free_port:
         kfree(port);
 fail:
@@ -1102,21 +1227,45 @@ fail:
         return err;
 }
 
-/* Remove all port-specific data. */
-static int remove_port(struct port *port)
+/* No users remain, remove all port-specific data. */
+static void remove_port(struct kref *kref)
+{
+        struct port *port;
+
+        port = container_of(kref, struct port, kref);
+
+        sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
+        device_destroy(pdrvdata.class, port->dev->devt);
+        cdev_del(port->cdev);
+
+        kfree(port->name);
+
+        debugfs_remove(port->debugfs_file);
+
+        kfree(port);
+}
+
+/*
+ * Port got unplugged.  Remove port from portdev's list and drop the
+ * kref reference.  If no userspace has this port opened, it will
+ * result in immediate removal the port.
+ */
+static void unplug_port(struct port *port)
 {
         struct port_buffer *buf;
 
+        spin_lock_irq(&port->portdev->ports_lock);
+        list_del(&port->list);
+        spin_unlock_irq(&port->portdev->ports_lock);
+
         if (port->guest_connected) {
                 port->guest_connected = false;
                 port->host_connected = false;
                 wake_up_interruptible(&port->waitqueue);
-                send_control_msg(port, VIRTIO_CONSOLE_PORT_OPEN, 0);
-        }
 
-        spin_lock_irq(&port->portdev->ports_lock);
-        list_del(&port->list);
-        spin_unlock_irq(&port->portdev->ports_lock);
+                /* Let the app know the port is going down. */
+                send_sigio_to_port(port);
+        }
 
         if (is_console_port(port)) {
                 spin_lock_irq(&pdrvdata_lock);
@@ -1135,9 +1284,6 @@ static int remove_port(struct port *port)
                 hvc_remove(port->cons.hvc);
 #endif
         }
-        sysfs_remove_group(&port->dev->kobj, &port_attribute_group);
-        device_destroy(pdrvdata.class, port->dev->devt);
-        cdev_del(&port->cdev);
 
         /* Remove unused data this port might have received. */
         discard_port_data(port);
@@ -1148,12 +1294,19 @@ static int remove_port(struct port *port)
         while ((buf = virtqueue_detach_unused_buf(port->in_vq)))
                 free_buf(buf);
 
-        kfree(port->name);
-
-        debugfs_remove(port->debugfs_file);
+        /*
+         * We should just assume the device itself has gone off --
+         * else a close on an open port later will try to send out a
+         * control message.
+         */
+        port->portdev = NULL;
 
-        kfree(port);
-        return 0;
+        /*
+         * Locks around here are not necessary - a port can't be
+         * opened after we removed the port struct from ports_list
+         * above.
+         */
+        kref_put(&port->kref, remove_port);
 }
 
 /* Any private messages that the Host and Guest want to share */
@@ -1192,7 +1345,7 @@ static void handle_control_message(struct ports_device *portdev,
                 add_port(portdev, cpkt->id);
                 break;
         case VIRTIO_CONSOLE_PORT_REMOVE:
-                remove_port(port);
+                unplug_port(port);
                 break;
         case VIRTIO_CONSOLE_CONSOLE_PORT:
                 if (!cpkt->value)
@@ -1234,6 +1387,12 @@ static void handle_control_message(struct ports_device *portdev,
                 spin_lock_irq(&port->outvq_lock);
                 reclaim_consumed_buffers(port);
                 spin_unlock_irq(&port->outvq_lock);
+
+                /*
+                 * If the guest is connected, it'll be interested in
+                 * knowing the host connection state changed.
+                 */
+                send_sigio_to_port(port);
                 break;
         case VIRTIO_CONSOLE_PORT_NAME:
                 /*
@@ -1330,6 +1489,9 @@ static void in_intr(struct virtqueue *vq)
 
         wake_up_interruptible(&port->waitqueue);
 
+        /* Send a SIGIO indicating new data in case the process asked for it */
+        send_sigio_to_port(port);
+
         if (is_console_port(port) && hvc_poll(port->cons.hvc))
                 hvc_kick();
 }
@@ -1566,6 +1728,10 @@ static int __devinit virtcons_probe(struct virtio_device *vdev)
                 add_port(portdev, 0);
         }
 
+        spin_lock_irq(&pdrvdata_lock);
+        list_add_tail(&portdev->list, &pdrvdata.portdevs);
+        spin_unlock_irq(&pdrvdata_lock);
+
         __send_control_msg(portdev, VIRTIO_CONSOLE_BAD_ID,
                            VIRTIO_CONSOLE_DEVICE_READY, 1);
         return 0;
@@ -1589,23 +1755,41 @@ static void virtcons_remove(struct virtio_device *vdev)
 {
         struct ports_device *portdev;
         struct port *port, *port2;
-        struct port_buffer *buf;
-        unsigned int len;
 
         portdev = vdev->priv;
 
+        spin_lock_irq(&pdrvdata_lock);
+        list_del(&portdev->list);
+        spin_unlock_irq(&pdrvdata_lock);
+
+        /* Disable interrupts for vqs */
+        vdev->config->reset(vdev);
+        /* Finish up work that's lined up */
         cancel_work_sync(&portdev->control_work);
 
         list_for_each_entry_safe(port, port2, &portdev->ports, list)
-                remove_port(port);
+                unplug_port(port);
 
         unregister_chrdev(portdev->chr_major, "virtio-portsdev");
 
-        while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
-                free_buf(buf);
+        /*
+         * When yanking out a device, we immediately lose the
+         * (device-side) queues.  So there's no point in keeping the
+         * guest side around till we drop our final reference.  This
+         * also means that any ports which are in an open state will
+         * have to just stop using the port, as the vqs are going
+         * away.
+         */
+        if (use_multiport(portdev)) {
+                struct port_buffer *buf;
+                unsigned int len;
 
-        while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
-                free_buf(buf);
+                while ((buf = virtqueue_get_buf(portdev->c_ivq, &len)))
+                        free_buf(buf);
+
+                while ((buf = virtqueue_detach_unused_buf(portdev->c_ivq)))
+                        free_buf(buf);
+        }
 
         vdev->config->del_vqs(vdev);
         kfree(portdev->in_vqs);
@@ -1652,6 +1836,7 @@ static int __init init(void)
                            PTR_ERR(pdrvdata.debugfs_dir));
         }
         INIT_LIST_HEAD(&pdrvdata.consoles);
+        INIT_LIST_HEAD(&pdrvdata.portdevs);
 
         return register_virtio_driver(&virtio_console);
 }
diff --git a/drivers/dma/ioat/dma_v2.c b/drivers/dma/ioat/dma_v2.c
index 216f9d383b5b..effd140fc042 100644
--- a/drivers/dma/ioat/dma_v2.c
+++ b/drivers/dma/ioat/dma_v2.c
@@ -879,7 +879,7 @@ int __devinit ioat2_dma_probe(struct ioatdma_device *device, int dca)
         dma->device_issue_pending = ioat2_issue_pending;
         dma->device_alloc_chan_resources = ioat2_alloc_chan_resources;
         dma->device_free_chan_resources = ioat2_free_chan_resources;
-        dma->device_tx_status = ioat_tx_status;
+        dma->device_tx_status = ioat_dma_tx_status;
 
         err = ioat_probe(device);
         if (err)
diff --git a/drivers/edac/Kconfig b/drivers/edac/Kconfig
index 70bb350de996..9dbb28b9559f 100644
--- a/drivers/edac/Kconfig
+++ b/drivers/edac/Kconfig
@@ -39,7 +39,7 @@ config EDAC_DEBUG
           there're four debug levels (x=0,1,2,3 from low to high).
           Usually you should select 'N'.
 
- config EDAC_DECODE_MCE
+config EDAC_DECODE_MCE
         tristate "Decode MCEs in human-readable form (only on AMD for now)"
         depends on CPU_SUP_AMD && X86_MCE
         default y
@@ -51,6 +51,16 @@ config EDAC_DEBUG
           which occur really early upon boot, before the module infrastructure
           has been initialized.
 
+config EDAC_MCE_INJ
+        tristate "Simple MCE injection interface over /sysfs"
+        depends on EDAC_DECODE_MCE
+        default n
+        help
+          This is a simple interface to inject MCEs over /sysfs and test
+          the MCE decoding code in EDAC.
+
+          This is currently AMD-only.
+
 config EDAC_MM_EDAC
         tristate "Main Memory EDAC (Error Detection And Correction) reporting"
         help
@@ -66,13 +76,13 @@ config EDAC_MCE
 
 config EDAC_AMD64
         tristate "AMD64 (Opteron, Athlon64) K8, F10h, F11h"
-        depends on EDAC_MM_EDAC && K8_NB && X86_64 && PCI && EDAC_DECODE_MCE
+        depends on EDAC_MM_EDAC && AMD_NB && X86_64 && PCI && EDAC_DECODE_MCE
         help
           Support for error detection and correction on the AMD 64
           Families of Memory Controllers (K8, F10h and F11h)
 
 config EDAC_AMD64_ERROR_INJECTION
-        bool "Sysfs Error Injection facilities"
+        bool "Sysfs HW Error injection facilities"
         depends on EDAC_AMD64
         help
           Recent Opterons (Family 10h and later) provide for Memory Error
diff --git a/drivers/edac/Makefile b/drivers/edac/Makefile
index ca6b1bb24ccc..32c7bc93c525 100644
--- a/drivers/edac/Makefile
+++ b/drivers/edac/Makefile
@@ -17,6 +17,9 @@ ifdef CONFIG_PCI
 edac_core-objs  += edac_pci.o edac_pci_sysfs.o
 endif
 
+obj-$(CONFIG_EDAC_MCE_INJ)              += mce_amd_inj.o
+
+edac_mce_amd-objs                       := mce_amd.o
 obj-$(CONFIG_EDAC_DECODE_MCE)           += edac_mce_amd.o
 
 obj-$(CONFIG_EDAC_AMD76X)               += amd76x_edac.o
diff --git a/drivers/edac/amd64_edac.c b/drivers/edac/amd64_edac.c
index e7d5d6b5dcf6..8521401bbd75 100644
--- a/drivers/edac/amd64_edac.c
+++ b/drivers/edac/amd64_edac.c
@@ -1,5 +1,5 @@
 #include "amd64_edac.h"
-#include <asm/k8.h>
+#include <asm/amd_nb.h>
 
 static struct edac_pci_ctl_info *amd64_ctl_pci;
 
@@ -2073,11 +2073,18 @@ static inline void __amd64_decode_bus_error(struct mem_ctl_info *mci,
                 amd64_handle_ue(mci, info);
 }
 
-void amd64_decode_bus_error(int node_id, struct err_regs *regs)
+void amd64_decode_bus_error(int node_id, struct mce *m, u32 nbcfg)
 {
         struct mem_ctl_info *mci = mci_lookup[node_id];
+        struct err_regs regs;
 
-        __amd64_decode_bus_error(mci, regs);
+        regs.nbsl  = (u32) m->status;
+        regs.nbsh  = (u32)(m->status >> 32);
+        regs.nbeal = (u32) m->addr;
+        regs.nbeah = (u32)(m->addr >> 32);
+        regs.nbcfg = nbcfg;
+
+        __amd64_decode_bus_error(mci, &regs);
 
         /*
          * Check the UE bit of the NB status high register, if set generate some
@@ -2086,7 +2093,7 @@ void amd64_decode_bus_error(int node_id, struct err_regs *regs)
          *
          * FIXME: this should go somewhere else, if at all.
          */
-        if (regs->nbsh & K8_NBSH_UC_ERR && !report_gart_errors)
+        if (regs.nbsh & K8_NBSH_UC_ERR && !report_gart_errors)
                 edac_mc_handle_ue_no_info(mci, "UE bit is set");
 
 }
@@ -2927,7 +2934,7 @@ static int __init amd64_edac_init(void)
          * to finish initialization of the MC instances.
          */
         err = -ENODEV;
-        for (nb = 0; nb < num_k8_northbridges; nb++) {
+        for (nb = 0; nb < k8_northbridges.num; nb++) {
                 if (!pvt_lookup[nb])
                         continue;
 
diff --git a/drivers/edac/amd64_edac.h b/drivers/edac/amd64_edac.h
index 613b9381e71a..044aee4f944d 100644
--- a/drivers/edac/amd64_edac.h
+++ b/drivers/edac/amd64_edac.h
@@ -72,7 +72,7 @@
 #include <linux/edac.h>
 #include <asm/msr.h>
 #include "edac_core.h"
-#include "edac_mce_amd.h"
+#include "mce_amd.h"
 
 #define amd64_printk(level, fmt, arg...) \
         edac_printk(level, "amd64", fmt, ##arg)
@@ -482,11 +482,10 @@ extern const char *rrrr_msgs[16];
 extern const char *to_msgs[2];
 extern const char *pp_msgs[4];
 extern const char *ii_msgs[4];
-extern const char *ext_msgs[32];
 extern const char *htlink_msgs[8];
 
 #ifdef CONFIG_EDAC_DEBUG
-#define NUM_DBG_ATTRS 9
+#define NUM_DBG_ATTRS 5
 #else
 #define NUM_DBG_ATTRS 0
 #endif
diff --git a/drivers/edac/amd64_edac_dbg.c b/drivers/edac/amd64_edac_dbg.c
index 59cf2cf6e11e..e3562288f4ce 100644
--- a/drivers/edac/amd64_edac_dbg.c
+++ b/drivers/edac/amd64_edac_dbg.c
@@ -1,167 +1,16 @@
 #include "amd64_edac.h"
 
-/*
- * accept a hex value and store it into the virtual error register file, field:
- * nbeal and nbeah. Assume virtual error values have already been set for: NBSL,
- * NBSH and NBCFG. Then proceed to map the error values to a MC, CSROW and
- * CHANNEL
- */
-static ssize_t amd64_nbea_store(struct mem_ctl_info *mci, const char *data,
-                                size_t count)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        unsigned long long value;
-        int ret = 0;
-
-        ret = strict_strtoull(data, 16, &value);
-        if (ret != -EINVAL) {
-                debugf0("received NBEA= 0x%llx\n", value);
-
-                /* place the value into the virtual error packet */
-                pvt->ctl_error_info.nbeal = (u32) value;
-                value >>= 32;
-                pvt->ctl_error_info.nbeah = (u32) value;
-
-                /* Process the Mapping request */
-                /* TODO: Add race prevention */
-                amd_decode_nb_mce(pvt->mc_node_id, &pvt->ctl_error_info, 1);
-
-                return count;
-        }
-        return ret;
-}
-
-/* display back what the last NBEA (MCA NB Address (MC4_ADDR)) was written */
-static ssize_t amd64_nbea_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        u64 value;
-
-        value = pvt->ctl_error_info.nbeah;
-        value <<= 32;
-        value |= pvt->ctl_error_info.nbeal;
-
-        return sprintf(data, "%llx\n", value);
-}
-
-/* store the NBSL (MCA NB Status Low (MC4_STATUS)) value user desires */
-static ssize_t amd64_nbsl_store(struct mem_ctl_info *mci, const char *data,
-                                size_t count)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        unsigned long value;
-        int ret = 0;
-
-        ret = strict_strtoul(data, 16, &value);
-        if (ret != -EINVAL) {
-                debugf0("received NBSL= 0x%lx\n", value);
-
-                pvt->ctl_error_info.nbsl = (u32) value;
-
-                return count;
-        }
-        return ret;
-}
-
-/* display back what the last NBSL value written */
-static ssize_t amd64_nbsl_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        u32 value;
-
-        value = pvt->ctl_error_info.nbsl;
-
-        return sprintf(data, "%x\n", value);
-}
-
-/* store the NBSH (MCA NB Status High) value user desires */
-static ssize_t amd64_nbsh_store(struct mem_ctl_info *mci, const char *data,
-                                size_t count)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        unsigned long value;
-        int ret = 0;
-
-        ret = strict_strtoul(data, 16, &value);
-        if (ret != -EINVAL) {
-                debugf0("received NBSH= 0x%lx\n", value);
-
-                pvt->ctl_error_info.nbsh = (u32) value;
-
-                return count;
-        }
-        return ret;
-}
-
-/* display back what the last NBSH value written */
-static ssize_t amd64_nbsh_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        u32 value;
-
-        value = pvt->ctl_error_info.nbsh;
-
-        return sprintf(data, "%x\n", value);
+#define EDAC_DCT_ATTR_SHOW(reg)                                         \
+static ssize_t amd64_##reg##_show(struct mem_ctl_info *mci, char *data) \
+{                                                                       \
+        struct amd64_pvt *pvt = mci->pvt_info;                          \
+                return sprintf(data, "0x%016llx\n", (u64)pvt->reg);     \
 }
 
-/* accept and store the NBCFG (MCA NB Configuration) value user desires */
-static ssize_t amd64_nbcfg_store(struct mem_ctl_info *mci,
-                                        const char *data, size_t count)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-        unsigned long value;
-        int ret = 0;
-
-        ret = strict_strtoul(data, 16, &value);
-        if (ret != -EINVAL) {
-                debugf0("received NBCFG= 0x%lx\n", value);
-
-                pvt->ctl_error_info.nbcfg = (u32) value;
-
-                return count;
-        }
-        return ret;
-}
-
-/* various show routines for the controls of a MCI */
-static ssize_t amd64_nbcfg_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-
-        return sprintf(data, "%x\n", pvt->ctl_error_info.nbcfg);
-}
-
-
-static ssize_t amd64_dhar_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-
-        return sprintf(data, "%x\n", pvt->dhar);
-}
-
-
-static ssize_t amd64_dbam_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-
-        return sprintf(data, "%x\n", pvt->dbam0);
-}
-
-
-static ssize_t amd64_topmem_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-
-        return sprintf(data, "%llx\n", pvt->top_mem);
-}
-
-
-static ssize_t amd64_topmem2_show(struct mem_ctl_info *mci, char *data)
-{
-        struct amd64_pvt *pvt = mci->pvt_info;
-
-        return sprintf(data, "%llx\n", pvt->top_mem2);
-}
+EDAC_DCT_ATTR_SHOW(dhar);
+EDAC_DCT_ATTR_SHOW(dbam0);
+EDAC_DCT_ATTR_SHOW(top_mem);
+EDAC_DCT_ATTR_SHOW(top_mem2);
 
 static ssize_t amd64_hole_show(struct mem_ctl_info *mci, char *data)
 {
@@ -182,38 +31,6 @@ struct mcidev_sysfs_attribute amd64_dbg_attrs[] = {
 
         {
                 .attr = {
-                        .name = "nbea_ctl",
-                        .mode = (S_IRUGO | S_IWUSR)
-                },
-                .show = amd64_nbea_show,
-                .store = amd64_nbea_store,
-        },
-        {
-                .attr = {
-                        .name = "nbsl_ctl",
-                        .mode = (S_IRUGO | S_IWUSR)
-                },
-                .show = amd64_nbsl_show,
-                .store = amd64_nbsl_store,
-        },
-        {
-                .attr = {
-                        .name = "nbsh_ctl",
-                        .mode = (S_IRUGO | S_IWUSR)
-                },
-                .show = amd64_nbsh_show,
-                .store = amd64_nbsh_store,
-        },
-        {
-                .attr = {
-                        .name = "nbcfg_ctl",
-                        .mode = (S_IRUGO | S_IWUSR)
-                },
-                .show = amd64_nbcfg_show,
-                .store = amd64_nbcfg_store,
-        },
-        {
-                .attr = {
                         .name = "dhar",
                         .mode = (S_IRUGO)
                 },
@@ -225,7 +42,7 @@ struct mcidev_sysfs_attribute amd64_dbg_attrs[] = {
                         .name = "dbam",
                         .mode = (S_IRUGO)
                 },
-                .show = amd64_dbam_show,
+                .show = amd64_dbam0_show,
                 .store = NULL,
         },
         {
@@ -233,7 +50,7 @@ struct mcidev_sysfs_attribute amd64_dbg_attrs[] = {
                         .name = "topmem",
                         .mode = (S_IRUGO)
                 },
-                .show = amd64_topmem_show,
+                .show = amd64_top_mem_show,
                 .store = NULL,
         },
         {
@@ -241,7 +58,7 @@ struct mcidev_sysfs_attribute amd64_dbg_attrs[] = {
                         .name = "topmem2",
                         .mode = (S_IRUGO)
                 },
-                .show = amd64_topmem2_show,
+                .show = amd64_top_mem2_show,
                 .store = NULL,
         },
         {
diff --git a/drivers/edac/edac_device_sysfs.c b/drivers/edac/edac_device_sysfs.c
index 070968178a24..2941dca91aae 100644
--- a/drivers/edac/edac_device_sysfs.c
+++ b/drivers/edac/edac_device_sysfs.c
@@ -13,6 +13,7 @@
 #include <linux/ctype.h>
 #include <linux/module.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 
 #include "edac_core.h"
 #include "edac_module.h"
@@ -235,7 +236,7 @@ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
         debugf1("%s()\n", __func__);
 
         /* get the /sys/devices/system/edac reference */
-        edac_class = edac_get_edac_class();
+        edac_class = edac_get_sysfs_class();
         if (edac_class == NULL) {
                 debugf1("%s() no edac_class error\n", __func__);
                 err = -ENODEV;
@@ -255,7 +256,7 @@ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
 
         if (!try_module_get(edac_dev->owner)) {
                 err = -ENODEV;
-                goto err_out;
+                goto err_mod_get;
         }
 
         /* register */
@@ -282,6 +283,9 @@ int edac_device_register_sysfs_main_kobj(struct edac_device_ctl_info *edac_dev)
 err_kobj_reg:
         module_put(edac_dev->owner);
 
+err_mod_get:
+        edac_put_sysfs_class();
+
 err_out:
         return err;
 }
@@ -290,12 +294,11 @@ err_out:
  * edac_device_unregister_sysfs_main_kobj:
  *      the '..../edac/<name>' kobject
  */
-void edac_device_unregister_sysfs_main_kobj(
-                                        struct edac_device_ctl_info *edac_dev)
+void edac_device_unregister_sysfs_main_kobj(struct edac_device_ctl_info *dev)
 {
         debugf0("%s()\n", __func__);
         debugf4("%s() name of kobject is: %s\n",
-                __func__, kobject_name(&edac_dev->kobj));
+                __func__, kobject_name(&dev->kobj));
 
         /*
          * Unregister the edac device's kobject and
@@ -304,7 +307,8 @@ void edac_device_unregister_sysfs_main_kobj(
          *   a) module_put() this module
          *   b) 'kfree' the memory
          */
-        kobject_put(&edac_dev->kobj);
+        kobject_put(&dev->kobj);
+        edac_put_sysfs_class();
 }
 
 /* edac_dev -> instance information */
diff --git a/drivers/edac/edac_mc_sysfs.c b/drivers/edac/edac_mc_sysfs.c
index 8aad94d10c0c..a4135860149b 100644
--- a/drivers/edac/edac_mc_sysfs.c
+++ b/drivers/edac/edac_mc_sysfs.c
@@ -11,6 +11,7 @@
 
 #include <linux/ctype.h>
 #include <linux/slab.h>
+#include <linux/edac.h>
 #include <linux/bug.h>
 
 #include "edac_core.h"
@@ -1011,13 +1012,13 @@ void edac_remove_sysfs_mci_device(struct mem_ctl_info *mci)
  */
 int edac_sysfs_setup_mc_kset(void)
 {
-        int err = 0;
+        int err = -EINVAL;
         struct sysdev_class *edac_class;
 
         debugf1("%s()\n", __func__);
 
         /* get the /sys/devices/system/edac class reference */
-        edac_class = edac_get_edac_class();
+        edac_class = edac_get_sysfs_class();
         if (edac_class == NULL) {
                 debugf1("%s() no edac_class error=%d\n", __func__, err);
                 goto fail_out;
@@ -1028,15 +1029,16 @@ int edac_sysfs_setup_mc_kset(void)
         if (!mc_kset) {
                 err = -ENOMEM;
                 debugf1("%s() Failed to register '.../edac/mc'\n", __func__);
-                goto fail_out;
+                goto fail_kset;
         }
 
         debugf1("%s() Registered '.../edac/mc' kobject\n", __func__);
 
         return 0;
 
+fail_kset:
+        edac_put_sysfs_class();
 
-        /* error unwind stack */
 fail_out:
         return err;
 }
@@ -1049,5 +1051,6 @@ fail_out:
 void edac_sysfs_teardown_mc_kset(void)
 {
         kset_unregister(mc_kset);
+        edac_put_sysfs_class();
 }
 
diff --git a/drivers/edac/edac_mce_amd.c b/drivers/edac/edac_mce_amd.c
deleted file mode 100644
index 9014df6f605d..000000000000
--- a/drivers/edac/edac_mce_amd.c
+++ /dev/null
@@ -1,452 +0,0 @@
-#include <linux/module.h>
-#include "edac_mce_amd.h"
-
-static bool report_gart_errors;
-static void (*nb_bus_decoder)(int node_id, struct err_regs *regs);
-
-void amd_report_gart_errors(bool v)
-{
-        report_gart_errors = v;
-}
-EXPORT_SYMBOL_GPL(amd_report_gart_errors);
-
-void amd_register_ecc_decoder(void (*f)(int, struct err_regs *))
-{
-        nb_bus_decoder = f;
-}
-EXPORT_SYMBOL_GPL(amd_register_ecc_decoder);
-
-void amd_unregister_ecc_decoder(void (*f)(int, struct err_regs *))
-{
-        if (nb_bus_decoder) {
-                WARN_ON(nb_bus_decoder != f);
-
-                nb_bus_decoder = NULL;
-        }
-}
-EXPORT_SYMBOL_GPL(amd_unregister_ecc_decoder);
-
-/*
- * string representation for the different MCA reported error types, see F3x48
- * or MSR0000_0411.
- */
-const char *tt_msgs[] = {        /* transaction type */
-        "instruction",
-        "data",
-        "generic",
-        "reserved"
-};
-EXPORT_SYMBOL_GPL(tt_msgs);
-
-const char *ll_msgs[] = {       /* cache level */
-        "L0",
-        "L1",
-        "L2",
-        "L3/generic"
-};
-EXPORT_SYMBOL_GPL(ll_msgs);
-
-const char *rrrr_msgs[] = {
-        "generic",
-        "generic read",
-        "generic write",
-        "data read",
-        "data write",
-        "inst fetch",
-        "prefetch",
-        "evict",
-        "snoop",
-        "reserved RRRR= 9",
-        "reserved RRRR= 10",
-        "reserved RRRR= 11",
-        "reserved RRRR= 12",
-        "reserved RRRR= 13",
-        "reserved RRRR= 14",
-        "reserved RRRR= 15"
-};
-EXPORT_SYMBOL_GPL(rrrr_msgs);
-
-const char *pp_msgs[] = {       /* participating processor */
-        "local node originated (SRC)",
-        "local node responded to request (RES)",
-        "local node observed as 3rd party (OBS)",
-        "generic"
-};
-EXPORT_SYMBOL_GPL(pp_msgs);
-
-const char *to_msgs[] = {
-        "no timeout",
-        "timed out"
-};
-EXPORT_SYMBOL_GPL(to_msgs);
-
-const char *ii_msgs[] = {       /* memory or i/o */
-        "mem access",
-        "reserved",
-        "i/o access",
-        "generic"
-};
-EXPORT_SYMBOL_GPL(ii_msgs);
-
-/*
- * Map the 4 or 5 (family-specific) bits of Extended Error code to the
- * string table.
- */
-const char *ext_msgs[] = {
-        "K8 ECC error",                                 /* 0_0000b */
-        "CRC error on link",                            /* 0_0001b */
-        "Sync error packets on link",                   /* 0_0010b */
-        "Master Abort during link operation",           /* 0_0011b */
-        "Target Abort during link operation",           /* 0_0100b */
-        "Invalid GART PTE entry during table walk",     /* 0_0101b */
-        "Unsupported atomic RMW command received",      /* 0_0110b */
-        "WDT error: NB transaction timeout",            /* 0_0111b */
-        "ECC/ChipKill ECC error",                       /* 0_1000b */
-        "SVM DEV Error",                                /* 0_1001b */
-        "Link Data error",                              /* 0_1010b */
-        "Link/L3/Probe Filter Protocol error",          /* 0_1011b */
-        "NB Internal Arrays Parity error",              /* 0_1100b */
-        "DRAM Address/Control Parity error",            /* 0_1101b */
-        "Link Transmission error",                      /* 0_1110b */
-        "GART/DEV Table Walk Data error"                /* 0_1111b */
-        "Res 0x100 error",                              /* 1_0000b */
-        "Res 0x101 error",                              /* 1_0001b */
-        "Res 0x102 error",                              /* 1_0010b */
-        "Res 0x103 error",                              /* 1_0011b */
-        "Res 0x104 error",                              /* 1_0100b */
-        "Res 0x105 error",                              /* 1_0101b */
-        "Res 0x106 error",                              /* 1_0110b */
-        "Res 0x107 error",                              /* 1_0111b */
-        "Res 0x108 error",                              /* 1_1000b */
-        "Res 0x109 error",                              /* 1_1001b */
-        "Res 0x10A error",                              /* 1_1010b */
-        "Res 0x10B error",                              /* 1_1011b */
-        "ECC error in L3 Cache Data",                   /* 1_1100b */
-        "L3 Cache Tag error",                           /* 1_1101b */
-        "L3 Cache LRU Parity error",                    /* 1_1110b */
-        "Probe Filter error"                            /* 1_1111b */
-};
-EXPORT_SYMBOL_GPL(ext_msgs);
-
-static void amd_decode_dc_mce(u64 mc0_status)
-{
-        u32 ec  = mc0_status & 0xffff;
-        u32 xec = (mc0_status >> 16) & 0xf;
-
-        pr_emerg("Data Cache Error");
-
-        if (xec == 1 && TLB_ERROR(ec))
-                pr_cont(": %s TLB multimatch.\n", LL_MSG(ec));
-        else if (xec == 0) {
-                if (mc0_status & (1ULL << 40))
-                        pr_cont(" during Data Scrub.\n");
-                else if (TLB_ERROR(ec))
-                        pr_cont(": %s TLB parity error.\n", LL_MSG(ec));
-                else if (MEM_ERROR(ec)) {
-                        u8 ll   = ec & 0x3;
-                        u8 tt   = (ec >> 2) & 0x3;
-                        u8 rrrr = (ec >> 4) & 0xf;
-
-                        /* see F10h BKDG (31116), Table 92. */
-                        if (ll == 0x1) {
-                                if (tt != 0x1)
-                                        goto wrong_dc_mce;
-
-                                pr_cont(": Data/Tag %s error.\n", RRRR_MSG(ec));
-
-                        } else if (ll == 0x2 && rrrr == 0x3)
-                                pr_cont(" during L1 linefill from L2.\n");
-                        else
-                                goto wrong_dc_mce;
-                } else if (BUS_ERROR(ec) && boot_cpu_data.x86 == 0xf)
-                        pr_cont(" during system linefill.\n");
-                else
-                        goto wrong_dc_mce;
-        } else
-                goto wrong_dc_mce;
-
-        return;
-
-wrong_dc_mce:
-        pr_warning("Corrupted DC MCE info?\n");
-}
-
-static void amd_decode_ic_mce(u64 mc1_status)
-{
-        u32 ec  = mc1_status & 0xffff;
-        u32 xec = (mc1_status >> 16) & 0xf;
-
-        pr_emerg("Instruction Cache Error");
-
-        if (xec == 1 && TLB_ERROR(ec))
-                pr_cont(": %s TLB multimatch.\n", LL_MSG(ec));
-        else if (xec == 0) {
-                if (TLB_ERROR(ec))
-                        pr_cont(": %s TLB Parity error.\n", LL_MSG(ec));
-                else if (BUS_ERROR(ec)) {
-                        if (boot_cpu_data.x86 == 0xf &&
-                            (mc1_status & (1ULL << 58)))
-                                pr_cont(" during system linefill.\n");
-                        else
-                                pr_cont(" during attempted NB data read.\n");
-                } else if (MEM_ERROR(ec)) {
-                        u8 ll   = ec & 0x3;
-                        u8 rrrr = (ec >> 4) & 0xf;
-
-                        if (ll == 0x2)
-                                pr_cont(" during a linefill from L2.\n");
-                        else if (ll == 0x1) {
-
-                                switch (rrrr) {
-                                case 0x5:
-                                        pr_cont(": Parity error during "
-                                               "data load.\n");
-                                        break;
-
-                                case 0x7:
-                                        pr_cont(": Copyback Parity/Victim"
-                                                " error.\n");
-                                        break;
-
-                                case 0x8:
-                                        pr_cont(": Tag Snoop error.\n");
-                                        break;
-
-                                default:
-                                        goto wrong_ic_mce;
-                                        break;
-                                }
-                        }
-                } else
-                        goto wrong_ic_mce;
-        } else
-                goto wrong_ic_mce;
-
-        return;
-
-wrong_ic_mce:
-        pr_warning("Corrupted IC MCE info?\n");
-}
-
-static void amd_decode_bu_mce(u64 mc2_status)
-{
-        u32 ec = mc2_status & 0xffff;
-        u32 xec = (mc2_status >> 16) & 0xf;
-
-        pr_emerg("Bus Unit Error");
-
-        if (xec == 0x1)
-                pr_cont(" in the write data buffers.\n");
-        else if (xec == 0x3)
-                pr_cont(" in the victim data buffers.\n");
-        else if (xec == 0x2 && MEM_ERROR(ec))
-                pr_cont(": %s error in the L2 cache tags.\n", RRRR_MSG(ec));
-        else if (xec == 0x0) {
-                if (TLB_ERROR(ec))
-                        pr_cont(": %s error in a Page Descriptor Cache or "
-                                "Guest TLB.\n", TT_MSG(ec));
-                else if (BUS_ERROR(ec))
-                        pr_cont(": %s/ECC error in data read from NB: %s.\n",
-                                RRRR_MSG(ec), PP_MSG(ec));
-                else if (MEM_ERROR(ec)) {
-                        u8 rrrr = (ec >> 4) & 0xf;
-
-                        if (rrrr >= 0x7)
-                                pr_cont(": %s error during data copyback.\n",
-                                        RRRR_MSG(ec));
-                        else if (rrrr <= 0x1)
-                                pr_cont(": %s parity/ECC error during data "
-                                        "access from L2.\n", RRRR_MSG(ec));
-                        else
-                                goto wrong_bu_mce;
-                } else
-                        goto wrong_bu_mce;
-        } else
-                goto wrong_bu_mce;
-
-        return;
-
-wrong_bu_mce:
-        pr_warning("Corrupted BU MCE info?\n");
-}
-
-static void amd_decode_ls_mce(u64 mc3_status)
-{
-        u32 ec  = mc3_status & 0xffff;
-        u32 xec = (mc3_status >> 16) & 0xf;
-
-        pr_emerg("Load Store Error");
-
-        if (xec == 0x0) {
-                u8 rrrr = (ec >> 4) & 0xf;
-
-                if (!BUS_ERROR(ec) || (rrrr != 0x3 && rrrr != 0x4))
-                        goto wrong_ls_mce;
-
-                pr_cont(" during %s.\n", RRRR_MSG(ec));
-        }
-        return;
-
-wrong_ls_mce:
-        pr_warning("Corrupted LS MCE info?\n");
-}
-
-void amd_decode_nb_mce(int node_id, struct err_regs *regs, int handle_errors)
-{
-        u32 ec  = ERROR_CODE(regs->nbsl);
-
-        if (!handle_errors)
-                return;
-
-        /*
-         * GART TLB error reporting is disabled by default. Bail out early.
-         */
-        if (TLB_ERROR(ec) && !report_gart_errors)
-                return;
-
-        pr_emerg("Northbridge Error, node %d", node_id);
-
-        /*
-         * F10h, revD can disable ErrCpu[3:0] so check that first and also the
-         * value encoding has changed so interpret those differently
-         */
-        if ((boot_cpu_data.x86 == 0x10) &&
-            (boot_cpu_data.x86_model > 7)) {
-                if (regs->nbsh & K8_NBSH_ERR_CPU_VAL)
-                        pr_cont(", core: %u\n", (u8)(regs->nbsh & 0xf));
-        } else {
-                u8 assoc_cpus = regs->nbsh & 0xf;
-
-                if (assoc_cpus > 0)
-                        pr_cont(", core: %d", fls(assoc_cpus) - 1);
-
-                pr_cont("\n");
-        }
-
-        pr_emerg("%s.\n", EXT_ERR_MSG(regs->nbsl));
-
-        if (BUS_ERROR(ec) && nb_bus_decoder)
-                nb_bus_decoder(node_id, regs);
-}
-EXPORT_SYMBOL_GPL(amd_decode_nb_mce);
-
-static void amd_decode_fr_mce(u64 mc5_status)
-{
-        /* we have only one error signature so match all fields at once. */
-        if ((mc5_status & 0xffff) == 0x0f0f)
-                pr_emerg(" FR Error: CPU Watchdog timer expire.\n");
-        else
-                pr_warning("Corrupted FR MCE info?\n");
-}
-
-static inline void amd_decode_err_code(unsigned int ec)
-{
-        if (TLB_ERROR(ec)) {
-                pr_emerg("Transaction: %s, Cache Level %s\n",
-                         TT_MSG(ec), LL_MSG(ec));
-        } else if (MEM_ERROR(ec)) {
-                pr_emerg("Transaction: %s, Type: %s, Cache Level: %s",
-                         RRRR_MSG(ec), TT_MSG(ec), LL_MSG(ec));
-        } else if (BUS_ERROR(ec)) {
-                pr_emerg("Transaction type: %s(%s), %s, Cache Level: %s, "
-                         "Participating Processor: %s\n",
-                          RRRR_MSG(ec), II_MSG(ec), TO_MSG(ec), LL_MSG(ec),
-                          PP_MSG(ec));
-        } else
-                pr_warning("Huh? Unknown MCE error 0x%x\n", ec);
-}
-
-static int amd_decode_mce(struct notifier_block *nb, unsigned long val,
-                           void *data)
-{
-        struct mce *m = (struct mce *)data;
-        struct err_regs regs;
-        int node, ecc;
-
-        pr_emerg("MC%d_STATUS: ", m->bank);
-
-        pr_cont("%sorrected error, other errors lost: %s, "
-                 "CPU context corrupt: %s",
-                 ((m->status & MCI_STATUS_UC) ? "Unc"  : "C"),
-                 ((m->status & MCI_STATUS_OVER) ? "yes"  : "no"),
-                 ((m->status & MCI_STATUS_PCC) ? "yes" : "no"));
-
-        /* do the two bits[14:13] together */
-        ecc = (m->status >> 45) & 0x3;
-        if (ecc)
-                pr_cont(", %sECC Error", ((ecc == 2) ? "C" : "U"));
-
-        pr_cont("\n");
-
-        switch (m->bank) {
-        case 0:
-                amd_decode_dc_mce(m->status);
-                break;
-
-        case 1:
-                amd_decode_ic_mce(m->status);
-                break;
-
-        case 2:
-                amd_decode_bu_mce(m->status);
-                break;
-
-        case 3:
-                amd_decode_ls_mce(m->status);
-                break;
-
-        case 4:
-                regs.nbsl  = (u32) m->status;
-                regs.nbsh  = (u32)(m->status >> 32);
-                regs.nbeal = (u32) m->addr;
-                regs.nbeah = (u32)(m->addr >> 32);
-                node       = amd_get_nb_id(m->extcpu);
-
-                amd_decode_nb_mce(node, &regs, 1);
-                break;
-
-        case 5:
-                amd_decode_fr_mce(m->status);
-                break;
-
-        default:
-                break;
-        }
-
-        amd_decode_err_code(m->status & 0xffff);
-
-        return NOTIFY_STOP;
-}
-
-static struct notifier_block amd_mce_dec_nb = {
-        .notifier_call  = amd_decode_mce,
-};
-
-static int __init mce_amd_init(void)
-{
-        /*
-         * We can decode MCEs for K8, F10h and F11h CPUs:
-         */
-        if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
-                return 0;
-
-        if (boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x11)
-                return 0;
-
-        atomic_notifier_chain_register(&x86_mce_decoder_chain, &amd_mce_dec_nb);
-
-        return 0;
-}
-early_initcall(mce_amd_init);
-
-#ifdef MODULE
-static void __exit mce_amd_exit(void)
-{
-        atomic_notifier_chain_unregister(&x86_mce_decoder_chain, &amd_mce_dec_nb);
-}
-
-MODULE_DESCRIPTION("AMD MCE decoder");
-MODULE_ALIAS("edac-mce-amd");
-MODULE_LICENSE("GPL");
-module_exit(mce_amd_exit);
-#endif
diff --git a/drivers/edac/edac_module.c b/drivers/edac/edac_module.c
index 7e1374afd967..be4b075c3098 100644
--- a/drivers/edac/edac_module.c
+++ b/drivers/edac/edac_module.c
@@ -27,15 +27,6 @@ EXPORT_SYMBOL_GPL(edac_debug_level);
 struct workqueue_struct *edac_workqueue;
 
 /*
- * sysfs object: /sys/devices/system/edac
- *      need to export to other files in this modules
- */
-static struct sysdev_class edac_class = {
-        .name = "edac",
-};
-static int edac_class_valid;
-
-/*
  * edac_op_state_to_string()
  */
 char *edac_op_state_to_string(int opstate)
@@ -55,60 +46,6 @@ char *edac_op_state_to_string(int opstate)
 }
 
 /*
- * edac_get_edac_class()
- *
- *      return pointer to the edac class of 'edac'
- */
-struct sysdev_class *edac_get_edac_class(void)
-{
-        struct sysdev_class *classptr = NULL;
-
-        if (edac_class_valid)
-                classptr = &edac_class;
-
-        return classptr;
-}
-
-/*
- * edac_register_sysfs_edac_name()
- *
- *      register the 'edac' into /sys/devices/system
- *
- * return:
- *      0  success
- *      !0 error
- */
-static int edac_register_sysfs_edac_name(void)
-{
-        int err;
-
-        /* create the /sys/devices/system/edac directory */
-        err = sysdev_class_register(&edac_class);
-
-        if (err) {
-                debugf1("%s() error=%d\n", __func__, err);
-                return err;
-        }
-
-        edac_class_valid = 1;
-        return 0;
-}
-
-/*
- * sysdev_class_unregister()
- *
- *      unregister the 'edac' from /sys/devices/system
- */
-static void edac_unregister_sysfs_edac_name(void)
-{
-        /* only if currently registered, then unregister it */
-        if (edac_class_valid)
-                sysdev_class_unregister(&edac_class);
-
-        edac_class_valid = 0;
-}
-
-/*
  * edac_workqueue_setup
  *      initialize the edac work queue for polling operations
  */
@@ -154,21 +91,11 @@ static int __init edac_init(void)
         edac_pci_clear_parity_errors();
 
         /*
-         * perform the registration of the /sys/devices/system/edac class object
-         */
-        if (edac_register_sysfs_edac_name()) {
-                edac_printk(KERN_ERR, EDAC_MC,
-                        "Error initializing 'edac' kobject\n");
-                err = -ENODEV;
-                goto error;
-        }
-
-        /*
          * now set up the mc_kset under the edac class object
          */
         err = edac_sysfs_setup_mc_kset();
         if (err)
-                goto sysfs_setup_fail;
+                goto error;
 
         /* Setup/Initialize the workq for this core */
         err = edac_workqueue_setup();
@@ -183,9 +110,6 @@ static int __init edac_init(void)
 workq_fail:
         edac_sysfs_teardown_mc_kset();
 
-sysfs_setup_fail:
-        edac_unregister_sysfs_edac_name();
-
 error:
         return err;
 }
@@ -201,7 +125,6 @@ static void __exit edac_exit(void)
         /* tear down the various subsystems */
         edac_workqueue_teardown();
         edac_sysfs_teardown_mc_kset();
-        edac_unregister_sysfs_edac_name();
 }
 
 /*
diff --git a/drivers/edac/edac_module.h b/drivers/edac/edac_module.h
index 233d4798c3aa..17aabb7b90ec 100644
--- a/drivers/edac/edac_module.h
+++ b/drivers/edac/edac_module.h
@@ -42,7 +42,6 @@ extern void edac_device_unregister_sysfs_main_kobj(
                                 struct edac_device_ctl_info *edac_dev);
 extern int edac_device_create_sysfs(struct edac_device_ctl_info *edac_dev);
 extern void edac_device_remove_sysfs(struct edac_device_ctl_info *edac_dev);
-extern struct sysdev_class *edac_get_edac_class(void);
 
 /* edac core workqueue: single CPU mode */
 extern struct workqueue_struct *edac_workqueue;
diff --git a/drivers/edac/edac_pci_sysfs.c b/drivers/edac/edac_pci_sysfs.c
index c39697df9cb4..023b01cb5175 100644
--- a/drivers/edac/edac_pci_sysfs.c
+++ b/drivers/edac/edac_pci_sysfs.c
@@ -7,7 +7,7 @@
  *
  */
 #include <linux/module.h>
-#include <linux/sysdev.h>
+#include <linux/edac.h>
 #include <linux/slab.h>
 #include <linux/ctype.h>
 
@@ -354,7 +354,7 @@ static int edac_pci_main_kobj_setup(void)
         /* First time, so create the main kobject and its
          * controls and atributes
          */
-        edac_class = edac_get_edac_class();
+        edac_class = edac_get_sysfs_class();
         if (edac_class == NULL) {
                 debugf1("%s() no edac_class\n", __func__);
                 err = -ENODEV;
@@ -368,7 +368,7 @@ static int edac_pci_main_kobj_setup(void)
         if (!try_module_get(THIS_MODULE)) {
                 debugf1("%s() try_module_get() failed\n", __func__);
                 err = -ENODEV;
-                goto decrement_count_fail;
+                goto mod_get_fail;
         }
 
         edac_pci_top_main_kobj = kzalloc(sizeof(struct kobject), GFP_KERNEL);
@@ -403,6 +403,9 @@ kobject_init_and_add_fail:
 kzalloc_fail:
         module_put(THIS_MODULE);
 
+mod_get_fail:
+        edac_put_sysfs_class();
+
 decrement_count_fail:
         /* if are on this error exit, nothing to tear down */
         atomic_dec(&edac_pci_sysfs_refcount);
@@ -429,6 +432,7 @@ static void edac_pci_main_kobj_teardown(void)
                         __func__);
                 kobject_put(edac_pci_top_main_kobj);
         }
+        edac_put_sysfs_class();
 }
 
 /*
diff --git a/drivers/edac/edac_stub.c b/drivers/edac/edac_stub.c
index 20b428aa155e..aab970760b75 100644
--- a/drivers/edac/edac_stub.c
+++ b/drivers/edac/edac_stub.c
@@ -3,10 +3,13 @@
  *
  * Author: Dave Jiang <djiang@mvista.com>
  *
- * 2007 (c) MontaVista Software, Inc. This file is licensed under
- * the terms of the GNU General Public License version 2. This program
- * is licensed "as is" without any warranty of any kind, whether express
- * or implied.
+ * 2007 (c) MontaVista Software, Inc.
+ * 2010 (c) Advanced Micro Devices Inc.
+ *          Borislav Petkov <borislav.petkov@amd.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
  *
  */
 #include <linux/module.h>
@@ -23,6 +26,8 @@ EXPORT_SYMBOL_GPL(edac_handlers);
 int edac_err_assert = 0;
 EXPORT_SYMBOL_GPL(edac_err_assert);
 
+static atomic_t edac_class_valid = ATOMIC_INIT(0);
+
 /*
  * called to determine if there is an EDAC driver interested in
  * knowing an event (such as NMI) occurred
@@ -44,3 +49,41 @@ void edac_atomic_assert_error(void)
         edac_err_assert++;
 }
 EXPORT_SYMBOL_GPL(edac_atomic_assert_error);
+
+/*
+ * sysfs object: /sys/devices/system/edac
+ *      need to export to other files
+ */
+struct sysdev_class edac_class = {
+        .name = "edac",
+};
+EXPORT_SYMBOL_GPL(edac_class);
+
+/* return pointer to the 'edac' node in sysfs */
+struct sysdev_class *edac_get_sysfs_class(void)
+{
+        int err = 0;
+
+        if (atomic_read(&edac_class_valid))
+                goto out;
+
+        /* create the /sys/devices/system/edac directory */
+        err = sysdev_class_register(&edac_class);
+        if (err) {
+                printk(KERN_ERR "Error registering toplevel EDAC sysfs dir\n");
+                return NULL;
+        }
+
+out:
+        atomic_inc(&edac_class_valid);
+        return &edac_class;
+}
+EXPORT_SYMBOL_GPL(edac_get_sysfs_class);
+
+void edac_put_sysfs_class(void)
+{
+        /* last user unregisters it */
+        if (atomic_dec_and_test(&edac_class_valid))
+                sysdev_class_unregister(&edac_class);
+}
+EXPORT_SYMBOL_GPL(edac_put_sysfs_class);
diff --git a/drivers/edac/mce_amd.c b/drivers/edac/mce_amd.c
new file mode 100644
index 000000000000..c0181093b490
--- /dev/null
+++ b/drivers/edac/mce_amd.c
@@ -0,0 +1,680 @@
+#include <linux/module.h>
+#include <linux/slab.h>
+
+#include "mce_amd.h"
+
+static struct amd_decoder_ops *fam_ops;
+
+static u8 nb_err_cpumask = 0xf;
+
+static bool report_gart_errors;
+static void (*nb_bus_decoder)(int node_id, struct mce *m, u32 nbcfg);
+
+void amd_report_gart_errors(bool v)
+{
+        report_gart_errors = v;
+}
+EXPORT_SYMBOL_GPL(amd_report_gart_errors);
+
+void amd_register_ecc_decoder(void (*f)(int, struct mce *, u32))
+{
+        nb_bus_decoder = f;
+}
+EXPORT_SYMBOL_GPL(amd_register_ecc_decoder);
+
+void amd_unregister_ecc_decoder(void (*f)(int, struct mce *, u32))
+{
+        if (nb_bus_decoder) {
+                WARN_ON(nb_bus_decoder != f);
+
+                nb_bus_decoder = NULL;
+        }
+}
+EXPORT_SYMBOL_GPL(amd_unregister_ecc_decoder);
+
+/*
+ * string representation for the different MCA reported error types, see F3x48
+ * or MSR0000_0411.
+ */
+
+/* transaction type */
+const char *tt_msgs[] = { "INSN", "DATA", "GEN", "RESV" };
+EXPORT_SYMBOL_GPL(tt_msgs);
+
+/* cache level */
+const char *ll_msgs[] = { "RESV", "L1", "L2", "L3/GEN" };
+EXPORT_SYMBOL_GPL(ll_msgs);
+
+/* memory transaction type */
+const char *rrrr_msgs[] = {
+       "GEN", "RD", "WR", "DRD", "DWR", "IRD", "PRF", "EV", "SNP"
+};
+EXPORT_SYMBOL_GPL(rrrr_msgs);
+
+/* participating processor */
+const char *pp_msgs[] = { "SRC", "RES", "OBS", "GEN" };
+EXPORT_SYMBOL_GPL(pp_msgs);
+
+/* request timeout */
+const char *to_msgs[] = { "no timeout", "timed out" };
+EXPORT_SYMBOL_GPL(to_msgs);
+
+/* memory or i/o */
+const char *ii_msgs[] = { "MEM", "RESV", "IO", "GEN" };
+EXPORT_SYMBOL_GPL(ii_msgs);
+
+static const char *f10h_nb_mce_desc[] = {
+        "HT link data error",
+        "Protocol error (link, L3, probe filter, etc.)",
+        "Parity error in NB-internal arrays",
+        "Link Retry due to IO link transmission error",
+        "L3 ECC data cache error",
+        "ECC error in L3 cache tag",
+        "L3 LRU parity bits error",
+        "ECC Error in the Probe Filter directory"
+};
+
+static bool f12h_dc_mce(u16 ec)
+{
+        bool ret = false;
+
+        if (MEM_ERROR(ec)) {
+                u8 ll = ec & 0x3;
+                ret = true;
+
+                if (ll == LL_L2)
+                        pr_cont("during L1 linefill from L2.\n");
+                else if (ll == LL_L1)
+                        pr_cont("Data/Tag %s error.\n", RRRR_MSG(ec));
+                else
+                        ret = false;
+        }
+        return ret;
+}
+
+static bool f10h_dc_mce(u16 ec)
+{
+        u8 r4  = (ec >> 4) & 0xf;
+        u8 ll  = ec & 0x3;
+
+        if (r4 == R4_GEN && ll == LL_L1) {
+                pr_cont("during data scrub.\n");
+                return true;
+        }
+        return f12h_dc_mce(ec);
+}
+
+static bool k8_dc_mce(u16 ec)
+{
+        if (BUS_ERROR(ec)) {
+                pr_cont("during system linefill.\n");
+                return true;
+        }
+
+        return f10h_dc_mce(ec);
+}
+
+static bool f14h_dc_mce(u16 ec)
+{
+        u8 r4    = (ec >> 4) & 0xf;
+        u8 ll    = ec & 0x3;
+        u8 tt    = (ec >> 2) & 0x3;
+        u8 ii    = tt;
+        bool ret = true;
+
+        if (MEM_ERROR(ec)) {
+
+                if (tt != TT_DATA || ll != LL_L1)
+                        return false;
+
+                switch (r4) {
+                case R4_DRD:
+                case R4_DWR:
+                        pr_cont("Data/Tag parity error due to %s.\n",
+                                (r4 == R4_DRD ? "load/hw prf" : "store"));
+                        break;
+                case R4_EVICT:
+                        pr_cont("Copyback parity error on a tag miss.\n");
+                        break;
+                case R4_SNOOP:
+                        pr_cont("Tag parity error during snoop.\n");
+                        break;
+                default:
+                        ret = false;
+                }
+        } else if (BUS_ERROR(ec)) {
+
+                if ((ii != II_MEM && ii != II_IO) || ll != LL_LG)
+                        return false;
+
+                pr_cont("System read data error on a ");
+
+                switch (r4) {
+                case R4_RD:
+                        pr_cont("TLB reload.\n");
+                        break;
+                case R4_DWR:
+                        pr_cont("store.\n");
+                        break;
+                case R4_DRD:
+                        pr_cont("load.\n");
+                        break;
+                default:
+                        ret = false;
+                }
+        } else {
+                ret = false;
+        }
+
+        return ret;
+}
+
+static void amd_decode_dc_mce(struct mce *m)
+{
+        u16 ec = m->status & 0xffff;
+        u8 xec = (m->status >> 16) & 0xf;
+
+        pr_emerg(HW_ERR "Data Cache Error: ");
+
+        /* TLB error signatures are the same across families */
+        if (TLB_ERROR(ec)) {
+                u8 tt = (ec >> 2) & 0x3;
+
+                if (tt == TT_DATA) {
+                        pr_cont("%s TLB %s.\n", LL_MSG(ec),
+                                (xec ? "multimatch" : "parity error"));
+                        return;
+                }
+                else
+                        goto wrong_dc_mce;
+        }
+
+        if (!fam_ops->dc_mce(ec))
+                goto wrong_dc_mce;
+
+        return;
+
+wrong_dc_mce:
+        pr_emerg(HW_ERR "Corrupted DC MCE info?\n");
+}
+
+static bool k8_ic_mce(u16 ec)
+{
+        u8 ll    = ec & 0x3;
+        u8 r4    = (ec >> 4) & 0xf;
+        bool ret = true;
+
+        if (!MEM_ERROR(ec))
+                return false;
+
+        if (ll == 0x2)
+                pr_cont("during a linefill from L2.\n");
+        else if (ll == 0x1) {
+                switch (r4) {
+                case R4_IRD:
+                        pr_cont("Parity error during data load.\n");
+                        break;
+
+                case R4_EVICT:
+                        pr_cont("Copyback Parity/Victim error.\n");
+                        break;
+
+                case R4_SNOOP:
+                        pr_cont("Tag Snoop error.\n");
+                        break;
+
+                default:
+                        ret = false;
+                        break;
+                }
+        } else
+                ret = false;
+
+        return ret;
+}
+
+static bool f14h_ic_mce(u16 ec)
+{
+        u8 ll    = ec & 0x3;
+        u8 tt    = (ec >> 2) & 0x3;
+        u8 r4  = (ec >> 4) & 0xf;
+        bool ret = true;
+
+        if (MEM_ERROR(ec)) {
+                if (tt != 0 || ll != 1)
+                        ret = false;
+
+                if (r4 == R4_IRD)
+                        pr_cont("Data/tag array parity error for a tag hit.\n");
+                else if (r4 == R4_SNOOP)
+                        pr_cont("Tag error during snoop/victimization.\n");
+                else
+                        ret = false;
+        }
+        return ret;
+}
+
+static void amd_decode_ic_mce(struct mce *m)
+{
+        u16 ec = m->status & 0xffff;
+        u8 xec = (m->status >> 16) & 0xf;
+
+        pr_emerg(HW_ERR "Instruction Cache Error: ");
+
+        if (TLB_ERROR(ec))
+                pr_cont("%s TLB %s.\n", LL_MSG(ec),
+                        (xec ? "multimatch" : "parity error"));
+        else if (BUS_ERROR(ec)) {
+                bool k8 = (boot_cpu_data.x86 == 0xf && (m->status & BIT_64(58)));
+
+                pr_cont("during %s.\n", (k8 ? "system linefill" : "NB data read"));
+        } else if (fam_ops->ic_mce(ec))
+                ;
+        else
+                pr_emerg(HW_ERR "Corrupted IC MCE info?\n");
+}
+
+static void amd_decode_bu_mce(struct mce *m)
+{
+        u32 ec = m->status & 0xffff;
+        u32 xec = (m->status >> 16) & 0xf;
+
+        pr_emerg(HW_ERR "Bus Unit Error");
+
+        if (xec == 0x1)
+                pr_cont(" in the write data buffers.\n");
+        else if (xec == 0x3)
+                pr_cont(" in the victim data buffers.\n");
+        else if (xec == 0x2 && MEM_ERROR(ec))
+                pr_cont(": %s error in the L2 cache tags.\n", RRRR_MSG(ec));
+        else if (xec == 0x0) {
+                if (TLB_ERROR(ec))
+                        pr_cont(": %s error in a Page Descriptor Cache or "
+                                "Guest TLB.\n", TT_MSG(ec));
+                else if (BUS_ERROR(ec))
+                        pr_cont(": %s/ECC error in data read from NB: %s.\n",
+                                RRRR_MSG(ec), PP_MSG(ec));
+                else if (MEM_ERROR(ec)) {
+                        u8 rrrr = (ec >> 4) & 0xf;
+
+                        if (rrrr >= 0x7)
+                                pr_cont(": %s error during data copyback.\n",
+                                        RRRR_MSG(ec));
+                        else if (rrrr <= 0x1)
+                                pr_cont(": %s parity/ECC error during data "
+                                        "access from L2.\n", RRRR_MSG(ec));
+                        else
+                                goto wrong_bu_mce;
+                } else
+                        goto wrong_bu_mce;
+        } else
+                goto wrong_bu_mce;
+
+        return;
+
+wrong_bu_mce:
+        pr_emerg(HW_ERR "Corrupted BU MCE info?\n");
+}
+
+static void amd_decode_ls_mce(struct mce *m)
+{
+        u16 ec = m->status & 0xffff;
+        u8 xec = (m->status >> 16) & 0xf;
+
+        if (boot_cpu_data.x86 == 0x14) {
+                pr_emerg("You shouldn't be seeing an LS MCE on this cpu family,"
+                         " please report on LKML.\n");
+                return;
+        }
+
+        pr_emerg(HW_ERR "Load Store Error");
+
+        if (xec == 0x0) {
+                u8 r4 = (ec >> 4) & 0xf;
+
+                if (!BUS_ERROR(ec) || (r4 != R4_DRD && r4 != R4_DWR))
+                        goto wrong_ls_mce;
+
+                pr_cont(" during %s.\n", RRRR_MSG(ec));
+        } else
+                goto wrong_ls_mce;
+
+        return;
+
+wrong_ls_mce:
+        pr_emerg(HW_ERR "Corrupted LS MCE info?\n");
+}
+
+static bool k8_nb_mce(u16 ec, u8 xec)
+{
+        bool ret = true;
+
+        switch (xec) {
+        case 0x1:
+                pr_cont("CRC error detected on HT link.\n");
+                break;
+
+        case 0x5:
+                pr_cont("Invalid GART PTE entry during GART table walk.\n");
+                break;
+
+        case 0x6:
+                pr_cont("Unsupported atomic RMW received from an IO link.\n");
+                break;
+
+        case 0x0:
+        case 0x8:
+                if (boot_cpu_data.x86 == 0x11)
+                        return false;
+
+                pr_cont("DRAM ECC error detected on the NB.\n");
+                break;
+
+        case 0xd:
+                pr_cont("Parity error on the DRAM addr/ctl signals.\n");
+                break;
+
+        default:
+                ret = false;
+                break;
+        }
+
+        return ret;
+}
+
+static bool f10h_nb_mce(u16 ec, u8 xec)
+{
+        bool ret = true;
+        u8 offset = 0;
+
+        if (k8_nb_mce(ec, xec))
+                return true;
+
+        switch(xec) {
+        case 0xa ... 0xc:
+                offset = 10;
+                break;
+
+        case 0xe:
+                offset = 11;
+                break;
+
+        case 0xf:
+                if (TLB_ERROR(ec))
+                        pr_cont("GART Table Walk data error.\n");
+                else if (BUS_ERROR(ec))
+                        pr_cont("DMA Exclusion Vector Table Walk error.\n");
+                else
+                        ret = false;
+
+                goto out;
+                break;
+
+        case 0x1c ... 0x1f:
+                offset = 24;
+                break;
+
+        default:
+                ret = false;
+
+                goto out;
+                break;
+        }
+
+        pr_cont("%s.\n", f10h_nb_mce_desc[xec - offset]);
+
+out:
+        return ret;
+}
+
+static bool nb_noop_mce(u16 ec, u8 xec)
+{
+        return false;
+}
+
+void amd_decode_nb_mce(int node_id, struct mce *m, u32 nbcfg)
+{
+        u8 xec   = (m->status >> 16) & 0x1f;
+        u16 ec   = m->status & 0xffff;
+        u32 nbsh = (u32)(m->status >> 32);
+
+        pr_emerg(HW_ERR "Northbridge Error, node %d: ", node_id);
+
+        /*
+         * F10h, revD can disable ErrCpu[3:0] so check that first and also the
+         * value encoding has changed so interpret those differently
+         */
+        if ((boot_cpu_data.x86 == 0x10) &&
+            (boot_cpu_data.x86_model > 7)) {
+                if (nbsh & K8_NBSH_ERR_CPU_VAL)
+                        pr_cont(", core: %u", (u8)(nbsh & nb_err_cpumask));
+        } else {
+                u8 assoc_cpus = nbsh & nb_err_cpumask;
+
+                if (assoc_cpus > 0)
+                        pr_cont(", core: %d", fls(assoc_cpus) - 1);
+        }
+
+        switch (xec) {
+        case 0x2:
+                pr_cont("Sync error (sync packets on HT link detected).\n");
+                return;
+
+        case 0x3:
+                pr_cont("HT Master abort.\n");
+                return;
+
+        case 0x4:
+                pr_cont("HT Target abort.\n");
+                return;
+
+        case 0x7:
+                pr_cont("NB Watchdog timeout.\n");
+                return;
+
+        case 0x9:
+                pr_cont("SVM DMA Exclusion Vector error.\n");
+                return;
+
+        default:
+                break;
+        }
+
+        if (!fam_ops->nb_mce(ec, xec))
+                goto wrong_nb_mce;
+
+        if (boot_cpu_data.x86 == 0xf || boot_cpu_data.x86 == 0x10)
+                if ((xec == 0x8 || xec == 0x0) && nb_bus_decoder)
+                        nb_bus_decoder(node_id, m, nbcfg);
+
+        return;
+
+wrong_nb_mce:
+        pr_emerg(HW_ERR "Corrupted NB MCE info?\n");
+}
+EXPORT_SYMBOL_GPL(amd_decode_nb_mce);
+
+static void amd_decode_fr_mce(struct mce *m)
+{
+        if (boot_cpu_data.x86 == 0xf ||
+            boot_cpu_data.x86 == 0x11)
+                goto wrong_fr_mce;
+
+        /* we have only one error signature so match all fields at once. */
+        if ((m->status & 0xffff) == 0x0f0f) {
+                pr_emerg(HW_ERR "FR Error: CPU Watchdog timer expire.\n");
+                return;
+        }
+
+wrong_fr_mce:
+        pr_emerg(HW_ERR "Corrupted FR MCE info?\n");
+}
+
+static inline void amd_decode_err_code(u16 ec)
+{
+        if (TLB_ERROR(ec)) {
+                pr_emerg(HW_ERR "Transaction: %s, Cache Level: %s\n",
+                         TT_MSG(ec), LL_MSG(ec));
+        } else if (MEM_ERROR(ec)) {
+                pr_emerg(HW_ERR "Transaction: %s, Type: %s, Cache Level: %s\n",
+                         RRRR_MSG(ec), TT_MSG(ec), LL_MSG(ec));
+        } else if (BUS_ERROR(ec)) {
+                pr_emerg(HW_ERR "Transaction: %s (%s), %s, Cache Level: %s, "
+                         "Participating Processor: %s\n",
+                          RRRR_MSG(ec), II_MSG(ec), TO_MSG(ec), LL_MSG(ec),
+                          PP_MSG(ec));
+        } else
+                pr_emerg(HW_ERR "Huh? Unknown MCE error 0x%x\n", ec);
+}
+
+/*
+ * Filter out unwanted MCE signatures here.
+ */
+static bool amd_filter_mce(struct mce *m)
+{
+        u8 xec = (m->status >> 16) & 0x1f;
+
+        /*
+         * NB GART TLB error reporting is disabled by default.
+         */
+        if (m->bank == 4 && xec == 0x5 && !report_gart_errors)
+                return true;
+
+        return false;
+}
+
+int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data)
+{
+        struct mce *m = (struct mce *)data;
+        int node, ecc;
+
+        if (amd_filter_mce(m))
+                return NOTIFY_STOP;
+
+        pr_emerg(HW_ERR "MC%d_STATUS: ", m->bank);
+
+        pr_cont("%sorrected error, other errors lost: %s, "
+                 "CPU context corrupt: %s",
+                 ((m->status & MCI_STATUS_UC) ? "Unc"  : "C"),
+                 ((m->status & MCI_STATUS_OVER) ? "yes"  : "no"),
+                 ((m->status & MCI_STATUS_PCC) ? "yes" : "no"));
+
+        /* do the two bits[14:13] together */
+        ecc = (m->status >> 45) & 0x3;
+        if (ecc)
+                pr_cont(", %sECC Error", ((ecc == 2) ? "C" : "U"));
+
+        pr_cont("\n");
+
+        switch (m->bank) {
+        case 0:
+                amd_decode_dc_mce(m);
+                break;
+
+        case 1:
+                amd_decode_ic_mce(m);
+                break;
+
+        case 2:
+                amd_decode_bu_mce(m);
+                break;
+
+        case 3:
+                amd_decode_ls_mce(m);
+                break;
+
+        case 4:
+                node = amd_get_nb_id(m->extcpu);
+                amd_decode_nb_mce(node, m, 0);
+                break;
+
+        case 5:
+                amd_decode_fr_mce(m);
+                break;
+
+        default:
+                break;
+        }
+
+        amd_decode_err_code(m->status & 0xffff);
+
+        return NOTIFY_STOP;
+}
+EXPORT_SYMBOL_GPL(amd_decode_mce);
+
+static struct notifier_block amd_mce_dec_nb = {
+        .notifier_call  = amd_decode_mce,
+};
+
+static int __init mce_amd_init(void)
+{
+        if (boot_cpu_data.x86_vendor != X86_VENDOR_AMD)
+                return 0;
+
+        if ((boot_cpu_data.x86 < 0xf || boot_cpu_data.x86 > 0x12) &&
+            (boot_cpu_data.x86 != 0x14 || boot_cpu_data.x86_model > 0xf))
+                return 0;
+
+        fam_ops = kzalloc(sizeof(struct amd_decoder_ops), GFP_KERNEL);
+        if (!fam_ops)
+                return -ENOMEM;
+
+        switch (boot_cpu_data.x86) {
+        case 0xf:
+                fam_ops->dc_mce = k8_dc_mce;
+                fam_ops->ic_mce = k8_ic_mce;
+                fam_ops->nb_mce = k8_nb_mce;
+                break;
+
+        case 0x10:
+                fam_ops->dc_mce = f10h_dc_mce;
+                fam_ops->ic_mce = k8_ic_mce;
+                fam_ops->nb_mce = f10h_nb_mce;
+                break;
+
+        case 0x11:
+                fam_ops->dc_mce = k8_dc_mce;
+                fam_ops->ic_mce = k8_ic_mce;
+                fam_ops->nb_mce = f10h_nb_mce;
+                break;
+
+        case 0x12:
+                fam_ops->dc_mce = f12h_dc_mce;
+                fam_ops->ic_mce = k8_ic_mce;
+                fam_ops->nb_mce = nb_noop_mce;
+                break;
+
+        case 0x14:
+                nb_err_cpumask  = 0x3;
+                fam_ops->dc_mce = f14h_dc_mce;
+                fam_ops->ic_mce = f14h_ic_mce;
+                fam_ops->nb_mce = nb_noop_mce;
+                break;
+
+        default:
+                printk(KERN_WARNING "Huh? What family is that: %d?!\n",
+                                    boot_cpu_data.x86);
+                kfree(fam_ops);
+                return -EINVAL;
+        }
+
+        pr_info("MCE: In-kernel MCE decoding enabled.\n");
+
+        atomic_notifier_chain_register(&x86_mce_decoder_chain, &amd_mce_dec_nb);
+
+        return 0;
+}
+early_initcall(mce_amd_init);
+
+#ifdef MODULE
+static void __exit mce_amd_exit(void)
+{
+        atomic_notifier_chain_unregister(&x86_mce_decoder_chain, &amd_mce_dec_nb);
+        kfree(fam_ops);
+}
+
+MODULE_DESCRIPTION("AMD MCE decoder");
+MODULE_ALIAS("edac-mce-amd");
+MODULE_LICENSE("GPL");
+module_exit(mce_amd_exit);
+#endif
diff --git a/drivers/edac/edac_mce_amd.h b/drivers/edac/mce_amd.h
index df23ee065f79..35f6e0e3b297 100644
--- a/drivers/edac/edac_mce_amd.h
+++ b/drivers/edac/mce_amd.h
@@ -1,11 +1,14 @@
 #ifndef _EDAC_MCE_AMD_H
 #define _EDAC_MCE_AMD_H
 
+#include <linux/notifier.h>
+
 #include <asm/mce.h>
 
+#define BIT_64(n)                       (U64_C(1) << (n))
+
 #define ERROR_CODE(x)                   ((x) & 0xffff)
 #define EXT_ERROR_CODE(x)               (((x) >> 16) & 0x1f)
-#define EXT_ERR_MSG(x)                  ext_msgs[EXT_ERROR_CODE(x)]
 
 #define LOW_SYNDROME(x)                 (((x) >> 15) & 0xff)
 #define HIGH_SYNDROME(x)                (((x) >> 24) & 0xff)
@@ -20,13 +23,14 @@
 #define II_MSG(x)                       ii_msgs[II(x)]
 #define LL(x)                           (((x) >> 0) & 0x3)
 #define LL_MSG(x)                       ll_msgs[LL(x)]
-#define RRRR(x)                         (((x) >> 4) & 0xf)
-#define RRRR_MSG(x)                     rrrr_msgs[RRRR(x)]
 #define TO(x)                           (((x) >> 8) & 0x1)
 #define TO_MSG(x)                       to_msgs[TO(x)]
 #define PP(x)                           (((x) >> 9) & 0x3)
 #define PP_MSG(x)                       pp_msgs[PP(x)]
 
+#define RRRR(x)                         (((x) >> 4) & 0xf)
+#define RRRR_MSG(x)                     ((RRRR(x) < 9) ?  rrrr_msgs[RRRR(x)] : "Wrong R4!")
+
 #define K8_NBSH                         0x4C
 
 #define K8_NBSH_VALID_BIT               BIT(31)
@@ -41,13 +45,45 @@
 #define K8_NBSH_UECC                    BIT(13)
 #define K8_NBSH_ERR_SCRUBER             BIT(8)
 
+enum tt_ids {
+        TT_INSTR = 0,
+        TT_DATA,
+        TT_GEN,
+        TT_RESV,
+};
+
+enum ll_ids {
+        LL_RESV = 0,
+        LL_L1,
+        LL_L2,
+        LL_LG,
+};
+
+enum ii_ids {
+        II_MEM = 0,
+        II_RESV,
+        II_IO,
+        II_GEN,
+};
+
+enum rrrr_ids {
+        R4_GEN  = 0,
+        R4_RD,
+        R4_WR,
+        R4_DRD,
+        R4_DWR,
+        R4_IRD,
+        R4_PREF,
+        R4_EVICT,
+        R4_SNOOP,
+};
+
 extern const char *tt_msgs[];
 extern const char *ll_msgs[];
 extern const char *rrrr_msgs[];
 extern const char *pp_msgs[];
 extern const char *to_msgs[];
 extern const char *ii_msgs[];
-extern const char *ext_msgs[];
 
 /*
  * relevant NB regs
@@ -60,10 +96,19 @@ struct err_regs {
         u32 nbeal;
 };
 
+/*
+ * per-family decoder ops
+ */
+struct amd_decoder_ops {
+        bool (*dc_mce)(u16);
+        bool (*ic_mce)(u16);
+        bool (*nb_mce)(u16, u8);
+};
 
 void amd_report_gart_errors(bool);
-void amd_register_ecc_decoder(void (*f)(int, struct err_regs *));
-void amd_unregister_ecc_decoder(void (*f)(int, struct err_regs *));
-void amd_decode_nb_mce(int, struct err_regs *, int);
+void amd_register_ecc_decoder(void (*f)(int, struct mce *, u32));
+void amd_unregister_ecc_decoder(void (*f)(int, struct mce *, u32));
+void amd_decode_nb_mce(int, struct mce *, u32);
+int amd_decode_mce(struct notifier_block *nb, unsigned long val, void *data);
 
 #endif /* _EDAC_MCE_AMD_H */
diff --git a/drivers/edac/mce_amd_inj.c b/drivers/edac/mce_amd_inj.c
new file mode 100644
index 000000000000..8d0688f36d4c
--- /dev/null
+++ b/drivers/edac/mce_amd_inj.c
@@ -0,0 +1,171 @@
+/*
+ * A simple MCE injection facility for testing the MCE decoding code. This
+ * driver should be built as module so that it can be loaded on production
+ * kernels for testing purposes.
+ *
+ * This file may be distributed under the terms of the GNU General Public
+ * License version 2.
+ *
+ * Copyright (c) 2010:  Borislav Petkov <borislav.petkov@amd.com>
+ *                      Advanced Micro Devices Inc.
+ */
+
+#include <linux/kobject.h>
+#include <linux/sysdev.h>
+#include <linux/edac.h>
+#include <asm/mce.h>
+
+#include "mce_amd.h"
+
+struct edac_mce_attr {
+        struct attribute attr;
+        ssize_t (*show) (struct kobject *kobj, struct edac_mce_attr *attr, char *buf);
+        ssize_t (*store)(struct kobject *kobj, struct edac_mce_attr *attr,
+                         const char *buf, size_t count);
+};
+
+#define EDAC_MCE_ATTR(_name, _mode, _show, _store)                      \
+static struct edac_mce_attr mce_attr_##_name = __ATTR(_name, _mode, _show, _store)
+
+static struct kobject *mce_kobj;
+
+/*
+ * Collect all the MCi_XXX settings
+ */
+static struct mce i_mce;
+
+#define MCE_INJECT_STORE(reg)                                           \
+static ssize_t edac_inject_##reg##_store(struct kobject *kobj,          \
+                                         struct edac_mce_attr *attr,    \
+                                         const char *data, size_t count)\
+{                                                                       \
+        int ret = 0;                                                    \
+        unsigned long value;                                            \
+                                                                        \
+        ret = strict_strtoul(data, 16, &value);                         \
+        if (ret < 0)                                                    \
+                printk(KERN_ERR "Error writing MCE " #reg " field.\n"); \
+                                                                        \
+        i_mce.reg = value;                                              \
+                                                                        \
+        return count;                                                   \
+}
+
+MCE_INJECT_STORE(status);
+MCE_INJECT_STORE(misc);
+MCE_INJECT_STORE(addr);
+
+#define MCE_INJECT_SHOW(reg)                                            \
+static ssize_t edac_inject_##reg##_show(struct kobject *kobj,           \
+                                        struct edac_mce_attr *attr,     \
+                                        char *buf)                      \
+{                                                                       \
+        return sprintf(buf, "0x%016llx\n", i_mce.reg);                  \
+}
+
+MCE_INJECT_SHOW(status);
+MCE_INJECT_SHOW(misc);
+MCE_INJECT_SHOW(addr);
+
+EDAC_MCE_ATTR(status, 0644, edac_inject_status_show, edac_inject_status_store);
+EDAC_MCE_ATTR(misc, 0644, edac_inject_misc_show, edac_inject_misc_store);
+EDAC_MCE_ATTR(addr, 0644, edac_inject_addr_show, edac_inject_addr_store);
+
+/*
+ * This denotes into which bank we're injecting and triggers
+ * the injection, at the same time.
+ */
+static ssize_t edac_inject_bank_store(struct kobject *kobj,
+                                      struct edac_mce_attr *attr,
+                                      const char *data, size_t count)
+{
+        int ret = 0;
+        unsigned long value;
+
+        ret = strict_strtoul(data, 10, &value);
+        if (ret < 0) {
+                printk(KERN_ERR "Invalid bank value!\n");
+                return -EINVAL;
+        }
+
+        if (value > 5) {
+                printk(KERN_ERR "Non-existant MCE bank: %lu\n", value);
+                return -EINVAL;
+        }
+
+        i_mce.bank = value;
+
+        amd_decode_mce(NULL, 0, &i_mce);
+
+        return count;
+}
+
+static ssize_t edac_inject_bank_show(struct kobject *kobj,
+                                     struct edac_mce_attr *attr, char *buf)
+{
+        return sprintf(buf, "%d\n", i_mce.bank);
+}
+
+EDAC_MCE_ATTR(bank, 0644, edac_inject_bank_show, edac_inject_bank_store);
+
+static struct edac_mce_attr *sysfs_attrs[] = { &mce_attr_status, &mce_attr_misc,
+                                               &mce_attr_addr, &mce_attr_bank
+};
+
+static int __init edac_init_mce_inject(void)
+{
+        struct sysdev_class *edac_class = NULL;
+        int i, err = 0;
+
+        edac_class = edac_get_sysfs_class();
+        if (!edac_class)
+                return -EINVAL;
+
+        mce_kobj = kobject_create_and_add("mce", &edac_class->kset.kobj);
+        if (!mce_kobj) {
+                printk(KERN_ERR "Error creating a mce kset.\n");
+                err = -ENOMEM;
+                goto err_mce_kobj;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++) {
+                err = sysfs_create_file(mce_kobj, &sysfs_attrs[i]->attr);
+                if (err) {
+                        printk(KERN_ERR "Error creating %s in sysfs.\n",
+                                        sysfs_attrs[i]->attr.name);
+                        goto err_sysfs_create;
+                }
+        }
+        return 0;
+
+err_sysfs_create:
+        while (i-- >= 0)
+                sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
+
+        kobject_del(mce_kobj);
+
+err_mce_kobj:
+        edac_put_sysfs_class();
+
+        return err;
+}
+
+static void __exit edac_exit_mce_inject(void)
+{
+        int i;
+
+        for (i = 0; i < ARRAY_SIZE(sysfs_attrs); i++)
+                sysfs_remove_file(mce_kobj, &sysfs_attrs[i]->attr);
+
+        kobject_del(mce_kobj);
+
+        edac_put_sysfs_class();
+}
+
+module_init(edac_init_mce_inject);
+module_exit(edac_exit_mce_inject);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Borislav Petkov <borislav.petkov@amd.com>");
+MODULE_AUTHOR("AMD Inc.");
+MODULE_DESCRIPTION("MCE injection facility for testing MCE decoding");
diff --git a/drivers/firewire/ohci.c b/drivers/firewire/ohci.c
index 1b05896648bc..9dcb17d51aee 100644
--- a/drivers/firewire/ohci.c
+++ b/drivers/firewire/ohci.c
@@ -2840,7 +2840,7 @@ static int __devinit pci_probe(struct pci_dev *dev,
                                const struct pci_device_id *ent)
 {
         struct fw_ohci *ohci;
-        u32 bus_options, max_receive, link_speed, version, link_enh;
+        u32 bus_options, max_receive, link_speed, version;
         u64 guid;
         int i, err, n_ir, n_it;
         size_t size;
@@ -2894,23 +2894,6 @@ static int __devinit pci_probe(struct pci_dev *dev,
         if (param_quirks)
                 ohci->quirks = param_quirks;
 
-        /* TI OHCI-Lynx and compatible: set recommended configuration bits. */
-        if (dev->vendor == PCI_VENDOR_ID_TI) {
-                pci_read_config_dword(dev, PCI_CFG_TI_LinkEnh, &link_enh);
-
-                /* adjust latency of ATx FIFO: use 1.7 KB threshold */
-                link_enh &= ~TI_LinkEnh_atx_thresh_mask;
-                link_enh |= TI_LinkEnh_atx_thresh_1_7K;
-
-                /* use priority arbitration for asynchronous responses */
-                link_enh |= TI_LinkEnh_enab_unfair;
-
-                /* required for aPhyEnhanceEnable to work */
-                link_enh |= TI_LinkEnh_enab_accel;
-
-                pci_write_config_dword(dev, PCI_CFG_TI_LinkEnh, link_enh);
-        }
-
         ar_context_init(&ohci->ar_request_ctx, ohci,
                         OHCI1394_AsReqRcvContextControlSet);
 
diff --git a/drivers/firewire/ohci.h b/drivers/firewire/ohci.h
index 0e6c5a466908..ef5e7336da68 100644
--- a/drivers/firewire/ohci.h
+++ b/drivers/firewire/ohci.h
@@ -155,12 +155,4 @@
 
 #define OHCI1394_phy_tcode              0xe
 
-/* TI extensions */
-
-#define PCI_CFG_TI_LinkEnh              0xf4
-#define  TI_LinkEnh_enab_accel          0x00000002
-#define  TI_LinkEnh_enab_unfair         0x00000080
-#define  TI_LinkEnh_atx_thresh_mask     0x00003000
-#define  TI_LinkEnh_atx_thresh_1_7K     0x00001000
-
 #endif /* _FIREWIRE_OHCI_H */
diff --git a/drivers/firmware/Kconfig b/drivers/firmware/Kconfig
index 280c9b5ad9e3..88a3ae6cd023 100644
--- a/drivers/firmware/Kconfig
+++ b/drivers/firmware/Kconfig
@@ -125,7 +125,7 @@ config ISCSI_IBFT_FIND
 config ISCSI_IBFT
         tristate "iSCSI Boot Firmware Table Attributes module"
         select ISCSI_BOOT_SYSFS
-        depends on ISCSI_IBFT_FIND && SCSI
+        depends on ISCSI_IBFT_FIND && SCSI && SCSI_LOWLEVEL
         default n
         help
           This option enables support for detection and exposing of iSCSI
diff --git a/drivers/gpio/tc35892-gpio.c b/drivers/gpio/tc35892-gpio.c
index 1be6288780de..7e10c935a047 100644
--- a/drivers/gpio/tc35892-gpio.c
+++ b/drivers/gpio/tc35892-gpio.c
@@ -322,6 +322,9 @@ static int __devinit tc35892_gpio_probe(struct platform_device *pdev)
                 goto out_freeirq;
         }
 
+        if (pdata->setup)
+                pdata->setup(tc35892, tc35892_gpio->chip.base);
+
         platform_set_drvdata(pdev, tc35892_gpio);
 
         return 0;
@@ -338,9 +341,14 @@ out_free:
 static int __devexit tc35892_gpio_remove(struct platform_device *pdev)
 {
         struct tc35892_gpio *tc35892_gpio = platform_get_drvdata(pdev);
+        struct tc35892 *tc35892 = tc35892_gpio->tc35892;
+        struct tc35892_gpio_platform_data *pdata = tc35892->pdata->gpio;
         int irq = platform_get_irq(pdev, 0);
         int ret;
 
+        if (pdata->remove)
+                pdata->remove(tc35892, tc35892_gpio->chip.base);
+
         ret = gpiochip_remove(&tc35892_gpio->chip);
         if (ret < 0) {
                 dev_err(tc35892_gpio->dev,
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index c74e4e8006d4..2dd2c93ebfa3 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -2231,6 +2231,9 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         dev_priv->mchdev_lock = &mchdev_lock;
         spin_unlock(&mchdev_lock);
 
+        /* XXX Prevent module unload due to memory corruption bugs. */
+        __module_get(THIS_MODULE);
+
         return 0;
 
 out_workqueue_free:
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 79082d4398ae..2f93d46ae69a 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -1137,7 +1137,7 @@ static void evergreen_gpu_init(struct radeon_device *rdev)
 
                 WREG32(RCU_IND_INDEX, 0x203);
                 efuse_straps_3 = RREG32(RCU_IND_DATA);
-                efuse_box_bit_127_124 = (u8)(efuse_straps_3 & 0xF0000000) >> 28;
+                efuse_box_bit_127_124 = (u8)((efuse_straps_3 & 0xF0000000) >> 28);
 
                 switch(efuse_box_bit_127_124) {
                 case 0x0:
@@ -1407,6 +1407,7 @@ int evergreen_mc_init(struct radeon_device *rdev)
         rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE) * 1024 * 1024;
         rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE) * 1024 * 1024;
         rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         r600_vram_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
 
@@ -1520,7 +1521,7 @@ void evergreen_disable_interrupt_state(struct radeon_device *rdev)
 {
         u32 tmp;
 
-        WREG32(CP_INT_CNTL, 0);
+        WREG32(CP_INT_CNTL, CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE);
         WREG32(GRBM_INT_CNTL, 0);
         WREG32(INT_MASK + EVERGREEN_CRTC0_REGISTER_OFFSET, 0);
         WREG32(INT_MASK + EVERGREEN_CRTC1_REGISTER_OFFSET, 0);
diff --git a/drivers/gpu/drm/radeon/r100.c b/drivers/gpu/drm/radeon/r100.c
index e151f16a8f86..e59422320bb6 100644
--- a/drivers/gpu/drm/radeon/r100.c
+++ b/drivers/gpu/drm/radeon/r100.c
@@ -1030,6 +1030,7 @@ int r100_cp_init(struct radeon_device *rdev, unsigned ring_size)
                 return r;
         }
         rdev->cp.ready = true;
+        rdev->mc.active_vram_size = rdev->mc.real_vram_size;
         return 0;
 }
 
@@ -1047,6 +1048,7 @@ void r100_cp_fini(struct radeon_device *rdev)
 void r100_cp_disable(struct radeon_device *rdev)
 {
         /* Disable ring */
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         rdev->cp.ready = false;
         WREG32(RADEON_CP_CSQ_MODE, 0);
         WREG32(RADEON_CP_CSQ_CNTL, 0);
@@ -2295,6 +2297,7 @@ void r100_vram_init_sizes(struct radeon_device *rdev)
         /* FIXME we don't use the second aperture yet when we could use it */
         if (rdev->mc.visible_vram_size > rdev->mc.aper_size)
                 rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         config_aper_size = RREG32(RADEON_CONFIG_APER_SIZE);
         if (rdev->flags & RADEON_IS_IGP) {
                 uint32_t tom;
diff --git a/drivers/gpu/drm/radeon/r600.c b/drivers/gpu/drm/radeon/r600.c
index 7a04959ba0ee..7b65e4efe8af 100644
--- a/drivers/gpu/drm/radeon/r600.c
+++ b/drivers/gpu/drm/radeon/r600.c
@@ -1248,6 +1248,7 @@ int r600_mc_init(struct radeon_device *rdev)
         rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE);
         rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE);
         rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         r600_vram_gtt_location(rdev, &rdev->mc);
 
         if (rdev->flags & RADEON_IS_IGP) {
@@ -1917,6 +1918,7 @@ void r600_pciep_wreg(struct radeon_device *rdev, u32 reg, u32 v)
  */
 void r600_cp_stop(struct radeon_device *rdev)
 {
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         WREG32(R_0086D8_CP_ME_CNTL, S_0086D8_CP_ME_HALT(1));
 }
 
@@ -2910,7 +2912,7 @@ static void r600_disable_interrupt_state(struct radeon_device *rdev)
 {
         u32 tmp;
 
-        WREG32(CP_INT_CNTL, 0);
+        WREG32(CP_INT_CNTL, CNTX_BUSY_INT_ENABLE | CNTX_EMPTY_INT_ENABLE);
         WREG32(GRBM_INT_CNTL, 0);
         WREG32(DxMODE_INT_MASK, 0);
         if (ASIC_IS_DCE3(rdev)) {
diff --git a/drivers/gpu/drm/radeon/r600_blit_kms.c b/drivers/gpu/drm/radeon/r600_blit_kms.c
index 9ceb2a1ce799..3473c00781ff 100644
--- a/drivers/gpu/drm/radeon/r600_blit_kms.c
+++ b/drivers/gpu/drm/radeon/r600_blit_kms.c
@@ -532,6 +532,7 @@ int r600_blit_init(struct radeon_device *rdev)
         memcpy(ptr + rdev->r600_blit.ps_offset, r6xx_ps, r6xx_ps_size * 4);
         radeon_bo_kunmap(rdev->r600_blit.shader_obj);
         radeon_bo_unreserve(rdev->r600_blit.shader_obj);
+        rdev->mc.active_vram_size = rdev->mc.real_vram_size;
         return 0;
 }
 
@@ -539,6 +540,7 @@ void r600_blit_fini(struct radeon_device *rdev)
 {
         int r;
 
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         if (rdev->r600_blit.shader_obj == NULL)
                 return;
         /* If we can't reserve the bo, unref should be enough to destroy
diff --git a/drivers/gpu/drm/radeon/radeon.h b/drivers/gpu/drm/radeon/radeon.h
index a168d644bf9e..9ff38c99a6ea 100644
--- a/drivers/gpu/drm/radeon/radeon.h
+++ b/drivers/gpu/drm/radeon/radeon.h
@@ -344,6 +344,7 @@ struct radeon_mc {
          * about vram size near mc fb location */
         u64                     mc_vram_size;
         u64                     visible_vram_size;
+        u64                     active_vram_size;
         u64                     gtt_size;
         u64                     gtt_start;
         u64                     gtt_end;
diff --git a/drivers/gpu/drm/radeon/radeon_atombios.c b/drivers/gpu/drm/radeon/radeon_atombios.c
index 68932ba7b8a4..8e43ddae70cc 100644
--- a/drivers/gpu/drm/radeon/radeon_atombios.c
+++ b/drivers/gpu/drm/radeon/radeon_atombios.c
@@ -1558,39 +1558,39 @@ radeon_atombios_get_tv_info(struct radeon_device *rdev)
                 switch (tv_info->ucTV_BootUpDefaultStandard) {
                 case ATOM_TV_NTSC:
                         tv_std = TV_STD_NTSC;
-                        DRM_INFO("Default TV standard: NTSC\n");
+                        DRM_DEBUG_KMS("Default TV standard: NTSC\n");
                         break;
                 case ATOM_TV_NTSCJ:
                         tv_std = TV_STD_NTSC_J;
-                        DRM_INFO("Default TV standard: NTSC-J\n");
+                        DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
                         break;
                 case ATOM_TV_PAL:
                         tv_std = TV_STD_PAL;
-                        DRM_INFO("Default TV standard: PAL\n");
+                        DRM_DEBUG_KMS("Default TV standard: PAL\n");
                         break;
                 case ATOM_TV_PALM:
                         tv_std = TV_STD_PAL_M;
-                        DRM_INFO("Default TV standard: PAL-M\n");
+                        DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
                         break;
                 case ATOM_TV_PALN:
                         tv_std = TV_STD_PAL_N;
-                        DRM_INFO("Default TV standard: PAL-N\n");
+                        DRM_DEBUG_KMS("Default TV standard: PAL-N\n");
                         break;
                 case ATOM_TV_PALCN:
                         tv_std = TV_STD_PAL_CN;
-                        DRM_INFO("Default TV standard: PAL-CN\n");
+                        DRM_DEBUG_KMS("Default TV standard: PAL-CN\n");
                         break;
                 case ATOM_TV_PAL60:
                         tv_std = TV_STD_PAL_60;
-                        DRM_INFO("Default TV standard: PAL-60\n");
+                        DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
                         break;
                 case ATOM_TV_SECAM:
                         tv_std = TV_STD_SECAM;
-                        DRM_INFO("Default TV standard: SECAM\n");
+                        DRM_DEBUG_KMS("Default TV standard: SECAM\n");
                         break;
                 default:
                         tv_std = TV_STD_NTSC;
-                        DRM_INFO("Unknown TV standard; defaulting to NTSC\n");
+                        DRM_DEBUG_KMS("Unknown TV standard; defaulting to NTSC\n");
                         break;
                 }
         }
diff --git a/drivers/gpu/drm/radeon/radeon_combios.c b/drivers/gpu/drm/radeon/radeon_combios.c
index a04b7a6ad95f..7b7ea269549c 100644
--- a/drivers/gpu/drm/radeon/radeon_combios.c
+++ b/drivers/gpu/drm/radeon/radeon_combios.c
@@ -913,47 +913,47 @@ radeon_combios_get_tv_info(struct radeon_device *rdev)
                         switch (RBIOS8(tv_info + 7) & 0xf) {
                         case 1:
                                 tv_std = TV_STD_NTSC;
-                                DRM_INFO("Default TV standard: NTSC\n");
+                                DRM_DEBUG_KMS("Default TV standard: NTSC\n");
                                 break;
                         case 2:
                                 tv_std = TV_STD_PAL;
-                                DRM_INFO("Default TV standard: PAL\n");
+                                DRM_DEBUG_KMS("Default TV standard: PAL\n");
                                 break;
                         case 3:
                                 tv_std = TV_STD_PAL_M;
-                                DRM_INFO("Default TV standard: PAL-M\n");
+                                DRM_DEBUG_KMS("Default TV standard: PAL-M\n");
                                 break;
                         case 4:
                                 tv_std = TV_STD_PAL_60;
-                                DRM_INFO("Default TV standard: PAL-60\n");
+                                DRM_DEBUG_KMS("Default TV standard: PAL-60\n");
                                 break;
                         case 5:
                                 tv_std = TV_STD_NTSC_J;
-                                DRM_INFO("Default TV standard: NTSC-J\n");
+                                DRM_DEBUG_KMS("Default TV standard: NTSC-J\n");
                                 break;
                         case 6:
                                 tv_std = TV_STD_SCART_PAL;
-                                DRM_INFO("Default TV standard: SCART-PAL\n");
+                                DRM_DEBUG_KMS("Default TV standard: SCART-PAL\n");
                                 break;
                         default:
                                 tv_std = TV_STD_NTSC;
-                                DRM_INFO
+                                DRM_DEBUG_KMS
                                     ("Unknown TV standard; defaulting to NTSC\n");
                                 break;
                         }
 
                         switch ((RBIOS8(tv_info + 9) >> 2) & 0x3) {
                         case 0:
-                                DRM_INFO("29.498928713 MHz TV ref clk\n");
+                                DRM_DEBUG_KMS("29.498928713 MHz TV ref clk\n");
                                 break;
                         case 1:
-                                DRM_INFO("28.636360000 MHz TV ref clk\n");
+                                DRM_DEBUG_KMS("28.636360000 MHz TV ref clk\n");
                                 break;
                         case 2:
-                                DRM_INFO("14.318180000 MHz TV ref clk\n");
+                                DRM_DEBUG_KMS("14.318180000 MHz TV ref clk\n");
                                 break;
                         case 3:
-                                DRM_INFO("27.000000000 MHz TV ref clk\n");
+                                DRM_DEBUG_KMS("27.000000000 MHz TV ref clk\n");
                                 break;
                         default:
                                 break;
@@ -1324,7 +1324,7 @@ bool radeon_legacy_get_tmds_info_from_combios(struct radeon_encoder *encoder,
 
         if (tmds_info) {
                 ver = RBIOS8(tmds_info);
-                DRM_INFO("DFP table revision: %d\n", ver);
+                DRM_DEBUG_KMS("DFP table revision: %d\n", ver);
                 if (ver == 3) {
                         n = RBIOS8(tmds_info + 5) + 1;
                         if (n > 4)
@@ -1408,7 +1408,7 @@ bool radeon_legacy_get_ext_tmds_info_from_combios(struct radeon_encoder *encoder
                 offset = combios_get_table_offset(dev, COMBIOS_EXT_TMDS_INFO_TABLE);
                 if (offset) {
                         ver = RBIOS8(offset);
-                        DRM_INFO("External TMDS Table revision: %d\n", ver);
+                        DRM_DEBUG_KMS("External TMDS Table revision: %d\n", ver);
                         tmds->slave_addr = RBIOS8(offset + 4 + 2);
                         tmds->slave_addr >>= 1; /* 7 bit addressing */
                         gpio = RBIOS8(offset + 4 + 3);
diff --git a/drivers/gpu/drm/radeon/radeon_cursor.c b/drivers/gpu/drm/radeon/radeon_cursor.c
index 5731fc9b1ae3..3eef567b0421 100644
--- a/drivers/gpu/drm/radeon/radeon_cursor.c
+++ b/drivers/gpu/drm/radeon/radeon_cursor.c
@@ -203,6 +203,7 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
         struct radeon_crtc *radeon_crtc = to_radeon_crtc(crtc);
         struct radeon_device *rdev = crtc->dev->dev_private;
         int xorigin = 0, yorigin = 0;
+        int w = radeon_crtc->cursor_width;
 
         if (x < 0)
                 xorigin = -x + 1;
@@ -213,22 +214,7 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
         if (yorigin >= CURSOR_HEIGHT)
                 yorigin = CURSOR_HEIGHT - 1;
 
-        radeon_lock_cursor(crtc, true);
-        if (ASIC_IS_DCE4(rdev)) {
-                /* cursors are offset into the total surface */
-                x += crtc->x;
-                y += crtc->y;
-                DRM_DEBUG("x %d y %d c->x %d c->y %d\n", x, y, crtc->x, crtc->y);
-
-                /* XXX: check if evergreen has the same issues as avivo chips */
-                WREG32(EVERGREEN_CUR_POSITION + radeon_crtc->crtc_offset,
-                       ((xorigin ? 0 : x) << 16) |
-                       (yorigin ? 0 : y));
-                WREG32(EVERGREEN_CUR_HOT_SPOT + radeon_crtc->crtc_offset, (xorigin << 16) | yorigin);
-                WREG32(EVERGREEN_CUR_SIZE + radeon_crtc->crtc_offset,
-                       ((radeon_crtc->cursor_width - 1) << 16) | (radeon_crtc->cursor_height - 1));
-        } else if (ASIC_IS_AVIVO(rdev)) {
-                int w = radeon_crtc->cursor_width;
+        if (ASIC_IS_AVIVO(rdev)) {
                 int i = 0;
                 struct drm_crtc *crtc_p;
 
@@ -260,7 +246,17 @@ int radeon_crtc_cursor_move(struct drm_crtc *crtc,
                         if (w <= 0)
                                 w = 1;
                 }
+        }
 
+        radeon_lock_cursor(crtc, true);
+        if (ASIC_IS_DCE4(rdev)) {
+                WREG32(EVERGREEN_CUR_POSITION + radeon_crtc->crtc_offset,
+                       ((xorigin ? 0 : x) << 16) |
+                       (yorigin ? 0 : y));
+                WREG32(EVERGREEN_CUR_HOT_SPOT + radeon_crtc->crtc_offset, (xorigin << 16) | yorigin);
+                WREG32(EVERGREEN_CUR_SIZE + radeon_crtc->crtc_offset,
+                       ((w - 1) << 16) | (radeon_crtc->cursor_height - 1));
+        } else if (ASIC_IS_AVIVO(rdev)) {
                 WREG32(AVIVO_D1CUR_POSITION + radeon_crtc->crtc_offset,
                              ((xorigin ? 0 : x) << 16) |
                              (yorigin ? 0 : y));
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index 0afd1e62347d..b3b5306bb578 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -69,7 +69,7 @@ void radeon_ttm_placement_from_domain(struct radeon_bo *rbo, u32 domain)
         u32 c = 0;
 
         rbo->placement.fpfn = 0;
-        rbo->placement.lpfn = 0;
+        rbo->placement.lpfn = rbo->rdev->mc.active_vram_size >> PAGE_SHIFT;
         rbo->placement.placement = rbo->placements;
         rbo->placement.busy_placement = rbo->placements;
         if (domain & RADEON_GEM_DOMAIN_VRAM)
diff --git a/drivers/gpu/drm/radeon/radeon_object.h b/drivers/gpu/drm/radeon/radeon_object.h
index 353998dc2c03..3481bc7f6f58 100644
--- a/drivers/gpu/drm/radeon/radeon_object.h
+++ b/drivers/gpu/drm/radeon/radeon_object.h
@@ -124,11 +124,8 @@ static inline int radeon_bo_wait(struct radeon_bo *bo, u32 *mem_type,
         int r;
 
         r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, 0);
-        if (unlikely(r != 0)) {
-                if (r != -ERESTARTSYS)
-                        dev_err(bo->rdev->dev, "%p reserve failed for wait\n", bo);
+        if (unlikely(r != 0))
                 return r;
-        }
         spin_lock(&bo->tbo.lock);
         if (mem_type)
                 *mem_type = bo->tbo.mem.mem_type;
diff --git a/drivers/gpu/drm/radeon/rs600.c b/drivers/gpu/drm/radeon/rs600.c
index cc05b230d7ef..51d5f7b5ab21 100644
--- a/drivers/gpu/drm/radeon/rs600.c
+++ b/drivers/gpu/drm/radeon/rs600.c
@@ -693,6 +693,7 @@ void rs600_mc_init(struct radeon_device *rdev)
         rdev->mc.real_vram_size = RREG32(RADEON_CONFIG_MEMSIZE);
         rdev->mc.mc_vram_size = rdev->mc.real_vram_size;
         rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         rdev->mc.igp_sideport_enabled = radeon_atombios_sideport_present(rdev);
         base = RREG32_MC(R_000004_MC_FB_LOCATION);
         base = G_000004_MC_FB_START(base) << 16;
diff --git a/drivers/gpu/drm/radeon/rs690.c b/drivers/gpu/drm/radeon/rs690.c
index 3e3f75718be3..4dc2a87ea680 100644
--- a/drivers/gpu/drm/radeon/rs690.c
+++ b/drivers/gpu/drm/radeon/rs690.c
@@ -157,6 +157,7 @@ void rs690_mc_init(struct radeon_device *rdev)
         rdev->mc.aper_base = pci_resource_start(rdev->pdev, 0);
         rdev->mc.aper_size = pci_resource_len(rdev->pdev, 0);
         rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         base = RREG32_MC(R_000100_MCCFG_FB_LOCATION);
         base = G_000100_MC_FB_START(base) << 16;
         rdev->mc.igp_sideport_enabled = radeon_atombios_sideport_present(rdev);
diff --git a/drivers/gpu/drm/radeon/rv770.c b/drivers/gpu/drm/radeon/rv770.c
index bfa59db374d2..9490da700749 100644
--- a/drivers/gpu/drm/radeon/rv770.c
+++ b/drivers/gpu/drm/radeon/rv770.c
@@ -267,6 +267,7 @@ static void rv770_mc_program(struct radeon_device *rdev)
  */
 void r700_cp_stop(struct radeon_device *rdev)
 {
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         WREG32(CP_ME_CNTL, (CP_ME_HALT | CP_PFP_HALT));
 }
 
@@ -992,6 +993,7 @@ int rv770_mc_init(struct radeon_device *rdev)
         rdev->mc.mc_vram_size = RREG32(CONFIG_MEMSIZE);
         rdev->mc.real_vram_size = RREG32(CONFIG_MEMSIZE);
         rdev->mc.visible_vram_size = rdev->mc.aper_size;
+        rdev->mc.active_vram_size = rdev->mc.visible_vram_size;
         r600_vram_gtt_location(rdev, &rdev->mc);
         radeon_update_bandwidth_info(rdev);
 
diff --git a/drivers/hid/hid-cando.c b/drivers/hid/hid-cando.c
index 4267a6fdc277..5925bdcd417d 100644
--- a/drivers/hid/hid-cando.c
+++ b/drivers/hid/hid-cando.c
@@ -237,6 +237,8 @@ static const struct hid_device_id cando_devices[] = {
                         USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
                         USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
         { }
 };
 MODULE_DEVICE_TABLE(hid, cando_devices);
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 3f7292486024..a0dea3d1296e 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1292,6 +1292,7 @@ static const struct hid_device_id hid_blacklist[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE_2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CANDO, USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CHERRY, USB_DEVICE_ID_CHERRY_CYMOTION_SOLAR) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_TACTICAL_PAD) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 765a4f53eb5c..c5ae5f1545bd 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -134,6 +134,7 @@
 #define USB_VENDOR_ID_CANDO             0x2087
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH 0x0a01
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
 
 #define USB_VENDOR_ID_CH                0x068e
 #define USB_DEVICE_ID_CH_PRO_PEDALS     0x00f2
@@ -503,6 +504,7 @@
 
 #define USB_VENDOR_ID_TURBOX            0x062a
 #define USB_DEVICE_ID_TURBOX_KEYBOARD   0x0201
+#define USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART 0x7100
 
 #define USB_VENDOR_ID_TWINHAN           0x6253
 #define USB_DEVICE_ID_TWINHAN_IR_REMOTE 0x0100
diff --git a/drivers/hid/hidraw.c b/drivers/hid/hidraw.c
index 47d70c523d93..a3866b5c0c43 100644
--- a/drivers/hid/hidraw.c
+++ b/drivers/hid/hidraw.c
@@ -109,6 +109,12 @@ static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t
         int ret = 0;
 
         mutex_lock(&minors_lock);
+
+        if (!hidraw_table[minor]) {
+                ret = -ENODEV;
+                goto out;
+        }
+
         dev = hidraw_table[minor]->hid;
 
         if (!dev->hid_output_raw_report) {
@@ -244,6 +250,10 @@ static long hidraw_ioctl(struct file *file, unsigned int cmd,
 
         mutex_lock(&minors_lock);
         dev = hidraw_table[minor];
+        if (!dev) {
+                ret = -ENODEV;
+                goto out;
+        }
 
         switch (cmd) {
                 case HIDIOCGRDESCSIZE:
@@ -317,6 +327,7 @@ static long hidraw_ioctl(struct file *file, unsigned int cmd,
 
                 ret = -ENOTTY;
         }
+out:
         mutex_unlock(&minors_lock);
         return ret;
 }
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 70da3181c8a0..f0260c699adb 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -36,6 +36,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_DWAV, USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER, HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_MOJO, USB_DEVICE_ID_RETRO_ADAPTER, HID_QUIRK_MULTI_INPUT },
+        { USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_DRIVING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FLYING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_HAPP, USB_DEVICE_ID_UGCI_FIGHTING, HID_QUIRK_BADPAD | HID_QUIRK_MULTI_INPUT },
diff --git a/drivers/i2c/busses/i2c-davinci.c b/drivers/i2c/busses/i2c-davinci.c
index b8feac5f2ef4..5795c8398c7c 100644
--- a/drivers/i2c/busses/i2c-davinci.c
+++ b/drivers/i2c/busses/i2c-davinci.c
@@ -331,21 +331,16 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
         INIT_COMPLETION(dev->cmd_complete);
         dev->cmd_err = 0;
 
-        /* Take I2C out of reset, configure it as master and set the
-         * start bit */
-        flag = DAVINCI_I2C_MDR_IRS | DAVINCI_I2C_MDR_MST | DAVINCI_I2C_MDR_STT;
+        /* Take I2C out of reset and configure it as master */
+        flag = DAVINCI_I2C_MDR_IRS | DAVINCI_I2C_MDR_MST;
 
         /* if the slave address is ten bit address, enable XA bit */
         if (msg->flags & I2C_M_TEN)
                 flag |= DAVINCI_I2C_MDR_XA;
         if (!(msg->flags & I2C_M_RD))
                 flag |= DAVINCI_I2C_MDR_TRX;
-        if (stop)
-                flag |= DAVINCI_I2C_MDR_STP;
-        if (msg->len == 0) {
+        if (msg->len == 0)
                 flag |= DAVINCI_I2C_MDR_RM;
-                flag &= ~DAVINCI_I2C_MDR_STP;
-        }
 
         /* Enable receive or transmit interrupts */
         w = davinci_i2c_read_reg(dev, DAVINCI_I2C_IMR_REG);
@@ -358,17 +353,28 @@ i2c_davinci_xfer_msg(struct i2c_adapter *adap, struct i2c_msg *msg, int stop)
         dev->terminate = 0;
 
         /*
+         * Write mode register first as needed for correct behaviour
+         * on OMAP-L138, but don't set STT yet to avoid a race with XRDY
+         * occuring before we have loaded DXR
+         */
+        davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
+
+        /*
          * First byte should be set here, not after interrupt,
          * because transmit-data-ready interrupt can come before
          * NACK-interrupt during sending of previous message and
          * ICDXR may have wrong data
+         * It also saves us one interrupt, slightly faster
          */
         if ((!(msg->flags & I2C_M_RD)) && dev->buf_len) {
                 davinci_i2c_write_reg(dev, DAVINCI_I2C_DXR_REG, *dev->buf++);
                 dev->buf_len--;
         }
 
-        /* write the data into mode register; start transmitting */
+        /* Set STT to begin transmit now DXR is loaded */
+        flag |= DAVINCI_I2C_MDR_STT;
+        if (stop && msg->len != 0)
+                flag |= DAVINCI_I2C_MDR_STP;
         davinci_i2c_write_reg(dev, DAVINCI_I2C_MDR_REG, flag);
 
         r = wait_for_completion_interruptible_timeout(&dev->cmd_complete,
diff --git a/drivers/i2c/busses/i2c-imx.c b/drivers/i2c/busses/i2c-imx.c
index d1ff9408dc1f..4c2a62b75b5c 100644
--- a/drivers/i2c/busses/i2c-imx.c
+++ b/drivers/i2c/busses/i2c-imx.c
@@ -159,15 +159,9 @@ static int i2c_imx_bus_busy(struct imx_i2c_struct *i2c_imx, int for_busy)
 
 static int i2c_imx_trx_complete(struct imx_i2c_struct *i2c_imx)
 {
-        int result;
-
-        result = wait_event_interruptible_timeout(i2c_imx->queue,
-                i2c_imx->i2csr & I2SR_IIF, HZ / 10);
+        wait_event_timeout(i2c_imx->queue, i2c_imx->i2csr & I2SR_IIF, HZ / 10);
 
-        if (unlikely(result < 0)) {
-                dev_dbg(&i2c_imx->adapter.dev, "<%s> result < 0\n", __func__);
-                return result;
-        } else if (unlikely(!(i2c_imx->i2csr & I2SR_IIF))) {
+        if (unlikely(!(i2c_imx->i2csr & I2SR_IIF))) {
                 dev_dbg(&i2c_imx->adapter.dev, "<%s> Timeout\n", __func__);
                 return -ETIMEDOUT;
         }
@@ -295,7 +289,7 @@ static irqreturn_t i2c_imx_isr(int irq, void *dev_id)
                 i2c_imx->i2csr = temp;
                 temp &= ~I2SR_IIF;
                 writeb(temp, i2c_imx->base + IMX_I2C_I2SR);
-                wake_up_interruptible(&i2c_imx->queue);
+                wake_up(&i2c_imx->queue);
                 return IRQ_HANDLED;
         }
 
diff --git a/drivers/ide/ide-cs.c b/drivers/ide/ide-cs.c
index 2a4cb9c18f01..404843e8611b 100644
--- a/drivers/ide/ide-cs.c
+++ b/drivers/ide/ide-cs.c
@@ -43,7 +43,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/cisreg.h>
@@ -72,17 +71,6 @@ static int ide_config(struct pcmcia_device *);
 
 static void ide_detach(struct pcmcia_device *p_dev);
 
-
-
-
-/*======================================================================
-
-    ide_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int ide_probe(struct pcmcia_device *link)
 {
     ide_info_t *info;
@@ -97,23 +85,12 @@ static int ide_probe(struct pcmcia_device *link)
     info->p_dev = link;
     link->priv = info;
 
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO |
+            CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC;
 
     return ide_config(link);
 } /* ide_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void ide_detach(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
@@ -187,79 +164,31 @@ out_release:
     return NULL;
 }
 
-/*======================================================================
-
-    ide_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ide device available to the system.
-
-======================================================================*/
-
-struct pcmcia_config_check {
-        unsigned long ctl_base;
-        int skip_vcc;
-        int is_kme;
-};
-
-static int pcmcia_check_one_config(struct pcmcia_device *pdev,
-                                   cistpl_cftable_entry_t *cfg,
-                                   cistpl_cftable_entry_t *dflt,
-                                   unsigned int vcc,
-                                   void *priv_data)
+static int pcmcia_check_one_config(struct pcmcia_device *pdev, void *priv_data)
 {
-        struct pcmcia_config_check *stk = priv_data;
-
-        /* Check for matching Vcc, unless we're desperate */
-        if (!stk->skip_vcc) {
-                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
-                                return -ENODEV;
-                }
-        }
+        int *is_kme = priv_data;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                pdev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                pdev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-
-                pdev->conf.ConfigIndex = cfg->index;
-                pdev->resource[0]->start = io->win[0].base;
-                if (!(io->flags & CISTPL_IO_16BIT)) {
-                        pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                        pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                }
-                if (io->nwin == 2) {
-                        pdev->resource[0]->end = 8;
-                        pdev->resource[1]->start = io->win[1].base;
-                        pdev->resource[1]->end = (stk->is_kme) ? 2 : 1;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[1]->start;
-                } else if ((io->nwin == 1) && (io->win[0].len >= 16)) {
-                        pdev->resource[0]->end = io->win[0].len;
-                        pdev->resource[1]->end = 0;
-                        if (pcmcia_request_io(pdev) != 0)
-                                return -ENODEV;
-                        stk->ctl_base = pdev->resource[0]->start + 0x0e;
-                } else
+        if (!(pdev->resource[0]->flags & IO_DATA_PATH_WIDTH_8)) {
+                pdev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                pdev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+        }
+        pdev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        pdev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        if (pdev->resource[1]->end) {
+                pdev->resource[0]->end = 8;
+                pdev->resource[1]->end = (*is_kme) ? 2 : 1;
+        } else {
+                if (pdev->resource[0]->end < 16)
                         return -ENODEV;
-                /* If we've got this far, we're done */
-                return 0;
         }
-        return -ENODEV;
+
+        return pcmcia_request_io(pdev);
 }
 
 static int ide_config(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
-    struct pcmcia_config_check *stk = NULL;
     int ret = 0, is_kme = 0;
     unsigned long io_base, ctl_base;
     struct ide_host *host;
@@ -270,23 +199,21 @@ static int ide_config(struct pcmcia_device *link)
               ((link->card_id == PRODID_KME_KXLC005_A) ||
                (link->card_id == PRODID_KME_KXLC005_B)));
 
-    stk = kzalloc(sizeof(*stk), GFP_KERNEL);
-    if (!stk)
-            goto err_mem;
-    stk->is_kme = is_kme;
-    stk->skip_vcc = io_base = ctl_base = 0;
-
-    if (pcmcia_loop_config(link, pcmcia_check_one_config, stk)) {
-            stk->skip_vcc = 1;
-            if (pcmcia_loop_config(link, pcmcia_check_one_config, stk))
+    if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme)) {
+            link->config_flags &= ~CONF_AUTO_CHECK_VCC;
+            if (pcmcia_loop_config(link, pcmcia_check_one_config, &is_kme))
                     goto failed; /* No suitable config found */
     }
     io_base = link->resource[0]->start;
-    ctl_base = stk->ctl_base;
+    if (link->resource[1]->end)
+            ctl_base = link->resource[1]->start;
+    else
+            ctl_base = link->resource[0]->start + 0x0e;
 
     if (!link->irq)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -311,29 +238,15 @@ static int ide_config(struct pcmcia_device *link)
     info->host = host;
     dev_info(&link->dev, "ide-cs: hd%c: Vpp = %d.%d\n",
             'a' + host->ports[0]->index * 2,
-            link->conf.Vpp / 10, link->conf.Vpp % 10);
+            link->vpp / 10, link->vpp % 10);
 
-    kfree(stk);
     return 0;
 
-err_mem:
-    printk(KERN_NOTICE "ide-cs: ide_config failed memory allocation\n");
-    goto failed;
-
 failed:
-    kfree(stk);
     ide_release(link);
     return -ENODEV;
 } /* ide_config */
 
-/*======================================================================
-
-    After a card is removed, ide_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void ide_release(struct pcmcia_device *link)
 {
     ide_info_t *info = link->priv;
@@ -359,15 +272,6 @@ static void ide_release(struct pcmcia_device *link)
 } /* ide_release */
 
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.  A CARD_REMOVAL event
-    also sets some flags to discourage the ide drivers from
-    talking to the ports.
-
-======================================================================*/
-
 static struct pcmcia_device_id ide_ids[] = {
         PCMCIA_DEVICE_FUNC_ID(4),
         PCMCIA_DEVICE_MANF_CARD(0x0000, 0x0000),        /* Corsair */
@@ -440,9 +344,7 @@ MODULE_DEVICE_TABLE(pcmcia, ide_ids);
 
 static struct pcmcia_driver ide_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "ide-cs",
-        },
+        .name           = "ide-cs",
         .probe          = ide_probe,
         .remove         = ide_detach,
         .id_table       = ide_ids,
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index 0906fc5b69b9..cb3ccf3ed221 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -59,18 +59,11 @@
 #include <linux/hrtimer.h>      /* ktime_get_real() */
 #include <trace/events/power.h>
 #include <linux/sched.h>
+#include <asm/mwait.h>
 
 #define INTEL_IDLE_VERSION "0.4"
 #define PREFIX "intel_idle: "
 
-#define MWAIT_SUBSTATE_MASK     (0xf)
-#define MWAIT_CSTATE_MASK       (0xf)
-#define MWAIT_SUBSTATE_SIZE     (4)
-#define MWAIT_MAX_NUM_CSTATES   8
-#define CPUID_MWAIT_LEAF (5)
-#define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
-#define CPUID5_ECX_INTERRUPT_BREAK      (0x2)
-
 static struct cpuidle_driver intel_idle_driver = {
         .name = "intel_idle",
         .owner = THIS_MODULE,
@@ -157,13 +150,13 @@ static struct cpuidle_state atom_cstates[MWAIT_MAX_NUM_CSTATES] = {
         { /* MWAIT C5 */ },
         { /* MWAIT C6 */
                 .name = "ATM-C6",
-                .desc = "MWAIT 0x40",
-                .driver_data = (void *) 0x40,
+                .desc = "MWAIT 0x52",
+                .driver_data = (void *) 0x52,
                 .flags = CPUIDLE_FLAG_TIME_VALID | CPUIDLE_FLAG_TLB_FLUSHED,
-                .exit_latency = 200,
+                .exit_latency = 140,
                 .power_usage = 150,
-                .target_residency = 800,
-                .enter = NULL },        /* disabled */
+                .target_residency = 560,
+                .enter = &intel_idle },
 };
 
 /**
diff --git a/drivers/input/evdev.c b/drivers/input/evdev.c
index c908c5f83645..af9ee313c10b 100644
--- a/drivers/input/evdev.c
+++ b/drivers/input/evdev.c
@@ -28,7 +28,7 @@ struct evdev {
         int minor;
         struct input_handle handle;
         wait_queue_head_t wait;
-        struct evdev_client *grab;
+        struct evdev_client __rcu *grab;
         struct list_head client_list;
         spinlock_t client_lock; /* protects client_list */
         struct mutex mutex;
@@ -669,6 +669,9 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
 
                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCGABS(0))) {
 
+                        if (!dev->absinfo)
+                                return -EINVAL;
+
                         t = _IOC_NR(cmd) & ABS_MAX;
                         abs = dev->absinfo[t];
 
@@ -680,10 +683,13 @@ static long evdev_do_ioctl(struct file *file, unsigned int cmd,
                 }
         }
 
-        if (_IOC_DIR(cmd) == _IOC_READ) {
+        if (_IOC_DIR(cmd) == _IOC_WRITE) {
 
                 if ((_IOC_NR(cmd) & ~ABS_MAX) == _IOC_NR(EVIOCSABS(0))) {
 
+                        if (!dev->absinfo)
+                                return -EINVAL;
+
                         t = _IOC_NR(cmd) & ABS_MAX;
 
                         if (copy_from_user(&abs, p, min_t(size_t,
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index 9cc488d21490..aa037fec2f86 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -338,7 +338,7 @@ config KEYBOARD_OPENCORES
 
 config KEYBOARD_PXA27x
         tristate "PXA27x/PXA3xx keypad support"
-        depends on PXA27x || PXA3xx
+        depends on PXA27x || PXA3xx || ARCH_MMP
         help
           Enable support for PXA27x/PXA3xx keypad controller.
 
diff --git a/drivers/input/keyboard/pxa27x_keypad.c b/drivers/input/keyboard/pxa27x_keypad.c
index f32404f99189..4b0ec35259a1 100644
--- a/drivers/input/keyboard/pxa27x_keypad.c
+++ b/drivers/input/keyboard/pxa27x_keypad.c
@@ -32,7 +32,7 @@
 #include <asm/mach/map.h>
 
 #include <mach/hardware.h>
-#include <mach/pxa27x_keypad.h>
+#include <plat/pxa27x_keypad.h>
 /*
  * Keypad Controller registers
  */
@@ -330,11 +330,21 @@ static void pxa27x_keypad_scan_direct(struct pxa27x_keypad *keypad)
         keypad->direct_key_state = new_state;
 }
 
+static void clear_wakeup_event(struct pxa27x_keypad *keypad)
+{
+        struct pxa27x_keypad_platform_data *pdata = keypad->pdata;
+
+        if (pdata->clear_wakeup_event)
+                (pdata->clear_wakeup_event)();
+}
+
 static irqreturn_t pxa27x_keypad_irq_handler(int irq, void *dev_id)
 {
         struct pxa27x_keypad *keypad = dev_id;
         unsigned long kpc = keypad_readl(KPC);
 
+        clear_wakeup_event(keypad);
+
         if (kpc & KPC_DI)
                 pxa27x_keypad_scan_direct(keypad);
 
diff --git a/drivers/input/misc/hp_sdc_rtc.c b/drivers/input/misc/hp_sdc_rtc.c
index c19066479057..7e2c12a5b839 100644
--- a/drivers/input/misc/hp_sdc_rtc.c
+++ b/drivers/input/misc/hp_sdc_rtc.c
@@ -104,7 +104,7 @@ static int hp_sdc_rtc_do_read_bbrtc (struct rtc_time *rtctm)
         t.endidx =              91;
         t.seq =                 tseq;
         t.act.semaphore =       &tsem;
-        init_MUTEX_LOCKED(&tsem);
+        sema_init(&tsem, 0);
         
         if (hp_sdc_enqueue_transaction(&t)) return -1;
         
@@ -698,7 +698,7 @@ static int __init hp_sdc_rtc_init(void)
                 return -ENODEV;
 #endif
 
-        init_MUTEX(&i8042tregs);
+        sema_init(&i8042tregs, 1);
 
         if ((ret = hp_sdc_request_timer_irq(&hp_sdc_rtc_isr)))
                 return ret;
diff --git a/drivers/input/serio/hil_mlc.c b/drivers/input/serio/hil_mlc.c
index c92f4edfee7b..e5624d8f1709 100644
--- a/drivers/input/serio/hil_mlc.c
+++ b/drivers/input/serio/hil_mlc.c
@@ -915,15 +915,15 @@ int hil_mlc_register(hil_mlc *mlc)
         mlc->ostarted = 0;
 
         rwlock_init(&mlc->lock);
-        init_MUTEX(&mlc->osem);
+        sema_init(&mlc->osem, 1);
 
-        init_MUTEX(&mlc->isem);
+        sema_init(&mlc->isem, 1);
         mlc->icount = -1;
         mlc->imatch = 0;
 
         mlc->opercnt = 0;
 
-        init_MUTEX_LOCKED(&(mlc->csem));
+        sema_init(&(mlc->csem), 0);
 
         hil_mlc_clear_di_scratch(mlc);
         hil_mlc_clear_di_map(mlc, 0);
diff --git a/drivers/input/serio/hp_sdc.c b/drivers/input/serio/hp_sdc.c
index bcc2d30ec245..8c0b51c31424 100644
--- a/drivers/input/serio/hp_sdc.c
+++ b/drivers/input/serio/hp_sdc.c
@@ -905,7 +905,7 @@ static int __init hp_sdc_init(void)
         ts_sync[1]      = 0x0f;
         ts_sync[2] = ts_sync[3] = ts_sync[4] = ts_sync[5] = 0;
         t_sync.act.semaphore = &s_sync;
-        init_MUTEX_LOCKED(&s_sync);
+        sema_init(&s_sync, 0);
         hp_sdc_enqueue_transaction(&t_sync);
         down(&s_sync); /* Wait for t_sync to complete */
 
@@ -1039,7 +1039,7 @@ static int __init hp_sdc_register(void)
                 return hp_sdc.dev_err;
         }
 
-        init_MUTEX_LOCKED(&tq_init_sem);
+        sema_init(&tq_init_sem, 0);
 
         tq_init.actidx          = 0;
         tq_init.idx             = 1;
diff --git a/drivers/input/tablet/wacom_wac.c b/drivers/input/tablet/wacom_wac.c
index 6e29badb969e..47fd7a041c52 100644
--- a/drivers/input/tablet/wacom_wac.c
+++ b/drivers/input/tablet/wacom_wac.c
@@ -442,8 +442,10 @@ static void wacom_intuos_general(struct wacom_wac *wacom)
         /* general pen packet */
         if ((data[1] & 0xb8) == 0xa0) {
                 t = (data[6] << 2) | ((data[7] >> 6) & 3);
-                if (features->type >= INTUOS4S && features->type <= INTUOS4L)
+                if ((features->type >= INTUOS4S && features->type <= INTUOS4L) ||
+                    features->type == WACOM_21UX2) {
                         t = (t << 1) | (data[1] & 1);
+                }
                 input_report_abs(input, ABS_PRESSURE, t);
                 input_report_abs(input, ABS_TILT_X,
                                 ((data[7] << 1) & 0x7e) | (data[8] >> 7));
diff --git a/drivers/isdn/act2000/act2000.h b/drivers/isdn/act2000/act2000.h
index d4c50512a1ff..88c9423500d8 100644
--- a/drivers/isdn/act2000/act2000.h
+++ b/drivers/isdn/act2000/act2000.h
@@ -141,9 +141,9 @@ typedef struct irq_data_isa {
         __u8            rcvhdr[8];
 } irq_data_isa;
 
-typedef union irq_data {
+typedef union act2000_irq_data {
         irq_data_isa isa;
-} irq_data;
+} act2000_irq_data;
 
 /*
  * Per card driver data
@@ -176,7 +176,7 @@ typedef struct act2000_card {
         char   *status_buf_read;
         char   *status_buf_write;
         char   *status_buf_end;
-        irq_data idat;                  /* Data used for IRQ handler        */
+        act2000_irq_data idat;          /* Data used for IRQ handler        */
         isdn_if interface;              /* Interface to upper layer         */
         char regname[35];               /* Name used for request_region     */
 } act2000_card;
diff --git a/drivers/isdn/hardware/avm/avm_cs.c b/drivers/isdn/hardware/avm/avm_cs.c
index 09b1795516f4..91f06a3ef002 100644
--- a/drivers/isdn/hardware/avm/avm_cs.c
+++ b/drivers/isdn/hardware/avm/avm_cs.c
@@ -20,7 +20,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -39,87 +38,32 @@ MODULE_LICENSE("GPL");
 
 /*====================================================================*/
 
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card insertion
-   and ejection events.  They are invoked from the skeleton event
-   handler.
-*/
-
 static int avmcs_config(struct pcmcia_device *link);
 static void avmcs_release(struct pcmcia_device *link);
-
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void avmcs_detach(struct pcmcia_device *p_dev);
 
-/*======================================================================
-
-    avmcs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-    
-======================================================================*/
-
 static int avmcs_probe(struct pcmcia_device *p_dev)
 {
-
-    /* The io structure describes IO port mapping */
-    p_dev->resource[0]->end = 16;
-    p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-
     /* General socket configuration */
-    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
-    p_dev->conf.IntType = INT_MEMORY_AND_IO;
-    p_dev->conf.ConfigIndex = 1;
-    p_dev->conf.Present = PRESENT_OPTION;
+    p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+    p_dev->config_index = 1;
+    p_dev->config_regs = PRESENT_OPTION;
 
     return avmcs_config(p_dev);
 } /* avmcs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
 
 static void avmcs_detach(struct pcmcia_device *link)
 {
         avmcs_release(link);
 } /* avmcs_detach */
 
-/*======================================================================
-
-    avmcs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-    
-======================================================================*/
-
-static int avmcs_configcheck(struct pcmcia_device *p_dev,
-                             cistpl_cftable_entry_t *cf,
-                             cistpl_cftable_entry_t *dflt,
-                             unsigned int vcc,
-                             void *priv_data)
+static int avmcs_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cf->io.nwin <= 0)
-                return -ENODEV;
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 
-        p_dev->resource[0]->start = cf->io.win[0].base;
-        p_dev->resource[0]->end = cf->io.win[0].len;
         return pcmcia_request_io(p_dev);
 }
 
@@ -150,7 +94,7 @@ static int avmcs_config(struct pcmcia_device *link)
         /*
          * configure the PCMCIA socket
           */
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0) {
             pcmcia_disable_device(link);
             break;
@@ -197,13 +141,6 @@ static int avmcs_config(struct pcmcia_device *link)
 
 } /* avmcs_config */
 
-/*======================================================================
-
-    After a card is removed, avmcs_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-    
-======================================================================*/
 
 static void avmcs_release(struct pcmcia_device *link)
 {
@@ -222,9 +159,7 @@ MODULE_DEVICE_TABLE(pcmcia, avmcs_ids);
 
 static struct pcmcia_driver avmcs_driver = {
         .owner  = THIS_MODULE,
-        .drv    = {
-                .name   = "avm_cs",
-        },
+        .name           = "avm_cs",
         .probe = avmcs_probe,
         .remove = avmcs_detach,
         .id_table = avmcs_ids,
diff --git a/drivers/isdn/hisax/avma1_cs.c b/drivers/isdn/hisax/avma1_cs.c
index 94263c22b874..ac4dd7857cbd 100644
--- a/drivers/isdn/hisax/avma1_cs.c
+++ b/drivers/isdn/hisax/avma1_cs.c
@@ -20,7 +20,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include "hisax_cfg.h"
@@ -40,67 +39,22 @@ module_param(isdnprot, int, 0);
 
 /*====================================================================*/
 
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card insertion
-   and ejection events.  They are invoked from the skeleton event
-   handler.
-*/
-
 static int avma1cs_config(struct pcmcia_device *link) __devinit ;
 static void avma1cs_release(struct pcmcia_device *link);
-
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void avma1cs_detach(struct pcmcia_device *p_dev) __devexit ;
 
-
-/*======================================================================
-
-    avma1cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-    
-======================================================================*/
-
 static int __devinit avma1cs_probe(struct pcmcia_device *p_dev)
 {
     dev_dbg(&p_dev->dev, "avma1cs_attach()\n");
 
-    /* The io structure describes IO port mapping */
-    p_dev->resource[0]->end = 16;
-    p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-    p_dev->resource[1]->end = 16;
-    p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_16;
-
     /* General socket configuration */
-    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
-    p_dev->conf.IntType = INT_MEMORY_AND_IO;
-    p_dev->conf.ConfigIndex = 1;
-    p_dev->conf.Present = PRESENT_OPTION;
+    p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+    p_dev->config_index = 1;
+    p_dev->config_regs = PRESENT_OPTION;
 
     return avma1cs_config(p_dev);
 } /* avma1cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void __devexit avma1cs_detach(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "avma1cs_detach(0x%p)\n", link);
@@ -108,26 +62,13 @@ static void __devexit avma1cs_detach(struct pcmcia_device *link)
         kfree(link->priv);
 } /* avma1cs_detach */
 
-/*======================================================================
-
-    avma1cs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-    
-======================================================================*/
-
-static int avma1cs_configcheck(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cf,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int avma1cs_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cf->io.nwin <= 0)
-                return -ENODEV;
-
-        p_dev->resource[0]->start = cf->io.win[0].base;
-        p_dev->resource[0]->end = cf->io.win[0].len;
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
         p_dev->io_lines = 5;
+
         return pcmcia_request_io(p_dev);
 }
 
@@ -161,7 +102,7 @@ static int __devinit avma1cs_config(struct pcmcia_device *link)
         /*
          * configure the PCMCIA socket
          */
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0) {
             pcmcia_disable_device(link);
             break;
@@ -175,9 +116,6 @@ static int __devinit avma1cs_config(struct pcmcia_device *link)
         return -ENODEV;
     }
 
-    printk(KERN_NOTICE "avma1_cs: checking at i/o %#x, irq %d\n",
-                (unsigned int) link->resource[0]->start, link->irq);
-
     icard.para[0] = link->irq;
     icard.para[1] = link->resource[0]->start;
     icard.protocol = isdnprot;
@@ -196,14 +134,6 @@ static int __devinit avma1cs_config(struct pcmcia_device *link)
     return 0;
 } /* avma1cs_config */
 
-/*======================================================================
-
-    After a card is removed, avma1cs_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-    
-======================================================================*/
-
 static void avma1cs_release(struct pcmcia_device *link)
 {
         unsigned long minor = (unsigned long) link->priv;
@@ -216,7 +146,6 @@ static void avma1cs_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 } /* avma1cs_release */
 
-
 static struct pcmcia_device_id avma1cs_ids[] = {
         PCMCIA_DEVICE_PROD_ID12("AVM", "ISDN A", 0x95d42008, 0xadc9d4bb),
         PCMCIA_DEVICE_PROD_ID12("ISDN", "CARD", 0x8d9761c8, 0x01c5aa7b),
@@ -226,19 +155,15 @@ MODULE_DEVICE_TABLE(pcmcia, avma1cs_ids);
 
 static struct pcmcia_driver avma1cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "avma1_cs",
-        },
+        .name           = "avma1_cs",
         .probe          = avma1cs_probe,
         .remove         = __devexit_p(avma1cs_detach),
         .id_table       = avma1cs_ids,
 };
 
-/*====================================================================*/
-
 static int __init init_avma1_cs(void)
 {
-        return(pcmcia_register_driver(&avma1cs_driver));
+        return pcmcia_register_driver(&avma1cs_driver);
 }
 
 static void __exit exit_avma1_cs(void)
diff --git a/drivers/isdn/hisax/config.c b/drivers/isdn/hisax/config.c
index 6f9afcd5ca4e..b133378d4dc9 100644
--- a/drivers/isdn/hisax/config.c
+++ b/drivers/isdn/hisax/config.c
@@ -801,6 +801,16 @@ static void closecard(int cardnr)
         ll_unload(csta);
 }
 
+static irqreturn_t card_irq(int intno, void *dev_id)
+{
+        struct IsdnCardState *cs = dev_id;
+        irqreturn_t ret = cs->irq_func(intno, cs);
+
+        if (ret == IRQ_HANDLED)
+                cs->irq_cnt++;
+        return ret;
+}
+
 static int init_card(struct IsdnCardState *cs)
 {
         int     irq_cnt, cnt = 3, ret;
@@ -809,10 +819,10 @@ static int init_card(struct IsdnCardState *cs)
                 ret = cs->cardmsg(cs, CARD_INIT, NULL);
                 return(ret);
         }
-        irq_cnt = kstat_irqs(cs->irq);
+        irq_cnt = cs->irq_cnt = 0;
         printk(KERN_INFO "%s: IRQ %d count %d\n", CardType[cs->typ],
                cs->irq, irq_cnt);
-        if (request_irq(cs->irq, cs->irq_func, cs->irq_flags, "HiSax", cs)) {
+        if (request_irq(cs->irq, card_irq, cs->irq_flags, "HiSax", cs)) {
                 printk(KERN_WARNING "HiSax: couldn't get interrupt %d\n",
                        cs->irq);
                 return 1;
@@ -822,8 +832,8 @@ static int init_card(struct IsdnCardState *cs)
                 /* Timeout 10ms */
                 msleep(10);
                 printk(KERN_INFO "%s: IRQ %d count %d\n",
-                       CardType[cs->typ], cs->irq, kstat_irqs(cs->irq));
-                if (kstat_irqs(cs->irq) == irq_cnt) {
+                       CardType[cs->typ], cs->irq, cs->irq_cnt);
+                if (cs->irq_cnt == irq_cnt) {
                         printk(KERN_WARNING
                                "%s: IRQ(%d) getting no interrupts during init %d\n",
                                CardType[cs->typ], cs->irq, 4 - cnt);
diff --git a/drivers/isdn/hisax/elsa_cs.c b/drivers/isdn/hisax/elsa_cs.c
index b3c08aaf41c4..496d477af0f8 100644
--- a/drivers/isdn/hisax/elsa_cs.c
+++ b/drivers/isdn/hisax/elsa_cs.c
@@ -46,7 +46,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -64,26 +63,8 @@ MODULE_LICENSE("Dual MPL/GPL");
 static int protocol = 2;        /* EURO-ISDN Default */
 module_param(protocol, int, 0);
 
-/*====================================================================*/
-
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card insertion
-   and ejection events.  They are invoked from the elsa_cs event
-   handler.
-*/
-
 static int elsa_cs_config(struct pcmcia_device *link) __devinit ;
 static void elsa_cs_release(struct pcmcia_device *link);
-
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void elsa_cs_detach(struct pcmcia_device *p_dev) __devexit;
 
 typedef struct local_info_t {
@@ -92,18 +73,6 @@ typedef struct local_info_t {
     int                 cardnr;
 } local_info_t;
 
-/*======================================================================
-
-    elsa_cs_attach() creates an "instance" of the driver, allocatingx
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int __devinit elsa_cs_probe(struct pcmcia_device *link)
 {
     local_info_t *local;
@@ -119,31 +88,9 @@ static int __devinit elsa_cs_probe(struct pcmcia_device *link)
 
     local->cardnr = -1;
 
-    /*
-      General socket configuration defaults can go here.  In this
-      client, we assume very little, and rely on the CIS for almost
-      everything.  In most clients, many details (i.e., number, sizes,
-      and attributes of IO windows) are fixed by the nature of the
-      device, and can be hard-wired here.
-    */
-    link->resource[0]->end = 8;
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-
     return elsa_cs_config(link);
 } /* elsa_cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void __devexit elsa_cs_detach(struct pcmcia_device *link)
 {
         local_info_t *info = link->priv;
@@ -156,27 +103,17 @@ static void __devexit elsa_cs_detach(struct pcmcia_device *link)
         kfree(info);
 } /* elsa_cs_detach */
 
-/*======================================================================
-
-    elsa_cs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
-static int elsa_cs_configcheck(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cf,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int elsa_cs_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
         int j;
 
         p_dev->io_lines = 3;
+        p_dev->resource[0]->end = 8;
+        p_dev->resource[0]->flags &= IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
-        if ((cf->io.nwin > 0) && cf->io.win[0].base) {
+        if ((p_dev->resource[0]->end) && p_dev->resource[0]->start) {
                 printk(KERN_INFO "(elsa_cs: looks like the 96 model)\n");
-                p_dev->resource[0]->start = cf->io.win[0].base;
                 if (!pcmcia_request_io(p_dev))
                         return 0;
         } else {
@@ -199,6 +136,8 @@ static int __devinit elsa_cs_config(struct pcmcia_device *link)
     dev_dbg(&link->dev, "elsa_config(0x%p)\n", link);
     dev = link->priv;
 
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
     i = pcmcia_loop_config(link, elsa_cs_configcheck, NULL);
     if (i != 0)
         goto failed;
@@ -206,21 +145,10 @@ static int __devinit elsa_cs_config(struct pcmcia_device *link)
     if (!link->irq)
         goto failed;
 
-    i = pcmcia_request_configuration(link, &link->conf);
+    i = pcmcia_enable_device(link);
     if (i != 0)
         goto failed;
 
-    /* Finally, report what we've done */
-    dev_info(&link->dev, "index 0x%02x: ",
-            link->conf.ConfigIndex);
-    if (link->conf.Attributes & CONF_ENABLE_IRQ)
-        printk(", irq %d", link->irq);
-    if (link->resource[0])
-        printk(" & %pR", link->resource[0]);
-    if (link->resource[1])
-        printk(" & %pR", link->resource[1]);
-    printk("\n");
-
     icard.para[0] = link->irq;
     icard.para[1] = link->resource[0]->start;
     icard.protocol = protocol;
@@ -240,14 +168,6 @@ failed:
     return -ENODEV;
 } /* elsa_cs_config */
 
-/*======================================================================
-
-    After a card is removed, elsa_cs_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void elsa_cs_release(struct pcmcia_device *link)
 {
     local_info_t *local = link->priv;
@@ -291,9 +211,7 @@ MODULE_DEVICE_TABLE(pcmcia, elsa_ids);
 
 static struct pcmcia_driver elsa_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "elsa_cs",
-        },
+        .name           = "elsa_cs",
         .probe          = elsa_cs_probe,
         .remove         = __devexit_p(elsa_cs_detach),
         .id_table       = elsa_ids,
diff --git a/drivers/isdn/hisax/hisax.h b/drivers/isdn/hisax/hisax.h
index 832a87855ffb..32ab3924aa73 100644
--- a/drivers/isdn/hisax/hisax.h
+++ b/drivers/isdn/hisax/hisax.h
@@ -959,6 +959,7 @@ struct IsdnCardState {
         u_long          event;
         struct work_struct tqueue;
         struct timer_list dbusytimer;
+        unsigned int    irq_cnt;
 #ifdef ERROR_STATISTIC
         int             err_crc;
         int             err_tx;
diff --git a/drivers/isdn/hisax/sedlbauer_cs.c b/drivers/isdn/hisax/sedlbauer_cs.c
index a024192b672a..360204bc2777 100644
--- a/drivers/isdn/hisax/sedlbauer_cs.c
+++ b/drivers/isdn/hisax/sedlbauer_cs.c
@@ -46,7 +46,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -64,26 +63,9 @@ MODULE_LICENSE("Dual MPL/GPL");
 static int protocol = 2;        /* EURO-ISDN Default */
 module_param(protocol, int, 0);
 
-/*====================================================================*/
-
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card
-   insertion and ejection events.  They are invoked from the sedlbauer
-   event handler. 
-*/
-
 static int sedlbauer_config(struct pcmcia_device *link) __devinit ;
 static void sedlbauer_release(struct pcmcia_device *link);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void sedlbauer_detach(struct pcmcia_device *p_dev) __devexit;
 
 typedef struct local_info_t {
@@ -92,18 +74,6 @@ typedef struct local_info_t {
     int                 cardnr;
 } local_info_t;
 
-/*======================================================================
-
-    sedlbauer_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-    
-======================================================================*/
-
 static int __devinit sedlbauer_probe(struct pcmcia_device *link)
 {
     local_info_t *local;
@@ -118,35 +88,9 @@ static int __devinit sedlbauer_probe(struct pcmcia_device *link)
     local->p_dev = link;
     link->priv = local;
 
-    /*
-      General socket configuration defaults can go here.  In this
-      client, we assume very little, and rely on the CIS for almost
-      everything.  In most clients, many details (i.e., number, sizes,
-      and attributes of IO windows) are fixed by the nature of the
-      device, and can be hard-wired here.
-    */
-
-    /* from old sedl_cs 
-    */
-    /* The io structure describes IO port mapping */
-    link->resource[0]->end = 8;
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-
-    link->conf.Attributes = 0;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-
     return sedlbauer_config(link);
 } /* sedlbauer_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void __devexit sedlbauer_detach(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "sedlbauer_detach(0x%p)\n", link);
@@ -158,70 +102,15 @@ static void __devexit sedlbauer_detach(struct pcmcia_device *link)
         kfree(link->priv);
 } /* sedlbauer_detach */
 
-/*======================================================================
-
-    sedlbauer_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-    
-======================================================================*/
-static int sedlbauer_config_check(struct pcmcia_device *p_dev,
-                                  cistpl_cftable_entry_t *cfg,
-                                  cistpl_cftable_entry_t *dflt,
-                                  unsigned int vcc,
-                                  void *priv_data)
+static int sedlbauer_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
-                        return -ENODEV;
-        } else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
-                        return -ENODEV;
-        }
-
-        if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
-        else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM]/10000;
-
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                                        pcmcia_io_cfg_data_width(io->flags);
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                p_dev->io_lines = 3;
-                if (pcmcia_request_io(p_dev) != 0)
-                        return -ENODEV;
-        }
-
-        return 0;
+        p_dev->io_lines = 3;
+        return pcmcia_request_io(p_dev);
 }
 
-
-
 static int __devinit sedlbauer_config(struct pcmcia_device *link)
 {
     int ret;
@@ -229,44 +118,17 @@ static int __devinit sedlbauer_config(struct pcmcia_device *link)
 
     dev_dbg(&link->dev, "sedlbauer_config(0x%p)\n", link);
 
-    /*
-      In this loop, we scan the CIS for configuration table entries,
-      each of which describes a valid card configuration, including
-      voltage, IO window, memory window, and interrupt settings.
-
-      We make no assumptions about the card to be configured: we use
-      just the information available in the CIS.  In an ideal world,
-      this would work for any PCMCIA card, but it requires a complete
-      and accurate CIS.  In practice, a driver usually "knows" most of
-      these things without consulting the CIS, and most client drivers
-      will only use the CIS to fill in implementation-defined details.
-    */
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_CHECK_VCC |
+            CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
+
     ret = pcmcia_loop_config(link, sedlbauer_config_check, NULL);
     if (ret)
             goto failed;
 
-    /*
-       This actually configures the PCMCIA socket -- setting up
-       the I/O windows and the interrupt mapping, and putting the
-       card and host interface into "Memory and IO" mode.
-    */
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
-    /* Finally, report what we've done */
-    dev_info(&link->dev, "index 0x%02x:",
-           link->conf.ConfigIndex);
-    if (link->conf.Vpp)
-        printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
-    if (link->conf.Attributes & CONF_ENABLE_IRQ)
-        printk(", irq %d", link->irq);
-    if (link->resource[0])
-        printk(" & %pR", link->resource[0]);
-    if (link->resource[1])
-        printk(" & %pR", link->resource[1]);
-    printk("\n");
-
     icard.para[0] = link->irq;
     icard.para[1] = link->resource[0]->start;
     icard.protocol = protocol;
@@ -290,14 +152,6 @@ failed:
 
 } /* sedlbauer_config */
 
-/*======================================================================
-
-    After a card is removed, sedlbauer_release() will unregister the
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-    
-======================================================================*/
-
 static void sedlbauer_release(struct pcmcia_device *link)
 {
     local_info_t *local = link->priv;
@@ -346,9 +200,7 @@ MODULE_DEVICE_TABLE(pcmcia, sedlbauer_ids);
 
 static struct pcmcia_driver sedlbauer_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "sedlbauer_cs",
-        },
+        .name           = "sedlbauer_cs",
         .probe          = sedlbauer_probe,
         .remove         = __devexit_p(sedlbauer_detach),
         .id_table       = sedlbauer_ids,
diff --git a/drivers/isdn/hisax/teles_cs.c b/drivers/isdn/hisax/teles_cs.c
index 7296102ca255..282a4467ef19 100644
--- a/drivers/isdn/hisax/teles_cs.c
+++ b/drivers/isdn/hisax/teles_cs.c
@@ -27,7 +27,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -45,26 +44,8 @@ MODULE_LICENSE("GPL");
 static int protocol = 2;        /* EURO-ISDN Default */
 module_param(protocol, int, 0);
 
-/*====================================================================*/
-
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card insertion
-   and ejection events.  They are invoked from the teles_cs event
-   handler.
-*/
-
 static int teles_cs_config(struct pcmcia_device *link) __devinit ;
 static void teles_cs_release(struct pcmcia_device *link);
-
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void teles_detach(struct pcmcia_device *p_dev) __devexit ;
 
 typedef struct local_info_t {
@@ -73,18 +54,6 @@ typedef struct local_info_t {
     int                 cardnr;
 } local_info_t;
 
-/*======================================================================
-
-    teles_attach() creates an "instance" of the driver, allocatingx
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int __devinit teles_probe(struct pcmcia_device *link)
 {
     local_info_t *local;
@@ -99,31 +68,11 @@ static int __devinit teles_probe(struct pcmcia_device *link)
     local->p_dev = link;
     link->priv = local;
 
-    /*
-      General socket configuration defaults can go here.  In this
-      client, we assume very little, and rely on the CIS for almost
-      everything.  In most clients, many details (i.e., number, sizes,
-      and attributes of IO windows) are fixed by the nature of the
-      device, and can be hard-wired here.
-    */
-    link->resource[0]->end = 96;
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
     return teles_cs_config(link);
 } /* teles_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void __devexit teles_detach(struct pcmcia_device *link)
 {
         local_info_t *info = link->priv;
@@ -136,27 +85,17 @@ static void __devexit teles_detach(struct pcmcia_device *link)
         kfree(info);
 } /* teles_detach */
 
-/*======================================================================
-
-    teles_cs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
-static int teles_cs_configcheck(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cf,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int teles_cs_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
         int j;
 
         p_dev->io_lines = 5;
+        p_dev->resource[0]->end = 96;
+        p_dev->resource[0]->flags &= IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
-        if ((cf->io.nwin > 0) && cf->io.win[0].base) {
+        if ((p_dev->resource[0]->end) && p_dev->resource[0]->start) {
                 printk(KERN_INFO "(teles_cs: looks like the 96 model)\n");
-                p_dev->resource[0]->start = cf->io.win[0].base;
                 if (!pcmcia_request_io(p_dev))
                         return 0;
         } else {
@@ -186,21 +125,10 @@ static int __devinit teles_cs_config(struct pcmcia_device *link)
     if (!link->irq)
         goto cs_failed;
 
-    i = pcmcia_request_configuration(link, &link->conf);
+    i = pcmcia_enable_device(link);
     if (i != 0)
       goto cs_failed;
 
-    /* Finally, report what we've done */
-    dev_info(&link->dev, "index 0x%02x:",
-            link->conf.ConfigIndex);
-    if (link->conf.Attributes & CONF_ENABLE_IRQ)
-            printk(", irq %d", link->irq);
-    if (link->resource[0])
-        printk(" & %pR", link->resource[0]);
-    if (link->resource[1])
-        printk(" & %pR", link->resource[1]);
-    printk("\n");
-
     icard.para[0] = link->irq;
     icard.para[1] = link->resource[0]->start;
     icard.protocol = protocol;
@@ -222,14 +150,6 @@ cs_failed:
     return -ENODEV;
 } /* teles_cs_config */
 
-/*======================================================================
-
-    After a card is removed, teles_cs_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void teles_cs_release(struct pcmcia_device *link)
 {
     local_info_t *local = link->priv;
@@ -273,9 +193,7 @@ MODULE_DEVICE_TABLE(pcmcia, teles_ids);
 
 static struct pcmcia_driver teles_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "teles_cs",
-        },
+        .name           = "teles_cs",
         .probe          = teles_probe,
         .remove         = __devexit_p(teles_detach),
         .id_table       = teles_ids,
diff --git a/drivers/isdn/sc/interrupt.c b/drivers/isdn/sc/interrupt.c
index 485be8b1e1b3..f0225bc0f267 100644
--- a/drivers/isdn/sc/interrupt.c
+++ b/drivers/isdn/sc/interrupt.c
@@ -112,11 +112,19 @@ irqreturn_t interrupt_handler(int dummy, void *card_inst)
                         }
                         else if(callid>=0x0000 && callid<=0x7FFF)
                         {
+                                int len;
+
                                 pr_debug("%s: Got Incoming Call\n",
                                                 sc_adapter[card]->devicename);
-                                strcpy(setup.phone,&(rcvmsg.msg_data.byte_array[4]));
-                                strcpy(setup.eazmsn,
-                                        sc_adapter[card]->channel[rcvmsg.phy_link_no-1].dn);
+                                len = strlcpy(setup.phone, &(rcvmsg.msg_data.byte_array[4]),
+                                                sizeof(setup.phone));
+                                if (len >= sizeof(setup.phone))
+                                        continue;
+                                len = strlcpy(setup.eazmsn,
+                                                sc_adapter[card]->channel[rcvmsg.phy_link_no - 1].dn,
+                                                sizeof(setup.eazmsn));
+                                if (len >= sizeof(setup.eazmsn))
+                                        continue;
                                 setup.si1 = 7;
                                 setup.si2 = 0;
                                 setup.plan = 0;
@@ -176,7 +184,9 @@ irqreturn_t interrupt_handler(int dummy, void *card_inst)
                  * Handle a GetMyNumber Rsp
                  */
                 if (IS_CE_MESSAGE(rcvmsg,Call,0,GetMyNumber)){
-                        strcpy(sc_adapter[card]->channel[rcvmsg.phy_link_no-1].dn,rcvmsg.msg_data.byte_array);
+                        strlcpy(sc_adapter[card]->channel[rcvmsg.phy_link_no - 1].dn,
+                                rcvmsg.msg_data.byte_array,
+                                sizeof(rcvmsg.msg_data.byte_array));
                         continue;
                 }
                         
diff --git a/drivers/leds/Kconfig b/drivers/leds/Kconfig
index e4112622e5a2..cc2a88d5192f 100644
--- a/drivers/leds/Kconfig
+++ b/drivers/leds/Kconfig
@@ -304,13 +304,22 @@ config LEDS_MC13783
 
 config LEDS_NS2
         tristate "LED support for Network Space v2 GPIO LEDs"
-        depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || MACH_NETSPACE_MAX_V2
+        depends on MACH_NETSPACE_V2 || MACH_INETSPACE_V2 || MACH_NETSPACE_MAX_V2 || D2NET_V2
         default y
         help
           This option enable support for the dual-GPIO LED found on the
           Network Space v2 board (and parents). This include Internet Space v2,
           Network Space (Max) v2 and d2 Network v2 boards.
 
+config LEDS_NETXBIG
+        tristate "LED support for Big Network series LEDs"
+        depends on MACH_NET2BIG_V2 || MACH_NET5BIG_V2
+        default y
+        help
+          This option enable support for LEDs found on the LaCie 2Big
+          and 5Big Network v2 boards. The LEDs are wired to a CPLD and are
+          controlled through a GPIO extension bus.
+
 config LEDS_TRIGGERS
         bool "LED Trigger support"
         help
diff --git a/drivers/leds/Makefile b/drivers/leds/Makefile
index 7d6b95831f8e..9c96db40ef6d 100644
--- a/drivers/leds/Makefile
+++ b/drivers/leds/Makefile
@@ -38,6 +38,7 @@ obj-$(CONFIG_LEDS_ADP5520)		+= leds-adp5520.o
 obj-$(CONFIG_LEDS_DELL_NETBOOKS)        += dell-led.o
 obj-$(CONFIG_LEDS_MC13783)              += leds-mc13783.o
 obj-$(CONFIG_LEDS_NS2)                  += leds-ns2.o
+obj-$(CONFIG_LEDS_NETXBIG)              += leds-netxbig.o
 
 # LED SPI Drivers
 obj-$(CONFIG_LEDS_DAC124S085)           += leds-dac124s085.o
diff --git a/drivers/leds/leds-netxbig.c b/drivers/leds/leds-netxbig.c
new file mode 100644
index 000000000000..f2e51c134399
--- /dev/null
+++ b/drivers/leds/leds-netxbig.c
@@ -0,0 +1,449 @@
+/*
+ * leds-netxbig.c - Driver for the 2Big and 5Big Network series LEDs
+ *
+ * Copyright (C) 2010 LaCie
+ *
+ * Author: Simon Guinot <sguinot@lacie.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/irq.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/platform_device.h>
+#include <linux/gpio.h>
+#include <linux/leds.h>
+#include <mach/leds-netxbig.h>
+
+/*
+ * GPIO extension bus.
+ */
+
+static DEFINE_SPINLOCK(gpio_ext_lock);
+
+static void gpio_ext_set_addr(struct netxbig_gpio_ext *gpio_ext, int addr)
+{
+        int pin;
+
+        for (pin = 0; pin < gpio_ext->num_addr; pin++)
+                gpio_set_value(gpio_ext->addr[pin], (addr >> pin) & 1);
+}
+
+static void gpio_ext_set_data(struct netxbig_gpio_ext *gpio_ext, int data)
+{
+        int pin;
+
+        for (pin = 0; pin < gpio_ext->num_data; pin++)
+                gpio_set_value(gpio_ext->data[pin], (data >> pin) & 1);
+}
+
+static void gpio_ext_enable_select(struct netxbig_gpio_ext *gpio_ext)
+{
+        /* Enable select is done on the raising edge. */
+        gpio_set_value(gpio_ext->enable, 0);
+        gpio_set_value(gpio_ext->enable, 1);
+}
+
+static void gpio_ext_set_value(struct netxbig_gpio_ext *gpio_ext,
+                               int addr, int value)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&gpio_ext_lock, flags);
+        gpio_ext_set_addr(gpio_ext, addr);
+        gpio_ext_set_data(gpio_ext, value);
+        gpio_ext_enable_select(gpio_ext);
+        spin_unlock_irqrestore(&gpio_ext_lock, flags);
+}
+
+static int __devinit gpio_ext_init(struct netxbig_gpio_ext *gpio_ext)
+{
+        int err;
+        int i;
+
+        if (unlikely(!gpio_ext))
+                return -EINVAL;
+
+        /* Configure address GPIOs. */
+        for (i = 0; i < gpio_ext->num_addr; i++) {
+                err = gpio_request(gpio_ext->addr[i], "GPIO extension addr");
+                if (err)
+                        goto err_free_addr;
+                err = gpio_direction_output(gpio_ext->addr[i], 0);
+                if (err) {
+                        gpio_free(gpio_ext->addr[i]);
+                        goto err_free_addr;
+                }
+        }
+        /* Configure data GPIOs. */
+        for (i = 0; i < gpio_ext->num_data; i++) {
+                err = gpio_request(gpio_ext->data[i], "GPIO extension data");
+                if (err)
+                        goto err_free_data;
+                err = gpio_direction_output(gpio_ext->data[i], 0);
+                if (err) {
+                        gpio_free(gpio_ext->data[i]);
+                        goto err_free_data;
+                }
+        }
+        /* Configure "enable select" GPIO. */
+        err = gpio_request(gpio_ext->enable, "GPIO extension enable");
+        if (err)
+                goto err_free_data;
+        err = gpio_direction_output(gpio_ext->enable, 0);
+        if (err) {
+                gpio_free(gpio_ext->enable);
+                goto err_free_data;
+        }
+
+        return 0;
+
+err_free_data:
+        for (i = i - 1; i >= 0; i--)
+                gpio_free(gpio_ext->data[i]);
+        i = gpio_ext->num_addr;
+err_free_addr:
+        for (i = i - 1; i >= 0; i--)
+                gpio_free(gpio_ext->addr[i]);
+
+        return err;
+}
+
+static void __devexit gpio_ext_free(struct netxbig_gpio_ext *gpio_ext)
+{
+        int i;
+
+        gpio_free(gpio_ext->enable);
+        for (i = gpio_ext->num_addr - 1; i >= 0; i--)
+                gpio_free(gpio_ext->addr[i]);
+        for (i = gpio_ext->num_data - 1; i >= 0; i--)
+                gpio_free(gpio_ext->data[i]);
+}
+
+/*
+ * Class LED driver.
+ */
+
+struct netxbig_led_data {
+        struct netxbig_gpio_ext *gpio_ext;
+        struct led_classdev     cdev;
+        int                     mode_addr;
+        int                     *mode_val;
+        int                     bright_addr;
+        int                     bright_max;
+        struct                  netxbig_led_timer *timer;
+        int                     num_timer;
+        enum netxbig_led_mode   mode;
+        int                     sata;
+        spinlock_t              lock;
+};
+
+static int netxbig_led_get_timer_mode(enum netxbig_led_mode *mode,
+                                      unsigned long delay_on,
+                                      unsigned long delay_off,
+                                      struct netxbig_led_timer *timer,
+                                      int num_timer)
+{
+        int i;
+
+        for (i = 0; i < num_timer; i++) {
+                if (timer[i].delay_on == delay_on &&
+                    timer[i].delay_off == delay_off) {
+                        *mode = timer[i].mode;
+                        return 0;
+                }
+        }
+        return -EINVAL;
+}
+
+static int netxbig_led_blink_set(struct led_classdev *led_cdev,
+                                 unsigned long *delay_on,
+                                 unsigned long *delay_off)
+{
+        struct netxbig_led_data *led_dat =
+                container_of(led_cdev, struct netxbig_led_data, cdev);
+        enum netxbig_led_mode mode;
+        int mode_val;
+        int ret;
+
+        /* Look for a LED mode with the requested timer frequency. */
+        ret = netxbig_led_get_timer_mode(&mode, *delay_on, *delay_off,
+                                         led_dat->timer, led_dat->num_timer);
+        if (ret < 0)
+                return ret;
+
+        mode_val = led_dat->mode_val[mode];
+        if (mode_val == NETXBIG_LED_INVALID_MODE)
+                return -EINVAL;
+
+        spin_lock_irq(&led_dat->lock);
+
+        gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
+        led_dat->mode = mode;
+
+        spin_unlock_irq(&led_dat->lock);
+
+        return 0;
+}
+
+static void netxbig_led_set(struct led_classdev *led_cdev,
+                            enum led_brightness value)
+{
+        struct netxbig_led_data *led_dat =
+                container_of(led_cdev, struct netxbig_led_data, cdev);
+        enum netxbig_led_mode mode;
+        int mode_val, bright_val;
+        int set_brightness = 1;
+        unsigned long flags;
+
+        spin_lock_irqsave(&led_dat->lock, flags);
+
+        if (value == LED_OFF) {
+                mode = NETXBIG_LED_OFF;
+                set_brightness = 0;
+        } else {
+                if (led_dat->sata)
+                        mode = NETXBIG_LED_SATA;
+                else if (led_dat->mode == NETXBIG_LED_OFF)
+                        mode = NETXBIG_LED_ON;
+                else /* Keep 'timer' mode. */
+                        mode = led_dat->mode;
+        }
+        mode_val = led_dat->mode_val[mode];
+
+        gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
+        led_dat->mode = mode;
+        /*
+         * Note that the brightness register is shared between all the
+         * SATA LEDs. So, change the brightness setting for a single
+         * SATA LED will affect all the others.
+         */
+        if (set_brightness) {
+                bright_val = DIV_ROUND_UP(value * led_dat->bright_max,
+                                          LED_FULL);
+                gpio_ext_set_value(led_dat->gpio_ext,
+                                   led_dat->bright_addr, bright_val);
+        }
+
+        spin_unlock_irqrestore(&led_dat->lock, flags);
+}
+
+static ssize_t netxbig_led_sata_store(struct device *dev,
+                                      struct device_attribute *attr,
+                                      const char *buff, size_t count)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct netxbig_led_data *led_dat =
+                container_of(led_cdev, struct netxbig_led_data, cdev);
+        unsigned long enable;
+        enum netxbig_led_mode mode;
+        int mode_val;
+        int ret;
+
+        ret = strict_strtoul(buff, 10, &enable);
+        if (ret < 0)
+                return ret;
+
+        enable = !!enable;
+
+        spin_lock_irq(&led_dat->lock);
+
+        if (led_dat->sata == enable) {
+                ret = count;
+                goto exit_unlock;
+        }
+
+        if (led_dat->mode != NETXBIG_LED_ON &&
+            led_dat->mode != NETXBIG_LED_SATA)
+                mode = led_dat->mode; /* Keep modes 'off' and 'timer'. */
+        else if (enable)
+                mode = NETXBIG_LED_SATA;
+        else
+                mode = NETXBIG_LED_ON;
+
+        mode_val = led_dat->mode_val[mode];
+        if (mode_val == NETXBIG_LED_INVALID_MODE) {
+                ret = -EINVAL;
+                goto exit_unlock;
+        }
+
+        gpio_ext_set_value(led_dat->gpio_ext, led_dat->mode_addr, mode_val);
+        led_dat->mode = mode;
+        led_dat->sata = enable;
+
+        ret = count;
+
+exit_unlock:
+        spin_unlock_irq(&led_dat->lock);
+
+        return ret;
+}
+
+static ssize_t netxbig_led_sata_show(struct device *dev,
+                                     struct device_attribute *attr, char *buf)
+{
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct netxbig_led_data *led_dat =
+                container_of(led_cdev, struct netxbig_led_data, cdev);
+
+        return sprintf(buf, "%d\n", led_dat->sata);
+}
+
+static DEVICE_ATTR(sata, 0644, netxbig_led_sata_show, netxbig_led_sata_store);
+
+static void __devexit delete_netxbig_led(struct netxbig_led_data *led_dat)
+{
+        if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE)
+                device_remove_file(led_dat->cdev.dev, &dev_attr_sata);
+        led_classdev_unregister(&led_dat->cdev);
+}
+
+static int __devinit
+create_netxbig_led(struct platform_device *pdev,
+                   struct netxbig_led_data *led_dat,
+                   const struct netxbig_led *template)
+{
+        struct netxbig_led_platform_data *pdata = pdev->dev.platform_data;
+        int ret;
+
+        spin_lock_init(&led_dat->lock);
+        led_dat->gpio_ext = pdata->gpio_ext;
+        led_dat->cdev.name = template->name;
+        led_dat->cdev.default_trigger = template->default_trigger;
+        led_dat->cdev.blink_set = netxbig_led_blink_set;
+        led_dat->cdev.brightness_set = netxbig_led_set;
+        /*
+         * Because the GPIO extension bus don't allow to read registers
+         * value, there is no way to probe the LED initial state.
+         * So, the initial sysfs LED value for the "brightness" and "sata"
+         * attributes are inconsistent.
+         *
+         * Note that the initial LED state can't be reconfigured.
+         * The reason is that the LED behaviour must stay uniform during
+         * the whole boot process (bootloader+linux).
+         */
+        led_dat->sata = 0;
+        led_dat->cdev.brightness = LED_OFF;
+        led_dat->cdev.flags |= LED_CORE_SUSPENDRESUME;
+        led_dat->mode_addr = template->mode_addr;
+        led_dat->mode_val = template->mode_val;
+        led_dat->bright_addr = template->bright_addr;
+        led_dat->bright_max = (1 << pdata->gpio_ext->num_data) - 1;
+        led_dat->timer = pdata->timer;
+        led_dat->num_timer = pdata->num_timer;
+
+        ret = led_classdev_register(&pdev->dev, &led_dat->cdev);
+        if (ret < 0)
+                return ret;
+
+        /*
+         * If available, expose the SATA activity blink capability through
+         * a "sata" sysfs attribute.
+         */
+        if (led_dat->mode_val[NETXBIG_LED_SATA] != NETXBIG_LED_INVALID_MODE) {
+                ret = device_create_file(led_dat->cdev.dev, &dev_attr_sata);
+                if (ret)
+                        led_classdev_unregister(&led_dat->cdev);
+        }
+
+        return ret;
+}
+
+static int __devinit netxbig_led_probe(struct platform_device *pdev)
+{
+        struct netxbig_led_platform_data *pdata = pdev->dev.platform_data;
+        struct netxbig_led_data *leds_data;
+        int i;
+        int ret;
+
+        if (!pdata)
+                return -EINVAL;
+
+        leds_data = kzalloc(sizeof(struct netxbig_led_data) * pdata->num_leds,
+                            GFP_KERNEL);
+        if (!leds_data)
+                return -ENOMEM;
+
+        ret = gpio_ext_init(pdata->gpio_ext);
+        if (ret < 0)
+                goto err_free_data;
+
+        for (i = 0; i < pdata->num_leds; i++) {
+                ret = create_netxbig_led(pdev, &leds_data[i], &pdata->leds[i]);
+                if (ret < 0)
+                        goto err_free_leds;
+        }
+
+        platform_set_drvdata(pdev, leds_data);
+
+        return 0;
+
+err_free_leds:
+        for (i = i - 1; i >= 0; i--)
+                delete_netxbig_led(&leds_data[i]);
+
+        gpio_ext_free(pdata->gpio_ext);
+err_free_data:
+        kfree(leds_data);
+
+        return ret;
+}
+
+static int __devexit netxbig_led_remove(struct platform_device *pdev)
+{
+        struct netxbig_led_platform_data *pdata = pdev->dev.platform_data;
+        struct netxbig_led_data *leds_data;
+        int i;
+
+        leds_data = platform_get_drvdata(pdev);
+
+        for (i = 0; i < pdata->num_leds; i++)
+                delete_netxbig_led(&leds_data[i]);
+
+        gpio_ext_free(pdata->gpio_ext);
+        kfree(leds_data);
+
+        return 0;
+}
+
+static struct platform_driver netxbig_led_driver = {
+        .probe          = netxbig_led_probe,
+        .remove         = __devexit_p(netxbig_led_remove),
+        .driver         = {
+                .name   = "leds-netxbig",
+                .owner  = THIS_MODULE,
+        },
+};
+MODULE_ALIAS("platform:leds-netxbig");
+
+static int __init netxbig_led_init(void)
+{
+        return platform_driver_register(&netxbig_led_driver);
+}
+
+static void __exit netxbig_led_exit(void)
+{
+        platform_driver_unregister(&netxbig_led_driver);
+}
+
+module_init(netxbig_led_init);
+module_exit(netxbig_led_exit);
+
+MODULE_AUTHOR("Simon Guinot <sguinot@lacie.com>");
+MODULE_DESCRIPTION("LED driver for LaCie xBig Network boards");
+MODULE_LICENSE("GPL");
diff --git a/drivers/leds/leds-ns2.c b/drivers/leds/leds-ns2.c
index 350eb34f049c..f77d48d0b3e4 100644
--- a/drivers/leds/leds-ns2.c
+++ b/drivers/leds/leds-ns2.c
@@ -141,10 +141,12 @@ static ssize_t ns2_led_sata_store(struct device *dev,
                                   struct device_attribute *attr,
                                   const char *buff, size_t count)
 {
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct ns2_led_data *led_dat =
+                container_of(led_cdev, struct ns2_led_data, cdev);
         int ret;
         unsigned long enable;
         enum ns2_led_modes mode;
-        struct ns2_led_data *led_dat = dev_get_drvdata(dev);
 
         ret = strict_strtoul(buff, 10, &enable);
         if (ret < 0)
@@ -172,7 +174,9 @@ static ssize_t ns2_led_sata_store(struct device *dev,
 static ssize_t ns2_led_sata_show(struct device *dev,
                                  struct device_attribute *attr, char *buf)
 {
-        struct ns2_led_data *led_dat = dev_get_drvdata(dev);
+        struct led_classdev *led_cdev = dev_get_drvdata(dev);
+        struct ns2_led_data *led_dat =
+                container_of(led_cdev, struct ns2_led_data, cdev);
 
         return sprintf(buf, "%d\n", led_dat->sata);
 }
@@ -234,7 +238,6 @@ create_ns2_led(struct platform_device *pdev, struct ns2_led_data *led_dat,
         if (ret < 0)
                 goto err_free_slow;
 
-        dev_set_drvdata(led_dat->cdev.dev, led_dat);
         ret = device_create_file(led_dat->cdev.dev, &dev_attr_sata);
         if (ret < 0)
                 goto err_free_cdev;
diff --git a/drivers/macintosh/adb.c b/drivers/macintosh/adb.c
index 1c4ee6e77937..bf64e49d996a 100644
--- a/drivers/macintosh/adb.c
+++ b/drivers/macintosh/adb.c
@@ -83,7 +83,7 @@ static struct adb_driver *adb_controller;
 BLOCKING_NOTIFIER_HEAD(adb_client_list);
 static int adb_got_sleep;
 static int adb_inited;
-static DECLARE_MUTEX(adb_probe_mutex);
+static DEFINE_SEMAPHORE(adb_probe_mutex);
 static int sleepy_trackpad;
 static int autopoll_devs;
 int __adb_probe_sync;
diff --git a/drivers/media/video/v4l2-compat-ioctl32.c b/drivers/media/video/v4l2-compat-ioctl32.c
index 073f01390cdd..86294ed35c9b 100644
--- a/drivers/media/video/v4l2-compat-ioctl32.c
+++ b/drivers/media/video/v4l2-compat-ioctl32.c
@@ -193,17 +193,24 @@ static int put_video_window32(struct video_window *kp, struct video_window32 __u
 struct video_code32 {
         char            loadwhat[16];   /* name or tag of file being passed */
         compat_int_t    datasize;
-        unsigned char   *data;
+        compat_uptr_t   data;
 };
 
-static int get_microcode32(struct video_code *kp, struct video_code32 __user *up)
+static struct video_code __user *get_microcode32(struct video_code32 *kp)
 {
-        if (!access_ok(VERIFY_READ, up, sizeof(struct video_code32)) ||
-                copy_from_user(kp->loadwhat, up->loadwhat, sizeof(up->loadwhat)) ||
-                get_user(kp->datasize, &up->datasize) ||
-                copy_from_user(kp->data, up->data, up->datasize))
-                        return -EFAULT;
-        return 0;
+        struct video_code __user *up;
+
+        up = compat_alloc_user_space(sizeof(*up));
+
+        /*
+         * NOTE! We don't actually care if these fail. If the
+         * user address is invalid, the native ioctl will do
+         * the error handling for us
+         */
+        (void) copy_to_user(up->loadwhat, kp->loadwhat, sizeof(up->loadwhat));
+        (void) put_user(kp->datasize, &up->datasize);
+        (void) put_user(compat_ptr(kp->data), &up->data);
+        return up;
 }
 
 #define VIDIOCGTUNER32          _IOWR('v', 4, struct video_tuner32)
@@ -739,7 +746,7 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar
                 struct video_tuner vt;
                 struct video_buffer vb;
                 struct video_window vw;
-                struct video_code vc;
+                struct video_code32 vc;
                 struct video_audio va;
 #endif
                 struct v4l2_format v2f;
@@ -818,8 +825,11 @@ static long do_video_ioctl(struct file *file, unsigned int cmd, unsigned long ar
                 break;
 
         case VIDIOCSMICROCODE:
-                err = get_microcode32(&karg.vc, up);
-                compatible_arg = 0;
+                /* Copy the 32-bit "video_code32" to kernel space */
+                if (copy_from_user(&karg.vc, up, sizeof(karg.vc)))
+                        return -EFAULT;
+                /* Convert the 32-bit version to a 64-bit version in user space */
+                up = get_microcode32(&karg.vc);
                 break;
 
         case VIDIOCSFREQ:
diff --git a/drivers/mfd/ab8500-spi.c b/drivers/mfd/ab8500-spi.c
index e1c8b62b086d..01b6d584442c 100644
--- a/drivers/mfd/ab8500-spi.c
+++ b/drivers/mfd/ab8500-spi.c
@@ -83,6 +83,11 @@ static int __devinit ab8500_spi_probe(struct spi_device *spi)
         struct ab8500 *ab8500;
         int ret;
 
+        spi->bits_per_word = 24;
+        ret = spi_setup(spi);
+        if (ret < 0)
+                return ret;
+
         ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
         if (!ab8500)
                 return -ENOMEM;
diff --git a/drivers/mfd/twl4030-irq.c b/drivers/mfd/twl4030-irq.c
index 097f24d8bceb..b9fda7018cef 100644
--- a/drivers/mfd/twl4030-irq.c
+++ b/drivers/mfd/twl4030-irq.c
@@ -78,7 +78,7 @@ struct sih {
         u8      irq_lines;              /* number of supported irq lines */
 
         /* SIR ignored -- set interrupt, for testing only */
-        struct irq_data {
+        struct sih_irq_data {
                 u8      isr_offset;
                 u8      imr_offset;
         } mask[2];
@@ -810,7 +810,7 @@ int twl4030_init_irq(int irq_num, unsigned irq_base, unsigned irq_end)
         twl4030_irq_chip = dummy_irq_chip;
         twl4030_irq_chip.name = "twl4030";
 
-        twl4030_sih_irq_chip.ack = dummy_irq_chip.ack;
+        twl4030_sih_irq_chip.irq_ack = dummy_irq_chip.irq_ack;
 
         for (i = irq_base; i < irq_end; i++) {
                 set_irq_chip_and_handler(i, &twl4030_irq_chip,
diff --git a/drivers/mmc/core/core.c b/drivers/mmc/core/core.c
index 5db49b124ffa..09eee6df0653 100644
--- a/drivers/mmc/core/core.c
+++ b/drivers/mmc/core/core.c
@@ -1631,6 +1631,19 @@ int mmc_suspend_host(struct mmc_host *host)
         if (host->bus_ops && !host->bus_dead) {
                 if (host->bus_ops->suspend)
                         err = host->bus_ops->suspend(host);
+                if (err == -ENOSYS || !host->bus_ops->resume) {
+                        /*
+                         * We simply "remove" the card in this case.
+                         * It will be redetected on resume.
+                         */
+                        if (host->bus_ops->remove)
+                                host->bus_ops->remove(host);
+                        mmc_claim_host(host);
+                        mmc_detach_bus(host);
+                        mmc_release_host(host);
+                        host->pm_flags = 0;
+                        err = 0;
+                }
         }
         mmc_bus_put(host);
 
diff --git a/drivers/mmc/host/mmci.c b/drivers/mmc/host/mmci.c
index 840b301b5671..f2e02d7d9f3d 100644
--- a/drivers/mmc/host/mmci.c
+++ b/drivers/mmc/host/mmci.c
@@ -41,23 +41,35 @@ static unsigned int fmax = 515633;
  * @clkreg: default value for MCICLOCK register
  * @clkreg_enable: enable value for MMCICLOCK register
  * @datalength_bits: number of bits in the MMCIDATALENGTH register
+ * @fifosize: number of bytes that can be written when MMCI_TXFIFOEMPTY
+ *            is asserted (likewise for RX)
+ * @fifohalfsize: number of bytes that can be written when MCI_TXFIFOHALFEMPTY
+ *                is asserted (likewise for RX)
  */
 struct variant_data {
         unsigned int            clkreg;
         unsigned int            clkreg_enable;
         unsigned int            datalength_bits;
+        unsigned int            fifosize;
+        unsigned int            fifohalfsize;
 };
 
 static struct variant_data variant_arm = {
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
         .datalength_bits        = 16,
 };
 
 static struct variant_data variant_u300 = {
+        .fifosize               = 16 * 4,
+        .fifohalfsize           = 8 * 4,
         .clkreg_enable          = 1 << 13, /* HWFCEN */
         .datalength_bits        = 16,
 };
 
 static struct variant_data variant_ux500 = {
+        .fifosize               = 30 * 4,
+        .fifohalfsize           = 8 * 4,
         .clkreg                 = MCI_CLK_ENABLE,
         .clkreg_enable          = 1 << 14, /* HWFCEN */
         .datalength_bits        = 24,
@@ -138,6 +150,7 @@ static void mmci_init_sg(struct mmci_host *host, struct mmc_data *data)
 
 static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
 {
+        struct variant_data *variant = host->variant;
         unsigned int datactrl, timeout, irqmask;
         unsigned long long clks;
         void __iomem *base;
@@ -173,7 +186,7 @@ static void mmci_start_data(struct mmci_host *host, struct mmc_data *data)
                  * If we have less than a FIFOSIZE of bytes to transfer,
                  * trigger a PIO interrupt as soon as any data is available.
                  */
-                if (host->size < MCI_FIFOSIZE)
+                if (host->size < variant->fifosize)
                         irqmask |= MCI_RXDATAAVLBLMASK;
         } else {
                 /*
@@ -332,13 +345,15 @@ static int mmci_pio_read(struct mmci_host *host, char *buffer, unsigned int rema
 
 static int mmci_pio_write(struct mmci_host *host, char *buffer, unsigned int remain, u32 status)
 {
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         char *ptr = buffer;
 
         do {
                 unsigned int count, maxcnt;
 
-                maxcnt = status & MCI_TXFIFOEMPTY ? MCI_FIFOSIZE : MCI_FIFOHALFSIZE;
+                maxcnt = status & MCI_TXFIFOEMPTY ?
+                         variant->fifosize : variant->fifohalfsize;
                 count = min(remain, maxcnt);
 
                 writesl(base + MMCIFIFO, ptr, count >> 2);
@@ -362,6 +377,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
 {
         struct mmci_host *host = dev_id;
         struct sg_mapping_iter *sg_miter = &host->sg_miter;
+        struct variant_data *variant = host->variant;
         void __iomem *base = host->base;
         unsigned long flags;
         u32 status;
@@ -420,7 +436,7 @@ static irqreturn_t mmci_pio_irq(int irq, void *dev_id)
          * If we're nearing the end of the read, switch to
          * "any data available" mode.
          */
-        if (status & MCI_RXACTIVE && host->size < MCI_FIFOSIZE)
+        if (status & MCI_RXACTIVE && host->size < variant->fifosize)
                 writel(MCI_RXDATAAVLBLMASK, base + MMCIMASK1);
 
         /*
@@ -564,18 +580,23 @@ static int mmci_get_ro(struct mmc_host *mmc)
         if (host->gpio_wp == -ENOSYS)
                 return -ENOSYS;
 
-        return gpio_get_value(host->gpio_wp);
+        return gpio_get_value_cansleep(host->gpio_wp);
 }
 
 static int mmci_get_cd(struct mmc_host *mmc)
 {
         struct mmci_host *host = mmc_priv(mmc);
+        struct mmci_platform_data *plat = host->plat;
         unsigned int status;
 
-        if (host->gpio_cd == -ENOSYS)
-                status = host->plat->status(mmc_dev(host->mmc));
-        else
-                status = !gpio_get_value(host->gpio_cd);
+        if (host->gpio_cd == -ENOSYS) {
+                if (!plat->status)
+                        return 1; /* Assume always present */
+
+                status = plat->status(mmc_dev(host->mmc));
+        } else
+                status = !!gpio_get_value_cansleep(host->gpio_cd)
+                        ^ plat->cd_invert;
 
         /*
          * Use positive logic throughout - status is zero for no card,
@@ -584,6 +605,15 @@ static int mmci_get_cd(struct mmc_host *mmc)
         return status;
 }
 
+static irqreturn_t mmci_cd_irq(int irq, void *dev_id)
+{
+        struct mmci_host *host = dev_id;
+
+        mmc_detect_change(host->mmc, msecs_to_jiffies(500));
+
+        return IRQ_HANDLED;
+}
+
 static const struct mmc_host_ops mmci_ops = {
         .request        = mmci_request,
         .set_ios        = mmci_set_ios,
@@ -620,6 +650,7 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
 
         host->gpio_wp = -ENOSYS;
         host->gpio_cd = -ENOSYS;
+        host->gpio_cd_irq = -1;
 
         host->hw_designer = amba_manf(dev);
         host->hw_revision = amba_rev(dev);
@@ -699,7 +730,6 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->vcc == NULL)
                 mmc->ocr_avail = plat->ocr_mask;
         mmc->caps = plat->capabilities;
-        mmc->caps |= MMC_CAP_NEEDS_POLL;
 
         /*
          * We can do SGIO
@@ -744,6 +774,12 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         host->gpio_cd = plat->gpio_cd;
                 else if (ret != -ENOSYS)
                         goto err_gpio_cd;
+
+                ret = request_any_context_irq(gpio_to_irq(plat->gpio_cd),
+                                              mmci_cd_irq, 0,
+                                              DRIVER_NAME " (cd)", host);
+                if (ret >= 0)
+                        host->gpio_cd_irq = gpio_to_irq(plat->gpio_cd);
         }
         if (gpio_is_valid(plat->gpio_wp)) {
                 ret = gpio_request(plat->gpio_wp, DRIVER_NAME " (wp)");
@@ -755,6 +791,10 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
                         goto err_gpio_wp;
         }
 
+        if ((host->plat->status || host->gpio_cd != -ENOSYS)
+            && host->gpio_cd_irq < 0)
+                mmc->caps |= MMC_CAP_NEEDS_POLL;
+
         ret = request_irq(dev->irq[0], mmci_irq, IRQF_SHARED, DRIVER_NAME " (cmd)", host);
         if (ret)
                 goto unmap;
@@ -781,6 +821,8 @@ static int __devinit mmci_probe(struct amba_device *dev, struct amba_id *id)
         if (host->gpio_wp != -ENOSYS)
                 gpio_free(host->gpio_wp);
  err_gpio_wp:
+        if (host->gpio_cd_irq >= 0)
+                free_irq(host->gpio_cd_irq, host);
         if (host->gpio_cd != -ENOSYS)
                 gpio_free(host->gpio_cd);
  err_gpio_cd:
@@ -819,6 +861,8 @@ static int __devexit mmci_remove(struct amba_device *dev)
 
                 if (host->gpio_wp != -ENOSYS)
                         gpio_free(host->gpio_wp);
+                if (host->gpio_cd_irq >= 0)
+                        free_irq(host->gpio_cd_irq, host);
                 if (host->gpio_cd != -ENOSYS)
                         gpio_free(host->gpio_cd);
 
diff --git a/drivers/mmc/host/mmci.h b/drivers/mmc/host/mmci.h
index 68970cfb81e1..4ae887fc0189 100644
--- a/drivers/mmc/host/mmci.h
+++ b/drivers/mmc/host/mmci.h
@@ -54,10 +54,16 @@
 #define MCI_DPSM_MODE           (1 << 2)
 #define MCI_DPSM_DMAENABLE      (1 << 3)
 #define MCI_DPSM_BLOCKSIZE      (1 << 4)
-#define MCI_DPSM_RWSTART        (1 << 8)
-#define MCI_DPSM_RWSTOP         (1 << 9)
-#define MCI_DPSM_RWMOD          (1 << 10)
-#define MCI_DPSM_SDIOEN         (1 << 11)
+/* Control register extensions in the ST Micro U300 and Ux500 versions */
+#define MCI_ST_DPSM_RWSTART     (1 << 8)
+#define MCI_ST_DPSM_RWSTOP      (1 << 9)
+#define MCI_ST_DPSM_RWMOD       (1 << 10)
+#define MCI_ST_DPSM_SDIOEN      (1 << 11)
+/* Control register extensions in the ST Micro Ux500 versions */
+#define MCI_ST_DPSM_DMAREQCTL   (1 << 12)
+#define MCI_ST_DPSM_DBOOTMODEEN (1 << 13)
+#define MCI_ST_DPSM_BUSYMODE    (1 << 14)
+#define MCI_ST_DPSM_DDRMODE     (1 << 15)
 
 #define MMCIDATACNT             0x030
 #define MMCISTATUS              0x034
@@ -133,13 +139,6 @@
         MCI_DATATIMEOUTMASK|MCI_TXUNDERRUNMASK|MCI_RXOVERRUNMASK|       \
         MCI_CMDRESPENDMASK|MCI_CMDSENTMASK|MCI_DATABLOCKENDMASK)
 
-/*
- * The size of the FIFO in bytes.
- */
-#define MCI_FIFOSIZE    (16*4)
-        
-#define MCI_FIFOHALFSIZE (MCI_FIFOSIZE / 2)
-
 #define NR_SG           16
 
 struct clk;
@@ -154,6 +153,7 @@ struct mmci_host {
         struct clk              *clk;
         int                     gpio_cd;
         int                     gpio_wp;
+        int                     gpio_cd_irq;
 
         unsigned int            data_xfered;
 
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index 7aa65bb2af4a..f472c2714eb8 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -30,7 +30,6 @@
 #include <linux/ioport.h>
 #include <linux/scatterlist.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <linux/io.h>
@@ -536,9 +535,7 @@ static int sdricoh_pcmcia_resume(struct pcmcia_device *link)
 #endif
 
 static struct pcmcia_driver sdricoh_driver = {
-        .drv = {
-                .name = DRIVER_NAME,
-                },
+        .name = DRIVER_NAME,
         .probe = sdricoh_pcmcia_probe,
         .remove = sdricoh_pcmcia_detach,
         .id_table = pcmcia_ids,
diff --git a/drivers/mtd/maps/pcmciamtd.c b/drivers/mtd/maps/pcmciamtd.c
index e9ca5ba7d9d2..57a1acfe22c4 100644
--- a/drivers/mtd/maps/pcmciamtd.c
+++ b/drivers/mtd/maps/pcmciamtd.c
@@ -16,7 +16,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -101,7 +100,7 @@ MODULE_PARM_DESC(mem_type, "Set Memory type (0=Flash, 1=RAM, 2=ROM, default=0)")
 static caddr_t remap_window(struct map_info *map, unsigned long to)
 {
         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
-        window_handle_t win = (window_handle_t)map->map_priv_2;
+        struct resource *win = (struct resource *) map->map_priv_2;
         unsigned int offset;
         int ret;
 
@@ -316,30 +315,19 @@ static void pcmciamtd_set_vpp(struct map_info *map, int on)
 {
         struct pcmciamtd_dev *dev = (struct pcmciamtd_dev *)map->map_priv_1;
         struct pcmcia_device *link = dev->p_dev;
-        modconf_t mod;
-        int ret;
-
-        mod.Attributes = CONF_VPP1_CHANGE_VALID | CONF_VPP2_CHANGE_VALID;
-        mod.Vcc = 0;
-        mod.Vpp1 = mod.Vpp2 = on ? dev->vpp : 0;
 
         DEBUG(2, "dev = %p on = %d vpp = %d\n", dev, on, dev->vpp);
-        ret = pcmcia_modify_configuration(link, &mod);
+        pcmcia_fixup_vpp(link, on ? dev->vpp : 0);
 }
 
 
-/* After a card is removed, pcmciamtd_release() will unregister the
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
-
 static void pcmciamtd_release(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev = link->priv;
 
         DEBUG(3, "link = 0x%p", link);
 
-        if (link->win) {
+        if (link->resource[2]->end) {
                 if(dev->win_base) {
                         iounmap(dev->win_base);
                         dev->win_base = NULL;
@@ -482,18 +470,12 @@ static void card_settings(struct pcmciamtd_dev *dev, struct pcmcia_device *p_dev
 }
 
 
-/* pcmciamtd_config() is scheduled to run after a CARD_INSERTION event
- * is received, to configure the PCMCIA socket, and to make the
- * MTD device available to the system.
- */
-
 static int pcmciamtd_config(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev = link->priv;
         struct mtd_info *mtd = NULL;
-        win_req_t req;
         int ret;
-        int i;
+        int i, j = 0;
         static char *probes[] = { "jedec_probe", "cfi_probe" };
         int new_name = 0;
 
@@ -520,28 +502,34 @@ static int pcmciamtd_config(struct pcmcia_device *link)
          * smaller windows until we succeed
          */
 
-        req.Attributes =  WIN_MEMORY_TYPE_CM | WIN_ENABLE;
-        req.Attributes |= (dev->pcmcia_map.bankwidth == 1) ? WIN_DATA_WIDTH_8 : WIN_DATA_WIDTH_16;
-        req.Base = 0;
-        req.AccessSpeed = mem_speed;
-        link->win = (window_handle_t)link;
-        req.Size = (force_size) ? force_size << 20 : MAX_PCMCIA_ADDR;
+        link->resource[2]->flags |=  WIN_MEMORY_TYPE_CM | WIN_ENABLE;
+        link->resource[2]->flags |= (dev->pcmcia_map.bankwidth == 1) ?
+                                        WIN_DATA_WIDTH_8 : WIN_DATA_WIDTH_16;
+        link->resource[2]->start = 0;
+        link->resource[2]->end = (force_size) ? force_size << 20 :
+                                        MAX_PCMCIA_ADDR;
         dev->win_size = 0;
 
         do {
                 int ret;
-                DEBUG(2, "requesting window with size = %dKiB memspeed = %d",
-                      req.Size >> 10, req.AccessSpeed);
-                ret = pcmcia_request_window(link, &req, &link->win);
+                DEBUG(2, "requesting window with size = %luKiB memspeed = %d",
+                        (unsigned long) resource_size(link->resource[2]) >> 10,
+                        mem_speed);
+                ret = pcmcia_request_window(link, link->resource[2], mem_speed);
                 DEBUG(2, "ret = %d dev->win_size = %d", ret, dev->win_size);
                 if(ret) {
-                        req.Size >>= 1;
+                        j++;
+                        link->resource[2]->start = 0;
+                        link->resource[2]->end = (force_size) ?
+                                        force_size << 20 : MAX_PCMCIA_ADDR;
+                        link->resource[2]->end >>= j;
                 } else {
-                        DEBUG(2, "Got window of size %dKiB", req.Size >> 10);
-                        dev->win_size = req.Size;
+                        DEBUG(2, "Got window of size %luKiB", (unsigned long)
+                                resource_size(link->resource[2]) >> 10);
+                        dev->win_size = resource_size(link->resource[2]);
                         break;
                 }
-        } while(req.Size >= 0x1000);
+        } while (link->resource[2]->end >= 0x1000);
 
         DEBUG(2, "dev->win_size = %d", dev->win_size);
 
@@ -553,33 +541,31 @@ static int pcmciamtd_config(struct pcmcia_device *link)
         DEBUG(1, "Allocated a window of %dKiB", dev->win_size >> 10);
 
         /* Get write protect status */
-        DEBUG(2, "window handle = 0x%8.8lx", (unsigned long)link->win);
-        dev->win_base = ioremap(req.Base, req.Size);
+        dev->win_base = ioremap(link->resource[2]->start,
+                                resource_size(link->resource[2]));
         if(!dev->win_base) {
-                dev_err(&dev->p_dev->dev, "ioremap(%lu, %u) failed\n",
-                        req.Base, req.Size);
+                dev_err(&dev->p_dev->dev, "ioremap(%pR) failed\n",
+                        link->resource[2]);
                 pcmciamtd_release(link);
                 return -ENODEV;
         }
-        DEBUG(1, "mapped window dev = %p req.base = 0x%lx base = %p size = 0x%x",
-              dev, req.Base, dev->win_base, req.Size);
+        DEBUG(1, "mapped window dev = %p @ %pR, base = %p",
+              dev, link->resource[2], dev->win_base);
 
         dev->offset = 0;
         dev->pcmcia_map.map_priv_1 = (unsigned long)dev;
-        dev->pcmcia_map.map_priv_2 = (unsigned long)link->win;
+        dev->pcmcia_map.map_priv_2 = (unsigned long)link->resource[2];
 
         dev->vpp = (vpp) ? vpp : link->socket->socket.Vpp;
-        link->conf.Attributes = 0;
         if(setvpp == 2) {
-                link->conf.Vpp = dev->vpp;
+                link->vpp = dev->vpp;
         } else {
-                link->conf.Vpp = 0;
+                link->vpp = 0;
         }
 
-        link->conf.IntType = INT_MEMORY;
-        link->conf.ConfigIndex = 0;
+        link->config_index = 0;
         DEBUG(2, "Setting Configuration");
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret != 0) {
                 if (dev->win_base) {
                         iounmap(dev->win_base);
@@ -680,12 +666,6 @@ static int pcmciamtd_resume(struct pcmcia_device *dev)
 }
 
 
-/* This deletes a driver "instance".  The device is de-registered
- * with Card Services.  If it has been released, all local data
- * structures are freed.  Otherwise, the structures will be freed
- * when the device is released.
- */
-
 static void pcmciamtd_detach(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev = link->priv;
@@ -703,11 +683,6 @@ static void pcmciamtd_detach(struct pcmcia_device *link)
 }
 
 
-/* pcmciamtd_attach() creates an "instance" of the driver, allocating
- * local data structures for one device.  The device is registered
- * with Card Services.
- */
-
 static int pcmciamtd_probe(struct pcmcia_device *link)
 {
         struct pcmciamtd_dev *dev;
@@ -720,9 +695,6 @@ static int pcmciamtd_probe(struct pcmcia_device *link)
         dev->p_dev = link;
         link->priv = dev;
 
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY;
-
         return pcmciamtd_config(link);
 }
 
@@ -757,9 +729,7 @@ static struct pcmcia_device_id pcmciamtd_ids[] = {
 MODULE_DEVICE_TABLE(pcmcia, pcmciamtd_ids);
 
 static struct pcmcia_driver pcmciamtd_driver = {
-        .drv            = {
-                .name   = "pcmciamtd"
-        },
+        .name           = "pcmciamtd",
         .probe          = pcmciamtd_probe,
         .remove         = pcmciamtd_detach,
         .owner          = THIS_MODULE,
@@ -771,8 +741,6 @@ static struct pcmcia_driver pcmciamtd_driver = {
 
 static int __init init_pcmciamtd(void)
 {
-        info(DRIVER_DESC);
-
         if(bankwidth && bankwidth != 1 && bankwidth != 2) {
                 info("bad bankwidth (%d), using default", bankwidth);
                 bankwidth = 2;
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index b2828e84d243..214b03afdd48 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -30,6 +30,8 @@
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/io.h>
+#include <linux/irq.h>
+#include <linux/completion.h>
 
 #include <asm/mach/flash.h>
 #include <mach/mxc_nand.h>
@@ -151,7 +153,7 @@ struct mxc_nand_host {
         int                     irq;
         int                     eccsize;
 
-        wait_queue_head_t       irq_waitq;
+        struct completion       op_completion;
 
         uint8_t                 *data_buf;
         unsigned int            buf_start;
@@ -164,6 +166,7 @@ struct mxc_nand_host {
         void                    (*send_read_id)(struct mxc_nand_host *);
         uint16_t                (*get_dev_status)(struct mxc_nand_host *);
         int                     (*check_int)(struct mxc_nand_host *);
+        void                    (*irq_control)(struct mxc_nand_host *, int);
 };
 
 /* OOB placement block for use with hardware ecc generation */
@@ -216,9 +219,12 @@ static irqreturn_t mxc_nfc_irq(int irq, void *dev_id)
 {
         struct mxc_nand_host *host = dev_id;
 
-        disable_irq_nosync(irq);
+        if (!host->check_int(host))
+                return IRQ_NONE;
 
-        wake_up(&host->irq_waitq);
+        host->irq_control(host, 0);
+
+        complete(&host->op_completion);
 
         return IRQ_HANDLED;
 }
@@ -245,11 +251,54 @@ static int check_int_v1_v2(struct mxc_nand_host *host)
         if (!(tmp & NFC_V1_V2_CONFIG2_INT))
                 return 0;
 
-        writew(tmp & ~NFC_V1_V2_CONFIG2_INT, NFC_V1_V2_CONFIG2);
+        if (!cpu_is_mx21())
+                writew(tmp & ~NFC_V1_V2_CONFIG2_INT, NFC_V1_V2_CONFIG2);
 
         return 1;
 }
 
+/*
+ * It has been observed that the i.MX21 cannot read the CONFIG2:INT bit
+ * if interrupts are masked (CONFIG1:INT_MSK is set). To handle this, the
+ * driver can enable/disable the irq line rather than simply masking the
+ * interrupts.
+ */
+static void irq_control_mx21(struct mxc_nand_host *host, int activate)
+{
+        if (activate)
+                enable_irq(host->irq);
+        else
+                disable_irq_nosync(host->irq);
+}
+
+static void irq_control_v1_v2(struct mxc_nand_host *host, int activate)
+{
+        uint16_t tmp;
+
+        tmp = readw(NFC_V1_V2_CONFIG1);
+
+        if (activate)
+                tmp &= ~NFC_V1_V2_CONFIG1_INT_MSK;
+        else
+                tmp |= NFC_V1_V2_CONFIG1_INT_MSK;
+
+        writew(tmp, NFC_V1_V2_CONFIG1);
+}
+
+static void irq_control_v3(struct mxc_nand_host *host, int activate)
+{
+        uint32_t tmp;
+
+        tmp = readl(NFC_V3_CONFIG2);
+
+        if (activate)
+                tmp &= ~NFC_V3_CONFIG2_INT_MSK;
+        else
+                tmp |= NFC_V3_CONFIG2_INT_MSK;
+
+        writel(tmp, NFC_V3_CONFIG2);
+}
+
 /* This function polls the NANDFC to wait for the basic operation to
  * complete by checking the INT bit of config2 register.
  */
@@ -259,10 +308,9 @@ static void wait_op_done(struct mxc_nand_host *host, int useirq)
 
         if (useirq) {
                 if (!host->check_int(host)) {
-
-                        enable_irq(host->irq);
-
-                        wait_event(host->irq_waitq, host->check_int(host));
+                        INIT_COMPLETION(host->op_completion);
+                        host->irq_control(host, 1);
+                        wait_for_completion(&host->op_completion);
                 }
         } else {
                 while (max_retries-- > 0) {
@@ -799,6 +847,7 @@ static void preset_v3(struct mtd_info *mtd)
                 NFC_V3_CONFIG2_2CMD_PHASES |
                 NFC_V3_CONFIG2_SPAS(mtd->oobsize >> 1) |
                 NFC_V3_CONFIG2_ST_CMD(0x70) |
+                NFC_V3_CONFIG2_INT_MSK |
                 NFC_V3_CONFIG2_NUM_ADDR_PHASE0;
 
         if (chip->ecc.mode == NAND_ECC_HW)
@@ -1024,6 +1073,10 @@ static int __init mxcnd_probe(struct platform_device *pdev)
                 host->send_read_id = send_read_id_v1_v2;
                 host->get_dev_status = get_dev_status_v1_v2;
                 host->check_int = check_int_v1_v2;
+                if (cpu_is_mx21())
+                        host->irq_control = irq_control_mx21;
+                else
+                        host->irq_control = irq_control_v1_v2;
         }
 
         if (nfc_is_v21()) {
@@ -1062,6 +1115,7 @@ static int __init mxcnd_probe(struct platform_device *pdev)
                 host->send_read_id = send_read_id_v3;
                 host->check_int = check_int_v3;
                 host->get_dev_status = get_dev_status_v3;
+                host->irq_control = irq_control_v3;
                 oob_smallpage = &nandv2_hw_eccoob_smallpage;
                 oob_largepage = &nandv2_hw_eccoob_largepage;
         } else
@@ -1093,14 +1147,34 @@ static int __init mxcnd_probe(struct platform_device *pdev)
                 this->options |= NAND_USE_FLASH_BBT;
         }
 
-        init_waitqueue_head(&host->irq_waitq);
+        init_completion(&host->op_completion);
 
         host->irq = platform_get_irq(pdev, 0);
 
+        /*
+         * mask the interrupt. For i.MX21 explicitely call
+         * irq_control_v1_v2 to use the mask bit. We can't call
+         * disable_irq_nosync() for an interrupt we do not own yet.
+         */
+        if (cpu_is_mx21())
+                irq_control_v1_v2(host, 0);
+        else
+                host->irq_control(host, 0);
+
         err = request_irq(host->irq, mxc_nfc_irq, IRQF_DISABLED, DRIVER_NAME, host);
         if (err)
                 goto eirq;
 
+        host->irq_control(host, 0);
+
+        /*
+         * Now that the interrupt is disabled make sure the interrupt
+         * mask bit is cleared on i.MX21. Otherwise we can't read
+         * the interrupt status bit on this machine.
+         */
+        if (cpu_is_mx21())
+                irq_control_v1_v2(host, 1);
+
         /* first scan to find the device and get the page size */
         if (nand_scan_ident(mtd, 1, NULL)) {
                 err = -ENXIO;
diff --git a/drivers/net/3c527.c b/drivers/net/3c527.c
index 70705d1306b9..eca55c52bdfd 100644
--- a/drivers/net/3c527.c
+++ b/drivers/net/3c527.c
@@ -522,7 +522,7 @@ static int __init mc32_probe1(struct net_device *dev, int slot)
         lp->tx_len              = lp->exec_box->data[9];   /* Transmit list count */
         lp->rx_len              = lp->exec_box->data[11];  /* Receive list count */
 
-        init_MUTEX_LOCKED(&lp->cmd_mutex);
+        sema_init(&lp->cmd_mutex, 0);
         init_completion(&lp->execution_cmd);
         init_completion(&lp->xceiver_cmd);
 
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 2cc81a54cbf3..77efe462b921 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2,6 +2,9 @@
 # Network device configuration
 #
 
+config HAVE_NET_MACB
+        bool
+
 menuconfig NETDEVICES
         default y if UML
         depends on NET
@@ -221,7 +224,7 @@ config MII
 
 config MACB
         tristate "Atmel MACB support"
-        depends on AVR32 || ARCH_AT91SAM9260 || ARCH_AT91SAM9263 || ARCH_AT91SAM9G20 || ARCH_AT91SAM9G45 || ARCH_AT91CAP9
+        depends on HAVE_NET_MACB
         select PHYLIB
         help
           The Atmel MACB ethernet interface is found on many AT32 and AT91
@@ -2428,7 +2431,7 @@ config UGETH_TX_ON_DEMAND
 
 config MV643XX_ETH
         tristate "Marvell Discovery (643XX) and Orion ethernet support"
-        depends on MV64X60 || PPC32 || PLAT_ORION
+        depends on (MV64X60 || PPC32 || PLAT_ORION) && INET
         select INET_LRO
         select PHYLIB
         help
@@ -2803,7 +2806,7 @@ config NIU
 
 config PASEMI_MAC
         tristate "PA Semi 1/10Gbit MAC"
-        depends on PPC_PASEMI && PCI
+        depends on PPC_PASEMI && PCI && INET
         select PHYLIB
         select INET_LRO
         help
diff --git a/drivers/net/b44.c b/drivers/net/b44.c
index 1e620e287ae0..efeffdf9e5fa 100644
--- a/drivers/net/b44.c
+++ b/drivers/net/b44.c
@@ -2170,8 +2170,6 @@ static int __devinit b44_init_one(struct ssb_device *sdev,
         dev->irq = sdev->irq;
         SET_ETHTOOL_OPS(dev, &b44_ethtool_ops);
 
-        netif_carrier_off(dev);
-
         err = ssb_bus_powerup(sdev->bus, 0);
         if (err) {
                 dev_err(sdev->dev,
@@ -2213,6 +2211,8 @@ static int __devinit b44_init_one(struct ssb_device *sdev,
                 goto err_out_powerdown;
         }
 
+        netif_carrier_off(dev);
+
         ssb_set_drvdata(sdev, dev);
 
         /* Chip reset provides power to the b44 MAC & PCI cores, which
diff --git a/drivers/net/bfin_mac.c b/drivers/net/bfin_mac.c
index 012613fde3f4..03d063554b7f 100644
--- a/drivers/net/bfin_mac.c
+++ b/drivers/net/bfin_mac.c
@@ -38,6 +38,7 @@
 #include <asm/blackfin.h>
 #include <asm/cacheflush.h>
 #include <asm/portmux.h>
+#include <mach/pll.h>
 
 #include "bfin_mac.h"
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index 3b16f62d5606..e953c6ad6e6d 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -5164,6 +5164,15 @@ int bond_create(struct net *net, const char *name)
                 res = dev_alloc_name(bond_dev, "bond%d");
                 if (res < 0)
                         goto out;
+        } else {
+                /*
+                 * If we're given a name to register
+                 * we need to ensure that its not already
+                 * registered
+                 */
+                res = -EEXIST;
+                if (__dev_get_by_name(net, name) != NULL)
+                        goto out;
         }
 
         res = register_netdevice(bond_dev);
diff --git a/drivers/net/ehea/ehea_main.c b/drivers/net/ehea/ehea_main.c
index a333b42111b8..6372610ed240 100644
--- a/drivers/net/ehea/ehea_main.c
+++ b/drivers/net/ehea/ehea_main.c
@@ -533,8 +533,15 @@ static inline void ehea_fill_skb(struct net_device *dev,
         int length = cqe->num_bytes_transfered - 4;     /*remove CRC */
 
         skb_put(skb, length);
-        skb->ip_summed = CHECKSUM_UNNECESSARY;
         skb->protocol = eth_type_trans(skb, dev);
+
+        /* The packet was not an IPV4 packet so a complemented checksum was
+           calculated. The value is found in the Internet Checksum field. */
+        if (cqe->status & EHEA_CQE_BLIND_CKSUM) {
+                skb->ip_summed = CHECKSUM_COMPLETE;
+                skb->csum = csum_unfold(~cqe->inet_checksum_value);
+        } else
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
 }
 
 static inline struct sk_buff *get_skb_by_index(struct sk_buff **skb_array,
diff --git a/drivers/net/ehea/ehea_qmr.h b/drivers/net/ehea/ehea_qmr.h
index f608a6c54af5..38104734a3be 100644
--- a/drivers/net/ehea/ehea_qmr.h
+++ b/drivers/net/ehea/ehea_qmr.h
@@ -150,6 +150,7 @@ struct ehea_rwqe {
 #define EHEA_CQE_TYPE_RQ           0x60
 #define EHEA_CQE_STAT_ERR_MASK     0x700F
 #define EHEA_CQE_STAT_FAT_ERR_MASK 0xF
+#define EHEA_CQE_BLIND_CKSUM       0x8000
 #define EHEA_CQE_STAT_ERR_TCP      0x4000
 #define EHEA_CQE_STAT_ERR_IP       0x2000
 #define EHEA_CQE_STAT_ERR_CRC      0x1000
diff --git a/drivers/net/fec.c b/drivers/net/fec.c
index 768b840aeb6b..cce32d43175f 100644
--- a/drivers/net/fec.c
+++ b/drivers/net/fec.c
@@ -678,24 +678,37 @@ static int fec_enet_mii_probe(struct net_device *dev)
 {
         struct fec_enet_private *fep = netdev_priv(dev);
         struct phy_device *phy_dev = NULL;
-        int ret;
+        char mdio_bus_id[MII_BUS_ID_SIZE];
+        char phy_name[MII_BUS_ID_SIZE + 3];
+        int phy_id;
 
         fep->phy_dev = NULL;
 
-        /* find the first phy */
-        phy_dev = phy_find_first(fep->mii_bus);
-        if (!phy_dev) {
-                printk(KERN_ERR "%s: no PHY found\n", dev->name);
-                return -ENODEV;
+        /* check for attached phy */
+        for (phy_id = 0; (phy_id < PHY_MAX_ADDR); phy_id++) {
+                if ((fep->mii_bus->phy_mask & (1 << phy_id)))
+                        continue;
+                if (fep->mii_bus->phy_map[phy_id] == NULL)
+                        continue;
+                if (fep->mii_bus->phy_map[phy_id]->phy_id == 0)
+                        continue;
+                strncpy(mdio_bus_id, fep->mii_bus->id, MII_BUS_ID_SIZE);
+                break;
         }
 
-        /* attach the mac to the phy */
-        ret = phy_connect_direct(dev, phy_dev,
-                             &fec_enet_adjust_link, 0,
-                             PHY_INTERFACE_MODE_MII);
-        if (ret) {
-                printk(KERN_ERR "%s: Could not attach to PHY\n", dev->name);
-                return ret;
+        if (phy_id >= PHY_MAX_ADDR) {
+                printk(KERN_INFO "%s: no PHY, assuming direct connection "
+                        "to switch\n", dev->name);
+                strncpy(mdio_bus_id, "0", MII_BUS_ID_SIZE);
+                phy_id = 0;
+        }
+
+        snprintf(phy_name, MII_BUS_ID_SIZE, PHY_ID_FMT, mdio_bus_id, phy_id);
+        phy_dev = phy_connect(dev, phy_name, &fec_enet_adjust_link, 0,
+                PHY_INTERFACE_MODE_MII);
+        if (IS_ERR(phy_dev)) {
+                printk(KERN_ERR "%s: could not attach to PHY\n", dev->name);
+                return PTR_ERR(phy_dev);
         }
 
         /* mask with MAC supported features */
@@ -738,7 +751,7 @@ static int fec_enet_mii_init(struct platform_device *pdev)
         fep->mii_bus->read = fec_enet_mdio_read;
         fep->mii_bus->write = fec_enet_mdio_write;
         fep->mii_bus->reset = fec_enet_mdio_reset;
-        snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id);
+        snprintf(fep->mii_bus->id, MII_BUS_ID_SIZE, "%x", pdev->id + 1);
         fep->mii_bus->priv = fep;
         fep->mii_bus->parent = &pdev->dev;
 
@@ -1311,6 +1324,9 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_mii_init;
 
+        /* Carrier starts down, phylib will bring it up */
+        netif_carrier_off(ndev);
+
         ret = register_netdev(ndev);
         if (ret)
                 goto failed_register;
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 4b52c767ad05..3e5d0b6b6516 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -608,7 +608,7 @@ static int sixpack_open(struct tty_struct *tty)
 
         spin_lock_init(&sp->lock);
         atomic_set(&sp->refcnt, 1);
-        init_MUTEX_LOCKED(&sp->dead_sem);
+        sema_init(&sp->dead_sem, 0);
 
         /* !!! length of the buffers. MTU is IP MTU, not PACLEN!  */
 
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index 66e88bd59caa..4c628393c8b1 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -747,7 +747,7 @@ static int mkiss_open(struct tty_struct *tty)
 
         spin_lock_init(&ax->buflock);
         atomic_set(&ax->refcnt, 1);
-        init_MUTEX_LOCKED(&ax->dead_sem);
+        sema_init(&ax->dead_sem, 0);
 
         ax->tty = tty;
         tty->disc_data = ax;
diff --git a/drivers/net/irda/sir_dev.c b/drivers/net/irda/sir_dev.c
index 1b051dab7b29..51d74447f8f8 100644
--- a/drivers/net/irda/sir_dev.c
+++ b/drivers/net/irda/sir_dev.c
@@ -909,7 +909,7 @@ struct sir_dev * sirdev_get_instance(const struct sir_driver *drv, const char *n
         dev->tx_skb = NULL;
 
         spin_lock_init(&dev->tx_lock);
-        init_MUTEX(&dev->fsm.sem);
+        sema_init(&dev->fsm.sem, 1);
 
         dev->drv = drv;
         dev->netdev = ndev;
diff --git a/drivers/net/pcmcia/3c574_cs.c b/drivers/net/pcmcia/3c574_cs.c
index c683f77c6f42..ff824e11f0b6 100644
--- a/drivers/net/pcmcia/3c574_cs.c
+++ b/drivers/net/pcmcia/3c574_cs.c
@@ -87,7 +87,6 @@ earlier 3Com products.
 #include <linux/bitops.h>
 #include <linux/mii.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -280,25 +279,15 @@ static int tc574_probe(struct pcmcia_device *link)
         spin_lock_init(&lp->window_lock);
         link->resource[0]->end = 32;
         link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-        link->conf.ConfigIndex = 1;
+        link->config_flags |= CONF_ENABLE_IRQ;
+        link->config_index = 1;
 
         dev->netdev_ops = &el3_netdev_ops;
         SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
         dev->watchdog_timeo = TX_TIMEOUT;
 
         return tc574_config(link);
-} /* tc574_attach */
-
-/*
-
-        This deletes a driver "instance".  The device is de-registered
-        with Card Services.  If it has been released, all local data
-        structures are freed.  Otherwise, the structures will be freed
-        when the device is released.
-
-*/
+}
 
 static void tc574_detach(struct pcmcia_device *link)
 {
@@ -313,12 +302,6 @@ static void tc574_detach(struct pcmcia_device *link)
         free_netdev(dev);
 } /* tc574_detach */
 
-/*
-        tc574_config() is scheduled to run after a CARD_INSERTION event
-        is received, to configure the PCMCIA socket, and to make the
-        ethernet device available to the system.
-*/
-
 static const char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
 
 static int tc574_config(struct pcmcia_device *link)
@@ -352,7 +335,7 @@ static int tc574_config(struct pcmcia_device *link)
         if (ret)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -465,12 +448,6 @@ failed:
 
 } /* tc574_config */
 
-/*
-        After a card is removed, tc574_release() will unregister the net
-        device, and release the PCMCIA configuration.  If the device is
-        still open, this will be postponed until it is closed.
-*/
-
 static void tc574_release(struct pcmcia_device *link)
 {
         pcmcia_disable_device(link);
@@ -1198,9 +1175,7 @@ MODULE_DEVICE_TABLE(pcmcia, tc574_ids);
 
 static struct pcmcia_driver tc574_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "3c574_cs",
-        },
+        .name           = "3c574_cs",
         .probe          = tc574_probe,
         .remove         = tc574_detach,
         .id_table       = tc574_ids,
diff --git a/drivers/net/pcmcia/3c589_cs.c b/drivers/net/pcmcia/3c589_cs.c
index 61f9cf2100ff..a07e22295330 100644
--- a/drivers/net/pcmcia/3c589_cs.c
+++ b/drivers/net/pcmcia/3c589_cs.c
@@ -41,7 +41,6 @@
 #include <linux/bitops.h>
 #include <linux/jiffies.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -176,14 +175,6 @@ static const struct ethtool_ops netdev_ethtool_ops;
 
 static void tc589_detach(struct pcmcia_device *p_dev);
 
-/*======================================================================
-
-    tc589_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static const struct net_device_ops el3_netdev_ops = {
         .ndo_open               = el3_open,
         .ndo_stop               = el3_close,
@@ -216,9 +207,8 @@ static int tc589_probe(struct pcmcia_device *link)
     link->resource[0]->end = 16;
     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.ConfigIndex = 1;
+    link->config_flags |= CONF_ENABLE_IRQ;
+    link->config_index = 1;
 
     dev->netdev_ops = &el3_netdev_ops;
     dev->watchdog_timeo = TX_TIMEOUT;
@@ -226,16 +216,7 @@ static int tc589_probe(struct pcmcia_device *link)
     SET_ETHTOOL_OPS(dev, &netdev_ethtool_ops);
 
     return tc589_config(link);
-} /* tc589_attach */
-
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
+}
 
 static void tc589_detach(struct pcmcia_device *link)
 {
@@ -250,14 +231,6 @@ static void tc589_detach(struct pcmcia_device *link)
     free_netdev(dev);
 } /* tc589_detach */
 
-/*======================================================================
-
-    tc589_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-
-======================================================================*/
-
 static int tc589_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
@@ -294,7 +267,7 @@ static int tc589_config(struct pcmcia_device *link)
     if (ret)
             goto failed;
 
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -352,14 +325,6 @@ failed:
     return -ENODEV;
 } /* tc589_config */
 
-/*======================================================================
-
-    After a card is removed, tc589_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void tc589_release(struct pcmcia_device *link)
 {
         pcmcia_disable_device(link);
@@ -955,9 +920,7 @@ MODULE_DEVICE_TABLE(pcmcia, tc589_ids);
 
 static struct pcmcia_driver tc589_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "3c589_cs",
-        },
+        .name           = "3c589_cs",
         .probe          = tc589_probe,
         .remove         = tc589_detach,
         .id_table       = tc589_ids,
diff --git a/drivers/net/pcmcia/axnet_cs.c b/drivers/net/pcmcia/axnet_cs.c
index 5f05ffb240cc..9e8b28b271ae 100644
--- a/drivers/net/pcmcia/axnet_cs.c
+++ b/drivers/net/pcmcia/axnet_cs.c
@@ -39,7 +39,6 @@
 #include <linux/mii.h>
 #include "../8390.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -140,14 +139,6 @@ static const struct net_device_ops axnet_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/*======================================================================
-
-    axnet_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int axnet_probe(struct pcmcia_device *link)
 {
     axnet_dev_t *info;
@@ -166,8 +157,7 @@ static int axnet_probe(struct pcmcia_device *link)
     info = PRIV(dev);
     info->p_dev = link;
     link->priv = dev;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ;
 
     dev->netdev_ops = &axnet_netdev_ops;
 
@@ -177,15 +167,6 @@ static int axnet_probe(struct pcmcia_device *link)
     return axnet_config(link);
 } /* axnet_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void axnet_detach(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
@@ -231,7 +212,7 @@ static int get_prom(struct pcmcia_device *link)
     };
 
     /* Not much of a test, but the alternatives are messy */
-    if (link->conf.ConfigBase != 0x03c0)
+    if (link->config_base != 0x03c0)
         return 0;
 
     axnet_reset_8390(dev);
@@ -248,14 +229,6 @@ static int get_prom(struct pcmcia_device *link)
     return 1;
 } /* get_prom */
 
-/*======================================================================
-
-    axnet_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-
-======================================================================*/
-
 static int try_io_port(struct pcmcia_device *link)
 {
     int j, ret;
@@ -286,35 +259,16 @@ static int try_io_port(struct pcmcia_device *link)
     }
 }
 
-static int axnet_configcheck(struct pcmcia_device *p_dev,
-                             cistpl_cftable_entry_t *cfg,
-                             cistpl_cftable_entry_t *dflt,
-                             unsigned int vcc,
-                             void *priv_data)
+static int axnet_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
-        int i;
-        cistpl_io_t *io = &cfg->io;
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        if (cfg->index == 0 || cfg->io.nwin == 0)
+        p_dev->config_index = 0x05;
+        if (p_dev->resource[0]->end + p_dev->resource[1]->end < 32)
                 return -ENODEV;
 
-        p_dev->conf.ConfigIndex = 0x05;
-        /* For multifunction cards, by convention, we configure the
-           network function with window 0, and serial with window 1 */
-        if (io->nwin > 1) {
-                i = (io->win[1].len > io->win[0].len);
-                p_dev->resource[1]->start = io->win[1-i].base;
-                p_dev->resource[1]->end = io->win[1-i].len;
-        } else {
-                i = p_dev->resource[1]->end = 0;
-        }
-        p_dev->resource[0]->start = io->win[i].base;
-        p_dev->resource[0]->end = io->win[i].len;
-        p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-        if (p_dev->resource[0]->end + p_dev->resource[1]->end >= 32)
-                return try_io_port(p_dev);
-
-        return -ENODEV;
+        return try_io_port(p_dev);
 }
 
 static int axnet_config(struct pcmcia_device *link)
@@ -326,20 +280,19 @@ static int axnet_config(struct pcmcia_device *link)
     dev_dbg(&link->dev, "axnet_config(0x%p)\n", link);
 
     /* don't trust the CIS on this; Linksys got it wrong */
-    link->conf.Present = 0x63;
+    link->config_regs = 0x63;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
     ret = pcmcia_loop_config(link, axnet_configcheck, NULL);
     if (ret != 0)
         goto failed;
 
     if (!link->irq)
             goto failed;
+
+    if (resource_size(link->resource[1]) == 8)
+        link->config_flags |= CONF_ENABLE_SPKR;
     
-    if (resource_size(link->resource[1]) == 8) {
-        link->conf.Attributes |= CONF_ENABLE_SPKR;
-        link->conf.Status = CCSR_AUDIO_ENA;
-    }
-    
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -414,14 +367,6 @@ failed:
     return -ENODEV;
 } /* axnet_config */
 
-/*======================================================================
-
-    After a card is removed, axnet_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void axnet_release(struct pcmcia_device *link)
 {
         pcmcia_disable_device(link);
@@ -783,9 +728,7 @@ MODULE_DEVICE_TABLE(pcmcia, axnet_ids);
 
 static struct pcmcia_driver axnet_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "axnet_cs",
-        },
+        .name           = "axnet_cs",
         .probe          = axnet_probe,
         .remove         = axnet_detach,
         .id_table       = axnet_ids,
diff --git a/drivers/net/pcmcia/com20020_cs.c b/drivers/net/pcmcia/com20020_cs.c
index 3c400cfa82ae..b706a7249477 100644
--- a/drivers/net/pcmcia/com20020_cs.c
+++ b/drivers/net/pcmcia/com20020_cs.c
@@ -43,7 +43,6 @@
 #include <linux/arcdevice.h>
 #include <linux/com20020.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -123,14 +122,6 @@ typedef struct com20020_dev_t {
     struct net_device       *dev;
 } com20020_dev_t;
 
-/*======================================================================
-
-    com20020_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int com20020_probe(struct pcmcia_device *p_dev)
 {
     com20020_dev_t *info;
@@ -160,8 +151,7 @@ static int com20020_probe(struct pcmcia_device *p_dev)
 
     p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
     p_dev->resource[0]->end = 16;
-    p_dev->conf.Attributes = CONF_ENABLE_IRQ;
-    p_dev->conf.IntType = INT_MEMORY_AND_IO;
+    p_dev->config_flags |= CONF_ENABLE_IRQ;
 
     info->dev = dev;
     p_dev->priv = info;
@@ -174,15 +164,6 @@ fail_alloc_info:
     return -ENOMEM;
 } /* com20020_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void com20020_detach(struct pcmcia_device *link)
 {
     struct com20020_dev_t *info = link->priv;
@@ -221,14 +202,6 @@ static void com20020_detach(struct pcmcia_device *link)
 
 } /* com20020_detach */
 
-/*======================================================================
-
-    com20020_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
 static int com20020_config(struct pcmcia_device *link)
 {
     struct arcnet_local *lp;
@@ -282,7 +255,7 @@ static int com20020_config(struct pcmcia_device *link)
 
     dev->irq = link->irq;
 
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -316,14 +289,6 @@ failed:
     return -ENODEV;
 } /* com20020_config */
 
-/*======================================================================
-
-    After a card is removed, com20020_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void com20020_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "com20020_release\n");
@@ -366,9 +331,7 @@ MODULE_DEVICE_TABLE(pcmcia, com20020_ids);
 
 static struct pcmcia_driver com20020_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "com20020_cs",
-        },
+        .name           = "com20020_cs",
         .probe          = com20020_probe,
         .remove         = com20020_detach,
         .id_table       = com20020_ids,
diff --git a/drivers/net/pcmcia/fmvj18x_cs.c b/drivers/net/pcmcia/fmvj18x_cs.c
index 98fffb03ecd7..1c327598bbe8 100644
--- a/drivers/net/pcmcia/fmvj18x_cs.c
+++ b/drivers/net/pcmcia/fmvj18x_cs.c
@@ -49,7 +49,6 @@
 #include <linux/ioport.h>
 #include <linux/crc32.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -252,8 +251,7 @@ static int fmvj18x_probe(struct pcmcia_device *link)
     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
     /* General socket configuration */
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ;
 
     dev->netdev_ops = &fjn_netdev_ops;
     dev->watchdog_timeo = TX_TIMEOUT;
@@ -313,7 +311,7 @@ static int ungermann_try_io_port(struct pcmcia_device *link)
         ret = pcmcia_request_io(link);
         if (ret == 0) {
             /* calculate ConfigIndex value */
-            link->conf.ConfigIndex = 
+            link->config_index =
                 ((link->resource[0]->start & 0x0f0) >> 3) | 0x22;
             return ret;
         }
@@ -321,11 +319,7 @@ static int ungermann_try_io_port(struct pcmcia_device *link)
     return ret; /* RequestIO failed */
 }
 
-static int fmvj18x_ioprobe(struct pcmcia_device *p_dev,
-                           cistpl_cftable_entry_t *cfg,
-                           cistpl_cftable_entry_t *dflt,
-                           unsigned int vcc,
-                           void *priv_data)
+static int fmvj18x_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
 {
         return 0; /* strange, but that's what the code did already before... */
 }
@@ -362,28 +356,28 @@ static int fmvj18x_config(struct pcmcia_device *link)
                 link->card_id == PRODID_TDK_NP9610 ||
                 link->card_id == PRODID_TDK_MN3200) {
                 /* MultiFunction Card */
-                link->conf.ConfigBase = 0x800;
-                link->conf.ConfigIndex = 0x47;
+                link->config_base = 0x800;
+                link->config_index = 0x47;
                 link->resource[1]->end = 8;
             }
             break;
         case MANFID_NEC:
             cardtype = NEC; /* MultiFunction Card */
-            link->conf.ConfigBase = 0x800;
-            link->conf.ConfigIndex = 0x47;
+            link->config_base = 0x800;
+            link->config_index = 0x47;
             link->resource[1]->end = 8;
             break;
         case MANFID_KME:
             cardtype = KME; /* MultiFunction Card */
-            link->conf.ConfigBase = 0x800;
-            link->conf.ConfigIndex = 0x47;
+            link->config_base = 0x800;
+            link->config_index = 0x47;
             link->resource[1]->end = 8;
             break;
         case MANFID_CONTEC:
             cardtype = CONTEC;
             break;
         case MANFID_FUJITSU:
-            if (link->conf.ConfigBase == 0x0fe0)
+            if (link->config_base == 0x0fe0)
                 cardtype = MBH10302;
             else if (link->card_id == PRODID_FUJITSU_MBH10302) 
                 /* RATOC REX-5588/9822/4886's PRODID are 0004(=MBH10302),
@@ -403,10 +397,10 @@ static int fmvj18x_config(struct pcmcia_device *link)
         case MANFID_FUJITSU:
             if (link->card_id == PRODID_FUJITSU_MBH10304) {
                 cardtype = XXX10304;    /* MBH10304 with buggy CIS */
-                link->conf.ConfigIndex = 0x20;
+                link->config_index = 0x20;
             } else {
                 cardtype = MBH10302;    /* NextCom NC5310, etc. */
-                link->conf.ConfigIndex = 1;
+                link->config_index = 1;
             }
             break;
         case MANFID_UNGERMANN:
@@ -414,7 +408,7 @@ static int fmvj18x_config(struct pcmcia_device *link)
             break;
         default:
             cardtype = MBH10302;
-            link->conf.ConfigIndex = 1;
+            link->config_index = 1;
         }
     }
 
@@ -432,7 +426,7 @@ static int fmvj18x_config(struct pcmcia_device *link)
     ret = pcmcia_request_irq(link, fjn_interrupt);
     if (ret)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -544,20 +538,18 @@ failed:
 
 static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 {
-    win_req_t req;
     u_char __iomem *base;
     int i, j;
 
     /* Allocate a small memory window */
-    req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
-    req.Base = 0; req.Size = 0;
-    req.AccessSpeed = 0;
-    i = pcmcia_request_window(link, &req, &link->win);
+    link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
+    link->resource[2]->start = 0; link->resource[2]->end = 0;
+    i = pcmcia_request_window(link, link->resource[2], 0);
     if (i != 0)
         return -1;
 
-    base = ioremap(req.Base, req.Size);
-    pcmcia_map_mem_page(link, link->win, 0);
+    base = ioremap(link->resource[2]->start, resource_size(link->resource[2]));
+    pcmcia_map_mem_page(link, link->resource[2], 0);
 
     /*
      *  MBH10304 CISTPL_FUNCE_LAN_NODE_ID format
@@ -582,7 +574,7 @@ static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
     }
 
     iounmap(base);
-    j = pcmcia_release_window(link, link->win);
+    j = pcmcia_release_window(link, link->resource[2]);
     return (i != 0x200) ? 0 : -1;
 
 } /* fmvj18x_get_hwinfo */
@@ -590,27 +582,26 @@ static int fmvj18x_get_hwinfo(struct pcmcia_device *link, u_char *node_id)
 
 static int fmvj18x_setup_mfc(struct pcmcia_device *link)
 {
-    win_req_t req;
     int i;
     struct net_device *dev = link->priv;
     unsigned int ioaddr;
     local_info_t *lp = netdev_priv(dev);
 
     /* Allocate a small memory window */
-    req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
-    req.Base = 0; req.Size = 0;
-    req.AccessSpeed = 0;
-    i = pcmcia_request_window(link, &req, &link->win);
+    link->resource[3]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
+    link->resource[3]->start = link->resource[3]->end = 0;
+    i = pcmcia_request_window(link, link->resource[3], 0);
     if (i != 0)
         return -1;
 
-    lp->base = ioremap(req.Base, req.Size);
+    lp->base = ioremap(link->resource[3]->start,
+                       resource_size(link->resource[3]));
     if (lp->base == NULL) {
         printk(KERN_NOTICE "fmvj18x_cs: ioremap failed\n");
         return -1;
     }
 
-    i = pcmcia_map_mem_page(link, link->win, 0);
+    i = pcmcia_map_mem_page(link, link->resource[3], 0);
     if (i != 0) {
         iounmap(lp->base);
         lp->base = NULL;
@@ -638,7 +629,6 @@ static void fmvj18x_release(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     local_info_t *lp = netdev_priv(dev);
     u_char __iomem *tmp;
-    int j;
 
     dev_dbg(&link->dev, "fmvj18x_release\n");
 
@@ -646,7 +636,6 @@ static void fmvj18x_release(struct pcmcia_device *link)
         tmp = lp->base;
         lp->base = NULL;    /* set NULL before iounmap */
         iounmap(tmp);
-        j = pcmcia_release_window(link, link->win);
     }
 
     pcmcia_disable_device(link);
@@ -708,9 +697,7 @@ MODULE_DEVICE_TABLE(pcmcia, fmvj18x_ids);
 
 static struct pcmcia_driver fmvj18x_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "fmvj18x_cs",
-        },
+        .name           = "fmvj18x_cs",
         .probe          = fmvj18x_probe,
         .remove         = fmvj18x_detach,
         .id_table       = fmvj18x_ids,
diff --git a/drivers/net/pcmcia/ibmtr_cs.c b/drivers/net/pcmcia/ibmtr_cs.c
index b0d06a3d962f..bf7dff96d881 100644
--- a/drivers/net/pcmcia/ibmtr_cs.c
+++ b/drivers/net/pcmcia/ibmtr_cs.c
@@ -57,7 +57,6 @@
 #include <linux/trdevice.h>
 #include <linux/ibmtr.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -102,9 +101,8 @@ static void ibmtr_detach(struct pcmcia_device *p_dev);
 
 typedef struct ibmtr_dev_t {
         struct pcmcia_device    *p_dev;
-    struct net_device   *dev;
-    window_handle_t     sram_win_handle;
-    struct tok_info     *ti;
+        struct net_device       *dev;
+        struct tok_info         *ti;
 } ibmtr_dev_t;
 
 static void netdev_get_drvinfo(struct net_device *dev,
@@ -123,14 +121,6 @@ static irqreturn_t ibmtr_interrupt(int irq, void *dev_id) {
         return tok_interrupt(irq, dev);
 };
 
-/*======================================================================
-
-    ibmtr_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int __devinit ibmtr_attach(struct pcmcia_device *link)
 {
     ibmtr_dev_t *info;
@@ -153,9 +143,8 @@ static int __devinit ibmtr_attach(struct pcmcia_device *link)
 
     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
     link->resource[0]->end = 4;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.Present = PRESENT_OPTION;
+    link->config_flags |= CONF_ENABLE_IRQ;
+    link->config_regs = PRESENT_OPTION;
 
     info->dev = dev;
 
@@ -164,15 +153,6 @@ static int __devinit ibmtr_attach(struct pcmcia_device *link)
     return ibmtr_config(link);
 } /* ibmtr_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void ibmtr_detach(struct pcmcia_device *link)
 {
     struct ibmtr_dev_t *info = link->priv;
@@ -197,26 +177,17 @@ static void ibmtr_detach(struct pcmcia_device *link)
     kfree(info);
 } /* ibmtr_detach */
 
-/*======================================================================
-
-    ibmtr_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    token-ring device available to the system.
-
-======================================================================*/
-
 static int __devinit ibmtr_config(struct pcmcia_device *link)
 {
     ibmtr_dev_t *info = link->priv;
     struct net_device *dev = info->dev;
     struct tok_info *ti = netdev_priv(dev);
-    win_req_t req;
     int i, ret;
 
     dev_dbg(&link->dev, "ibmtr_config\n");
 
-    link->conf.ConfigIndex = 0x61;
     link->io_lines = 16;
+    link->config_index = 0x61;
 
     /* Determine if this is PRIMARY or ALTERNATE. */
 
@@ -240,39 +211,39 @@ static int __devinit ibmtr_config(struct pcmcia_device *link)
     ti->global_int_enable=GLOBAL_INT_ENABLE+((dev->irq==9) ? 2 : dev->irq);
 
     /* Allocate the MMIO memory window */
-    req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
-    req.Attributes |= WIN_USE_WAIT;
-    req.Base = 0; 
-    req.Size = 0x2000;
-    req.AccessSpeed = 250;
-    ret = pcmcia_request_window(link, &req, &link->win);
+    link->resource[2]->flags |= WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
+    link->resource[2]->flags |= WIN_USE_WAIT;
+    link->resource[2]->start = 0;
+    link->resource[2]->end = 0x2000;
+    ret = pcmcia_request_window(link, link->resource[2], 250);
     if (ret)
             goto failed;
 
-    ret = pcmcia_map_mem_page(link, link->win, mmiobase);
+    ret = pcmcia_map_mem_page(link, link->resource[2], mmiobase);
     if (ret)
             goto failed;
-    ti->mmio = ioremap(req.Base, req.Size);
+    ti->mmio = ioremap(link->resource[2]->start,
+                    resource_size(link->resource[2]));
 
     /* Allocate the SRAM memory window */
-    req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
-    req.Attributes |= WIN_USE_WAIT;
-    req.Base = 0;
-    req.Size = sramsize * 1024;
-    req.AccessSpeed = 250;
-    ret = pcmcia_request_window(link, &req, &info->sram_win_handle);
+    link->resource[3]->flags = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
+    link->resource[3]->flags |= WIN_USE_WAIT;
+    link->resource[3]->start = 0;
+    link->resource[3]->end = sramsize * 1024;
+    ret = pcmcia_request_window(link, link->resource[3], 250);
     if (ret)
             goto failed;
 
-    ret = pcmcia_map_mem_page(link, info->sram_win_handle, srambase);
+    ret = pcmcia_map_mem_page(link, link->resource[3], srambase);
     if (ret)
             goto failed;
 
     ti->sram_base = srambase >> 12;
-    ti->sram_virt = ioremap(req.Base, req.Size);
-    ti->sram_phys = req.Base;
+    ti->sram_virt = ioremap(link->resource[3]->start,
+                    resource_size(link->resource[3]));
+    ti->sram_phys = link->resource[3]->start;
 
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -301,14 +272,6 @@ failed:
     return -ENODEV;
 } /* ibmtr_config */
 
-/*======================================================================
-
-    After a card is removed, ibmtr_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void ibmtr_release(struct pcmcia_device *link)
 {
         ibmtr_dev_t *info = link->priv;
@@ -316,7 +279,7 @@ static void ibmtr_release(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "ibmtr_release\n");
 
-        if (link->win) {
+        if (link->resource[2]->end) {
                 struct tok_info *ti = netdev_priv(dev);
                 iounmap(ti->mmio);
         }
@@ -398,9 +361,7 @@ MODULE_DEVICE_TABLE(pcmcia, ibmtr_ids);
 
 static struct pcmcia_driver ibmtr_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "ibmtr_cs",
-        },
+        .name           = "ibmtr_cs",
         .probe          = ibmtr_attach,
         .remove         = ibmtr_detach,
         .id_table       = ibmtr_ids,
diff --git a/drivers/net/pcmcia/nmclan_cs.c b/drivers/net/pcmcia/nmclan_cs.c
index 68f2deeb3ade..1eca4f5a6e78 100644
--- a/drivers/net/pcmcia/nmclan_cs.c
+++ b/drivers/net/pcmcia/nmclan_cs.c
@@ -146,7 +146,6 @@ Include Files
 #include <linux/ioport.h>
 #include <linux/bitops.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
@@ -435,13 +434,6 @@ static const struct net_device_ops mace_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/* ----------------------------------------------------------------------------
-nmclan_attach
-        Creates an "instance" of the driver, allocating local data
-        structures for one device.  The device is registered with Card
-        Services.
----------------------------------------------------------------------------- */
-
 static int nmclan_probe(struct pcmcia_device *link)
 {
     mace_private *lp;
@@ -460,10 +452,9 @@ static int nmclan_probe(struct pcmcia_device *link)
     spin_lock_init(&lp->bank_lock);
     link->resource[0]->end = 32;
     link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.ConfigIndex = 1;
-    link->conf.Present = PRESENT_OPTION;
+    link->config_flags |= CONF_ENABLE_IRQ;
+    link->config_index = 1;
+    link->config_regs = PRESENT_OPTION;
 
     lp->tx_free_frames=AM2150_MAX_TX_FRAMES;
 
@@ -474,14 +465,6 @@ static int nmclan_probe(struct pcmcia_device *link)
     return nmclan_config(link);
 } /* nmclan_attach */
 
-/* ----------------------------------------------------------------------------
-nmclan_detach
-        This deletes a driver "instance".  The device is de-registered
-        with Card Services.  If it has been released, all local data
-        structures are freed.  Otherwise, the structures will be freed
-        when the device is released.
----------------------------------------------------------------------------- */
-
 static void nmclan_detach(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
@@ -625,13 +608,6 @@ static int mace_init(mace_private *lp, unsigned int ioaddr, char *enet_addr)
   return 0;
 } /* mace_init */
 
-/* ----------------------------------------------------------------------------
-nmclan_config
-        This routine is scheduled to run after a CARD_INSERTION event
-        is received, to configure the PCMCIA socket, and to make the
-        ethernet device available to the system.
----------------------------------------------------------------------------- */
-
 static int nmclan_config(struct pcmcia_device *link)
 {
   struct net_device *dev = link->priv;
@@ -650,7 +626,7 @@ static int nmclan_config(struct pcmcia_device *link)
   ret = pcmcia_request_exclusive_irq(link, mace_interrupt);
   if (ret)
           goto failed;
-  ret = pcmcia_request_configuration(link, &link->conf);
+  ret = pcmcia_enable_device(link);
   if (ret)
           goto failed;
 
@@ -712,12 +688,6 @@ failed:
         return -ENODEV;
 } /* nmclan_config */
 
-/* ----------------------------------------------------------------------------
-nmclan_release
-        After a card is removed, nmclan_release() will unregister the
-        net device, and release the PCMCIA configuration.  If the device
-        is still open, this will be postponed until it is closed.
----------------------------------------------------------------------------- */
 static void nmclan_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "nmclan_release\n");
@@ -1535,9 +1505,7 @@ MODULE_DEVICE_TABLE(pcmcia, nmclan_ids);
 
 static struct pcmcia_driver nmclan_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "nmclan_cs",
-        },
+        .name           = "nmclan_cs",
         .probe          = nmclan_probe,
         .remove         = nmclan_detach,
         .id_table       = nmclan_ids,
diff --git a/drivers/net/pcmcia/pcnet_cs.c b/drivers/net/pcmcia/pcnet_cs.c
index f9b509a6b09a..5d7d1d3088ae 100644
--- a/drivers/net/pcmcia/pcnet_cs.c
+++ b/drivers/net/pcmcia/pcnet_cs.c
@@ -42,7 +42,6 @@
 #include <linux/mii.h>
 #include "../8390.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -238,14 +237,6 @@ static const struct net_device_ops pcnet_netdev_ops = {
 #endif
 };
 
-/*======================================================================
-
-    pcnet_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int pcnet_probe(struct pcmcia_device *link)
 {
     pcnet_dev_t *info;
@@ -260,23 +251,13 @@ static int pcnet_probe(struct pcmcia_device *link)
     info->p_dev = link;
     link->priv = dev;
 
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
     dev->netdev_ops = &pcnet_netdev_ops;
 
     return pcnet_config(link);
 } /* pcnet_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void pcnet_detach(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
@@ -300,22 +281,22 @@ static void pcnet_detach(struct pcmcia_device *link)
 static hw_info_t *get_hwinfo(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
-    win_req_t req;
     u_char __iomem *base, *virt;
     int i, j;
 
     /* Allocate a small memory window */
-    req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
-    req.Base = 0; req.Size = 0;
-    req.AccessSpeed = 0;
-    i = pcmcia_request_window(link, &req, &link->win);
+    link->resource[2]->flags |= WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
+    link->resource[2]->start = 0; link->resource[2]->end = 0;
+    i = pcmcia_request_window(link, link->resource[2], 0);
     if (i != 0)
         return NULL;
 
-    virt = ioremap(req.Base, req.Size);
+    virt = ioremap(link->resource[2]->start,
+            resource_size(link->resource[2]));
     for (i = 0; i < NR_INFO; i++) {
-        pcmcia_map_mem_page(link, link->win, hw_info[i].offset & ~(req.Size-1));
-        base = &virt[hw_info[i].offset & (req.Size-1)];
+        pcmcia_map_mem_page(link, link->resource[2],
+                hw_info[i].offset & ~(resource_size(link->resource[2])-1));
+        base = &virt[hw_info[i].offset & (resource_size(link->resource[2])-1)];
         if ((readb(base+0) == hw_info[i].a0) &&
             (readb(base+2) == hw_info[i].a1) &&
             (readb(base+4) == hw_info[i].a2)) {
@@ -326,7 +307,7 @@ static hw_info_t *get_hwinfo(struct pcmcia_device *link)
     }
 
     iounmap(virt);
-    j = pcmcia_release_window(link, link->win);
+    j = pcmcia_release_window(link, link->resource[2]);
     return (i < NR_INFO) ? hw_info+i : NULL;
 } /* get_hwinfo */
 
@@ -421,7 +402,7 @@ static hw_info_t *get_ax88190(struct pcmcia_device *link)
     int i, j;
 
     /* Not much of a test, but the alternatives are messy */
-    if (link->conf.ConfigBase != 0x03c0)
+    if (link->config_base != 0x03c0)
         return NULL;
 
     outb_p(0x01, ioaddr + EN0_DCFG);    /* Set word-wide access. */
@@ -463,14 +444,6 @@ static hw_info_t *get_hwired(struct pcmcia_device *link)
     return &default_info;
 } /* get_hwired */
 
-/*======================================================================
-
-    pcnet_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-
-======================================================================*/
-
 static int try_io_port(struct pcmcia_device *link)
 {
     int j, ret;
@@ -502,43 +475,22 @@ static int try_io_port(struct pcmcia_device *link)
     }
 }
 
-static int pcnet_confcheck(struct pcmcia_device *p_dev,
-                           cistpl_cftable_entry_t *cfg,
-                           cistpl_cftable_entry_t *dflt,
-                           unsigned int vcc,
-                           void *priv_data)
+static int pcnet_confcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
         int *priv = priv_data;
         int try = (*priv & 0x1);
-        int i;
-        cistpl_io_t *io = &cfg->io;
 
-        if (cfg->index == 0 || cfg->io.nwin == 0)
-                return -EINVAL;
+        *priv &= (p_dev->resource[2]->end >= 0x4000) ? 0x10 : ~0x10;
 
-        /* For multifunction cards, by convention, we configure the
-           network function with window 0, and serial with window 1 */
-        if (io->nwin > 1) {
-                i = (io->win[1].len > io->win[0].len);
-                p_dev->resource[1]->start = io->win[1-i].base;
-                p_dev->resource[1]->end = io->win[1-i].len;
-        } else {
-                i = p_dev->resource[1]->end = 0;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        *priv &= ((cfg->mem.nwin == 1) &&
-                  (cfg->mem.win[0].len >= 0x4000)) ? 0x10 : ~0x10;
+        if (p_dev->resource[0]->end + p_dev->resource[1]->end < 32)
+                return -EINVAL;
 
-        p_dev->resource[0]->start = io->win[i].base;
-        p_dev->resource[0]->end = io->win[i].len;
-        if (!try)
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-        else
+        if (try)
                 p_dev->io_lines = 16;
-        if (p_dev->resource[0]->end + p_dev->resource[1]->end >= 32)
-                return try_io_port(p_dev);
-
-        return -EINVAL;
+        return try_io_port(p_dev);
 }
 
 static hw_info_t *pcnet_try_config(struct pcmcia_device *link,
@@ -560,15 +512,14 @@ static hw_info_t *pcnet_try_config(struct pcmcia_device *link,
         if (!link->irq)
                 return NULL;
 
-        if (resource_size(link->resource[1]) == 8) {
-                link->conf.Attributes |= CONF_ENABLE_SPKR;
-                link->conf.Status = CCSR_AUDIO_ENA;
-        }
+        if (resource_size(link->resource[1]) == 8)
+                link->config_flags |= CONF_ENABLE_SPKR;
+
         if ((link->manf_id == MANFID_IBM) &&
             (link->card_id == PRODID_IBM_HOME_AND_AWAY))
-                link->conf.ConfigIndex |= 0x10;
+                link->config_index |= 0x10;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 return NULL;
 
@@ -583,7 +534,7 @@ static hw_info_t *pcnet_try_config(struct pcmcia_device *link,
         } else
                 dev->if_port = 0;
 
-        if ((link->conf.ConfigBase == 0x03c0) &&
+        if ((link->config_base == 0x03c0) &&
             (link->manf_id == 0x149) && (link->card_id == 0xc1ab)) {
                 dev_info(&link->dev,
                         "this is an AX88190 card - use axnet_cs instead.\n");
@@ -689,14 +640,6 @@ failed:
     return -ENODEV;
 } /* pcnet_config */
 
-/*======================================================================
-
-    After a card is removed, pcnet_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void pcnet_release(struct pcmcia_device *link)
 {
         pcnet_dev_t *info = PRIV(link->priv);
@@ -709,15 +652,6 @@ static void pcnet_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 }
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.  A CARD_REMOVAL event
-    also sets some flags to discourage the net drivers from trying
-    to talk to the card any more.
-
-======================================================================*/
-
 static int pcnet_suspend(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
@@ -1486,7 +1420,6 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
 {
     struct net_device *dev = link->priv;
     pcnet_dev_t *info = PRIV(dev);
-    win_req_t req;
     int i, window_size, offset, ret;
 
     window_size = (stop_pg - start_pg) << 8;
@@ -1497,22 +1430,22 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
     window_size = roundup_pow_of_two(window_size);
 
     /* Allocate a memory window */
-    req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
-    req.Attributes |= WIN_USE_WAIT;
-    req.Base = 0; req.Size = window_size;
-    req.AccessSpeed = mem_speed;
-    ret = pcmcia_request_window(link, &req, &link->win);
+    link->resource[3]->flags |= WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM|WIN_ENABLE;
+    link->resource[3]->flags |= WIN_USE_WAIT;
+    link->resource[3]->start = 0; link->resource[3]->end = window_size;
+    ret = pcmcia_request_window(link, link->resource[3], mem_speed);
     if (ret)
             goto failed;
 
     offset = (start_pg << 8) + cm_offset;
     offset -= offset % window_size;
-    ret = pcmcia_map_mem_page(link, link->win, offset);
+    ret = pcmcia_map_mem_page(link, link->resource[3], offset);
     if (ret)
             goto failed;
 
     /* Try scribbling on the buffer */
-    info->base = ioremap(req.Base, window_size);
+    info->base = ioremap(link->resource[3]->start,
+                        resource_size(link->resource[3]));
     for (i = 0; i < (TX_PAGES<<8); i += 2)
         __raw_writew((i>>1), info->base+offset+i);
     udelay(100);
@@ -1521,19 +1454,20 @@ static int setup_shmem_window(struct pcmcia_device *link, int start_pg,
     pcnet_reset_8390(dev);
     if (i != (TX_PAGES<<8)) {
         iounmap(info->base);
-        pcmcia_release_window(link, link->win);
-        info->base = NULL; link->win = 0;
+        pcmcia_release_window(link, link->resource[3]);
+        info->base = NULL;
         goto failed;
     }
 
     ei_status.mem = info->base + offset;
-    ei_status.priv = req.Size;
+    ei_status.priv = resource_size(link->resource[3]);
     dev->mem_start = (u_long)ei_status.mem;
-    dev->mem_end = dev->mem_start + req.Size;
+    dev->mem_end = dev->mem_start + resource_size(link->resource[3]);
 
     ei_status.tx_start_page = start_pg;
     ei_status.rx_start_page = start_pg + TX_PAGES;
-    ei_status.stop_page = start_pg + ((req.Size - offset) >> 8);
+    ei_status.stop_page = start_pg + (
+            (resource_size(link->resource[3]) - offset) >> 8);
 
     /* set up block i/o functions */
     ei_status.get_8390_hdr = &shmem_get_8390_hdr;
@@ -1772,9 +1706,7 @@ MODULE_FIRMWARE("cis/PE-200.cis");
 MODULE_FIRMWARE("cis/tamarack.cis");
 
 static struct pcmcia_driver pcnet_driver = {
-        .drv            = {
-                .name   = "pcnet_cs",
-        },
+        .name           = "pcnet_cs",
         .probe          = pcnet_probe,
         .remove         = pcnet_detach,
         .owner          = THIS_MODULE,
diff --git a/drivers/net/pcmcia/smc91c92_cs.c b/drivers/net/pcmcia/smc91c92_cs.c
index 377367d03b41..0af2fc8ec164 100644
--- a/drivers/net/pcmcia/smc91c92_cs.c
+++ b/drivers/net/pcmcia/smc91c92_cs.c
@@ -44,7 +44,6 @@
 #include <linux/jiffies.h>
 #include <linux/firmware.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -300,14 +299,6 @@ static const struct net_device_ops smc_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/*======================================================================
-
-  smc91c92_attach() creates an "instance" of the driver, allocating
-  local data structures for one device.  The device is registered
-  with Card Services.
-
-======================================================================*/
-
 static int smc91c92_probe(struct pcmcia_device *link)
 {
     struct smc_private *smc;
@@ -324,10 +315,6 @@ static int smc91c92_probe(struct pcmcia_device *link)
     link->priv = dev;
 
     spin_lock_init(&smc->lock);
-    link->resource[0]->end = 16;
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
 
     /* The SMC91c92-specific entries in the device structure. */
     dev->netdev_ops = &smc_netdev_ops;
@@ -343,15 +330,6 @@ static int smc91c92_probe(struct pcmcia_device *link)
     return smc91c92_config(link);
 } /* smc91c92_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void smc91c92_detach(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
@@ -412,26 +390,28 @@ static int mhz_3288_power(struct pcmcia_device *link)
     mdelay(200);
 
     /* Now read and write the COR... */
-    tmp = readb(smc->base + link->conf.ConfigBase + CISREG_COR);
+    tmp = readb(smc->base + link->config_base + CISREG_COR);
     udelay(5);
-    writeb(tmp, smc->base + link->conf.ConfigBase + CISREG_COR);
+    writeb(tmp, smc->base + link->config_base + CISREG_COR);
 
     return 0;
 }
 
-static int mhz_mfc_config_check(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cf,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int mhz_mfc_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         int k;
-        p_dev->resource[1]->start = cf->io.win[0].base;
+        p_dev->io_lines = 16;
+        p_dev->resource[1]->start = p_dev->resource[0]->start;
+        p_dev->resource[1]->end = 8;
+        p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
         for (k = 0; k < 0x400; k += 0x10) {
                 if (k & 0x80)
                         continue;
                 p_dev->resource[0]->start = k ^ 0x300;
-                p_dev->io_lines = 16;
                 if (!pcmcia_request_io(p_dev))
                         return 0;
         }
@@ -442,14 +422,11 @@ static int mhz_mfc_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
     struct smc_private *smc = netdev_priv(dev);
-    win_req_t req;
     unsigned int offset;
     int i;
 
-    link->conf.Attributes |= CONF_ENABLE_SPKR;
-    link->conf.Status = CCSR_AUDIO_ENA;
-    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-    link->resource[1]->end = 8;
+    link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ |
+            CONF_AUTO_SET_IO;
 
     /* The Megahertz combo cards have modem-like CIS entries, so
        we have to explicitly try a bunch of port combinations. */
@@ -459,16 +436,16 @@ static int mhz_mfc_config(struct pcmcia_device *link)
     dev->base_addr = link->resource[0]->start;
 
     /* Allocate a memory window, for accessing the ISR */
-    req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
-    req.Base = req.Size = 0;
-    req.AccessSpeed = 0;
-    i = pcmcia_request_window(link, &req, &link->win);
+    link->resource[2]->flags = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
+    link->resource[2]->start = link->resource[2]->end = 0;
+    i = pcmcia_request_window(link, link->resource[2], 0);
     if (i != 0)
             return -ENODEV;
 
-    smc->base = ioremap(req.Base, req.Size);
-    offset = (smc->manfid == MANFID_MOTOROLA) ? link->conf.ConfigBase : 0;
-    i = pcmcia_map_mem_page(link, link->win, offset);
+    smc->base = ioremap(link->resource[2]->start,
+                    resource_size(link->resource[2]));
+    offset = (smc->manfid == MANFID_MOTOROLA) ? link->config_base : 0;
+    i = pcmcia_map_mem_page(link, link->resource[2], offset);
     if ((i == 0) &&
         (smc->manfid == MANFID_MEGAHERTZ) &&
         (smc->cardid == PRODID_MEGAHERTZ_EM3288))
@@ -591,14 +568,12 @@ static int mot_setup(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-static int smc_configcheck(struct pcmcia_device *p_dev,
-                           cistpl_cftable_entry_t *cf,
-                           cistpl_cftable_entry_t *dflt,
-                           unsigned int vcc,
-                           void *priv_data)
+static int smc_configcheck(struct pcmcia_device *p_dev, void *priv_data)
 {
-        p_dev->resource[0]->start = cf->io.win[0].base;
-        p_dev->io_lines = cf->io.flags & CISTPL_IO_LINES_MASK;
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+
         return pcmcia_request_io(p_dev);
 }
 
@@ -607,7 +582,8 @@ static int smc_config(struct pcmcia_device *link)
     struct net_device *dev = link->priv;
     int i;
 
-    link->resource[0]->end = 16;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
     i = pcmcia_loop_config(link, smc_configcheck, NULL);
     if (!i)
             dev->base_addr = link->resource[0]->start;
@@ -640,15 +616,14 @@ static int osi_config(struct pcmcia_device *link)
     static const unsigned int com[4] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8 };
     int i, j;
 
-    link->conf.Attributes |= CONF_ENABLE_SPKR;
-    link->conf.Status = CCSR_AUDIO_ENA;
+    link->config_flags |= CONF_ENABLE_SPKR | CONF_ENABLE_IRQ;
     link->resource[0]->end = 64;
     link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
     link->resource[1]->end = 8;
 
     /* Enable Hard Decode, LAN, Modem */
-    link->conf.ConfigIndex = 0x23;
     link->io_lines = 16;
+    link->config_index = 0x23;
 
     for (i = j = 0; j < 4; j++) {
         link->resource[1]->start = com[j];
@@ -658,7 +633,7 @@ static int osi_config(struct pcmcia_device *link)
     }
     if (i != 0) {
         /* Fallback: turn off hard decode */
-        link->conf.ConfigIndex = 0x03;
+        link->config_index = 0x03;
         link->resource[1]->end = 0;
         i = pcmcia_request_io(link);
     }
@@ -817,27 +792,16 @@ static int check_sig(struct pcmcia_device *link)
     }
 
     if (width) {
-            modconf_t mod = {
-                    .Attributes = CONF_IO_CHANGE_WIDTH,
-            };
             printk(KERN_INFO "smc91c92_cs: using 8-bit IO window.\n");
 
             smc91c92_suspend(link);
-            pcmcia_modify_configuration(link, &mod);
+            pcmcia_fixup_iowidth(link);
             smc91c92_resume(link);
             return check_sig(link);
     }
     return -ENODEV;
 }
 
-/*======================================================================
-
-    smc91c92_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-
-======================================================================*/
-
 static int smc91c92_config(struct pcmcia_device *link)
 {
     struct net_device *dev = link->priv;
@@ -869,7 +833,7 @@ static int smc91c92_config(struct pcmcia_device *link)
     i = pcmcia_request_irq(link, smc_interrupt);
     if (i)
             goto config_failed;
-    i = pcmcia_request_configuration(link, &link->conf);
+    i = pcmcia_enable_device(link);
     if (i)
             goto config_failed;
 
@@ -988,18 +952,10 @@ config_failed:
     return -ENODEV;
 } /* smc91c92_config */
 
-/*======================================================================
-
-    After a card is removed, smc91c92_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void smc91c92_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "smc91c92_release\n");
-        if (link->win) {
+        if (link->resource[2]->end) {
                 struct net_device *dev = link->priv;
                 struct smc_private *smc = netdev_priv(dev);
                 iounmap(smc->base);
@@ -2101,9 +2057,7 @@ MODULE_DEVICE_TABLE(pcmcia, smc91c92_ids);
 
 static struct pcmcia_driver smc91c92_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "smc91c92_cs",
-        },
+        .name           = "smc91c92_cs",
         .probe          = smc91c92_probe,
         .remove         = smc91c92_detach,
         .id_table       = smc91c92_ids,
diff --git a/drivers/net/pcmcia/xirc2ps_cs.c b/drivers/net/pcmcia/xirc2ps_cs.c
index f5819526b5ee..1fece617c069 100644
--- a/drivers/net/pcmcia/xirc2ps_cs.c
+++ b/drivers/net/pcmcia/xirc2ps_cs.c
@@ -82,7 +82,6 @@
 #include <linux/bitops.h>
 #include <linux/mii.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -267,33 +266,11 @@ static unsigned mii_rd(unsigned int ioaddr, u_char phyaddr, u_char phyreg);
 static void mii_wr(unsigned int ioaddr, u_char phyaddr, u_char phyreg,
                    unsigned data, int len);
 
-/*
- * The event() function is this driver's Card Services event handler.
- * It will be called by Card Services when an appropriate card status
- * event is received.  The config() and release() entry points are
- * used to configure or release a socket, in response to card insertion
- * and ejection events.  They are invoked from the event handler.
- */
-
 static int has_ce2_string(struct pcmcia_device * link);
 static int xirc2ps_config(struct pcmcia_device * link);
 static void xirc2ps_release(struct pcmcia_device * link);
-
-/****************
- * The attach() and detach() entry points are used to create and destroy
- * "instances" of the driver, where each instance represents everything
- * needed to manage one actual PCMCIA card.
- */
-
 static void xirc2ps_detach(struct pcmcia_device *p_dev);
 
-/****************
- * You'll also need to prototype all the functions that will actually
- * be used to talk to your device.  See 'pcmem_cs' for a good example
- * of a fully self-sufficient driver; the other drivers rely more or
- * less on other parts of the kernel.
- */
-
 static irqreturn_t xirc2ps_interrupt(int irq, void *dev_id);
 
 typedef struct local_info_t {
@@ -501,16 +478,6 @@ static const struct net_device_ops netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/****************
- * xirc2ps_attach() creates an "instance" of the driver, allocating
- * local data structures for one device.  The device is registered
- * with Card Services.
- *
- * The dev_link structure is initialized, but we don't actually
- * configure the card at this point -- we wait until we receive a
- * card insertion event.
- */
-
 static int
 xirc2ps_probe(struct pcmcia_device *link)
 {
@@ -529,9 +496,7 @@ xirc2ps_probe(struct pcmcia_device *link)
     link->priv = dev;
 
     /* General socket configuration */
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.ConfigIndex = 1;
+    link->config_index = 1;
 
     /* Fill in card specific entries */
     dev->netdev_ops = &netdev_ops;
@@ -542,13 +507,6 @@ xirc2ps_probe(struct pcmcia_device *link)
     return xirc2ps_config(link);
 } /* xirc2ps_attach */
 
-/****************
- *  This deletes a driver "instance".  The device is de-registered
- *  with Card Services.  If it has been released, all local data
- *  structures are freed.  Otherwise, the structures will be freed
- *  when the device is released.
- */
-
 static void
 xirc2ps_detach(struct pcmcia_device *link)
 {
@@ -667,44 +625,53 @@ has_ce2_string(struct pcmcia_device * p_dev)
 }
 
 static int
-xirc2ps_config_modem(struct pcmcia_device *p_dev,
-                     cistpl_cftable_entry_t *cf,
-                     cistpl_cftable_entry_t *dflt,
-                     unsigned int vcc,
-                     void *priv_data)
+xirc2ps_config_modem(struct pcmcia_device *p_dev, void *priv_data)
 {
         unsigned int ioaddr;
 
-        if (cf->io.nwin > 0  &&  (cf->io.win[0].base & 0xf) == 8) {
-                for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
-                        p_dev->resource[1]->start = cf->io.win[0].base;
-                        p_dev->resource[0]->start = ioaddr;
-                        if (!pcmcia_request_io(p_dev))
-                                return 0;
-                }
+        if ((p_dev->resource[0]->start & 0xf) == 8)
+                return -ENODEV;
+
+        p_dev->resource[0]->end = 16;
+        p_dev->resource[1]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
+        p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->io_lines = 10;
+
+        p_dev->resource[1]->start = p_dev->resource[0]->start;
+        for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
+                p_dev->resource[0]->start = ioaddr;
+                if (!pcmcia_request_io(p_dev))
+                        return 0;
         }
         return -ENODEV;
 }
 
 static int
-xirc2ps_config_check(struct pcmcia_device *p_dev,
-                     cistpl_cftable_entry_t *cf,
-                     cistpl_cftable_entry_t *dflt,
-                     unsigned int vcc,
-                     void *priv_data)
+xirc2ps_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         int *pass = priv_data;
+        resource_size_t tmp = p_dev->resource[1]->start;
 
-        if (cf->io.nwin > 0 && (cf->io.win[0].base & 0xf) == 8) {
-                p_dev->resource[1]->start = cf->io.win[0].base;
-                p_dev->resource[0]->start = p_dev->resource[1]->start
-                        + (*pass ? (cf->index & 0x20 ? -24:8)
-                           : (cf->index & 0x20 ?   8:-24));
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -ENODEV;
+        tmp += (*pass ? (p_dev->config_index & 0x20 ? -24 : 8)
+                : (p_dev->config_index & 0x20 ?   8 : -24));
+
+        if ((p_dev->resource[0]->start & 0xf) == 8)
+                return -ENODEV;
+
+        p_dev->resource[0]->end = 18;
+        p_dev->resource[1]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
+        p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->io_lines = 10;
 
+        p_dev->resource[1]->start = p_dev->resource[0]->start;
+        p_dev->resource[0]->start = tmp;
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -727,11 +694,6 @@ static int pcmcia_get_mac_ce(struct pcmcia_device *p_dev,
 };
 
 
-/****************
- * xirc2ps_config() is scheduled to run after a CARD_INSERTION event
- * is received, to configure the PCMCIA socket, and to make the
- * ethernet device available to the system.
- */
 static int
 xirc2ps_config(struct pcmcia_device * link)
 {
@@ -807,32 +769,24 @@ xirc2ps_config(struct pcmcia_device * link)
         goto failure;
     }
 
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
-    link->io_lines = 10;
     if (local->modem) {
         int pass;
+        link->config_flags |= CONF_AUTO_SET_IO;
 
-        if (do_sound) {
-            link->conf.Attributes |= CONF_ENABLE_SPKR;
-            link->conf.Status |= CCSR_AUDIO_ENA;
-        }
-        link->resource[1]->end = 8;
-        link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
         if (local->dingo) {
             /* Take the Modem IO port from the CIS and scan for a free
              * Ethernet port */
-            link->resource[0]->end = 16; /* no Mako stuff anymore */
             if (!pcmcia_loop_config(link, xirc2ps_config_modem, NULL))
                     goto port_found;
         } else {
-            link->resource[0]->end = 18;
             /* We do 2 passes here: The first one uses the regular mapping and
              * the second tries again, thereby considering that the 32 ports are
              * mirrored every 32 bytes. Actually we use a mirrored port for
              * the Mako if (on the first pass) the COR bit 5 is set.
              */
             for (pass=0; pass < 2; pass++)
-                    if (!pcmcia_loop_config(link, xirc2ps_config_check, &pass))
+                    if (!pcmcia_loop_config(link, xirc2ps_config_check,
+                                                    &pass))
                             goto port_found;
             /* if special option:
              * try to configure as Ethernet only.
@@ -840,7 +794,9 @@ xirc2ps_config(struct pcmcia_device * link)
         }
         printk(KNOT_XIRC "no ports available\n");
     } else {
+        link->io_lines = 10;
         link->resource[0]->end = 16;
+        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
         for (ioaddr = 0x300; ioaddr < 0x400; ioaddr += 0x10) {
             link->resource[0]->start = ioaddr;
             if (!(err = pcmcia_request_io(link)))
@@ -861,16 +817,14 @@ xirc2ps_config(struct pcmcia_device * link)
     if ((err=pcmcia_request_irq(link, xirc2ps_interrupt)))
         goto config_error;
 
-    /****************
-     * This actually configures the PCMCIA socket -- setting up
-     * the I/O windows and the interrupt mapping.
-     */
-    if ((err=pcmcia_request_configuration(link, &link->conf)))
+    link->config_flags |= CONF_ENABLE_IRQ;
+    if (do_sound)
+            link->config_flags |= CONF_ENABLE_SPKR;
+
+    if ((err = pcmcia_enable_device(link)))
         goto config_error;
 
     if (local->dingo) {
-        win_req_t req;
-
         /* Reset the modem's BAR to the correct value
          * This is necessary because in the RequestConfiguration call,
          * the base address of the ethernet port (BasePort1) is written
@@ -890,14 +844,14 @@ xirc2ps_config(struct pcmcia_device * link)
          * is at 0x0800. So we allocate a window into the attribute
          * memory and write direct to the CIS registers
          */
-        req.Attributes = WIN_DATA_WIDTH_8|WIN_MEMORY_TYPE_AM|WIN_ENABLE;
-        req.Base = req.Size = 0;
-        req.AccessSpeed = 0;
-        if ((err = pcmcia_request_window(link, &req, &link->win)))
+        link->resource[2]->flags = WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_AM |
+                                        WIN_ENABLE;
+        link->resource[2]->start = link->resource[2]->end = 0;
+        if ((err = pcmcia_request_window(link, link->resource[2], 0)))
             goto config_error;
 
-        local->dingo_ccr = ioremap(req.Base,0x1000) + 0x0800;
-        if ((err = pcmcia_map_mem_page(link, link->win, 0)))
+        local->dingo_ccr = ioremap(link->resource[2]->start, 0x1000) + 0x0800;
+        if ((err = pcmcia_map_mem_page(link, link->resource[2], 0)))
             goto config_error;
 
         /* Setup the CCRs; there are no infos in the CIS about the Ethernet
@@ -978,17 +932,12 @@ xirc2ps_config(struct pcmcia_device * link)
     return -ENODEV;
 } /* xirc2ps_config */
 
-/****************
- * After a card is removed, xirc2ps_release() will unregister the net
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
 static void
 xirc2ps_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "release\n");
 
-        if (link->win) {
+        if (link->resource[2]->end) {
                 struct net_device *dev = link->priv;
                 local_info_t *local = netdev_priv(dev);
                 if (local->dingo)
@@ -1830,9 +1779,7 @@ MODULE_DEVICE_TABLE(pcmcia, xirc2ps_ids);
 
 static struct pcmcia_driver xirc2ps_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "xirc2ps_cs",
-        },
+        .name           = "xirc2ps_cs",
         .probe          = xirc2ps_probe,
         .remove         = xirc2ps_detach,
         .id_table       = xirc2ps_ids,
diff --git a/drivers/net/ppp_async.c b/drivers/net/ppp_async.c
index af50a530daee..78d70a6481bf 100644
--- a/drivers/net/ppp_async.c
+++ b/drivers/net/ppp_async.c
@@ -184,7 +184,7 @@ ppp_asynctty_open(struct tty_struct *tty)
         tasklet_init(&ap->tsk, ppp_async_process, (unsigned long) ap);
 
         atomic_set(&ap->refcnt, 1);
-        init_MUTEX_LOCKED(&ap->dead_sem);
+        sema_init(&ap->dead_sem, 0);
 
         ap->chan.private = ap;
         ap->chan.ops = &async_ops;
diff --git a/drivers/net/r8169.c b/drivers/net/r8169.c
index a0da4a17b025..992db2fa136e 100644
--- a/drivers/net/r8169.c
+++ b/drivers/net/r8169.c
@@ -1212,7 +1212,8 @@ static void rtl8169_update_counters(struct net_device *dev)
         if ((RTL_R8(ChipCmd) & CmdRxEnb) == 0)
                 return;
 
-        counters = pci_alloc_consistent(tp->pci_dev, sizeof(*counters), &paddr);
+        counters = dma_alloc_coherent(&tp->pci_dev->dev, sizeof(*counters),
+                                      &paddr, GFP_KERNEL);
         if (!counters)
                 return;
 
@@ -1233,7 +1234,8 @@ static void rtl8169_update_counters(struct net_device *dev)
         RTL_W32(CounterAddrLow, 0);
         RTL_W32(CounterAddrHigh, 0);
 
-        pci_free_consistent(tp->pci_dev, sizeof(*counters), counters, paddr);
+        dma_free_coherent(&tp->pci_dev->dev, sizeof(*counters), counters,
+                          paddr);
 }
 
 static void rtl8169_get_ethtool_stats(struct net_device *dev,
@@ -3292,15 +3294,15 @@ static int rtl8169_open(struct net_device *dev)
 
         /*
          * Rx and Tx desscriptors needs 256 bytes alignment.
-         * pci_alloc_consistent provides more.
+         * dma_alloc_coherent provides more.
          */
-        tp->TxDescArray = pci_alloc_consistent(pdev, R8169_TX_RING_BYTES,
-                                               &tp->TxPhyAddr);
+        tp->TxDescArray = dma_alloc_coherent(&pdev->dev, R8169_TX_RING_BYTES,
+                                             &tp->TxPhyAddr, GFP_KERNEL);
         if (!tp->TxDescArray)
                 goto err_pm_runtime_put;
 
-        tp->RxDescArray = pci_alloc_consistent(pdev, R8169_RX_RING_BYTES,
-                                               &tp->RxPhyAddr);
+        tp->RxDescArray = dma_alloc_coherent(&pdev->dev, R8169_RX_RING_BYTES,
+                                             &tp->RxPhyAddr, GFP_KERNEL);
         if (!tp->RxDescArray)
                 goto err_free_tx_0;
 
@@ -3334,12 +3336,12 @@ out:
 err_release_ring_2:
         rtl8169_rx_clear(tp);
 err_free_rx_1:
-        pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray,
-                            tp->RxPhyAddr);
+        dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray,
+                          tp->RxPhyAddr);
         tp->RxDescArray = NULL;
 err_free_tx_0:
-        pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray,
-                            tp->TxPhyAddr);
+        dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray,
+                          tp->TxPhyAddr);
         tp->TxDescArray = NULL;
 err_pm_runtime_put:
         pm_runtime_put_noidle(&pdev->dev);
@@ -3975,7 +3977,7 @@ static void rtl8169_free_rx_skb(struct rtl8169_private *tp,
 {
         struct pci_dev *pdev = tp->pci_dev;
 
-        pci_unmap_single(pdev, le64_to_cpu(desc->addr), tp->rx_buf_sz,
+        dma_unmap_single(&pdev->dev, le64_to_cpu(desc->addr), tp->rx_buf_sz,
                          PCI_DMA_FROMDEVICE);
         dev_kfree_skb(*sk_buff);
         *sk_buff = NULL;
@@ -4000,7 +4002,7 @@ static inline void rtl8169_map_to_asic(struct RxDesc *desc, dma_addr_t mapping,
 static struct sk_buff *rtl8169_alloc_rx_skb(struct pci_dev *pdev,
                                             struct net_device *dev,
                                             struct RxDesc *desc, int rx_buf_sz,
-                                            unsigned int align)
+                                            unsigned int align, gfp_t gfp)
 {
         struct sk_buff *skb;
         dma_addr_t mapping;
@@ -4008,13 +4010,13 @@ static struct sk_buff *rtl8169_alloc_rx_skb(struct pci_dev *pdev,
 
         pad = align ? align : NET_IP_ALIGN;
 
-        skb = netdev_alloc_skb(dev, rx_buf_sz + pad);
+        skb = __netdev_alloc_skb(dev, rx_buf_sz + pad, gfp);
         if (!skb)
                 goto err_out;
 
         skb_reserve(skb, align ? ((pad - 1) & (unsigned long)skb->data) : pad);
 
-        mapping = pci_map_single(pdev, skb->data, rx_buf_sz,
+        mapping = dma_map_single(&pdev->dev, skb->data, rx_buf_sz,
                                  PCI_DMA_FROMDEVICE);
 
         rtl8169_map_to_asic(desc, mapping, rx_buf_sz);
@@ -4039,7 +4041,7 @@ static void rtl8169_rx_clear(struct rtl8169_private *tp)
 }
 
 static u32 rtl8169_rx_fill(struct rtl8169_private *tp, struct net_device *dev,
-                           u32 start, u32 end)
+                           u32 start, u32 end, gfp_t gfp)
 {
         u32 cur;
 
@@ -4054,7 +4056,7 @@ static u32 rtl8169_rx_fill(struct rtl8169_private *tp, struct net_device *dev,
 
                 skb = rtl8169_alloc_rx_skb(tp->pci_dev, dev,
                                            tp->RxDescArray + i,
-                                           tp->rx_buf_sz, tp->align);
+                                           tp->rx_buf_sz, tp->align, gfp);
                 if (!skb)
                         break;
 
@@ -4082,7 +4084,7 @@ static int rtl8169_init_ring(struct net_device *dev)
         memset(tp->tx_skb, 0x0, NUM_TX_DESC * sizeof(struct ring_info));
         memset(tp->Rx_skbuff, 0x0, NUM_RX_DESC * sizeof(struct sk_buff *));
 
-        if (rtl8169_rx_fill(tp, dev, 0, NUM_RX_DESC) != NUM_RX_DESC)
+        if (rtl8169_rx_fill(tp, dev, 0, NUM_RX_DESC, GFP_KERNEL) != NUM_RX_DESC)
                 goto err_out;
 
         rtl8169_mark_as_last_descriptor(tp->RxDescArray + NUM_RX_DESC - 1);
@@ -4099,7 +4101,8 @@ static void rtl8169_unmap_tx_skb(struct pci_dev *pdev, struct ring_info *tx_skb,
 {
         unsigned int len = tx_skb->len;
 
-        pci_unmap_single(pdev, le64_to_cpu(desc->addr), len, PCI_DMA_TODEVICE);
+        dma_unmap_single(&pdev->dev, le64_to_cpu(desc->addr), len,
+                         PCI_DMA_TODEVICE);
         desc->opts1 = 0x00;
         desc->opts2 = 0x00;
         desc->addr = 0x00;
@@ -4243,7 +4246,8 @@ static int rtl8169_xmit_frags(struct rtl8169_private *tp, struct sk_buff *skb,
                 txd = tp->TxDescArray + entry;
                 len = frag->size;
                 addr = ((void *) page_address(frag->page)) + frag->page_offset;
-                mapping = pci_map_single(tp->pci_dev, addr, len, PCI_DMA_TODEVICE);
+                mapping = dma_map_single(&tp->pci_dev->dev, addr, len,
+                                         PCI_DMA_TODEVICE);
 
                 /* anti gcc 2.95.3 bugware (sic) */
                 status = opts1 | len | (RingEnd * !((entry + 1) % NUM_TX_DESC));
@@ -4313,7 +4317,8 @@ static netdev_tx_t rtl8169_start_xmit(struct sk_buff *skb,
                 tp->tx_skb[entry].skb = skb;
         }
 
-        mapping = pci_map_single(tp->pci_dev, skb->data, len, PCI_DMA_TODEVICE);
+        mapping = dma_map_single(&tp->pci_dev->dev, skb->data, len,
+                                 PCI_DMA_TODEVICE);
 
         tp->tx_skb[entry].len = len;
         txd->addr = cpu_to_le64(mapping);
@@ -4477,8 +4482,8 @@ static inline bool rtl8169_try_rx_copy(struct sk_buff **sk_buff,
         if (!skb)
                 goto out;
 
-        pci_dma_sync_single_for_cpu(tp->pci_dev, addr, pkt_size,
-                                    PCI_DMA_FROMDEVICE);
+        dma_sync_single_for_cpu(&tp->pci_dev->dev, addr, pkt_size,
+                                PCI_DMA_FROMDEVICE);
         skb_copy_from_linear_data(*sk_buff, skb->data, pkt_size);
         *sk_buff = skb;
         done = true;
@@ -4549,11 +4554,11 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
                         rtl8169_rx_csum(skb, desc);
 
                         if (rtl8169_try_rx_copy(&skb, tp, pkt_size, addr)) {
-                                pci_dma_sync_single_for_device(pdev, addr,
+                                dma_sync_single_for_device(&pdev->dev, addr,
                                         pkt_size, PCI_DMA_FROMDEVICE);
                                 rtl8169_mark_to_asic(desc, tp->rx_buf_sz);
                         } else {
-                                pci_unmap_single(pdev, addr, tp->rx_buf_sz,
+                                dma_unmap_single(&pdev->dev, addr, tp->rx_buf_sz,
                                                  PCI_DMA_FROMDEVICE);
                                 tp->Rx_skbuff[entry] = NULL;
                         }
@@ -4583,7 +4588,7 @@ static int rtl8169_rx_interrupt(struct net_device *dev,
         count = cur_rx - tp->cur_rx;
         tp->cur_rx = cur_rx;
 
-        delta = rtl8169_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx);
+        delta = rtl8169_rx_fill(tp, dev, tp->dirty_rx, tp->cur_rx, GFP_ATOMIC);
         if (!delta && count)
                 netif_info(tp, intr, dev, "no Rx buffer allocated\n");
         tp->dirty_rx += delta;
@@ -4769,10 +4774,10 @@ static int rtl8169_close(struct net_device *dev)
 
         free_irq(dev->irq, dev);
 
-        pci_free_consistent(pdev, R8169_RX_RING_BYTES, tp->RxDescArray,
-                            tp->RxPhyAddr);
-        pci_free_consistent(pdev, R8169_TX_RING_BYTES, tp->TxDescArray,
-                            tp->TxPhyAddr);
+        dma_free_coherent(&pdev->dev, R8169_RX_RING_BYTES, tp->RxDescArray,
+                          tp->RxPhyAddr);
+        dma_free_coherent(&pdev->dev, R8169_TX_RING_BYTES, tp->TxDescArray,
+                          tp->TxPhyAddr);
         tp->TxDescArray = NULL;
         tp->RxDescArray = NULL;
 
diff --git a/drivers/net/skge.c b/drivers/net/skge.c
index 40e5c46e7571..465ae7e84507 100644
--- a/drivers/net/skge.c
+++ b/drivers/net/skge.c
@@ -43,6 +43,7 @@
 #include <linux/seq_file.h>
 #include <linux/mii.h>
 #include <linux/slab.h>
+#include <linux/dmi.h>
 #include <asm/irq.h>
 
 #include "skge.h"
@@ -3868,6 +3869,8 @@ static void __devinit skge_show_addr(struct net_device *dev)
         netif_info(skge, probe, skge->netdev, "addr %pM\n", dev->dev_addr);
 }
 
+static int only_32bit_dma;
+
 static int __devinit skge_probe(struct pci_dev *pdev,
                                 const struct pci_device_id *ent)
 {
@@ -3889,7 +3892,7 @@ static int __devinit skge_probe(struct pci_dev *pdev,
 
         pci_set_master(pdev);
 
-        if (!pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
+        if (!only_32bit_dma && !pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) {
                 using_dac = 1;
                 err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
         } else if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32)))) {
@@ -4147,8 +4150,21 @@ static struct pci_driver skge_driver = {
         .shutdown =     skge_shutdown,
 };
 
+static struct dmi_system_id skge_32bit_dma_boards[] = {
+        {
+                .ident = "Gigabyte nForce boards",
+                .matches = {
+                        DMI_MATCH(DMI_BOARD_VENDOR, "Gigabyte Technology Co"),
+                        DMI_MATCH(DMI_BOARD_NAME, "nForce"),
+                },
+        },
+        {}
+};
+
 static int __init skge_init_module(void)
 {
+        if (dmi_check_system(skge_32bit_dma_boards))
+                only_32bit_dma = 1;
         skge_debug_init();
         return pci_register_driver(&skge_driver);
 }
diff --git a/drivers/net/smc91x.c b/drivers/net/smc91x.c
index 10cf0cbc2185..726df611ee17 100644
--- a/drivers/net/smc91x.c
+++ b/drivers/net/smc91x.c
@@ -72,6 +72,7 @@ static const char version[] =
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/interrupt.h>
+#include <linux/irq.h>
 #include <linux/errno.h>
 #include <linux/ioport.h>
 #include <linux/crc32.h>
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index bc3af78a869f..1ec4b9e0239a 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -4666,7 +4666,7 @@ static int tg3_rx(struct tg3_napi *tnapi, int budget)
                                        desc_idx, *post_ptr);
                 drop_it_no_recycle:
                         /* Other statistics kept track of by card. */
-                        tp->net_stats.rx_dropped++;
+                        tp->rx_dropped++;
                         goto next_pkt;
                 }
 
@@ -4726,7 +4726,7 @@ static int tg3_rx(struct tg3_napi *tnapi, int budget)
                 if (len > (tp->dev->mtu + ETH_HLEN) &&
                     skb->protocol != htons(ETH_P_8021Q)) {
                         dev_kfree_skb(skb);
-                        goto next_pkt;
+                        goto drop_it_no_recycle;
                 }
 
                 if (desc->type_flags & RXD_FLAG_VLAN &&
@@ -9240,6 +9240,8 @@ static struct rtnl_link_stats64 *tg3_get_stats64(struct net_device *dev,
         stats->rx_missed_errors = old_stats->rx_missed_errors +
                 get_stat64(&hw_stats->rx_discards);
 
+        stats->rx_dropped = tp->rx_dropped;
+
         return stats;
 }
 
diff --git a/drivers/net/tg3.h b/drivers/net/tg3.h
index 4937bd190964..be7ff138a7f9 100644
--- a/drivers/net/tg3.h
+++ b/drivers/net/tg3.h
@@ -2759,7 +2759,7 @@ struct tg3 {
 
 
         /* begin "everything else" cacheline(s) section */
-        struct rtnl_link_stats64        net_stats;
+        unsigned long                   rx_dropped;
         struct rtnl_link_stats64        net_stats_prev;
         struct tg3_ethtool_stats        estats;
         struct tg3_ethtool_stats        estats_prev;
diff --git a/drivers/net/wan/cosa.c b/drivers/net/wan/cosa.c
index 04c6cd4333f1..10bafd59f9c3 100644
--- a/drivers/net/wan/cosa.c
+++ b/drivers/net/wan/cosa.c
@@ -575,7 +575,7 @@ static int cosa_probe(int base, int irq, int dma)
 
                 /* Initialize the chardev data structures */
                 mutex_init(&chan->rlock);
-                init_MUTEX(&chan->wsem);
+                sema_init(&chan->wsem, 1);
 
                 /* Register the network interface */
                 if (!(chan->netdev = alloc_hdlcdev(chan))) {
diff --git a/drivers/net/wimax/i2400m/rx.c b/drivers/net/wimax/i2400m/rx.c
index 8cc9e319f435..1737d1488b35 100644
--- a/drivers/net/wimax/i2400m/rx.c
+++ b/drivers/net/wimax/i2400m/rx.c
@@ -1244,16 +1244,16 @@ int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb)
         int i, result;
         struct device *dev = i2400m_dev(i2400m);
         const struct i2400m_msg_hdr *msg_hdr;
-        size_t pl_itr, pl_size, skb_len;
+        size_t pl_itr, pl_size;
         unsigned long flags;
-        unsigned num_pls, single_last;
+        unsigned num_pls, single_last, skb_len;
 
         skb_len = skb->len;
-        d_fnstart(4, dev, "(i2400m %p skb %p [size %zu])\n",
+        d_fnstart(4, dev, "(i2400m %p skb %p [size %u])\n",
                   i2400m, skb, skb_len);
         result = -EIO;
         msg_hdr = (void *) skb->data;
-        result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb->len);
+        result = i2400m_rx_msg_hdr_check(i2400m, msg_hdr, skb_len);
         if (result < 0)
                 goto error_msg_hdr_check;
         result = -EIO;
@@ -1261,10 +1261,10 @@ int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb)
         pl_itr = sizeof(*msg_hdr) +     /* Check payload descriptor(s) */
                 num_pls * sizeof(msg_hdr->pld[0]);
         pl_itr = ALIGN(pl_itr, I2400M_PL_ALIGN);
-        if (pl_itr > skb->len) {        /* got all the payload descriptors? */
+        if (pl_itr > skb_len) { /* got all the payload descriptors? */
                 dev_err(dev, "RX: HW BUG? message too short (%u bytes) for "
                         "%u payload descriptors (%zu each, total %zu)\n",
-                        skb->len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr);
+                        skb_len, num_pls, sizeof(msg_hdr->pld[0]), pl_itr);
                 goto error_pl_descr_short;
         }
         /* Walk each payload payload--check we really got it */
@@ -1272,7 +1272,7 @@ int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb)
                 /* work around old gcc warnings */
                 pl_size = i2400m_pld_size(&msg_hdr->pld[i]);
                 result = i2400m_rx_pl_descr_check(i2400m, &msg_hdr->pld[i],
-                                                  pl_itr, skb->len);
+                                                  pl_itr, skb_len);
                 if (result < 0)
                         goto error_pl_descr_check;
                 single_last = num_pls == 1 || i == num_pls - 1;
@@ -1290,16 +1290,16 @@ int i2400m_rx(struct i2400m *i2400m, struct sk_buff *skb)
         if (i < i2400m->rx_pl_min)
                 i2400m->rx_pl_min = i;
         i2400m->rx_num++;
-        i2400m->rx_size_acc += skb->len;
-        if (skb->len < i2400m->rx_size_min)
-                i2400m->rx_size_min = skb->len;
-        if (skb->len > i2400m->rx_size_max)
-                i2400m->rx_size_max = skb->len;
+        i2400m->rx_size_acc += skb_len;
+        if (skb_len < i2400m->rx_size_min)
+                i2400m->rx_size_min = skb_len;
+        if (skb_len > i2400m->rx_size_max)
+                i2400m->rx_size_max = skb_len;
         spin_unlock_irqrestore(&i2400m->rx_lock, flags);
 error_pl_descr_check:
 error_pl_descr_short:
 error_msg_hdr_check:
-        d_fnend(4, dev, "(i2400m %p skb %p [size %zu]) = %d\n",
+        d_fnend(4, dev, "(i2400m %p skb %p [size %u]) = %d\n",
                 i2400m, skb, skb_len, result);
         return result;
 }
diff --git a/drivers/net/wireless/airo_cs.c b/drivers/net/wireless/airo_cs.c
index 9a121a5b787c..df2484d45474 100644
--- a/drivers/net/wireless/airo_cs.c
+++ b/drivers/net/wireless/airo_cs.c
@@ -32,7 +32,6 @@
 #include <linux/timer.h>
 #include <linux/netdevice.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -54,58 +53,21 @@ MODULE_SUPPORTED_DEVICE("Aironet 4500, 4800 and Cisco 340 PCMCIA cards");
 
 /*====================================================================*/
 
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card
-   insertion and ejection events.  They are invoked from the airo_cs
-   event handler.
-*/
-
 static int airo_config(struct pcmcia_device *link);
 static void airo_release(struct pcmcia_device *link);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void airo_detach(struct pcmcia_device *p_dev);
 
 typedef struct local_info_t {
         struct net_device *eth_dev;
 } local_info_t;
 
-/*======================================================================
-
-  airo_attach() creates an "instance" of the driver, allocating
-  local data structures for one device.  The device is registered
-  with Card Services.
-
-  The dev_link structure is initialized, but we don't actually
-  configure the card at this point -- we wait until we receive a
-  card insertion event.
-
-  ======================================================================*/
-
 static int airo_probe(struct pcmcia_device *p_dev)
 {
         local_info_t *local;
 
         dev_dbg(&p_dev->dev, "airo_attach()\n");
 
-        /*
-          General socket configuration defaults can go here.  In this
-          client, we assume very little, and rely on the CIS for almost
-          everything.  In most clients, many details (i.e., number, sizes,
-          and attributes of IO windows) are fixed by the nature of the
-          device, and can be hard-wired here.
-        */
-        p_dev->conf.Attributes = 0;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
-
         /* Allocate space for private device-specific data */
         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
         if (!local) {
@@ -117,15 +79,6 @@ static int airo_probe(struct pcmcia_device *p_dev)
         return airo_config(p_dev);
 } /* airo_attach */
 
-/*======================================================================
-
-  This deletes a driver "instance".  The device is de-registered
-  with Card Services.  If it has been released, all local data
-  structures are freed.  Otherwise, the structures will be freed
-  when the device is released.
-
-  ======================================================================*/
-
 static void airo_detach(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "airo_detach\n");
@@ -140,60 +93,12 @@ static void airo_detach(struct pcmcia_device *link)
         kfree(link->priv);
 } /* airo_detach */
 
-/*======================================================================
-
-  airo_config() is scheduled to run after a CARD_INSERTION event
-  is received, to configure the PCMCIA socket, and to make the
-  device available to the system.
-
-  ======================================================================*/
-
-static int airo_cs_config_check(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int airo_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
-        else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM]/10000;
-
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* This reserves IO space but doesn't actually enable it */
-        if (pcmcia_request_io(p_dev) != 0)
-                return -ENODEV;
-
-        /* If we got this far, we're cool! */
-        return 0;
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -206,20 +111,9 @@ static int airo_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "airo_config\n");
 
-        /*
-         * In this loop, we scan the CIS for configuration table
-         * entries, each of which describes a valid card
-         * configuration, including voltage, IO window, memory window,
-         * and interrupt settings.
-         *
-         * We make no assumptions about the card to be configured: we
-         * use just the information available in the CIS.  In an ideal
-         * world, this would work for any PCMCIA card, but it requires
-         * a complete and accurate CIS.  In practice, a driver usually
-         * "knows" most of these things without consulting the CIS,
-         * and most client drivers will only use the CIS to fill in
-         * implementation-defined details.
-         */
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, airo_cs_config_check, NULL);
         if (ret)
                 goto failed;
@@ -227,12 +121,7 @@ static int airo_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-          This actually configures the PCMCIA socket -- setting up
-          the I/O windows and the interrupt mapping, and putting the
-          card and host interface into "Memory and IO" mode.
-        */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
         ((local_info_t *)link->priv)->eth_dev =
@@ -241,17 +130,6 @@ static int airo_config(struct pcmcia_device *link)
         if (!((local_info_t *)link->priv)->eth_dev)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x: ",
-               link->conf.ConfigIndex);
-        if (link->conf.Vpp)
-                printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
-        printk(", irq %d", link->irq);
-        if (link->resource[0])
-                printk(" & %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
         return 0;
 
  failed:
@@ -259,14 +137,6 @@ static int airo_config(struct pcmcia_device *link)
         return -ENODEV;
 } /* airo_config */
 
-/*======================================================================
-
-  After a card is removed, airo_release() will unregister the
-  device, and release the PCMCIA configuration.  If the device is
-  still open, this will be postponed until it is closed.
-
-  ======================================================================*/
-
 static void airo_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "airo_release\n");
@@ -305,9 +175,7 @@ MODULE_DEVICE_TABLE(pcmcia, airo_ids);
 
 static struct pcmcia_driver airo_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "airo_cs",
-        },
+        .name           = "airo_cs",
         .probe          = airo_probe,
         .remove         = airo_detach,
         .id_table       = airo_ids,
@@ -315,12 +183,12 @@ static struct pcmcia_driver airo_driver = {
         .resume         = airo_resume,
 };
 
-static int airo_cs_init(void)
+static int __init airo_cs_init(void)
 {
         return pcmcia_register_driver(&airo_driver);
 }
 
-static void airo_cs_cleanup(void)
+static void __exit airo_cs_cleanup(void)
 {
         pcmcia_unregister_driver(&airo_driver);
 }
diff --git a/drivers/net/wireless/ath/ath9k/ani.c b/drivers/net/wireless/ath/ath9k/ani.c
index cc648b6ae31c..a3d95cca8f0c 100644
--- a/drivers/net/wireless/ath/ath9k/ani.c
+++ b/drivers/net/wireless/ath/ath9k/ani.c
@@ -543,7 +543,7 @@ static u8 ath9k_hw_chan_2_clockrate_mhz(struct ath_hw *ah)
         if (conf_is_ht40(conf))
                 return clockrate * 2;
 
-        return clockrate * 2;
+        return clockrate;
 }
 
 static int32_t ath9k_hw_ani_get_listen_time(struct ath_hw *ah)
diff --git a/drivers/net/wireless/atmel_cs.c b/drivers/net/wireless/atmel_cs.c
index 3b632161c106..c96e19da2949 100644
--- a/drivers/net/wireless/atmel_cs.c
+++ b/drivers/net/wireless/atmel_cs.c
@@ -42,7 +42,6 @@
 #include <linux/moduleparam.h>
 #include <linux/device.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -64,58 +63,21 @@ MODULE_SUPPORTED_DEVICE("Atmel at76c50x PCMCIA cards");
 
 /*====================================================================*/
 
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card
-   insertion and ejection events.  They are invoked from the atmel_cs
-   event handler.
-*/
-
 static int atmel_config(struct pcmcia_device *link);
 static void atmel_release(struct pcmcia_device *link);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static void atmel_detach(struct pcmcia_device *p_dev);
 
 typedef struct local_info_t {
         struct net_device *eth_dev;
 } local_info_t;
 
-/*======================================================================
-
-  atmel_attach() creates an "instance" of the driver, allocating
-  local data structures for one device.  The device is registered
-  with Card Services.
-
-  The dev_link structure is initialized, but we don't actually
-  configure the card at this point -- we wait until we receive a
-  card insertion event.
-
-  ======================================================================*/
-
 static int atmel_probe(struct pcmcia_device *p_dev)
 {
         local_info_t *local;
 
         dev_dbg(&p_dev->dev, "atmel_attach()\n");
 
-        /*
-          General socket configuration defaults can go here.  In this
-          client, we assume very little, and rely on the CIS for almost
-          everything.  In most clients, many details (i.e., number, sizes,
-          and attributes of IO windows) are fixed by the nature of the
-          device, and can be hard-wired here.
-        */
-        p_dev->conf.Attributes = 0;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
-
         /* Allocate space for private device-specific data */
         local = kzalloc(sizeof(local_info_t), GFP_KERNEL);
         if (!local) {
@@ -127,15 +89,6 @@ static int atmel_probe(struct pcmcia_device *p_dev)
         return atmel_config(p_dev);
 } /* atmel_attach */
 
-/*======================================================================
-
-  This deletes a driver "instance".  The device is de-registered
-  with Card Services.  If it has been released, all local data
-  structures are freed.  Otherwise, the structures will be freed
-  when the device is released.
-
-  ======================================================================*/
-
 static void atmel_detach(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "atmel_detach\n");
@@ -145,14 +98,6 @@ static void atmel_detach(struct pcmcia_device *link)
         kfree(link->priv);
 }
 
-/*======================================================================
-
-  atmel_config() is scheduled to run after a CARD_INSERTION event
-  is received, to configure the PCMCIA socket, and to make the
-  device available to the system.
-
-  ======================================================================*/
-
 /* Call-back function to interrogate PCMCIA-specific information
    about the current existance of the card */
 static int card_present(void *arg)
@@ -165,47 +110,11 @@ static int card_present(void *arg)
         return 0;
 }
 
-static int atmel_config_check(struct pcmcia_device *p_dev,
-                              cistpl_cftable_entry_t *cfg,
-                              cistpl_cftable_entry_t *dflt,
-                              unsigned int vcc,
-                              void *priv_data)
+static int atmel_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
-        else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM]/10000;
-
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-        }
-
-        /* This reserves IO space but doesn't actually enable it */
         return pcmcia_request_io(p_dev);
 }
 
@@ -220,18 +129,9 @@ static int atmel_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "atmel_config\n");
 
-        /*
-          In this loop, we scan the CIS for configuration table entries,
-          each of which describes a valid card configuration, including
-          voltage, IO window, memory window, and interrupt settings.
-
-          We make no assumptions about the card to be configured: we use
-          just the information available in the CIS.  In an ideal world,
-          this would work for any PCMCIA card, but it requires a complete
-          and accurate CIS.  In practice, a driver usually "knows" most of
-          these things without consulting the CIS, and most client drivers
-          will only use the CIS to fill in implementation-defined details.
-        */
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
+
         if (pcmcia_loop_config(link, atmel_config_check, NULL))
                 goto failed;
 
@@ -240,12 +140,7 @@ static int atmel_config(struct pcmcia_device *link)
                 goto failed;
         }
 
-        /*
-          This actually configures the PCMCIA socket -- setting up
-          the I/O windows and the interrupt mapping, and putting the
-          card and host interface into "Memory and IO" mode.
-        */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -267,14 +162,6 @@ static int atmel_config(struct pcmcia_device *link)
         return -ENODEV;
 }
 
-/*======================================================================
-
-  After a card is removed, atmel_release() will unregister the
-  device, and release the PCMCIA configuration.  If the device is
-  still open, this will be postponed until it is closed.
-
-  ======================================================================*/
-
 static void atmel_release(struct pcmcia_device *link)
 {
         struct net_device *dev = ((local_info_t*)link->priv)->eth_dev;
@@ -353,9 +240,7 @@ MODULE_DEVICE_TABLE(pcmcia, atmel_ids);
 
 static struct pcmcia_driver atmel_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "atmel_cs",
-        },
+        .name           = "atmel_cs",
         .probe          = atmel_probe,
         .remove         = atmel_detach,
         .id_table       = atmel_ids,
@@ -363,12 +248,12 @@ static struct pcmcia_driver atmel_driver = {
         .resume         = atmel_resume,
 };
 
-static int atmel_cs_init(void)
+static int __init atmel_cs_init(void)
 {
         return pcmcia_register_driver(&atmel_driver);
 }
 
-static void atmel_cs_cleanup(void)
+static void __exit atmel_cs_cleanup(void)
 {
         pcmcia_unregister_driver(&atmel_driver);
 }
diff --git a/drivers/net/wireless/b43/pcmcia.c b/drivers/net/wireless/b43/pcmcia.c
index dfbc41d431ff..7dcba5fafdc7 100644
--- a/drivers/net/wireless/b43/pcmcia.c
+++ b/drivers/net/wireless/b43/pcmcia.c
@@ -26,7 +26,6 @@
 #include <linux/ssb/ssb.h>
 #include <linux/slab.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -63,7 +62,6 @@ static int b43_pcmcia_resume(struct pcmcia_device *dev)
 static int __devinit b43_pcmcia_probe(struct pcmcia_device *dev)
 {
         struct ssb_bus *ssb;
-        win_req_t win;
         int err = -ENOMEM;
         int res = 0;
 
@@ -73,30 +71,28 @@ static int __devinit b43_pcmcia_probe(struct pcmcia_device *dev)
 
         err = -ENODEV;
 
-        dev->conf.Attributes = CONF_ENABLE_IRQ;
-        dev->conf.IntType = INT_MEMORY_AND_IO;
+        dev->config_flags |= CONF_ENABLE_IRQ;
 
-        win.Attributes =  WIN_ENABLE | WIN_DATA_WIDTH_16 |
+        dev->resource[2]->flags |=  WIN_ENABLE | WIN_DATA_WIDTH_16 |
                          WIN_USE_WAIT;
-        win.Base = 0;
-        win.Size = SSB_CORE_SIZE;
-        win.AccessSpeed = 250;
-        res = pcmcia_request_window(dev, &win, &dev->win);
+        dev->resource[2]->start = 0;
+        dev->resource[2]->end = SSB_CORE_SIZE;
+        res = pcmcia_request_window(dev, dev->resource[2], 250);
         if (res != 0)
                 goto err_kfree_ssb;
 
-        res = pcmcia_map_mem_page(dev, dev->win, 0);
+        res = pcmcia_map_mem_page(dev, dev->resource[2], 0);
         if (res != 0)
                 goto err_disable;
 
         if (!dev->irq)
                 goto err_disable;
 
-        res = pcmcia_request_configuration(dev, &dev->conf);
+        res = pcmcia_enable_device(dev);
         if (res != 0)
                 goto err_disable;
 
-        err = ssb_bus_pcmciabus_register(ssb, dev, win.Base);
+        err = ssb_bus_pcmciabus_register(ssb, dev, dev->resource[2]->start);
         if (err)
                 goto err_disable;
         dev->priv = ssb;
@@ -125,9 +121,7 @@ static void __devexit b43_pcmcia_remove(struct pcmcia_device *dev)
 
 static struct pcmcia_driver b43_pcmcia_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                                .name = "b43-pcmcia",
-                        },
+        .name           = "b43-pcmcia",
         .id_table       = b43_pcmcia_tbl,
         .probe          = b43_pcmcia_probe,
         .remove         = __devexit_p(b43_pcmcia_remove),
diff --git a/drivers/net/wireless/hostap/hostap_cs.c b/drivers/net/wireless/hostap/hostap_cs.c
index ba54d1b04d22..bd8a4134edeb 100644
--- a/drivers/net/wireless/hostap/hostap_cs.c
+++ b/drivers/net/wireless/hostap/hostap_cs.c
@@ -12,7 +12,6 @@
 #include <linux/wireless.h>
 #include <net/iw_handler.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -437,7 +436,6 @@ static int hostap_cs_probe(struct pcmcia_device *p_dev)
         int ret;
 
         PDEBUG(DEBUG_HW, "%s: setting Vcc=33 (constant)\n", dev_info);
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
 
         ret = prism2_config(p_dev);
         if (ret) {
@@ -468,74 +466,11 @@ static void prism2_detach(struct pcmcia_device *link)
 }
 
 
-/* run after a CARD_INSERTION event is received to configure the PCMCIA
- * socket and make the device available to the system */
-
-static int prism2_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cfg,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int prism2_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        PDEBUG(DEBUG_EXTRA, "Checking CFTABLE_ENTRY 0x%02X "
-               "(default 0x%02X)\n", cfg->index, dflt->index);
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] /
-                    10000 && !ignore_cis_vcc) {
-                        PDEBUG(DEBUG_EXTRA, "  Vcc mismatch - skipping"
-                               " this entry\n");
-                        return -ENODEV;
-                }
-        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] /
-                    10000 && !ignore_cis_vcc) {
-                        PDEBUG(DEBUG_EXTRA, "  Vcc (default) mismatch "
-                               "- skipping this entry\n");
-                        return -ENODEV;
-                }
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp = dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        PDEBUG(DEBUG_EXTRA, "IO window settings: cfg->io.nwin=%d "
-               "dflt->io.nwin=%d\n",
-               cfg->io.nwin, dflt->io.nwin);
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-        }
-
-        /* This reserves IO space but doesn't actually enable it */
         return pcmcia_request_io(p_dev);
 }
 
@@ -557,6 +492,10 @@ static int prism2_config(struct pcmcia_device *link)
         }
 
         /* Look for an appropriate configuration table entry in the CIS */
+        link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO |
+                CONF_AUTO_CHECK_VCC | CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
+        if (ignore_cis_vcc)
+                link->config_flags &= ~CONF_AUTO_CHECK_VCC;
         ret = pcmcia_loop_config(link, prism2_config_check, NULL);
         if (ret) {
                 if (!ignore_cis_vcc)
@@ -588,12 +527,7 @@ static int prism2_config(struct pcmcia_device *link)
         if (ret)
                 goto failed_unlock;
 
-        /*
-         * This actually configures the PCMCIA socket -- setting up
-         * the I/O windows and the interrupt mapping, and putting the
-         * card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed_unlock;
 
@@ -602,20 +536,6 @@ static int prism2_config(struct pcmcia_device *link)
 
         spin_unlock_irqrestore(&local->irq_init_lock, flags);
 
-        /* Finally, report what we've done */
-        printk(KERN_INFO "%s: index 0x%02x: ",
-               dev_info, link->conf.ConfigIndex);
-        if (link->conf.Vpp)
-                printk(", Vpp %d.%d", link->conf.Vpp / 10,
-                       link->conf.Vpp % 10);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %d", link->irq);
-        if (link->resource[0])
-                printk(" & %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         local->shutdown = 0;
 
         sandisk_enable_wireless(dev);
@@ -627,7 +547,7 @@ static int prism2_config(struct pcmcia_device *link)
         return ret;
 
  failed_unlock:
-         spin_unlock_irqrestore(&local->irq_init_lock, flags);
+        spin_unlock_irqrestore(&local->irq_init_lock, flags);
  failed:
         kfree(hw_priv);
         prism2_release((u_long)link);
@@ -779,9 +699,7 @@ MODULE_DEVICE_TABLE(pcmcia, hostap_cs_ids);
 
 
 static struct pcmcia_driver hostap_driver = {
-        .drv            = {
-                .name   = "hostap_cs",
-        },
+        .name           = "hostap_cs",
         .probe          = hostap_cs_probe,
         .remove         = prism2_detach,
         .owner          = THIS_MODULE,
diff --git a/drivers/net/wireless/libertas/if_cs.c b/drivers/net/wireless/libertas/if_cs.c
index 9c298396be50..ff1280f41336 100644
--- a/drivers/net/wireless/libertas/if_cs.c
+++ b/drivers/net/wireless/libertas/if_cs.c
@@ -28,7 +28,6 @@
 #include <linux/firmware.h>
 #include <linux/netdevice.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -761,15 +760,6 @@ static int if_cs_host_to_card(struct lbs_private *priv,
 }
 
 
-/********************************************************************/
-/* Card Services                                                    */
-/********************************************************************/
-
-/*
- * After a card is removed, if_cs_release() will unregister the
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
 static void if_cs_release(struct pcmcia_device *p_dev)
 {
         struct if_cs_card *card = p_dev->priv;
@@ -785,31 +775,12 @@ static void if_cs_release(struct pcmcia_device *p_dev)
 }
 
 
-/*
- * This creates an "instance" of the driver, allocating local data
- * structures for one device.  The device is registered with Card
- * Services.
- *
- * The dev_link structure is initialized, but we don't actually
- * configure the card at this point -- we wait until we receive a card
- * insertion event.
- */
-
-static int if_cs_ioprobe(struct pcmcia_device *p_dev,
-                         cistpl_cftable_entry_t *cfg,
-                         cistpl_cftable_entry_t *dflt,
-                         unsigned int vcc,
-                         void *priv_data)
+static int if_cs_ioprobe(struct pcmcia_device *p_dev, void *priv_data)
 {
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
 
-        /* IO window settings */
-        if (cfg->io.nwin != 1) {
+        if (p_dev->resource[1]->end) {
                 lbs_pr_err("wrong CIS (check number of IO windows)\n");
                 return -ENODEV;
         }
@@ -835,15 +806,13 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
         card->p_dev = p_dev;
         p_dev->priv = card;
 
-        p_dev->conf.Attributes = 0;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
+        p_dev->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
         if (pcmcia_loop_config(p_dev, if_cs_ioprobe, NULL)) {
                 lbs_pr_err("error in pcmcia_loop_config\n");
                 goto out1;
         }
 
-
         /*
          * Allocate an interrupt line.  Note that this does not assign
          * a handler to the interrupt, unless the 'Handler' member of
@@ -861,14 +830,9 @@ static int if_cs_probe(struct pcmcia_device *p_dev)
                 goto out1;
         }
 
-        /*
-         * This actually configures the PCMCIA socket -- setting up
-         * the I/O windows and the interrupt mapping, and putting the
-         * card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
+        ret = pcmcia_enable_device(p_dev);
         if (ret) {
-                lbs_pr_err("error in pcmcia_request_configuration\n");
+                lbs_pr_err("error in pcmcia_enable_device\n");
                 goto out2;
         }
 
@@ -962,12 +926,6 @@ out:
 }
 
 
-/*
- * This deletes a driver "instance".  The device is de-registered with
- * Card Services.  If it has been released, all local data structures
- * are freed.  Otherwise, the structures will be freed when the device
- * is released.
- */
 static void if_cs_detach(struct pcmcia_device *p_dev)
 {
         struct if_cs_card *card = p_dev->priv;
@@ -1000,9 +958,7 @@ MODULE_DEVICE_TABLE(pcmcia, if_cs_ids);
 
 static struct pcmcia_driver lbs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = DRV_NAME,
-        },
+        .name           = DRV_NAME,
         .probe          = if_cs_probe,
         .remove         = if_cs_detach,
         .id_table       = if_cs_ids,
diff --git a/drivers/net/wireless/orinoco/orinoco_cs.c b/drivers/net/wireless/orinoco/orinoco_cs.c
index ef46a2d88539..71b3d68b9403 100644
--- a/drivers/net/wireless/orinoco/orinoco_cs.c
+++ b/drivers/net/wireless/orinoco/orinoco_cs.c
@@ -17,7 +17,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -93,14 +92,6 @@ orinoco_cs_hard_reset(struct orinoco_private *priv)
 /* PCMCIA stuff                                                     */
 /********************************************************************/
 
-/*
- * This creates an "instance" of the driver, allocating local data
- * structures for one device.  The device is registered with Card
- * Services.
- *
- * The dev_link structure is initialized, but we don't actually
- * configure the card at this point -- we wait until we receive a card
- * insertion event.  */
 static int
 orinoco_cs_probe(struct pcmcia_device *link)
 {
@@ -117,23 +108,9 @@ orinoco_cs_probe(struct pcmcia_device *link)
         card->p_dev = link;
         link->priv = priv;
 
-        /* General socket configuration defaults can go here.  In this
-         * client, we assume very little, and rely on the CIS for
-         * almost everything.  In most clients, many details (i.e.,
-         * number, sizes, and attributes of IO windows) are fixed by
-         * the nature of the device, and can be hard-wired here. */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         return orinoco_cs_config(link);
 }                               /* orinoco_cs_attach */
 
-/*
- * This deletes a driver "instance".  The device is de-registered with
- * Card Services.  If it has been released, all local data structures
- * are freed.  Otherwise, the structures will be freed when the device
- * is released.
- */
 static void orinoco_cs_detach(struct pcmcia_device *link)
 {
         struct orinoco_private *priv = link->priv;
@@ -145,76 +122,12 @@ static void orinoco_cs_detach(struct pcmcia_device *link)
         free_orinocodev(priv);
 }                               /* orinoco_cs_detach */
 
-/*
- * orinoco_cs_config() is scheduled to run after a CARD_INSERTION
- * event is received, to configure the PCMCIA socket, and to make the
- * device available to the system.
- */
-
-static int orinoco_cs_config_check(struct pcmcia_device *p_dev,
-                                   cistpl_cftable_entry_t *cfg,
-                                   cistpl_cftable_entry_t *dflt,
-                                   unsigned int vcc,
-                                   void *priv_data)
+static int orinoco_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                goto next_entry;
-
-        /* Use power settings for Vcc and Vpp if present */
-        /* Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                        DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
-                              __func__, vcc,
-                              cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
-                        if (!ignore_cis_vcc)
-                                goto next_entry;
-                }
-        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                        DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
-                              __func__, vcc,
-                              dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
-                        if (!ignore_cis_vcc)
-                                goto next_entry;
-                }
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-
-                /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev) != 0)
-                        goto next_entry;
-        }
-        return 0;
-
-next_entry:
-        pcmcia_disable_device(p_dev);
-        return -ENODEV;
+        return pcmcia_request_io(p_dev);
 };
 
 static int
@@ -225,20 +138,10 @@ orinoco_cs_config(struct pcmcia_device *link)
         int ret;
         void __iomem *mem;
 
-        /*
-         * In this loop, we scan the CIS for configuration table
-         * entries, each of which describes a valid card
-         * configuration, including voltage, IO window, memory window,
-         * and interrupt settings.
-         *
-         * We make no assumptions about the card to be configured: we
-         * use just the information available in the CIS.  In an ideal
-         * world, this would work for any PCMCIA card, but it requires
-         * a complete and accurate CIS.  In practice, a driver usually
-         * "knows" most of these things without consulting the CIS,
-         * and most client drivers will only use the CIS to fill in
-         * implementation-defined details.
-         */
+        link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC |
+                CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
+        if (ignore_cis_vcc)
+                link->config_flags &= ~CONF_AUTO_CHECK_VCC;
         ret = pcmcia_loop_config(link, orinoco_cs_config_check, NULL);
         if (ret) {
                 if (!ignore_cis_vcc)
@@ -262,12 +165,7 @@ orinoco_cs_config(struct pcmcia_device *link)
 
         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
 
-        /*
-         * This actually configures the PCMCIA socket -- setting up
-         * the I/O windows and the interrupt mapping, and putting the
-         * card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -291,11 +189,6 @@ orinoco_cs_config(struct pcmcia_device *link)
         return -ENODEV;
 }                               /* orinoco_cs_config */
 
-/*
- * After a card is removed, orinoco_cs_release() will unregister the
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
 static void
 orinoco_cs_release(struct pcmcia_device *link)
 {
@@ -344,12 +237,6 @@ static int orinoco_cs_resume(struct pcmcia_device *link)
 /* Module initialization                                            */
 /********************************************************************/
 
-/* Can't be declared "const" or the whole __initdata section will
- * become const */
-static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
-        " (David Gibson <hermes@gibson.dropbear.id.au>, "
-        "Pavel Roskin <proski@gnu.org>, et al)";
-
 static struct pcmcia_device_id orinoco_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x0101, 0x0777), /* 3Com AirConnect PCI 777A */
         PCMCIA_DEVICE_MANF_CARD(0x0156, 0x0002), /* Lucent Orinoco and old Intersil */
@@ -441,9 +328,7 @@ MODULE_DEVICE_TABLE(pcmcia, orinoco_cs_ids);
 
 static struct pcmcia_driver orinoco_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = DRIVER_NAME,
-        },
+        .name           = DRIVER_NAME,
         .probe          = orinoco_cs_probe,
         .remove         = orinoco_cs_detach,
         .id_table       = orinoco_cs_ids,
@@ -454,8 +339,6 @@ static struct pcmcia_driver orinoco_driver = {
 static int __init
 init_orinoco_cs(void)
 {
-        printk(KERN_DEBUG "%s\n", version);
-
         return pcmcia_register_driver(&orinoco_driver);
 }
 
diff --git a/drivers/net/wireless/orinoco/spectrum_cs.c b/drivers/net/wireless/orinoco/spectrum_cs.c
index 873877e17e1b..fb859a5ad2eb 100644
--- a/drivers/net/wireless/orinoco/spectrum_cs.c
+++ b/drivers/net/wireless/orinoco/spectrum_cs.c
@@ -25,7 +25,6 @@
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/delay.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -154,14 +153,6 @@ spectrum_cs_stop_firmware(struct orinoco_private *priv, int idle)
 /* PCMCIA stuff                                                     */
 /********************************************************************/
 
-/*
- * This creates an "instance" of the driver, allocating local data
- * structures for one device.  The device is registered with Card
- * Services.
- *
- * The dev_link structure is initialized, but we don't actually
- * configure the card at this point -- we wait until we receive a card
- * insertion event.  */
 static int
 spectrum_cs_probe(struct pcmcia_device *link)
 {
@@ -179,23 +170,9 @@ spectrum_cs_probe(struct pcmcia_device *link)
         card->p_dev = link;
         link->priv = priv;
 
-        /* General socket configuration defaults can go here.  In this
-         * client, we assume very little, and rely on the CIS for
-         * almost everything.  In most clients, many details (i.e.,
-         * number, sizes, and attributes of IO windows) are fixed by
-         * the nature of the device, and can be hard-wired here. */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         return spectrum_cs_config(link);
 }                               /* spectrum_cs_attach */
 
-/*
- * This deletes a driver "instance".  The device is de-registered with
- * Card Services.  If it has been released, all local data structures
- * are freed.  Otherwise, the structures will be freed when the device
- * is released.
- */
 static void spectrum_cs_detach(struct pcmcia_device *link)
 {
         struct orinoco_private *priv = link->priv;
@@ -207,76 +184,13 @@ static void spectrum_cs_detach(struct pcmcia_device *link)
         free_orinocodev(priv);
 }                               /* spectrum_cs_detach */
 
-/*
- * spectrum_cs_config() is scheduled to run after a CARD_INSERTION
- * event is received, to configure the PCMCIA socket, and to make the
- * device available to the system.
- */
-
 static int spectrum_cs_config_check(struct pcmcia_device *p_dev,
-                                    cistpl_cftable_entry_t *cfg,
-                                    cistpl_cftable_entry_t *dflt,
-                                    unsigned int vcc,
                                     void *priv_data)
 {
-        if (cfg->index == 0)
-                goto next_entry;
-
-        /* Use power settings for Vcc and Vpp if present */
-        /* Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                        DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
-                              __func__, vcc,
-                              cfg->vcc.param[CISTPL_POWER_VNOM] / 10000);
-                        if (!ignore_cis_vcc)
-                                goto next_entry;
-                }
-        } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
-                if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000) {
-                        DEBUG(2, "%s: Vcc mismatch (vcc = %d, CIS = %d)\n",
-                              __func__, vcc,
-                              dflt->vcc.param[CISTPL_POWER_VNOM] / 10000);
-                        if (!ignore_cis_vcc)
-                                goto next_entry;
-                }
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-        else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-
-                /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev) != 0)
-                        goto next_entry;
-        }
-        return 0;
-
-next_entry:
-        pcmcia_disable_device(p_dev);
-        return -ENODEV;
+        return pcmcia_request_io(p_dev);
 };
 
 static int
@@ -287,20 +201,10 @@ spectrum_cs_config(struct pcmcia_device *link)
         int ret;
         void __iomem *mem;
 
-        /*
-         * In this loop, we scan the CIS for configuration table
-         * entries, each of which describes a valid card
-         * configuration, including voltage, IO window, memory window,
-         * and interrupt settings.
-         *
-         * We make no assumptions about the card to be configured: we
-         * use just the information available in the CIS.  In an ideal
-         * world, this would work for any PCMCIA card, but it requires
-         * a complete and accurate CIS.  In practice, a driver usually
-         * "knows" most of these things without consulting the CIS,
-         * and most client drivers will only use the CIS to fill in
-         * implementation-defined details.
-         */
+        link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_CHECK_VCC |
+                CONF_AUTO_SET_IO | CONF_ENABLE_IRQ;
+        if (ignore_cis_vcc)
+                link->config_flags &= ~CONF_AUTO_CHECK_VCC;
         ret = pcmcia_loop_config(link, spectrum_cs_config_check, NULL);
         if (ret) {
                 if (!ignore_cis_vcc)
@@ -325,12 +229,7 @@ spectrum_cs_config(struct pcmcia_device *link)
         hermes_struct_init(hw, mem, HERMES_16BIT_REGSPACING);
         hw->eeprom_pda = true;
 
-        /*
-         * This actually configures the PCMCIA socket -- setting up
-         * the I/O windows and the interrupt mapping, and putting the
-         * card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -358,11 +257,6 @@ spectrum_cs_config(struct pcmcia_device *link)
         return -ENODEV;
 }                               /* spectrum_cs_config */
 
-/*
- * After a card is removed, spectrum_cs_release() will unregister the
- * device, and release the PCMCIA configuration.  If the device is
- * still open, this will be postponed until it is closed.
- */
 static void
 spectrum_cs_release(struct pcmcia_device *link)
 {
@@ -407,12 +301,6 @@ spectrum_cs_resume(struct pcmcia_device *link)
 /* Module initialization                                            */
 /********************************************************************/
 
-/* Can't be declared "const" or the whole __initdata section will
- * become const */
-static char version[] __initdata = DRIVER_NAME " " DRIVER_VERSION
-        " (Pavel Roskin <proski@gnu.org>,"
-        " David Gibson <hermes@gibson.dropbear.id.au>, et al)";
-
 static struct pcmcia_device_id spectrum_cs_ids[] = {
         PCMCIA_DEVICE_MANF_CARD(0x026c, 0x0001), /* Symbol Spectrum24 LA4137 */
         PCMCIA_DEVICE_MANF_CARD(0x0104, 0x0001), /* Socket Communications CF */
@@ -423,9 +311,7 @@ MODULE_DEVICE_TABLE(pcmcia, spectrum_cs_ids);
 
 static struct pcmcia_driver orinoco_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = DRIVER_NAME,
-        },
+        .name           = DRIVER_NAME,
         .probe          = spectrum_cs_probe,
         .remove         = spectrum_cs_detach,
         .suspend        = spectrum_cs_suspend,
@@ -436,8 +322,6 @@ static struct pcmcia_driver orinoco_driver = {
 static int __init
 init_spectrum_cs(void)
 {
-        printk(KERN_DEBUG "%s\n", version);
-
         return pcmcia_register_driver(&orinoco_driver);
 }
 
diff --git a/drivers/net/wireless/ray_cs.c b/drivers/net/wireless/ray_cs.c
index 88560d0ae50a..af5b17ce5a15 100644
--- a/drivers/net/wireless/ray_cs.c
+++ b/drivers/net/wireless/ray_cs.c
@@ -46,7 +46,6 @@
 #include <linux/ethtool.h>
 #include <linux/ieee80211.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -169,13 +168,6 @@ static int bc;
  */
 static char *phy_addr = NULL;
 
-
-/* A struct pcmcia_device structure has fields for most things that are needed
-   to keep track of a socket, but there will usually be some device
-   specific information that also needs to be kept track of.  The
-   'priv' pointer in a struct pcmcia_device structure can be used to point to
-   a device-specific private data structure, like this.
-*/
 static unsigned int ray_mem_speed = 500;
 
 /* WARNING: THIS DRIVER IS NOT CAPABLE OF HANDLING MULTIPLE DEVICES! */
@@ -290,14 +282,6 @@ static const struct net_device_ops ray_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/*=============================================================================
-    ray_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-=============================================================================*/
 static int ray_probe(struct pcmcia_device *p_dev)
 {
         ray_dev_t *local;
@@ -318,9 +302,8 @@ static int ray_probe(struct pcmcia_device *p_dev)
         p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
 
         /* General socket configuration */
-        p_dev->conf.Attributes = CONF_ENABLE_IRQ;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
-        p_dev->conf.ConfigIndex = 1;
+        p_dev->config_flags |= CONF_ENABLE_IRQ;
+        p_dev->config_index = 1;
 
         p_dev->priv = dev;
 
@@ -353,12 +336,6 @@ fail_alloc_dev:
         return -ENOMEM;
 } /* ray_attach */
 
-/*=============================================================================
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-=============================================================================*/
 static void ray_detach(struct pcmcia_device *link)
 {
         struct net_device *dev;
@@ -381,17 +358,11 @@ static void ray_detach(struct pcmcia_device *link)
         dev_dbg(&link->dev, "ray_cs ray_detach ending\n");
 } /* ray_detach */
 
-/*=============================================================================
-    ray_config() is run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-=============================================================================*/
 #define MAX_TUPLE_SIZE 128
 static int ray_config(struct pcmcia_device *link)
 {
         int ret = 0;
         int i;
-        win_req_t req;
         struct net_device *dev = (struct net_device *)link->priv;
         ray_dev_t *local = netdev_priv(dev);
 
@@ -412,54 +383,50 @@ static int ray_config(struct pcmcia_device *link)
                 goto failed;
         dev->irq = link->irq;
 
-        /* This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
 /*** Set up 32k window for shared memory (transmit and control) ************/
-        req.Attributes =
-            WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
-        req.Base = 0;
-        req.Size = 0x8000;
-        req.AccessSpeed = ray_mem_speed;
-        ret = pcmcia_request_window(link, &req, &link->win);
+        link->resource[2]->flags |= WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
+        link->resource[2]->start = 0;
+        link->resource[2]->end = 0x8000;
+        ret = pcmcia_request_window(link, link->resource[2], ray_mem_speed);
         if (ret)
                 goto failed;
-        ret = pcmcia_map_mem_page(link, link->win, 0);
+        ret = pcmcia_map_mem_page(link, link->resource[2], 0);
         if (ret)
                 goto failed;
-        local->sram = ioremap(req.Base, req.Size);
+        local->sram = ioremap(link->resource[2]->start,
+                        resource_size(link->resource[2]));
 
 /*** Set up 16k window for shared memory (receive buffer) ***************/
-        req.Attributes =
+        link->resource[3]->flags |=
             WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_CM | WIN_ENABLE | WIN_USE_WAIT;
-        req.Base = 0;
-        req.Size = 0x4000;
-        req.AccessSpeed = ray_mem_speed;
-        ret = pcmcia_request_window(link, &req, &local->rmem_handle);
+        link->resource[3]->start = 0;
+        link->resource[3]->end = 0x4000;
+        ret = pcmcia_request_window(link, link->resource[3], ray_mem_speed);
         if (ret)
                 goto failed;
-        ret = pcmcia_map_mem_page(link, local->rmem_handle, 0x8000);
+        ret = pcmcia_map_mem_page(link, link->resource[3], 0x8000);
         if (ret)
                 goto failed;
-        local->rmem = ioremap(req.Base, req.Size);
+        local->rmem = ioremap(link->resource[3]->start,
+                        resource_size(link->resource[3]));
 
 /*** Set up window for attribute memory ***********************************/
-        req.Attributes =
+        link->resource[4]->flags |=
             WIN_DATA_WIDTH_8 | WIN_MEMORY_TYPE_AM | WIN_ENABLE | WIN_USE_WAIT;
-        req.Base = 0;
-        req.Size = 0x1000;
-        req.AccessSpeed = ray_mem_speed;
-        ret = pcmcia_request_window(link, &req, &local->amem_handle);
+        link->resource[4]->start = 0;
+        link->resource[4]->end = 0x1000;
+        ret = pcmcia_request_window(link, link->resource[4], ray_mem_speed);
         if (ret)
                 goto failed;
-        ret = pcmcia_map_mem_page(link, local->amem_handle, 0);
+        ret = pcmcia_map_mem_page(link, link->resource[4], 0);
         if (ret)
                 goto failed;
-        local->amem = ioremap(req.Base, req.Size);
+        local->amem = ioremap(link->resource[4]->start,
+                        resource_size(link->resource[4]));
 
         dev_dbg(&link->dev, "ray_config sram=%p\n", local->sram);
         dev_dbg(&link->dev, "ray_config rmem=%p\n", local->rmem);
@@ -775,11 +742,7 @@ static void join_net(u_long data)
         local->card_status = CARD_DOING_ACQ;
 }
 
-/*============================================================================
-    After a card is removed, ray_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-=============================================================================*/
+
 static void ray_release(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
@@ -2847,9 +2810,7 @@ MODULE_DEVICE_TABLE(pcmcia, ray_ids);
 
 static struct pcmcia_driver ray_driver = {
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "ray_cs",
-                },
+        .name = "ray_cs",
         .probe = ray_probe,
         .remove = ray_detach,
         .id_table = ray_ids,
diff --git a/drivers/net/wireless/ray_cs.h b/drivers/net/wireless/ray_cs.h
index 9f01ddb19748..e79848fbcca1 100644
--- a/drivers/net/wireless/ray_cs.h
+++ b/drivers/net/wireless/ray_cs.h
@@ -25,8 +25,6 @@ struct beacon_rx {
 typedef struct ray_dev_t {
     int card_status;
     int authentication_state;
-    window_handle_t amem_handle;   /* handle to window for attribute memory  */
-    window_handle_t rmem_handle;   /* handle to window for rx buffer on card */
     void __iomem *sram;            /* pointer to beginning of shared RAM     */
     void __iomem *amem;            /* pointer to attribute mem window        */
     void __iomem *rmem;            /* pointer to receive buffer window       */
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index a1cc2d498a1c..ca3f8961fa27 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -48,7 +48,6 @@
 
 #include <net/iw_handler.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -78,13 +77,6 @@
 #define WL3501_RESUME   0
 #define WL3501_SUSPEND  1
 
-/*
- * The event() function is this driver's Card Services event handler.  It will
- * be called by Card Services when an appropriate card status event is
- * received. The config() and release() entry points are used to configure or
- * release a socket, in response to card insertion and ejection events.  They
- * are invoked from the wl24 event handler.
- */
 static int wl3501_config(struct pcmcia_device *link);
 static void wl3501_release(struct pcmcia_device *link);
 
@@ -1869,15 +1861,6 @@ static const struct net_device_ops wl3501_netdev_ops = {
         .ndo_validate_addr      = eth_validate_addr,
 };
 
-/**
- * wl3501_attach - creates an "instance" of the driver
- *
- * Creates an "instance" of the driver, allocating local data structures for
- * one device.  The device is registered with Card Services.
- *
- * The dev_link structure is initialized, but we don't actually configure the
- * card at this point -- we wait until we receive a card insertion event.
- */
 static int wl3501_probe(struct pcmcia_device *p_dev)
 {
         struct net_device *dev;
@@ -1888,9 +1871,8 @@ static int wl3501_probe(struct pcmcia_device *p_dev)
         p_dev->resource[0]->flags       = IO_DATA_PATH_WIDTH_8;
 
         /* General socket configuration */
-        p_dev->conf.Attributes  = CONF_ENABLE_IRQ;
-        p_dev->conf.IntType     = INT_MEMORY_AND_IO;
-        p_dev->conf.ConfigIndex = 1;
+        p_dev->config_flags     = CONF_ENABLE_IRQ;
+        p_dev->config_index     = 1;
 
         dev = alloc_etherdev(sizeof(struct wl3501_card));
         if (!dev)
@@ -1914,14 +1896,6 @@ out_link:
         return -ENOMEM;
 }
 
-/**
- * wl3501_config - configure the PCMCIA socket and make eth device available
- * @link - FILL_IN
- *
- * wl3501_config() is scheduled to run after a CARD_INSERTION event is
- * received, to configure the PCMCIA socket, and to make the ethernet device
- * available to the system.
- */
 static int wl3501_config(struct pcmcia_device *link)
 {
         struct net_device *dev = link->priv;
@@ -1952,10 +1926,7 @@ static int wl3501_config(struct pcmcia_device *link)
         if (ret)
                 goto failed;
 
-        /* This actually configures the PCMCIA socket -- setting up the I/O
-         * windows and the interrupt mapping.  */
-
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -2010,14 +1981,6 @@ failed:
         return -ENODEV;
 }
 
-/**
- * wl3501_release - unregister the net, release PCMCIA configuration
- * @arg - link
- *
- * After a card is removed, wl3501_release() will unregister the net device,
- * and release the PCMCIA configuration.  If the device is still open, this
- * will be postponed until it is closed.
- */
 static void wl3501_release(struct pcmcia_device *link)
 {
         pcmcia_disable_device(link);
@@ -2056,9 +2019,7 @@ MODULE_DEVICE_TABLE(pcmcia, wl3501_ids);
 
 static struct pcmcia_driver wl3501_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "wl3501_cs",
-        },
+        .name           = "wl3501_cs",
         .probe          = wl3501_probe,
         .remove         = wl3501_detach,
         .id_table       = wl3501_ids,
diff --git a/drivers/oprofile/oprof.c b/drivers/oprofile/oprof.c
index b336cd9ee7a1..f9bda64fcd1b 100644
--- a/drivers/oprofile/oprof.c
+++ b/drivers/oprofile/oprof.c
@@ -225,26 +225,17 @@ post_sync:
         mutex_unlock(&start_mutex);
 }
 
-int oprofile_set_backtrace(unsigned long val)
+int oprofile_set_ulong(unsigned long *addr, unsigned long val)
 {
-        int err = 0;
+        int err = -EBUSY;
 
         mutex_lock(&start_mutex);
-
-        if (oprofile_started) {
-                err = -EBUSY;
-                goto out;
-        }
-
-        if (!oprofile_ops.backtrace) {
-                err = -EINVAL;
-                goto out;
+        if (!oprofile_started) {
+                *addr = val;
+                err = 0;
         }
-
-        oprofile_backtrace_depth = val;
-
-out:
         mutex_unlock(&start_mutex);
+
         return err;
 }
 
@@ -257,16 +248,9 @@ static int __init oprofile_init(void)
                 printk(KERN_INFO "oprofile: using timer interrupt.\n");
                 err = oprofile_timer_init(&oprofile_ops);
                 if (err)
-                        goto out_arch;
+                        return err;
         }
-        err = oprofilefs_register();
-        if (err)
-                goto out_arch;
-        return 0;
-
-out_arch:
-        oprofile_arch_exit();
-        return err;
+        return oprofilefs_register();
 }
 
 
diff --git a/drivers/oprofile/oprof.h b/drivers/oprofile/oprof.h
index 47e12cb4ee8b..177b73de5e5f 100644
--- a/drivers/oprofile/oprof.h
+++ b/drivers/oprofile/oprof.h
@@ -37,7 +37,7 @@ void oprofile_create_files(struct super_block *sb, struct dentry *root);
 int oprofile_timer_init(struct oprofile_operations *ops);
 void oprofile_timer_exit(void);
 
-int oprofile_set_backtrace(unsigned long depth);
+int oprofile_set_ulong(unsigned long *addr, unsigned long val);
 int oprofile_set_timeout(unsigned long time);
 
 #endif /* OPROF_H */
diff --git a/drivers/oprofile/oprofile_files.c b/drivers/oprofile/oprofile_files.c
index bbd7516e0869..ccf099e684a4 100644
--- a/drivers/oprofile/oprofile_files.c
+++ b/drivers/oprofile/oprofile_files.c
@@ -79,14 +79,17 @@ static ssize_t depth_write(struct file *file, char const __user *buf, size_t cou
         if (*offset)
                 return -EINVAL;
 
+        if (!oprofile_ops.backtrace)
+                return -EINVAL;
+
         retval = oprofilefs_ulong_from_user(&val, buf, count);
         if (retval)
                 return retval;
 
-        retval = oprofile_set_backtrace(val);
-
+        retval = oprofile_set_ulong(&oprofile_backtrace_depth, val);
         if (retval)
                 return retval;
+
         return count;
 }
 
diff --git a/drivers/oprofile/oprofile_perf.c b/drivers/oprofile/oprofile_perf.c
new file mode 100644
index 000000000000..9046f7b2ed79
--- /dev/null
+++ b/drivers/oprofile/oprofile_perf.c
@@ -0,0 +1,328 @@
+/*
+ * Copyright 2010 ARM Ltd.
+ *
+ * Perf-events backend for OProfile.
+ */
+#include <linux/perf_event.h>
+#include <linux/platform_device.h>
+#include <linux/oprofile.h>
+#include <linux/slab.h>
+
+/*
+ * Per performance monitor configuration as set via oprofilefs.
+ */
+struct op_counter_config {
+        unsigned long count;
+        unsigned long enabled;
+        unsigned long event;
+        unsigned long unit_mask;
+        unsigned long kernel;
+        unsigned long user;
+        struct perf_event_attr attr;
+};
+
+static int oprofile_perf_enabled;
+static DEFINE_MUTEX(oprofile_perf_mutex);
+
+static struct op_counter_config *counter_config;
+static struct perf_event **perf_events[nr_cpumask_bits];
+static int num_counters;
+
+/*
+ * Overflow callback for oprofile.
+ */
+static void op_overflow_handler(struct perf_event *event, int unused,
+                        struct perf_sample_data *data, struct pt_regs *regs)
+{
+        int id;
+        u32 cpu = smp_processor_id();
+
+        for (id = 0; id < num_counters; ++id)
+                if (perf_events[cpu][id] == event)
+                        break;
+
+        if (id != num_counters)
+                oprofile_add_sample(regs, id);
+        else
+                pr_warning("oprofile: ignoring spurious overflow "
+                                "on cpu %u\n", cpu);
+}
+
+/*
+ * Called by oprofile_perf_setup to create perf attributes to mirror the oprofile
+ * settings in counter_config. Attributes are created as `pinned' events and
+ * so are permanently scheduled on the PMU.
+ */
+static void op_perf_setup(void)
+{
+        int i;
+        u32 size = sizeof(struct perf_event_attr);
+        struct perf_event_attr *attr;
+
+        for (i = 0; i < num_counters; ++i) {
+                attr = &counter_config[i].attr;
+                memset(attr, 0, size);
+                attr->type              = PERF_TYPE_RAW;
+                attr->size              = size;
+                attr->config            = counter_config[i].event;
+                attr->sample_period     = counter_config[i].count;
+                attr->pinned            = 1;
+        }
+}
+
+static int op_create_counter(int cpu, int event)
+{
+        struct perf_event *pevent;
+
+        if (!counter_config[event].enabled || perf_events[cpu][event])
+                return 0;
+
+        pevent = perf_event_create_kernel_counter(&counter_config[event].attr,
+                                                  cpu, NULL,
+                                                  op_overflow_handler);
+
+        if (IS_ERR(pevent))
+                return PTR_ERR(pevent);
+
+        if (pevent->state != PERF_EVENT_STATE_ACTIVE) {
+                perf_event_release_kernel(pevent);
+                pr_warning("oprofile: failed to enable event %d "
+                                "on CPU %d\n", event, cpu);
+                return -EBUSY;
+        }
+
+        perf_events[cpu][event] = pevent;
+
+        return 0;
+}
+
+static void op_destroy_counter(int cpu, int event)
+{
+        struct perf_event *pevent = perf_events[cpu][event];
+
+        if (pevent) {
+                perf_event_release_kernel(pevent);
+                perf_events[cpu][event] = NULL;
+        }
+}
+
+/*
+ * Called by oprofile_perf_start to create active perf events based on the
+ * perviously configured attributes.
+ */
+static int op_perf_start(void)
+{
+        int cpu, event, ret = 0;
+
+        for_each_online_cpu(cpu) {
+                for (event = 0; event < num_counters; ++event) {
+                        ret = op_create_counter(cpu, event);
+                        if (ret)
+                                return ret;
+                }
+        }
+
+        return ret;
+}
+
+/*
+ * Called by oprofile_perf_stop at the end of a profiling run.
+ */
+static void op_perf_stop(void)
+{
+        int cpu, event;
+
+        for_each_online_cpu(cpu)
+                for (event = 0; event < num_counters; ++event)
+                        op_destroy_counter(cpu, event);
+}
+
+static int oprofile_perf_create_files(struct super_block *sb, struct dentry *root)
+{
+        unsigned int i;
+
+        for (i = 0; i < num_counters; i++) {
+                struct dentry *dir;
+                char buf[4];
+
+                snprintf(buf, sizeof buf, "%d", i);
+                dir = oprofilefs_mkdir(sb, root, buf);
+                oprofilefs_create_ulong(sb, dir, "enabled", &counter_config[i].enabled);
+                oprofilefs_create_ulong(sb, dir, "event", &counter_config[i].event);
+                oprofilefs_create_ulong(sb, dir, "count", &counter_config[i].count);
+                oprofilefs_create_ulong(sb, dir, "unit_mask", &counter_config[i].unit_mask);
+                oprofilefs_create_ulong(sb, dir, "kernel", &counter_config[i].kernel);
+                oprofilefs_create_ulong(sb, dir, "user", &counter_config[i].user);
+        }
+
+        return 0;
+}
+
+static int oprofile_perf_setup(void)
+{
+        spin_lock(&oprofilefs_lock);
+        op_perf_setup();
+        spin_unlock(&oprofilefs_lock);
+        return 0;
+}
+
+static int oprofile_perf_start(void)
+{
+        int ret = -EBUSY;
+
+        mutex_lock(&oprofile_perf_mutex);
+        if (!oprofile_perf_enabled) {
+                ret = 0;
+                op_perf_start();
+                oprofile_perf_enabled = 1;
+        }
+        mutex_unlock(&oprofile_perf_mutex);
+        return ret;
+}
+
+static void oprofile_perf_stop(void)
+{
+        mutex_lock(&oprofile_perf_mutex);
+        if (oprofile_perf_enabled)
+                op_perf_stop();
+        oprofile_perf_enabled = 0;
+        mutex_unlock(&oprofile_perf_mutex);
+}
+
+#ifdef CONFIG_PM
+
+static int oprofile_perf_suspend(struct platform_device *dev, pm_message_t state)
+{
+        mutex_lock(&oprofile_perf_mutex);
+        if (oprofile_perf_enabled)
+                op_perf_stop();
+        mutex_unlock(&oprofile_perf_mutex);
+        return 0;
+}
+
+static int oprofile_perf_resume(struct platform_device *dev)
+{
+        mutex_lock(&oprofile_perf_mutex);
+        if (oprofile_perf_enabled && op_perf_start())
+                oprofile_perf_enabled = 0;
+        mutex_unlock(&oprofile_perf_mutex);
+        return 0;
+}
+
+static struct platform_driver oprofile_driver = {
+        .driver         = {
+                .name           = "oprofile-perf",
+        },
+        .resume         = oprofile_perf_resume,
+        .suspend        = oprofile_perf_suspend,
+};
+
+static struct platform_device *oprofile_pdev;
+
+static int __init init_driverfs(void)
+{
+        int ret;
+
+        ret = platform_driver_register(&oprofile_driver);
+        if (ret)
+                return ret;
+
+        oprofile_pdev = platform_device_register_simple(
+                                oprofile_driver.driver.name, 0, NULL, 0);
+        if (IS_ERR(oprofile_pdev)) {
+                ret = PTR_ERR(oprofile_pdev);
+                platform_driver_unregister(&oprofile_driver);
+        }
+
+        return ret;
+}
+
+static void exit_driverfs(void)
+{
+        platform_device_unregister(oprofile_pdev);
+        platform_driver_unregister(&oprofile_driver);
+}
+
+#else
+
+static inline int  init_driverfs(void) { return 0; }
+static inline void exit_driverfs(void) { }
+
+#endif /* CONFIG_PM */
+
+void oprofile_perf_exit(void)
+{
+        int cpu, id;
+        struct perf_event *event;
+
+        for_each_possible_cpu(cpu) {
+                for (id = 0; id < num_counters; ++id) {
+                        event = perf_events[cpu][id];
+                        if (event)
+                                perf_event_release_kernel(event);
+                }
+
+                kfree(perf_events[cpu]);
+        }
+
+        kfree(counter_config);
+        exit_driverfs();
+}
+
+int __init oprofile_perf_init(struct oprofile_operations *ops)
+{
+        int cpu, ret = 0;
+
+        ret = init_driverfs();
+        if (ret)
+                return ret;
+
+        memset(&perf_events, 0, sizeof(perf_events));
+
+        num_counters = perf_num_counters();
+        if (num_counters <= 0) {
+                pr_info("oprofile: no performance counters\n");
+                ret = -ENODEV;
+                goto out;
+        }
+
+        counter_config = kcalloc(num_counters,
+                        sizeof(struct op_counter_config), GFP_KERNEL);
+
+        if (!counter_config) {
+                pr_info("oprofile: failed to allocate %d "
+                                "counters\n", num_counters);
+                ret = -ENOMEM;
+                num_counters = 0;
+                goto out;
+        }
+
+        for_each_possible_cpu(cpu) {
+                perf_events[cpu] = kcalloc(num_counters,
+                                sizeof(struct perf_event *), GFP_KERNEL);
+                if (!perf_events[cpu]) {
+                        pr_info("oprofile: failed to allocate %d perf events "
+                                        "for cpu %d\n", num_counters, cpu);
+                        ret = -ENOMEM;
+                        goto out;
+                }
+        }
+
+        ops->create_files       = oprofile_perf_create_files;
+        ops->setup              = oprofile_perf_setup;
+        ops->start              = oprofile_perf_start;
+        ops->stop               = oprofile_perf_stop;
+        ops->shutdown           = oprofile_perf_stop;
+        ops->cpu_type           = op_name_from_perf_id();
+
+        if (!ops->cpu_type)
+                ret = -ENODEV;
+        else
+                pr_info("oprofile: using %s\n", ops->cpu_type);
+
+out:
+        if (ret)
+                oprofile_perf_exit();
+
+        return ret;
+}
diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index 2766a6d3c2e9..1944621930d9 100644
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -91,16 +91,20 @@ static ssize_t ulong_read_file(struct file *file, char __user *buf, size_t count
 
 static ssize_t ulong_write_file(struct file *file, char const __user *buf, size_t count, loff_t *offset)
 {
-        unsigned long *value = file->private_data;
+        unsigned long value;
         int retval;
 
         if (*offset)
                 return -EINVAL;
 
-        retval = oprofilefs_ulong_from_user(value, buf, count);
+        retval = oprofilefs_ulong_from_user(&value, buf, count);
+        if (retval)
+                return retval;
 
+        retval = oprofile_set_ulong(file->private_data, value);
         if (retval)
                 return retval;
+
         return count;
 }
 
@@ -126,50 +130,41 @@ static const struct file_operations ulong_ro_fops = {
 };
 
 
-static struct dentry *__oprofilefs_create_file(struct super_block *sb,
+static int __oprofilefs_create_file(struct super_block *sb,
         struct dentry *root, char const *name, const struct file_operations *fops,
-        int perm)
+        int perm, void *priv)
 {
         struct dentry *dentry;
         struct inode *inode;
 
         dentry = d_alloc_name(root, name);
         if (!dentry)
-                return NULL;
+                return -ENOMEM;
         inode = oprofilefs_get_inode(sb, S_IFREG | perm);
         if (!inode) {
                 dput(dentry);
-                return NULL;
+                return -ENOMEM;
         }
         inode->i_fop = fops;
         d_add(dentry, inode);
-        return dentry;
+        dentry->d_inode->i_private = priv;
+        return 0;
 }
 
 
 int oprofilefs_create_ulong(struct super_block *sb, struct dentry *root,
         char const *name, unsigned long *val)
 {
-        struct dentry *d = __oprofilefs_create_file(sb, root, name,
-                                                     &ulong_fops, 0644);
-        if (!d)
-                return -EFAULT;
-
-        d->d_inode->i_private = val;
-        return 0;
+        return __oprofilefs_create_file(sb, root, name,
+                                        &ulong_fops, 0644, val);
 }
 
 
 int oprofilefs_create_ro_ulong(struct super_block *sb, struct dentry *root,
         char const *name, unsigned long *val)
 {
-        struct dentry *d = __oprofilefs_create_file(sb, root, name,
-                                                     &ulong_ro_fops, 0444);
-        if (!d)
-                return -EFAULT;
-
-        d->d_inode->i_private = val;
-        return 0;
+        return __oprofilefs_create_file(sb, root, name,
+                                        &ulong_ro_fops, 0444, val);
 }
 
 
@@ -189,31 +184,22 @@ static const struct file_operations atomic_ro_fops = {
 int oprofilefs_create_ro_atomic(struct super_block *sb, struct dentry *root,
         char const *name, atomic_t *val)
 {
-        struct dentry *d = __oprofilefs_create_file(sb, root, name,
-                                                     &atomic_ro_fops, 0444);
-        if (!d)
-                return -EFAULT;
-
-        d->d_inode->i_private = val;
-        return 0;
+        return __oprofilefs_create_file(sb, root, name,
+                                        &atomic_ro_fops, 0444, val);
 }
 
 
 int oprofilefs_create_file(struct super_block *sb, struct dentry *root,
         char const *name, const struct file_operations *fops)
 {
-        if (!__oprofilefs_create_file(sb, root, name, fops, 0644))
-                return -EFAULT;
-        return 0;
+        return __oprofilefs_create_file(sb, root, name, fops, 0644, NULL);
 }
 
 
 int oprofilefs_create_file_perm(struct super_block *sb, struct dentry *root,
         char const *name, const struct file_operations *fops, int perm)
 {
-        if (!__oprofilefs_create_file(sb, root, name, fops, perm))
-                return -EFAULT;
-        return 0;
+        return __oprofilefs_create_file(sb, root, name, fops, perm, NULL);
 }
 
 
diff --git a/drivers/parport/parport_cs.c b/drivers/parport/parport_cs.c
index 23e50f4a27c5..787ebdeae310 100644
--- a/drivers/parport/parport_cs.c
+++ b/drivers/parport/parport_cs.c
@@ -48,7 +48,6 @@
 #include <linux/parport.h>
 #include <linux/parport_pc.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/cisreg.h>
@@ -81,14 +80,6 @@ static void parport_detach(struct pcmcia_device *p_dev);
 static int parport_config(struct pcmcia_device *link);
 static void parport_cs_release(struct pcmcia_device *);
 
-/*======================================================================
-
-    parport_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int parport_probe(struct pcmcia_device *link)
 {
     parport_info_t *info;
@@ -101,23 +92,11 @@ static int parport_probe(struct pcmcia_device *link)
     link->priv = info;
     info->p_dev = link;
 
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-    link->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
     return parport_config(link);
 } /* parport_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void parport_detach(struct pcmcia_device *link)
 {
     dev_dbg(&link->dev, "parport_detach\n");
@@ -127,36 +106,14 @@ static void parport_detach(struct pcmcia_device *link)
     kfree(link->priv);
 } /* parport_detach */
 
-/*======================================================================
-
-    parport_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    parport device available to the system.
-
-======================================================================*/
-
-static int parport_config_check(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int parport_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                if (epp_mode)
-                        p_dev->conf.ConfigIndex |= FORCE_EPP_MODE;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin == 2) {
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                if (pcmcia_request_io(p_dev) != 0)
-                        return -ENODEV;
-                return 0;
-        }
-        return -ENODEV;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int parport_config(struct pcmcia_device *link)
@@ -167,13 +124,16 @@ static int parport_config(struct pcmcia_device *link)
 
     dev_dbg(&link->dev, "parport_config\n");
 
+    if (epp_mode)
+            link->config_index |= FORCE_EPP_MODE;
+
     ret = pcmcia_loop_config(link, parport_config_check, NULL);
     if (ret)
             goto failed;
 
     if (!link->irq)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -202,14 +162,6 @@ failed:
     return -ENODEV;
 } /* parport_config */
 
-/*======================================================================
-
-    After a card is removed, parport_cs_release() will unregister the
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-    
-======================================================================*/
-
 static void parport_cs_release(struct pcmcia_device *link)
 {
         parport_info_t *info = link->priv;
@@ -236,9 +188,7 @@ MODULE_DEVICE_TABLE(pcmcia, parport_ids);
 
 static struct pcmcia_driver parport_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "parport_cs",
-        },
+        .name           = "parport_cs",
         .probe          = parport_probe,
         .remove         = parport_detach,
         .id_table       = parport_ids,
diff --git a/drivers/parport/share.c b/drivers/parport/share.c
index dffa5d4fb298..a2d9d1e59260 100644
--- a/drivers/parport/share.c
+++ b/drivers/parport/share.c
@@ -306,7 +306,7 @@ struct parport *parport_register_port(unsigned long base, int irq, int dma,
         spin_lock_init(&tmp->pardevice_lock);
         tmp->ieee1284.mode = IEEE1284_MODE_COMPAT;
         tmp->ieee1284.phase = IEEE1284_PH_FWD_IDLE;
-        init_MUTEX_LOCKED (&tmp->ieee1284.irq); /* actually a semaphore at 0 */
+        sema_init(&tmp->ieee1284.irq, 0);
         tmp->spintime = parport_default_spintime;
         atomic_set (&tmp->ref_count, 1);
         INIT_LIST_HEAD(&tmp->full_list);
diff --git a/drivers/pci/dmar.c b/drivers/pci/dmar.c
index 0a19708074c2..0157708d474d 100644
--- a/drivers/pci/dmar.c
+++ b/drivers/pci/dmar.c
@@ -36,6 +36,7 @@
 #include <linux/tboot.h>
 #include <linux/dmi.h>
 #include <linux/slab.h>
+#include <asm/iommu_table.h>
 
 #define PREFIX "DMAR: "
 
@@ -687,7 +688,7 @@ failed:
         return 0;
 }
 
-void __init detect_intel_iommu(void)
+int __init detect_intel_iommu(void)
 {
         int ret;
 
@@ -723,6 +724,8 @@ void __init detect_intel_iommu(void)
         }
         early_acpi_os_unmap_memory(dmar_tbl, dmar_tbl_size);
         dmar_tbl = NULL;
+
+        return ret ? 1 : -ENODEV;
 }
 
 
@@ -1221,9 +1224,9 @@ const char *dmar_get_fault_reason(u8 fault_reason, int *fault_type)
         }
 }
 
-void dmar_msi_unmask(unsigned int irq)
+void dmar_msi_unmask(struct irq_data *data)
 {
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_data_get_irq_data(data);
         unsigned long flag;
 
         /* unmask it */
@@ -1234,10 +1237,10 @@ void dmar_msi_unmask(unsigned int irq)
         spin_unlock_irqrestore(&iommu->register_lock, flag);
 }
 
-void dmar_msi_mask(unsigned int irq)
+void dmar_msi_mask(struct irq_data *data)
 {
         unsigned long flag;
-        struct intel_iommu *iommu = get_irq_data(irq);
+        struct intel_iommu *iommu = irq_data_get_irq_data(data);
 
         /* mask it */
         spin_lock_irqsave(&iommu->register_lock, flag);
@@ -1455,3 +1458,4 @@ int __init dmar_ir_support(void)
                 return 0;
         return dmar->flags & 0x1;
 }
+IOMMU_INIT_POST(detect_intel_iommu);
diff --git a/drivers/pci/htirq.c b/drivers/pci/htirq.c
index 98abf8b91294..834842aa5bbf 100644
--- a/drivers/pci/htirq.c
+++ b/drivers/pci/htirq.c
@@ -57,28 +57,22 @@ void fetch_ht_irq_msg(unsigned int irq, struct ht_irq_msg *msg)
         *msg = cfg->msg;
 }
 
-void mask_ht_irq(unsigned int irq)
+void mask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg;
-        struct ht_irq_msg msg;
-
-        cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_msg msg = cfg->msg;
 
-        msg = cfg->msg;
         msg.address_lo |= 1;
-        write_ht_irq_msg(irq, &msg);
+        write_ht_irq_msg(data->irq, &msg);
 }
 
-void unmask_ht_irq(unsigned int irq)
+void unmask_ht_irq(struct irq_data *data)
 {
-        struct ht_irq_cfg *cfg;
-        struct ht_irq_msg msg;
-
-        cfg = get_irq_data(irq);
+        struct ht_irq_cfg *cfg = irq_data_get_irq_data(data);
+        struct ht_irq_msg msg = cfg->msg;
 
-        msg = cfg->msg;
         msg.address_lo &= ~1;
-        write_ht_irq_msg(irq, &msg);
+        write_ht_irq_msg(data->irq, &msg);
 }
 
 /**
diff --git a/drivers/pci/intr_remapping.c b/drivers/pci/intr_remapping.c
index fd1d2867cdcc..ec87cd66f3eb 100644
--- a/drivers/pci/intr_remapping.c
+++ b/drivers/pci/intr_remapping.c
@@ -46,109 +46,24 @@ static __init int setup_intremap(char *str)
 }
 early_param("intremap", setup_intremap);
 
-struct irq_2_iommu {
-        struct intel_iommu *iommu;
-        u16 irte_index;
-        u16 sub_handle;
-        u8  irte_mask;
-};
-
-#ifdef CONFIG_GENERIC_HARDIRQS
-static struct irq_2_iommu *get_one_free_irq_2_iommu(int node)
-{
-        struct irq_2_iommu *iommu;
-
-        iommu = kzalloc_node(sizeof(*iommu), GFP_ATOMIC, node);
-        printk(KERN_DEBUG "alloc irq_2_iommu on node %d\n", node);
-
-        return iommu;
-}
-
-static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
-{
-        struct irq_desc *desc;
-
-        desc = irq_to_desc(irq);
-
-        if (WARN_ON_ONCE(!desc))
-                return NULL;
-
-        return desc->irq_2_iommu;
-}
-
-static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
-{
-        struct irq_desc *desc;
-        struct irq_2_iommu *irq_iommu;
-
-        desc = irq_to_desc(irq);
-        if (!desc) {
-                printk(KERN_INFO "can not get irq_desc for %d\n", irq);
-                return NULL;
-        }
-
-        irq_iommu = desc->irq_2_iommu;
-
-        if (!irq_iommu)
-                desc->irq_2_iommu = get_one_free_irq_2_iommu(irq_node(irq));
-
-        return desc->irq_2_iommu;
-}
-
-#else /* !CONFIG_SPARSE_IRQ */
-
-static struct irq_2_iommu irq_2_iommuX[NR_IRQS];
-
-static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
-{
-        if (irq < nr_irqs)
-                return &irq_2_iommuX[irq];
-
-        return NULL;
-}
-static struct irq_2_iommu *irq_2_iommu_alloc(unsigned int irq)
-{
-        return irq_2_iommu(irq);
-}
-#endif
-
 static DEFINE_SPINLOCK(irq_2_ir_lock);
 
-static struct irq_2_iommu *valid_irq_2_iommu(unsigned int irq)
-{
-        struct irq_2_iommu *irq_iommu;
-
-        irq_iommu = irq_2_iommu(irq);
-
-        if (!irq_iommu)
-                return NULL;
-
-        if (!irq_iommu->iommu)
-                return NULL;
-
-        return irq_iommu;
-}
-
-int irq_remapped(int irq)
+static struct irq_2_iommu *irq_2_iommu(unsigned int irq)
 {
-        return valid_irq_2_iommu(irq) != NULL;
+        struct irq_cfg *cfg = get_irq_chip_data(irq);
+        return cfg ? &cfg->irq_2_iommu : NULL;
 }
 
 int get_irte(int irq, struct irte *entry)
 {
-        int index;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int index;
 
-        if (!entry)
+        if (!entry || !irq_iommu)
                 return -1;
 
         spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
 
         index = irq_iommu->irte_index + irq_iommu->sub_handle;
         *entry = *(irq_iommu->iommu->ir_table->base + index);
@@ -160,20 +75,14 @@ int get_irte(int irq, struct irte *entry)
 int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
 {
         struct ir_table *table = iommu->ir_table;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         u16 index, start_index;
         unsigned int mask = 0;
         unsigned long flags;
         int i;
 
-        if (!count)
-                return -1;
-
-#ifndef CONFIG_SPARSE_IRQ
-        /* protect irq_2_iommu_alloc later */
-        if (irq >= nr_irqs)
+        if (!count || !irq_iommu)
                 return -1;
-#endif
 
         /*
          * start the IRTE search from index 0.
@@ -214,13 +123,6 @@ int alloc_irte(struct intel_iommu *iommu, int irq, u16 count)
         for (i = index; i < index + count; i++)
                 table->base[i].present = 1;
 
-        irq_iommu = irq_2_iommu_alloc(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                printk(KERN_ERR "can't allocate irq_2_iommu\n");
-                return -1;
-        }
-
         irq_iommu->iommu = iommu;
         irq_iommu->irte_index =  index;
         irq_iommu->sub_handle = 0;
@@ -244,17 +146,14 @@ static int qi_flush_iec(struct intel_iommu *iommu, int index, int mask)
 
 int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 {
-        int index;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int index;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
 
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
         *sub_handle = irq_iommu->sub_handle;
         index = irq_iommu->irte_index;
         spin_unlock_irqrestore(&irq_2_ir_lock, flags);
@@ -263,18 +162,13 @@ int map_irq_to_irte_handle(int irq, u16 *sub_handle)
 
 int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
 {
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-
-        irq_iommu = irq_2_iommu_alloc(irq);
-
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                printk(KERN_ERR "can't allocate irq_2_iommu\n");
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         irq_iommu->iommu = iommu;
         irq_iommu->irte_index = index;
@@ -286,43 +180,18 @@ int set_irte_irq(int irq, struct intel_iommu *iommu, u16 index, u16 subhandle)
         return 0;
 }
 
-int clear_irte_irq(int irq, struct intel_iommu *iommu, u16 index)
-{
-        struct irq_2_iommu *irq_iommu;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
-
-        irq_iommu->iommu = NULL;
-        irq_iommu->irte_index = 0;
-        irq_iommu->sub_handle = 0;
-        irq_2_iommu(irq)->irte_mask = 0;
-
-        spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-
-        return 0;
-}
-
 int modify_irte(int irq, struct irte *irte_modified)
 {
-        int rc;
-        int index;
-        struct irte *irte;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         struct intel_iommu *iommu;
-        struct irq_2_iommu *irq_iommu;
         unsigned long flags;
+        struct irte *irte;
+        int rc, index;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         iommu = irq_iommu->iommu;
 
@@ -339,31 +208,6 @@ int modify_irte(int irq, struct irte *irte_modified)
         return rc;
 }
 
-int flush_irte(int irq)
-{
-        int rc;
-        int index;
-        struct intel_iommu *iommu;
-        struct irq_2_iommu *irq_iommu;
-        unsigned long flags;
-
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-                return -1;
-        }
-
-        iommu = irq_iommu->iommu;
-
-        index = irq_iommu->irte_index + irq_iommu->sub_handle;
-
-        rc = qi_flush_iec(iommu, index, irq_iommu->irte_mask);
-        spin_unlock_irqrestore(&irq_2_ir_lock, flags);
-
-        return rc;
-}
-
 struct intel_iommu *map_hpet_to_ir(u8 hpet_id)
 {
         int i;
@@ -420,16 +264,14 @@ static int clear_entries(struct irq_2_iommu *irq_iommu)
 
 int free_irte(int irq)
 {
-        int rc = 0;
-        struct irq_2_iommu *irq_iommu;
+        struct irq_2_iommu *irq_iommu = irq_2_iommu(irq);
         unsigned long flags;
+        int rc;
 
-        spin_lock_irqsave(&irq_2_ir_lock, flags);
-        irq_iommu = valid_irq_2_iommu(irq);
-        if (!irq_iommu) {
-                spin_unlock_irqrestore(&irq_2_ir_lock, flags);
+        if (!irq_iommu)
                 return -1;
-        }
+
+        spin_lock_irqsave(&irq_2_ir_lock, flags);
 
         rc = clear_entries(irq_iommu);
 
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 69b7be33b3a2..5fcf5aec680f 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -170,33 +170,31 @@ static void msix_mask_irq(struct msi_desc *desc, u32 flag)
         desc->masked = __msix_mask_irq(desc, flag);
 }
 
-static void msi_set_mask_bit(unsigned irq, u32 flag)
+static void msi_set_mask_bit(struct irq_data *data, u32 flag)
 {
-        struct msi_desc *desc = get_irq_msi(irq);
+        struct msi_desc *desc = irq_data_get_msi(data);
 
         if (desc->msi_attrib.is_msix) {
                 msix_mask_irq(desc, flag);
                 readl(desc->mask_base);         /* Flush write to device */
         } else {
-                unsigned offset = irq - desc->dev->irq;
+                unsigned offset = data->irq - desc->dev->irq;
                 msi_mask_irq(desc, 1 << offset, flag << offset);
         }
 }
 
-void mask_msi_irq(unsigned int irq)
+void mask_msi_irq(struct irq_data *data)
 {
-        msi_set_mask_bit(irq, 1);
+        msi_set_mask_bit(data, 1);
 }
 
-void unmask_msi_irq(unsigned int irq)
+void unmask_msi_irq(struct irq_data *data)
 {
-        msi_set_mask_bit(irq, 0);
+        msi_set_mask_bit(data, 0);
 }
 
-void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __read_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         BUG_ON(entry->dev->current_state != PCI_D0);
 
         if (entry->msi_attrib.is_msix) {
@@ -227,15 +225,13 @@ void read_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void read_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        read_msi_msg_desc(desc, msg);
+        __read_msi_msg(entry, msg);
 }
 
-void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __get_cached_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         /* Assert that the cache is valid, assuming that
          * valid messages are not all-zeroes. */
         BUG_ON(!(entry->msg.address_hi | entry->msg.address_lo |
@@ -246,15 +242,13 @@ void get_cached_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void get_cached_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        get_cached_msi_msg_desc(desc, msg);
+        __get_cached_msi_msg(entry, msg);
 }
 
-void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
+void __write_msi_msg(struct msi_desc *entry, struct msi_msg *msg)
 {
-        struct msi_desc *entry = get_irq_desc_msi(desc);
-
         if (entry->dev->current_state != PCI_D0) {
                 /* Don't touch the hardware now */
         } else if (entry->msi_attrib.is_msix) {
@@ -292,9 +286,9 @@ void write_msi_msg_desc(struct irq_desc *desc, struct msi_msg *msg)
 
 void write_msi_msg(unsigned int irq, struct msi_msg *msg)
 {
-        struct irq_desc *desc = irq_to_desc(irq);
+        struct msi_desc *entry = get_irq_msi(irq);
 
-        write_msi_msg_desc(desc, msg);
+        __write_msi_msg(entry, msg);
 }
 
 static void free_msi_irqs(struct pci_dev *dev)
diff --git a/drivers/pcmcia/au1000_generic.c b/drivers/pcmcia/au1000_generic.c
index 88c4c4098789..95dd7c62741f 100644
--- a/drivers/pcmcia/au1000_generic.c
+++ b/drivers/pcmcia/au1000_generic.c
@@ -441,14 +441,12 @@ int au1x00_pcmcia_socket_probe(struct device *dev, struct pcmcia_low_level *ops,
 
 
 out_err:
-        flush_scheduled_work();
         ops->hw_shutdown(skt);
         while (i-- > 0) {
                 skt = PCMCIA_SOCKET(i);
 
                 del_timer_sync(&skt->poll_timer);
                 pcmcia_unregister_socket(&skt->socket);
-                flush_scheduled_work();
                 if (i == 0) {
                         iounmap(skt->virt_io + (u32)mips_io_port_base);
                         skt->virt_io = NULL;
@@ -480,7 +478,6 @@ int au1x00_drv_pcmcia_remove(struct platform_device *dev)
 
                 del_timer_sync(&skt->poll_timer);
                 pcmcia_unregister_socket(&skt->socket);
-                flush_scheduled_work();
                 skt->ops->hw_shutdown(skt);
                 au1x00_pcmcia_config_skt(skt, &dead_socket);
                 iounmap(skt->virt_io + (u32)mips_io_port_base);
diff --git a/drivers/pcmcia/au1000_generic.h b/drivers/pcmcia/au1000_generic.h
index 67530cefcf3c..5c36bda2963b 100644
--- a/drivers/pcmcia/au1000_generic.h
+++ b/drivers/pcmcia/au1000_generic.h
@@ -23,7 +23,6 @@
 
 /* include the world */
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/cistpl.h>
 #include "cs_internal.h"
diff --git a/drivers/pcmcia/au1000_pb1x00.c b/drivers/pcmcia/au1000_pb1x00.c
index 807f2d75dad3..b2396647a165 100644
--- a/drivers/pcmcia/au1000_pb1x00.c
+++ b/drivers/pcmcia/au1000_pb1x00.c
@@ -31,7 +31,6 @@
 #include <linux/proc_fs.h>
 #include <linux/types.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/cistpl.h>
 
diff --git a/drivers/pcmcia/cistpl.c b/drivers/pcmcia/cistpl.c
index 91414a0ddc44..884a984216fe 100644
--- a/drivers/pcmcia/cistpl.c
+++ b/drivers/pcmcia/cistpl.c
@@ -28,7 +28,6 @@
 #include <asm/unaligned.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/cistpl.h>
 #include "cs_internal.h"
diff --git a/drivers/pcmcia/cs.c b/drivers/pcmcia/cs.c
index 2ec8ac97445c..d9ea192c4001 100644
--- a/drivers/pcmcia/cs.c
+++ b/drivers/pcmcia/cs.c
@@ -33,7 +33,6 @@
 #include <asm/irq.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -845,7 +844,7 @@ static int pcmcia_socket_dev_resume_noirq(struct device *dev)
         return __pcmcia_pm_op(dev, socket_early_resume);
 }
 
-static int pcmcia_socket_dev_resume(struct device *dev)
+static int __used pcmcia_socket_dev_resume(struct device *dev)
 {
         return __pcmcia_pm_op(dev, socket_late_resume);
 }
diff --git a/drivers/pcmcia/cs_internal.h b/drivers/pcmcia/cs_internal.h
index da055dc14d98..7f1953f78b12 100644
--- a/drivers/pcmcia/cs_internal.h
+++ b/drivers/pcmcia/cs_internal.h
@@ -33,18 +33,9 @@
 typedef struct config_t {
         struct kref     ref;
         unsigned int    state;
-        unsigned int    Attributes;
-        unsigned int    IntType;
-        unsigned int    ConfigBase;
-        unsigned char   Status, Pin, Copy, Option, ExtStatus;
-        unsigned int    CardValues;
 
         struct resource io[MAX_IO_WIN]; /* io ports */
         struct resource mem[MAX_WIN];   /* mem areas */
-
-        struct {
-                u_int   Attributes;
-        } irq;
 } config_t;
 
 
diff --git a/drivers/pcmcia/ds.c b/drivers/pcmcia/ds.c
index 55570d9e1e4c..100c4412457d 100644
--- a/drivers/pcmcia/ds.c
+++ b/drivers/pcmcia/ds.c
@@ -26,7 +26,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/slab.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/ss.h>
@@ -52,7 +51,7 @@ static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
 
         if (!p_drv->probe || !p_drv->remove)
                 printk(KERN_DEBUG "pcmcia: %s lacks a requisite callback "
-                       "function\n", p_drv->drv.name);
+                       "function\n", p_drv->name);
 
         while (did && did->match_flags) {
                 for (i = 0; i < 4; i++) {
@@ -65,7 +64,7 @@ static void pcmcia_check_driver(struct pcmcia_driver *p_drv)
 
                         printk(KERN_DEBUG "pcmcia: %s: invalid hash for "
                                "product string \"%s\": is 0x%x, should "
-                               "be 0x%x\n", p_drv->drv.name, did->prod_id[i],
+                               "be 0x%x\n", p_drv->name, did->prod_id[i],
                                did->prod_id_hash[i], hash);
                         printk(KERN_DEBUG "pcmcia: see "
                                 "Documentation/pcmcia/devicetable.txt for "
@@ -180,10 +179,11 @@ int pcmcia_register_driver(struct pcmcia_driver *driver)
         /* initialize common fields */
         driver->drv.bus = &pcmcia_bus_type;
         driver->drv.owner = driver->owner;
+        driver->drv.name = driver->name;
         mutex_init(&driver->dynids.lock);
         INIT_LIST_HEAD(&driver->dynids.list);
 
-        pr_debug("registering driver %s\n", driver->drv.name);
+        pr_debug("registering driver %s\n", driver->name);
 
         error = driver_register(&driver->drv);
         if (error < 0)
@@ -203,7 +203,7 @@ EXPORT_SYMBOL(pcmcia_register_driver);
  */
 void pcmcia_unregister_driver(struct pcmcia_driver *driver)
 {
-        pr_debug("unregistering driver %s\n", driver->drv.name);
+        pr_debug("unregistering driver %s\n", driver->name);
         driver_unregister(&driver->drv);
         pcmcia_free_dynids(driver);
 }
@@ -264,7 +264,7 @@ static int pcmcia_device_probe(struct device *dev)
         p_drv = to_pcmcia_drv(dev->driver);
         s = p_dev->socket;
 
-        dev_dbg(dev, "trying to bind to %s\n", p_drv->drv.name);
+        dev_dbg(dev, "trying to bind to %s\n", p_drv->name);
 
         if ((!p_drv->probe) || (!p_dev->function_config) ||
             (!try_module_get(p_drv->owner))) {
@@ -276,21 +276,28 @@ static int pcmcia_device_probe(struct device *dev)
         ret = pccard_read_tuple(p_dev->socket, p_dev->func, CISTPL_CONFIG,
                                 &cis_config);
         if (!ret) {
-                p_dev->conf.ConfigBase = cis_config.base;
-                p_dev->conf.Present = cis_config.rmask[0];
+                p_dev->config_base = cis_config.base;
+                p_dev->config_regs = cis_config.rmask[0];
+                dev_dbg(dev, "base %x, regs %x", p_dev->config_base,
+                        p_dev->config_regs);
         } else {
                 dev_printk(KERN_INFO, dev,
                            "pcmcia: could not parse base and rmask0 of CIS\n");
-                p_dev->conf.ConfigBase = 0;
-                p_dev->conf.Present = 0;
+                p_dev->config_base = 0;
+                p_dev->config_regs = 0;
         }
 
         ret = p_drv->probe(p_dev);
         if (ret) {
                 dev_dbg(dev, "binding to %s failed with %d\n",
-                           p_drv->drv.name, ret);
+                           p_drv->name, ret);
                 goto put_module;
         }
+        dev_dbg(dev, "%s bound: Vpp %d.%d, idx %x, IRQ %d", p_drv->name,
+                p_dev->vpp/10, p_dev->vpp%10, p_dev->config_index, p_dev->irq);
+        dev_dbg(dev, "resources: ioport %pR %pR iomem %pR %pR %pR",
+                p_dev->resource[0], p_dev->resource[1], p_dev->resource[2],
+                p_dev->resource[3], p_dev->resource[4]);
 
         mutex_lock(&s->ops_mutex);
         if ((s->pcmcia_pfc) &&
@@ -374,13 +381,13 @@ static int pcmcia_device_remove(struct device *dev)
         if (p_dev->_irq || p_dev->_io || p_dev->_locked)
                 dev_printk(KERN_INFO, dev,
                         "pcmcia: driver %s did not release config properly\n",
-                        p_drv->drv.name);
+                        p_drv->name);
 
         for (i = 0; i < MAX_WIN; i++)
                 if (p_dev->_win & CLIENT_WIN_REQ(i))
                         dev_printk(KERN_INFO, dev,
                           "pcmcia: driver %s did not release window properly\n",
-                           p_drv->drv.name);
+                           p_drv->name);
 
         /* references from pcmcia_probe_device */
         pcmcia_put_dev(p_dev);
@@ -1136,7 +1143,7 @@ static int pcmcia_dev_suspend(struct device *dev, pm_message_t state)
                         dev_printk(KERN_ERR, dev,
                                    "pcmcia: device %s (driver %s) did "
                                    "not want to go to sleep (%d)\n",
-                                   p_dev->devname, p_drv->drv.name, ret);
+                                   p_dev->devname, p_drv->name, ret);
                         mutex_lock(&p_dev->socket->ops_mutex);
                         p_dev->suspended = 0;
                         mutex_unlock(&p_dev->socket->ops_mutex);
@@ -1178,7 +1185,7 @@ static int pcmcia_dev_resume(struct device *dev)
 
         if (p_dev->device_no == p_dev->func) {
                 dev_dbg(dev, "requesting configuration\n");
-                ret = pcmcia_request_configuration(p_dev, &p_dev->conf);
+                ret = pcmcia_enable_device(p_dev);
                 if (ret)
                         goto out;
         }
diff --git a/drivers/pcmcia/i82092.c b/drivers/pcmcia/i82092.c
index 05d0879ce935..fc7906eaf228 100644
--- a/drivers/pcmcia/i82092.c
+++ b/drivers/pcmcia/i82092.c
@@ -16,7 +16,6 @@
 #include <linux/device.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 #include <asm/system.h>
 #include <asm/io.h>
diff --git a/drivers/pcmcia/i82365.c b/drivers/pcmcia/i82365.c
index 61746bd598b3..72a033a2acdb 100644
--- a/drivers/pcmcia/i82365.c
+++ b/drivers/pcmcia/i82365.c
@@ -51,7 +51,6 @@
 #include <asm/system.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 #include <linux/isapnp.h>
 
diff --git a/drivers/pcmcia/m32r_cfc.c b/drivers/pcmcia/m32r_cfc.c
index 24de49925863..2adb0106a039 100644
--- a/drivers/pcmcia/m32r_cfc.c
+++ b/drivers/pcmcia/m32r_cfc.c
@@ -27,7 +27,6 @@
 #include <asm/system.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 #undef MAX_IO_WIN       /* FIXME */
 #define MAX_IO_WIN 1
diff --git a/drivers/pcmcia/m32r_pcc.c b/drivers/pcmcia/m32r_pcc.c
index 8e4723844ad3..1511ff71c87b 100644
--- a/drivers/pcmcia/m32r_pcc.c
+++ b/drivers/pcmcia/m32r_pcc.c
@@ -28,7 +28,6 @@
 #include <asm/addrspace.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 /* XXX: should be moved into asm/irq.h */
 #define PCC0_IRQ 24
diff --git a/drivers/pcmcia/m8xx_pcmcia.c b/drivers/pcmcia/m8xx_pcmcia.c
index f0ecad99ce81..99d4f23cb435 100644
--- a/drivers/pcmcia/m8xx_pcmcia.c
+++ b/drivers/pcmcia/m8xx_pcmcia.c
@@ -59,7 +59,6 @@
 #include <asm/irq.h>
 #include <asm/fs_pd.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 
 #define pcmcia_info(args...) printk(KERN_INFO "m8xx_pcmcia: "args)
diff --git a/drivers/pcmcia/o2micro.h b/drivers/pcmcia/o2micro.h
index e74bebac2695..5096e92c7a4c 100644
--- a/drivers/pcmcia/o2micro.h
+++ b/drivers/pcmcia/o2micro.h
@@ -153,14 +153,14 @@ static int o2micro_override(struct yenta_socket *socket)
 
                 if (use_speedup) {
                         dev_info(&socket->dev->dev,
-                                "O2: enabling read prefetch/write burst\n");
+                                "O2: enabling read prefetch/write burst. If you experience problems or performance issues, use the yenta_socket parameter 'o2_speedup=off'\n");
                         config_writeb(socket, O2_RESERVED1,
                                       a | O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST);
                         config_writeb(socket, O2_RESERVED2,
                                       b | O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST);
                 } else {
                         dev_info(&socket->dev->dev,
-                                "O2: disabling read prefetch/write burst\n");
+                                "O2: disabling read prefetch/write burst. If you experience problems or performance issues, use the yenta_socket parameter 'o2_speedup=on'\n");
                         config_writeb(socket, O2_RESERVED1,
                                       a & ~(O2_RES_READ_PREFETCH | O2_RES_WRITE_BURST));
                         config_writeb(socket, O2_RESERVED2,
diff --git a/drivers/pcmcia/pcmcia_cis.c b/drivers/pcmcia/pcmcia_cis.c
index 0ac54da15885..e2c92415b892 100644
--- a/drivers/pcmcia/pcmcia_cis.c
+++ b/drivers/pcmcia/pcmcia_cis.c
@@ -6,7 +6,7 @@
  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  *
  * Copyright (C) 1999        David A. Hinds
- * Copyright (C) 2004-2009   Dominik Brodowski
+ * Copyright (C) 2004-2010   Dominik Brodowski
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -22,7 +22,6 @@
 #include <pcmcia/cisreg.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/ds.h>
 #include "cs_internal.h"
 
@@ -126,14 +125,24 @@ next_entry:
         return ret;
 }
 
+
+/**
+ * pcmcia_io_cfg_data_width() - convert cfgtable to data path width parameter
+ */
+static int pcmcia_io_cfg_data_width(unsigned int flags)
+{
+        if (!(flags & CISTPL_IO_8BIT))
+                return IO_DATA_PATH_WIDTH_16;
+        if (!(flags & CISTPL_IO_16BIT))
+                return IO_DATA_PATH_WIDTH_8;
+        return IO_DATA_PATH_WIDTH_AUTO;
+}
+
+
 struct pcmcia_cfg_mem {
         struct pcmcia_device *p_dev;
+        int (*conf_check) (struct pcmcia_device *p_dev, void *priv_data);
         void *priv_data;
-        int (*conf_check) (struct pcmcia_device *p_dev,
-                           cistpl_cftable_entry_t *cfg,
-                           cistpl_cftable_entry_t *dflt,
-                           unsigned int vcc,
-                           void *priv_data);
         cisparse_t parse;
         cistpl_cftable_entry_t dflt;
 };
@@ -147,25 +156,102 @@ struct pcmcia_cfg_mem {
  */
 static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv)
 {
-        cistpl_cftable_entry_t *cfg = &parse->cftable_entry;
         struct pcmcia_cfg_mem *cfg_mem = priv;
+        struct pcmcia_device *p_dev = cfg_mem->p_dev;
+        cistpl_cftable_entry_t *cfg = &parse->cftable_entry;
+        cistpl_cftable_entry_t *dflt = &cfg_mem->dflt;
+        unsigned int flags = p_dev->config_flags;
+        unsigned int vcc = p_dev->socket->socket.Vcc;
+
+        dev_dbg(&p_dev->dev, "testing configuration %x, autoconf %x\n",
+                cfg->index, flags);
 
         /* default values */
-        cfg_mem->p_dev->conf.ConfigIndex = cfg->index;
+        cfg_mem->p_dev->config_index = cfg->index;
         if (cfg->flags & CISTPL_CFTABLE_DEFAULT)
                 cfg_mem->dflt = *cfg;
 
-        return cfg_mem->conf_check(cfg_mem->p_dev, cfg, &cfg_mem->dflt,
-                                   cfg_mem->p_dev->socket->socket.Vcc,
-                                   cfg_mem->priv_data);
+        /* check for matching Vcc? */
+        if (flags & CONF_AUTO_CHECK_VCC) {
+                if (cfg->vcc.present & (1 << CISTPL_POWER_VNOM)) {
+                        if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                                return -ENODEV;
+                } else if (dflt->vcc.present & (1 << CISTPL_POWER_VNOM)) {
+                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM] / 10000)
+                                return -ENODEV;
+                }
+        }
+
+        /* set Vpp? */
+        if (flags & CONF_AUTO_SET_VPP) {
+                if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM))
+                        p_dev->vpp = cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
+                else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM))
+                        p_dev->vpp =
+                                dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
+        }
+
+        /* enable audio? */
+        if ((flags & CONF_AUTO_AUDIO) && (cfg->flags & CISTPL_CFTABLE_AUDIO))
+                p_dev->config_flags |= CONF_ENABLE_SPKR;
+
+
+        /* IO window settings? */
+        if (flags & CONF_AUTO_SET_IO) {
+                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
+                int i = 0;
+
+                p_dev->resource[0]->start = p_dev->resource[0]->end = 0;
+                p_dev->resource[1]->start = p_dev->resource[1]->end = 0;
+                if (io->nwin == 0)
+                        return -ENODEV;
+
+                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+                p_dev->resource[0]->flags |=
+                                        pcmcia_io_cfg_data_width(io->flags);
+                if (io->nwin > 1) {
+                        /* For multifunction cards, by convention, we
+                         * configure the network function with window 0,
+                         * and serial with window 1 */
+                        i = (io->win[1].len > io->win[0].len);
+                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
+                        p_dev->resource[1]->start = io->win[1-i].base;
+                        p_dev->resource[1]->end = io->win[1-i].len;
+                }
+                p_dev->resource[0]->start = io->win[i].base;
+                p_dev->resource[0]->end = io->win[i].len;
+                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
+        }
+
+        /* MEM window settings? */
+        if (flags & CONF_AUTO_SET_IOMEM) {
+                /* so far, we only set one memory window */
+                cistpl_mem_t *mem = (cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
+
+                p_dev->resource[2]->start = p_dev->resource[2]->end = 0;
+                if (mem->nwin == 0)
+                        return -ENODEV;
+
+                p_dev->resource[2]->start = mem->win[0].host_addr;
+                p_dev->resource[2]->end = mem->win[0].len;
+                if (p_dev->resource[2]->end < 0x1000)
+                        p_dev->resource[2]->end = 0x1000;
+                p_dev->card_addr = mem->win[0].card_addr;
+        }
+
+        dev_dbg(&p_dev->dev,
+                "checking configuration %x: %pr %pr %pr (%d lines)\n",
+                p_dev->config_index, p_dev->resource[0], p_dev->resource[1],
+                p_dev->resource[2], p_dev->io_lines);
+
+        return cfg_mem->conf_check(p_dev, cfg_mem->priv_data);
 }
 
 /**
  * pcmcia_loop_config() - loop over configuration options
  * @p_dev:      the struct pcmcia_device which we need to loop for.
  * @conf_check: function to call for each configuration option.
- *              It gets passed the struct pcmcia_device, the CIS data
- *              describing the configuration option, and private data
+ *              It gets passed the struct pcmcia_device and private data
  *              being passed to pcmcia_loop_config()
  * @priv_data:  private data to be passed to the conf_check function.
  *
@@ -175,9 +261,6 @@ static int pcmcia_do_loop_config(tuple_t *tuple, cisparse_t *parse, void *priv)
  */
 int pcmcia_loop_config(struct pcmcia_device *p_dev,
                        int      (*conf_check)   (struct pcmcia_device *p_dev,
-                                                 cistpl_cftable_entry_t *cfg,
-                                                 cistpl_cftable_entry_t *dflt,
-                                                 unsigned int vcc,
                                                  void *priv_data),
                        void *priv_data)
 {
diff --git a/drivers/pcmcia/pcmcia_resource.c b/drivers/pcmcia/pcmcia_resource.c
index 9ba4dade69a4..a9af0d784426 100644
--- a/drivers/pcmcia/pcmcia_resource.c
+++ b/drivers/pcmcia/pcmcia_resource.c
@@ -6,7 +6,7 @@
  * are Copyright (C) 1999 David A. Hinds.  All Rights Reserved.
  *
  * Copyright (C) 1999        David A. Hinds
- * Copyright (C) 2004-2005   Dominik Brodowski
+ * Copyright (C) 2004-2010   Dominik Brodowski
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
@@ -26,7 +26,6 @@
 #include <asm/irq.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -56,6 +55,12 @@ struct resource *pcmcia_find_mem_region(u_long base, u_long num, u_long align,
 }
 
 
+/**
+ * release_io_space() - release IO ports allocated with alloc_io_space()
+ * @s: pcmcia socket
+ * @res: resource to release
+ *
+ */
 static void release_io_space(struct pcmcia_socket *s, struct resource *res)
 {
         resource_size_t num = resource_size(res);
@@ -81,9 +86,14 @@ static void release_io_space(struct pcmcia_socket *s, struct resource *res)
                         }
                 }
         }
-} /* release_io_space */
+}
+
 
-/** alloc_io_space
+/**
+ * alloc_io_space() - allocate IO ports for use by a PCMCIA device
+ * @s: pcmcia socket
+ * @res: resource to allocate (begin: begin, end: size)
+ * @lines: number of IO lines decoded by the PCMCIA card
  *
  * Special stuff for managing IO windows, because they are scarce
  */
@@ -135,7 +145,7 @@ static int alloc_io_space(struct pcmcia_socket *s, struct resource *res,
         }
         dev_dbg(&s->dev, "alloc_io_space request result %d: %pR\n", ret, res);
         return ret;
-} /* alloc_io_space */
+}
 
 
 /**
@@ -168,14 +178,14 @@ static int pcmcia_access_config(struct pcmcia_device *p_dev,
                 return -EACCES;
         }
 
-        addr = (c->ConfigBase + where) >> 1;
+        addr = (p_dev->config_base + where) >> 1;
 
         ret = accessf(s, 1, addr, 1, val);
 
         mutex_unlock(&s->ops_mutex);
 
         return ret;
-} /* pcmcia_access_config */
+}
 
 
 /**
@@ -204,11 +214,20 @@ int pcmcia_write_config_byte(struct pcmcia_device *p_dev, off_t where, u8 val)
 EXPORT_SYMBOL(pcmcia_write_config_byte);
 
 
-int pcmcia_map_mem_page(struct pcmcia_device *p_dev, window_handle_t wh,
+/**
+ * pcmcia_map_mem_page() - modify iomem window to point to a different offset
+ * @p_dev: pcmcia device
+ * @res: iomem resource already enabled by pcmcia_request_window()
+ * @offset: card_offset to map
+ *
+ * pcmcia_map_mem_page() modifies what can be read and written by accessing
+ * an iomem range previously enabled by pcmcia_request_window(), by setting
+ * the card_offset value to @offset.
+ */
+int pcmcia_map_mem_page(struct pcmcia_device *p_dev, struct resource *res,
                         unsigned int offset)
 {
         struct pcmcia_socket *s = p_dev->socket;
-        struct resource *res = wh;
         unsigned int w;
         int ret;
 
@@ -223,98 +242,111 @@ int pcmcia_map_mem_page(struct pcmcia_device *p_dev, window_handle_t wh,
                 dev_warn(&p_dev->dev, "failed to set_mem_map\n");
         mutex_unlock(&s->ops_mutex);
         return ret;
-} /* pcmcia_map_mem_page */
+}
 EXPORT_SYMBOL(pcmcia_map_mem_page);
 
 
-/** pcmcia_modify_configuration
+/**
+ * pcmcia_fixup_iowidth() - reduce io width to 8bit
+ * @p_dev: pcmcia device
  *
- * Modify a locked socket configuration
+ * pcmcia_fixup_iowidth() allows a PCMCIA device driver to reduce the
+ * IO width to 8bit after having called pcmcia_enable_device()
+ * previously.
  */
-int pcmcia_modify_configuration(struct pcmcia_device *p_dev,
-                                modconf_t *mod)
+int pcmcia_fixup_iowidth(struct pcmcia_device *p_dev)
 {
-        struct pcmcia_socket *s;
-        config_t *c;
-        int ret;
-
-        s = p_dev->socket;
+        struct pcmcia_socket *s = p_dev->socket;
+        pccard_io_map io_off = { 0, 0, 0, 0, 1 };
+        pccard_io_map io_on;
+        int i, ret = 0;
 
         mutex_lock(&s->ops_mutex);
-        c = p_dev->function_config;
 
-        if (!(s->state & SOCKET_PRESENT)) {
-                dev_dbg(&p_dev->dev, "No card present\n");
-                ret = -ENODEV;
-                goto unlock;
-        }
-        if (!(c->state & CONFIG_LOCKED)) {
-                dev_dbg(&p_dev->dev, "Configuration isnt't locked\n");
+        dev_dbg(&p_dev->dev, "fixup iowidth to 8bit\n");
+
+        if (!(s->state & SOCKET_PRESENT) ||
+                !(p_dev->function_config->state & CONFIG_LOCKED)) {
+                dev_dbg(&p_dev->dev, "No card? Config not locked?\n");
                 ret = -EACCES;
                 goto unlock;
         }
 
-        if (mod->Attributes & (CONF_IRQ_CHANGE_VALID | CONF_VCC_CHANGE_VALID)) {
-                dev_dbg(&p_dev->dev,
-                        "changing Vcc or IRQ is not allowed at this time\n");
-                ret = -EINVAL;
-                goto unlock;
-        }
+        io_on.speed = io_speed;
+        for (i = 0; i < MAX_IO_WIN; i++) {
+                if (!s->io[i].res)
+                        continue;
+                io_off.map = i;
+                io_on.map = i;
 
-        /* We only allow changing Vpp1 and Vpp2 to the same value */
-        if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) &&
-            (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
-                if (mod->Vpp1 != mod->Vpp2) {
-                        dev_dbg(&p_dev->dev,
-                                "Vpp1 and Vpp2 must be the same\n");
-                        ret = -EINVAL;
-                        goto unlock;
-                }
-                s->socket.Vpp = mod->Vpp1;
-                if (s->ops->set_socket(s, &s->socket)) {
-                        dev_printk(KERN_WARNING, &p_dev->dev,
-                                   "Unable to set VPP\n");
-                        ret = -EIO;
-                        goto unlock;
-                }
-        } else if ((mod->Attributes & CONF_VPP1_CHANGE_VALID) ||
-                   (mod->Attributes & CONF_VPP2_CHANGE_VALID)) {
-                dev_dbg(&p_dev->dev,
-                        "changing Vcc is not allowed at this time\n");
-                ret = -EINVAL;
-                goto unlock;
+                io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8;
+                io_on.start = s->io[i].res->start;
+                io_on.stop = s->io[i].res->end;
+
+                s->ops->set_io_map(s, &io_off);
+                mdelay(40);
+                s->ops->set_io_map(s, &io_on);
         }
+unlock:
+        mutex_unlock(&s->ops_mutex);
+
+        return ret;
+}
+EXPORT_SYMBOL(pcmcia_fixup_iowidth);
+
+
+/**
+ * pcmcia_fixup_vpp() - set Vpp to a new voltage level
+ * @p_dev: pcmcia device
+ * @new_vpp: new Vpp voltage
+ *
+ * pcmcia_fixup_vpp() allows a PCMCIA device driver to set Vpp to
+ * a new voltage level between calls to pcmcia_enable_device()
+ * and pcmcia_disable_device().
+ */
+int pcmcia_fixup_vpp(struct pcmcia_device *p_dev, unsigned char new_vpp)
+{
+        struct pcmcia_socket *s = p_dev->socket;
+        int ret = 0;
 
-        if (mod->Attributes & CONF_IO_CHANGE_WIDTH) {
-                pccard_io_map io_off = { 0, 0, 0, 0, 1 };
-                pccard_io_map io_on;
-                int i;
+        mutex_lock(&s->ops_mutex);
 
-                io_on.speed = io_speed;
-                for (i = 0; i < MAX_IO_WIN; i++) {
-                        if (!s->io[i].res)
-                                continue;
-                        io_off.map = i;
-                        io_on.map = i;
+        dev_dbg(&p_dev->dev, "fixup Vpp to %d\n", new_vpp);
 
-                        io_on.flags = MAP_ACTIVE | IO_DATA_PATH_WIDTH_8;
-                        io_on.start = s->io[i].res->start;
-                        io_on.stop = s->io[i].res->end;
+        if (!(s->state & SOCKET_PRESENT) ||
+                !(p_dev->function_config->state & CONFIG_LOCKED)) {
+                dev_dbg(&p_dev->dev, "No card? Config not locked?\n");
+                ret = -EACCES;
+                goto unlock;
+        }
 
-                        s->ops->set_io_map(s, &io_off);
-                        mdelay(40);
-                        s->ops->set_io_map(s, &io_on);
-                }
+        s->socket.Vpp = new_vpp;
+        if (s->ops->set_socket(s, &s->socket)) {
+                dev_warn(&p_dev->dev, "Unable to set VPP\n");
+                ret = -EIO;
+                goto unlock;
         }
-        ret = 0;
+        p_dev->vpp = new_vpp;
+
 unlock:
         mutex_unlock(&s->ops_mutex);
 
         return ret;
-} /* modify_configuration */
-EXPORT_SYMBOL(pcmcia_modify_configuration);
+}
+EXPORT_SYMBOL(pcmcia_fixup_vpp);
 
 
+/**
+ * pcmcia_release_configuration() - physically disable a PCMCIA device
+ * @p_dev: pcmcia device
+ *
+ * pcmcia_release_configuration() is the 1:1 counterpart to
+ * pcmcia_enable_device(): If a PCMCIA device is no longer used by any
+ * driver, the Vpp voltage is set to 0, IRQs will no longer be generated,
+ * and I/O ranges will be disabled. As pcmcia_release_io() and
+ * pcmcia_release_window() still need to be called, device drivers are
+ * expected to call pcmcia_disable_device() instead.
+ */
 int pcmcia_release_configuration(struct pcmcia_device *p_dev)
 {
         pccard_io_map io = { 0, 0, 0, 0, 1 };
@@ -327,7 +359,7 @@ int pcmcia_release_configuration(struct pcmcia_device *p_dev)
         if (p_dev->_locked) {
                 p_dev->_locked = 0;
                 if (--(s->lock_count) == 0) {
-                        s->socket.flags = SS_OUTPUT_ENA;   /* Is this correct? */
+                        s->socket.flags = SS_OUTPUT_ENA; /* Is this correct? */
                         s->socket.Vpp = 0;
                         s->socket.io_irq = 0;
                         s->ops->set_socket(s, &s->socket);
@@ -349,16 +381,18 @@ int pcmcia_release_configuration(struct pcmcia_device *p_dev)
         mutex_unlock(&s->ops_mutex);
 
         return 0;
-} /* pcmcia_release_configuration */
+}
 
 
-/** pcmcia_release_io
+/**
+ * pcmcia_release_io() - release I/O allocated by a PCMCIA device
+ * @p_dev: pcmcia device
  *
- * Release_io() releases the I/O ranges allocated by a client.  This
- * may be invoked some time after a card ejection has already dumped
- * the actual socket configuration, so if the client is "stale", we
- * don't bother checking the port ranges against the current socket
- * values.
+ * pcmcia_release_io() releases the I/O ranges allocated by a PCMCIA
+ * device.  This may be invoked some time after a card ejection has
+ * already dumped the actual socket configuration, so if the client is
+ * "stale", we don't bother checking the port ranges against the
+ * current socket values.
  */
 static int pcmcia_release_io(struct pcmcia_device *p_dev)
 {
@@ -387,6 +421,14 @@ out:
 } /* pcmcia_release_io */
 
 
+/**
+ * pcmcia_release_window() - release reserved iomem for PCMCIA devices
+ * @p_dev: pcmcia device
+ * @res: iomem resource to release
+ *
+ * pcmcia_release_window() releases &struct resource *res which was
+ * previously reserved by calling pcmcia_request_window().
+ */
 int pcmcia_release_window(struct pcmcia_device *p_dev, struct resource *res)
 {
         struct pcmcia_socket *s = p_dev->socket;
@@ -420,6 +462,8 @@ int pcmcia_release_window(struct pcmcia_device *p_dev, struct resource *res)
                 kfree(win->res);
                 win->res = NULL;
         }
+        res->start = res->end = 0;
+        res->flags = IORESOURCE_MEM;
         p_dev->_win &= ~CLIENT_WIN_REQ(w);
         mutex_unlock(&s->ops_mutex);
 
@@ -428,23 +472,30 @@ int pcmcia_release_window(struct pcmcia_device *p_dev, struct resource *res)
 EXPORT_SYMBOL(pcmcia_release_window);
 
 
-int pcmcia_request_configuration(struct pcmcia_device *p_dev,
-                                 config_req_t *req)
+/**
+ * pcmcia_enable_device() - set up and activate a PCMCIA device
+ * @p_dev: the associated PCMCIA device
+ *
+ * pcmcia_enable_device() physically enables a PCMCIA device. It parses
+ * the flags passed to in @flags and stored in @p_dev->flags and sets up
+ * the Vpp voltage, enables the speaker line, I/O ports and store proper
+ * values to configuration registers.
+ */
+int pcmcia_enable_device(struct pcmcia_device *p_dev)
 {
         int i;
-        u_int base;
+        unsigned int base;
         struct pcmcia_socket *s = p_dev->socket;
         config_t *c;
         pccard_io_map iomap;
+        unsigned char status = 0;
+        unsigned char ext_status = 0;
+        unsigned char option = 0;
+        unsigned int flags = p_dev->config_flags;
 
         if (!(s->state & SOCKET_PRESENT))
                 return -ENODEV;
 
-        if (req->IntType & INT_CARDBUS) {
-                dev_dbg(&p_dev->dev, "IntType may not be INT_CARDBUS\n");
-                return -EINVAL;
-        }
-
         mutex_lock(&s->ops_mutex);
         c = p_dev->function_config;
         if (c->state & CONFIG_LOCKED) {
@@ -454,7 +505,7 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
         }
 
         /* Do power control.  We don't allow changes in Vcc. */
-        s->socket.Vpp = req->Vpp;
+        s->socket.Vpp = p_dev->vpp;
         if (s->ops->set_socket(s, &s->socket)) {
                 mutex_unlock(&s->ops_mutex);
                 dev_printk(KERN_WARNING, &p_dev->dev,
@@ -463,64 +514,72 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
         }
 
         /* Pick memory or I/O card, DMA mode, interrupt */
-        c->IntType = req->IntType;
-        c->Attributes = req->Attributes;
-        if (req->IntType & INT_MEMORY_AND_IO)
+        if (p_dev->_io)
                 s->socket.flags |= SS_IOCARD;
-        if (req->IntType & INT_ZOOMED_VIDEO)
-                s->socket.flags |= SS_ZVCARD | SS_IOCARD;
-        if (req->Attributes & CONF_ENABLE_DMA)
-                s->socket.flags |= SS_DMA_MODE;
-        if (req->Attributes & CONF_ENABLE_SPKR)
+        if (flags & CONF_ENABLE_SPKR) {
                 s->socket.flags |= SS_SPKR_ENA;
-        if (req->Attributes & CONF_ENABLE_IRQ)
+                status = CCSR_AUDIO_ENA;
+                if (!(p_dev->config_regs & PRESENT_STATUS))
+                        dev_warn(&p_dev->dev, "speaker requested, but "
+                                              "PRESENT_STATUS not set!\n");
+        }
+        if (flags & CONF_ENABLE_IRQ)
                 s->socket.io_irq = s->pcmcia_irq;
         else
                 s->socket.io_irq = 0;
+        if (flags & CONF_ENABLE_ESR) {
+                p_dev->config_regs |= PRESENT_EXT_STATUS;
+                ext_status = ESR_REQ_ATTN_ENA;
+        }
         s->ops->set_socket(s, &s->socket);
         s->lock_count++;
 
+        dev_dbg(&p_dev->dev,
+                "enable_device: V %d, flags %x, base %x, regs %x, idx %x\n",
+                p_dev->vpp, flags, p_dev->config_base, p_dev->config_regs,
+                p_dev->config_index);
+
         /* Set up CIS configuration registers */
-        base = c->ConfigBase = req->ConfigBase;
-        c->CardValues = req->Present;
-        if (req->Present & PRESENT_COPY) {
-                c->Copy = req->Copy;
-                pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &c->Copy);
-        }
-        if (req->Present & PRESENT_OPTION) {
+        base = p_dev->config_base;
+        if (p_dev->config_regs & PRESENT_COPY) {
+                u16 tmp = 0;
+                dev_dbg(&p_dev->dev, "clearing CISREG_SCR\n");
+                pcmcia_write_cis_mem(s, 1, (base + CISREG_SCR)>>1, 1, &tmp);
+        }
+        if (p_dev->config_regs & PRESENT_PIN_REPLACE) {
+                u16 tmp = 0;
+                dev_dbg(&p_dev->dev, "clearing CISREG_PRR\n");
+                pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &tmp);
+        }
+        if (p_dev->config_regs & PRESENT_OPTION) {
                 if (s->functions == 1) {
-                        c->Option = req->ConfigIndex & COR_CONFIG_MASK;
+                        option = p_dev->config_index & COR_CONFIG_MASK;
                 } else {
-                        c->Option = req->ConfigIndex & COR_MFC_CONFIG_MASK;
-                        c->Option |= COR_FUNC_ENA|COR_IREQ_ENA;
-                        if (req->Present & PRESENT_IOBASE_0)
-                                c->Option |= COR_ADDR_DECODE;
+                        option = p_dev->config_index & COR_MFC_CONFIG_MASK;
+                        option |= COR_FUNC_ENA|COR_IREQ_ENA;
+                        if (p_dev->config_regs & PRESENT_IOBASE_0)
+                                option |= COR_ADDR_DECODE;
                 }
-                if ((req->Attributes & CONF_ENABLE_IRQ) &&
-                        !(req->Attributes & CONF_ENABLE_PULSE_IRQ))
-                        c->Option |= COR_LEVEL_REQ;
-                pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &c->Option);
+                if ((flags & CONF_ENABLE_IRQ) &&
+                        !(flags & CONF_ENABLE_PULSE_IRQ))
+                        option |= COR_LEVEL_REQ;
+                pcmcia_write_cis_mem(s, 1, (base + CISREG_COR)>>1, 1, &option);
                 mdelay(40);
         }
-        if (req->Present & PRESENT_STATUS) {
-                c->Status = req->Status;
-                pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &c->Status);
-        }
-        if (req->Present & PRESENT_PIN_REPLACE) {
-                c->Pin = req->Pin;
-                pcmcia_write_cis_mem(s, 1, (base + CISREG_PRR)>>1, 1, &c->Pin);
-        }
-        if (req->Present & PRESENT_EXT_STATUS) {
-                c->ExtStatus = req->ExtStatus;
-                pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1, &c->ExtStatus);
-        }
-        if (req->Present & PRESENT_IOBASE_0) {
+        if (p_dev->config_regs & PRESENT_STATUS)
+                pcmcia_write_cis_mem(s, 1, (base + CISREG_CCSR)>>1, 1, &status);
+
+        if (p_dev->config_regs & PRESENT_EXT_STATUS)
+                pcmcia_write_cis_mem(s, 1, (base + CISREG_ESR)>>1, 1,
+                                        &ext_status);
+
+        if (p_dev->config_regs & PRESENT_IOBASE_0) {
                 u8 b = c->io[0].start & 0xff;
                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_0)>>1, 1, &b);
                 b = (c->io[0].start >> 8) & 0xff;
                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOBASE_1)>>1, 1, &b);
         }
-        if (req->Present & PRESENT_IOSIZE) {
+        if (p_dev->config_regs & PRESENT_IOSIZE) {
                 u8 b = resource_size(&c->io[0]) + resource_size(&c->io[1]) - 1;
                 pcmcia_write_cis_mem(s, 1, (base + CISREG_IOSIZE)>>1, 1, &b);
         }
@@ -551,14 +610,15 @@ int pcmcia_request_configuration(struct pcmcia_device *p_dev,
         p_dev->_locked = 1;
         mutex_unlock(&s->ops_mutex);
         return 0;
-} /* pcmcia_request_configuration */
-EXPORT_SYMBOL(pcmcia_request_configuration);
+} /* pcmcia_enable_device */
+EXPORT_SYMBOL(pcmcia_enable_device);
 
 
 /**
  * pcmcia_request_io() - attempt to reserve port ranges for PCMCIA devices
+ * @p_dev: the associated PCMCIA device
  *
- * pcmcia_request_io() attepts to reserve the IO port ranges specified in
+ * pcmcia_request_io() attempts to reserve the IO port ranges specified in
  * &struct pcmcia_device @p_dev->resource[0] and @p_dev->resource[1]. The
  * "start" value is the requested start of the IO port resource; "end"
  * reflects the number of ports requested. The number of IO lines requested
@@ -622,11 +682,13 @@ EXPORT_SYMBOL(pcmcia_request_io);
 
 /**
  * pcmcia_request_irq() - attempt to request a IRQ for a PCMCIA device
+ * @p_dev: the associated PCMCIA device
+ * @handler: IRQ handler to register
  *
- * pcmcia_request_irq() is a wrapper around request_irq which will allow
+ * pcmcia_request_irq() is a wrapper around request_irq() which allows
  * the PCMCIA core to clean up the registration in pcmcia_disable_device().
  * Drivers are free to use request_irq() directly, but then they need to
- * call free_irq themselfves, too. Also, only IRQF_SHARED capable IRQ
+ * call free_irq() themselfves, too. Also, only %IRQF_SHARED capable IRQ
  * handlers are allowed.
  */
 int __must_check pcmcia_request_irq(struct pcmcia_device *p_dev,
@@ -649,12 +711,14 @@ EXPORT_SYMBOL(pcmcia_request_irq);
 
 /**
  * pcmcia_request_exclusive_irq() - attempt to request an exclusive IRQ first
+ * @p_dev: the associated PCMCIA device
+ * @handler: IRQ handler to register
  *
- * pcmcia_request_exclusive_irq() is a wrapper around request_irq which
+ * pcmcia_request_exclusive_irq() is a wrapper around request_irq() which
  * attempts first to request an exclusive IRQ. If it fails, it also accepts
  * a shared IRQ, but prints out a warning. PCMCIA drivers should allow for
  * IRQ sharing and either use request_irq directly (then they need to call
- * free_irq themselves, too), or the pcmcia_request_irq() function.
+ * free_irq() themselves, too), or the pcmcia_request_irq() function.
  */
 int __must_check
 __pcmcia_request_exclusive_irq(struct pcmcia_device *p_dev,
@@ -795,38 +859,47 @@ int pcmcia_setup_irq(struct pcmcia_device *p_dev)
 }
 
 
-/** pcmcia_request_window
+/**
+ * pcmcia_request_window() - attempt to reserve iomem for PCMCIA devices
+ * @p_dev: the associated PCMCIA device
+ * @res: &struct resource pointing to p_dev->resource[2..5]
+ * @speed: access speed
  *
- * Request_window() establishes a mapping between card memory space
- * and system memory space.
+ * pcmcia_request_window() attepts to reserve an iomem ranges specified in
+ * &struct resource @res pointing to one of the entries in
+ * &struct pcmcia_device @p_dev->resource[2..5]. The "start" value is the
+ * requested start of the IO mem resource; "end" reflects the size
+ * requested.
  */
-int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_handle_t *wh)
+int pcmcia_request_window(struct pcmcia_device *p_dev, struct resource *res,
+                        unsigned int speed)
 {
         struct pcmcia_socket *s = p_dev->socket;
         pccard_mem_map *win;
         u_long align;
-        struct resource *res;
         int w;
 
+        dev_dbg(&p_dev->dev, "request_window %pR %d\n", res, speed);
+
         if (!(s->state & SOCKET_PRESENT)) {
                 dev_dbg(&p_dev->dev, "No card present\n");
                 return -ENODEV;
         }
 
         /* Window size defaults to smallest available */
-        if (req->Size == 0)
-                req->Size = s->map_size;
-        align = (s->features & SS_CAP_MEM_ALIGN) ? req->Size : s->map_size;
-        if (req->Size & (s->map_size-1)) {
+        if (res->end == 0)
+                res->end = s->map_size;
+        align = (s->features & SS_CAP_MEM_ALIGN) ? res->end : s->map_size;
+        if (res->end & (s->map_size-1)) {
                 dev_dbg(&p_dev->dev, "invalid map size\n");
                 return -EINVAL;
         }
-        if ((req->Base && (s->features & SS_CAP_STATIC_MAP)) ||
-            (req->Base & (align-1))) {
+        if ((res->start && (s->features & SS_CAP_STATIC_MAP)) ||
+            (res->start & (align-1))) {
                 dev_dbg(&p_dev->dev, "invalid base address\n");
                 return -EINVAL;
         }
-        if (req->Base)
+        if (res->start)
                 align = 0;
 
         /* Allocate system memory window */
@@ -843,7 +916,7 @@ int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_ha
         win = &s->win[w];
 
         if (!(s->features & SS_CAP_STATIC_MAP)) {
-                win->res = pcmcia_find_mem_region(req->Base, req->Size, align,
+                win->res = pcmcia_find_mem_region(res->start, res->end, align,
                                                 0, s);
                 if (!win->res) {
                         dev_dbg(&p_dev->dev, "allocating mem region failed\n");
@@ -855,8 +928,8 @@ int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_ha
 
         /* Configure the socket controller */
         win->map = w+1;
-        win->flags = req->Attributes;
-        win->speed = req->AccessSpeed;
+        win->flags = res->flags & WIN_FLAGS_MAP;
+        win->speed = speed;
         win->card_start = 0;
 
         if (s->ops->set_mem_map(s, win) != 0) {
@@ -868,17 +941,14 @@ int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_ha
 
         /* Return window handle */
         if (s->features & SS_CAP_STATIC_MAP)
-                req->Base = win->static_start;
+                res->start = win->static_start;
         else
-                req->Base = win->res->start;
+                res->start = win->res->start;
 
         /* convert to new-style resources */
-        res = p_dev->resource[w + MAX_IO_WIN];
-        res->start = req->Base;
-        res->end = req->Base + req->Size - 1;
-        res->flags &= ~IORESOURCE_BITS;
-        res->flags |= (req->Attributes & WIN_FLAGS_MAP) | (win->map << 2);
-        res->flags |= IORESOURCE_MEM;
+        res->end += res->start - 1;
+        res->flags &= ~WIN_FLAGS_REQ;
+        res->flags |= (win->map << 2) | IORESOURCE_MEM;
         res->parent = win->res;
         if (win->res)
                 request_resource(&iomem_resource, res);
@@ -886,15 +956,30 @@ int pcmcia_request_window(struct pcmcia_device *p_dev, win_req_t *req, window_ha
         dev_dbg(&p_dev->dev, "request_window results in %pR\n", res);
 
         mutex_unlock(&s->ops_mutex);
-        *wh = res;
 
         return 0;
 } /* pcmcia_request_window */
 EXPORT_SYMBOL(pcmcia_request_window);
 
+
+/**
+ * pcmcia_disable_device() - disable and clean up a PCMCIA device
+ * @p_dev: the associated PCMCIA device
+ *
+ * pcmcia_disable_device() is the driver-callable counterpart to
+ * pcmcia_enable_device(): If a PCMCIA device is no longer used,
+ * drivers are expected to clean up and disable the device by calling
+ * this function. Any I/O ranges (iomem and ioports) will be released,
+ * the Vpp voltage will be set to 0, and IRQs will no longer be
+ * generated -- at least if there is no other card function (of
+ * multifunction devices) being used.
+ */
 void pcmcia_disable_device(struct pcmcia_device *p_dev)
 {
         int i;
+
+        dev_dbg(&p_dev->dev, "disabling device\n");
+
         for (i = 0; i < MAX_WIN; i++) {
                 struct resource *res = p_dev->resource[MAX_IO_WIN + i];
                 if (res->flags & WIN_FLAGS_REQ)
diff --git a/drivers/pcmcia/pd6729.c b/drivers/pcmcia/pd6729.c
index deef6656ab7b..8cbfa067171f 100644
--- a/drivers/pcmcia/pd6729.c
+++ b/drivers/pcmcia/pd6729.c
@@ -18,7 +18,6 @@
 #include <linux/io.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 #include <asm/system.h>
 
diff --git a/drivers/pcmcia/rsrc_iodyn.c b/drivers/pcmcia/rsrc_iodyn.c
index 8510c35d2952..523eb691c30b 100644
--- a/drivers/pcmcia/rsrc_iodyn.c
+++ b/drivers/pcmcia/rsrc_iodyn.c
@@ -17,7 +17,6 @@
 #include <linux/kernel.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include "cs_internal.h"
 
diff --git a/drivers/pcmcia/rsrc_mgr.c b/drivers/pcmcia/rsrc_mgr.c
index 4e80421fd908..aa628ed0e9f4 100644
--- a/drivers/pcmcia/rsrc_mgr.c
+++ b/drivers/pcmcia/rsrc_mgr.c
@@ -17,7 +17,6 @@
 #include <linux/kernel.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include "cs_internal.h"
 
diff --git a/drivers/pcmcia/rsrc_nonstatic.c b/drivers/pcmcia/rsrc_nonstatic.c
index 96f348b35fde..b187555d4388 100644
--- a/drivers/pcmcia/rsrc_nonstatic.c
+++ b/drivers/pcmcia/rsrc_nonstatic.c
@@ -29,7 +29,6 @@
 #include <asm/irq.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include "cs_internal.h"
 
diff --git a/drivers/pcmcia/sa1100_generic.c b/drivers/pcmcia/sa1100_generic.c
index e09851480295..945857f8c284 100644
--- a/drivers/pcmcia/sa1100_generic.c
+++ b/drivers/pcmcia/sa1100_generic.c
@@ -35,7 +35,6 @@
 #include <linux/slab.h>
 #include <linux/platform_device.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 
 #include <asm/hardware/scoop.h>
diff --git a/drivers/pcmcia/soc_common.c b/drivers/pcmcia/soc_common.c
index 6f1a86b43c60..689e3c02edb8 100644
--- a/drivers/pcmcia/soc_common.c
+++ b/drivers/pcmcia/soc_common.c
@@ -627,8 +627,6 @@ void soc_pcmcia_remove_one(struct soc_pcmcia_socket *skt)
 
         pcmcia_unregister_socket(&skt->socket);
 
-        flush_scheduled_work();
-
         skt->ops->hw_shutdown(skt);
 
         soc_common_pcmcia_config_skt(skt, &dead_socket);
@@ -720,8 +718,6 @@ int soc_pcmcia_add_one(struct soc_pcmcia_socket *skt)
         pcmcia_unregister_socket(&skt->socket);
 
  out_err_7:
-        flush_scheduled_work();
-
         skt->ops->hw_shutdown(skt);
  out_err_6:
         list_del(&skt->node);
diff --git a/drivers/pcmcia/soc_common.h b/drivers/pcmcia/soc_common.h
index 3fba3a679128..bbcd5385a221 100644
--- a/drivers/pcmcia/soc_common.h
+++ b/drivers/pcmcia/soc_common.h
@@ -11,7 +11,6 @@
 
 /* include the world */
 #include <linux/cpufreq.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/cistpl.h>
 
diff --git a/drivers/pcmcia/socket_sysfs.c b/drivers/pcmcia/socket_sysfs.c
index cb0d3ace18bd..71aeed93037c 100644
--- a/drivers/pcmcia/socket_sysfs.c
+++ b/drivers/pcmcia/socket_sysfs.c
@@ -27,7 +27,6 @@
 #include <asm/irq.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
diff --git a/drivers/pcmcia/tcic.c b/drivers/pcmcia/tcic.c
index be0d841c7ebd..310160bffe38 100644
--- a/drivers/pcmcia/tcic.c
+++ b/drivers/pcmcia/tcic.c
@@ -49,7 +49,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 #include "tcic.h"
 
diff --git a/drivers/pcmcia/vrc4173_cardu.c b/drivers/pcmcia/vrc4173_cardu.c
index 9b3c15827e5c..c6d36b3a6ce8 100644
--- a/drivers/pcmcia/vrc4173_cardu.c
+++ b/drivers/pcmcia/vrc4173_cardu.c
@@ -461,7 +461,7 @@ static int __devinit vrc4173_cardu_probe(struct pci_dev *dev,
 {
         vrc4173_socket_t *socket;
         unsigned long start, len, flags;
-        int slot, err;
+        int slot, err, ret;
 
         slot = vrc4173_cardu_slots++;
         socket = &cardu_sockets[slot];
@@ -474,43 +474,63 @@ static int __devinit vrc4173_cardu_probe(struct pci_dev *dev,
                 return err;
 
         start = pci_resource_start(dev, 0);
-        if (start == 0)
-                return -ENODEV;
+        if (start == 0) {
+                ret = -ENODEV;
+                goto disable;
+        }
 
         len = pci_resource_len(dev, 0);
-        if (len == 0)
-                return -ENODEV;
+        if (len == 0) {
+                ret = -ENODEV;
+                goto disable;
+        }
 
-        if (((flags = pci_resource_flags(dev, 0)) & IORESOURCE_MEM) == 0)
-                return -EBUSY;
+        flags = pci_resource_flags(dev, 0);
+        if ((flags & IORESOURCE_MEM) == 0) {
+                ret = -EBUSY;
+                goto disable;
+        }
 
-        if ((err = pci_request_regions(dev, socket->name)) < 0)
-                return err;
+        err = pci_request_regions(dev, socket->name);
+        if (err < 0) {
+                ret = err;
+                goto disable;
+        }
 
         socket->base = ioremap(start, len);
-        if (socket->base == NULL)
-                return -ENODEV;
+        if (socket->base == NULL) {
+                ret = -ENODEV;
+                goto release;
+        }
 
         socket->dev = dev;
 
         socket->pcmcia_socket = pcmcia_register_socket(slot, &cardu_operations, 1);
         if (socket->pcmcia_socket == NULL) {
-                iounmap(socket->base);
-                socket->base = NULL;
-                return -ENOMEM;
+                ret =  -ENOMEM;
+                goto unmap;
         }
 
         if (request_irq(dev->irq, cardu_interrupt, IRQF_SHARED, socket->name, socket) < 0) {
-                pcmcia_unregister_socket(socket->pcmcia_socket);
-                socket->pcmcia_socket = NULL;
-                iounmap(socket->base);
-                socket->base = NULL;
-                return -EBUSY;
+                ret = -EBUSY;
+                goto unregister;
         }
 
         printk(KERN_INFO "%s at %#08lx, IRQ %d\n", socket->name, start, dev->irq);
 
         return 0;
+
+unregister:
+        pcmcia_unregister_socket(socket->pcmcia_socket);
+        socket->pcmcia_socket = NULL;
+unmap:
+        iounmap(socket->base);
+        socket->base = NULL;
+release:
+        pci_release_regions(dev);
+disable:
+        pci_disable_device(dev);
+        return ret;
 }
 
 static int __devinit vrc4173_cardu_setup(char *options)
diff --git a/drivers/pcmcia/xxs1500_ss.c b/drivers/pcmcia/xxs1500_ss.c
index fa88c360c37a..3b67a1b6a197 100644
--- a/drivers/pcmcia/xxs1500_ss.c
+++ b/drivers/pcmcia/xxs1500_ss.c
@@ -17,7 +17,6 @@
 #include <linux/slab.h>
 #include <linux/spinlock.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/ss.h>
 #include <pcmcia/cistpl.h>
 
diff --git a/drivers/pcmcia/yenta_socket.c b/drivers/pcmcia/yenta_socket.c
index 414d9a6f9a32..408dbaa080a1 100644
--- a/drivers/pcmcia/yenta_socket.c
+++ b/drivers/pcmcia/yenta_socket.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 
 #include <pcmcia/ss.h>
-#include <pcmcia/cs.h>
 
 #include "yenta_socket.h"
 #include "i82365.h"
diff --git a/drivers/platform/x86/intel_ips.c b/drivers/platform/x86/intel_ips.c
index 9024480a8228..c44a5e8b8b82 100644
--- a/drivers/platform/x86/intel_ips.c
+++ b/drivers/platform/x86/intel_ips.c
@@ -51,7 +51,6 @@
  * TODO:
  *   - handle CPU hotplug
  *   - provide turbo enable/disable api
- *   - make sure we can write turbo enable/disable reg based on MISC_EN
  *
  * Related documents:
  *   - CDI 403777, 403778 - Auburndale EDS vol 1 & 2
@@ -230,7 +229,7 @@
 #define THM_TC2         0xac
 #define THM_DTV         0xb0
 #define THM_ITV         0xd8
-#define   ITV_ME_SEQNO_MASK 0x000f0000 /* ME should update every ~200ms */
+#define   ITV_ME_SEQNO_MASK 0x00ff0000 /* ME should update every ~200ms */
 #define   ITV_ME_SEQNO_SHIFT (16)
 #define   ITV_MCH_TEMP_MASK 0x0000ff00
 #define   ITV_MCH_TEMP_SHIFT (8)
@@ -325,6 +324,7 @@ struct ips_driver {
         bool gpu_preferred;
         bool poll_turbo_status;
         bool second_cpu;
+        bool turbo_toggle_allowed;
         struct ips_mcp_limits *limits;
 
         /* Optional MCH interfaces for if i915 is in use */
@@ -415,7 +415,7 @@ static void ips_cpu_lower(struct ips_driver *ips)
         new_limit = cur_limit - 8; /* 1W decrease */
 
         /* Clamp to SKU TDP limit */
-        if (((new_limit * 10) / 8) < (ips->orig_turbo_limit & TURBO_TDP_MASK))
+        if (new_limit  < (ips->orig_turbo_limit & TURBO_TDP_MASK))
                 new_limit = ips->orig_turbo_limit & TURBO_TDP_MASK;
 
         thm_writew(THM_MPCPC, (new_limit * 10) / 8);
@@ -461,7 +461,8 @@ static void ips_enable_cpu_turbo(struct ips_driver *ips)
         if (ips->__cpu_turbo_on)
                 return;
 
-        on_each_cpu(do_enable_cpu_turbo, ips, 1);
+        if (ips->turbo_toggle_allowed)
+                on_each_cpu(do_enable_cpu_turbo, ips, 1);
 
         ips->__cpu_turbo_on = true;
 }
@@ -498,7 +499,8 @@ static void ips_disable_cpu_turbo(struct ips_driver *ips)
         if (!ips->__cpu_turbo_on)
                 return;
 
-        on_each_cpu(do_disable_cpu_turbo, ips, 1);
+        if (ips->turbo_toggle_allowed)
+                on_each_cpu(do_disable_cpu_turbo, ips, 1);
 
         ips->__cpu_turbo_on = false;
 }
@@ -598,17 +600,29 @@ static bool mcp_exceeded(struct ips_driver *ips)
 {
         unsigned long flags;
         bool ret = false;
+        u32 temp_limit;
+        u32 avg_power;
+        const char *msg = "MCP limit exceeded: ";
 
         spin_lock_irqsave(&ips->turbo_status_lock, flags);
-        if (ips->mcp_avg_temp > (ips->mcp_temp_limit * 100))
-                ret = true;
-        if (ips->cpu_avg_power + ips->mch_avg_power > ips->mcp_power_limit)
+
+        temp_limit = ips->mcp_temp_limit * 100;
+        if (ips->mcp_avg_temp > temp_limit) {
+                dev_info(&ips->dev->dev,
+                        "%sAvg temp %u, limit %u\n", msg, ips->mcp_avg_temp,
+                        temp_limit);
                 ret = true;
-        spin_unlock_irqrestore(&ips->turbo_status_lock, flags);
+        }
 
-        if (ret)
+        avg_power = ips->cpu_avg_power + ips->mch_avg_power;
+        if (avg_power > ips->mcp_power_limit) {
                 dev_info(&ips->dev->dev,
-                         "MCP power or thermal limit exceeded\n");
+                        "%sAvg power %u, limit %u\n", msg, avg_power,
+                        ips->mcp_power_limit);
+                ret = true;
+        }
+
+        spin_unlock_irqrestore(&ips->turbo_status_lock, flags);
 
         return ret;
 }
@@ -663,6 +677,27 @@ static bool mch_exceeded(struct ips_driver *ips)
 }
 
 /**
+ * verify_limits - verify BIOS provided limits
+ * @ips: IPS structure
+ *
+ * BIOS can optionally provide non-default limits for power and temp.  Check
+ * them here and use the defaults if the BIOS values are not provided or
+ * are otherwise unusable.
+ */
+static void verify_limits(struct ips_driver *ips)
+{
+        if (ips->mcp_power_limit < ips->limits->mcp_power_limit ||
+            ips->mcp_power_limit > 35000)
+                ips->mcp_power_limit = ips->limits->mcp_power_limit;
+
+        if (ips->mcp_temp_limit < ips->limits->core_temp_limit ||
+            ips->mcp_temp_limit < ips->limits->mch_temp_limit ||
+            ips->mcp_temp_limit > 150)
+                ips->mcp_temp_limit = min(ips->limits->core_temp_limit,
+                                          ips->limits->mch_temp_limit);
+}
+
+/**
  * update_turbo_limits - get various limits & settings from regs
  * @ips: IPS driver struct
  *
@@ -680,12 +715,21 @@ static void update_turbo_limits(struct ips_driver *ips)
         u32 hts = thm_readl(THM_HTS);
 
         ips->cpu_turbo_enabled = !(hts & HTS_PCTD_DIS);
-        ips->gpu_turbo_enabled = !(hts & HTS_GTD_DIS);
+        /* 
+         * Disable turbo for now, until we can figure out why the power figures
+         * are wrong
+         */
+        ips->cpu_turbo_enabled = false;
+
+        if (ips->gpu_busy)
+                ips->gpu_turbo_enabled = !(hts & HTS_GTD_DIS);
+
         ips->core_power_limit = thm_readw(THM_MPCPC);
         ips->mch_power_limit = thm_readw(THM_MMGPC);
         ips->mcp_temp_limit = thm_readw(THM_PTL);
         ips->mcp_power_limit = thm_readw(THM_MPPC);
 
+        verify_limits(ips);
         /* Ignore BIOS CPU vs GPU pref */
 }
 
@@ -858,7 +902,7 @@ static u32 get_cpu_power(struct ips_driver *ips, u32 *last, int period)
         ret = (ret * 1000) / 65535;
         *last = val;
 
-        return ret;
+        return 0;
 }
 
 static const u16 temp_decay_factor = 2;
@@ -940,7 +984,6 @@ static int ips_monitor(void *data)
                 kfree(mch_samples);
                 kfree(cpu_samples);
                 kfree(mchp_samples);
-                kthread_stop(ips->adjust);
                 return -ENOMEM;
         }
 
@@ -948,7 +991,7 @@ static int ips_monitor(void *data)
                 ITV_ME_SEQNO_SHIFT;
         seqno_timestamp = get_jiffies_64();
 
-        old_cpu_power = thm_readl(THM_CEC) / 65535;
+        old_cpu_power = thm_readl(THM_CEC);
         schedule_timeout_interruptible(msecs_to_jiffies(IPS_SAMPLE_PERIOD));
 
         /* Collect an initial average */
@@ -1150,11 +1193,18 @@ static irqreturn_t ips_irq_handler(int irq, void *arg)
                                 STS_GPL_SHIFT;
                         /* ignore EC CPU vs GPU pref */
                         ips->cpu_turbo_enabled = !(sts & STS_PCTD_DIS);
-                        ips->gpu_turbo_enabled = !(sts & STS_GTD_DIS);
+                        /* 
+                         * Disable turbo for now, until we can figure
+                         * out why the power figures are wrong
+                         */
+                        ips->cpu_turbo_enabled = false;
+                        if (ips->gpu_busy)
+                                ips->gpu_turbo_enabled = !(sts & STS_GTD_DIS);
                         ips->mcp_temp_limit = (sts & STS_PTL_MASK) >>
                                 STS_PTL_SHIFT;
                         ips->mcp_power_limit = (tc1 & STS_PPL_MASK) >>
                                 STS_PPL_SHIFT;
+                        verify_limits(ips);
                         spin_unlock(&ips->turbo_status_lock);
 
                         thm_writeb(THM_SEC, SEC_ACK);
@@ -1333,8 +1383,10 @@ static struct ips_mcp_limits *ips_detect_cpu(struct ips_driver *ips)
          * turbo manually or we'll get an illegal MSR access, even though
          * turbo will still be available.
          */
-        if (!(misc_en & IA32_MISC_TURBO_EN))
-                ; /* add turbo MSR write allowed flag if necessary */
+        if (misc_en & IA32_MISC_TURBO_EN)
+                ips->turbo_toggle_allowed = true;
+        else
+                ips->turbo_toggle_allowed = false;
 
         if (strstr(boot_cpu_data.x86_model_id, "CPU       M"))
                 limits = &ips_sv_limits;
@@ -1351,9 +1403,10 @@ static struct ips_mcp_limits *ips_detect_cpu(struct ips_driver *ips)
         tdp = turbo_power & TURBO_TDP_MASK;
 
         /* Sanity check TDP against CPU */
-        if (limits->mcp_power_limit != (tdp / 8) * 1000) {
-                dev_warn(&ips->dev->dev, "Warning: CPU TDP doesn't match expected value (found %d, expected %d)\n",
-                         tdp / 8, limits->mcp_power_limit / 1000);
+        if (limits->core_power_limit != (tdp / 8) * 1000) {
+                dev_info(&ips->dev->dev, "CPU TDP doesn't match expected value (found %d, expected %d)\n",
+                         tdp / 8, limits->core_power_limit / 1000);
+                limits->core_power_limit = (tdp / 8) * 1000;
         }
 
 out:
@@ -1390,7 +1443,7 @@ static bool ips_get_i915_syms(struct ips_driver *ips)
         return true;
 
 out_put_busy:
-        symbol_put(i915_gpu_turbo_disable);
+        symbol_put(i915_gpu_busy);
 out_put_lower:
         symbol_put(i915_gpu_lower);
 out_put_raise:
@@ -1532,22 +1585,27 @@ static int ips_probe(struct pci_dev *dev, const struct pci_device_id *id)
         /* Save turbo limits & ratios */
         rdmsrl(TURBO_POWER_CURRENT_LIMIT, ips->orig_turbo_limit);
 
-        ips_enable_cpu_turbo(ips);
-        ips->cpu_turbo_enabled = true;
+        ips_disable_cpu_turbo(ips);
+        ips->cpu_turbo_enabled = false;
 
-        /* Set up the work queue and monitor/adjust threads */
-        ips->monitor = kthread_run(ips_monitor, ips, "ips-monitor");
-        if (IS_ERR(ips->monitor)) {
+        /* Create thermal adjust thread */
+        ips->adjust = kthread_create(ips_adjust, ips, "ips-adjust");
+        if (IS_ERR(ips->adjust)) {
                 dev_err(&dev->dev,
-                        "failed to create thermal monitor thread, aborting\n");
+                        "failed to create thermal adjust thread, aborting\n");
                 ret = -ENOMEM;
                 goto error_free_irq;
+
         }
 
-        ips->adjust = kthread_create(ips_adjust, ips, "ips-adjust");
-        if (IS_ERR(ips->adjust)) {
+        /*
+         * Set up the work queue and monitor thread. The monitor thread
+         * will wake up ips_adjust thread.
+         */
+        ips->monitor = kthread_run(ips_monitor, ips, "ips-monitor");
+        if (IS_ERR(ips->monitor)) {
                 dev_err(&dev->dev,
-                        "failed to create thermal adjust thread, aborting\n");
+                        "failed to create thermal monitor thread, aborting\n");
                 ret = -ENOMEM;
                 goto error_thread_cleanup;
         }
@@ -1566,7 +1624,7 @@ static int ips_probe(struct pci_dev *dev, const struct pci_device_id *id)
         return ret;
 
 error_thread_cleanup:
-        kthread_stop(ips->monitor);
+        kthread_stop(ips->adjust);
 error_free_irq:
         free_irq(ips->dev->irq, ips);
 error_unmap:
diff --git a/drivers/s390/char/sclp.c b/drivers/s390/char/sclp.c
index f6d72e1f2a38..5707a80b96b6 100644
--- a/drivers/s390/char/sclp.c
+++ b/drivers/s390/char/sclp.c
@@ -468,7 +468,7 @@ sclp_sync_wait(void)
         cr0_sync &= 0xffff00a0;
         cr0_sync |= 0x00000200;
         __ctl_load(cr0_sync, 0, 0);
-        __raw_local_irq_stosm(0x01);
+        __arch_local_irq_stosm(0x01);
         /* Loop until driver state indicates finished request */
         while (sclp_running_state != sclp_running_state_idle) {
                 /* Check for expired request timer */
diff --git a/drivers/scsi/pcmcia/aha152x_stub.c b/drivers/scsi/pcmcia/aha152x_stub.c
index 61f49bdcc0c2..e77dd02eccdd 100644
--- a/drivers/scsi/pcmcia/aha152x_stub.c
+++ b/drivers/scsi/pcmcia/aha152x_stub.c
@@ -49,7 +49,6 @@
 #include <scsi/scsi_host.h>
 #include "aha152x.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -86,8 +85,6 @@ static void aha152x_release_cs(struct pcmcia_device *link);
 static void aha152x_detach(struct pcmcia_device *p_dev);
 static int aha152x_config_cs(struct pcmcia_device *link);
 
-static struct pcmcia_device *dev_list;
-
 static int aha152x_probe(struct pcmcia_device *link)
 {
     scsi_info_t *info;
@@ -100,11 +97,8 @@ static int aha152x_probe(struct pcmcia_device *link)
     info->p_dev = link;
     link->priv = info;
 
-    link->resource[0]->end = 0x20;
-    link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-    link->conf.Attributes = CONF_ENABLE_IRQ;
-    link->conf.IntType = INT_MEMORY_AND_IO;
-    link->conf.Present = PRESENT_OPTION;
+    link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+    link->config_regs = PRESENT_OPTION;
 
     return aha152x_config_cs(link);
 } /* aha152x_attach */
@@ -123,25 +117,24 @@ static void aha152x_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-static int aha152x_config_check(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int aha152x_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         p_dev->io_lines = 10;
+
         /* For New Media T&J, look for a SCSI window */
-        if (cfg->io.win[0].len >= 0x20)
-                p_dev->resource[0]->start = cfg->io.win[0].base;
-        else if ((cfg->io.nwin > 1) &&
-                 (cfg->io.win[1].len >= 0x20))
-                p_dev->resource[0]->start = cfg->io.win[1].base;
-        if ((cfg->io.nwin > 0) &&
-            (p_dev->resource[0]->start < 0xffff)) {
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -EINVAL;
+        if ((p_dev->resource[0]->end < 0x20) &&
+                (p_dev->resource[1]->end >= 0x20))
+                p_dev->resource[0]->start = p_dev->resource[1]->start;
+
+        if (p_dev->resource[0]->start >= 0xffff)
+                return -EINVAL;
+
+        p_dev->resource[1]->start = p_dev->resource[1]->end = 0;
+        p_dev->resource[0]->end = 0x20;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int aha152x_config_cs(struct pcmcia_device *link)
@@ -160,7 +153,7 @@ static int aha152x_config_cs(struct pcmcia_device *link)
     if (!link->irq)
             goto failed;
 
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
     
@@ -221,9 +214,7 @@ MODULE_DEVICE_TABLE(pcmcia, aha152x_ids);
 
 static struct pcmcia_driver aha152x_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "aha152x_cs",
-        },
+        .name           = "aha152x_cs",
         .probe          = aha152x_probe,
         .remove         = aha152x_detach,
         .id_table       = aha152x_ids,
@@ -238,7 +229,6 @@ static int __init init_aha152x_cs(void)
 static void __exit exit_aha152x_cs(void)
 {
         pcmcia_unregister_driver(&aha152x_cs_driver);
-        BUG_ON(dev_list != NULL);
 }
 
 module_init(init_aha152x_cs);
diff --git a/drivers/scsi/pcmcia/fdomain_stub.c b/drivers/scsi/pcmcia/fdomain_stub.c
index 13dbe5c48492..cd69c2670f81 100644
--- a/drivers/scsi/pcmcia/fdomain_stub.c
+++ b/drivers/scsi/pcmcia/fdomain_stub.c
@@ -46,7 +46,6 @@
 #include <scsi/scsi_host.h>
 #include "fdomain.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -83,11 +82,8 @@ static int fdomain_probe(struct pcmcia_device *link)
 
         info->p_dev = link;
         link->priv = info;
-        link->resource[0]->end = 0x10;
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-        link->conf.Present = PRESENT_OPTION;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+        link->config_regs = PRESENT_OPTION;
 
         return fdomain_config(link);
 } /* fdomain_attach */
@@ -105,14 +101,12 @@ static void fdomain_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-static int fdomain_config_check(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int fdomain_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         p_dev->io_lines = 10;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
+        p_dev->resource[0]->end = 0x10;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
         return pcmcia_request_io(p_dev);
 }
 
@@ -132,7 +126,7 @@ static int fdomain_config(struct pcmcia_device *link)
 
     if (!link->irq)
             goto failed;
-    ret = pcmcia_request_configuration(link, &link->conf);
+    ret = pcmcia_enable_device(link);
     if (ret)
             goto failed;
 
@@ -194,9 +188,7 @@ MODULE_DEVICE_TABLE(pcmcia, fdomain_ids);
 
 static struct pcmcia_driver fdomain_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "fdomain_cs",
-        },
+        .name           = "fdomain_cs",
         .probe          = fdomain_probe,
         .remove         = fdomain_detach,
         .id_table       = fdomain_ids,
diff --git a/drivers/scsi/pcmcia/nsp_cs.c b/drivers/scsi/pcmcia/nsp_cs.c
index dd9b40306f3d..9326c2c14880 100644
--- a/drivers/scsi/pcmcia/nsp_cs.c
+++ b/drivers/scsi/pcmcia/nsp_cs.c
@@ -47,7 +47,6 @@
 #include <scsi/scsi.h>
 #include <scsi/scsi_ioctl.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -1531,15 +1530,6 @@ static int nsp_eh_host_reset(struct scsi_cmnd *SCpnt)
   PCMCIA functions
 **********************************************************************/
 
-/*======================================================================
-    nsp_cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-======================================================================*/
 static int nsp_cs_probe(struct pcmcia_device *link)
 {
         scsi_info_t  *info;
@@ -1557,14 +1547,6 @@ static int nsp_cs_probe(struct pcmcia_device *link)
 
         nsp_dbg(NSP_DEBUG_INIT, "info=0x%p", info);
 
-        /* The io structure describes IO port mapping */
-        link->resource[0]->end   = 0x10;
-        link->resource[0]->flags = IO_DATA_PATH_WIDTH_AUTO;
-
-        /* General socket configuration */
-        link->conf.Attributes    = CONF_ENABLE_IRQ;
-        link->conf.IntType       = INT_MEMORY_AND_IO;
-
         ret = nsp_cs_config(link);
 
         nsp_dbg(NSP_DEBUG_INIT, "link=0x%p", link);
@@ -1572,12 +1554,6 @@ static int nsp_cs_probe(struct pcmcia_device *link)
 } /* nsp_cs_attach */
 
 
-/*======================================================================
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-======================================================================*/
 static void nsp_cs_detach(struct pcmcia_device *link)
 {
         nsp_dbg(NSP_DEBUG_INIT, "in, link=0x%p", link);
@@ -1590,98 +1566,36 @@ static void nsp_cs_detach(struct pcmcia_device *link)
 } /* nsp_cs_detach */
 
 
-/*======================================================================
-    nsp_cs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    ethernet device available to the system.
-======================================================================*/
-
-struct nsp_cs_configdata {
-        nsp_hw_data             *data;
-        win_req_t               req;
-};
-
-static int nsp_cs_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cfg,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int nsp_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        struct nsp_cs_configdata *cfg_mem = priv_data;
+        nsp_hw_data             *data = priv_data;
 
-        if (cfg->index == 0)
+        if (p_dev->config_index == 0)
                 return -ENODEV;
 
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (vcc != cfg->vcc.param[CISTPL_POWER_VNOM]/10000)
-                        return -ENODEV;
-                else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                        if (vcc != dflt->vcc.param[CISTPL_POWER_VNOM]/10000)
-                                return -ENODEV;
-                }
-
-                if (cfg->vpp1.present & (1 << CISTPL_POWER_VNOM)) {
-                        p_dev->conf.Vpp =
-                                cfg->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-                } else if (dflt->vpp1.present & (1 << CISTPL_POWER_VNOM)) {
-                        p_dev->conf.Vpp =
-                                dflt->vpp1.param[CISTPL_POWER_VNOM] / 10000;
-                }
-
-                /* Do we need to allocate an interrupt? */
-                p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-                /* IO window settings */
-                p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-                if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                        cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                        p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                        p_dev->resource[0]->flags |=
-                                pcmcia_io_cfg_data_width(io->flags);
-                        p_dev->resource[0]->start = io->win[0].base;
-                        p_dev->resource[0]->end = io->win[0].len;
-                        if (io->nwin > 1) {
-                                p_dev->resource[1]->flags =
-                                        p_dev->resource[0]->flags;
-                                p_dev->resource[1]->start = io->win[1].base;
-                                p_dev->resource[1]->end = io->win[1].len;
-                        }
-                        /* This reserves IO space but doesn't actually enable it */
-                        if (pcmcia_request_io(p_dev) != 0)
-                                goto next_entry;
-                }
-
-                if ((cfg->mem.nwin > 0) || (dflt->mem.nwin > 0)) {
-                        cistpl_mem_t    *mem =
-                                (cfg->mem.nwin) ? &cfg->mem : &dflt->mem;
-                        cfg_mem->req.Attributes = WIN_DATA_WIDTH_16|WIN_MEMORY_TYPE_CM;
-                        cfg_mem->req.Attributes |= WIN_ENABLE;
-                        cfg_mem->req.Base = mem->win[0].host_addr;
-                        cfg_mem->req.Size = mem->win[0].len;
-                        if (cfg_mem->req.Size < 0x1000)
-                                cfg_mem->req.Size = 0x1000;
-                        cfg_mem->req.AccessSpeed = 0;
-                        if (pcmcia_request_window(p_dev, &cfg_mem->req, &p_dev->win) != 0)
-                                goto next_entry;
-                        if (pcmcia_map_mem_page(p_dev, p_dev->win,
-                                        mem->win[0].card_addr) != 0)
-                                goto next_entry;
-
-                        cfg_mem->data->MmioAddress = (unsigned long) ioremap_nocache(cfg_mem->req.Base, cfg_mem->req.Size);
-                        cfg_mem->data->MmioLength  = cfg_mem->req.Size;
-                }
-                /* If we got this far, we're cool! */
-                return 0;
+        /* This reserves IO space but doesn't actually enable it */
+        if (pcmcia_request_io(p_dev) != 0)
+                goto next_entry;
+
+        if (resource_size(p_dev->resource[2])) {
+                p_dev->resource[2]->flags |= (WIN_DATA_WIDTH_16 |
+                                        WIN_MEMORY_TYPE_CM |
+                                        WIN_ENABLE);
+                if (p_dev->resource[2]->end < 0x1000)
+                        p_dev->resource[2]->end = 0x1000;
+                if (pcmcia_request_window(p_dev, p_dev->resource[2], 0) != 0)
+                        goto next_entry;
+                if (pcmcia_map_mem_page(p_dev, p_dev->resource[2],
+                                                p_dev->card_addr) != 0)
+                        goto next_entry;
+
+                data->MmioAddress = (unsigned long)
+                        ioremap_nocache(p_dev->resource[2]->start,
+                                        resource_size(p_dev->resource[2]));
+                data->MmioLength  = resource_size(p_dev->resource[2]);
         }
+        /* If we got this far, we're cool! */
+        return 0;
 
 next_entry:
         nsp_dbg(NSP_DEBUG_INIT, "next");
@@ -1693,25 +1607,23 @@ static int nsp_cs_config(struct pcmcia_device *link)
 {
         int               ret;
         scsi_info_t      *info   = link->priv;
-        struct nsp_cs_configdata *cfg_mem;
         struct Scsi_Host *host;
         nsp_hw_data      *data = &nsp_data_base;
 
         nsp_dbg(NSP_DEBUG_INIT, "in");
 
-        cfg_mem = kzalloc(sizeof(*cfg_mem), GFP_KERNEL);
-        if (!cfg_mem)
-                return -ENOMEM;
-        cfg_mem->data = data;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_CHECK_VCC |
+                CONF_AUTO_SET_VPP | CONF_AUTO_AUDIO | CONF_AUTO_SET_IOMEM |
+                CONF_AUTO_SET_IO;
 
-        ret = pcmcia_loop_config(link, nsp_cs_config_check, cfg_mem);
+        ret = pcmcia_loop_config(link, nsp_cs_config_check, data);
         if (ret)
                 goto cs_failed;
 
         if (pcmcia_request_irq(link, nspintr))
                 goto cs_failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto cs_failed;
 
@@ -1754,41 +1666,16 @@ static int nsp_cs_config(struct pcmcia_device *link)
 
         info->host = host;
 
-        /* Finally, report what we've done */
-        printk(KERN_INFO "nsp_cs: index 0x%02x: ",
-               link->conf.ConfigIndex);
-        if (link->conf.Vpp) {
-                printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
-        }
-        if (link->conf.Attributes & CONF_ENABLE_IRQ) {
-                printk(", irq %d", link->irq);
-        }
-        if (link->resource[0])
-                printk(", io %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        if (link->win)
-                printk(", mem 0x%06lx-0x%06lx", cfg_mem->req.Base,
-                       cfg_mem->req.Base+cfg_mem->req.Size-1);
-        printk("\n");
-
-        kfree(cfg_mem);
         return 0;
 
  cs_failed:
         nsp_dbg(NSP_DEBUG_INIT, "config fail");
         nsp_cs_release(link);
-        kfree(cfg_mem);
 
         return -ENODEV;
 } /* nsp_cs_config */
 
 
-/*======================================================================
-    After a card is removed, nsp_cs_release() will unregister the net
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-======================================================================*/
 static void nsp_cs_release(struct pcmcia_device *link)
 {
         scsi_info_t *info = link->priv;
@@ -1807,7 +1694,7 @@ static void nsp_cs_release(struct pcmcia_device *link)
                 scsi_remove_host(info->host);
         }
 
-        if (link->win) {
+        if (resource_size(link->resource[2])) {
                 if (data != NULL) {
                         iounmap((void *)(data->MmioAddress));
                 }
@@ -1877,9 +1764,7 @@ MODULE_DEVICE_TABLE(pcmcia, nsp_cs_ids);
 
 static struct pcmcia_driver nsp_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "nsp_cs",
-        },
+        .name           = "nsp_cs",
         .probe          = nsp_cs_probe,
         .remove         = nsp_cs_detach,
         .id_table       = nsp_cs_ids,
@@ -1889,14 +1774,11 @@ static struct pcmcia_driver nsp_driver = {
 
 static int __init nsp_cs_init(void)
 {
-        nsp_msg(KERN_INFO, "loading...");
-
         return pcmcia_register_driver(&nsp_driver);
 }
 
 static void __exit nsp_cs_exit(void)
 {
-        nsp_msg(KERN_INFO, "unloading...");
         pcmcia_unregister_driver(&nsp_driver);
 }
 
diff --git a/drivers/scsi/pcmcia/qlogic_stub.c b/drivers/scsi/pcmcia/qlogic_stub.c
index eb775f1a523c..9c96ca889ec9 100644
--- a/drivers/scsi/pcmcia/qlogic_stub.c
+++ b/drivers/scsi/pcmcia/qlogic_stub.c
@@ -48,7 +48,6 @@
 #include <scsi/scsi_host.h>
 #include "../qlogicfas408.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/ciscode.h>
@@ -156,11 +155,8 @@ static int qlogic_probe(struct pcmcia_device *link)
                 return -ENOMEM;
         info->p_dev = link;
         link->priv = info;
-        link->resource[0]->end = 16;
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-        link->conf.Present = PRESENT_OPTION;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+        link->config_regs = PRESENT_OPTION;
 
         return qlogic_config(link);
 }                               /* qlogic_attach */
@@ -178,15 +174,11 @@ static void qlogic_detach(struct pcmcia_device *link)
 
 /*====================================================================*/
 
-static int qlogic_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cfg,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int qlogic_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         p_dev->io_lines = 10;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
         if (p_dev->resource[0]->start == 0)
                 return -ENODEV;
@@ -209,7 +201,7 @@ static int qlogic_config(struct pcmcia_device * link)
         if (!link->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -264,7 +256,7 @@ static int qlogic_resume(struct pcmcia_device *link)
 {
         scsi_info_t *info = link->priv;
 
-        pcmcia_request_configuration(link, &link->conf);
+        pcmcia_enable_device(link);
         if ((info->manf_id == MANFID_MACNICA) ||
             (info->manf_id == MANFID_PIONEER) ||
             (info->manf_id == 0x0098)) {
@@ -302,9 +294,7 @@ MODULE_DEVICE_TABLE(pcmcia, qlogic_ids);
 
 static struct pcmcia_driver qlogic_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
         .name           = "qlogic_cs",
-        },
         .probe          = qlogic_probe,
         .remove         = qlogic_detach,
         .id_table       = qlogic_ids,
diff --git a/drivers/scsi/pcmcia/sym53c500_cs.c b/drivers/scsi/pcmcia/sym53c500_cs.c
index 321e390c9120..0ae27cb5cd6f 100644
--- a/drivers/scsi/pcmcia/sym53c500_cs.c
+++ b/drivers/scsi/pcmcia/sym53c500_cs.c
@@ -71,7 +71,6 @@
 #include <scsi/scsi.h>
 #include <scsi/scsi_host.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 #include <pcmcia/ciscode.h>
@@ -684,15 +683,11 @@ static struct scsi_host_template sym53c500_driver_template = {
      .shost_attrs               = SYM53C500_shost_attrs
 };
 
-static int SYM53C500_config_check(struct pcmcia_device *p_dev,
-                                  cistpl_cftable_entry_t *cfg,
-                                  cistpl_cftable_entry_t *dflt,
-                                  unsigned int vcc,
-                                  void *priv_data)
+static int SYM53C500_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         p_dev->io_lines = 10;
-        p_dev->resource[0]->start = cfg->io.win[0].base;
-        p_dev->resource[0]->end = cfg->io.win[0].len;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
 
         if (p_dev->resource[0]->start == 0)
                 return -ENODEV;
@@ -721,7 +716,7 @@ SYM53C500_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
@@ -859,10 +854,7 @@ SYM53C500_probe(struct pcmcia_device *link)
                 return -ENOMEM;
         info->p_dev = link;
         link->priv = info;
-        link->resource[0]->end = 16;
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_AUTO;
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
         return SYM53C500_config(link);
 } /* SYM53C500_attach */
@@ -881,9 +873,7 @@ MODULE_DEVICE_TABLE(pcmcia, sym53c500_ids);
 
 static struct pcmcia_driver sym53c500_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "sym53c500_cs",
-        },
+        .name           = "sym53c500_cs",
         .probe          = SYM53C500_probe,
         .remove         = SYM53C500_detach,
         .id_table       = sym53c500_ids,
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index ad0ed212db4a..348fba0a8976 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -1046,13 +1046,13 @@ int scsi_get_vpd_page(struct scsi_device *sdev, u8 page, unsigned char *buf,
 
         /* If the user actually wanted this page, we can skip the rest */
         if (page == 0)
-                return -EINVAL;
+                return 0;
 
         for (i = 0; i < min((int)buf[3], buf_len - 4); i++)
                 if (buf[i + 4] == page)
                         goto found;
 
-        if (i < buf[3] && i > buf_len)
+        if (i < buf[3] && i >= buf_len - 4)
                 /* ran off the end of the buffer, give us benefit of doubt */
                 goto found;
         /* The device claims it doesn't support the requested page */
diff --git a/drivers/serial/Kconfig b/drivers/serial/Kconfig
index 12900f7083b0..3198c5335f0b 100644
--- a/drivers/serial/Kconfig
+++ b/drivers/serial/Kconfig
@@ -458,6 +458,7 @@ config SERIAL_SAMSUNG_UARTS
         int
         depends on ARM && PLAT_SAMSUNG
         default 2 if ARCH_S3C2400
+        default 6 if ARCH_S5P6450
         default 4 if SERIAL_SAMSUNG_UARTS_4
         default 3
         help
@@ -526,12 +527,12 @@ config SERIAL_S3C24A0
           Serial port support for the Samsung S3C24A0 SoC
 
 config SERIAL_S3C6400
-        tristate "Samsung S3C6400/S3C6410/S5P6440/S5PC100 Serial port support"
-        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410 || CPU_S5P6440 || CPU_S5PC100)
+        tristate "Samsung S3C6400/S3C6410/S5P6440/S5P6450/S5PC100 Serial port support"
+        depends on SERIAL_SAMSUNG && (CPU_S3C6400 || CPU_S3C6410 || CPU_S5P6440 || CPU_S5P6450 || CPU_S5PC100)
         select SERIAL_SAMSUNG_UARTS_4
         default y
         help
-          Serial port support for the Samsung S3C6400, S3C6410, S5P6440
+          Serial port support for the Samsung S3C6400, S3C6410, S5P6440, S5P6450
           and S5PC100 SoCs
 
 config SERIAL_S5PV210
diff --git a/drivers/serial/ioc3_serial.c b/drivers/serial/ioc3_serial.c
index 93de907b1208..ee43efc7bdcc 100644
--- a/drivers/serial/ioc3_serial.c
+++ b/drivers/serial/ioc3_serial.c
@@ -2017,6 +2017,7 @@ ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
         struct ioc3_port *port;
         struct ioc3_port *ports[PORTS_PER_CARD];
         int phys_port;
+        int cnt;
 
         DPRINT_CONFIG(("%s (0x%p, 0x%p)\n", __func__, is, idd));
 
@@ -2044,6 +2045,7 @@ ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
                 if (!port) {
                         printk(KERN_WARNING
                                "IOC3 serial memory not available for port\n");
+                        ret = -ENOMEM;
                         goto out4;
                 }
                 spin_lock_init(&port->ip_lock);
@@ -2146,6 +2148,9 @@ ioc3uart_probe(struct ioc3_submodule *is, struct ioc3_driver_data *idd)
 
         /* error exits that give back resources */
 out4:
+        for (cnt = 0; cnt < phys_port; cnt++)
+                kfree(ports[cnt]);
+
         kfree(card_ptr);
         return ret;
 }
diff --git a/drivers/serial/samsung.c b/drivers/serial/samsung.c
index b1156ba8ad14..7ac2bf5167cd 100644
--- a/drivers/serial/samsung.c
+++ b/drivers/serial/samsung.c
@@ -1101,7 +1101,7 @@ static int s3c24xx_serial_init_port(struct s3c24xx_uart_port *ourport,
         dbg("resource %p (%lx..%lx)\n", res, res->start, res->end);
 
         port->mapbase = res->start;
-        port->membase = S3C_VA_UART + res->start - (S3C_PA_UART & 0xfff00000);
+        port->membase = S3C_VA_UART + (res->start & 0xfffff);
         ret = platform_get_irq(platdev, 0);
         if (ret < 0)
                 port->irq = 0;
diff --git a/drivers/serial/serial_cs.c b/drivers/serial/serial_cs.c
index 7d475b2a79e8..93760b2ea172 100644
--- a/drivers/serial/serial_cs.c
+++ b/drivers/serial/serial_cs.c
@@ -45,7 +45,6 @@
 #include <asm/io.h>
 #include <asm/system.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
@@ -183,10 +182,8 @@ static void quirk_config_socket(struct pcmcia_device *link)
 {
         struct serial_info *info = link->priv;
 
-        if (info->multi) {
-                link->conf.Present |= PRESENT_EXT_STATUS;
-                link->conf.ExtStatus = ESR_REQ_ATTN_ENA;
-        }
+        if (info->multi)
+                link->config_flags |= CONF_ENABLE_ESR;
 }
 
 static const struct serial_quirk quirks[] = {
@@ -265,13 +262,6 @@ static const struct serial_quirk quirks[] = {
 static int serial_config(struct pcmcia_device * link);
 
 
-/*======================================================================
-
-    After a card is removed, serial_remove() will unregister
-    the serial device(s), and release the PCMCIA configuration.
-    
-======================================================================*/
-
 static void serial_remove(struct pcmcia_device *link)
 {
         struct serial_info *info = link->priv;
@@ -314,14 +304,6 @@ static int serial_resume(struct pcmcia_device *link)
         return 0;
 }
 
-/*======================================================================
-
-    serial_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-======================================================================*/
-
 static int serial_probe(struct pcmcia_device *link)
 {
         struct serial_info *info;
@@ -335,25 +317,13 @@ static int serial_probe(struct pcmcia_device *link)
         info->p_dev = link;
         link->priv = info;
 
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        if (do_sound) {
-                link->conf.Attributes |= CONF_ENABLE_SPKR;
-                link->conf.Status = CCSR_AUDIO_ENA;
-        }
-        link->conf.IntType = INT_MEMORY_AND_IO;
+        link->config_flags |= CONF_ENABLE_IRQ;
+        if (do_sound)
+                link->config_flags |= CONF_ENABLE_SPKR;
 
         return serial_config(link);
 }
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void serial_detach(struct pcmcia_device *link)
 {
         struct serial_info *info = link->priv;
@@ -361,11 +331,6 @@ static void serial_detach(struct pcmcia_device *link)
         dev_dbg(&link->dev, "serial_detach\n");
 
         /*
-         * Ensure any outstanding scheduled tasks are completed.
-         */
-        flush_scheduled_work();
-
-        /*
          * Ensure that the ports have been released.
          */
         serial_remove(link);
@@ -430,47 +395,45 @@ static int pfc_config(struct pcmcia_device *p_dev)
         return -ENODEV;
 }
 
-static int simple_config_check(struct pcmcia_device *p_dev,
-                               cistpl_cftable_entry_t *cf,
-                               cistpl_cftable_entry_t *dflt,
-                               unsigned int vcc,
-                               void *priv_data)
+static int simple_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
         static const int size_table[2] = { 8, 16 };
         int *try = priv_data;
 
-        if (cf->vpp1.present & (1 << CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        cf->vpp1.param[CISTPL_POWER_VNOM] / 10000;
+        if (p_dev->resource[0]->start == 0)
+                return -ENODEV;
 
-        p_dev->io_lines = ((*try & 0x1) == 0) ?
-                        16 : cf->io.flags & CISTPL_IO_LINES_MASK;
+        if ((*try & 0x1) == 0)
+                p_dev->io_lines = 16;
 
-        if ((cf->io.nwin > 0) && (cf->io.win[0].len == size_table[(*try >> 1)])
-            && (cf->io.win[0].base != 0)) {
-                p_dev->resource[0]->start = cf->io.win[0].base;
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -EINVAL;
+        if (p_dev->resource[0]->end != size_table[(*try >> 1)])
+                return -ENODEV;
+
+        p_dev->resource[0]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int simple_config_check_notpicky(struct pcmcia_device *p_dev,
-                                        cistpl_cftable_entry_t *cf,
-                                        cistpl_cftable_entry_t *dflt,
-                                        unsigned int vcc,
                                         void *priv_data)
 {
         static const unsigned int base[5] = { 0x3f8, 0x2f8, 0x3e8, 0x2e8, 0x0 };
         int j;
 
-        if ((cf->io.nwin > 0) && ((cf->io.flags & CISTPL_IO_LINES_MASK) <= 3)) {
-                for (j = 0; j < 5; j++) {
-                        p_dev->resource[0]->start = base[j];
-                        p_dev->io_lines = base[j] ? 16 : 3;
-                        if (!pcmcia_request_io(p_dev))
-                                return 0;
-                }
+        if (p_dev->io_lines > 3)
+                return -ENODEV;
+
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[0]->end = 8;
+
+        for (j = 0; j < 5; j++) {
+                p_dev->resource[0]->start = base[j];
+                p_dev->io_lines = base[j] ? 16 : 3;
+                if (!pcmcia_request_io(p_dev))
+                        return 0;
         }
         return -ENODEV;
 }
@@ -480,11 +443,9 @@ static int simple_config(struct pcmcia_device *link)
         struct serial_info *info = link->priv;
         int i = -ENODEV, try;
 
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        link->resource[0]->end = 8;
-
         /* First pass: look for a config entry that looks normal.
          * Two tries: without IO aliases, then with aliases */
+        link->config_flags |= CONF_AUTO_SET_VPP | CONF_AUTO_SET_IO;
         for (try = 0; try < 4; try++)
                 if (!pcmcia_loop_config(link, simple_config_check, &try))
                         goto found_port;
@@ -500,7 +461,7 @@ static int simple_config(struct pcmcia_device *link)
 
 found_port:
         if (info->multi && (info->manfid == MANFID_3COM))
-                link->conf.ConfigIndex &= ~(0x08);
+                link->config_index &= ~(0x08);
 
         /*
          * Apply any configuration quirks.
@@ -508,51 +469,50 @@ found_port:
         if (info->quirk && info->quirk->config)
                 info->quirk->config(link);
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 return -1;
         return setup_serial(link, info, link->resource[0]->start, link->irq);
 }
 
-static int multi_config_check(struct pcmcia_device *p_dev,
-                              cistpl_cftable_entry_t *cf,
-                              cistpl_cftable_entry_t *dflt,
-                              unsigned int vcc,
-                              void *priv_data)
+static int multi_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        int *base2 = priv_data;
+        int *multi = priv_data;
+
+        if (p_dev->resource[1]->end)
+                return -EINVAL;
 
         /* The quad port cards have bad CIS's, so just look for a
            window larger than 8 ports and assume it will be right */
-        if ((cf->io.nwin == 1) && (cf->io.win[0].len > 8)) {
-                p_dev->resource[0]->start = cf->io.win[0].base;
-                p_dev->io_lines = cf->io.flags & CISTPL_IO_LINES_MASK;
-                if (!pcmcia_request_io(p_dev)) {
-                        *base2 = p_dev->resource[0]->start + 8;
-                        return 0;
-                }
-        }
-        return -ENODEV;
+        if (p_dev->resource[0]->end <= 8)
+                return -EINVAL;
+
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[0]->end = *multi * 8;
+
+        if (pcmcia_request_io(p_dev))
+                return -ENODEV;
+        return 0;
 }
 
 static int multi_config_check_notpicky(struct pcmcia_device *p_dev,
-                                       cistpl_cftable_entry_t *cf,
-                                       cistpl_cftable_entry_t *dflt,
-                                       unsigned int vcc,
                                        void *priv_data)
 {
         int *base2 = priv_data;
 
-        if (cf->io.nwin == 2) {
-                p_dev->resource[0]->start = cf->io.win[0].base;
-                p_dev->resource[1]->start = cf->io.win[1].base;
-                p_dev->io_lines = cf->io.flags & CISTPL_IO_LINES_MASK;
-                if (!pcmcia_request_io(p_dev)) {
-                        *base2 = p_dev->resource[1]->start;
-                        return 0;
-                }
-        }
-        return -ENODEV;
+        if (!p_dev->resource[0]->end || !p_dev->resource[1]->end)
+                return -ENODEV;
+
+        p_dev->resource[0]->end = p_dev->resource[1]->end = 8;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+
+        if (pcmcia_request_io(p_dev))
+                return -ENODEV;
+
+        *base2 = p_dev->resource[0]->start + 8;
+        return 0;
 }
 
 static int multi_config(struct pcmcia_device *link)
@@ -560,12 +520,12 @@ static int multi_config(struct pcmcia_device *link)
         struct serial_info *info = link->priv;
         int i, base2 = 0;
 
+        link->config_flags |= CONF_AUTO_SET_IO;
         /* First, look for a generic full-sized window */
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        link->resource[0]->end = info->multi * 8;
-        if (pcmcia_loop_config(link, multi_config_check, &base2)) {
+        if (!pcmcia_loop_config(link, multi_config_check, &info->multi))
+                base2 = link->resource[0]->start + 8;
+        else {
                 /* If that didn't work, look for two windows */
-                link->resource[0]->end = link->resource[1]->end = 8;
                 info->multi = 2;
                 if (pcmcia_loop_config(link, multi_config_check_notpicky,
                                        &base2)) {
@@ -584,7 +544,7 @@ static int multi_config(struct pcmcia_device *link)
         if (info->quirk && info->quirk->config)
                 info->quirk->config(link);
 
-        i = pcmcia_request_configuration(link, &link->conf);
+        i = pcmcia_enable_device(link);
         if (i != 0)
                 return -ENODEV;
 
@@ -596,11 +556,11 @@ static int multi_config(struct pcmcia_device *link)
                                 info->prodid == PRODID_POSSIO_GCC)) {
                 int err;
 
-                if (link->conf.ConfigIndex == 1 ||
-                    link->conf.ConfigIndex == 3) {
+                if (link->config_index == 1 ||
+                    link->config_index == 3) {
                         err = setup_serial(link, info, base2,
                                         link->irq);
-                        base2 = link->resource[0]->start;;
+                        base2 = link->resource[0]->start;
                 } else {
                         err = setup_serial(link, info, link->resource[0]->start,
                                         link->irq);
@@ -624,33 +584,24 @@ static int multi_config(struct pcmcia_device *link)
         return 0;
 }
 
-static int serial_check_for_multi(struct pcmcia_device *p_dev,
-                                  cistpl_cftable_entry_t *cf,
-                                  cistpl_cftable_entry_t *dflt,
-                                  unsigned int vcc,
-                                  void *priv_data)
+static int serial_check_for_multi(struct pcmcia_device *p_dev,  void *priv_data)
 {
         struct serial_info *info = p_dev->priv;
 
-        if ((cf->io.nwin == 1) && (cf->io.win[0].len % 8 == 0))
-                info->multi = cf->io.win[0].len >> 3;
+        if (!p_dev->resource[0]->end)
+                return -EINVAL;
+
+        if ((!p_dev->resource[1]->end) && (p_dev->resource[0]->end % 8 == 0))
+                info->multi = p_dev->resource[0]->end >> 3;
 
-        if ((cf->io.nwin == 2) && (cf->io.win[0].len == 8) &&
-                (cf->io.win[1].len == 8))
+        if ((p_dev->resource[1]->end) && (p_dev->resource[0]->end == 8)
+                && (p_dev->resource[1]->end == 8))
                 info->multi = 2;
 
         return 0; /* break */
 }
 
 
-/*======================================================================
-
-    serial_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    serial device available to the system.
-
-======================================================================*/
-
 static int serial_config(struct pcmcia_device * link)
 {
         struct serial_info *info = link->priv;
@@ -894,9 +845,7 @@ MODULE_FIRMWARE("cis/RS-COM-2P.cis");
 
 static struct pcmcia_driver serial_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "serial_cs",
-        },
+        .name           = "serial_cs",
         .probe          = serial_probe,
         .remove         = serial_detach,
         .id_table       = serial_ids,
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index 91c2f4f3af10..4b9eec68fad6 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -143,10 +143,26 @@ config SPI_GPIO
           GPIO operations, you should be able to leverage that for better
           speed with a custom version of this driver; see the source code.
 
+config SPI_IMX_VER_IMX1
+        def_bool y if SOC_IMX1
+
+config SPI_IMX_VER_0_0
+        def_bool y if SOC_IMX21 || SOC_IMX27
+
+config SPI_IMX_VER_0_4
+        def_bool y if ARCH_MX31
+
+config SPI_IMX_VER_0_7
+        def_bool y if ARCH_MX25 || ARCH_MX35 || ARCH_MX51
+
+config SPI_IMX_VER_2_3
+        def_bool y if ARCH_MX51
+
 config SPI_IMX
         tristate "Freescale i.MX SPI controllers"
         depends on ARCH_MXC
         select SPI_BITBANG
+        default m if IMX_HAVE_PLATFORM_SPI_IMX
         help
           This enables using the Freescale i.MX SPI controllers in master
           mode.
@@ -182,12 +198,27 @@ config SPI_MPC512x_PSC
           This enables using the Freescale MPC5121 Programmable Serial
           Controller in SPI master mode.
 
-config SPI_MPC8xxx
-        tristate "Freescale MPC8xxx SPI controller"
+config SPI_FSL_LIB
+        tristate
+        depends on FSL_SOC
+
+config SPI_FSL_SPI
+        tristate "Freescale SPI controller"
         depends on FSL_SOC
+        select SPI_FSL_LIB
         help
-          This enables using the Freescale MPC8xxx SPI controllers in master
-          mode.
+          This enables using the Freescale SPI controllers in master mode.
+          MPC83xx platform uses the controller in cpu mode or CPM/QE mode.
+          MPC8569 uses the controller in QE mode, MPC8610 in cpu mode.
+
+config SPI_FSL_ESPI
+        tristate "Freescale eSPI controller"
+        depends on FSL_SOC
+        select SPI_FSL_LIB
+        help
+          This enables using the Freescale eSPI controllers in master mode.
+          From MPC8536, 85xx platform uses the controller, and all P10xx,
+          P20xx, P30xx,P40xx, P50xx uses this controller.
 
 config SPI_OMAP_UWIRE
         tristate "OMAP1 MicroWire"
@@ -298,6 +329,13 @@ config SPI_STMP3XXX
         help
           SPI driver for Freescale STMP37xx/378x SoC SSP interface
 
+config SPI_TOPCLIFF_PCH
+        tristate "Topcliff PCH SPI Controller"
+        depends on PCI
+        help
+          SPI driver for the Topcliff PCH (Platform Controller Hub) SPI bus
+          used in some x86 embedded processors.
+
 config SPI_TXX9
         tristate "Toshiba TXx9 SPI controller"
         depends on GENERIC_GPIO && CPU_TX49XX
diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
index e9cbd18217a0..557aaadf56b2 100644
--- a/drivers/spi/Makefile
+++ b/drivers/spi/Makefile
@@ -2,9 +2,7 @@
 # Makefile for kernel SPI drivers.
 #
 
-ifeq ($(CONFIG_SPI_DEBUG),y)
-EXTRA_CFLAGS += -DDEBUG
-endif
+ccflags-$(CONFIG_SPI_DEBUG) := -DDEBUG
 
 # small core, mostly translating board-specific
 # config declarations into driver model code
@@ -34,11 +32,14 @@ obj-$(CONFIG_SPI_PL022)			+= amba-pl022.o
 obj-$(CONFIG_SPI_MPC512x_PSC)           += mpc512x_psc_spi.o
 obj-$(CONFIG_SPI_MPC52xx_PSC)           += mpc52xx_psc_spi.o
 obj-$(CONFIG_SPI_MPC52xx)               += mpc52xx_spi.o
-obj-$(CONFIG_SPI_MPC8xxx)               += spi_mpc8xxx.o
+obj-$(CONFIG_SPI_FSL_LIB)               += spi_fsl_lib.o
+obj-$(CONFIG_SPI_FSL_ESPI)              += spi_fsl_espi.o
+obj-$(CONFIG_SPI_FSL_SPI)               += spi_fsl_spi.o
 obj-$(CONFIG_SPI_PPC4xx)                += spi_ppc4xx.o
 obj-$(CONFIG_SPI_S3C24XX_GPIO)          += spi_s3c24xx_gpio.o
 obj-$(CONFIG_SPI_S3C24XX)               += spi_s3c24xx_hw.o
 obj-$(CONFIG_SPI_S3C64XX)               += spi_s3c64xx.o
+obj-$(CONFIG_SPI_TOPCLIFF_PCH)          += spi_topcliff_pch.o
 obj-$(CONFIG_SPI_TXX9)                  += spi_txx9.o
 obj-$(CONFIG_SPI_XILINX)                += xilinx_spi.o
 obj-$(CONFIG_SPI_XILINX_OF)             += xilinx_spi_of.o
diff --git a/drivers/spi/amba-pl022.c b/drivers/spi/amba-pl022.c
index 4c37c4e28647..fb3d1b31772d 100644
--- a/drivers/spi/amba-pl022.c
+++ b/drivers/spi/amba-pl022.c
@@ -27,7 +27,6 @@
 /*
  * TODO:
  * - add timeout on polled transfers
- * - add generic DMA framework support
  */
 
 #include <linux/init.h>
@@ -45,6 +44,9 @@
 #include <linux/amba/pl022.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
+#include <linux/scatterlist.h>
 
 /*
  * This macro is used to define some register default values.
@@ -381,6 +383,14 @@ struct pl022 {
         enum ssp_reading                read;
         enum ssp_writing                write;
         u32                             exp_fifo_level;
+        /* DMA settings */
+#ifdef CONFIG_DMA_ENGINE
+        struct dma_chan                 *dma_rx_channel;
+        struct dma_chan                 *dma_tx_channel;
+        struct sg_table                 sgt_rx;
+        struct sg_table                 sgt_tx;
+        char                            *dummypage;
+#endif
 };
 
 /**
@@ -406,7 +416,7 @@ struct chip_data {
         u16 dmacr;
         u16 cpsr;
         u8 n_bytes;
-        u8 enable_dma:1;
+        bool enable_dma;
         enum ssp_reading read;
         enum ssp_writing write;
         void (*cs_control) (u32 command);
@@ -763,6 +773,371 @@ static void *next_transfer(struct pl022 *pl022)
         }
         return STATE_DONE;
 }
+
+/*
+ * This DMA functionality is only compiled in if we have
+ * access to the generic DMA devices/DMA engine.
+ */
+#ifdef CONFIG_DMA_ENGINE
+static void unmap_free_dma_scatter(struct pl022 *pl022)
+{
+        /* Unmap and free the SG tables */
+        dma_unmap_sg(&pl022->adev->dev, pl022->sgt_tx.sgl,
+                     pl022->sgt_tx.nents, DMA_TO_DEVICE);
+        dma_unmap_sg(&pl022->adev->dev, pl022->sgt_rx.sgl,
+                     pl022->sgt_rx.nents, DMA_FROM_DEVICE);
+        sg_free_table(&pl022->sgt_rx);
+        sg_free_table(&pl022->sgt_tx);
+}
+
+static void dma_callback(void *data)
+{
+        struct pl022 *pl022 = data;
+        struct spi_message *msg = pl022->cur_msg;
+
+        BUG_ON(!pl022->sgt_rx.sgl);
+
+#ifdef VERBOSE_DEBUG
+        /*
+         * Optionally dump out buffers to inspect contents, this is
+         * good if you want to convince yourself that the loopback
+         * read/write contents are the same, when adopting to a new
+         * DMA engine.
+         */
+        {
+                struct scatterlist *sg;
+                unsigned int i;
+
+                dma_sync_sg_for_cpu(&pl022->adev->dev,
+                                    pl022->sgt_rx.sgl,
+                                    pl022->sgt_rx.nents,
+                                    DMA_FROM_DEVICE);
+
+                for_each_sg(pl022->sgt_rx.sgl, sg, pl022->sgt_rx.nents, i) {
+                        dev_dbg(&pl022->adev->dev, "SPI RX SG ENTRY: %d", i);
+                        print_hex_dump(KERN_ERR, "SPI RX: ",
+                                       DUMP_PREFIX_OFFSET,
+                                       16,
+                                       1,
+                                       sg_virt(sg),
+                                       sg_dma_len(sg),
+                                       1);
+                }
+                for_each_sg(pl022->sgt_tx.sgl, sg, pl022->sgt_tx.nents, i) {
+                        dev_dbg(&pl022->adev->dev, "SPI TX SG ENTRY: %d", i);
+                        print_hex_dump(KERN_ERR, "SPI TX: ",
+                                       DUMP_PREFIX_OFFSET,
+                                       16,
+                                       1,
+                                       sg_virt(sg),
+                                       sg_dma_len(sg),
+                                       1);
+                }
+        }
+#endif
+
+        unmap_free_dma_scatter(pl022);
+
+        /* Update total bytes transfered */
+        msg->actual_length += pl022->cur_transfer->len;
+        if (pl022->cur_transfer->cs_change)
+                pl022->cur_chip->
+                        cs_control(SSP_CHIP_DESELECT);
+
+        /* Move to next transfer */
+        msg->state = next_transfer(pl022);
+        tasklet_schedule(&pl022->pump_transfers);
+}
+
+static void setup_dma_scatter(struct pl022 *pl022,
+                              void *buffer,
+                              unsigned int length,
+                              struct sg_table *sgtab)
+{
+        struct scatterlist *sg;
+        int bytesleft = length;
+        void *bufp = buffer;
+        int mapbytes;
+        int i;
+
+        if (buffer) {
+                for_each_sg(sgtab->sgl, sg, sgtab->nents, i) {
+                        /*
+                         * If there are less bytes left than what fits
+                         * in the current page (plus page alignment offset)
+                         * we just feed in this, else we stuff in as much
+                         * as we can.
+                         */
+                        if (bytesleft < (PAGE_SIZE - offset_in_page(bufp)))
+                                mapbytes = bytesleft;
+                        else
+                                mapbytes = PAGE_SIZE - offset_in_page(bufp);
+                        sg_set_page(sg, virt_to_page(bufp),
+                                    mapbytes, offset_in_page(bufp));
+                        bufp += mapbytes;
+                        bytesleft -= mapbytes;
+                        dev_dbg(&pl022->adev->dev,
+                                "set RX/TX target page @ %p, %d bytes, %d left\n",
+                                bufp, mapbytes, bytesleft);
+                }
+        } else {
+                /* Map the dummy buffer on every page */
+                for_each_sg(sgtab->sgl, sg, sgtab->nents, i) {
+                        if (bytesleft < PAGE_SIZE)
+                                mapbytes = bytesleft;
+                        else
+                                mapbytes = PAGE_SIZE;
+                        sg_set_page(sg, virt_to_page(pl022->dummypage),
+                                    mapbytes, 0);
+                        bytesleft -= mapbytes;
+                        dev_dbg(&pl022->adev->dev,
+                                "set RX/TX to dummy page %d bytes, %d left\n",
+                                mapbytes, bytesleft);
+
+                }
+        }
+        BUG_ON(bytesleft);
+}
+
+/**
+ * configure_dma - configures the channels for the next transfer
+ * @pl022: SSP driver's private data structure
+ */
+static int configure_dma(struct pl022 *pl022)
+{
+        struct dma_slave_config rx_conf = {
+                .src_addr = SSP_DR(pl022->phybase),
+                .direction = DMA_FROM_DEVICE,
+                .src_maxburst = pl022->vendor->fifodepth >> 1,
+        };
+        struct dma_slave_config tx_conf = {
+                .dst_addr = SSP_DR(pl022->phybase),
+                .direction = DMA_TO_DEVICE,
+                .dst_maxburst = pl022->vendor->fifodepth >> 1,
+        };
+        unsigned int pages;
+        int ret;
+        int sglen;
+        struct dma_chan *rxchan = pl022->dma_rx_channel;
+        struct dma_chan *txchan = pl022->dma_tx_channel;
+        struct dma_async_tx_descriptor *rxdesc;
+        struct dma_async_tx_descriptor *txdesc;
+        dma_cookie_t cookie;
+
+        /* Check that the channels are available */
+        if (!rxchan || !txchan)
+                return -ENODEV;
+
+        switch (pl022->read) {
+        case READING_NULL:
+                /* Use the same as for writing */
+                rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
+                break;
+        case READING_U8:
+                rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                break;
+        case READING_U16:
+                rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
+                break;
+        case READING_U32:
+                rx_conf.src_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
+                break;
+        }
+
+        switch (pl022->write) {
+        case WRITING_NULL:
+                /* Use the same as for reading */
+                tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_UNDEFINED;
+                break;
+        case WRITING_U8:
+                tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_1_BYTE;
+                break;
+        case WRITING_U16:
+                tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_2_BYTES;
+                break;
+        case WRITING_U32:
+                tx_conf.dst_addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;;
+                break;
+        }
+
+        /* SPI pecularity: we need to read and write the same width */
+        if (rx_conf.src_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED)
+                rx_conf.src_addr_width = tx_conf.dst_addr_width;
+        if (tx_conf.dst_addr_width == DMA_SLAVE_BUSWIDTH_UNDEFINED)
+                tx_conf.dst_addr_width = rx_conf.src_addr_width;
+        BUG_ON(rx_conf.src_addr_width != tx_conf.dst_addr_width);
+
+        rxchan->device->device_control(rxchan, DMA_SLAVE_CONFIG,
+                                       (unsigned long) &rx_conf);
+        txchan->device->device_control(txchan, DMA_SLAVE_CONFIG,
+                                       (unsigned long) &tx_conf);
+
+        /* Create sglists for the transfers */
+        pages = (pl022->cur_transfer->len >> PAGE_SHIFT) + 1;
+        dev_dbg(&pl022->adev->dev, "using %d pages for transfer\n", pages);
+
+        ret = sg_alloc_table(&pl022->sgt_rx, pages, GFP_KERNEL);
+        if (ret)
+                goto err_alloc_rx_sg;
+
+        ret = sg_alloc_table(&pl022->sgt_tx, pages, GFP_KERNEL);
+        if (ret)
+                goto err_alloc_tx_sg;
+
+        /* Fill in the scatterlists for the RX+TX buffers */
+        setup_dma_scatter(pl022, pl022->rx,
+                          pl022->cur_transfer->len, &pl022->sgt_rx);
+        setup_dma_scatter(pl022, pl022->tx,
+                          pl022->cur_transfer->len, &pl022->sgt_tx);
+
+        /* Map DMA buffers */
+        sglen = dma_map_sg(&pl022->adev->dev, pl022->sgt_rx.sgl,
+                           pl022->sgt_rx.nents, DMA_FROM_DEVICE);
+        if (!sglen)
+                goto err_rx_sgmap;
+
+        sglen = dma_map_sg(&pl022->adev->dev, pl022->sgt_tx.sgl,
+                           pl022->sgt_tx.nents, DMA_TO_DEVICE);
+        if (!sglen)
+                goto err_tx_sgmap;
+
+        /* Send both scatterlists */
+        rxdesc = rxchan->device->device_prep_slave_sg(rxchan,
+                                      pl022->sgt_rx.sgl,
+                                      pl022->sgt_rx.nents,
+                                      DMA_FROM_DEVICE,
+                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!rxdesc)
+                goto err_rxdesc;
+
+        txdesc = txchan->device->device_prep_slave_sg(txchan,
+                                      pl022->sgt_tx.sgl,
+                                      pl022->sgt_tx.nents,
+                                      DMA_TO_DEVICE,
+                                      DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+        if (!txdesc)
+                goto err_txdesc;
+
+        /* Put the callback on the RX transfer only, that should finish last */
+        rxdesc->callback = dma_callback;
+        rxdesc->callback_param = pl022;
+
+        /* Submit and fire RX and TX with TX last so we're ready to read! */
+        cookie = rxdesc->tx_submit(rxdesc);
+        if (dma_submit_error(cookie))
+                goto err_submit_rx;
+        cookie = txdesc->tx_submit(txdesc);
+        if (dma_submit_error(cookie))
+                goto err_submit_tx;
+        rxchan->device->device_issue_pending(rxchan);
+        txchan->device->device_issue_pending(txchan);
+
+        return 0;
+
+err_submit_tx:
+err_submit_rx:
+err_txdesc:
+        txchan->device->device_control(txchan, DMA_TERMINATE_ALL, 0);
+err_rxdesc:
+        rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0);
+        dma_unmap_sg(&pl022->adev->dev, pl022->sgt_tx.sgl,
+                     pl022->sgt_tx.nents, DMA_TO_DEVICE);
+err_tx_sgmap:
+        dma_unmap_sg(&pl022->adev->dev, pl022->sgt_rx.sgl,
+                     pl022->sgt_tx.nents, DMA_FROM_DEVICE);
+err_rx_sgmap:
+        sg_free_table(&pl022->sgt_tx);
+err_alloc_tx_sg:
+        sg_free_table(&pl022->sgt_rx);
+err_alloc_rx_sg:
+        return -ENOMEM;
+}
+
+static int __init pl022_dma_probe(struct pl022 *pl022)
+{
+        dma_cap_mask_t mask;
+
+        /* Try to acquire a generic DMA engine slave channel */
+        dma_cap_zero(mask);
+        dma_cap_set(DMA_SLAVE, mask);
+        /*
+         * We need both RX and TX channels to do DMA, else do none
+         * of them.
+         */
+        pl022->dma_rx_channel = dma_request_channel(mask,
+                                            pl022->master_info->dma_filter,
+                                            pl022->master_info->dma_rx_param);
+        if (!pl022->dma_rx_channel) {
+                dev_err(&pl022->adev->dev, "no RX DMA channel!\n");
+                goto err_no_rxchan;
+        }
+
+        pl022->dma_tx_channel = dma_request_channel(mask,
+                                            pl022->master_info->dma_filter,
+                                            pl022->master_info->dma_tx_param);
+        if (!pl022->dma_tx_channel) {
+                dev_err(&pl022->adev->dev, "no TX DMA channel!\n");
+                goto err_no_txchan;
+        }
+
+        pl022->dummypage = kmalloc(PAGE_SIZE, GFP_KERNEL);
+        if (!pl022->dummypage) {
+                dev_err(&pl022->adev->dev, "no DMA dummypage!\n");
+                goto err_no_dummypage;
+        }
+
+        dev_info(&pl022->adev->dev, "setup for DMA on RX %s, TX %s\n",
+                 dma_chan_name(pl022->dma_rx_channel),
+                 dma_chan_name(pl022->dma_tx_channel));
+
+        return 0;
+
+err_no_dummypage:
+        dma_release_channel(pl022->dma_tx_channel);
+err_no_txchan:
+        dma_release_channel(pl022->dma_rx_channel);
+        pl022->dma_rx_channel = NULL;
+err_no_rxchan:
+        return -ENODEV;
+}
+
+static void terminate_dma(struct pl022 *pl022)
+{
+        struct dma_chan *rxchan = pl022->dma_rx_channel;
+        struct dma_chan *txchan = pl022->dma_tx_channel;
+
+        rxchan->device->device_control(rxchan, DMA_TERMINATE_ALL, 0);
+        txchan->device->device_control(txchan, DMA_TERMINATE_ALL, 0);
+        unmap_free_dma_scatter(pl022);
+}
+
+static void pl022_dma_remove(struct pl022 *pl022)
+{
+        if (pl022->busy)
+                terminate_dma(pl022);
+        if (pl022->dma_tx_channel)
+                dma_release_channel(pl022->dma_tx_channel);
+        if (pl022->dma_rx_channel)
+                dma_release_channel(pl022->dma_rx_channel);
+        kfree(pl022->dummypage);
+}
+
+#else
+static inline int configure_dma(struct pl022 *pl022)
+{
+        return -ENODEV;
+}
+
+static inline int pl022_dma_probe(struct pl022 *pl022)
+{
+        return 0;
+}
+
+static inline void pl022_dma_remove(struct pl022 *pl022)
+{
+}
+#endif
+
 /**
  * pl022_interrupt_handler - Interrupt handler for SSP controller
  *
@@ -794,14 +1169,17 @@ static irqreturn_t pl022_interrupt_handler(int irq, void *dev_id)
         if (unlikely(!irq_status))
                 return IRQ_NONE;
 
-        /* This handles the error code interrupts */
+        /*
+         * This handles the FIFO interrupts, the timeout
+         * interrupts are flatly ignored, they cannot be
+         * trusted.
+         */
         if (unlikely(irq_status & SSP_MIS_MASK_RORMIS)) {
                 /*
                  * Overrun interrupt - bail out since our Data has been
                  * corrupted
                  */
-                dev_err(&pl022->adev->dev,
-                        "FIFO overrun\n");
+                dev_err(&pl022->adev->dev, "FIFO overrun\n");
                 if (readw(SSP_SR(pl022->virtbase)) & SSP_SR_MASK_RFF)
                         dev_err(&pl022->adev->dev,
                                 "RXFIFO is full\n");
@@ -896,8 +1274,8 @@ static int set_up_next_transfer(struct pl022 *pl022,
 }
 
 /**
- * pump_transfers - Tasklet function which schedules next interrupt transfer
- * when running in interrupt transfer mode.
+ * pump_transfers - Tasklet function which schedules next transfer
+ * when running in interrupt or DMA transfer mode.
  * @data: SSP driver private data structure
  *
  */
@@ -954,65 +1332,23 @@ static void pump_transfers(unsigned long data)
         }
         /* Flush the FIFOs and let's go! */
         flush(pl022);
-        writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase));
-}
-
-/**
- * NOT IMPLEMENTED
- * configure_dma - It configures the DMA pipes for DMA transfers
- * @data: SSP driver's private data structure
- *
- */
-static int configure_dma(void *data)
-{
-        struct pl022 *pl022 = data;
-        dev_dbg(&pl022->adev->dev, "configure DMA\n");
-        return -ENOTSUPP;
-}
-
-/**
- * do_dma_transfer - It handles transfers of the current message
- * if it is DMA xfer.
- * NOT FULLY IMPLEMENTED
- * @data: SSP driver's private data structure
- */
-static void do_dma_transfer(void *data)
-{
-        struct pl022 *pl022 = data;
-
-        if (configure_dma(data)) {
-                dev_dbg(&pl022->adev->dev, "configuration of DMA Failed!\n");
-                goto err_config_dma;
-        }
 
-        /* TODO: Implememt DMA setup of pipes here */
-
-        /* Enable target chip, set up transfer */
-        pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
-        if (set_up_next_transfer(pl022, pl022->cur_transfer)) {
-                /* Error path */
-                pl022->cur_msg->state = STATE_ERROR;
-                pl022->cur_msg->status = -EIO;
-                giveback(pl022);
+        if (pl022->cur_chip->enable_dma) {
+                if (configure_dma(pl022)) {
+                        dev_dbg(&pl022->adev->dev,
+                                "configuration of DMA failed, fall back to interrupt mode\n");
+                        goto err_config_dma;
+                }
                 return;
         }
-        /* Enable SSP */
-        writew((readw(SSP_CR1(pl022->virtbase)) | SSP_CR1_MASK_SSE),
-               SSP_CR1(pl022->virtbase));
-
-        /* TODO: Enable the DMA transfer here */
-        return;
 
- err_config_dma:
-        pl022->cur_msg->state = STATE_ERROR;
-        pl022->cur_msg->status = -EIO;
-        giveback(pl022);
-        return;
+err_config_dma:
+        writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase));
 }
 
-static void do_interrupt_transfer(void *data)
+static void do_interrupt_dma_transfer(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = data;
+        u32 irqflags = ENABLE_ALL_INTERRUPTS;
 
         /* Enable target chip */
         pl022->cur_chip->cs_control(SSP_CHIP_SELECT);
@@ -1023,15 +1359,26 @@ static void do_interrupt_transfer(void *data)
                 giveback(pl022);
                 return;
         }
+        /* If we're using DMA, set up DMA here */
+        if (pl022->cur_chip->enable_dma) {
+                /* Configure DMA transfer */
+                if (configure_dma(pl022)) {
+                        dev_dbg(&pl022->adev->dev,
+                                "configuration of DMA failed, fall back to interrupt mode\n");
+                        goto err_config_dma;
+                }
+                /* Disable interrupts in DMA mode, IRQ from DMA controller */
+                irqflags = DISABLE_ALL_INTERRUPTS;
+        }
+err_config_dma:
         /* Enable SSP, turn on interrupts */
         writew((readw(SSP_CR1(pl022->virtbase)) | SSP_CR1_MASK_SSE),
                SSP_CR1(pl022->virtbase));
-        writew(ENABLE_ALL_INTERRUPTS, SSP_IMSC(pl022->virtbase));
+        writew(irqflags, SSP_IMSC(pl022->virtbase));
 }
 
-static void do_polling_transfer(void *data)
+static void do_polling_transfer(struct pl022 *pl022)
 {
-        struct pl022 *pl022 = data;
         struct spi_message *message = NULL;
         struct spi_transfer *transfer = NULL;
         struct spi_transfer *previous = NULL;
@@ -1101,7 +1448,7 @@ static void do_polling_transfer(void *data)
  *
  * This function checks if there is any spi message in the queue that
  * needs processing and delegate control to appropriate function
- * do_polling_transfer()/do_interrupt_transfer()/do_dma_transfer()
+ * do_polling_transfer()/do_interrupt_dma_transfer()
  * based on the kind of the transfer
  *
  */
@@ -1150,10 +1497,8 @@ static void pump_messages(struct work_struct *work)
 
         if (pl022->cur_chip->xfer_type == POLLING_TRANSFER)
                 do_polling_transfer(pl022);
-        else if (pl022->cur_chip->xfer_type == INTERRUPT_TRANSFER)
-                do_interrupt_transfer(pl022);
         else
-                do_dma_transfer(pl022);
+                do_interrupt_dma_transfer(pl022);
 }
 
 
@@ -1248,100 +1593,56 @@ static int destroy_queue(struct pl022 *pl022)
 }
 
 static int verify_controller_parameters(struct pl022 *pl022,
-                                        struct pl022_config_chip *chip_info)
+                                struct pl022_config_chip const *chip_info)
 {
-        if ((chip_info->lbm != LOOPBACK_ENABLED)
-            && (chip_info->lbm != LOOPBACK_DISABLED)) {
-                dev_err(chip_info->dev,
-                        "loopback Mode is configured incorrectly\n");
-                return -EINVAL;
-        }
         if ((chip_info->iface < SSP_INTERFACE_MOTOROLA_SPI)
             || (chip_info->iface > SSP_INTERFACE_UNIDIRECTIONAL)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "interface is configured incorrectly\n");
                 return -EINVAL;
         }
         if ((chip_info->iface == SSP_INTERFACE_UNIDIRECTIONAL) &&
             (!pl022->vendor->unidir)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "unidirectional mode not supported in this "
                         "hardware version\n");
                 return -EINVAL;
         }
         if ((chip_info->hierarchy != SSP_MASTER)
             && (chip_info->hierarchy != SSP_SLAVE)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "hierarchy is configured incorrectly\n");
                 return -EINVAL;
         }
-        if (((chip_info->clk_freq).cpsdvsr < CPSDVR_MIN)
-            || ((chip_info->clk_freq).cpsdvsr > CPSDVR_MAX)) {
-                dev_err(chip_info->dev,
-                        "cpsdvsr is configured incorrectly\n");
-                return -EINVAL;
-        }
-        if ((chip_info->endian_rx != SSP_RX_MSB)
-            && (chip_info->endian_rx != SSP_RX_LSB)) {
-                dev_err(chip_info->dev,
-                        "RX FIFO endianess is configured incorrectly\n");
-                return -EINVAL;
-        }
-        if ((chip_info->endian_tx != SSP_TX_MSB)
-            && (chip_info->endian_tx != SSP_TX_LSB)) {
-                dev_err(chip_info->dev,
-                        "TX FIFO endianess is configured incorrectly\n");
-                return -EINVAL;
-        }
-        if ((chip_info->data_size < SSP_DATA_BITS_4)
-            || (chip_info->data_size > SSP_DATA_BITS_32)) {
-                dev_err(chip_info->dev,
-                        "DATA Size is configured incorrectly\n");
-                return -EINVAL;
-        }
         if ((chip_info->com_mode != INTERRUPT_TRANSFER)
             && (chip_info->com_mode != DMA_TRANSFER)
             && (chip_info->com_mode != POLLING_TRANSFER)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "Communication mode is configured incorrectly\n");
                 return -EINVAL;
         }
         if ((chip_info->rx_lev_trig < SSP_RX_1_OR_MORE_ELEM)
             || (chip_info->rx_lev_trig > SSP_RX_32_OR_MORE_ELEM)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "RX FIFO Trigger Level is configured incorrectly\n");
                 return -EINVAL;
         }
         if ((chip_info->tx_lev_trig < SSP_TX_1_OR_MORE_EMPTY_LOC)
             || (chip_info->tx_lev_trig > SSP_TX_32_OR_MORE_EMPTY_LOC)) {
-                dev_err(chip_info->dev,
+                dev_err(&pl022->adev->dev,
                         "TX FIFO Trigger Level is configured incorrectly\n");
                 return -EINVAL;
         }
-        if (chip_info->iface == SSP_INTERFACE_MOTOROLA_SPI) {
-                if ((chip_info->clk_phase != SSP_CLK_FIRST_EDGE)
-                    && (chip_info->clk_phase != SSP_CLK_SECOND_EDGE)) {
-                        dev_err(chip_info->dev,
-                                "Clock Phase is configured incorrectly\n");
-                        return -EINVAL;
-                }
-                if ((chip_info->clk_pol != SSP_CLK_POL_IDLE_LOW)
-                    && (chip_info->clk_pol != SSP_CLK_POL_IDLE_HIGH)) {
-                        dev_err(chip_info->dev,
-                                "Clock Polarity is configured incorrectly\n");
-                        return -EINVAL;
-                }
-        }
         if (chip_info->iface == SSP_INTERFACE_NATIONAL_MICROWIRE) {
                 if ((chip_info->ctrl_len < SSP_BITS_4)
                     || (chip_info->ctrl_len > SSP_BITS_32)) {
-                        dev_err(chip_info->dev,
+                        dev_err(&pl022->adev->dev,
                                 "CTRL LEN is configured incorrectly\n");
                         return -EINVAL;
                 }
                 if ((chip_info->wait_state != SSP_MWIRE_WAIT_ZERO)
                     && (chip_info->wait_state != SSP_MWIRE_WAIT_ONE)) {
-                        dev_err(chip_info->dev,
+                        dev_err(&pl022->adev->dev,
                                 "Wait State is configured incorrectly\n");
                         return -EINVAL;
                 }
@@ -1350,24 +1651,20 @@ static int verify_controller_parameters(struct pl022 *pl022,
                         if ((chip_info->duplex !=
                              SSP_MICROWIRE_CHANNEL_FULL_DUPLEX)
                             && (chip_info->duplex !=
-                                SSP_MICROWIRE_CHANNEL_HALF_DUPLEX))
-                                dev_err(chip_info->dev,
+                                SSP_MICROWIRE_CHANNEL_HALF_DUPLEX)) {
+                                dev_err(&pl022->adev->dev,
                                         "Microwire duplex mode is configured incorrectly\n");
                                 return -EINVAL;
+                        }
                 } else {
                         if (chip_info->duplex != SSP_MICROWIRE_CHANNEL_FULL_DUPLEX)
-                                dev_err(chip_info->dev,
+                                dev_err(&pl022->adev->dev,
                                         "Microwire half duplex mode requested,"
                                         " but this is only available in the"
                                         " ST version of PL022\n");
                         return -EINVAL;
                 }
         }
-        if (chip_info->cs_control == NULL) {
-                dev_warn(chip_info->dev,
-                        "Chip Select Function is NULL for this chip\n");
-                chip_info->cs_control = null_cs_control;
-        }
         return 0;
 }
 
@@ -1467,22 +1764,24 @@ static int calculate_effective_freq(struct pl022 *pl022,
         return 0;
 }
 
-/**
- * NOT IMPLEMENTED
- * process_dma_info - Processes the DMA info provided by client drivers
- * @chip_info: chip info provided by client device
- * @chip: Runtime state maintained by the SSP controller for each spi device
- *
- * This function processes and stores DMA config provided by client driver
- * into the runtime state maintained by the SSP controller driver
+
+/*
+ * A piece of default chip info unless the platform
+ * supplies it.
  */
-static int process_dma_info(struct pl022_config_chip *chip_info,
-                            struct chip_data *chip)
-{
-        dev_err(chip_info->dev,
-                "cannot process DMA info, DMA not implemented!\n");
-        return -ENOTSUPP;
-}
+static const struct pl022_config_chip pl022_default_chip_info = {
+        .com_mode = POLLING_TRANSFER,
+        .iface = SSP_INTERFACE_MOTOROLA_SPI,
+        .hierarchy = SSP_SLAVE,
+        .slave_tx_disable = DO_NOT_DRIVE_TX,
+        .rx_lev_trig = SSP_RX_1_OR_MORE_ELEM,
+        .tx_lev_trig = SSP_TX_1_OR_MORE_EMPTY_LOC,
+        .ctrl_len = SSP_BITS_8,
+        .wait_state = SSP_MWIRE_WAIT_ZERO,
+        .duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX,
+        .cs_control = null_cs_control,
+};
+
 
 /**
  * pl022_setup - setup function registered to SPI master framework
@@ -1496,23 +1795,15 @@ static int process_dma_info(struct pl022_config_chip *chip_info,
  * controller hardware here, that is not done until the actual transfer
  * commence.
  */
-
-/* FIXME: JUST GUESSING the spi->mode bits understood by this driver */
-#define MODEBITS        (SPI_CPOL | SPI_CPHA | SPI_CS_HIGH \
-                        | SPI_LSB_FIRST | SPI_LOOP)
-
 static int pl022_setup(struct spi_device *spi)
 {
-        struct pl022_config_chip *chip_info;
+        struct pl022_config_chip const *chip_info;
         struct chip_data *chip;
+        struct ssp_clock_params clk_freq;
         int status = 0;
         struct pl022 *pl022 = spi_master_get_devdata(spi->master);
-
-        if (spi->mode & ~MODEBITS) {
-                dev_dbg(&spi->dev, "unsupported mode bits %x\n",
-                        spi->mode & ~MODEBITS);
-                return -EINVAL;
-        }
+        unsigned int bits = spi->bits_per_word;
+        u32 tmp;
 
         if (!spi->max_speed_hz)
                 return -EINVAL;
@@ -1535,48 +1826,13 @@ static int pl022_setup(struct spi_device *spi)
         chip_info = spi->controller_data;
 
         if (chip_info == NULL) {
+                chip_info = &pl022_default_chip_info;
                 /* spi_board_info.controller_data not is supplied */
                 dev_dbg(&spi->dev,
                         "using default controller_data settings\n");
-
-                chip_info =
-                        kzalloc(sizeof(struct pl022_config_chip), GFP_KERNEL);
-
-                if (!chip_info) {
-                        dev_err(&spi->dev,
-                                "cannot allocate controller data\n");
-                        status = -ENOMEM;
-                        goto err_first_setup;
-                }
-
-                dev_dbg(&spi->dev, "allocated memory for controller data\n");
-
-                /* Pointer back to the SPI device */
-                chip_info->dev = &spi->dev;
-                /*
-                 * Set controller data default values:
-                 * Polling is supported by default
-                 */
-                chip_info->lbm = LOOPBACK_DISABLED;
-                chip_info->com_mode = POLLING_TRANSFER;
-                chip_info->iface = SSP_INTERFACE_MOTOROLA_SPI;
-                chip_info->hierarchy = SSP_SLAVE;
-                chip_info->slave_tx_disable = DO_NOT_DRIVE_TX;
-                chip_info->endian_tx = SSP_TX_LSB;
-                chip_info->endian_rx = SSP_RX_LSB;
-                chip_info->data_size = SSP_DATA_BITS_12;
-                chip_info->rx_lev_trig = SSP_RX_1_OR_MORE_ELEM;
-                chip_info->tx_lev_trig = SSP_TX_1_OR_MORE_EMPTY_LOC;
-                chip_info->clk_phase = SSP_CLK_SECOND_EDGE;
-                chip_info->clk_pol = SSP_CLK_POL_IDLE_LOW;
-                chip_info->ctrl_len = SSP_BITS_8;
-                chip_info->wait_state = SSP_MWIRE_WAIT_ZERO;
-                chip_info->duplex = SSP_MICROWIRE_CHANNEL_FULL_DUPLEX;
-                chip_info->cs_control = null_cs_control;
-        } else {
+        } else
                 dev_dbg(&spi->dev,
                         "using user supplied controller_data settings\n");
-        }
 
         /*
          * We can override with custom divisors, else we use the board
@@ -1586,29 +1842,48 @@ static int pl022_setup(struct spi_device *spi)
             && (0 == chip_info->clk_freq.scr)) {
                 status = calculate_effective_freq(pl022,
                                                   spi->max_speed_hz,
-                                                  &chip_info->clk_freq);
+                                                  &clk_freq);
                 if (status < 0)
                         goto err_config_params;
         } else {
-                if ((chip_info->clk_freq.cpsdvsr % 2) != 0)
-                        chip_info->clk_freq.cpsdvsr =
-                                chip_info->clk_freq.cpsdvsr - 1;
+                memcpy(&clk_freq, &chip_info->clk_freq, sizeof(clk_freq));
+                if ((clk_freq.cpsdvsr % 2) != 0)
+                        clk_freq.cpsdvsr =
+                                clk_freq.cpsdvsr - 1;
+        }
+        if ((clk_freq.cpsdvsr < CPSDVR_MIN)
+            || (clk_freq.cpsdvsr > CPSDVR_MAX)) {
+                dev_err(&spi->dev,
+                        "cpsdvsr is configured incorrectly\n");
+                goto err_config_params;
         }
+
+
         status = verify_controller_parameters(pl022, chip_info);
         if (status) {
                 dev_err(&spi->dev, "controller data is incorrect");
                 goto err_config_params;
         }
+
         /* Now set controller state based on controller data */
         chip->xfer_type = chip_info->com_mode;
-        chip->cs_control = chip_info->cs_control;
-
-        if (chip_info->data_size <= 8) {
-                dev_dbg(&spi->dev, "1 <= n <=8 bits per word\n");
+        if (!chip_info->cs_control) {
+                chip->cs_control = null_cs_control;
+                dev_warn(&spi->dev,
+                         "chip select function is NULL for this chip\n");
+        } else
+                chip->cs_control = chip_info->cs_control;
+
+        if (bits <= 3) {
+                /* PL022 doesn't support less than 4-bits */
+                status = -ENOTSUPP;
+                goto err_config_params;
+        } else if (bits <= 8) {
+                dev_dbg(&spi->dev, "4 <= n <=8 bits per word\n");
                 chip->n_bytes = 1;
                 chip->read = READING_U8;
                 chip->write = WRITING_U8;
-        } else if (chip_info->data_size <= 16) {
+        } else if (bits <= 16) {
                 dev_dbg(&spi->dev, "9 <= n <= 16 bits per word\n");
                 chip->n_bytes = 2;
                 chip->read = READING_U16;
@@ -1625,6 +1900,7 @@ static int pl022_setup(struct spi_device *spi)
                         dev_err(&spi->dev,
                                 "a standard pl022 can only handle "
                                 "1 <= n <= 16 bit words\n");
+                        status = -ENOTSUPP;
                         goto err_config_params;
                 }
         }
@@ -1636,9 +1912,8 @@ static int pl022_setup(struct spi_device *spi)
         chip->cpsr = 0;
         if ((chip_info->com_mode == DMA_TRANSFER)
             && ((pl022->master_info)->enable_dma)) {
-                chip->enable_dma = 1;
+                chip->enable_dma = true;
                 dev_dbg(&spi->dev, "DMA mode set in controller state\n");
-                status = process_dma_info(chip_info, chip);
                 if (status < 0)
                         goto err_config_params;
                 SSP_WRITE_BITS(chip->dmacr, SSP_DMA_ENABLED,
@@ -1646,7 +1921,7 @@ static int pl022_setup(struct spi_device *spi)
                 SSP_WRITE_BITS(chip->dmacr, SSP_DMA_ENABLED,
                                SSP_DMACR_MASK_TXDMAE, 1);
         } else {
-                chip->enable_dma = 0;
+                chip->enable_dma = false;
                 dev_dbg(&spi->dev, "DMA mode NOT set in controller state\n");
                 SSP_WRITE_BITS(chip->dmacr, SSP_DMA_DISABLED,
                                SSP_DMACR_MASK_RXDMAE, 0);
@@ -1654,10 +1929,12 @@ static int pl022_setup(struct spi_device *spi)
                                SSP_DMACR_MASK_TXDMAE, 1);
         }
 
-        chip->cpsr = chip_info->clk_freq.cpsdvsr;
+        chip->cpsr = clk_freq.cpsdvsr;
 
         /* Special setup for the ST micro extended control registers */
         if (pl022->vendor->extended_cr) {
+                u32 etx;
+
                 if (pl022->vendor->pl023) {
                         /* These bits are only in the PL023 */
                         SSP_WRITE_BITS(chip->cr1, chip_info->clkdelay,
@@ -1673,29 +1950,51 @@ static int pl022_setup(struct spi_device *spi)
                         SSP_WRITE_BITS(chip->cr1, chip_info->wait_state,
                                        SSP_CR1_MASK_MWAIT_ST, 6);
                 }
-                SSP_WRITE_BITS(chip->cr0, chip_info->data_size,
+                SSP_WRITE_BITS(chip->cr0, bits - 1,
                                SSP_CR0_MASK_DSS_ST, 0);
-                SSP_WRITE_BITS(chip->cr1, chip_info->endian_rx,
-                               SSP_CR1_MASK_RENDN_ST, 4);
-                SSP_WRITE_BITS(chip->cr1, chip_info->endian_tx,
-                               SSP_CR1_MASK_TENDN_ST, 5);
+
+                if (spi->mode & SPI_LSB_FIRST) {
+                        tmp = SSP_RX_LSB;
+                        etx = SSP_TX_LSB;
+                } else {
+                        tmp = SSP_RX_MSB;
+                        etx = SSP_TX_MSB;
+                }
+                SSP_WRITE_BITS(chip->cr1, tmp, SSP_CR1_MASK_RENDN_ST, 4);
+                SSP_WRITE_BITS(chip->cr1, etx, SSP_CR1_MASK_TENDN_ST, 5);
                 SSP_WRITE_BITS(chip->cr1, chip_info->rx_lev_trig,
                                SSP_CR1_MASK_RXIFLSEL_ST, 7);
                 SSP_WRITE_BITS(chip->cr1, chip_info->tx_lev_trig,
                                SSP_CR1_MASK_TXIFLSEL_ST, 10);
         } else {
-                SSP_WRITE_BITS(chip->cr0, chip_info->data_size,
+                SSP_WRITE_BITS(chip->cr0, bits - 1,
                                SSP_CR0_MASK_DSS, 0);
                 SSP_WRITE_BITS(chip->cr0, chip_info->iface,
                                SSP_CR0_MASK_FRF, 4);
         }
+
         /* Stuff that is common for all versions */
-        SSP_WRITE_BITS(chip->cr0, chip_info->clk_pol, SSP_CR0_MASK_SPO, 6);
-        SSP_WRITE_BITS(chip->cr0, chip_info->clk_phase, SSP_CR0_MASK_SPH, 7);
-        SSP_WRITE_BITS(chip->cr0, chip_info->clk_freq.scr, SSP_CR0_MASK_SCR, 8);
+        if (spi->mode & SPI_CPOL)
+                tmp = SSP_CLK_POL_IDLE_HIGH;
+        else
+                tmp = SSP_CLK_POL_IDLE_LOW;
+        SSP_WRITE_BITS(chip->cr0, tmp, SSP_CR0_MASK_SPO, 6);
+
+        if (spi->mode & SPI_CPHA)
+                tmp = SSP_CLK_SECOND_EDGE;
+        else
+                tmp = SSP_CLK_FIRST_EDGE;
+        SSP_WRITE_BITS(chip->cr0, tmp, SSP_CR0_MASK_SPH, 7);
+
+        SSP_WRITE_BITS(chip->cr0, clk_freq.scr, SSP_CR0_MASK_SCR, 8);
         /* Loopback is available on all versions except PL023 */
-        if (!pl022->vendor->pl023)
-                SSP_WRITE_BITS(chip->cr1, chip_info->lbm, SSP_CR1_MASK_LBM, 0);
+        if (!pl022->vendor->pl023) {
+                if (spi->mode & SPI_LOOP)
+                        tmp = LOOPBACK_ENABLED;
+                else
+                        tmp = LOOPBACK_DISABLED;
+                SSP_WRITE_BITS(chip->cr1, tmp, SSP_CR1_MASK_LBM, 0);
+        }
         SSP_WRITE_BITS(chip->cr1, SSP_DISABLED, SSP_CR1_MASK_SSE, 1);
         SSP_WRITE_BITS(chip->cr1, chip_info->hierarchy, SSP_CR1_MASK_MS, 2);
         SSP_WRITE_BITS(chip->cr1, chip_info->slave_tx_disable, SSP_CR1_MASK_SOD, 3);
@@ -1704,7 +2003,7 @@ static int pl022_setup(struct spi_device *spi)
         spi_set_ctldata(spi, chip);
         return status;
  err_config_params:
- err_first_setup:
+        spi_set_ctldata(spi, NULL);
         kfree(chip);
         return status;
 }
@@ -1766,12 +2065,21 @@ pl022_probe(struct amba_device *adev, struct amba_id *id)
         master->setup = pl022_setup;
         master->transfer = pl022_transfer;
 
+        /*
+         * Supports mode 0-3, loopback, and active low CS. Transfers are
+         * always MS bit first on the original pl022.
+         */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH | SPI_LOOP;
+        if (pl022->vendor->extended_cr)
+                master->mode_bits |= SPI_LSB_FIRST;
+
         dev_dbg(&adev->dev, "BUSNO: %d\n", master->bus_num);
 
         status = amba_request_regions(adev, NULL);
         if (status)
                 goto err_no_ioregion;
 
+        pl022->phybase = adev->res.start;
         pl022->virtbase = ioremap(adev->res.start, resource_size(&adev->res));
         if (pl022->virtbase == NULL) {
                 status = -ENOMEM;
@@ -1798,6 +2106,14 @@ pl022_probe(struct amba_device *adev, struct amba_id *id)
                 dev_err(&adev->dev, "probe - cannot get IRQ (%d)\n", status);
                 goto err_no_irq;
         }
+
+        /* Get DMA channels */
+        if (platform_info->enable_dma) {
+                status = pl022_dma_probe(pl022);
+                if (status != 0)
+                        goto err_no_dma;
+        }
+
         /* Initialize and start queue */
         status = init_queue(pl022);
         if (status != 0) {
@@ -1826,6 +2142,8 @@ pl022_probe(struct amba_device *adev, struct amba_id *id)
  err_start_queue:
  err_init_queue:
         destroy_queue(pl022);
+        pl022_dma_remove(pl022);
+ err_no_dma:
         free_irq(adev->irq[0], pl022);
  err_no_irq:
         clk_put(pl022->clk);
@@ -1856,6 +2174,7 @@ pl022_remove(struct amba_device *adev)
                 return status;
         }
         load_ssp_default_config(pl022);
+        pl022_dma_remove(pl022);
         free_irq(adev->irq[0], pl022);
         clk_disable(pl022->clk);
         clk_put(pl022->clk);
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index c4e04428992d..154529aacc03 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -654,6 +654,8 @@ static int atmel_spi_transfer(struct spi_device *spi, struct spi_message *msg)
         struct spi_transfer     *xfer;
         unsigned long           flags;
         struct device           *controller = spi->master->dev.parent;
+        u8                      bits;
+        struct atmel_spi_device *asd;
 
         as = spi_master_get_devdata(spi->master);
 
@@ -672,8 +674,18 @@ static int atmel_spi_transfer(struct spi_device *spi, struct spi_message *msg)
                         return -EINVAL;
                 }
 
+                if (xfer->bits_per_word) {
+                        asd = spi->controller_state;
+                        bits = (asd->csr >> 4) & 0xf;
+                        if (bits != xfer->bits_per_word - 8) {
+                                dev_dbg(&spi->dev, "you can't yet change "
+                                         "bits_per_word in transfers\n");
+                                return -ENOPROTOOPT;
+                        }
+                }
+
                 /* FIXME implement these protocol options!! */
-                if (xfer->bits_per_word || xfer->speed_hz) {
+                if (xfer->speed_hz) {
                         dev_dbg(&spi->dev, "no protocol options yet\n");
                         return -ENOPROTOOPT;
                 }
diff --git a/drivers/spi/omap2_mcspi.c b/drivers/spi/omap2_mcspi.c
index b3a94ca0a75a..2a651e61bfbf 100644
--- a/drivers/spi/omap2_mcspi.c
+++ b/drivers/spi/omap2_mcspi.c
@@ -296,6 +296,19 @@ static int omap2_mcspi_enable_clocks(struct omap2_mcspi *mcspi)
         return 0;
 }
 
+static int mcspi_wait_for_reg_bit(void __iomem *reg, unsigned long bit)
+{
+        unsigned long timeout;
+
+        timeout = jiffies + msecs_to_jiffies(1000);
+        while (!(__raw_readl(reg) & bit)) {
+                if (time_after(jiffies, timeout))
+                        return -1;
+                cpu_relax();
+        }
+        return 0;
+}
+
 static unsigned
 omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
 {
@@ -309,11 +322,14 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         u32                     l;
         u8                      * rx;
         const u8                * tx;
+        void __iomem            *chstat_reg;
 
         mcspi = spi_master_get_devdata(spi->master);
         mcspi_dma = &mcspi->dma_channels[spi->chip_select];
         l = mcspi_cached_chconf0(spi);
 
+        chstat_reg = cs->base + OMAP2_MCSPI_CHSTAT0;
+
         count = xfer->len;
         c = count;
         word_len = cs->word_len;
@@ -382,6 +398,16 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         if (tx != NULL) {
                 wait_for_completion(&mcspi_dma->dma_tx_completion);
                 dma_unmap_single(NULL, xfer->tx_dma, count, DMA_TO_DEVICE);
+
+                /* for TX_ONLY mode, be sure all words have shifted out */
+                if (rx == NULL) {
+                        if (mcspi_wait_for_reg_bit(chstat_reg,
+                                                OMAP2_MCSPI_CHSTAT_TXS) < 0)
+                                dev_err(&spi->dev, "TXS timed out\n");
+                        else if (mcspi_wait_for_reg_bit(chstat_reg,
+                                                OMAP2_MCSPI_CHSTAT_EOT) < 0)
+                                dev_err(&spi->dev, "EOT timed out\n");
+                }
         }
 
         if (rx != NULL) {
@@ -435,19 +461,6 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
         return count;
 }
 
-static int mcspi_wait_for_reg_bit(void __iomem *reg, unsigned long bit)
-{
-        unsigned long timeout;
-
-        timeout = jiffies + msecs_to_jiffies(1000);
-        while (!(__raw_readl(reg) & bit)) {
-                if (time_after(jiffies, timeout))
-                        return -1;
-                cpu_relax();
-        }
-        return 0;
-}
-
 static unsigned
 omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
 {
@@ -489,10 +502,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                         dev_err(&spi->dev, "TXS timed out\n");
                                         goto out;
                                 }
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "write-%d %02x\n",
+                                dev_vdbg(&spi->dev, "write-%d %02x\n",
                                                 word_len, *tx);
-#endif
                                 __raw_writel(*tx++, tx_reg);
                         }
                         if (rx != NULL) {
@@ -506,10 +517,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                     (l & OMAP2_MCSPI_CHCONF_TURBO)) {
                                         omap2_mcspi_set_enable(spi, 0);
                                         *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                        dev_dbg(&spi->dev, "read-%d %02x\n",
+                                        dev_vdbg(&spi->dev, "read-%d %02x\n",
                                                     word_len, *(rx - 1));
-#endif
                                         if (mcspi_wait_for_reg_bit(chstat_reg,
                                                 OMAP2_MCSPI_CHSTAT_RXS) < 0) {
                                                 dev_err(&spi->dev,
@@ -522,10 +531,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                 }
 
                                 *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "read-%d %02x\n",
+                                dev_vdbg(&spi->dev, "read-%d %02x\n",
                                                 word_len, *(rx - 1));
-#endif
                         }
                 } while (c);
         } else if (word_len <= 16) {
@@ -542,10 +549,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                         dev_err(&spi->dev, "TXS timed out\n");
                                         goto out;
                                 }
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "write-%d %04x\n",
+                                dev_vdbg(&spi->dev, "write-%d %04x\n",
                                                 word_len, *tx);
-#endif
                                 __raw_writel(*tx++, tx_reg);
                         }
                         if (rx != NULL) {
@@ -559,10 +564,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                     (l & OMAP2_MCSPI_CHCONF_TURBO)) {
                                         omap2_mcspi_set_enable(spi, 0);
                                         *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                        dev_dbg(&spi->dev, "read-%d %04x\n",
+                                        dev_vdbg(&spi->dev, "read-%d %04x\n",
                                                     word_len, *(rx - 1));
-#endif
                                         if (mcspi_wait_for_reg_bit(chstat_reg,
                                                 OMAP2_MCSPI_CHSTAT_RXS) < 0) {
                                                 dev_err(&spi->dev,
@@ -575,10 +578,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                 }
 
                                 *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "read-%d %04x\n",
+                                dev_vdbg(&spi->dev, "read-%d %04x\n",
                                                 word_len, *(rx - 1));
-#endif
                         }
                 } while (c);
         } else if (word_len <= 32) {
@@ -595,10 +596,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                         dev_err(&spi->dev, "TXS timed out\n");
                                         goto out;
                                 }
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "write-%d %08x\n",
+                                dev_vdbg(&spi->dev, "write-%d %08x\n",
                                                 word_len, *tx);
-#endif
                                 __raw_writel(*tx++, tx_reg);
                         }
                         if (rx != NULL) {
@@ -612,10 +611,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                     (l & OMAP2_MCSPI_CHCONF_TURBO)) {
                                         omap2_mcspi_set_enable(spi, 0);
                                         *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                        dev_dbg(&spi->dev, "read-%d %08x\n",
+                                        dev_vdbg(&spi->dev, "read-%d %08x\n",
                                                     word_len, *(rx - 1));
-#endif
                                         if (mcspi_wait_for_reg_bit(chstat_reg,
                                                 OMAP2_MCSPI_CHSTAT_RXS) < 0) {
                                                 dev_err(&spi->dev,
@@ -628,10 +625,8 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                                 }
 
                                 *rx++ = __raw_readl(rx_reg);
-#ifdef VERBOSE
-                                dev_dbg(&spi->dev, "read-%d %08x\n",
+                                dev_vdbg(&spi->dev, "read-%d %08x\n",
                                                 word_len, *(rx - 1));
-#endif
                         }
                 } while (c);
         }
@@ -644,6 +639,12 @@ omap2_mcspi_txrx_pio(struct spi_device *spi, struct spi_transfer *xfer)
                 } else if (mcspi_wait_for_reg_bit(chstat_reg,
                                 OMAP2_MCSPI_CHSTAT_EOT) < 0)
                         dev_err(&spi->dev, "EOT timed out\n");
+
+                /* disable chan to purge rx datas received in TX_ONLY transfer,
+                 * otherwise these rx datas will affect the direct following
+                 * RX_ONLY transfer.
+                 */
+                omap2_mcspi_set_enable(spi, 0);
         }
 out:
         omap2_mcspi_set_enable(spi, 1);
diff --git a/drivers/spi/orion_spi.c b/drivers/spi/orion_spi.c
index 3aea50da7b29..0b677dc041ad 100644
--- a/drivers/spi/orion_spi.c
+++ b/drivers/spi/orion_spi.c
@@ -404,7 +404,7 @@ static int orion_spi_transfer(struct spi_device *spi, struct spi_message *m)
                         goto msg_rejected;
                 }
 
-                if ((t != NULL) && t->bits_per_word)
+                if (t->bits_per_word)
                         bits_per_word = t->bits_per_word;
 
                 if ((bits_per_word != 8) && (bits_per_word != 16)) {
@@ -415,7 +415,7 @@ static int orion_spi_transfer(struct spi_device *spi, struct spi_message *m)
                         goto msg_rejected;
                 }
                 /*make sure buffer length is even when working in 16 bit mode*/
-                if ((t != NULL) && (t->bits_per_word == 16) && (t->len & 1)) {
+                if ((t->bits_per_word == 16) && (t->len & 1)) {
                         dev_err(&spi->dev,
                                 "message rejected : "
                                 "odd data length (%d) while in 16 bit mode\n",
diff --git a/drivers/spi/spi_bfin5xx.c b/drivers/spi/spi_bfin5xx.c
index 10a6dc3d37ac..ab483a0ec6d0 100644
--- a/drivers/spi/spi_bfin5xx.c
+++ b/drivers/spi/spi_bfin5xx.c
@@ -1,7 +1,7 @@
 /*
  * Blackfin On-Chip SPI Driver
  *
- * Copyright 2004-2007 Analog Devices Inc.
+ * Copyright 2004-2010 Analog Devices Inc.
  *
  * Enter bugs at http://blackfin.uclinux.org/
  *
@@ -41,13 +41,16 @@ MODULE_LICENSE("GPL");
 #define RUNNING_STATE   ((void *)1)
 #define DONE_STATE      ((void *)2)
 #define ERROR_STATE     ((void *)-1)
-#define QUEUE_RUNNING   0
-#define QUEUE_STOPPED   1
 
-/* Value to send if no TX value is supplied */
-#define SPI_IDLE_TXVAL 0x0000
+struct bfin_spi_master_data;
 
-struct driver_data {
+struct bfin_spi_transfer_ops {
+        void (*write) (struct bfin_spi_master_data *);
+        void (*read) (struct bfin_spi_master_data *);
+        void (*duplex) (struct bfin_spi_master_data *);
+};
+
+struct bfin_spi_master_data {
         /* Driver model hookup */
         struct platform_device *pdev;
 
@@ -69,7 +72,7 @@ struct driver_data {
         spinlock_t lock;
         struct list_head queue;
         int busy;
-        int run;
+        bool running;
 
         /* Message Transfer pump */
         struct tasklet_struct pump_transfers;
@@ -77,7 +80,7 @@ struct driver_data {
         /* Current message transfer state info */
         struct spi_message *cur_msg;
         struct spi_transfer *cur_transfer;
-        struct chip_data *cur_chip;
+        struct bfin_spi_slave_data *cur_chip;
         size_t len_in_bytes;
         size_t len;
         void *tx;
@@ -92,38 +95,37 @@ struct driver_data {
         dma_addr_t rx_dma;
         dma_addr_t tx_dma;
 
+        int irq_requested;
+        int spi_irq;
+
         size_t rx_map_len;
         size_t tx_map_len;
         u8 n_bytes;
+        u16 ctrl_reg;
+        u16 flag_reg;
+
         int cs_change;
-        void (*write) (struct driver_data *);
-        void (*read) (struct driver_data *);
-        void (*duplex) (struct driver_data *);
+        const struct bfin_spi_transfer_ops *ops;
 };
 
-struct chip_data {
+struct bfin_spi_slave_data {
         u16 ctl_reg;
         u16 baud;
         u16 flag;
 
         u8 chip_select_num;
-        u8 n_bytes;
-        u8 width;               /* 0 or 1 */
         u8 enable_dma;
-        u8 bits_per_word;       /* 8 or 16 */
-        u8 cs_change_per_word;
         u16 cs_chg_udelay;      /* Some devices require > 255usec delay */
         u32 cs_gpio;
         u16 idle_tx_val;
-        void (*write) (struct driver_data *);
-        void (*read) (struct driver_data *);
-        void (*duplex) (struct driver_data *);
+        u8 pio_interrupt;       /* use spi data irq */
+        const struct bfin_spi_transfer_ops *ops;
 };
 
 #define DEFINE_SPI_REG(reg, off) \
-static inline u16 read_##reg(struct driver_data *drv_data) \
+static inline u16 read_##reg(struct bfin_spi_master_data *drv_data) \
         { return bfin_read16(drv_data->regs_base + off); } \
-static inline void write_##reg(struct driver_data *drv_data, u16 v) \
+static inline void write_##reg(struct bfin_spi_master_data *drv_data, u16 v) \
         { bfin_write16(drv_data->regs_base + off, v); }
 
 DEFINE_SPI_REG(CTRL, 0x00)
@@ -134,7 +136,7 @@ DEFINE_SPI_REG(RDBR, 0x10)
 DEFINE_SPI_REG(BAUD, 0x14)
 DEFINE_SPI_REG(SHAW, 0x18)
 
-static void bfin_spi_enable(struct driver_data *drv_data)
+static void bfin_spi_enable(struct bfin_spi_master_data *drv_data)
 {
         u16 cr;
 
@@ -142,7 +144,7 @@ static void bfin_spi_enable(struct driver_data *drv_data)
         write_CTRL(drv_data, (cr | BIT_CTL_ENABLE));
 }
 
-static void bfin_spi_disable(struct driver_data *drv_data)
+static void bfin_spi_disable(struct bfin_spi_master_data *drv_data)
 {
         u16 cr;
 
@@ -165,7 +167,7 @@ static u16 hz_to_spi_baud(u32 speed_hz)
         return spi_baud;
 }
 
-static int bfin_spi_flush(struct driver_data *drv_data)
+static int bfin_spi_flush(struct bfin_spi_master_data *drv_data)
 {
         unsigned long limit = loops_per_jiffy << 1;
 
@@ -179,13 +181,12 @@ static int bfin_spi_flush(struct driver_data *drv_data)
 }
 
 /* Chip select operation functions for cs_change flag */
-static void bfin_spi_cs_active(struct driver_data *drv_data, struct chip_data *chip)
+static void bfin_spi_cs_active(struct bfin_spi_master_data *drv_data, struct bfin_spi_slave_data *chip)
 {
-        if (likely(chip->chip_select_num)) {
+        if (likely(chip->chip_select_num < MAX_CTRL_CS)) {
                 u16 flag = read_FLAG(drv_data);
 
-                flag |= chip->flag;
-                flag &= ~(chip->flag << 8);
+                flag &= ~chip->flag;
 
                 write_FLAG(drv_data, flag);
         } else {
@@ -193,13 +194,13 @@ static void bfin_spi_cs_active(struct driver_data *drv_data, struct chip_data *c
         }
 }
 
-static void bfin_spi_cs_deactive(struct driver_data *drv_data, struct chip_data *chip)
+static void bfin_spi_cs_deactive(struct bfin_spi_master_data *drv_data,
+                                 struct bfin_spi_slave_data *chip)
 {
-        if (likely(chip->chip_select_num)) {
+        if (likely(chip->chip_select_num < MAX_CTRL_CS)) {
                 u16 flag = read_FLAG(drv_data);
 
-                flag &= ~chip->flag;
-                flag |= (chip->flag << 8);
+                flag |= chip->flag;
 
                 write_FLAG(drv_data, flag);
         } else {
@@ -211,16 +212,43 @@ static void bfin_spi_cs_deactive(struct driver_data *drv_data, struct chip_data
                 udelay(chip->cs_chg_udelay);
 }
 
+/* enable or disable the pin muxed by GPIO and SPI CS to work as SPI CS */
+static inline void bfin_spi_cs_enable(struct bfin_spi_master_data *drv_data,
+                                      struct bfin_spi_slave_data *chip)
+{
+        if (chip->chip_select_num < MAX_CTRL_CS) {
+                u16 flag = read_FLAG(drv_data);
+
+                flag |= (chip->flag >> 8);
+
+                write_FLAG(drv_data, flag);
+        }
+}
+
+static inline void bfin_spi_cs_disable(struct bfin_spi_master_data *drv_data,
+                                       struct bfin_spi_slave_data *chip)
+{
+        if (chip->chip_select_num < MAX_CTRL_CS) {
+                u16 flag = read_FLAG(drv_data);
+
+                flag &= ~(chip->flag >> 8);
+
+                write_FLAG(drv_data, flag);
+        }
+}
+
 /* stop controller and re-config current chip*/
-static void bfin_spi_restore_state(struct driver_data *drv_data)
+static void bfin_spi_restore_state(struct bfin_spi_master_data *drv_data)
 {
-        struct chip_data *chip = drv_data->cur_chip;
+        struct bfin_spi_slave_data *chip = drv_data->cur_chip;
 
         /* Clear status and disable clock */
         write_STAT(drv_data, BIT_STAT_CLR);
         bfin_spi_disable(drv_data);
         dev_dbg(&drv_data->pdev->dev, "restoring spi ctl state\n");
 
+        SSYNC();
+
         /* Load the registers */
         write_CTRL(drv_data, chip->ctl_reg);
         write_BAUD(drv_data, chip->baud);
@@ -230,49 +258,12 @@ static void bfin_spi_restore_state(struct driver_data *drv_data)
 }
 
 /* used to kick off transfer in rx mode and read unwanted RX data */
-static inline void bfin_spi_dummy_read(struct driver_data *drv_data)
+static inline void bfin_spi_dummy_read(struct bfin_spi_master_data *drv_data)
 {
         (void) read_RDBR(drv_data);
 }
 
-static void bfin_spi_null_writer(struct driver_data *drv_data)
-{
-        u8 n_bytes = drv_data->n_bytes;
-        u16 tx_val = drv_data->cur_chip->idle_tx_val;
-
-        /* clear RXS (we check for RXS inside the loop) */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->tx < drv_data->tx_end) {
-                write_TDBR(drv_data, tx_val);
-                drv_data->tx += n_bytes;
-                /* wait until transfer finished.
-                   checking SPIF or TXS may not guarantee transfer completion */
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                /* discard RX data and clear RXS */
-                bfin_spi_dummy_read(drv_data);
-        }
-}
-
-static void bfin_spi_null_reader(struct driver_data *drv_data)
-{
-        u8 n_bytes = drv_data->n_bytes;
-        u16 tx_val = drv_data->cur_chip->idle_tx_val;
-
-        /* discard old RX data and clear RXS */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->rx < drv_data->rx_end) {
-                write_TDBR(drv_data, tx_val);
-                drv_data->rx += n_bytes;
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                bfin_spi_dummy_read(drv_data);
-        }
-}
-
-static void bfin_spi_u8_writer(struct driver_data *drv_data)
+static void bfin_spi_u8_writer(struct bfin_spi_master_data *drv_data)
 {
         /* clear RXS (we check for RXS inside the loop) */
         bfin_spi_dummy_read(drv_data);
@@ -288,25 +279,7 @@ static void bfin_spi_u8_writer(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u8_cs_chg_writer(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-
-        /* clear RXS (we check for RXS inside the loop) */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->tx < drv_data->tx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, (*(u8 *) (drv_data->tx++)));
-                /* make sure transfer finished before deactiving CS */
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                bfin_spi_dummy_read(drv_data);
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
-
-static void bfin_spi_u8_reader(struct driver_data *drv_data)
+static void bfin_spi_u8_reader(struct bfin_spi_master_data *drv_data)
 {
         u16 tx_val = drv_data->cur_chip->idle_tx_val;
 
@@ -321,25 +294,7 @@ static void bfin_spi_u8_reader(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u8_cs_chg_reader(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-        u16 tx_val = chip->idle_tx_val;
-
-        /* discard old RX data and clear RXS */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->rx < drv_data->rx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, tx_val);
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                *(u8 *) (drv_data->rx++) = read_RDBR(drv_data);
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
-
-static void bfin_spi_u8_duplex(struct driver_data *drv_data)
+static void bfin_spi_u8_duplex(struct bfin_spi_master_data *drv_data)
 {
         /* discard old RX data and clear RXS */
         bfin_spi_dummy_read(drv_data);
@@ -352,24 +307,13 @@ static void bfin_spi_u8_duplex(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u8_cs_chg_duplex(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-
-        /* discard old RX data and clear RXS */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->rx < drv_data->rx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, (*(u8 *) (drv_data->tx++)));
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                *(u8 *) (drv_data->rx++) = read_RDBR(drv_data);
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
+static const struct bfin_spi_transfer_ops bfin_bfin_spi_transfer_ops_u8 = {
+        .write  = bfin_spi_u8_writer,
+        .read   = bfin_spi_u8_reader,
+        .duplex = bfin_spi_u8_duplex,
+};
 
-static void bfin_spi_u16_writer(struct driver_data *drv_data)
+static void bfin_spi_u16_writer(struct bfin_spi_master_data *drv_data)
 {
         /* clear RXS (we check for RXS inside the loop) */
         bfin_spi_dummy_read(drv_data);
@@ -386,26 +330,7 @@ static void bfin_spi_u16_writer(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u16_cs_chg_writer(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-
-        /* clear RXS (we check for RXS inside the loop) */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->tx < drv_data->tx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
-                drv_data->tx += 2;
-                /* make sure transfer finished before deactiving CS */
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                bfin_spi_dummy_read(drv_data);
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
-
-static void bfin_spi_u16_reader(struct driver_data *drv_data)
+static void bfin_spi_u16_reader(struct bfin_spi_master_data *drv_data)
 {
         u16 tx_val = drv_data->cur_chip->idle_tx_val;
 
@@ -421,26 +346,7 @@ static void bfin_spi_u16_reader(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u16_cs_chg_reader(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-        u16 tx_val = chip->idle_tx_val;
-
-        /* discard old RX data and clear RXS */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->rx < drv_data->rx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, tx_val);
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
-                drv_data->rx += 2;
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
-
-static void bfin_spi_u16_duplex(struct driver_data *drv_data)
+static void bfin_spi_u16_duplex(struct bfin_spi_master_data *drv_data)
 {
         /* discard old RX data and clear RXS */
         bfin_spi_dummy_read(drv_data);
@@ -455,27 +361,14 @@ static void bfin_spi_u16_duplex(struct driver_data *drv_data)
         }
 }
 
-static void bfin_spi_u16_cs_chg_duplex(struct driver_data *drv_data)
-{
-        struct chip_data *chip = drv_data->cur_chip;
-
-        /* discard old RX data and clear RXS */
-        bfin_spi_dummy_read(drv_data);
-
-        while (drv_data->rx < drv_data->rx_end) {
-                bfin_spi_cs_active(drv_data, chip);
-                write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
-                drv_data->tx += 2;
-                while (!(read_STAT(drv_data) & BIT_STAT_RXS))
-                        cpu_relax();
-                *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
-                drv_data->rx += 2;
-                bfin_spi_cs_deactive(drv_data, chip);
-        }
-}
+static const struct bfin_spi_transfer_ops bfin_bfin_spi_transfer_ops_u16 = {
+        .write  = bfin_spi_u16_writer,
+        .read   = bfin_spi_u16_reader,
+        .duplex = bfin_spi_u16_duplex,
+};
 
-/* test if ther is more transfer to be done */
-static void *bfin_spi_next_transfer(struct driver_data *drv_data)
+/* test if there is more transfer to be done */
+static void *bfin_spi_next_transfer(struct bfin_spi_master_data *drv_data)
 {
         struct spi_message *msg = drv_data->cur_msg;
         struct spi_transfer *trans = drv_data->cur_transfer;
@@ -494,9 +387,9 @@ static void *bfin_spi_next_transfer(struct driver_data *drv_data)
  * caller already set message->status;
  * dma and pio irqs are blocked give finished message back
  */
-static void bfin_spi_giveback(struct driver_data *drv_data)
+static void bfin_spi_giveback(struct bfin_spi_master_data *drv_data)
 {
-        struct chip_data *chip = drv_data->cur_chip;
+        struct bfin_spi_slave_data *chip = drv_data->cur_chip;
         struct spi_transfer *last_transfer;
         unsigned long flags;
         struct spi_message *msg;
@@ -525,10 +418,83 @@ static void bfin_spi_giveback(struct driver_data *drv_data)
                 msg->complete(msg->context);
 }
 
+/* spi data irq handler */
+static irqreturn_t bfin_spi_pio_irq_handler(int irq, void *dev_id)
+{
+        struct bfin_spi_master_data *drv_data = dev_id;
+        struct bfin_spi_slave_data *chip = drv_data->cur_chip;
+        struct spi_message *msg = drv_data->cur_msg;
+        int n_bytes = drv_data->n_bytes;
+
+        /* wait until transfer finished. */
+        while (!(read_STAT(drv_data) & BIT_STAT_RXS))
+                cpu_relax();
+
+        if ((drv_data->tx && drv_data->tx >= drv_data->tx_end) ||
+                (drv_data->rx && drv_data->rx >= (drv_data->rx_end - n_bytes))) {
+                /* last read */
+                if (drv_data->rx) {
+                        dev_dbg(&drv_data->pdev->dev, "last read\n");
+                        if (n_bytes == 2)
+                                *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
+                        else if (n_bytes == 1)
+                                *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
+                        drv_data->rx += n_bytes;
+                }
+
+                msg->actual_length += drv_data->len_in_bytes;
+                if (drv_data->cs_change)
+                        bfin_spi_cs_deactive(drv_data, chip);
+                /* Move to next transfer */
+                msg->state = bfin_spi_next_transfer(drv_data);
+
+                disable_irq_nosync(drv_data->spi_irq);
+
+                /* Schedule transfer tasklet */
+                tasklet_schedule(&drv_data->pump_transfers);
+                return IRQ_HANDLED;
+        }
+
+        if (drv_data->rx && drv_data->tx) {
+                /* duplex */
+                dev_dbg(&drv_data->pdev->dev, "duplex: write_TDBR\n");
+                if (drv_data->n_bytes == 2) {
+                        *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
+                        write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
+                } else if (drv_data->n_bytes == 1) {
+                        *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
+                        write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
+                }
+        } else if (drv_data->rx) {
+                /* read */
+                dev_dbg(&drv_data->pdev->dev, "read: write_TDBR\n");
+                if (drv_data->n_bytes == 2)
+                        *(u16 *) (drv_data->rx) = read_RDBR(drv_data);
+                else if (drv_data->n_bytes == 1)
+                        *(u8 *) (drv_data->rx) = read_RDBR(drv_data);
+                write_TDBR(drv_data, chip->idle_tx_val);
+        } else if (drv_data->tx) {
+                /* write */
+                dev_dbg(&drv_data->pdev->dev, "write: write_TDBR\n");
+                bfin_spi_dummy_read(drv_data);
+                if (drv_data->n_bytes == 2)
+                        write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
+                else if (drv_data->n_bytes == 1)
+                        write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
+        }
+
+        if (drv_data->tx)
+                drv_data->tx += n_bytes;
+        if (drv_data->rx)
+                drv_data->rx += n_bytes;
+
+        return IRQ_HANDLED;
+}
+
 static irqreturn_t bfin_spi_dma_irq_handler(int irq, void *dev_id)
 {
-        struct driver_data *drv_data = dev_id;
-        struct chip_data *chip = drv_data->cur_chip;
+        struct bfin_spi_master_data *drv_data = dev_id;
+        struct bfin_spi_slave_data *chip = drv_data->cur_chip;
         struct spi_message *msg = drv_data->cur_msg;
         unsigned long timeout;
         unsigned short dmastat = get_dma_curr_irqstat(drv_data->dma_channel);
@@ -540,10 +506,6 @@ static irqreturn_t bfin_spi_dma_irq_handler(int irq, void *dev_id)
 
         clear_dma_irqstat(drv_data->dma_channel);
 
-        /* Wait for DMA to complete */
-        while (get_dma_curr_irqstat(drv_data->dma_channel) & DMA_RUN)
-                cpu_relax();
-
         /*
          * wait for the last transaction shifted out.  HRM states:
          * at this point there may still be data in the SPI DMA FIFO waiting
@@ -551,8 +513,8 @@ static irqreturn_t bfin_spi_dma_irq_handler(int irq, void *dev_id)
          * register until it goes low for 2 successive reads
          */
         if (drv_data->tx != NULL) {
-                while ((read_STAT(drv_data) & TXS) ||
-                       (read_STAT(drv_data) & TXS))
+                while ((read_STAT(drv_data) & BIT_STAT_TXS) ||
+                       (read_STAT(drv_data) & BIT_STAT_TXS))
                         cpu_relax();
         }
 
@@ -561,14 +523,14 @@ static irqreturn_t bfin_spi_dma_irq_handler(int irq, void *dev_id)
                 dmastat, read_STAT(drv_data));
 
         timeout = jiffies + HZ;
-        while (!(read_STAT(drv_data) & SPIF))
+        while (!(read_STAT(drv_data) & BIT_STAT_SPIF))
                 if (!time_before(jiffies, timeout)) {
                         dev_warn(&drv_data->pdev->dev, "timeout waiting for SPIF");
                         break;
                 } else
                         cpu_relax();
 
-        if ((dmastat & DMA_ERR) && (spistat & RBSY)) {
+        if ((dmastat & DMA_ERR) && (spistat & BIT_STAT_RBSY)) {
                 msg->state = ERROR_STATE;
                 dev_err(&drv_data->pdev->dev, "dma receive: fifo/buffer overflow\n");
         } else {
@@ -588,20 +550,20 @@ static irqreturn_t bfin_spi_dma_irq_handler(int irq, void *dev_id)
         dev_dbg(&drv_data->pdev->dev,
                 "disable dma channel irq%d\n",
                 drv_data->dma_channel);
-        dma_disable_irq(drv_data->dma_channel);
+        dma_disable_irq_nosync(drv_data->dma_channel);
 
         return IRQ_HANDLED;
 }
 
 static void bfin_spi_pump_transfers(unsigned long data)
 {
-        struct driver_data *drv_data = (struct driver_data *)data;
+        struct bfin_spi_master_data *drv_data = (struct bfin_spi_master_data *)data;
         struct spi_message *message = NULL;
         struct spi_transfer *transfer = NULL;
         struct spi_transfer *previous = NULL;
-        struct chip_data *chip = NULL;
-        u8 width;
-        u16 cr, dma_width, dma_config;
+        struct bfin_spi_slave_data *chip = NULL;
+        unsigned int bits_per_word;
+        u16 cr, cr_width, dma_width, dma_config;
         u32 tranf_success = 1;
         u8 full_duplex = 0;
 
@@ -639,7 +601,7 @@ static void bfin_spi_pump_transfers(unsigned long data)
                         udelay(previous->delay_usecs);
         }
 
-        /* Setup the transfer state based on the type of transfer */
+        /* Flush any existing transfers that may be sitting in the hardware */
         if (bfin_spi_flush(drv_data) == 0) {
                 dev_err(&drv_data->pdev->dev, "pump_transfers: flush failed\n");
                 message->status = -EIO;
@@ -679,52 +641,31 @@ static void bfin_spi_pump_transfers(unsigned long data)
         drv_data->cs_change = transfer->cs_change;
 
         /* Bits per word setup */
-        switch (transfer->bits_per_word) {
-        case 8:
+        bits_per_word = transfer->bits_per_word ? : message->spi->bits_per_word;
+        if (bits_per_word == 8) {
                 drv_data->n_bytes = 1;
-                width = CFG_SPI_WORDSIZE8;
-                drv_data->read = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_reader : bfin_spi_u8_reader;
-                drv_data->write = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_writer : bfin_spi_u8_writer;
-                drv_data->duplex = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_duplex : bfin_spi_u8_duplex;
-                break;
-
-        case 16:
+                drv_data->len = transfer->len;
+                cr_width = 0;
+                drv_data->ops = &bfin_bfin_spi_transfer_ops_u8;
+        } else if (bits_per_word == 16) {
                 drv_data->n_bytes = 2;
-                width = CFG_SPI_WORDSIZE16;
-                drv_data->read = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_reader : bfin_spi_u16_reader;
-                drv_data->write = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_writer : bfin_spi_u16_writer;
-                drv_data->duplex = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_duplex : bfin_spi_u16_duplex;
-                break;
-
-        default:
-                /* No change, the same as default setting */
-                drv_data->n_bytes = chip->n_bytes;
-                width = chip->width;
-                drv_data->write = drv_data->tx ? chip->write : bfin_spi_null_writer;
-                drv_data->read = drv_data->rx ? chip->read : bfin_spi_null_reader;
-                drv_data->duplex = chip->duplex ? chip->duplex : bfin_spi_null_writer;
-                break;
-        }
-        cr = (read_CTRL(drv_data) & (~BIT_CTL_TIMOD));
-        cr |= (width << 8);
-        write_CTRL(drv_data, cr);
-
-        if (width == CFG_SPI_WORDSIZE16) {
                 drv_data->len = (transfer->len) >> 1;
+                cr_width = BIT_CTL_WORDSIZE;
+                drv_data->ops = &bfin_bfin_spi_transfer_ops_u16;
         } else {
-                drv_data->len = transfer->len;
+                dev_err(&drv_data->pdev->dev, "transfer: unsupported bits_per_word\n");
+                message->status = -EINVAL;
+                bfin_spi_giveback(drv_data);
+                return;
         }
+        cr = read_CTRL(drv_data) & ~(BIT_CTL_TIMOD | BIT_CTL_WORDSIZE);
+        cr |= cr_width;
+        write_CTRL(drv_data, cr);
+
         dev_dbg(&drv_data->pdev->dev,
-                "transfer: drv_data->write is %p, chip->write is %p, null_wr is %p\n",
-                drv_data->write, chip->write, bfin_spi_null_writer);
+                "transfer: drv_data->ops is %p, chip->ops is %p, u8_ops is %p\n",
+                drv_data->ops, chip->ops, &bfin_bfin_spi_transfer_ops_u8);
 
-        /* speed and width has been set on per message */
         message->state = RUNNING_STATE;
         dma_config = 0;
 
@@ -735,13 +676,11 @@ static void bfin_spi_pump_transfers(unsigned long data)
                 write_BAUD(drv_data, chip->baud);
 
         write_STAT(drv_data, BIT_STAT_CLR);
-        cr = (read_CTRL(drv_data) & (~BIT_CTL_TIMOD));
-        if (drv_data->cs_change)
-                bfin_spi_cs_active(drv_data, chip);
+        bfin_spi_cs_active(drv_data, chip);
 
         dev_dbg(&drv_data->pdev->dev,
                 "now pumping a transfer: width is %d, len is %d\n",
-                width, transfer->len);
+                cr_width, transfer->len);
 
         /*
          * Try to map dma buffer and do a dma transfer.  If successful use,
@@ -760,7 +699,7 @@ static void bfin_spi_pump_transfers(unsigned long data)
                 /* config dma channel */
                 dev_dbg(&drv_data->pdev->dev, "doing dma transfer\n");
                 set_dma_x_count(drv_data->dma_channel, drv_data->len);
-                if (width == CFG_SPI_WORDSIZE16) {
+                if (cr_width == BIT_CTL_WORDSIZE) {
                         set_dma_x_modify(drv_data->dma_channel, 2);
                         dma_width = WDSIZE_16;
                 } else {
@@ -846,73 +785,100 @@ static void bfin_spi_pump_transfers(unsigned long data)
                 dma_enable_irq(drv_data->dma_channel);
                 local_irq_restore(flags);
 
-        } else {
-                /* IO mode write then read */
-                dev_dbg(&drv_data->pdev->dev, "doing IO transfer\n");
-
-                /* we always use SPI_WRITE mode. SPI_READ mode
-                   seems to have problems with setting up the
-                   output value in TDBR prior to the transfer. */
-                write_CTRL(drv_data, (cr | CFG_SPI_WRITE));
-
-                if (full_duplex) {
-                        /* full duplex mode */
-                        BUG_ON((drv_data->tx_end - drv_data->tx) !=
-                               (drv_data->rx_end - drv_data->rx));
-                        dev_dbg(&drv_data->pdev->dev,
-                                "IO duplex: cr is 0x%x\n", cr);
-
-                        drv_data->duplex(drv_data);
+                return;
+        }
 
-                        if (drv_data->tx != drv_data->tx_end)
-                                tranf_success = 0;
-                } else if (drv_data->tx != NULL) {
-                        /* write only half duplex */
-                        dev_dbg(&drv_data->pdev->dev,
-                                "IO write: cr is 0x%x\n", cr);
+        /*
+         * We always use SPI_WRITE mode (transfer starts with TDBR write).
+         * SPI_READ mode (transfer starts with RDBR read) seems to have
+         * problems with setting up the output value in TDBR prior to the
+         * start of the transfer.
+         */
+        write_CTRL(drv_data, cr | BIT_CTL_TXMOD);
 
-                        drv_data->write(drv_data);
+        if (chip->pio_interrupt) {
+                /* SPI irq should have been disabled by now */
 
-                        if (drv_data->tx != drv_data->tx_end)
-                                tranf_success = 0;
-                } else if (drv_data->rx != NULL) {
-                        /* read only half duplex */
-                        dev_dbg(&drv_data->pdev->dev,
-                                "IO read: cr is 0x%x\n", cr);
+                /* discard old RX data and clear RXS */
+                bfin_spi_dummy_read(drv_data);
 
-                        drv_data->read(drv_data);
-                        if (drv_data->rx != drv_data->rx_end)
-                                tranf_success = 0;
+                /* start transfer */
+                if (drv_data->tx == NULL)
+                        write_TDBR(drv_data, chip->idle_tx_val);
+                else {
+                        if (bits_per_word == 8)
+                                write_TDBR(drv_data, (*(u8 *) (drv_data->tx)));
+                        else
+                                write_TDBR(drv_data, (*(u16 *) (drv_data->tx)));
+                        drv_data->tx += drv_data->n_bytes;
                 }
 
-                if (!tranf_success) {
-                        dev_dbg(&drv_data->pdev->dev,
-                                "IO write error!\n");
-                        message->state = ERROR_STATE;
-                } else {
-                        /* Update total byte transfered */
-                        message->actual_length += drv_data->len_in_bytes;
-                        /* Move to next transfer of this msg */
-                        message->state = bfin_spi_next_transfer(drv_data);
-                        if (drv_data->cs_change)
-                                bfin_spi_cs_deactive(drv_data, chip);
-                }
-                /* Schedule next transfer tasklet */
-                tasklet_schedule(&drv_data->pump_transfers);
+                /* once TDBR is empty, interrupt is triggered */
+                enable_irq(drv_data->spi_irq);
+                return;
+        }
+
+        /* IO mode */
+        dev_dbg(&drv_data->pdev->dev, "doing IO transfer\n");
+
+        if (full_duplex) {
+                /* full duplex mode */
+                BUG_ON((drv_data->tx_end - drv_data->tx) !=
+                       (drv_data->rx_end - drv_data->rx));
+                dev_dbg(&drv_data->pdev->dev,
+                        "IO duplex: cr is 0x%x\n", cr);
+
+                drv_data->ops->duplex(drv_data);
+
+                if (drv_data->tx != drv_data->tx_end)
+                        tranf_success = 0;
+        } else if (drv_data->tx != NULL) {
+                /* write only half duplex */
+                dev_dbg(&drv_data->pdev->dev,
+                        "IO write: cr is 0x%x\n", cr);
+
+                drv_data->ops->write(drv_data);
+
+                if (drv_data->tx != drv_data->tx_end)
+                        tranf_success = 0;
+        } else if (drv_data->rx != NULL) {
+                /* read only half duplex */
+                dev_dbg(&drv_data->pdev->dev,
+                        "IO read: cr is 0x%x\n", cr);
+
+                drv_data->ops->read(drv_data);
+                if (drv_data->rx != drv_data->rx_end)
+                        tranf_success = 0;
+        }
+
+        if (!tranf_success) {
+                dev_dbg(&drv_data->pdev->dev,
+                        "IO write error!\n");
+                message->state = ERROR_STATE;
+        } else {
+                /* Update total byte transfered */
+                message->actual_length += drv_data->len_in_bytes;
+                /* Move to next transfer of this msg */
+                message->state = bfin_spi_next_transfer(drv_data);
+                if (drv_data->cs_change)
+                        bfin_spi_cs_deactive(drv_data, chip);
         }
+
+        /* Schedule next transfer tasklet */
+        tasklet_schedule(&drv_data->pump_transfers);
 }
 
 /* pop a msg from queue and kick off real transfer */
 static void bfin_spi_pump_messages(struct work_struct *work)
 {
-        struct driver_data *drv_data;
+        struct bfin_spi_master_data *drv_data;
         unsigned long flags;
 
-        drv_data = container_of(work, struct driver_data, pump_messages);
+        drv_data = container_of(work, struct bfin_spi_master_data, pump_messages);
 
         /* Lock queue and check for queue work */
         spin_lock_irqsave(&drv_data->lock, flags);
-        if (list_empty(&drv_data->queue) || drv_data->run == QUEUE_STOPPED) {
+        if (list_empty(&drv_data->queue) || !drv_data->running) {
                 /* pumper kicked off but no work to do */
                 drv_data->busy = 0;
                 spin_unlock_irqrestore(&drv_data->lock, flags);
@@ -962,12 +928,12 @@ static void bfin_spi_pump_messages(struct work_struct *work)
  */
 static int bfin_spi_transfer(struct spi_device *spi, struct spi_message *msg)
 {
-        struct driver_data *drv_data = spi_master_get_devdata(spi->master);
+        struct bfin_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
         unsigned long flags;
 
         spin_lock_irqsave(&drv_data->lock, flags);
 
-        if (drv_data->run == QUEUE_STOPPED) {
+        if (!drv_data->running) {
                 spin_unlock_irqrestore(&drv_data->lock, flags);
                 return -ESHUTDOWN;
         }
@@ -979,7 +945,7 @@ static int bfin_spi_transfer(struct spi_device *spi, struct spi_message *msg)
         dev_dbg(&spi->dev, "adding an msg in transfer() \n");
         list_add_tail(&msg->queue, &drv_data->queue);
 
-        if (drv_data->run == QUEUE_RUNNING && !drv_data->busy)
+        if (drv_data->running && !drv_data->busy)
                 queue_work(drv_data->workqueue, &drv_data->pump_messages);
 
         spin_unlock_irqrestore(&drv_data->lock, flags);
@@ -1003,147 +969,184 @@ static u16 ssel[][MAX_SPI_SSEL] = {
         P_SPI2_SSEL6, P_SPI2_SSEL7},
 };
 
-/* first setup for new devices */
+/* setup for devices (may be called multiple times -- not just first setup) */
 static int bfin_spi_setup(struct spi_device *spi)
 {
-        struct bfin5xx_spi_chip *chip_info = NULL;
-        struct chip_data *chip;
-        struct driver_data *drv_data = spi_master_get_devdata(spi->master);
-        int ret;
-
-        if (spi->bits_per_word != 8 && spi->bits_per_word != 16)
-                return -EINVAL;
+        struct bfin5xx_spi_chip *chip_info;
+        struct bfin_spi_slave_data *chip = NULL;
+        struct bfin_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
+        u16 bfin_ctl_reg;
+        int ret = -EINVAL;
 
         /* Only alloc (or use chip_info) on first setup */
+        chip_info = NULL;
         chip = spi_get_ctldata(spi);
         if (chip == NULL) {
-                chip = kzalloc(sizeof(struct chip_data), GFP_KERNEL);
-                if (!chip)
-                        return -ENOMEM;
+                chip = kzalloc(sizeof(*chip), GFP_KERNEL);
+                if (!chip) {
+                        dev_err(&spi->dev, "cannot allocate chip data\n");
+                        ret = -ENOMEM;
+                        goto error;
+                }
 
                 chip->enable_dma = 0;
                 chip_info = spi->controller_data;
         }
 
+        /* Let people set non-standard bits directly */
+        bfin_ctl_reg = BIT_CTL_OPENDRAIN | BIT_CTL_EMISO |
+                BIT_CTL_PSSE | BIT_CTL_GM | BIT_CTL_SZ;
+
         /* chip_info isn't always needed */
         if (chip_info) {
                 /* Make sure people stop trying to set fields via ctl_reg
                  * when they should actually be using common SPI framework.
-                 * Currently we let through: WOM EMISO PSSE GM SZ TIMOD.
+                 * Currently we let through: WOM EMISO PSSE GM SZ.
                  * Not sure if a user actually needs/uses any of these,
                  * but let's assume (for now) they do.
                  */
-                if (chip_info->ctl_reg & (SPE|MSTR|CPOL|CPHA|LSBF|SIZE)) {
+                if (chip_info->ctl_reg & ~bfin_ctl_reg) {
                         dev_err(&spi->dev, "do not set bits in ctl_reg "
                                 "that the SPI framework manages\n");
-                        return -EINVAL;
+                        goto error;
                 }
-
                 chip->enable_dma = chip_info->enable_dma != 0
                     && drv_data->master_info->enable_dma;
                 chip->ctl_reg = chip_info->ctl_reg;
-                chip->bits_per_word = chip_info->bits_per_word;
-                chip->cs_change_per_word = chip_info->cs_change_per_word;
                 chip->cs_chg_udelay = chip_info->cs_chg_udelay;
-                chip->cs_gpio = chip_info->cs_gpio;
                 chip->idle_tx_val = chip_info->idle_tx_val;
+                chip->pio_interrupt = chip_info->pio_interrupt;
+                spi->bits_per_word = chip_info->bits_per_word;
+        } else {
+                /* force a default base state */
+                chip->ctl_reg &= bfin_ctl_reg;
+        }
+
+        if (spi->bits_per_word != 8 && spi->bits_per_word != 16) {
+                dev_err(&spi->dev, "%d bits_per_word is not supported\n",
+                                spi->bits_per_word);
+                goto error;
         }
 
         /* translate common spi framework into our register */
+        if (spi->mode & ~(SPI_CPOL | SPI_CPHA | SPI_LSB_FIRST)) {
+                dev_err(&spi->dev, "unsupported spi modes detected\n");
+                goto error;
+        }
         if (spi->mode & SPI_CPOL)
-                chip->ctl_reg |= CPOL;
+                chip->ctl_reg |= BIT_CTL_CPOL;
         if (spi->mode & SPI_CPHA)
-                chip->ctl_reg |= CPHA;
+                chip->ctl_reg |= BIT_CTL_CPHA;
         if (spi->mode & SPI_LSB_FIRST)
-                chip->ctl_reg |= LSBF;
+                chip->ctl_reg |= BIT_CTL_LSBF;
         /* we dont support running in slave mode (yet?) */
-        chip->ctl_reg |= MSTR;
+        chip->ctl_reg |= BIT_CTL_MASTER;
 
         /*
+         * Notice: for blackfin, the speed_hz is the value of register
+         * SPI_BAUD, not the real baudrate
+         */
+        chip->baud = hz_to_spi_baud(spi->max_speed_hz);
+        chip->chip_select_num = spi->chip_select;
+        if (chip->chip_select_num < MAX_CTRL_CS) {
+                if (!(spi->mode & SPI_CPHA))
+                        dev_warn(&spi->dev, "Warning: SPI CPHA not set:"
+                                " Slave Select not under software control!\n"
+                                " See Documentation/blackfin/bfin-spi-notes.txt");
+
+                chip->flag = (1 << spi->chip_select) << 8;
+        } else
+                chip->cs_gpio = chip->chip_select_num - MAX_CTRL_CS;
+
+        if (chip->enable_dma && chip->pio_interrupt) {
+                dev_err(&spi->dev, "enable_dma is set, "
+                                "do not set pio_interrupt\n");
+                goto error;
+        }
+        /*
          * if any one SPI chip is registered and wants DMA, request the
          * DMA channel for it
          */
         if (chip->enable_dma && !drv_data->dma_requested) {
                 /* register dma irq handler */
-                if (request_dma(drv_data->dma_channel, "BFIN_SPI_DMA") < 0) {
-                        dev_dbg(&spi->dev,
+                ret = request_dma(drv_data->dma_channel, "BFIN_SPI_DMA");
+                if (ret) {
+                        dev_err(&spi->dev,
                                 "Unable to request BlackFin SPI DMA channel\n");
-                        return -ENODEV;
+                        goto error;
                 }
-                if (set_dma_callback(drv_data->dma_channel,
-                    bfin_spi_dma_irq_handler, drv_data) < 0) {
-                        dev_dbg(&spi->dev, "Unable to set dma callback\n");
-                        return -EPERM;
+                drv_data->dma_requested = 1;
+
+                ret = set_dma_callback(drv_data->dma_channel,
+                        bfin_spi_dma_irq_handler, drv_data);
+                if (ret) {
+                        dev_err(&spi->dev, "Unable to set dma callback\n");
+                        goto error;
                 }
                 dma_disable_irq(drv_data->dma_channel);
-                drv_data->dma_requested = 1;
         }
 
-        /*
-         * Notice: for blackfin, the speed_hz is the value of register
-         * SPI_BAUD, not the real baudrate
-         */
-        chip->baud = hz_to_spi_baud(spi->max_speed_hz);
-        chip->flag = 1 << (spi->chip_select);
-        chip->chip_select_num = spi->chip_select;
+        if (chip->pio_interrupt && !drv_data->irq_requested) {
+                ret = request_irq(drv_data->spi_irq, bfin_spi_pio_irq_handler,
+                        IRQF_DISABLED, "BFIN_SPI", drv_data);
+                if (ret) {
+                        dev_err(&spi->dev, "Unable to register spi IRQ\n");
+                        goto error;
+                }
+                drv_data->irq_requested = 1;
+                /* we use write mode, spi irq has to be disabled here */
+                disable_irq(drv_data->spi_irq);
+        }
 
-        if (chip->chip_select_num == 0) {
+        if (chip->chip_select_num >= MAX_CTRL_CS) {
                 ret = gpio_request(chip->cs_gpio, spi->modalias);
                 if (ret) {
-                        if (drv_data->dma_requested)
-                                free_dma(drv_data->dma_channel);
-                        return ret;
+                        dev_err(&spi->dev, "gpio_request() error\n");
+                        goto pin_error;
                 }
                 gpio_direction_output(chip->cs_gpio, 1);
         }
 
-        switch (chip->bits_per_word) {
-        case 8:
-                chip->n_bytes = 1;
-                chip->width = CFG_SPI_WORDSIZE8;
-                chip->read = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_reader : bfin_spi_u8_reader;
-                chip->write = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_writer : bfin_spi_u8_writer;
-                chip->duplex = chip->cs_change_per_word ?
-                        bfin_spi_u8_cs_chg_duplex : bfin_spi_u8_duplex;
-                break;
-
-        case 16:
-                chip->n_bytes = 2;
-                chip->width = CFG_SPI_WORDSIZE16;
-                chip->read = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_reader : bfin_spi_u16_reader;
-                chip->write = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_writer : bfin_spi_u16_writer;
-                chip->duplex = chip->cs_change_per_word ?
-                        bfin_spi_u16_cs_chg_duplex : bfin_spi_u16_duplex;
-                break;
-
-        default:
-                dev_err(&spi->dev, "%d bits_per_word is not supported\n",
-                                chip->bits_per_word);
-                if (chip_info)
-                        kfree(chip);
-                return -ENODEV;
-        }
-
         dev_dbg(&spi->dev, "setup spi chip %s, width is %d, dma is %d\n",
-                        spi->modalias, chip->width, chip->enable_dma);
+                        spi->modalias, spi->bits_per_word, chip->enable_dma);
         dev_dbg(&spi->dev, "ctl_reg is 0x%x, flag_reg is 0x%x\n",
                         chip->ctl_reg, chip->flag);
 
         spi_set_ctldata(spi, chip);
 
         dev_dbg(&spi->dev, "chip select number is %d\n", chip->chip_select_num);
-        if ((chip->chip_select_num > 0)
-                && (chip->chip_select_num <= spi->master->num_chipselect))
-                peripheral_request(ssel[spi->master->bus_num]
-                        [chip->chip_select_num-1], spi->modalias);
+        if (chip->chip_select_num < MAX_CTRL_CS) {
+                ret = peripheral_request(ssel[spi->master->bus_num]
+                                         [chip->chip_select_num-1], spi->modalias);
+                if (ret) {
+                        dev_err(&spi->dev, "peripheral_request() error\n");
+                        goto pin_error;
+                }
+        }
 
+        bfin_spi_cs_enable(drv_data, chip);
         bfin_spi_cs_deactive(drv_data, chip);
 
         return 0;
+
+ pin_error:
+        if (chip->chip_select_num >= MAX_CTRL_CS)
+                gpio_free(chip->cs_gpio);
+        else
+                peripheral_free(ssel[spi->master->bus_num]
+                        [chip->chip_select_num - 1]);
+ error:
+        if (chip) {
+                if (drv_data->dma_requested)
+                        free_dma(drv_data->dma_channel);
+                drv_data->dma_requested = 0;
+
+                kfree(chip);
+                /* prevent free 'chip' twice */
+                spi_set_ctldata(spi, NULL);
+        }
+
+        return ret;
 }
 
 /*
@@ -1152,28 +1155,30 @@ static int bfin_spi_setup(struct spi_device *spi)
  */
 static void bfin_spi_cleanup(struct spi_device *spi)
 {
-        struct chip_data *chip = spi_get_ctldata(spi);
+        struct bfin_spi_slave_data *chip = spi_get_ctldata(spi);
+        struct bfin_spi_master_data *drv_data = spi_master_get_devdata(spi->master);
 
         if (!chip)
                 return;
 
-        if ((chip->chip_select_num > 0)
-                && (chip->chip_select_num <= spi->master->num_chipselect))
+        if (chip->chip_select_num < MAX_CTRL_CS) {
                 peripheral_free(ssel[spi->master->bus_num]
                                         [chip->chip_select_num-1]);
-
-        if (chip->chip_select_num == 0)
+                bfin_spi_cs_disable(drv_data, chip);
+        } else
                 gpio_free(chip->cs_gpio);
 
         kfree(chip);
+        /* prevent free 'chip' twice */
+        spi_set_ctldata(spi, NULL);
 }
 
-static inline int bfin_spi_init_queue(struct driver_data *drv_data)
+static inline int bfin_spi_init_queue(struct bfin_spi_master_data *drv_data)
 {
         INIT_LIST_HEAD(&drv_data->queue);
         spin_lock_init(&drv_data->lock);
 
-        drv_data->run = QUEUE_STOPPED;
+        drv_data->running = false;
         drv_data->busy = 0;
 
         /* init transfer tasklet */
@@ -1190,18 +1195,18 @@ static inline int bfin_spi_init_queue(struct driver_data *drv_data)
         return 0;
 }
 
-static inline int bfin_spi_start_queue(struct driver_data *drv_data)
+static inline int bfin_spi_start_queue(struct bfin_spi_master_data *drv_data)
 {
         unsigned long flags;
 
         spin_lock_irqsave(&drv_data->lock, flags);
 
-        if (drv_data->run == QUEUE_RUNNING || drv_data->busy) {
+        if (drv_data->running || drv_data->busy) {
                 spin_unlock_irqrestore(&drv_data->lock, flags);
                 return -EBUSY;
         }
 
-        drv_data->run = QUEUE_RUNNING;
+        drv_data->running = true;
         drv_data->cur_msg = NULL;
         drv_data->cur_transfer = NULL;
         drv_data->cur_chip = NULL;
@@ -1212,7 +1217,7 @@ static inline int bfin_spi_start_queue(struct driver_data *drv_data)
         return 0;
 }
 
-static inline int bfin_spi_stop_queue(struct driver_data *drv_data)
+static inline int bfin_spi_stop_queue(struct bfin_spi_master_data *drv_data)
 {
         unsigned long flags;
         unsigned limit = 500;
@@ -1226,7 +1231,7 @@ static inline int bfin_spi_stop_queue(struct driver_data *drv_data)
          * execution path (pump_messages) would be required to call wake_up or
          * friends on every SPI message. Do this instead
          */
-        drv_data->run = QUEUE_STOPPED;
+        drv_data->running = false;
         while (!list_empty(&drv_data->queue) && drv_data->busy && limit--) {
                 spin_unlock_irqrestore(&drv_data->lock, flags);
                 msleep(10);
@@ -1241,7 +1246,7 @@ static inline int bfin_spi_stop_queue(struct driver_data *drv_data)
         return status;
 }
 
-static inline int bfin_spi_destroy_queue(struct driver_data *drv_data)
+static inline int bfin_spi_destroy_queue(struct bfin_spi_master_data *drv_data)
 {
         int status;
 
@@ -1259,14 +1264,14 @@ static int __init bfin_spi_probe(struct platform_device *pdev)
         struct device *dev = &pdev->dev;
         struct bfin5xx_spi_master *platform_info;
         struct spi_master *master;
-        struct driver_data *drv_data = 0;
+        struct bfin_spi_master_data *drv_data;
         struct resource *res;
         int status = 0;
 
         platform_info = dev->platform_data;
 
         /* Allocate master with space for drv_data */
-        master = spi_alloc_master(dev, sizeof(struct driver_data) + 16);
+        master = spi_alloc_master(dev, sizeof(*drv_data));
         if (!master) {
                 dev_err(&pdev->dev, "can not alloc spi_master\n");
                 return -ENOMEM;
@@ -1302,11 +1307,19 @@ static int __init bfin_spi_probe(struct platform_device *pdev)
                 goto out_error_ioremap;
         }
 
-        drv_data->dma_channel = platform_get_irq(pdev, 0);
-        if (drv_data->dma_channel < 0) {
+        res = platform_get_resource(pdev, IORESOURCE_DMA, 0);
+        if (res == NULL) {
                 dev_err(dev, "No DMA channel specified\n");
                 status = -ENOENT;
-                goto out_error_no_dma_ch;
+                goto out_error_free_io;
+        }
+        drv_data->dma_channel = res->start;
+
+        drv_data->spi_irq = platform_get_irq(pdev, 0);
+        if (drv_data->spi_irq < 0) {
+                dev_err(dev, "No spi pio irq specified\n");
+                status = -ENOENT;
+                goto out_error_free_io;
         }
 
         /* Initial and start queue */
@@ -1328,6 +1341,12 @@ static int __init bfin_spi_probe(struct platform_device *pdev)
                 goto out_error_queue_alloc;
         }
 
+        /* Reset SPI registers. If these registers were used by the boot loader,
+         * the sky may fall on your head if you enable the dma controller.
+         */
+        write_CTRL(drv_data, BIT_CTL_CPHA | BIT_CTL_MASTER);
+        write_FLAG(drv_data, 0xFF00);
+
         /* Register with the SPI framework */
         platform_set_drvdata(pdev, drv_data);
         status = spi_register_master(master);
@@ -1343,7 +1362,7 @@ static int __init bfin_spi_probe(struct platform_device *pdev)
 
 out_error_queue_alloc:
         bfin_spi_destroy_queue(drv_data);
-out_error_no_dma_ch:
+out_error_free_io:
         iounmap((void *) drv_data->regs_base);
 out_error_ioremap:
 out_error_get_res:
@@ -1355,7 +1374,7 @@ out_error_get_res:
 /* stop hardware and remove the driver */
 static int __devexit bfin_spi_remove(struct platform_device *pdev)
 {
-        struct driver_data *drv_data = platform_get_drvdata(pdev);
+        struct bfin_spi_master_data *drv_data = platform_get_drvdata(pdev);
         int status = 0;
 
         if (!drv_data)
@@ -1375,6 +1394,11 @@ static int __devexit bfin_spi_remove(struct platform_device *pdev)
                         free_dma(drv_data->dma_channel);
         }
 
+        if (drv_data->irq_requested) {
+                free_irq(drv_data->spi_irq, drv_data);
+                drv_data->irq_requested = 0;
+        }
+
         /* Disconnect from the SPI framework */
         spi_unregister_master(drv_data->master);
 
@@ -1389,26 +1413,32 @@ static int __devexit bfin_spi_remove(struct platform_device *pdev)
 #ifdef CONFIG_PM
 static int bfin_spi_suspend(struct platform_device *pdev, pm_message_t state)
 {
-        struct driver_data *drv_data = platform_get_drvdata(pdev);
+        struct bfin_spi_master_data *drv_data = platform_get_drvdata(pdev);
         int status = 0;
 
         status = bfin_spi_stop_queue(drv_data);
         if (status != 0)
                 return status;
 
-        /* stop hardware */
-        bfin_spi_disable(drv_data);
+        drv_data->ctrl_reg = read_CTRL(drv_data);
+        drv_data->flag_reg = read_FLAG(drv_data);
+
+        /*
+         * reset SPI_CTL and SPI_FLG registers
+         */
+        write_CTRL(drv_data, BIT_CTL_CPHA | BIT_CTL_MASTER);
+        write_FLAG(drv_data, 0xFF00);
 
         return 0;
 }
 
 static int bfin_spi_resume(struct platform_device *pdev)
 {
-        struct driver_data *drv_data = platform_get_drvdata(pdev);
+        struct bfin_spi_master_data *drv_data = platform_get_drvdata(pdev);
         int status = 0;
 
-        /* Enable the SPI interface */
-        bfin_spi_enable(drv_data);
+        write_CTRL(drv_data, drv_data->ctrl_reg);
+        write_FLAG(drv_data, drv_data->flag_reg);
 
         /* Start the queue running */
         status = bfin_spi_start_queue(drv_data);
@@ -1439,7 +1469,7 @@ static int __init bfin_spi_init(void)
 {
         return platform_driver_probe(&bfin_spi_driver, bfin_spi_probe);
 }
-module_init(bfin_spi_init);
+subsys_initcall(bfin_spi_init);
 
 static void __exit bfin_spi_exit(void)
 {
diff --git a/drivers/spi/spi_fsl_espi.c b/drivers/spi/spi_fsl_espi.c
new file mode 100644
index 000000000000..e3b4f6451966
--- /dev/null
+++ b/drivers/spi/spi_fsl_espi.c
@@ -0,0 +1,748 @@
+/*
+ * Freescale eSPI controller driver.
+ *
+ * Copyright 2010 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/irq.h>
+#include <linux/spi/spi.h>
+#include <linux/platform_device.h>
+#include <linux/fsl_devices.h>
+#include <linux/mm.h>
+#include <linux/of.h>
+#include <linux/of_platform.h>
+#include <linux/of_spi.h>
+#include <linux/interrupt.h>
+#include <linux/err.h>
+#include <sysdev/fsl_soc.h>
+
+#include "spi_fsl_lib.h"
+
+/* eSPI Controller registers */
+struct fsl_espi_reg {
+        __be32 mode;            /* 0x000 - eSPI mode register */
+        __be32 event;           /* 0x004 - eSPI event register */
+        __be32 mask;            /* 0x008 - eSPI mask register */
+        __be32 command;         /* 0x00c - eSPI command register */
+        __be32 transmit;        /* 0x010 - eSPI transmit FIFO access register*/
+        __be32 receive;         /* 0x014 - eSPI receive FIFO access register*/
+        u8 res[8];              /* 0x018 - 0x01c reserved */
+        __be32 csmode[4];       /* 0x020 - 0x02c eSPI cs mode register */
+};
+
+struct fsl_espi_transfer {
+        const void *tx_buf;
+        void *rx_buf;
+        unsigned len;
+        unsigned n_tx;
+        unsigned n_rx;
+        unsigned actual_length;
+        int status;
+};
+
+/* eSPI Controller mode register definitions */
+#define SPMODE_ENABLE           (1 << 31)
+#define SPMODE_LOOP             (1 << 30)
+#define SPMODE_TXTHR(x)         ((x) << 8)
+#define SPMODE_RXTHR(x)         ((x) << 0)
+
+/* eSPI Controller CS mode register definitions */
+#define CSMODE_CI_INACTIVEHIGH  (1 << 31)
+#define CSMODE_CP_BEGIN_EDGECLK (1 << 30)
+#define CSMODE_REV              (1 << 29)
+#define CSMODE_DIV16            (1 << 28)
+#define CSMODE_PM(x)            ((x) << 24)
+#define CSMODE_POL_1            (1 << 20)
+#define CSMODE_LEN(x)           ((x) << 16)
+#define CSMODE_BEF(x)           ((x) << 12)
+#define CSMODE_AFT(x)           ((x) << 8)
+#define CSMODE_CG(x)            ((x) << 3)
+
+/* Default mode/csmode for eSPI controller */
+#define SPMODE_INIT_VAL (SPMODE_TXTHR(4) | SPMODE_RXTHR(3))
+#define CSMODE_INIT_VAL (CSMODE_POL_1 | CSMODE_BEF(0) \
+                | CSMODE_AFT(0) | CSMODE_CG(1))
+
+/* SPIE register values */
+#define SPIE_NE         0x00000200      /* Not empty */
+#define SPIE_NF         0x00000100      /* Not full */
+
+/* SPIM register values */
+#define SPIM_NE         0x00000200      /* Not empty */
+#define SPIM_NF         0x00000100      /* Not full */
+#define SPIE_RXCNT(reg)     ((reg >> 24) & 0x3F)
+#define SPIE_TXCNT(reg)     ((reg >> 16) & 0x3F)
+
+/* SPCOM register values */
+#define SPCOM_CS(x)             ((x) << 30)
+#define SPCOM_TRANLEN(x)        ((x) << 0)
+#define SPCOM_TRANLEN_MAX       0xFFFF  /* Max transaction length */
+
+static void fsl_espi_change_mode(struct spi_device *spi)
+{
+        struct mpc8xxx_spi *mspi = spi_master_get_devdata(spi->master);
+        struct spi_mpc8xxx_cs *cs = spi->controller_state;
+        struct fsl_espi_reg *reg_base = mspi->reg_base;
+        __be32 __iomem *mode = &reg_base->csmode[spi->chip_select];
+        __be32 __iomem *espi_mode = &reg_base->mode;
+        u32 tmp;
+        unsigned long flags;
+
+        /* Turn off IRQs locally to minimize time that SPI is disabled. */
+        local_irq_save(flags);
+
+        /* Turn off SPI unit prior changing mode */
+        tmp = mpc8xxx_spi_read_reg(espi_mode);
+        mpc8xxx_spi_write_reg(espi_mode, tmp & ~SPMODE_ENABLE);
+        mpc8xxx_spi_write_reg(mode, cs->hw_mode);
+        mpc8xxx_spi_write_reg(espi_mode, tmp);
+
+        local_irq_restore(flags);
+}
+
+static u32 fsl_espi_tx_buf_lsb(struct mpc8xxx_spi *mpc8xxx_spi)
+{
+        u32 data;
+        u16 data_h;
+        u16 data_l;
+        const u32 *tx = mpc8xxx_spi->tx;
+
+        if (!tx)
+                return 0;
+
+        data = *tx++ << mpc8xxx_spi->tx_shift;
+        data_l = data & 0xffff;
+        data_h = (data >> 16) & 0xffff;
+        swab16s(&data_l);
+        swab16s(&data_h);
+        data = data_h | data_l;
+
+        mpc8xxx_spi->tx = tx;
+        return data;
+}
+
+static int fsl_espi_setup_transfer(struct spi_device *spi,
+                                        struct spi_transfer *t)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
+        int bits_per_word = 0;
+        u8 pm;
+        u32 hz = 0;
+        struct spi_mpc8xxx_cs *cs = spi->controller_state;
+
+        if (t) {
+                bits_per_word = t->bits_per_word;
+                hz = t->speed_hz;
+        }
+
+        /* spi_transfer level calls that work per-word */
+        if (!bits_per_word)
+                bits_per_word = spi->bits_per_word;
+
+        /* Make sure its a bit width we support [4..16] */
+        if ((bits_per_word < 4) || (bits_per_word > 16))
+                return -EINVAL;
+
+        if (!hz)
+                hz = spi->max_speed_hz;
+
+        cs->rx_shift = 0;
+        cs->tx_shift = 0;
+        cs->get_rx = mpc8xxx_spi_rx_buf_u32;
+        cs->get_tx = mpc8xxx_spi_tx_buf_u32;
+        if (bits_per_word <= 8) {
+                cs->rx_shift = 8 - bits_per_word;
+        } else if (bits_per_word <= 16) {
+                cs->rx_shift = 16 - bits_per_word;
+                if (spi->mode & SPI_LSB_FIRST)
+                        cs->get_tx = fsl_espi_tx_buf_lsb;
+        } else {
+                return -EINVAL;
+        }
+
+        mpc8xxx_spi->rx_shift = cs->rx_shift;
+        mpc8xxx_spi->tx_shift = cs->tx_shift;
+        mpc8xxx_spi->get_rx = cs->get_rx;
+        mpc8xxx_spi->get_tx = cs->get_tx;
+
+        bits_per_word = bits_per_word - 1;
+
+        /* mask out bits we are going to set */
+        cs->hw_mode &= ~(CSMODE_LEN(0xF) | CSMODE_DIV16 | CSMODE_PM(0xF));
+
+        cs->hw_mode |= CSMODE_LEN(bits_per_word);
+
+        if ((mpc8xxx_spi->spibrg / hz) > 64) {
+                cs->hw_mode |= CSMODE_DIV16;
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 64) + 1;
+
+                WARN_ONCE(pm > 16, "%s: Requested speed is too low: %d Hz. "
+                          "Will use %d Hz instead.\n", dev_name(&spi->dev),
+                          hz, mpc8xxx_spi->spibrg / 1024);
+                if (pm > 16)
+                        pm = 16;
+        } else {
+                pm = (mpc8xxx_spi->spibrg - 1) / (hz * 4) + 1;
+        }
+        if (pm)
+                pm--;
+
+        cs->hw_mode |= CSMODE_PM(pm);
+
+        fsl_espi_change_mode(spi);
+        return 0;
+}
+
+static int fsl_espi_cpu_bufs(struct mpc8xxx_spi *mspi, struct spi_transfer *t,
+                unsigned int len)
+{
+        u32 word;
+        struct fsl_espi_reg *reg_base = mspi->reg_base;
+
+        mspi->count = len;
+
+        /* enable rx ints */
+        mpc8xxx_spi_write_reg(&reg_base->mask, SPIM_NE);
+
+        /* transmit word */
+        word = mspi->get_tx(mspi);
+        mpc8xxx_spi_write_reg(&reg_base->transmit, word);
+
+        return 0;
+}
+
+static int fsl_espi_bufs(struct spi_device *spi, struct spi_transfer *t)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
+        struct fsl_espi_reg *reg_base = mpc8xxx_spi->reg_base;
+        unsigned int len = t->len;
+        u8 bits_per_word;
+        int ret;
+
+        bits_per_word = spi->bits_per_word;
+        if (t->bits_per_word)
+                bits_per_word = t->bits_per_word;
+
+        mpc8xxx_spi->len = t->len;
+        len = roundup(len, 4) / 4;
+
+        mpc8xxx_spi->tx = t->tx_buf;
+        mpc8xxx_spi->rx = t->rx_buf;
+
+        INIT_COMPLETION(mpc8xxx_spi->done);
+
+        /* Set SPCOM[CS] and SPCOM[TRANLEN] field */
+        if ((t->len - 1) > SPCOM_TRANLEN_MAX) {
+                dev_err(mpc8xxx_spi->dev, "Transaction length (%d)"
+                                " beyond the SPCOM[TRANLEN] field\n", t->len);
+                return -EINVAL;
+        }
+        mpc8xxx_spi_write_reg(&reg_base->command,
+                (SPCOM_CS(spi->chip_select) | SPCOM_TRANLEN(t->len - 1)));
+
+        ret = fsl_espi_cpu_bufs(mpc8xxx_spi, t, len);
+        if (ret)
+                return ret;
+
+        wait_for_completion(&mpc8xxx_spi->done);
+
+        /* disable rx ints */
+        mpc8xxx_spi_write_reg(&reg_base->mask, 0);
+
+        return mpc8xxx_spi->count;
+}
+
+static void fsl_espi_addr2cmd(unsigned int addr, u8 *cmd)
+{
+        if (cmd[1] && cmd[2] && cmd[3]) {
+                cmd[1] = (u8)(addr >> 16);
+                cmd[2] = (u8)(addr >> 8);
+                cmd[3] = (u8)(addr >> 0);
+        }
+}
+
+static unsigned int fsl_espi_cmd2addr(u8 *cmd)
+{
+        if (cmd[1] && cmd[2] && cmd[3])
+                return cmd[1] << 16 | cmd[2] << 8 | cmd[3] << 0;
+
+        return 0;
+}
+
+static void fsl_espi_do_trans(struct spi_message *m,
+                                struct fsl_espi_transfer *tr)
+{
+        struct spi_device *spi = m->spi;
+        struct mpc8xxx_spi *mspi = spi_master_get_devdata(spi->master);
+        struct fsl_espi_transfer *espi_trans = tr;
+        struct spi_message message;
+        struct spi_transfer *t, *first, trans;
+        int status = 0;
+
+        spi_message_init(&message);
+        memset(&trans, 0, sizeof(trans));
+
+        first = list_first_entry(&m->transfers, struct spi_transfer,
+                        transfer_list);
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                if ((first->bits_per_word != t->bits_per_word) ||
+                        (first->speed_hz != t->speed_hz)) {
+                        espi_trans->status = -EINVAL;
+                        dev_err(mspi->dev, "bits_per_word/speed_hz should be"
+                                        " same for the same SPI transfer\n");
+                        return;
+                }
+
+                trans.speed_hz = t->speed_hz;
+                trans.bits_per_word = t->bits_per_word;
+                trans.delay_usecs = max(first->delay_usecs, t->delay_usecs);
+        }
+
+        trans.len = espi_trans->len;
+        trans.tx_buf = espi_trans->tx_buf;
+        trans.rx_buf = espi_trans->rx_buf;
+        spi_message_add_tail(&trans, &message);
+
+        list_for_each_entry(t, &message.transfers, transfer_list) {
+                if (t->bits_per_word || t->speed_hz) {
+                        status = -EINVAL;
+
+                        status = fsl_espi_setup_transfer(spi, t);
+                        if (status < 0)
+                                break;
+                }
+
+                if (t->len)
+                        status = fsl_espi_bufs(spi, t);
+
+                if (status) {
+                        status = -EMSGSIZE;
+                        break;
+                }
+
+                if (t->delay_usecs)
+                        udelay(t->delay_usecs);
+        }
+
+        espi_trans->status = status;
+        fsl_espi_setup_transfer(spi, NULL);
+}
+
+static void fsl_espi_cmd_trans(struct spi_message *m,
+                                struct fsl_espi_transfer *trans, u8 *rx_buff)
+{
+        struct spi_transfer *t;
+        u8 *local_buf;
+        int i = 0;
+        struct fsl_espi_transfer *espi_trans = trans;
+
+        local_buf = kzalloc(SPCOM_TRANLEN_MAX, GFP_KERNEL);
+        if (!local_buf) {
+                espi_trans->status = -ENOMEM;
+                return;
+        }
+
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                if (t->tx_buf) {
+                        memcpy(local_buf + i, t->tx_buf, t->len);
+                        i += t->len;
+                }
+        }
+
+        espi_trans->tx_buf = local_buf;
+        espi_trans->rx_buf = local_buf + espi_trans->n_tx;
+        fsl_espi_do_trans(m, espi_trans);
+
+        espi_trans->actual_length = espi_trans->len;
+        kfree(local_buf);
+}
+
+static void fsl_espi_rw_trans(struct spi_message *m,
+                                struct fsl_espi_transfer *trans, u8 *rx_buff)
+{
+        struct fsl_espi_transfer *espi_trans = trans;
+        unsigned int n_tx = espi_trans->n_tx;
+        unsigned int n_rx = espi_trans->n_rx;
+        struct spi_transfer *t;
+        u8 *local_buf;
+        u8 *rx_buf = rx_buff;
+        unsigned int trans_len;
+        unsigned int addr;
+        int i, pos, loop;
+
+        local_buf = kzalloc(SPCOM_TRANLEN_MAX, GFP_KERNEL);
+        if (!local_buf) {
+                espi_trans->status = -ENOMEM;
+                return;
+        }
+
+        for (pos = 0, loop = 0; pos < n_rx; pos += trans_len, loop++) {
+                trans_len = n_rx - pos;
+                if (trans_len > SPCOM_TRANLEN_MAX - n_tx)
+                        trans_len = SPCOM_TRANLEN_MAX - n_tx;
+
+                i = 0;
+                list_for_each_entry(t, &m->transfers, transfer_list) {
+                        if (t->tx_buf) {
+                                memcpy(local_buf + i, t->tx_buf, t->len);
+                                i += t->len;
+                        }
+                }
+
+                addr = fsl_espi_cmd2addr(local_buf);
+                addr += pos;
+                fsl_espi_addr2cmd(addr, local_buf);
+
+                espi_trans->n_tx = n_tx;
+                espi_trans->n_rx = trans_len;
+                espi_trans->len = trans_len + n_tx;
+                espi_trans->tx_buf = local_buf;
+                espi_trans->rx_buf = local_buf + n_tx;
+                fsl_espi_do_trans(m, espi_trans);
+
+                memcpy(rx_buf + pos, espi_trans->rx_buf + n_tx, trans_len);
+
+                if (loop > 0)
+                        espi_trans->actual_length += espi_trans->len - n_tx;
+                else
+                        espi_trans->actual_length += espi_trans->len;
+        }
+
+        kfree(local_buf);
+}
+
+static void fsl_espi_do_one_msg(struct spi_message *m)
+{
+        struct spi_transfer *t;
+        u8 *rx_buf = NULL;
+        unsigned int n_tx = 0;
+        unsigned int n_rx = 0;
+        struct fsl_espi_transfer espi_trans;
+
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                if (t->tx_buf)
+                        n_tx += t->len;
+                if (t->rx_buf) {
+                        n_rx += t->len;
+                        rx_buf = t->rx_buf;
+                }
+        }
+
+        espi_trans.n_tx = n_tx;
+        espi_trans.n_rx = n_rx;
+        espi_trans.len = n_tx + n_rx;
+        espi_trans.actual_length = 0;
+        espi_trans.status = 0;
+
+        if (!rx_buf)
+                fsl_espi_cmd_trans(m, &espi_trans, NULL);
+        else
+                fsl_espi_rw_trans(m, &espi_trans, rx_buf);
+
+        m->actual_length = espi_trans.actual_length;
+        m->status = espi_trans.status;
+        m->complete(m->context);
+}
+
+static int fsl_espi_setup(struct spi_device *spi)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_espi_reg *reg_base;
+        int retval;
+        u32 hw_mode;
+        u32 loop_mode;
+        struct spi_mpc8xxx_cs *cs = spi->controller_state;
+
+        if (!spi->max_speed_hz)
+                return -EINVAL;
+
+        if (!cs) {
+                cs = kzalloc(sizeof *cs, GFP_KERNEL);
+                if (!cs)
+                        return -ENOMEM;
+                spi->controller_state = cs;
+        }
+
+        mpc8xxx_spi = spi_master_get_devdata(spi->master);
+        reg_base = mpc8xxx_spi->reg_base;
+
+        hw_mode = cs->hw_mode; /* Save orginal settings */
+        cs->hw_mode = mpc8xxx_spi_read_reg(
+                        &reg_base->csmode[spi->chip_select]);
+        /* mask out bits we are going to set */
+        cs->hw_mode &= ~(CSMODE_CP_BEGIN_EDGECLK | CSMODE_CI_INACTIVEHIGH
+                         | CSMODE_REV);
+
+        if (spi->mode & SPI_CPHA)
+                cs->hw_mode |= CSMODE_CP_BEGIN_EDGECLK;
+        if (spi->mode & SPI_CPOL)
+                cs->hw_mode |= CSMODE_CI_INACTIVEHIGH;
+        if (!(spi->mode & SPI_LSB_FIRST))
+                cs->hw_mode |= CSMODE_REV;
+
+        /* Handle the loop mode */
+        loop_mode = mpc8xxx_spi_read_reg(&reg_base->mode);
+        loop_mode &= ~SPMODE_LOOP;
+        if (spi->mode & SPI_LOOP)
+                loop_mode |= SPMODE_LOOP;
+        mpc8xxx_spi_write_reg(&reg_base->mode, loop_mode);
+
+        retval = fsl_espi_setup_transfer(spi, NULL);
+        if (retval < 0) {
+                cs->hw_mode = hw_mode; /* Restore settings */
+                return retval;
+        }
+        return 0;
+}
+
+void fsl_espi_cpu_irq(struct mpc8xxx_spi *mspi, u32 events)
+{
+        struct fsl_espi_reg *reg_base = mspi->reg_base;
+
+        /* We need handle RX first */
+        if (events & SPIE_NE) {
+                u32 rx_data;
+
+                /* Spin until RX is done */
+                while (SPIE_RXCNT(events) < min(4, mspi->len)) {
+                        cpu_relax();
+                        events = mpc8xxx_spi_read_reg(&reg_base->event);
+                }
+                mspi->len -= 4;
+
+                rx_data = mpc8xxx_spi_read_reg(&reg_base->receive);
+
+                if (mspi->rx)
+                        mspi->get_rx(rx_data, mspi);
+        }
+
+        if (!(events & SPIE_NF)) {
+                int ret;
+
+                /* spin until TX is done */
+                ret = spin_event_timeout(((events = mpc8xxx_spi_read_reg(
+                                &reg_base->event)) & SPIE_NF) == 0, 1000, 0);
+                if (!ret) {
+                        dev_err(mspi->dev, "tired waiting for SPIE_NF\n");
+                        return;
+                }
+        }
+
+        /* Clear the events */
+        mpc8xxx_spi_write_reg(&reg_base->event, events);
+
+        mspi->count -= 1;
+        if (mspi->count) {
+                u32 word = mspi->get_tx(mspi);
+
+                mpc8xxx_spi_write_reg(&reg_base->transmit, word);
+        } else {
+                complete(&mspi->done);
+        }
+}
+
+static irqreturn_t fsl_espi_irq(s32 irq, void *context_data)
+{
+        struct mpc8xxx_spi *mspi = context_data;
+        struct fsl_espi_reg *reg_base = mspi->reg_base;
+        irqreturn_t ret = IRQ_NONE;
+        u32 events;
+
+        /* Get interrupt events(tx/rx) */
+        events = mpc8xxx_spi_read_reg(&reg_base->event);
+        if (events)
+                ret = IRQ_HANDLED;
+
+        dev_vdbg(mspi->dev, "%s: events %x\n", __func__, events);
+
+        fsl_espi_cpu_irq(mspi, events);
+
+        return ret;
+}
+
+static void fsl_espi_remove(struct mpc8xxx_spi *mspi)
+{
+        iounmap(mspi->reg_base);
+}
+
+static struct spi_master * __devinit fsl_espi_probe(struct device *dev,
+                struct resource *mem, unsigned int irq)
+{
+        struct fsl_spi_platform_data *pdata = dev->platform_data;
+        struct spi_master *master;
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_espi_reg *reg_base;
+        u32 regval;
+        int i, ret = 0;
+
+        master = spi_alloc_master(dev, sizeof(struct mpc8xxx_spi));
+        if (!master) {
+                ret = -ENOMEM;
+                goto err;
+        }
+
+        dev_set_drvdata(dev, master);
+
+        ret = mpc8xxx_spi_probe(dev, mem, irq);
+        if (ret)
+                goto err_probe;
+
+        master->setup = fsl_espi_setup;
+
+        mpc8xxx_spi = spi_master_get_devdata(master);
+        mpc8xxx_spi->spi_do_one_msg = fsl_espi_do_one_msg;
+        mpc8xxx_spi->spi_remove = fsl_espi_remove;
+
+        mpc8xxx_spi->reg_base = ioremap(mem->start, resource_size(mem));
+        if (!mpc8xxx_spi->reg_base) {
+                ret = -ENOMEM;
+                goto err_probe;
+        }
+
+        reg_base = mpc8xxx_spi->reg_base;
+
+        /* Register for SPI Interrupt */
+        ret = request_irq(mpc8xxx_spi->irq, fsl_espi_irq,
+                          0, "fsl_espi", mpc8xxx_spi);
+        if (ret)
+                goto free_irq;
+
+        if (mpc8xxx_spi->flags & SPI_QE_CPU_MODE) {
+                mpc8xxx_spi->rx_shift = 16;
+                mpc8xxx_spi->tx_shift = 24;
+        }
+
+        /* SPI controller initializations */
+        mpc8xxx_spi_write_reg(&reg_base->mode, 0);
+        mpc8xxx_spi_write_reg(&reg_base->mask, 0);
+        mpc8xxx_spi_write_reg(&reg_base->command, 0);
+        mpc8xxx_spi_write_reg(&reg_base->event, 0xffffffff);
+
+        /* Init eSPI CS mode register */
+        for (i = 0; i < pdata->max_chipselect; i++)
+                mpc8xxx_spi_write_reg(&reg_base->csmode[i], CSMODE_INIT_VAL);
+
+        /* Enable SPI interface */
+        regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
+
+        mpc8xxx_spi_write_reg(&reg_base->mode, regval);
+
+        ret = spi_register_master(master);
+        if (ret < 0)
+                goto unreg_master;
+
+        dev_info(dev, "at 0x%p (irq = %d)\n", reg_base, mpc8xxx_spi->irq);
+
+        return master;
+
+unreg_master:
+        free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
+free_irq:
+        iounmap(mpc8xxx_spi->reg_base);
+err_probe:
+        spi_master_put(master);
+err:
+        return ERR_PTR(ret);
+}
+
+static int of_fsl_espi_get_chipselects(struct device *dev)
+{
+        struct device_node *np = dev->of_node;
+        struct fsl_spi_platform_data *pdata = dev->platform_data;
+        const u32 *prop;
+        int len;
+
+        prop = of_get_property(np, "fsl,espi-num-chipselects", &len);
+        if (!prop || len < sizeof(*prop)) {
+                dev_err(dev, "No 'fsl,espi-num-chipselects' property\n");
+                return -EINVAL;
+        }
+
+        pdata->max_chipselect = *prop;
+        pdata->cs_control = NULL;
+
+        return 0;
+}
+
+static int __devinit of_fsl_espi_probe(struct platform_device *ofdev,
+                                        const struct of_device_id *ofid)
+{
+        struct device *dev = &ofdev->dev;
+        struct device_node *np = ofdev->dev.of_node;
+        struct spi_master *master;
+        struct resource mem;
+        struct resource irq;
+        int ret = -ENOMEM;
+
+        ret = of_mpc8xxx_spi_probe(ofdev, ofid);
+        if (ret)
+                return ret;
+
+        ret = of_fsl_espi_get_chipselects(dev);
+        if (ret)
+                goto err;
+
+        ret = of_address_to_resource(np, 0, &mem);
+        if (ret)
+                goto err;
+
+        ret = of_irq_to_resource(np, 0, &irq);
+        if (!ret) {
+                ret = -EINVAL;
+                goto err;
+        }
+
+        master = fsl_espi_probe(dev, &mem, irq.start);
+        if (IS_ERR(master)) {
+                ret = PTR_ERR(master);
+                goto err;
+        }
+
+        return 0;
+
+err:
+        return ret;
+}
+
+static int __devexit of_fsl_espi_remove(struct platform_device *dev)
+{
+        return mpc8xxx_spi_remove(&dev->dev);
+}
+
+static const struct of_device_id of_fsl_espi_match[] = {
+        { .compatible = "fsl,mpc8536-espi" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, of_fsl_espi_match);
+
+static struct of_platform_driver fsl_espi_driver = {
+        .driver = {
+                .name = "fsl_espi",
+                .owner = THIS_MODULE,
+                .of_match_table = of_fsl_espi_match,
+        },
+        .probe          = of_fsl_espi_probe,
+        .remove         = __devexit_p(of_fsl_espi_remove),
+};
+
+static int __init fsl_espi_init(void)
+{
+        return of_register_platform_driver(&fsl_espi_driver);
+}
+module_init(fsl_espi_init);
+
+static void __exit fsl_espi_exit(void)
+{
+        of_unregister_platform_driver(&fsl_espi_driver);
+}
+module_exit(fsl_espi_exit);
+
+MODULE_AUTHOR("Mingkai Hu");
+MODULE_DESCRIPTION("Enhanced Freescale SPI Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi_fsl_lib.c b/drivers/spi/spi_fsl_lib.c
new file mode 100644
index 000000000000..5cd741fdb5c3
--- /dev/null
+++ b/drivers/spi/spi_fsl_lib.c
@@ -0,0 +1,237 @@
+/*
+ * Freescale SPI/eSPI controller driver library.
+ *
+ * Maintainer: Kumar Gala
+ *
+ * Copyright (C) 2006 Polycom, Inc.
+ *
+ * CPM SPI and QE buffer descriptors mode support:
+ * Copyright (c) 2009  MontaVista Software, Inc.
+ * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
+ * Copyright 2010 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+#include <linux/kernel.h>
+#include <linux/interrupt.h>
+#include <linux/fsl_devices.h>
+#include <linux/dma-mapping.h>
+#include <linux/mm.h>
+#include <linux/of_platform.h>
+#include <linux/of_spi.h>
+#include <sysdev/fsl_soc.h>
+
+#include "spi_fsl_lib.h"
+
+#define MPC8XXX_SPI_RX_BUF(type)                                          \
+void mpc8xxx_spi_rx_buf_##type(u32 data, struct mpc8xxx_spi *mpc8xxx_spi) \
+{                                                                         \
+        type *rx = mpc8xxx_spi->rx;                                       \
+        *rx++ = (type)(data >> mpc8xxx_spi->rx_shift);                    \
+        mpc8xxx_spi->rx = rx;                                             \
+}
+
+#define MPC8XXX_SPI_TX_BUF(type)                                \
+u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi)  \
+{                                                               \
+        u32 data;                                               \
+        const type *tx = mpc8xxx_spi->tx;                       \
+        if (!tx)                                                \
+                return 0;                                       \
+        data = *tx++ << mpc8xxx_spi->tx_shift;                  \
+        mpc8xxx_spi->tx = tx;                                   \
+        return data;                                            \
+}
+
+MPC8XXX_SPI_RX_BUF(u8)
+MPC8XXX_SPI_RX_BUF(u16)
+MPC8XXX_SPI_RX_BUF(u32)
+MPC8XXX_SPI_TX_BUF(u8)
+MPC8XXX_SPI_TX_BUF(u16)
+MPC8XXX_SPI_TX_BUF(u32)
+
+struct mpc8xxx_spi_probe_info *to_of_pinfo(struct fsl_spi_platform_data *pdata)
+{
+        return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
+}
+
+void mpc8xxx_spi_work(struct work_struct *work)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi = container_of(work, struct mpc8xxx_spi,
+                                                       work);
+
+        spin_lock_irq(&mpc8xxx_spi->lock);
+        while (!list_empty(&mpc8xxx_spi->queue)) {
+                struct spi_message *m = container_of(mpc8xxx_spi->queue.next,
+                                                   struct spi_message, queue);
+
+                list_del_init(&m->queue);
+                spin_unlock_irq(&mpc8xxx_spi->lock);
+
+                if (mpc8xxx_spi->spi_do_one_msg)
+                        mpc8xxx_spi->spi_do_one_msg(m);
+
+                spin_lock_irq(&mpc8xxx_spi->lock);
+        }
+        spin_unlock_irq(&mpc8xxx_spi->lock);
+}
+
+int mpc8xxx_spi_transfer(struct spi_device *spi,
+                                struct spi_message *m)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
+        unsigned long flags;
+
+        m->actual_length = 0;
+        m->status = -EINPROGRESS;
+
+        spin_lock_irqsave(&mpc8xxx_spi->lock, flags);
+        list_add_tail(&m->queue, &mpc8xxx_spi->queue);
+        queue_work(mpc8xxx_spi->workqueue, &mpc8xxx_spi->work);
+        spin_unlock_irqrestore(&mpc8xxx_spi->lock, flags);
+
+        return 0;
+}
+
+void mpc8xxx_spi_cleanup(struct spi_device *spi)
+{
+        kfree(spi->controller_state);
+}
+
+const char *mpc8xxx_spi_strmode(unsigned int flags)
+{
+        if (flags & SPI_QE_CPU_MODE) {
+                return "QE CPU";
+        } else if (flags & SPI_CPM_MODE) {
+                if (flags & SPI_QE)
+                        return "QE";
+                else if (flags & SPI_CPM2)
+                        return "CPM2";
+                else
+                        return "CPM1";
+        }
+        return "CPU";
+}
+
+int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
+                        unsigned int irq)
+{
+        struct fsl_spi_platform_data *pdata = dev->platform_data;
+        struct spi_master *master;
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        int ret = 0;
+
+        master = dev_get_drvdata(dev);
+
+        /* the spi->mode bits understood by this driver: */
+        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH
+                        | SPI_LSB_FIRST | SPI_LOOP;
+
+        master->transfer = mpc8xxx_spi_transfer;
+        master->cleanup = mpc8xxx_spi_cleanup;
+        master->dev.of_node = dev->of_node;
+
+        mpc8xxx_spi = spi_master_get_devdata(master);
+        mpc8xxx_spi->dev = dev;
+        mpc8xxx_spi->get_rx = mpc8xxx_spi_rx_buf_u8;
+        mpc8xxx_spi->get_tx = mpc8xxx_spi_tx_buf_u8;
+        mpc8xxx_spi->flags = pdata->flags;
+        mpc8xxx_spi->spibrg = pdata->sysclk;
+        mpc8xxx_spi->irq = irq;
+
+        mpc8xxx_spi->rx_shift = 0;
+        mpc8xxx_spi->tx_shift = 0;
+
+        init_completion(&mpc8xxx_spi->done);
+
+        master->bus_num = pdata->bus_num;
+        master->num_chipselect = pdata->max_chipselect;
+
+        spin_lock_init(&mpc8xxx_spi->lock);
+        init_completion(&mpc8xxx_spi->done);
+        INIT_WORK(&mpc8xxx_spi->work, mpc8xxx_spi_work);
+        INIT_LIST_HEAD(&mpc8xxx_spi->queue);
+
+        mpc8xxx_spi->workqueue = create_singlethread_workqueue(
+                dev_name(master->dev.parent));
+        if (mpc8xxx_spi->workqueue == NULL) {
+                ret = -EBUSY;
+                goto err;
+        }
+
+        return 0;
+
+err:
+        return ret;
+}
+
+int __devexit mpc8xxx_spi_remove(struct device *dev)
+{
+        struct mpc8xxx_spi *mpc8xxx_spi;
+        struct spi_master *master;
+
+        master = dev_get_drvdata(dev);
+        mpc8xxx_spi = spi_master_get_devdata(master);
+
+        flush_workqueue(mpc8xxx_spi->workqueue);
+        destroy_workqueue(mpc8xxx_spi->workqueue);
+        spi_unregister_master(master);
+
+        free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
+
+        if (mpc8xxx_spi->spi_remove)
+                mpc8xxx_spi->spi_remove(mpc8xxx_spi);
+
+        return 0;
+}
+
+int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev,
+                                        const struct of_device_id *ofid)
+{
+        struct device *dev = &ofdev->dev;
+        struct device_node *np = ofdev->dev.of_node;
+        struct mpc8xxx_spi_probe_info *pinfo;
+        struct fsl_spi_platform_data *pdata;
+        const void *prop;
+        int ret = -ENOMEM;
+
+        pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
+        if (!pinfo)
+                return -ENOMEM;
+
+        pdata = &pinfo->pdata;
+        dev->platform_data = pdata;
+
+        /* Allocate bus num dynamically. */
+        pdata->bus_num = -1;
+
+        /* SPI controller is either clocked from QE or SoC clock. */
+        pdata->sysclk = get_brgfreq();
+        if (pdata->sysclk == -1) {
+                pdata->sysclk = fsl_get_sys_freq();
+                if (pdata->sysclk == -1) {
+                        ret = -ENODEV;
+                        goto err;
+                }
+        }
+
+        prop = of_get_property(np, "mode", NULL);
+        if (prop && !strcmp(prop, "cpu-qe"))
+                pdata->flags = SPI_QE_CPU_MODE;
+        else if (prop && !strcmp(prop, "qe"))
+                pdata->flags = SPI_CPM_MODE | SPI_QE;
+        else if (of_device_is_compatible(np, "fsl,cpm2-spi"))
+                pdata->flags = SPI_CPM_MODE | SPI_CPM2;
+        else if (of_device_is_compatible(np, "fsl,cpm1-spi"))
+                pdata->flags = SPI_CPM_MODE | SPI_CPM1;
+
+        return 0;
+
+err:
+        kfree(pinfo);
+        return ret;
+}
diff --git a/drivers/spi/spi_fsl_lib.h b/drivers/spi/spi_fsl_lib.h
new file mode 100644
index 000000000000..281e060977cd
--- /dev/null
+++ b/drivers/spi/spi_fsl_lib.h
@@ -0,0 +1,124 @@
+/*
+ * Freescale SPI/eSPI controller driver library.
+ *
+ * Maintainer: Kumar Gala
+ *
+ * Copyright 2010 Freescale Semiconductor, Inc.
+ * Copyright (C) 2006 Polycom, Inc.
+ *
+ * CPM SPI and QE buffer descriptors mode support:
+ * Copyright (c) 2009  MontaVista Software, Inc.
+ * Author: Anton Vorontsov <avorontsov@ru.mvista.com>
+ *
+ * This program is free software; you can redistribute  it and/or modify it
+ * under  the terms of  the GNU General  Public License as published by the
+ * Free Software Foundation;  either version 2 of the  License, or (at your
+ * option) any later version.
+ */
+#ifndef __SPI_FSL_LIB_H__
+#define __SPI_FSL_LIB_H__
+
+#include <asm/io.h>
+
+/* SPI/eSPI Controller driver's private data. */
+struct mpc8xxx_spi {
+        struct device *dev;
+        void *reg_base;
+
+        /* rx & tx bufs from the spi_transfer */
+        const void *tx;
+        void *rx;
+#ifdef CONFIG_SPI_FSL_ESPI
+        int len;
+#endif
+
+        int subblock;
+        struct spi_pram __iomem *pram;
+        struct cpm_buf_desc __iomem *tx_bd;
+        struct cpm_buf_desc __iomem *rx_bd;
+
+        struct spi_transfer *xfer_in_progress;
+
+        /* dma addresses for CPM transfers */
+        dma_addr_t tx_dma;
+        dma_addr_t rx_dma;
+        bool map_tx_dma;
+        bool map_rx_dma;
+
+        dma_addr_t dma_dummy_tx;
+        dma_addr_t dma_dummy_rx;
+
+        /* functions to deal with different sized buffers */
+        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
+        u32(*get_tx) (struct mpc8xxx_spi *);
+
+        /* hooks for different controller driver */
+        void (*spi_do_one_msg) (struct spi_message *m);
+        void (*spi_remove) (struct mpc8xxx_spi *mspi);
+
+        unsigned int count;
+        unsigned int irq;
+
+        unsigned nsecs;         /* (clock cycle time)/2 */
+
+        u32 spibrg;             /* SPIBRG input clock */
+        u32 rx_shift;           /* RX data reg shift when in qe mode */
+        u32 tx_shift;           /* TX data reg shift when in qe mode */
+
+        unsigned int flags;
+
+        struct workqueue_struct *workqueue;
+        struct work_struct work;
+
+        struct list_head queue;
+        spinlock_t lock;
+
+        struct completion done;
+};
+
+struct spi_mpc8xxx_cs {
+        /* functions to deal with different sized buffers */
+        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
+        u32 (*get_tx) (struct mpc8xxx_spi *);
+        u32 rx_shift;           /* RX data reg shift when in qe mode */
+        u32 tx_shift;           /* TX data reg shift when in qe mode */
+        u32 hw_mode;            /* Holds HW mode register settings */
+};
+
+static inline void mpc8xxx_spi_write_reg(__be32 __iomem *reg, u32 val)
+{
+        out_be32(reg, val);
+}
+
+static inline u32 mpc8xxx_spi_read_reg(__be32 __iomem *reg)
+{
+        return in_be32(reg);
+}
+
+struct mpc8xxx_spi_probe_info {
+        struct fsl_spi_platform_data pdata;
+        int *gpios;
+        bool *alow_flags;
+};
+
+extern u32 mpc8xxx_spi_tx_buf_u8(struct mpc8xxx_spi *mpc8xxx_spi);
+extern u32 mpc8xxx_spi_tx_buf_u16(struct mpc8xxx_spi *mpc8xxx_spi);
+extern u32 mpc8xxx_spi_tx_buf_u32(struct mpc8xxx_spi *mpc8xxx_spi);
+extern void mpc8xxx_spi_rx_buf_u8(u32 data, struct mpc8xxx_spi *mpc8xxx_spi);
+extern void mpc8xxx_spi_rx_buf_u16(u32 data, struct mpc8xxx_spi *mpc8xxx_spi);
+extern void mpc8xxx_spi_rx_buf_u32(u32 data, struct mpc8xxx_spi *mpc8xxx_spi);
+
+extern struct mpc8xxx_spi_probe_info *to_of_pinfo(
+                struct fsl_spi_platform_data *pdata);
+extern int mpc8xxx_spi_bufs(struct mpc8xxx_spi *mspi,
+                struct spi_transfer *t, unsigned int len);
+extern int mpc8xxx_spi_transfer(struct spi_device *spi, struct spi_message *m);
+extern void mpc8xxx_spi_cleanup(struct spi_device *spi);
+extern const char *mpc8xxx_spi_strmode(unsigned int flags);
+extern int mpc8xxx_spi_probe(struct device *dev, struct resource *mem,
+                unsigned int irq);
+extern int mpc8xxx_spi_remove(struct device *dev);
+extern int of_mpc8xxx_spi_probe(struct platform_device *ofdev,
+                                const struct of_device_id *ofid);
+
+#endif /* __SPI_FSL_LIB_H__ */
diff --git a/drivers/spi/spi_mpc8xxx.c b/drivers/spi/spi_fsl_spi.c
index 1dd86b835cd8..7ca52d3ae8f8 100644
--- a/drivers/spi/spi_mpc8xxx.c
+++ b/drivers/spi/spi_fsl_spi.c
@@ -1,9 +1,10 @@
 /*
- * MPC8xxx SPI controller driver.
+ * Freescale SPI controller driver.
  *
  * Maintainer: Kumar Gala
  *
  * Copyright (C) 2006 Polycom, Inc.
+ * Copyright 2010 Freescale Semiconductor, Inc.
  *
  * CPM SPI and QE buffer descriptors mode support:
  * Copyright (c) 2009  MontaVista Software, Inc.
@@ -15,18 +16,11 @@
  * option) any later version.
  */
 #include <linux/module.h>
-#include <linux/init.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
-#include <linux/bug.h>
-#include <linux/errno.h>
-#include <linux/err.h>
-#include <linux/io.h>
-#include <linux/completion.h>
 #include <linux/interrupt.h>
 #include <linux/delay.h>
 #include <linux/irq.h>
-#include <linux/device.h>
 #include <linux/spi/spi.h>
 #include <linux/spi/spi_bitbang.h>
 #include <linux/platform_device.h>
@@ -38,12 +32,12 @@
 #include <linux/of_platform.h>
 #include <linux/gpio.h>
 #include <linux/of_gpio.h>
-#include <linux/slab.h>
 
 #include <sysdev/fsl_soc.h>
 #include <asm/cpm.h>
 #include <asm/qe.h>
-#include <asm/irq.h>
+
+#include "spi_fsl_lib.h"
 
 /* CPM1 and CPM2 are mutually exclusive. */
 #ifdef CONFIG_CPM1
@@ -55,7 +49,7 @@
 #endif
 
 /* SPI Controller registers */
-struct mpc8xxx_spi_reg {
+struct fsl_spi_reg {
         u8 res1[0x20];
         __be32 mode;
         __be32 event;
@@ -80,7 +74,7 @@ struct mpc8xxx_spi_reg {
 
 /*
  * Default for SPI Mode:
- *      SPI MODE 0 (inactive low, phase middle, MSB, 8-bit length, slow clk
+ *      SPI MODE 0 (inactive low, phase middle, MSB, 8-bit length, slow clk
  */
 #define SPMODE_INIT_VAL (SPMODE_CI_INACTIVEHIGH | SPMODE_DIV16 | SPMODE_REV | \
                          SPMODE_MS | SPMODE_LEN(7) | SPMODE_PM(0xf))
@@ -102,112 +96,16 @@ struct mpc8xxx_spi_reg {
 #define SPI_PRAM_SIZE   0x100
 #define SPI_MRBLR       ((unsigned int)PAGE_SIZE)
 
-/* SPI Controller driver's private data. */
-struct mpc8xxx_spi {
-        struct device *dev;
-        struct mpc8xxx_spi_reg __iomem *base;
-
-        /* rx & tx bufs from the spi_transfer */
-        const void *tx;
-        void *rx;
-
-        int subblock;
-        struct spi_pram __iomem *pram;
-        struct cpm_buf_desc __iomem *tx_bd;
-        struct cpm_buf_desc __iomem *rx_bd;
-
-        struct spi_transfer *xfer_in_progress;
-
-        /* dma addresses for CPM transfers */
-        dma_addr_t tx_dma;
-        dma_addr_t rx_dma;
-        bool map_tx_dma;
-        bool map_rx_dma;
-
-        dma_addr_t dma_dummy_tx;
-        dma_addr_t dma_dummy_rx;
-
-        /* functions to deal with different sized buffers */
-        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
-        u32(*get_tx) (struct mpc8xxx_spi *);
-
-        unsigned int count;
-        unsigned int irq;
-
-        unsigned nsecs;         /* (clock cycle time)/2 */
-
-        u32 spibrg;             /* SPIBRG input clock */
-        u32 rx_shift;           /* RX data reg shift when in qe mode */
-        u32 tx_shift;           /* TX data reg shift when in qe mode */
-
-        unsigned int flags;
-
-        struct workqueue_struct *workqueue;
-        struct work_struct work;
-
-        struct list_head queue;
-        spinlock_t lock;
-
-        struct completion done;
-};
-
-static void *mpc8xxx_dummy_rx;
-static DEFINE_MUTEX(mpc8xxx_dummy_rx_lock);
-static int mpc8xxx_dummy_rx_refcnt;
-
-struct spi_mpc8xxx_cs {
-        /* functions to deal with different sized buffers */
-        void (*get_rx) (u32 rx_data, struct mpc8xxx_spi *);
-        u32 (*get_tx) (struct mpc8xxx_spi *);
-        u32 rx_shift;           /* RX data reg shift when in qe mode */
-        u32 tx_shift;           /* TX data reg shift when in qe mode */
-        u32 hw_mode;            /* Holds HW mode register settings */
-};
-
-static inline void mpc8xxx_spi_write_reg(__be32 __iomem *reg, u32 val)
-{
-        out_be32(reg, val);
-}
-
-static inline u32 mpc8xxx_spi_read_reg(__be32 __iomem *reg)
-{
-        return in_be32(reg);
-}
-
-#define MPC83XX_SPI_RX_BUF(type)                                          \
-static                                                                    \
-void mpc8xxx_spi_rx_buf_##type(u32 data, struct mpc8xxx_spi *mpc8xxx_spi) \
-{                                                                         \
-        type *rx = mpc8xxx_spi->rx;                                       \
-        *rx++ = (type)(data >> mpc8xxx_spi->rx_shift);                    \
-        mpc8xxx_spi->rx = rx;                                             \
-}
-
-#define MPC83XX_SPI_TX_BUF(type)                                \
-static                                                          \
-u32 mpc8xxx_spi_tx_buf_##type(struct mpc8xxx_spi *mpc8xxx_spi)  \
-{                                                               \
-        u32 data;                                               \
-        const type *tx = mpc8xxx_spi->tx;                       \
-        if (!tx)                                                \
-                return 0;                                       \
-        data = *tx++ << mpc8xxx_spi->tx_shift;                  \
-        mpc8xxx_spi->tx = tx;                                   \
-        return data;                                            \
-}
+static void *fsl_dummy_rx;
+static DEFINE_MUTEX(fsl_dummy_rx_lock);
+static int fsl_dummy_rx_refcnt;
 
-MPC83XX_SPI_RX_BUF(u8)
-MPC83XX_SPI_RX_BUF(u16)
-MPC83XX_SPI_RX_BUF(u32)
-MPC83XX_SPI_TX_BUF(u8)
-MPC83XX_SPI_TX_BUF(u16)
-MPC83XX_SPI_TX_BUF(u32)
-
-static void mpc8xxx_spi_change_mode(struct spi_device *spi)
+static void fsl_spi_change_mode(struct spi_device *spi)
 {
         struct mpc8xxx_spi *mspi = spi_master_get_devdata(spi->master);
         struct spi_mpc8xxx_cs *cs = spi->controller_state;
-        __be32 __iomem *mode = &mspi->base->mode;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
+        __be32 __iomem *mode = &reg_base->mode;
         unsigned long flags;
 
         if (cs->hw_mode == mpc8xxx_spi_read_reg(mode))
@@ -238,7 +136,7 @@ static void mpc8xxx_spi_change_mode(struct spi_device *spi)
         local_irq_restore(flags);
 }
 
-static void mpc8xxx_spi_chipselect(struct spi_device *spi, int value)
+static void fsl_spi_chipselect(struct spi_device *spi, int value)
 {
         struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
         struct fsl_spi_platform_data *pdata = spi->dev.parent->platform_data;
@@ -256,18 +154,17 @@ static void mpc8xxx_spi_chipselect(struct spi_device *spi, int value)
                 mpc8xxx_spi->get_rx = cs->get_rx;
                 mpc8xxx_spi->get_tx = cs->get_tx;
 
-                mpc8xxx_spi_change_mode(spi);
+                fsl_spi_change_mode(spi);
 
                 if (pdata->cs_control)
                         pdata->cs_control(spi, pol);
         }
 }
 
-static int
-mspi_apply_cpu_mode_quirks(struct spi_mpc8xxx_cs *cs,
-                           struct spi_device *spi,
-                           struct mpc8xxx_spi *mpc8xxx_spi,
-                           int bits_per_word)
+static int mspi_apply_cpu_mode_quirks(struct spi_mpc8xxx_cs *cs,
+                                struct spi_device *spi,
+                                struct mpc8xxx_spi *mpc8xxx_spi,
+                                int bits_per_word)
 {
         cs->rx_shift = 0;
         cs->tx_shift = 0;
@@ -307,10 +204,9 @@ mspi_apply_cpu_mode_quirks(struct spi_mpc8xxx_cs *cs,
         return bits_per_word;
 }
 
-static int
-mspi_apply_qe_mode_quirks(struct spi_mpc8xxx_cs *cs,
-                          struct spi_device *spi,
-                          int bits_per_word)
+static int mspi_apply_qe_mode_quirks(struct spi_mpc8xxx_cs *cs,
+                                struct spi_device *spi,
+                                int bits_per_word)
 {
         /* QE uses Little Endian for words > 8
          * so transform all words > 8 into 8 bits
@@ -326,13 +222,13 @@ mspi_apply_qe_mode_quirks(struct spi_mpc8xxx_cs *cs,
         return bits_per_word;
 }
 
-static
-int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
+static int fsl_spi_setup_transfer(struct spi_device *spi,
+                                        struct spi_transfer *t)
 {
         struct mpc8xxx_spi *mpc8xxx_spi;
-        int bits_per_word;
+        int bits_per_word = 0;
         u8 pm;
-        u32 hz;
+        u32 hz = 0;
         struct spi_mpc8xxx_cs   *cs = spi->controller_state;
 
         mpc8xxx_spi = spi_master_get_devdata(spi->master);
@@ -340,9 +236,6 @@ int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
         if (t) {
                 bits_per_word = t->bits_per_word;
                 hz = t->speed_hz;
-        } else {
-                bits_per_word = 0;
-                hz = 0;
         }
 
         /* spi_transfer level calls that work per-word */
@@ -388,23 +281,25 @@ int mpc8xxx_spi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                           hz, mpc8xxx_spi->spibrg / 1024);
                 if (pm > 16)
                         pm = 16;
-        } else
+        } else {
                 pm = (mpc8xxx_spi->spibrg - 1) / (hz * 4) + 1;
+        }
         if (pm)
                 pm--;
 
         cs->hw_mode |= SPMODE_PM(pm);
 
-        mpc8xxx_spi_change_mode(spi);
+        fsl_spi_change_mode(spi);
         return 0;
 }
 
-static void mpc8xxx_spi_cpm_bufs_start(struct mpc8xxx_spi *mspi)
+static void fsl_spi_cpm_bufs_start(struct mpc8xxx_spi *mspi)
 {
         struct cpm_buf_desc __iomem *tx_bd = mspi->tx_bd;
         struct cpm_buf_desc __iomem *rx_bd = mspi->rx_bd;
         unsigned int xfer_len = min(mspi->count, SPI_MRBLR);
         unsigned int xfer_ofs;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
 
         xfer_ofs = mspi->xfer_in_progress->len - mspi->count;
 
@@ -424,13 +319,14 @@ static void mpc8xxx_spi_cpm_bufs_start(struct mpc8xxx_spi *mspi)
                                  BD_SC_LAST);
 
         /* start transfer */
-        mpc8xxx_spi_write_reg(&mspi->base->command, SPCOM_STR);
+        mpc8xxx_spi_write_reg(&reg_base->command, SPCOM_STR);
 }
 
-static int mpc8xxx_spi_cpm_bufs(struct mpc8xxx_spi *mspi,
+static int fsl_spi_cpm_bufs(struct mpc8xxx_spi *mspi,
                                 struct spi_transfer *t, bool is_dma_mapped)
 {
         struct device *dev = mspi->dev;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
 
         if (is_dma_mapped) {
                 mspi->map_tx_dma = 0;
@@ -475,13 +371,13 @@ static int mpc8xxx_spi_cpm_bufs(struct mpc8xxx_spi *mspi,
         }
 
         /* enable rx ints */
-        mpc8xxx_spi_write_reg(&mspi->base->mask, SPIE_RXB);
+        mpc8xxx_spi_write_reg(&reg_base->mask, SPIE_RXB);
 
         mspi->xfer_in_progress = t;
         mspi->count = t->len;
 
         /* start CPM transfers */
-        mpc8xxx_spi_cpm_bufs_start(mspi);
+        fsl_spi_cpm_bufs_start(mspi);
 
         return 0;
 
@@ -491,7 +387,7 @@ err_rx_dma:
         return -ENOMEM;
 }
 
-static void mpc8xxx_spi_cpm_bufs_complete(struct mpc8xxx_spi *mspi)
+static void fsl_spi_cpm_bufs_complete(struct mpc8xxx_spi *mspi)
 {
         struct device *dev = mspi->dev;
         struct spi_transfer *t = mspi->xfer_in_progress;
@@ -503,31 +399,34 @@ static void mpc8xxx_spi_cpm_bufs_complete(struct mpc8xxx_spi *mspi)
         mspi->xfer_in_progress = NULL;
 }
 
-static int mpc8xxx_spi_cpu_bufs(struct mpc8xxx_spi *mspi,
+static int fsl_spi_cpu_bufs(struct mpc8xxx_spi *mspi,
                                 struct spi_transfer *t, unsigned int len)
 {
         u32 word;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
 
         mspi->count = len;
 
         /* enable rx ints */
-        mpc8xxx_spi_write_reg(&mspi->base->mask, SPIM_NE);
+        mpc8xxx_spi_write_reg(&reg_base->mask, SPIM_NE);
 
         /* transmit word */
         word = mspi->get_tx(mspi);
-        mpc8xxx_spi_write_reg(&mspi->base->transmit, word);
+        mpc8xxx_spi_write_reg(&reg_base->transmit, word);
 
         return 0;
 }
 
-static int mpc8xxx_spi_bufs(struct spi_device *spi, struct spi_transfer *t,
+static int fsl_spi_bufs(struct spi_device *spi, struct spi_transfer *t,
                             bool is_dma_mapped)
 {
         struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
+        struct fsl_spi_reg *reg_base;
         unsigned int len = t->len;
         u8 bits_per_word;
         int ret;
 
+        reg_base = mpc8xxx_spi->reg_base;
         bits_per_word = spi->bits_per_word;
         if (t->bits_per_word)
                 bits_per_word = t->bits_per_word;
@@ -551,24 +450,24 @@ static int mpc8xxx_spi_bufs(struct spi_device *spi, struct spi_transfer *t,
         INIT_COMPLETION(mpc8xxx_spi->done);
 
         if (mpc8xxx_spi->flags & SPI_CPM_MODE)
-                ret = mpc8xxx_spi_cpm_bufs(mpc8xxx_spi, t, is_dma_mapped);
+                ret = fsl_spi_cpm_bufs(mpc8xxx_spi, t, is_dma_mapped);
         else
-                ret = mpc8xxx_spi_cpu_bufs(mpc8xxx_spi, t, len);
+                ret = fsl_spi_cpu_bufs(mpc8xxx_spi, t, len);
         if (ret)
                 return ret;
 
         wait_for_completion(&mpc8xxx_spi->done);
 
         /* disable rx ints */
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
+        mpc8xxx_spi_write_reg(&reg_base->mask, 0);
 
         if (mpc8xxx_spi->flags & SPI_CPM_MODE)
-                mpc8xxx_spi_cpm_bufs_complete(mpc8xxx_spi);
+                fsl_spi_cpm_bufs_complete(mpc8xxx_spi);
 
         return mpc8xxx_spi->count;
 }
 
-static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
+static void fsl_spi_do_one_msg(struct spi_message *m)
 {
         struct spi_device *spi = m->spi;
         struct spi_transfer *t;
@@ -584,18 +483,18 @@ static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
                         status = -EINVAL;
 
                         if (cs_change)
-                                status = mpc8xxx_spi_setup_transfer(spi, t);
+                                status = fsl_spi_setup_transfer(spi, t);
                         if (status < 0)
                                 break;
                 }
 
                 if (cs_change) {
-                        mpc8xxx_spi_chipselect(spi, BITBANG_CS_ACTIVE);
+                        fsl_spi_chipselect(spi, BITBANG_CS_ACTIVE);
                         ndelay(nsecs);
                 }
                 cs_change = t->cs_change;
                 if (t->len)
-                        status = mpc8xxx_spi_bufs(spi, t, m->is_dma_mapped);
+                        status = fsl_spi_bufs(spi, t, m->is_dma_mapped);
                 if (status) {
                         status = -EMSGSIZE;
                         break;
@@ -607,7 +506,7 @@ static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
 
                 if (cs_change) {
                         ndelay(nsecs);
-                        mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
+                        fsl_spi_chipselect(spi, BITBANG_CS_INACTIVE);
                         ndelay(nsecs);
                 }
         }
@@ -617,35 +516,16 @@ static void mpc8xxx_spi_do_one_msg(struct spi_message *m)
 
         if (status || !cs_change) {
                 ndelay(nsecs);
-                mpc8xxx_spi_chipselect(spi, BITBANG_CS_INACTIVE);
+                fsl_spi_chipselect(spi, BITBANG_CS_INACTIVE);
         }
 
-        mpc8xxx_spi_setup_transfer(spi, NULL);
-}
-
-static void mpc8xxx_spi_work(struct work_struct *work)
-{
-        struct mpc8xxx_spi *mpc8xxx_spi = container_of(work, struct mpc8xxx_spi,
-                                                       work);
-
-        spin_lock_irq(&mpc8xxx_spi->lock);
-        while (!list_empty(&mpc8xxx_spi->queue)) {
-                struct spi_message *m = container_of(mpc8xxx_spi->queue.next,
-                                                   struct spi_message, queue);
-
-                list_del_init(&m->queue);
-                spin_unlock_irq(&mpc8xxx_spi->lock);
-
-                mpc8xxx_spi_do_one_msg(m);
-
-                spin_lock_irq(&mpc8xxx_spi->lock);
-        }
-        spin_unlock_irq(&mpc8xxx_spi->lock);
+        fsl_spi_setup_transfer(spi, NULL);
 }
 
-static int mpc8xxx_spi_setup(struct spi_device *spi)
+static int fsl_spi_setup(struct spi_device *spi)
 {
         struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_spi_reg *reg_base;
         int retval;
         u32 hw_mode;
         struct spi_mpc8xxx_cs   *cs = spi->controller_state;
@@ -661,8 +541,10 @@ static int mpc8xxx_spi_setup(struct spi_device *spi)
         }
         mpc8xxx_spi = spi_master_get_devdata(spi->master);
 
+        reg_base = mpc8xxx_spi->reg_base;
+
         hw_mode = cs->hw_mode; /* Save original settings */
-        cs->hw_mode = mpc8xxx_spi_read_reg(&mpc8xxx_spi->base->mode);
+        cs->hw_mode = mpc8xxx_spi_read_reg(&reg_base->mode);
         /* mask out bits we are going to set */
         cs->hw_mode &= ~(SPMODE_CP_BEGIN_EDGECLK | SPMODE_CI_INACTIVEHIGH
                          | SPMODE_REV | SPMODE_LOOP);
@@ -676,7 +558,7 @@ static int mpc8xxx_spi_setup(struct spi_device *spi)
         if (spi->mode & SPI_LOOP)
                 cs->hw_mode |= SPMODE_LOOP;
 
-        retval = mpc8xxx_spi_setup_transfer(spi, NULL);
+        retval = fsl_spi_setup_transfer(spi, NULL);
         if (retval < 0) {
                 cs->hw_mode = hw_mode; /* Restore settings */
                 return retval;
@@ -684,9 +566,10 @@ static int mpc8xxx_spi_setup(struct spi_device *spi)
         return 0;
 }
 
-static void mpc8xxx_spi_cpm_irq(struct mpc8xxx_spi *mspi, u32 events)
+static void fsl_spi_cpm_irq(struct mpc8xxx_spi *mspi, u32 events)
 {
         u16 len;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
 
         dev_dbg(mspi->dev, "%s: bd datlen %d, count %d\n", __func__,
                 in_be16(&mspi->rx_bd->cbd_datlen), mspi->count);
@@ -698,20 +581,22 @@ static void mpc8xxx_spi_cpm_irq(struct mpc8xxx_spi *mspi, u32 events)
         }
 
         /* Clear the events */
-        mpc8xxx_spi_write_reg(&mspi->base->event, events);
+        mpc8xxx_spi_write_reg(&reg_base->event, events);
 
         mspi->count -= len;
         if (mspi->count)
-                mpc8xxx_spi_cpm_bufs_start(mspi);
+                fsl_spi_cpm_bufs_start(mspi);
         else
                 complete(&mspi->done);
 }
 
-static void mpc8xxx_spi_cpu_irq(struct mpc8xxx_spi *mspi, u32 events)
+static void fsl_spi_cpu_irq(struct mpc8xxx_spi *mspi, u32 events)
 {
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
+
         /* We need handle RX first */
         if (events & SPIE_NE) {
-                u32 rx_data = mpc8xxx_spi_read_reg(&mspi->base->receive);
+                u32 rx_data = mpc8xxx_spi_read_reg(&reg_base->receive);
 
                 if (mspi->rx)
                         mspi->get_rx(rx_data, mspi);
@@ -720,102 +605,80 @@ static void mpc8xxx_spi_cpu_irq(struct mpc8xxx_spi *mspi, u32 events)
         if ((events & SPIE_NF) == 0)
                 /* spin until TX is done */
                 while (((events =
-                        mpc8xxx_spi_read_reg(&mspi->base->event)) &
+                        mpc8xxx_spi_read_reg(&reg_base->event)) &
                                                 SPIE_NF) == 0)
                         cpu_relax();
 
         /* Clear the events */
-        mpc8xxx_spi_write_reg(&mspi->base->event, events);
+        mpc8xxx_spi_write_reg(&reg_base->event, events);
 
         mspi->count -= 1;
         if (mspi->count) {
                 u32 word = mspi->get_tx(mspi);
 
-                mpc8xxx_spi_write_reg(&mspi->base->transmit, word);
+                mpc8xxx_spi_write_reg(&reg_base->transmit, word);
         } else {
                 complete(&mspi->done);
         }
 }
 
-static irqreturn_t mpc8xxx_spi_irq(s32 irq, void *context_data)
+static irqreturn_t fsl_spi_irq(s32 irq, void *context_data)
 {
         struct mpc8xxx_spi *mspi = context_data;
         irqreturn_t ret = IRQ_NONE;
         u32 events;
+        struct fsl_spi_reg *reg_base = mspi->reg_base;
 
         /* Get interrupt events(tx/rx) */
-        events = mpc8xxx_spi_read_reg(&mspi->base->event);
+        events = mpc8xxx_spi_read_reg(&reg_base->event);
         if (events)
                 ret = IRQ_HANDLED;
 
         dev_dbg(mspi->dev, "%s: events %x\n", __func__, events);
 
         if (mspi->flags & SPI_CPM_MODE)
-                mpc8xxx_spi_cpm_irq(mspi, events);
+                fsl_spi_cpm_irq(mspi, events);
         else
-                mpc8xxx_spi_cpu_irq(mspi, events);
+                fsl_spi_cpu_irq(mspi, events);
 
         return ret;
 }
 
-static int mpc8xxx_spi_transfer(struct spi_device *spi,
-                                struct spi_message *m)
+static void *fsl_spi_alloc_dummy_rx(void)
 {
-        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
-        unsigned long flags;
+        mutex_lock(&fsl_dummy_rx_lock);
 
-        m->actual_length = 0;
-        m->status = -EINPROGRESS;
+        if (!fsl_dummy_rx)
+                fsl_dummy_rx = kmalloc(SPI_MRBLR, GFP_KERNEL);
+        if (fsl_dummy_rx)
+                fsl_dummy_rx_refcnt++;
 
-        spin_lock_irqsave(&mpc8xxx_spi->lock, flags);
-        list_add_tail(&m->queue, &mpc8xxx_spi->queue);
-        queue_work(mpc8xxx_spi->workqueue, &mpc8xxx_spi->work);
-        spin_unlock_irqrestore(&mpc8xxx_spi->lock, flags);
+        mutex_unlock(&fsl_dummy_rx_lock);
 
-        return 0;
+        return fsl_dummy_rx;
 }
 
-
-static void mpc8xxx_spi_cleanup(struct spi_device *spi)
+static void fsl_spi_free_dummy_rx(void)
 {
-        kfree(spi->controller_state);
-}
+        mutex_lock(&fsl_dummy_rx_lock);
 
-static void *mpc8xxx_spi_alloc_dummy_rx(void)
-{
-        mutex_lock(&mpc8xxx_dummy_rx_lock);
-
-        if (!mpc8xxx_dummy_rx)
-                mpc8xxx_dummy_rx = kmalloc(SPI_MRBLR, GFP_KERNEL);
-        if (mpc8xxx_dummy_rx)
-                mpc8xxx_dummy_rx_refcnt++;
-
-        mutex_unlock(&mpc8xxx_dummy_rx_lock);
-
-        return mpc8xxx_dummy_rx;
-}
-
-static void mpc8xxx_spi_free_dummy_rx(void)
-{
-        mutex_lock(&mpc8xxx_dummy_rx_lock);
-
-        switch (mpc8xxx_dummy_rx_refcnt) {
+        switch (fsl_dummy_rx_refcnt) {
         case 0:
                 WARN_ON(1);
                 break;
         case 1:
-                kfree(mpc8xxx_dummy_rx);
-                mpc8xxx_dummy_rx = NULL;
+                kfree(fsl_dummy_rx);
+                fsl_dummy_rx = NULL;
                 /* fall through */
         default:
-                mpc8xxx_dummy_rx_refcnt--;
+                fsl_dummy_rx_refcnt--;
                 break;
         }
 
-        mutex_unlock(&mpc8xxx_dummy_rx_lock);
+        mutex_unlock(&fsl_dummy_rx_lock);
 }
 
-static unsigned long mpc8xxx_spi_cpm_get_pram(struct mpc8xxx_spi *mspi)
+static unsigned long fsl_spi_cpm_get_pram(struct mpc8xxx_spi *mspi)
 {
         struct device *dev = mspi->dev;
         struct device_node *np = dev->of_node;
@@ -869,7 +732,7 @@ static unsigned long mpc8xxx_spi_cpm_get_pram(struct mpc8xxx_spi *mspi)
         return pram_ofs;
 }
 
-static int mpc8xxx_spi_cpm_init(struct mpc8xxx_spi *mspi)
+static int fsl_spi_cpm_init(struct mpc8xxx_spi *mspi)
 {
         struct device *dev = mspi->dev;
         struct device_node *np = dev->of_node;
@@ -881,7 +744,7 @@ static int mpc8xxx_spi_cpm_init(struct mpc8xxx_spi *mspi)
         if (!(mspi->flags & SPI_CPM_MODE))
                 return 0;
 
-        if (!mpc8xxx_spi_alloc_dummy_rx())
+        if (!fsl_spi_alloc_dummy_rx())
                 return -ENOMEM;
 
         if (mspi->flags & SPI_QE) {
@@ -902,7 +765,7 @@ static int mpc8xxx_spi_cpm_init(struct mpc8xxx_spi *mspi)
                 }
         }
 
-        pram_ofs = mpc8xxx_spi_cpm_get_pram(mspi);
+        pram_ofs = fsl_spi_cpm_get_pram(mspi);
         if (IS_ERR_VALUE(pram_ofs)) {
                 dev_err(dev, "can't allocate spi parameter ram\n");
                 goto err_pram;
@@ -922,7 +785,7 @@ static int mpc8xxx_spi_cpm_init(struct mpc8xxx_spi *mspi)
                 goto err_dummy_tx;
         }
 
-        mspi->dma_dummy_rx = dma_map_single(dev, mpc8xxx_dummy_rx, SPI_MRBLR,
+        mspi->dma_dummy_rx = dma_map_single(dev, fsl_dummy_rx, SPI_MRBLR,
                                             DMA_FROM_DEVICE);
         if (dma_mapping_error(dev, mspi->dma_dummy_rx)) {
                 dev_err(dev, "unable to map dummy rx buffer\n");
@@ -960,11 +823,11 @@ err_dummy_tx:
 err_bds:
         cpm_muram_free(pram_ofs);
 err_pram:
-        mpc8xxx_spi_free_dummy_rx();
+        fsl_spi_free_dummy_rx();
         return -ENOMEM;
 }
 
-static void mpc8xxx_spi_cpm_free(struct mpc8xxx_spi *mspi)
+static void fsl_spi_cpm_free(struct mpc8xxx_spi *mspi)
 {
         struct device *dev = mspi->dev;
 
@@ -972,30 +835,22 @@ static void mpc8xxx_spi_cpm_free(struct mpc8xxx_spi *mspi)
         dma_unmap_single(dev, mspi->dma_dummy_tx, PAGE_SIZE, DMA_TO_DEVICE);
         cpm_muram_free(cpm_muram_offset(mspi->tx_bd));
         cpm_muram_free(cpm_muram_offset(mspi->pram));
-        mpc8xxx_spi_free_dummy_rx();
+        fsl_spi_free_dummy_rx();
 }
 
-static const char *mpc8xxx_spi_strmode(unsigned int flags)
+static void fsl_spi_remove(struct mpc8xxx_spi *mspi)
 {
-        if (flags & SPI_QE_CPU_MODE) {
-                return "QE CPU";
-        } else if (flags & SPI_CPM_MODE) {
-                if (flags & SPI_QE)
-                        return "QE";
-                else if (flags & SPI_CPM2)
-                        return "CPM2";
-                else
-                        return "CPM1";
-        }
-        return "CPU";
+        iounmap(mspi->reg_base);
+        fsl_spi_cpm_free(mspi);
 }
 
-static struct spi_master * __devinit
-mpc8xxx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
+static struct spi_master * __devinit fsl_spi_probe(struct device *dev,
+                struct resource *mem, unsigned int irq)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
         struct spi_master *master;
         struct mpc8xxx_spi *mpc8xxx_spi;
+        struct fsl_spi_reg *reg_base;
         u32 regval;
         int ret = 0;
 
@@ -1007,132 +862,77 @@ mpc8xxx_spi_probe(struct device *dev, struct resource *mem, unsigned int irq)
 
         dev_set_drvdata(dev, master);
 
-        /* the spi->mode bits understood by this driver: */
-        master->mode_bits = SPI_CPOL | SPI_CPHA | SPI_CS_HIGH
-                        | SPI_LSB_FIRST | SPI_LOOP;
+        ret = mpc8xxx_spi_probe(dev, mem, irq);
+        if (ret)
+                goto err_probe;
 
-        master->setup = mpc8xxx_spi_setup;
-        master->transfer = mpc8xxx_spi_transfer;
-        master->cleanup = mpc8xxx_spi_cleanup;
-        master->dev.of_node = dev->of_node;
+        master->setup = fsl_spi_setup;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
-        mpc8xxx_spi->dev = dev;
-        mpc8xxx_spi->get_rx = mpc8xxx_spi_rx_buf_u8;
-        mpc8xxx_spi->get_tx = mpc8xxx_spi_tx_buf_u8;
-        mpc8xxx_spi->flags = pdata->flags;
-        mpc8xxx_spi->spibrg = pdata->sysclk;
+        mpc8xxx_spi->spi_do_one_msg = fsl_spi_do_one_msg;
+        mpc8xxx_spi->spi_remove = fsl_spi_remove;
+
 
-        ret = mpc8xxx_spi_cpm_init(mpc8xxx_spi);
+        ret = fsl_spi_cpm_init(mpc8xxx_spi);
         if (ret)
                 goto err_cpm_init;
 
-        mpc8xxx_spi->rx_shift = 0;
-        mpc8xxx_spi->tx_shift = 0;
         if (mpc8xxx_spi->flags & SPI_QE_CPU_MODE) {
                 mpc8xxx_spi->rx_shift = 16;
                 mpc8xxx_spi->tx_shift = 24;
         }
 
-        init_completion(&mpc8xxx_spi->done);
-
-        mpc8xxx_spi->base = ioremap(mem->start, resource_size(mem));
-        if (mpc8xxx_spi->base == NULL) {
+        mpc8xxx_spi->reg_base = ioremap(mem->start, resource_size(mem));
+        if (mpc8xxx_spi->reg_base == NULL) {
                 ret = -ENOMEM;
                 goto err_ioremap;
         }
 
-        mpc8xxx_spi->irq = irq;
-
         /* Register for SPI Interrupt */
-        ret = request_irq(mpc8xxx_spi->irq, mpc8xxx_spi_irq,
-                          0, "mpc8xxx_spi", mpc8xxx_spi);
+        ret = request_irq(mpc8xxx_spi->irq, fsl_spi_irq,
+                          0, "fsl_spi", mpc8xxx_spi);
 
         if (ret != 0)
-                goto unmap_io;
+                goto free_irq;
 
-        master->bus_num = pdata->bus_num;
-        master->num_chipselect = pdata->max_chipselect;
+        reg_base = mpc8xxx_spi->reg_base;
 
         /* SPI controller initializations */
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, 0);
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mask, 0);
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->command, 0);
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->event, 0xffffffff);
+        mpc8xxx_spi_write_reg(&reg_base->mode, 0);
+        mpc8xxx_spi_write_reg(&reg_base->mask, 0);
+        mpc8xxx_spi_write_reg(&reg_base->command, 0);
+        mpc8xxx_spi_write_reg(&reg_base->event, 0xffffffff);
 
         /* Enable SPI interface */
         regval = pdata->initial_spmode | SPMODE_INIT_VAL | SPMODE_ENABLE;
         if (mpc8xxx_spi->flags & SPI_QE_CPU_MODE)
                 regval |= SPMODE_OP;
 
-        mpc8xxx_spi_write_reg(&mpc8xxx_spi->base->mode, regval);
-        spin_lock_init(&mpc8xxx_spi->lock);
-        init_completion(&mpc8xxx_spi->done);
-        INIT_WORK(&mpc8xxx_spi->work, mpc8xxx_spi_work);
-        INIT_LIST_HEAD(&mpc8xxx_spi->queue);
-
-        mpc8xxx_spi->workqueue = create_singlethread_workqueue(
-                dev_name(master->dev.parent));
-        if (mpc8xxx_spi->workqueue == NULL) {
-                ret = -EBUSY;
-                goto free_irq;
-        }
+        mpc8xxx_spi_write_reg(&reg_base->mode, regval);
 
         ret = spi_register_master(master);
         if (ret < 0)
                 goto unreg_master;
 
-        dev_info(dev, "at 0x%p (irq = %d), %s mode\n", mpc8xxx_spi->base,
+        dev_info(dev, "at 0x%p (irq = %d), %s mode\n", reg_base,
                  mpc8xxx_spi->irq, mpc8xxx_spi_strmode(mpc8xxx_spi->flags));
 
         return master;
 
 unreg_master:
-        destroy_workqueue(mpc8xxx_spi->workqueue);
-free_irq:
         free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
-unmap_io:
-        iounmap(mpc8xxx_spi->base);
+free_irq:
+        iounmap(mpc8xxx_spi->reg_base);
 err_ioremap:
-        mpc8xxx_spi_cpm_free(mpc8xxx_spi);
+        fsl_spi_cpm_free(mpc8xxx_spi);
 err_cpm_init:
+err_probe:
         spi_master_put(master);
 err:
         return ERR_PTR(ret);
 }
 
-static int __devexit mpc8xxx_spi_remove(struct device *dev)
-{
-        struct mpc8xxx_spi *mpc8xxx_spi;
-        struct spi_master *master;
-
-        master = dev_get_drvdata(dev);
-        mpc8xxx_spi = spi_master_get_devdata(master);
-
-        flush_workqueue(mpc8xxx_spi->workqueue);
-        destroy_workqueue(mpc8xxx_spi->workqueue);
-        spi_unregister_master(master);
-
-        free_irq(mpc8xxx_spi->irq, mpc8xxx_spi);
-        iounmap(mpc8xxx_spi->base);
-        mpc8xxx_spi_cpm_free(mpc8xxx_spi);
-
-        return 0;
-}
-
-struct mpc8xxx_spi_probe_info {
-        struct fsl_spi_platform_data pdata;
-        int *gpios;
-        bool *alow_flags;
-};
-
-static struct mpc8xxx_spi_probe_info *
-to_of_pinfo(struct fsl_spi_platform_data *pdata)
-{
-        return container_of(pdata, struct mpc8xxx_spi_probe_info, pdata);
-}
-
-static void mpc8xxx_spi_cs_control(struct spi_device *spi, bool on)
+static void fsl_spi_cs_control(struct spi_device *spi, bool on)
 {
         struct device *dev = spi->dev.parent;
         struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(dev->platform_data);
@@ -1143,7 +943,7 @@ static void mpc8xxx_spi_cs_control(struct spi_device *spi, bool on)
         gpio_set_value(gpio, on ^ alow);
 }
 
-static int of_mpc8xxx_spi_get_chipselects(struct device *dev)
+static int of_fsl_spi_get_chipselects(struct device *dev)
 {
         struct device_node *np = dev->of_node;
         struct fsl_spi_platform_data *pdata = dev->platform_data;
@@ -1204,7 +1004,7 @@ static int of_mpc8xxx_spi_get_chipselects(struct device *dev)
         }
 
         pdata->max_chipselect = ngpios;
-        pdata->cs_control = mpc8xxx_spi_cs_control;
+        pdata->cs_control = fsl_spi_cs_control;
 
         return 0;
 
@@ -1223,7 +1023,7 @@ err_alloc_flags:
         return ret;
 }
 
-static int of_mpc8xxx_spi_free_chipselects(struct device *dev)
+static int of_fsl_spi_free_chipselects(struct device *dev)
 {
         struct fsl_spi_platform_data *pdata = dev->platform_data;
         struct mpc8xxx_spi_probe_info *pinfo = to_of_pinfo(pdata);
@@ -1242,50 +1042,21 @@ static int of_mpc8xxx_spi_free_chipselects(struct device *dev)
         return 0;
 }
 
-static int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev,
-                                          const struct of_device_id *ofid)
+static int __devinit of_fsl_spi_probe(struct platform_device *ofdev,
+                                        const struct of_device_id *ofid)
 {
         struct device *dev = &ofdev->dev;
         struct device_node *np = ofdev->dev.of_node;
-        struct mpc8xxx_spi_probe_info *pinfo;
-        struct fsl_spi_platform_data *pdata;
         struct spi_master *master;
         struct resource mem;
         struct resource irq;
-        const void *prop;
         int ret = -ENOMEM;
 
-        pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
-        if (!pinfo)
-                return -ENOMEM;
-
-        pdata = &pinfo->pdata;
-        dev->platform_data = pdata;
-
-        /* Allocate bus num dynamically. */
-        pdata->bus_num = -1;
-
-        /* SPI controller is either clocked from QE or SoC clock. */
-        pdata->sysclk = get_brgfreq();
-        if (pdata->sysclk == -1) {
-                pdata->sysclk = fsl_get_sys_freq();
-                if (pdata->sysclk == -1) {
-                        ret = -ENODEV;
-                        goto err_clk;
-                }
-        }
+        ret = of_mpc8xxx_spi_probe(ofdev, ofid);
+        if (ret)
+                return ret;
 
-        prop = of_get_property(np, "mode", NULL);
-        if (prop && !strcmp(prop, "cpu-qe"))
-                pdata->flags = SPI_QE_CPU_MODE;
-        else if (prop && !strcmp(prop, "qe"))
-                pdata->flags = SPI_CPM_MODE | SPI_QE;
-        else if (of_device_is_compatible(np, "fsl,cpm2-spi"))
-                pdata->flags = SPI_CPM_MODE | SPI_CPM2;
-        else if (of_device_is_compatible(np, "fsl,cpm1-spi"))
-                pdata->flags = SPI_CPM_MODE | SPI_CPM1;
-
-        ret = of_mpc8xxx_spi_get_chipselects(dev);
+        ret = of_fsl_spi_get_chipselects(dev);
         if (ret)
                 goto err;
 
@@ -1299,7 +1070,7 @@ static int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev,
                 goto err;
         }
 
-        master = mpc8xxx_spi_probe(dev, &mem, irq.start);
+        master = fsl_spi_probe(dev, &mem, irq.start);
         if (IS_ERR(master)) {
                 ret = PTR_ERR(master);
                 goto err;
@@ -1308,42 +1079,40 @@ static int __devinit of_mpc8xxx_spi_probe(struct platform_device *ofdev,
         return 0;
 
 err:
-        of_mpc8xxx_spi_free_chipselects(dev);
-err_clk:
-        kfree(pinfo);
+        of_fsl_spi_free_chipselects(dev);
         return ret;
 }
 
-static int __devexit of_mpc8xxx_spi_remove(struct platform_device *ofdev)
+static int __devexit of_fsl_spi_remove(struct platform_device *ofdev)
 {
         int ret;
 
         ret = mpc8xxx_spi_remove(&ofdev->dev);
         if (ret)
                 return ret;
-        of_mpc8xxx_spi_free_chipselects(&ofdev->dev);
+        of_fsl_spi_free_chipselects(&ofdev->dev);
         return 0;
 }
 
-static const struct of_device_id of_mpc8xxx_spi_match[] = {
+static const struct of_device_id of_fsl_spi_match[] = {
         { .compatible = "fsl,spi" },
-        {},
+        {}
 };
-MODULE_DEVICE_TABLE(of, of_mpc8xxx_spi_match);
+MODULE_DEVICE_TABLE(of, of_fsl_spi_match);
 
-static struct of_platform_driver of_mpc8xxx_spi_driver = {
+static struct of_platform_driver of_fsl_spi_driver = {
         .driver = {
-                .name = "mpc8xxx_spi",
+                .name = "fsl_spi",
                 .owner = THIS_MODULE,
-                .of_match_table = of_mpc8xxx_spi_match,
+                .of_match_table = of_fsl_spi_match,
         },
-        .probe          = of_mpc8xxx_spi_probe,
-        .remove         = __devexit_p(of_mpc8xxx_spi_remove),
+        .probe          = of_fsl_spi_probe,
+        .remove         = __devexit_p(of_fsl_spi_remove),
 };
 
 #ifdef CONFIG_MPC832x_RDB
 /*
- *                              XXX XXX XXX
+ * XXX XXX XXX
  * This is "legacy" platform driver, was used by the MPC8323E-RDB boards
  * only. The driver should go away soon, since newer MPC8323E-RDB's device
  * tree can work with OpenFirmware driver. But for now we support old trees
@@ -1366,7 +1135,7 @@ static int __devinit plat_mpc8xxx_spi_probe(struct platform_device *pdev)
         if (irq <= 0)
                 return -EINVAL;
 
-        master = mpc8xxx_spi_probe(&pdev->dev, mem, irq);
+        master = fsl_spi_probe(&pdev->dev, mem, irq);
         if (IS_ERR(master))
                 return PTR_ERR(master);
         return 0;
@@ -1405,21 +1174,20 @@ static void __init legacy_driver_register(void) {}
 static void __exit legacy_driver_unregister(void) {}
 #endif /* CONFIG_MPC832x_RDB */
 
-static int __init mpc8xxx_spi_init(void)
+static int __init fsl_spi_init(void)
 {
         legacy_driver_register();
-        return of_register_platform_driver(&of_mpc8xxx_spi_driver);
+        return of_register_platform_driver(&of_fsl_spi_driver);
 }
+module_init(fsl_spi_init);
 
-static void __exit mpc8xxx_spi_exit(void)
+static void __exit fsl_spi_exit(void)
 {
-        of_unregister_platform_driver(&of_mpc8xxx_spi_driver);
+        of_unregister_platform_driver(&of_fsl_spi_driver);
         legacy_driver_unregister();
 }
-
-module_init(mpc8xxx_spi_init);
-module_exit(mpc8xxx_spi_exit);
+module_exit(fsl_spi_exit);
 
 MODULE_AUTHOR("Kumar Gala");
-MODULE_DESCRIPTION("Simple MPC8xxx SPI Driver");
+MODULE_DESCRIPTION("Simple Freescale SPI Driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index 7972e9077473..55a38e2c6c13 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -56,7 +56,28 @@ struct spi_imx_config {
         unsigned int speed_hz;
         unsigned int bpw;
         unsigned int mode;
-        int cs;
+        u8 cs;
+};
+
+enum spi_imx_devtype {
+        SPI_IMX_VER_IMX1,
+        SPI_IMX_VER_0_0,
+        SPI_IMX_VER_0_4,
+        SPI_IMX_VER_0_5,
+        SPI_IMX_VER_0_7,
+        SPI_IMX_VER_2_3,
+        SPI_IMX_VER_AUTODETECT,
+};
+
+struct spi_imx_data;
+
+struct spi_imx_devtype_data {
+        void (*intctrl)(struct spi_imx_data *, int);
+        int (*config)(struct spi_imx_data *, struct spi_imx_config *);
+        void (*trigger)(struct spi_imx_data *);
+        int (*rx_available)(struct spi_imx_data *);
+        void (*reset)(struct spi_imx_data *);
+        unsigned int fifosize;
 };
 
 struct spi_imx_data {
@@ -76,11 +97,7 @@ struct spi_imx_data {
         const void *tx_buf;
         unsigned int txfifo; /* number of words pushed in tx FIFO */
 
-        /* SoC specific functions */
-        void (*intctrl)(struct spi_imx_data *, int);
-        int (*config)(struct spi_imx_data *, struct spi_imx_config *);
-        void (*trigger)(struct spi_imx_data *);
-        int (*rx_available)(struct spi_imx_data *);
+        struct spi_imx_devtype_data devtype_data;
 };
 
 #define MXC_SPI_BUF_RX(type)                                            \
@@ -140,7 +157,7 @@ static unsigned int spi_imx_clkdiv_1(unsigned int fin,
         return max;
 }
 
-/* MX1, MX31, MX35 */
+/* MX1, MX31, MX35, MX51 CSPI */
 static unsigned int spi_imx_clkdiv_2(unsigned int fin,
                 unsigned int fspi)
 {
@@ -155,6 +172,128 @@ static unsigned int spi_imx_clkdiv_2(unsigned int fin,
         return 7;
 }
 
+#define SPI_IMX2_3_CTRL         0x08
+#define SPI_IMX2_3_CTRL_ENABLE          (1 <<  0)
+#define SPI_IMX2_3_CTRL_XCH             (1 <<  2)
+#define SPI_IMX2_3_CTRL_MODE(cs)        (1 << ((cs) +  4))
+#define SPI_IMX2_3_CTRL_POSTDIV_OFFSET  8
+#define SPI_IMX2_3_CTRL_PREDIV_OFFSET   12
+#define SPI_IMX2_3_CTRL_CS(cs)          ((cs) << 18)
+#define SPI_IMX2_3_CTRL_BL_OFFSET       20
+
+#define SPI_IMX2_3_CONFIG       0x0c
+#define SPI_IMX2_3_CONFIG_SCLKPHA(cs)   (1 << ((cs) +  0))
+#define SPI_IMX2_3_CONFIG_SCLKPOL(cs)   (1 << ((cs) +  4))
+#define SPI_IMX2_3_CONFIG_SBBCTRL(cs)   (1 << ((cs) +  8))
+#define SPI_IMX2_3_CONFIG_SSBPOL(cs)    (1 << ((cs) + 12))
+
+#define SPI_IMX2_3_INT          0x10
+#define SPI_IMX2_3_INT_TEEN             (1 <<  0)
+#define SPI_IMX2_3_INT_RREN             (1 <<  3)
+
+#define SPI_IMX2_3_STAT         0x18
+#define SPI_IMX2_3_STAT_RR              (1 <<  3)
+
+/* MX51 eCSPI */
+static unsigned int spi_imx2_3_clkdiv(unsigned int fin, unsigned int fspi)
+{
+        /*
+         * there are two 4-bit dividers, the pre-divider divides by
+         * $pre, the post-divider by 2^$post
+         */
+        unsigned int pre, post;
+
+        if (unlikely(fspi > fin))
+                return 0;
+
+        post = fls(fin) - fls(fspi);
+        if (fin > fspi << post)
+                post++;
+
+        /* now we have: (fin <= fspi << post) with post being minimal */
+
+        post = max(4U, post) - 4;
+        if (unlikely(post > 0xf)) {
+                pr_err("%s: cannot set clock freq: %u (base freq: %u)\n",
+                                __func__, fspi, fin);
+                return 0xff;
+        }
+
+        pre = DIV_ROUND_UP(fin, fspi << post) - 1;
+
+        pr_debug("%s: fin: %u, fspi: %u, post: %u, pre: %u\n",
+                        __func__, fin, fspi, post, pre);
+        return (pre << SPI_IMX2_3_CTRL_PREDIV_OFFSET) |
+                (post << SPI_IMX2_3_CTRL_POSTDIV_OFFSET);
+}
+
+static void __maybe_unused spi_imx2_3_intctrl(struct spi_imx_data *spi_imx, int enable)
+{
+        unsigned val = 0;
+
+        if (enable & MXC_INT_TE)
+                val |= SPI_IMX2_3_INT_TEEN;
+
+        if (enable & MXC_INT_RR)
+                val |= SPI_IMX2_3_INT_RREN;
+
+        writel(val, spi_imx->base + SPI_IMX2_3_INT);
+}
+
+static void __maybe_unused spi_imx2_3_trigger(struct spi_imx_data *spi_imx)
+{
+        u32 reg;
+
+        reg = readl(spi_imx->base + SPI_IMX2_3_CTRL);
+        reg |= SPI_IMX2_3_CTRL_XCH;
+        writel(reg, spi_imx->base + SPI_IMX2_3_CTRL);
+}
+
+static int __maybe_unused spi_imx2_3_config(struct spi_imx_data *spi_imx,
+                struct spi_imx_config *config)
+{
+        u32 ctrl = SPI_IMX2_3_CTRL_ENABLE, cfg = 0;
+
+        /* set master mode */
+        ctrl |= SPI_IMX2_3_CTRL_MODE(config->cs);
+
+        /* set clock speed */
+        ctrl |= spi_imx2_3_clkdiv(spi_imx->spi_clk, config->speed_hz);
+
+        /* set chip select to use */
+        ctrl |= SPI_IMX2_3_CTRL_CS(config->cs);
+
+        ctrl |= (config->bpw - 1) << SPI_IMX2_3_CTRL_BL_OFFSET;
+
+        cfg |= SPI_IMX2_3_CONFIG_SBBCTRL(config->cs);
+
+        if (config->mode & SPI_CPHA)
+                cfg |= SPI_IMX2_3_CONFIG_SCLKPHA(config->cs);
+
+        if (config->mode & SPI_CPOL)
+                cfg |= SPI_IMX2_3_CONFIG_SCLKPOL(config->cs);
+
+        if (config->mode & SPI_CS_HIGH)
+                cfg |= SPI_IMX2_3_CONFIG_SSBPOL(config->cs);
+
+        writel(ctrl, spi_imx->base + SPI_IMX2_3_CTRL);
+        writel(cfg, spi_imx->base + SPI_IMX2_3_CONFIG);
+
+        return 0;
+}
+
+static int __maybe_unused spi_imx2_3_rx_available(struct spi_imx_data *spi_imx)
+{
+        return readl(spi_imx->base + SPI_IMX2_3_STAT) & SPI_IMX2_3_STAT_RR;
+}
+
+static void __maybe_unused spi_imx2_3_reset(struct spi_imx_data *spi_imx)
+{
+        /* drain receive buffer */
+        while (spi_imx2_3_rx_available(spi_imx))
+                readl(spi_imx->base + MXC_CSPIRXDATA);
+}
+
 #define MX31_INTREG_TEEN        (1 << 0)
 #define MX31_INTREG_RREN        (1 << 3)
 
@@ -178,7 +317,7 @@ static unsigned int spi_imx_clkdiv_2(unsigned int fin,
  * the i.MX35 has a slightly different register layout for bits
  * we do not use here.
  */
-static void mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
+static void __maybe_unused mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
 {
         unsigned int val = 0;
 
@@ -190,7 +329,7 @@ static void mx31_intctrl(struct spi_imx_data *spi_imx, int enable)
         writel(val, spi_imx->base + MXC_CSPIINT);
 }
 
-static void mx31_trigger(struct spi_imx_data *spi_imx)
+static void __maybe_unused mx31_trigger(struct spi_imx_data *spi_imx)
 {
         unsigned int reg;
 
@@ -199,20 +338,16 @@ static void mx31_trigger(struct spi_imx_data *spi_imx)
         writel(reg, spi_imx->base + MXC_CSPICTRL);
 }
 
-static int mx31_config(struct spi_imx_data *spi_imx,
+static int __maybe_unused spi_imx0_4_config(struct spi_imx_data *spi_imx,
                 struct spi_imx_config *config)
 {
         unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;
+        int cs = spi_imx->chipselect[config->cs];
 
         reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
                 MX31_CSPICTRL_DR_SHIFT;
 
-        if (cpu_is_mx31())
-                reg |= (config->bpw - 1) << MX31_CSPICTRL_BC_SHIFT;
-        else if (cpu_is_mx25() || cpu_is_mx35()) {
-                reg |= (config->bpw - 1) << MX35_CSPICTRL_BL_SHIFT;
-                reg |= MX31_CSPICTRL_SSCTL;
-        }
+        reg |= (config->bpw - 1) << MX31_CSPICTRL_BC_SHIFT;
 
         if (config->mode & SPI_CPHA)
                 reg |= MX31_CSPICTRL_PHA;
@@ -220,23 +355,52 @@ static int mx31_config(struct spi_imx_data *spi_imx,
                 reg |= MX31_CSPICTRL_POL;
         if (config->mode & SPI_CS_HIGH)
                 reg |= MX31_CSPICTRL_SSPOL;
-        if (config->cs < 0) {
-                if (cpu_is_mx31())
-                        reg |= (config->cs + 32) << MX31_CSPICTRL_CS_SHIFT;
-                else if (cpu_is_mx25() || cpu_is_mx35())
-                        reg |= (config->cs + 32) << MX35_CSPICTRL_CS_SHIFT;
-        }
+        if (cs < 0)
+                reg |= (cs + 32) << MX31_CSPICTRL_CS_SHIFT;
+
+        writel(reg, spi_imx->base + MXC_CSPICTRL);
+
+        return 0;
+}
+
+static int __maybe_unused spi_imx0_7_config(struct spi_imx_data *spi_imx,
+                struct spi_imx_config *config)
+{
+        unsigned int reg = MX31_CSPICTRL_ENABLE | MX31_CSPICTRL_MASTER;
+        int cs = spi_imx->chipselect[config->cs];
+
+        reg |= spi_imx_clkdiv_2(spi_imx->spi_clk, config->speed_hz) <<
+                MX31_CSPICTRL_DR_SHIFT;
+
+        reg |= (config->bpw - 1) << MX35_CSPICTRL_BL_SHIFT;
+        reg |= MX31_CSPICTRL_SSCTL;
+
+        if (config->mode & SPI_CPHA)
+                reg |= MX31_CSPICTRL_PHA;
+        if (config->mode & SPI_CPOL)
+                reg |= MX31_CSPICTRL_POL;
+        if (config->mode & SPI_CS_HIGH)
+                reg |= MX31_CSPICTRL_SSPOL;
+        if (cs < 0)
+                reg |= (cs + 32) << MX35_CSPICTRL_CS_SHIFT;
 
         writel(reg, spi_imx->base + MXC_CSPICTRL);
 
         return 0;
 }
 
-static int mx31_rx_available(struct spi_imx_data *spi_imx)
+static int __maybe_unused mx31_rx_available(struct spi_imx_data *spi_imx)
 {
         return readl(spi_imx->base + MX31_CSPISTATUS) & MX31_STATUS_RR;
 }
 
+static void __maybe_unused spi_imx0_4_reset(struct spi_imx_data *spi_imx)
+{
+        /* drain receive buffer */
+        while (readl(spi_imx->base + MX3_CSPISTAT) & MX3_CSPISTAT_RR)
+                readl(spi_imx->base + MXC_CSPIRXDATA);
+}
+
 #define MX27_INTREG_RR          (1 << 4)
 #define MX27_INTREG_TEEN        (1 << 9)
 #define MX27_INTREG_RREN        (1 << 13)
@@ -250,7 +414,7 @@ static int mx31_rx_available(struct spi_imx_data *spi_imx)
 #define MX27_CSPICTRL_DR_SHIFT  14
 #define MX27_CSPICTRL_CS_SHIFT  19
 
-static void mx27_intctrl(struct spi_imx_data *spi_imx, int enable)
+static void __maybe_unused mx27_intctrl(struct spi_imx_data *spi_imx, int enable)
 {
         unsigned int val = 0;
 
@@ -262,7 +426,7 @@ static void mx27_intctrl(struct spi_imx_data *spi_imx, int enable)
         writel(val, spi_imx->base + MXC_CSPIINT);
 }
 
-static void mx27_trigger(struct spi_imx_data *spi_imx)
+static void __maybe_unused mx27_trigger(struct spi_imx_data *spi_imx)
 {
         unsigned int reg;
 
@@ -271,10 +435,11 @@ static void mx27_trigger(struct spi_imx_data *spi_imx)
         writel(reg, spi_imx->base + MXC_CSPICTRL);
 }
 
-static int mx27_config(struct spi_imx_data *spi_imx,
+static int __maybe_unused mx27_config(struct spi_imx_data *spi_imx,
                 struct spi_imx_config *config)
 {
         unsigned int reg = MX27_CSPICTRL_ENABLE | MX27_CSPICTRL_MASTER;
+        int cs = spi_imx->chipselect[config->cs];
 
         reg |= spi_imx_clkdiv_1(spi_imx->spi_clk, config->speed_hz) <<
                 MX27_CSPICTRL_DR_SHIFT;
@@ -286,19 +451,24 @@ static int mx27_config(struct spi_imx_data *spi_imx,
                 reg |= MX27_CSPICTRL_POL;
         if (config->mode & SPI_CS_HIGH)
                 reg |= MX27_CSPICTRL_SSPOL;
-        if (config->cs < 0)
-                reg |= (config->cs + 32) << MX27_CSPICTRL_CS_SHIFT;
+        if (cs < 0)
+                reg |= (cs + 32) << MX27_CSPICTRL_CS_SHIFT;
 
         writel(reg, spi_imx->base + MXC_CSPICTRL);
 
         return 0;
 }
 
-static int mx27_rx_available(struct spi_imx_data *spi_imx)
+static int __maybe_unused mx27_rx_available(struct spi_imx_data *spi_imx)
 {
         return readl(spi_imx->base + MXC_CSPIINT) & MX27_INTREG_RR;
 }
 
+static void __maybe_unused spi_imx0_0_reset(struct spi_imx_data *spi_imx)
+{
+        writel(1, spi_imx->base + MXC_RESET);
+}
+
 #define MX1_INTREG_RR           (1 << 3)
 #define MX1_INTREG_TEEN         (1 << 8)
 #define MX1_INTREG_RREN         (1 << 11)
@@ -310,7 +480,7 @@ static int mx27_rx_available(struct spi_imx_data *spi_imx)
 #define MX1_CSPICTRL_MASTER     (1 << 10)
 #define MX1_CSPICTRL_DR_SHIFT   13
 
-static void mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
+static void __maybe_unused mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
 {
         unsigned int val = 0;
 
@@ -322,7 +492,7 @@ static void mx1_intctrl(struct spi_imx_data *spi_imx, int enable)
         writel(val, spi_imx->base + MXC_CSPIINT);
 }
 
-static void mx1_trigger(struct spi_imx_data *spi_imx)
+static void __maybe_unused mx1_trigger(struct spi_imx_data *spi_imx)
 {
         unsigned int reg;
 
@@ -331,7 +501,7 @@ static void mx1_trigger(struct spi_imx_data *spi_imx)
         writel(reg, spi_imx->base + MXC_CSPICTRL);
 }
 
-static int mx1_config(struct spi_imx_data *spi_imx,
+static int __maybe_unused mx1_config(struct spi_imx_data *spi_imx,
                 struct spi_imx_config *config)
 {
         unsigned int reg = MX1_CSPICTRL_ENABLE | MX1_CSPICTRL_MASTER;
@@ -350,11 +520,73 @@ static int mx1_config(struct spi_imx_data *spi_imx,
         return 0;
 }
 
-static int mx1_rx_available(struct spi_imx_data *spi_imx)
+static int __maybe_unused mx1_rx_available(struct spi_imx_data *spi_imx)
 {
         return readl(spi_imx->base + MXC_CSPIINT) & MX1_INTREG_RR;
 }
 
+static void __maybe_unused mx1_reset(struct spi_imx_data *spi_imx)
+{
+        writel(1, spi_imx->base + MXC_RESET);
+}
+
+/*
+ * These version numbers are taken from the Freescale driver.  Unfortunately it
+ * doesn't support i.MX1, so this entry doesn't match the scheme. :-(
+ */
+static struct spi_imx_devtype_data spi_imx_devtype_data[] __devinitdata = {
+#ifdef CONFIG_SPI_IMX_VER_IMX1
+        [SPI_IMX_VER_IMX1] = {
+                .intctrl = mx1_intctrl,
+                .config = mx1_config,
+                .trigger = mx1_trigger,
+                .rx_available = mx1_rx_available,
+                .reset = mx1_reset,
+                .fifosize = 8,
+        },
+#endif
+#ifdef CONFIG_SPI_IMX_VER_0_0
+        [SPI_IMX_VER_0_0] = {
+                .intctrl = mx27_intctrl,
+                .config = mx27_config,
+                .trigger = mx27_trigger,
+                .rx_available = mx27_rx_available,
+                .reset = spi_imx0_0_reset,
+                .fifosize = 8,
+        },
+#endif
+#ifdef CONFIG_SPI_IMX_VER_0_4
+        [SPI_IMX_VER_0_4] = {
+                .intctrl = mx31_intctrl,
+                .config = spi_imx0_4_config,
+                .trigger = mx31_trigger,
+                .rx_available = mx31_rx_available,
+                .reset = spi_imx0_4_reset,
+                .fifosize = 8,
+        },
+#endif
+#ifdef CONFIG_SPI_IMX_VER_0_7
+        [SPI_IMX_VER_0_7] = {
+                .intctrl = mx31_intctrl,
+                .config = spi_imx0_7_config,
+                .trigger = mx31_trigger,
+                .rx_available = mx31_rx_available,
+                .reset = spi_imx0_4_reset,
+                .fifosize = 8,
+        },
+#endif
+#ifdef CONFIG_SPI_IMX_VER_2_3
+        [SPI_IMX_VER_2_3] = {
+                .intctrl = spi_imx2_3_intctrl,
+                .config = spi_imx2_3_config,
+                .trigger = spi_imx2_3_trigger,
+                .rx_available = spi_imx2_3_rx_available,
+                .reset = spi_imx2_3_reset,
+                .fifosize = 64,
+        },
+#endif
+};
+
 static void spi_imx_chipselect(struct spi_device *spi, int is_active)
 {
         struct spi_imx_data *spi_imx = spi_master_get_devdata(spi->master);
@@ -370,21 +602,21 @@ static void spi_imx_chipselect(struct spi_device *spi, int is_active)
 
 static void spi_imx_push(struct spi_imx_data *spi_imx)
 {
-        while (spi_imx->txfifo < 8) {
+        while (spi_imx->txfifo < spi_imx->devtype_data.fifosize) {
                 if (!spi_imx->count)
                         break;
                 spi_imx->tx(spi_imx);
                 spi_imx->txfifo++;
         }
 
-        spi_imx->trigger(spi_imx);
+        spi_imx->devtype_data.trigger(spi_imx);
 }
 
 static irqreturn_t spi_imx_isr(int irq, void *dev_id)
 {
         struct spi_imx_data *spi_imx = dev_id;
 
-        while (spi_imx->rx_available(spi_imx)) {
+        while (spi_imx->devtype_data.rx_available(spi_imx)) {
                 spi_imx->rx(spi_imx);
                 spi_imx->txfifo--;
         }
@@ -398,11 +630,12 @@ static irqreturn_t spi_imx_isr(int irq, void *dev_id)
                 /* No data left to push, but still waiting for rx data,
                  * enable receive data available interrupt.
                  */
-                spi_imx->intctrl(spi_imx, MXC_INT_RR);
+                spi_imx->devtype_data.intctrl(
+                                spi_imx, MXC_INT_RR);
                 return IRQ_HANDLED;
         }
 
-        spi_imx->intctrl(spi_imx, 0);
+        spi_imx->devtype_data.intctrl(spi_imx, 0);
         complete(&spi_imx->xfer_done);
 
         return IRQ_HANDLED;
@@ -417,7 +650,7 @@ static int spi_imx_setupxfer(struct spi_device *spi,
         config.bpw = t ? t->bits_per_word : spi->bits_per_word;
         config.speed_hz  = t ? t->speed_hz : spi->max_speed_hz;
         config.mode = spi->mode;
-        config.cs = spi_imx->chipselect[spi->chip_select];
+        config.cs = spi->chip_select;
 
         if (!config.speed_hz)
                 config.speed_hz = spi->max_speed_hz;
@@ -439,7 +672,7 @@ static int spi_imx_setupxfer(struct spi_device *spi,
         } else
                 BUG();
 
-        spi_imx->config(spi_imx, &config);
+        spi_imx->devtype_data.config(spi_imx, &config);
 
         return 0;
 }
@@ -458,7 +691,7 @@ static int spi_imx_transfer(struct spi_device *spi,
 
         spi_imx_push(spi_imx);
 
-        spi_imx->intctrl(spi_imx, MXC_INT_TE);
+        spi_imx->devtype_data.intctrl(spi_imx, MXC_INT_TE);
 
         wait_for_completion(&spi_imx->xfer_done);
 
@@ -485,6 +718,39 @@ static void spi_imx_cleanup(struct spi_device *spi)
 {
 }
 
+static struct platform_device_id spi_imx_devtype[] = {
+        {
+                .name = DRIVER_NAME,
+                .driver_data = SPI_IMX_VER_AUTODETECT,
+        }, {
+                .name = "imx1-cspi",
+                .driver_data = SPI_IMX_VER_IMX1,
+        }, {
+                .name = "imx21-cspi",
+                .driver_data = SPI_IMX_VER_0_0,
+        }, {
+                .name = "imx25-cspi",
+                .driver_data = SPI_IMX_VER_0_7,
+        }, {
+                .name = "imx27-cspi",
+                .driver_data = SPI_IMX_VER_0_0,
+        }, {
+                .name = "imx31-cspi",
+                .driver_data = SPI_IMX_VER_0_4,
+        }, {
+                .name = "imx35-cspi",
+                .driver_data = SPI_IMX_VER_0_7,
+        }, {
+                .name = "imx51-cspi",
+                .driver_data = SPI_IMX_VER_0_7,
+        }, {
+                .name = "imx51-ecspi",
+                .driver_data = SPI_IMX_VER_2_3,
+        }, {
+                /* sentinel */
+        }
+};
+
 static int __devinit spi_imx_probe(struct platform_device *pdev)
 {
         struct spi_imx_master *mxc_platform_info;
@@ -536,6 +802,31 @@ static int __devinit spi_imx_probe(struct platform_device *pdev)
 
         init_completion(&spi_imx->xfer_done);
 
+        if (pdev->id_entry->driver_data == SPI_IMX_VER_AUTODETECT) {
+                if (cpu_is_mx25() || cpu_is_mx35())
+                        spi_imx->devtype_data =
+                                spi_imx_devtype_data[SPI_IMX_VER_0_7];
+                else if (cpu_is_mx25() || cpu_is_mx31() || cpu_is_mx35())
+                        spi_imx->devtype_data =
+                                spi_imx_devtype_data[SPI_IMX_VER_0_4];
+                else if (cpu_is_mx27() || cpu_is_mx21())
+                        spi_imx->devtype_data =
+                                spi_imx_devtype_data[SPI_IMX_VER_0_0];
+                else if (cpu_is_mx1())
+                        spi_imx->devtype_data =
+                                spi_imx_devtype_data[SPI_IMX_VER_IMX1];
+                else
+                        BUG();
+        } else
+                spi_imx->devtype_data =
+                        spi_imx_devtype_data[pdev->id_entry->driver_data];
+
+        if (!spi_imx->devtype_data.intctrl) {
+                dev_err(&pdev->dev, "no support for this device compiled in\n");
+                ret = -ENODEV;
+                goto out_gpio_free;
+        }
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
                 dev_err(&pdev->dev, "can't get platform resource\n");
@@ -567,24 +858,6 @@ static int __devinit spi_imx_probe(struct platform_device *pdev)
                 goto out_iounmap;
         }
 
-        if (cpu_is_mx25() || cpu_is_mx31() || cpu_is_mx35()) {
-                spi_imx->intctrl = mx31_intctrl;
-                spi_imx->config = mx31_config;
-                spi_imx->trigger = mx31_trigger;
-                spi_imx->rx_available = mx31_rx_available;
-        } else  if (cpu_is_mx27() || cpu_is_mx21()) {
-                spi_imx->intctrl = mx27_intctrl;
-                spi_imx->config = mx27_config;
-                spi_imx->trigger = mx27_trigger;
-                spi_imx->rx_available = mx27_rx_available;
-        } else if (cpu_is_mx1()) {
-                spi_imx->intctrl = mx1_intctrl;
-                spi_imx->config = mx1_config;
-                spi_imx->trigger = mx1_trigger;
-                spi_imx->rx_available = mx1_rx_available;
-        } else
-                BUG();
-
         spi_imx->clk = clk_get(&pdev->dev, NULL);
         if (IS_ERR(spi_imx->clk)) {
                 dev_err(&pdev->dev, "unable to get clock\n");
@@ -595,15 +868,9 @@ static int __devinit spi_imx_probe(struct platform_device *pdev)
         clk_enable(spi_imx->clk);
         spi_imx->spi_clk = clk_get_rate(spi_imx->clk);
 
-        if (cpu_is_mx1() || cpu_is_mx21() || cpu_is_mx27())
-                writel(1, spi_imx->base + MXC_RESET);
-
-        /* drain receive buffer */
-        if (cpu_is_mx25() || cpu_is_mx31() || cpu_is_mx35())
-                while (readl(spi_imx->base + MX3_CSPISTAT) & MX3_CSPISTAT_RR)
-                        readl(spi_imx->base + MXC_CSPIRXDATA);
+        spi_imx->devtype_data.reset(spi_imx);
 
-        spi_imx->intctrl(spi_imx, 0);
+        spi_imx->devtype_data.intctrl(spi_imx, 0);
 
         ret = spi_bitbang_start(&spi_imx->bitbang);
         if (ret) {
@@ -668,6 +935,7 @@ static struct platform_driver spi_imx_driver = {
                    .name = DRIVER_NAME,
                    .owner = THIS_MODULE,
                    },
+        .id_table = spi_imx_devtype,
         .probe = spi_imx_probe,
         .remove = __devexit_p(spi_imx_remove),
 };
diff --git a/drivers/spi/spi_s3c64xx.c b/drivers/spi/spi_s3c64xx.c
index c3038da2648a..795828b90f45 100644
--- a/drivers/spi/spi_s3c64xx.c
+++ b/drivers/spi/spi_s3c64xx.c
@@ -261,15 +261,25 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                 chcfg |= S3C64XX_SPI_CH_TXCH_ON;
                 if (dma_mode) {
                         modecfg |= S3C64XX_SPI_MODE_TXDMA_ON;
-                        s3c2410_dma_config(sdd->tx_dmach, 1);
+                        s3c2410_dma_config(sdd->tx_dmach, sdd->cur_bpw / 8);
                         s3c2410_dma_enqueue(sdd->tx_dmach, (void *)sdd,
                                                 xfer->tx_dma, xfer->len);
                         s3c2410_dma_ctrl(sdd->tx_dmach, S3C2410_DMAOP_START);
                 } else {
-                        unsigned char *buf = (unsigned char *) xfer->tx_buf;
-                        int i = 0;
-                        while (i < xfer->len)
-                                writeb(buf[i++], regs + S3C64XX_SPI_TX_DATA);
+                        switch (sdd->cur_bpw) {
+                        case 32:
+                                iowrite32_rep(regs + S3C64XX_SPI_TX_DATA,
+                                        xfer->tx_buf, xfer->len / 4);
+                                break;
+                        case 16:
+                                iowrite16_rep(regs + S3C64XX_SPI_TX_DATA,
+                                        xfer->tx_buf, xfer->len / 2);
+                                break;
+                        default:
+                                iowrite8_rep(regs + S3C64XX_SPI_TX_DATA,
+                                        xfer->tx_buf, xfer->len);
+                                break;
+                        }
                 }
         }
 
@@ -286,7 +296,7 @@ static void enable_datapath(struct s3c64xx_spi_driver_data *sdd,
                         writel(((xfer->len * 8 / sdd->cur_bpw) & 0xffff)
                                         | S3C64XX_SPI_PACKET_CNT_EN,
                                         regs + S3C64XX_SPI_PACKET_CNT);
-                        s3c2410_dma_config(sdd->rx_dmach, 1);
+                        s3c2410_dma_config(sdd->rx_dmach, sdd->cur_bpw / 8);
                         s3c2410_dma_enqueue(sdd->rx_dmach, (void *)sdd,
                                                 xfer->rx_dma, xfer->len);
                         s3c2410_dma_ctrl(sdd->rx_dmach, S3C2410_DMAOP_START);
@@ -366,20 +376,26 @@ static int wait_for_xfer(struct s3c64xx_spi_driver_data *sdd,
                                 return -EIO;
                 }
         } else {
-                unsigned char *buf;
-                int i;
-
                 /* If it was only Tx */
                 if (xfer->rx_buf == NULL) {
                         sdd->state &= ~TXBUSY;
                         return 0;
                 }
 
-                i = 0;
-                buf = xfer->rx_buf;
-                while (i < xfer->len)
-                        buf[i++] = readb(regs + S3C64XX_SPI_RX_DATA);
-
+                switch (sdd->cur_bpw) {
+                case 32:
+                        ioread32_rep(regs + S3C64XX_SPI_RX_DATA,
+                                xfer->rx_buf, xfer->len / 4);
+                        break;
+                case 16:
+                        ioread16_rep(regs + S3C64XX_SPI_RX_DATA,
+                                xfer->rx_buf, xfer->len / 2);
+                        break;
+                default:
+                        ioread8_rep(regs + S3C64XX_SPI_RX_DATA,
+                                xfer->rx_buf, xfer->len);
+                        break;
+                }
                 sdd->state &= ~RXBUSY;
         }
 
@@ -399,13 +415,18 @@ static inline void disable_cs(struct s3c64xx_spi_driver_data *sdd,
 
 static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         void __iomem *regs = sdd->regs;
         u32 val;
 
         /* Disable Clock */
-        val = readl(regs + S3C64XX_SPI_CLK_CFG);
-        val &= ~S3C64XX_SPI_ENCLK_ENABLE;
-        writel(val, regs + S3C64XX_SPI_CLK_CFG);
+        if (sci->clk_from_cmu) {
+                clk_disable(sdd->src_clk);
+        } else {
+                val = readl(regs + S3C64XX_SPI_CLK_CFG);
+                val &= ~S3C64XX_SPI_ENCLK_ENABLE;
+                writel(val, regs + S3C64XX_SPI_CLK_CFG);
+        }
 
         /* Set Polarity and Phase */
         val = readl(regs + S3C64XX_SPI_CH_CFG);
@@ -429,29 +450,39 @@ static void s3c64xx_spi_config(struct s3c64xx_spi_driver_data *sdd)
         switch (sdd->cur_bpw) {
         case 32:
                 val |= S3C64XX_SPI_MODE_BUS_TSZ_WORD;
+                val |= S3C64XX_SPI_MODE_CH_TSZ_WORD;
                 break;
         case 16:
                 val |= S3C64XX_SPI_MODE_BUS_TSZ_HALFWORD;
+                val |= S3C64XX_SPI_MODE_CH_TSZ_HALFWORD;
                 break;
         default:
                 val |= S3C64XX_SPI_MODE_BUS_TSZ_BYTE;
+                val |= S3C64XX_SPI_MODE_CH_TSZ_BYTE;
                 break;
         }
-        val |= S3C64XX_SPI_MODE_CH_TSZ_BYTE; /* Always 8bits wide */
 
         writel(val, regs + S3C64XX_SPI_MODE_CFG);
 
-        /* Configure Clock */
-        val = readl(regs + S3C64XX_SPI_CLK_CFG);
-        val &= ~S3C64XX_SPI_PSR_MASK;
-        val |= ((clk_get_rate(sdd->src_clk) / sdd->cur_speed / 2 - 1)
-                        & S3C64XX_SPI_PSR_MASK);
-        writel(val, regs + S3C64XX_SPI_CLK_CFG);
-
-        /* Enable Clock */
-        val = readl(regs + S3C64XX_SPI_CLK_CFG);
-        val |= S3C64XX_SPI_ENCLK_ENABLE;
-        writel(val, regs + S3C64XX_SPI_CLK_CFG);
+        if (sci->clk_from_cmu) {
+                /* Configure Clock */
+                /* There is half-multiplier before the SPI */
+                clk_set_rate(sdd->src_clk, sdd->cur_speed * 2);
+                /* Enable Clock */
+                clk_enable(sdd->src_clk);
+        } else {
+                /* Configure Clock */
+                val = readl(regs + S3C64XX_SPI_CLK_CFG);
+                val &= ~S3C64XX_SPI_PSR_MASK;
+                val |= ((clk_get_rate(sdd->src_clk) / sdd->cur_speed / 2 - 1)
+                                & S3C64XX_SPI_PSR_MASK);
+                writel(val, regs + S3C64XX_SPI_CLK_CFG);
+
+                /* Enable Clock */
+                val = readl(regs + S3C64XX_SPI_CLK_CFG);
+                val |= S3C64XX_SPI_ENCLK_ENABLE;
+                writel(val, regs + S3C64XX_SPI_CLK_CFG);
+        }
 }
 
 static void s3c64xx_spi_dma_rxcb(struct s3c2410_dma_chan *chan, void *buf_id,
@@ -499,6 +530,7 @@ static void s3c64xx_spi_dma_txcb(struct s3c2410_dma_chan *chan, void *buf_id,
 static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
                                                 struct spi_message *msg)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct device *dev = &sdd->pdev->dev;
         struct spi_transfer *xfer;
 
@@ -514,6 +546,9 @@ static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
         /* Map until end or first fail */
         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
 
+                if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1))
+                        continue;
+
                 if (xfer->tx_buf != NULL) {
                         xfer->tx_dma = dma_map_single(dev,
                                         (void *)xfer->tx_buf, xfer->len,
@@ -545,6 +580,7 @@ static int s3c64xx_spi_map_mssg(struct s3c64xx_spi_driver_data *sdd,
 static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
                                                 struct spi_message *msg)
 {
+        struct s3c64xx_spi_info *sci = sdd->cntrlr_info;
         struct device *dev = &sdd->pdev->dev;
         struct spi_transfer *xfer;
 
@@ -553,6 +589,9 @@ static void s3c64xx_spi_unmap_mssg(struct s3c64xx_spi_driver_data *sdd,
 
         list_for_each_entry(xfer, &msg->transfers, transfer_list) {
 
+                if (xfer->len <= ((sci->fifo_lvl_mask >> 1) + 1))
+                        continue;
+
                 if (xfer->rx_buf != NULL
                                 && xfer->rx_dma != XFER_DMAADDR_INVALID)
                         dma_unmap_single(dev, xfer->rx_dma,
@@ -608,6 +647,14 @@ static void handle_msg(struct s3c64xx_spi_driver_data *sdd,
                 bpw = xfer->bits_per_word ? : spi->bits_per_word;
                 speed = xfer->speed_hz ? : spi->max_speed_hz;
 
+                if (xfer->len % (bpw / 8)) {
+                        dev_err(&spi->dev,
+                                "Xfer length(%u) not a multiple of word size(%u)\n",
+                                xfer->len, bpw / 8);
+                        status = -EIO;
+                        goto out;
+                }
+
                 if (bpw != sdd->cur_bpw || speed != sdd->cur_speed) {
                         sdd->cur_bpw = bpw;
                         sdd->cur_speed = speed;
@@ -798,7 +845,6 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
         struct s3c64xx_spi_driver_data *sdd;
         struct s3c64xx_spi_info *sci;
         struct spi_message *msg;
-        u32 psr, speed;
         unsigned long flags;
         int err = 0;
 
@@ -841,32 +887,37 @@ static int s3c64xx_spi_setup(struct spi_device *spi)
         }
 
         /* Check if we can provide the requested rate */
-        speed = clk_get_rate(sdd->src_clk) / 2 / (0 + 1); /* Max possible */
-
-        if (spi->max_speed_hz > speed)
-                spi->max_speed_hz = speed;
-
-        psr = clk_get_rate(sdd->src_clk) / 2 / spi->max_speed_hz - 1;
-        psr &= S3C64XX_SPI_PSR_MASK;
-        if (psr == S3C64XX_SPI_PSR_MASK)
-                psr--;
+        if (!sci->clk_from_cmu) {
+                u32 psr, speed;
+
+                /* Max possible */
+                speed = clk_get_rate(sdd->src_clk) / 2 / (0 + 1);
+
+                if (spi->max_speed_hz > speed)
+                        spi->max_speed_hz = speed;
+
+                psr = clk_get_rate(sdd->src_clk) / 2 / spi->max_speed_hz - 1;
+                psr &= S3C64XX_SPI_PSR_MASK;
+                if (psr == S3C64XX_SPI_PSR_MASK)
+                        psr--;
+
+                speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
+                if (spi->max_speed_hz < speed) {
+                        if (psr+1 < S3C64XX_SPI_PSR_MASK) {
+                                psr++;
+                        } else {
+                                err = -EINVAL;
+                                goto setup_exit;
+                        }
+                }
 
-        speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
-        if (spi->max_speed_hz < speed) {
-                if (psr+1 < S3C64XX_SPI_PSR_MASK) {
-                        psr++;
-                } else {
+                speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
+                if (spi->max_speed_hz >= speed)
+                        spi->max_speed_hz = speed;
+                else
                         err = -EINVAL;
-                        goto setup_exit;
-                }
         }
 
-        speed = clk_get_rate(sdd->src_clk) / 2 / (psr + 1);
-        if (spi->max_speed_hz >= speed)
-                spi->max_speed_hz = speed;
-        else
-                err = -EINVAL;
-
 setup_exit:
 
         /* setup() returns with device de-selected */
@@ -888,7 +939,8 @@ static void s3c64xx_spi_hwinit(struct s3c64xx_spi_driver_data *sdd, int channel)
         /* Disable Interrupts - we use Polling if not DMA mode */
         writel(0, regs + S3C64XX_SPI_INT_EN);
 
-        writel(sci->src_clk_nr << S3C64XX_SPI_CLKSEL_SRCSHFT,
+        if (!sci->clk_from_cmu)
+                writel(sci->src_clk_nr << S3C64XX_SPI_CLKSEL_SRCSHFT,
                                 regs + S3C64XX_SPI_CLK_CFG);
         writel(0, regs + S3C64XX_SPI_MODE_CFG);
         writel(0, regs + S3C64XX_SPI_PACKET_CNT);
diff --git a/drivers/spi/spi_topcliff_pch.c b/drivers/spi/spi_topcliff_pch.c
new file mode 100644
index 000000000000..58e187f45ec7
--- /dev/null
+++ b/drivers/spi/spi_topcliff_pch.c
@@ -0,0 +1,1303 @@
+/*
+ * SPI bus driver for the Topcliff PCH used by Intel SoCs
+ *
+ * Copyright (C) 2010 OKI SEMICONDUCTOR Co., LTD.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; version 2 of the License.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#include <linux/delay.h>
+#include <linux/pci.h>
+#include <linux/wait.h>
+#include <linux/spi/spi.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <linux/spi/spidev.h>
+#include <linux/module.h>
+#include <linux/device.h>
+
+/* Register offsets */
+#define PCH_SPCR                0x00    /* SPI control register */
+#define PCH_SPBRR               0x04    /* SPI baud rate register */
+#define PCH_SPSR                0x08    /* SPI status register */
+#define PCH_SPDWR               0x0C    /* SPI write data register */
+#define PCH_SPDRR               0x10    /* SPI read data register */
+#define PCH_SSNXCR              0x18    /* SSN Expand Control Register */
+#define PCH_SRST                0x1C    /* SPI reset register */
+
+#define PCH_SPSR_TFD            0x000007C0
+#define PCH_SPSR_RFD            0x0000F800
+
+#define PCH_READABLE(x)         (((x) & PCH_SPSR_RFD)>>11)
+#define PCH_WRITABLE(x)         (((x) & PCH_SPSR_TFD)>>6)
+
+#define PCH_RX_THOLD            7
+#define PCH_RX_THOLD_MAX        15
+
+#define PCH_MAX_BAUDRATE        5000000
+#define PCH_MAX_FIFO_DEPTH      16
+
+#define STATUS_RUNNING          1
+#define STATUS_EXITING          2
+#define PCH_SLEEP_TIME          10
+
+#define PCH_ADDRESS_SIZE        0x20
+
+#define SSN_LOW                 0x02U
+#define SSN_NO_CONTROL          0x00U
+#define PCH_MAX_CS              0xFF
+#define PCI_DEVICE_ID_GE_SPI    0x8816
+
+#define SPCR_SPE_BIT            (1 << 0)
+#define SPCR_MSTR_BIT           (1 << 1)
+#define SPCR_LSBF_BIT           (1 << 4)
+#define SPCR_CPHA_BIT           (1 << 5)
+#define SPCR_CPOL_BIT           (1 << 6)
+#define SPCR_TFIE_BIT           (1 << 8)
+#define SPCR_RFIE_BIT           (1 << 9)
+#define SPCR_FIE_BIT            (1 << 10)
+#define SPCR_ORIE_BIT           (1 << 11)
+#define SPCR_MDFIE_BIT          (1 << 12)
+#define SPCR_FICLR_BIT          (1 << 24)
+#define SPSR_TFI_BIT            (1 << 0)
+#define SPSR_RFI_BIT            (1 << 1)
+#define SPSR_FI_BIT             (1 << 2)
+#define SPBRR_SIZE_BIT          (1 << 10)
+
+#define PCH_ALL                 (SPCR_TFIE_BIT|SPCR_RFIE_BIT|SPCR_FIE_BIT|SPCR_ORIE_BIT|SPCR_MDFIE_BIT)
+
+#define SPCR_RFIC_FIELD         20
+#define SPCR_TFIC_FIELD         16
+
+#define SPSR_INT_BITS           0x1F
+#define MASK_SPBRR_SPBR_BITS    (~((1 << 10) - 1))
+#define MASK_RFIC_SPCR_BITS     (~(0xf << 20))
+#define MASK_TFIC_SPCR_BITS     (~(0xf000f << 12))
+
+#define PCH_CLOCK_HZ            50000000
+#define PCH_MAX_SPBR            1023
+
+
+/**
+ * struct pch_spi_data - Holds the SPI channel specific details
+ * @io_remap_addr:              The remapped PCI base address
+ * @master:                     Pointer to the SPI master structure
+ * @work:                       Reference to work queue handler
+ * @wk:                         Workqueue for carrying out execution of the
+ *                              requests
+ * @wait:                       Wait queue for waking up upon receiving an
+ *                              interrupt.
+ * @transfer_complete:          Status of SPI Transfer
+ * @bcurrent_msg_processing:    Status flag for message processing
+ * @lock:                       Lock for protecting this structure
+ * @queue:                      SPI Message queue
+ * @status:                     Status of the SPI driver
+ * @bpw_len:                    Length of data to be transferred in bits per
+ *                              word
+ * @transfer_active:            Flag showing active transfer
+ * @tx_index:                   Transmit data count; for bookkeeping during
+ *                              transfer
+ * @rx_index:                   Receive data count; for bookkeeping during
+ *                              transfer
+ * @tx_buff:                    Buffer for data to be transmitted
+ * @rx_index:                   Buffer for Received data
+ * @n_curnt_chip:               The chip number that this SPI driver currently
+ *                              operates on
+ * @current_chip:               Reference to the current chip that this SPI
+ *                              driver currently operates on
+ * @current_msg:                The current message that this SPI driver is
+ *                              handling
+ * @cur_trans:                  The current transfer that this SPI driver is
+ *                              handling
+ * @board_dat:                  Reference to the SPI device data structure
+ */
+struct pch_spi_data {
+        void __iomem *io_remap_addr;
+        struct spi_master *master;
+        struct work_struct work;
+        struct workqueue_struct *wk;
+        wait_queue_head_t wait;
+        u8 transfer_complete;
+        u8 bcurrent_msg_processing;
+        spinlock_t lock;
+        struct list_head queue;
+        u8 status;
+        u32 bpw_len;
+        u8 transfer_active;
+        u32 tx_index;
+        u32 rx_index;
+        u16 *pkt_tx_buff;
+        u16 *pkt_rx_buff;
+        u8 n_curnt_chip;
+        struct spi_device *current_chip;
+        struct spi_message *current_msg;
+        struct spi_transfer *cur_trans;
+        struct pch_spi_board_data *board_dat;
+};
+
+/**
+ * struct pch_spi_board_data - Holds the SPI device specific details
+ * @pdev:               Pointer to the PCI device
+ * @irq_reg_sts:        Status of IRQ registration
+ * @pci_req_sts:        Status of pci_request_regions
+ * @suspend_sts:        Status of suspend
+ * @data:               Pointer to SPI channel data structure
+ */
+struct pch_spi_board_data {
+        struct pci_dev *pdev;
+        u8 irq_reg_sts;
+        u8 pci_req_sts;
+        u8 suspend_sts;
+        struct pch_spi_data *data;
+};
+
+static struct pci_device_id pch_spi_pcidev_id[] = {
+        {PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_GE_SPI)},
+        {0,}
+};
+
+/**
+ * pch_spi_writereg() - Performs  register writes
+ * @master:     Pointer to struct spi_master.
+ * @idx:        Register offset.
+ * @val:        Value to be written to register.
+ */
+static inline void pch_spi_writereg(struct spi_master *master, int idx, u32 val)
+{
+        struct pch_spi_data *data = spi_master_get_devdata(master);
+        iowrite32(val, (data->io_remap_addr + idx));
+}
+
+/**
+ * pch_spi_readreg() - Performs register reads
+ * @master:     Pointer to struct spi_master.
+ * @idx:        Register offset.
+ */
+static inline u32 pch_spi_readreg(struct spi_master *master, int idx)
+{
+        struct pch_spi_data *data = spi_master_get_devdata(master);
+        return ioread32(data->io_remap_addr + idx);
+}
+
+static inline void pch_spi_setclr_reg(struct spi_master *master, int idx,
+                                      u32 set, u32 clr)
+{
+        u32 tmp = pch_spi_readreg(master, idx);
+        tmp = (tmp & ~clr) | set;
+        pch_spi_writereg(master, idx, tmp);
+}
+
+static void pch_spi_set_master_mode(struct spi_master *master)
+{
+        pch_spi_setclr_reg(master, PCH_SPCR, SPCR_MSTR_BIT, 0);
+}
+
+/**
+ * pch_spi_clear_fifo() - Clears the Transmit and Receive FIFOs
+ * @master:     Pointer to struct spi_master.
+ */
+static void pch_spi_clear_fifo(struct spi_master *master)
+{
+        pch_spi_setclr_reg(master, PCH_SPCR, SPCR_FICLR_BIT, 0);
+        pch_spi_setclr_reg(master, PCH_SPCR, 0, SPCR_FICLR_BIT);
+}
+
+static void pch_spi_handler_sub(struct pch_spi_data *data, u32 reg_spsr_val,
+                                void __iomem *io_remap_addr)
+{
+        u32 n_read, tx_index, rx_index, bpw_len;
+        u16 *pkt_rx_buffer, *pkt_tx_buff;
+        int read_cnt;
+        u32 reg_spcr_val;
+        void __iomem *spsr;
+        void __iomem *spdrr;
+        void __iomem *spdwr;
+
+        spsr = io_remap_addr + PCH_SPSR;
+        iowrite32(reg_spsr_val, spsr);
+
+        if (data->transfer_active) {
+                rx_index = data->rx_index;
+                tx_index = data->tx_index;
+                bpw_len = data->bpw_len;
+                pkt_rx_buffer = data->pkt_rx_buff;
+                pkt_tx_buff = data->pkt_tx_buff;
+
+                spdrr = io_remap_addr + PCH_SPDRR;
+                spdwr = io_remap_addr + PCH_SPDWR;
+
+                n_read = PCH_READABLE(reg_spsr_val);
+
+                for (read_cnt = 0; (read_cnt < n_read); read_cnt++) {
+                        pkt_rx_buffer[rx_index++] = ioread32(spdrr);
+                        if (tx_index < bpw_len)
+                                iowrite32(pkt_tx_buff[tx_index++], spdwr);
+                }
+
+                /* disable RFI if not needed */
+                if ((bpw_len - rx_index) <= PCH_MAX_FIFO_DEPTH) {
+                        reg_spcr_val = ioread32(io_remap_addr + PCH_SPCR);
+                        reg_spcr_val &= ~SPCR_RFIE_BIT; /* disable RFI */
+
+                        /* reset rx threshold */
+                        reg_spcr_val &= MASK_RFIC_SPCR_BITS;
+                        reg_spcr_val |= (PCH_RX_THOLD_MAX << SPCR_RFIC_FIELD);
+                        iowrite32(((reg_spcr_val) &= (~(SPCR_RFIE_BIT))),
+                                 (io_remap_addr + PCH_SPCR));
+                }
+
+                /* update counts */
+                data->tx_index = tx_index;
+                data->rx_index = rx_index;
+
+        }
+
+        /* if transfer complete interrupt */
+        if (reg_spsr_val & SPSR_FI_BIT) {
+                /* disable FI & RFI interrupts */
+                pch_spi_setclr_reg(data->master, PCH_SPCR, 0,
+                                   SPCR_FIE_BIT | SPCR_TFIE_BIT);
+
+                /* transfer is completed;inform pch_spi_process_messages */
+                data->transfer_complete = true;
+                wake_up(&data->wait);
+        }
+}
+
+/**
+ * pch_spi_handler() - Interrupt handler
+ * @irq:        The interrupt number.
+ * @dev_id:     Pointer to struct pch_spi_board_data.
+ */
+static irqreturn_t pch_spi_handler(int irq, void *dev_id)
+{
+        u32 reg_spsr_val;
+        struct pch_spi_data *data;
+        void __iomem *spsr;
+        void __iomem *io_remap_addr;
+        irqreturn_t ret = IRQ_NONE;
+        struct pch_spi_board_data *board_dat = dev_id;
+
+        if (board_dat->suspend_sts) {
+                dev_dbg(&board_dat->pdev->dev,
+                        "%s returning due to suspend\n", __func__);
+                return IRQ_NONE;
+        }
+
+        data = board_dat->data;
+        io_remap_addr = data->io_remap_addr;
+        spsr = io_remap_addr + PCH_SPSR;
+
+        reg_spsr_val = ioread32(spsr);
+
+        /* Check if the interrupt is for SPI device */
+        if (reg_spsr_val & (SPSR_FI_BIT | SPSR_RFI_BIT)) {
+                pch_spi_handler_sub(data, reg_spsr_val, io_remap_addr);
+                ret = IRQ_HANDLED;
+        }
+
+        dev_dbg(&board_dat->pdev->dev, "%s EXIT return value=%d\n",
+                __func__, ret);
+
+        return ret;
+}
+
+/**
+ * pch_spi_set_baud_rate() - Sets SPBR field in SPBRR
+ * @master:     Pointer to struct spi_master.
+ * @speed_hz:   Baud rate.
+ */
+static void pch_spi_set_baud_rate(struct spi_master *master, u32 speed_hz)
+{
+        u32 n_spbr = PCH_CLOCK_HZ / (speed_hz * 2);
+
+        /* if baud rate is less than we can support limit it */
+        if (n_spbr > PCH_MAX_SPBR)
+                n_spbr = PCH_MAX_SPBR;
+
+        pch_spi_setclr_reg(master, PCH_SPBRR, n_spbr, ~MASK_SPBRR_SPBR_BITS);
+}
+
+/**
+ * pch_spi_set_bits_per_word() - Sets SIZE field in SPBRR
+ * @master:             Pointer to struct spi_master.
+ * @bits_per_word:      Bits per word for SPI transfer.
+ */
+static void pch_spi_set_bits_per_word(struct spi_master *master,
+                                      u8 bits_per_word)
+{
+        if (bits_per_word == 8)
+                pch_spi_setclr_reg(master, PCH_SPBRR, 0, SPBRR_SIZE_BIT);
+        else
+                pch_spi_setclr_reg(master, PCH_SPBRR, SPBRR_SIZE_BIT, 0);
+}
+
+/**
+ * pch_spi_setup_transfer() - Configures the PCH SPI hardware for transfer
+ * @spi:        Pointer to struct spi_device.
+ */
+static void pch_spi_setup_transfer(struct spi_device *spi)
+{
+        u32 flags = 0;
+
+        dev_dbg(&spi->dev, "%s SPBRR content =%x setting baud rate=%d\n",
+                __func__, pch_spi_readreg(spi->master, PCH_SPBRR),
+                spi->max_speed_hz);
+        pch_spi_set_baud_rate(spi->master, spi->max_speed_hz);
+
+        /* set bits per word */
+        pch_spi_set_bits_per_word(spi->master, spi->bits_per_word);
+
+        if (!(spi->mode & SPI_LSB_FIRST))
+                flags |= SPCR_LSBF_BIT;
+        if (spi->mode & SPI_CPOL)
+                flags |= SPCR_CPOL_BIT;
+        if (spi->mode & SPI_CPHA)
+                flags |= SPCR_CPHA_BIT;
+        pch_spi_setclr_reg(spi->master, PCH_SPCR, flags,
+                           (SPCR_LSBF_BIT | SPCR_CPOL_BIT | SPCR_CPHA_BIT));
+
+        /* Clear the FIFO by toggling  FICLR to 1 and back to 0 */
+        pch_spi_clear_fifo(spi->master);
+}
+
+/**
+ * pch_spi_reset() - Clears SPI registers
+ * @master:     Pointer to struct spi_master.
+ */
+static void pch_spi_reset(struct spi_master *master)
+{
+        /* write 1 to reset SPI */
+        pch_spi_writereg(master, PCH_SRST, 0x1);
+
+        /* clear reset */
+        pch_spi_writereg(master, PCH_SRST, 0x0);
+}
+
+static int pch_spi_setup(struct spi_device *pspi)
+{
+        /* check bits per word */
+        if (pspi->bits_per_word == 0) {
+                pspi->bits_per_word = 8;
+                dev_dbg(&pspi->dev, "%s 8 bits per word\n", __func__);
+        }
+
+        if ((pspi->bits_per_word != 8) && (pspi->bits_per_word != 16)) {
+                dev_err(&pspi->dev, "%s Invalid bits per word\n", __func__);
+                return -EINVAL;
+        }
+
+        /* Check baud rate setting */
+        /* if baud rate of chip is greater than
+           max we can support,return error */
+        if ((pspi->max_speed_hz) > PCH_MAX_BAUDRATE)
+                pspi->max_speed_hz = PCH_MAX_BAUDRATE;
+
+        dev_dbg(&pspi->dev, "%s MODE = %x\n", __func__,
+                (pspi->mode) & (SPI_CPOL | SPI_CPHA));
+
+        return 0;
+}
+
+static int pch_spi_transfer(struct spi_device *pspi, struct spi_message *pmsg)
+{
+
+        struct spi_transfer *transfer;
+        struct pch_spi_data *data = spi_master_get_devdata(pspi->master);
+        int retval;
+        unsigned long flags;
+
+        /* validate spi message and baud rate */
+        if (unlikely(list_empty(&pmsg->transfers) == 1)) {
+                dev_err(&pspi->dev, "%s list empty\n", __func__);
+                retval = -EINVAL;
+                goto err_out;
+        }
+
+        if (unlikely(pspi->max_speed_hz == 0)) {
+                dev_err(&pspi->dev, "%s pch_spi_tranfer maxspeed=%d\n",
+                        __func__, pspi->max_speed_hz);
+                retval = -EINVAL;
+                goto err_out;
+        }
+
+        dev_dbg(&pspi->dev, "%s Transfer List not empty. "
+                "Transfer Speed is set.\n", __func__);
+
+        /* validate Tx/Rx buffers and Transfer length */
+        list_for_each_entry(transfer, &pmsg->transfers, transfer_list) {
+                if (!transfer->tx_buf && !transfer->rx_buf) {
+                        dev_err(&pspi->dev,
+                                "%s Tx and Rx buffer NULL\n", __func__);
+                        retval = -EINVAL;
+                        goto err_out;
+                }
+
+                if (!transfer->len) {
+                        dev_err(&pspi->dev, "%s Transfer length invalid\n",
+                                __func__);
+                        retval = -EINVAL;
+                        goto err_out;
+                }
+
+                dev_dbg(&pspi->dev, "%s Tx/Rx buffer valid. Transfer length"
+                        " valid\n", __func__);
+
+                /* if baud rate hs been specified validate the same */
+                if (transfer->speed_hz > PCH_MAX_BAUDRATE)
+                        transfer->speed_hz = PCH_MAX_BAUDRATE;
+
+                /* if bits per word has been specified validate the same */
+                if (transfer->bits_per_word) {
+                        if ((transfer->bits_per_word != 8)
+                            && (transfer->bits_per_word != 16)) {
+                                retval = -EINVAL;
+                                dev_err(&pspi->dev,
+                                        "%s Invalid bits per word\n", __func__);
+                                goto err_out;
+                        }
+                }
+        }
+
+        spin_lock_irqsave(&data->lock, flags);
+
+        /* We won't process any messages if we have been asked to terminate */
+        if (data->status == STATUS_EXITING) {
+                dev_err(&pspi->dev, "%s status = STATUS_EXITING.\n", __func__);
+                retval = -ESHUTDOWN;
+                goto err_return_spinlock;
+        }
+
+        /* If suspended ,return -EINVAL */
+        if (data->board_dat->suspend_sts) {
+                dev_err(&pspi->dev, "%s suspend; returning EINVAL\n", __func__);
+                retval = -EINVAL;
+                goto err_return_spinlock;
+        }
+
+        /* set status of message */
+        pmsg->actual_length = 0;
+        dev_dbg(&pspi->dev, "%s - pmsg->status =%d\n", __func__, pmsg->status);
+
+        pmsg->status = -EINPROGRESS;
+
+        /* add message to queue */
+        list_add_tail(&pmsg->queue, &data->queue);
+        dev_dbg(&pspi->dev, "%s - Invoked list_add_tail\n", __func__);
+
+        /* schedule work queue to run */
+        queue_work(data->wk, &data->work);
+        dev_dbg(&pspi->dev, "%s - Invoked queue work\n", __func__);
+
+        retval = 0;
+
+err_return_spinlock:
+        spin_unlock_irqrestore(&data->lock, flags);
+err_out:
+        dev_dbg(&pspi->dev, "%s RETURN=%d\n", __func__, retval);
+        return retval;
+}
+
+static inline void pch_spi_select_chip(struct pch_spi_data *data,
+                                       struct spi_device *pspi)
+{
+        if (data->current_chip != NULL) {
+                if (pspi->chip_select != data->n_curnt_chip) {
+                        dev_dbg(&pspi->dev, "%s : different slave\n", __func__);
+                        data->current_chip = NULL;
+                }
+        }
+
+        data->current_chip = pspi;
+
+        data->n_curnt_chip = data->current_chip->chip_select;
+
+        dev_dbg(&pspi->dev, "%s :Invoking pch_spi_setup_transfer\n", __func__);
+        pch_spi_setup_transfer(pspi);
+}
+
+static void pch_spi_set_tx(struct pch_spi_data *data, int *bpw,
+                           struct spi_message **ppmsg)
+{
+        int size;
+        u32 n_writes;
+        int j;
+        struct spi_message *pmsg;
+        const u8 *tx_buf;
+        const u16 *tx_sbuf;
+
+        pmsg = *ppmsg;
+
+        /* set baud rate if needed */
+        if (data->cur_trans->speed_hz) {
+                dev_dbg(&data->master->dev, "%s:setting baud rate\n", __func__);
+                pch_spi_set_baud_rate(data->master, data->cur_trans->speed_hz);
+        }
+
+        /* set bits per word if needed */
+        if (data->cur_trans->bits_per_word &&
+            (data->current_msg->spi->bits_per_word != data->cur_trans->bits_per_word)) {
+                dev_dbg(&data->master->dev, "%s:set bits per word\n", __func__);
+                pch_spi_set_bits_per_word(data->master,
+                                          data->cur_trans->bits_per_word);
+                *bpw = data->cur_trans->bits_per_word;
+        } else {
+                *bpw = data->current_msg->spi->bits_per_word;
+        }
+
+        /* reset Tx/Rx index */
+        data->tx_index = 0;
+        data->rx_index = 0;
+
+        data->bpw_len = data->cur_trans->len / (*bpw / 8);
+
+        /* find alloc size */
+        size = data->cur_trans->len * sizeof(*data->pkt_tx_buff);
+
+        /* allocate memory for pkt_tx_buff & pkt_rx_buffer */
+        data->pkt_tx_buff = kzalloc(size, GFP_KERNEL);
+        if (data->pkt_tx_buff != NULL) {
+                data->pkt_rx_buff = kzalloc(size, GFP_KERNEL);
+                if (!data->pkt_rx_buff)
+                        kfree(data->pkt_tx_buff);
+        }
+
+        if (!data->pkt_rx_buff) {
+                /* flush queue and set status of all transfers to -ENOMEM */
+                dev_err(&data->master->dev, "%s :kzalloc failed\n", __func__);
+                list_for_each_entry(pmsg, data->queue.next, queue) {
+                        pmsg->status = -ENOMEM;
+
+                        if (pmsg->complete != 0)
+                                pmsg->complete(pmsg->context);
+
+                        /* delete from queue */
+                        list_del_init(&pmsg->queue);
+                }
+                return;
+        }
+
+        /* copy Tx Data */
+        if (data->cur_trans->tx_buf != NULL) {
+                if (*bpw == 8) {
+                        tx_buf = data->cur_trans->tx_buf;
+                        for (j = 0; j < data->bpw_len; j++)
+                                data->pkt_tx_buff[j] = *tx_buf++;
+                } else {
+                        tx_sbuf = data->cur_trans->tx_buf;
+                        for (j = 0; j < data->bpw_len; j++)
+                                data->pkt_tx_buff[j] = *tx_sbuf++;
+                }
+        }
+
+        /* if len greater than PCH_MAX_FIFO_DEPTH, write 16,else len bytes */
+        n_writes = data->bpw_len;
+        if (n_writes > PCH_MAX_FIFO_DEPTH)
+                n_writes = PCH_MAX_FIFO_DEPTH;
+
+        dev_dbg(&data->master->dev, "\n%s:Pulling down SSN low - writing "
+                "0x2 to SSNXCR\n", __func__);
+        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_LOW);
+
+        for (j = 0; j < n_writes; j++)
+                pch_spi_writereg(data->master, PCH_SPDWR, data->pkt_tx_buff[j]);
+
+        /* update tx_index */
+        data->tx_index = j;
+
+        /* reset transfer complete flag */
+        data->transfer_complete = false;
+        data->transfer_active = true;
+}
+
+
+static void pch_spi_nomore_transfer(struct pch_spi_data *data,
+                                                struct spi_message *pmsg)
+{
+        dev_dbg(&data->master->dev, "%s called\n", __func__);
+        /* Invoke complete callback
+         * [To the spi core..indicating end of transfer] */
+        data->current_msg->status = 0;
+
+        if (data->current_msg->complete != 0) {
+                dev_dbg(&data->master->dev,
+                        "%s:Invoking callback of SPI core\n", __func__);
+                data->current_msg->complete(data->current_msg->context);
+        }
+
+        /* update status in global variable */
+        data->bcurrent_msg_processing = false;
+
+        dev_dbg(&data->master->dev,
+                "%s:data->bcurrent_msg_processing = false\n", __func__);
+
+        data->current_msg = NULL;
+        data->cur_trans = NULL;
+
+        /* check if we have items in list and not suspending
+         * return 1 if list empty */
+        if ((list_empty(&data->queue) == 0) &&
+            (!data->board_dat->suspend_sts) &&
+            (data->status != STATUS_EXITING)) {
+                /* We have some more work to do (either there is more tranint
+                 * bpw;sfer requests in the current message or there are
+                 *more messages)
+                 */
+                dev_dbg(&data->master->dev, "%s:Invoke queue_work\n", __func__);
+                queue_work(data->wk, &data->work);
+        } else if (data->board_dat->suspend_sts ||
+                   data->status == STATUS_EXITING) {
+                dev_dbg(&data->master->dev,
+                        "%s suspend/remove initiated, flushing queue\n",
+                        __func__);
+                list_for_each_entry(pmsg, data->queue.next, queue) {
+                        pmsg->status = -EIO;
+
+                        if (pmsg->complete)
+                                pmsg->complete(pmsg->context);
+
+                        /* delete from queue */
+                        list_del_init(&pmsg->queue);
+                }
+        }
+}
+
+static void pch_spi_set_ir(struct pch_spi_data *data)
+{
+        /* enable interrupts */
+        if ((data->bpw_len) > PCH_MAX_FIFO_DEPTH) {
+                /* set receive threhold to PCH_RX_THOLD */
+                pch_spi_setclr_reg(data->master, PCH_SPCR,
+                                   PCH_RX_THOLD << SPCR_TFIC_FIELD,
+                                   ~MASK_TFIC_SPCR_BITS);
+                /* enable FI and RFI interrupts */
+                pch_spi_setclr_reg(data->master, PCH_SPCR,
+                                   SPCR_RFIE_BIT | SPCR_TFIE_BIT, 0);
+        } else {
+                /* set receive threhold to maximum */
+                pch_spi_setclr_reg(data->master, PCH_SPCR,
+                                   PCH_RX_THOLD_MAX << SPCR_TFIC_FIELD,
+                                   ~MASK_TFIC_SPCR_BITS);
+                /* enable FI interrupt */
+                pch_spi_setclr_reg(data->master, PCH_SPCR, SPCR_FIE_BIT, 0);
+        }
+
+        dev_dbg(&data->master->dev,
+                "%s:invoking pch_spi_set_enable to enable SPI\n", __func__);
+
+        /* SPI set enable */
+        pch_spi_setclr_reg(data->current_chip->master, PCH_SPCR, SPCR_SPE_BIT, 0);
+
+        /* Wait until the transfer completes; go to sleep after
+                                 initiating the transfer. */
+        dev_dbg(&data->master->dev,
+                "%s:waiting for transfer to get over\n", __func__);
+
+        wait_event_interruptible(data->wait, data->transfer_complete);
+
+        pch_spi_writereg(data->master, PCH_SSNXCR, SSN_NO_CONTROL);
+        dev_dbg(&data->master->dev,
+                "%s:no more control over SSN-writing 0 to SSNXCR.", __func__);
+
+        data->transfer_active = false;
+        dev_dbg(&data->master->dev,
+                "%s set data->transfer_active = false\n", __func__);
+
+        /* clear all interrupts */
+        pch_spi_writereg(data->master, PCH_SPSR,
+                         pch_spi_readreg(data->master, PCH_SPSR));
+        /* disable interrupts */
+        pch_spi_setclr_reg(data->master, PCH_SPCR, 0, PCH_ALL);
+}
+
+static void pch_spi_copy_rx_data(struct pch_spi_data *data, int bpw)
+{
+        int j;
+        u8 *rx_buf;
+        u16 *rx_sbuf;
+
+        /* copy Rx Data */
+        if (!data->cur_trans->rx_buf)
+                return;
+
+        if (bpw == 8) {
+                rx_buf = data->cur_trans->rx_buf;
+                for (j = 0; j < data->bpw_len; j++)
+                        *rx_buf++ = data->pkt_rx_buff[j] & 0xFF;
+        } else {
+                rx_sbuf = data->cur_trans->rx_buf;
+                for (j = 0; j < data->bpw_len; j++)
+                        *rx_sbuf++ = data->pkt_rx_buff[j];
+        }
+}
+
+
+static void pch_spi_process_messages(struct work_struct *pwork)
+{
+        struct spi_message *pmsg;
+        struct pch_spi_data *data;
+        int bpw;
+
+        data = container_of(pwork, struct pch_spi_data, work);
+        dev_dbg(&data->master->dev, "%s data initialized\n", __func__);
+
+        spin_lock(&data->lock);
+
+        /* check if suspend has been initiated;if yes flush queue */
+        if (data->board_dat->suspend_sts || (data->status == STATUS_EXITING)) {
+                dev_dbg(&data->master->dev,
+                        "%s suspend/remove initiated,flushing queue\n",
+                        __func__);
+
+                list_for_each_entry(pmsg, data->queue.next, queue) {
+                        pmsg->status = -EIO;
+
+                        if (pmsg->complete != 0) {
+                                spin_unlock(&data->lock);
+                                pmsg->complete(pmsg->context);
+                                spin_lock(&data->lock);
+                        }
+
+                        /* delete from queue */
+                        list_del_init(&pmsg->queue);
+                }
+
+                spin_unlock(&data->lock);
+                return;
+        }
+
+        data->bcurrent_msg_processing = true;
+        dev_dbg(&data->master->dev,
+                "%s Set data->bcurrent_msg_processing= true\n", __func__);
+
+        /* Get the message from the queue and delete it from there. */
+        data->current_msg = list_entry(data->queue.next, struct spi_message,
+                                        queue);
+
+        list_del_init(&data->current_msg->queue);
+
+        data->current_msg->status = 0;
+
+        pch_spi_select_chip(data, data->current_msg->spi);
+
+        spin_unlock(&data->lock);
+
+        do {
+                /* If we are already processing a message get the next
+                transfer structure from the message otherwise retrieve
+                the 1st transfer request from the message. */
+                spin_lock(&data->lock);
+
+                if (data->cur_trans == NULL) {
+                        data->cur_trans =
+                            list_entry(data->current_msg->transfers.
+                                       next, struct spi_transfer,
+                                       transfer_list);
+                        dev_dbg(&data->master->dev,
+                                "%s :Getting 1st transfer message\n", __func__);
+                } else {
+                        data->cur_trans =
+                            list_entry(data->cur_trans->transfer_list.next,
+                                       struct spi_transfer,
+                                       transfer_list);
+                        dev_dbg(&data->master->dev,
+                                "%s :Getting next transfer message\n",
+                                __func__);
+                }
+
+                spin_unlock(&data->lock);
+
+                pch_spi_set_tx(data, &bpw, &pmsg);
+
+                /* Control interrupt*/
+                pch_spi_set_ir(data);
+
+                /* Disable SPI transfer */
+                pch_spi_setclr_reg(data->current_chip->master, PCH_SPCR, 0,
+                                   SPCR_SPE_BIT);
+
+                /* clear FIFO */
+                pch_spi_clear_fifo(data->master);
+
+                /* copy Rx Data */
+                pch_spi_copy_rx_data(data, bpw);
+
+                /* free memory */
+                kfree(data->pkt_rx_buff);
+                data->pkt_rx_buff = NULL;
+
+                kfree(data->pkt_tx_buff);
+                data->pkt_tx_buff = NULL;
+
+                /* increment message count */
+                data->current_msg->actual_length += data->cur_trans->len;
+
+                dev_dbg(&data->master->dev,
+                        "%s:data->current_msg->actual_length=%d\n",
+                        __func__, data->current_msg->actual_length);
+
+                /* check for delay */
+                if (data->cur_trans->delay_usecs) {
+                        dev_dbg(&data->master->dev, "%s:"
+                                "delay in usec=%d\n", __func__,
+                                data->cur_trans->delay_usecs);
+                        udelay(data->cur_trans->delay_usecs);
+                }
+
+                spin_lock(&data->lock);
+
+                /* No more transfer in this message. */
+                if ((data->cur_trans->transfer_list.next) ==
+                    &(data->current_msg->transfers)) {
+                        pch_spi_nomore_transfer(data, pmsg);
+                }
+
+                spin_unlock(&data->lock);
+
+        } while (data->cur_trans != NULL);
+}
+
+static void pch_spi_free_resources(struct pch_spi_board_data *board_dat)
+{
+        dev_dbg(&board_dat->pdev->dev, "%s ENTRY\n", __func__);
+
+        /* free workqueue */
+        if (board_dat->data->wk != NULL) {
+                destroy_workqueue(board_dat->data->wk);
+                board_dat->data->wk = NULL;
+                dev_dbg(&board_dat->pdev->dev,
+                        "%s destroy_workqueue invoked successfully\n",
+                        __func__);
+        }
+
+        /* disable interrupts & free IRQ */
+        if (board_dat->irq_reg_sts) {
+                /* disable interrupts */
+                pch_spi_setclr_reg(board_dat->data->master, PCH_SPCR, 0,
+                                   PCH_ALL);
+
+                /* free IRQ */
+                free_irq(board_dat->pdev->irq, board_dat);
+
+                dev_dbg(&board_dat->pdev->dev,
+                        "%s free_irq invoked successfully\n", __func__);
+
+                board_dat->irq_reg_sts = false;
+        }
+
+        /* unmap PCI base address */
+        if (board_dat->data->io_remap_addr != 0) {
+                pci_iounmap(board_dat->pdev, board_dat->data->io_remap_addr);
+
+                board_dat->data->io_remap_addr = 0;
+
+                dev_dbg(&board_dat->pdev->dev,
+                        "%s pci_iounmap invoked successfully\n", __func__);
+        }
+
+        /* release PCI region */
+        if (board_dat->pci_req_sts) {
+                pci_release_regions(board_dat->pdev);
+                dev_dbg(&board_dat->pdev->dev,
+                        "%s pci_release_regions invoked successfully\n",
+                        __func__);
+                board_dat->pci_req_sts = false;
+        }
+}
+
+static int pch_spi_get_resources(struct pch_spi_board_data *board_dat)
+{
+        void __iomem *io_remap_addr;
+        int retval;
+        dev_dbg(&board_dat->pdev->dev, "%s ENTRY\n", __func__);
+
+        /* create workqueue */
+        board_dat->data->wk = create_singlethread_workqueue(KBUILD_MODNAME);
+        if (!board_dat->data->wk) {
+                dev_err(&board_dat->pdev->dev,
+                        "%s create_singlet hread_workqueue failed\n", __func__);
+                retval = -EBUSY;
+                goto err_return;
+        }
+
+        dev_dbg(&board_dat->pdev->dev,
+                "%s create_singlethread_workqueue success\n", __func__);
+
+        retval = pci_request_regions(board_dat->pdev, KBUILD_MODNAME);
+        if (retval != 0) {
+                dev_err(&board_dat->pdev->dev,
+                        "%s request_region failed\n", __func__);
+                goto err_return;
+        }
+
+        board_dat->pci_req_sts = true;
+
+        io_remap_addr = pci_iomap(board_dat->pdev, 1, 0);
+        if (io_remap_addr == 0) {
+                dev_err(&board_dat->pdev->dev,
+                        "%s pci_iomap failed\n", __func__);
+                retval = -ENOMEM;
+                goto err_return;
+        }
+
+        /* calculate base address for all channels */
+        board_dat->data->io_remap_addr = io_remap_addr;
+
+        /* reset PCH SPI h/w */
+        pch_spi_reset(board_dat->data->master);
+        dev_dbg(&board_dat->pdev->dev,
+                "%s pch_spi_reset invoked successfully\n", __func__);
+
+        /* register IRQ */
+        retval = request_irq(board_dat->pdev->irq, pch_spi_handler,
+                             IRQF_SHARED, KBUILD_MODNAME, board_dat);
+        if (retval != 0) {
+                dev_err(&board_dat->pdev->dev,
+                        "%s request_irq failed\n", __func__);
+                goto err_return;
+        }
+
+        dev_dbg(&board_dat->pdev->dev, "%s request_irq returned=%d\n",
+                __func__, retval);
+
+        board_dat->irq_reg_sts = true;
+        dev_dbg(&board_dat->pdev->dev, "%s data->irq_reg_sts=true\n", __func__);
+
+err_return:
+        if (retval != 0) {
+                dev_err(&board_dat->pdev->dev,
+                        "%s FAIL:invoking pch_spi_free_resources\n", __func__);
+                pch_spi_free_resources(board_dat);
+        }
+
+        dev_dbg(&board_dat->pdev->dev, "%s Return=%d\n", __func__, retval);
+
+        return retval;
+}
+
+static int pch_spi_probe(struct pci_dev *pdev, const struct pci_device_id *id)
+{
+
+        struct spi_master *master;
+
+        struct pch_spi_board_data *board_dat;
+        int retval;
+
+        dev_dbg(&pdev->dev, "%s ENTRY\n", __func__);
+
+        /* allocate memory for private data */
+        board_dat = kzalloc(sizeof(struct pch_spi_board_data), GFP_KERNEL);
+        if (board_dat == NULL) {
+                dev_err(&pdev->dev,
+                        " %s memory allocation for private data failed\n",
+                        __func__);
+                retval = -ENOMEM;
+                goto err_kmalloc;
+        }
+
+        dev_dbg(&pdev->dev,
+                "%s memory allocation for private data success\n", __func__);
+
+        /* enable PCI device */
+        retval = pci_enable_device(pdev);
+        if (retval != 0) {
+                dev_err(&pdev->dev, "%s pci_enable_device FAILED\n", __func__);
+
+                goto err_pci_en_device;
+        }
+
+        dev_dbg(&pdev->dev, "%s pci_enable_device returned=%d\n",
+                __func__, retval);
+
+        board_dat->pdev = pdev;
+
+        /* alllocate memory for SPI master */
+        master = spi_alloc_master(&pdev->dev, sizeof(struct pch_spi_data));
+        if (master == NULL) {
+                retval = -ENOMEM;
+                dev_err(&pdev->dev, "%s Fail.\n", __func__);
+                goto err_spi_alloc_master;
+        }
+
+        dev_dbg(&pdev->dev,
+                "%s spi_alloc_master returned non NULL\n", __func__);
+
+        /* initialize members of SPI master */
+        master->bus_num = -1;
+        master->num_chipselect = PCH_MAX_CS;
+        master->setup = pch_spi_setup;
+        master->transfer = pch_spi_transfer;
+        dev_dbg(&pdev->dev,
+                "%s transfer member of SPI master initialized\n", __func__);
+
+        board_dat->data = spi_master_get_devdata(master);
+
+        board_dat->data->master = master;
+        board_dat->data->n_curnt_chip = 255;
+        board_dat->data->board_dat = board_dat;
+        board_dat->data->status = STATUS_RUNNING;
+
+        INIT_LIST_HEAD(&board_dat->data->queue);
+        spin_lock_init(&board_dat->data->lock);
+        INIT_WORK(&board_dat->data->work, pch_spi_process_messages);
+        init_waitqueue_head(&board_dat->data->wait);
+
+        /* allocate resources for PCH SPI */
+        retval = pch_spi_get_resources(board_dat);
+        if (retval) {
+                dev_err(&pdev->dev, "%s fail(retval=%d)\n", __func__, retval);
+                goto err_spi_get_resources;
+        }
+
+        dev_dbg(&pdev->dev, "%s pch_spi_get_resources returned=%d\n",
+                __func__, retval);
+
+        /* save private data in dev */
+        pci_set_drvdata(pdev, board_dat);
+        dev_dbg(&pdev->dev, "%s invoked pci_set_drvdata\n", __func__);
+
+        /* set master mode */
+        pch_spi_set_master_mode(master);
+        dev_dbg(&pdev->dev,
+                "%s invoked pch_spi_set_master_mode\n", __func__);
+
+        /* Register the controller with the SPI core. */
+        retval = spi_register_master(master);
+        if (retval != 0) {
+                dev_err(&pdev->dev,
+                        "%s spi_register_master FAILED\n", __func__);
+                goto err_spi_reg_master;
+        }
+
+        dev_dbg(&pdev->dev, "%s spi_register_master returned=%d\n",
+                __func__, retval);
+
+
+        return 0;
+
+err_spi_reg_master:
+        spi_unregister_master(master);
+err_spi_get_resources:
+err_spi_alloc_master:
+        spi_master_put(master);
+        pci_disable_device(pdev);
+err_pci_en_device:
+        kfree(board_dat);
+err_kmalloc:
+        return retval;
+}
+
+static void pch_spi_remove(struct pci_dev *pdev)
+{
+        struct pch_spi_board_data *board_dat = pci_get_drvdata(pdev);
+        int count;
+
+        dev_dbg(&pdev->dev, "%s ENTRY\n", __func__);
+
+        if (!board_dat) {
+                dev_err(&pdev->dev,
+                        "%s pci_get_drvdata returned NULL\n", __func__);
+                return;
+        }
+
+        /* check for any pending messages; no action is taken if the queue
+         * is still full; but at least we tried.  Unload anyway */
+        count = 500;
+        spin_lock(&board_dat->data->lock);
+        board_dat->data->status = STATUS_EXITING;
+        while ((list_empty(&board_dat->data->queue) == 0) && --count) {
+                dev_dbg(&board_dat->pdev->dev, "%s :queue not empty\n",
+                        __func__);
+                spin_unlock(&board_dat->data->lock);
+                msleep(PCH_SLEEP_TIME);
+                spin_lock(&board_dat->data->lock);
+        }
+        spin_unlock(&board_dat->data->lock);
+
+        /* Free resources allocated for PCH SPI */
+        pch_spi_free_resources(board_dat);
+
+        spi_unregister_master(board_dat->data->master);
+
+        /* free memory for private data */
+        kfree(board_dat);
+
+        pci_set_drvdata(pdev, NULL);
+
+        /* disable PCI device */
+        pci_disable_device(pdev);
+
+        dev_dbg(&pdev->dev, "%s invoked pci_disable_device\n", __func__);
+}
+
+#ifdef CONFIG_PM
+static int pch_spi_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        u8 count;
+        int retval;
+
+        struct pch_spi_board_data *board_dat = pci_get_drvdata(pdev);
+
+        dev_dbg(&pdev->dev, "%s ENTRY\n", __func__);
+
+        if (!board_dat) {
+                dev_err(&pdev->dev,
+                        "%s pci_get_drvdata returned NULL\n", __func__);
+                return -EFAULT;
+        }
+
+        retval = 0;
+        board_dat->suspend_sts = true;
+
+        /* check if the current message is processed:
+           Only after thats done the transfer will be suspended */
+        count = 255;
+        while ((--count) > 0) {
+                if (!(board_dat->data->bcurrent_msg_processing)) {
+                        dev_dbg(&pdev->dev, "%s board_dat->data->bCurrent_"
+                                "msg_processing = false\n", __func__);
+                        break;
+                } else {
+                        dev_dbg(&pdev->dev, "%s board_dat->data->bCurrent_msg_"
+                                "processing = true\n", __func__);
+                }
+                msleep(PCH_SLEEP_TIME);
+        }
+
+        /* Free IRQ */
+        if (board_dat->irq_reg_sts) {
+                /* disable all interrupts */
+                pch_spi_setclr_reg(board_dat->data->master, PCH_SPCR, 0,
+                                   PCH_ALL);
+                pch_spi_reset(board_dat->data->master);
+
+                free_irq(board_dat->pdev->irq, board_dat);
+
+                board_dat->irq_reg_sts = false;
+                dev_dbg(&pdev->dev,
+                        "%s free_irq invoked successfully.\n", __func__);
+        }
+
+        /* save config space */
+        retval = pci_save_state(pdev);
+
+        if (retval == 0) {
+                dev_dbg(&pdev->dev, "%s pci_save_state returned=%d\n",
+                        __func__, retval);
+                /* disable PM notifications */
+                pci_enable_wake(pdev, PCI_D3hot, 0);
+                dev_dbg(&pdev->dev,
+                        "%s pci_enable_wake invoked successfully\n", __func__);
+                /* disable PCI device */
+                pci_disable_device(pdev);
+                dev_dbg(&pdev->dev,
+                        "%s pci_disable_device invoked successfully\n",
+                        __func__);
+                /* move device to D3hot  state */
+                pci_set_power_state(pdev, PCI_D3hot);
+                dev_dbg(&pdev->dev,
+                        "%s pci_set_power_state invoked successfully\n",
+                        __func__);
+        } else {
+                dev_err(&pdev->dev, "%s pci_save_state failed\n", __func__);
+        }
+
+        dev_dbg(&pdev->dev, "%s return=%d\n", __func__, retval);
+
+        return retval;
+}
+
+static int pch_spi_resume(struct pci_dev *pdev)
+{
+        int retval;
+
+        struct pch_spi_board_data *board = pci_get_drvdata(pdev);
+        dev_dbg(&pdev->dev, "%s ENTRY\n", __func__);
+
+        if (!board) {
+                dev_err(&pdev->dev,
+                        "%s pci_get_drvdata returned NULL\n", __func__);
+                return -EFAULT;
+        }
+
+        /* move device to DO power state */
+        pci_set_power_state(pdev, PCI_D0);
+
+        /* restore state */
+        pci_restore_state(pdev);
+
+        retval = pci_enable_device(pdev);
+        if (retval < 0) {
+                dev_err(&pdev->dev,
+                        "%s pci_enable_device failed\n", __func__);
+        } else {
+                /* disable PM notifications */
+                pci_enable_wake(pdev, PCI_D3hot, 0);
+
+                /* register IRQ handler */
+                if (!board->irq_reg_sts) {
+                        /* register IRQ */
+                        retval = request_irq(board->pdev->irq, pch_spi_handler,
+                                             IRQF_SHARED, KBUILD_MODNAME,
+                                             board);
+                        if (retval < 0) {
+                                dev_err(&pdev->dev,
+                                        "%s request_irq failed\n", __func__);
+                                return retval;
+                        }
+                        board->irq_reg_sts = true;
+
+                        /* reset PCH SPI h/w */
+                        pch_spi_reset(board->data->master);
+                        pch_spi_set_master_mode(board->data->master);
+
+                        /* set suspend status to false */
+                        board->suspend_sts = false;
+
+                }
+        }
+
+        dev_dbg(&pdev->dev, "%s returning=%d\n", __func__, retval);
+
+        return retval;
+}
+#else
+#define pch_spi_suspend NULL
+#define pch_spi_resume NULL
+
+#endif
+
+static struct pci_driver pch_spi_pcidev = {
+        .name = "pch_spi",
+        .id_table = pch_spi_pcidev_id,
+        .probe = pch_spi_probe,
+        .remove = pch_spi_remove,
+        .suspend = pch_spi_suspend,
+        .resume = pch_spi_resume,
+};
+
+static int __init pch_spi_init(void)
+{
+        return pci_register_driver(&pch_spi_pcidev);
+}
+module_init(pch_spi_init);
+
+static void __exit pch_spi_exit(void)
+{
+        pci_unregister_driver(&pch_spi_pcidev);
+}
+module_exit(pch_spi_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Topcliff PCH SPI PCI Driver");
diff --git a/drivers/ssb/main.c b/drivers/ssb/main.c
index 7892ac163522..c68b3dc19e11 100644
--- a/drivers/ssb/main.c
+++ b/drivers/ssb/main.c
@@ -20,7 +20,6 @@
 #include <linux/mmc/sdio_func.h>
 #include <linux/slab.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
diff --git a/drivers/ssb/pcmcia.c b/drivers/ssb/pcmcia.c
index 526682d68de8..c7345dbf43fa 100644
--- a/drivers/ssb/pcmcia.c
+++ b/drivers/ssb/pcmcia.c
@@ -13,7 +13,6 @@
 #include <linux/io.h>
 #include <linux/etherdevice.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ciscode.h>
 #include <pcmcia/ds.h>
diff --git a/drivers/ssb/scan.c b/drivers/ssb/scan.c
index 9738cad4ba13..ee079ab9fb28 100644
--- a/drivers/ssb/scan.c
+++ b/drivers/ssb/scan.c
@@ -17,7 +17,6 @@
 #include <linux/pci.h>
 #include <linux/io.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
diff --git a/drivers/staging/comedi/drivers/cb_das16_cs.c b/drivers/staging/comedi/drivers/cb_das16_cs.c
index f8ede1182ccc..0345b4caba73 100644
--- a/drivers/staging/comedi/drivers/cb_das16_cs.c
+++ b/drivers/staging/comedi/drivers/cb_das16_cs.c
@@ -37,7 +37,6 @@ Status: experimental
 #include <linux/delay.h>
 #include <linux/pci.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -692,10 +691,6 @@ static int das16cs_pcmcia_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /* Initialize the pcmcia_device structure */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         cur_dev = link;
 
         das16cs_pcmcia_config(link);
@@ -715,37 +710,12 @@ static void das16cs_pcmcia_detach(struct pcmcia_device *link)
 
 
 static int das16cs_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
                                 void *priv_data)
 {
-        if (cfg->index == 0)
+        if (p_dev->config_index == 0)
                 return -EINVAL;
 
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                return pcmcia_request_io(p_dev);
-        }
-
-        return 0;
+        return pcmcia_request_io(p_dev);
 }
 
 static void das16cs_pcmcia_config(struct pcmcia_device *link)
@@ -754,6 +724,9 @@ static void das16cs_pcmcia_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "das16cs_pcmcia_config\n");
 
+        /* Do we need to allocate an interrupt? */
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, das16cs_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -763,25 +736,10 @@ static void das16cs_pcmcia_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %u", link->irq);
-        if (link->resource[0])
-                printk(", io %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(", io %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -832,9 +790,7 @@ struct pcmcia_driver das16cs_driver = {
         .resume = das16cs_pcmcia_resume,
         .id_table = das16cs_id_table,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "cb_das16_cs",
-                },
+        .name = "cb_das16_cs",
 };
 
 static int __init init_das16cs_pcmcia_cs(void)
diff --git a/drivers/staging/comedi/drivers/das08_cs.c b/drivers/staging/comedi/drivers/das08_cs.c
index 48d9fb1227df..0b32a2df7768 100644
--- a/drivers/staging/comedi/drivers/das08_cs.c
+++ b/drivers/staging/comedi/drivers/das08_cs.c
@@ -48,7 +48,6 @@ Command support does not exist, but could be added for this board.
 #include "das08.h"
 
 /* pcmcia includes */
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -115,40 +114,15 @@ static void das08_pcmcia_release(struct pcmcia_device *link);
 static int das08_pcmcia_suspend(struct pcmcia_device *p_dev);
 static int das08_pcmcia_resume(struct pcmcia_device *p_dev);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static int das08_pcmcia_attach(struct pcmcia_device *);
 static void das08_pcmcia_detach(struct pcmcia_device *);
 
-/*
-   You'll also need to prototype all the functions that will actually
-   be used to talk to your device.  See 'memory_cs' for a good example
-   of a fully self-sufficient driver; the other drivers rely more or
-   less on other parts of the kernel.
-*/
-
 struct local_info_t {
         struct pcmcia_device *link;
         int stop;
         struct bus_operations *bus;
 };
 
-/*======================================================================
-
-    das08_pcmcia_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int das08_pcmcia_attach(struct pcmcia_device *link)
 {
         struct local_info_t *local;
@@ -162,16 +136,6 @@ static int das08_pcmcia_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /*
-           General socket configuration defaults can go here.  In this
-           client, we assume very little, and rely on the CIS for almost
-           everything.  In most clients, many details (i.e., number, sizes,
-           and attributes of IO windows) are fixed by the nature of the
-           device, and can be hard-wired here.
-         */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         cur_dev = link;
 
         das08_pcmcia_config(link);
@@ -179,15 +143,6 @@ static int das08_pcmcia_attach(struct pcmcia_device *link)
         return 0;
 }                               /* das08_pcmcia_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void das08_pcmcia_detach(struct pcmcia_device *link)
 {
 
@@ -203,46 +158,13 @@ static void das08_pcmcia_detach(struct pcmcia_device *link)
 
 
 static int das08_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
                                 void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                return pcmcia_request_io(p_dev);
-        }
-        return 0;
-}
-
-
-/*======================================================================
-
-    das08_pcmcia_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-======================================================================*/
+        return pcmcia_request_io(p_dev);
+}
 
 static void das08_pcmcia_config(struct pcmcia_device *link)
 {
@@ -250,6 +172,8 @@ static void das08_pcmcia_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "das08_pcmcia_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, das08_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -259,25 +183,10 @@ static void das08_pcmcia_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %u", link->irq);
-        if (link->resource[0])
-                printk(", io %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -285,32 +194,12 @@ failed:
 
 }                               /* das08_pcmcia_config */
 
-/*======================================================================
-
-    After a card is removed, das08_pcmcia_release() will unregister the
-    device, and release the PCMCIA configuration.  If the device is
-    still open, this will be postponed until it is closed.
-
-======================================================================*/
-
 static void das08_pcmcia_release(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "das08_pcmcia_release\n");
         pcmcia_disable_device(link);
 }                               /* das08_pcmcia_release */
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.
-
-    When a CARD_REMOVAL event is received, we immediately set a
-    private flag to block future accesses to this device.  All the
-    functions that actually access the device should check this flag
-    to make sure the card is still present.
-
-======================================================================*/
-
 static int das08_pcmcia_suspend(struct pcmcia_device *link)
 {
         struct local_info_t *local = link->priv;
@@ -348,9 +237,7 @@ struct pcmcia_driver das08_cs_driver = {
         .resume = das08_pcmcia_resume,
         .id_table = das08_cs_id_table,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "pcm-das08",
-                },
+        .name = "pcm-das08",
 };
 
 static int __init init_das08_pcmcia_cs(void)
diff --git a/drivers/staging/comedi/drivers/ni_daq_700.c b/drivers/staging/comedi/drivers/ni_daq_700.c
index cc15666e5cc1..fc772a8a55c6 100644
--- a/drivers/staging/comedi/drivers/ni_daq_700.c
+++ b/drivers/staging/comedi/drivers/ni_daq_700.c
@@ -47,7 +47,6 @@ IRQ is assigned but not used.
 
 #include <linux/ioport.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -435,47 +434,20 @@ static int dio700_detach(struct comedi_device *dev)
         return 0;
 };
 
-/* PCMCIA crap -- watch your words, please! */
-
 static void dio700_config(struct pcmcia_device *link);
 static void dio700_release(struct pcmcia_device *link);
 static int dio700_cs_suspend(struct pcmcia_device *p_dev);
 static int dio700_cs_resume(struct pcmcia_device *p_dev);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static int dio700_cs_attach(struct pcmcia_device *);
 static void dio700_cs_detach(struct pcmcia_device *);
 
-/*
-   You'll also need to prototype all the functions that will actually
-   be used to talk to your device.  See 'memory_cs' for a good example
-   of a fully self-sufficient driver; the other drivers rely more or
-   less on other parts of the kernel.
-*/
-
 struct local_info_t {
         struct pcmcia_device *link;
         int stop;
         struct bus_operations *bus;
 };
 
-/*======================================================================
-
-    dio700_cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int dio700_cs_attach(struct pcmcia_device *link)
 {
         struct local_info_t *local;
@@ -491,16 +463,6 @@ static int dio700_cs_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /*
-           General socket configuration defaults can go here.  In this
-           client, we assume very little, and rely on the CIS for almost
-           everything.  In most clients, many details (i.e., number, sizes,
-           and attributes of IO windows) are fixed by the nature of the
-           device, and can be hard-wired here.
-         */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         pcmcia_cur_dev = link;
 
         dio700_config(link);
@@ -508,15 +470,6 @@ static int dio700_cs_attach(struct pcmcia_device *link)
         return 0;
 }                               /* dio700_cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void dio700_cs_detach(struct pcmcia_device *link)
 {
 
@@ -532,54 +485,13 @@ static void dio700_cs_detach(struct pcmcia_device *link)
 
 }                               /* dio700_cs_detach */
 
-/*======================================================================
-
-    dio700_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
 static int dio700_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
                                 void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev) != 0)
-                        return -ENODEV;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* If we got this far, we're cool! */
-        return 0;
+        return pcmcia_request_io(p_dev);
 }
 
 static void dio700_config(struct pcmcia_device *link)
@@ -591,6 +503,9 @@ static void dio700_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "dio700_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_AUDIO |
+                CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, dio700_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -600,25 +515,10 @@ static void dio700_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret != 0)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %d", link->irq);
-        if (link->resource[0])
-                printk(", io %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -634,18 +534,6 @@ static void dio700_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 }                               /* dio700_release */
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.
-
-    When a CARD_REMOVAL event is received, we immediately set a
-    private flag to block future accesses to this device.  All the
-    functions that actually access the device should check this flag
-    to make sure the card is still present.
-
-======================================================================*/
-
 static int dio700_cs_suspend(struct pcmcia_device *link)
 {
         struct local_info_t *local = link->priv;
@@ -685,9 +573,7 @@ struct pcmcia_driver dio700_cs_driver = {
         .resume = dio700_cs_resume,
         .id_table = dio700_cs_ids,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "ni_daq_700",
-                },
+        .name = "ni_daq_700",
 };
 
 static int __init init_dio700_cs(void)
diff --git a/drivers/staging/comedi/drivers/ni_daq_dio24.c b/drivers/staging/comedi/drivers/ni_daq_dio24.c
index 773ae2044e0e..c9c28584db67 100644
--- a/drivers/staging/comedi/drivers/ni_daq_dio24.c
+++ b/drivers/staging/comedi/drivers/ni_daq_dio24.c
@@ -48,7 +48,6 @@ the PCMCIA interface.
 
 #include "8255.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -187,47 +186,20 @@ static int dio24_detach(struct comedi_device *dev)
         return 0;
 };
 
-/* PCMCIA crap -- watch your words! */
-
 static void dio24_config(struct pcmcia_device *link);
 static void dio24_release(struct pcmcia_device *link);
 static int dio24_cs_suspend(struct pcmcia_device *p_dev);
 static int dio24_cs_resume(struct pcmcia_device *p_dev);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static int dio24_cs_attach(struct pcmcia_device *);
 static void dio24_cs_detach(struct pcmcia_device *);
 
-/*
-   You'll also need to prototype all the functions that will actually
-   be used to talk to your device.  See 'memory_cs' for a good example
-   of a fully self-sufficient driver; the other drivers rely more or
-   less on other parts of the kernel.
-*/
-
 struct local_info_t {
         struct pcmcia_device *link;
         int stop;
         struct bus_operations *bus;
 };
 
-/*======================================================================
-
-    dio24_cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int dio24_cs_attach(struct pcmcia_device *link)
 {
         struct local_info_t *local;
@@ -243,16 +215,6 @@ static int dio24_cs_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /*
-           General socket configuration defaults can go here.  In this
-           client, we assume very little, and rely on the CIS for almost
-           everything.  In most clients, many details (i.e., number, sizes,
-           and attributes of IO windows) are fixed by the nature of the
-           device, and can be hard-wired here.
-         */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         pcmcia_cur_dev = link;
 
         dio24_config(link);
@@ -260,15 +222,6 @@ static int dio24_cs_attach(struct pcmcia_device *link)
         return 0;
 }                               /* dio24_cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void dio24_cs_detach(struct pcmcia_device *link)
 {
 
@@ -284,54 +237,13 @@ static void dio24_cs_detach(struct pcmcia_device *link)
 
 }                               /* dio24_cs_detach */
 
-/*======================================================================
-
-    dio24_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
 static int dio24_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
                                 void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev) != 0)
-                        return -ENODEV;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* If we got this far, we're cool! */
-        return 0;
+        return pcmcia_request_io(p_dev);
 }
 
 static void dio24_config(struct pcmcia_device *link)
@@ -342,6 +254,9 @@ static void dio24_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "dio24_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_AUDIO |
+                CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, dio24_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -351,25 +266,10 @@ static void dio24_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %d", link->irq);
-        if (link->resource[0])
-                printk(" & %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -385,18 +285,6 @@ static void dio24_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 }                               /* dio24_release */
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.
-
-    When a CARD_REMOVAL event is received, we immediately set a
-    private flag to block future accesses to this device.  All the
-    functions that actually access the device should check this flag
-    to make sure the card is still present.
-
-======================================================================*/
-
 static int dio24_cs_suspend(struct pcmcia_device *link)
 {
         struct local_info_t *local = link->priv;
@@ -435,9 +323,7 @@ struct pcmcia_driver dio24_cs_driver = {
         .resume = dio24_cs_resume,
         .id_table = dio24_cs_ids,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "ni_daq_dio24",
-                },
+        .name = "ni_daq_dio24",
 };
 
 static int __init init_dio24_cs(void)
diff --git a/drivers/staging/comedi/drivers/ni_labpc_cs.c b/drivers/staging/comedi/drivers/ni_labpc_cs.c
index 68c4ecbd93ae..6facbc8bf776 100644
--- a/drivers/staging/comedi/drivers/ni_labpc_cs.c
+++ b/drivers/staging/comedi/drivers/ni_labpc_cs.c
@@ -71,7 +71,6 @@ NI manuals:
 #include "comedi_fc.h"
 #include "ni_labpc.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -153,59 +152,20 @@ static int labpc_attach(struct comedi_device *dev, struct comedi_devconfig *it)
         return labpc_common_attach(dev, iobase, irq, 0);
 }
 
-/*====================================================================*/
-
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card
-   insertion and ejection events.  They are invoked from the dummy
-   event handler.
-
-   Kernel version 2.6.16 upwards uses suspend() and resume() functions
-   instead of an event() function.
-*/
-
 static void labpc_config(struct pcmcia_device *link);
 static void labpc_release(struct pcmcia_device *link);
 static int labpc_cs_suspend(struct pcmcia_device *p_dev);
 static int labpc_cs_resume(struct pcmcia_device *p_dev);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static int labpc_cs_attach(struct pcmcia_device *);
 static void labpc_cs_detach(struct pcmcia_device *);
 
-/*
-   You'll also need to prototype all the functions that will actually
-   be used to talk to your device.  See 'memory_cs' for a good example
-   of a fully self-sufficient driver; the other drivers rely more or
-   less on other parts of the kernel.
-*/
-
 struct local_info_t {
         struct pcmcia_device *link;
         int stop;
         struct bus_operations *bus;
 };
 
-/*======================================================================
-
-    labpc_cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int labpc_cs_attach(struct pcmcia_device *link)
 {
         struct local_info_t *local;
@@ -219,16 +179,6 @@ static int labpc_cs_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /*
-           General socket configuration defaults can go here.  In this
-           client, we assume very little, and rely on the CIS for almost
-           everything.  In most clients, many details (i.e., number, sizes,
-           and attributes of IO windows) are fixed by the nature of the
-           device, and can be hard-wired here.
-         */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         pcmcia_cur_dev = link;
 
         labpc_config(link);
@@ -236,15 +186,6 @@ static int labpc_cs_attach(struct pcmcia_device *link)
         return 0;
 }                               /* labpc_cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void labpc_cs_detach(struct pcmcia_device *link)
 {
         dev_dbg(&link->dev, "labpc_cs_detach\n");
@@ -263,54 +204,13 @@ static void labpc_cs_detach(struct pcmcia_device *link)
 
 }                               /* labpc_cs_detach */
 
-/*======================================================================
-
-    labpc_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
 static int labpc_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
                                 void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Does this card need audio output? */
-        if (cfg->flags & CISTPL_CFTABLE_AUDIO) {
-                p_dev->conf.Attributes |= CONF_ENABLE_SPKR;
-                p_dev->conf.Status = CCSR_AUDIO_ENA;
-        }
-
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                /* This reserves IO space but doesn't actually enable it */
-                if (pcmcia_request_io(p_dev) != 0)
-                        return -ENODEV;
-        }
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* If we got this far, we're cool! */
-        return 0;
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -320,6 +220,9 @@ static void labpc_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "labpc_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_ENABLE_PULSE_IRQ |
+                CONF_AUTO_AUDIO | CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, labpc_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -329,25 +232,10 @@ static void labpc_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %d", link->irq);
-        if (link->resource[0])
-                printk(" & %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -362,18 +250,6 @@ static void labpc_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 }                               /* labpc_release */
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.
-
-    When a CARD_REMOVAL event is received, we immediately set a
-    private flag to block future accesses to this device.  All the
-    functions that actually access the device should check this flag
-    to make sure the card is still present.
-
-======================================================================*/
-
 static int labpc_cs_suspend(struct pcmcia_device *link)
 {
         struct local_info_t *local = link->priv;
@@ -391,8 +267,6 @@ static int labpc_cs_resume(struct pcmcia_device *link)
         return 0;
 }                               /* labpc_cs_resume */
 
-/*====================================================================*/
-
 static struct pcmcia_device_id labpc_cs_ids[] = {
         /* N.B. These IDs should match those in labpc_cs_boards (ni_labpc.c) */
         PCMCIA_DEVICE_MANF_CARD(0x010b, 0x0103),        /* daqcard-1200 */
@@ -411,9 +285,7 @@ struct pcmcia_driver labpc_cs_driver = {
         .resume = labpc_cs_resume,
         .id_table = labpc_cs_ids,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "daqcard-1200",
-                },
+        .name = "daqcard-1200",
 };
 
 static int __init init_labpc_cs(void)
diff --git a/drivers/staging/comedi/drivers/ni_mio_cs.c b/drivers/staging/comedi/drivers/ni_mio_cs.c
index 1f2426352eb5..49563273f605 100644
--- a/drivers/staging/comedi/drivers/ni_mio_cs.c
+++ b/drivers/staging/comedi/drivers/ni_mio_cs.c
@@ -48,7 +48,6 @@ See the notes in the ni_atmio.o driver.
 #include "ni_stc.h"
 #include "8255.h"
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -263,11 +262,6 @@ static struct pcmcia_device *cur_dev = NULL;
 
 static int cs_attach(struct pcmcia_device *link)
 {
-        link->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
-        link->resource[0]->end = 16;
-        link->conf.Attributes = CONF_ENABLE_IRQ;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         cur_dev = link;
 
         mio_cs_config(link);
@@ -301,16 +295,12 @@ static int mio_cs_resume(struct pcmcia_device *link)
 }
 
 
-static int mio_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int mio_pcmcia_config_loop(struct pcmcia_device *p_dev, void *priv_data)
 {
         int base, ret;
 
-        p_dev->resource[0]->end = cfg->io.win[0].len;
-        p_dev->io_lines = cfg->io.flags & CISTPL_IO_LINES_MASK;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_16;
 
         for (base = 0x000; base < 0x400; base += 0x20) {
                 p_dev->resource[0]->start = base;
@@ -327,6 +317,7 @@ static void mio_cs_config(struct pcmcia_device *link)
         int ret;
 
         DPRINTK("mio_cs_config(link=%p)\n", link);
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
 
         ret = pcmcia_loop_config(link, mio_pcmcia_config_loop, NULL);
         if (ret) {
@@ -337,7 +328,7 @@ static void mio_cs_config(struct pcmcia_device *link)
         if (!link->irq)
                 dev_info(&link->dev, "no IRQ available\n");
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
 }
 
 static int mio_cs_attach(struct comedi_device *dev, struct comedi_devconfig *it)
@@ -446,9 +437,7 @@ struct pcmcia_driver ni_mio_cs_driver = {
         .resume = &mio_cs_resume,
         .id_table = ni_mio_cs_ids,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "ni_mio_cs",
-                },
+        .name = "ni_mio_cs",
 };
 
 int init_module(void)
diff --git a/drivers/staging/comedi/drivers/quatech_daqp_cs.c b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
index bf489d7f4990..ebba9bb47777 100644
--- a/drivers/staging/comedi/drivers/quatech_daqp_cs.c
+++ b/drivers/staging/comedi/drivers/quatech_daqp_cs.c
@@ -50,7 +50,6 @@ Devices: [Quatech] DAQP-208 (daqp), DAQP-308
 #include "../comedidev.h"
 #include <linux/semaphore.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -969,43 +968,14 @@ static int daqp_detach(struct comedi_device *dev)
 
 ======================================================================*/
 
-/*
-   The event() function is this driver's Card Services event handler.
-   It will be called by Card Services when an appropriate card status
-   event is received.  The config() and release() entry points are
-   used to configure or release a socket, in response to card
-   insertion and ejection events.
-
-   Kernel version 2.6.16 upwards uses suspend() and resume() functions
-   instead of an event() function.
-*/
-
 static void daqp_cs_config(struct pcmcia_device *link);
 static void daqp_cs_release(struct pcmcia_device *link);
 static int daqp_cs_suspend(struct pcmcia_device *p_dev);
 static int daqp_cs_resume(struct pcmcia_device *p_dev);
 
-/*
-   The attach() and detach() entry points are used to create and destroy
-   "instances" of the driver, where each instance represents everything
-   needed to manage one actual PCMCIA card.
-*/
-
 static int daqp_cs_attach(struct pcmcia_device *);
 static void daqp_cs_detach(struct pcmcia_device *);
 
-/*======================================================================
-
-    daqp_cs_attach() creates an "instance" of the driver, allocating
-    local data structures for one device.  The device is registered
-    with Card Services.
-
-    The dev_link structure is initialized, but we don't actually
-    configure the card at this point -- we wait until we receive a
-    card insertion event.
-
-======================================================================*/
-
 static int daqp_cs_attach(struct pcmcia_device *link)
 {
         struct local_info_t *local;
@@ -1031,30 +1001,11 @@ static int daqp_cs_attach(struct pcmcia_device *link)
         local->link = link;
         link->priv = local;
 
-        /*
-           General socket configuration defaults can go here.  In this
-           client, we assume very little, and rely on the CIS for almost
-           everything.  In most clients, many details (i.e., number, sizes,
-           and attributes of IO windows) are fixed by the nature of the
-           device, and can be hard-wired here.
-         */
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         daqp_cs_config(link);
 
         return 0;
 }                               /* daqp_cs_attach */
 
-/*======================================================================
-
-    This deletes a driver "instance".  The device is de-registered
-    with Card Services.  If it has been released, all local data
-    structures are freed.  Otherwise, the structures will be freed
-    when the device is released.
-
-======================================================================*/
-
 static void daqp_cs_detach(struct pcmcia_device *link)
 {
         struct local_info_t *dev = link->priv;
@@ -1070,45 +1021,11 @@ static void daqp_cs_detach(struct pcmcia_device *link)
 
 }                               /* daqp_cs_detach */
 
-/*======================================================================
-
-    daqp_cs_config() is scheduled to run after a CARD_INSERTION event
-    is received, to configure the PCMCIA socket, and to make the
-    device available to the system.
-
-======================================================================*/
-
-
-static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev,
-                                cistpl_cftable_entry_t *cfg,
-                                cistpl_cftable_entry_t *dflt,
-                                unsigned int vcc,
-                                void *priv_data)
+static int daqp_pcmcia_config_loop(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
+        if (p_dev->config_index == 0)
+                return -EINVAL;
 
-        /* Do we need to allocate an interrupt? */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-                p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
-                p_dev->resource[0]->flags |=
-                        pcmcia_io_cfg_data_width(io->flags);
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                if (io->nwin > 1) {
-                        p_dev->resource[1]->flags = p_dev->resource[0]->flags;
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-        }
-
-        /* This reserves IO space but doesn't actually enable it */
         return pcmcia_request_io(p_dev);
 }
 
@@ -1118,6 +1035,8 @@ static void daqp_cs_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "daqp_cs_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_IO;
+
         ret = pcmcia_loop_config(link, daqp_pcmcia_config_loop, NULL);
         if (ret) {
                 dev_warn(&link->dev, "no configuration found\n");
@@ -1128,25 +1047,10 @@ static void daqp_cs_config(struct pcmcia_device *link)
         if (ret)
                 goto failed;
 
-        /*
-           This actually configures the PCMCIA socket -- setting up
-           the I/O windows and the interrupt mapping, and putting the
-           card and host interface into "Memory and IO" mode.
-         */
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        /* Finally, report what we've done */
-        dev_info(&link->dev, "index 0x%02x", link->conf.ConfigIndex);
-        if (link->conf.Attributes & CONF_ENABLE_IRQ)
-                printk(", irq %u", link->irq);
-        if (link->resource[0])
-                printk(" & %pR", link->resource[0]);
-        if (link->resource[1])
-                printk(" & %pR", link->resource[1]);
-        printk("\n");
-
         return;
 
 failed:
@@ -1161,18 +1065,6 @@ static void daqp_cs_release(struct pcmcia_device *link)
         pcmcia_disable_device(link);
 }                               /* daqp_cs_release */
 
-/*======================================================================
-
-    The card status event handler.  Mostly, this schedules other
-    stuff to run after an event is received.
-
-    When a CARD_REMOVAL event is received, we immediately set a
-    private flag to block future accesses to this device.  All the
-    functions that actually access the device should check this flag
-    to make sure the card is still present.
-
-======================================================================*/
-
 static int daqp_cs_suspend(struct pcmcia_device *link)
 {
         struct local_info_t *local = link->priv;
@@ -1212,9 +1104,7 @@ static struct pcmcia_driver daqp_cs_driver = {
         .resume = daqp_cs_resume,
         .id_table = daqp_cs_id_table,
         .owner = THIS_MODULE,
-        .drv = {
-                .name = "quatech_daqp_cs",
-                },
+        .name = "quatech_daqp_cs",
 };
 
 int __init init_module(void)
diff --git a/drivers/staging/wlags49_h2/wl_cs.c b/drivers/staging/wlags49_h2/wl_cs.c
index 19c335458653..6555891e149c 100644
--- a/drivers/staging/wlags49_h2/wl_cs.c
+++ b/drivers/staging/wlags49_h2/wl_cs.c
@@ -83,7 +83,6 @@
 #include <linux/if_arp.h>
 #include <linux/ioport.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
@@ -147,10 +146,9 @@ static int wl_adapter_attach(struct pcmcia_device *link)
 
         link->resource[0]->end  = HCF_NUM_IO_PORTS;
         link->resource[0]->flags= IO_DATA_PATH_WIDTH_16;
-        link->conf.Attributes   = CONF_ENABLE_IRQ;
-        link->conf.IntType      = INT_MEMORY_AND_IO;
-        link->conf.ConfigIndex  = 5;
-        link->conf.Present      = PRESENT_OPTION;
+        link->config_flags     |= CONF_ENABLE_IRQ;
+        link->config_index      = 5;
+        link->config_regs       = PRESENT_OPTION;
 
         link->priv = dev;
         lp = wl_priv(dev);
@@ -165,27 +163,6 @@ static int wl_adapter_attach(struct pcmcia_device *link)
 
 
 
-/*******************************************************************************
- *      wl_adapter_detach()
- *******************************************************************************
- *
- *  DESCRIPTION:
- *
- *      This deletes a driver "instance". The device is de-registered with Card
- *  Services. If it has been released, then the net device is unregistered, and
- *  all local data structures are freed. Otherwise, the structures will be
- *  freed when the device is released.
- *
- *  PARAMETERS:
- *
- *      link    - pointer to the dev_link_t structure representing the device to
- *                detach
- *
- *  RETURNS:
- *
- *      N/A
- *
- ******************************************************************************/
 static void wl_adapter_detach(struct pcmcia_device *link)
 {
         struct net_device   *dev = link->priv;
@@ -209,26 +186,6 @@ static void wl_adapter_detach(struct pcmcia_device *link)
 /*============================================================================*/
 
 
-/*******************************************************************************
- *      wl_adapter_release()
- *******************************************************************************
- *
- *  DESCRIPTION:
- *
- *      After a card is removed, this routine will release the PCMCIA
- *  configuration. If the device is still open, this will be postponed until it
- *  is closed.
- *
- *  PARAMETERS:
- *
- *      arg - a u_long representing a pointer to a dev_link_t structure for the
- *            device to be released.
- *
- *  RETURNS:
- *
- *      N/A
- *
- ******************************************************************************/
 void wl_adapter_release(struct pcmcia_device *link)
 {
         DBG_FUNC("wl_adapter_release");
@@ -268,26 +225,6 @@ static int wl_adapter_resume(struct pcmcia_device *link)
         return 0;
 } /* wl_adapter_resume */
 
-/*******************************************************************************
- *      wl_adapter_insert()
- *******************************************************************************
- *
- *  DESCRIPTION:
- *
- *      wl_adapter_insert() is scheduled to run after a CARD_INSERTION event is
- *  received, to configure the PCMCIA socket, and to make the ethernet device
- *  available to the system.
- *
- *  PARAMETERS:
- *
- *      link    - pointer to the dev_link_t structure representing the device to
- *                insert
- *
- *  RETURNS:
- *
- *      N/A
- *
- ******************************************************************************/
 void wl_adapter_insert(struct pcmcia_device *link)
 {
         struct net_device *dev;
@@ -302,7 +239,7 @@ void wl_adapter_insert(struct pcmcia_device *link)
         dev     = link->priv;
 
         /* Do we need to allocate an interrupt? */
-        link->conf.Attributes |= CONF_ENABLE_IRQ;
+        link->config_flags |= CONF_ENABLE_IRQ;
         link->io_lines = 6;
 
         ret = pcmcia_request_io(link);
@@ -313,7 +250,7 @@ void wl_adapter_insert(struct pcmcia_device *link)
         if (ret != 0)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret != 0)
                 goto failed;
 
@@ -457,9 +394,7 @@ MODULE_DEVICE_TABLE(pcmcia, wl_adapter_ids);
 
 static struct pcmcia_driver wlags49_driver = {
         .owner      = THIS_MODULE,
-        .drv        = {
-                .name = DRIVER_NAME,
-        },
+        .name       = DRIVER_NAME,
         .probe      = wl_adapter_attach,
         .remove     = wl_adapter_detach,
         .id_table   = wl_adapter_ids,
diff --git a/drivers/staging/wlags49_h2/wl_internal.h b/drivers/staging/wlags49_h2/wl_internal.h
index 02f0a20e178a..cd129b3ee6c0 100644
--- a/drivers/staging/wlags49_h2/wl_internal.h
+++ b/drivers/staging/wlags49_h2/wl_internal.h
@@ -69,7 +69,6 @@
  ******************************************************************************/
 #include <linux/version.h>
 #ifdef BUS_PCMCIA
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ciscode.h>
diff --git a/drivers/staging/wlags49_h2/wl_main.c b/drivers/staging/wlags49_h2/wl_main.c
index 88d0d472142f..8e3536acbf46 100644
--- a/drivers/staging/wlags49_h2/wl_main.c
+++ b/drivers/staging/wlags49_h2/wl_main.c
@@ -414,25 +414,6 @@ extern memimage fw_image;            // firmware image to be downloaded
 #endif /* HCF_STA */
 
 
-/*******************************************************************************
- *      wl_insert()
- *******************************************************************************
- *
- *  DESCRIPTION:
- *
- *      wl_insert() is scheduled to run after a CARD_INSERTION event is
- *  received, to configure the PCMCIA socket, and to make the ethernet device
- *  available to the system.
- *
- *  PARAMETERS:
- *
- *      dev - a pointer to the net_device struct of the wireless device
- *
- *  RETURNS:
- *
- *      TRUE or FALSE
- *
- ******************************************************************************/
 int wl_insert( struct net_device *dev )
 {
         int                     result = 0;
diff --git a/drivers/telephony/ixj_pcmcia.c b/drivers/telephony/ixj_pcmcia.c
index a1900e502518..d005b9eeebbc 100644
--- a/drivers/telephony/ixj_pcmcia.c
+++ b/drivers/telephony/ixj_pcmcia.c
@@ -8,7 +8,6 @@
 #include <linux/errno.h>        /* error codes */
 #include <linux/slab.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/ds.h>
 
@@ -32,9 +31,6 @@ static int ixj_probe(struct pcmcia_device *p_dev)
 {
         dev_dbg(&p_dev->dev, "ixj_attach()\n");
         /* Create new ixj device */
-        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
-        p_dev->conf.IntType = INT_MEMORY_AND_IO;
         p_dev->priv = kzalloc(sizeof(struct ixj_info_t), GFP_KERNEL);
         if (!p_dev->priv) {
                 return -ENOMEM;
@@ -111,40 +107,31 @@ failed:
         return;
 }
 
-static int ixj_config_check(struct pcmcia_device *p_dev,
-                            cistpl_cftable_entry_t *cfg,
-                            cistpl_cftable_entry_t *dflt,
-                            unsigned int vcc,
-                            void *priv_data)
+static int ixj_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-                p_dev->io_lines = 3;
-                if (io->nwin == 2) {
-                        p_dev->resource[1]->start = io->win[1].base;
-                        p_dev->resource[1]->end = io->win[1].len;
-                }
-                if (!pcmcia_request_io(p_dev))
-                        return 0;
-        }
-        return -ENODEV;
+        p_dev->resource[0]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->resource[1]->flags &= ~IO_DATA_PATH_WIDTH;
+        p_dev->resource[1]->flags |= IO_DATA_PATH_WIDTH_8;
+        p_dev->io_lines = 3;
+
+        return pcmcia_request_io(p_dev);
 }
 
 static int ixj_config(struct pcmcia_device * link)
 {
         IXJ *j;
         ixj_info_t *info;
-        cistpl_cftable_entry_t dflt = { 0 };
 
         info = link->priv;
         dev_dbg(&link->dev, "ixj_config\n");
 
-        if (pcmcia_loop_config(link, ixj_config_check, &dflt))
+        link->config_flags = CONF_AUTO_SET_IO;
+
+        if (pcmcia_loop_config(link, ixj_config_check, NULL))
                 goto failed;
 
-        if (pcmcia_request_configuration(link, &link->conf))
+        if (pcmcia_enable_device(link))
                 goto failed;
 
         /*
@@ -178,9 +165,7 @@ MODULE_DEVICE_TABLE(pcmcia, ixj_ids);
 
 static struct pcmcia_driver ixj_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "ixj_cs",
-        },
+        .name           = "ixj_cs",
         .probe          = ixj_probe,
         .remove         = ixj_detach,
         .id_table       = ixj_ids,
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index 418163894775..afef7b0a4195 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -24,6 +24,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk.h>
 #include <mach/ohci.h>
+#include <mach/pxa3xx-u2d.h>
 
 /*
  * UHC: USB Host Controller (OHCI-like) register definitions
@@ -235,6 +236,9 @@ static int pxa27x_start_hc(struct pxa27x_ohci *ohci, struct device *dev)
         if (retval < 0)
                 return retval;
 
+        if (cpu_is_pxa3xx())
+                pxa3xx_u2d_start_hc(&ohci_to_hcd(&ohci->ohci)->self);
+
         uhchr = __raw_readl(ohci->mmio_base + UHCHR) & ~UHCHR_SSE;
         __raw_writel(uhchr, ohci->mmio_base + UHCHR);
         __raw_writel(UHCHIE_UPRIE | UHCHIE_RWIE, ohci->mmio_base + UHCHIE);
@@ -251,6 +255,9 @@ static void pxa27x_stop_hc(struct pxa27x_ohci *ohci, struct device *dev)
 
         inf = dev->platform_data;
 
+        if (cpu_is_pxa3xx())
+                pxa3xx_u2d_stop_hc(&ohci_to_hcd(&ohci->ohci)->self);
+
         if (inf->exit)
                 inf->exit(dev);
 
diff --git a/drivers/usb/host/sl811_cs.c b/drivers/usb/host/sl811_cs.c
index 0e13a00eb2ed..3775c035a6c5 100644
--- a/drivers/usb/host/sl811_cs.c
+++ b/drivers/usb/host/sl811_cs.c
@@ -20,7 +20,6 @@
 #include <linux/ioport.h>
 #include <linux/platform_device.h>
 
-#include <pcmcia/cs.h>
 #include <pcmcia/cistpl.h>
 #include <pcmcia/cisreg.h>
 #include <pcmcia/ds.h>
@@ -132,49 +131,12 @@ static void sl811_cs_release(struct pcmcia_device * link)
         platform_device_unregister(&platform_dev);
 }
 
-static int sl811_cs_config_check(struct pcmcia_device *p_dev,
-                                 cistpl_cftable_entry_t *cfg,
-                                 cistpl_cftable_entry_t *dflt,
-                                 unsigned int vcc,
-                                 void *priv_data)
+static int sl811_cs_config_check(struct pcmcia_device *p_dev, void *priv_data)
 {
-        if (cfg->index == 0)
-                return -ENODEV;
-
-        /* Use power settings for Vcc and Vpp if present */
-        /*  Note that the CIS values need to be rescaled */
-        if (cfg->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (cfg->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
-                        return -ENODEV;
-        } else if (dflt->vcc.present & (1<<CISTPL_POWER_VNOM)) {
-                if (dflt->vcc.param[CISTPL_POWER_VNOM]/10000 != vcc)
-                        return -ENODEV;
-                }
-
-        if (cfg->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        cfg->vpp1.param[CISTPL_POWER_VNOM]/10000;
-        else if (dflt->vpp1.present & (1<<CISTPL_POWER_VNOM))
-                p_dev->conf.Vpp =
-                        dflt->vpp1.param[CISTPL_POWER_VNOM]/10000;
-
-        /* we need an interrupt */
-        p_dev->conf.Attributes |= CONF_ENABLE_IRQ;
-
-        /* IO window settings */
-        p_dev->resource[0]->end = p_dev->resource[1]->end = 0;
-        if ((cfg->io.nwin > 0) || (dflt->io.nwin > 0)) {
-                cistpl_io_t *io = (cfg->io.nwin) ? &cfg->io : &dflt->io;
-                p_dev->io_lines = io->flags & CISTPL_IO_LINES_MASK;
-
-                p_dev->resource[0]->flags |= IO_DATA_PATH_WIDTH_8;
-                p_dev->resource[0]->start = io->win[0].base;
-                p_dev->resource[0]->end = io->win[0].len;
-
-                return pcmcia_request_io(p_dev);
-        }
-        pcmcia_disable_device(p_dev);
-        return -ENODEV;
+        if (p_dev->config_index == 0)
+                return -EINVAL;
+
+        return pcmcia_request_io(p_dev);
 }
 
 
@@ -185,6 +147,9 @@ static int sl811_cs_config(struct pcmcia_device *link)
 
         dev_dbg(&link->dev, "sl811_cs_config\n");
 
+        link->config_flags |= CONF_ENABLE_IRQ | CONF_AUTO_SET_VPP |
+                CONF_AUTO_CHECK_VCC | CONF_AUTO_SET_IO;
+
         if (pcmcia_loop_config(link, sl811_cs_config_check, NULL))
                 goto failed;
 
@@ -195,18 +160,10 @@ static int sl811_cs_config(struct pcmcia_device *link)
         if (!link->irq)
                 goto failed;
 
-        ret = pcmcia_request_configuration(link, &link->conf);
+        ret = pcmcia_enable_device(link);
         if (ret)
                 goto failed;
 
-        dev_info(&link->dev, "index 0x%02x: ",
-                link->conf.ConfigIndex);
-        if (link->conf.Vpp)
-                printk(", Vpp %d.%d", link->conf.Vpp/10, link->conf.Vpp%10);
-        printk(", irq %d", link->irq);
-        printk(", io %pR", link->resource[0]);
-        printk("\n");
-
         if (sl811_hc_init(parent, link->resource[0]->start, link->irq)
                         < 0) {
 failed:
@@ -227,9 +184,6 @@ static int sl811_cs_probe(struct pcmcia_device *link)
         local->p_dev = link;
         link->priv = local;
 
-        link->conf.Attributes = 0;
-        link->conf.IntType = INT_MEMORY_AND_IO;
-
         return sl811_cs_config(link);
 }
 
@@ -241,9 +195,7 @@ MODULE_DEVICE_TABLE(pcmcia, sl811_ids);
 
 static struct pcmcia_driver sl811_cs_driver = {
         .owner          = THIS_MODULE,
-        .drv            = {
-                .name   = "sl811_cs",
-        },
+        .name           = "sl811_cs",
         .probe          = sl811_cs_probe,
         .remove         = sl811_cs_detach,
         .id_table       = sl811_ids,
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 7c8008225ee3..17927b1f9334 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -127,7 +127,10 @@ static void handle_tx(struct vhost_net *net)
         size_t len, total_len = 0;
         int err, wmem;
         size_t hdr_size;
-        struct socket *sock = rcu_dereference(vq->private_data);
+        struct socket *sock;
+
+        sock = rcu_dereference_check(vq->private_data,
+                                     lockdep_is_held(&vq->mutex));
         if (!sock)
                 return;
 
@@ -582,7 +585,10 @@ static void vhost_net_disable_vq(struct vhost_net *n,
 static void vhost_net_enable_vq(struct vhost_net *n,
                                 struct vhost_virtqueue *vq)
 {
-        struct socket *sock = vq->private_data;
+        struct socket *sock;
+
+        sock = rcu_dereference_protected(vq->private_data,
+                                         lockdep_is_held(&vq->mutex));
         if (!sock)
                 return;
         if (vq == n->vqs + VHOST_NET_VQ_TX) {
@@ -598,7 +604,8 @@ static struct socket *vhost_net_stop_vq(struct vhost_net *n,
         struct socket *sock;
 
         mutex_lock(&vq->mutex);
-        sock = vq->private_data;
+        sock = rcu_dereference_protected(vq->private_data,
+                                         lockdep_is_held(&vq->mutex));
         vhost_net_disable_vq(n, vq);
         rcu_assign_pointer(vq->private_data, NULL);
         mutex_unlock(&vq->mutex);
@@ -736,7 +743,8 @@ static long vhost_net_set_backend(struct vhost_net *n, unsigned index, int fd)
         }
 
         /* start polling new socket */
-        oldsock = vq->private_data;
+        oldsock = rcu_dereference_protected(vq->private_data,
+                                            lockdep_is_held(&vq->mutex));
         if (sock != oldsock) {
                 vhost_net_disable_vq(n, vq);
                 rcu_assign_pointer(vq->private_data, sock);
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index dd3d6f7406f8..8b5a1b33d0fe 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -320,7 +320,7 @@ long vhost_dev_reset_owner(struct vhost_dev *dev)
         vhost_dev_cleanup(dev);
 
         memory->nregions = 0;
-        dev->memory = memory;
+        RCU_INIT_POINTER(dev->memory, memory);
         return 0;
 }
 
@@ -352,8 +352,9 @@ void vhost_dev_cleanup(struct vhost_dev *dev)
                 fput(dev->log_file);
         dev->log_file = NULL;
         /* No one will access memory at this point */
-        kfree(dev->memory);
-        dev->memory = NULL;
+        kfree(rcu_dereference_protected(dev->memory,
+                                        lockdep_is_held(&dev->mutex)));
+        RCU_INIT_POINTER(dev->memory, NULL);
         if (dev->mm)
                 mmput(dev->mm);
         dev->mm = NULL;
@@ -440,14 +441,22 @@ static int vq_access_ok(unsigned int num,
 /* Caller should have device mutex but not vq mutex */
 int vhost_log_access_ok(struct vhost_dev *dev)
 {
-        return memory_access_ok(dev, dev->memory, 1);
+        struct vhost_memory *mp;
+
+        mp = rcu_dereference_protected(dev->memory,
+                                       lockdep_is_held(&dev->mutex));
+        return memory_access_ok(dev, mp, 1);
 }
 
 /* Verify access for write logging. */
 /* Caller should have vq mutex and device mutex */
 static int vq_log_access_ok(struct vhost_virtqueue *vq, void __user *log_base)
 {
-        return vq_memory_access_ok(log_base, vq->dev->memory,
+        struct vhost_memory *mp;
+
+        mp = rcu_dereference_protected(vq->dev->memory,
+                                       lockdep_is_held(&vq->mutex));
+        return vq_memory_access_ok(log_base, mp,
                             vhost_has_feature(vq->dev, VHOST_F_LOG_ALL)) &&
                 (!vq->log_used || log_access_ok(log_base, vq->log_addr,
                                         sizeof *vq->used +
@@ -487,7 +496,8 @@ static long vhost_set_memory(struct vhost_dev *d, struct vhost_memory __user *m)
                 kfree(newmem);
                 return -EFAULT;
         }
-        oldmem = d->memory;
+        oldmem = rcu_dereference_protected(d->memory,
+                                           lockdep_is_held(&d->mutex));
         rcu_assign_pointer(d->memory, newmem);
         synchronize_rcu();
         kfree(oldmem);
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index afd77295971c..af3c11ded5fd 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -106,7 +106,7 @@ struct vhost_virtqueue {
          * vhost_work execution acts instead of rcu_read_lock() and the end of
          * vhost_work execution acts instead of rcu_read_lock().
          * Writers use virtqueue mutex. */
-        void *private_data;
+        void __rcu *private_data;
         /* Log write descriptors */
         void __user *log_base;
         struct vhost_log log[VHOST_NET_MAX_SG];
@@ -116,7 +116,7 @@ struct vhost_dev {
         /* Readers use RCU to access memory table pointer
          * log base pointer and features.
          * Writers use mutex below.*/
-        struct vhost_memory *memory;
+        struct vhost_memory __rcu *memory;
         struct mm_struct *mm;
         struct mutex mutex;
         unsigned acked_features;
@@ -173,7 +173,11 @@ enum {
 
 static inline int vhost_has_feature(struct vhost_dev *dev, int bit)
 {
-        unsigned acked_features = rcu_dereference(dev->acked_features);
+        unsigned acked_features;
+
+        acked_features =
+                rcu_dereference_index_check(dev->acked_features,
+                                            lockdep_is_held(&dev->mutex));
         return acked_features & (1 << bit);
 }
 
diff --git a/drivers/video/pxa168fb.c b/drivers/video/pxa168fb.c
index a31a77ff6f3d..cea6403ae71c 100644
--- a/drivers/video/pxa168fb.c
+++ b/drivers/video/pxa168fb.c
@@ -784,12 +784,53 @@ failed:
         return ret;
 }
 
+static int __devexit pxa168fb_remove(struct platform_device *pdev)
+{
+        struct pxa168fb_info *fbi = platform_get_drvdata(pdev);
+        struct fb_info *info;
+        int irq;
+        unsigned int data;
+
+        if (!fbi)
+                return 0;
+
+        /* disable DMA transfer */
+        data = readl(fbi->reg_base + LCD_SPU_DMA_CTRL0);
+        data &= ~CFG_GRA_ENA_MASK;
+        writel(data, fbi->reg_base + LCD_SPU_DMA_CTRL0);
+
+        info = fbi->info;
+
+        unregister_framebuffer(info);
+
+        writel(GRA_FRAME_IRQ0_ENA(0x0), fbi->reg_base + SPU_IRQ_ENA);
+
+        if (info->cmap.len)
+                fb_dealloc_cmap(&info->cmap);
+
+        irq = platform_get_irq(pdev, 0);
+        free_irq(irq, fbi);
+
+        dma_free_writecombine(fbi->dev, PAGE_ALIGN(info->fix.smem_len),
+                                info->screen_base, info->fix.smem_start);
+
+        iounmap(fbi->reg_base);
+
+        clk_disable(fbi->clk);
+        clk_put(fbi->clk);
+
+        framebuffer_release(info);
+
+        return 0;
+}
+
 static struct platform_driver pxa168fb_driver = {
         .driver         = {
                 .name   = "pxa168-fb",
                 .owner  = THIS_MODULE,
         },
         .probe          = pxa168fb_probe,
+        .remove         = __devexit_p(pxa168fb_remove),
 };
 
 static int __init pxa168fb_init(void)
@@ -798,6 +839,12 @@ static int __init pxa168fb_init(void)
 }
 module_init(pxa168fb_init);
 
+static void __exit pxa168fb_exit(void)
+{
+        platform_driver_unregister(&pxa168fb_driver);
+}
+module_exit(pxa168fb_exit);
+
 MODULE_AUTHOR("Lennert Buytenhek <buytenh@marvell.com> "
               "Green Wan <gwan@marvell.com>");
 MODULE_DESCRIPTION("Framebuffer driver for PXA168/910");
diff --git a/drivers/vlynq/vlynq.c b/drivers/vlynq/vlynq.c
index f2d9e667972d..f885c868a04d 100644
--- a/drivers/vlynq/vlynq.c
+++ b/drivers/vlynq/vlynq.c
@@ -31,6 +31,7 @@
 #include <linux/delay.h>
 #include <linux/io.h>
 #include <linux/slab.h>
+#include <linux/irq.h>
 
 #include <linux/vlynq.h>
 
diff --git a/drivers/watchdog/octeon-wdt-main.c b/drivers/watchdog/octeon-wdt-main.c
index 2a410170eca6..909923800a02 100644
--- a/drivers/watchdog/octeon-wdt-main.c
+++ b/drivers/watchdog/octeon-wdt-main.c
@@ -64,6 +64,7 @@
 #include <linux/cpu.h>
 #include <linux/smp.h>
 #include <linux/fs.h>
+#include <linux/irq.h>
 
 #include <asm/mipsregs.h>
 #include <asm/uasm.h>
diff --git a/drivers/xen/events.c b/drivers/xen/events.c
index 13365ba35218..7d24b0d94ed4 100644
--- a/drivers/xen/events.c
+++ b/drivers/xen/events.c
@@ -338,30 +338,29 @@ static void unmask_evtchn(int port)
 
 static int find_unbound_irq(void)
 {
-        int irq;
-        struct irq_desc *desc;
+        struct irq_data *data;
+        int irq, res;
 
         for (irq = 0; irq < nr_irqs; irq++) {
-                desc = irq_to_desc(irq);
+                data = irq_get_irq_data(irq);
                 /* only 0->15 have init'd desc; handle irq > 16 */
-                if (desc == NULL)
+                if (!data)
                         break;
-                if (desc->chip == &no_irq_chip)
+                if (data->chip == &no_irq_chip)
                         break;
-                if (desc->chip != &xen_dynamic_chip)
+                if (data->chip != &xen_dynamic_chip)
                         continue;
                 if (irq_info[irq].type == IRQT_UNBOUND)
-                        break;
+                        return irq;
         }
 
         if (irq == nr_irqs)
                 panic("No available IRQ to bind to: increase nr_irqs!\n");
 
-        desc = irq_to_desc_alloc_node(irq, 0);
-        if (WARN_ON(desc == NULL))
-                return -1;
+        res = irq_alloc_desc_at(irq, 0);
 
-        dynamic_irq_init_keep_chip_data(irq);
+        if (WARN_ON(res != irq))
+                return -1;
 
         return irq;
 }
@@ -495,7 +494,7 @@ static void unbind_from_irq(unsigned int irq)
         if (irq_info[irq].type != IRQT_UNBOUND) {
                 irq_info[irq] = mk_unbound_info();
 
-                dynamic_irq_cleanup(irq);
+                irq_free_desc(irq);
         }
 
         spin_unlock(&irq_mapping_update_lock);