329 files changed, 9431 insertions, 3361 deletions

diff --git a/drivers/Kconfig b/drivers/Kconfig
index 3d93b3a3d63..dd0a5b5e9bf 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -88,6 +88,8 @@ source "drivers/memstick/Kconfig"
 
 source "drivers/leds/Kconfig"
 
+source "drivers/nfc/Kconfig"
+
 source "drivers/accessibility/Kconfig"
 
 source "drivers/infiniband/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index bf15ce7493d..ef5132469f5 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -40,7 +40,7 @@ obj-$(CONFIG_FB_INTEL)          += video/intelfb/
 
 obj-y                           += serial/
 obj-$(CONFIG_PARPORT)           += parport/
-obj-y                           += base/ block/ misc/ mfd/
+obj-y                           += base/ block/ misc/ mfd/ nfc/
 obj-$(CONFIG_NUBUS)             += nubus/
 obj-y                           += macintosh/
 obj-$(CONFIG_IDE)               += ide/
diff --git a/drivers/acpi/acpica/acobject.h b/drivers/acpi/acpica/acobject.h
index bdbfaf22bd1..962a3ccff6f 100644
--- a/drivers/acpi/acpica/acobject.h
+++ b/drivers/acpi/acpica/acobject.h
@@ -93,7 +93,7 @@
 
 #define AOPOBJ_AML_CONSTANT         0x01        /* Integer is an AML constant */
 #define AOPOBJ_STATIC_POINTER       0x02        /* Data is part of an ACPI table, don't delete */
-#define AOPOBJ_DATA_VALID           0x04        /* Object is intialized and data is valid */
+#define AOPOBJ_DATA_VALID           0x04        /* Object is initialized and data is valid */
 #define AOPOBJ_OBJECT_INITIALIZED   0x08        /* Region is initialized, _REG was run */
 #define AOPOBJ_SETUP_COMPLETE       0x10        /* Region setup is complete */
 #define AOPOBJ_INVALID              0x20        /* Host OS won't allow a Region address */
diff --git a/drivers/acpi/apei/einj.c b/drivers/acpi/apei/einj.c
index cf29df69380..096aebfe7f3 100644
--- a/drivers/acpi/apei/einj.c
+++ b/drivers/acpi/apei/einj.c
@@ -39,7 +39,7 @@
 #define EINJ_PFX "EINJ: "
 
 #define SPIN_UNIT               100                     /* 100ns */
-/* Firmware should respond within 1 miliseconds */
+/* Firmware should respond within 1 milliseconds */
 #define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
 
 /*
diff --git a/drivers/acpi/apei/erst.c b/drivers/acpi/apei/erst.c
index 5850d320404..cf6db6b7662 100644
--- a/drivers/acpi/apei/erst.c
+++ b/drivers/acpi/apei/erst.c
@@ -53,7 +53,7 @@
                                      sizeof(struct acpi_table_erst)))
 
 #define SPIN_UNIT               100                     /* 100ns */
-/* Firmware should respond within 1 miliseconds */
+/* Firmware should respond within 1 milliseconds */
 #define FIRMWARE_TIMEOUT        (1 * NSEC_PER_MSEC)
 #define FIRMWARE_MAX_STALL      50                      /* 50us */
 
diff --git a/drivers/acpi/sleep.c b/drivers/acpi/sleep.c
index febb153b5a6..c423231b952 100644
--- a/drivers/acpi/sleep.c
+++ b/drivers/acpi/sleep.c
@@ -319,7 +319,7 @@ static int acpi_suspend_state_valid(suspend_state_t pm_state)
         }
 }
 
-static struct platform_suspend_ops acpi_suspend_ops = {
+static const struct platform_suspend_ops acpi_suspend_ops = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin,
         .prepare_late = acpi_pm_prepare,
@@ -347,7 +347,7 @@ static int acpi_suspend_begin_old(suspend_state_t pm_state)
  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
  * been requested.
  */
-static struct platform_suspend_ops acpi_suspend_ops_old = {
+static const struct platform_suspend_ops acpi_suspend_ops_old = {
         .valid = acpi_suspend_state_valid,
         .begin = acpi_suspend_begin_old,
         .prepare_late = acpi_pm_pre_suspend,
@@ -506,7 +506,7 @@ static void acpi_pm_thaw(void)
         acpi_enable_all_runtime_gpes();
 }
 
-static struct platform_hibernation_ops acpi_hibernation_ops = {
+static const struct platform_hibernation_ops acpi_hibernation_ops = {
         .begin = acpi_hibernation_begin,
         .end = acpi_pm_end,
         .pre_snapshot = acpi_pm_prepare,
@@ -549,7 +549,7 @@ static int acpi_hibernation_begin_old(void)
  * The following callbacks are used if the pre-ACPI 2.0 suspend ordering has
  * been requested.
  */
-static struct platform_hibernation_ops acpi_hibernation_ops_old = {
+static const struct platform_hibernation_ops acpi_hibernation_ops_old = {
         .begin = acpi_hibernation_begin_old,
         .end = acpi_pm_end,
         .pre_snapshot = acpi_pm_pre_suspend,
diff --git a/drivers/acpi/video.c b/drivers/acpi/video.c
index 5cd0228d2da..15a0fde4b32 100644
--- a/drivers/acpi/video.c
+++ b/drivers/acpi/video.c
@@ -260,7 +260,7 @@ static int acpi_video_set_brightness(struct backlight_device *bd)
                                 vd->brightness->levels[request_level]);
 }
 
-static struct backlight_ops acpi_backlight_ops = {
+static const struct backlight_ops acpi_backlight_ops = {
         .get_brightness = acpi_video_get_brightness,
         .update_status  = acpi_video_set_brightness,
 };
diff --git a/drivers/ata/libata-core.c b/drivers/ata/libata-core.c
index 0a6a943b377..a31fe96f7de 100644
--- a/drivers/ata/libata-core.c
+++ b/drivers/ata/libata-core.c
@@ -2240,7 +2240,7 @@ int ata_dev_configure(struct ata_device *dev)
                         if (id[ATA_ID_CFA_KEY_MGMT] & 1)
                                 ata_dev_printk(dev, KERN_WARNING,
                                                "supports DRM functions and may "
-                                               "not be fully accessable.\n");
+                                               "not be fully accessible.\n");
                         snprintf(revbuf, 7, "CFA");
                 } else {
                         snprintf(revbuf, 7, "ATA-%d", ata_id_major_version(id));
@@ -2248,7 +2248,7 @@ int ata_dev_configure(struct ata_device *dev)
                         if (ata_id_has_tpm(id))
                                 ata_dev_printk(dev, KERN_WARNING,
                                                "supports DRM functions and may "
-                                               "not be fully accessable.\n");
+                                               "not be fully accessible.\n");
                 }
 
                 dev->n_sectors = ata_id_n_sectors(id);
diff --git a/drivers/ata/sata_vsc.c b/drivers/ata/sata_vsc.c
index b777176ff49..e079cf29ed5 100644
--- a/drivers/ata/sata_vsc.c
+++ b/drivers/ata/sata_vsc.c
@@ -370,7 +370,7 @@ static int __devinit vsc_sata_init_one(struct pci_dev *pdev,
         if (pci_resource_len(pdev, 0) == 0)
                 return -ENODEV;
 
-        /* map IO regions and intialize host accordingly */
+        /* map IO regions and initialize host accordingly */
         rc = pcim_iomap_regions(pdev, 1 << VSC_MMIO_BAR, DRV_NAME);
         if (rc == -EBUSY)
                 pcim_pin_device(pdev);
diff --git a/drivers/atm/idt77252.h b/drivers/atm/idt77252.h
index 5042bb2dab1..f53a43ae2bb 100644
--- a/drivers/atm/idt77252.h
+++ b/drivers/atm/idt77252.h
@@ -572,7 +572,7 @@ struct idt77252_dev
 #define SAR_STAT_TSQF       0x00001000 /* Transmit Status Queue full      */
 #define SAR_STAT_TMROF      0x00000800 /* Timer overflow                  */
 #define SAR_STAT_PHYI       0x00000400 /* PHY device Interrupt flag       */
-#define SAR_STAT_CMDBZ      0x00000200 /* ABR SAR Comand Busy Flag        */
+#define SAR_STAT_CMDBZ      0x00000200 /* ABR SAR Command Busy Flag       */
 #define SAR_STAT_FBQ3A      0x00000100 /* Free Buffer Queue 3 Attention   */
 #define SAR_STAT_FBQ2A      0x00000080 /* Free Buffer Queue 2 Attention   */
 #define SAR_STAT_RSQF       0x00000040 /* Receive Status Queue full       */
diff --git a/drivers/atm/iphase.c b/drivers/atm/iphase.c
index 72925405375..d80d51b62a1 100644
--- a/drivers/atm/iphase.c
+++ b/drivers/atm/iphase.c
@@ -2063,7 +2063,7 @@ static int tx_init(struct atm_dev *dev)
                 - UBR Table size is 4K  
                 - UBR wait queue is 4K  
            since the table and wait queues are contiguous, all the bytes   
-           can be initialized by one memeset.  
+           can be initialized by one memeset.
         */  
         
         vcsize_sel = 0;
@@ -2089,7 +2089,7 @@ static int tx_init(struct atm_dev *dev)
                 - ABR Table size is 2K  
                 - ABR wait queue is 2K  
            since the table and wait queues are contiguous, all the bytes   
-           can be intialized by one memeset.  
+           can be initialized by one memeset.
         */  
         i = ABR_SCHED_TABLE * iadev->memSize;
         writew((i >> 11) & 0xffff, iadev->seg_reg+ABR_SBPTR_BASE);
diff --git a/drivers/base/bus.c b/drivers/base/bus.c
index e243bd49764..000e7b2006f 100644
--- a/drivers/base/bus.c
+++ b/drivers/base/bus.c
@@ -975,7 +975,7 @@ struct klist *bus_get_device_klist(struct bus_type *bus)
 EXPORT_SYMBOL_GPL(bus_get_device_klist);
 
 /*
- * Yes, this forcably breaks the klist abstraction temporarily.  It
+ * Yes, this forcibly breaks the klist abstraction temporarily.  It
  * just wants to sort the klist, not change reference counts and
  * take/drop locks rapidly in the process.  It does all this while
  * holding the lock for the list, so objects can't otherwise be
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index 2a52270aeb3..83404973f97 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -8,7 +8,7 @@
  *
  *
  * The driver model core calls device_pm_add() when a device is registered.
- * This will intialize the embedded device_pm_info object in the device
+ * This will initialize the embedded device_pm_info object in the device
  * and add it to the list of power-controlled devices. sysfs entries for
  * controlling device power management will also be added.
  *
diff --git a/drivers/block/Kconfig b/drivers/block/Kconfig
index 4b9359a6f6c..83c32cb7258 100644
--- a/drivers/block/Kconfig
+++ b/drivers/block/Kconfig
@@ -464,6 +464,7 @@ config XEN_BLKDEV_FRONTEND
         tristate "Xen virtual block device support"
         depends on XEN
         default y
+        select XEN_XENBUS_FRONTEND
         help
           This driver implements the front-end of the Xen virtual
           block device driver.  It communicates with a back-end driver
diff --git a/drivers/char/Kconfig b/drivers/char/Kconfig
index d4a7776f4b7..0f175a866ef 100644
--- a/drivers/char/Kconfig
+++ b/drivers/char/Kconfig
@@ -1047,15 +1047,6 @@ config NSC_GPIO
           pc8736x_gpio drivers.  If those drivers are built as
           modules, this one will be too, named nsc_gpio
 
-config CS5535_GPIO
-        tristate "AMD CS5535/CS5536 GPIO (Geode Companion Device)"
-        depends on X86_32
-        help
-          Give userspace access to the GPIO pins on the AMD CS5535 and
-          CS5536 Geode companion devices.
-
-          If compiled as a module, it will be called cs5535_gpio.
-
 config RAW_DRIVER
         tristate "RAW driver (/dev/raw/rawN)"
         depends on BLOCK
diff --git a/drivers/char/Makefile b/drivers/char/Makefile
index fa0b824b7a6..1e9dffb3377 100644
--- a/drivers/char/Makefile
+++ b/drivers/char/Makefile
@@ -82,7 +82,6 @@ obj-$(CONFIG_NWFLASH)		+= nwflash.o
 obj-$(CONFIG_SCx200_GPIO)       += scx200_gpio.o
 obj-$(CONFIG_PC8736x_GPIO)      += pc8736x_gpio.o
 obj-$(CONFIG_NSC_GPIO)          += nsc_gpio.o
-obj-$(CONFIG_CS5535_GPIO)       += cs5535_gpio.o
 obj-$(CONFIG_GPIO_TB0219)       += tb0219.o
 obj-$(CONFIG_TELCLOCK)          += tlclk.o
 
diff --git a/drivers/char/agp/intel-agp.h b/drivers/char/agp/intel-agp.h
index 010e3defd6c..c195bfeade1 100644
--- a/drivers/char/agp/intel-agp.h
+++ b/drivers/char/agp/intel-agp.h
@@ -94,6 +94,8 @@
 #define G4x_GMCH_SIZE_VT_1_5M   (0xa << 8)
 #define G4x_GMCH_SIZE_VT_2M     (0xc << 8)
 
+#define GFX_FLSH_CNTL           0x2170 /* 915+ */
+
 #define I810_DRAM_CTL           0x3000
 #define I810_DRAM_ROW_0         0x00000001
 #define I810_DRAM_ROW_0_SDRAM   0x00000001
diff --git a/drivers/char/agp/intel-gtt.c b/drivers/char/agp/intel-gtt.c
index 356f73e0d17..e921b693412 100644
--- a/drivers/char/agp/intel-gtt.c
+++ b/drivers/char/agp/intel-gtt.c
@@ -688,14 +688,14 @@ static int intel_gtt_init(void)
 
         intel_private.base.stolen_size = intel_gtt_stolen_size();
 
+        intel_private.base.needs_dmar = USE_PCI_DMA_API && INTEL_GTT_GEN > 2;
+
         ret = intel_gtt_setup_scratch_page();
         if (ret != 0) {
                 intel_gtt_cleanup();
                 return ret;
         }
 
-        intel_private.base.needs_dmar = USE_PCI_DMA_API && INTEL_GTT_GEN > 2;
-
         return 0;
 }
 
@@ -814,6 +814,12 @@ static bool intel_enable_gtt(void)
                 }
         }
 
+        /* On the resume path we may be adjusting the PGTBL value, so
+         * be paranoid and flush all chipset write buffers...
+         */
+        if (INTEL_GTT_GEN >= 3)
+                writel(0, intel_private.registers+GFX_FLSH_CNTL);
+
         reg = intel_private.registers+I810_PGETBL_CTL;
         writel(intel_private.PGETBL_save, reg);
         if (HAS_PGTBL_EN && (readl(reg) & I810_PGETBL_ENABLED) == 0) {
@@ -823,6 +829,9 @@ static bool intel_enable_gtt(void)
                 return false;
         }
 
+        if (INTEL_GTT_GEN >= 3)
+                writel(0, intel_private.registers+GFX_FLSH_CNTL);
+
         return true;
 }
 
@@ -991,14 +1000,14 @@ static int intel_fake_agp_remove_entries(struct agp_memory *mem,
         if (mem->page_count == 0)
                 return 0;
 
+        intel_gtt_clear_range(pg_start, mem->page_count);
+
         if (intel_private.base.needs_dmar) {
                 intel_gtt_unmap_memory(mem->sg_list, mem->num_sg);
                 mem->sg_list = NULL;
                 mem->num_sg = 0;
         }
 
-        intel_gtt_clear_range(pg_start, mem->page_count);
-
         return 0;
 }
 
diff --git a/drivers/char/ramoops.c b/drivers/char/ramoops.c
index d3d63be2cd3..1a9f5f6d6ac 100644
--- a/drivers/char/ramoops.c
+++ b/drivers/char/ramoops.c
@@ -30,7 +30,7 @@
 
 #define RAMOOPS_KERNMSG_HDR "===="
 
-#define RECORD_SIZE 4096
+#define RECORD_SIZE 4096UL
 
 static ulong mem_address;
 module_param(mem_address, ulong, 0400);
@@ -68,11 +68,16 @@ static void ramoops_do_dump(struct kmsg_dumper *dumper,
         char *buf, *buf_orig;
         struct timeval timestamp;
 
+        if (reason != KMSG_DUMP_OOPS &&
+            reason != KMSG_DUMP_PANIC &&
+            reason != KMSG_DUMP_KEXEC)
+                return;
+
         /* Only dump oopses if dump_oops is set */
         if (reason == KMSG_DUMP_OOPS && !dump_oops)
                 return;
 
-        buf = (char *)(cxt->virt_addr + (cxt->count * RECORD_SIZE));
+        buf = cxt->virt_addr + (cxt->count * RECORD_SIZE);
         buf_orig = buf;
 
         memset(buf, '\0', RECORD_SIZE);
@@ -83,8 +88,8 @@ static void ramoops_do_dump(struct kmsg_dumper *dumper,
         buf += res;
 
         hdr_size = buf - buf_orig;
-        l2_cpy = min(l2, (unsigned long)(RECORD_SIZE - hdr_size));
-        l1_cpy = min(l1, (unsigned long)(RECORD_SIZE - hdr_size) - l2_cpy);
+        l2_cpy = min(l2, RECORD_SIZE - hdr_size);
+        l1_cpy = min(l1, RECORD_SIZE - hdr_size - l2_cpy);
 
         s2_start = l2 - l2_cpy;
         s1_start = l1 - l1_cpy;
diff --git a/drivers/dca/dca-core.c b/drivers/dca/dca-core.c
index b98c67664ae..c461eda6241 100644
--- a/drivers/dca/dca-core.c
+++ b/drivers/dca/dca-core.c
@@ -110,8 +110,6 @@ static void unregister_dca_providers(void)
 
         /* at this point only one domain in the list is expected */
         domain = list_first_entry(&dca_domains, struct dca_domain, node);
-        if (!domain)
-                return;
 
         list_for_each_entry_safe(dca, _dca, &domain->dca_providers, node) {
                 list_del(&dca->node);
diff --git a/drivers/dma/intel_mid_dma.c b/drivers/dma/intel_mid_dma.c
index 3109bd94bc4..78266382797 100644
--- a/drivers/dma/intel_mid_dma.c
+++ b/drivers/dma/intel_mid_dma.c
@@ -1060,8 +1060,8 @@ static irqreturn_t intel_mid_dma_interrupt2(int irq, void *data)
  * mid_setup_dma -      Setup the DMA controller
  * @pdev: Controller PCI device structure
  *
- * Initilize the DMA controller, channels, registers with DMA engine,
- * ISR. Initilize DMA controller channels.
+ * Initialize the DMA controller, channels, registers with DMA engine,
+ * ISR. Initialize DMA controller channels.
  */
 static int mid_setup_dma(struct pci_dev *pdev)
 {
@@ -1217,7 +1217,7 @@ static void middma_shutdown(struct pci_dev *pdev)
  * @pdev: Controller PCI device structure
  * @id: pci device id structure
  *
- * Initilize the PCI device, map BARs, query driver data.
+ * Initialize the PCI device, map BARs, query driver data.
  * Call setup_dma to complete contoller and chan initilzation
  */
 static int __devinit intel_mid_dma_probe(struct pci_dev *pdev,
diff --git a/drivers/edac/amd8131_edac.h b/drivers/edac/amd8131_edac.h
index 60e0d1c72de..6f8b07131ec 100644
--- a/drivers/edac/amd8131_edac.h
+++ b/drivers/edac/amd8131_edac.h
@@ -99,7 +99,7 @@ struct amd8131_dev_info {
 
 /*
  * AMD8131 chipset has two pairs of PCIX Bridge and related IOAPIC
- * Controler, and ATCA-6101 has two AMD8131 chipsets, so there are
+ * Controller, and ATCA-6101 has two AMD8131 chipsets, so there are
  * four PCIX Bridges on ATCA-6101 altogether.
  *
  * These PCIX Bridges share the same PCI Device ID and are all of
diff --git a/drivers/edac/cell_edac.c b/drivers/edac/cell_edac.c
index c973004c002..db1df59ae2b 100644
--- a/drivers/edac/cell_edac.c
+++ b/drivers/edac/cell_edac.c
@@ -47,7 +47,7 @@ static void cell_edac_count_ce(struct mem_ctl_info *mci, int chan, u64 ar)
         offset = address & ~PAGE_MASK;
         syndrome = (ar & 0x000000001fe00000ul) >> 21;
 
-        /* TODO: Decoding of the error addresss */
+        /* TODO: Decoding of the error address */
         edac_mc_handle_ce(mci, csrow->first_page + pfn, offset,
                           syndrome, 0, chan, "");
 }
@@ -68,7 +68,7 @@ static void cell_edac_count_ue(struct mem_ctl_info *mci, int chan, u64 ar)
         pfn = address >> PAGE_SHIFT;
         offset = address & ~PAGE_MASK;
 
-        /* TODO: Decoding of the error addresss */
+        /* TODO: Decoding of the error address */
         edac_mc_handle_ue(mci, csrow->first_page + pfn, offset, 0, "");
 }
 
diff --git a/drivers/edac/edac_core.h b/drivers/edac/edac_core.h
index ff1eb7bb26c..3d965347a67 100644
--- a/drivers/edac/edac_core.h
+++ b/drivers/edac/edac_core.h
@@ -259,7 +259,7 @@ enum scrub_type {
  *                      for single channel are 64 bits, for dual channel 128
  *                      bits.
  *
- * Single-Ranked stick: A Single-ranked stick has 1 chip-select row of memmory.
+ * Single-Ranked stick: A Single-ranked stick has 1 chip-select row of memory.
  *                      Motherboards commonly drive two chip-select pins to
  *                      a memory stick. A single-ranked stick, will occupy
  *                      only one of those rows. The other will be unused.
diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c
index 362861c1577..81154ab296b 100644
--- a/drivers/edac/i7core_edac.c
+++ b/drivers/edac/i7core_edac.c
@@ -1,6 +1,6 @@
 /* Intel i7 core/Nehalem Memory Controller kernel module
  *
- * This driver supports yhe memory controllers found on the Intel
+ * This driver supports the memory controllers found on the Intel
  * processor families i7core, i7core 7xx/8xx, i5core, Xeon 35xx,
  * Xeon 55xx and Xeon 56xx also known as Nehalem, Nehalem-EP, Lynnfield
  * and Westmere-EP.
@@ -1271,7 +1271,7 @@ static void __init i7core_xeon_pci_fixup(const struct pci_id_table *table)
         int i;
 
         /*
-         * On Xeon 55xx, the Intel Quckpath Arch Generic Non-core pci buses
+         * On Xeon 55xx, the Intel Quick Path Arch Generic Non-core pci buses
          * aren't announced by acpi. So, we need to use a legacy scan probing
          * to detect them
          */
@@ -1864,7 +1864,7 @@ static int i7core_mce_check_error(void *priv, struct mce *mce)
         if (mce->mcgstatus & 1)
                 i7core_check_error(mci);
 
-        /* Advice mcelog that the error were handled */
+        /* Advise mcelog that the errors were handled */
         return 1;
 }
 
diff --git a/drivers/edac/ppc4xx_edac.c b/drivers/edac/ppc4xx_edac.c
index 070cea41b66..b9f0c20df1a 100644
--- a/drivers/edac/ppc4xx_edac.c
+++ b/drivers/edac/ppc4xx_edac.c
@@ -873,7 +873,7 @@ ppc4xx_edac_get_mtype(u32 mcopt1)
 }
 
 /**
- * ppc4xx_edac_init_csrows - intialize driver instance rows
+ * ppc4xx_edac_init_csrows - initialize driver instance rows
  * @mci: A pointer to the EDAC memory controller instance
  *       associated with the ibm,sdram-4xx-ddr2 controller for which
  *       the csrows (i.e. banks/ranks) are being initialized.
@@ -881,7 +881,7 @@ ppc4xx_edac_get_mtype(u32 mcopt1)
  *          currently set for the controller, from which bank width
  *          and memory typ information is derived.
  *
- * This routine intializes the virtual "chip select rows" associated
+ * This routine initializes the virtual "chip select rows" associated
  * with the EDAC memory controller instance. An ibm,sdram-4xx-ddr2
  * controller bank/rank is mapped to a row.
  *
@@ -992,7 +992,7 @@ ppc4xx_edac_init_csrows(struct mem_ctl_info *mci, u32 mcopt1)
 }
 
 /**
- * ppc4xx_edac_mc_init - intialize driver instance
+ * ppc4xx_edac_mc_init - initialize driver instance
  * @mci: A pointer to the EDAC memory controller instance being
  *       initialized.
  * @op: A pointer to the OpenFirmware device tree node associated
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index 082495bb08a..664660e5633 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -118,7 +118,7 @@ config GPIO_SCH
 
 config GPIO_VX855
         tristate "VIA VX855/VX875 GPIO"
-        depends on GPIOLIB
+        depends on GPIOLIB && MFD_SUPPORT && PCI
         select MFD_CORE
         select MFD_VX855
         help
@@ -295,7 +295,7 @@ comment "PCI GPIO expanders:"
 
 config GPIO_CS5535
         tristate "AMD CS5535/CS5536 GPIO support"
-        depends on PCI && !CS5535_GPIO
+        depends on PCI && X86 && !CS5535_GPIO
         help
           The AMD CS5535 and CS5536 southbridges support 28 GPIO pins that
           can be used for quite a number of things.  The CS5535/6 is found on
@@ -333,6 +333,15 @@ config GPIO_PCH
           which is an IOH(Input/Output Hub) for x86 embedded processor.
           This driver can access PCH GPIO device.
 
+config GPIO_ML_IOH
+        tristate "OKI SEMICONDUCTOR ML7213 IOH GPIO support"
+        depends on PCI
+        help
+          ML7213 is companion chip for Intel Atom E6xx series.
+          This driver can be used for OKI SEMICONDUCTOR ML7213 IOH(Input/Output
+          Hub) which is for IVI(In-Vehicle Infotainment) use.
+          This driver can access the IOH's GPIO device.
+
 config GPIO_TIMBERDALE
         bool "Support for timberdale GPIO IP"
         depends on MFD_TIMBERDALE && GPIOLIB && HAS_IOMEM
@@ -342,6 +351,7 @@ config GPIO_TIMBERDALE
 config GPIO_RDC321X
         tristate "RDC R-321x GPIO support"
         depends on PCI && GPIOLIB
+        select MFD_SUPPORT
         select MFD_CORE
         select MFD_RDC321X
         help
diff --git a/drivers/gpio/Makefile b/drivers/gpio/Makefile
index 39bfd7a3765..3351cf87b0e 100644
--- a/drivers/gpio/Makefile
+++ b/drivers/gpio/Makefile
@@ -41,3 +41,4 @@ obj-$(CONFIG_GPIO_RDC321X)	+= rdc321x-gpio.o
 obj-$(CONFIG_GPIO_JANZ_TTL)     += janz-ttl.o
 obj-$(CONFIG_GPIO_SX150X)       += sx150x.o
 obj-$(CONFIG_GPIO_VX855)        += vx855_gpio.o
+obj-$(CONFIG_GPIO_ML_IOH)       += ml_ioh_gpio.o
diff --git a/drivers/gpio/adp5588-gpio.c b/drivers/gpio/adp5588-gpio.c
index 0871f78af59..33fc685cb38 100644
--- a/drivers/gpio/adp5588-gpio.c
+++ b/drivers/gpio/adp5588-gpio.c
@@ -146,9 +146,10 @@ static int adp5588_gpio_to_irq(struct gpio_chip *chip, unsigned off)
         return dev->irq_base + off;
 }
 
-static void adp5588_irq_bus_lock(unsigned int irq)
+static void adp5588_irq_bus_lock(struct irq_data *d)
 {
-        struct adp5588_gpio *dev = get_irq_chip_data(irq);
+        struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
+
         mutex_lock(&dev->irq_lock);
 }
 
@@ -160,9 +161,9 @@ static void adp5588_irq_bus_lock(unsigned int irq)
   * and unlocks the bus.
   */
 
-static void adp5588_irq_bus_sync_unlock(unsigned int irq)
+static void adp5588_irq_bus_sync_unlock(struct irq_data *d)
 {
-        struct adp5588_gpio *dev = get_irq_chip_data(irq);
+        struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
         int i;
 
         for (i = 0; i <= ADP5588_BANK(ADP5588_MAXGPIO); i++)
@@ -175,31 +176,31 @@ static void adp5588_irq_bus_sync_unlock(unsigned int irq)
         mutex_unlock(&dev->irq_lock);
 }
 
-static void adp5588_irq_mask(unsigned int irq)
+static void adp5588_irq_mask(struct irq_data *d)
 {
-        struct adp5588_gpio *dev = get_irq_chip_data(irq);
-        unsigned gpio = irq - dev->irq_base;
+        struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
+        unsigned gpio = d->irq - dev->irq_base;
 
         dev->irq_mask[ADP5588_BANK(gpio)] &= ~ADP5588_BIT(gpio);
 }
 
-static void adp5588_irq_unmask(unsigned int irq)
+static void adp5588_irq_unmask(struct irq_data *d)
 {
-        struct adp5588_gpio *dev = get_irq_chip_data(irq);
-        unsigned gpio = irq - dev->irq_base;
+        struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
+        unsigned gpio = d->irq - dev->irq_base;
 
         dev->irq_mask[ADP5588_BANK(gpio)] |= ADP5588_BIT(gpio);
 }
 
-static int adp5588_irq_set_type(unsigned int irq, unsigned int type)
+static int adp5588_irq_set_type(struct irq_data *d, unsigned int type)
 {
-        struct adp5588_gpio *dev = get_irq_chip_data(irq);
-        uint16_t gpio = irq - dev->irq_base;
+        struct adp5588_gpio *dev = irq_data_get_irq_chip_data(d);
+        uint16_t gpio = d->irq - dev->irq_base;
         unsigned bank, bit;
 
         if ((type & IRQ_TYPE_EDGE_BOTH)) {
                 dev_err(&dev->client->dev, "irq %d: unsupported type %d\n",
-                        irq, type);
+                        d->irq, type);
                 return -EINVAL;
         }
 
@@ -222,11 +223,11 @@ static int adp5588_irq_set_type(unsigned int irq, unsigned int type)
 
 static struct irq_chip adp5588_irq_chip = {
         .name                   = "adp5588",
-        .mask                   = adp5588_irq_mask,
-        .unmask                 = adp5588_irq_unmask,
-        .bus_lock               = adp5588_irq_bus_lock,
-        .bus_sync_unlock        = adp5588_irq_bus_sync_unlock,
-        .set_type               = adp5588_irq_set_type,
+        .irq_mask               = adp5588_irq_mask,
+        .irq_unmask             = adp5588_irq_unmask,
+        .irq_bus_lock           = adp5588_irq_bus_lock,
+        .irq_bus_sync_unlock    = adp5588_irq_bus_sync_unlock,
+        .irq_set_type           = adp5588_irq_set_type,
 };
 
 static int adp5588_gpio_read_intstat(struct i2c_client *client, u8 *buf)
diff --git a/drivers/gpio/cs5535-gpio.c b/drivers/gpio/cs5535-gpio.c
index d3e55a0ae92..815d98b2c1b 100644
--- a/drivers/gpio/cs5535-gpio.c
+++ b/drivers/gpio/cs5535-gpio.c
@@ -15,6 +15,7 @@
 #include <linux/gpio.h>
 #include <linux/io.h>
 #include <linux/cs5535.h>
+#include <asm/msr.h>
 
 #define DRV_NAME "cs5535-gpio"
 #define GPIO_BAR 1
@@ -144,6 +145,57 @@ int cs5535_gpio_isset(unsigned offset, unsigned int reg)
 }
 EXPORT_SYMBOL_GPL(cs5535_gpio_isset);
 
+int cs5535_gpio_set_irq(unsigned group, unsigned irq)
+{
+        uint32_t lo, hi;
+
+        if (group > 7 || irq > 15)
+                return -EINVAL;
+
+        rdmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+
+        lo &= ~(0xF << (group * 4));
+        lo |= (irq & 0xF) << (group * 4);
+
+        wrmsr(MSR_PIC_ZSEL_HIGH, lo, hi);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(cs5535_gpio_set_irq);
+
+void cs5535_gpio_setup_event(unsigned offset, int pair, int pme)
+{
+        struct cs5535_gpio_chip *chip = &cs5535_gpio_chip;
+        uint32_t shift = (offset % 8) * 4;
+        unsigned long flags;
+        uint32_t val;
+
+        if (offset >= 24)
+                offset = GPIO_MAP_W;
+        else if (offset >= 16)
+                offset = GPIO_MAP_Z;
+        else if (offset >= 8)
+                offset = GPIO_MAP_Y;
+        else
+                offset = GPIO_MAP_X;
+
+        spin_lock_irqsave(&chip->lock, flags);
+        val = inl(chip->base + offset);
+
+        /* Clear whatever was there before */
+        val &= ~(0xF << shift);
+
+        /* Set the new value */
+        val |= ((pair & 7) << shift);
+
+        /* Set the PME bit if this is a PME event */
+        if (pme)
+                val |= (1 << (shift + 3));
+
+        outl(val, chip->base + offset);
+        spin_unlock_irqrestore(&chip->lock, flags);
+}
+EXPORT_SYMBOL_GPL(cs5535_gpio_setup_event);
+
 /*
  * Generic gpio_chip API support.
  */
diff --git a/drivers/gpio/langwell_gpio.c b/drivers/gpio/langwell_gpio.c
index 64db9dc3a27..d81cc748e77 100644
--- a/drivers/gpio/langwell_gpio.c
+++ b/drivers/gpio/langwell_gpio.c
@@ -134,10 +134,10 @@ static int lnw_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
         return lnw->irq_base + offset;
 }
 
-static int lnw_irq_type(unsigned irq, unsigned type)
+static int lnw_irq_type(struct irq_data *d, unsigned type)
 {
-        struct lnw_gpio *lnw = get_irq_chip_data(irq);
-        u32 gpio = irq - lnw->irq_base;
+        struct lnw_gpio *lnw = irq_data_get_irq_chip_data(d);
+        u32 gpio = d->irq - lnw->irq_base;
         unsigned long flags;
         u32 value;
         void __iomem *grer = gpio_reg(&lnw->chip, gpio, GRER);
@@ -162,19 +162,19 @@ static int lnw_irq_type(unsigned irq, unsigned type)
         return 0;
 }
 
-static void lnw_irq_unmask(unsigned irq)
+static void lnw_irq_unmask(struct irq_data *d)
 {
 }
 
-static void lnw_irq_mask(unsigned irq)
+static void lnw_irq_mask(struct irq_data *d)
 {
 }
 
 static struct irq_chip lnw_irqchip = {
         .name           = "LNW-GPIO",
-        .mask           = lnw_irq_mask,
-        .unmask         = lnw_irq_unmask,
-        .set_type       = lnw_irq_type,
+        .irq_mask       = lnw_irq_mask,
+        .irq_unmask     = lnw_irq_unmask,
+        .irq_set_type   = lnw_irq_type,
 };
 
 static DEFINE_PCI_DEVICE_TABLE(lnw_gpio_ids) = {   /* pin number */
diff --git a/drivers/gpio/max732x.c b/drivers/gpio/max732x.c
index 9cad60f9e96..9e1d01f0071 100644
--- a/drivers/gpio/max732x.c
+++ b/drivers/gpio/max732x.c
@@ -327,40 +327,40 @@ static int max732x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
         return chip->irq_base + off;
 }
 
-static void max732x_irq_mask(unsigned int irq)
+static void max732x_irq_mask(struct irq_data *d)
 {
-        struct max732x_chip *chip = get_irq_chip_data(irq);
+        struct max732x_chip *chip = irq_data_get_irq_chip_data(d);
 
-        chip->irq_mask_cur &= ~(1 << (irq - chip->irq_base));
+        chip->irq_mask_cur &= ~(1 << (d->irq - chip->irq_base));
 }
 
-static void max732x_irq_unmask(unsigned int irq)
+static void max732x_irq_unmask(struct irq_data *d)
 {
-        struct max732x_chip *chip = get_irq_chip_data(irq);
+        struct max732x_chip *chip = irq_data_get_irq_chip_data(d);
 
-        chip->irq_mask_cur |= 1 << (irq - chip->irq_base);
+        chip->irq_mask_cur |= 1 << (d->irq - chip->irq_base);
 }
 
-static void max732x_irq_bus_lock(unsigned int irq)
+static void max732x_irq_bus_lock(struct irq_data *d)
 {
-        struct max732x_chip *chip = get_irq_chip_data(irq);
+        struct max732x_chip *chip = irq_data_get_irq_chip_data(d);
 
         mutex_lock(&chip->irq_lock);
         chip->irq_mask_cur = chip->irq_mask;
 }
 
-static void max732x_irq_bus_sync_unlock(unsigned int irq)
+static void max732x_irq_bus_sync_unlock(struct irq_data *d)
 {
-        struct max732x_chip *chip = get_irq_chip_data(irq);
+        struct max732x_chip *chip = irq_data_get_irq_chip_data(d);
 
         max732x_irq_update_mask(chip);
         mutex_unlock(&chip->irq_lock);
 }
 
-static int max732x_irq_set_type(unsigned int irq, unsigned int type)
+static int max732x_irq_set_type(struct irq_data *d, unsigned int type)
 {
-        struct max732x_chip *chip = get_irq_chip_data(irq);
-        uint16_t off = irq - chip->irq_base;
+        struct max732x_chip *chip = irq_data_get_irq_chip_data(d);
+        uint16_t off = d->irq - chip->irq_base;
         uint16_t mask = 1 << off;
 
         if (!(mask & chip->dir_input)) {
@@ -371,7 +371,7 @@ static int max732x_irq_set_type(unsigned int irq, unsigned int type)
 
         if (!(type & IRQ_TYPE_EDGE_BOTH)) {
                 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
-                        irq, type);
+                        d->irq, type);
                 return -EINVAL;
         }
 
@@ -390,11 +390,11 @@ static int max732x_irq_set_type(unsigned int irq, unsigned int type)
 
 static struct irq_chip max732x_irq_chip = {
         .name                   = "max732x",
-        .mask                   = max732x_irq_mask,
-        .unmask                 = max732x_irq_unmask,
-        .bus_lock               = max732x_irq_bus_lock,
-        .bus_sync_unlock        = max732x_irq_bus_sync_unlock,
-        .set_type               = max732x_irq_set_type,
+        .irq_mask               = max732x_irq_mask,
+        .irq_unmask             = max732x_irq_unmask,
+        .irq_bus_lock           = max732x_irq_bus_lock,
+        .irq_bus_sync_unlock    = max732x_irq_bus_sync_unlock,
+        .irq_set_type           = max732x_irq_set_type,
 };
 
 static uint8_t max732x_irq_pending(struct max732x_chip *chip)
diff --git a/drivers/gpio/ml_ioh_gpio.c b/drivers/gpio/ml_ioh_gpio.c
new file mode 100644
index 00000000000..cead8e6ff34
--- /dev/null
+++ b/drivers/gpio/ml_ioh_gpio.c
@@ -0,0 +1,352 @@
+/*
+ * 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/kernel.h>
+#include <linux/pci.h>
+#include <linux/gpio.h>
+
+#define PCI_VENDOR_ID_ROHM             0x10DB
+
+struct ioh_reg_comn {
+        u32     ien;
+        u32     istatus;
+        u32     idisp;
+        u32     iclr;
+        u32     imask;
+        u32     imaskclr;
+        u32     po;
+        u32     pi;
+        u32     pm;
+        u32     im_0;
+        u32     im_1;
+        u32     reserved;
+};
+
+struct ioh_regs {
+        struct ioh_reg_comn regs[8];
+        u32 reserve1[16];
+        u32 ioh_sel_reg[4];
+        u32 reserve2[11];
+        u32 srst;
+};
+
+/**
+ * struct ioh_gpio_reg_data - The register store data.
+ * @po_reg:     To store contents of PO register.
+ * @pm_reg:     To store contents of PM register.
+ */
+struct ioh_gpio_reg_data {
+        u32 po_reg;
+        u32 pm_reg;
+};
+
+/**
+ * struct ioh_gpio - GPIO private data structure.
+ * @base:                       PCI base address of Memory mapped I/O register.
+ * @reg:                        Memory mapped IOH GPIO register list.
+ * @dev:                        Pointer to device structure.
+ * @gpio:                       Data for GPIO infrastructure.
+ * @ioh_gpio_reg:               Memory mapped Register data is saved here
+ *                              when suspend.
+ * @ch:                         Indicate GPIO channel
+ */
+struct ioh_gpio {
+        void __iomem *base;
+        struct ioh_regs __iomem *reg;
+        struct device *dev;
+        struct gpio_chip gpio;
+        struct ioh_gpio_reg_data ioh_gpio_reg;
+        struct mutex lock;
+        int ch;
+};
+
+static const int num_ports[] = {6, 12, 16, 16, 15, 16, 16, 12};
+
+static void ioh_gpio_set(struct gpio_chip *gpio, unsigned nr, int val)
+{
+        u32 reg_val;
+        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+
+        mutex_lock(&chip->lock);
+        reg_val = ioread32(&chip->reg->regs[chip->ch].po);
+        if (val)
+                reg_val |= (1 << nr);
+        else
+                reg_val &= ~(1 << nr);
+
+        iowrite32(reg_val, &chip->reg->regs[chip->ch].po);
+        mutex_unlock(&chip->lock);
+}
+
+static int ioh_gpio_get(struct gpio_chip *gpio, unsigned nr)
+{
+        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+
+        return ioread32(&chip->reg->regs[chip->ch].pi) & (1 << nr);
+}
+
+static int ioh_gpio_direction_output(struct gpio_chip *gpio, unsigned nr,
+                                     int val)
+{
+        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        u32 pm;
+        u32 reg_val;
+
+        mutex_lock(&chip->lock);
+        pm = ioread32(&chip->reg->regs[chip->ch].pm) &
+                                        ((1 << num_ports[chip->ch]) - 1);
+        pm |= (1 << nr);
+        iowrite32(pm, &chip->reg->regs[chip->ch].pm);
+
+        reg_val = ioread32(&chip->reg->regs[chip->ch].po);
+        if (val)
+                reg_val |= (1 << nr);
+        else
+                reg_val &= ~(1 << nr);
+
+        mutex_unlock(&chip->lock);
+
+        return 0;
+}
+
+static int ioh_gpio_direction_input(struct gpio_chip *gpio, unsigned nr)
+{
+        struct ioh_gpio *chip = container_of(gpio, struct ioh_gpio, gpio);
+        u32 pm;
+
+        mutex_lock(&chip->lock);
+        pm = ioread32(&chip->reg->regs[chip->ch].pm) &
+                                ((1 << num_ports[chip->ch]) - 1);
+        pm &= ~(1 << nr);
+        iowrite32(pm, &chip->reg->regs[chip->ch].pm);
+        mutex_unlock(&chip->lock);
+
+        return 0;
+}
+
+/*
+ * Save register configuration and disable interrupts.
+ */
+static void ioh_gpio_save_reg_conf(struct ioh_gpio *chip)
+{
+        chip->ioh_gpio_reg.po_reg = ioread32(&chip->reg->regs[chip->ch].po);
+        chip->ioh_gpio_reg.pm_reg = ioread32(&chip->reg->regs[chip->ch].pm);
+}
+
+/*
+ * This function restores the register configuration of the GPIO device.
+ */
+static void ioh_gpio_restore_reg_conf(struct ioh_gpio *chip)
+{
+        /* to store contents of PO register */
+        iowrite32(chip->ioh_gpio_reg.po_reg, &chip->reg->regs[chip->ch].po);
+        /* to store contents of PM register */
+        iowrite32(chip->ioh_gpio_reg.pm_reg, &chip->reg->regs[chip->ch].pm);
+}
+
+static void ioh_gpio_setup(struct ioh_gpio *chip, int num_port)
+{
+        struct gpio_chip *gpio = &chip->gpio;
+
+        gpio->label = dev_name(chip->dev);
+        gpio->owner = THIS_MODULE;
+        gpio->direction_input = ioh_gpio_direction_input;
+        gpio->get = ioh_gpio_get;
+        gpio->direction_output = ioh_gpio_direction_output;
+        gpio->set = ioh_gpio_set;
+        gpio->dbg_show = NULL;
+        gpio->base = -1;
+        gpio->ngpio = num_port;
+        gpio->can_sleep = 0;
+}
+
+static int __devinit ioh_gpio_probe(struct pci_dev *pdev,
+                                    const struct pci_device_id *id)
+{
+        int ret;
+        int i;
+        struct ioh_gpio *chip;
+        void __iomem *base;
+        void __iomem *chip_save;
+
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "%s : pci_enable_device failed", __func__);
+                goto err_pci_enable;
+        }
+
+        ret = pci_request_regions(pdev, KBUILD_MODNAME);
+        if (ret) {
+                dev_err(&pdev->dev, "pci_request_regions failed-%d", ret);
+                goto err_request_regions;
+        }
+
+        base = pci_iomap(pdev, 1, 0);
+        if (base == 0) {
+                dev_err(&pdev->dev, "%s : pci_iomap failed", __func__);
+                ret = -ENOMEM;
+                goto err_iomap;
+        }
+
+        chip_save = kzalloc(sizeof(*chip) * 8, GFP_KERNEL);
+        if (chip_save == NULL) {
+                dev_err(&pdev->dev, "%s : kzalloc failed", __func__);
+                ret = -ENOMEM;
+                goto err_kzalloc;
+        }
+
+        chip = chip_save;
+        for (i = 0; i < 8; i++, chip++) {
+                chip->dev = &pdev->dev;
+                chip->base = base;
+                chip->reg = chip->base;
+                chip->ch = i;
+                mutex_init(&chip->lock);
+                ioh_gpio_setup(chip, num_ports[i]);
+                ret = gpiochip_add(&chip->gpio);
+                if (ret) {
+                        dev_err(&pdev->dev, "IOH gpio: Failed to register GPIO\n");
+                        goto err_gpiochip_add;
+                }
+        }
+
+        chip = chip_save;
+        pci_set_drvdata(pdev, chip);
+
+        return 0;
+
+err_gpiochip_add:
+        for (; i != 0; i--) {
+                chip--;
+                ret = gpiochip_remove(&chip->gpio);
+                if (ret)
+                        dev_err(&pdev->dev, "Failed gpiochip_remove(%d)\n", i);
+        }
+        kfree(chip_save);
+
+err_kzalloc:
+        pci_iounmap(pdev, base);
+
+err_iomap:
+        pci_release_regions(pdev);
+
+err_request_regions:
+        pci_disable_device(pdev);
+
+err_pci_enable:
+
+        dev_err(&pdev->dev, "%s Failed returns %d\n", __func__, ret);
+        return ret;
+}
+
+static void __devexit ioh_gpio_remove(struct pci_dev *pdev)
+{
+        int err;
+        int i;
+        struct ioh_gpio *chip = pci_get_drvdata(pdev);
+        void __iomem *chip_save;
+
+        chip_save = chip;
+        for (i = 0; i < 8; i++, chip++) {
+                err = gpiochip_remove(&chip->gpio);
+                if (err)
+                        dev_err(&pdev->dev, "Failed gpiochip_remove\n");
+        }
+
+        chip = chip_save;
+        pci_iounmap(pdev, chip->base);
+        pci_release_regions(pdev);
+        pci_disable_device(pdev);
+        kfree(chip);
+}
+
+#ifdef CONFIG_PM
+static int ioh_gpio_suspend(struct pci_dev *pdev, pm_message_t state)
+{
+        s32 ret;
+        struct ioh_gpio *chip = pci_get_drvdata(pdev);
+
+        ioh_gpio_save_reg_conf(chip);
+        ioh_gpio_restore_reg_conf(chip);
+
+        ret = pci_save_state(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "pci_save_state Failed-%d\n", ret);
+                return ret;
+        }
+        pci_disable_device(pdev);
+        pci_set_power_state(pdev, PCI_D0);
+        ret = pci_enable_wake(pdev, PCI_D0, 1);
+        if (ret)
+                dev_err(&pdev->dev, "pci_enable_wake Failed -%d\n", ret);
+
+        return 0;
+}
+
+static int ioh_gpio_resume(struct pci_dev *pdev)
+{
+        s32 ret;
+        struct ioh_gpio *chip = pci_get_drvdata(pdev);
+
+        ret = pci_enable_wake(pdev, PCI_D0, 0);
+
+        pci_set_power_state(pdev, PCI_D0);
+        ret = pci_enable_device(pdev);
+        if (ret) {
+                dev_err(&pdev->dev, "pci_enable_device Failed-%d ", ret);
+                return ret;
+        }
+        pci_restore_state(pdev);
+
+        iowrite32(0x01, &chip->reg->srst);
+        iowrite32(0x00, &chip->reg->srst);
+        ioh_gpio_restore_reg_conf(chip);
+
+        return 0;
+}
+#else
+#define ioh_gpio_suspend NULL
+#define ioh_gpio_resume NULL
+#endif
+
+static DEFINE_PCI_DEVICE_TABLE(ioh_gpio_pcidev_id) = {
+        { PCI_DEVICE(PCI_VENDOR_ID_ROHM, 0x802E) },
+        { 0, }
+};
+
+static struct pci_driver ioh_gpio_driver = {
+        .name = "ml_ioh_gpio",
+        .id_table = ioh_gpio_pcidev_id,
+        .probe = ioh_gpio_probe,
+        .remove = __devexit_p(ioh_gpio_remove),
+        .suspend = ioh_gpio_suspend,
+        .resume = ioh_gpio_resume
+};
+
+static int __init ioh_gpio_pci_init(void)
+{
+        return pci_register_driver(&ioh_gpio_driver);
+}
+module_init(ioh_gpio_pci_init);
+
+static void __exit ioh_gpio_pci_exit(void)
+{
+        pci_unregister_driver(&ioh_gpio_driver);
+}
+module_exit(ioh_gpio_pci_exit);
+
+MODULE_DESCRIPTION("OKI SEMICONDUCTOR ML-IOH series GPIO Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/gpio/pca953x.c b/drivers/gpio/pca953x.c
index 501866662e0..a261972f603 100644
--- a/drivers/gpio/pca953x.c
+++ b/drivers/gpio/pca953x.c
@@ -228,30 +228,30 @@ static int pca953x_gpio_to_irq(struct gpio_chip *gc, unsigned off)
         return chip->irq_base + off;
 }
 
-static void pca953x_irq_mask(unsigned int irq)
+static void pca953x_irq_mask(struct irq_data *d)
 {
-        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 
-        chip->irq_mask &= ~(1 << (irq - chip->irq_base));
+        chip->irq_mask &= ~(1 << (d->irq - chip->irq_base));
 }
 
-static void pca953x_irq_unmask(unsigned int irq)
+static void pca953x_irq_unmask(struct irq_data *d)
 {
-        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 
-        chip->irq_mask |= 1 << (irq - chip->irq_base);
+        chip->irq_mask |= 1 << (d->irq - chip->irq_base);
 }
 
-static void pca953x_irq_bus_lock(unsigned int irq)
+static void pca953x_irq_bus_lock(struct irq_data *d)
 {
-        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
 
         mutex_lock(&chip->irq_lock);
 }
 
-static void pca953x_irq_bus_sync_unlock(unsigned int irq)
+static void pca953x_irq_bus_sync_unlock(struct irq_data *d)
 {
-        struct pca953x_chip *chip = get_irq_chip_data(irq);
+        struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
         uint16_t new_irqs;
         uint16_t level;
 
@@ -268,15 +268,15 @@ static void pca953x_irq_bus_sync_unlock(unsigned int irq)
         mutex_unlock(&chip->irq_lock);
 }
 
-static int pca953x_irq_set_type(unsigned int irq, unsigned int type)
+static int pca953x_irq_set_type(struct irq_data *d, unsigned int type)
 {
-        struct pca953x_chip *chip = get_irq_chip_data(irq);
-        uint16_t level = irq - chip->irq_base;
+        struct pca953x_chip *chip = irq_data_get_irq_chip_data(d);
+        uint16_t level = d->irq - chip->irq_base;
         uint16_t mask = 1 << level;
 
         if (!(type & IRQ_TYPE_EDGE_BOTH)) {
                 dev_err(&chip->client->dev, "irq %d: unsupported type %d\n",
-                        irq, type);
+                        d->irq, type);
                 return -EINVAL;
         }
 
@@ -295,11 +295,11 @@ static int pca953x_irq_set_type(unsigned int irq, unsigned int type)
 
 static struct irq_chip pca953x_irq_chip = {
         .name                   = "pca953x",
-        .mask                   = pca953x_irq_mask,
-        .unmask                 = pca953x_irq_unmask,
-        .bus_lock               = pca953x_irq_bus_lock,
-        .bus_sync_unlock        = pca953x_irq_bus_sync_unlock,
-        .set_type               = pca953x_irq_set_type,
+        .irq_mask               = pca953x_irq_mask,
+        .irq_unmask             = pca953x_irq_unmask,
+        .irq_bus_lock           = pca953x_irq_bus_lock,
+        .irq_bus_sync_unlock    = pca953x_irq_bus_sync_unlock,
+        .irq_set_type           = pca953x_irq_set_type,
 };
 
 static uint16_t pca953x_irq_pending(struct pca953x_chip *chip)
diff --git a/drivers/gpio/pl061.c b/drivers/gpio/pl061.c
index 5005990f751..2975d22daff 100644
--- a/drivers/gpio/pl061.c
+++ b/drivers/gpio/pl061.c
@@ -129,10 +129,10 @@ static int pl061_to_irq(struct gpio_chip *gc, unsigned offset)
 /*
  * PL061 GPIO IRQ
  */
-static void pl061_irq_disable(unsigned irq)
+static void pl061_irq_disable(struct irq_data *d)
 {
-        struct pl061_gpio *chip = get_irq_chip_data(irq);
-        int offset = irq - chip->irq_base;
+        struct pl061_gpio *chip = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - chip->irq_base;
         unsigned long flags;
         u8 gpioie;
 
@@ -143,10 +143,10 @@ static void pl061_irq_disable(unsigned irq)
         spin_unlock_irqrestore(&chip->irq_lock, flags);
 }
 
-static void pl061_irq_enable(unsigned irq)
+static void pl061_irq_enable(struct irq_data *d)
 {
-        struct pl061_gpio *chip = get_irq_chip_data(irq);
-        int offset = irq - chip->irq_base;
+        struct pl061_gpio *chip = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - chip->irq_base;
         unsigned long flags;
         u8 gpioie;
 
@@ -157,10 +157,10 @@ static void pl061_irq_enable(unsigned irq)
         spin_unlock_irqrestore(&chip->irq_lock, flags);
 }
 
-static int pl061_irq_type(unsigned irq, unsigned trigger)
+static int pl061_irq_type(struct irq_data *d, unsigned trigger)
 {
-        struct pl061_gpio *chip = get_irq_chip_data(irq);
-        int offset = irq - chip->irq_base;
+        struct pl061_gpio *chip = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - chip->irq_base;
         unsigned long flags;
         u8 gpiois, gpioibe, gpioiev;
 
@@ -203,9 +203,9 @@ static int pl061_irq_type(unsigned irq, unsigned trigger)
 
 static struct irq_chip pl061_irqchip = {
         .name           = "GPIO",
-        .enable         = pl061_irq_enable,
-        .disable        = pl061_irq_disable,
-        .set_type       = pl061_irq_type,
+        .irq_enable     = pl061_irq_enable,
+        .irq_disable    = pl061_irq_disable,
+        .irq_set_type   = pl061_irq_type,
 };
 
 static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
@@ -214,7 +214,7 @@ static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
         struct list_head *ptr;
         struct pl061_gpio *chip;
 
-        desc->chip->ack(irq);
+        desc->irq_data.chip->irq_ack(&desc->irq_data);
         list_for_each(ptr, chip_list) {
                 unsigned long pending;
                 int offset;
@@ -229,7 +229,7 @@ static void pl061_irq_handler(unsigned irq, struct irq_desc *desc)
                 for_each_set_bit(offset, &pending, PL061_GPIO_NR)
                         generic_handle_irq(pl061_to_irq(&chip->gc, offset));
         }
-        desc->chip->unmask(irq);
+        desc->irq_data.chip->irq_unmask(&desc->irq_data);
 }
 
 static int pl061_probe(struct amba_device *dev, struct amba_id *id)
diff --git a/drivers/gpio/stmpe-gpio.c b/drivers/gpio/stmpe-gpio.c
index 7c9e6a052c4..eb2901f8ab5 100644
--- a/drivers/gpio/stmpe-gpio.c
+++ b/drivers/gpio/stmpe-gpio.c
@@ -122,10 +122,10 @@ static struct gpio_chip template_chip = {
         .can_sleep              = 1,
 };
 
-static int stmpe_gpio_irq_set_type(unsigned int irq, unsigned int type)
+static int stmpe_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
-        struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);
-        int offset = irq - stmpe_gpio->irq_base;
+        struct stmpe_gpio *stmpe_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - stmpe_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
@@ -145,16 +145,16 @@ static int stmpe_gpio_irq_set_type(unsigned int irq, unsigned int type)
         return 0;
 }
 
-static void stmpe_gpio_irq_lock(unsigned int irq)
+static void stmpe_gpio_irq_lock(struct irq_data *d)
 {
-        struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);
+        struct stmpe_gpio *stmpe_gpio = irq_data_get_irq_chip_data(d);
 
         mutex_lock(&stmpe_gpio->irq_lock);
 }
 
-static void stmpe_gpio_irq_sync_unlock(unsigned int irq)
+static void stmpe_gpio_irq_sync_unlock(struct irq_data *d)
 {
-        struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);
+        struct stmpe_gpio *stmpe_gpio = irq_data_get_irq_chip_data(d);
         struct stmpe *stmpe = stmpe_gpio->stmpe;
         int num_banks = DIV_ROUND_UP(stmpe->num_gpios, 8);
         static const u8 regmap[] = {
@@ -180,20 +180,20 @@ static void stmpe_gpio_irq_sync_unlock(unsigned int irq)
         mutex_unlock(&stmpe_gpio->irq_lock);
 }
 
-static void stmpe_gpio_irq_mask(unsigned int irq)
+static void stmpe_gpio_irq_mask(struct irq_data *d)
 {
-        struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);
-        int offset = irq - stmpe_gpio->irq_base;
+        struct stmpe_gpio *stmpe_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - stmpe_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
         stmpe_gpio->regs[REG_IE][regoffset] &= ~mask;
 }
 
-static void stmpe_gpio_irq_unmask(unsigned int irq)
+static void stmpe_gpio_irq_unmask(struct irq_data *d)
 {
-        struct stmpe_gpio *stmpe_gpio = get_irq_chip_data(irq);
-        int offset = irq - stmpe_gpio->irq_base;
+        struct stmpe_gpio *stmpe_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - stmpe_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
@@ -202,11 +202,11 @@ static void stmpe_gpio_irq_unmask(unsigned int irq)
 
 static struct irq_chip stmpe_gpio_irq_chip = {
         .name                   = "stmpe-gpio",
-        .bus_lock               = stmpe_gpio_irq_lock,
-        .bus_sync_unlock        = stmpe_gpio_irq_sync_unlock,
-        .mask                   = stmpe_gpio_irq_mask,
-        .unmask                 = stmpe_gpio_irq_unmask,
-        .set_type               = stmpe_gpio_irq_set_type,
+        .irq_bus_lock           = stmpe_gpio_irq_lock,
+        .irq_bus_sync_unlock    = stmpe_gpio_irq_sync_unlock,
+        .irq_mask               = stmpe_gpio_irq_mask,
+        .irq_unmask             = stmpe_gpio_irq_unmask,
+        .irq_set_type           = stmpe_gpio_irq_set_type,
 };
 
 static irqreturn_t stmpe_gpio_irq(int irq, void *dev)
diff --git a/drivers/gpio/sx150x.c b/drivers/gpio/sx150x.c
index 823559ab0e2..e60be0015c9 100644
--- a/drivers/gpio/sx150x.c
+++ b/drivers/gpio/sx150x.c
@@ -304,36 +304,36 @@ static int sx150x_gpio_to_irq(struct gpio_chip *gc, unsigned offset)
         return chip->irq_base + offset;
 }
 
-static void sx150x_irq_mask(unsigned int irq)
+static void sx150x_irq_mask(struct irq_data *d)
 {
-        struct irq_chip *ic = get_irq_chip(irq);
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
         struct sx150x_chip *chip;
         unsigned n;
 
         chip = container_of(ic, struct sx150x_chip, irq_chip);
-        n = irq - chip->irq_base;
+        n = d->irq - chip->irq_base;
 
         sx150x_write_cfg(chip, n, 1, chip->dev_cfg->reg_irq_mask, 1);
         sx150x_write_cfg(chip, n, 2, chip->dev_cfg->reg_sense, 0);
 }
 
-static void sx150x_irq_unmask(unsigned int irq)
+static void sx150x_irq_unmask(struct irq_data *d)
 {
-        struct irq_chip *ic = get_irq_chip(irq);
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
         struct sx150x_chip *chip;
         unsigned n;
 
         chip = container_of(ic, struct sx150x_chip, irq_chip);
-        n = irq - chip->irq_base;
+        n = d->irq - chip->irq_base;
 
         sx150x_write_cfg(chip, n, 1, chip->dev_cfg->reg_irq_mask, 0);
         sx150x_write_cfg(chip, n, 2, chip->dev_cfg->reg_sense,
                          chip->irq_sense >> (n * 2));
 }
 
-static int sx150x_irq_set_type(unsigned int irq, unsigned int flow_type)
+static int sx150x_irq_set_type(struct irq_data *d, unsigned int flow_type)
 {
-        struct irq_chip *ic = get_irq_chip(irq);
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
         struct sx150x_chip *chip;
         unsigned n, val = 0;
 
@@ -341,7 +341,7 @@ static int sx150x_irq_set_type(unsigned int irq, unsigned int flow_type)
                 return -EINVAL;
 
         chip = container_of(ic, struct sx150x_chip, irq_chip);
-        n = irq - chip->irq_base;
+        n = d->irq - chip->irq_base;
 
         if (flow_type & IRQ_TYPE_EDGE_RISING)
                 val |= 0x1;
@@ -386,9 +386,9 @@ static irqreturn_t sx150x_irq_thread_fn(int irq, void *dev_id)
         return (nhandled > 0 ? IRQ_HANDLED : IRQ_NONE);
 }
 
-static void sx150x_irq_bus_lock(unsigned int irq)
+static void sx150x_irq_bus_lock(struct irq_data *d)
 {
-        struct irq_chip *ic = get_irq_chip(irq);
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
         struct sx150x_chip *chip;
 
         chip = container_of(ic, struct sx150x_chip, irq_chip);
@@ -396,9 +396,9 @@ static void sx150x_irq_bus_lock(unsigned int irq)
         mutex_lock(&chip->lock);
 }
 
-static void sx150x_irq_bus_sync_unlock(unsigned int irq)
+static void sx150x_irq_bus_sync_unlock(struct irq_data *d)
 {
-        struct irq_chip *ic = get_irq_chip(irq);
+        struct irq_chip *ic = irq_data_get_irq_chip(d);
         struct sx150x_chip *chip;
         unsigned n;
 
@@ -437,16 +437,16 @@ static void sx150x_init_chip(struct sx150x_chip *chip,
         if (pdata->oscio_is_gpo)
                 ++chip->gpio_chip.ngpio;
 
-        chip->irq_chip.name            = client->name;
-        chip->irq_chip.mask            = sx150x_irq_mask;
-        chip->irq_chip.unmask          = sx150x_irq_unmask;
-        chip->irq_chip.set_type        = sx150x_irq_set_type;
-        chip->irq_chip.bus_lock        = sx150x_irq_bus_lock;
-        chip->irq_chip.bus_sync_unlock = sx150x_irq_bus_sync_unlock;
-        chip->irq_summary              = -1;
-        chip->irq_base                 = -1;
-        chip->irq_sense                = 0;
-        chip->irq_set_type_pending     = 0;
+        chip->irq_chip.name                = client->name;
+        chip->irq_chip.irq_mask            = sx150x_irq_mask;
+        chip->irq_chip.irq_unmask          = sx150x_irq_unmask;
+        chip->irq_chip.irq_set_type        = sx150x_irq_set_type;
+        chip->irq_chip.irq_bus_lock        = sx150x_irq_bus_lock;
+        chip->irq_chip.irq_bus_sync_unlock = sx150x_irq_bus_sync_unlock;
+        chip->irq_summary                  = -1;
+        chip->irq_base                     = -1;
+        chip->irq_sense                    = 0;
+        chip->irq_set_type_pending         = 0;
 }
 
 static int sx150x_init_io(struct sx150x_chip *chip, u8 base, u16 cfg)
diff --git a/drivers/gpio/tc3589x-gpio.c b/drivers/gpio/tc3589x-gpio.c
index 180d584454f..27200af1a59 100644
--- a/drivers/gpio/tc3589x-gpio.c
+++ b/drivers/gpio/tc3589x-gpio.c
@@ -110,10 +110,10 @@ static struct gpio_chip template_chip = {
         .can_sleep              = 1,
 };
 
-static int tc3589x_gpio_irq_set_type(unsigned int irq, unsigned int type)
+static int tc3589x_gpio_irq_set_type(struct irq_data *d, unsigned int type)
 {
-        struct tc3589x_gpio *tc3589x_gpio = get_irq_chip_data(irq);
-        int offset = irq - tc3589x_gpio->irq_base;
+        struct tc3589x_gpio *tc3589x_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tc3589x_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
@@ -137,16 +137,16 @@ static int tc3589x_gpio_irq_set_type(unsigned int irq, unsigned int type)
         return 0;
 }
 
-static void tc3589x_gpio_irq_lock(unsigned int irq)
+static void tc3589x_gpio_irq_lock(struct irq_data *d)
 {
-        struct tc3589x_gpio *tc3589x_gpio = get_irq_chip_data(irq);
+        struct tc3589x_gpio *tc3589x_gpio = irq_data_get_irq_chip_data(d);
 
         mutex_lock(&tc3589x_gpio->irq_lock);
 }
 
-static void tc3589x_gpio_irq_sync_unlock(unsigned int irq)
+static void tc3589x_gpio_irq_sync_unlock(struct irq_data *d)
 {
-        struct tc3589x_gpio *tc3589x_gpio = get_irq_chip_data(irq);
+        struct tc3589x_gpio *tc3589x_gpio = irq_data_get_irq_chip_data(d);
         struct tc3589x *tc3589x = tc3589x_gpio->tc3589x;
         static const u8 regmap[] = {
                 [REG_IBE]       = TC3589x_GPIOIBE0,
@@ -172,20 +172,20 @@ static void tc3589x_gpio_irq_sync_unlock(unsigned int irq)
         mutex_unlock(&tc3589x_gpio->irq_lock);
 }
 
-static void tc3589x_gpio_irq_mask(unsigned int irq)
+static void tc3589x_gpio_irq_mask(struct irq_data *d)
 {
-        struct tc3589x_gpio *tc3589x_gpio = get_irq_chip_data(irq);
-        int offset = irq - tc3589x_gpio->irq_base;
+        struct tc3589x_gpio *tc3589x_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tc3589x_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
         tc3589x_gpio->regs[REG_IE][regoffset] &= ~mask;
 }
 
-static void tc3589x_gpio_irq_unmask(unsigned int irq)
+static void tc3589x_gpio_irq_unmask(struct irq_data *d)
 {
-        struct tc3589x_gpio *tc3589x_gpio = get_irq_chip_data(irq);
-        int offset = irq - tc3589x_gpio->irq_base;
+        struct tc3589x_gpio *tc3589x_gpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tc3589x_gpio->irq_base;
         int regoffset = offset / 8;
         int mask = 1 << (offset % 8);
 
@@ -194,11 +194,11 @@ static void tc3589x_gpio_irq_unmask(unsigned int irq)
 
 static struct irq_chip tc3589x_gpio_irq_chip = {
         .name                   = "tc3589x-gpio",
-        .bus_lock               = tc3589x_gpio_irq_lock,
-        .bus_sync_unlock        = tc3589x_gpio_irq_sync_unlock,
-        .mask                   = tc3589x_gpio_irq_mask,
-        .unmask                 = tc3589x_gpio_irq_unmask,
-        .set_type               = tc3589x_gpio_irq_set_type,
+        .irq_bus_lock           = tc3589x_gpio_irq_lock,
+        .irq_bus_sync_unlock    = tc3589x_gpio_irq_sync_unlock,
+        .irq_mask               = tc3589x_gpio_irq_mask,
+        .irq_unmask             = tc3589x_gpio_irq_unmask,
+        .irq_set_type           = tc3589x_gpio_irq_set_type,
 };
 
 static irqreturn_t tc3589x_gpio_irq(int irq, void *dev)
diff --git a/drivers/gpio/timbgpio.c b/drivers/gpio/timbgpio.c
index 45293662e95..349131eb1ce 100644
--- a/drivers/gpio/timbgpio.c
+++ b/drivers/gpio/timbgpio.c
@@ -109,10 +109,10 @@ static int timbgpio_to_irq(struct gpio_chip *gpio, unsigned offset)
 /*
  * GPIO IRQ
  */
-static void timbgpio_irq_disable(unsigned irq)
+static void timbgpio_irq_disable(struct irq_data *d)
 {
-        struct timbgpio *tgpio = get_irq_chip_data(irq);
-        int offset = irq - tgpio->irq_base;
+        struct timbgpio *tgpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tgpio->irq_base;
         unsigned long flags;
 
         spin_lock_irqsave(&tgpio->lock, flags);
@@ -121,10 +121,10 @@ static void timbgpio_irq_disable(unsigned irq)
         spin_unlock_irqrestore(&tgpio->lock, flags);
 }
 
-static void timbgpio_irq_enable(unsigned irq)
+static void timbgpio_irq_enable(struct irq_data *d)
 {
-        struct timbgpio *tgpio = get_irq_chip_data(irq);
-        int offset = irq - tgpio->irq_base;
+        struct timbgpio *tgpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tgpio->irq_base;
         unsigned long flags;
 
         spin_lock_irqsave(&tgpio->lock, flags);
@@ -133,10 +133,10 @@ static void timbgpio_irq_enable(unsigned irq)
         spin_unlock_irqrestore(&tgpio->lock, flags);
 }
 
-static int timbgpio_irq_type(unsigned irq, unsigned trigger)
+static int timbgpio_irq_type(struct irq_data *d, unsigned trigger)
 {
-        struct timbgpio *tgpio = get_irq_chip_data(irq);
-        int offset = irq - tgpio->irq_base;
+        struct timbgpio *tgpio = irq_data_get_irq_chip_data(d);
+        int offset = d->irq - tgpio->irq_base;
         unsigned long flags;
         u32 lvr, flr, bflr = 0;
         u32 ver;
@@ -193,13 +193,13 @@ out:
         return ret;
 }
 
-static void timbgpio_irq(unsigned int irq, struct irq_desc *desc)
+static void timbgpio_irq(struct irq_data *d, struct irq_desc *desc)
 {
-        struct timbgpio *tgpio = get_irq_data(irq);
+        struct timbgpio *tgpio = irq_data_get_irq_data(d);
         unsigned long ipr;
         int offset;
 
-        desc->chip->ack(irq);
+        desc->irq_data.chip->ack(irq_get_irq_data(d));
         ipr = ioread32(tgpio->membase + TGPIO_IPR);
         iowrite32(ipr, tgpio->membase + TGPIO_ICR);
 
@@ -217,9 +217,9 @@ static void timbgpio_irq(unsigned int irq, struct irq_desc *desc)
 
 static struct irq_chip timbgpio_irqchip = {
         .name           = "GPIO",
-        .enable         = timbgpio_irq_enable,
-        .disable        = timbgpio_irq_disable,
-        .set_type       = timbgpio_irq_type,
+        .irq_enable     = timbgpio_irq_enable,
+        .irq_disable    = timbgpio_irq_disable,
+        .irq_set_type   = timbgpio_irq_type,
 };
 
 static int __devinit timbgpio_probe(struct platform_device *pdev)
diff --git a/drivers/gpio/vr41xx_giu.c b/drivers/gpio/vr41xx_giu.c
index b16c9a8c03f..cffa3bd7ad3 100644
--- a/drivers/gpio/vr41xx_giu.c
+++ b/drivers/gpio/vr41xx_giu.c
@@ -111,69 +111,69 @@ static inline u16 giu_clear(u16 offset, u16 clear)
         return data;
 }
 
-static void ack_giuint_low(unsigned int irq)
+static void ack_giuint_low(struct irq_data *d)
 {
-        giu_write(GIUINTSTATL, 1 << GPIO_PIN_OF_IRQ(irq));
+        giu_write(GIUINTSTATL, 1 << GPIO_PIN_OF_IRQ(d->irq));
 }
 
-static void mask_giuint_low(unsigned int irq)
+static void mask_giuint_low(struct irq_data *d)
 {
-        giu_clear(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
+        giu_clear(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(d->irq));
 }
 
-static void mask_ack_giuint_low(unsigned int irq)
+static void mask_ack_giuint_low(struct irq_data *d)
 {
         unsigned int pin;
 
-        pin = GPIO_PIN_OF_IRQ(irq);
+        pin = GPIO_PIN_OF_IRQ(d->irq);
         giu_clear(GIUINTENL, 1 << pin);
         giu_write(GIUINTSTATL, 1 << pin);
 }
 
-static void unmask_giuint_low(unsigned int irq)
+static void unmask_giuint_low(struct irq_data *d)
 {
-        giu_set(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(irq));
+        giu_set(GIUINTENL, 1 << GPIO_PIN_OF_IRQ(d->irq));
 }
 
 static struct irq_chip giuint_low_irq_chip = {
         .name           = "GIUINTL",
-        .ack            = ack_giuint_low,
-        .mask           = mask_giuint_low,
-        .mask_ack       = mask_ack_giuint_low,
-        .unmask         = unmask_giuint_low,
+        .irq_ack        = ack_giuint_low,
+        .irq_mask       = mask_giuint_low,
+        .irq_mask_ack   = mask_ack_giuint_low,
+        .irq_unmask     = unmask_giuint_low,
 };
 
-static void ack_giuint_high(unsigned int irq)
+static void ack_giuint_high(struct irq_data *d)
 {
         giu_write(GIUINTSTATH,
-                  1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+                  1 << (GPIO_PIN_OF_IRQ(d->irq) - GIUINT_HIGH_OFFSET));
 }
 
-static void mask_giuint_high(unsigned int irq)
+static void mask_giuint_high(struct irq_data *d)
 {
-        giu_clear(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+        giu_clear(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(d->irq) - GIUINT_HIGH_OFFSET));
 }
 
-static void mask_ack_giuint_high(unsigned int irq)
+static void mask_ack_giuint_high(struct irq_data *d)
 {
         unsigned int pin;
 
-        pin = GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET;
+        pin = GPIO_PIN_OF_IRQ(d->irq) - GIUINT_HIGH_OFFSET;
         giu_clear(GIUINTENH, 1 << pin);
         giu_write(GIUINTSTATH, 1 << pin);
 }
 
-static void unmask_giuint_high(unsigned int irq)
+static void unmask_giuint_high(struct irq_data *d)
 {
-        giu_set(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(irq) - GIUINT_HIGH_OFFSET));
+        giu_set(GIUINTENH, 1 << (GPIO_PIN_OF_IRQ(d->irq) - GIUINT_HIGH_OFFSET));
 }
 
 static struct irq_chip giuint_high_irq_chip = {
         .name           = "GIUINTH",
-        .ack            = ack_giuint_high,
-        .mask           = mask_giuint_high,
-        .mask_ack       = mask_ack_giuint_high,
-        .unmask         = unmask_giuint_high,
+        .irq_ack        = ack_giuint_high,
+        .irq_mask       = mask_giuint_high,
+        .irq_mask_ack   = mask_ack_giuint_high,
+        .irq_unmask     = unmask_giuint_high,
 };
 
 static int giu_get_irq(unsigned int irq)
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 92f75782c33..19a3d58044d 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -106,10 +106,19 @@ static const char *get_tiling_flag(struct drm_i915_gem_object *obj)
     }
 }
 
+static const char *agp_type_str(int type)
+{
+        switch (type) {
+        case 0: return " uncached";
+        case 1: return " snooped";
+        default: return "";
+        }
+}
+
 static void
 describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
 {
-        seq_printf(m, "%p: %s%s %8zd %04x %04x %d %d%s%s",
+        seq_printf(m, "%p: %s%s %8zd %04x %04x %d %d%s%s%s",
                    &obj->base,
                    get_pin_flag(obj),
                    get_tiling_flag(obj),
@@ -118,6 +127,7 @@ describe_obj(struct seq_file *m, struct drm_i915_gem_object *obj)
                    obj->base.write_domain,
                    obj->last_rendering_seqno,
                    obj->last_fenced_seqno,
+                   agp_type_str(obj->agp_type == AGP_USER_CACHED_MEMORY),
                    obj->dirty ? " dirty" : "",
                    obj->madv == I915_MADV_DONTNEED ? " purgeable" : "");
         if (obj->base.name)
@@ -276,6 +286,37 @@ static int i915_gem_object_info(struct seq_file *m, void* data)
         return 0;
 }
 
+static int i915_gem_gtt_info(struct seq_file *m, void* data)
+{
+        struct drm_info_node *node = (struct drm_info_node *) m->private;
+        struct drm_device *dev = node->minor->dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        struct drm_i915_gem_object *obj;
+        size_t total_obj_size, total_gtt_size;
+        int count, ret;
+
+        ret = mutex_lock_interruptible(&dev->struct_mutex);
+        if (ret)
+                return ret;
+
+        total_obj_size = total_gtt_size = count = 0;
+        list_for_each_entry(obj, &dev_priv->mm.gtt_list, gtt_list) {
+                seq_printf(m, "   ");
+                describe_obj(m, obj);
+                seq_printf(m, "\n");
+                total_obj_size += obj->base.size;
+                total_gtt_size += obj->gtt_space->size;
+                count++;
+        }
+
+        mutex_unlock(&dev->struct_mutex);
+
+        seq_printf(m, "Total %d objects, %zu bytes, %zu GTT size\n",
+                   count, total_obj_size, total_gtt_size);
+
+        return 0;
+}
+
 
 static int i915_gem_pageflip_info(struct seq_file *m, void *data)
 {
@@ -456,8 +497,14 @@ static int i915_interrupt_info(struct seq_file *m, void *data)
         }
         seq_printf(m, "Interrupts received: %d\n",
                    atomic_read(&dev_priv->irq_received));
-        for (i = 0; i < I915_NUM_RINGS; i++)
+        for (i = 0; i < I915_NUM_RINGS; i++) {
+                if (IS_GEN6(dev)) {
+                        seq_printf(m, "Graphics Interrupt mask (%s):    %08x\n",
+                                   dev_priv->ring[i].name,
+                                   I915_READ_IMR(&dev_priv->ring[i]));
+                }
                 i915_ring_seqno_info(m, &dev_priv->ring[i]);
+        }
         mutex_unlock(&dev->struct_mutex);
 
         return 0;
@@ -656,7 +703,7 @@ static void print_error_buffers(struct seq_file *m,
         seq_printf(m, "%s [%d]:\n", name, count);
 
         while (count--) {
-                seq_printf(m, "  %08x %8zd %04x %04x %08x%s%s%s%s%s",
+                seq_printf(m, "  %08x %8zd %04x %04x %08x%s%s%s%s%s%s",
                            err->gtt_offset,
                            err->size,
                            err->read_domains,
@@ -666,7 +713,8 @@ static void print_error_buffers(struct seq_file *m,
                            tiling_flag(err->tiling),
                            dirty_flag(err->dirty),
                            purgeable_flag(err->purgeable),
-                           ring_str(err->ring));
+                           ring_str(err->ring),
+                           agp_type_str(err->agp_type));
 
                 if (err->name)
                         seq_printf(m, " (name: %d)", err->name);
@@ -744,7 +792,9 @@ static int i915_error_state(struct seq_file *m, void *unused)
                 if (error->batchbuffer[i]) {
                         struct drm_i915_error_object *obj = error->batchbuffer[i];
 
-                        seq_printf(m, "--- gtt_offset = 0x%08x\n", obj->gtt_offset);
+                        seq_printf(m, "%s --- gtt_offset = 0x%08x\n",
+                                   dev_priv->ring[i].name,
+                                   obj->gtt_offset);
                         offset = 0;
                         for (page = 0; page < obj->page_count; page++) {
                                 for (elt = 0; elt < PAGE_SIZE/4; elt++) {
@@ -890,7 +940,7 @@ static int i915_drpc_info(struct seq_file *m, void *unused)
         struct drm_device *dev = node->minor->dev;
         drm_i915_private_t *dev_priv = dev->dev_private;
         u32 rgvmodectl = I915_READ(MEMMODECTL);
-        u32 rstdbyctl = I915_READ(MCHBAR_RENDER_STANDBY);
+        u32 rstdbyctl = I915_READ(RSTDBYCTL);
         u16 crstandvid = I915_READ16(CRSTANDVID);
 
         seq_printf(m, "HD boost: %s\n", (rgvmodectl & MEMMODE_BOOST_EN) ?
@@ -913,6 +963,30 @@ static int i915_drpc_info(struct seq_file *m, void *unused)
         seq_printf(m, "RS2 VID: %d\n", ((crstandvid >> 8) & 0x3f));
         seq_printf(m, "Render standby enabled: %s\n",
                    (rstdbyctl & RCX_SW_EXIT) ? "no" : "yes");
+        seq_printf(m, "Current RS state: ");
+        switch (rstdbyctl & RSX_STATUS_MASK) {
+        case RSX_STATUS_ON:
+                seq_printf(m, "on\n");
+                break;
+        case RSX_STATUS_RC1:
+                seq_printf(m, "RC1\n");
+                break;
+        case RSX_STATUS_RC1E:
+                seq_printf(m, "RC1E\n");
+                break;
+        case RSX_STATUS_RS1:
+                seq_printf(m, "RS1\n");
+                break;
+        case RSX_STATUS_RS2:
+                seq_printf(m, "RS2 (RC6)\n");
+                break;
+        case RSX_STATUS_RS3:
+                seq_printf(m, "RC3 (RC6+)\n");
+                break;
+        default:
+                seq_printf(m, "unknown\n");
+                break;
+        }
 
         return 0;
 }
@@ -1187,6 +1261,7 @@ static int i915_wedged_create(struct dentry *root, struct drm_minor *minor)
 static struct drm_info_list i915_debugfs_list[] = {
         {"i915_capabilities", i915_capabilities, 0, 0},
         {"i915_gem_objects", i915_gem_object_info, 0},
+        {"i915_gem_gtt", i915_gem_gtt_info, 0},
         {"i915_gem_active", i915_gem_object_list_info, 0, (void *) ACTIVE_LIST},
         {"i915_gem_flushing", i915_gem_object_list_info, 0, (void *) FLUSHING_LIST},
         {"i915_gem_inactive", i915_gem_object_list_info, 0, (void *) INACTIVE_LIST},
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index 0568dbdc10e..844f3c972b0 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -1962,13 +1962,6 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
         /* enable GEM by default */
         dev_priv->has_gem = 1;
 
-        if (dev_priv->has_gem == 0 &&
-            drm_core_check_feature(dev, DRIVER_MODESET)) {
-                DRM_ERROR("kernel modesetting requires GEM, disabling driver.\n");
-                ret = -ENODEV;
-                goto out_workqueue_free;
-        }
-
         dev->driver->get_vblank_counter = i915_get_vblank_counter;
         dev->max_vblank_count = 0xffffff; /* only 24 bits of frame count */
         if (IS_G4X(dev) || IS_GEN5(dev) || IS_GEN6(dev)) {
@@ -2055,7 +2048,6 @@ out_gem_unload:
 
         intel_teardown_gmbus(dev);
         intel_teardown_mchbar(dev);
-out_workqueue_free:
         destroy_workqueue(dev_priv->wq);
 out_iomapfree:
         io_mapping_free(dev_priv->mm.gtt_mapping);
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 87249333198..0de75a23f8e 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -49,6 +49,9 @@ module_param_named(powersave, i915_powersave, int, 0600);
 unsigned int i915_lvds_downclock = 0;
 module_param_named(lvds_downclock, i915_lvds_downclock, int, 0400);
 
+bool i915_try_reset = true;
+module_param_named(reset, i915_try_reset, bool, 0600);
+
 static struct drm_driver driver;
 extern int intel_agp_enabled;
 
@@ -352,6 +355,9 @@ static int i915_drm_thaw(struct drm_device *dev)
 
                 /* Resume the modeset for every activated CRTC */
                 drm_helper_resume_force_mode(dev);
+
+                if (dev_priv->renderctx && dev_priv->pwrctx)
+                        ironlake_enable_rc6(dev);
         }
 
         intel_opregion_init(dev);
@@ -475,6 +481,9 @@ int i915_reset(struct drm_device *dev, u8 flags)
         bool need_display = true;
         int ret;
 
+        if (!i915_try_reset)
+                return 0;
+
         if (!mutex_trylock(&dev->struct_mutex))
                 return -EBUSY;
 
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index aac1bf332f7..385fc7ec39d 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -172,20 +172,21 @@ struct drm_i915_error_state {
                 int page_count;
                 u32 gtt_offset;
                 u32 *pages[0];
-        } *ringbuffer, *batchbuffer[2];
+        } *ringbuffer, *batchbuffer[I915_NUM_RINGS];
         struct drm_i915_error_buffer {
-                size_t size;
+                u32 size;
                 u32 name;
                 u32 seqno;
                 u32 gtt_offset;
                 u32 read_domains;
                 u32 write_domain;
-                u32 fence_reg;
+                s32 fence_reg:5;
                 s32 pinned:2;
                 u32 tiling:2;
                 u32 dirty:1;
                 u32 purgeable:1;
                 u32 ring:4;
+                u32 agp_type:1;
         } *active_bo, *pinned_bo;
         u32 active_bo_count, pinned_bo_count;
         struct intel_overlay_error_state *overlay;
@@ -332,6 +333,7 @@ typedef struct drm_i915_private {
 
         /* LVDS info */
         int backlight_level;  /* restore backlight to this value */
+        bool backlight_enabled;
         struct drm_display_mode *panel_fixed_mode;
         struct drm_display_mode *lfp_lvds_vbt_mode; /* if any */
         struct drm_display_mode *sdvo_lvds_vbt_mode; /* if any */
@@ -794,6 +796,7 @@ struct drm_i915_gem_object {
          */
         struct hlist_node exec_node;
         unsigned long exec_handle;
+        struct drm_i915_gem_exec_object2 *exec_entry;
 
         /**
          * Current offset of the object in GTT space.
@@ -1006,12 +1009,6 @@ extern u32 i915_get_vblank_counter(struct drm_device *dev, int crtc);
 extern u32 gm45_get_vblank_counter(struct drm_device *dev, int crtc);
 extern int i915_vblank_swap(struct drm_device *dev, void *data,
                             struct drm_file *file_priv);
-extern void i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask);
-extern void i915_disable_irq(drm_i915_private_t *dev_priv, u32 mask);
-extern void ironlake_enable_graphics_irq(drm_i915_private_t *dev_priv,
-                u32 mask);
-extern void ironlake_disable_graphics_irq(drm_i915_private_t *dev_priv,
-                u32 mask);
 
 void
 i915_enable_pipestat(drm_i915_private_t *dev_priv, int pipe, u32 mask);
@@ -1091,10 +1088,10 @@ int i915_gem_get_aperture_ioctl(struct drm_device *dev, void *data,
                                 struct drm_file *file_priv);
 void i915_gem_load(struct drm_device *dev);
 int i915_gem_init_object(struct drm_gem_object *obj);
-void i915_gem_flush_ring(struct drm_device *dev,
-                         struct intel_ring_buffer *ring,
-                         uint32_t invalidate_domains,
-                         uint32_t flush_domains);
+int __must_check i915_gem_flush_ring(struct drm_device *dev,
+                                     struct intel_ring_buffer *ring,
+                                     uint32_t invalidate_domains,
+                                     uint32_t flush_domains);
 struct drm_i915_gem_object *i915_gem_alloc_object(struct drm_device *dev,
                                                   size_t size);
 void i915_gem_free_object(struct drm_gem_object *obj);
@@ -1265,6 +1262,7 @@ extern void intel_disable_fbc(struct drm_device *dev);
 extern void intel_enable_fbc(struct drm_crtc *crtc, unsigned long interval);
 extern bool intel_fbc_enabled(struct drm_device *dev);
 extern bool ironlake_set_drps(struct drm_device *dev, u8 val);
+extern void ironlake_enable_rc6(struct drm_device *dev);
 extern void gen6_set_rps(struct drm_device *dev, u8 val);
 extern void intel_detect_pch (struct drm_device *dev);
 extern int intel_trans_dp_port_sel (struct drm_crtc *crtc);
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index c79c0b62ef6..3dfc848ff75 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -35,18 +35,18 @@
 #include <linux/swap.h>
 #include <linux/pci.h>
 
-static void i915_gem_object_flush_gpu_write_domain(struct drm_i915_gem_object *obj);
+static __must_check int i915_gem_object_flush_gpu_write_domain(struct drm_i915_gem_object *obj);
 static void i915_gem_object_flush_gtt_write_domain(struct drm_i915_gem_object *obj);
 static void i915_gem_object_flush_cpu_write_domain(struct drm_i915_gem_object *obj);
-static int i915_gem_object_set_to_cpu_domain(struct drm_i915_gem_object *obj,
-                                             bool write);
-static int i915_gem_object_set_cpu_read_domain_range(struct drm_i915_gem_object *obj,
-                                                     uint64_t offset,
-                                                     uint64_t size);
+static __must_check int i915_gem_object_set_to_cpu_domain(struct drm_i915_gem_object *obj,
+                                                          bool write);
+static __must_check int i915_gem_object_set_cpu_read_domain_range(struct drm_i915_gem_object *obj,
+                                                                  uint64_t offset,
+                                                                  uint64_t size);
 static void i915_gem_object_set_to_full_cpu_read_domain(struct drm_i915_gem_object *obj);
-static int i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
-                                       unsigned alignment,
-                                       bool map_and_fenceable);
+static __must_check int i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
+                                                    unsigned alignment,
+                                                    bool map_and_fenceable);
 static void i915_gem_clear_fence_reg(struct drm_device *dev,
                                      struct drm_i915_fence_reg *reg);
 static int i915_gem_phys_pwrite(struct drm_device *dev,
@@ -1935,6 +1935,8 @@ i915_gem_retire_work_handler(struct work_struct *work)
 {
         drm_i915_private_t *dev_priv;
         struct drm_device *dev;
+        bool idle;
+        int i;
 
         dev_priv = container_of(work, drm_i915_private_t,
                                 mm.retire_work.work);
@@ -1948,11 +1950,31 @@ i915_gem_retire_work_handler(struct work_struct *work)
 
         i915_gem_retire_requests(dev);
 
-        if (!dev_priv->mm.suspended &&
-                (!list_empty(&dev_priv->ring[RCS].request_list) ||
-                 !list_empty(&dev_priv->ring[VCS].request_list) ||
-                 !list_empty(&dev_priv->ring[BCS].request_list)))
+        /* Send a periodic flush down the ring so we don't hold onto GEM
+         * objects indefinitely.
+         */
+        idle = true;
+        for (i = 0; i < I915_NUM_RINGS; i++) {
+                struct intel_ring_buffer *ring = &dev_priv->ring[i];
+
+                if (!list_empty(&ring->gpu_write_list)) {
+                        struct drm_i915_gem_request *request;
+                        int ret;
+
+                        ret = i915_gem_flush_ring(dev, ring, 0,
+                                                  I915_GEM_GPU_DOMAINS);
+                        request = kzalloc(sizeof(*request), GFP_KERNEL);
+                        if (ret || request == NULL ||
+                            i915_add_request(dev, NULL, request, ring))
+                            kfree(request);
+                }
+
+                idle &= list_empty(&ring->request_list);
+        }
+
+        if (!dev_priv->mm.suspended && !idle)
                 queue_delayed_work(dev_priv->wq, &dev_priv->mm.retire_work, HZ);
+
         mutex_unlock(&dev->struct_mutex);
 }
 
@@ -2142,25 +2164,37 @@ i915_gem_object_unbind(struct drm_i915_gem_object *obj)
         return ret;
 }
 
-void
+int
 i915_gem_flush_ring(struct drm_device *dev,
                     struct intel_ring_buffer *ring,
                     uint32_t invalidate_domains,
                     uint32_t flush_domains)
 {
-        ring->flush(ring, invalidate_domains, flush_domains);
+        int ret;
+
+        ret = ring->flush(ring, invalidate_domains, flush_domains);
+        if (ret)
+                return ret;
+
         i915_gem_process_flushing_list(dev, flush_domains, ring);
+        return 0;
 }
 
 static int i915_ring_idle(struct drm_device *dev,
                           struct intel_ring_buffer *ring)
 {
+        int ret;
+
         if (list_empty(&ring->gpu_write_list) && list_empty(&ring->active_list))
                 return 0;
 
-        if (!list_empty(&ring->gpu_write_list))
-                i915_gem_flush_ring(dev, ring,
+        if (!list_empty(&ring->gpu_write_list)) {
+                ret = i915_gem_flush_ring(dev, ring,
                                     I915_GEM_GPU_DOMAINS, I915_GEM_GPU_DOMAINS);
+                if (ret)
+                        return ret;
+        }
+
         return i915_wait_request(dev,
                                  i915_gem_next_request_seqno(dev, ring),
                                  ring);
@@ -2370,10 +2404,13 @@ i915_gem_object_flush_fence(struct drm_i915_gem_object *obj,
         int ret;
 
         if (obj->fenced_gpu_access) {
-                if (obj->base.write_domain & I915_GEM_GPU_DOMAINS)
-                        i915_gem_flush_ring(obj->base.dev,
-                                            obj->last_fenced_ring,
-                                            0, obj->base.write_domain);
+                if (obj->base.write_domain & I915_GEM_GPU_DOMAINS) {
+                        ret = i915_gem_flush_ring(obj->base.dev,
+                                                  obj->last_fenced_ring,
+                                                  0, obj->base.write_domain);
+                        if (ret)
+                                return ret;
+                }
 
                 obj->fenced_gpu_access = false;
         }
@@ -2393,6 +2430,12 @@ i915_gem_object_flush_fence(struct drm_i915_gem_object *obj,
                 obj->last_fenced_ring = NULL;
         }
 
+        /* Ensure that all CPU reads are completed before installing a fence
+         * and all writes before removing the fence.
+         */
+        if (obj->base.read_domains & I915_GEM_DOMAIN_GTT)
+                mb();
+
         return 0;
 }
 
@@ -2523,9 +2566,12 @@ i915_gem_object_get_fence(struct drm_i915_gem_object *obj,
                                 return ret;
                 } else if (obj->tiling_changed) {
                         if (obj->fenced_gpu_access) {
-                                if (obj->base.write_domain & I915_GEM_GPU_DOMAINS)
-                                        i915_gem_flush_ring(obj->base.dev, obj->ring,
-                                                            0, obj->base.write_domain);
+                                if (obj->base.write_domain & I915_GEM_GPU_DOMAINS) {
+                                        ret = i915_gem_flush_ring(obj->base.dev, obj->ring,
+                                                                  0, obj->base.write_domain);
+                                        if (ret)
+                                                return ret;
+                                }
 
                                 obj->fenced_gpu_access = false;
                         }
@@ -2736,10 +2782,8 @@ i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
                 obj->gtt_space = NULL;
 
                 if (ret == -ENOMEM) {
-                        /* first try to clear up some space from the GTT */
-                        ret = i915_gem_evict_something(dev, size,
-                                                       alignment,
-                                                       map_and_fenceable);
+                        /* first try to reclaim some memory by clearing the GTT */
+                        ret = i915_gem_evict_everything(dev, false);
                         if (ret) {
                                 /* now try to shrink everyone else */
                                 if (gfpmask) {
@@ -2747,7 +2791,7 @@ i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
                                         goto search_free;
                                 }
 
-                                return ret;
+                                return -ENOMEM;
                         }
 
                         goto search_free;
@@ -2762,9 +2806,7 @@ i915_gem_object_bind_to_gtt(struct drm_i915_gem_object *obj,
                 drm_mm_put_block(obj->gtt_space);
                 obj->gtt_space = NULL;
 
-                ret = i915_gem_evict_something(dev, size,
-                                               alignment, map_and_fenceable);
-                if (ret)
+                if (i915_gem_evict_everything(dev, false))
                         return ret;
 
                 goto search_free;
@@ -2811,17 +2853,16 @@ i915_gem_clflush_object(struct drm_i915_gem_object *obj)
 }
 
 /** Flushes any GPU write domain for the object if it's dirty. */
-static void
+static int
 i915_gem_object_flush_gpu_write_domain(struct drm_i915_gem_object *obj)
 {
         struct drm_device *dev = obj->base.dev;
 
         if ((obj->base.write_domain & I915_GEM_GPU_DOMAINS) == 0)
-                return;
+                return 0;
 
         /* Queue the GPU write cache flushing we need. */
-        i915_gem_flush_ring(dev, obj->ring, 0, obj->base.write_domain);
-        BUG_ON(obj->base.write_domain);
+        return i915_gem_flush_ring(dev, obj->ring, 0, obj->base.write_domain);
 }
 
 /** Flushes the GTT write domain for the object if it's dirty. */
@@ -2833,10 +2874,16 @@ i915_gem_object_flush_gtt_write_domain(struct drm_i915_gem_object *obj)
         if (obj->base.write_domain != I915_GEM_DOMAIN_GTT)
                 return;
 
-        /* No actual flushing is required for the GTT write domain.   Writes
+        /* No actual flushing is required for the GTT write domain.  Writes
          * to it immediately go to main memory as far as we know, so there's
          * no chipset flush.  It also doesn't land in render cache.
+         *
+         * However, we do have to enforce the order so that all writes through
+         * the GTT land before any writes to the device, such as updates to
+         * the GATT itself.
          */
+        wmb();
+
         i915_gem_release_mmap(obj);
 
         old_write_domain = obj->base.write_domain;
@@ -2882,7 +2929,10 @@ i915_gem_object_set_to_gtt_domain(struct drm_i915_gem_object *obj, bool write)
         if (obj->gtt_space == NULL)
                 return -EINVAL;
 
-        i915_gem_object_flush_gpu_write_domain(obj);
+        ret = i915_gem_object_flush_gpu_write_domain(obj);
+        if (ret)
+                return ret;
+
         if (obj->pending_gpu_write || write) {
                 ret = i915_gem_object_wait_rendering(obj, true);
                 if (ret)
@@ -2927,7 +2977,10 @@ i915_gem_object_set_to_display_plane(struct drm_i915_gem_object *obj,
         if (obj->gtt_space == NULL)
                 return -EINVAL;
 
-        i915_gem_object_flush_gpu_write_domain(obj);
+        ret = i915_gem_object_flush_gpu_write_domain(obj);
+        if (ret)
+                return ret;
+
 
         /* Currently, we are always called from an non-interruptible context. */
         if (pipelined != obj->ring) {
@@ -2952,12 +3005,17 @@ int
 i915_gem_object_flush_gpu(struct drm_i915_gem_object *obj,
                           bool interruptible)
 {
+        int ret;
+
         if (!obj->active)
                 return 0;
 
-        if (obj->base.write_domain & I915_GEM_GPU_DOMAINS)
-                i915_gem_flush_ring(obj->base.dev, obj->ring,
-                                    0, obj->base.write_domain);
+        if (obj->base.write_domain & I915_GEM_GPU_DOMAINS) {
+                ret = i915_gem_flush_ring(obj->base.dev, obj->ring,
+                                          0, obj->base.write_domain);
+                if (ret)
+                        return ret;
+        }
 
         return i915_gem_object_wait_rendering(obj, interruptible);
 }
@@ -2974,7 +3032,10 @@ i915_gem_object_set_to_cpu_domain(struct drm_i915_gem_object *obj, bool write)
         uint32_t old_write_domain, old_read_domains;
         int ret;
 
-        i915_gem_object_flush_gpu_write_domain(obj);
+        ret = i915_gem_object_flush_gpu_write_domain(obj);
+        if (ret)
+                return ret;
+
         ret = i915_gem_object_wait_rendering(obj, true);
         if (ret)
                 return ret;
@@ -3069,7 +3130,10 @@ i915_gem_object_set_cpu_read_domain_range(struct drm_i915_gem_object *obj,
         if (offset == 0 && size == obj->base.size)
                 return i915_gem_object_set_to_cpu_domain(obj, 0);
 
-        i915_gem_object_flush_gpu_write_domain(obj);
+        ret = i915_gem_object_flush_gpu_write_domain(obj);
+        if (ret)
+                return ret;
+
         ret = i915_gem_object_wait_rendering(obj, true);
         if (ret)
                 return ret;
@@ -3362,8 +3426,8 @@ i915_gem_busy_ioctl(struct drm_device *dev, void *data,
                  * flush earlier is beneficial.
                  */
                 if (obj->base.write_domain & I915_GEM_GPU_DOMAINS) {
-                        i915_gem_flush_ring(dev, obj->ring,
-                                            0, obj->base.write_domain);
+                        ret = i915_gem_flush_ring(dev, obj->ring,
+                                                  0, obj->base.write_domain);
                 } else if (obj->ring->outstanding_lazy_request ==
                            obj->last_rendering_seqno) {
                         struct drm_i915_gem_request *request;
diff --git a/drivers/gpu/drm/i915/i915_gem_evict.c b/drivers/gpu/drm/i915/i915_gem_evict.c
index 78b8cf90c92..3d39005540a 100644
--- a/drivers/gpu/drm/i915/i915_gem_evict.c
+++ b/drivers/gpu/drm/i915/i915_gem_evict.c
@@ -127,9 +127,15 @@ i915_gem_evict_something(struct drm_device *dev, int min_size,
         }
 
         /* Nothing found, clean up and bail out! */
-        list_for_each_entry(obj, &unwind_list, exec_list) {
+        while (!list_empty(&unwind_list)) {
+                obj = list_first_entry(&unwind_list,
+                                       struct drm_i915_gem_object,
+                                       exec_list);
+
                 ret = drm_mm_scan_remove_block(obj->gtt_space);
                 BUG_ON(ret);
+
+                list_del_init(&obj->exec_list);
                 drm_gem_object_unreference(&obj->base);
         }
 
@@ -162,6 +168,7 @@ found:
                                        exec_list);
                 if (ret == 0)
                         ret = i915_gem_object_unbind(obj);
+
                 list_del_init(&obj->exec_list);
                 drm_gem_object_unreference(&obj->base);
         }
diff --git a/drivers/gpu/drm/i915/i915_gem_execbuffer.c b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
index 61129e6759e..e69834341ef 100644
--- a/drivers/gpu/drm/i915/i915_gem_execbuffer.c
+++ b/drivers/gpu/drm/i915/i915_gem_execbuffer.c
@@ -268,7 +268,6 @@ eb_destroy(struct eb_objects *eb)
 static int
 i915_gem_execbuffer_relocate_entry(struct drm_i915_gem_object *obj,
                                    struct eb_objects *eb,
-                                   struct drm_i915_gem_exec_object2 *entry,
                                    struct drm_i915_gem_relocation_entry *reloc)
 {
         struct drm_device *dev = obj->base.dev;
@@ -411,10 +410,10 @@ i915_gem_execbuffer_relocate_entry(struct drm_i915_gem_object *obj,
 
 static int
 i915_gem_execbuffer_relocate_object(struct drm_i915_gem_object *obj,
-                                    struct eb_objects *eb,
-                                    struct drm_i915_gem_exec_object2 *entry)
+                                    struct eb_objects *eb)
 {
         struct drm_i915_gem_relocation_entry __user *user_relocs;
+        struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
         int i, ret;
 
         user_relocs = (void __user *)(uintptr_t)entry->relocs_ptr;
@@ -426,7 +425,7 @@ i915_gem_execbuffer_relocate_object(struct drm_i915_gem_object *obj,
                                               sizeof(reloc)))
                         return -EFAULT;
 
-                ret = i915_gem_execbuffer_relocate_entry(obj, eb, entry, &reloc);
+                ret = i915_gem_execbuffer_relocate_entry(obj, eb, &reloc);
                 if (ret)
                         return ret;
 
@@ -442,13 +441,13 @@ i915_gem_execbuffer_relocate_object(struct drm_i915_gem_object *obj,
 static int
 i915_gem_execbuffer_relocate_object_slow(struct drm_i915_gem_object *obj,
                                          struct eb_objects *eb,
-                                         struct drm_i915_gem_exec_object2 *entry,
                                          struct drm_i915_gem_relocation_entry *relocs)
 {
+        const struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
         int i, ret;
 
         for (i = 0; i < entry->relocation_count; i++) {
-                ret = i915_gem_execbuffer_relocate_entry(obj, eb, entry, &relocs[i]);
+                ret = i915_gem_execbuffer_relocate_entry(obj, eb, &relocs[i]);
                 if (ret)
                         return ret;
         }
@@ -459,8 +458,7 @@ i915_gem_execbuffer_relocate_object_slow(struct drm_i915_gem_object *obj,
 static int
 i915_gem_execbuffer_relocate(struct drm_device *dev,
                              struct eb_objects *eb,
-                             struct list_head *objects,
-                             struct drm_i915_gem_exec_object2 *exec)
+                             struct list_head *objects)
 {
         struct drm_i915_gem_object *obj;
         int ret;
@@ -468,7 +466,7 @@ i915_gem_execbuffer_relocate(struct drm_device *dev,
         list_for_each_entry(obj, objects, exec_list) {
                 obj->base.pending_read_domains = 0;
                 obj->base.pending_write_domain = 0;
-                ret = i915_gem_execbuffer_relocate_object(obj, eb, exec++);
+                ret = i915_gem_execbuffer_relocate_object(obj, eb);
                 if (ret)
                         return ret;
         }
@@ -479,13 +477,36 @@ i915_gem_execbuffer_relocate(struct drm_device *dev,
 static int
 i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
                             struct drm_file *file,
-                            struct list_head *objects,
-                            struct drm_i915_gem_exec_object2 *exec)
+                            struct list_head *objects)
 {
         struct drm_i915_gem_object *obj;
-        struct drm_i915_gem_exec_object2 *entry;
         int ret, retry;
         bool has_fenced_gpu_access = INTEL_INFO(ring->dev)->gen < 4;
+        struct list_head ordered_objects;
+
+        INIT_LIST_HEAD(&ordered_objects);
+        while (!list_empty(objects)) {
+                struct drm_i915_gem_exec_object2 *entry;
+                bool need_fence, need_mappable;
+
+                obj = list_first_entry(objects,
+                                       struct drm_i915_gem_object,
+                                       exec_list);
+                entry = obj->exec_entry;
+
+                need_fence =
+                        has_fenced_gpu_access &&
+                        entry->flags & EXEC_OBJECT_NEEDS_FENCE &&
+                        obj->tiling_mode != I915_TILING_NONE;
+                need_mappable =
+                        entry->relocation_count ? true : need_fence;
+
+                if (need_mappable)
+                        list_move(&obj->exec_list, &ordered_objects);
+                else
+                        list_move_tail(&obj->exec_list, &ordered_objects);
+        }
+        list_splice(&ordered_objects, objects);
 
         /* Attempt to pin all of the buffers into the GTT.
          * This is done in 3 phases:
@@ -504,14 +525,11 @@ i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
                 ret = 0;
 
                 /* Unbind any ill-fitting objects or pin. */
-                entry = exec;
                 list_for_each_entry(obj, objects, exec_list) {
+                        struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
                         bool need_fence, need_mappable;
-
-                        if (!obj->gtt_space) {
-                                entry++;
+                        if (!obj->gtt_space)
                                 continue;
-                        }
 
                         need_fence =
                                 has_fenced_gpu_access &&
@@ -534,8 +552,8 @@ i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
                 }
 
                 /* Bind fresh objects */
-                entry = exec;
                 list_for_each_entry(obj, objects, exec_list) {
+                        struct drm_i915_gem_exec_object2 *entry = obj->exec_entry;
                         bool need_fence;
 
                         need_fence =
@@ -570,7 +588,6 @@ i915_gem_execbuffer_reserve(struct intel_ring_buffer *ring,
                         }
 
                         entry->offset = obj->gtt_offset;
-                        entry++;
                 }
 
                 /* Decrement pin count for bound objects */
@@ -622,7 +639,7 @@ i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
         int i, total, ret;
 
         /* We may process another execbuffer during the unlock... */
-        while (list_empty(objects)) {
+        while (!list_empty(objects)) {
                 obj = list_first_entry(objects,
                                        struct drm_i915_gem_object,
                                        exec_list);
@@ -665,7 +682,6 @@ i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
         }
 
         /* reacquire the objects */
-        INIT_LIST_HEAD(objects);
         eb_reset(eb);
         for (i = 0; i < count; i++) {
                 struct drm_i915_gem_object *obj;
@@ -681,10 +697,11 @@ i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
 
                 list_add_tail(&obj->exec_list, objects);
                 obj->exec_handle = exec[i].handle;
+                obj->exec_entry = &exec[i];
                 eb_add_object(eb, obj);
         }
 
-        ret = i915_gem_execbuffer_reserve(ring, file, objects, exec);
+        ret = i915_gem_execbuffer_reserve(ring, file, objects);
         if (ret)
                 goto err;
 
@@ -693,7 +710,6 @@ i915_gem_execbuffer_relocate_slow(struct drm_device *dev,
                 obj->base.pending_read_domains = 0;
                 obj->base.pending_write_domain = 0;
                 ret = i915_gem_execbuffer_relocate_object_slow(obj, eb,
-                                                               exec,
                                                                reloc + total);
                 if (ret)
                         goto err;
@@ -713,25 +729,34 @@ err:
         return ret;
 }
 
-static void
+static int
 i915_gem_execbuffer_flush(struct drm_device *dev,
                           uint32_t invalidate_domains,
                           uint32_t flush_domains,
                           uint32_t flush_rings)
 {
         drm_i915_private_t *dev_priv = dev->dev_private;
-        int i;
+        int i, ret;
 
         if (flush_domains & I915_GEM_DOMAIN_CPU)
                 intel_gtt_chipset_flush();
 
+        if (flush_domains & I915_GEM_DOMAIN_GTT)
+                wmb();
+
         if ((flush_domains | invalidate_domains) & I915_GEM_GPU_DOMAINS) {
                 for (i = 0; i < I915_NUM_RINGS; i++)
-                        if (flush_rings & (1 << i))
-                                i915_gem_flush_ring(dev, &dev_priv->ring[i],
-                                                    invalidate_domains,
-                                                    flush_domains);
+                        if (flush_rings & (1 << i)) {
+                                ret = i915_gem_flush_ring(dev,
+                                                          &dev_priv->ring[i],
+                                                          invalidate_domains,
+                                                          flush_domains);
+                                if (ret)
+                                        return ret;
+                        }
         }
+
+        return 0;
 }
 
 static int
@@ -795,10 +820,12 @@ i915_gem_execbuffer_move_to_gpu(struct intel_ring_buffer *ring,
                          cd.invalidate_domains,
                          cd.flush_domains);
 #endif
-                i915_gem_execbuffer_flush(ring->dev,
-                                          cd.invalidate_domains,
-                                          cd.flush_domains,
-                                          cd.flush_rings);
+                ret = i915_gem_execbuffer_flush(ring->dev,
+                                                cd.invalidate_domains,
+                                                cd.flush_domains,
+                                                cd.flush_rings);
+                if (ret)
+                        return ret;
         }
 
         list_for_each_entry(obj, objects, exec_list) {
@@ -921,7 +948,7 @@ i915_gem_execbuffer_retire_commands(struct drm_device *dev,
                                     struct intel_ring_buffer *ring)
 {
         struct drm_i915_gem_request *request;
-        u32 flush_domains;
+        u32 invalidate;
 
         /*
          * Ensure that the commands in the batch buffer are
@@ -929,11 +956,13 @@ i915_gem_execbuffer_retire_commands(struct drm_device *dev,
          *
          * The sampler always gets flushed on i965 (sigh).
          */
-        flush_domains = 0;
+        invalidate = I915_GEM_DOMAIN_COMMAND;
         if (INTEL_INFO(dev)->gen >= 4)
-                flush_domains |= I915_GEM_DOMAIN_SAMPLER;
-
-        ring->flush(ring, I915_GEM_DOMAIN_COMMAND, flush_domains);
+                invalidate |= I915_GEM_DOMAIN_SAMPLER;
+        if (ring->flush(ring, invalidate, 0)) {
+                i915_gem_next_request_seqno(dev, ring);
+                return;
+        }
 
         /* Add a breadcrumb for the completion of the batch buffer */
         request = kzalloc(sizeof(*request), GFP_KERNEL);
@@ -1098,16 +1127,22 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
 
                 list_add_tail(&obj->exec_list, &objects);
                 obj->exec_handle = exec[i].handle;
+                obj->exec_entry = &exec[i];
                 eb_add_object(eb, obj);
         }
 
+        /* take note of the batch buffer before we might reorder the lists */
+        batch_obj = list_entry(objects.prev,
+                               struct drm_i915_gem_object,
+                               exec_list);
+
         /* Move the objects en-masse into the GTT, evicting if necessary. */
-        ret = i915_gem_execbuffer_reserve(ring, file, &objects, exec);
+        ret = i915_gem_execbuffer_reserve(ring, file, &objects);
         if (ret)
                 goto err;
 
         /* The objects are in their final locations, apply the relocations. */
-        ret = i915_gem_execbuffer_relocate(dev, eb, &objects, exec);
+        ret = i915_gem_execbuffer_relocate(dev, eb, &objects);
         if (ret) {
                 if (ret == -EFAULT) {
                         ret = i915_gem_execbuffer_relocate_slow(dev, file, ring,
@@ -1121,9 +1156,6 @@ i915_gem_do_execbuffer(struct drm_device *dev, void *data,
         }
 
         /* Set the pending read domains for the batch buffer to COMMAND */
-        batch_obj = list_entry(objects.prev,
-                               struct drm_i915_gem_object,
-                               exec_list);
         if (batch_obj->base.pending_write_domain) {
                 DRM_ERROR("Attempting to use self-modifying batch buffer\n");
                 ret = -EINVAL;
@@ -1340,4 +1372,3 @@ i915_gem_execbuffer2(struct drm_device *dev, void *data,
         drm_free_large(exec2_list);
         return ret;
 }
-
diff --git a/drivers/gpu/drm/i915/i915_gem_gtt.c b/drivers/gpu/drm/i915/i915_gem_gtt.c
index 86673e77d7c..70433ae50ac 100644
--- a/drivers/gpu/drm/i915/i915_gem_gtt.c
+++ b/drivers/gpu/drm/i915/i915_gem_gtt.c
@@ -85,15 +85,11 @@ int i915_gem_gtt_bind_object(struct drm_i915_gem_object *obj)
 
 void i915_gem_gtt_unbind_object(struct drm_i915_gem_object *obj)
 {
-        struct drm_device *dev = obj->base.dev;
-        struct drm_i915_private *dev_priv = dev->dev_private;
+        intel_gtt_clear_range(obj->gtt_space->start >> PAGE_SHIFT,
+                              obj->base.size >> PAGE_SHIFT);
 
-        if (dev_priv->mm.gtt->needs_dmar) {
+        if (obj->sg_list) {
                 intel_gtt_unmap_memory(obj->sg_list, obj->num_sg);
                 obj->sg_list = NULL;
-                obj->num_sg = 0;
         }
-
-        intel_gtt_clear_range(obj->gtt_space->start >> PAGE_SHIFT,
-                              obj->base.size >> PAGE_SHIFT);
 }
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index 0dadc025b77..e418e8bb61e 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -64,26 +64,6 @@
 #define DRM_I915_VBLANK_PIPE_ALL        (DRM_I915_VBLANK_PIPE_A | \
                                          DRM_I915_VBLANK_PIPE_B)
 
-void
-ironlake_enable_graphics_irq(drm_i915_private_t *dev_priv, u32 mask)
-{
-        if ((dev_priv->gt_irq_mask & mask) != 0) {
-                dev_priv->gt_irq_mask &= ~mask;
-                I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
-                POSTING_READ(GTIMR);
-        }
-}
-
-void
-ironlake_disable_graphics_irq(drm_i915_private_t *dev_priv, u32 mask)
-{
-        if ((dev_priv->gt_irq_mask & mask) != mask) {
-                dev_priv->gt_irq_mask |= mask;
-                I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
-                POSTING_READ(GTIMR);
-        }
-}
-
 /* For display hotplug interrupt */
 static void
 ironlake_enable_display_irq(drm_i915_private_t *dev_priv, u32 mask)
@@ -105,26 +85,6 @@ ironlake_disable_display_irq(drm_i915_private_t *dev_priv, u32 mask)
         }
 }
 
-void
-i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
-{
-        if ((dev_priv->irq_mask & mask) != 0) {
-                dev_priv->irq_mask &= ~mask;
-                I915_WRITE(IMR, dev_priv->irq_mask);
-                POSTING_READ(IMR);
-        }
-}
-
-void
-i915_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
-{
-        if ((dev_priv->irq_mask & mask) != mask) {
-                dev_priv->irq_mask |= mask;
-                I915_WRITE(IMR, dev_priv->irq_mask);
-                POSTING_READ(IMR);
-        }
-}
-
 static inline u32
 i915_pipestat(int pipe)
 {
@@ -389,9 +349,12 @@ static void notify_ring(struct drm_device *dev,
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
         u32 seqno = ring->get_seqno(ring);
-        ring->irq_seqno = seqno;
+
         trace_i915_gem_request_complete(dev, seqno);
+
+        ring->irq_seqno = seqno;
         wake_up_all(&ring->irq_queue);
+
         dev_priv->hangcheck_count = 0;
         mod_timer(&dev_priv->hangcheck_timer,
                   jiffies + msecs_to_jiffies(DRM_I915_HANGCHECK_PERIOD));
@@ -435,6 +398,50 @@ static void gen6_pm_irq_handler(struct drm_device *dev)
         I915_WRITE(GEN6_PMIIR, pm_iir);
 }
 
+static void pch_irq_handler(struct drm_device *dev)
+{
+        drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
+        u32 pch_iir;
+
+        pch_iir = I915_READ(SDEIIR);
+
+        if (pch_iir & SDE_AUDIO_POWER_MASK)
+                DRM_DEBUG_DRIVER("PCH audio power change on port %d\n",
+                                 (pch_iir & SDE_AUDIO_POWER_MASK) >>
+                                 SDE_AUDIO_POWER_SHIFT);
+
+        if (pch_iir & SDE_GMBUS)
+                DRM_DEBUG_DRIVER("PCH GMBUS interrupt\n");
+
+        if (pch_iir & SDE_AUDIO_HDCP_MASK)
+                DRM_DEBUG_DRIVER("PCH HDCP audio interrupt\n");
+
+        if (pch_iir & SDE_AUDIO_TRANS_MASK)
+                DRM_DEBUG_DRIVER("PCH transcoder audio interrupt\n");
+
+        if (pch_iir & SDE_POISON)
+                DRM_ERROR("PCH poison interrupt\n");
+
+        if (pch_iir & SDE_FDI_MASK) {
+                u32 fdia, fdib;
+
+                fdia = I915_READ(FDI_RXA_IIR);
+                fdib = I915_READ(FDI_RXB_IIR);
+                DRM_DEBUG_DRIVER("PCH FDI RX interrupt; FDI RXA IIR: 0x%08x, FDI RXB IIR: 0x%08x\n", fdia, fdib);
+        }
+
+        if (pch_iir & (SDE_TRANSB_CRC_DONE | SDE_TRANSA_CRC_DONE))
+                DRM_DEBUG_DRIVER("PCH transcoder CRC done interrupt\n");
+
+        if (pch_iir & (SDE_TRANSB_CRC_ERR | SDE_TRANSA_CRC_ERR))
+                DRM_DEBUG_DRIVER("PCH transcoder CRC error interrupt\n");
+
+        if (pch_iir & SDE_TRANSB_FIFO_UNDER)
+                DRM_DEBUG_DRIVER("PCH transcoder B underrun interrupt\n");
+        if (pch_iir & SDE_TRANSA_FIFO_UNDER)
+                DRM_DEBUG_DRIVER("PCH transcoder A underrun interrupt\n");
+}
+
 static irqreturn_t ironlake_irq_handler(struct drm_device *dev)
 {
         drm_i915_private_t *dev_priv = (drm_i915_private_t *) dev->dev_private;
@@ -502,8 +509,11 @@ static irqreturn_t ironlake_irq_handler(struct drm_device *dev)
                 drm_handle_vblank(dev, 1);
 
         /* check event from PCH */
-        if ((de_iir & DE_PCH_EVENT) && (pch_iir & hotplug_mask))
-                queue_work(dev_priv->wq, &dev_priv->hotplug_work);
+        if (de_iir & DE_PCH_EVENT) {
+                if (pch_iir & hotplug_mask)
+                        queue_work(dev_priv->wq, &dev_priv->hotplug_work);
+                pch_irq_handler(dev);
+        }
 
         if (de_iir & DE_PCU_EVENT) {
                 I915_WRITE16(MEMINTRSTS, I915_READ(MEMINTRSTS));
@@ -556,10 +566,9 @@ static void i915_error_work_func(struct work_struct *work)
 
 #ifdef CONFIG_DEBUG_FS
 static struct drm_i915_error_object *
-i915_error_object_create(struct drm_device *dev,
+i915_error_object_create(struct drm_i915_private *dev_priv,
                          struct drm_i915_gem_object *src)
 {
-        drm_i915_private_t *dev_priv = dev->dev_private;
         struct drm_i915_error_object *dst;
         int page, page_count;
         u32 reloc_offset;
@@ -632,52 +641,6 @@ i915_error_state_free(struct drm_device *dev,
         kfree(error);
 }
 
-static u32
-i915_get_bbaddr(struct drm_device *dev, u32 *ring)
-{
-        u32 cmd;
-
-        if (IS_I830(dev) || IS_845G(dev))
-                cmd = MI_BATCH_BUFFER;
-        else if (INTEL_INFO(dev)->gen >= 4)
-                cmd = (MI_BATCH_BUFFER_START | (2 << 6) |
-                       MI_BATCH_NON_SECURE_I965);
-        else
-                cmd = (MI_BATCH_BUFFER_START | (2 << 6));
-
-        return ring[0] == cmd ? ring[1] : 0;
-}
-
-static u32
-i915_ringbuffer_last_batch(struct drm_device *dev,
-                           struct intel_ring_buffer *ring)
-{
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        u32 head, bbaddr;
-        u32 *val;
-
-        /* Locate the current position in the ringbuffer and walk back
-         * to find the most recently dispatched batch buffer.
-         */
-        head = I915_READ_HEAD(ring) & HEAD_ADDR;
-
-        val = (u32 *)(ring->virtual_start + head);
-        while (--val >= (u32 *)ring->virtual_start) {
-                bbaddr = i915_get_bbaddr(dev, val);
-                if (bbaddr)
-                        return bbaddr;
-        }
-
-        val = (u32 *)(ring->virtual_start + ring->size);
-        while (--val >= (u32 *)ring->virtual_start) {
-                bbaddr = i915_get_bbaddr(dev, val);
-                if (bbaddr)
-                        return bbaddr;
-        }
-
-        return 0;
-}
-
 static u32 capture_bo_list(struct drm_i915_error_buffer *err,
                            int count,
                            struct list_head *head)
@@ -702,6 +665,7 @@ static u32 capture_bo_list(struct drm_i915_error_buffer *err,
                 err->dirty = obj->dirty;
                 err->purgeable = obj->madv != I915_MADV_WILLNEED;
                 err->ring = obj->ring ? obj->ring->id : 0;
+                err->agp_type = obj->agp_type == AGP_USER_CACHED_MEMORY;
 
                 if (++i == count)
                         break;
@@ -741,6 +705,36 @@ static void i915_gem_record_fences(struct drm_device *dev,
         }
 }
 
+static struct drm_i915_error_object *
+i915_error_first_batchbuffer(struct drm_i915_private *dev_priv,
+                             struct intel_ring_buffer *ring)
+{
+        struct drm_i915_gem_object *obj;
+        u32 seqno;
+
+        if (!ring->get_seqno)
+                return NULL;
+
+        seqno = ring->get_seqno(ring);
+        list_for_each_entry(obj, &dev_priv->mm.active_list, mm_list) {
+                if (obj->ring != ring)
+                        continue;
+
+                if (!i915_seqno_passed(obj->last_rendering_seqno, seqno))
+                        continue;
+
+                if ((obj->base.read_domains & I915_GEM_DOMAIN_COMMAND) == 0)
+                        continue;
+
+                /* We need to copy these to an anonymous buffer as the simplest
+                 * method to avoid being overwritten by userspace.
+                 */
+                return i915_error_object_create(dev_priv, obj);
+        }
+
+        return NULL;
+}
+
 /**
  * i915_capture_error_state - capture an error record for later analysis
  * @dev: drm device
@@ -755,10 +749,8 @@ static void i915_capture_error_state(struct drm_device *dev)
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct drm_i915_gem_object *obj;
         struct drm_i915_error_state *error;
-        struct drm_i915_gem_object *batchbuffer[2];
         unsigned long flags;
-        u32 bbaddr;
-        int count;
+        int i;
 
         spin_lock_irqsave(&dev_priv->error_lock, flags);
         error = dev_priv->first_error;
@@ -817,83 +809,30 @@ static void i915_capture_error_state(struct drm_device *dev)
         }
         i915_gem_record_fences(dev, error);
 
-        bbaddr = i915_ringbuffer_last_batch(dev, &dev_priv->ring[RCS]);
-
-        /* Grab the current batchbuffer, most likely to have crashed. */
-        batchbuffer[0] = NULL;
-        batchbuffer[1] = NULL;
-        count = 0;
-        list_for_each_entry(obj, &dev_priv->mm.active_list, mm_list) {
-                if (batchbuffer[0] == NULL &&
-                    bbaddr >= obj->gtt_offset &&
-                    bbaddr < obj->gtt_offset + obj->base.size)
-                        batchbuffer[0] = obj;
-
-                if (batchbuffer[1] == NULL &&
-                    error->acthd >= obj->gtt_offset &&
-                    error->acthd < obj->gtt_offset + obj->base.size)
-                        batchbuffer[1] = obj;
-
-                count++;
-        }
-        /* Scan the other lists for completeness for those bizarre errors. */
-        if (batchbuffer[0] == NULL || batchbuffer[1] == NULL) {
-                list_for_each_entry(obj, &dev_priv->mm.flushing_list, mm_list) {
-                        if (batchbuffer[0] == NULL &&
-                            bbaddr >= obj->gtt_offset &&
-                            bbaddr < obj->gtt_offset + obj->base.size)
-                                batchbuffer[0] = obj;
-
-                        if (batchbuffer[1] == NULL &&
-                            error->acthd >= obj->gtt_offset &&
-                            error->acthd < obj->gtt_offset + obj->base.size)
-                                batchbuffer[1] = obj;
-
-                        if (batchbuffer[0] && batchbuffer[1])
-                                break;
-                }
-        }
-        if (batchbuffer[0] == NULL || batchbuffer[1] == NULL) {
-                list_for_each_entry(obj, &dev_priv->mm.inactive_list, mm_list) {
-                        if (batchbuffer[0] == NULL &&
-                            bbaddr >= obj->gtt_offset &&
-                            bbaddr < obj->gtt_offset + obj->base.size)
-                                batchbuffer[0] = obj;
-
-                        if (batchbuffer[1] == NULL &&
-                            error->acthd >= obj->gtt_offset &&
-                            error->acthd < obj->gtt_offset + obj->base.size)
-                                batchbuffer[1] = obj;
-
-                        if (batchbuffer[0] && batchbuffer[1])
-                                break;
-                }
-        }
-
-        /* We need to copy these to an anonymous buffer as the simplest
-         * method to avoid being overwritten by userspace.
-         */
-        error->batchbuffer[0] = i915_error_object_create(dev, batchbuffer[0]);
-        if (batchbuffer[1] != batchbuffer[0])
-                error->batchbuffer[1] = i915_error_object_create(dev, batchbuffer[1]);
-        else
-                error->batchbuffer[1] = NULL;
+        /* Record the active batchbuffers */
+        for (i = 0; i < I915_NUM_RINGS; i++)
+                error->batchbuffer[i] =
+                        i915_error_first_batchbuffer(dev_priv,
+                                                     &dev_priv->ring[i]);
 
         /* Record the ringbuffer */
-        error->ringbuffer = i915_error_object_create(dev,
+        error->ringbuffer = i915_error_object_create(dev_priv,
                                                      dev_priv->ring[RCS].obj);
 
         /* Record buffers on the active and pinned lists. */
         error->active_bo = NULL;
         error->pinned_bo = NULL;
 
-        error->active_bo_count = count;
+        i = 0;
+        list_for_each_entry(obj, &dev_priv->mm.active_list, mm_list)
+                i++;
+        error->active_bo_count = i;
         list_for_each_entry(obj, &dev_priv->mm.pinned_list, mm_list)
-                count++;
-        error->pinned_bo_count = count - error->active_bo_count;
+                i++;
+        error->pinned_bo_count = i - error->active_bo_count;
 
-        if (count) {
-                error->active_bo = kmalloc(sizeof(*error->active_bo)*count,
+        if (i) {
+                error->active_bo = kmalloc(sizeof(*error->active_bo)*i,
                                            GFP_ATOMIC);
                 if (error->active_bo)
                         error->pinned_bo =
@@ -1673,11 +1612,6 @@ static int ironlake_irq_postinstall(struct drm_device *dev)
 
         I915_WRITE(GTIIR, I915_READ(GTIIR));
         I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
-        if (IS_GEN6(dev)) {
-                I915_WRITE(GEN6_RENDER_IMR, ~GEN6_RENDER_USER_INTERRUPT);
-                I915_WRITE(GEN6_BSD_IMR, ~GEN6_BSD_USER_INTERRUPT);
-                I915_WRITE(GEN6_BLITTER_IMR, ~GEN6_BLITTER_USER_INTERRUPT);
-        }
 
         if (IS_GEN6(dev))
                 render_irqs =
@@ -1698,6 +1632,9 @@ static int ironlake_irq_postinstall(struct drm_device *dev)
         } else {
                 hotplug_mask = SDE_CRT_HOTPLUG | SDE_PORTB_HOTPLUG |
                                SDE_PORTC_HOTPLUG | SDE_PORTD_HOTPLUG;
+                hotplug_mask |= SDE_AUX_MASK | SDE_FDI_MASK | SDE_TRANS_MASK;
+                I915_WRITE(FDI_RXA_IMR, 0);
+                I915_WRITE(FDI_RXB_IMR, 0);
         }
 
         dev_priv->pch_irq_mask = ~hotplug_mask;
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index 8f948a6fbc1..40a407f41f6 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -145,6 +145,8 @@
 #define   MI_END_SCENE          (1 << 4) /* flush binner and incr scene count */
 #define   MI_INVALIDATE_ISP     (1 << 5) /* invalidate indirect state pointers */
 #define MI_BATCH_BUFFER_END     MI_INSTR(0x0a, 0)
+#define MI_SUSPEND_FLUSH        MI_INSTR(0x0b, 0)
+#define   MI_SUSPEND_FLUSH_EN   (1<<0)
 #define MI_REPORT_HEAD          MI_INSTR(0x07, 0)
 #define MI_OVERLAY_FLIP         MI_INSTR(0x11,0)
 #define   MI_OVERLAY_CONTINUE   (0x0<<21)
@@ -159,6 +161,7 @@
 #define   MI_MM_SPACE_PHYSICAL          (0<<8)
 #define   MI_SAVE_EXT_STATE_EN          (1<<3)
 #define   MI_RESTORE_EXT_STATE_EN       (1<<2)
+#define   MI_FORCE_RESTORE              (1<<1)
 #define   MI_RESTORE_INHIBIT            (1<<0)
 #define MI_STORE_DWORD_IMM      MI_INSTR(0x20, 1)
 #define   MI_MEM_VIRTUAL        (1 << 22) /* 965+ only */
@@ -288,6 +291,7 @@
 #define RING_HWS_PGA_GEN6(base) ((base)+0x2080)
 #define RING_ACTHD(base)        ((base)+0x74)
 #define RING_NOPID(base)        ((base)+0x94)
+#define RING_IMR(base)          ((base)+0xa8)
 #define   TAIL_ADDR             0x001FFFF8
 #define   HEAD_WRAP_COUNT       0xFFE00000
 #define   HEAD_WRAP_ONE         0x00200000
@@ -1130,9 +1134,50 @@
 #define RCBMINAVG               0x111a0
 #define RCUPEI                  0x111b0
 #define RCDNEI                  0x111b4
-#define MCHBAR_RENDER_STANDBY           0x111b8
-#define   RCX_SW_EXIT           (1<<23)
-#define   RSX_STATUS_MASK       0x00700000
+#define RSTDBYCTL               0x111b8
+#define   RS1EN                 (1<<31)
+#define   RS2EN                 (1<<30)
+#define   RS3EN                 (1<<29)
+#define   D3RS3EN               (1<<28) /* Display D3 imlies RS3 */
+#define   SWPROMORSX            (1<<27) /* RSx promotion timers ignored */
+#define   RCWAKERW              (1<<26) /* Resetwarn from PCH causes wakeup */
+#define   DPRSLPVREN            (1<<25) /* Fast voltage ramp enable */
+#define   GFXTGHYST             (1<<24) /* Hysteresis to allow trunk gating */
+#define   RCX_SW_EXIT           (1<<23) /* Leave RSx and prevent re-entry */
+#define   RSX_STATUS_MASK       (7<<20)
+#define   RSX_STATUS_ON         (0<<20)
+#define   RSX_STATUS_RC1        (1<<20)
+#define   RSX_STATUS_RC1E       (2<<20)
+#define   RSX_STATUS_RS1        (3<<20)
+#define   RSX_STATUS_RS2        (4<<20) /* aka rc6 */
+#define   RSX_STATUS_RSVD       (5<<20) /* deep rc6 unsupported on ilk */
+#define   RSX_STATUS_RS3        (6<<20) /* rs3 unsupported on ilk */
+#define   RSX_STATUS_RSVD2      (7<<20)
+#define   UWRCRSXE              (1<<19) /* wake counter limit prevents rsx */
+#define   RSCRP                 (1<<18) /* rs requests control on rs1/2 reqs */
+#define   JRSC                  (1<<17) /* rsx coupled to cpu c-state */
+#define   RS2INC0               (1<<16) /* allow rs2 in cpu c0 */
+#define   RS1CONTSAV_MASK       (3<<14)
+#define   RS1CONTSAV_NO_RS1     (0<<14) /* rs1 doesn't save/restore context */
+#define   RS1CONTSAV_RSVD       (1<<14)
+#define   RS1CONTSAV_SAVE_RS1   (2<<14) /* rs1 saves context */
+#define   RS1CONTSAV_FULL_RS1   (3<<14) /* rs1 saves and restores context */
+#define   NORMSLEXLAT_MASK      (3<<12)
+#define   SLOW_RS123            (0<<12)
+#define   SLOW_RS23             (1<<12)
+#define   SLOW_RS3              (2<<12)
+#define   NORMAL_RS123          (3<<12)
+#define   RCMODE_TIMEOUT        (1<<11) /* 0 is eval interval method */
+#define   IMPROMOEN             (1<<10) /* promo is immediate or delayed until next idle interval (only for timeout method above) */
+#define   RCENTSYNC             (1<<9) /* rs coupled to cpu c-state (3/6/7) */
+#define   STATELOCK             (1<<7) /* locked to rs_cstate if 0 */
+#define   RS_CSTATE_MASK        (3<<4)
+#define   RS_CSTATE_C367_RS1    (0<<4)
+#define   RS_CSTATE_C36_RS1_C7_RS2 (1<<4)
+#define   RS_CSTATE_RSVD        (2<<4)
+#define   RS_CSTATE_C367_RS2    (3<<4)
+#define   REDSAVES              (1<<3) /* no context save if was idle during rs0 */
+#define   REDRESTORES           (1<<2) /* no restore if was idle during rs0 */
 #define VIDCTL                  0x111c0
 #define VIDSTS                  0x111c8
 #define VIDSTART                0x111cc /* 8 bits */
@@ -2345,8 +2390,13 @@
 
 /* Memory latency timer register */
 #define MLTR_ILK                0x11222
+#define  MLTR_WM1_SHIFT         0
+#define  MLTR_WM2_SHIFT         8
 /* the unit of memory self-refresh latency time is 0.5us */
 #define  ILK_SRLT_MASK          0x3f
+#define ILK_LATENCY(shift)      (I915_READ(MLTR_ILK) >> (shift) & ILK_SRLT_MASK)
+#define ILK_READ_WM1_LATENCY()  ILK_LATENCY(MLTR_WM1_SHIFT)
+#define ILK_READ_WM2_LATENCY()  ILK_LATENCY(MLTR_WM2_SHIFT)
 
 /* define the fifo size on Ironlake */
 #define ILK_DISPLAY_FIFO        128
@@ -2728,12 +2778,41 @@
 /* PCH */
 
 /* south display engine interrupt */
+#define SDE_AUDIO_POWER_D       (1 << 27)
+#define SDE_AUDIO_POWER_C       (1 << 26)
+#define SDE_AUDIO_POWER_B       (1 << 25)
+#define SDE_AUDIO_POWER_SHIFT   (25)
+#define SDE_AUDIO_POWER_MASK    (7 << SDE_AUDIO_POWER_SHIFT)
+#define SDE_GMBUS               (1 << 24)
+#define SDE_AUDIO_HDCP_TRANSB   (1 << 23)
+#define SDE_AUDIO_HDCP_TRANSA   (1 << 22)
+#define SDE_AUDIO_HDCP_MASK     (3 << 22)
+#define SDE_AUDIO_TRANSB        (1 << 21)
+#define SDE_AUDIO_TRANSA        (1 << 20)
+#define SDE_AUDIO_TRANS_MASK    (3 << 20)
+#define SDE_POISON              (1 << 19)
+/* 18 reserved */
+#define SDE_FDI_RXB             (1 << 17)
+#define SDE_FDI_RXA             (1 << 16)
+#define SDE_FDI_MASK            (3 << 16)
+#define SDE_AUXD                (1 << 15)
+#define SDE_AUXC                (1 << 14)
+#define SDE_AUXB                (1 << 13)
+#define SDE_AUX_MASK            (7 << 13)
+/* 12 reserved */
 #define SDE_CRT_HOTPLUG         (1 << 11)
 #define SDE_PORTD_HOTPLUG       (1 << 10)
 #define SDE_PORTC_HOTPLUG       (1 << 9)
 #define SDE_PORTB_HOTPLUG       (1 << 8)
 #define SDE_SDVOB_HOTPLUG       (1 << 6)
 #define SDE_HOTPLUG_MASK        (0xf << 8)
+#define SDE_TRANSB_CRC_DONE     (1 << 5)
+#define SDE_TRANSB_CRC_ERR      (1 << 4)
+#define SDE_TRANSB_FIFO_UNDER   (1 << 3)
+#define SDE_TRANSA_CRC_DONE     (1 << 2)
+#define SDE_TRANSA_CRC_ERR      (1 << 1)
+#define SDE_TRANSA_FIFO_UNDER   (1 << 0)
+#define SDE_TRANS_MASK          (0x3f)
 /* CPT */
 #define SDE_CRT_HOTPLUG_CPT     (1 << 19)
 #define SDE_PORTD_HOTPLUG_CPT   (1 << 23)
@@ -3174,10 +3253,11 @@
 #define  EDP_LINK_TRAIN_600MV_3_5DB_SNB_A       (0x01<<22)
 #define  EDP_LINK_TRAIN_800MV_0DB_SNB_A         (0x0<<22)
 /* SNB B-stepping */
-#define  EDP_LINK_TRAIN_400MV_0DB_SNB_B         (0x0<<22)
-#define  EDP_LINK_TRAIN_400MV_6DB_SNB_B         (0x3a<<22)
-#define  EDP_LINK_TRAIN_600MV_3_5DB_SNB_B       (0x39<<22)
-#define  EDP_LINK_TRAIN_800MV_0DB_SNB_B         (0x38<<22)
+#define  EDP_LINK_TRAIN_400_600MV_0DB_SNB_B     (0x0<<22)
+#define  EDP_LINK_TRAIN_400MV_3_5DB_SNB_B       (0x1<<22)
+#define  EDP_LINK_TRAIN_400_600MV_6DB_SNB_B     (0x3a<<22)
+#define  EDP_LINK_TRAIN_600_800MV_3_5DB_SNB_B   (0x39<<22)
+#define  EDP_LINK_TRAIN_800_1200MV_0DB_SNB_B    (0x38<<22)
 #define  EDP_LINK_TRAIN_VOL_EMP_MASK_SNB        (0x3f<<22)
 
 #define  FORCEWAKE                              0xA18C
@@ -3239,6 +3319,7 @@
 
 #define GEN6_PCODE_MAILBOX                      0x138124
 #define   GEN6_PCODE_READY                      (1<<31)
+#define   GEN6_READ_OC_PARAMS                   0xc
 #define   GEN6_PCODE_WRITE_MIN_FREQ_TABLE       0x9
 #define GEN6_PCODE_DATA                         0x138128
 
diff --git a/drivers/gpu/drm/i915/i915_suspend.c b/drivers/gpu/drm/i915/i915_suspend.c
index 410772466fa..0521ecf2601 100644
--- a/drivers/gpu/drm/i915/i915_suspend.c
+++ b/drivers/gpu/drm/i915/i915_suspend.c
@@ -740,7 +740,7 @@ void i915_restore_display(struct drm_device *dev)
                 I915_WRITE(PCH_PP_OFF_DELAYS, dev_priv->savePP_OFF_DELAYS);
                 I915_WRITE(PCH_PP_DIVISOR, dev_priv->savePP_DIVISOR);
                 I915_WRITE(PCH_PP_CONTROL, dev_priv->savePP_CONTROL);
-                I915_WRITE(MCHBAR_RENDER_STANDBY,
+                I915_WRITE(RSTDBYCTL,
                            dev_priv->saveMCHBAR_RENDER_STANDBY);
         } else {
                 I915_WRITE(PFIT_PGM_RATIOS, dev_priv->savePFIT_PGM_RATIOS);
@@ -811,7 +811,7 @@ int i915_save_state(struct drm_device *dev)
                 dev_priv->saveFDI_RXA_IMR = I915_READ(FDI_RXA_IMR);
                 dev_priv->saveFDI_RXB_IMR = I915_READ(FDI_RXB_IMR);
                 dev_priv->saveMCHBAR_RENDER_STANDBY =
-                        I915_READ(MCHBAR_RENDER_STANDBY);
+                        I915_READ(RSTDBYCTL);
         } else {
                 dev_priv->saveIER = I915_READ(IER);
                 dev_priv->saveIMR = I915_READ(IMR);
@@ -822,10 +822,6 @@ int i915_save_state(struct drm_device *dev)
         if (IS_GEN6(dev))
                 gen6_disable_rps(dev);
 
-        /* XXX disabling the clock gating breaks suspend on gm45
-        intel_disable_clock_gating(dev);
-         */
-
         /* Cache mode state */
         dev_priv->saveCACHE_MODE_0 = I915_READ(CACHE_MODE_0);
 
diff --git a/drivers/gpu/drm/i915/intel_crt.c b/drivers/gpu/drm/i915/intel_crt.c
index 8df57431606..17035b87ee4 100644
--- a/drivers/gpu/drm/i915/intel_crt.c
+++ b/drivers/gpu/drm/i915/intel_crt.c
@@ -30,6 +30,7 @@
 #include "drm.h"
 #include "drm_crtc.h"
 #include "drm_crtc_helper.h"
+#include "drm_edid.h"
 #include "intel_drv.h"
 #include "i915_drm.h"
 #include "i915_drv.h"
@@ -287,8 +288,9 @@ static bool intel_crt_ddc_probe(struct drm_i915_private *dev_priv, int ddc_bus)
         return i2c_transfer(&dev_priv->gmbus[ddc_bus].adapter, msgs, 1) == 1;
 }
 
-static bool intel_crt_detect_ddc(struct intel_crt *crt)
+static bool intel_crt_detect_ddc(struct drm_connector *connector)
 {
+        struct intel_crt *crt = intel_attached_crt(connector);
         struct drm_i915_private *dev_priv = crt->base.base.dev->dev_private;
 
         /* CRT should always be at 0, but check anyway */
@@ -301,8 +303,26 @@ static bool intel_crt_detect_ddc(struct intel_crt *crt)
         }
 
         if (intel_ddc_probe(&crt->base, dev_priv->crt_ddc_pin)) {
-                DRM_DEBUG_KMS("CRT detected via DDC:0x50 [EDID]\n");
-                return true;
+                struct edid *edid;
+                bool is_digital = false;
+
+                edid = drm_get_edid(connector,
+                        &dev_priv->gmbus[dev_priv->crt_ddc_pin].adapter);
+                /*
+                 * This may be a DVI-I connector with a shared DDC
+                 * link between analog and digital outputs, so we
+                 * have to check the EDID input spec of the attached device.
+                 */
+                if (edid != NULL) {
+                        is_digital = edid->input & DRM_EDID_INPUT_DIGITAL;
+                        connector->display_info.raw_edid = NULL;
+                        kfree(edid);
+                }
+
+                if (!is_digital) {
+                        DRM_DEBUG_KMS("CRT detected via DDC:0x50 [EDID]\n");
+                        return true;
+                }
         }
 
         return false;
@@ -458,7 +478,7 @@ intel_crt_detect(struct drm_connector *connector, bool force)
                 }
         }
 
-        if (intel_crt_detect_ddc(crt))
+        if (intel_crt_detect_ddc(connector))
                 return connector_status_connected;
 
         if (!force)
@@ -472,7 +492,7 @@ intel_crt_detect(struct drm_connector *connector, bool force)
                 crtc = intel_get_load_detect_pipe(&crt->base, connector,
                                                   NULL, &dpms_mode);
                 if (crtc) {
-                        if (intel_crt_detect_ddc(crt))
+                        if (intel_crt_detect_ddc(connector))
                                 status = connector_status_connected;
                         else
                                 status = intel_crt_load_detect(crtc, crt);
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 0abe79fb638..25d96889d7d 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -3418,15 +3418,16 @@ static void i830_update_wm(struct drm_device *dev, int planea_clock, int unused,
 static bool ironlake_compute_wm0(struct drm_device *dev,
                                  int pipe,
                                  const struct intel_watermark_params *display,
-                                 int display_latency,
+                                 int display_latency_ns,
                                  const struct intel_watermark_params *cursor,
-                                 int cursor_latency,
+                                 int cursor_latency_ns,
                                  int *plane_wm,
                                  int *cursor_wm)
 {
         struct drm_crtc *crtc;
-        int htotal, hdisplay, clock, pixel_size = 0;
-        int line_time_us, line_count, entries;
+        int htotal, hdisplay, clock, pixel_size;
+        int line_time_us, line_count;
+        int entries, tlb_miss;
 
         crtc = intel_get_crtc_for_pipe(dev, pipe);
         if (crtc->fb == NULL || !crtc->enabled)
@@ -3438,7 +3439,10 @@ static bool ironlake_compute_wm0(struct drm_device *dev,
         pixel_size = crtc->fb->bits_per_pixel / 8;
 
         /* Use the small buffer method to calculate plane watermark */
-        entries = ((clock * pixel_size / 1000) * display_latency * 100) / 1000;
+        entries = ((clock * pixel_size / 1000) * display_latency_ns) / 1000;
+        tlb_miss = display->fifo_size*display->cacheline_size - hdisplay * 8;
+        if (tlb_miss > 0)
+                entries += tlb_miss;
         entries = DIV_ROUND_UP(entries, display->cacheline_size);
         *plane_wm = entries + display->guard_size;
         if (*plane_wm > (int)display->max_wm)
@@ -3446,8 +3450,11 @@ static bool ironlake_compute_wm0(struct drm_device *dev,
 
         /* Use the large buffer method to calculate cursor watermark */
         line_time_us = ((htotal * 1000) / clock);
-        line_count = (cursor_latency * 100 / line_time_us + 1000) / 1000;
+        line_count = (cursor_latency_ns / line_time_us + 1000) / 1000;
         entries = line_count * 64 * pixel_size;
+        tlb_miss = cursor->fifo_size*cursor->cacheline_size - hdisplay * 8;
+        if (tlb_miss > 0)
+                entries += tlb_miss;
         entries = DIV_ROUND_UP(entries, cursor->cacheline_size);
         *cursor_wm = entries + cursor->guard_size;
         if (*cursor_wm > (int)cursor->max_wm)
@@ -3456,113 +3463,17 @@ static bool ironlake_compute_wm0(struct drm_device *dev,
         return true;
 }
 
-static void ironlake_update_wm(struct drm_device *dev,
-                               int planea_clock, int planeb_clock,
-                               int sr_hdisplay, int sr_htotal,
-                               int pixel_size)
-{
-        struct drm_i915_private *dev_priv = dev->dev_private;
-        int plane_wm, cursor_wm, enabled;
-        int tmp;
-
-        enabled = 0;
-        if (ironlake_compute_wm0(dev, 0,
-                                 &ironlake_display_wm_info,
-                                 ILK_LP0_PLANE_LATENCY,
-                                 &ironlake_cursor_wm_info,
-                                 ILK_LP0_CURSOR_LATENCY,
-                                 &plane_wm, &cursor_wm)) {
-                I915_WRITE(WM0_PIPEA_ILK,
-                           (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm);
-                DRM_DEBUG_KMS("FIFO watermarks For pipe A -"
-                              " plane %d, " "cursor: %d\n",
-                              plane_wm, cursor_wm);
-                enabled++;
-        }
-
-        if (ironlake_compute_wm0(dev, 1,
-                                 &ironlake_display_wm_info,
-                                 ILK_LP0_PLANE_LATENCY,
-                                 &ironlake_cursor_wm_info,
-                                 ILK_LP0_CURSOR_LATENCY,
-                                 &plane_wm, &cursor_wm)) {
-                I915_WRITE(WM0_PIPEB_ILK,
-                           (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm);
-                DRM_DEBUG_KMS("FIFO watermarks For pipe B -"
-                              " plane %d, cursor: %d\n",
-                              plane_wm, cursor_wm);
-                enabled++;
-        }
-
-        /*
-         * Calculate and update the self-refresh watermark only when one
-         * display plane is used.
-         */
-        tmp = 0;
-        if (enabled == 1) {
-                unsigned long line_time_us;
-                int small, large, plane_fbc;
-                int sr_clock, entries;
-                int line_count, line_size;
-                /* Read the self-refresh latency. The unit is 0.5us */
-                int ilk_sr_latency = I915_READ(MLTR_ILK) & ILK_SRLT_MASK;
-
-                sr_clock = planea_clock ? planea_clock : planeb_clock;
-                line_time_us = (sr_htotal * 1000) / sr_clock;
-
-                /* Use ns/us then divide to preserve precision */
-                line_count = ((ilk_sr_latency * 500) / line_time_us + 1000)
-                        / 1000;
-                line_size = sr_hdisplay * pixel_size;
-
-                /* Use the minimum of the small and large buffer method for primary */
-                small = ((sr_clock * pixel_size / 1000) * (ilk_sr_latency * 500)) / 1000;
-                large = line_count * line_size;
-
-                entries = DIV_ROUND_UP(min(small, large),
-                                       ironlake_display_srwm_info.cacheline_size);
-
-                plane_fbc = entries * 64;
-                plane_fbc = DIV_ROUND_UP(plane_fbc, line_size);
-
-                plane_wm = entries + ironlake_display_srwm_info.guard_size;
-                if (plane_wm > (int)ironlake_display_srwm_info.max_wm)
-                        plane_wm = ironlake_display_srwm_info.max_wm;
-
-                /* calculate the self-refresh watermark for display cursor */
-                entries = line_count * pixel_size * 64;
-                entries = DIV_ROUND_UP(entries,
-                                       ironlake_cursor_srwm_info.cacheline_size);
-
-                cursor_wm = entries + ironlake_cursor_srwm_info.guard_size;
-                if (cursor_wm > (int)ironlake_cursor_srwm_info.max_wm)
-                        cursor_wm = ironlake_cursor_srwm_info.max_wm;
-
-                /* configure watermark and enable self-refresh */
-                tmp = (WM1_LP_SR_EN |
-                       (ilk_sr_latency << WM1_LP_LATENCY_SHIFT) |
-                       (plane_fbc << WM1_LP_FBC_SHIFT) |
-                       (plane_wm << WM1_LP_SR_SHIFT) |
-                       cursor_wm);
-                DRM_DEBUG_KMS("self-refresh watermark: display plane %d, fbc lines %d,"
-                              " cursor %d\n", plane_wm, plane_fbc, cursor_wm);
-        }
-        I915_WRITE(WM1_LP_ILK, tmp);
-        /* XXX setup WM2 and WM3 */
-}
-
 /*
  * Check the wm result.
  *
  * If any calculated watermark values is larger than the maximum value that
  * can be programmed into the associated watermark register, that watermark
  * must be disabled.
- *
- * Also return true if all of those watermark values is 0, which is set by
- * sandybridge_compute_srwm, to indicate the latency is ZERO.
  */
-static bool sandybridge_check_srwm(struct drm_device *dev, int level,
-                                   int fbc_wm, int display_wm, int cursor_wm)
+static bool ironlake_check_srwm(struct drm_device *dev, int level,
+                                int fbc_wm, int display_wm, int cursor_wm,
+                                const struct intel_watermark_params *display,
+                                const struct intel_watermark_params *cursor)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
 
@@ -3571,7 +3482,7 @@ static bool sandybridge_check_srwm(struct drm_device *dev, int level,
 
         if (fbc_wm > SNB_FBC_MAX_SRWM) {
                 DRM_DEBUG_KMS("fbc watermark(%d) is too large(%d), disabling wm%d+\n",
-                                fbc_wm, SNB_FBC_MAX_SRWM, level);
+                              fbc_wm, SNB_FBC_MAX_SRWM, level);
 
                 /* fbc has it's own way to disable FBC WM */
                 I915_WRITE(DISP_ARB_CTL,
@@ -3579,15 +3490,15 @@ static bool sandybridge_check_srwm(struct drm_device *dev, int level,
                 return false;
         }
 
-        if (display_wm > SNB_DISPLAY_MAX_SRWM) {
+        if (display_wm > display->max_wm) {
                 DRM_DEBUG_KMS("display watermark(%d) is too large(%d), disabling wm%d+\n",
-                                display_wm, SNB_DISPLAY_MAX_SRWM, level);
+                              display_wm, SNB_DISPLAY_MAX_SRWM, level);
                 return false;
         }
 
-        if (cursor_wm > SNB_CURSOR_MAX_SRWM) {
+        if (cursor_wm > cursor->max_wm) {
                 DRM_DEBUG_KMS("cursor watermark(%d) is too large(%d), disabling wm%d+\n",
-                                cursor_wm, SNB_CURSOR_MAX_SRWM, level);
+                              cursor_wm, SNB_CURSOR_MAX_SRWM, level);
                 return false;
         }
 
@@ -3602,16 +3513,18 @@ static bool sandybridge_check_srwm(struct drm_device *dev, int level,
 /*
  * Compute watermark values of WM[1-3],
  */
-static bool sandybridge_compute_srwm(struct drm_device *dev, int level,
-                                     int hdisplay, int htotal, int pixel_size,
-                                     int clock, int latency_ns, int *fbc_wm,
-                                     int *display_wm, int *cursor_wm)
+static bool ironlake_compute_srwm(struct drm_device *dev, int level,
+                                  int hdisplay, int htotal,
+                                  int pixel_size, int clock, int latency_ns,
+                                  const struct intel_watermark_params *display,
+                                  const struct intel_watermark_params *cursor,
+                                  int *fbc_wm, int *display_wm, int *cursor_wm)
 {
 
         unsigned long line_time_us;
+        int line_count, line_size;
         int small, large;
         int entries;
-        int line_count, line_size;
 
         if (!latency_ns) {
                 *fbc_wm = *display_wm = *cursor_wm = 0;
@@ -3626,24 +3539,110 @@ static bool sandybridge_compute_srwm(struct drm_device *dev, int level,
         small = ((clock * pixel_size / 1000) * latency_ns) / 1000;
         large = line_count * line_size;
 
-        entries = DIV_ROUND_UP(min(small, large),
-                                sandybridge_display_srwm_info.cacheline_size);
-        *display_wm = entries + sandybridge_display_srwm_info.guard_size;
+        entries = DIV_ROUND_UP(min(small, large), display->cacheline_size);
+        *display_wm = entries + display->guard_size;
 
         /*
-         * Spec said:
+         * Spec says:
          * FBC WM = ((Final Primary WM * 64) / number of bytes per line) + 2
          */
         *fbc_wm = DIV_ROUND_UP(*display_wm * 64, line_size) + 2;
 
         /* calculate the self-refresh watermark for display cursor */
         entries = line_count * pixel_size * 64;
-        entries = DIV_ROUND_UP(entries,
-                               sandybridge_cursor_srwm_info.cacheline_size);
-        *cursor_wm = entries + sandybridge_cursor_srwm_info.guard_size;
+        entries = DIV_ROUND_UP(entries, cursor->cacheline_size);
+        *cursor_wm = entries + cursor->guard_size;
 
-        return sandybridge_check_srwm(dev, level,
-                                      *fbc_wm, *display_wm, *cursor_wm);
+        return ironlake_check_srwm(dev, level,
+                                   *fbc_wm, *display_wm, *cursor_wm,
+                                   display, cursor);
+}
+
+static void ironlake_update_wm(struct drm_device *dev,
+                               int planea_clock, int planeb_clock,
+                               int hdisplay, int htotal,
+                               int pixel_size)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int fbc_wm, plane_wm, cursor_wm, enabled;
+        int clock;
+
+        enabled = 0;
+        if (ironlake_compute_wm0(dev, 0,
+                                 &ironlake_display_wm_info,
+                                 ILK_LP0_PLANE_LATENCY,
+                                 &ironlake_cursor_wm_info,
+                                 ILK_LP0_CURSOR_LATENCY,
+                                 &plane_wm, &cursor_wm)) {
+                I915_WRITE(WM0_PIPEA_ILK,
+                           (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm);
+                DRM_DEBUG_KMS("FIFO watermarks For pipe A -"
+                              " plane %d, " "cursor: %d\n",
+                              plane_wm, cursor_wm);
+                enabled++;
+        }
+
+        if (ironlake_compute_wm0(dev, 1,
+                                 &ironlake_display_wm_info,
+                                 ILK_LP0_PLANE_LATENCY,
+                                 &ironlake_cursor_wm_info,
+                                 ILK_LP0_CURSOR_LATENCY,
+                                 &plane_wm, &cursor_wm)) {
+                I915_WRITE(WM0_PIPEB_ILK,
+                           (plane_wm << WM0_PIPE_PLANE_SHIFT) | cursor_wm);
+                DRM_DEBUG_KMS("FIFO watermarks For pipe B -"
+                              " plane %d, cursor: %d\n",
+                              plane_wm, cursor_wm);
+                enabled++;
+        }
+
+        /*
+         * Calculate and update the self-refresh watermark only when one
+         * display plane is used.
+         */
+        I915_WRITE(WM3_LP_ILK, 0);
+        I915_WRITE(WM2_LP_ILK, 0);
+        I915_WRITE(WM1_LP_ILK, 0);
+
+        if (enabled != 1)
+                return;
+
+        clock = planea_clock ? planea_clock : planeb_clock;
+
+        /* WM1 */
+        if (!ironlake_compute_srwm(dev, 1, hdisplay, htotal, pixel_size,
+                                   clock, ILK_READ_WM1_LATENCY() * 500,
+                                   &ironlake_display_srwm_info,
+                                   &ironlake_cursor_srwm_info,
+                                   &fbc_wm, &plane_wm, &cursor_wm))
+                return;
+
+        I915_WRITE(WM1_LP_ILK,
+                   WM1_LP_SR_EN |
+                   (ILK_READ_WM1_LATENCY() << WM1_LP_LATENCY_SHIFT) |
+                   (fbc_wm << WM1_LP_FBC_SHIFT) |
+                   (plane_wm << WM1_LP_SR_SHIFT) |
+                   cursor_wm);
+
+        /* WM2 */
+        if (!ironlake_compute_srwm(dev, 2, hdisplay, htotal, pixel_size,
+                                   clock, ILK_READ_WM2_LATENCY() * 500,
+                                   &ironlake_display_srwm_info,
+                                   &ironlake_cursor_srwm_info,
+                                   &fbc_wm, &plane_wm, &cursor_wm))
+                return;
+
+        I915_WRITE(WM2_LP_ILK,
+                   WM2_LP_EN |
+                   (ILK_READ_WM2_LATENCY() << WM1_LP_LATENCY_SHIFT) |
+                   (fbc_wm << WM1_LP_FBC_SHIFT) |
+                   (plane_wm << WM1_LP_SR_SHIFT) |
+                   cursor_wm);
+
+        /*
+         * WM3 is unsupported on ILK, probably because we don't have latency
+         * data for that power state
+         */
 }
 
 static void sandybridge_update_wm(struct drm_device *dev,
@@ -3652,7 +3651,7 @@ static void sandybridge_update_wm(struct drm_device *dev,
                                int pixel_size)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        int latency = SNB_READ_WM0_LATENCY();
+        int latency = SNB_READ_WM0_LATENCY() * 100;     /* In unit 0.1us */
         int fbc_wm, plane_wm, cursor_wm, enabled;
         int clock;
 
@@ -3701,9 +3700,11 @@ static void sandybridge_update_wm(struct drm_device *dev,
         clock = planea_clock ? planea_clock : planeb_clock;
 
         /* WM1 */
-        if (!sandybridge_compute_srwm(dev, 1, hdisplay, htotal, pixel_size,
-                                      clock, SNB_READ_WM1_LATENCY() * 500,
-                                      &fbc_wm, &plane_wm, &cursor_wm))
+        if (!ironlake_compute_srwm(dev, 1, hdisplay, htotal, pixel_size,
+                                   clock, SNB_READ_WM1_LATENCY() * 500,
+                                   &sandybridge_display_srwm_info,
+                                   &sandybridge_cursor_srwm_info,
+                                   &fbc_wm, &plane_wm, &cursor_wm))
                 return;
 
         I915_WRITE(WM1_LP_ILK,
@@ -3714,10 +3715,12 @@ static void sandybridge_update_wm(struct drm_device *dev,
                    cursor_wm);
 
         /* WM2 */
-        if (!sandybridge_compute_srwm(dev, 2,
-                                      hdisplay, htotal, pixel_size,
-                                      clock, SNB_READ_WM2_LATENCY() * 500,
-                                      &fbc_wm, &plane_wm, &cursor_wm))
+        if (!ironlake_compute_srwm(dev, 2,
+                                   hdisplay, htotal, pixel_size,
+                                   clock, SNB_READ_WM2_LATENCY() * 500,
+                                   &sandybridge_display_srwm_info,
+                                   &sandybridge_cursor_srwm_info,
+                                   &fbc_wm, &plane_wm, &cursor_wm))
                 return;
 
         I915_WRITE(WM2_LP_ILK,
@@ -3728,10 +3731,12 @@ static void sandybridge_update_wm(struct drm_device *dev,
                    cursor_wm);
 
         /* WM3 */
-        if (!sandybridge_compute_srwm(dev, 3,
-                                      hdisplay, htotal, pixel_size,
-                                      clock, SNB_READ_WM3_LATENCY() * 500,
-                                      &fbc_wm, &plane_wm, &cursor_wm))
+        if (!ironlake_compute_srwm(dev, 3,
+                                   hdisplay, htotal, pixel_size,
+                                   clock, SNB_READ_WM3_LATENCY() * 500,
+                                   &sandybridge_display_srwm_info,
+                                   &sandybridge_cursor_srwm_info,
+                                   &fbc_wm, &plane_wm, &cursor_wm))
                 return;
 
         I915_WRITE(WM3_LP_ILK,
@@ -3951,7 +3956,7 @@ static int intel_crtc_mode_set(struct drm_crtc *crtc,
                 int lane = 0, link_bw, bpp;
                 /* CPU eDP doesn't require FDI link, so just set DP M/N
                    according to current link config */
-                if (has_edp_encoder && !intel_encoder_is_pch_edp(&encoder->base)) {
+                if (has_edp_encoder && !intel_encoder_is_pch_edp(&has_edp_encoder->base)) {
                         target_clock = mode->clock;
                         intel_edp_link_config(has_edp_encoder,
                                               &lane, &link_bw);
@@ -5038,8 +5043,8 @@ static void intel_increase_pllclock(struct drm_crtc *crtc)
         drm_i915_private_t *dev_priv = dev->dev_private;
         struct intel_crtc *intel_crtc = to_intel_crtc(crtc);
         int pipe = intel_crtc->pipe;
-        int dpll_reg = (pipe == 0) ? DPLL_A : DPLL_B;
-        int dpll = I915_READ(dpll_reg);
+        int dpll_reg = DPLL(pipe);
+        int dpll;
 
         if (HAS_PCH_SPLIT(dev))
                 return;
@@ -5047,17 +5052,19 @@ static void intel_increase_pllclock(struct drm_crtc *crtc)
         if (!dev_priv->lvds_downclock_avail)
                 return;
 
+        dpll = I915_READ(dpll_reg);
         if (!HAS_PIPE_CXSR(dev) && (dpll & DISPLAY_RATE_SELECT_FPA1)) {
                 DRM_DEBUG_DRIVER("upclocking LVDS\n");
 
                 /* Unlock panel regs */
-                I915_WRITE(PP_CONTROL, I915_READ(PP_CONTROL) |
-                           PANEL_UNLOCK_REGS);
+                I915_WRITE(PP_CONTROL,
+                           I915_READ(PP_CONTROL) | PANEL_UNLOCK_REGS);
 
                 dpll &= ~DISPLAY_RATE_SELECT_FPA1;
                 I915_WRITE(dpll_reg, dpll);
-                dpll = I915_READ(dpll_reg);
+                POSTING_READ(dpll_reg);
                 intel_wait_for_vblank(dev, pipe);
+
                 dpll = I915_READ(dpll_reg);
                 if (dpll & DISPLAY_RATE_SELECT_FPA1)
                         DRM_DEBUG_DRIVER("failed to upclock LVDS!\n");
@@ -5802,6 +5809,8 @@ static void intel_setup_outputs(struct drm_device *dev)
                 encoder->base.possible_clones =
                         intel_encoder_clones(dev, encoder->clone_mask);
         }
+
+        intel_panel_setup_backlight(dev);
 }
 
 static void intel_user_framebuffer_destroy(struct drm_framebuffer *fb)
@@ -6145,6 +6154,10 @@ void intel_init_emon(struct drm_device *dev)
 
 void gen6_enable_rps(struct drm_i915_private *dev_priv)
 {
+        u32 rp_state_cap = I915_READ(GEN6_RP_STATE_CAP);
+        u32 gt_perf_status = I915_READ(GEN6_GT_PERF_STATUS);
+        u32 pcu_mbox;
+        int cur_freq, min_freq, max_freq;
         int i;
 
         /* Here begins a magic sequence of register writes to enable
@@ -6216,6 +6229,29 @@ void gen6_enable_rps(struct drm_i915_private *dev_priv)
                      500))
                 DRM_ERROR("timeout waiting for pcode mailbox to finish\n");
 
+        min_freq = (rp_state_cap & 0xff0000) >> 16;
+        max_freq = rp_state_cap & 0xff;
+        cur_freq = (gt_perf_status & 0xff00) >> 8;
+
+        /* Check for overclock support */
+        if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
+                     500))
+                DRM_ERROR("timeout waiting for pcode mailbox to become idle\n");
+        I915_WRITE(GEN6_PCODE_MAILBOX, GEN6_READ_OC_PARAMS);
+        pcu_mbox = I915_READ(GEN6_PCODE_DATA);
+        if (wait_for((I915_READ(GEN6_PCODE_MAILBOX) & GEN6_PCODE_READY) == 0,
+                     500))
+                DRM_ERROR("timeout waiting for pcode mailbox to finish\n");
+        if (pcu_mbox & (1<<31)) { /* OC supported */
+                max_freq = pcu_mbox & 0xff;
+                DRM_DEBUG_DRIVER("overclocking supported, adjusting frequency max to %dMHz\n", pcu_mbox * 100);
+        }
+
+        /* In units of 100MHz */
+        dev_priv->max_delay = max_freq;
+        dev_priv->min_delay = min_freq;
+        dev_priv->cur_delay = cur_freq;
+
         /* requires MSI enabled */
         I915_WRITE(GEN6_PMIER,
                    GEN6_PM_MBOX_EVENT |
@@ -6386,42 +6422,6 @@ void intel_enable_clock_gating(struct drm_device *dev)
         } else if (IS_I830(dev)) {
                 I915_WRITE(DSPCLK_GATE_D, OVRUNIT_CLOCK_GATE_DISABLE);
         }
-
-        /*
-         * GPU can automatically power down the render unit if given a page
-         * to save state.
-         */
-        if (IS_IRONLAKE_M(dev) && 0) { /* XXX causes a failure during suspend */
-                if (dev_priv->renderctx == NULL)
-                        dev_priv->renderctx = intel_alloc_context_page(dev);
-                if (dev_priv->renderctx) {
-                        struct drm_i915_gem_object *obj = dev_priv->renderctx;
-                        if (BEGIN_LP_RING(4) == 0) {
-                                OUT_RING(MI_SET_CONTEXT);
-                                OUT_RING(obj->gtt_offset |
-                                         MI_MM_SPACE_GTT |
-                                         MI_SAVE_EXT_STATE_EN |
-                                         MI_RESTORE_EXT_STATE_EN |
-                                         MI_RESTORE_INHIBIT);
-                                OUT_RING(MI_NOOP);
-                                OUT_RING(MI_FLUSH);
-                                ADVANCE_LP_RING();
-                        }
-                } else
-                        DRM_DEBUG_KMS("Failed to allocate render context."
-                                       "Disable RC6\n");
-        }
-
-        if (IS_GEN4(dev) && IS_MOBILE(dev)) {
-                if (dev_priv->pwrctx == NULL)
-                        dev_priv->pwrctx = intel_alloc_context_page(dev);
-                if (dev_priv->pwrctx) {
-                        struct drm_i915_gem_object *obj = dev_priv->pwrctx;
-                        I915_WRITE(PWRCTXA, obj->gtt_offset | PWRCTX_EN);
-                        I915_WRITE(MCHBAR_RENDER_STANDBY,
-                                   I915_READ(MCHBAR_RENDER_STANDBY) & ~RCX_SW_EXIT);
-                }
-        }
 }
 
 void intel_disable_clock_gating(struct drm_device *dev)
@@ -6451,6 +6451,57 @@ void intel_disable_clock_gating(struct drm_device *dev)
         }
 }
 
+static void ironlake_disable_rc6(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        /* Wake the GPU, prevent RC6, then restore RSTDBYCTL */
+        I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) | RCX_SW_EXIT);
+        wait_for(((I915_READ(RSTDBYCTL) & RSX_STATUS_MASK) == RSX_STATUS_ON),
+                 10);
+        POSTING_READ(CCID);
+        I915_WRITE(PWRCTXA, 0);
+        POSTING_READ(PWRCTXA);
+        I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT);
+        POSTING_READ(RSTDBYCTL);
+        i915_gem_object_unpin(dev_priv->renderctx);
+        drm_gem_object_unreference(&dev_priv->renderctx->base);
+        dev_priv->renderctx = NULL;
+        i915_gem_object_unpin(dev_priv->pwrctx);
+        drm_gem_object_unreference(&dev_priv->pwrctx->base);
+        dev_priv->pwrctx = NULL;
+}
+
+void ironlake_enable_rc6(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+        int ret;
+
+        /*
+         * GPU can automatically power down the render unit if given a page
+         * to save state.
+         */
+        ret = BEGIN_LP_RING(6);
+        if (ret) {
+                ironlake_disable_rc6(dev);
+                return;
+        }
+        OUT_RING(MI_SUSPEND_FLUSH | MI_SUSPEND_FLUSH_EN);
+        OUT_RING(MI_SET_CONTEXT);
+        OUT_RING(dev_priv->renderctx->gtt_offset |
+                 MI_MM_SPACE_GTT |
+                 MI_SAVE_EXT_STATE_EN |
+                 MI_RESTORE_EXT_STATE_EN |
+                 MI_RESTORE_INHIBIT);
+        OUT_RING(MI_SUSPEND_FLUSH);
+        OUT_RING(MI_NOOP);
+        OUT_RING(MI_FLUSH);
+        ADVANCE_LP_RING();
+
+        I915_WRITE(PWRCTXA, dev_priv->pwrctx->gtt_offset | PWRCTX_EN);
+        I915_WRITE(RSTDBYCTL, I915_READ(RSTDBYCTL) & ~RCX_SW_EXIT);
+}
+
 /* Set up chip specific display functions */
 static void intel_init_display(struct drm_device *dev)
 {
@@ -6665,12 +6716,7 @@ void intel_modeset_init(struct drm_device *dev)
                 dev->mode_config.max_width = 8192;
                 dev->mode_config.max_height = 8192;
         }
-
-        /* set memory base */
-        if (IS_GEN2(dev))
-                dev->mode_config.fb_base = pci_resource_start(dev->pdev, 0);
-        else
-                dev->mode_config.fb_base = pci_resource_start(dev->pdev, 2);
+        dev->mode_config.fb_base = dev->agp->base;
 
         if (IS_MOBILE(dev) || !IS_GEN2(dev))
                 dev_priv->num_pipe = 2;
@@ -6698,6 +6744,21 @@ void intel_modeset_init(struct drm_device *dev)
         if (IS_GEN6(dev))
                 gen6_enable_rps(dev_priv);
 
+        if (IS_IRONLAKE_M(dev)) {
+                dev_priv->renderctx = intel_alloc_context_page(dev);
+                if (!dev_priv->renderctx)
+                        goto skip_rc6;
+                dev_priv->pwrctx = intel_alloc_context_page(dev);
+                if (!dev_priv->pwrctx) {
+                        i915_gem_object_unpin(dev_priv->renderctx);
+                        drm_gem_object_unreference(&dev_priv->renderctx->base);
+                        dev_priv->renderctx = NULL;
+                        goto skip_rc6;
+                }
+                ironlake_enable_rc6(dev);
+        }
+
+skip_rc6:
         INIT_WORK(&dev_priv->idle_work, intel_idle_update);
         setup_timer(&dev_priv->idle_timer, intel_gpu_idle_timer,
                     (unsigned long)dev);
@@ -6734,7 +6795,8 @@ void intel_modeset_cleanup(struct drm_device *dev)
         if (IS_GEN6(dev))
                 gen6_disable_rps(dev);
 
-        intel_disable_clock_gating(dev);
+        if (IS_IRONLAKE_M(dev))
+                ironlake_disable_rc6(dev);
 
         mutex_unlock(&dev->struct_mutex);
 
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index 1dc60408d5b..1f4242b682c 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -1153,18 +1153,27 @@ intel_dp_signal_levels(uint8_t train_set, int lane_count)
 static uint32_t
 intel_gen6_edp_signal_levels(uint8_t train_set)
 {
-        switch (train_set & (DP_TRAIN_VOLTAGE_SWING_MASK|DP_TRAIN_PRE_EMPHASIS_MASK)) {
+        int signal_levels = train_set & (DP_TRAIN_VOLTAGE_SWING_MASK |
+                                         DP_TRAIN_PRE_EMPHASIS_MASK);
+        switch (signal_levels) {
         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_0:
-                return EDP_LINK_TRAIN_400MV_0DB_SNB_B;
+        case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_0:
+                return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
+        case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_3_5:
+                return EDP_LINK_TRAIN_400MV_3_5DB_SNB_B;
         case DP_TRAIN_VOLTAGE_SWING_400 | DP_TRAIN_PRE_EMPHASIS_6:
-                return EDP_LINK_TRAIN_400MV_6DB_SNB_B;
+        case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_6:
+                return EDP_LINK_TRAIN_400_600MV_6DB_SNB_B;
         case DP_TRAIN_VOLTAGE_SWING_600 | DP_TRAIN_PRE_EMPHASIS_3_5:
-                return EDP_LINK_TRAIN_600MV_3_5DB_SNB_B;
+        case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_3_5:
+                return EDP_LINK_TRAIN_600_800MV_3_5DB_SNB_B;
         case DP_TRAIN_VOLTAGE_SWING_800 | DP_TRAIN_PRE_EMPHASIS_0:
-                return EDP_LINK_TRAIN_800MV_0DB_SNB_B;
+        case DP_TRAIN_VOLTAGE_SWING_1200 | DP_TRAIN_PRE_EMPHASIS_0:
+                return EDP_LINK_TRAIN_800_1200MV_0DB_SNB_B;
         default:
-                DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level\n");
-                return EDP_LINK_TRAIN_400MV_0DB_SNB_B;
+                DRM_DEBUG_KMS("Unsupported voltage swing/pre-emphasis level:"
+                              "0x%x\n", signal_levels);
+                return EDP_LINK_TRAIN_400_600MV_0DB_SNB_B;
         }
 }
 
@@ -1334,17 +1343,24 @@ intel_dp_complete_link_train(struct intel_dp *intel_dp)
         struct drm_device *dev = intel_dp->base.base.dev;
         struct drm_i915_private *dev_priv = dev->dev_private;
         bool channel_eq = false;
-        int tries;
+        int tries, cr_tries;
         u32 reg;
         uint32_t DP = intel_dp->DP;
 
         /* channel equalization */
         tries = 0;
+        cr_tries = 0;
         channel_eq = false;
         for (;;) {
                 /* Use intel_dp->train_set[0] to set the voltage and pre emphasis values */
                 uint32_t    signal_levels;
 
+                if (cr_tries > 5) {
+                        DRM_ERROR("failed to train DP, aborting\n");
+                        intel_dp_link_down(intel_dp);
+                        break;
+                }
+
                 if (IS_GEN6(dev) && is_edp(intel_dp)) {
                         signal_levels = intel_gen6_edp_signal_levels(intel_dp->train_set[0]);
                         DP = (DP & ~EDP_LINK_TRAIN_VOL_EMP_MASK_SNB) | signal_levels;
@@ -1367,14 +1383,26 @@ intel_dp_complete_link_train(struct intel_dp *intel_dp)
                 if (!intel_dp_get_link_status(intel_dp))
                         break;
 
+                /* Make sure clock is still ok */
+                if (!intel_clock_recovery_ok(intel_dp->link_status, intel_dp->lane_count)) {
+                        intel_dp_start_link_train(intel_dp);
+                        cr_tries++;
+                        continue;
+                }
+
                 if (intel_channel_eq_ok(intel_dp)) {
                         channel_eq = true;
                         break;
                 }
 
-                /* Try 5 times */
-                if (tries > 5)
-                        break;
+                /* Try 5 times, then try clock recovery if that fails */
+                if (tries > 5) {
+                        intel_dp_link_down(intel_dp);
+                        intel_dp_start_link_train(intel_dp);
+                        tries = 0;
+                        cr_tries++;
+                        continue;
+                }
 
                 /* Compute new intel_dp->train_set as requested by target */
                 intel_get_adjust_train(intel_dp);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index d782ad9fd6d..74db2557d64 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -257,6 +257,9 @@ extern void intel_pch_panel_fitting(struct drm_device *dev,
 extern u32 intel_panel_get_max_backlight(struct drm_device *dev);
 extern u32 intel_panel_get_backlight(struct drm_device *dev);
 extern void intel_panel_set_backlight(struct drm_device *dev, u32 level);
+extern void intel_panel_setup_backlight(struct drm_device *dev);
+extern void intel_panel_enable_backlight(struct drm_device *dev);
+extern void intel_panel_disable_backlight(struct drm_device *dev);
 
 extern void intel_crtc_load_lut(struct drm_crtc *crtc);
 extern void intel_encoder_prepare (struct drm_encoder *encoder);
diff --git a/drivers/gpu/drm/i915/intel_fb.c b/drivers/gpu/drm/i915/intel_fb.c
index 701e830d001..ee145a25728 100644
--- a/drivers/gpu/drm/i915/intel_fb.c
+++ b/drivers/gpu/drm/i915/intel_fb.c
@@ -62,6 +62,7 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
                           struct drm_fb_helper_surface_size *sizes)
 {
         struct drm_device *dev = ifbdev->helper.dev;
+        struct drm_i915_private *dev_priv = dev->dev_private;
         struct fb_info *info;
         struct drm_framebuffer *fb;
         struct drm_mode_fb_cmd mode_cmd;
@@ -77,7 +78,7 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
         mode_cmd.height = sizes->surface_height;
 
         mode_cmd.bpp = sizes->surface_bpp;
-        mode_cmd.pitch = ALIGN(mode_cmd.width * ((mode_cmd.bpp + 1) / 8), 64);
+        mode_cmd.pitch = ALIGN(mode_cmd.width * ((mode_cmd.bpp + 7) / 8), 64);
         mode_cmd.depth = sizes->surface_depth;
 
         size = mode_cmd.pitch * mode_cmd.height;
@@ -120,6 +121,11 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
         info->flags = FBINFO_DEFAULT | FBINFO_CAN_FORCE_OUTPUT;
         info->fbops = &intelfb_ops;
 
+        ret = fb_alloc_cmap(&info->cmap, 256, 0);
+        if (ret) {
+                ret = -ENOMEM;
+                goto out_unpin;
+        }
         /* setup aperture base/size for vesafb takeover */
         info->apertures = alloc_apertures(1);
         if (!info->apertures) {
@@ -127,10 +133,8 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
                 goto out_unpin;
         }
         info->apertures->ranges[0].base = dev->mode_config.fb_base;
-        if (!IS_GEN2(dev))
-                info->apertures->ranges[0].size = pci_resource_len(dev->pdev, 2);
-        else
-                info->apertures->ranges[0].size = pci_resource_len(dev->pdev, 0);
+        info->apertures->ranges[0].size =
+                dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
 
         info->fix.smem_start = dev->mode_config.fb_base + obj->gtt_offset;
         info->fix.smem_len = size;
@@ -140,12 +144,6 @@ static int intelfb_create(struct intel_fbdev *ifbdev,
                 ret = -ENOSPC;
                 goto out_unpin;
         }
-
-        ret = fb_alloc_cmap(&info->cmap, 256, 0);
-        if (ret) {
-                ret = -ENOMEM;
-                goto out_unpin;
-        }
         info->screen_size = size;
 
 //      memset(info->screen_base, 0, size);
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index aa2307080be..8f4f6bd33ee 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -106,7 +106,7 @@ static void intel_lvds_enable(struct intel_lvds *intel_lvds)
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) | POWER_TARGET_ON);
         POSTING_READ(lvds_reg);
 
-        intel_panel_set_backlight(dev, dev_priv->backlight_level);
+        intel_panel_enable_backlight(dev);
 }
 
 static void intel_lvds_disable(struct intel_lvds *intel_lvds)
@@ -123,8 +123,7 @@ static void intel_lvds_disable(struct intel_lvds *intel_lvds)
                 lvds_reg = LVDS;
         }
 
-        dev_priv->backlight_level = intel_panel_get_backlight(dev);
-        intel_panel_set_backlight(dev, 0);
+        intel_panel_disable_backlight(dev);
 
         I915_WRITE(ctl_reg, I915_READ(ctl_reg) & ~POWER_TARGET_ON);
 
@@ -375,6 +374,10 @@ static bool intel_lvds_mode_fixup(struct drm_encoder *encoder,
         }
 
 out:
+        if ((pfit_control & PFIT_ENABLE) == 0) {
+                pfit_control = 0;
+                pfit_pgm_ratios = 0;
+        }
         if (pfit_control != intel_lvds->pfit_control ||
             pfit_pgm_ratios != intel_lvds->pfit_pgm_ratios) {
                 intel_lvds->pfit_control = pfit_control;
@@ -398,8 +401,6 @@ static void intel_lvds_prepare(struct drm_encoder *encoder)
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        dev_priv->backlight_level = intel_panel_get_backlight(dev);
-
         /* We try to do the minimum that is necessary in order to unlock
          * the registers for mode setting.
          *
@@ -430,9 +431,6 @@ static void intel_lvds_commit(struct drm_encoder *encoder)
         struct drm_i915_private *dev_priv = dev->dev_private;
         struct intel_lvds *intel_lvds = to_intel_lvds(encoder);
 
-        if (dev_priv->backlight_level == 0)
-                dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
-
         /* Undo any unlocking done in prepare to prevent accidental
          * adjustment of the registers.
          */
diff --git a/drivers/gpu/drm/i915/intel_panel.c b/drivers/gpu/drm/i915/intel_panel.c
index 7350ec2515c..e00d200df3d 100644
--- a/drivers/gpu/drm/i915/intel_panel.c
+++ b/drivers/gpu/drm/i915/intel_panel.c
@@ -250,3 +250,34 @@ void intel_panel_set_backlight(struct drm_device *dev, u32 level)
                 tmp &= ~BACKLIGHT_DUTY_CYCLE_MASK;
         I915_WRITE(BLC_PWM_CTL, tmp | level);
 }
+
+void intel_panel_disable_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        if (dev_priv->backlight_enabled) {
+                dev_priv->backlight_level = intel_panel_get_backlight(dev);
+                dev_priv->backlight_enabled = false;
+        }
+
+        intel_panel_set_backlight(dev, 0);
+}
+
+void intel_panel_enable_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        if (dev_priv->backlight_level == 0)
+                dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
+
+        intel_panel_set_backlight(dev, dev_priv->backlight_level);
+        dev_priv->backlight_enabled = true;
+}
+
+void intel_panel_setup_backlight(struct drm_device *dev)
+{
+        struct drm_i915_private *dev_priv = dev->dev_private;
+
+        dev_priv->backlight_level = intel_panel_get_max_backlight(dev);
+        dev_priv->backlight_enabled = dev_priv->backlight_level != 0;
+}
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index 56bc95c056d..03e33707251 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -48,7 +48,7 @@ static u32 i915_gem_get_seqno(struct drm_device *dev)
         return seqno;
 }
 
-static void
+static int
 render_ring_flush(struct intel_ring_buffer *ring,
                   u32   invalidate_domains,
                   u32   flush_domains)
@@ -56,6 +56,7 @@ render_ring_flush(struct intel_ring_buffer *ring,
         struct drm_device *dev = ring->dev;
         drm_i915_private_t *dev_priv = dev->dev_private;
         u32 cmd;
+        int ret;
 
 #if WATCH_EXEC
         DRM_INFO("%s: invalidate %08x flush %08x\n", __func__,
@@ -116,12 +117,16 @@ render_ring_flush(struct intel_ring_buffer *ring,
 #if WATCH_EXEC
                 DRM_INFO("%s: queue flush %08x to ring\n", __func__, cmd);
 #endif
-                if (intel_ring_begin(ring, 2) == 0) {
-                        intel_ring_emit(ring, cmd);
-                        intel_ring_emit(ring, MI_NOOP);
-                        intel_ring_advance(ring);
-                }
+                ret = intel_ring_begin(ring, 2);
+                if (ret)
+                        return ret;
+
+                intel_ring_emit(ring, cmd);
+                intel_ring_emit(ring, MI_NOOP);
+                intel_ring_advance(ring);
         }
+
+        return 0;
 }
 
 static void ring_write_tail(struct intel_ring_buffer *ring,
@@ -480,26 +485,56 @@ pc_render_get_seqno(struct intel_ring_buffer *ring)
         return pc->cpu_page[0];
 }
 
+static void
+ironlake_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
+{
+        dev_priv->gt_irq_mask &= ~mask;
+        I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
+        POSTING_READ(GTIMR);
+}
+
+static void
+ironlake_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
+{
+        dev_priv->gt_irq_mask |= mask;
+        I915_WRITE(GTIMR, dev_priv->gt_irq_mask);
+        POSTING_READ(GTIMR);
+}
+
+static void
+i915_enable_irq(drm_i915_private_t *dev_priv, u32 mask)
+{
+        dev_priv->irq_mask &= ~mask;
+        I915_WRITE(IMR, dev_priv->irq_mask);
+        POSTING_READ(IMR);
+}
+
+static void
+i915_disable_irq(drm_i915_private_t *dev_priv, u32 mask)
+{
+        dev_priv->irq_mask |= mask;
+        I915_WRITE(IMR, dev_priv->irq_mask);
+        POSTING_READ(IMR);
+}
+
 static bool
 render_ring_get_irq(struct intel_ring_buffer *ring)
 {
         struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
 
         if (!dev->irq_enabled)
                 return false;
 
-        if (atomic_inc_return(&ring->irq_refcount) == 1) {
-                drm_i915_private_t *dev_priv = dev->dev_private;
-                unsigned long irqflags;
-
-                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
+        spin_lock(&ring->irq_lock);
+        if (ring->irq_refcount++ == 0) {
                 if (HAS_PCH_SPLIT(dev))
-                        ironlake_enable_graphics_irq(dev_priv,
-                                                     GT_PIPE_NOTIFY | GT_USER_INTERRUPT);
+                        ironlake_enable_irq(dev_priv,
+                                            GT_PIPE_NOTIFY | GT_USER_INTERRUPT);
                 else
                         i915_enable_irq(dev_priv, I915_USER_INTERRUPT);
-                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
         }
+        spin_unlock(&ring->irq_lock);
 
         return true;
 }
@@ -508,20 +543,18 @@ static void
 render_ring_put_irq(struct intel_ring_buffer *ring)
 {
         struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
 
-        if (atomic_dec_and_test(&ring->irq_refcount)) {
-                drm_i915_private_t *dev_priv = dev->dev_private;
-                unsigned long irqflags;
-
-                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
+        spin_lock(&ring->irq_lock);
+        if (--ring->irq_refcount == 0) {
                 if (HAS_PCH_SPLIT(dev))
-                        ironlake_disable_graphics_irq(dev_priv,
-                                                      GT_USER_INTERRUPT |
-                                                      GT_PIPE_NOTIFY);
+                        ironlake_disable_irq(dev_priv,
+                                             GT_USER_INTERRUPT |
+                                             GT_PIPE_NOTIFY);
                 else
                         i915_disable_irq(dev_priv, I915_USER_INTERRUPT);
-                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
         }
+        spin_unlock(&ring->irq_lock);
 }
 
 void intel_ring_setup_status_page(struct intel_ring_buffer *ring)
@@ -534,19 +567,24 @@ void intel_ring_setup_status_page(struct intel_ring_buffer *ring)
         POSTING_READ(mmio);
 }
 
-static void
+static int
 bsd_ring_flush(struct intel_ring_buffer *ring,
                u32     invalidate_domains,
                u32     flush_domains)
 {
+        int ret;
+
         if ((flush_domains & I915_GEM_DOMAIN_RENDER) == 0)
-                return;
+                return 0;
 
-        if (intel_ring_begin(ring, 2) == 0) {
-                intel_ring_emit(ring, MI_FLUSH);
-                intel_ring_emit(ring, MI_NOOP);
-                intel_ring_advance(ring);
-        }
+        ret = intel_ring_begin(ring, 2);
+        if (ret)
+                return ret;
+
+        intel_ring_emit(ring, MI_FLUSH);
+        intel_ring_emit(ring, MI_NOOP);
+        intel_ring_advance(ring);
+        return 0;
 }
 
 static int
@@ -577,18 +615,15 @@ static bool
 ring_get_irq(struct intel_ring_buffer *ring, u32 flag)
 {
         struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
 
         if (!dev->irq_enabled)
                return false;
 
-        if (atomic_inc_return(&ring->irq_refcount) == 1) {
-                drm_i915_private_t *dev_priv = dev->dev_private;
-                unsigned long irqflags;
-
-                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
-                ironlake_enable_graphics_irq(dev_priv, flag);
-                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
-        }
+        spin_lock(&ring->irq_lock);
+        if (ring->irq_refcount++ == 0)
+                ironlake_enable_irq(dev_priv, flag);
+        spin_unlock(&ring->irq_lock);
 
         return true;
 }
@@ -597,15 +632,47 @@ static void
 ring_put_irq(struct intel_ring_buffer *ring, u32 flag)
 {
         struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
 
-        if (atomic_dec_and_test(&ring->irq_refcount)) {
-                drm_i915_private_t *dev_priv = dev->dev_private;
-                unsigned long irqflags;
+        spin_lock(&ring->irq_lock);
+        if (--ring->irq_refcount == 0)
+                ironlake_disable_irq(dev_priv, flag);
+        spin_unlock(&ring->irq_lock);
+}
 
-                spin_lock_irqsave(&dev_priv->irq_lock, irqflags);
-                ironlake_disable_graphics_irq(dev_priv, flag);
-                spin_unlock_irqrestore(&dev_priv->irq_lock, irqflags);
+static bool
+gen6_ring_get_irq(struct intel_ring_buffer *ring, u32 gflag, u32 rflag)
+{
+        struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+
+        if (!dev->irq_enabled)
+               return false;
+
+        spin_lock(&ring->irq_lock);
+        if (ring->irq_refcount++ == 0) {
+                ring->irq_mask &= ~rflag;
+                I915_WRITE_IMR(ring, ring->irq_mask);
+                ironlake_enable_irq(dev_priv, gflag);
         }
+        spin_unlock(&ring->irq_lock);
+
+        return true;
+}
+
+static void
+gen6_ring_put_irq(struct intel_ring_buffer *ring, u32 gflag, u32 rflag)
+{
+        struct drm_device *dev = ring->dev;
+        drm_i915_private_t *dev_priv = dev->dev_private;
+
+        spin_lock(&ring->irq_lock);
+        if (--ring->irq_refcount == 0) {
+                ring->irq_mask |= rflag;
+                I915_WRITE_IMR(ring, ring->irq_mask);
+                ironlake_disable_irq(dev_priv, gflag);
+        }
+        spin_unlock(&ring->irq_lock);
 }
 
 static bool
@@ -748,6 +815,9 @@ int intel_init_ring_buffer(struct drm_device *dev,
         INIT_LIST_HEAD(&ring->request_list);
         INIT_LIST_HEAD(&ring->gpu_write_list);
 
+        spin_lock_init(&ring->irq_lock);
+        ring->irq_mask = ~0;
+
         if (I915_NEED_GFX_HWS(dev)) {
                 ret = init_status_page(ring);
                 if (ret)
@@ -785,6 +855,14 @@ int intel_init_ring_buffer(struct drm_device *dev,
         if (ret)
                 goto err_unmap;
 
+        /* Workaround an erratum on the i830 which causes a hang if
+         * the TAIL pointer points to within the last 2 cachelines
+         * of the buffer.
+         */
+        ring->effective_size = ring->size;
+        if (IS_I830(ring->dev))
+                ring->effective_size -= 128;
+
         return 0;
 
 err_unmap:
@@ -827,8 +905,7 @@ void intel_cleanup_ring_buffer(struct intel_ring_buffer *ring)
 static int intel_wrap_ring_buffer(struct intel_ring_buffer *ring)
 {
         unsigned int *virt;
-        int rem;
-        rem = ring->size - ring->tail;
+        int rem = ring->size - ring->tail;
 
         if (ring->space < rem) {
                 int ret = intel_wait_ring_buffer(ring, rem);
@@ -895,7 +972,7 @@ int intel_ring_begin(struct intel_ring_buffer *ring,
         int n = 4*num_dwords;
         int ret;
 
-        if (unlikely(ring->tail + n > ring->size)) {
+        if (unlikely(ring->tail + n > ring->effective_size)) {
                 ret = intel_wrap_ring_buffer(ring);
                 if (unlikely(ret))
                         return ret;
@@ -973,20 +1050,25 @@ static void gen6_bsd_ring_write_tail(struct intel_ring_buffer *ring,
                GEN6_BSD_SLEEP_PSMI_CONTROL_RC_ILDL_MESSAGE_ENABLE);
 }
 
-static void gen6_ring_flush(struct intel_ring_buffer *ring,
-                            u32 invalidate_domains,
-                            u32 flush_domains)
+static int gen6_ring_flush(struct intel_ring_buffer *ring,
+                           u32 invalidate_domains,
+                           u32 flush_domains)
 {
+        int ret;
+
         if ((flush_domains & I915_GEM_DOMAIN_RENDER) == 0)
-                return;
+                return 0;
 
-        if (intel_ring_begin(ring, 4) == 0) {
-                intel_ring_emit(ring, MI_FLUSH_DW);
-                intel_ring_emit(ring, 0);
-                intel_ring_emit(ring, 0);
-                intel_ring_emit(ring, 0);
-                intel_ring_advance(ring);
-        }
+        ret = intel_ring_begin(ring, 4);
+        if (ret)
+                return ret;
+
+        intel_ring_emit(ring, MI_FLUSH_DW);
+        intel_ring_emit(ring, 0);
+        intel_ring_emit(ring, 0);
+        intel_ring_emit(ring, 0);
+        intel_ring_advance(ring);
+        return 0;
 }
 
 static int
@@ -1008,15 +1090,35 @@ gen6_ring_dispatch_execbuffer(struct intel_ring_buffer *ring,
 }
 
 static bool
+gen6_render_ring_get_irq(struct intel_ring_buffer *ring)
+{
+        return gen6_ring_get_irq(ring,
+                                 GT_USER_INTERRUPT,
+                                 GEN6_RENDER_USER_INTERRUPT);
+}
+
+static void
+gen6_render_ring_put_irq(struct intel_ring_buffer *ring)
+{
+        return gen6_ring_put_irq(ring,
+                                 GT_USER_INTERRUPT,
+                                 GEN6_RENDER_USER_INTERRUPT);
+}
+
+static bool
 gen6_bsd_ring_get_irq(struct intel_ring_buffer *ring)
 {
-        return ring_get_irq(ring, GT_GEN6_BSD_USER_INTERRUPT);
+        return gen6_ring_get_irq(ring,
+                                 GT_GEN6_BSD_USER_INTERRUPT,
+                                 GEN6_BSD_USER_INTERRUPT);
 }
 
 static void
 gen6_bsd_ring_put_irq(struct intel_ring_buffer *ring)
 {
-        ring_put_irq(ring, GT_GEN6_BSD_USER_INTERRUPT);
+        return gen6_ring_put_irq(ring,
+                                 GT_GEN6_BSD_USER_INTERRUPT,
+                                 GEN6_BSD_USER_INTERRUPT);
 }
 
 /* ring buffer for Video Codec for Gen6+ */
@@ -1040,13 +1142,17 @@ static const struct intel_ring_buffer gen6_bsd_ring = {
 static bool
 blt_ring_get_irq(struct intel_ring_buffer *ring)
 {
-        return ring_get_irq(ring, GT_BLT_USER_INTERRUPT);
+        return gen6_ring_get_irq(ring,
+                                 GT_BLT_USER_INTERRUPT,
+                                 GEN6_BLITTER_USER_INTERRUPT);
 }
 
 static void
 blt_ring_put_irq(struct intel_ring_buffer *ring)
 {
-        ring_put_irq(ring, GT_BLT_USER_INTERRUPT);
+        gen6_ring_put_irq(ring,
+                          GT_BLT_USER_INTERRUPT,
+                          GEN6_BLITTER_USER_INTERRUPT);
 }
 
 
@@ -1115,20 +1221,25 @@ static int blt_ring_begin(struct intel_ring_buffer *ring,
                 return intel_ring_begin(ring, 4);
 }
 
-static void blt_ring_flush(struct intel_ring_buffer *ring,
+static int blt_ring_flush(struct intel_ring_buffer *ring,
                            u32 invalidate_domains,
                            u32 flush_domains)
 {
+        int ret;
+
         if ((flush_domains & I915_GEM_DOMAIN_RENDER) == 0)
-                return;
+                return 0;
 
-        if (blt_ring_begin(ring, 4) == 0) {
-                intel_ring_emit(ring, MI_FLUSH_DW);
-                intel_ring_emit(ring, 0);
-                intel_ring_emit(ring, 0);
-                intel_ring_emit(ring, 0);
-                intel_ring_advance(ring);
-        }
+        ret = blt_ring_begin(ring, 4);
+        if (ret)
+                return ret;
+
+        intel_ring_emit(ring, MI_FLUSH_DW);
+        intel_ring_emit(ring, 0);
+        intel_ring_emit(ring, 0);
+        intel_ring_emit(ring, 0);
+        intel_ring_advance(ring);
+        return 0;
 }
 
 static void blt_ring_cleanup(struct intel_ring_buffer *ring)
@@ -1165,6 +1276,8 @@ int intel_init_render_ring_buffer(struct drm_device *dev)
         *ring = render_ring;
         if (INTEL_INFO(dev)->gen >= 6) {
                 ring->add_request = gen6_add_request;
+                ring->irq_get = gen6_render_ring_get_irq;
+                ring->irq_put = gen6_render_ring_put_irq;
         } else if (IS_GEN5(dev)) {
                 ring->add_request = pc_render_add_request;
                 ring->get_seqno = pc_render_get_seqno;
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.h b/drivers/gpu/drm/i915/intel_ringbuffer.h
index 8e2e357ad6e..be9087e4c9b 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.h
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.h
@@ -16,21 +16,24 @@ struct  intel_hw_status_page {
 
 #define I915_RING_READ(reg) i915_safe_read(dev_priv, reg)
 
-#define I915_READ_TAIL(ring) I915_RING_READ(RING_TAIL(ring->mmio_base))
-#define I915_WRITE_TAIL(ring, val) I915_WRITE(RING_TAIL(ring->mmio_base), val)
+#define I915_READ_TAIL(ring) I915_RING_READ(RING_TAIL((ring)->mmio_base))
+#define I915_WRITE_TAIL(ring, val) I915_WRITE(RING_TAIL((ring)->mmio_base), val)
 
-#define I915_READ_START(ring) I915_RING_READ(RING_START(ring->mmio_base))
-#define I915_WRITE_START(ring, val) I915_WRITE(RING_START(ring->mmio_base), val)
+#define I915_READ_START(ring) I915_RING_READ(RING_START((ring)->mmio_base))
+#define I915_WRITE_START(ring, val) I915_WRITE(RING_START((ring)->mmio_base), val)
 
-#define I915_READ_HEAD(ring)  I915_RING_READ(RING_HEAD(ring->mmio_base))
-#define I915_WRITE_HEAD(ring, val) I915_WRITE(RING_HEAD(ring->mmio_base), val)
+#define I915_READ_HEAD(ring)  I915_RING_READ(RING_HEAD((ring)->mmio_base))
+#define I915_WRITE_HEAD(ring, val) I915_WRITE(RING_HEAD((ring)->mmio_base), val)
 
-#define I915_READ_CTL(ring) I915_RING_READ(RING_CTL(ring->mmio_base))
-#define I915_WRITE_CTL(ring, val) I915_WRITE(RING_CTL(ring->mmio_base), val)
+#define I915_READ_CTL(ring) I915_RING_READ(RING_CTL((ring)->mmio_base))
+#define I915_WRITE_CTL(ring, val) I915_WRITE(RING_CTL((ring)->mmio_base), val)
 
-#define I915_READ_NOPID(ring) I915_RING_READ(RING_NOPID(ring->mmio_base))
-#define I915_READ_SYNC_0(ring) I915_RING_READ(RING_SYNC_0(ring->mmio_base))
-#define I915_READ_SYNC_1(ring) I915_RING_READ(RING_SYNC_1(ring->mmio_base))
+#define I915_WRITE_IMR(ring, val) I915_WRITE(RING_IMR((ring)->mmio_base), val)
+#define I915_READ_IMR(ring) I915_RING_READ(RING_IMR((ring)->mmio_base))
+
+#define I915_READ_NOPID(ring) I915_RING_READ(RING_NOPID((ring)->mmio_base))
+#define I915_READ_SYNC_0(ring) I915_RING_READ(RING_SYNC_0((ring)->mmio_base))
+#define I915_READ_SYNC_1(ring) I915_RING_READ(RING_SYNC_1((ring)->mmio_base))
 
 struct  intel_ring_buffer {
         const char      *name;
@@ -49,12 +52,15 @@ struct  intel_ring_buffer {
         u32             tail;
         int             space;
         int             size;
+        int             effective_size;
         struct intel_hw_status_page status_page;
 
+        spinlock_t      irq_lock;
+        u32             irq_refcount;
+        u32             irq_mask;
         u32             irq_seqno;              /* last seq seem at irq time */
         u32             waiting_seqno;
         u32             sync_seqno[I915_NUM_RINGS-1];
-        atomic_t        irq_refcount;
         bool __must_check (*irq_get)(struct intel_ring_buffer *ring);
         void            (*irq_put)(struct intel_ring_buffer *ring);
 
@@ -62,9 +68,9 @@ struct  intel_ring_buffer {
 
         void            (*write_tail)(struct intel_ring_buffer *ring,
                                       u32 value);
-        void            (*flush)(struct intel_ring_buffer *ring,
-                                 u32    invalidate_domains,
-                                 u32    flush_domains);
+        int __must_check (*flush)(struct intel_ring_buffer *ring,
+                                  u32   invalidate_domains,
+                                  u32   flush_domains);
         int             (*add_request)(struct intel_ring_buffer *ring,
                                        u32 *seqno);
         u32             (*get_seqno)(struct intel_ring_buffer *ring);
diff --git a/drivers/gpu/drm/i915/intel_sdvo.c b/drivers/gpu/drm/i915/intel_sdvo.c
index 9d0af36a13e..45cd37652a3 100644
--- a/drivers/gpu/drm/i915/intel_sdvo.c
+++ b/drivers/gpu/drm/i915/intel_sdvo.c
@@ -1024,9 +1024,13 @@ static void intel_sdvo_mode_set(struct drm_encoder *encoder,
         if (!intel_sdvo_set_target_input(intel_sdvo))
                 return;
 
-        if (intel_sdvo->has_hdmi_monitor &&
-            !intel_sdvo_set_avi_infoframe(intel_sdvo))
-                return;
+        if (intel_sdvo->has_hdmi_monitor) {
+                intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_HDMI);
+                intel_sdvo_set_colorimetry(intel_sdvo,
+                                           SDVO_COLORIMETRY_RGB256);
+                intel_sdvo_set_avi_infoframe(intel_sdvo);
+        } else
+                intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_DVI);
 
         if (intel_sdvo->is_tv &&
             !intel_sdvo_set_tv_format(intel_sdvo))
@@ -1398,6 +1402,9 @@ intel_sdvo_detect(struct drm_connector *connector, bool force)
 
         intel_sdvo->attached_output = response;
 
+        intel_sdvo->has_hdmi_monitor = false;
+        intel_sdvo->has_hdmi_audio = false;
+
         if ((intel_sdvo_connector->output_flag & response) == 0)
                 ret = connector_status_disconnected;
         else if (response & SDVO_TMDS_MASK)
@@ -1922,20 +1929,7 @@ intel_sdvo_select_i2c_bus(struct drm_i915_private *dev_priv,
 static bool
 intel_sdvo_is_hdmi_connector(struct intel_sdvo *intel_sdvo, int device)
 {
-        int is_hdmi;
-
-        if (!intel_sdvo_check_supp_encode(intel_sdvo))
-                return false;
-
-        if (!intel_sdvo_set_target_output(intel_sdvo,
-                                          device == 0 ? SDVO_OUTPUT_TMDS0 : SDVO_OUTPUT_TMDS1))
-                return false;
-
-        is_hdmi = 0;
-        if (!intel_sdvo_get_value(intel_sdvo, SDVO_CMD_GET_ENCODE, &is_hdmi, 1))
-                return false;
-
-        return !!is_hdmi;
+        return intel_sdvo_check_supp_encode(intel_sdvo);
 }
 
 static u8
@@ -2037,12 +2031,7 @@ intel_sdvo_dvi_init(struct intel_sdvo *intel_sdvo, int device)
         connector->connector_type = DRM_MODE_CONNECTOR_DVID;
 
         if (intel_sdvo_is_hdmi_connector(intel_sdvo, device)) {
-                /* enable hdmi encoding mode if supported */
-                intel_sdvo_set_encode(intel_sdvo, SDVO_ENCODE_HDMI);
-                intel_sdvo_set_colorimetry(intel_sdvo,
-                                           SDVO_COLORIMETRY_RGB256);
                 connector->connector_type = DRM_MODE_CONNECTOR_HDMIA;
-
                 intel_sdvo->is_hdmi = true;
         }
         intel_sdvo->base.clone_mask = ((1 << INTEL_SDVO_NON_TV_CLONE_BIT) |
diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c
index b14c8111057..d3a9c6e0247 100644
--- a/drivers/gpu/drm/nouveau/nouveau_backlight.c
+++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c
@@ -59,7 +59,7 @@ static int nv40_set_intensity(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops nv40_bl_ops = {
+static const struct backlight_ops nv40_bl_ops = {
         .options = BL_CORE_SUSPENDRESUME,
         .get_brightness = nv40_get_intensity,
         .update_status = nv40_set_intensity,
@@ -82,7 +82,7 @@ static int nv50_set_intensity(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops nv50_bl_ops = {
+static const struct backlight_ops nv50_bl_ops = {
         .options = BL_CORE_SUSPENDRESUME,
         .get_brightness = nv50_get_intensity,
         .update_status = nv50_set_intensity,
diff --git a/drivers/gpu/drm/nouveau/nouveau_bios.c b/drivers/gpu/drm/nouveau/nouveau_bios.c
index d3046559bf0..2aef5cd3acf 100644
--- a/drivers/gpu/drm/nouveau/nouveau_bios.c
+++ b/drivers/gpu/drm/nouveau/nouveau_bios.c
@@ -1927,7 +1927,7 @@ init_ltime(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
          * offset      (8  bit): opcode
          * offset + 1  (16 bit): time
          *
-         * Sleep for "time" miliseconds.
+         * Sleep for "time" milliseconds.
          */
 
         unsigned time = ROM16(bios->data[offset + 1]);
@@ -1935,7 +1935,7 @@ init_ltime(struct nvbios *bios, uint16_t offset, struct init_exec *iexec)
         if (!iexec->execute)
                 return 3;
 
-        BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X miliseconds\n",
+        BIOSLOG(bios, "0x%04X: Sleeping for 0x%04X milliseconds\n",
                 offset, time);
 
         msleep(time);
diff --git a/drivers/gpu/drm/radeon/atombios.h b/drivers/gpu/drm/radeon/atombios.h
index 58a0cd02c0a..04b269d14a5 100644
--- a/drivers/gpu/drm/radeon/atombios.h
+++ b/drivers/gpu/drm/radeon/atombios.h
@@ -1629,7 +1629,7 @@ typedef struct _GET_ENGINE_CLOCK_PARAMETERS
 typedef struct _READ_EDID_FROM_HW_I2C_DATA_PARAMETERS
 {
   USHORT    usPrescale;         //Ratio between Engine clock and I2C clock
-  USHORT    usVRAMAddress;      //Adress in Frame Buffer where to pace raw EDID
+  USHORT    usVRAMAddress;      //Address in Frame Buffer where to pace raw EDID
   USHORT    usStatus;           //When use output: lower byte EDID checksum, high byte hardware status
                                 //WHen use input:  lower byte as 'byte to read':currently limited to 128byte or 1byte
   UCHAR     ucSlaveAddr;        //Read from which slave
diff --git a/drivers/hid/Kconfig b/drivers/hid/Kconfig
index ffbc278647b..24cca2f69df 100644
--- a/drivers/hid/Kconfig
+++ b/drivers/hid/Kconfig
@@ -295,6 +295,23 @@ config HID_MONTEREY
         ---help---
         Support for Monterey Genius KB29E.
 
+config HID_MULTITOUCH
+        tristate "HID Multitouch panels"
+        depends on USB_HID
+        ---help---
+          Generic support for HID multitouch panels.
+
+          Say Y here if you have one of the following devices:
+          - Cypress TrueTouch panels
+          - Hanvon dual touch panels
+          - Pixcir dual touch panels
+          - 'Sensing Win7-TwoFinger' panel by GeneralTouch
+
+          If unsure, say N.
+
+          To compile this driver as a module, choose M here: the
+          module will be called hid-multitouch.
+
 config HID_NTRIG
         tristate "N-Trig touch screen"
         depends on USB_HID
diff --git a/drivers/hid/Makefile b/drivers/hid/Makefile
index 6eae9a90b8d..6efc2a0370a 100644
--- a/drivers/hid/Makefile
+++ b/drivers/hid/Makefile
@@ -47,6 +47,7 @@ obj-$(CONFIG_HID_MAGICMOUSE)    += hid-magicmouse.o
 obj-$(CONFIG_HID_MICROSOFT)     += hid-microsoft.o
 obj-$(CONFIG_HID_MONTEREY)      += hid-monterey.o
 obj-$(CONFIG_HID_MOSART)        += hid-mosart.o
+obj-$(CONFIG_HID_MULTITOUCH)    += hid-multitouch.o
 obj-$(CONFIG_HID_NTRIG)         += hid-ntrig.o
 obj-$(CONFIG_HID_ORTEK)         += hid-ortek.o
 obj-$(CONFIG_HID_PRODIKEYS)     += hid-prodikeys.o
diff --git a/drivers/hid/hid-cando.c b/drivers/hid/hid-cando.c
index 375b50929a5..1ea066c5520 100644
--- a/drivers/hid/hid-cando.c
+++ b/drivers/hid/hid-cando.c
@@ -236,6 +236,8 @@ static const struct hid_device_id cando_devices[] = {
         { 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_10_1) },
+        { 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) },
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 261168607c9..d678cf3d33d 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1312,7 +1312,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_BELKIN, USB_DEVICE_ID_FLIP_KVM) },
         { HID_USB_DEVICE(USB_VENDOR_ID_BTC, USB_DEVICE_ID_BTC_EMPREX_REMOTE) },
         { 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_PIXCIR_MULTI_TOUCH) },
         { 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_10_1) },
         { 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) },
@@ -1324,6 +1326,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_BARCODE_3) },
         { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_MOUSE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS, USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DRAGONRISE, 0x0006) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_DWAV, USB_DEVICE_ID_DWAV_EGALAX_MULTITOUCH1) },
@@ -1335,11 +1338,13 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_EZKEY, USB_DEVICE_ID_BTC_8193) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0012) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GYRATION, USB_DEVICE_ID_GYRATION_REMOTE_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_HANVON, USB_DEVICE_ID_HANVON_MULTITOUCH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KENSINGTON, USB_DEVICE_ID_KS_SLIMBLADE) },
         { HID_USB_DEVICE(USB_VENDOR_ID_KYE, USB_DEVICE_ID_KYE_ERGO_525V) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LABTEC, USB_DEVICE_ID_LABTEC_WIRELESS_KEYBOARD) },
@@ -1422,6 +1427,7 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED, USB_DEVICE_ID_TOPSEED_CYBERLINK) },
         { HID_USB_DEVICE(USB_VENDOR_ID_TOPSEED2, USB_DEVICE_ID_TOPSEED2_RF_COMBO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_TWINHAN, USB_DEVICE_ID_TWINHAN_IR_REMOTE) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_PF1209) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP4030U) },
         { HID_USB_DEVICE(USB_VENDOR_ID_UCLOGIC, USB_DEVICE_ID_UCLOGIC_TABLET_WP5540U) },
@@ -1640,7 +1646,6 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_ESSENTIAL_REALITY, USB_DEVICE_ID_ESSENTIAL_REALITY_P5) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC5UH) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ETT, USB_DEVICE_ID_TC4UM) },
-        { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0001) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0002) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0003) },
         { HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH, 0x0004) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index f65cace7772..92a0d61a737 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -140,7 +140,9 @@
 #define USB_DEVICE_ID_BTC_EMPREX_REMOTE_2       0x5577
 
 #define USB_VENDOR_ID_CANDO             0x2087
+#define USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH 0x0703
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH 0x0a01
+#define USB_DEVICE_ID_CANDO_MULTI_TOUCH_10_1 0x0a02
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_11_6 0x0b03
 #define USB_DEVICE_ID_CANDO_MULTI_TOUCH_15_6 0x0f01
 
@@ -186,6 +188,7 @@
 #define USB_DEVICE_ID_CYPRESS_BARCODE_1 0xde61
 #define USB_DEVICE_ID_CYPRESS_BARCODE_2 0xde64
 #define USB_DEVICE_ID_CYPRESS_BARCODE_3 0xbca1
+#define USB_DEVICE_ID_CYPRESS_TRUETOUCH 0xc001
 
 #define USB_VENDOR_ID_DEALEXTREAME      0x10c5
 #define USB_DEVICE_ID_DEALEXTREAME_RADIO_SI4701 0x819a
@@ -236,6 +239,7 @@
 #define USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR  0x0002
 
 #define USB_VENDOR_ID_GENERAL_TOUCH     0x0dfc
+#define USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS 0x0001
 
 #define USB_VENDOR_ID_GLAB              0x06c2
 #define USB_DEVICE_ID_4_PHIDGETSERVO_30 0x0038
@@ -318,6 +322,9 @@
 #define USB_DEVICE_ID_HANWANG_TABLET_FIRST      0x5000
 #define USB_DEVICE_ID_HANWANG_TABLET_LAST       0x8fff
 
+#define USB_VENDOR_ID_HANVON            0x20b3
+#define USB_DEVICE_ID_HANVON_MULTITOUCH 0x0a18
+
 #define USB_VENDOR_ID_HAPP              0x078b
 #define USB_DEVICE_ID_UGCI_DRIVING      0x0010
 #define USB_DEVICE_ID_UGCI_FLYING       0x0020
diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c
index e60fdb88101..7f552bfad32 100644
--- a/drivers/hid/hid-input.c
+++ b/drivers/hid/hid-input.c
@@ -290,6 +290,14 @@ static void hidinput_configure_usage(struct hid_input *hidinput, struct hid_fiel
                 goto ignore;
         }
 
+        if (field->report_type == HID_FEATURE_REPORT) {
+                if (device->driver->feature_mapping) {
+                        device->driver->feature_mapping(device, hidinput, field,
+                                usage);
+                }
+                goto ignore;
+        }
+
         if (device->driver->input_mapping) {
                 int ret = device->driver->input_mapping(device, hidinput, field,
                                 usage, &bit, &max);
@@ -839,7 +847,6 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
         struct hid_input *hidinput = NULL;
         struct input_dev *input_dev;
         int i, j, k;
-        int max_report_type = HID_OUTPUT_REPORT;
 
         INIT_LIST_HEAD(&hid->inputs);
 
@@ -856,10 +863,11 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                         return -1;
         }
 
-        if (hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
-                max_report_type = HID_INPUT_REPORT;
+        for (k = HID_INPUT_REPORT; k <= HID_FEATURE_REPORT; k++) {
+                if (k == HID_OUTPUT_REPORT &&
+                        hid->quirks & HID_QUIRK_SKIP_OUTPUT_REPORTS)
+                        continue;
 
-        for (k = HID_INPUT_REPORT; k <= max_report_type; k++)
                 list_for_each_entry(report, &hid->report_enum[k].report_list, list) {
 
                         if (!report->maxfield)
@@ -912,6 +920,7 @@ int hidinput_connect(struct hid_device *hid, unsigned int force)
                                 hidinput = NULL;
                         }
                 }
+        }
 
         if (hidinput && input_register_device(hidinput->input))
                 goto out_cleanup;
diff --git a/drivers/hid/hid-mosart.c b/drivers/hid/hid-mosart.c
index 9fb050ce6f0..aed7ffe3628 100644
--- a/drivers/hid/hid-mosart.c
+++ b/drivers/hid/hid-mosart.c
@@ -257,6 +257,7 @@ static void mosart_remove(struct hid_device *hdev)
 static const struct hid_device_id mosart_devices[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUS_T91MT) },
         { HID_USB_DEVICE(USB_VENDOR_ID_ASUS, USB_DEVICE_ID_ASUSTEK_MULTITOUCH_YFO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_TURBOX_TOUCHSCREEN_MOSART) },
         { }
 };
 MODULE_DEVICE_TABLE(hid, mosart_devices);
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
new file mode 100644
index 00000000000..07d3183fdde
--- /dev/null
+++ b/drivers/hid/hid-multitouch.c
@@ -0,0 +1,516 @@
+/*
+ *  HID driver for multitouch panels
+ *
+ *  Copyright (c) 2010-2011 Stephane Chatty <chatty@enac.fr>
+ *  Copyright (c) 2010-2011 Benjamin Tissoires <benjamin.tissoires@gmail.com>
+ *  Copyright (c) 2010-2011 Ecole Nationale de l'Aviation Civile, France
+ *
+ */
+
+/*
+ * 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/device.h>
+#include <linux/hid.h>
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/usb.h>
+#include <linux/input/mt.h>
+#include "usbhid/usbhid.h"
+
+
+MODULE_AUTHOR("Stephane Chatty <chatty@enac.fr>");
+MODULE_DESCRIPTION("HID multitouch panels");
+MODULE_LICENSE("GPL");
+
+#include "hid-ids.h"
+
+/* quirks to control the device */
+#define MT_QUIRK_NOT_SEEN_MEANS_UP      (1 << 0)
+#define MT_QUIRK_SLOT_IS_CONTACTID      (1 << 1)
+#define MT_QUIRK_CYPRESS                (1 << 2)
+#define MT_QUIRK_SLOT_IS_CONTACTNUMBER  (1 << 3)
+#define MT_QUIRK_VALID_IS_INRANGE       (1 << 4)
+#define MT_QUIRK_VALID_IS_CONFIDENCE    (1 << 5)
+
+struct mt_slot {
+        __s32 x, y, p, w, h;
+        __s32 contactid;        /* the device ContactID assigned to this slot */
+        bool touch_state;       /* is the touch valid? */
+        bool seen_in_this_frame;/* has this slot been updated */
+};
+
+struct mt_device {
+        struct mt_slot curdata; /* placeholder of incoming data */
+        struct mt_class *mtclass;       /* our mt device class */
+        unsigned last_field_index;      /* last field index of the report */
+        unsigned last_slot_field;       /* the last field of a slot */
+        __s8 inputmode;         /* InputMode HID feature, -1 if non-existent */
+        __u8 num_received;      /* how many contacts we received */
+        __u8 num_expected;      /* expected last contact index */
+        bool curvalid;          /* is the current contact valid? */
+        struct mt_slot slots[0];        /* first slot */
+};
+
+struct mt_class {
+        __s32 name;     /* MT_CLS */
+        __s32 quirks;
+        __s32 sn_move;  /* Signal/noise ratio for move events */
+        __s32 sn_pressure;      /* Signal/noise ratio for pressure events */
+        __u8 maxcontacts;
+};
+
+/* classes of device behavior */
+#define MT_CLS_DEFAULT  1
+#define MT_CLS_DUAL1    2
+#define MT_CLS_DUAL2    3
+#define MT_CLS_CYPRESS  4
+
+/*
+ * these device-dependent functions determine what slot corresponds
+ * to a valid contact that was just read.
+ */
+
+static int cypress_compute_slot(struct mt_device *td)
+{
+        if (td->curdata.contactid != 0 || td->num_received == 0)
+                return td->curdata.contactid;
+        else
+                return -1;
+}
+
+static int find_slot_from_contactid(struct mt_device *td)
+{
+        int i;
+        for (i = 0; i < td->mtclass->maxcontacts; ++i) {
+                if (td->slots[i].contactid == td->curdata.contactid &&
+                        td->slots[i].touch_state)
+                        return i;
+        }
+        for (i = 0; i < td->mtclass->maxcontacts; ++i) {
+                if (!td->slots[i].seen_in_this_frame &&
+                        !td->slots[i].touch_state)
+                        return i;
+        }
+        /* should not occurs. If this happens that means
+         * that the device sent more touches that it says
+         * in the report descriptor. It is ignored then. */
+        return -1;
+}
+
+struct mt_class mt_classes[] = {
+        { .name = MT_CLS_DEFAULT,
+                .quirks = MT_QUIRK_VALID_IS_INRANGE,
+                .maxcontacts = 10 },
+        { .name = MT_CLS_DUAL1,
+                .quirks = MT_QUIRK_VALID_IS_INRANGE |
+                        MT_QUIRK_SLOT_IS_CONTACTID,
+                .maxcontacts = 2 },
+        { .name = MT_CLS_DUAL2,
+                .quirks = MT_QUIRK_VALID_IS_INRANGE |
+                        MT_QUIRK_SLOT_IS_CONTACTNUMBER,
+                .maxcontacts = 2 },
+        { .name = MT_CLS_CYPRESS,
+                .quirks = MT_QUIRK_NOT_SEEN_MEANS_UP |
+                        MT_QUIRK_CYPRESS,
+                .maxcontacts = 10 },
+
+        { }
+};
+
+static void mt_feature_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage)
+{
+        if (usage->hid == HID_DG_INPUTMODE) {
+                struct mt_device *td = hid_get_drvdata(hdev);
+                td->inputmode = field->report->id;
+        }
+}
+
+static void set_abs(struct input_dev *input, unsigned int code,
+                struct hid_field *field, int snratio)
+{
+        int fmin = field->logical_minimum;
+        int fmax = field->logical_maximum;
+        int fuzz = snratio ? (fmax - fmin) / snratio : 0;
+        input_set_abs_params(input, code, fmin, fmax, fuzz, 0);
+}
+
+static int mt_input_mapping(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        struct mt_class *cls = td->mtclass;
+        switch (usage->hid & HID_USAGE_PAGE) {
+
+        case HID_UP_GENDESK:
+                switch (usage->hid) {
+                case HID_GD_X:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_X);
+                        set_abs(hi->input, ABS_MT_POSITION_X, field,
+                                cls->sn_move);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_X, field, cls->sn_move);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_GD_Y:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_POSITION_Y);
+                        set_abs(hi->input, ABS_MT_POSITION_Y, field,
+                                cls->sn_move);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_Y, field, cls->sn_move);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                }
+                return 0;
+
+        case HID_UP_DIGITIZER:
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONFIDENCE:
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_TIPSWITCH:
+                        hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_TOUCH);
+                        input_set_capability(hi->input, EV_KEY, BTN_TOUCH);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONTACTID:
+                        input_mt_init_slots(hi->input,
+                                        td->mtclass->maxcontacts);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_WIDTH:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MAJOR);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_HEIGHT:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_TOUCH_MINOR);
+                        field->logical_maximum = 1;
+                        field->logical_minimum = 0;
+                        set_abs(hi->input, ABS_MT_ORIENTATION, field, 0);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_TIPPRESSURE:
+                        hid_map_usage(hi, usage, bit, max,
+                                        EV_ABS, ABS_MT_PRESSURE);
+                        set_abs(hi->input, ABS_MT_PRESSURE, field,
+                                cls->sn_pressure);
+                        /* touchscreen emulation */
+                        set_abs(hi->input, ABS_PRESSURE, field,
+                                cls->sn_pressure);
+                        td->last_slot_field = usage->hid;
+                        return 1;
+                case HID_DG_CONTACTCOUNT:
+                        td->last_field_index = field->report->maxfield - 1;
+                        return 1;
+                case HID_DG_CONTACTMAX:
+                        /* we don't set td->last_slot_field as contactcount and
+                         * contact max are global to the report */
+                        return -1;
+                }
+                /* let hid-input decide for the others */
+                return 0;
+
+        case 0xff000000:
+                /* we do not want to map these: no input-oriented meaning */
+                return -1;
+        }
+
+        return 0;
+}
+
+static int mt_input_mapped(struct hid_device *hdev, struct hid_input *hi,
+                struct hid_field *field, struct hid_usage *usage,
+                unsigned long **bit, int *max)
+{
+        if (usage->type == EV_KEY || usage->type == EV_ABS)
+                set_bit(usage->type, hi->input->evbit);
+
+        return -1;
+}
+
+static int mt_compute_slot(struct mt_device *td)
+{
+        __s32 quirks = td->mtclass->quirks;
+
+        if (quirks & MT_QUIRK_SLOT_IS_CONTACTID)
+                return td->curdata.contactid;
+
+        if (quirks & MT_QUIRK_CYPRESS)
+                return cypress_compute_slot(td);
+
+        if (quirks & MT_QUIRK_SLOT_IS_CONTACTNUMBER)
+                return td->num_received;
+
+        return find_slot_from_contactid(td);
+}
+
+/*
+ * this function is called when a whole contact has been processed,
+ * so that it can assign it to a slot and store the data there
+ */
+static void mt_complete_slot(struct mt_device *td)
+{
+        td->curdata.seen_in_this_frame = true;
+        if (td->curvalid) {
+                int slotnum = mt_compute_slot(td);
+
+                if (slotnum >= 0 && slotnum < td->mtclass->maxcontacts)
+                        td->slots[slotnum] = td->curdata;
+        }
+        td->num_received++;
+}
+
+
+/*
+ * this function is called when a whole packet has been received and processed,
+ * so that it can decide what to send to the input layer.
+ */
+static void mt_emit_event(struct mt_device *td, struct input_dev *input)
+{
+        int i;
+
+        for (i = 0; i < td->mtclass->maxcontacts; ++i) {
+                struct mt_slot *s = &(td->slots[i]);
+                if ((td->mtclass->quirks & MT_QUIRK_NOT_SEEN_MEANS_UP) &&
+                        !s->seen_in_this_frame) {
+                        s->touch_state = false;
+                }
+
+                input_mt_slot(input, i);
+                input_mt_report_slot_state(input, MT_TOOL_FINGER,
+                        s->touch_state);
+                if (s->touch_state) {
+                        input_event(input, EV_ABS, ABS_MT_POSITION_X, s->x);
+                        input_event(input, EV_ABS, ABS_MT_POSITION_Y, s->y);
+                        input_event(input, EV_ABS, ABS_MT_PRESSURE, s->p);
+                        input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, s->w);
+                        input_event(input, EV_ABS, ABS_MT_TOUCH_MINOR, s->h);
+                }
+                s->seen_in_this_frame = false;
+
+        }
+
+        input_mt_report_pointer_emulation(input, true);
+        input_sync(input);
+        td->num_received = 0;
+}
+
+
+
+static int mt_event(struct hid_device *hid, struct hid_field *field,
+                                struct hid_usage *usage, __s32 value)
+{
+        struct mt_device *td = hid_get_drvdata(hid);
+        __s32 quirks = td->mtclass->quirks;
+
+        if (hid->claimed & HID_CLAIMED_INPUT) {
+                switch (usage->hid) {
+                case HID_DG_INRANGE:
+                        if (quirks & MT_QUIRK_VALID_IS_INRANGE)
+                                td->curvalid = value;
+                        break;
+                case HID_DG_TIPSWITCH:
+                        if (quirks & MT_QUIRK_NOT_SEEN_MEANS_UP)
+                                td->curvalid = value;
+                        td->curdata.touch_state = value;
+                        break;
+                case HID_DG_CONFIDENCE:
+                        if (quirks & MT_QUIRK_VALID_IS_CONFIDENCE)
+                                td->curvalid = value;
+                        break;
+                case HID_DG_CONTACTID:
+                        td->curdata.contactid = value;
+                        break;
+                case HID_DG_TIPPRESSURE:
+                        td->curdata.p = value;
+                        break;
+                case HID_GD_X:
+                        td->curdata.x = value;
+                        break;
+                case HID_GD_Y:
+                        td->curdata.y = value;
+                        break;
+                case HID_DG_WIDTH:
+                        td->curdata.w = value;
+                        break;
+                case HID_DG_HEIGHT:
+                        td->curdata.h = value;
+                        break;
+                case HID_DG_CONTACTCOUNT:
+                        /*
+                         * Includes multi-packet support where subsequent
+                         * packets are sent with zero contactcount.
+                         */
+                        if (value)
+                                td->num_expected = value;
+                        break;
+
+                default:
+                        /* fallback to the generic hidinput handling */
+                        return 0;
+                }
+
+                if (usage->hid == td->last_slot_field)
+                        mt_complete_slot(td);
+
+                if (field->index == td->last_field_index
+                        && td->num_received >= td->num_expected)
+                        mt_emit_event(td, field->hidinput->input);
+
+        }
+
+        /* we have handled the hidinput part, now remains hiddev */
+        if (hid->claimed & HID_CLAIMED_HIDDEV && hid->hiddev_hid_event)
+                hid->hiddev_hid_event(hid, field, usage, value);
+
+        return 1;
+}
+
+static void mt_set_input_mode(struct hid_device *hdev)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        struct hid_report *r;
+        struct hid_report_enum *re;
+
+        if (td->inputmode < 0)
+                return;
+
+        re = &(hdev->report_enum[HID_FEATURE_REPORT]);
+        r = re->report_id_hash[td->inputmode];
+        if (r) {
+                r->field[0]->value[0] = 0x02;
+                usbhid_submit_report(hdev, r, USB_DIR_OUT);
+        }
+}
+
+static int mt_probe(struct hid_device *hdev, const struct hid_device_id *id)
+{
+        int ret, i;
+        struct mt_device *td;
+        struct mt_class *mtclass = mt_classes; /* MT_CLS_DEFAULT */
+
+        for (i = 0; mt_classes[i].name ; i++) {
+                if (id->driver_data == mt_classes[i].name) {
+                        mtclass = &(mt_classes[i]);
+                        break;
+                }
+        }
+
+        /* This allows the driver to correctly support devices
+         * that emit events over several HID messages.
+         */
+        hdev->quirks |= HID_QUIRK_NO_INPUT_SYNC;
+
+        td = kzalloc(sizeof(struct mt_device) +
+                                mtclass->maxcontacts * sizeof(struct mt_slot),
+                                GFP_KERNEL);
+        if (!td) {
+                dev_err(&hdev->dev, "cannot allocate multitouch data\n");
+                return -ENOMEM;
+        }
+        td->mtclass = mtclass;
+        td->inputmode = -1;
+        hid_set_drvdata(hdev, td);
+
+        ret = hid_parse(hdev);
+        if (ret != 0)
+                goto fail;
+
+        ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+        if (ret)
+                goto fail;
+
+        mt_set_input_mode(hdev);
+
+        return 0;
+
+fail:
+        kfree(td);
+        return ret;
+}
+
+#ifdef CONFIG_PM
+static int mt_reset_resume(struct hid_device *hdev)
+{
+        mt_set_input_mode(hdev);
+        return 0;
+}
+#endif
+
+static void mt_remove(struct hid_device *hdev)
+{
+        struct mt_device *td = hid_get_drvdata(hdev);
+        hid_hw_stop(hdev);
+        kfree(td);
+        hid_set_drvdata(hdev, NULL);
+}
+
+static const struct hid_device_id mt_devices[] = {
+
+        /* Cypress panel */
+        { .driver_data = MT_CLS_CYPRESS,
+                HID_USB_DEVICE(USB_VENDOR_ID_CYPRESS,
+                        USB_DEVICE_ID_CYPRESS_TRUETOUCH) },
+
+        /* GeneralTouch panel */
+        { .driver_data = MT_CLS_DUAL2,
+                HID_USB_DEVICE(USB_VENDOR_ID_GENERAL_TOUCH,
+                        USB_DEVICE_ID_GENERAL_TOUCH_WIN7_TWOFINGERS) },
+
+        /* PixCir-based panels */
+        { .driver_data = MT_CLS_DUAL1,
+                HID_USB_DEVICE(USB_VENDOR_ID_HANVON,
+                        USB_DEVICE_ID_HANVON_MULTITOUCH) },
+        { .driver_data = MT_CLS_DUAL1,
+                HID_USB_DEVICE(USB_VENDOR_ID_CANDO,
+                        USB_DEVICE_ID_CANDO_PIXCIR_MULTI_TOUCH) },
+
+        { }
+};
+MODULE_DEVICE_TABLE(hid, mt_devices);
+
+static const struct hid_usage_id mt_grabbed_usages[] = {
+        { HID_ANY_ID, HID_ANY_ID, HID_ANY_ID },
+        { HID_ANY_ID - 1, HID_ANY_ID - 1, HID_ANY_ID - 1}
+};
+
+static struct hid_driver mt_driver = {
+        .name = "hid-multitouch",
+        .id_table = mt_devices,
+        .probe = mt_probe,
+        .remove = mt_remove,
+        .input_mapping = mt_input_mapping,
+        .input_mapped = mt_input_mapped,
+        .feature_mapping = mt_feature_mapping,
+        .usage_table = mt_grabbed_usages,
+        .event = mt_event,
+#ifdef CONFIG_PM
+        .reset_resume = mt_reset_resume,
+#endif
+};
+
+static int __init mt_init(void)
+{
+        return hid_register_driver(&mt_driver);
+}
+
+static void __exit mt_exit(void)
+{
+        hid_unregister_driver(&mt_driver);
+}
+
+module_init(mt_init);
+module_exit(mt_exit);
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index 76b9a149c7d..9a94b643ccd 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -35,7 +35,6 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_CHIC, USB_DEVICE_ID_CHIC_GAMEPAD, HID_QUIRK_BADPAD },
         { USB_VENDOR_ID_DWAV, USB_DEVICE_ID_EGALAX_TOUCHCONTROLLER, HID_QUIRK_MULTI_INPUT | HID_QUIRK_NOGET },
         { 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/hwmon/Kconfig b/drivers/hwmon/Kconfig
index bdc13d28b1e..35f00dae367 100644
--- a/drivers/hwmon/Kconfig
+++ b/drivers/hwmon/Kconfig
@@ -809,10 +809,10 @@ config SENSORS_DME1737
           will be called dme1737.
 
 config SENSORS_EMC1403
-        tristate "SMSC EMC1403 thermal sensor"
+        tristate "SMSC EMC1403/23 thermal sensor"
         depends on I2C
         help
-          If you say yes here you get support for the SMSC EMC1403
+          If you say yes here you get support for the SMSC EMC1403/23
           temperature monitoring chip.
 
           Threshold values can be configured using sysfs.
diff --git a/drivers/hwmon/adm9240.c b/drivers/hwmon/adm9240.c
index 0727ad25079..9e234b981b8 100644
--- a/drivers/hwmon/adm9240.c
+++ b/drivers/hwmon/adm9240.c
@@ -20,7 +20,7 @@
  * Alarms       16-bit map of active alarms
  * Analog Out   0..1250 mV output
  *
- * Chassis Intrusion: clear CI latch with 'echo 1 > chassis_clear'
+ * Chassis Intrusion: clear CI latch with 'echo 0 > intrusion0_alarm'
  *
  * Test hardware: Intel SE440BX-2 desktop motherboard --Grant
  *
@@ -476,13 +476,16 @@ static ssize_t set_aout(struct device *dev,
 static DEVICE_ATTR(aout_output, S_IRUGO | S_IWUSR, show_aout, set_aout);
 
 /* chassis_clear */
-static ssize_t chassis_clear(struct device *dev,
+static ssize_t chassis_clear_legacy(struct device *dev,
                 struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct i2c_client *client = to_i2c_client(dev);
         unsigned long val = simple_strtol(buf, NULL, 10);
 
+        dev_warn(dev, "Attribute chassis_clear is deprecated, "
+                 "use intrusion0_alarm instead\n");
+
         if (val == 1) {
                 i2c_smbus_write_byte_data(client,
                                 ADM9240_REG_CHASSIS_CLEAR, 0x80);
@@ -490,7 +493,29 @@ static ssize_t chassis_clear(struct device *dev,
         }
         return count;
 }
-static DEVICE_ATTR(chassis_clear, S_IWUSR, NULL, chassis_clear);
+static DEVICE_ATTR(chassis_clear, S_IWUSR, NULL, chassis_clear_legacy);
+
+static ssize_t chassis_clear(struct device *dev,
+                struct device_attribute *attr,
+                const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct adm9240_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+
+        if (strict_strtoul(buf, 10, &val) || val != 0)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        i2c_smbus_write_byte_data(client, ADM9240_REG_CHASSIS_CLEAR, 0x80);
+        data->valid = 0;                /* Force cache refresh */
+        mutex_unlock(&data->update_lock);
+        dev_dbg(&client->dev, "chassis intrusion latch cleared\n");
+
+        return count;
+}
+static SENSOR_DEVICE_ATTR(intrusion0_alarm, S_IRUGO | S_IWUSR, show_alarm,
+                chassis_clear, 12);
 
 static struct attribute *adm9240_attributes[] = {
         &sensor_dev_attr_in0_input.dev_attr.attr,
@@ -532,6 +557,7 @@ static struct attribute *adm9240_attributes[] = {
         &dev_attr_alarms.attr,
         &dev_attr_aout_output.attr,
         &dev_attr_chassis_clear.attr,
+        &sensor_dev_attr_intrusion0_alarm.dev_attr.attr,
         &dev_attr_cpu0_vid.attr,
         NULL
 };
diff --git a/drivers/hwmon/ads7828.c b/drivers/hwmon/ads7828.c
index aac85f3aed5..c42c5a69a66 100644
--- a/drivers/hwmon/ads7828.c
+++ b/drivers/hwmon/ads7828.c
@@ -4,7 +4,7 @@
 
         This driver is based on the lm75 and other lm_sensors/hwmon drivers
 
-        Written by Steve Hardy <steve@linuxrealtime.co.uk>
+        Written by Steve Hardy <shardy@redhat.com>
 
         Datasheet available at: http://focus.ti.com/lit/ds/symlink/ads7828.pdf
 
@@ -271,7 +271,7 @@ static void __exit sensors_ads7828_exit(void)
         i2c_del_driver(&ads7828_driver);
 }
 
-MODULE_AUTHOR("Steve Hardy <steve@linuxrealtime.co.uk>");
+MODULE_AUTHOR("Steve Hardy <shardy@redhat.com>");
 MODULE_DESCRIPTION("ADS7828 driver");
 MODULE_LICENSE("GPL");
 
diff --git a/drivers/hwmon/dme1737.c b/drivers/hwmon/dme1737.c
index e9a610bfd0c..d9c59271391 100644
--- a/drivers/hwmon/dme1737.c
+++ b/drivers/hwmon/dme1737.c
@@ -77,12 +77,14 @@ enum chips { dme1737, sch5027, sch311x, sch5127 };
  * in4   +12V
  * in5   VTR   (+3.3V stby)
  * in6   Vbat
+ * in7   Vtrip (sch5127 only)
  *
  * --------------------------------------------------------------------- */
 
-/* Voltages (in) numbered 0-6 (ix) */
-#define DME1737_REG_IN(ix)              ((ix) < 5 ? 0x20 + (ix) \
-                                                  : 0x94 + (ix))
+/* Voltages (in) numbered 0-7 (ix) */
+#define DME1737_REG_IN(ix)              ((ix) < 5 ? 0x20 + (ix) : \
+                                         (ix) < 7 ? 0x94 + (ix) : \
+                                                    0x1f)
 #define DME1737_REG_IN_MIN(ix)          ((ix) < 5 ? 0x44 + (ix) * 2 \
                                                   : 0x91 + (ix) * 2)
 #define DME1737_REG_IN_MAX(ix)          ((ix) < 5 ? 0x45 + (ix) * 2 \
@@ -101,10 +103,11 @@ enum chips { dme1737, sch5027, sch311x, sch5127 };
  *    IN_TEMP_LSB(1) = [temp3, temp1]
  *    IN_TEMP_LSB(2) = [in4, temp2]
  *    IN_TEMP_LSB(3) = [in3, in0]
- *    IN_TEMP_LSB(4) = [in2, in1] */
+ *    IN_TEMP_LSB(4) = [in2, in1]
+ *    IN_TEMP_LSB(5) = [res, in7] */
 #define DME1737_REG_IN_TEMP_LSB(ix)     (0x84 + (ix))
-static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0};
-static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4};
+static const u8 DME1737_REG_IN_LSB[] = {3, 4, 4, 3, 2, 0, 0, 5};
+static const u8 DME1737_REG_IN_LSB_SHL[] = {4, 4, 0, 0, 0, 0, 4, 4};
 static const u8 DME1737_REG_TEMP_LSB[] = {1, 2, 1};
 static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0};
 
@@ -145,7 +148,7 @@ static const u8 DME1737_REG_TEMP_LSB_SHL[] = {4, 4, 0};
 #define DME1737_REG_ALARM1              0x41
 #define DME1737_REG_ALARM2              0x42
 #define DME1737_REG_ALARM3              0x83
-static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17};
+static const u8 DME1737_BIT_ALARM_IN[] = {0, 1, 2, 3, 8, 16, 17, 18};
 static const u8 DME1737_BIT_ALARM_TEMP[] = {4, 5, 6};
 static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 
@@ -190,6 +193,7 @@ static const u8 DME1737_BIT_ALARM_FAN[] = {10, 11, 12, 13, 22, 23};
 #define HAS_PWM_MIN             (1 << 4)                /* bit 4 */
 #define HAS_FAN(ix)             (1 << ((ix) + 5))       /* bits 5-10 */
 #define HAS_PWM(ix)             (1 << ((ix) + 11))      /* bits 11-16 */
+#define HAS_IN7                 (1 << 17)               /* bit 17 */
 
 /* ---------------------------------------------------------------------
  * Data structures and manipulation thereof
@@ -213,9 +217,9 @@ struct dme1737_data {
         u32 has_features;
 
         /* Register values */
-        u16 in[7];
-        u8  in_min[7];
-        u8  in_max[7];
+        u16 in[8];
+        u8  in_min[8];
+        u8  in_max[8];
         s16 temp[3];
         s8  temp_min[3];
         s8  temp_max[3];
@@ -247,7 +251,7 @@ static const int IN_NOMINAL_SCH311x[] = {2500, 1500, 3300, 5000, 12000, 3300,
 static const int IN_NOMINAL_SCH5027[] = {5000, 2250, 3300, 1125, 1125, 3300,
                                          3300};
 static const int IN_NOMINAL_SCH5127[] = {2500, 2250, 3300, 1125, 1125, 3300,
-                                         3300};
+                                         3300, 1500};
 #define IN_NOMINAL(type)        ((type) == sch311x ? IN_NOMINAL_SCH311x : \
                                  (type) == sch5027 ? IN_NOMINAL_SCH5027 : \
                                  (type) == sch5127 ? IN_NOMINAL_SCH5127 : \
@@ -580,7 +584,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 {
         struct dme1737_data *data = dev_get_drvdata(dev);
         int ix;
-        u8 lsb[5];
+        u8 lsb[6];
 
         mutex_lock(&data->update_lock);
 
@@ -603,6 +607,9 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                         /* Voltage inputs are stored as 16 bit values even
                          * though they have only 12 bits resolution. This is
                          * to make it consistent with the temp inputs. */
+                        if (ix == 7 && !(data->has_features & HAS_IN7)) {
+                                continue;
+                        }
                         data->in[ix] = dme1737_read(data,
                                         DME1737_REG_IN(ix)) << 8;
                         data->in_min[ix] = dme1737_read(data,
@@ -635,10 +642,16 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
                  * which the registers are read (MSB first, then LSB) is
                  * important! */
                 for (ix = 0; ix < ARRAY_SIZE(lsb); ix++) {
+                        if (ix == 5 && !(data->has_features & HAS_IN7)) {
+                                continue;
+                        }
                         lsb[ix] = dme1737_read(data,
                                         DME1737_REG_IN_TEMP_LSB(ix));
                 }
                 for (ix = 0; ix < ARRAY_SIZE(data->in); ix++) {
+                        if (ix == 7 && !(data->has_features & HAS_IN7)) {
+                                continue;
+                        }
                         data->in[ix] |= (lsb[DME1737_REG_IN_LSB[ix]] <<
                                         DME1737_REG_IN_LSB_SHL[ix]) & 0xf0;
                 }
@@ -762,7 +775,7 @@ static struct dme1737_data *dme1737_update_device(struct device *dev)
 
 /* ---------------------------------------------------------------------
  * Voltage sysfs attributes
- * ix = [0-5]
+ * ix = [0-7]
  * --------------------------------------------------------------------- */
 
 #define SYS_IN_INPUT    0
@@ -1439,7 +1452,7 @@ static ssize_t show_name(struct device *dev, struct device_attribute *attr,
  * Sysfs device attribute defines and structs
  * --------------------------------------------------------------------- */
 
-/* Voltages 0-6 */
+/* Voltages 0-7 */
 
 #define SENSOR_DEVICE_ATTR_IN(ix) \
 static SENSOR_DEVICE_ATTR_2(in##ix##_input, S_IRUGO, \
@@ -1458,6 +1471,7 @@ SENSOR_DEVICE_ATTR_IN(3);
 SENSOR_DEVICE_ATTR_IN(4);
 SENSOR_DEVICE_ATTR_IN(5);
 SENSOR_DEVICE_ATTR_IN(6);
+SENSOR_DEVICE_ATTR_IN(7);
 
 /* Temperatures 1-3 */
 
@@ -1576,7 +1590,7 @@ static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);   /* for ISA devices */
  * created unconditionally. The attributes that need modification of their
  * permissions are created read-only and write permissions are added or removed
  * on the fly when required */
-static struct attribute *dme1737_attr[] ={
+static struct attribute *dme1737_attr[] = {
         /* Voltages */
         &sensor_dev_attr_in0_input.dev_attr.attr,
         &sensor_dev_attr_in0_min.dev_attr.attr,
@@ -1681,7 +1695,7 @@ static const struct attribute_group dme1737_zone3_group = {
 };
 
 
-/* The following struct holds temp zone hysteresis  related attributes, which
+/* The following struct holds temp zone hysteresis related attributes, which
  * are not available in all chips. The following chips support them:
  * DME1737, SCH311x */
 static struct attribute *dme1737_zone_hyst_attr[] = {
@@ -1695,6 +1709,21 @@ static const struct attribute_group dme1737_zone_hyst_group = {
         .attrs = dme1737_zone_hyst_attr,
 };
 
+/* The following struct holds voltage in7 related attributes, which
+ * are not available in all chips. The following chips support them:
+ * SCH5127 */
+static struct attribute *dme1737_in7_attr[] = {
+        &sensor_dev_attr_in7_input.dev_attr.attr,
+        &sensor_dev_attr_in7_min.dev_attr.attr,
+        &sensor_dev_attr_in7_max.dev_attr.attr,
+        &sensor_dev_attr_in7_alarm.dev_attr.attr,
+        NULL
+};
+
+static const struct attribute_group dme1737_in7_group = {
+        .attrs = dme1737_in7_attr,
+};
+
 /* The following structs hold the PWM attributes, some of which are optional.
  * Their creation depends on the chip configuration which is determined during
  * module load. */
@@ -1986,6 +2015,9 @@ static void dme1737_remove_files(struct device *dev)
         if (data->has_features & HAS_ZONE_HYST) {
                 sysfs_remove_group(&dev->kobj, &dme1737_zone_hyst_group);
         }
+        if (data->has_features & HAS_IN7) {
+                sysfs_remove_group(&dev->kobj, &dme1737_in7_group);
+        }
         sysfs_remove_group(&dev->kobj, &dme1737_group);
 
         if (!data->client) {
@@ -1999,43 +2031,58 @@ static int dme1737_create_files(struct device *dev)
         int err, ix;
 
         /* Create a name attribute for ISA devices */
-        if (!data->client &&
-            (err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr))) {
-                goto exit;
+        if (!data->client) {
+                err = sysfs_create_file(&dev->kobj, &dev_attr_name.attr);
+                if (err) {
+                        goto exit;
+                }
         }
 
         /* Create standard sysfs attributes */
-        if ((err = sysfs_create_group(&dev->kobj, &dme1737_group))) {
+        err = sysfs_create_group(&dev->kobj, &dme1737_group);
+        if (err) {
                 goto exit_remove;
         }
 
         /* Create chip-dependent sysfs attributes */
-        if ((data->has_features & HAS_TEMP_OFFSET) &&
-            (err = sysfs_create_group(&dev->kobj,
-                                      &dme1737_temp_offset_group))) {
-                goto exit_remove;
+        if (data->has_features & HAS_TEMP_OFFSET) {
+                err = sysfs_create_group(&dev->kobj,
+                                         &dme1737_temp_offset_group);
+                if (err) {
+                        goto exit_remove;
+                }
         }
-        if ((data->has_features & HAS_VID) &&
-            (err = sysfs_create_group(&dev->kobj,
-                                      &dme1737_vid_group))) {
-                goto exit_remove;
+        if (data->has_features & HAS_VID) {
+                err = sysfs_create_group(&dev->kobj, &dme1737_vid_group);
+                if (err) {
+                        goto exit_remove;
+                }
         }
-        if ((data->has_features & HAS_ZONE3) &&
-            (err = sysfs_create_group(&dev->kobj,
-                                      &dme1737_zone3_group))) {
-                goto exit_remove;
+        if (data->has_features & HAS_ZONE3) {
+                err = sysfs_create_group(&dev->kobj, &dme1737_zone3_group);
+                if (err) {
+                        goto exit_remove;
+                }
         }
-        if ((data->has_features & HAS_ZONE_HYST) &&
-            (err = sysfs_create_group(&dev->kobj,
-                                      &dme1737_zone_hyst_group))) {
-                goto exit_remove;
+        if (data->has_features & HAS_ZONE_HYST) {
+                err = sysfs_create_group(&dev->kobj, &dme1737_zone_hyst_group);
+                if (err) {
+                        goto exit_remove;
+                }
+        }
+        if (data->has_features & HAS_IN7) {
+                err = sysfs_create_group(&dev->kobj, &dme1737_in7_group);
+                if (err) {
+                        goto exit_remove;
+                }
         }
 
         /* Create fan sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_fan_group); ix++) {
                 if (data->has_features & HAS_FAN(ix)) {
-                        if ((err = sysfs_create_group(&dev->kobj,
-                                                &dme1737_fan_group[ix]))) {
+                        err = sysfs_create_group(&dev->kobj,
+                                                 &dme1737_fan_group[ix]);
+                        if (err) {
                                 goto exit_remove;
                         }
                 }
@@ -2044,14 +2091,17 @@ static int dme1737_create_files(struct device *dev)
         /* Create PWM sysfs attributes */
         for (ix = 0; ix < ARRAY_SIZE(dme1737_pwm_group); ix++) {
                 if (data->has_features & HAS_PWM(ix)) {
-                        if ((err = sysfs_create_group(&dev->kobj,
-                                                &dme1737_pwm_group[ix]))) {
+                        err = sysfs_create_group(&dev->kobj,
+                                                 &dme1737_pwm_group[ix]);
+                        if (err) {
                                 goto exit_remove;
                         }
-                        if ((data->has_features & HAS_PWM_MIN) && ix < 3 &&
-                            (err = sysfs_create_file(&dev->kobj,
-                                        dme1737_auto_pwm_min_attr[ix]))) {
-                                goto exit_remove;
+                        if ((data->has_features & HAS_PWM_MIN) && (ix < 3)) {
+                                err = sysfs_create_file(&dev->kobj,
+                                                dme1737_auto_pwm_min_attr[ix]);
+                                if (err) {
+                                        goto exit_remove;
+                                }
                         }
                 }
         }
@@ -2188,7 +2238,7 @@ static int dme1737_init_device(struct device *dev)
                 data->has_features |= HAS_ZONE3;
                 break;
         case sch5127:
-                data->has_features |= HAS_FAN(2) | HAS_PWM(2);
+                data->has_features |= HAS_FAN(2) | HAS_PWM(2) | HAS_IN7;
                 break;
         default:
                 break;
@@ -2281,8 +2331,9 @@ static int dme1737_i2c_get_features(int sio_cip, struct dme1737_data *data)
         dme1737_sio_outb(sio_cip, 0x07, 0x0a);
 
         /* Get the base address of the runtime registers */
-        if (!(addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
-                      dme1737_sio_inb(sio_cip, 0x61))) {
+        addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
+                dme1737_sio_inb(sio_cip, 0x61);
+        if (!addr) {
                 err = -ENODEV;
                 goto exit;
         }
@@ -2363,13 +2414,15 @@ static int dme1737_i2c_probe(struct i2c_client *client,
         mutex_init(&data->update_lock);
 
         /* Initialize the DME1737 chip */
-        if ((err = dme1737_init_device(dev))) {
+        err = dme1737_init_device(dev);
+        if (err) {
                 dev_err(dev, "Failed to initialize device.\n");
                 goto exit_kfree;
         }
 
         /* Create sysfs files */
-        if ((err = dme1737_create_files(dev))) {
+        err = dme1737_create_files(dev);
+        if (err) {
                 dev_err(dev, "Failed to create sysfs files.\n");
                 goto exit_kfree;
         }
@@ -2446,8 +2499,9 @@ static int __init dme1737_isa_detect(int sio_cip, unsigned short *addr)
         dme1737_sio_outb(sio_cip, 0x07, 0x0a);
 
         /* Get the base address of the runtime registers */
-        if (!(base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
-                           dme1737_sio_inb(sio_cip, 0x61))) {
+        base_addr = (dme1737_sio_inb(sio_cip, 0x60) << 8) |
+                     dme1737_sio_inb(sio_cip, 0x61);
+        if (!base_addr) {
                 pr_err("Base address not set\n");
                 err = -ENODEV;
                 goto exit;
@@ -2476,18 +2530,21 @@ static int __init dme1737_isa_device_add(unsigned short addr)
         if (err)
                 goto exit;
 
-        if (!(pdev = platform_device_alloc("dme1737", addr))) {
+        pdev = platform_device_alloc("dme1737", addr);
+        if (!pdev) {
                 pr_err("Failed to allocate device\n");
                 err = -ENOMEM;
                 goto exit;
         }
 
-        if ((err = platform_device_add_resources(pdev, &res, 1))) {
+        err = platform_device_add_resources(pdev, &res, 1);
+        if (err) {
                 pr_err("Failed to add device resource (err = %d)\n", err);
                 goto exit_device_put;
         }
 
-        if ((err = platform_device_add(pdev))) {
+        err = platform_device_add(pdev);
+        if (err) {
                 pr_err("Failed to add device (err = %d)\n", err);
                 goto exit_device_put;
         }
@@ -2514,11 +2571,12 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
                 dev_err(dev, "Failed to request region 0x%04x-0x%04x.\n",
                         (unsigned short)res->start,
                         (unsigned short)res->start + DME1737_EXTENT - 1);
-                err = -EBUSY;
-                goto exit;
-        }
+                err = -EBUSY;
+                goto exit;
+        }
 
-        if (!(data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL))) {
+        data = kzalloc(sizeof(struct dme1737_data), GFP_KERNEL);
+        if (!data) {
                 err = -ENOMEM;
                 goto exit_release_region;
         }
@@ -2565,13 +2623,15 @@ static int __devinit dme1737_isa_probe(struct platform_device *pdev)
                  data->type == sch5127 ? "SCH5127" : "SCH311x", data->addr);
 
         /* Initialize the chip */
-        if ((err = dme1737_init_device(dev))) {
+        err = dme1737_init_device(dev);
+        if (err) {
                 dev_err(dev, "Failed to initialize device.\n");
                 goto exit_kfree;
         }
 
         /* Create sysfs files */
-        if ((err = dme1737_create_files(dev))) {
+        err = dme1737_create_files(dev);
+        if (err) {
                 dev_err(dev, "Failed to create sysfs files.\n");
                 goto exit_kfree;
         }
@@ -2628,7 +2688,8 @@ static int __init dme1737_init(void)
         int err;
         unsigned short addr;
 
-        if ((err = i2c_add_driver(&dme1737_i2c_driver))) {
+        err = i2c_add_driver(&dme1737_i2c_driver);
+        if (err) {
                 goto exit;
         }
 
@@ -2641,12 +2702,14 @@ static int __init dme1737_init(void)
                 return 0;
         }
 
-        if ((err = platform_driver_register(&dme1737_isa_driver))) {
+        err = platform_driver_register(&dme1737_isa_driver);
+        if (err) {
                 goto exit_del_i2c_driver;
         }
 
         /* Sets global pdev as a side effect */
-        if ((err = dme1737_isa_device_add(addr))) {
+        err = dme1737_isa_device_add(addr);
+        if (err) {
                 goto exit_del_isa_driver;
         }
 
diff --git a/drivers/hwmon/emc1403.c b/drivers/hwmon/emc1403.c
index 8dee3f38fdf..5dea9faa165 100644
--- a/drivers/hwmon/emc1403.c
+++ b/drivers/hwmon/emc1403.c
@@ -269,23 +269,30 @@ static int emc1403_detect(struct i2c_client *client,
                         struct i2c_board_info *info)
 {
         int id;
-        /* Check if thermal chip is SMSC and EMC1403 */
+        /* Check if thermal chip is SMSC and EMC1403 or EMC1423 */
 
         id = i2c_smbus_read_byte_data(client, THERMAL_SMSC_ID_REG);
         if (id != 0x5d)
                 return -ENODEV;
 
+        id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG);
+        switch (id) {
+        case 0x21:
+                strlcpy(info->type, "emc1403", I2C_NAME_SIZE);
+                break;
+        case 0x23:
+                strlcpy(info->type, "emc1423", I2C_NAME_SIZE);
+                break;
         /* Note: 0x25 is the 1404 which is very similar and this
            driver could be extended */
-        id = i2c_smbus_read_byte_data(client, THERMAL_PID_REG);
-        if (id != 0x21)
+        default:
                 return -ENODEV;
+        }
 
         id = i2c_smbus_read_byte_data(client, THERMAL_REVISION_REG);
         if (id != 0x01)
                 return -ENODEV;
 
-        strlcpy(info->type, "emc1403", I2C_NAME_SIZE);
         return 0;
 }
 
@@ -342,6 +349,7 @@ static const unsigned short emc1403_address_list[] = {
 
 static const struct i2c_device_id emc1403_idtable[] = {
         { "emc1403", 0 },
+        { "emc1423", 0 },
         { }
 };
 MODULE_DEVICE_TABLE(i2c, emc1403_idtable);
diff --git a/drivers/hwmon/fschmd.c b/drivers/hwmon/fschmd.c
index d4d4ca65d37..aa6d8b686f8 100644
--- a/drivers/hwmon/fschmd.c
+++ b/drivers/hwmon/fschmd.c
@@ -49,7 +49,6 @@
 #include <linux/kref.h>
 
 /* Addresses to scan */
-static DEFINE_MUTEX(watchdog_mutex);
 static const unsigned short normal_i2c[] = { 0x73, I2C_CLIENT_END };
 
 /* Insmod parameters */
@@ -850,7 +849,7 @@ static ssize_t watchdog_write(struct file *filp, const char __user *buf,
 
 static long watchdog_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
-        static struct watchdog_info ident = {
+        struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING | WDIOF_SETTIMEOUT |
                                 WDIOF_CARDRESET,
                 .identity = "FSC watchdog"
@@ -858,7 +857,6 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd, unsigned long ar
         int i, ret = 0;
         struct fschmd_data *data = filp->private_data;
 
-        mutex_lock(&watchdog_mutex);
         switch (cmd) {
         case WDIOC_GETSUPPORT:
                 ident.firmware_version = data->revision;
@@ -915,7 +913,6 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd, unsigned long ar
         default:
                 ret = -ENOTTY;
         }
-        mutex_unlock(&watchdog_mutex);
         return ret;
 }
 
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index a428a926419..316b64823f7 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -38,6 +38,8 @@
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -1570,26 +1572,25 @@ static int __init it87_find(unsigned short *address,
         case 0xffff:    /* No device at all */
                 goto exit;
         default:
-                pr_debug(DRVNAME ": Unsupported chip (DEVID=0x%x)\n",
-                         chip_type);
+                pr_debug("Unsupported chip (DEVID=0x%x)\n", chip_type);
                 goto exit;
         }
 
         superio_select(PME);
         if (!(superio_inb(IT87_ACT_REG) & 0x01)) {
-                pr_info("it87: Device not activated, skipping\n");
+                pr_info("Device not activated, skipping\n");
                 goto exit;
         }
 
         *address = superio_inw(IT87_BASE_REG) & ~(IT87_EXTENT - 1);
         if (*address == 0) {
-                pr_info("it87: Base address not set, skipping\n");
+                pr_info("Base address not set, skipping\n");
                 goto exit;
         }
 
         err = 0;
         sio_data->revision = superio_inb(DEVREV) & 0x0f;
-        pr_info("it87: Found IT%04xF chip at 0x%x, revision %d\n",
+        pr_info("Found IT%04xF chip at 0x%x, revision %d\n",
                 chip_type, *address, sio_data->revision);
 
         /* in8 (Vbat) is always internal */
@@ -1615,7 +1616,7 @@ static int __init it87_find(unsigned short *address,
                 } else {
                         /* We need at least 4 VID pins */
                         if (reg & 0x0f) {
-                                pr_info("it87: VID is disabled (pins used for GPIO)\n");
+                                pr_info("VID is disabled (pins used for GPIO)\n");
                                 sio_data->skip_vid = 1;
                         }
                 }
@@ -1651,7 +1652,7 @@ static int __init it87_find(unsigned short *address,
                 if (sio_data->type == it8720 && !(reg & (1 << 1))) {
                         reg |= (1 << 1);
                         superio_outb(IT87_SIO_PINX2_REG, reg);
-                        pr_notice("it87: Routing internal VCCH to in7\n");
+                        pr_notice("Routing internal VCCH to in7\n");
                 }
                 if (reg & (1 << 0))
                         sio_data->internal |= (1 << 0);
@@ -1661,7 +1662,7 @@ static int __init it87_find(unsigned short *address,
                 sio_data->beep_pin = superio_inb(IT87_SIO_BEEP_PIN_REG) & 0x3f;
         }
         if (sio_data->beep_pin)
-                pr_info("it87: Beeping is supported\n");
+                pr_info("Beeping is supported\n");
 
         /* Disable specific features based on DMI strings */
         board_vendor = dmi_get_system_info(DMI_BOARD_VENDOR);
@@ -1675,8 +1676,7 @@ static int __init it87_find(unsigned short *address,
                            the PWM2 duty cycle, so we disable it.
                            I use the board name string as the trigger in case
                            the same board is ever used in other systems. */
-                        pr_info("it87: Disabling pwm2 due to "
-                                "hardware constraints\n");
+                        pr_info("Disabling pwm2 due to hardware constraints\n");
                         sio_data->skip_pwm = (1 << 1);
                 }
         }
@@ -2189,28 +2189,26 @@ static int __init it87_device_add(unsigned short address,
         pdev = platform_device_alloc(DRVNAME, address);
         if (!pdev) {
                 err = -ENOMEM;
-                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                pr_err("Device allocation failed\n");
                 goto exit;
         }
 
         err = platform_device_add_resources(pdev, &res, 1);
         if (err) {
-                printk(KERN_ERR DRVNAME ": Device resource addition failed "
-                       "(%d)\n", err);
+                pr_err("Device resource addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
         err = platform_device_add_data(pdev, sio_data,
                                        sizeof(struct it87_sio_data));
         if (err) {
-                printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+                pr_err("Platform data allocation failed\n");
                 goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
         if (err) {
-                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
-                       err);
+                pr_err("Device addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
diff --git a/drivers/hwmon/lm78.c b/drivers/hwmon/lm78.c
index 72ff2c4e757..4cb24eafe31 100644
--- a/drivers/hwmon/lm78.c
+++ b/drivers/hwmon/lm78.c
@@ -19,6 +19,8 @@
     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -858,7 +860,7 @@ static int __init lm78_isa_found(unsigned short address)
          * individually for the probing phase. */
         for (port = address; port < address + LM78_EXTENT; port++) {
                 if (!request_region(port, 1, "lm78")) {
-                        pr_debug("lm78: Failed to request port 0x%x\n", port);
+                        pr_debug("Failed to request port 0x%x\n", port);
                         goto release;
                 }
         }
@@ -920,7 +922,7 @@ static int __init lm78_isa_found(unsigned short address)
                 found = 1;
 
         if (found)
-                pr_info("lm78: Found an %s chip at %#x\n",
+                pr_info("Found an %s chip at %#x\n",
                         val & 0x80 ? "LM79" : "LM78", (int)address);
 
  release:
@@ -942,21 +944,19 @@ static int __init lm78_isa_device_add(unsigned short address)
         pdev = platform_device_alloc("lm78", address);
         if (!pdev) {
                 err = -ENOMEM;
-                printk(KERN_ERR "lm78: Device allocation failed\n");
+                pr_err("Device allocation failed\n");
                 goto exit;
         }
 
         err = platform_device_add_resources(pdev, &res, 1);
         if (err) {
-                printk(KERN_ERR "lm78: Device resource addition failed "
-                       "(%d)\n", err);
+                pr_err("Device resource addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
         if (err) {
-                printk(KERN_ERR "lm78: Device addition failed (%d)\n",
-                       err);
+                pr_err("Device addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
diff --git a/drivers/hwmon/pc87360.c b/drivers/hwmon/pc87360.c
index 68e69a49633..3d99b8854d7 100644
--- a/drivers/hwmon/pc87360.c
+++ b/drivers/hwmon/pc87360.c
@@ -33,6 +33,8 @@
  *  the standard Super-I/O addresses is used (0x2E/0x2F or 0x4E/0x4F).
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -1031,16 +1033,15 @@ static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses
 
                 val = superio_inb(sioaddr, ACT);
                 if (!(val & 0x01)) {
-                        printk(KERN_INFO "pc87360: Device 0x%02x not "
-                               "activated\n", logdev[i]);
+                        pr_info("Device 0x%02x not activated\n", logdev[i]);
                         continue;
                 }
 
                 val = (superio_inb(sioaddr, BASE) << 8)
                     | superio_inb(sioaddr, BASE + 1);
                 if (!val) {
-                        printk(KERN_INFO "pc87360: Base address not set for "
-                               "device 0x%02x\n", logdev[i]);
+                        pr_info("Base address not set for device 0x%02x\n",
+                                logdev[i]);
                         continue;
                 }
 
@@ -1050,17 +1051,15 @@ static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses
                         confreg[0] = superio_inb(sioaddr, 0xF0);
                         confreg[1] = superio_inb(sioaddr, 0xF1);
 
-#ifdef DEBUG
-                        printk(KERN_DEBUG "pc87360: Fan 1: mon=%d "
-                               "ctrl=%d inv=%d\n", (confreg[0]>>2)&1,
-                               (confreg[0]>>3)&1, (confreg[0]>>4)&1);
-                        printk(KERN_DEBUG "pc87360: Fan 2: mon=%d "
-                               "ctrl=%d inv=%d\n", (confreg[0]>>5)&1,
-                               (confreg[0]>>6)&1, (confreg[0]>>7)&1);
-                        printk(KERN_DEBUG "pc87360: Fan 3: mon=%d "
-                               "ctrl=%d inv=%d\n", confreg[1]&1,
-                               (confreg[1]>>1)&1, (confreg[1]>>2)&1);
-#endif
+                        pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 1,
+                                 (confreg[0] >> 2) & 1, (confreg[0] >> 3) & 1,
+                                 (confreg[0] >> 4) & 1);
+                        pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 2,
+                                 (confreg[0] >> 5) & 1, (confreg[0] >> 6) & 1,
+                                 (confreg[0] >> 7) & 1);
+                        pr_debug("Fan %d: mon=%d ctrl=%d inv=%d\n", 3,
+                                 confreg[1] & 1, (confreg[1] >> 1) & 1,
+                                 (confreg[1] >> 2) & 1);
                 } else if (i==1) { /* Voltages */
                         /* Are we using thermistors? */
                         if (*devid == 0xE9) { /* PC87366 */
@@ -1071,14 +1070,12 @@ static int __init pc87360_find(int sioaddr, u8 *devid, unsigned short *addresses
                                 confreg[3] = superio_inb(sioaddr, 0x25);
 
                                 if (confreg[2] & 0x40) {
-                                        printk(KERN_INFO "pc87360: Using "
-                                               "thermistors for temperature "
-                                               "monitoring\n");
+                                        pr_info("Using thermistors for "
+                                                "temperature monitoring\n");
                                 }
                                 if (confreg[3] & 0xE0) {
-                                        printk(KERN_INFO "pc87360: VID "
-                                               "inputs routed (mode %u)\n",
-                                               confreg[3] >> 5);
+                                        pr_info("VID inputs routed (mode %u)\n",
+                                                confreg[3] >> 5);
                                 }
                         }
                 }
@@ -1616,7 +1613,7 @@ static int __init pc87360_device_add(unsigned short address)
         pdev = platform_device_alloc("pc87360", address);
         if (!pdev) {
                 err = -ENOMEM;
-                printk(KERN_ERR "pc87360: Device allocation failed\n");
+                pr_err("Device allocation failed\n");
                 goto exit;
         }
 
@@ -1639,15 +1636,13 @@ static int __init pc87360_device_add(unsigned short address)
 
         err = platform_device_add_resources(pdev, res, res_count);
         if (err) {
-                printk(KERN_ERR "pc87360: Device resources addition failed "
-                       "(%d)\n", err);
+                pr_err("Device resources addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
         if (err) {
-                printk(KERN_ERR "pc87360: Device addition failed (%d)\n",
-                       err);
+                pr_err("Device addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
@@ -1666,8 +1661,7 @@ static int __init pc87360_init(void)
 
         if (pc87360_find(0x2e, &devid, extra_isa)
          && pc87360_find(0x4e, &devid, extra_isa)) {
-                printk(KERN_WARNING "pc87360: PC8736x not detected, "
-                       "module not inserted.\n");
+                pr_warn("PC8736x not detected, module not inserted\n");
                 return -ENODEV;
         }
 
@@ -1680,8 +1674,7 @@ static int __init pc87360_init(void)
         }
 
         if (address == 0x0000) {
-                printk(KERN_WARNING "pc87360: No active logical device, "
-                       "module not inserted.\n");
+                pr_warn("No active logical device, module not inserted\n");
                 return -ENODEV;
         }
 
diff --git a/drivers/hwmon/pc87427.c b/drivers/hwmon/pc87427.c
index 9ec4daaf6ca..8da2181630b 100644
--- a/drivers/hwmon/pc87427.c
+++ b/drivers/hwmon/pc87427.c
@@ -22,6 +22,8 @@
  *  mode, and voltages aren't supported at all.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -1077,7 +1079,7 @@ static int __devinit pc87427_probe(struct platform_device *pdev)
         data = kzalloc(sizeof(struct pc87427_data), GFP_KERNEL);
         if (!data) {
                 err = -ENOMEM;
-                printk(KERN_ERR DRVNAME ": Out of memory\n");
+                pr_err("Out of memory\n");
                 goto exit;
         }
 
@@ -1196,28 +1198,26 @@ static int __init pc87427_device_add(const struct pc87427_sio_data *sio_data)
         pdev = platform_device_alloc(DRVNAME, res[0].start);
         if (!pdev) {
                 err = -ENOMEM;
-                printk(KERN_ERR DRVNAME ": Device allocation failed\n");
+                pr_err("Device allocation failed\n");
                 goto exit;
         }
 
         err = platform_device_add_resources(pdev, res, res_count);
         if (err) {
-                printk(KERN_ERR DRVNAME ": Device resource addition failed "
-                       "(%d)\n", err);
+                pr_err("Device resource addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
         err = platform_device_add_data(pdev, sio_data,
                                        sizeof(struct pc87427_sio_data));
         if (err) {
-                printk(KERN_ERR DRVNAME ": Platform data allocation failed\n");
+                pr_err("Platform data allocation failed\n");
                 goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
         if (err) {
-                printk(KERN_ERR DRVNAME ": Device addition failed (%d)\n",
-                       err);
+                pr_err("Device addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
@@ -1249,23 +1249,23 @@ static int __init pc87427_find(int sioaddr, struct pc87427_sio_data *sio_data)
 
                 val = superio_inb(sioaddr, SIOREG_ACT);
                 if (!(val & 0x01)) {
-                        printk(KERN_INFO DRVNAME ": Logical device 0x%02x "
-                               "not activated\n", logdev[i]);
+                        pr_info("Logical device 0x%02x not activated\n",
+                                logdev[i]);
                         continue;
                 }
 
                 val = superio_inb(sioaddr, SIOREG_MAP);
                 if (val & 0x01) {
-                        printk(KERN_WARNING DRVNAME ": Logical device 0x%02x "
-                               "is memory-mapped, can't use\n", logdev[i]);
+                        pr_warn("Logical device 0x%02x is memory-mapped, "
+                                "can't use\n", logdev[i]);
                         continue;
                 }
 
                 val = (superio_inb(sioaddr, SIOREG_IOBASE) << 8)
                     | superio_inb(sioaddr, SIOREG_IOBASE + 1);
                 if (!val) {
-                        printk(KERN_INFO DRVNAME ": I/O base address not set "
-                               "for logical device 0x%02x\n", logdev[i]);
+                        pr_info("I/O base address not set for logical device "
+                                "0x%02x\n", logdev[i]);
                         continue;
                 }
                 sio_data->address[i] = val;
diff --git a/drivers/hwmon/via686a.c b/drivers/hwmon/via686a.c
index 13e8d218e49..25e91665a0a 100644
--- a/drivers/hwmon/via686a.c
+++ b/drivers/hwmon/via686a.c
@@ -689,6 +689,13 @@ static int __devexit via686a_remove(struct platform_device *pdev)
         return 0;
 }
 
+static void via686a_update_fan_div(struct via686a_data *data)
+{
+        int reg = via686a_read_value(data, VIA686A_REG_FANDIV);
+        data->fan_div[0] = (reg >> 4) & 0x03;
+        data->fan_div[1] = reg >> 6;
+}
+
 static void __devinit via686a_init_device(struct via686a_data *data)
 {
         u8 reg;
@@ -702,6 +709,9 @@ static void __devinit via686a_init_device(struct via686a_data *data)
         via686a_write_value(data, VIA686A_REG_TEMP_MODE,
                             (reg & ~VIA686A_TEMP_MODE_MASK)
                             | VIA686A_TEMP_MODE_CONTINUOUS);
+
+        /* Pre-read fan clock divisor values */
+        via686a_update_fan_div(data);
 }
 
 static struct via686a_data *via686a_update_device(struct device *dev)
@@ -753,9 +763,7 @@ static struct via686a_data *via686a_update_device(struct device *dev)
                     (via686a_read_value(data, VIA686A_REG_TEMP_LOW23) &
                      0xc0) >> 6;
 
-                i = via686a_read_value(data, VIA686A_REG_FANDIV);
-                data->fan_div[0] = (i >> 4) & 0x03;
-                data->fan_div[1] = i >> 6;
+                via686a_update_fan_div(data);
                 data->alarms =
                     via686a_read_value(data,
                                        VIA686A_REG_ALARM1) |
diff --git a/drivers/hwmon/w83781d.c b/drivers/hwmon/w83781d.c
index c84b9b4e696..eed43a008be 100644
--- a/drivers/hwmon/w83781d.c
+++ b/drivers/hwmon/w83781d.c
@@ -33,6 +33,8 @@
 
 */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -1798,8 +1800,7 @@ w83781d_isa_found(unsigned short address)
          * individually for the probing phase. */
         for (port = address; port < address + W83781D_EXTENT; port++) {
                 if (!request_region(port, 1, "w83781d")) {
-                        pr_debug("w83781d: Failed to request port 0x%x\n",
-                                 port);
+                        pr_debug("Failed to request port 0x%x\n", port);
                         goto release;
                 }
         }
@@ -1811,7 +1812,7 @@ w83781d_isa_found(unsigned short address)
         if (inb_p(address + 2) != val
          || inb_p(address + 3) != val
          || inb_p(address + 7) != val) {
-                pr_debug("w83781d: Detection failed at step 1\n");
+                pr_debug("Detection failed at step %d\n", 1);
                 goto release;
         }
 #undef REALLY_SLOW_IO
@@ -1820,14 +1821,14 @@ w83781d_isa_found(unsigned short address)
            MSB (busy flag) should be clear initially, set after the write. */
         save = inb_p(address + W83781D_ADDR_REG_OFFSET);
         if (save & 0x80) {
-                pr_debug("w83781d: Detection failed at step 2\n");
+                pr_debug("Detection failed at step %d\n", 2);
                 goto release;
         }
         val = ~save & 0x7f;
         outb_p(val, address + W83781D_ADDR_REG_OFFSET);
         if (inb_p(address + W83781D_ADDR_REG_OFFSET) != (val | 0x80)) {
                 outb_p(save, address + W83781D_ADDR_REG_OFFSET);
-                pr_debug("w83781d: Detection failed at step 3\n");
+                pr_debug("Detection failed at step %d\n", 3);
                 goto release;
         }
 
@@ -1835,7 +1836,7 @@ w83781d_isa_found(unsigned short address)
         outb_p(W83781D_REG_CONFIG, address + W83781D_ADDR_REG_OFFSET);
         val = inb_p(address + W83781D_DATA_REG_OFFSET);
         if (val & 0x80) {
-                pr_debug("w83781d: Detection failed at step 4\n");
+                pr_debug("Detection failed at step %d\n", 4);
                 goto release;
         }
         outb_p(W83781D_REG_BANK, address + W83781D_ADDR_REG_OFFSET);
@@ -1844,19 +1845,19 @@ w83781d_isa_found(unsigned short address)
         val = inb_p(address + W83781D_DATA_REG_OFFSET);
         if ((!(save & 0x80) && (val != 0xa3))
          || ((save & 0x80) && (val != 0x5c))) {
-                pr_debug("w83781d: Detection failed at step 5\n");
+                pr_debug("Detection failed at step %d\n", 5);
                 goto release;
         }
         outb_p(W83781D_REG_I2C_ADDR, address + W83781D_ADDR_REG_OFFSET);
         val = inb_p(address + W83781D_DATA_REG_OFFSET);
         if (val < 0x03 || val > 0x77) { /* Not a valid I2C address */
-                pr_debug("w83781d: Detection failed at step 6\n");
+                pr_debug("Detection failed at step %d\n", 6);
                 goto release;
         }
 
         /* The busy flag should be clear again */
         if (inb_p(address + W83781D_ADDR_REG_OFFSET) & 0x80) {
-                pr_debug("w83781d: Detection failed at step 7\n");
+                pr_debug("Detection failed at step %d\n", 7);
                 goto release;
         }
 
@@ -1871,7 +1872,7 @@ w83781d_isa_found(unsigned short address)
                 found = 1;
 
         if (found)
-                pr_info("w83781d: Found a %s chip at %#x\n",
+                pr_info("Found a %s chip at %#x\n",
                         val == 0x30 ? "W83782D" : "W83781D", (int)address);
 
  release:
@@ -1894,21 +1895,19 @@ w83781d_isa_device_add(unsigned short address)
         pdev = platform_device_alloc("w83781d", address);
         if (!pdev) {
                 err = -ENOMEM;
-                printk(KERN_ERR "w83781d: Device allocation failed\n");
+                pr_err("Device allocation failed\n");
                 goto exit;
         }
 
         err = platform_device_add_resources(pdev, &res, 1);
         if (err) {
-                printk(KERN_ERR "w83781d: Device resource addition failed "
-                       "(%d)\n", err);
+                pr_err("Device resource addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
         err = platform_device_add(pdev);
         if (err) {
-                printk(KERN_ERR "w83781d: Device addition failed (%d)\n",
-                       err);
+                pr_err("Device addition failed (%d)\n", err);
                 goto exit_device_put;
         }
 
diff --git a/drivers/hwmon/w83792d.c b/drivers/hwmon/w83792d.c
index 679718e6b01..63841f8cec0 100644
--- a/drivers/hwmon/w83792d.c
+++ b/drivers/hwmon/w83792d.c
@@ -691,7 +691,7 @@ store_pwm_mode(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
-show_regs_chassis(struct device *dev, struct device_attribute *attr,
+show_chassis(struct device *dev, struct device_attribute *attr,
                         char *buf)
 {
         struct w83792d_data *data = w83792d_update_device(dev);
@@ -699,6 +699,16 @@ show_regs_chassis(struct device *dev, struct device_attribute *attr,
 }
 
 static ssize_t
+show_regs_chassis(struct device *dev, struct device_attribute *attr,
+                        char *buf)
+{
+        dev_warn(dev,
+                 "Attribute %s is deprecated, use intrusion0_alarm instead\n",
+                 "chassis");
+        return show_chassis(dev, attr, buf);
+}
+
+static ssize_t
 show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct w83792d_data *data = w83792d_update_device(dev);
@@ -706,7 +716,7 @@ show_chassis_clear(struct device *dev, struct device_attribute *attr, char *buf)
 }
 
 static ssize_t
-store_chassis_clear(struct device *dev, struct device_attribute *attr,
+store_chassis_clear_legacy(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count)
 {
         struct i2c_client *client = to_i2c_client(dev);
@@ -714,6 +724,10 @@ store_chassis_clear(struct device *dev, struct device_attribute *attr,
         u32 val;
         u8 temp1 = 0, temp2 = 0;
 
+        dev_warn(dev,
+                 "Attribute %s is deprecated, use intrusion0_alarm instead\n",
+                 "chassis_clear");
+
         val = simple_strtoul(buf, NULL, 10);
         mutex_lock(&data->update_lock);
         data->chassis_clear = SENSORS_LIMIT(val, 0 ,1);
@@ -726,6 +740,27 @@ store_chassis_clear(struct device *dev, struct device_attribute *attr,
         return count;
 }
 
+static ssize_t
+store_chassis_clear(struct device *dev, struct device_attribute *attr,
+                        const char *buf, size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83792d_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+        u8 reg;
+
+        if (strict_strtoul(buf, 10, &val) || val != 0)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        reg = w83792d_read_value(client, W83792D_REG_CHASSIS_CLR);
+        w83792d_write_value(client, W83792D_REG_CHASSIS_CLR, reg | 0x80);
+        data->valid = 0;                /* Force cache refresh */
+        mutex_unlock(&data->update_lock);
+
+        return count;
+}
+
 /* For Smart Fan I / Thermal Cruise */
 static ssize_t
 show_thermal_cruise(struct device *dev, struct device_attribute *attr,
@@ -1012,7 +1047,9 @@ static SENSOR_DEVICE_ATTR(fan5_alarm, S_IRUGO, show_alarm, NULL, 22);
 static SENSOR_DEVICE_ATTR(fan6_alarm, S_IRUGO, show_alarm, NULL, 23);
 static DEVICE_ATTR(chassis, S_IRUGO, show_regs_chassis, NULL);
 static DEVICE_ATTR(chassis_clear, S_IRUGO | S_IWUSR,
-                        show_chassis_clear, store_chassis_clear);
+                        show_chassis_clear, store_chassis_clear_legacy);
+static DEVICE_ATTR(intrusion0_alarm, S_IRUGO | S_IWUSR,
+                        show_chassis, store_chassis_clear);
 static SENSOR_DEVICE_ATTR(pwm1, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 0);
 static SENSOR_DEVICE_ATTR(pwm2, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 1);
 static SENSOR_DEVICE_ATTR(pwm3, S_IWUSR | S_IRUGO, show_pwm, store_pwm, 2);
@@ -1214,6 +1251,7 @@ static struct attribute *w83792d_attributes[] = {
         &dev_attr_alarms.attr,
         &dev_attr_chassis.attr,
         &dev_attr_chassis_clear.attr,
+        &dev_attr_intrusion0_alarm.attr,
         &sensor_dev_attr_tolerance1.dev_attr.attr,
         &sensor_dev_attr_thermal_cruise1.dev_attr.attr,
         &sensor_dev_attr_tolerance2.dev_attr.attr,
diff --git a/drivers/hwmon/w83793.c b/drivers/hwmon/w83793.c
index 8e540ada47d..e3bdedfb534 100644
--- a/drivers/hwmon/w83793.c
+++ b/drivers/hwmon/w83793.c
@@ -51,7 +51,6 @@
 #define WATCHDOG_TIMEOUT 2      /* 2 minute default timeout */
 
 /* Addresses to scan */
-static DEFINE_MUTEX(watchdog_mutex);
 static const unsigned short normal_i2c[] = { 0x2c, 0x2d, 0x2e, 0x2f,
                                                 I2C_CLIENT_END };
 
@@ -421,14 +420,17 @@ store_beep_enable(struct device *dev, struct device_attribute *attr,
 
 /* Write any value to clear chassis alarm */
 static ssize_t
-store_chassis_clear(struct device *dev,
-                    struct device_attribute *attr, const char *buf,
-                    size_t count)
+store_chassis_clear_legacy(struct device *dev,
+                           struct device_attribute *attr, const char *buf,
+                           size_t count)
 {
         struct i2c_client *client = to_i2c_client(dev);
         struct w83793_data *data = i2c_get_clientdata(client);
         u8 val;
 
+        dev_warn(dev, "Attribute chassis is deprecated, "
+                 "use intrusion0_alarm instead\n");
+
         mutex_lock(&data->update_lock);
         val = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
         val |= 0x80;
@@ -437,6 +439,28 @@ store_chassis_clear(struct device *dev,
         return count;
 }
 
+/* Write 0 to clear chassis alarm */
+static ssize_t
+store_chassis_clear(struct device *dev,
+                    struct device_attribute *attr, const char *buf,
+                    size_t count)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct w83793_data *data = i2c_get_clientdata(client);
+        unsigned long val;
+        u8 reg;
+
+        if (strict_strtoul(buf, 10, &val) || val != 0)
+                return -EINVAL;
+
+        mutex_lock(&data->update_lock);
+        reg = w83793_read_value(client, W83793_REG_CLR_CHASSIS);
+        w83793_write_value(client, W83793_REG_CLR_CHASSIS, reg | 0x80);
+        data->valid = 0;                /* Force cache refresh */
+        mutex_unlock(&data->update_lock);
+        return count;
+}
+
 #define FAN_INPUT                       0
 #define FAN_MIN                         1
 static ssize_t
@@ -1102,6 +1126,8 @@ static DEVICE_ATTR(vrm, S_IWUSR | S_IRUGO, show_vrm, store_vrm);
 
 static struct sensor_device_attribute_2 sda_single_files[] = {
         SENSOR_ATTR_2(chassis, S_IWUSR | S_IRUGO, show_alarm_beep,
+                      store_chassis_clear_legacy, ALARM_STATUS, 30),
+        SENSOR_ATTR_2(intrusion0_alarm, S_IWUSR | S_IRUGO, show_alarm_beep,
                       store_chassis_clear, ALARM_STATUS, 30),
         SENSOR_ATTR_2(beep_enable, S_IWUSR | S_IRUGO, show_beep_enable,
                       store_beep_enable, NOT_USED, NOT_USED),
@@ -1323,7 +1349,7 @@ static ssize_t watchdog_write(struct file *filp, const char __user *buf,
 static long watchdog_ioctl(struct file *filp, unsigned int cmd,
                            unsigned long arg)
 {
-        static struct watchdog_info ident = {
+        struct watchdog_info ident = {
                 .options = WDIOF_KEEPALIVEPING |
                            WDIOF_SETTIMEOUT |
                            WDIOF_CARDRESET,
@@ -1333,7 +1359,6 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd,
         int val, ret = 0;
         struct w83793_data *data = filp->private_data;
 
-        mutex_lock(&watchdog_mutex);
         switch (cmd) {
         case WDIOC_GETSUPPORT:
                 if (!nowayout)
@@ -1387,7 +1412,6 @@ static long watchdog_ioctl(struct file *filp, unsigned int cmd,
         default:
                 ret = -ENOTTY;
         }
-        mutex_unlock(&watchdog_mutex);
         return ret;
 }
 
diff --git a/drivers/hwmon/w83795.c b/drivers/hwmon/w83795.c
index cdbc7448491..845232d7f61 100644
--- a/drivers/hwmon/w83795.c
+++ b/drivers/hwmon/w83795.c
@@ -458,6 +458,7 @@ static void w83795_update_limits(struct i2c_client *client)
 {
         struct w83795_data *data = i2c_get_clientdata(client);
         int i, limit;
+        u8 lsb;
 
         /* Read the voltage limits */
         for (i = 0; i < ARRAY_SIZE(data->in); i++) {
@@ -479,9 +480,8 @@ static void w83795_update_limits(struct i2c_client *client)
         }
 
         /* Read the fan limits */
+        lsb = 0; /* Silent false gcc warning */
         for (i = 0; i < ARRAY_SIZE(data->fan); i++) {
-                u8 lsb;
-
                 /* Each register contains LSB for 2 fans, but we want to
                  * read it only once to save time */
                 if ((i & 1) == 0 && (data->has_fan & (3 << i)))
diff --git a/drivers/i2c/busses/i2c-nomadik.c b/drivers/i2c/busses/i2c-nomadik.c
index c9fffd0389f..2bd3469b307 100644
--- a/drivers/i2c/busses/i2c-nomadik.c
+++ b/drivers/i2c/busses/i2c-nomadik.c
@@ -434,7 +434,7 @@ static int read_i2c(struct nmk_i2c_dev *dev)
         }
 
         if (timeout == 0) {
-                /* controler has timedout, re-init the h/w */
+                /* controller has timedout, re-init the h/w */
                 dev_err(&dev->pdev->dev, "controller timed out, re-init h/w\n");
                 (void) init_hw(dev);
                 status = -ETIMEDOUT;
@@ -498,7 +498,7 @@ static int write_i2c(struct nmk_i2c_dev *dev)
         }
 
         if (timeout == 0) {
-                /* controler has timedout, re-init the h/w */
+                /* controller has timedout, re-init the h/w */
                 dev_err(&dev->pdev->dev, "controller timed out, re-init h/w\n");
                 (void) init_hw(dev);
                 status = -ETIMEDOUT;
diff --git a/drivers/infiniband/hw/cxgb3/cxio_wr.h b/drivers/infiniband/hw/cxgb3/cxio_wr.h
index 4bb997aa39d..83d2e19d31a 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_wr.h
+++ b/drivers/infiniband/hw/cxgb3/cxio_wr.h
@@ -689,7 +689,7 @@ struct t3_swrq {
  * A T3 WQ implements both the SQ and RQ.
  */
 struct t3_wq {
-        union t3_wr *queue;             /* DMA accessable memory */
+        union t3_wr *queue;             /* DMA accessible memory */
         dma_addr_t dma_addr;            /* DMA address for HW */
         DEFINE_DMA_UNMAP_ADDR(mapping); /* unmap kruft */
         u32 error;                      /* 1 once we go to ERROR */
diff --git a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
index cc600c2dd0b..2fe19ec9ba6 100644
--- a/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
+++ b/drivers/infiniband/hw/cxgb4/iw_cxgb4.h
@@ -46,7 +46,6 @@
 #include <linux/timer.h>
 #include <linux/io.h>
 #include <linux/kfifo.h>
-#include <linux/mutex.h>
 
 #include <asm/byteorder.h>
 
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index dbbb0e85afe..abd409d592e 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -332,7 +332,7 @@ MODULE_PARM_DESC(txselect, \
 #define krp_serdesctrl KREG_IBPORT_IDX(IBSerdesCtrl)
 
 /*
- * Per-context kernel registers.  Acess only with qib_read_kreg_ctxt()
+ * Per-context kernel registers.  Access only with qib_read_kreg_ctxt()
  * or qib_write_kreg_ctxt()
  */
 #define krc_rcvhdraddr KREG_IDX(RcvHdrAddr0)
diff --git a/drivers/input/joystick/Kconfig b/drivers/input/joystick/Kconfig
index 5b596165b57..56eb471b557 100644
--- a/drivers/input/joystick/Kconfig
+++ b/drivers/input/joystick/Kconfig
@@ -255,6 +255,16 @@ config JOYSTICK_AMIGA
           To compile this driver as a module, choose M here: the
           module will be called amijoy.
 
+config JOYSTICK_AS5011
+        tristate "Austria Microsystem AS5011 joystick"
+        depends on I2C
+        help
+          Say Y here if you have an AS5011 digital joystick connected to your
+          system.
+
+          To compile this driver as a module, choose M here: the
+          module will be called as5011.
+
 config JOYSTICK_JOYDUMP
         tristate "Gameport data dumper"
         select GAMEPORT
diff --git a/drivers/input/joystick/Makefile b/drivers/input/joystick/Makefile
index f3a8cbe2abb..92dc0de9dfe 100644
--- a/drivers/input/joystick/Makefile
+++ b/drivers/input/joystick/Makefile
@@ -7,6 +7,7 @@
 obj-$(CONFIG_JOYSTICK_A3D)              += a3d.o
 obj-$(CONFIG_JOYSTICK_ADI)              += adi.o
 obj-$(CONFIG_JOYSTICK_AMIGA)            += amijoy.o
+obj-$(CONFIG_JOYSTICK_AS5011)           += as5011.o
 obj-$(CONFIG_JOYSTICK_ANALOG)           += analog.o
 obj-$(CONFIG_JOYSTICK_COBRA)            += cobra.o
 obj-$(CONFIG_JOYSTICK_DB9)              += db9.o
diff --git a/drivers/input/joystick/as5011.c b/drivers/input/joystick/as5011.c
new file mode 100644
index 00000000000..f6732b57ca0
--- /dev/null
+++ b/drivers/input/joystick/as5011.c
@@ -0,0 +1,367 @@
+/*
+ * Copyright (c) 2010, 2011 Fabien Marteau <fabien.marteau@armadeus.com>
+ * Sponsored by ARMadeus Systems
+ *
+ * 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
+ *
+ * Driver for Austria Microsystems joysticks AS5011
+ *
+ * TODO:
+ *      - Power on the chip when open() and power down when close()
+ *      - Manage power mode
+ */
+
+#include <linux/i2c.h>
+#include <linux/interrupt.h>
+#include <linux/input.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <linux/input/as5011.h>
+#include <linux/slab.h>
+
+#define DRIVER_DESC "Driver for Austria Microsystems AS5011 joystick"
+#define MODULE_DEVICE_ALIAS "as5011"
+
+MODULE_AUTHOR("Fabien Marteau <fabien.marteau@armadeus.com>");
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
+
+/* registers */
+#define AS5011_CTRL1            0x76
+#define AS5011_CTRL2            0x75
+#define AS5011_XP               0x43
+#define AS5011_XN               0x44
+#define AS5011_YP               0x53
+#define AS5011_YN               0x54
+#define AS5011_X_REG            0x41
+#define AS5011_Y_REG            0x42
+#define AS5011_X_RES_INT        0x51
+#define AS5011_Y_RES_INT        0x52
+
+/* CTRL1 bits */
+#define AS5011_CTRL1_LP_PULSED          0x80
+#define AS5011_CTRL1_LP_ACTIVE          0x40
+#define AS5011_CTRL1_LP_CONTINUE        0x20
+#define AS5011_CTRL1_INT_WUP_EN         0x10
+#define AS5011_CTRL1_INT_ACT_EN         0x08
+#define AS5011_CTRL1_EXT_CLK_EN         0x04
+#define AS5011_CTRL1_SOFT_RST           0x02
+#define AS5011_CTRL1_DATA_VALID         0x01
+
+/* CTRL2 bits */
+#define AS5011_CTRL2_EXT_SAMPLE_EN      0x08
+#define AS5011_CTRL2_RC_BIAS_ON         0x04
+#define AS5011_CTRL2_INV_SPINNING       0x02
+
+#define AS5011_MAX_AXIS 80
+#define AS5011_MIN_AXIS (-80)
+#define AS5011_FUZZ     8
+#define AS5011_FLAT     40
+
+struct as5011_device {
+        struct input_dev *input_dev;
+        struct i2c_client *i2c_client;
+        unsigned int button_gpio;
+        unsigned int button_irq;
+        unsigned int axis_irq;
+};
+
+static int as5011_i2c_write(struct i2c_client *client,
+                            uint8_t aregaddr,
+                            uint8_t avalue)
+{
+        uint8_t data[2] = { aregaddr, avalue };
+        struct i2c_msg msg = {
+                client->addr, I2C_M_IGNORE_NAK, 2, (uint8_t *)data
+        };
+        int error;
+
+        error = i2c_transfer(client->adapter, &msg, 1);
+        return error < 0 ? error : 0;
+}
+
+static int as5011_i2c_read(struct i2c_client *client,
+                           uint8_t aregaddr, signed char *value)
+{
+        uint8_t data[2] = { aregaddr };
+        struct i2c_msg msg_set[2] = {
+                { client->addr, I2C_M_REV_DIR_ADDR, 1, (uint8_t *)data },
+                { client->addr, I2C_M_RD | I2C_M_NOSTART, 1, (uint8_t *)data }
+        };
+        int error;
+
+        error = i2c_transfer(client->adapter, msg_set, 2);
+        if (error < 0)
+                return error;
+
+        *value = data[0] & 0x80 ? -1 * (1 + ~data[0]) : data[0];
+        return 0;
+}
+
+static irqreturn_t as5011_button_interrupt(int irq, void *dev_id)
+{
+        struct as5011_device *as5011 = dev_id;
+        int val = gpio_get_value_cansleep(as5011->button_gpio);
+
+        input_report_key(as5011->input_dev, BTN_JOYSTICK, !val);
+        input_sync(as5011->input_dev);
+
+        return IRQ_HANDLED;
+}
+
+static irqreturn_t as5011_axis_interrupt(int irq, void *dev_id)
+{
+        struct as5011_device *as5011 = dev_id;
+        int error;
+        signed char x, y;
+
+        error = as5011_i2c_read(as5011->i2c_client, AS5011_X_RES_INT, &x);
+        if (error < 0)
+                goto out;
+
+        error = as5011_i2c_read(as5011->i2c_client, AS5011_Y_RES_INT, &y);
+        if (error < 0)
+                goto out;
+
+        input_report_abs(as5011->input_dev, ABS_X, x);
+        input_report_abs(as5011->input_dev, ABS_Y, y);
+        input_sync(as5011->input_dev);
+
+out:
+        return IRQ_HANDLED;
+}
+
+static int __devinit as5011_configure_chip(struct as5011_device *as5011,
+                                const struct as5011_platform_data *plat_dat)
+{
+        struct i2c_client *client = as5011->i2c_client;
+        int error;
+        signed char value;
+
+        /* chip soft reset */
+        error = as5011_i2c_write(client, AS5011_CTRL1,
+                                 AS5011_CTRL1_SOFT_RST);
+        if (error < 0) {
+                dev_err(&client->dev, "Soft reset failed\n");
+                return error;
+        }
+
+        mdelay(10);
+
+        error = as5011_i2c_write(client, AS5011_CTRL1,
+                                 AS5011_CTRL1_LP_PULSED |
+                                 AS5011_CTRL1_LP_ACTIVE |
+                                 AS5011_CTRL1_INT_ACT_EN);
+        if (error < 0) {
+                dev_err(&client->dev, "Power config failed\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_CTRL2,
+                                 AS5011_CTRL2_INV_SPINNING);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't invert spinning\n");
+                return error;
+        }
+
+        /* write threshold */
+        error = as5011_i2c_write(client, AS5011_XP, plat_dat->xp);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_XN, plat_dat->xn);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_YP, plat_dat->yp);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        error = as5011_i2c_write(client, AS5011_YN, plat_dat->yn);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't write threshold\n");
+                return error;
+        }
+
+        /* to free irq gpio in chip */
+        error = as5011_i2c_read(client, AS5011_X_RES_INT, &value);
+        if (error < 0) {
+                dev_err(&client->dev, "Can't read i2c X resolution value\n");
+                return error;
+        }
+
+        return 0;
+}
+
+static int __devinit as5011_probe(struct i2c_client *client,
+                                const struct i2c_device_id *id)
+{
+        const struct as5011_platform_data *plat_data;
+        struct as5011_device *as5011;
+        struct input_dev *input_dev;
+        int irq;
+        int error;
+
+        plat_data = client->dev.platform_data;
+        if (!plat_data)
+                return -EINVAL;
+
+        if (!plat_data->axis_irq) {
+                dev_err(&client->dev, "No axis IRQ?\n");
+                return -EINVAL;
+        }
+
+        if (!i2c_check_functionality(client->adapter,
+                                     I2C_FUNC_PROTOCOL_MANGLING)) {
+                dev_err(&client->dev,
+                        "need i2c bus that supports protocol mangling\n");
+                return -ENODEV;
+        }
+
+        as5011 = kmalloc(sizeof(struct as5011_device), GFP_KERNEL);
+        input_dev = input_allocate_device();
+        if (!as5011 || !input_dev) {
+                dev_err(&client->dev,
+                        "Can't allocate memory for device structure\n");
+                error = -ENOMEM;
+                goto err_free_mem;
+        }
+
+        as5011->i2c_client = client;
+        as5011->input_dev = input_dev;
+        as5011->button_gpio = plat_data->button_gpio;
+        as5011->axis_irq = plat_data->axis_irq;
+
+        input_dev->name = "Austria Microsystem as5011 joystick";
+        input_dev->id.bustype = BUS_I2C;
+        input_dev->dev.parent = &client->dev;
+
+        __set_bit(EV_KEY, input_dev->evbit);
+        __set_bit(EV_ABS, input_dev->evbit);
+        __set_bit(BTN_JOYSTICK, input_dev->keybit);
+
+        input_set_abs_params(input_dev, ABS_X,
+                AS5011_MIN_AXIS, AS5011_MAX_AXIS, AS5011_FUZZ, AS5011_FLAT);
+        input_set_abs_params(as5011->input_dev, ABS_Y,
+                AS5011_MIN_AXIS, AS5011_MAX_AXIS, AS5011_FUZZ, AS5011_FLAT);
+
+        error = gpio_request(as5011->button_gpio, "AS5011 button");
+        if (error < 0) {
+                dev_err(&client->dev, "Failed to request button gpio\n");
+                goto err_free_mem;
+        }
+
+        irq = gpio_to_irq(as5011->button_gpio);
+        if (irq < 0) {
+                dev_err(&client->dev,
+                        "Failed to get irq number for button gpio\n");
+                goto err_free_button_gpio;
+        }
+
+        as5011->button_irq = irq;
+
+        error = request_threaded_irq(as5011->button_irq,
+                                     NULL, as5011_button_interrupt,
+                                     IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                     "as5011_button", as5011);
+        if (error < 0) {
+                dev_err(&client->dev,
+                        "Can't allocate button irq %d\n", as5011->button_irq);
+                goto err_free_button_gpio;
+        }
+
+        error = as5011_configure_chip(as5011, plat_data);
+        if (error)
+                goto err_free_button_irq;
+
+        error = request_threaded_irq(as5011->axis_irq, NULL,
+                                     as5011_axis_interrupt,
+                                     plat_data->axis_irqflags,
+                                     "as5011_joystick", as5011);
+        if (error) {
+                dev_err(&client->dev,
+                        "Can't allocate axis irq %d\n", plat_data->axis_irq);
+                goto err_free_button_irq;
+        }
+
+        error = input_register_device(as5011->input_dev);
+        if (error) {
+                dev_err(&client->dev, "Failed to register input device\n");
+                goto err_free_axis_irq;
+        }
+
+        i2c_set_clientdata(client, as5011);
+
+        return 0;
+
+err_free_axis_irq:
+        free_irq(as5011->axis_irq, as5011);
+err_free_button_irq:
+        free_irq(as5011->button_irq, as5011);
+err_free_button_gpio:
+        gpio_free(as5011->button_gpio);
+err_free_mem:
+        input_free_device(input_dev);
+        kfree(as5011);
+
+        return error;
+}
+
+static int __devexit as5011_remove(struct i2c_client *client)
+{
+        struct as5011_device *as5011 = i2c_get_clientdata(client);
+
+        free_irq(as5011->axis_irq, as5011);
+        free_irq(as5011->button_irq, as5011);
+        gpio_free(as5011->button_gpio);
+
+        input_unregister_device(as5011->input_dev);
+        kfree(as5011);
+
+        return 0;
+}
+
+static const struct i2c_device_id as5011_id[] = {
+        { MODULE_DEVICE_ALIAS, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, as5011_id);
+
+static struct i2c_driver as5011_driver = {
+        .driver = {
+                .name = "as5011",
+        },
+        .probe          = as5011_probe,
+        .remove         = __devexit_p(as5011_remove),
+        .id_table       = as5011_id,
+};
+
+static int __init as5011_init(void)
+{
+        return i2c_add_driver(&as5011_driver);
+}
+module_init(as5011_init);
+
+static void __exit as5011_exit(void)
+{
+        i2c_del_driver(&as5011_driver);
+}
+module_exit(as5011_exit);
diff --git a/drivers/input/keyboard/Kconfig b/drivers/input/keyboard/Kconfig
index f829998fabe..7b3c0b8fa43 100644
--- a/drivers/input/keyboard/Kconfig
+++ b/drivers/input/keyboard/Kconfig
@@ -12,18 +12,6 @@ menuconfig INPUT_KEYBOARD
 
 if INPUT_KEYBOARD
 
-config KEYBOARD_AAED2000
-        tristate "AAED-2000 keyboard"
-        depends on MACH_AAED2000
-        select INPUT_POLLDEV
-        default y
-        help
-          Say Y here to enable the keyboard on the Agilent AAED-2000
-          development board.
-
-          To compile this driver as a module, choose M here: the
-          module will be called aaed2000_kbd.
-
 config KEYBOARD_ADP5520
         tristate "Keypad Support for ADP5520 PMIC"
         depends on PMIC_ADP5520
diff --git a/drivers/input/keyboard/Makefile b/drivers/input/keyboard/Makefile
index 8933e9ca938..4e5571b72cd 100644
--- a/drivers/input/keyboard/Makefile
+++ b/drivers/input/keyboard/Makefile
@@ -4,7 +4,6 @@
 
 # Each configuration option enables a list of files.
 
-obj-$(CONFIG_KEYBOARD_AAED2000)         += aaed2000_kbd.o
 obj-$(CONFIG_KEYBOARD_ADP5520)          += adp5520-keys.o
 obj-$(CONFIG_KEYBOARD_ADP5588)          += adp5588-keys.o
 obj-$(CONFIG_KEYBOARD_AMIGA)            += amikbd.o
diff --git a/drivers/input/keyboard/aaed2000_kbd.c b/drivers/input/keyboard/aaed2000_kbd.c
deleted file mode 100644
index 18222a689a0..00000000000
--- a/drivers/input/keyboard/aaed2000_kbd.c
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
- *  Keyboard driver for the AAED-2000 dev board
- *
- *  Copyright (c) 2006 Nicolas Bellido Y Ortega
- *
- *  Based on corgikbd.c
- *
- *  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/delay.h>
-#include <linux/platform_device.h>
-#include <linux/init.h>
-#include <linux/input-polldev.h>
-#include <linux/interrupt.h>
-#include <linux/jiffies.h>
-#include <linux/module.h>
-#include <linux/slab.h>
-
-#include <mach/hardware.h>
-#include <mach/aaed2000.h>
-
-#define KB_ROWS                 12
-#define KB_COLS                 8
-#define KB_ROWMASK(r)           (1 << (r))
-#define SCANCODE(r,c)           (((c) * KB_ROWS) + (r))
-#define NR_SCANCODES            (KB_COLS * KB_ROWS)
-
-#define SCAN_INTERVAL           (50) /* ms */
-#define KB_ACTIVATE_DELAY       (20) /* us */
-
-static unsigned char aaedkbd_keycode[NR_SCANCODES] = {
-        KEY_9, KEY_0, KEY_MINUS, KEY_EQUAL, KEY_BACKSPACE, 0, KEY_SPACE, KEY_KP6, 0, KEY_KPDOT, 0, 0,
-        KEY_K, KEY_M, KEY_O, KEY_DOT, KEY_SLASH, 0, KEY_F, 0, 0, 0, KEY_LEFTSHIFT, 0,
-        KEY_I, KEY_P, KEY_LEFTBRACE, KEY_RIGHTBRACE, KEY_BACKSLASH, 0, 0, 0, 0, 0, KEY_RIGHTSHIFT, 0,
-        KEY_8, KEY_L, KEY_SEMICOLON, KEY_APOSTROPHE, KEY_ENTER, 0, 0, 0, 0, 0, 0, 0,
-        KEY_J, KEY_H, KEY_B, KEY_KP8, KEY_KP4, 0, KEY_C, KEY_D, KEY_S, KEY_A, 0, KEY_CAPSLOCK,
-        KEY_Y, KEY_U, KEY_N, KEY_T, 0, 0, KEY_R, KEY_E, KEY_W, KEY_Q, 0, KEY_TAB,
-        KEY_7, KEY_6, KEY_G, 0, KEY_5, 0, KEY_4, KEY_3, KEY_2, KEY_1, 0, KEY_GRAVE,
-        0, 0, KEY_COMMA, 0, KEY_KP2, 0, KEY_V, KEY_LEFTALT, KEY_X, KEY_Z, 0, KEY_LEFTCTRL
-};
-
-struct aaedkbd {
-        unsigned char keycode[ARRAY_SIZE(aaedkbd_keycode)];
-        struct input_polled_dev *poll_dev;
-        int kbdscan_state[KB_COLS];
-        int kbdscan_count[KB_COLS];
-};
-
-#define KBDSCAN_STABLE_COUNT 2
-
-static void aaedkbd_report_col(struct aaedkbd *aaedkbd,
-                                unsigned int col, unsigned int rowd)
-{
-        unsigned int scancode, pressed;
-        unsigned int row;
-
-        for (row = 0; row < KB_ROWS; row++) {
-                scancode = SCANCODE(row, col);
-                pressed = rowd & KB_ROWMASK(row);
-
-                input_report_key(aaedkbd->poll_dev->input,
-                                 aaedkbd->keycode[scancode], pressed);
-        }
-}
-
-/* Scan the hardware keyboard and push any changes up through the input layer */
-static void aaedkbd_poll(struct input_polled_dev *dev)
-{
-        struct aaedkbd *aaedkbd = dev->private;
-        unsigned int col, rowd;
-
-        col = 0;
-        do {
-                AAEC_GPIO_KSCAN = col + 8;
-                udelay(KB_ACTIVATE_DELAY);
-                rowd = AAED_EXT_GPIO & AAED_EGPIO_KBD_SCAN;
-
-                if (rowd != aaedkbd->kbdscan_state[col]) {
-                        aaedkbd->kbdscan_count[col] = 0;
-                        aaedkbd->kbdscan_state[col] = rowd;
-                } else if (++aaedkbd->kbdscan_count[col] >= KBDSCAN_STABLE_COUNT) {
-                        aaedkbd_report_col(aaedkbd, col, rowd);
-                        col++;
-                }
-        } while (col < KB_COLS);
-
-        AAEC_GPIO_KSCAN = 0x07;
-        input_sync(dev->input);
-}
-
-static int __devinit aaedkbd_probe(struct platform_device *pdev)
-{
-        struct aaedkbd *aaedkbd;
-        struct input_polled_dev *poll_dev;
-        struct input_dev *input_dev;
-        int i;
-        int error;
-
-        aaedkbd = kzalloc(sizeof(struct aaedkbd), GFP_KERNEL);
-        poll_dev = input_allocate_polled_device();
-        if (!aaedkbd || !poll_dev) {
-                error = -ENOMEM;
-                goto fail;
-        }
-
-        platform_set_drvdata(pdev, aaedkbd);
-
-        aaedkbd->poll_dev = poll_dev;
-        memcpy(aaedkbd->keycode, aaedkbd_keycode, sizeof(aaedkbd->keycode));
-
-        poll_dev->private = aaedkbd;
-        poll_dev->poll = aaedkbd_poll;
-        poll_dev->poll_interval = SCAN_INTERVAL;
-
-        input_dev = poll_dev->input;
-        input_dev->name = "AAED-2000 Keyboard";
-        input_dev->phys = "aaedkbd/input0";
-        input_dev->id.bustype = BUS_HOST;
-        input_dev->id.vendor = 0x0001;
-        input_dev->id.product = 0x0001;
-        input_dev->id.version = 0x0100;
-        input_dev->dev.parent = &pdev->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REP);
-        input_dev->keycode = aaedkbd->keycode;
-        input_dev->keycodesize = sizeof(unsigned char);
-        input_dev->keycodemax = ARRAY_SIZE(aaedkbd_keycode);
-
-        for (i = 0; i < ARRAY_SIZE(aaedkbd_keycode); i++)
-                set_bit(aaedkbd->keycode[i], input_dev->keybit);
-        clear_bit(0, input_dev->keybit);
-
-        error = input_register_polled_device(aaedkbd->poll_dev);
-        if (error)
-                goto fail;
-
-        return 0;
-
- fail:  kfree(aaedkbd);
-        input_free_polled_device(poll_dev);
-        return error;
-}
-
-static int __devexit aaedkbd_remove(struct platform_device *pdev)
-{
-        struct aaedkbd *aaedkbd = platform_get_drvdata(pdev);
-
-        input_unregister_polled_device(aaedkbd->poll_dev);
-        input_free_polled_device(aaedkbd->poll_dev);
-        kfree(aaedkbd);
-
-        return 0;
-}
-
-/* work with hotplug and coldplug */
-MODULE_ALIAS("platform:aaed2000-keyboard");
-
-static struct platform_driver aaedkbd_driver = {
-        .probe          = aaedkbd_probe,
-        .remove         = __devexit_p(aaedkbd_remove),
-        .driver         = {
-                .name   = "aaed2000-keyboard",
-                .owner  = THIS_MODULE,
-        },
-};
-
-static int __init aaedkbd_init(void)
-{
-        return platform_driver_register(&aaedkbd_driver);
-}
-
-static void __exit aaedkbd_exit(void)
-{
-        platform_driver_unregister(&aaedkbd_driver);
-}
-
-module_init(aaedkbd_init);
-module_exit(aaedkbd_exit);
-
-MODULE_AUTHOR("Nicolas Bellido Y Ortega");
-MODULE_DESCRIPTION("AAED-2000 Keyboard Driver");
-MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/serio/Kconfig b/drivers/input/serio/Kconfig
index bcb1fdedb59..307eef77a17 100644
--- a/drivers/input/serio/Kconfig
+++ b/drivers/input/serio/Kconfig
@@ -229,7 +229,7 @@ config SERIO_PS2MULT
         tristate "TQC PS/2 multiplexer"
         help
           Say Y here if you have the PS/2 line multiplexer like the one
-          present on TQC boads.
+          present on TQC boards.
 
           To compile this driver as a module, choose M here: the
           module will be called ps2mult.
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
index 5ae0fc4578f..bb9f5d31f0d 100644
--- a/drivers/input/serio/i8042-x86ia64io.h
+++ b/drivers/input/serio/i8042-x86ia64io.h
@@ -424,6 +424,13 @@ static const struct dmi_system_id __initconst i8042_dmi_nomux_table[] = {
                         DMI_MATCH(DMI_PRODUCT_VERSION, "0100"),
                 },
         },
+        {
+                /* Dell Vostro V13 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V13"),
+                },
+        },
         { }
 };
 
@@ -545,6 +552,17 @@ static const struct dmi_system_id __initconst i8042_dmi_laptop_table[] = {
 };
 #endif
 
+static const struct dmi_system_id __initconst i8042_dmi_notimeout_table[] = {
+        {
+                /* Dell Vostro V13 */
+                .matches = {
+                        DMI_MATCH(DMI_SYS_VENDOR, "Dell Inc."),
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Vostro V13"),
+                },
+        },
+        { }
+};
+
 /*
  * Some Wistron based laptops need us to explicitly enable the 'Dritek
  * keyboard extension' to make their extra keys start generating scancodes.
@@ -896,6 +914,9 @@ static int __init i8042_platform_init(void)
         if (dmi_check_system(i8042_dmi_nomux_table))
                 i8042_nomux = true;
 
+        if (dmi_check_system(i8042_dmi_notimeout_table))
+                i8042_notimeout = true;
+
         if (dmi_check_system(i8042_dmi_dritek_table))
                 i8042_dritek = true;
 #endif /* CONFIG_X86 */
diff --git a/drivers/input/serio/i8042.c b/drivers/input/serio/i8042.c
index c04ff00a366..ac4c93689ab 100644
--- a/drivers/input/serio/i8042.c
+++ b/drivers/input/serio/i8042.c
@@ -63,6 +63,10 @@ static bool i8042_noloop;
 module_param_named(noloop, i8042_noloop, bool, 0);
 MODULE_PARM_DESC(noloop, "Disable the AUX Loopback command while probing for the AUX port");
 
+static bool i8042_notimeout;
+module_param_named(notimeout, i8042_notimeout, bool, 0);
+MODULE_PARM_DESC(notimeout, "Ignore timeouts signalled by i8042");
+
 #ifdef CONFIG_X86
 static bool i8042_dritek;
 module_param_named(dritek, i8042_dritek, bool, 0);
@@ -504,7 +508,7 @@ static irqreturn_t i8042_interrupt(int irq, void *dev_id)
         } else {
 
                 dfl = ((str & I8042_STR_PARITY) ? SERIO_PARITY : 0) |
-                      ((str & I8042_STR_TIMEOUT) ? SERIO_TIMEOUT : 0);
+                      ((str & I8042_STR_TIMEOUT && !i8042_notimeout) ? SERIO_TIMEOUT : 0);
 
                 port_no = (str & I8042_STR_AUXDATA) ?
                                 I8042_AUX_PORT_NO : I8042_KBD_PORT_NO;
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 07ac77d393a..0c9f4b158ff 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -610,7 +610,7 @@ config TOUCHSCREEN_USB_ZYTRONIC
 
 config TOUCHSCREEN_USB_ETT_TC45USB
         default y
-        bool "ET&T USB series TC4UM/TC5UH touchscreen controler support" if EMBEDDED
+        bool "ET&T USB series TC4UM/TC5UH touchscreen controller support" if EMBEDDED
         depends on TOUCHSCREEN_USB_COMPOSITE
 
 config TOUCHSCREEN_USB_NEXIO
diff --git a/drivers/input/touchscreen/ad7879-i2c.c b/drivers/input/touchscreen/ad7879-i2c.c
index d82a38ee9a3..4e4e58cec6c 100644
--- a/drivers/input/touchscreen/ad7879-i2c.c
+++ b/drivers/input/touchscreen/ad7879-i2c.c
@@ -10,14 +10,16 @@
 #include <linux/i2c.h>
 #include <linux/module.h>
 #include <linux/types.h>
+#include <linux/pm.h>
 
 #include "ad7879.h"
 
 #define AD7879_DEVID            0x79    /* AD7879-1/AD7889-1 */
 
 #ifdef CONFIG_PM
-static int ad7879_i2c_suspend(struct i2c_client *client, pm_message_t message)
+static int ad7879_i2c_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct ad7879 *ts = i2c_get_clientdata(client);
 
         ad7879_suspend(ts);
@@ -25,17 +27,17 @@ static int ad7879_i2c_suspend(struct i2c_client *client, pm_message_t message)
         return 0;
 }
 
-static int ad7879_i2c_resume(struct i2c_client *client)
+static int ad7879_i2c_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct ad7879 *ts = i2c_get_clientdata(client);
 
         ad7879_resume(ts);
 
         return 0;
 }
-#else
-# define ad7879_i2c_suspend NULL
-# define ad7879_i2c_resume  NULL
+
+static SIMPLE_DEV_PM_OPS(ad7879_i2c_pm, ad7879_i2c_suspend, ad7879_i2c_resume);
 #endif
 
 /* All registers are word-sized.
@@ -117,11 +119,12 @@ static struct i2c_driver ad7879_i2c_driver = {
         .driver = {
                 .name   = "ad7879",
                 .owner  = THIS_MODULE,
+#ifdef CONFIG_PM
+                .pm     = &ad7879_i2c_pm,
+#endif
         },
         .probe          = ad7879_i2c_probe,
         .remove         = __devexit_p(ad7879_i2c_remove),
-        .suspend        = ad7879_i2c_suspend,
-        .resume         = ad7879_i2c_resume,
         .id_table       = ad7879_id,
 };
 
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
index d0c3a7229ad..a93c5c26ab3 100644
--- a/drivers/input/touchscreen/cy8ctmg110_ts.c
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -280,8 +280,9 @@ err_free_mem:
 }
 
 #ifdef CONFIG_PM
-static int cy8ctmg110_suspend(struct i2c_client *client, pm_message_t mesg)
+static int cy8ctmg110_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 
         if (device_may_wakeup(&client->dev))
@@ -293,8 +294,9 @@ static int cy8ctmg110_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int cy8ctmg110_resume(struct i2c_client *client)
+static int cy8ctmg110_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct cy8ctmg110 *ts = i2c_get_clientdata(client);
 
         if (device_may_wakeup(&client->dev))
@@ -305,6 +307,8 @@ static int cy8ctmg110_resume(struct i2c_client *client)
         }
         return 0;
 }
+
+static SIMPLE_DEV_PM_OPS(cy8ctmg110_pm, cy8ctmg110_suspend, cy8ctmg110_resume);
 #endif
 
 static int __devexit cy8ctmg110_remove(struct i2c_client *client)
@@ -335,14 +339,13 @@ static struct i2c_driver cy8ctmg110_driver = {
         .driver         = {
                 .owner  = THIS_MODULE,
                 .name   = CY8CTMG110_DRIVER_NAME,
+#ifdef CONFIG_PM
+                .pm     = &cy8ctmg110_pm,
+#endif
         },
         .id_table       = cy8ctmg110_idtable,
         .probe          = cy8ctmg110_probe,
         .remove         = __devexit_p(cy8ctmg110_remove),
-#ifdef CONFIG_PM
-        .suspend        = cy8ctmg110_suspend,
-        .resume         = cy8ctmg110_resume,
-#endif
 };
 
 static int __init cy8ctmg110_init(void)
diff --git a/drivers/input/touchscreen/eeti_ts.c b/drivers/input/touchscreen/eeti_ts.c
index 7a3a916f84a..7f8f538a980 100644
--- a/drivers/input/touchscreen/eeti_ts.c
+++ b/drivers/input/touchscreen/eeti_ts.c
@@ -261,8 +261,9 @@ static int __devexit eeti_ts_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int eeti_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
         struct input_dev *input_dev = priv->input;
 
@@ -279,8 +280,9 @@ static int eeti_ts_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int eeti_ts_resume(struct i2c_client *client)
+static int eeti_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct eeti_ts_priv *priv = i2c_get_clientdata(client);
         struct input_dev *input_dev = priv->input;
 
@@ -296,9 +298,8 @@ static int eeti_ts_resume(struct i2c_client *client)
 
         return 0;
 }
-#else
-#define eeti_ts_suspend NULL
-#define eeti_ts_resume NULL
+
+static SIMPLE_DEV_PM_OPS(eeti_ts_pm, eeti_ts_suspend, eeti_ts_resume);
 #endif
 
 static const struct i2c_device_id eeti_ts_id[] = {
@@ -310,11 +311,12 @@ MODULE_DEVICE_TABLE(i2c, eeti_ts_id);
 static struct i2c_driver eeti_ts_driver = {
         .driver = {
                 .name = "eeti_ts",
+#ifdef CONFIG_PM
+                .pm = &eeti_ts_pm,
+#endif
         },
         .probe = eeti_ts_probe,
         .remove = __devexit_p(eeti_ts_remove),
-        .suspend = eeti_ts_suspend,
-        .resume = eeti_ts_resume,
         .id_table = eeti_ts_id,
 };
 
diff --git a/drivers/input/touchscreen/mcs5000_ts.c b/drivers/input/touchscreen/mcs5000_ts.c
index 6ee9940aaf5..2d84c80ceb6 100644
--- a/drivers/input/touchscreen/mcs5000_ts.c
+++ b/drivers/input/touchscreen/mcs5000_ts.c
@@ -261,25 +261,27 @@ static int __devexit mcs5000_ts_remove(struct i2c_client *client)
 }
 
 #ifdef CONFIG_PM
-static int mcs5000_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int mcs5000_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
+
         /* Touch sleep mode */
         i2c_smbus_write_byte_data(client, MCS5000_TS_OP_MODE, OP_MODE_SLEEP);
 
         return 0;
 }
 
-static int mcs5000_ts_resume(struct i2c_client *client)
+static int mcs5000_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct mcs5000_ts_data *data = i2c_get_clientdata(client);
 
         mcs5000_ts_phys_init(data);
 
         return 0;
 }
-#else
-#define mcs5000_ts_suspend      NULL
-#define mcs5000_ts_resume       NULL
+
+static SIMPLE_DEV_PM_OPS(mcs5000_ts_pm, mcs5000_ts_suspend, mcs5000_ts_resume);
 #endif
 
 static const struct i2c_device_id mcs5000_ts_id[] = {
@@ -291,10 +293,11 @@ MODULE_DEVICE_TABLE(i2c, mcs5000_ts_id);
 static struct i2c_driver mcs5000_ts_driver = {
         .probe          = mcs5000_ts_probe,
         .remove         = __devexit_p(mcs5000_ts_remove),
-        .suspend        = mcs5000_ts_suspend,
-        .resume         = mcs5000_ts_resume,
         .driver = {
                 .name = "mcs5000_ts",
+#ifdef CONFIG_PM
+                .pm   = &mcs5000_ts_pm,
+#endif
         },
         .id_table       = mcs5000_ts_id,
 };
diff --git a/drivers/input/touchscreen/migor_ts.c b/drivers/input/touchscreen/migor_ts.c
index defe5dd3627..5803bd0c1cc 100644
--- a/drivers/input/touchscreen/migor_ts.c
+++ b/drivers/input/touchscreen/migor_ts.c
@@ -23,6 +23,7 @@
 #include <linux/kernel.h>
 #include <linux/input.h>
 #include <linux/interrupt.h>
+#include <linux/pm.h>
 #include <linux/slab.h>
 #include <asm/io.h>
 #include <linux/i2c.h>
@@ -226,8 +227,9 @@ static int migor_ts_remove(struct i2c_client *client)
         return 0;
 }
 
-static int migor_ts_suspend(struct i2c_client *client, pm_message_t mesg)
+static int migor_ts_suspend(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
@@ -236,8 +238,9 @@ static int migor_ts_suspend(struct i2c_client *client, pm_message_t mesg)
         return 0;
 }
 
-static int migor_ts_resume(struct i2c_client *client)
+static int migor_ts_resume(struct device *dev)
 {
+        struct i2c_client *client = to_i2c_client(dev);
         struct migor_ts_priv *priv = dev_get_drvdata(&client->dev);
 
         if (device_may_wakeup(&client->dev))
@@ -246,6 +249,8 @@ static int migor_ts_resume(struct i2c_client *client)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(migor_ts_pm, migor_ts_suspend, migor_ts_resume);
+
 static const struct i2c_device_id migor_ts_id[] = {
         { "migor_ts", 0 },
         { }
@@ -255,11 +260,10 @@ MODULE_DEVICE_TABLE(i2c, migor_ts);
 static struct i2c_driver migor_ts_driver = {
         .driver = {
                 .name = "migor_ts",
+                .pm = &migor_ts_pm,
         },
         .probe = migor_ts_probe,
         .remove = migor_ts_remove,
-        .suspend = migor_ts_suspend,
-        .resume = migor_ts_resume,
         .id_table = migor_ts_id,
 };
 
diff --git a/drivers/input/touchscreen/wacom_w8001.c b/drivers/input/touchscreen/wacom_w8001.c
index 8ed53aded2d..5cb8449c909 100644
--- a/drivers/input/touchscreen/wacom_w8001.c
+++ b/drivers/input/touchscreen/wacom_w8001.c
@@ -3,6 +3,7 @@
  *
  * Copyright (c) 2008 Jaya Kumar
  * Copyright (c) 2010 Red Hat, Inc.
+ * Copyright (c) 2010 - 2011 Ping Cheng, Wacom. <pingc@wacom.com>
  *
  * This file is subject to the terms and conditions of the GNU General Public
  * License. See the file COPYING in the main directory of this archive for
@@ -64,11 +65,11 @@ struct w8001_coord {
 
 /* touch query reply packet */
 struct w8001_touch_query {
+        u16 x;
+        u16 y;
         u8 panel_res;
         u8 capacity_res;
         u8 sensor_id;
-        u16 x;
-        u16 y;
 };
 
 /*
@@ -87,9 +88,14 @@ struct w8001 {
         char phys[32];
         int type;
         unsigned int pktlen;
+        u16 max_touch_x;
+        u16 max_touch_y;
+        u16 max_pen_x;
+        u16 max_pen_y;
+        char name[64];
 };
 
-static void parse_data(u8 *data, struct w8001_coord *coord)
+static void parse_pen_data(u8 *data, struct w8001_coord *coord)
 {
         memset(coord, 0, sizeof(*coord));
 
@@ -113,11 +119,30 @@ static void parse_data(u8 *data, struct w8001_coord *coord)
         coord->tilt_y = data[8] & 0x7F;
 }
 
-static void parse_touch(struct w8001 *w8001)
+static void parse_single_touch(u8 *data, struct w8001_coord *coord)
+{
+        coord->x = (data[1] << 7) | data[2];
+        coord->y = (data[3] << 7) | data[4];
+        coord->tsw = data[0] & 0x01;
+}
+
+static void scale_touch_coordinates(struct w8001 *w8001,
+                                    unsigned int *x, unsigned int *y)
+{
+        if (w8001->max_pen_x && w8001->max_touch_x)
+                *x = *x * w8001->max_pen_x / w8001->max_touch_x;
+
+        if (w8001->max_pen_y && w8001->max_touch_y)
+                *y = *y * w8001->max_pen_y / w8001->max_touch_y;
+}
+
+static void parse_multi_touch(struct w8001 *w8001)
 {
         struct input_dev *dev = w8001->dev;
         unsigned char *data = w8001->data;
+        unsigned int x, y;
         int i;
+        int count = 0;
 
         for (i = 0; i < 2; i++) {
                 bool touch = data[0] & (1 << i);
@@ -125,15 +150,29 @@ static void parse_touch(struct w8001 *w8001)
                 input_mt_slot(dev, i);
                 input_mt_report_slot_state(dev, MT_TOOL_FINGER, touch);
                 if (touch) {
-                        int x = (data[6 * i + 1] << 7) | (data[6 * i + 2]);
-                        int y = (data[6 * i + 3] << 7) | (data[6 * i + 4]);
+                        x = (data[6 * i + 1] << 7) | data[6 * i + 2];
+                        y = (data[6 * i + 3] << 7) | data[6 * i + 4];
                         /* data[5,6] and [11,12] is finger capacity */
 
+                        /* scale to pen maximum */
+                        scale_touch_coordinates(w8001, &x, &y);
+
                         input_report_abs(dev, ABS_MT_POSITION_X, x);
                         input_report_abs(dev, ABS_MT_POSITION_Y, y);
+                        count++;
                 }
         }
 
+        /* emulate single touch events when stylus is out of proximity.
+         * This is to make single touch backward support consistent
+         * across all Wacom single touch devices.
+         */
+        if (w8001->type != BTN_TOOL_PEN &&
+                            w8001->type != BTN_TOOL_RUBBER) {
+                w8001->type = count == 1 ? BTN_TOOL_FINGER : KEY_RESERVED;
+                input_mt_report_pointer_emulation(dev, true);
+        }
+
         input_sync(dev);
 }
 
@@ -152,6 +191,15 @@ static void parse_touchquery(u8 *data, struct w8001_touch_query *query)
         query->y = data[5] << 9;
         query->y |= data[6] << 2;
         query->y |= (data[2] >> 3) & 0x3;
+
+        /* Early days' single-finger touch models need the following defaults */
+        if (!query->x && !query->y) {
+                query->x = 1024;
+                query->y = 1024;
+                if (query->panel_res)
+                        query->x = query->y = (1 << query->panel_res);
+                query->panel_res = 10;
+        }
 }
 
 static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord)
@@ -161,16 +209,15 @@ static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord)
         /*
          * We have 1 bit for proximity (rdy) and 3 bits for tip, side,
          * side2/eraser. If rdy && f2 are set, this can be either pen + side2,
-         * or eraser. assume
+         * or eraser. Assume:
          * - if dev is already in proximity and f2 is toggled → pen + side2
          * - if dev comes into proximity with f2 set → eraser
          * If f2 disappears after assuming eraser, fake proximity out for
          * eraser and in for pen.
          */
 
-        if (!w8001->type) {
-                w8001->type = coord->f2 ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
-        } else if (w8001->type == BTN_TOOL_RUBBER) {
+        switch (w8001->type) {
+        case BTN_TOOL_RUBBER:
                 if (!coord->f2) {
                         input_report_abs(dev, ABS_PRESSURE, 0);
                         input_report_key(dev, BTN_TOUCH, 0);
@@ -180,8 +227,21 @@ static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord)
                         input_sync(dev);
                         w8001->type = BTN_TOOL_PEN;
                 }
-        } else {
+                break;
+
+        case BTN_TOOL_FINGER:
+                input_report_key(dev, BTN_TOUCH, 0);
+                input_report_key(dev, BTN_TOOL_FINGER, 0);
+                input_sync(dev);
+                /* fall through */
+
+        case KEY_RESERVED:
+                w8001->type = coord->f2 ? BTN_TOOL_RUBBER : BTN_TOOL_PEN;
+                break;
+
+        default:
                 input_report_key(dev, BTN_STYLUS2, coord->f2);
+                break;
         }
 
         input_report_abs(dev, ABS_X, coord->x);
@@ -193,7 +253,26 @@ static void report_pen_events(struct w8001 *w8001, struct w8001_coord *coord)
         input_sync(dev);
 
         if (!coord->rdy)
-                w8001->type = 0;
+                w8001->type = KEY_RESERVED;
+}
+
+static void report_single_touch(struct w8001 *w8001, struct w8001_coord *coord)
+{
+        struct input_dev *dev = w8001->dev;
+        unsigned int x = coord->x;
+        unsigned int y = coord->y;
+
+        /* scale to pen maximum */
+        scale_touch_coordinates(w8001, &x, &y);
+
+        input_report_abs(dev, ABS_X, x);
+        input_report_abs(dev, ABS_Y, y);
+        input_report_key(dev, BTN_TOUCH, coord->tsw);
+        input_report_key(dev, BTN_TOOL_FINGER, coord->tsw);
+
+        input_sync(dev);
+
+        w8001->type = coord->tsw ? BTN_TOOL_FINGER : KEY_RESERVED;
 }
 
 static irqreturn_t w8001_interrupt(struct serio *serio,
@@ -214,9 +293,18 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
 
         case W8001_PKTLEN_TOUCH93 - 1:
         case W8001_PKTLEN_TOUCH9A - 1:
-                /* ignore one-finger touch packet. */
-                if (w8001->pktlen == w8001->idx)
+                tmp = w8001->data[0] & W8001_TOUCH_BYTE;
+                if (tmp != W8001_TOUCH_BYTE)
+                        break;
+
+                if (w8001->pktlen == w8001->idx) {
                         w8001->idx = 0;
+                        if (w8001->type != BTN_TOOL_PEN &&
+                            w8001->type != BTN_TOOL_RUBBER) {
+                                parse_single_touch(w8001->data, &coord);
+                                report_single_touch(w8001, &coord);
+                        }
+                }
                 break;
 
         /* Pen coordinates packet */
@@ -225,18 +313,18 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
                 if (unlikely(tmp == W8001_TAB_BYTE))
                         break;
 
-                tmp = (w8001->data[0] & W8001_TOUCH_BYTE);
+                tmp = w8001->data[0] & W8001_TOUCH_BYTE;
                 if (tmp == W8001_TOUCH_BYTE)
                         break;
 
                 w8001->idx = 0;
-                parse_data(w8001->data, &coord);
+                parse_pen_data(w8001->data, &coord);
                 report_pen_events(w8001, &coord);
                 break;
 
         /* control packet */
         case W8001_PKTLEN_TPCCTL - 1:
-                tmp = (w8001->data[0] & W8001_TOUCH_MASK);
+                tmp = w8001->data[0] & W8001_TOUCH_MASK;
                 if (tmp == W8001_TOUCH_BYTE)
                         break;
 
@@ -249,7 +337,7 @@ static irqreturn_t w8001_interrupt(struct serio *serio,
         /* 2 finger touch packet */
         case W8001_PKTLEN_TOUCH2FG - 1:
                 w8001->idx = 0;
-                parse_touch(w8001);
+                parse_multi_touch(w8001);
                 break;
         }
 
@@ -279,6 +367,7 @@ static int w8001_setup(struct w8001 *w8001)
 {
         struct input_dev *dev = w8001->dev;
         struct w8001_coord coord;
+        struct w8001_touch_query touch;
         int error;
 
         error = w8001_command(w8001, W8001_CMD_STOP, false);
@@ -287,14 +376,21 @@ static int w8001_setup(struct w8001 *w8001)
 
         msleep(250);    /* wait 250ms before querying the device */
 
+        dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
+        strlcat(w8001->name, "Wacom Serial", sizeof(w8001->name));
+
         /* penabled? */
         error = w8001_command(w8001, W8001_CMD_QUERY, true);
         if (!error) {
+                __set_bit(BTN_TOUCH, dev->keybit);
                 __set_bit(BTN_TOOL_PEN, dev->keybit);
                 __set_bit(BTN_TOOL_RUBBER, dev->keybit);
                 __set_bit(BTN_STYLUS, dev->keybit);
                 __set_bit(BTN_STYLUS2, dev->keybit);
-                parse_data(w8001->response, &coord);
+
+                parse_pen_data(w8001->response, &coord);
+                w8001->max_pen_x = coord.x;
+                w8001->max_pen_y = coord.y;
 
                 input_set_abs_params(dev, ABS_X, 0, coord.x, 0, 0);
                 input_set_abs_params(dev, ABS_Y, 0, coord.y, 0, 0);
@@ -303,6 +399,8 @@ static int w8001_setup(struct w8001 *w8001)
                         input_set_abs_params(dev, ABS_TILT_X, 0, coord.tilt_x, 0, 0);
                         input_set_abs_params(dev, ABS_TILT_Y, 0, coord.tilt_y, 0, 0);
                 }
+                w8001->id = 0x90;
+                strlcat(w8001->name, " Penabled", sizeof(w8001->name));
         }
 
         /* Touch enabled? */
@@ -313,24 +411,38 @@ static int w8001_setup(struct w8001 *w8001)
          * second byte is empty, which indicates touch is not supported.
          */
         if (!error && w8001->response[1]) {
-                struct w8001_touch_query touch;
+                __set_bit(BTN_TOUCH, dev->keybit);
+                __set_bit(BTN_TOOL_FINGER, dev->keybit);
 
                 parse_touchquery(w8001->response, &touch);
+                w8001->max_touch_x = touch.x;
+                w8001->max_touch_y = touch.y;
+
+                /* scale to pen maximum */
+                if (w8001->max_pen_x && w8001->max_pen_y) {
+                        touch.x = w8001->max_pen_x;
+                        touch.y = w8001->max_pen_y;
+                }
 
                 input_set_abs_params(dev, ABS_X, 0, touch.x, 0, 0);
                 input_set_abs_params(dev, ABS_Y, 0, touch.y, 0, 0);
-                __set_bit(BTN_TOOL_FINGER, dev->keybit);
 
                 switch (touch.sensor_id) {
                 case 0:
                 case 2:
                         w8001->pktlen = W8001_PKTLEN_TOUCH93;
+                        w8001->id = 0x93;
+                        strlcat(w8001->name, " 1FG", sizeof(w8001->name));
                         break;
+
                 case 1:
                 case 3:
                 case 4:
                         w8001->pktlen = W8001_PKTLEN_TOUCH9A;
+                        strlcat(w8001->name, " 1FG", sizeof(w8001->name));
+                        w8001->id = 0x9a;
                         break;
+
                 case 5:
                         w8001->pktlen = W8001_PKTLEN_TOUCH2FG;
 
@@ -341,10 +453,18 @@ static int w8001_setup(struct w8001 *w8001)
                                                 0, touch.y, 0, 0);
                         input_set_abs_params(dev, ABS_MT_TOOL_TYPE,
                                                 0, MT_TOOL_MAX, 0, 0);
+
+                        strlcat(w8001->name, " 2FG", sizeof(w8001->name));
+                        if (w8001->max_pen_x && w8001->max_pen_y)
+                                w8001->id = 0xE3;
+                        else
+                                w8001->id = 0xE2;
                         break;
                 }
         }
 
+        strlcat(w8001->name, " Touchscreen", sizeof(w8001->name));
+
         return w8001_command(w8001, W8001_CMD_START, false);
 }
 
@@ -384,22 +504,10 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         }
 
         w8001->serio = serio;
-        w8001->id = serio->id.id;
         w8001->dev = input_dev;
         init_completion(&w8001->cmd_done);
         snprintf(w8001->phys, sizeof(w8001->phys), "%s/input0", serio->phys);
 
-        input_dev->name = "Wacom W8001 Penabled Serial TouchScreen";
-        input_dev->phys = w8001->phys;
-        input_dev->id.bustype = BUS_RS232;
-        input_dev->id.vendor = SERIO_W8001;
-        input_dev->id.product = w8001->id;
-        input_dev->id.version = 0x0100;
-        input_dev->dev.parent = &serio->dev;
-
-        input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-        __set_bit(BTN_TOUCH, input_dev->keybit);
-
         serio_set_drvdata(serio, w8001);
         err = serio_open(serio, drv);
         if (err)
@@ -409,6 +517,14 @@ static int w8001_connect(struct serio *serio, struct serio_driver *drv)
         if (err)
                 goto fail3;
 
+        input_dev->name = w8001->name;
+        input_dev->phys = w8001->phys;
+        input_dev->id.product = w8001->id;
+        input_dev->id.bustype = BUS_RS232;
+        input_dev->id.vendor = 0x056a;
+        input_dev->id.version = 0x0100;
+        input_dev->dev.parent = &serio->dev;
+
         err = input_register_device(w8001->dev);
         if (err)
                 goto fail3;
diff --git a/drivers/isdn/gigaset/bas-gigaset.c b/drivers/isdn/gigaset/bas-gigaset.c
index 178942a2ee6..8a3c5cfc4fe 100644
--- a/drivers/isdn/gigaset/bas-gigaset.c
+++ b/drivers/isdn/gigaset/bas-gigaset.c
@@ -2318,7 +2318,7 @@ static int gigaset_probe(struct usb_interface *interface,
                  __func__, le16_to_cpu(udev->descriptor.idVendor),
                  le16_to_cpu(udev->descriptor.idProduct));
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         cs = gigaset_initcs(driver, BAS_CHANNELS, 0, 0, cidmode,
                             GIGASET_MODULENAME);
         if (!cs)
@@ -2576,7 +2576,7 @@ static int __init bas_gigaset_init(void)
 {
         int result;
 
-        /* allocate memory for our driver state and intialize it */
+        /* allocate memory for our driver state and initialize it */
         driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
                                     GIGASET_MODULENAME, GIGASET_DEVNAME,
                                     &gigops, THIS_MODULE);
diff --git a/drivers/isdn/gigaset/ser-gigaset.c b/drivers/isdn/gigaset/ser-gigaset.c
index d151dcbf770..0ef09d0eb96 100644
--- a/drivers/isdn/gigaset/ser-gigaset.c
+++ b/drivers/isdn/gigaset/ser-gigaset.c
@@ -513,7 +513,7 @@ gigaset_tty_open(struct tty_struct *tty)
                 return -ENODEV;
         }
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
         if (!cs)
                 goto error;
@@ -771,7 +771,7 @@ static int __init ser_gigaset_init(void)
                 return rc;
         }
 
-        /* allocate memory for our driver state and intialize it */
+        /* allocate memory for our driver state and initialize it */
         driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
                                           GIGASET_MODULENAME, GIGASET_DEVNAME,
                                           &ops, THIS_MODULE);
diff --git a/drivers/isdn/gigaset/usb-gigaset.c b/drivers/isdn/gigaset/usb-gigaset.c
index 4a66338f4e7..5e3300d8a2a 100644
--- a/drivers/isdn/gigaset/usb-gigaset.c
+++ b/drivers/isdn/gigaset/usb-gigaset.c
@@ -695,7 +695,7 @@ static int gigaset_probe(struct usb_interface *interface,
 
         dev_info(&udev->dev, "%s: Device matched ... !\n", __func__);
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         cs = gigaset_initcs(driver, 1, 1, 0, cidmode, GIGASET_MODULENAME);
         if (!cs)
                 return -ENODEV;
@@ -894,7 +894,7 @@ static int __init usb_gigaset_init(void)
 {
         int result;
 
-        /* allocate memory for our driver state and intialize it */
+        /* allocate memory for our driver state and initialize it */
         driver = gigaset_initdriver(GIGASET_MINOR, GIGASET_MINORS,
                                     GIGASET_MODULENAME, GIGASET_DEVNAME,
                                     &ops, THIS_MODULE);
diff --git a/drivers/isdn/hardware/mISDN/ipac.h b/drivers/isdn/hardware/mISDN/ipac.h
index 74a6ccf9065..8121e046b73 100644
--- a/drivers/isdn/hardware/mISDN/ipac.h
+++ b/drivers/isdn/hardware/mISDN/ipac.h
@@ -29,7 +29,7 @@ struct isac_hw {
         u32                     type;
         u32                     off;            /* offset to isac regs */
         char                    *name;
-        spinlock_t              *hwlock;        /* lock HW acccess */
+        spinlock_t              *hwlock;        /* lock HW access */
         read_reg_func           *read_reg;
         write_reg_func          *write_reg;
         fifo_func               *read_fifo;
@@ -70,7 +70,7 @@ struct ipac_hw {
         struct hscx_hw          hscx[2];
         char                    *name;
         void                    *hw;
-        spinlock_t              *hwlock;        /* lock HW acccess */
+        spinlock_t              *hwlock;        /* lock HW access */
         struct module           *owner;
         u32                     type;
         read_reg_func           *read_reg;
diff --git a/drivers/isdn/hardware/mISDN/isar.h b/drivers/isdn/hardware/mISDN/isar.h
index 4a134acd44d..9962bdf699c 100644
--- a/drivers/isdn/hardware/mISDN/isar.h
+++ b/drivers/isdn/hardware/mISDN/isar.h
@@ -44,7 +44,7 @@ struct isar_ch {
 struct isar_hw {
         struct  isar_ch ch[2];
         void            *hw;
-        spinlock_t      *hwlock;        /* lock HW acccess */
+        spinlock_t      *hwlock;        /* lock HW access */
         char            *name;
         struct module   *owner;
         read_reg_func   *read_reg;
diff --git a/drivers/isdn/mISDN/dsp_cmx.c b/drivers/isdn/mISDN/dsp_cmx.c
index 76d9e673b4e..309bacf1fad 100644
--- a/drivers/isdn/mISDN/dsp_cmx.c
+++ b/drivers/isdn/mISDN/dsp_cmx.c
@@ -112,7 +112,7 @@
  * Disable rx-data:
  * If cmx is realized in hardware, rx data will be disabled if requested by
  * the upper layer. If dtmf decoding is done by software and enabled, rx data
- * will not be diabled but blocked to the upper layer.
+ * will not be disabled but blocked to the upper layer.
  *
  * HFC conference engine:
  * If it is possible to realize all features using hardware, hardware will be
diff --git a/drivers/leds/leds-lp5521.c b/drivers/leds/leds-lp5521.c
index 33facd0c45d..80a3ae3c00b 100644
--- a/drivers/leds/leds-lp5521.c
+++ b/drivers/leds/leds-lp5521.c
@@ -98,7 +98,6 @@
 #define LP5521_EXT_CLK_USED             0x08
 
 struct lp5521_engine {
-        const struct attribute_group *attributes;
         int             id;
         u8              mode;
         u8              prog_page;
@@ -225,25 +224,22 @@ static int lp5521_set_led_current(struct lp5521_chip *chip, int led, u8 curr)
                     curr);
 }
 
-static void lp5521_init_engine(struct lp5521_chip *chip,
-                        const struct attribute_group *attr_group)
+static void lp5521_init_engine(struct lp5521_chip *chip)
 {
         int i;
         for (i = 0; i < ARRAY_SIZE(chip->engines); i++) {
                 chip->engines[i].id = i + 1;
                 chip->engines[i].engine_mask = LP5521_ENG_MASK_BASE >> (i * 2);
                 chip->engines[i].prog_page = i;
-                chip->engines[i].attributes = &attr_group[i];
         }
 }
 
-static int lp5521_configure(struct i2c_client *client,
-                        const struct attribute_group *attr_group)
+static int lp5521_configure(struct i2c_client *client)
 {
         struct lp5521_chip *chip = i2c_get_clientdata(client);
         int ret;
 
-        lp5521_init_engine(chip, attr_group);
+        lp5521_init_engine(chip);
 
         /* Set all PWMs to direct control mode */
         ret = lp5521_write(client, LP5521_REG_OP_MODE, 0x3F);
@@ -329,9 +325,6 @@ static int lp5521_detect(struct i2c_client *client)
 /* Set engine mode and create appropriate sysfs attributes, if required. */
 static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
 {
-        struct lp5521_chip *chip = engine_to_lp5521(engine);
-        struct i2c_client *client = chip->client;
-        struct device *dev = &client->dev;
         int ret = 0;
 
         /* if in that mode already do nothing, except for run */
@@ -343,18 +336,10 @@ static int lp5521_set_mode(struct lp5521_engine *engine, u8 mode)
         } else if (mode == LP5521_CMD_LOAD) {
                 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
                 lp5521_set_engine_mode(engine, LP5521_CMD_LOAD);
-
-                ret = sysfs_create_group(&dev->kobj, engine->attributes);
-                if (ret)
-                        return ret;
         } else if (mode == LP5521_CMD_DISABLED) {
                 lp5521_set_engine_mode(engine, LP5521_CMD_DISABLED);
         }
 
-        /* remove load attribute from sysfs if not in load mode */
-        if (engine->mode == LP5521_CMD_LOAD && mode != LP5521_CMD_LOAD)
-                sysfs_remove_group(&dev->kobj, engine->attributes);
-
         engine->mode = mode;
 
         return ret;
@@ -373,6 +358,8 @@ static int lp5521_do_store_load(struct lp5521_engine *engine,
         while ((offset < len - 1) && (i < LP5521_PROGRAM_LENGTH)) {
                 /* separate sscanfs because length is working only for %s */
                 ret = sscanf(buf + offset, "%2s%n ", c, &nrchars);
+                if (ret != 2)
+                        goto fail;
                 ret = sscanf(c, "%2x", &cmd);
                 if (ret != 1)
                         goto fail;
@@ -387,7 +374,10 @@ static int lp5521_do_store_load(struct lp5521_engine *engine,
                 goto fail;
 
         mutex_lock(&chip->lock);
-        ret = lp5521_load_program(engine, pattern);
+        if (engine->mode == LP5521_CMD_LOAD)
+                ret = lp5521_load_program(engine, pattern);
+        else
+                ret = -EINVAL;
         mutex_unlock(&chip->lock);
 
         if (ret) {
@@ -574,20 +564,8 @@ static struct attribute *lp5521_attributes[] = {
         &dev_attr_engine2_mode.attr,
         &dev_attr_engine3_mode.attr,
         &dev_attr_selftest.attr,
-        NULL
-};
-
-static struct attribute *lp5521_engine1_attributes[] = {
         &dev_attr_engine1_load.attr,
-        NULL
-};
-
-static struct attribute *lp5521_engine2_attributes[] = {
         &dev_attr_engine2_load.attr,
-        NULL
-};
-
-static struct attribute *lp5521_engine3_attributes[] = {
         &dev_attr_engine3_load.attr,
         NULL
 };
@@ -596,12 +574,6 @@ static const struct attribute_group lp5521_group = {
         .attrs = lp5521_attributes,
 };
 
-static const struct attribute_group lp5521_engine_group[] = {
-        {.attrs = lp5521_engine1_attributes },
-        {.attrs = lp5521_engine2_attributes },
-        {.attrs = lp5521_engine3_attributes },
-};
-
 static int lp5521_register_sysfs(struct i2c_client *client)
 {
         struct device *dev = &client->dev;
@@ -616,12 +588,6 @@ static void lp5521_unregister_sysfs(struct i2c_client *client)
 
         sysfs_remove_group(&dev->kobj, &lp5521_group);
 
-        for (i = 0; i <  ARRAY_SIZE(chip->engines); i++) {
-                if (chip->engines[i].mode == LP5521_CMD_LOAD)
-                        sysfs_remove_group(&dev->kobj,
-                                        chip->engines[i].attributes);
-        }
-
         for (i = 0; i < chip->num_leds; i++)
                 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
                                 &lp5521_led_attribute_group);
@@ -651,7 +617,8 @@ static int __init lp5521_init_led(struct lp5521_led *led,
                 return -EINVAL;
         }
 
-        snprintf(name, sizeof(name), "%s:channel%d", client->name, chan);
+        snprintf(name, sizeof(name), "%s:channel%d",
+                        pdata->label ?: client->name, chan);
         led->cdev.brightness_set = lp5521_set_brightness;
         led->cdev.name = name;
         res = led_classdev_register(dev, &led->cdev);
@@ -723,7 +690,7 @@ static int lp5521_probe(struct i2c_client *client,
 
         dev_info(&client->dev, "%s programmable led chip found\n", id->name);
 
-        ret = lp5521_configure(client, lp5521_engine_group);
+        ret = lp5521_configure(client);
         if (ret < 0) {
                 dev_err(&client->dev, "error configuring chip\n");
                 goto fail2;
diff --git a/drivers/leds/leds-lp5523.c b/drivers/leds/leds-lp5523.c
index 0cc4ead2fd8..d0c4068ecdd 100644
--- a/drivers/leds/leds-lp5523.c
+++ b/drivers/leds/leds-lp5523.c
@@ -105,7 +105,6 @@
 #define SHIFT_MASK(id)                  (((id) - 1) * 2)
 
 struct lp5523_engine {
-        const struct attribute_group *attributes;
         int             id;
         u8              mode;
         u8              prog_page;
@@ -403,14 +402,23 @@ static ssize_t store_engine_leds(struct device *dev,
         struct i2c_client *client = to_i2c_client(dev);
         struct lp5523_chip *chip = i2c_get_clientdata(client);
         u16 mux = 0;
+        ssize_t ret;
 
         if (lp5523_mux_parse(buf, &mux, len))
                 return -EINVAL;
 
+        mutex_lock(&chip->lock);
+        ret = -EINVAL;
+        if (chip->engines[nr - 1].mode != LP5523_CMD_LOAD)
+                goto leave;
+
         if (lp5523_load_mux(&chip->engines[nr - 1], mux))
-                return -EINVAL;
+                goto leave;
 
-        return len;
+        ret = len;
+leave:
+        mutex_unlock(&chip->lock);
+        return ret;
 }
 
 #define store_leds(nr)                                          \
@@ -556,7 +564,11 @@ static int lp5523_do_store_load(struct lp5523_engine *engine,
 
         mutex_lock(&chip->lock);
 
-        ret = lp5523_load_program(engine, pattern);
+        if (engine->mode == LP5523_CMD_LOAD)
+                ret = lp5523_load_program(engine, pattern);
+        else
+                ret = -EINVAL;
+
         mutex_unlock(&chip->lock);
 
         if (ret) {
@@ -737,37 +749,18 @@ static struct attribute *lp5523_attributes[] = {
         &dev_attr_engine2_mode.attr,
         &dev_attr_engine3_mode.attr,
         &dev_attr_selftest.attr,
-        NULL
-};
-
-static struct attribute *lp5523_engine1_attributes[] = {
         &dev_attr_engine1_load.attr,
         &dev_attr_engine1_leds.attr,
-        NULL
-};
-
-static struct attribute *lp5523_engine2_attributes[] = {
         &dev_attr_engine2_load.attr,
         &dev_attr_engine2_leds.attr,
-        NULL
-};
-
-static struct attribute *lp5523_engine3_attributes[] = {
         &dev_attr_engine3_load.attr,
         &dev_attr_engine3_leds.attr,
-        NULL
 };
 
 static const struct attribute_group lp5523_group = {
         .attrs = lp5523_attributes,
 };
 
-static const struct attribute_group lp5523_engine_group[] = {
-        {.attrs = lp5523_engine1_attributes },
-        {.attrs = lp5523_engine2_attributes },
-        {.attrs = lp5523_engine3_attributes },
-};
-
 static int lp5523_register_sysfs(struct i2c_client *client)
 {
         struct device *dev = &client->dev;
@@ -788,10 +781,6 @@ static void lp5523_unregister_sysfs(struct i2c_client *client)
 
         sysfs_remove_group(&dev->kobj, &lp5523_group);
 
-        for (i = 0; i < ARRAY_SIZE(chip->engines); i++)
-                if (chip->engines[i].mode == LP5523_CMD_LOAD)
-                        sysfs_remove_group(&dev->kobj, &lp5523_engine_group[i]);
-
         for (i = 0; i < chip->num_leds; i++)
                 sysfs_remove_group(&chip->leds[i].cdev.dev->kobj,
                                 &lp5523_led_attribute_group);
@@ -802,10 +791,6 @@ static void lp5523_unregister_sysfs(struct i2c_client *client)
 /*--------------------------------------------------------------*/
 static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
 {
-        /*  engine to chip */
-        struct lp5523_chip *chip = engine_to_lp5523(engine);
-        struct i2c_client *client = chip->client;
-        struct device *dev = &client->dev;
         int ret = 0;
 
         /* if in that mode already do nothing, except for run */
@@ -817,18 +802,10 @@ static int lp5523_set_mode(struct lp5523_engine *engine, u8 mode)
         } else if (mode == LP5523_CMD_LOAD) {
                 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
                 lp5523_set_engine_mode(engine, LP5523_CMD_LOAD);
-
-                ret = sysfs_create_group(&dev->kobj, engine->attributes);
-                if (ret)
-                        return ret;
         } else if (mode == LP5523_CMD_DISABLED) {
                 lp5523_set_engine_mode(engine, LP5523_CMD_DISABLED);
         }
 
-        /* remove load attribute from sysfs if not in load mode */
-        if (engine->mode == LP5523_CMD_LOAD && mode != LP5523_CMD_LOAD)
-                sysfs_remove_group(&dev->kobj, engine->attributes);
-
         engine->mode = mode;
 
         return ret;
@@ -845,7 +822,6 @@ static int __init lp5523_init_engine(struct lp5523_engine *engine, int id)
         engine->engine_mask = LP5523_ENG_MASK_BASE >> SHIFT_MASK(id);
         engine->prog_page = id - 1;
         engine->mux_page = id + 2;
-        engine->attributes = &lp5523_engine_group[id - 1];
 
         return 0;
 }
@@ -870,7 +846,8 @@ static int __init lp5523_init_led(struct lp5523_led *led, struct device *dev,
                         return -EINVAL;
                 }
 
-                snprintf(name, 32, "lp5523:channel%d", chan);
+                snprintf(name, sizeof(name), "%s:channel%d",
+                        pdata->label ?: "lp5523", chan);
 
                 led->cdev.name = name;
                 led->cdev.brightness_set = lp5523_set_brightness;
diff --git a/drivers/leds/leds-pca9532.c b/drivers/leds/leds-pca9532.c
index 43d08756d82..afac338d502 100644
--- a/drivers/leds/leds-pca9532.c
+++ b/drivers/leds/leds-pca9532.c
@@ -200,6 +200,32 @@ static void pca9532_led_work(struct work_struct *work)
         pca9532_setled(led);
 }
 
+static void pca9532_destroy_devices(struct pca9532_data *data, int n_devs)
+{
+        int i = n_devs;
+
+        if (!data)
+                return;
+
+        while (--i >= 0) {
+                switch (data->leds[i].type) {
+                case PCA9532_TYPE_NONE:
+                        break;
+                case PCA9532_TYPE_LED:
+                        led_classdev_unregister(&data->leds[i].ldev);
+                        cancel_work_sync(&data->leds[i].work);
+                        break;
+                case PCA9532_TYPE_N2100_BEEP:
+                        if (data->idev != NULL) {
+                                input_unregister_device(data->idev);
+                                cancel_work_sync(&data->work);
+                                data->idev = NULL;
+                        }
+                        break;
+                }
+        }
+}
+
 static int pca9532_configure(struct i2c_client *client,
         struct pca9532_data *data, struct pca9532_platform_data *pdata)
 {
@@ -274,25 +300,7 @@ static int pca9532_configure(struct i2c_client *client,
         return 0;
 
 exit:
-        if (i > 0)
-                for (i = i - 1; i >= 0; i--)
-                        switch (data->leds[i].type) {
-                        case PCA9532_TYPE_NONE:
-                                break;
-                        case PCA9532_TYPE_LED:
-                                led_classdev_unregister(&data->leds[i].ldev);
-                                cancel_work_sync(&data->leds[i].work);
-                                break;
-                        case PCA9532_TYPE_N2100_BEEP:
-                                if (data->idev != NULL) {
-                                        input_unregister_device(data->idev);
-                                        input_free_device(data->idev);
-                                        cancel_work_sync(&data->work);
-                                        data->idev = NULL;
-                                }
-                                break;
-                        }
-
+        pca9532_destroy_devices(data, i);
         return err;
 }
 
@@ -329,25 +337,7 @@ static int pca9532_probe(struct i2c_client *client,
 static int pca9532_remove(struct i2c_client *client)
 {
         struct pca9532_data *data = i2c_get_clientdata(client);
-        int i;
-        for (i = 0; i < 16; i++)
-                switch (data->leds[i].type) {
-                case PCA9532_TYPE_NONE:
-                        break;
-                case PCA9532_TYPE_LED:
-                        led_classdev_unregister(&data->leds[i].ldev);
-                        cancel_work_sync(&data->leds[i].work);
-                        break;
-                case PCA9532_TYPE_N2100_BEEP:
-                        if (data->idev != NULL) {
-                                input_unregister_device(data->idev);
-                                input_free_device(data->idev);
-                                cancel_work_sync(&data->work);
-                                data->idev = NULL;
-                        }
-                        break;
-                }
-
+        pca9532_destroy_devices(data, 16);
         kfree(data);
         return 0;
 }
diff --git a/drivers/leds/ledtrig-backlight.c b/drivers/leds/ledtrig-backlight.c
index f948e57bd9b..2b513a2ad7d 100644
--- a/drivers/leds/ledtrig-backlight.c
+++ b/drivers/leds/ledtrig-backlight.c
@@ -26,6 +26,7 @@ struct bl_trig_notifier {
         int brightness;
         int old_status;
         struct notifier_block notifier;
+        unsigned invert;
 };
 
 static int fb_notifier_callback(struct notifier_block *p,
@@ -36,23 +37,64 @@ static int fb_notifier_callback(struct notifier_block *p,
         struct led_classdev *led = n->led;
         struct fb_event *fb_event = data;
         int *blank = fb_event->data;
+        int new_status = *blank ? BLANK : UNBLANK;
 
         switch (event) {
         case FB_EVENT_BLANK :
-                if (*blank && n->old_status == UNBLANK) {
+                if (new_status == n->old_status)
+                        break;
+
+                if ((n->old_status == UNBLANK) ^ n->invert) {
                         n->brightness = led->brightness;
                         led_set_brightness(led, LED_OFF);
-                        n->old_status = BLANK;
-                } else if (!*blank && n->old_status == BLANK) {
+                } else {
                         led_set_brightness(led, n->brightness);
-                        n->old_status = UNBLANK;
                 }
+
+                n->old_status = new_status;
+
                 break;
         }
 
         return 0;
 }
 
+static ssize_t bl_trig_invert_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        struct led_classdev *led = dev_get_drvdata(dev);
+        struct bl_trig_notifier *n = led->trigger_data;
+
+        return sprintf(buf, "%u\n", n->invert);
+}
+
+static ssize_t bl_trig_invert_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t num)
+{
+        struct led_classdev *led = dev_get_drvdata(dev);
+        struct bl_trig_notifier *n = led->trigger_data;
+        unsigned long invert;
+        int ret;
+
+        ret = strict_strtoul(buf, 10, &invert);
+        if (ret < 0)
+                return ret;
+
+        if (invert > 1)
+                return -EINVAL;
+
+        n->invert = invert;
+
+        /* After inverting, we need to update the LED. */
+        if ((n->old_status == BLANK) ^ n->invert)
+                led_set_brightness(led, LED_OFF);
+        else
+                led_set_brightness(led, n->brightness);
+
+        return num;
+}
+static DEVICE_ATTR(inverted, 0644, bl_trig_invert_show, bl_trig_invert_store);
+
 static void bl_trig_activate(struct led_classdev *led)
 {
         int ret;
@@ -66,6 +108,10 @@ static void bl_trig_activate(struct led_classdev *led)
                 return;
         }
 
+        ret = device_create_file(led->dev, &dev_attr_inverted);
+        if (ret)
+                goto err_invert;
+
         n->led = led;
         n->brightness = led->brightness;
         n->old_status = UNBLANK;
@@ -74,6 +120,12 @@ static void bl_trig_activate(struct led_classdev *led)
         ret = fb_register_client(&n->notifier);
         if (ret)
                 dev_err(led->dev, "unable to register backlight trigger\n");
+
+        return;
+
+err_invert:
+        led->trigger_data = NULL;
+        kfree(n);
 }
 
 static void bl_trig_deactivate(struct led_classdev *led)
@@ -82,6 +134,7 @@ static void bl_trig_deactivate(struct led_classdev *led)
                 (struct bl_trig_notifier *) led->trigger_data;
 
         if (n) {
+                device_remove_file(led->dev, &dev_attr_inverted);
                 fb_unregister_client(&n->notifier);
                 kfree(n);
         }
diff --git a/drivers/macintosh/via-pmu-backlight.c b/drivers/macintosh/via-pmu-backlight.c
index 1cec02f6c43..ade1e656bfb 100644
--- a/drivers/macintosh/via-pmu-backlight.c
+++ b/drivers/macintosh/via-pmu-backlight.c
@@ -15,7 +15,7 @@
 
 #define MAX_PMU_LEVEL 0xFF
 
-static struct backlight_ops pmu_backlight_data;
+static const struct backlight_ops pmu_backlight_data;
 static DEFINE_SPINLOCK(pmu_backlight_lock);
 static int sleeping, uses_pmu_bl;
 static u8 bl_curve[FB_BACKLIGHT_LEVELS];
@@ -115,7 +115,7 @@ static int pmu_backlight_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops pmu_backlight_data = {
+static const struct backlight_ops pmu_backlight_data = {
         .get_brightness = pmu_backlight_get_brightness,
         .update_status  = pmu_backlight_update_status,
 
diff --git a/drivers/macintosh/via-pmu.c b/drivers/macintosh/via-pmu.c
index cd29c824838..8b021eb0d48 100644
--- a/drivers/macintosh/via-pmu.c
+++ b/drivers/macintosh/via-pmu.c
@@ -2257,7 +2257,7 @@ static int pmu_sleep_valid(suspend_state_t state)
                 && (pmac_call_feature(PMAC_FTR_SLEEP_STATE, NULL, 0, -1) >= 0);
 }
 
-static struct platform_suspend_ops pmu_pm_ops = {
+static const struct platform_suspend_ops pmu_pm_ops = {
         .enter = powerbook_sleep,
         .valid = pmu_sleep_valid,
 };
diff --git a/drivers/media/video/cx18/cx23418.h b/drivers/media/video/cx18/cx23418.h
index 2c00980acfc..7e40035028d 100644
--- a/drivers/media/video/cx18/cx23418.h
+++ b/drivers/media/video/cx18/cx23418.h
@@ -177,7 +177,7 @@
    IN[0] - Task handle.
    IN[1] - luma type: 0 = disable, 1 = 1D horizontal only, 2 = 1D vertical only,
                       3 = 2D H/V separable, 4 = 2D symmetric non-separable
-   IN[2] - chroma type: 0 - diable, 1 = 1D horizontal
+   IN[2] - chroma type: 0 - disable, 1 = 1D horizontal
    ReturnCode - One of the ERR_CAPTURE_... */
 #define CX18_CPU_SET_SPATIAL_FILTER_TYPE        (CPU_CMD_MASK_CAPTURE | 0x000C)
 
diff --git a/drivers/media/video/cx25840/cx25840-ir.c b/drivers/media/video/cx25840/cx25840-ir.c
index 627926f6bde..7eb79af28aa 100644
--- a/drivers/media/video/cx25840/cx25840-ir.c
+++ b/drivers/media/video/cx25840/cx25840-ir.c
@@ -261,7 +261,7 @@ static u16 ns_to_pulse_width_count(u32 ns, u16 divider)
         u32 rem;
 
         /*
-         * The 2 lsb's of the pulse width timer count are not accessable, hence
+         * The 2 lsb's of the pulse width timer count are not accessible, hence
          * the (1 << 2)
          */
         n = ((u64) ns) * CX25840_IR_REFCLK_FREQ / 1000000; /* millicycles */
diff --git a/drivers/media/video/davinci/vpif.h b/drivers/media/video/davinci/vpif.h
index 188841b476e..ebd5c4338eb 100644
--- a/drivers/media/video/davinci/vpif.h
+++ b/drivers/media/video/davinci/vpif.h
@@ -33,7 +33,7 @@ extern spinlock_t vpif_lock;
 #define regr(reg)               readl((reg) + vpif_base)
 #define regw(value, reg)        writel(value, (reg + vpif_base))
 
-/* Register Addresss Offsets */
+/* Register Address Offsets */
 #define VPIF_PID                        (0x0000)
 #define VPIF_CH0_CTRL                   (0x0004)
 #define VPIF_CH1_CTRL                   (0x0008)
diff --git a/drivers/media/video/davinci/vpss.c b/drivers/media/video/davinci/vpss.c
index 7918680917d..3e5cf27ec2b 100644
--- a/drivers/media/video/davinci/vpss.c
+++ b/drivers/media/video/davinci/vpss.c
@@ -85,7 +85,7 @@ enum vpss_platform_type {
 /*
  * vpss operations. Depends on platform. Not all functions are available
  * on all platforms. The api, first check if a functio is available before
- * invoking it. In the probe, the function ptrs are intialized based on
+ * invoking it. In the probe, the function ptrs are initialized based on
  * vpss name. vpss name can be "dm355_vpss", "dm644x_vpss" etc.
  */
 struct vpss_hw_ops {
diff --git a/drivers/media/video/omap/omap_vout.c b/drivers/media/video/omap/omap_vout.c
index 83de97ad971..029a4babfd6 100644
--- a/drivers/media/video/omap/omap_vout.c
+++ b/drivers/media/video/omap/omap_vout.c
@@ -1286,7 +1286,7 @@ static int omap_vout_release(struct file *file)
         videobuf_mmap_free(q);
 
         /* Even if apply changes fails we should continue
-           freeing allocated memeory */
+           freeing allocated memory */
         if (vout->streaming) {
                 u32 mask = 0;
 
diff --git a/drivers/media/video/saa7164/saa7164-core.c b/drivers/media/video/saa7164/saa7164-core.c
index d6bf3f82cc3..58af67f2278 100644
--- a/drivers/media/video/saa7164/saa7164-core.c
+++ b/drivers/media/video/saa7164/saa7164-core.c
@@ -655,8 +655,8 @@ static irqreturn_t saa7164_irq(int irq, void *dev_id)
                 goto out;
         }
 
-        /* Check that the hardware is accessable. If the status bytes are
-         * 0xFF then the device is not accessable, the the IRQ belongs
+        /* Check that the hardware is accessible. If the status bytes are
+         * 0xFF then the device is not accessible, the the IRQ belongs
          * to another driver.
          * 4 x u32 interrupt registers.
          */
diff --git a/drivers/media/video/sn9c102/sn9c102_sensor.h b/drivers/media/video/sn9c102/sn9c102_sensor.h
index 494957b10ba..7f38549715b 100644
--- a/drivers/media/video/sn9c102/sn9c102_sensor.h
+++ b/drivers/media/video/sn9c102/sn9c102_sensor.h
@@ -147,7 +147,7 @@ enum sn9c102_i2c_interface {
 
 struct sn9c102_sensor {
         char name[32], /* sensor name */
-             maintainer[64]; /* name of the mantainer <email> */
+             maintainer[64]; /* name of the maintainer <email> */
 
         enum sn9c102_bridge supported_bridge; /* supported SN9C1xx bridges */
 
diff --git a/drivers/media/video/tvp7002.c b/drivers/media/video/tvp7002.c
index e63b40f5a70..c799e4eb6fc 100644
--- a/drivers/media/video/tvp7002.c
+++ b/drivers/media/video/tvp7002.c
@@ -789,7 +789,7 @@ static int tvp7002_query_dv_preset(struct v4l2_subdev *sd,
  * Get the value of a TVP7002 decoder device register.
  * Returns zero when successful, -EINVAL if register read fails or
  * access to I2C client fails, -EPERM if the call is not allowed
- * by diabled CAP_SYS_ADMIN.
+ * by disabled CAP_SYS_ADMIN.
  */
 static int tvp7002_g_register(struct v4l2_subdev *sd,
                                                 struct v4l2_dbg_register *reg)
diff --git a/drivers/media/video/via-camera.c b/drivers/media/video/via-camera.c
index e25aca5759f..2f973cd5640 100644
--- a/drivers/media/video/via-camera.c
+++ b/drivers/media/video/via-camera.c
@@ -13,14 +13,12 @@
 #include <linux/pci.h>
 #include <linux/gpio.h>
 #include <linux/interrupt.h>
-#include <linux/pci.h>
 #include <linux/platform_device.h>
 #include <linux/videodev2.h>
 #include <media/v4l2-device.h>
 #include <media/v4l2-ioctl.h>
 #include <media/v4l2-chip-ident.h>
 #include <media/videobuf-dma-sg.h>
-#include <linux/device.h>
 #include <linux/delay.h>
 #include <linux/dma-mapping.h>
 #include <linux/pm_qos_params.h>
diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
index c00fe8253c5..e9a3eab7b0c 100644
--- a/drivers/memstick/core/memstick.c
+++ b/drivers/memstick/core/memstick.c
@@ -465,6 +465,7 @@ static void memstick_check(struct work_struct *work)
                 if (!host->card) {
                         host->card = card;
                         if (device_register(&card->dev)) {
+                                put_device(&card->dev);
                                 kfree(host->card);
                                 host->card = NULL;
                         }
@@ -510,14 +511,18 @@ int memstick_add_host(struct memstick_host *host)
 {
         int rc;
 
-        if (!idr_pre_get(&memstick_host_idr, GFP_KERNEL))
-                return -ENOMEM;
+        while (1) {
+                if (!idr_pre_get(&memstick_host_idr, GFP_KERNEL))
+                        return -ENOMEM;
 
-        spin_lock(&memstick_host_lock);
-        rc = idr_get_new(&memstick_host_idr, host, &host->id);
-        spin_unlock(&memstick_host_lock);
-        if (rc)
-                return rc;
+                spin_lock(&memstick_host_lock);
+                rc = idr_get_new(&memstick_host_idr, host, &host->id);
+                spin_unlock(&memstick_host_lock);
+                if (!rc)
+                        break;
+                else if (rc != -EAGAIN)
+                        return rc;
+        }
 
         dev_set_name(&host->dev, "memstick%u", host->id);
 
diff --git a/drivers/memstick/core/mspro_block.c b/drivers/memstick/core/mspro_block.c
index 02362eccc58..57b42bfc7d2 100644
--- a/drivers/memstick/core/mspro_block.c
+++ b/drivers/memstick/core/mspro_block.c
@@ -23,7 +23,6 @@
 
 #define DRIVER_NAME "mspro_block"
 
-static DEFINE_MUTEX(mspro_block_mutex);
 static int major;
 module_param(major, int, 0644);
 
@@ -160,6 +159,13 @@ struct mspro_block_data {
         int                   (*mrq_handler)(struct memstick_dev *card,
                                              struct memstick_request **mrq);
 
+
+        /* Default request setup function for data access method preferred by
+         * this host instance.
+         */
+        void                  (*setup_transfer)(struct memstick_dev *card,
+                                                u64 offset, size_t length);
+
         struct attribute_group attr_group;
 
         struct scatterlist    req_sg[MSPRO_BLOCK_MAX_SEGS];
@@ -181,7 +187,6 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
         struct mspro_block_data *msb = disk->private_data;
         int rc = -ENXIO;
 
-        mutex_lock(&mspro_block_mutex);
         mutex_lock(&mspro_block_disk_lock);
 
         if (msb && msb->card) {
@@ -193,7 +198,6 @@ static int mspro_block_bd_open(struct block_device *bdev, fmode_t mode)
         }
 
         mutex_unlock(&mspro_block_disk_lock);
-        mutex_unlock(&mspro_block_mutex);
 
         return rc;
 }
@@ -225,11 +229,7 @@ static int mspro_block_disk_release(struct gendisk *disk)
 
 static int mspro_block_bd_release(struct gendisk *disk, fmode_t mode)
 {
-        int ret;
-        mutex_lock(&mspro_block_mutex);
-        ret = mspro_block_disk_release(disk);
-        mutex_unlock(&mspro_block_mutex);
-        return ret;
+        return mspro_block_disk_release(disk);
 }
 
 static int mspro_block_bd_getgeo(struct block_device *bdev,
@@ -663,14 +663,43 @@ has_int_reg:
         }
 }
 
+/*** Transfer setup functions for different access methods. ***/
+
+/** Setup data transfer request for SET_CMD TPC with arguments in card
+ *  registers.
+ *
+ *  @card    Current media instance
+ *  @offset  Target data offset in bytes
+ *  @length  Required transfer length in bytes.
+ */
+static void h_mspro_block_setup_cmd(struct memstick_dev *card, u64 offset,
+                                    size_t length)
+{
+        struct mspro_block_data *msb = memstick_get_drvdata(card);
+        struct mspro_param_register param = {
+                .system = msb->system,
+                .data_count = cpu_to_be16((uint16_t)(length / msb->page_size)),
+                /* ISO C90 warning precludes direct initialization for now. */
+                .data_address = 0,
+                .tpc_param = 0
+        };
+
+        do_div(offset, msb->page_size);
+        param.data_address = cpu_to_be32((uint32_t)offset);
+
+        card->next_request = h_mspro_block_req_init;
+        msb->mrq_handler = h_mspro_block_transfer_data;
+        memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
+                          &param, sizeof(param));
+}
+
 /*** Data transfer ***/
 
 static int mspro_block_issue_req(struct memstick_dev *card, int chunk)
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        sector_t t_sec;
+        u64 t_off;
         unsigned int count;
-        struct mspro_param_register param;
 
 try_again:
         while (chunk) {
@@ -685,30 +714,17 @@ try_again:
                         continue;
                 }
 
-                t_sec = blk_rq_pos(msb->block_req) << 9;
-                sector_div(t_sec, msb->page_size);
-
+                t_off = blk_rq_pos(msb->block_req);
+                t_off <<= 9;
                 count = blk_rq_bytes(msb->block_req);
-                count /= msb->page_size;
 
-                param.system = msb->system;
-                param.data_count = cpu_to_be16(count);
-                param.data_address = cpu_to_be32((uint32_t)t_sec);
-                param.tpc_param = 0;
+                msb->setup_transfer(card, t_off, count);
 
                 msb->data_dir = rq_data_dir(msb->block_req);
                 msb->transfer_cmd = msb->data_dir == READ
                                     ? MSPRO_CMD_READ_DATA
                                     : MSPRO_CMD_WRITE_DATA;
 
-                dev_dbg(&card->dev, "data transfer: cmd %x, "
-                        "lba %x, count %x\n", msb->transfer_cmd,
-                        be32_to_cpu(param.data_address), count);
-
-                card->next_request = h_mspro_block_req_init;
-                msb->mrq_handler = h_mspro_block_transfer_data;
-                memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
-                                  &param, sizeof(param));
                 memstick_new_req(card->host);
                 return 0;
         }
@@ -963,18 +979,16 @@ try_again:
 static int mspro_block_read_attributes(struct memstick_dev *card)
 {
         struct mspro_block_data *msb = memstick_get_drvdata(card);
-        struct mspro_param_register param = {
-                .system = msb->system,
-                .data_count = cpu_to_be16(1),
-                .data_address = 0,
-                .tpc_param = 0
-        };
         struct mspro_attribute *attr = NULL;
         struct mspro_sys_attr *s_attr = NULL;
         unsigned char *buffer = NULL;
         int cnt, rc, attr_count;
-        unsigned int addr;
-        unsigned short page_count;
+        /* While normally physical device offsets, represented here by
+         * attr_offset and attr_len will be of large numeric types, we can be
+         * sure, that attributes are close enough to the beginning of the
+         * device, to save ourselves some trouble.
+         */
+        unsigned int addr, attr_offset = 0, attr_len = msb->page_size;
 
         attr = kmalloc(msb->page_size, GFP_KERNEL);
         if (!attr)
@@ -987,10 +1001,8 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
         msb->data_dir = READ;
         msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
 
-        card->next_request = h_mspro_block_req_init;
-        msb->mrq_handler = h_mspro_block_transfer_data;
-        memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG, &param,
-                          sizeof(param));
+        msb->setup_transfer(card, attr_offset, attr_len);
+
         memstick_new_req(card->host);
         wait_for_completion(&card->mrq_complete);
         if (card->current_mrq.error) {
@@ -1021,13 +1033,12 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
         }
         msb->attr_group.name = "media_attributes";
 
-        buffer = kmalloc(msb->page_size, GFP_KERNEL);
+        buffer = kmalloc(attr_len, GFP_KERNEL);
         if (!buffer) {
                 rc = -ENOMEM;
                 goto out_free_attr;
         }
-        memcpy(buffer, (char *)attr, msb->page_size);
-        page_count = 1;
+        memcpy(buffer, (char *)attr, attr_len);
 
         for (cnt = 0; cnt < attr_count; ++cnt) {
                 s_attr = kzalloc(sizeof(struct mspro_sys_attr), GFP_KERNEL);
@@ -1038,9 +1049,10 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
 
                 msb->attr_group.attrs[cnt] = &s_attr->dev_attr.attr;
                 addr = be32_to_cpu(attr->entries[cnt].address);
-                rc = be32_to_cpu(attr->entries[cnt].size);
+                s_attr->size = be32_to_cpu(attr->entries[cnt].size);
                 dev_dbg(&card->dev, "adding attribute %d: id %x, address %x, "
-                        "size %x\n", cnt, attr->entries[cnt].id, addr, rc);
+                        "size %zx\n", cnt, attr->entries[cnt].id, addr,
+                        s_attr->size);
                 s_attr->id = attr->entries[cnt].id;
                 if (mspro_block_attr_name(s_attr->id))
                         snprintf(s_attr->name, sizeof(s_attr->name), "%s",
@@ -1054,57 +1066,47 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
                 s_attr->dev_attr.attr.mode = S_IRUGO;
                 s_attr->dev_attr.show = mspro_block_attr_show(s_attr->id);
 
-                if (!rc)
+                if (!s_attr->size)
                         continue;
 
-                s_attr->size = rc;
-                s_attr->data = kmalloc(rc, GFP_KERNEL);
+                s_attr->data = kmalloc(s_attr->size, GFP_KERNEL);
                 if (!s_attr->data) {
                         rc = -ENOMEM;
                         goto out_free_buffer;
                 }
 
-                if (((addr / msb->page_size)
-                     == be32_to_cpu(param.data_address))
-                    && (((addr + rc - 1) / msb->page_size)
-                        == be32_to_cpu(param.data_address))) {
+                if (((addr / msb->page_size) == (attr_offset / msb->page_size))
+                    && (((addr + s_attr->size - 1) / msb->page_size)
+                        == (attr_offset / msb->page_size))) {
                         memcpy(s_attr->data, buffer + addr % msb->page_size,
-                               rc);
+                               s_attr->size);
                         continue;
                 }
 
-                if (page_count <= (rc / msb->page_size)) {
+                attr_offset = (addr / msb->page_size) * msb->page_size;
+
+                if ((attr_offset + attr_len) < (addr + s_attr->size)) {
                         kfree(buffer);
-                        page_count = (rc / msb->page_size) + 1;
-                        buffer = kmalloc(page_count * msb->page_size,
-                                         GFP_KERNEL);
+                        attr_len = (((addr + s_attr->size) / msb->page_size)
+                                    + 1 ) * msb->page_size - attr_offset;
+                        buffer = kmalloc(attr_len, GFP_KERNEL);
                         if (!buffer) {
                                 rc = -ENOMEM;
                                 goto out_free_attr;
                         }
                 }
 
-                param.system = msb->system;
-                param.data_count = cpu_to_be16((rc / msb->page_size) + 1);
-                param.data_address = cpu_to_be32(addr / msb->page_size);
-                param.tpc_param = 0;
-
-                sg_init_one(&msb->req_sg[0], buffer,
-                            be16_to_cpu(param.data_count) * msb->page_size);
+                sg_init_one(&msb->req_sg[0], buffer, attr_len);
                 msb->seg_count = 1;
                 msb->current_seg = 0;
                 msb->current_page = 0;
                 msb->data_dir = READ;
                 msb->transfer_cmd = MSPRO_CMD_READ_ATRB;
 
-                dev_dbg(&card->dev, "reading attribute pages %x, %x\n",
-                        be32_to_cpu(param.data_address),
-                        be16_to_cpu(param.data_count));
+                dev_dbg(&card->dev, "reading attribute range %x, %x\n",
+                        attr_offset, attr_len);
 
-                card->next_request = h_mspro_block_req_init;
-                msb->mrq_handler = h_mspro_block_transfer_data;
-                memstick_init_req(&card->current_mrq, MS_TPC_WRITE_REG,
-                                  (char *)&param, sizeof(param));
+                msb->setup_transfer(card, attr_offset, attr_len);
                 memstick_new_req(card->host);
                 wait_for_completion(&card->mrq_complete);
                 if (card->current_mrq.error) {
@@ -1112,7 +1114,8 @@ static int mspro_block_read_attributes(struct memstick_dev *card)
                         goto out_free_buffer;
                 }
 
-                memcpy(s_attr->data, buffer + addr % msb->page_size, rc);
+                memcpy(s_attr->data, buffer + addr % msb->page_size,
+                       s_attr->size);
         }
 
         rc = 0;
@@ -1130,6 +1133,8 @@ static int mspro_block_init_card(struct memstick_dev *card)
         int rc = 0;
 
         msb->system = MEMSTICK_SYS_SERIAL;
+        msb->setup_transfer = h_mspro_block_setup_cmd;
+
         card->reg_addr.r_offset = offsetof(struct mspro_register, status);
         card->reg_addr.r_length = sizeof(struct ms_status_register);
         card->reg_addr.w_offset = offsetof(struct mspro_register, param);
@@ -1206,10 +1211,12 @@ static int mspro_block_init_disk(struct memstick_dev *card)
 
         msb->page_size = be16_to_cpu(sys_info->unit_size);
 
-        if (!idr_pre_get(&mspro_block_disk_idr, GFP_KERNEL))
+        mutex_lock(&mspro_block_disk_lock);
+        if (!idr_pre_get(&mspro_block_disk_idr, GFP_KERNEL)) {
+                mutex_unlock(&mspro_block_disk_lock);
                 return -ENOMEM;
+        }
 
-        mutex_lock(&mspro_block_disk_lock);
         rc = idr_get_new(&mspro_block_disk_idr, card, &disk_id);
         mutex_unlock(&mspro_block_disk_lock);
 
diff --git a/drivers/memstick/host/jmb38x_ms.c b/drivers/memstick/host/jmb38x_ms.c
index f2b894cd8b0..d89d925caec 100644
--- a/drivers/memstick/host/jmb38x_ms.c
+++ b/drivers/memstick/host/jmb38x_ms.c
@@ -61,6 +61,7 @@ struct jmb38x_ms_host {
         struct memstick_request *req;
         unsigned char           cmd_flags;
         unsigned char           io_pos;
+        unsigned char           ifmode;
         unsigned int            io_word[2];
 };
 
@@ -136,15 +137,14 @@ struct jmb38x_ms {
 #define PAD_PU_PD_ON_MS_SOCK0 0x5f8f0000
 #define PAD_PU_PD_ON_MS_SOCK1 0x0f0f0000
 
+#define CLOCK_CONTROL_BY_MMIO 0x00000008
 #define CLOCK_CONTROL_40MHZ   0x00000001
-#define CLOCK_CONTROL_50MHZ   0x0000000a
-#define CLOCK_CONTROL_60MHZ   0x00000008
-#define CLOCK_CONTROL_62_5MHZ 0x0000000c
+#define CLOCK_CONTROL_50MHZ   0x00000002
+#define CLOCK_CONTROL_60MHZ   0x00000010
+#define CLOCK_CONTROL_62_5MHZ 0x00000004
 #define CLOCK_CONTROL_OFF     0x00000000
 
 #define PCI_CTL_CLOCK_DLY_ADDR   0x000000b0
-#define PCI_CTL_CLOCK_DLY_MASK_A 0x00000f00
-#define PCI_CTL_CLOCK_DLY_MASK_B 0x0000f000
 
 enum {
         CMD_READY    = 0x01,
@@ -390,8 +390,13 @@ static int jmb38x_ms_issue_cmd(struct memstick_host *msh)
 
         if (host->req->data_dir == READ)
                 cmd |= TPC_DIR;
-        if (host->req->need_card_int)
-                cmd |= TPC_WAIT_INT;
+
+        if (host->req->need_card_int) {
+                if (host->ifmode == MEMSTICK_SERIAL)
+                        cmd |= TPC_GET_INT;
+                else
+                        cmd |= TPC_WAIT_INT;
+        }
 
         data = host->req->data;
 
@@ -529,7 +534,10 @@ static irqreturn_t jmb38x_ms_isr(int irq, void *dev_id)
                 if (irq_status & INT_STATUS_ANY_ERR) {
                         if (irq_status & INT_STATUS_CRC_ERR)
                                 host->req->error = -EILSEQ;
-                        else
+                        else if (irq_status & INT_STATUS_TPC_ERR) {
+                                dev_dbg(&host->chip->pdev->dev, "TPC_ERR\n");
+                                jmb38x_ms_complete_cmd(msh, 0);
+                        } else
                                 host->req->error = -ETIME;
                 } else {
                         if (host->cmd_flags & DMA_DATA) {
@@ -644,7 +652,6 @@ static int jmb38x_ms_reset(struct jmb38x_ms_host *host)
                 ndelay(20);
         }
         dev_dbg(&host->chip->pdev->dev, "reset_req timeout\n");
-        /* return -EIO; */
 
 reset_next:
         writel(HOST_CONTROL_RESET | HOST_CONTROL_CLOCK_EN
@@ -675,7 +682,7 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
 {
         struct jmb38x_ms_host *host = memstick_priv(msh);
         unsigned int host_ctl = readl(host->addr + HOST_CONTROL);
-        unsigned int clock_ctl = CLOCK_CONTROL_40MHZ, clock_delay = 0;
+        unsigned int clock_ctl = CLOCK_CONTROL_BY_MMIO, clock_delay = 0;
         int rc = 0;
 
         switch (param) {
@@ -687,9 +694,7 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
 
                         host_ctl = 7;
                         host_ctl |= HOST_CONTROL_POWER_EN
-                                    | HOST_CONTROL_CLOCK_EN
-                                    | HOST_CONTROL_HW_OC_P
-                                    | HOST_CONTROL_TDELAY_EN;
+                                 | HOST_CONTROL_CLOCK_EN;
                         writel(host_ctl, host->addr + HOST_CONTROL);
 
                         writel(host->id ? PAD_PU_PD_ON_MS_SOCK1
@@ -712,46 +717,88 @@ static int jmb38x_ms_set_param(struct memstick_host *msh,
                         return -EINVAL;
                 break;
         case MEMSTICK_INTERFACE:
+                dev_dbg(&host->chip->pdev->dev,
+                        "Set Host Interface Mode to %d\n", value);
+                host_ctl &= ~(HOST_CONTROL_FAST_CLK | HOST_CONTROL_REI |
+                              HOST_CONTROL_REO);
+                host_ctl |= HOST_CONTROL_TDELAY_EN | HOST_CONTROL_HW_OC_P;
                 host_ctl &= ~(3 << HOST_CONTROL_IF_SHIFT);
-                pci_read_config_dword(host->chip->pdev,
-                                      PCI_CTL_CLOCK_DLY_ADDR,
-                                      &clock_delay);
-                clock_delay &= host->id ? ~PCI_CTL_CLOCK_DLY_MASK_B
-                                        : ~PCI_CTL_CLOCK_DLY_MASK_A;
 
                 if (value == MEMSTICK_SERIAL) {
-                        host_ctl &= ~HOST_CONTROL_FAST_CLK;
-                        host_ctl &= ~HOST_CONTROL_REO;
                         host_ctl |= HOST_CONTROL_IF_SERIAL
                                     << HOST_CONTROL_IF_SHIFT;
                         host_ctl |= HOST_CONTROL_REI;
-                        clock_ctl = CLOCK_CONTROL_40MHZ;
+                        clock_ctl |= CLOCK_CONTROL_40MHZ;
+                        clock_delay = 0;
                 } else if (value == MEMSTICK_PAR4) {
-                        host_ctl |= HOST_CONTROL_FAST_CLK | HOST_CONTROL_REO;
+                        host_ctl |= HOST_CONTROL_FAST_CLK;
                         host_ctl |= HOST_CONTROL_IF_PAR4
                                     << HOST_CONTROL_IF_SHIFT;
-                        host_ctl &= ~HOST_CONTROL_REI;
-                        clock_ctl = CLOCK_CONTROL_40MHZ;
-                        clock_delay |= host->id ? (4 << 12) : (4 << 8);
+                        host_ctl |= HOST_CONTROL_REO;
+                        clock_ctl |= CLOCK_CONTROL_40MHZ;
+                        clock_delay = 4;
                 } else if (value == MEMSTICK_PAR8) {
                         host_ctl |= HOST_CONTROL_FAST_CLK;
                         host_ctl |= HOST_CONTROL_IF_PAR8
                                     << HOST_CONTROL_IF_SHIFT;
-                        host_ctl &= ~(HOST_CONTROL_REI | HOST_CONTROL_REO);
-                        clock_ctl = CLOCK_CONTROL_50MHZ;
+                        clock_ctl |= CLOCK_CONTROL_50MHZ;
+                        clock_delay = 0;
                 } else
                         return -EINVAL;
 
                 writel(host_ctl, host->addr + HOST_CONTROL);
+                writel(CLOCK_CONTROL_OFF, host->addr + CLOCK_CONTROL);
                 writel(clock_ctl, host->addr + CLOCK_CONTROL);
-                pci_write_config_dword(host->chip->pdev,
-                                       PCI_CTL_CLOCK_DLY_ADDR,
-                                       clock_delay);
+                pci_write_config_byte(host->chip->pdev,
+                                      PCI_CTL_CLOCK_DLY_ADDR + 1,
+                                      clock_delay);
+                host->ifmode = value;
                 break;
         };
         return 0;
 }
 
+#define PCI_PMOS0_CONTROL               0xae
+#define  PMOS0_ENABLE                   0x01
+#define  PMOS0_OVERCURRENT_LEVEL_2_4V   0x06
+#define  PMOS0_EN_OVERCURRENT_DEBOUNCE  0x40
+#define  PMOS0_SW_LED_POLARITY_ENABLE   0x80
+#define  PMOS0_ACTIVE_BITS (PMOS0_ENABLE | PMOS0_EN_OVERCURRENT_DEBOUNCE | \
+                            PMOS0_OVERCURRENT_LEVEL_2_4V)
+#define PCI_PMOS1_CONTROL               0xbd
+#define  PMOS1_ACTIVE_BITS              0x4a
+#define PCI_CLOCK_CTL                   0xb9
+
+static int jmb38x_ms_pmos(struct pci_dev *pdev, int flag)
+{
+        unsigned char val;
+
+        pci_read_config_byte(pdev, PCI_PMOS0_CONTROL, &val);
+        if (flag)
+                val |= PMOS0_ACTIVE_BITS;
+        else
+                val &= ~PMOS0_ACTIVE_BITS;
+        pci_write_config_byte(pdev, PCI_PMOS0_CONTROL, val);
+        dev_dbg(&pdev->dev, "JMB38x: set PMOS0 val 0x%x\n", val);
+
+        if (pci_resource_flags(pdev, 1)) {
+                pci_read_config_byte(pdev, PCI_PMOS1_CONTROL, &val);
+                if (flag)
+                        val |= PMOS1_ACTIVE_BITS;
+                else
+                        val &= ~PMOS1_ACTIVE_BITS;
+                pci_write_config_byte(pdev, PCI_PMOS1_CONTROL, val);
+                dev_dbg(&pdev->dev, "JMB38x: set PMOS1 val 0x%x\n", val);
+        }
+
+        pci_read_config_byte(pdev, PCI_CLOCK_CTL, &val);
+        pci_write_config_byte(pdev, PCI_CLOCK_CTL, val & ~0x0f);
+        pci_write_config_byte(pdev, PCI_CLOCK_CTL, val | 0x01);
+        dev_dbg(&pdev->dev, "Clock Control by PCI config is disabled!\n");
+
+        return 0;
+}
+
 #ifdef CONFIG_PM
 
 static int jmb38x_ms_suspend(struct pci_dev *dev, pm_message_t state)
@@ -784,8 +831,7 @@ static int jmb38x_ms_resume(struct pci_dev *dev)
                 return rc;
         pci_set_master(dev);
 
-        pci_read_config_dword(dev, 0xac, &rc);
-        pci_write_config_dword(dev, 0xac, rc | 0x00470000);
+        jmb38x_ms_pmos(dev, 1);
 
         for (rc = 0; rc < jm->host_cnt; ++rc) {
                 if (!jm->hosts[rc])
@@ -894,8 +940,7 @@ static int jmb38x_ms_probe(struct pci_dev *pdev,
                 goto err_out;
         }
 
-        pci_read_config_dword(pdev, 0xac, &rc);
-        pci_write_config_dword(pdev, 0xac, rc | 0x00470000);
+        jmb38x_ms_pmos(pdev, 1);
 
         cnt = jmb38x_ms_count_slots(pdev);
         if (!cnt) {
@@ -976,6 +1021,8 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
                 jmb38x_ms_free_host(jm->hosts[cnt]);
         }
 
+        jmb38x_ms_pmos(dev, 0);
+
         pci_set_drvdata(dev, NULL);
         pci_release_regions(dev);
         pci_disable_device(dev);
@@ -983,8 +1030,9 @@ static void jmb38x_ms_remove(struct pci_dev *dev)
 }
 
 static struct pci_device_id jmb38x_ms_id_tbl [] = {
-        { PCI_VENDOR_ID_JMICRON, PCI_DEVICE_ID_JMICRON_JMB38X_MS, PCI_ANY_ID,
-          PCI_ANY_ID, 0, 0, 0 },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB38X_MS) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB385_MS) },
+        { PCI_VDEVICE(JMICRON, PCI_DEVICE_ID_JMICRON_JMB390_MS) },
         { }
 };
 
diff --git a/drivers/message/fusion/lsi/mpi_log_sas.h b/drivers/message/fusion/lsi/mpi_log_sas.h
index 691620dbedd..8b04810df46 100644
--- a/drivers/message/fusion/lsi/mpi_log_sas.h
+++ b/drivers/message/fusion/lsi/mpi_log_sas.h
@@ -268,7 +268,7 @@
 
 /* Compatibility Error : IR Disabled */
 #define IR_LOGINFO_COMPAT_ERROR_RAID_DISABLED                  (0x00010030)
-/* Compatibility Error : Inquiry Comand failed */
+/* Compatibility Error : Inquiry Command failed */
 #define IR_LOGINFO_COMPAT_ERROR_INQUIRY_FAILED                 (0x00010031)
 /* Compatibility Error : Device not direct access device */
 #define IR_LOGINFO_COMPAT_ERROR_NOT_DIRECT_ACCESS              (0x00010032)
diff --git a/drivers/message/fusion/mptbase.c b/drivers/message/fusion/mptbase.c
index 3e57b61ca44..3358c0af346 100644
--- a/drivers/message/fusion/mptbase.c
+++ b/drivers/message/fusion/mptbase.c
@@ -7977,7 +7977,7 @@ mpt_spi_log_info(MPT_ADAPTER *ioc, u32 log_info)
                 NULL,                                           /* 2Eh */
                 NULL,                                           /* 2Fh */
                 "Compatibility Error: IR Disabled",             /* 30h */
-                "Compatibility Error: Inquiry Comand Failed",   /* 31h */
+                "Compatibility Error: Inquiry Command Failed",  /* 31h */
                 "Compatibility Error: Device not Direct Access "
                     "Device ",                                  /* 32h */
                 "Compatibility Error: Removable Device Found",  /* 33h */
diff --git a/drivers/message/fusion/mptsas.c b/drivers/message/fusion/mptsas.c
index d48c2c6058e..8aefb1829fc 100644
--- a/drivers/message/fusion/mptsas.c
+++ b/drivers/message/fusion/mptsas.c
@@ -1146,7 +1146,7 @@ mptsas_target_reset_queue(MPT_ADAPTER *ioc,
  *
  * This function will delete scheduled target reset from the list and
  * try to send next target reset. This will be called from completion
- * context of any Task managment command.
+ * context of any Task management command.
  */
 
 void
diff --git a/drivers/message/i2o/i2o_block.c b/drivers/message/i2o/i2o_block.c
index f87a9d405a5..ae7cad18589 100644
--- a/drivers/message/i2o/i2o_block.c
+++ b/drivers/message/i2o/i2o_block.c
@@ -309,7 +309,7 @@ static inline void i2o_block_request_free(struct i2o_block_request *ireq)
  *      @ireq: I2O block request
  *      @mptr: message body pointer
  *
- *      Builds the SG list and map it to be accessable by the controller.
+ *      Builds the SG list and map it to be accessible by the controller.
  *
  *      Returns 0 on failure or 1 on success.
  */
diff --git a/drivers/misc/Kconfig b/drivers/misc/Kconfig
index 4d073f1e450..1e1a4be8eb6 100644
--- a/drivers/misc/Kconfig
+++ b/drivers/misc/Kconfig
@@ -402,7 +402,7 @@ config TI_DAC7512
           DAC7512 16-bit digital-to-analog converter.
 
           This driver can also be built as a module. If so, the module
-          will be calles ti_dac7512.
+          will be called ti_dac7512.
 
 config VMWARE_BALLOON
         tristate "VMware Balloon Driver"
diff --git a/drivers/misc/arm-charlcd.c b/drivers/misc/arm-charlcd.c
index 9e3879ef58f..fe8616a8d28 100644
--- a/drivers/misc/arm-charlcd.c
+++ b/drivers/misc/arm-charlcd.c
@@ -313,7 +313,7 @@ static int __init charlcd_probe(struct platform_device *pdev)
         INIT_DELAYED_WORK(&lcd->init_work, charlcd_init_work);
         schedule_delayed_work(&lcd->init_work, 0);
 
-        dev_info(&pdev->dev, "initalized ARM character LCD at %08x\n",
+        dev_info(&pdev->dev, "initialized ARM character LCD at %08x\n",
                 lcd->phybase);
 
         return 0;
diff --git a/drivers/misc/vmw_balloon.c b/drivers/misc/vmw_balloon.c
index 2a1e804a71a..4d2ea8e8014 100644
--- a/drivers/misc/vmw_balloon.c
+++ b/drivers/misc/vmw_balloon.c
@@ -45,7 +45,7 @@
 
 MODULE_AUTHOR("VMware, Inc.");
 MODULE_DESCRIPTION("VMware Memory Control (Balloon) Driver");
-MODULE_VERSION("1.2.1.1-k");
+MODULE_VERSION("1.2.1.2-k");
 MODULE_ALIAS("dmi:*:svnVMware*:*");
 MODULE_ALIAS("vmware_vmmemctl");
 MODULE_LICENSE("GPL");
@@ -315,7 +315,8 @@ static bool vmballoon_send_get_target(struct vmballoon *b, u32 *new_target)
  * fear that guest will need it. Host may reject some pages, we need to
  * check the return value and maybe submit a different page.
  */
-static bool vmballoon_send_lock_page(struct vmballoon *b, unsigned long pfn)
+static bool vmballoon_send_lock_page(struct vmballoon *b, unsigned long pfn,
+                                     unsigned int *hv_status)
 {
         unsigned long status, dummy;
         u32 pfn32;
@@ -326,7 +327,7 @@ static bool vmballoon_send_lock_page(struct vmballoon *b, unsigned long pfn)
 
         STATS_INC(b->stats.lock);
 
-        status = VMWARE_BALLOON_CMD(LOCK, pfn, dummy);
+        *hv_status = status = VMWARE_BALLOON_CMD(LOCK, pfn, dummy);
         if (vmballoon_check_status(b, status))
                 return true;
 
@@ -410,6 +411,7 @@ static int vmballoon_reserve_page(struct vmballoon *b, bool can_sleep)
 {
         struct page *page;
         gfp_t flags;
+        unsigned int hv_status;
         bool locked = false;
 
         do {
@@ -429,11 +431,12 @@ static int vmballoon_reserve_page(struct vmballoon *b, bool can_sleep)
                 }
 
                 /* inform monitor */
-                locked = vmballoon_send_lock_page(b, page_to_pfn(page));
+                locked = vmballoon_send_lock_page(b, page_to_pfn(page), &hv_status);
                 if (!locked) {
                         STATS_INC(b->stats.refused_alloc);
 
-                        if (b->reset_required) {
+                        if (hv_status == VMW_BALLOON_ERROR_RESET ||
+                            hv_status == VMW_BALLOON_ERROR_PPN_NOTNEEDED) {
                                 __free_page(page);
                                 return -EIO;
                         }
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 217f82037fc..bfc8a8ae55d 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -257,7 +257,7 @@ static u32 get_card_status(struct mmc_card *card, struct request *req)
         cmd.flags = MMC_RSP_SPI_R2 | MMC_RSP_R1 | MMC_CMD_AC;
         err = mmc_wait_for_cmd(card->host, &cmd, 0);
         if (err)
-                printk(KERN_ERR "%s: error %d sending status comand",
+                printk(KERN_ERR "%s: error %d sending status command",
                        req->rq_disk->disk_name, err);
         return cmd.resp[0];
 }
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index c22a4c03998..afe8c6fa166 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -501,7 +501,7 @@ config MMC_SH_MMCIF
         tristate "SuperH Internal MMCIF support"
         depends on MMC_BLOCK && (SUPERH || ARCH_SHMOBILE)
         help
-          This selects the MMC Host Interface controler (MMCIF).
+          This selects the MMC Host Interface controller (MMCIF).
 
           This driver supports MMCIF in sh7724/sh7757/sh7372.
 
diff --git a/drivers/mmc/host/au1xmmc.c b/drivers/mmc/host/au1xmmc.c
index 41e5a60493a..ef72e874ca3 100644
--- a/drivers/mmc/host/au1xmmc.c
+++ b/drivers/mmc/host/au1xmmc.c
@@ -192,7 +192,7 @@ static inline void SEND_STOP(struct au1xmmc_host *host)
         au_writel(config2 | SD_CONFIG2_DF, HOST_CONFIG2(host));
         au_sync();
 
-        /* Send the stop commmand */
+        /* Send the stop command */
         au_writel(STOP_CMD, HOST_CMD(host));
 }
 
diff --git a/drivers/mmc/host/sdricoh_cs.c b/drivers/mmc/host/sdricoh_cs.c
index f472c2714eb..bbc298fd2a1 100644
--- a/drivers/mmc/host/sdricoh_cs.c
+++ b/drivers/mmc/host/sdricoh_cs.c
@@ -446,7 +446,7 @@ static int sdricoh_init_mmc(struct pci_dev *pci_dev,
         mmc->max_seg_size = 1024 * 512;
         mmc->max_blk_size = 512;
 
-        /* reset the controler */
+        /* reset the controller */
         if (sdricoh_reset(host)) {
                 dev_dbg(dev, "could not reset\n");
                 result = -EIO;
@@ -478,7 +478,7 @@ static int sdricoh_pcmcia_probe(struct pcmcia_device *pcmcia_dev)
         dev_info(&pcmcia_dev->dev, "Searching MMC controller for pcmcia device"
                 " %s %s ...\n", pcmcia_dev->prod_id[0], pcmcia_dev->prod_id[1]);
 
-        /* search pci cardbus bridge that contains the mmc controler */
+        /* search pci cardbus bridge that contains the mmc controller */
         /* the io region is already claimed by yenta_socket... */
         while ((pci_dev =
                 pci_get_device(PCI_VENDOR_ID_RICOH, PCI_DEVICE_ID_RICOH_RL5C476,
diff --git a/drivers/mtd/mtdoops.c b/drivers/mtd/mtdoops.c
index 1ee72f3f051..c948150079b 100644
--- a/drivers/mtd/mtdoops.c
+++ b/drivers/mtd/mtdoops.c
@@ -307,6 +307,11 @@ static void mtdoops_do_dump(struct kmsg_dumper *dumper,
         unsigned long l1_cpy, l2_cpy;
         char *dst;
 
+        if (reason != KMSG_DUMP_OOPS &&
+            reason != KMSG_DUMP_PANIC &&
+            reason != KMSG_DUMP_KEXEC)
+                return;
+
         /* Only dump oopses if dump_oops is set */
         if (reason == KMSG_DUMP_OOPS && !dump_oops)
                 return;
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index 1f75a1b1f7c..31bf376b82a 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -821,7 +821,7 @@ retry:
  *
  * Wait for command done. This is a helper function for nand_wait used when
  * we are in interrupt context. May happen when in panic and trying to write
- * an oops trough mtdoops.
+ * an oops through mtdoops.
  */
 static void panic_nand_wait(struct mtd_info *mtd, struct nand_chip *chip,
                             unsigned long timeo)
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index ff652c77a0a..4c8bfc97fb4 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -2963,6 +2963,7 @@ config TILE_NET
 config XEN_NETDEV_FRONTEND
         tristate "Xen network device frontend driver"
         depends on XEN
+        select XEN_XENBUS_FRONTEND
         default y
         help
           The network device frontend driver allows the kernel to
diff --git a/drivers/net/bnx2x/bnx2x.h b/drivers/net/bnx2x/bnx2x.h
index 6a858a29db5..a6cd335c943 100644
--- a/drivers/net/bnx2x/bnx2x.h
+++ b/drivers/net/bnx2x/bnx2x.h
@@ -1415,12 +1415,12 @@ struct bnx2x_func_init_params {
                 else
 
 /* skip rx queue
- * if FCOE l2 support is diabled and this is the fcoe L2 queue
+ * if FCOE l2 support is disabled and this is the fcoe L2 queue
  */
 #define skip_rx_queue(bp, idx)  (NO_FCOE(bp) && IS_FCOE_IDX(idx))
 
 /* skip tx queue
- * if FCOE l2 support is diabled and this is the fcoe L2 queue
+ * if FCOE l2 support is disabled and this is the fcoe L2 queue
  */
 #define skip_tx_queue(bp, idx)  (NO_FCOE(bp) && IS_FCOE_IDX(idx))
 
diff --git a/drivers/net/bnx2x/bnx2x_main.c b/drivers/net/bnx2x/bnx2x_main.c
index 84e1af4d65e..8cdcf5b39d1 100644
--- a/drivers/net/bnx2x/bnx2x_main.c
+++ b/drivers/net/bnx2x/bnx2x_main.c
@@ -5037,7 +5037,7 @@ static int bnx2x_init_hw_common(struct bnx2x *bp, u32 load_code)
                 memset(&ilt_cli, 0, sizeof(struct ilt_client_info));
                 memset(&ilt, 0, sizeof(struct bnx2x_ilt));
 
-                /* initalize dummy TM client */
+                /* initialize dummy TM client */
                 ilt_cli.start = 0;
                 ilt_cli.end = ILT_NUM_PAGE_ENTRIES - 1;
                 ilt_cli.client_num = ILT_CLIENT_TM;
diff --git a/drivers/net/bnx2x/bnx2x_reg.h b/drivers/net/bnx2x/bnx2x_reg.h
index 38ef7ca9f21..c939683e3d6 100644
--- a/drivers/net/bnx2x/bnx2x_reg.h
+++ b/drivers/net/bnx2x/bnx2x_reg.h
@@ -1633,7 +1633,7 @@
    (~misc_registers_sw_timer_cfg_4.sw_timer_cfg_4[1] ) is set */
 #define MISC_REG_SW_TIMER_RELOAD_VAL_4                           0xa2fc
 /* [RW 32] the value of the counter for sw timers1-8. there are 8 addresses
-   in this register. addres 0 - timer 1; address 1 - timer 2, ...  address 7 -
+   in this register. address 0 - timer 1; address 1 - timer 2, ...  address 7 -
    timer 8 */
 #define MISC_REG_SW_TIMER_VAL                                    0xa5c0
 /* [RW 1] Set by the MCP to remember if one or more of the drivers is/are
diff --git a/drivers/net/bonding/bond_3ad.c b/drivers/net/bonding/bond_3ad.c
index 48cf24ff4e6..171782e2bb3 100644
--- a/drivers/net/bonding/bond_3ad.c
+++ b/drivers/net/bonding/bond_3ad.c
@@ -840,7 +840,7 @@ static int ad_lacpdu_send(struct port *port)
         lacpdu_header = (struct lacpdu_header *)skb_put(skb, length);
 
         memcpy(lacpdu_header->hdr.h_dest, lacpdu_mcast_addr, ETH_ALEN);
-        /* Note: source addres is set to be the member's PERMANENT address,
+        /* Note: source address is set to be the member's PERMANENT address,
            because we use it to identify loopback lacpdus in receive. */
         memcpy(lacpdu_header->hdr.h_source, slave->perm_hwaddr, ETH_ALEN);
         lacpdu_header->hdr.h_proto = PKT_TYPE_LACPDU;
@@ -881,7 +881,7 @@ static int ad_marker_send(struct port *port, struct bond_marker *marker)
         marker_header = (struct bond_marker_header *)skb_put(skb, length);
 
         memcpy(marker_header->hdr.h_dest, lacpdu_mcast_addr, ETH_ALEN);
-        /* Note: source addres is set to be the member's PERMANENT address,
+        /* Note: source address is set to be the member's PERMANENT address,
            because we use it to identify loopback MARKERs in receive. */
         memcpy(marker_header->hdr.h_source, slave->perm_hwaddr, ETH_ALEN);
         marker_header->hdr.h_proto = PKT_TYPE_LACPDU;
@@ -1916,7 +1916,7 @@ int bond_3ad_bind_slave(struct slave *slave)
                 return -1;
         }
 
-        //check that the slave has not been intialized yet.
+        //check that the slave has not been initialized yet.
         if (SLAVE_AD_INFO(slave).port.slave != slave) {
 
                 // port initialization
diff --git a/drivers/net/chelsio/subr.c b/drivers/net/chelsio/subr.c
index 63ebf76d239..8a43c7e1970 100644
--- a/drivers/net/chelsio/subr.c
+++ b/drivers/net/chelsio/subr.c
@@ -556,7 +556,7 @@ struct chelsio_vpd_t {
 #define EEPROM_MAX_POLL   4
 
 /*
- * Read SEEPROM. A zero is written to the flag register when the addres is
+ * Read SEEPROM. A zero is written to the flag register when the address is
  * written to the Control register. The hardware device will set the flag to a
  * one when 4B have been transferred to the Data register.
  */
diff --git a/drivers/net/cxgb3/mc5.c b/drivers/net/cxgb3/mc5.c
index a8766fb2f9a..e13b7fe9d08 100644
--- a/drivers/net/cxgb3/mc5.c
+++ b/drivers/net/cxgb3/mc5.c
@@ -318,7 +318,7 @@ static void mc5_dbgi_mode_disable(const struct mc5 *mc5)
 
 /*
  * Initialization that requires the OS and protocol layers to already
- * be intialized goes here.
+ * be initialized goes here.
  */
 int t3_mc5_init(struct mc5 *mc5, unsigned int nservers, unsigned int nfilters,
                 unsigned int nroutes)
diff --git a/drivers/net/cxgb3/t3_hw.c b/drivers/net/cxgb3/t3_hw.c
index ec8579a0a80..d55db6b38e7 100644
--- a/drivers/net/cxgb3/t3_hw.c
+++ b/drivers/net/cxgb3/t3_hw.c
@@ -607,7 +607,7 @@ struct t3_vpd {
  *
  *      Read a 32-bit word from a location in VPD EEPROM using the card's PCI
  *      VPD ROM capability.  A zero is written to the flag bit when the
- *      addres is written to the control register.  The hardware device will
+ *      address is written to the control register.  The hardware device will
  *      set the flag to 1 when 4 bytes have been read into the data register.
  */
 int t3_seeprom_read(struct adapter *adapter, u32 addr, __le32 *data)
diff --git a/drivers/net/e1000/e1000_hw.h b/drivers/net/e1000/e1000_hw.h
index f5514a0d5be..196eeda2dd6 100644
--- a/drivers/net/e1000/e1000_hw.h
+++ b/drivers/net/e1000/e1000_hw.h
@@ -41,7 +41,7 @@ struct e1000_hw;
 struct e1000_hw_stats;
 
 /* Enumerated types specific to the e1000 hardware */
-/* Media Access Controlers */
+/* Media Access Controllers */
 typedef enum {
         e1000_undefined = 0,
         e1000_82542_rev2_0,
diff --git a/drivers/net/e1000/e1000_main.c b/drivers/net/e1000/e1000_main.c
index 4ff88a683f6..de69c54301c 100644
--- a/drivers/net/e1000/e1000_main.c
+++ b/drivers/net/e1000/e1000_main.c
@@ -2233,7 +2233,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
          * addresses take precedence to avoid disabling unicast filtering
          * when possible.
          *
-         * RAR 0 is used for the station MAC adddress
+         * RAR 0 is used for the station MAC address
          * if there are not 14 addresses, go ahead and clear the filters
          */
         i = 1;
diff --git a/drivers/net/e1000e/82571.c b/drivers/net/e1000e/82571.c
index cb6c7b1c1fb..1397da118f0 100644
--- a/drivers/net/e1000e/82571.c
+++ b/drivers/net/e1000e/82571.c
@@ -328,7 +328,7 @@ static s32 e1000_init_mac_params_82571(struct e1000_adapter *adapter)
 
         /*
          * Ensure that the inter-port SWSM.SMBI lock bit is clear before
-         * first NVM or PHY acess. This should be done for single-port
+         * first NVM or PHY access. This should be done for single-port
          * devices, and for one port only on dual-port devices so that
          * for those devices we can still use the SMBI lock to synchronize
          * inter-port accesses to the PHY & NVM.
diff --git a/drivers/net/e1000e/ich8lan.c b/drivers/net/e1000e/ich8lan.c
index 5328a292773..5bb65b7382d 100644
--- a/drivers/net/e1000e/ich8lan.c
+++ b/drivers/net/e1000e/ich8lan.c
@@ -321,7 +321,7 @@ static s32 e1000_init_phy_params_pchlan(struct e1000_hw *hw)
         }
 
         /*
-         * Reset the PHY before any acccess to it.  Doing so, ensures that
+         * Reset the PHY before any access to it.  Doing so, ensures that
          * the PHY is in a known good state before we read/write PHY registers.
          * The generic reset is sufficient here, because we haven't determined
          * the PHY type yet.
diff --git a/drivers/net/e1000e/phy.c b/drivers/net/e1000e/phy.c
index a640f1c369a..00f89e8a9fa 100644
--- a/drivers/net/e1000e/phy.c
+++ b/drivers/net/e1000e/phy.c
@@ -2986,7 +2986,7 @@ s32 e1000_write_phy_reg_hv_locked(struct e1000_hw *hw, u32 offset, u16 data)
 }
 
 /**
- *  e1000_get_phy_addr_for_hv_page - Get PHY adrress based on page
+ *  e1000_get_phy_addr_for_hv_page - Get PHY address based on page
  *  @page: page to be accessed
  **/
 static u32 e1000_get_phy_addr_for_hv_page(u32 page)
diff --git a/drivers/net/eepro.c b/drivers/net/eepro.c
index 4fa8d2a4aef..eb35951a244 100644
--- a/drivers/net/eepro.c
+++ b/drivers/net/eepro.c
@@ -1761,7 +1761,7 @@ module_param_array(io, int, NULL, 0);
 module_param_array(irq, int, NULL, 0);
 module_param_array(mem, int, NULL, 0);
 module_param(autodetect, int, 0);
-MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base addres(es)");
+MODULE_PARM_DESC(io, "EtherExpress Pro/10 I/O base address(es)");
 MODULE_PARM_DESC(irq, "EtherExpress Pro/10 IRQ number(s)");
 MODULE_PARM_DESC(mem, "EtherExpress Pro/10 Rx buffer size(es) in kB (3-29)");
 MODULE_PARM_DESC(autodetect, "EtherExpress Pro/10 force board(s) detection (0-1)");
diff --git a/drivers/net/irda/donauboe.h b/drivers/net/irda/donauboe.h
index 4dc39e5f015..77fcf445916 100644
--- a/drivers/net/irda/donauboe.h
+++ b/drivers/net/irda/donauboe.h
@@ -30,7 +30,7 @@
  *     or the type-DO IR port.
  *
  * IrDA chip set list from Toshiba Computer Engineering Corp.
- * model                        method  maker   controler               Version 
+ * model                        method  maker   controller              Version 
  * Portege 320CT        FIR,SIR Toshiba Oboe(Triangle) 
  * Portege 3010CT       FIR,SIR Toshiba Oboe(Sydney) 
  * Portege 3015CT       FIR,SIR Toshiba Oboe(Sydney) 
diff --git a/drivers/net/ixgbe/ixgbe_82599.c b/drivers/net/ixgbe/ixgbe_82599.c
index 8d316d9cd29..a21f5817685 100644
--- a/drivers/net/ixgbe/ixgbe_82599.c
+++ b/drivers/net/ixgbe/ixgbe_82599.c
@@ -1079,7 +1079,7 @@ s32 ixgbe_init_fdir_signature_82599(struct ixgbe_hw *hw, u32 pballoc)
 
         /*
          * The defaults in the HW for RX PB 1-7 are not zero and so should be
-         * intialized to zero for non DCB mode otherwise actual total RX PB
+         * initialized to zero for non DCB mode otherwise actual total RX PB
          * would be bigger than programmed and filter space would run into
          * the PB 0 region.
          */
@@ -1167,7 +1167,7 @@ s32 ixgbe_init_fdir_perfect_82599(struct ixgbe_hw *hw, u32 pballoc)
 
         /*
          * The defaults in the HW for RX PB 1-7 are not zero and so should be
-         * intialized to zero for non DCB mode otherwise actual total RX PB
+         * initialized to zero for non DCB mode otherwise actual total RX PB
          * would be bigger than programmed and filter space would run into
          * the PB 0 region.
          */
diff --git a/drivers/net/ll_temac_main.c b/drivers/net/ll_temac_main.c
index 183765cb7f2..f35554d1144 100644
--- a/drivers/net/ll_temac_main.c
+++ b/drivers/net/ll_temac_main.c
@@ -238,7 +238,7 @@ static int temac_dma_bd_init(struct net_device *ndev)
                 goto out;
         }
         /* allocate the tx and rx ring buffer descriptors. */
-        /* returns a virtual addres and a physical address. */
+        /* returns a virtual address and a physical address. */
         lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
                                          sizeof(*lp->tx_bd_v) * TX_BD_NUM,
                                          &lp->tx_bd_p, GFP_KERNEL);
diff --git a/drivers/net/sis900.c b/drivers/net/sis900.c
index 58183686709..5976d1d51df 100644
--- a/drivers/net/sis900.c
+++ b/drivers/net/sis900.c
@@ -36,7 +36,7 @@
    Rev 1.07.06 Nov.  7 2000 Jeff Garzik <jgarzik@pobox.com> some bug fix and cleaning
    Rev 1.07.05 Nov.  6 2000 metapirat<metapirat@gmx.de> contribute media type select by ifconfig
    Rev 1.07.04 Sep.  6 2000 Lei-Chun Chang added ICS1893 PHY support
-   Rev 1.07.03 Aug. 24 2000 Lei-Chun Chang (lcchang@sis.com.tw) modified 630E eqaulizer workaround rule
+   Rev 1.07.03 Aug. 24 2000 Lei-Chun Chang (lcchang@sis.com.tw) modified 630E equalizer workaround rule
    Rev 1.07.01 Aug. 08 2000 Ollie Lho minor update for SiS 630E and SiS 630E A1
    Rev 1.07    Mar. 07 2000 Ollie Lho bug fix in Rx buffer ring
    Rev 1.06.04 Feb. 11 2000 Jeff Garzik <jgarzik@pobox.com> softnet and init for kernel 2.4
diff --git a/drivers/net/tehuti.c b/drivers/net/tehuti.c
index 296000bf5a2..3397618d4d9 100644
--- a/drivers/net/tehuti.c
+++ b/drivers/net/tehuti.c
@@ -12,7 +12,7 @@
 /*
  * RX HW/SW interaction overview
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * There are 2 types of RX communication channels betwean driver and NIC.
+ * There are 2 types of RX communication channels between driver and NIC.
  * 1) RX Free Fifo - RXF - holds descriptors of empty buffers to accept incoming
  * traffic. This Fifo is filled by SW and is readen by HW. Each descriptor holds
  * info about buffer's location, size and ID. An ID field is used to identify a
@@ -821,7 +821,7 @@ static void bdx_setmulti(struct net_device *ndev)
                 }
 
                 /* use PMF to accept first MAC_MCST_NUM (15) addresses */
-                /* TBD: sort addreses and write them in ascending order
+                /* TBD: sort addresses and write them in ascending order
                  * into RX_MAC_MCST regs. we skip this phase now and accept ALL
                  * multicast frames throu IMF */
                 /* accept the rest of addresses throu IMF */
@@ -1346,7 +1346,7 @@ static void print_rxfd(struct rxf_desc *rxfd)
 /*
  * TX HW/SW interaction overview
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- * There are 2 types of TX communication channels betwean driver and NIC.
+ * There are 2 types of TX communication channels between driver and NIC.
  * 1) TX Free Fifo - TXF - holds ack descriptors for sent packets
  * 2) TX Data Fifo - TXD - holds descriptors of full buffers.
  *
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 7599c457abd..b100bd50a0d 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -1309,7 +1309,7 @@ static long __tun_chr_ioctl(struct file *file, unsigned int cmd,
                 break;
 
         case SIOCGIFHWADDR:
-                /* Get hw addres */
+                /* Get hw address */
                 memcpy(ifr.ifr_hwaddr.sa_data, tun->dev->dev_addr, ETH_ALEN);
                 ifr.ifr_hwaddr.sa_family = tun->dev->type;
                 if (copy_to_user(argp, &ifr, ifreq_len))
diff --git a/drivers/net/via-velocity.c b/drivers/net/via-velocity.c
index cab96ad49e6..09cac704fdd 100644
--- a/drivers/net/via-velocity.c
+++ b/drivers/net/via-velocity.c
@@ -898,7 +898,7 @@ static int velocity_set_media_mode(struct velocity_info *vptr, u32 mii_status)
         set_mii_flow_control(vptr);
 
         /*
-           Check if new status is consisent with current status
+           Check if new status is consistent with current status
            if (((mii_status & curr_status) & VELOCITY_AUTONEG_ENABLE) ||
                (mii_status==curr_status)) {
            vptr->mii_status=mii_check_media_mode(vptr->mac_regs);
diff --git a/drivers/net/vxge/vxge-traffic.h b/drivers/net/vxge/vxge-traffic.h
index 8c3103fb644..d48486d6afa 100644
--- a/drivers/net/vxge/vxge-traffic.h
+++ b/drivers/net/vxge/vxge-traffic.h
@@ -1695,7 +1695,7 @@ struct vxge_hw_device_stats_sw_err {
  * struct vxge_hw_device_stats - Contains HW per-device statistics,
  * including hw.
  * @devh: HW device handle.
- * @dma_addr: DMA addres of the %hw_info. Given to device to fill-in the stats.
+ * @dma_addr: DMA address of the %hw_info. Given to device to fill-in the stats.
  * @hw_info_dmah: DMA handle used to map hw statistics onto the device memory
  *                space.
  * @hw_info_dma_acch: One more DMA handle used subsequently to free the
diff --git a/drivers/net/wan/dscc4.c b/drivers/net/wan/dscc4.c
index 34cff6ce6d2..4578e5b4b41 100644
--- a/drivers/net/wan/dscc4.c
+++ b/drivers/net/wan/dscc4.c
@@ -125,7 +125,7 @@ static u32 dscc4_pci_config_store[16];
 /* Module parameters */
 
 MODULE_AUTHOR("Maintainer: Francois Romieu <romieu@cogenit.fr>");
-MODULE_DESCRIPTION("Siemens PEB20534 PCI Controler");
+MODULE_DESCRIPTION("Siemens PEB20534 PCI Controller");
 MODULE_LICENSE("GPL");
 module_param(debug, int, 0);
 MODULE_PARM_DESC(debug,"Enable/disable extra messages");
diff --git a/drivers/net/wimax/i2400m/driver.c b/drivers/net/wimax/i2400m/driver.c
index f0603327aaf..65bc334ed57 100644
--- a/drivers/net/wimax/i2400m/driver.c
+++ b/drivers/net/wimax/i2400m/driver.c
@@ -232,7 +232,7 @@ int i2400m_check_mac_addr(struct i2400m *i2400m)
                         result);
                 goto error;
         }
-        /* Extract MAC addresss */
+        /* Extract MAC address */
         ddi = (void *) skb->data;
         BUILD_BUG_ON(ETH_ALEN != sizeof(ddi->mac_address));
         d_printf(2, dev, "GET DEVICE INFO: mac addr %pM\n",
diff --git a/drivers/net/wimax/i2400m/i2400m.h b/drivers/net/wimax/i2400m/i2400m.h
index 17ecaa41a80..030cbfd3170 100644
--- a/drivers/net/wimax/i2400m/i2400m.h
+++ b/drivers/net/wimax/i2400m/i2400m.h
@@ -186,7 +186,7 @@ enum {
  * struct i2400m_poke_table - Hardware poke table for the Intel 2400m
  *
  * This structure will be used to create a device specific poke table
- * to put the device in a consistant state at boot time.
+ * to put the device in a consistent state at boot time.
  *
  * @address: The device address to poke
  *
@@ -703,7 +703,7 @@ enum i2400m_bm_cmd_flags {
  * @I2400M_BRI_MAC_REINIT: We need to reinitialize the boot
  *     rom after reading the MAC address. This is quite a dirty hack,
  *     if you ask me -- the device requires the bootrom to be
- *     intialized after reading the MAC address.
+ *     initialized after reading the MAC address.
  */
 enum i2400m_bri {
         I2400M_BRI_SOFT       = 1 << 1,
diff --git a/drivers/net/wireless/ath/ath5k/reg.h b/drivers/net/wireless/ath/ath5k/reg.h
index 7ad05d401ab..fd14b910395 100644
--- a/drivers/net/wireless/ath/ath5k/reg.h
+++ b/drivers/net/wireless/ath/ath5k/reg.h
@@ -1064,7 +1064,7 @@
 /*
  * EEPROM command register
  */
-#define AR5K_EEPROM_CMD         0x6008                  /* Register Addres */
+#define AR5K_EEPROM_CMD         0x6008                  /* Register Address */
 #define AR5K_EEPROM_CMD_READ    0x00000001      /* EEPROM read */
 #define AR5K_EEPROM_CMD_WRITE   0x00000002      /* EEPROM write */
 #define AR5K_EEPROM_CMD_RESET   0x00000004      /* EEPROM reset */
@@ -1084,7 +1084,7 @@
 /*
  * EEPROM config register
  */
-#define AR5K_EEPROM_CFG                 0x6010                  /* Register Addres */
+#define AR5K_EEPROM_CFG                 0x6010                  /* Register Address */
 #define AR5K_EEPROM_CFG_SIZE            0x00000003              /* Size determination override */
 #define AR5K_EEPROM_CFG_SIZE_AUTO       0
 #define AR5K_EEPROM_CFG_SIZE_4KBIT      1
@@ -1126,7 +1126,7 @@
  * Second station id register (Upper 16 bits of MAC address + PCU settings)
  */
 #define AR5K_STA_ID1                    0x8004                  /* Register Address */
-#define AR5K_STA_ID1_ADDR_U16           0x0000ffff      /* Upper 16 bits of MAC addres */
+#define AR5K_STA_ID1_ADDR_U16           0x0000ffff      /* Upper 16 bits of MAC address */
 #define AR5K_STA_ID1_AP                 0x00010000      /* Set AP mode */
 #define AR5K_STA_ID1_ADHOC              0x00020000      /* Set Ad-Hoc mode */
 #define AR5K_STA_ID1_PWR_SV             0x00040000      /* Power save reporting */
diff --git a/drivers/net/wireless/b43/phy_g.c b/drivers/net/wireless/b43/phy_g.c
index 0dc33b65e86..be482816701 100644
--- a/drivers/net/wireless/b43/phy_g.c
+++ b/drivers/net/wireless/b43/phy_g.c
@@ -1919,7 +1919,7 @@ static void b43_hardware_pctl_init_gphy(struct b43_wldev *dev)
         b43_hf_write(dev, b43_hf_read(dev) | B43_HF_HWPCTL);
 }
 
-/* Intialize B/G PHY power control */
+/* Initialize B/G PHY power control */
 static void b43_phy_init_pctl(struct b43_wldev *dev)
 {
         struct ssb_bus *bus = dev->dev->bus;
diff --git a/drivers/net/wireless/b43legacy/phy.c b/drivers/net/wireless/b43legacy/phy.c
index 35033dd342c..28e477d0158 100644
--- a/drivers/net/wireless/b43legacy/phy.c
+++ b/drivers/net/wireless/b43legacy/phy.c
@@ -153,7 +153,7 @@ void b43legacy_phy_calibrate(struct b43legacy_wldev *dev)
         phy->calibrated = 1;
 }
 
-/* intialize B PHY power control
+/* initialize B PHY power control
  * as described in http://bcm-specs.sipsolutions.net/InitPowerControl
  */
 static void b43legacy_phy_init_pctl(struct b43legacy_wldev *dev)
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn-ict.c b/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
index a5dbfea1bfa..b5cb3be0eb4 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn-ict.c
@@ -197,7 +197,7 @@ static irqreturn_t iwl_isr(int irq, void *data)
 
  none:
         /* re-enable interrupts here since we don't have anything to service. */
-        /* only Re-enable if diabled by irq  and no schedules tasklet. */
+        /* only Re-enable if disabled by irq  and no schedules tasklet. */
         if (test_bit(STATUS_INT_ENABLED, &priv->status) && !priv->_agn.inta)
                 iwl_enable_interrupts(priv);
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-agn.c b/drivers/net/wireless/iwlwifi/iwl-agn.c
index f13a83a7e62..36335b1b54d 100644
--- a/drivers/net/wireless/iwlwifi/iwl-agn.c
+++ b/drivers/net/wireless/iwlwifi/iwl-agn.c
@@ -1154,7 +1154,7 @@ static void iwl_irq_tasklet_legacy(struct iwl_priv *priv)
         }
 
         /* Re-enable all interrupts */
-        /* only Re-enable if diabled by irq */
+        /* only Re-enable if disabled by irq */
         if (test_bit(STATUS_INT_ENABLED, &priv->status))
                 iwl_enable_interrupts(priv);
 
@@ -1368,7 +1368,7 @@ static void iwl_irq_tasklet(struct iwl_priv *priv)
         }
 
         /* Re-enable all interrupts */
-        /* only Re-enable if diabled by irq */
+        /* only Re-enable if disabled by irq */
         if (test_bit(STATUS_INT_ENABLED, &priv->status))
                 iwl_enable_interrupts(priv);
 }
diff --git a/drivers/net/wireless/iwlwifi/iwl-legacy.c b/drivers/net/wireless/iwlwifi/iwl-legacy.c
index a08b4e56e6b..bb1a742a98a 100644
--- a/drivers/net/wireless/iwlwifi/iwl-legacy.c
+++ b/drivers/net/wireless/iwlwifi/iwl-legacy.c
@@ -619,7 +619,7 @@ unplugged:
 
 none:
         /* re-enable interrupts here since we don't have anything to service. */
-        /* only Re-enable if diabled by irq */
+        /* only Re-enable if disabled by irq */
         if (test_bit(STATUS_INT_ENABLED, &priv->status))
                 iwl_enable_interrupts(priv);
         spin_unlock_irqrestore(&priv->lock, flags);
diff --git a/drivers/net/wireless/iwlwifi/iwl-sta.c b/drivers/net/wireless/iwlwifi/iwl-sta.c
index 4776323b1eb..49493d17651 100644
--- a/drivers/net/wireless/iwlwifi/iwl-sta.c
+++ b/drivers/net/wireless/iwlwifi/iwl-sta.c
@@ -107,7 +107,7 @@ static int iwl_process_add_sta_resp(struct iwl_priv *priv,
         /*
          * XXX: The MAC address in the command buffer is often changed from
          * the original sent to the device. That is, the MAC address
-         * written to the command buffer often is not the same MAC adress
+         * written to the command buffer often is not the same MAC address
          * read from the command buffer when the command returns. This
          * issue has not yet been resolved and this debugging is left to
          * observe the problem.
diff --git a/drivers/net/wireless/prism54/islpci_dev.c b/drivers/net/wireless/prism54/islpci_dev.c
index 2c8cc954d1b..ec2c75d77ce 100644
--- a/drivers/net/wireless/prism54/islpci_dev.c
+++ b/drivers/net/wireless/prism54/islpci_dev.c
@@ -630,7 +630,7 @@ islpci_alloc_memory(islpci_private *priv)
         printk(KERN_DEBUG "islpci_alloc_memory\n");
 #endif
 
-        /* remap the PCI device base address to accessable */
+        /* remap the PCI device base address to accessible */
         if (!(priv->device_base =
               ioremap(pci_resource_start(priv->pdev, 0),
                       ISL38XX_PCI_MEM_SIZE))) {
@@ -709,7 +709,7 @@ islpci_alloc_memory(islpci_private *priv)
                                    PCI_DMA_FROMDEVICE);
                 if (!priv->pci_map_rx_address[counter]) {
                         /* error mapping the buffer to device
-                           accessable memory address */
+                           accessible memory address */
                         printk(KERN_ERR "failed to map skb DMA'able\n");
                         goto out_free;
                 }
@@ -773,7 +773,7 @@ islpci_free_memory(islpci_private *priv)
                 priv->data_low_rx[counter] = NULL;
         }
 
-        /* Free the acces control list and the WPA list */
+        /* Free the access control list and the WPA list */
         prism54_acl_clean(&priv->acl);
         prism54_wpa_bss_ie_clean(priv);
         mgt_clean(priv);
diff --git a/drivers/net/wireless/prism54/islpci_eth.c b/drivers/net/wireless/prism54/islpci_eth.c
index 2fc52bc2d7d..d44f8e20cce 100644
--- a/drivers/net/wireless/prism54/islpci_eth.c
+++ b/drivers/net/wireless/prism54/islpci_eth.c
@@ -450,7 +450,7 @@ islpci_eth_receive(islpci_private *priv)
                                    MAX_FRAGMENT_SIZE_RX + 2,
                                    PCI_DMA_FROMDEVICE);
                 if (unlikely(!priv->pci_map_rx_address[index])) {
-                        /* error mapping the buffer to device accessable memory address */
+                        /* error mapping the buffer to device accessible memory address */
                         DEBUG(SHOW_ERROR_MESSAGES,
                               "Error mapping DMA address\n");
 
diff --git a/drivers/net/wireless/rt2x00/rt2x00mac.c b/drivers/net/wireless/rt2x00/rt2x00mac.c
index 658542d2efe..f3da051df39 100644
--- a/drivers/net/wireless/rt2x00/rt2x00mac.c
+++ b/drivers/net/wireless/rt2x00/rt2x00mac.c
@@ -273,7 +273,7 @@ int rt2x00mac_add_interface(struct ieee80211_hw *hw,
         intf->beacon = entry;
 
         /*
-         * The MAC adddress must be configured after the device
+         * The MAC address must be configured after the device
          * has been initialized. Otherwise the device can reset
          * the MAC registers.
          * The BSSID address must only be configured in AP mode,
diff --git a/drivers/net/wireless/wl1251/acx.h b/drivers/net/wireless/wl1251/acx.h
index e54b21a4f8b..efcc3aaca14 100644
--- a/drivers/net/wireless/wl1251/acx.h
+++ b/drivers/net/wireless/wl1251/acx.h
@@ -1272,10 +1272,10 @@ struct wl1251_acx_tid_cfg {
 /* OBSOLETE */
 #define WL1251_ACX_INTR_WAKE_ON_HOST    BIT(6)
 
-/* Trace meassge on MBOX #A */
+/* Trace message on MBOX #A */
 #define WL1251_ACX_INTR_TRACE_A         BIT(7)
 
-/* Trace meassge on MBOX #B */
+/* Trace message on MBOX #B */
 #define WL1251_ACX_INTR_TRACE_B         BIT(8)
 
 /* Command processing completion */
diff --git a/drivers/net/wireless/wl1251/wl1251.h b/drivers/net/wireless/wl1251/wl1251.h
index 13fbeeccf60..c0ce2c8b43b 100644
--- a/drivers/net/wireless/wl1251/wl1251.h
+++ b/drivers/net/wireless/wl1251/wl1251.h
@@ -419,7 +419,7 @@ void wl1251_disable_interrupts(struct wl1251 *wl);
 #define WL1251_FW_NAME "wl1251-fw.bin"
 #define WL1251_NVS_NAME "wl1251-nvs.bin"
 
-#define WL1251_POWER_ON_SLEEP 10 /* in miliseconds */
+#define WL1251_POWER_ON_SLEEP 10 /* in milliseconds */
 
 #define WL1251_PART_DOWN_MEM_START      0x0
 #define WL1251_PART_DOWN_MEM_SIZE       0x16800
diff --git a/drivers/net/wireless/wl12xx/acx.h b/drivers/net/wireless/wl12xx/acx.h
index 9cbc3f40c8d..7bd8e4db4a7 100644
--- a/drivers/net/wireless/wl12xx/acx.h
+++ b/drivers/net/wireless/wl12xx/acx.h
@@ -47,9 +47,9 @@
 #define WL1271_ACX_INTR_HW_AVAILABLE       BIT(5)
 /* The MISC bit is used for aggregation of RX, TxComplete and TX rate update */
 #define WL1271_ACX_INTR_DATA               BIT(6)
-/* Trace meassge on MBOX #A */
+/* Trace message on MBOX #A */
 #define WL1271_ACX_INTR_TRACE_A            BIT(7)
-/* Trace meassge on MBOX #B */
+/* Trace message on MBOX #B */
 #define WL1271_ACX_INTR_TRACE_B            BIT(8)
 
 #define WL1271_ACX_INTR_ALL                0xFFFFFFFF
diff --git a/drivers/net/wireless/wl12xx/wl12xx.h b/drivers/net/wireless/wl12xx/wl12xx.h
index ce3d31f98c5..9050dd9b62d 100644
--- a/drivers/net/wireless/wl12xx/wl12xx.h
+++ b/drivers/net/wireless/wl12xx/wl12xx.h
@@ -416,8 +416,8 @@ int wl1271_plt_stop(struct wl1271 *wl);
 
 /* WL1271 needs a 200ms sleep after power on, and a 20ms sleep before power
    on in case is has been shut down shortly before */
-#define WL1271_PRE_POWER_ON_SLEEP 20 /* in miliseconds */
-#define WL1271_POWER_ON_SLEEP 200 /* in miliseconds */
+#define WL1271_PRE_POWER_ON_SLEEP 20 /* in milliseconds */
+#define WL1271_POWER_ON_SLEEP 200 /* in milliseconds */
 
 /* Macros to handle wl1271.sta_rate_set */
 #define HW_BG_RATES_MASK        0xffff
diff --git a/drivers/net/wireless/wl3501_cs.c b/drivers/net/wireless/wl3501_cs.c
index ee82df62e64..3e5befe4d03 100644
--- a/drivers/net/wireless/wl3501_cs.c
+++ b/drivers/net/wireless/wl3501_cs.c
@@ -192,7 +192,7 @@ static inline void wl3501_switch_page(struct wl3501_card *this, u8 page)
 }
 
 /*
- * Get Ethernet MAC addresss.
+ * Get Ethernet MAC address.
  *
  * WARNING: We switch to FPAGE0 and switc back again.
  *          Making sure there is no other WL function beening called by ISR.
diff --git a/drivers/nfc/Kconfig b/drivers/nfc/Kconfig
new file mode 100644
index 00000000000..ffedfd49275
--- /dev/null
+++ b/drivers/nfc/Kconfig
@@ -0,0 +1,30 @@
+#
+# Near Field Communication (NFC) devices
+#
+
+menuconfig NFC_DEVICES
+        bool "NFC devices"
+        default n
+        ---help---
+          You'll have to say Y if your computer contains an NFC device that
+          you want to use under Linux.
+
+          You can say N here if you don't have any Near Field Communication
+          devices connected to your computer.
+
+if NFC_DEVICES
+
+config PN544_NFC
+        tristate "PN544 NFC driver"
+        depends on I2C
+        select CRC_CCITT
+        default n
+        ---help---
+          Say yes if you want PN544 Near Field Communication driver.
+          This is for i2c connected version. If unsure, say N here.
+
+          To compile this driver as a module, choose m here. The module will
+          be called pn544.
+
+
+endif # NFC_DEVICES
diff --git a/drivers/nfc/Makefile b/drivers/nfc/Makefile
new file mode 100644
index 00000000000..a4efb164ec4
--- /dev/null
+++ b/drivers/nfc/Makefile
@@ -0,0 +1,5 @@
+#
+# Makefile for nfc devices
+#
+
+obj-$(CONFIG_PN544_NFC)         += pn544.o
diff --git a/drivers/nfc/pn544.c b/drivers/nfc/pn544.c
new file mode 100644
index 00000000000..401c44b6ead
--- /dev/null
+++ b/drivers/nfc/pn544.c
@@ -0,0 +1,891 @@
+/*
+ * Driver for the PN544 NFC chip.
+ *
+ * Copyright (C) Nokia Corporation
+ *
+ * Author: Jari Vanhala <ext-jari.vanhala@nokia.com>
+ * Contact: Matti Aaltonen <matti.j.aaltonen@nokia.com>
+ *
+ * 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.
+ *
+ * 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/completion.h>
+#include <linux/crc-ccitt.h>
+#include <linux/delay.h>
+#include <linux/interrupt.h>
+#include <linux/kernel.h>
+#include <linux/miscdevice.h>
+#include <linux/module.h>
+#include <linux/mutex.h>
+#include <linux/nfc/pn544.h>
+#include <linux/poll.h>
+#include <linux/regulator/consumer.h>
+#include <linux/serial_core.h> /* for TCGETS */
+#include <linux/slab.h>
+
+#define DRIVER_CARD     "PN544 NFC"
+#define DRIVER_DESC     "NFC driver for PN544"
+
+static struct i2c_device_id pn544_id_table[] = {
+        { PN544_DRIVER_NAME, 0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, pn544_id_table);
+
+#define HCI_MODE        0
+#define FW_MODE         1
+
+enum pn544_state {
+        PN544_ST_COLD,
+        PN544_ST_FW_READY,
+        PN544_ST_READY,
+};
+
+enum pn544_irq {
+        PN544_NONE,
+        PN544_INT,
+};
+
+struct pn544_info {
+        struct miscdevice miscdev;
+        struct i2c_client *i2c_dev;
+        struct regulator_bulk_data regs[2];
+
+        enum pn544_state state;
+        wait_queue_head_t read_wait;
+        loff_t read_offset;
+        enum pn544_irq read_irq;
+        struct mutex read_mutex; /* Serialize read_irq access */
+        struct mutex mutex; /* Serialize info struct access */
+        u8 *buf;
+        unsigned int buflen;
+};
+
+static const char reg_vdd_io[]  = "Vdd_IO";
+static const char reg_vbat[]    = "VBat";
+
+/* sysfs interface */
+static ssize_t pn544_test(struct device *dev,
+                          struct device_attribute *attr, char *buf)
+{
+        struct pn544_info *info = dev_get_drvdata(dev);
+        struct i2c_client *client = info->i2c_dev;
+        struct pn544_nfc_platform_data *pdata = client->dev.platform_data;
+
+        return snprintf(buf, PAGE_SIZE, "%d\n", pdata->test());
+}
+
+static int pn544_enable(struct pn544_info *info, int mode)
+{
+        struct pn544_nfc_platform_data *pdata;
+        struct i2c_client *client = info->i2c_dev;
+
+        int r;
+
+        r = regulator_bulk_enable(ARRAY_SIZE(info->regs), info->regs);
+        if (r < 0)
+                return r;
+
+        pdata = client->dev.platform_data;
+        info->read_irq = PN544_NONE;
+        if (pdata->enable)
+                pdata->enable(mode);
+
+        if (mode) {
+                info->state = PN544_ST_FW_READY;
+                dev_dbg(&client->dev, "now in FW-mode\n");
+        } else {
+                info->state = PN544_ST_READY;
+                dev_dbg(&client->dev, "now in HCI-mode\n");
+        }
+
+        usleep_range(10000, 15000);
+
+        return 0;
+}
+
+static void pn544_disable(struct pn544_info *info)
+{
+        struct pn544_nfc_platform_data *pdata;
+        struct i2c_client *client = info->i2c_dev;
+
+        pdata = client->dev.platform_data;
+        if (pdata->disable)
+                pdata->disable();
+
+        info->state = PN544_ST_COLD;
+
+        dev_dbg(&client->dev, "Now in OFF-mode\n");
+
+        msleep(PN544_RESETVEN_TIME);
+
+        info->read_irq = PN544_NONE;
+        regulator_bulk_disable(ARRAY_SIZE(info->regs), info->regs);
+}
+
+static int check_crc(u8 *buf, int buflen)
+{
+        u8 len;
+        u16 crc;
+
+        len = buf[0] + 1;
+        if (len < 4 || len != buflen || len > PN544_MSG_MAX_SIZE) {
+                pr_err(PN544_DRIVER_NAME
+                       ": CRC; corrupt packet len %u (%d)\n", len, buflen);
+                print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,
+                               16, 2, buf, buflen, false);
+                return -EPERM;
+        }
+        crc = crc_ccitt(0xffff, buf, len - 2);
+        crc = ~crc;
+
+        if (buf[len-2] != (crc & 0xff) || buf[len-1] != (crc >> 8)) {
+                pr_err(PN544_DRIVER_NAME ": CRC error 0x%x != 0x%x 0x%x\n",
+                       crc, buf[len-1], buf[len-2]);
+
+                print_hex_dump(KERN_DEBUG, "crc: ", DUMP_PREFIX_NONE,
+                               16, 2, buf, buflen, false);
+                return -EPERM;
+        }
+        return 0;
+}
+
+static int pn544_i2c_write(struct i2c_client *client, u8 *buf, int len)
+{
+        int r;
+
+        if (len < 4 || len != (buf[0] + 1)) {
+                dev_err(&client->dev, "%s: Illegal message length: %d\n",
+                        __func__, len);
+                return -EINVAL;
+        }
+
+        if (check_crc(buf, len))
+                return -EINVAL;
+
+        usleep_range(3000, 6000);
+
+        r = i2c_master_send(client, buf, len);
+        dev_dbg(&client->dev, "send: %d\n", r);
+
+        if (r == -EREMOTEIO) { /* Retry, chip was in standby */
+                usleep_range(6000, 10000);
+                r = i2c_master_send(client, buf, len);
+                dev_dbg(&client->dev, "send2: %d\n", r);
+        }
+
+        if (r != len)
+                return -EREMOTEIO;
+
+        return r;
+}
+
+static int pn544_i2c_read(struct i2c_client *client, u8 *buf, int buflen)
+{
+        int r;
+        u8 len;
+
+        /*
+         * You could read a packet in one go, but then you'd need to read
+         * max size and rest would be 0xff fill, so we do split reads.
+         */
+        r = i2c_master_recv(client, &len, 1);
+        dev_dbg(&client->dev, "recv1: %d\n", r);
+
+        if (r != 1)
+                return -EREMOTEIO;
+
+        if (len < PN544_LLC_HCI_OVERHEAD)
+                len = PN544_LLC_HCI_OVERHEAD;
+        else if (len > (PN544_MSG_MAX_SIZE - 1))
+                len = PN544_MSG_MAX_SIZE - 1;
+
+        if (1 + len > buflen) /* len+(data+crc16) */
+                return -EMSGSIZE;
+
+        buf[0] = len;
+
+        r = i2c_master_recv(client, buf + 1, len);
+        dev_dbg(&client->dev, "recv2: %d\n", r);
+
+        if (r != len)
+                return -EREMOTEIO;
+
+        usleep_range(3000, 6000);
+
+        return r + 1;
+}
+
+static int pn544_fw_write(struct i2c_client *client, u8 *buf, int len)
+{
+        int r;
+
+        dev_dbg(&client->dev, "%s\n", __func__);
+
+        if (len < PN544_FW_HEADER_SIZE ||
+            (PN544_FW_HEADER_SIZE + (buf[1] << 8) + buf[2]) != len)
+                return -EINVAL;
+
+        r = i2c_master_send(client, buf, len);
+        dev_dbg(&client->dev, "fw send: %d\n", r);
+
+        if (r == -EREMOTEIO) { /* Retry, chip was in standby */
+                usleep_range(6000, 10000);
+                r = i2c_master_send(client, buf, len);
+                dev_dbg(&client->dev, "fw send2: %d\n", r);
+        }
+
+        if (r != len)
+                return -EREMOTEIO;
+
+        return r;
+}
+
+static int pn544_fw_read(struct i2c_client *client, u8 *buf, int buflen)
+{
+        int r, len;
+
+        if (buflen < PN544_FW_HEADER_SIZE)
+                return -EINVAL;
+
+        r = i2c_master_recv(client, buf, PN544_FW_HEADER_SIZE);
+        dev_dbg(&client->dev, "FW recv1: %d\n", r);
+
+        if (r < 0)
+                return r;
+
+        if (r < PN544_FW_HEADER_SIZE)
+                return -EINVAL;
+
+        len = (buf[1] << 8) + buf[2];
+        if (len == 0) /* just header, no additional data */
+                return r;
+
+        if (len > buflen - PN544_FW_HEADER_SIZE)
+                return -EMSGSIZE;
+
+        r = i2c_master_recv(client, buf + PN544_FW_HEADER_SIZE, len);
+        dev_dbg(&client->dev, "fw recv2: %d\n", r);
+
+        if (r != len)
+                return -EINVAL;
+
+        return r + PN544_FW_HEADER_SIZE;
+}
+
+static irqreturn_t pn544_irq_thread_fn(int irq, void *dev_id)
+{
+        struct pn544_info *info = dev_id;
+        struct i2c_client *client = info->i2c_dev;
+
+        BUG_ON(!info);
+        BUG_ON(irq != info->i2c_dev->irq);
+
+        dev_dbg(&client->dev, "IRQ\n");
+
+        mutex_lock(&info->read_mutex);
+        info->read_irq = PN544_INT;
+        mutex_unlock(&info->read_mutex);
+
+        wake_up_interruptible(&info->read_wait);
+
+        return IRQ_HANDLED;
+}
+
+static enum pn544_irq pn544_irq_state(struct pn544_info *info)
+{
+        enum pn544_irq irq;
+
+        mutex_lock(&info->read_mutex);
+        irq = info->read_irq;
+        mutex_unlock(&info->read_mutex);
+        /*
+         * XXX: should we check GPIO-line status directly?
+         * return pdata->irq_status() ? PN544_INT : PN544_NONE;
+         */
+
+        return irq;
+}
+
+static ssize_t pn544_read(struct file *file, char __user *buf,
+                          size_t count, loff_t *offset)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+        enum pn544_irq irq;
+        size_t len;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s: info: %p, count: %zu\n", __func__,
+                info, count);
+
+        mutex_lock(&info->mutex);
+
+        if (info->state == PN544_ST_COLD) {
+                r = -ENODEV;
+                goto out;
+        }
+
+        irq = pn544_irq_state(info);
+        if (irq == PN544_NONE) {
+                if (file->f_flags & O_NONBLOCK) {
+                        r = -EAGAIN;
+                        goto out;
+                }
+
+                if (wait_event_interruptible(info->read_wait,
+                                             (info->read_irq == PN544_INT))) {
+                        r = -ERESTARTSYS;
+                        goto out;
+                }
+        }
+
+        if (info->state == PN544_ST_FW_READY) {
+                len = min(count, info->buflen);
+
+                mutex_lock(&info->read_mutex);
+                r = pn544_fw_read(info->i2c_dev, info->buf, len);
+                info->read_irq = PN544_NONE;
+                mutex_unlock(&info->read_mutex);
+
+                if (r < 0) {
+                        dev_err(&info->i2c_dev->dev, "FW read failed: %d\n", r);
+                        goto out;
+                }
+
+                print_hex_dump(KERN_DEBUG, "FW read: ", DUMP_PREFIX_NONE,
+                               16, 2, info->buf, r, false);
+
+                *offset += r;
+                if (copy_to_user(buf, info->buf, r)) {
+                        r = -EFAULT;
+                        goto out;
+                }
+        } else {
+                len = min(count, info->buflen);
+
+                mutex_lock(&info->read_mutex);
+                r = pn544_i2c_read(info->i2c_dev, info->buf, len);
+                info->read_irq = PN544_NONE;
+                mutex_unlock(&info->read_mutex);
+
+                if (r < 0) {
+                        dev_err(&info->i2c_dev->dev, "read failed (%d)\n", r);
+                        goto out;
+                }
+                print_hex_dump(KERN_DEBUG, "read: ", DUMP_PREFIX_NONE,
+                               16, 2, info->buf, r, false);
+
+                *offset += r;
+                if (copy_to_user(buf, info->buf, r)) {
+                        r = -EFAULT;
+                        goto out;
+                }
+        }
+
+out:
+        mutex_unlock(&info->mutex);
+
+        return r;
+}
+
+static unsigned int pn544_poll(struct file *file, poll_table *wait)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s: info: %p\n", __func__, info);
+
+        mutex_lock(&info->mutex);
+
+        if (info->state == PN544_ST_COLD) {
+                r = -ENODEV;
+                goto out;
+        }
+
+        poll_wait(file, &info->read_wait, wait);
+
+        if (pn544_irq_state(info) == PN544_INT) {
+                r = POLLIN | POLLRDNORM;
+                goto out;
+        }
+out:
+        mutex_unlock(&info->mutex);
+
+        return r;
+}
+
+static ssize_t pn544_write(struct file *file, const char __user *buf,
+                           size_t count, loff_t *ppos)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+        ssize_t len;
+        int r;
+
+        dev_dbg(&client->dev, "%s: info: %p, count %zu\n", __func__,
+                info, count);
+
+        mutex_lock(&info->mutex);
+
+        if (info->state == PN544_ST_COLD) {
+                r = -ENODEV;
+                goto out;
+        }
+
+        /*
+         * XXX: should we detect rset-writes and clean possible
+         * read_irq state
+         */
+        if (info->state == PN544_ST_FW_READY) {
+                size_t fw_len;
+
+                if (count < PN544_FW_HEADER_SIZE) {
+                        r = -EINVAL;
+                        goto out;
+                }
+
+                len = min(count, info->buflen);
+                if (copy_from_user(info->buf, buf, len)) {
+                        r = -EFAULT;
+                        goto out;
+                }
+
+                print_hex_dump(KERN_DEBUG, "FW write: ", DUMP_PREFIX_NONE,
+                               16, 2, info->buf, len, false);
+
+                fw_len = PN544_FW_HEADER_SIZE + (info->buf[1] << 8) +
+                        info->buf[2];
+
+                if (len > fw_len) /* 1 msg at a time */
+                        len = fw_len;
+
+                r = pn544_fw_write(info->i2c_dev, info->buf, len);
+        } else {
+                if (count < PN544_LLC_MIN_SIZE) {
+                        r = -EINVAL;
+                        goto out;
+                }
+
+                len = min(count, info->buflen);
+                if (copy_from_user(info->buf, buf, len)) {
+                        r = -EFAULT;
+                        goto out;
+                }
+
+                print_hex_dump(KERN_DEBUG, "write: ", DUMP_PREFIX_NONE,
+                               16, 2, info->buf, len, false);
+
+                if (len > (info->buf[0] + 1)) /* 1 msg at a time */
+                        len  = info->buf[0] + 1;
+
+                r = pn544_i2c_write(info->i2c_dev, info->buf, len);
+        }
+out:
+        mutex_unlock(&info->mutex);
+
+        return r;
+
+}
+
+static long pn544_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+        struct pn544_nfc_platform_data *pdata;
+        unsigned int val;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s: info: %p, cmd: 0x%x\n", __func__, info, cmd);
+
+        mutex_lock(&info->mutex);
+
+        if (info->state == PN544_ST_COLD) {
+                r = -ENODEV;
+                goto out;
+        }
+
+        pdata = info->i2c_dev->dev.platform_data;
+        switch (cmd) {
+        case PN544_GET_FW_MODE:
+                dev_dbg(&client->dev, "%s:  PN544_GET_FW_MODE\n", __func__);
+
+                val = (info->state == PN544_ST_FW_READY);
+                if (copy_to_user((void __user *)arg, &val, sizeof(val))) {
+                        r = -EFAULT;
+                        goto out;
+                }
+
+                break;
+
+        case PN544_SET_FW_MODE:
+                dev_dbg(&client->dev, "%s:  PN544_SET_FW_MODE\n", __func__);
+
+                if (copy_from_user(&val, (void __user *)arg, sizeof(val))) {
+                        r = -EFAULT;
+                        goto out;
+                }
+
+                if (val) {
+                        if (info->state == PN544_ST_FW_READY)
+                                break;
+
+                        pn544_disable(info);
+                        r = pn544_enable(info, FW_MODE);
+                        if (r < 0)
+                                goto out;
+                } else {
+                        if (info->state == PN544_ST_READY)
+                                break;
+                        pn544_disable(info);
+                        r = pn544_enable(info, HCI_MODE);
+                        if (r < 0)
+                                goto out;
+                }
+                file->f_pos = info->read_offset;
+                break;
+
+        case TCGETS:
+                dev_dbg(&client->dev, "%s:  TCGETS\n", __func__);
+
+                r = -ENOIOCTLCMD;
+                break;
+
+        default:
+                dev_err(&client->dev, "Unknown ioctl 0x%x\n", cmd);
+                r = -ENOIOCTLCMD;
+                break;
+        }
+
+out:
+        mutex_unlock(&info->mutex);
+
+        return r;
+}
+
+static int pn544_open(struct inode *inode, struct file *file)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s: info: %p, client %p\n", __func__,
+                info, info->i2c_dev);
+
+        mutex_lock(&info->mutex);
+
+        /*
+         * Only 1 at a time.
+         * XXX: maybe user (counter) would work better
+         */
+        if (info->state != PN544_ST_COLD) {
+                r = -EBUSY;
+                goto out;
+        }
+
+        file->f_pos = info->read_offset;
+        r = pn544_enable(info, HCI_MODE);
+
+out:
+        mutex_unlock(&info->mutex);
+        return r;
+}
+
+static int pn544_close(struct inode *inode, struct file *file)
+{
+        struct pn544_info *info = container_of(file->private_data,
+                                               struct pn544_info, miscdev);
+        struct i2c_client *client = info->i2c_dev;
+
+        dev_dbg(&client->dev, "%s: info: %p, client %p\n",
+                __func__, info, info->i2c_dev);
+
+        mutex_lock(&info->mutex);
+        pn544_disable(info);
+        mutex_unlock(&info->mutex);
+
+        return 0;
+}
+
+static const struct file_operations pn544_fops = {
+        .owner          = THIS_MODULE,
+        .llseek         = no_llseek,
+        .read           = pn544_read,
+        .write          = pn544_write,
+        .poll           = pn544_poll,
+        .open           = pn544_open,
+        .release        = pn544_close,
+        .unlocked_ioctl = pn544_ioctl,
+};
+
+#ifdef CONFIG_PM
+static int pn544_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct pn544_info *info;
+        int r = 0;
+
+        dev_info(&client->dev, "***\n%s: client %p\n***\n", __func__, client);
+
+        info = i2c_get_clientdata(client);
+        dev_info(&client->dev, "%s: info: %p, client %p\n", __func__,
+                 info, client);
+
+        mutex_lock(&info->mutex);
+
+        switch (info->state) {
+        case PN544_ST_FW_READY:
+                /* Do not suspend while upgrading FW, please! */
+                r = -EPERM;
+                break;
+
+        case PN544_ST_READY:
+                /*
+                 * CHECK: Device should be in standby-mode. No way to check?
+                 * Allowing low power mode for the regulator is potentially
+                 * dangerous if pn544 does not go to suspension.
+                 */
+                break;
+
+        case PN544_ST_COLD:
+                break;
+        };
+
+        mutex_unlock(&info->mutex);
+        return r;
+}
+
+static int pn544_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct pn544_info *info = i2c_get_clientdata(client);
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s: info: %p, client %p\n", __func__,
+                info, client);
+
+        mutex_lock(&info->mutex);
+
+        switch (info->state) {
+        case PN544_ST_READY:
+                /*
+                 * CHECK: If regulator low power mode is allowed in
+                 * pn544_suspend, we should go back to normal mode
+                 * here.
+                 */
+                break;
+
+        case PN544_ST_COLD:
+                break;
+
+        case PN544_ST_FW_READY:
+                break;
+        };
+
+        mutex_unlock(&info->mutex);
+
+        return r;
+}
+
+static SIMPLE_DEV_PM_OPS(pn544_pm_ops, pn544_suspend, pn544_resume);
+#endif
+
+static struct device_attribute pn544_attr =
+        __ATTR(nfc_test, S_IRUGO, pn544_test, NULL);
+
+static int __devinit pn544_probe(struct i2c_client *client,
+                                 const struct i2c_device_id *id)
+{
+        struct pn544_info *info;
+        struct pn544_nfc_platform_data *pdata;
+        int r = 0;
+
+        dev_dbg(&client->dev, "%s\n", __func__);
+        dev_dbg(&client->dev, "IRQ: %d\n", client->irq);
+
+        /* private data allocation */
+        info = kzalloc(sizeof(struct pn544_info), GFP_KERNEL);
+        if (!info) {
+                dev_err(&client->dev,
+                        "Cannot allocate memory for pn544_info.\n");
+                r = -ENOMEM;
+                goto err_info_alloc;
+        }
+
+        info->buflen = max(PN544_MSG_MAX_SIZE, PN544_MAX_I2C_TRANSFER);
+        info->buf = kzalloc(info->buflen, GFP_KERNEL);
+        if (!info->buf) {
+                dev_err(&client->dev,
+                        "Cannot allocate memory for pn544_info->buf.\n");
+                r = -ENOMEM;
+                goto err_buf_alloc;
+        }
+
+        info->regs[0].supply = reg_vdd_io;
+        info->regs[1].supply = reg_vbat;
+        r = regulator_bulk_get(&client->dev, ARRAY_SIZE(info->regs),
+                                 info->regs);
+        if (r < 0)
+                goto err_kmalloc;
+
+        info->i2c_dev = client;
+        info->state = PN544_ST_COLD;
+        info->read_irq = PN544_NONE;
+        mutex_init(&info->read_mutex);
+        mutex_init(&info->mutex);
+        init_waitqueue_head(&info->read_wait);
+        i2c_set_clientdata(client, info);
+        pdata = client->dev.platform_data;
+        if (!pdata) {
+                dev_err(&client->dev, "No platform data\n");
+                r = -EINVAL;
+                goto err_reg;
+        }
+
+        if (!pdata->request_resources) {
+                dev_err(&client->dev, "request_resources() missing\n");
+                r = -EINVAL;
+                goto err_reg;
+        }
+
+        r = pdata->request_resources(client);
+        if (r) {
+                dev_err(&client->dev, "Cannot get platform resources\n");
+                goto err_reg;
+        }
+
+        r = request_threaded_irq(client->irq, NULL, pn544_irq_thread_fn,
+                                 IRQF_TRIGGER_RISING, PN544_DRIVER_NAME,
+                                 info);
+        if (r < 0) {
+                dev_err(&client->dev, "Unable to register IRQ handler\n");
+                goto err_res;
+        }
+
+        /* If we don't have the test we don't need the sysfs file */
+        if (pdata->test) {
+                r = device_create_file(&client->dev, &pn544_attr);
+                if (r) {
+                        dev_err(&client->dev,
+                                "sysfs registration failed, error %d\n", r);
+                        goto err_irq;
+                }
+        }
+
+        info->miscdev.minor = MISC_DYNAMIC_MINOR;
+        info->miscdev.name = PN544_DRIVER_NAME;
+        info->miscdev.fops = &pn544_fops;
+        info->miscdev.parent = &client->dev;
+        r = misc_register(&info->miscdev);
+        if (r < 0) {
+                dev_err(&client->dev, "Device registration failed\n");
+                goto err_sysfs;
+        }
+
+        dev_dbg(&client->dev, "%s: info: %p, pdata %p, client %p\n",
+                __func__, info, pdata, client);
+
+        return 0;
+
+err_sysfs:
+        if (pdata->test)
+                device_remove_file(&client->dev, &pn544_attr);
+err_irq:
+        free_irq(client->irq, info);
+err_res:
+        if (pdata->free_resources)
+                pdata->free_resources();
+err_reg:
+        regulator_bulk_free(ARRAY_SIZE(info->regs), info->regs);
+err_kmalloc:
+        kfree(info->buf);
+err_buf_alloc:
+        kfree(info);
+err_info_alloc:
+        return r;
+}
+
+static __devexit int pn544_remove(struct i2c_client *client)
+{
+        struct pn544_info *info = i2c_get_clientdata(client);
+        struct pn544_nfc_platform_data *pdata = client->dev.platform_data;
+
+        dev_dbg(&client->dev, "%s\n", __func__);
+
+        misc_deregister(&info->miscdev);
+        if (pdata->test)
+                device_remove_file(&client->dev, &pn544_attr);
+
+        if (info->state != PN544_ST_COLD) {
+                if (pdata->disable)
+                        pdata->disable();
+
+                info->read_irq = PN544_NONE;
+        }
+
+        free_irq(client->irq, info);
+        if (pdata->free_resources)
+                pdata->free_resources();
+
+        regulator_bulk_free(ARRAY_SIZE(info->regs), info->regs);
+        kfree(info->buf);
+        kfree(info);
+
+        return 0;
+}
+
+static struct i2c_driver pn544_driver = {
+        .driver = {
+                .name = PN544_DRIVER_NAME,
+#ifdef CONFIG_PM
+                .pm = &pn544_pm_ops,
+#endif
+        },
+        .probe = pn544_probe,
+        .id_table = pn544_id_table,
+        .remove = __devexit_p(pn544_remove),
+};
+
+static int __init pn544_init(void)
+{
+        int r;
+
+        pr_debug(DRIVER_DESC ": %s\n", __func__);
+
+        r = i2c_add_driver(&pn544_driver);
+        if (r) {
+                pr_err(PN544_DRIVER_NAME ": driver registration failed\n");
+                return r;
+        }
+
+        return 0;
+}
+
+static void __exit pn544_exit(void)
+{
+        i2c_del_driver(&pn544_driver);
+        pr_info(DRIVER_DESC ", Exiting.\n");
+}
+
+module_init(pn544_init);
+module_exit(pn544_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION(DRIVER_DESC);
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 5b1630e4e9e..a9523fdc691 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -45,6 +45,7 @@ config XEN_PCIDEV_FRONTEND
         depends on PCI && X86 && XEN
         select HOTPLUG
         select PCI_XEN
+        select XEN_XENBUS_FRONTEND
         default y
         help
           The PCI device frontend driver allows the kernel to import arbitrary
diff --git a/drivers/pcmcia/m32r_cfc.h b/drivers/pcmcia/m32r_cfc.h
index 8146e3bee2e..f558e1adf95 100644
--- a/drivers/pcmcia/m32r_cfc.h
+++ b/drivers/pcmcia/m32r_cfc.h
@@ -9,7 +9,7 @@
 #endif
 
 /*
- * M32R PC Card Controler
+ * M32R PC Card Controller
  */
 #define M32R_PCC0_BASE        0x00ef7000
 #define M32R_PCC1_BASE        0x00ef7020
diff --git a/drivers/pcmcia/m32r_pcc.h b/drivers/pcmcia/m32r_pcc.h
index e4fffe417ba..f95c58563bc 100644
--- a/drivers/pcmcia/m32r_pcc.h
+++ b/drivers/pcmcia/m32r_pcc.h
@@ -5,7 +5,7 @@
 #define M32R_MAX_PCC    2
 
 /*
- * M32R PC Card Controler
+ * M32R PC Card Controller
  */
 #define M32R_PCC0_BASE        0x00ef7000
 #define M32R_PCC1_BASE        0x00ef7020
diff --git a/drivers/pcmcia/m8xx_pcmcia.c b/drivers/pcmcia/m8xx_pcmcia.c
index 99d4f23cb43..0db482771fb 100644
--- a/drivers/pcmcia/m8xx_pcmcia.c
+++ b/drivers/pcmcia/m8xx_pcmcia.c
@@ -1198,7 +1198,7 @@ static int __init m8xx_probe(struct platform_device *ofdev,
         out_be32(M8XX_PGCRX(1),
                  M8XX_PGCRX_CXOE | (mk_int_int_mask(hwirq) << 16));
 
-        /* intialize the fixed memory windows */
+        /* initialize the fixed memory windows */
 
         for (i = 0; i < PCMCIA_SOCKETS_NO; i++) {
                 for (m = 0; m < PCMCIA_MEM_WIN_NO; m++) {
diff --git a/drivers/platform/x86/acer-wmi.c b/drivers/platform/x86/acer-wmi.c
index ee40d681edd..c5c4b8c32eb 100644
--- a/drivers/platform/x86/acer-wmi.c
+++ b/drivers/platform/x86/acer-wmi.c
@@ -1021,7 +1021,7 @@ static int update_bl_status(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops acer_bl_ops = {
+static const struct backlight_ops acer_bl_ops = {
         .get_brightness = read_brightness,
         .update_status = update_bl_status,
 };
diff --git a/drivers/platform/x86/asus-laptop.c b/drivers/platform/x86/asus-laptop.c
index d235f44fd7a..f3aa6a7fdab 100644
--- a/drivers/platform/x86/asus-laptop.c
+++ b/drivers/platform/x86/asus-laptop.c
@@ -640,7 +640,7 @@ static int update_bl_status(struct backlight_device *bd)
         return asus_lcd_set(asus, value);
 }
 
-static struct backlight_ops asusbl_ops = {
+static const struct backlight_ops asusbl_ops = {
         .get_brightness = asus_read_brightness,
         .update_status = update_bl_status,
 };
diff --git a/drivers/platform/x86/asus_acpi.c b/drivers/platform/x86/asus_acpi.c
index ca05aefd03b..4633fd8532c 100644
--- a/drivers/platform/x86/asus_acpi.c
+++ b/drivers/platform/x86/asus_acpi.c
@@ -1467,7 +1467,7 @@ static int asus_hotk_remove(struct acpi_device *device, int type)
         return 0;
 }
 
-static struct backlight_ops asus_backlight_data = {
+static const struct backlight_ops asus_backlight_data = {
         .get_brightness = read_brightness,
         .update_status  = set_brightness_status,
 };
diff --git a/drivers/platform/x86/dell-laptop.c b/drivers/platform/x86/dell-laptop.c
index cf8a89a0d8f..34657f96b5a 100644
--- a/drivers/platform/x86/dell-laptop.c
+++ b/drivers/platform/x86/dell-laptop.c
@@ -546,7 +546,7 @@ out:
         return buffer->output[1];
 }
 
-static struct backlight_ops dell_ops = {
+static const struct backlight_ops dell_ops = {
         .get_brightness = dell_get_intensity,
         .update_status  = dell_send_intensity,
 };
diff --git a/drivers/platform/x86/eeepc-laptop.c b/drivers/platform/x86/eeepc-laptop.c
index e9fc530e7dc..49d9ad708f8 100644
--- a/drivers/platform/x86/eeepc-laptop.c
+++ b/drivers/platform/x86/eeepc-laptop.c
@@ -1126,7 +1126,7 @@ static int update_bl_status(struct backlight_device *bd)
         return set_brightness(bd, bd->props.brightness);
 }
 
-static struct backlight_ops eeepcbl_ops = {
+static const struct backlight_ops eeepcbl_ops = {
         .get_brightness = read_brightness,
         .update_status = update_bl_status,
 };
diff --git a/drivers/platform/x86/fujitsu-laptop.c b/drivers/platform/x86/fujitsu-laptop.c
index ad88b2ec34a..19e92b2a7f7 100644
--- a/drivers/platform/x86/fujitsu-laptop.c
+++ b/drivers/platform/x86/fujitsu-laptop.c
@@ -437,7 +437,7 @@ static int bl_update_status(struct backlight_device *b)
         return ret;
 }
 
-static struct backlight_ops fujitsubl_ops = {
+static const struct backlight_ops fujitsubl_ops = {
         .get_brightness = bl_get_brightness,
         .update_status = bl_update_status,
 };
diff --git a/drivers/platform/x86/sony-laptop.c b/drivers/platform/x86/sony-laptop.c
index b4a95bb2f23..5e83370b081 100644
--- a/drivers/platform/x86/sony-laptop.c
+++ b/drivers/platform/x86/sony-laptop.c
@@ -858,7 +858,7 @@ static int sony_backlight_get_brightness(struct backlight_device *bd)
 }
 
 static struct backlight_device *sony_backlight_device;
-static struct backlight_ops sony_backlight_ops = {
+static const struct backlight_ops sony_backlight_ops = {
         .update_status = sony_backlight_update_status,
         .get_brightness = sony_backlight_get_brightness,
 };
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index a974ca383cb..dd599585c6a 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -6110,7 +6110,7 @@ static void tpacpi_brightness_notify_change(void)
                                BACKLIGHT_UPDATE_HOTKEY);
 }
 
-static struct backlight_ops ibm_backlight_data = {
+static const struct backlight_ops ibm_backlight_data = {
         .get_brightness = brightness_get,
         .update_status  = brightness_update_status,
 };
@@ -7194,7 +7194,7 @@ static struct ibm_struct volume_driver_data = {
  *              TPACPI_FAN_WR_ACPI_FANS (X31/X40/X41)
  *
  *      FIRMWARE BUG: on some models, EC 0x2f might not be initialized at
- *      boot. Apparently the EC does not intialize it, so unless ACPI DSDT
+ *      boot. Apparently the EC does not initialize it, so unless ACPI DSDT
  *      does so, its initial value is meaningless (0x07).
  *
  *      For firmware bugs, refer to:
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index 4276da7291b..209cced786c 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -841,7 +841,7 @@ static void remove_toshiba_proc_entries(void)
         remove_proc_entry("version", toshiba_proc_dir);
 }
 
-static struct backlight_ops toshiba_backlight_data = {
+static const struct backlight_ops toshiba_backlight_data = {
         .get_brightness = get_lcd,
         .update_status  = set_lcd_status,
 };
diff --git a/drivers/power/s3c_adc_battery.c b/drivers/power/s3c_adc_battery.c
index fe16b482e91..4a8ae3935b3 100644
--- a/drivers/power/s3c_adc_battery.c
+++ b/drivers/power/s3c_adc_battery.c
@@ -1,5 +1,5 @@
 /*
- *      iPAQ h1930/h1940/rx1950 battery controler driver
+ *      iPAQ h1930/h1940/rx1950 battery controller driver
  *      Copyright (c) Vasily Khoruzhick
  *      Based on h1940_battery.c by Arnaud Patard
  *
@@ -427,5 +427,5 @@ static void __exit s3c_adc_bat_exit(void)
 module_exit(s3c_adc_bat_exit);
 
 MODULE_AUTHOR("Vasily Khoruzhick <anarsoul@gmail.com>");
-MODULE_DESCRIPTION("iPAQ H1930/H1940/RX1950 battery controler driver");
+MODULE_DESCRIPTION("iPAQ H1930/H1940/RX1950 battery controller driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/pps/Kconfig b/drivers/pps/Kconfig
index 1afe4e03440..f0d3376b58b 100644
--- a/drivers/pps/Kconfig
+++ b/drivers/pps/Kconfig
@@ -30,6 +30,17 @@ config PPS_DEBUG
           messages to the system log.  Select this if you are having a
           problem with PPS support and want to see more of what is going on.
 
+config NTP_PPS
+        bool "PPS kernel consumer support"
+        depends on PPS && !NO_HZ
+        help
+          This option adds support for direct in-kernel time
+          syncronization using an external PPS signal.
+
+          It doesn't work on tickless systems at the moment.
+
 source drivers/pps/clients/Kconfig
 
+source drivers/pps/generators/Kconfig
+
 endmenu
diff --git a/drivers/pps/Makefile b/drivers/pps/Makefile
index 98960ddd318..4483eaadadd 100644
--- a/drivers/pps/Makefile
+++ b/drivers/pps/Makefile
@@ -3,7 +3,8 @@
 #
 
 pps_core-y                      := pps.o kapi.o sysfs.o
+pps_core-$(CONFIG_NTP_PPS)      += kc.o
 obj-$(CONFIG_PPS)               := pps_core.o
-obj-y                           += clients/
+obj-y                           += clients/ generators/
 
 ccflags-$(CONFIG_PPS_DEBUG) := -DDEBUG
diff --git a/drivers/pps/clients/Kconfig b/drivers/pps/clients/Kconfig
index 4e801bd7254..8520a7f4dd6 100644
--- a/drivers/pps/clients/Kconfig
+++ b/drivers/pps/clients/Kconfig
@@ -22,4 +22,11 @@ config PPS_CLIENT_LDISC
           If you say yes here you get support for a PPS source connected
           with the CD (Carrier Detect) pin of your serial port.
 
+config PPS_CLIENT_PARPORT
+        tristate "Parallel port PPS client"
+        depends on PPS && PARPORT
+        help
+          If you say yes here you get support for a PPS source connected
+          with the interrupt pin of your parallel port.
+
 endif
diff --git a/drivers/pps/clients/Makefile b/drivers/pps/clients/Makefile
index 812c9b19b43..42517da0704 100644
--- a/drivers/pps/clients/Makefile
+++ b/drivers/pps/clients/Makefile
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_PPS_CLIENT_KTIMER) += pps-ktimer.o
 obj-$(CONFIG_PPS_CLIENT_LDISC)  += pps-ldisc.o
+obj-$(CONFIG_PPS_CLIENT_PARPORT) += pps_parport.o
 
 ifeq ($(CONFIG_PPS_DEBUG),y)
 EXTRA_CFLAGS += -DDEBUG
diff --git a/drivers/pps/clients/pps-ktimer.c b/drivers/pps/clients/pps-ktimer.c
index e7ef5b8186d..2728469d388 100644
--- a/drivers/pps/clients/pps-ktimer.c
+++ b/drivers/pps/clients/pps-ktimer.c
@@ -19,6 +19,7 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -31,7 +32,7 @@
  * Global variables
  */
 
-static int source;
+static struct pps_device *pps;
 static struct timer_list ktimer;
 
 /*
@@ -40,19 +41,14 @@ static struct timer_list ktimer;
 
 static void pps_ktimer_event(unsigned long ptr)
 {
-        struct timespec __ts;
-        struct pps_ktime ts;
+        struct pps_event_time ts;
 
         /* First of all we get the time stamp... */
-        getnstimeofday(&__ts);
+        pps_get_ts(&ts);
 
-        pr_info("PPS event at %lu\n", jiffies);
+        dev_info(pps->dev, "PPS event at %lu\n", jiffies);
 
-        /* ... and translate it to PPS time data struct */
-        ts.sec = __ts.tv_sec;
-        ts.nsec = __ts.tv_nsec;
-
-        pps_event(source, &ts, PPS_CAPTUREASSERT, NULL);
+        pps_event(pps, &ts, PPS_CAPTUREASSERT, NULL);
 
         mod_timer(&ktimer, jiffies + HZ);
 }
@@ -61,12 +57,11 @@ static void pps_ktimer_event(unsigned long ptr)
  * The echo function
  */
 
-static void pps_ktimer_echo(int source, int event, void *data)
+static void pps_ktimer_echo(struct pps_device *pps, int event, void *data)
 {
-        pr_info("echo %s %s for source %d\n",
+        dev_info(pps->dev, "echo %s %s\n",
                 event & PPS_CAPTUREASSERT ? "assert" : "",
-                event & PPS_CAPTURECLEAR ? "clear" : "",
-                source);
+                event & PPS_CAPTURECLEAR ? "clear" : "");
 }
 
 /*
@@ -89,30 +84,27 @@ static struct pps_source_info pps_ktimer_info = {
 
 static void __exit pps_ktimer_exit(void)
 {
-        del_timer_sync(&ktimer);
-        pps_unregister_source(source);
+        dev_info(pps->dev, "ktimer PPS source unregistered\n");
 
-        pr_info("ktimer PPS source unregistered\n");
+        del_timer_sync(&ktimer);
+        pps_unregister_source(pps);
 }
 
 static int __init pps_ktimer_init(void)
 {
-        int ret;
-
-        ret = pps_register_source(&pps_ktimer_info,
+        pps = pps_register_source(&pps_ktimer_info,
                                 PPS_CAPTUREASSERT | PPS_OFFSETASSERT);
-        if (ret < 0) {
-                printk(KERN_ERR "cannot register ktimer source\n");
-                return ret;
+        if (pps == NULL) {
+                pr_err("cannot register PPS source\n");
+                return -ENOMEM;
         }
-        source = ret;
 
         setup_timer(&ktimer, pps_ktimer_event, 0);
         mod_timer(&ktimer, jiffies + HZ);
 
-        pr_info("ktimer PPS source registered at %d\n", source);
+        dev_info(pps->dev, "ktimer PPS source registered\n");
 
-        return  0;
+        return 0;
 }
 
 module_init(pps_ktimer_init);
diff --git a/drivers/pps/clients/pps-ldisc.c b/drivers/pps/clients/pps-ldisc.c
index 8e1932d29fd..79451f2dea6 100644
--- a/drivers/pps/clients/pps-ldisc.c
+++ b/drivers/pps/clients/pps-ldisc.c
@@ -19,6 +19,8 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/module.h>
 #include <linux/serial_core.h>
 #include <linux/tty.h>
@@ -27,30 +29,18 @@
 #define PPS_TTY_MAGIC           0x0001
 
 static void pps_tty_dcd_change(struct tty_struct *tty, unsigned int status,
-                                struct timespec *ts)
+                                struct pps_event_time *ts)
 {
-        int id = (long)tty->disc_data;
-        struct timespec __ts;
-        struct pps_ktime pps_ts;
-
-        /* First of all we get the time stamp... */
-        getnstimeofday(&__ts);
-
-        /* Does caller give us a timestamp? */
-        if (ts) {       /* Yes. Let's use it! */
-                pps_ts.sec = ts->tv_sec;
-                pps_ts.nsec = ts->tv_nsec;
-        } else {        /* No. Do it ourself! */
-                pps_ts.sec = __ts.tv_sec;
-                pps_ts.nsec = __ts.tv_nsec;
-        }
+        struct pps_device *pps = (struct pps_device *)tty->disc_data;
+
+        BUG_ON(pps == NULL);
 
         /* Now do the PPS event report */
-        pps_event(id, &pps_ts, status ? PPS_CAPTUREASSERT : PPS_CAPTURECLEAR,
-                        NULL);
+        pps_event(pps, ts, status ? PPS_CAPTUREASSERT :
+                        PPS_CAPTURECLEAR, NULL);
 
-        pr_debug("PPS %s at %lu on source #%d\n",
-                        status ? "assert" : "clear", jiffies, id);
+        dev_dbg(pps->dev, "PPS %s at %lu\n",
+                        status ? "assert" : "clear", jiffies);
 }
 
 static int (*alias_n_tty_open)(struct tty_struct *tty);
@@ -60,6 +50,7 @@ static int pps_tty_open(struct tty_struct *tty)
         struct pps_source_info info;
         struct tty_driver *drv = tty->driver;
         int index = tty->index + drv->name_base;
+        struct pps_device *pps;
         int ret;
 
         info.owner = THIS_MODULE;
@@ -70,34 +61,42 @@ static int pps_tty_open(struct tty_struct *tty)
                         PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
                         PPS_CANWAIT | PPS_TSFMT_TSPEC;
 
-        ret = pps_register_source(&info, PPS_CAPTUREBOTH | \
+        pps = pps_register_source(&info, PPS_CAPTUREBOTH | \
                                 PPS_OFFSETASSERT | PPS_OFFSETCLEAR);
-        if (ret < 0) {
+        if (pps == NULL) {
                 pr_err("cannot register PPS source \"%s\"\n", info.path);
-                return ret;
+                return -ENOMEM;
         }
-        tty->disc_data = (void *)(long)ret;
+        tty->disc_data = pps;
 
         /* Should open N_TTY ldisc too */
         ret = alias_n_tty_open(tty);
-        if (ret < 0)
-                pps_unregister_source((long)tty->disc_data);
+        if (ret < 0) {
+                pr_err("cannot open tty ldisc \"%s\"\n", info.path);
+                goto err_unregister;
+        }
 
-        pr_info("PPS source #%d \"%s\" added\n", ret, info.path);
+        dev_info(pps->dev, "source \"%s\" added\n", info.path);
 
         return 0;
+
+err_unregister:
+        tty->disc_data = NULL;
+        pps_unregister_source(pps);
+        return ret;
 }
 
 static void (*alias_n_tty_close)(struct tty_struct *tty);
 
 static void pps_tty_close(struct tty_struct *tty)
 {
-        int id = (long)tty->disc_data;
+        struct pps_device *pps = (struct pps_device *)tty->disc_data;
 
-        pps_unregister_source(id);
         alias_n_tty_close(tty);
 
-        pr_info("PPS source #%d removed\n", id);
+        tty->disc_data = NULL;
+        dev_info(pps->dev, "removed\n");
+        pps_unregister_source(pps);
 }
 
 static struct tty_ldisc_ops pps_ldisc_ops;
diff --git a/drivers/pps/clients/pps_parport.c b/drivers/pps/clients/pps_parport.c
new file mode 100644
index 00000000000..32221efd9ca
--- /dev/null
+++ b/drivers/pps/clients/pps_parport.c
@@ -0,0 +1,258 @@
+/*
+ * pps_parport.c -- kernel parallel port PPS client
+ *
+ *
+ * Copyright (C) 2009   Alexander Gordeev <lasaine@lvk.cs.msu.su>
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+/*
+ * TODO:
+ * implement echo over SEL pin
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/irqnr.h>
+#include <linux/time.h>
+#include <linux/parport.h>
+#include <linux/pps_kernel.h>
+
+#define DRVDESC "parallel port PPS client"
+
+/* module parameters */
+
+#define CLEAR_WAIT_MAX          100
+#define CLEAR_WAIT_MAX_ERRORS   5
+
+static unsigned int clear_wait = 100;
+MODULE_PARM_DESC(clear_wait,
+        "Maximum number of port reads when polling for signal clear,"
+        " zero turns clear edge capture off entirely");
+module_param(clear_wait, uint, 0);
+
+
+/* internal per port structure */
+struct pps_client_pp {
+        struct pardevice *pardev;       /* parport device */
+        struct pps_device *pps;         /* PPS device */
+        unsigned int cw;                /* port clear timeout */
+        unsigned int cw_err;            /* number of timeouts */
+};
+
+static inline int signal_is_set(struct parport *port)
+{
+        return (port->ops->read_status(port) & PARPORT_STATUS_ACK) != 0;
+}
+
+/* parport interrupt handler */
+static void parport_irq(void *handle)
+{
+        struct pps_event_time ts_assert, ts_clear;
+        struct pps_client_pp *dev = handle;
+        struct parport *port = dev->pardev->port;
+        unsigned int i;
+        unsigned long flags;
+
+        /* first of all we get the time stamp... */
+        pps_get_ts(&ts_assert);
+
+        if (dev->cw == 0)
+                /* clear edge capture disabled */
+                goto out_assert;
+
+        /* try capture the clear edge */
+
+        /* We have to disable interrupts here. The idea is to prevent
+         * other interrupts on the same processor to introduce random
+         * lags while polling the port. Reading from IO port is known
+         * to take approximately 1us while other interrupt handlers can
+         * take much more potentially.
+         *
+         * Interrupts won't be disabled for a long time because the
+         * number of polls is limited by clear_wait parameter which is
+         * kept rather low. So it should never be an issue.
+         */
+        local_irq_save(flags);
+        /* check the signal (no signal means the pulse is lost this time) */
+        if (!signal_is_set(port)) {
+                local_irq_restore(flags);
+                dev_err(dev->pps->dev, "lost the signal\n");
+                goto out_assert;
+        }
+
+        /* poll the port until the signal is unset */
+        for (i = dev->cw; i; i--)
+                if (!signal_is_set(port)) {
+                        pps_get_ts(&ts_clear);
+                        local_irq_restore(flags);
+                        dev->cw_err = 0;
+                        goto out_both;
+                }
+        local_irq_restore(flags);
+
+        /* timeout */
+        dev->cw_err++;
+        if (dev->cw_err >= CLEAR_WAIT_MAX_ERRORS) {
+                dev_err(dev->pps->dev, "disabled clear edge capture after %d"
+                                " timeouts\n", dev->cw_err);
+                dev->cw = 0;
+                dev->cw_err = 0;
+        }
+
+out_assert:
+        /* fire assert event */
+        pps_event(dev->pps, &ts_assert,
+                        PPS_CAPTUREASSERT, NULL);
+        return;
+
+out_both:
+        /* fire assert event */
+        pps_event(dev->pps, &ts_assert,
+                        PPS_CAPTUREASSERT, NULL);
+        /* fire clear event */
+        pps_event(dev->pps, &ts_clear,
+                        PPS_CAPTURECLEAR, NULL);
+        return;
+}
+
+/* the PPS echo function */
+static void pps_echo(struct pps_device *pps, int event, void *data)
+{
+        dev_info(pps->dev, "echo %s %s\n",
+                event & PPS_CAPTUREASSERT ? "assert" : "",
+                event & PPS_CAPTURECLEAR ? "clear" : "");
+}
+
+static void parport_attach(struct parport *port)
+{
+        struct pps_client_pp *device;
+        struct pps_source_info info = {
+                .name           = KBUILD_MODNAME,
+                .path           = "",
+                .mode           = PPS_CAPTUREBOTH | \
+                                  PPS_OFFSETASSERT | PPS_OFFSETCLEAR | \
+                                  PPS_ECHOASSERT | PPS_ECHOCLEAR | \
+                                  PPS_CANWAIT | PPS_TSFMT_TSPEC,
+                .echo           = pps_echo,
+                .owner          = THIS_MODULE,
+                .dev            = NULL
+        };
+
+        device = kzalloc(sizeof(struct pps_client_pp), GFP_KERNEL);
+        if (!device) {
+                pr_err("memory allocation failed, not attaching\n");
+                return;
+        }
+
+        device->pardev = parport_register_device(port, KBUILD_MODNAME,
+                        NULL, NULL, parport_irq, 0, device);
+        if (!device->pardev) {
+                pr_err("couldn't register with %s\n", port->name);
+                goto err_free;
+        }
+
+        if (parport_claim_or_block(device->pardev) < 0) {
+                pr_err("couldn't claim %s\n", port->name);
+                goto err_unregister_dev;
+        }
+
+        device->pps = pps_register_source(&info,
+                        PPS_CAPTUREBOTH | PPS_OFFSETASSERT | PPS_OFFSETCLEAR);
+        if (device->pps == NULL) {
+                pr_err("couldn't register PPS source\n");
+                goto err_release_dev;
+        }
+
+        device->cw = clear_wait;
+
+        port->ops->enable_irq(port);
+
+        pr_info("attached to %s\n", port->name);
+
+        return;
+
+err_release_dev:
+        parport_release(device->pardev);
+err_unregister_dev:
+        parport_unregister_device(device->pardev);
+err_free:
+        kfree(device);
+}
+
+static void parport_detach(struct parport *port)
+{
+        struct pardevice *pardev = port->cad;
+        struct pps_client_pp *device;
+
+        /* FIXME: oooh, this is ugly! */
+        if (strcmp(pardev->name, KBUILD_MODNAME))
+                /* not our port */
+                return;
+
+        device = pardev->private;
+
+        port->ops->disable_irq(port);
+        pps_unregister_source(device->pps);
+        parport_release(pardev);
+        parport_unregister_device(pardev);
+        kfree(device);
+}
+
+static struct parport_driver pps_parport_driver = {
+        .name = KBUILD_MODNAME,
+        .attach = parport_attach,
+        .detach = parport_detach,
+};
+
+/* module staff */
+
+static int __init pps_parport_init(void)
+{
+        int ret;
+
+        pr_info(DRVDESC "\n");
+
+        if (clear_wait > CLEAR_WAIT_MAX) {
+                pr_err("clear_wait value should be not greater"
+                                " then %d\n", CLEAR_WAIT_MAX);
+                return -EINVAL;
+        }
+
+        ret = parport_register_driver(&pps_parport_driver);
+        if (ret) {
+                pr_err("unable to register with parport\n");
+                return ret;
+        }
+
+        return  0;
+}
+
+static void __exit pps_parport_exit(void)
+{
+        parport_unregister_driver(&pps_parport_driver);
+}
+
+module_init(pps_parport_init);
+module_exit(pps_parport_exit);
+
+MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
+MODULE_DESCRIPTION(DRVDESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/generators/Kconfig b/drivers/pps/generators/Kconfig
new file mode 100644
index 00000000000..f3a73dd7766
--- /dev/null
+++ b/drivers/pps/generators/Kconfig
@@ -0,0 +1,13 @@
+#
+# PPS generators configuration
+#
+
+comment "PPS generators support"
+
+config PPS_GENERATOR_PARPORT
+        tristate "Parallel port PPS signal generator"
+        depends on PARPORT
+        help
+          If you say yes here you get support for a PPS signal generator which
+          utilizes STROBE pin of a parallel port to send PPS signals. It uses
+          parport abstraction layer and hrtimers to precisely control the signal.
diff --git a/drivers/pps/generators/Makefile b/drivers/pps/generators/Makefile
new file mode 100644
index 00000000000..303304a6b8e
--- /dev/null
+++ b/drivers/pps/generators/Makefile
@@ -0,0 +1,9 @@
+#
+# Makefile for PPS generators.
+#
+
+obj-$(CONFIG_PPS_GENERATOR_PARPORT) += pps_gen_parport.o
+
+ifeq ($(CONFIG_PPS_DEBUG),y)
+EXTRA_CFLAGS += -DDEBUG
+endif
diff --git a/drivers/pps/generators/pps_gen_parport.c b/drivers/pps/generators/pps_gen_parport.c
new file mode 100644
index 00000000000..5c32f8dacf5
--- /dev/null
+++ b/drivers/pps/generators/pps_gen_parport.c
@@ -0,0 +1,282 @@
+/*
+ * pps_gen_parport.c -- kernel parallel port PPS signal generator
+ *
+ *
+ * Copyright (C) 2009   Alexander Gordeev <lasaine@lvk.cs.msu.su>
+ *
+ * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+
+/*
+ * TODO:
+ * fix issues when realtime clock is adjusted in a leap
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/time.h>
+#include <linux/hrtimer.h>
+#include <linux/parport.h>
+
+#define DRVDESC "parallel port PPS signal generator"
+
+#define SIGNAL          0
+#define NO_SIGNAL       PARPORT_CONTROL_STROBE
+
+/* module parameters */
+
+#define SEND_DELAY_MAX          100000
+
+static unsigned int send_delay = 30000;
+MODULE_PARM_DESC(delay,
+        "Delay between setting and dropping the signal (ns)");
+module_param_named(delay, send_delay, uint, 0);
+
+
+#define SAFETY_INTERVAL 3000    /* set the hrtimer earlier for safety (ns) */
+
+/* internal per port structure */
+struct pps_generator_pp {
+        struct pardevice *pardev;       /* parport device */
+        struct hrtimer timer;
+        long port_write_time;           /* calibrated port write time (ns) */
+};
+
+static struct pps_generator_pp device = {
+        .pardev = NULL,
+};
+
+static int attached;
+
+/* calibrated time between a hrtimer event and the reaction */
+static long hrtimer_error = SAFETY_INTERVAL;
+
+/* the kernel hrtimer event */
+static enum hrtimer_restart hrtimer_event(struct hrtimer *timer)
+{
+        struct timespec expire_time, ts1, ts2, ts3, dts;
+        struct pps_generator_pp *dev;
+        struct parport *port;
+        long lim, delta;
+        unsigned long flags;
+
+        /* We have to disable interrupts here. The idea is to prevent
+         * other interrupts on the same processor to introduce random
+         * lags while polling the clock. getnstimeofday() takes <1us on
+         * most machines while other interrupt handlers can take much
+         * more potentially.
+         *
+         * NB: approx time with blocked interrupts =
+         * send_delay + 3 * SAFETY_INTERVAL
+         */
+        local_irq_save(flags);
+
+        /* first of all we get the time stamp... */
+        getnstimeofday(&ts1);
+        expire_time = ktime_to_timespec(hrtimer_get_softexpires(timer));
+        dev = container_of(timer, struct pps_generator_pp, timer);
+        lim = NSEC_PER_SEC - send_delay - dev->port_write_time;
+
+        /* check if we are late */
+        if (expire_time.tv_sec != ts1.tv_sec || ts1.tv_nsec > lim) {
+                local_irq_restore(flags);
+                pr_err("we are late this time %ld.%09ld\n",
+                                ts1.tv_sec, ts1.tv_nsec);
+                goto done;
+        }
+
+        /* busy loop until the time is right for an assert edge */
+        do {
+                getnstimeofday(&ts2);
+        } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
+
+        /* set the signal */
+        port = dev->pardev->port;
+        port->ops->write_control(port, SIGNAL);
+
+        /* busy loop until the time is right for a clear edge */
+        lim = NSEC_PER_SEC - dev->port_write_time;
+        do {
+                getnstimeofday(&ts2);
+        } while (expire_time.tv_sec == ts2.tv_sec && ts2.tv_nsec < lim);
+
+        /* unset the signal */
+        port->ops->write_control(port, NO_SIGNAL);
+
+        getnstimeofday(&ts3);
+
+        local_irq_restore(flags);
+
+        /* update calibrated port write time */
+        dts = timespec_sub(ts3, ts2);
+        dev->port_write_time =
+                (dev->port_write_time + timespec_to_ns(&dts)) >> 1;
+
+done:
+        /* update calibrated hrtimer error */
+        dts = timespec_sub(ts1, expire_time);
+        delta = timespec_to_ns(&dts);
+        /* If the new error value is bigger then the old, use the new
+         * value, if not then slowly move towards the new value. This
+         * way it should be safe in bad conditions and efficient in
+         * good conditions.
+         */
+        if (delta >= hrtimer_error)
+                hrtimer_error = delta;
+        else
+                hrtimer_error = (3 * hrtimer_error + delta) >> 2;
+
+        /* update the hrtimer expire time */
+        hrtimer_set_expires(timer,
+                        ktime_set(expire_time.tv_sec + 1,
+                                NSEC_PER_SEC - (send_delay +
+                                dev->port_write_time + SAFETY_INTERVAL +
+                                2 * hrtimer_error)));
+
+        return HRTIMER_RESTART;
+}
+
+/* calibrate port write time */
+#define PORT_NTESTS_SHIFT       5
+static void calibrate_port(struct pps_generator_pp *dev)
+{
+        struct parport *port = dev->pardev->port;
+        int i;
+        long acc = 0;
+
+        for (i = 0; i < (1 << PORT_NTESTS_SHIFT); i++) {
+                struct timespec a, b;
+                unsigned long irq_flags;
+
+                local_irq_save(irq_flags);
+                getnstimeofday(&a);
+                port->ops->write_control(port, NO_SIGNAL);
+                getnstimeofday(&b);
+                local_irq_restore(irq_flags);
+
+                b = timespec_sub(b, a);
+                acc += timespec_to_ns(&b);
+        }
+
+        dev->port_write_time = acc >> PORT_NTESTS_SHIFT;
+        pr_info("port write takes %ldns\n", dev->port_write_time);
+}
+
+static inline ktime_t next_intr_time(struct pps_generator_pp *dev)
+{
+        struct timespec ts;
+
+        getnstimeofday(&ts);
+
+        return ktime_set(ts.tv_sec +
+                        ((ts.tv_nsec > 990 * NSEC_PER_MSEC) ? 1 : 0),
+                        NSEC_PER_SEC - (send_delay +
+                        dev->port_write_time + 3 * SAFETY_INTERVAL));
+}
+
+static void parport_attach(struct parport *port)
+{
+        if (attached) {
+                /* we already have a port */
+                return;
+        }
+
+        device.pardev = parport_register_device(port, KBUILD_MODNAME,
+                        NULL, NULL, NULL, 0, &device);
+        if (!device.pardev) {
+                pr_err("couldn't register with %s\n", port->name);
+                return;
+        }
+
+        if (parport_claim_or_block(device.pardev) < 0) {
+                pr_err("couldn't claim %s\n", port->name);
+                goto err_unregister_dev;
+        }
+
+        pr_info("attached to %s\n", port->name);
+        attached = 1;
+
+        calibrate_port(&device);
+
+        hrtimer_init(&device.timer, CLOCK_REALTIME, HRTIMER_MODE_ABS);
+        device.timer.function = hrtimer_event;
+#ifdef CONFIG_PREEMPT_RT
+        /* hrtimer interrupt will run in the interrupt context with this */
+        device.timer.irqsafe = 1;
+#endif
+
+        hrtimer_start(&device.timer, next_intr_time(&device), HRTIMER_MODE_ABS);
+
+        return;
+
+err_unregister_dev:
+        parport_unregister_device(device.pardev);
+}
+
+static void parport_detach(struct parport *port)
+{
+        if (port->cad != device.pardev)
+                return; /* not our port */
+
+        hrtimer_cancel(&device.timer);
+        parport_release(device.pardev);
+        parport_unregister_device(device.pardev);
+}
+
+static struct parport_driver pps_gen_parport_driver = {
+        .name = KBUILD_MODNAME,
+        .attach = parport_attach,
+        .detach = parport_detach,
+};
+
+/* module staff */
+
+static int __init pps_gen_parport_init(void)
+{
+        int ret;
+
+        pr_info(DRVDESC "\n");
+
+        if (send_delay > SEND_DELAY_MAX) {
+                pr_err("delay value should be not greater"
+                                " then %d\n", SEND_DELAY_MAX);
+                return -EINVAL;
+        }
+
+        ret = parport_register_driver(&pps_gen_parport_driver);
+        if (ret) {
+                pr_err("unable to register with parport\n");
+                return ret;
+        }
+
+        return  0;
+}
+
+static void __exit pps_gen_parport_exit(void)
+{
+        parport_unregister_driver(&pps_gen_parport_driver);
+        pr_info("hrtimer avg error is %ldns\n", hrtimer_error);
+}
+
+module_init(pps_gen_parport_init);
+module_exit(pps_gen_parport_exit);
+
+MODULE_AUTHOR("Alexander Gordeev <lasaine@lvk.cs.msu.su>");
+MODULE_DESCRIPTION(DRVDESC);
+MODULE_LICENSE("GPL");
diff --git a/drivers/pps/kapi.c b/drivers/pps/kapi.c
index 1aa02db3ff4..cba1b43f751 100644
--- a/drivers/pps/kapi.c
+++ b/drivers/pps/kapi.c
@@ -19,24 +19,20 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/init.h>
 #include <linux/sched.h>
 #include <linux/time.h>
+#include <linux/timex.h>
 #include <linux/spinlock.h>
-#include <linux/idr.h>
 #include <linux/fs.h>
 #include <linux/pps_kernel.h>
 #include <linux/slab.h>
 
-/*
- * Global variables
- */
-
-DEFINE_SPINLOCK(pps_idr_lock);
-DEFINE_IDR(pps_idr);
+#include "kc.h"
 
 /*
  * Local functions
@@ -60,60 +56,6 @@ static void pps_add_offset(struct pps_ktime *ts, struct pps_ktime *offset)
  * Exported functions
  */
 
-/* pps_get_source - find a PPS source
- * @source: the PPS source ID.
- *
- * This function is used to find an already registered PPS source into the
- * system.
- *
- * The function returns NULL if found nothing, otherwise it returns a pointer
- * to the PPS source data struct (the refcounter is incremented by 1).
- */
-
-struct pps_device *pps_get_source(int source)
-{
-        struct pps_device *pps;
-        unsigned long flags;
-
-        spin_lock_irqsave(&pps_idr_lock, flags);
-
-        pps = idr_find(&pps_idr, source);
-        if (pps != NULL)
-                atomic_inc(&pps->usage);
-
-        spin_unlock_irqrestore(&pps_idr_lock, flags);
-
-        return pps;
-}
-
-/* pps_put_source - free the PPS source data
- * @pps: a pointer to the PPS source.
- *
- * This function is used to free a PPS data struct if its refcount is 0.
- */
-
-void pps_put_source(struct pps_device *pps)
-{
-        unsigned long flags;
-
-        spin_lock_irqsave(&pps_idr_lock, flags);
-        BUG_ON(atomic_read(&pps->usage) == 0);
-
-        if (!atomic_dec_and_test(&pps->usage)) {
-                pps = NULL;
-                goto exit;
-        }
-
-        /* No more reference to the PPS source. We can safely remove the
-         * PPS data struct.
-         */
-        idr_remove(&pps_idr, pps->id);
-
-exit:
-        spin_unlock_irqrestore(&pps_idr_lock, flags);
-        kfree(pps);
-}
-
 /* pps_register_source - add a PPS source in the system
  * @info: the PPS info struct
  * @default_params: the default PPS parameters of the new source
@@ -122,31 +64,31 @@ exit:
  * source is described by info's fields and it will have, as default PPS
  * parameters, the ones specified into default_params.
  *
- * The function returns, in case of success, the PPS source ID.
+ * The function returns, in case of success, the PPS device. Otherwise NULL.
  */
 
-int pps_register_source(struct pps_source_info *info, int default_params)
+struct pps_device *pps_register_source(struct pps_source_info *info,
+                int default_params)
 {
         struct pps_device *pps;
-        int id;
         int err;
 
         /* Sanity checks */
         if ((info->mode & default_params) != default_params) {
-                printk(KERN_ERR "pps: %s: unsupported default parameters\n",
+                pr_err("%s: unsupported default parameters\n",
                                         info->name);
                 err = -EINVAL;
                 goto pps_register_source_exit;
         }
         if ((info->mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)) != 0 &&
                         info->echo == NULL) {
-                printk(KERN_ERR "pps: %s: echo function is not defined\n",
+                pr_err("%s: echo function is not defined\n",
                                         info->name);
                 err = -EINVAL;
                 goto pps_register_source_exit;
         }
         if ((info->mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
-                printk(KERN_ERR "pps: %s: unspecified time format\n",
+                pr_err("%s: unspecified time format\n",
                                         info->name);
                 err = -EINVAL;
                 goto pps_register_source_exit;
@@ -168,94 +110,48 @@ int pps_register_source(struct pps_source_info *info, int default_params)
 
         init_waitqueue_head(&pps->queue);
         spin_lock_init(&pps->lock);
-        atomic_set(&pps->usage, 1);
-
-        /* Get new ID for the new PPS source */
-        if (idr_pre_get(&pps_idr, GFP_KERNEL) == 0) {
-                err = -ENOMEM;
-                goto kfree_pps;
-        }
-
-        spin_lock_irq(&pps_idr_lock);
-
-        /* Now really allocate the PPS source.
-         * After idr_get_new() calling the new source will be freely available
-         * into the kernel.
-         */
-        err = idr_get_new(&pps_idr, pps, &id);
-        if (err < 0) {
-                spin_unlock_irq(&pps_idr_lock);
-                goto kfree_pps;
-        }
-
-        id = id & MAX_ID_MASK;
-        if (id >= PPS_MAX_SOURCES) {
-                spin_unlock_irq(&pps_idr_lock);
-
-                printk(KERN_ERR "pps: %s: too many PPS sources in the system\n",
-                                        info->name);
-                err = -EBUSY;
-                goto free_idr;
-        }
-        pps->id = id;
-
-        spin_unlock_irq(&pps_idr_lock);
 
         /* Create the char device */
         err = pps_register_cdev(pps);
         if (err < 0) {
-                printk(KERN_ERR "pps: %s: unable to create char device\n",
+                pr_err("%s: unable to create char device\n",
                                         info->name);
-                goto free_idr;
+                goto kfree_pps;
         }
 
-        pr_info("new PPS source %s at ID %d\n", info->name, id);
+        dev_info(pps->dev, "new PPS source %s\n", info->name);
 
-        return id;
-
-free_idr:
-        spin_lock_irq(&pps_idr_lock);
-        idr_remove(&pps_idr, id);
-        spin_unlock_irq(&pps_idr_lock);
+        return pps;
 
 kfree_pps:
         kfree(pps);
 
 pps_register_source_exit:
-        printk(KERN_ERR "pps: %s: unable to register source\n", info->name);
+        pr_err("%s: unable to register source\n", info->name);
 
-        return err;
+        return NULL;
 }
 EXPORT_SYMBOL(pps_register_source);
 
 /* pps_unregister_source - remove a PPS source from the system
- * @source: the PPS source ID
+ * @pps: the PPS source
  *
  * This function is used to remove a previously registered PPS source from
  * the system.
  */
 
-void pps_unregister_source(int source)
+void pps_unregister_source(struct pps_device *pps)
 {
-        struct pps_device *pps;
-
-        spin_lock_irq(&pps_idr_lock);
-        pps = idr_find(&pps_idr, source);
-
-        if (!pps) {
-                BUG();
-                spin_unlock_irq(&pps_idr_lock);
-                return;
-        }
-        spin_unlock_irq(&pps_idr_lock);
-
+        pps_kc_remove(pps);
         pps_unregister_cdev(pps);
-        pps_put_source(pps);
+
+        /* don't have to kfree(pps) here because it will be done on
+         * device destruction */
 }
 EXPORT_SYMBOL(pps_unregister_source);
 
 /* pps_event - register a PPS event into the system
- * @source: the PPS source ID
+ * @pps: the PPS device
  * @ts: the event timestamp
  * @event: the event type
  * @data: userdef pointer
@@ -263,78 +159,72 @@ EXPORT_SYMBOL(pps_unregister_source);
  * This function is used by each PPS client in order to register a new
  * PPS event into the system (it's usually called inside an IRQ handler).
  *
- * If an echo function is associated with the PPS source it will be called
+ * If an echo function is associated with the PPS device it will be called
  * as:
- *      pps->info.echo(source, event, data);
+ *      pps->info.echo(pps, event, data);
  */
-
-void pps_event(int source, struct pps_ktime *ts, int event, void *data)
+void pps_event(struct pps_device *pps, struct pps_event_time *ts, int event,
+                void *data)
 {
-        struct pps_device *pps;
         unsigned long flags;
         int captured = 0;
+        struct pps_ktime ts_real;
 
-        if ((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0) {
-                printk(KERN_ERR "pps: unknown event (%x) for source %d\n",
-                        event, source);
-                return;
-        }
+        /* check event type */
+        BUG_ON((event & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR)) == 0);
 
-        pps = pps_get_source(source);
-        if (!pps)
-                return;
+        dev_dbg(pps->dev, "PPS event at %ld.%09ld\n",
+                        ts->ts_real.tv_sec, ts->ts_real.tv_nsec);
 
-        pr_debug("PPS event on source %d at %llu.%06u\n",
-                        pps->id, (unsigned long long) ts->sec, ts->nsec);
+        timespec_to_pps_ktime(&ts_real, ts->ts_real);
 
         spin_lock_irqsave(&pps->lock, flags);
 
         /* Must call the echo function? */
         if ((pps->params.mode & (PPS_ECHOASSERT | PPS_ECHOCLEAR)))
-                pps->info.echo(source, event, data);
+                pps->info.echo(pps, event, data);
 
         /* Check the event */
         pps->current_mode = pps->params.mode;
-        if ((event & PPS_CAPTUREASSERT) &
-                        (pps->params.mode & PPS_CAPTUREASSERT)) {
+        if (event & pps->params.mode & PPS_CAPTUREASSERT) {
                 /* We have to add an offset? */
                 if (pps->params.mode & PPS_OFFSETASSERT)
-                        pps_add_offset(ts, &pps->params.assert_off_tu);
+                        pps_add_offset(&ts_real,
+                                        &pps->params.assert_off_tu);
 
                 /* Save the time stamp */
-                pps->assert_tu = *ts;
+                pps->assert_tu = ts_real;
                 pps->assert_sequence++;
-                pr_debug("capture assert seq #%u for source %d\n",
-                        pps->assert_sequence, source);
+                dev_dbg(pps->dev, "capture assert seq #%u\n",
+                        pps->assert_sequence);
 
                 captured = ~0;
         }
-        if ((event & PPS_CAPTURECLEAR) &
-                        (pps->params.mode & PPS_CAPTURECLEAR)) {
+        if (event & pps->params.mode & PPS_CAPTURECLEAR) {
                 /* We have to add an offset? */
                 if (pps->params.mode & PPS_OFFSETCLEAR)
-                        pps_add_offset(ts, &pps->params.clear_off_tu);
+                        pps_add_offset(&ts_real,
+                                        &pps->params.clear_off_tu);
 
                 /* Save the time stamp */
-                pps->clear_tu = *ts;
+                pps->clear_tu = ts_real;
                 pps->clear_sequence++;
-                pr_debug("capture clear seq #%u for source %d\n",
-                        pps->clear_sequence, source);
+                dev_dbg(pps->dev, "capture clear seq #%u\n",
+                        pps->clear_sequence);
 
                 captured = ~0;
         }
 
-        /* Wake up iif captured somthing */
+        pps_kc_event(pps, ts, event);
+
+        /* Wake up if captured something */
         if (captured) {
-                pps->go = ~0;
-                wake_up_interruptible(&pps->queue);
+                pps->last_ev++;
+                wake_up_interruptible_all(&pps->queue);
 
                 kill_fasync(&pps->async_queue, SIGIO, POLL_IN);
         }
 
         spin_unlock_irqrestore(&pps->lock, flags);
-
-        /* Now we can release the PPS source for (possible) deregistration */
-        pps_put_source(pps);
 }
 EXPORT_SYMBOL(pps_event);
diff --git a/drivers/pps/kc.c b/drivers/pps/kc.c
new file mode 100644
index 00000000000..079e930b193
--- /dev/null
+++ b/drivers/pps/kc.c
@@ -0,0 +1,122 @@
+/*
+ * PPS kernel consumer API
+ *
+ * Copyright (C) 2009-2010   Alexander Gordeev <lasaine@lvk.cs.msu.su>
+ *
+ *   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/device.h>
+#include <linux/init.h>
+#include <linux/spinlock.h>
+#include <linux/pps_kernel.h>
+
+#include "kc.h"
+
+/*
+ * Global variables
+ */
+
+/* state variables to bind kernel consumer */
+DEFINE_SPINLOCK(pps_kc_hardpps_lock);
+/* PPS API (RFC 2783): current source and mode for kernel consumer */
+struct pps_device *pps_kc_hardpps_dev;  /* unique pointer to device */
+int pps_kc_hardpps_mode;                /* mode bits for kernel consumer */
+
+/* pps_kc_bind - control PPS kernel consumer binding
+ * @pps: the PPS source
+ * @bind_args: kernel consumer bind parameters
+ *
+ * This function is used to bind or unbind PPS kernel consumer according to
+ * supplied parameters. Should not be called in interrupt context.
+ */
+int pps_kc_bind(struct pps_device *pps, struct pps_bind_args *bind_args)
+{
+        /* Check if another consumer is already bound */
+        spin_lock_irq(&pps_kc_hardpps_lock);
+
+        if (bind_args->edge == 0)
+                if (pps_kc_hardpps_dev == pps) {
+                        pps_kc_hardpps_mode = 0;
+                        pps_kc_hardpps_dev = NULL;
+                        spin_unlock_irq(&pps_kc_hardpps_lock);
+                        dev_info(pps->dev, "unbound kernel"
+                                        " consumer\n");
+                } else {
+                        spin_unlock_irq(&pps_kc_hardpps_lock);
+                        dev_err(pps->dev, "selected kernel consumer"
+                                        " is not bound\n");
+                        return -EINVAL;
+                }
+        else
+                if (pps_kc_hardpps_dev == NULL ||
+                                pps_kc_hardpps_dev == pps) {
+                        pps_kc_hardpps_mode = bind_args->edge;
+                        pps_kc_hardpps_dev = pps;
+                        spin_unlock_irq(&pps_kc_hardpps_lock);
+                        dev_info(pps->dev, "bound kernel consumer: "
+                                "edge=0x%x\n", bind_args->edge);
+                } else {
+                        spin_unlock_irq(&pps_kc_hardpps_lock);
+                        dev_err(pps->dev, "another kernel consumer"
+                                        " is already bound\n");
+                        return -EINVAL;
+                }
+
+        return 0;
+}
+
+/* pps_kc_remove - unbind kernel consumer on PPS source removal
+ * @pps: the PPS source
+ *
+ * This function is used to disable kernel consumer on PPS source removal
+ * if this source was bound to PPS kernel consumer. Can be called on any
+ * source safely. Should not be called in interrupt context.
+ */
+void pps_kc_remove(struct pps_device *pps)
+{
+        spin_lock_irq(&pps_kc_hardpps_lock);
+        if (pps == pps_kc_hardpps_dev) {
+                pps_kc_hardpps_mode = 0;
+                pps_kc_hardpps_dev = NULL;
+                spin_unlock_irq(&pps_kc_hardpps_lock);
+                dev_info(pps->dev, "unbound kernel consumer"
+                                " on device removal\n");
+        } else
+                spin_unlock_irq(&pps_kc_hardpps_lock);
+}
+
+/* pps_kc_event - call hardpps() on PPS event
+ * @pps: the PPS source
+ * @ts: PPS event timestamp
+ * @event: PPS event edge
+ *
+ * This function calls hardpps() when an event from bound PPS source occurs.
+ */
+void pps_kc_event(struct pps_device *pps, struct pps_event_time *ts,
+                int event)
+{
+        unsigned long flags;
+
+        /* Pass some events to kernel consumer if activated */
+        spin_lock_irqsave(&pps_kc_hardpps_lock, flags);
+        if (pps == pps_kc_hardpps_dev && event & pps_kc_hardpps_mode)
+                hardpps(&ts->ts_real, &ts->ts_raw);
+        spin_unlock_irqrestore(&pps_kc_hardpps_lock, flags);
+}
diff --git a/drivers/pps/kc.h b/drivers/pps/kc.h
new file mode 100644
index 00000000000..d296fcd0a17
--- /dev/null
+++ b/drivers/pps/kc.h
@@ -0,0 +1,46 @@
+/*
+ * PPS kernel consumer API header
+ *
+ * Copyright (C) 2009-2010   Alexander Gordeev <lasaine@lvk.cs.msu.su>
+ *
+ *   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., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef LINUX_PPS_KC_H
+#define LINUX_PPS_KC_H
+
+#include <linux/errno.h>
+#include <linux/pps_kernel.h>
+
+#ifdef CONFIG_NTP_PPS
+
+extern int pps_kc_bind(struct pps_device *pps,
+                struct pps_bind_args *bind_args);
+extern void pps_kc_remove(struct pps_device *pps);
+extern void pps_kc_event(struct pps_device *pps,
+                struct pps_event_time *ts, int event);
+
+
+#else /* CONFIG_NTP_PPS */
+
+static inline int pps_kc_bind(struct pps_device *pps,
+                struct pps_bind_args *bind_args) { return -EOPNOTSUPP; }
+static inline void pps_kc_remove(struct pps_device *pps) {}
+static inline void pps_kc_event(struct pps_device *pps,
+                struct pps_event_time *ts, int event) {}
+
+#endif /* CONFIG_NTP_PPS */
+
+#endif /* LINUX_PPS_KC_H */
diff --git a/drivers/pps/pps.c b/drivers/pps/pps.c
index ca5183bdad8..2baadd21b7a 100644
--- a/drivers/pps/pps.c
+++ b/drivers/pps/pps.c
@@ -19,6 +19,7 @@
  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -26,9 +27,13 @@
 #include <linux/sched.h>
 #include <linux/uaccess.h>
 #include <linux/idr.h>
+#include <linux/mutex.h>
 #include <linux/cdev.h>
 #include <linux/poll.h>
 #include <linux/pps_kernel.h>
+#include <linux/slab.h>
+
+#include "kc.h"
 
 /*
  * Local variables
@@ -37,6 +42,9 @@
 static dev_t pps_devt;
 static struct class *pps_class;
 
+static DEFINE_MUTEX(pps_idr_lock);
+static DEFINE_IDR(pps_idr);
+
 /*
  * Char device methods
  */
@@ -61,15 +69,13 @@ static long pps_cdev_ioctl(struct file *file,
 {
         struct pps_device *pps = file->private_data;
         struct pps_kparams params;
-        struct pps_fdata fdata;
-        unsigned long ticks;
         void __user *uarg = (void __user *) arg;
         int __user *iuarg = (int __user *) arg;
         int err;
 
         switch (cmd) {
         case PPS_GETPARAMS:
-                pr_debug("PPS_GETPARAMS: source %d\n", pps->id);
+                dev_dbg(pps->dev, "PPS_GETPARAMS\n");
 
                 spin_lock_irq(&pps->lock);
 
@@ -85,7 +91,7 @@ static long pps_cdev_ioctl(struct file *file,
                 break;
 
         case PPS_SETPARAMS:
-                pr_debug("PPS_SETPARAMS: source %d\n", pps->id);
+                dev_dbg(pps->dev, "PPS_SETPARAMS\n");
 
                 /* Check the capabilities */
                 if (!capable(CAP_SYS_TIME))
@@ -95,14 +101,14 @@ static long pps_cdev_ioctl(struct file *file,
                 if (err)
                         return -EFAULT;
                 if (!(params.mode & (PPS_CAPTUREASSERT | PPS_CAPTURECLEAR))) {
-                        pr_debug("capture mode unspecified (%x)\n",
+                        dev_dbg(pps->dev, "capture mode unspecified (%x)\n",
                                                                 params.mode);
                         return -EINVAL;
                 }
 
                 /* Check for supported capabilities */
                 if ((params.mode & ~pps->info.mode) != 0) {
-                        pr_debug("unsupported capabilities (%x)\n",
+                        dev_dbg(pps->dev, "unsupported capabilities (%x)\n",
                                                                 params.mode);
                         return -EINVAL;
                 }
@@ -115,7 +121,7 @@ static long pps_cdev_ioctl(struct file *file,
                 /* Restore the read only parameters */
                 if ((params.mode & (PPS_TSFMT_TSPEC | PPS_TSFMT_NTPFP)) == 0) {
                         /* section 3.3 of RFC 2783 interpreted */
-                        pr_debug("time format unspecified (%x)\n",
+                        dev_dbg(pps->dev, "time format unspecified (%x)\n",
                                                                 params.mode);
                         pps->params.mode |= PPS_TSFMT_TSPEC;
                 }
@@ -128,7 +134,7 @@ static long pps_cdev_ioctl(struct file *file,
                 break;
 
         case PPS_GETCAP:
-                pr_debug("PPS_GETCAP: source %d\n", pps->id);
+                dev_dbg(pps->dev, "PPS_GETCAP\n");
 
                 err = put_user(pps->info.mode, iuarg);
                 if (err)
@@ -136,20 +142,26 @@ static long pps_cdev_ioctl(struct file *file,
 
                 break;
 
-        case PPS_FETCH:
-                pr_debug("PPS_FETCH: source %d\n", pps->id);
+        case PPS_FETCH: {
+                struct pps_fdata fdata;
+                unsigned int ev;
+
+                dev_dbg(pps->dev, "PPS_FETCH\n");
 
                 err = copy_from_user(&fdata, uarg, sizeof(struct pps_fdata));
                 if (err)
                         return -EFAULT;
 
-                pps->go = 0;
+                ev = pps->last_ev;
 
                 /* Manage the timeout */
                 if (fdata.timeout.flags & PPS_TIME_INVALID)
-                        err = wait_event_interruptible(pps->queue, pps->go);
+                        err = wait_event_interruptible(pps->queue,
+                                        ev != pps->last_ev);
                 else {
-                        pr_debug("timeout %lld.%09d\n",
+                        unsigned long ticks;
+
+                        dev_dbg(pps->dev, "timeout %lld.%09d\n",
                                         (long long) fdata.timeout.sec,
                                         fdata.timeout.nsec);
                         ticks = fdata.timeout.sec * HZ;
@@ -157,7 +169,9 @@ static long pps_cdev_ioctl(struct file *file,
 
                         if (ticks != 0) {
                                 err = wait_event_interruptible_timeout(
-                                                pps->queue, pps->go, ticks);
+                                                pps->queue,
+                                                ev != pps->last_ev,
+                                                ticks);
                                 if (err == 0)
                                         return -ETIMEDOUT;
                         }
@@ -165,7 +179,7 @@ static long pps_cdev_ioctl(struct file *file,
 
                 /* Check for pending signals */
                 if (err == -ERESTARTSYS) {
-                        pr_debug("pending signal caught\n");
+                        dev_dbg(pps->dev, "pending signal caught\n");
                         return -EINTR;
                 }
 
@@ -185,10 +199,44 @@ static long pps_cdev_ioctl(struct file *file,
                         return -EFAULT;
 
                 break;
+        }
+        case PPS_KC_BIND: {
+                struct pps_bind_args bind_args;
+
+                dev_dbg(pps->dev, "PPS_KC_BIND\n");
+
+                /* Check the capabilities */
+                if (!capable(CAP_SYS_TIME))
+                        return -EPERM;
+
+                if (copy_from_user(&bind_args, uarg,
+                                        sizeof(struct pps_bind_args)))
+                        return -EFAULT;
 
+                /* Check for supported capabilities */
+                if ((bind_args.edge & ~pps->info.mode) != 0) {
+                        dev_err(pps->dev, "unsupported capabilities (%x)\n",
+                                        bind_args.edge);
+                        return -EINVAL;
+                }
+
+                /* Validate parameters roughly */
+                if (bind_args.tsformat != PPS_TSFMT_TSPEC ||
+                                (bind_args.edge & ~PPS_CAPTUREBOTH) != 0 ||
+                                bind_args.consumer != PPS_KC_HARDPPS) {
+                        dev_err(pps->dev, "invalid kernel consumer bind"
+                                        " parameters (%x)\n", bind_args.edge);
+                        return -EINVAL;
+                }
+
+                err = pps_kc_bind(pps, &bind_args);
+                if (err < 0)
+                        return err;
+
+                break;
+        }
         default:
                 return -ENOTTY;
-                break;
         }
 
         return 0;
@@ -198,12 +246,6 @@ static int pps_cdev_open(struct inode *inode, struct file *file)
 {
         struct pps_device *pps = container_of(inode->i_cdev,
                                                 struct pps_device, cdev);
-        int found;
-
-        found = pps_get_source(pps->id) != 0;
-        if (!found)
-                return -ENODEV;
-
         file->private_data = pps;
 
         return 0;
@@ -211,11 +253,6 @@ static int pps_cdev_open(struct inode *inode, struct file *file)
 
 static int pps_cdev_release(struct inode *inode, struct file *file)
 {
-        struct pps_device *pps = file->private_data;
-
-        /* Free the PPS source and wake up (possible) deregistration */
-        pps_put_source(pps);
-
         return 0;
 }
 
@@ -233,25 +270,67 @@ static const struct file_operations pps_cdev_fops = {
         .release        = pps_cdev_release,
 };
 
+static void pps_device_destruct(struct device *dev)
+{
+        struct pps_device *pps = dev_get_drvdata(dev);
+
+        /* release id here to protect others from using it while it's
+         * still in use */
+        mutex_lock(&pps_idr_lock);
+        idr_remove(&pps_idr, pps->id);
+        mutex_unlock(&pps_idr_lock);
+
+        kfree(dev);
+        kfree(pps);
+}
+
 int pps_register_cdev(struct pps_device *pps)
 {
         int err;
+        dev_t devt;
+
+        mutex_lock(&pps_idr_lock);
+        /* Get new ID for the new PPS source */
+        if (idr_pre_get(&pps_idr, GFP_KERNEL) == 0) {
+                mutex_unlock(&pps_idr_lock);
+                return -ENOMEM;
+        }
+
+        /* Now really allocate the PPS source.
+         * After idr_get_new() calling the new source will be freely available
+         * into the kernel.
+         */
+        err = idr_get_new(&pps_idr, pps, &pps->id);
+        mutex_unlock(&pps_idr_lock);
+
+        if (err < 0)
+                return err;
+
+        pps->id &= MAX_ID_MASK;
+        if (pps->id >= PPS_MAX_SOURCES) {
+                pr_err("%s: too many PPS sources in the system\n",
+                                        pps->info.name);
+                err = -EBUSY;
+                goto free_idr;
+        }
+
+        devt = MKDEV(MAJOR(pps_devt), pps->id);
 
-        pps->devno = MKDEV(MAJOR(pps_devt), pps->id);
         cdev_init(&pps->cdev, &pps_cdev_fops);
         pps->cdev.owner = pps->info.owner;
 
-        err = cdev_add(&pps->cdev, pps->devno, 1);
+        err = cdev_add(&pps->cdev, devt, 1);
         if (err) {
-                printk(KERN_ERR "pps: %s: failed to add char device %d:%d\n",
+                pr_err("%s: failed to add char device %d:%d\n",
                                 pps->info.name, MAJOR(pps_devt), pps->id);
-                return err;
+                goto free_idr;
         }
-        pps->dev = device_create(pps_class, pps->info.dev, pps->devno, NULL,
+        pps->dev = device_create(pps_class, pps->info.dev, devt, pps,
                                                         "pps%d", pps->id);
         if (IS_ERR(pps->dev))
                 goto del_cdev;
-        dev_set_drvdata(pps->dev, pps);
+
+        pps->dev->release = pps_device_destruct;
 
         pr_debug("source %s got cdev (%d:%d)\n", pps->info.name,
                         MAJOR(pps_devt), pps->id);
@@ -261,12 +340,17 @@ int pps_register_cdev(struct pps_device *pps)
 del_cdev:
         cdev_del(&pps->cdev);
 
+free_idr:
+        mutex_lock(&pps_idr_lock);
+        idr_remove(&pps_idr, pps->id);
+        mutex_unlock(&pps_idr_lock);
+
         return err;
 }
 
 void pps_unregister_cdev(struct pps_device *pps)
 {
-        device_destroy(pps_class, pps->devno);
+        device_destroy(pps_class, pps->dev->devt);
         cdev_del(&pps->cdev);
 }
 
@@ -286,14 +370,14 @@ static int __init pps_init(void)
 
         pps_class = class_create(THIS_MODULE, "pps");
         if (!pps_class) {
-                printk(KERN_ERR "pps: failed to allocate class\n");
+                pr_err("failed to allocate class\n");
                 return -ENOMEM;
         }
         pps_class->dev_attrs = pps_attrs;
 
         err = alloc_chrdev_region(&pps_devt, 0, PPS_MAX_SOURCES, "pps");
         if (err < 0) {
-                printk(KERN_ERR "pps: failed to allocate char device region\n");
+                pr_err("failed to allocate char device region\n");
                 goto remove_class;
         }
 
diff --git a/drivers/rapidio/rio-scan.c b/drivers/rapidio/rio-scan.c
index 1eb82c4c712..467e82bd092 100644
--- a/drivers/rapidio/rio-scan.c
+++ b/drivers/rapidio/rio-scan.c
@@ -46,7 +46,6 @@ static void rio_init_em(struct rio_dev *rdev);
 DEFINE_SPINLOCK(rio_global_list_lock);
 
 static int next_destid = 0;
-static int next_switchid = 0;
 static int next_net = 0;
 static int next_comptag = 1;
 
@@ -378,12 +377,30 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         struct rio_dev *rdev;
         struct rio_switch *rswitch = NULL;
         int result, rdid;
+        size_t size;
+        u32 swpinfo = 0;
 
-        rdev = kzalloc(sizeof(struct rio_dev), GFP_KERNEL);
+        size = sizeof(struct rio_dev);
+        if (rio_mport_read_config_32(port, destid, hopcount,
+                                     RIO_PEF_CAR, &result))
+                return NULL;
+
+        if (result & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
+                rio_mport_read_config_32(port, destid, hopcount,
+                                         RIO_SWP_INFO_CAR, &swpinfo);
+                if (result & RIO_PEF_SWITCH) {
+                        size += (RIO_GET_TOTAL_PORTS(swpinfo) *
+                                sizeof(rswitch->nextdev[0])) + sizeof(*rswitch);
+                }
+        }
+
+        rdev = kzalloc(size, GFP_KERNEL);
         if (!rdev)
                 return NULL;
 
         rdev->net = net;
+        rdev->pef = result;
+        rdev->swpinfo = swpinfo;
         rio_mport_read_config_32(port, destid, hopcount, RIO_DEV_ID_CAR,
                                  &result);
         rdev->did = result >> 16;
@@ -397,8 +414,6 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         rio_mport_read_config_32(port, destid, hopcount, RIO_ASM_INFO_CAR,
                                  &result);
         rdev->asm_rev = result >> 16;
-        rio_mport_read_config_32(port, destid, hopcount, RIO_PEF_CAR,
-                                 &rdev->pef);
         if (rdev->pef & RIO_PEF_EXT_FEATURES) {
                 rdev->efptr = result & 0xffff;
                 rdev->phys_efptr = rio_mport_get_physefb(port, 0, destid,
@@ -408,11 +423,6 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                                                 hopcount, RIO_EFB_ERR_MGMNT);
         }
 
-        if (rdev->pef & (RIO_PEF_SWITCH | RIO_PEF_MULTIPORT)) {
-                rio_mport_read_config_32(port, destid, hopcount,
-                                         RIO_SWP_INFO_CAR, &rdev->swpinfo);
-        }
-
         rio_mport_read_config_32(port, destid, hopcount, RIO_SRC_OPS_CAR,
                                  &rdev->src_ops);
         rio_mport_read_config_32(port, destid, hopcount, RIO_DST_OPS_CAR,
@@ -427,6 +437,10 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                 rio_mport_write_config_32(port, destid, hopcount,
                                           RIO_COMPONENT_TAG_CSR, next_comptag);
                 rdev->comp_tag = next_comptag++;
+        }  else {
+                rio_mport_read_config_32(port, destid, hopcount,
+                                         RIO_COMPONENT_TAG_CSR,
+                                         &rdev->comp_tag);
         }
 
         if (rio_device_has_destid(port, rdev->src_ops, rdev->dst_ops)) {
@@ -437,21 +451,20 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                                 next_destid++;
                 } else
                         rdev->destid = rio_get_device_id(port, destid, hopcount);
-        } else
-                /* Switch device has an associated destID */
-                rdev->destid = RIO_INVALID_DESTID;
+
+                rdev->hopcount = 0xff;
+        } else {
+                /* Switch device has an associated destID which
+                 * will be adjusted later
+                 */
+                rdev->destid = destid;
+                rdev->hopcount = hopcount;
+        }
 
         /* If a PE has both switch and other functions, show it as a switch */
         if (rio_is_switch(rdev)) {
-                rswitch = kzalloc(sizeof(*rswitch) +
-                                  RIO_GET_TOTAL_PORTS(rdev->swpinfo) *
-                                  sizeof(rswitch->nextdev[0]),
-                                  GFP_KERNEL);
-                if (!rswitch)
-                        goto cleanup;
-                rswitch->switchid = next_switchid;
-                rswitch->hopcount = hopcount;
-                rswitch->destid = destid;
+                rswitch = rdev->rswitch;
+                rswitch->switchid = rdev->comp_tag & RIO_CTAG_UDEVID;
                 rswitch->port_ok = 0;
                 rswitch->route_table = kzalloc(sizeof(u8)*
                                         RIO_MAX_ROUTE_ENTRIES(port->sys_size),
@@ -462,15 +475,13 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
                 for (rdid = 0; rdid < RIO_MAX_ROUTE_ENTRIES(port->sys_size);
                                 rdid++)
                         rswitch->route_table[rdid] = RIO_INVALID_ROUTE;
-                rdev->rswitch = rswitch;
-                rswitch->rdev = rdev;
                 dev_set_name(&rdev->dev, "%02x:s:%04x", rdev->net->id,
-                             rdev->rswitch->switchid);
+                             rswitch->switchid);
                 rio_switch_init(rdev, do_enum);
 
-                if (do_enum && rdev->rswitch->clr_table)
-                        rdev->rswitch->clr_table(port, destid, hopcount,
-                                                 RIO_GLOBAL_TABLE);
+                if (do_enum && rswitch->clr_table)
+                        rswitch->clr_table(port, destid, hopcount,
+                                           RIO_GLOBAL_TABLE);
 
                 list_add_tail(&rswitch->node, &rio_switches);
 
@@ -506,10 +517,9 @@ static struct rio_dev __devinit *rio_setup_device(struct rio_net *net,
         return rdev;
 
 cleanup:
-        if (rswitch) {
+        if (rswitch->route_table)
                 kfree(rswitch->route_table);
-                kfree(rswitch);
-        }
+
         kfree(rdev);
         return NULL;
 }
@@ -632,8 +642,7 @@ rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)
 
 /**
  * rio_route_add_entry- Add a route entry to a switch routing table
- * @mport: Master port to send transaction
- * @rswitch: Switch device
+ * @rdev: RIO device
  * @table: Routing table ID
  * @route_destid: Destination ID to be routed
  * @route_port: Port number to be routed
@@ -647,31 +656,31 @@ rio_unlock_device(struct rio_mport *port, u16 destid, u8 hopcount)
  * on failure.
  */
 static int
-rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswitch,
+rio_route_add_entry(struct rio_dev *rdev,
                     u16 table, u16 route_destid, u8 route_port, int lock)
 {
         int rc;
 
         if (lock) {
-                rc = rio_lock_device(mport, rswitch->destid,
-                                     rswitch->hopcount, 1000);
+                rc = rio_lock_device(rdev->net->hport, rdev->destid,
+                                     rdev->hopcount, 1000);
                 if (rc)
                         return rc;
         }
 
-        rc = rswitch->add_entry(mport, rswitch->destid,
-                                        rswitch->hopcount, table,
-                                        route_destid, route_port);
+        rc = rdev->rswitch->add_entry(rdev->net->hport, rdev->destid,
+                                      rdev->hopcount, table,
+                                      route_destid, route_port);
         if (lock)
-                rio_unlock_device(mport, rswitch->destid, rswitch->hopcount);
+                rio_unlock_device(rdev->net->hport, rdev->destid,
+                                  rdev->hopcount);
 
         return rc;
 }
 
 /**
  * rio_route_get_entry- Read a route entry in a switch routing table
- * @mport: Master port to send transaction
- * @rswitch: Switch device
+ * @rdev: RIO device
  * @table: Routing table ID
  * @route_destid: Destination ID to be routed
  * @route_port: Pointer to read port number into
@@ -685,23 +694,24 @@ rio_route_add_entry(struct rio_mport *mport, struct rio_switch *rswitch,
  * on failure.
  */
 static int
-rio_route_get_entry(struct rio_mport *mport, struct rio_switch *rswitch, u16 table,
+rio_route_get_entry(struct rio_dev *rdev, u16 table,
                     u16 route_destid, u8 *route_port, int lock)
 {
         int rc;
 
         if (lock) {
-                rc = rio_lock_device(mport, rswitch->destid,
-                                     rswitch->hopcount, 1000);
+                rc = rio_lock_device(rdev->net->hport, rdev->destid,
+                                     rdev->hopcount, 1000);
                 if (rc)
                         return rc;
         }
 
-        rc = rswitch->get_entry(mport, rswitch->destid,
-                                        rswitch->hopcount, table,
-                                        route_destid, route_port);
+        rc = rdev->rswitch->get_entry(rdev->net->hport, rdev->destid,
+                                      rdev->hopcount, table,
+                                      route_destid, route_port);
         if (lock)
-                rio_unlock_device(mport, rswitch->destid, rswitch->hopcount);
+                rio_unlock_device(rdev->net->hport, rdev->destid,
+                                  rdev->hopcount);
 
         return rc;
 }
@@ -809,16 +819,15 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                 return -1;
 
         if (rio_is_switch(rdev)) {
-                next_switchid++;
                 sw_inport = RIO_GET_PORT_NUM(rdev->swpinfo);
-                rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE,
+                rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
                                     port->host_deviceid, sw_inport, 0);
                 rdev->rswitch->route_table[port->host_deviceid] = sw_inport;
 
                 for (destid = 0; destid < next_destid; destid++) {
                         if (destid == port->host_deviceid)
                                 continue;
-                        rio_route_add_entry(port, rdev->rswitch, RIO_GLOBAL_TABLE,
+                        rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
                                             destid, sw_inport, 0);
                         rdev->rswitch->route_table[destid] = sw_inport;
                 }
@@ -850,8 +859,7 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                     "RIO: scanning device on port %d\n",
                                     port_num);
                                 rdev->rswitch->port_ok |= (1 << port_num);
-                                rio_route_add_entry(port, rdev->rswitch,
-                                                RIO_GLOBAL_TABLE,
+                                rio_route_add_entry(rdev, RIO_GLOBAL_TABLE,
                                                 RIO_ANY_DESTID(port->sys_size),
                                                 port_num, 0);
 
@@ -865,7 +873,7 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                              destid < next_destid; destid++) {
                                                 if (destid == port->host_deviceid)
                                                         continue;
-                                                rio_route_add_entry(port, rdev->rswitch,
+                                                rio_route_add_entry(rdev,
                                                                     RIO_GLOBAL_TABLE,
                                                                     destid,
                                                                     port_num,
@@ -904,7 +912,7 @@ static int __devinit rio_enum_peer(struct rio_net *net, struct rio_mport *port,
                                 next_destid++;
                 }
 
-                rdev->rswitch->destid = sw_destid;
+                rdev->destid = sw_destid;
         } else
                 pr_debug("RIO: found %s (vid %4.4x did %4.4x)\n",
                     rio_name(rdev), rdev->vid, rdev->did);
@@ -941,7 +949,7 @@ static int rio_enum_complete(struct rio_mport *port)
  */
 static int __devinit
 rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
-              u8 hopcount)
+              u8 hopcount, struct rio_dev *prev, int prev_port)
 {
         u8 port_num, route_port;
         struct rio_dev *rdev;
@@ -951,14 +959,15 @@ rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
         if ((rdev = rio_setup_device(net, port, destid, hopcount, 0))) {
                 /* Add device to the global and bus/net specific list. */
                 list_add_tail(&rdev->net_list, &net->devices);
+                rdev->prev = prev;
+                if (prev && rio_is_switch(prev))
+                        prev->rswitch->nextdev[prev_port] = rdev;
         } else
                 return -1;
 
         if (rio_is_switch(rdev)) {
-                next_switchid++;
-
                 /* Associated destid is how we accessed this switch */
-                rdev->rswitch->destid = destid;
+                rdev->destid = destid;
 
                 pr_debug(
                     "RIO: found %s (vid %4.4x did %4.4x) with %d ports\n",
@@ -981,7 +990,7 @@ rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
                                 for (ndestid = 0;
                                      ndestid < RIO_ANY_DESTID(port->sys_size);
                                      ndestid++) {
-                                        rio_route_get_entry(port, rdev->rswitch,
+                                        rio_route_get_entry(rdev,
                                                             RIO_GLOBAL_TABLE,
                                                             ndestid,
                                                             &route_port, 0);
@@ -992,8 +1001,8 @@ rio_disc_peer(struct rio_net *net, struct rio_mport *port, u16 destid,
                                 if (ndestid == RIO_ANY_DESTID(port->sys_size))
                                         continue;
                                 rio_unlock_device(port, destid, hopcount);
-                                if (rio_disc_peer
-                                    (net, port, ndestid, hopcount + 1) < 0)
+                                if (rio_disc_peer(net, port, ndestid,
+                                        hopcount + 1, rdev, port_num) < 0)
                                         return -1;
                         }
                 }
@@ -1069,14 +1078,14 @@ static struct rio_net __devinit *rio_alloc_net(struct rio_mport *port)
  */
 static void rio_update_route_tables(struct rio_mport *port)
 {
-        struct rio_dev *rdev;
+        struct rio_dev *rdev, *swrdev;
         struct rio_switch *rswitch;
         u8 sport;
         u16 destid;
 
         list_for_each_entry(rdev, &rio_devices, global_list) {
 
-                destid = (rio_is_switch(rdev))?rdev->rswitch->destid:rdev->destid;
+                destid = rdev->destid;
 
                 list_for_each_entry(rswitch, &rio_switches, node) {
 
@@ -1084,14 +1093,16 @@ static void rio_update_route_tables(struct rio_mport *port)
                                 continue;
 
                         if (RIO_INVALID_ROUTE == rswitch->route_table[destid]) {
+                                swrdev = sw_to_rio_dev(rswitch);
+
                                 /* Skip if destid ends in empty switch*/
-                                if (rswitch->destid == destid)
+                                if (swrdev->destid == destid)
                                         continue;
 
-                                sport = RIO_GET_PORT_NUM(rswitch->rdev->swpinfo);
+                                sport = RIO_GET_PORT_NUM(swrdev->swpinfo);
 
                                 if (rswitch->add_entry) {
-                                        rio_route_add_entry(port, rswitch,
+                                        rio_route_add_entry(swrdev,
                                                 RIO_GLOBAL_TABLE, destid,
                                                 sport, 0);
                                         rswitch->route_table[destid] = sport;
@@ -1203,21 +1214,20 @@ static void rio_build_route_tables(void)
 
         list_for_each_entry(rdev, &rio_devices, global_list)
                 if (rio_is_switch(rdev)) {
-                        rio_lock_device(rdev->net->hport, rdev->rswitch->destid,
-                                        rdev->rswitch->hopcount, 1000);
+                        rio_lock_device(rdev->net->hport, rdev->destid,
+                                        rdev->hopcount, 1000);
                         for (i = 0;
                              i < RIO_MAX_ROUTE_ENTRIES(rdev->net->hport->sys_size);
                              i++) {
-                                if (rio_route_get_entry
-                                    (rdev->net->hport, rdev->rswitch,
-                                     RIO_GLOBAL_TABLE, i, &sport, 0) < 0)
+                                if (rio_route_get_entry(rdev,
+                                        RIO_GLOBAL_TABLE, i, &sport, 0) < 0)
                                         continue;
                                 rdev->rswitch->route_table[i] = sport;
                         }
 
                         rio_unlock_device(rdev->net->hport,
-                                          rdev->rswitch->destid,
-                                          rdev->rswitch->hopcount);
+                                          rdev->destid,
+                                          rdev->hopcount);
                 }
 }
 
@@ -1284,7 +1294,7 @@ int __devinit rio_disc_mport(struct rio_mport *mport)
                                                    mport->host_deviceid);
 
                 if (rio_disc_peer(net, mport, RIO_ANY_DESTID(mport->sys_size),
-                                        0) < 0) {
+                                        0, NULL, 0) < 0) {
                         printk(KERN_INFO
                                "RIO: master port %d device has failed discovery\n",
                                mport->id);
diff --git a/drivers/rapidio/rio-sysfs.c b/drivers/rapidio/rio-sysfs.c
index 137ed93ee33..76b41853a87 100644
--- a/drivers/rapidio/rio-sysfs.c
+++ b/drivers/rapidio/rio-sysfs.c
@@ -217,7 +217,7 @@ int rio_create_sysfs_dev_files(struct rio_dev *rdev)
 
         err = device_create_bin_file(&rdev->dev, &rio_config_attr);
 
-        if (!err && rdev->rswitch) {
+        if (!err && (rdev->pef & RIO_PEF_SWITCH)) {
                 err = device_create_file(&rdev->dev, &dev_attr_routes);
                 if (!err && rdev->rswitch->sw_sysfs)
                         err = rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_CREATE);
@@ -239,7 +239,7 @@ int rio_create_sysfs_dev_files(struct rio_dev *rdev)
 void rio_remove_sysfs_dev_files(struct rio_dev *rdev)
 {
         device_remove_bin_file(&rdev->dev, &rio_config_attr);
-        if (rdev->rswitch) {
+        if (rdev->pef & RIO_PEF_SWITCH) {
                 device_remove_file(&rdev->dev, &dev_attr_routes);
                 if (rdev->rswitch->sw_sysfs)
                         rdev->rswitch->sw_sysfs(rdev, RIO_SW_SYSFS_REMOVE);
diff --git a/drivers/rapidio/rio.c b/drivers/rapidio/rio.c
index 7b5080c4556..cc2a3b74d0f 100644
--- a/drivers/rapidio/rio.c
+++ b/drivers/rapidio/rio.c
@@ -471,16 +471,9 @@ exit:
  */
 int rio_set_port_lockout(struct rio_dev *rdev, u32 pnum, int lock)
 {
-        u8 hopcount = 0xff;
-        u16 destid = rdev->destid;
         u32 regval;
 
-        if (rdev->rswitch) {
-                destid = rdev->rswitch->destid;
-                hopcount = rdev->rswitch->hopcount;
-        }
-
-        rio_mport_read_config_32(rdev->net->hport, destid, hopcount,
+        rio_read_config_32(rdev,
                                  rdev->phys_efptr + RIO_PORT_N_CTL_CSR(pnum),
                                  &regval);
         if (lock)
@@ -488,7 +481,7 @@ int rio_set_port_lockout(struct rio_dev *rdev, u32 pnum, int lock)
         else
                 regval &= ~RIO_PORT_N_CTL_LOCKOUT;
 
-        rio_mport_write_config_32(rdev->net->hport, destid, hopcount,
+        rio_write_config_32(rdev,
                                   rdev->phys_efptr + RIO_PORT_N_CTL_CSR(pnum),
                                   regval);
         return 0;
@@ -507,7 +500,7 @@ static int
 rio_chk_dev_route(struct rio_dev *rdev, struct rio_dev **nrdev, int *npnum)
 {
         u32 result;
-        int p_port, dstid, rc = -EIO;
+        int p_port, rc = -EIO;
         struct rio_dev *prev = NULL;
 
         /* Find switch with failed RIO link */
@@ -522,9 +515,7 @@ rio_chk_dev_route(struct rio_dev *rdev, struct rio_dev **nrdev, int *npnum)
         if (prev == NULL)
                 goto err_out;
 
-        dstid = (rdev->pef & RIO_PEF_SWITCH) ?
-                        rdev->rswitch->destid : rdev->destid;
-        p_port = prev->rswitch->route_table[dstid];
+        p_port = prev->rswitch->route_table[rdev->destid];
 
         if (p_port != RIO_INVALID_ROUTE) {
                 pr_debug("RIO: link failed on [%s]-P%d\n",
@@ -567,15 +558,8 @@ rio_mport_chk_dev_access(struct rio_mport *mport, u16 destid, u8 hopcount)
  */
 static int rio_chk_dev_access(struct rio_dev *rdev)
 {
-        u8 hopcount = 0xff;
-        u16 destid = rdev->destid;
-
-        if (rdev->rswitch) {
-                destid = rdev->rswitch->destid;
-                hopcount = rdev->rswitch->hopcount;
-        }
-
-        return rio_mport_chk_dev_access(rdev->net->hport, destid, hopcount);
+        return rio_mport_chk_dev_access(rdev->net->hport,
+                                        rdev->destid, rdev->hopcount);
 }
 
 /**
@@ -588,23 +572,20 @@ static int rio_chk_dev_access(struct rio_dev *rdev)
 static int
 rio_get_input_status(struct rio_dev *rdev, int pnum, u32 *lnkresp)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 regval;
         int checkcount;
 
         if (lnkresp) {
                 /* Read from link maintenance response register
                  * to clear valid bit */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_MNT_RSP_CSR(pnum),
                         &regval);
                 udelay(50);
         }
 
         /* Issue Input-status command */
-        rio_mport_write_config_32(mport, destid, hopcount,
+        rio_write_config_32(rdev,
                 rdev->phys_efptr + RIO_PORT_N_MNT_REQ_CSR(pnum),
                 RIO_MNT_REQ_CMD_IS);
 
@@ -615,7 +596,7 @@ rio_get_input_status(struct rio_dev *rdev, int pnum, u32 *lnkresp)
         checkcount = 3;
         while (checkcount--) {
                 udelay(50);
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_MNT_RSP_CSR(pnum),
                         &regval);
                 if (regval & RIO_PORT_N_MNT_RSP_RVAL) {
@@ -635,15 +616,12 @@ rio_get_input_status(struct rio_dev *rdev, int pnum, u32 *lnkresp)
  */
 static int rio_clr_err_stopped(struct rio_dev *rdev, u32 pnum, u32 err_status)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         struct rio_dev *nextdev = rdev->rswitch->nextdev[pnum];
         u32 regval;
         u32 far_ackid, far_linkstat, near_ackid;
 
         if (err_status == 0)
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(pnum),
                         &err_status);
 
@@ -661,7 +639,7 @@ static int rio_clr_err_stopped(struct rio_dev *rdev, u32 pnum, u32 err_status)
                          pnum, regval);
                 far_ackid = (regval & RIO_PORT_N_MNT_RSP_ASTAT) >> 5;
                 far_linkstat = regval & RIO_PORT_N_MNT_RSP_LSTAT;
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ACK_STS_CSR(pnum),
                         &regval);
                 pr_debug("RIO_EM: SP%d_ACK_STS_CSR=0x%08x\n", pnum, regval);
@@ -679,9 +657,8 @@ static int rio_clr_err_stopped(struct rio_dev *rdev, u32 pnum, u32 err_status)
                         /* Align near outstanding/outbound ackIDs with
                          * far inbound.
                          */
-                        rio_mport_write_config_32(mport, destid,
-                                hopcount, rdev->phys_efptr +
-                                        RIO_PORT_N_ACK_STS_CSR(pnum),
+                        rio_write_config_32(rdev,
+                                rdev->phys_efptr + RIO_PORT_N_ACK_STS_CSR(pnum),
                                 (near_ackid << 24) |
                                         (far_ackid << 8) | far_ackid);
                         /* Align far outstanding/outbound ackIDs with
@@ -698,7 +675,7 @@ static int rio_clr_err_stopped(struct rio_dev *rdev, u32 pnum, u32 err_status)
                                 pr_debug("RIO_EM: Invalid nextdev pointer (NULL)\n");
                 }
 rd_err:
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(pnum),
                         &err_status);
                 pr_debug("RIO_EM: SP%d_ERR_STS_CSR=0x%08x\n", pnum, err_status);
@@ -710,7 +687,7 @@ rd_err:
                                      RIO_GET_PORT_NUM(nextdev->swpinfo), NULL);
                 udelay(50);
 
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(pnum),
                         &err_status);
                 pr_debug("RIO_EM: SP%d_ERR_STS_CSR=0x%08x\n", pnum, err_status);
@@ -730,13 +707,10 @@ rd_err:
 int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg)
 {
         struct rio_dev *rdev;
-        struct rio_mport *mport;
-        u8 hopcount;
-        u16 destid;
         u32 err_status, em_perrdet, em_ltlerrdet;
         int rc, portnum;
 
-        rdev = rio_get_comptag(pw_msg->em.comptag, NULL);
+        rdev = rio_get_comptag((pw_msg->em.comptag & RIO_CTAG_UDEVID), NULL);
         if (rdev == NULL) {
                 /* Device removed or enumeration error */
                 pr_debug("RIO: %s No matching device for CTag 0x%08x\n",
@@ -800,17 +774,13 @@ int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg)
                 return 0;
         }
 
-        mport = rdev->net->hport;
-        destid = rdev->rswitch->destid;
-        hopcount = rdev->rswitch->hopcount;
-
         /*
          * Process the port-write notification from switch
          */
         if (rdev->rswitch->em_handle)
                 rdev->rswitch->em_handle(rdev, portnum);
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
                         &err_status);
         pr_debug("RIO_PW: SP%d_ERR_STS_CSR=0x%08x\n", portnum, err_status);
@@ -840,7 +810,7 @@ int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg)
                         rdev->rswitch->port_ok &= ~(1 << portnum);
                         rio_set_port_lockout(rdev, portnum, 1);
 
-                        rio_mport_write_config_32(mport, destid, hopcount,
+                        rio_write_config_32(rdev,
                                 rdev->phys_efptr +
                                         RIO_PORT_N_ACK_STS_CSR(portnum),
                                 RIO_PORT_N_ACK_CLEAR);
@@ -851,28 +821,28 @@ int rio_inb_pwrite_handler(union rio_pw_msg *pw_msg)
                 }
         }
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                 rdev->em_efptr + RIO_EM_PN_ERR_DETECT(portnum), &em_perrdet);
         if (em_perrdet) {
                 pr_debug("RIO_PW: RIO_EM_P%d_ERR_DETECT=0x%08x\n",
                          portnum, em_perrdet);
                 /* Clear EM Port N Error Detect CSR */
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                         rdev->em_efptr + RIO_EM_PN_ERR_DETECT(portnum), 0);
         }
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                 rdev->em_efptr + RIO_EM_LTL_ERR_DETECT, &em_ltlerrdet);
         if (em_ltlerrdet) {
                 pr_debug("RIO_PW: RIO_EM_LTL_ERR_DETECT=0x%08x\n",
                          em_ltlerrdet);
                 /* Clear EM L/T Layer Error Detect CSR */
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                         rdev->em_efptr + RIO_EM_LTL_ERR_DETECT, 0);
         }
 
         /* Clear remaining error bits and Port-Write Pending bit */
-        rio_mport_write_config_32(mport, destid, hopcount,
+        rio_write_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
                         err_status);
 
diff --git a/drivers/rapidio/switches/idt_gen2.c b/drivers/rapidio/switches/idt_gen2.c
index 0bb871cb5c4..095016a9dec 100644
--- a/drivers/rapidio/switches/idt_gen2.c
+++ b/drivers/rapidio/switches/idt_gen2.c
@@ -209,9 +209,6 @@ idtg2_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
 static int
 idtg2_em_init(struct rio_dev *rdev)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 regval;
         int i, tmp;
 
@@ -220,29 +217,25 @@ idtg2_em_init(struct rio_dev *rdev)
          * All standard EM configuration should be performed at upper level.
          */
 
-        pr_debug("RIO: %s [%d:%d]\n", __func__, destid, hopcount);
+        pr_debug("RIO: %s [%d:%d]\n", __func__, rdev->destid, rdev->hopcount);
 
         /* Set Port-Write info CSR: PRIO=3 and CRF=1 */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_PW_INFO_CSR, 0x0000e000);
+        rio_write_config_32(rdev, IDT_PW_INFO_CSR, 0x0000e000);
 
         /*
          * Configure LT LAYER error reporting.
          */
 
         /* Enable standard (RIO.p8) error reporting */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_LT_ERR_REPORT_EN,
+        rio_write_config_32(rdev, IDT_LT_ERR_REPORT_EN,
                         REM_LTL_ERR_ILLTRAN | REM_LTL_ERR_UNSOLR |
                         REM_LTL_ERR_UNSUPTR);
 
         /* Use Port-Writes for LT layer error reporting.
          * Enable per-port reset
          */
-        rio_mport_read_config_32(mport, destid, hopcount,
-                        IDT_DEV_CTRL_1, &regval);
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_DEV_CTRL_1,
+        rio_read_config_32(rdev, IDT_DEV_CTRL_1, &regval);
+        rio_write_config_32(rdev, IDT_DEV_CTRL_1,
                         regval | IDT_DEV_CTRL_1_GENPW | IDT_DEV_CTRL_1_PRSTBEH);
 
         /*
@@ -250,45 +243,40 @@ idtg2_em_init(struct rio_dev *rdev)
          */
 
         /* Report all RIO.p8 errors supported by device */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_PORT_ERR_REPORT_EN_BC, 0x807e8037);
+        rio_write_config_32(rdev, IDT_PORT_ERR_REPORT_EN_BC, 0x807e8037);
 
         /* Configure reporting of implementation specific errors/events */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_PORT_ISERR_REPORT_EN_BC, IDT_PORT_INIT_TX_ACQUIRED);
+        rio_write_config_32(rdev, IDT_PORT_ISERR_REPORT_EN_BC,
+                            IDT_PORT_INIT_TX_ACQUIRED);
 
         /* Use Port-Writes for port error reporting and enable error logging */
         tmp = RIO_GET_TOTAL_PORTS(rdev->swpinfo);
         for (i = 0; i < tmp; i++) {
-                rio_mport_read_config_32(mport, destid, hopcount,
-                                IDT_PORT_OPS(i), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev, IDT_PORT_OPS(i), &regval);
+                rio_write_config_32(rdev,
                                 IDT_PORT_OPS(i), regval | IDT_PORT_OPS_GENPW |
                                 IDT_PORT_OPS_PL_ELOG |
                                 IDT_PORT_OPS_LL_ELOG |
                                 IDT_PORT_OPS_LT_ELOG);
         }
         /* Overwrite error log if full */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_ERR_CAP, IDT_ERR_CAP_LOG_OVERWR);
+        rio_write_config_32(rdev, IDT_ERR_CAP, IDT_ERR_CAP_LOG_OVERWR);
 
         /*
          * Configure LANE error reporting.
          */
 
         /* Disable line error reporting */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_LANE_ERR_REPORT_EN_BC, 0);
+        rio_write_config_32(rdev, IDT_LANE_ERR_REPORT_EN_BC, 0);
 
         /* Use Port-Writes for lane error reporting (when enabled)
          * (do per-lane update because lanes may have different configuration)
          */
         tmp = (rdev->did == RIO_DID_IDTCPS1848) ? 48 : 16;
         for (i = 0; i < tmp; i++) {
-                rio_mport_read_config_32(mport, destid, hopcount,
-                                IDT_LANE_CTRL(i), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
-                                IDT_LANE_CTRL(i), regval | IDT_LANE_CTRL_GENPW);
+                rio_read_config_32(rdev, IDT_LANE_CTRL(i), &regval);
+                rio_write_config_32(rdev, IDT_LANE_CTRL(i),
+                                    regval | IDT_LANE_CTRL_GENPW);
         }
 
         /*
@@ -296,41 +284,32 @@ idtg2_em_init(struct rio_dev *rdev)
          */
 
         /* Disable JTAG and I2C Error capture */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_AUX_PORT_ERR_CAP_EN, 0);
+        rio_write_config_32(rdev, IDT_AUX_PORT_ERR_CAP_EN, 0);
 
         /* Disable JTAG and I2C Error reporting/logging */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_AUX_ERR_REPORT_EN, 0);
+        rio_write_config_32(rdev, IDT_AUX_ERR_REPORT_EN, 0);
 
         /* Disable Port-Write notification from JTAG */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_JTAG_CTRL, 0);
+        rio_write_config_32(rdev, IDT_JTAG_CTRL, 0);
 
         /* Disable Port-Write notification from I2C */
-        rio_mport_read_config_32(mport, destid, hopcount,
-                        IDT_I2C_MCTRL, &regval);
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_I2C_MCTRL,
-                        regval & ~IDT_I2C_MCTRL_GENPW);
+        rio_read_config_32(rdev, IDT_I2C_MCTRL, &regval);
+        rio_write_config_32(rdev, IDT_I2C_MCTRL, regval & ~IDT_I2C_MCTRL_GENPW);
 
         /*
          * Configure CFG_BLK error reporting.
          */
 
         /* Disable Configuration Block error capture */
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_CFGBLK_ERR_CAPTURE_EN, 0);
+        rio_write_config_32(rdev, IDT_CFGBLK_ERR_CAPTURE_EN, 0);
 
         /* Disable Port-Writes for Configuration Block error reporting */
-        rio_mport_read_config_32(mport, destid, hopcount,
-                        IDT_CFGBLK_ERR_REPORT, &regval);
-        rio_mport_write_config_32(mport, destid, hopcount,
-                        IDT_CFGBLK_ERR_REPORT,
-                        regval & ~IDT_CFGBLK_ERR_REPORT_GENPW);
+        rio_read_config_32(rdev, IDT_CFGBLK_ERR_REPORT, &regval);
+        rio_write_config_32(rdev, IDT_CFGBLK_ERR_REPORT,
+                            regval & ~IDT_CFGBLK_ERR_REPORT_GENPW);
 
         /* set TVAL = ~50us */
-        rio_mport_write_config_32(mport, destid, hopcount,
+        rio_write_config_32(rdev,
                 rdev->phys_efptr + RIO_PORT_LINKTO_CTL_CSR, 0x8e << 8);
 
         return 0;
@@ -339,18 +318,15 @@ idtg2_em_init(struct rio_dev *rdev)
 static int
 idtg2_em_handler(struct rio_dev *rdev, u8 portnum)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 regval, em_perrdet, em_ltlerrdet;
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                 rdev->em_efptr + RIO_EM_LTL_ERR_DETECT, &em_ltlerrdet);
         if (em_ltlerrdet) {
                 /* Service Logical/Transport Layer Error(s) */
                 if (em_ltlerrdet & REM_LTL_ERR_IMPSPEC) {
                         /* Implementation specific error reported */
-                        rio_mport_read_config_32(mport, destid, hopcount,
+                        rio_read_config_32(rdev,
                                         IDT_ISLTL_ADDRESS_CAP, &regval);
 
                         pr_debug("RIO: %s Implementation Specific LTL errors" \
@@ -358,13 +334,12 @@ idtg2_em_handler(struct rio_dev *rdev, u8 portnum)
                                  rio_name(rdev), em_ltlerrdet, regval);
 
                         /* Clear implementation specific address capture CSR */
-                        rio_mport_write_config_32(mport, destid, hopcount,
-                                        IDT_ISLTL_ADDRESS_CAP, 0);
+                        rio_write_config_32(rdev, IDT_ISLTL_ADDRESS_CAP, 0);
 
                 }
         }
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                 rdev->em_efptr + RIO_EM_PN_ERR_DETECT(portnum), &em_perrdet);
         if (em_perrdet) {
                 /* Service Port-Level Error(s) */
@@ -372,14 +347,14 @@ idtg2_em_handler(struct rio_dev *rdev, u8 portnum)
                         /* Implementation Specific port error reported */
 
                         /* Get IS errors reported */
-                        rio_mport_read_config_32(mport, destid, hopcount,
+                        rio_read_config_32(rdev,
                                         IDT_PORT_ISERR_DET(portnum), &regval);
 
                         pr_debug("RIO: %s Implementation Specific Port" \
                                  " errors 0x%x\n", rio_name(rdev), regval);
 
                         /* Clear all implementation specific events */
-                        rio_mport_write_config_32(mport, destid, hopcount,
+                        rio_write_config_32(rdev,
                                         IDT_PORT_ISERR_DET(portnum), 0);
                 }
         }
@@ -391,14 +366,10 @@ static ssize_t
 idtg2_show_errlog(struct device *dev, struct device_attribute *attr, char *buf)
 {
         struct rio_dev *rdev = to_rio_dev(dev);
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         ssize_t len = 0;
         u32 regval;
 
-        while (!rio_mport_read_config_32(mport, destid, hopcount,
-                                         IDT_ERR_RD, &regval)) {
+        while (!rio_read_config_32(rdev, IDT_ERR_RD, &regval)) {
                 if (!regval)    /* 0 = end of log */
                         break;
                 len += snprintf(buf + len, PAGE_SIZE - len,
@@ -445,3 +416,5 @@ static int idtg2_switch_init(struct rio_dev *rdev, int do_enum)
 
 DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS1848, idtg2_switch_init);
 DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTCPS1616, idtg2_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTVPS1616, idtg2_switch_init);
+DECLARE_RIO_SWITCH_INIT(RIO_VID_IDT, RIO_DID_IDTSPS1616, idtg2_switch_init);
diff --git a/drivers/rapidio/switches/idtcps.c b/drivers/rapidio/switches/idtcps.c
index fc9f6374f75..3a971077e7b 100644
--- a/drivers/rapidio/switches/idtcps.c
+++ b/drivers/rapidio/switches/idtcps.c
@@ -117,10 +117,6 @@ idtcps_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
 
 static int idtcps_switch_init(struct rio_dev *rdev, int do_enum)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
-
         pr_debug("RIO: %s for %s\n", __func__, rio_name(rdev));
         rdev->rswitch->add_entry = idtcps_route_add_entry;
         rdev->rswitch->get_entry = idtcps_route_get_entry;
@@ -132,7 +128,7 @@ static int idtcps_switch_init(struct rio_dev *rdev, int do_enum)
 
         if (do_enum) {
                 /* set TVAL = ~50us */
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_LINKTO_CTL_CSR, 0x8e << 8);
         }
 
diff --git a/drivers/rapidio/switches/tsi568.c b/drivers/rapidio/switches/tsi568.c
index b9a389b9f81..3994c00aa01 100644
--- a/drivers/rapidio/switches/tsi568.c
+++ b/drivers/rapidio/switches/tsi568.c
@@ -113,22 +113,17 @@ tsi568_route_clr_table(struct rio_mport *mport, u16 destid, u8 hopcount,
 static int
 tsi568_em_init(struct rio_dev *rdev)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 regval;
         int portnum;
 
-        pr_debug("TSI568 %s [%d:%d]\n", __func__, destid, hopcount);
+        pr_debug("TSI568 %s [%d:%d]\n", __func__, rdev->destid, rdev->hopcount);
 
         /* Make sure that Port-Writes are disabled (for all ports) */
         for (portnum = 0;
              portnum < RIO_GET_TOTAL_PORTS(rdev->swpinfo); portnum++) {
-                rio_mport_read_config_32(mport, destid, hopcount,
-                                TSI568_SP_MODE(portnum), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
-                                TSI568_SP_MODE(portnum),
-                                regval | TSI568_SP_MODE_PW_DIS);
+                rio_read_config_32(rdev, TSI568_SP_MODE(portnum), &regval);
+                rio_write_config_32(rdev, TSI568_SP_MODE(portnum),
+                                    regval | TSI568_SP_MODE_PW_DIS);
         }
 
         return 0;
diff --git a/drivers/rapidio/switches/tsi57x.c b/drivers/rapidio/switches/tsi57x.c
index 2003fb63c40..1a62934bfeb 100644
--- a/drivers/rapidio/switches/tsi57x.c
+++ b/drivers/rapidio/switches/tsi57x.c
@@ -158,48 +158,45 @@ tsi57x_get_domain(struct rio_mport *mport, u16 destid, u8 hopcount,
 static int
 tsi57x_em_init(struct rio_dev *rdev)
 {
-        struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 regval;
         int portnum;
 
-        pr_debug("TSI578 %s [%d:%d]\n", __func__, destid, hopcount);
+        pr_debug("TSI578 %s [%d:%d]\n", __func__, rdev->destid, rdev->hopcount);
 
         for (portnum = 0;
              portnum < RIO_GET_TOTAL_PORTS(rdev->swpinfo); portnum++) {
                 /* Make sure that Port-Writes are enabled (for all ports) */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 TSI578_SP_MODE(portnum), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                                 TSI578_SP_MODE(portnum),
                                 regval & ~TSI578_SP_MODE_PW_DIS);
 
                 /* Clear all pending interrupts */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 rdev->phys_efptr +
                                         RIO_PORT_N_ERR_STS_CSR(portnum),
                                 &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                                 rdev->phys_efptr +
                                         RIO_PORT_N_ERR_STS_CSR(portnum),
                                 regval & 0x07120214);
 
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 TSI578_SP_INT_STATUS(portnum), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                                 TSI578_SP_INT_STATUS(portnum),
                                 regval & 0x000700bd);
 
                 /* Enable all interrupts to allow ports to send a port-write */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 TSI578_SP_CTL_INDEP(portnum), &regval);
-                rio_mport_write_config_32(mport, destid, hopcount,
+                rio_write_config_32(rdev,
                                 TSI578_SP_CTL_INDEP(portnum),
                                 regval | 0x000b0000);
 
                 /* Skip next (odd) port if the current port is in x4 mode */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
                                 &regval);
                 if ((regval & RIO_PORT_N_CTL_PWIDTH) == RIO_PORT_N_CTL_PWIDTH_4)
@@ -207,7 +204,7 @@ tsi57x_em_init(struct rio_dev *rdev)
         }
 
         /* set TVAL = ~50us */
-        rio_mport_write_config_32(mport, destid, hopcount,
+        rio_write_config_32(rdev,
                 rdev->phys_efptr + RIO_PORT_LINKTO_CTL_CSR, 0x9a << 8);
 
         return 0;
@@ -217,14 +214,12 @@ static int
 tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
 {
         struct rio_mport *mport = rdev->net->hport;
-        u16 destid = rdev->rswitch->destid;
-        u8 hopcount = rdev->rswitch->hopcount;
         u32 intstat, err_status;
         int sendcount, checkcount;
         u8 route_port;
         u32 regval;
 
-        rio_mport_read_config_32(mport, destid, hopcount,
+        rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_ERR_STS_CSR(portnum),
                         &err_status);
 
@@ -232,15 +227,15 @@ tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
             (err_status & (RIO_PORT_N_ERR_STS_PW_OUT_ES |
                           RIO_PORT_N_ERR_STS_PW_INP_ES))) {
                 /* Remove any queued packets by locking/unlocking port */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
                         &regval);
                 if (!(regval & RIO_PORT_N_CTL_LOCKOUT)) {
-                        rio_mport_write_config_32(mport, destid, hopcount,
+                        rio_write_config_32(rdev,
                                 rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
                                 regval | RIO_PORT_N_CTL_LOCKOUT);
                         udelay(50);
-                        rio_mport_write_config_32(mport, destid, hopcount,
+                        rio_write_config_32(rdev,
                                 rdev->phys_efptr + RIO_PORT_N_CTL_CSR(portnum),
                                 regval);
                 }
@@ -248,7 +243,7 @@ tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
                 /* Read from link maintenance response register to clear
                  * valid bit
                  */
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                         rdev->phys_efptr + RIO_PORT_N_MNT_RSP_CSR(portnum),
                         &regval);
 
@@ -257,13 +252,12 @@ tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
                  */
                 sendcount = 3;
                 while (sendcount) {
-                        rio_mport_write_config_32(mport, destid, hopcount,
+                        rio_write_config_32(rdev,
                                           TSI578_SP_CS_TX(portnum), 0x40fc8000);
                         checkcount = 3;
                         while (checkcount--) {
                                 udelay(50);
-                                rio_mport_read_config_32(
-                                        mport, destid, hopcount,
+                                rio_read_config_32(rdev,
                                         rdev->phys_efptr +
                                                 RIO_PORT_N_MNT_RSP_CSR(portnum),
                                         &regval);
@@ -277,25 +271,23 @@ tsi57x_em_handler(struct rio_dev *rdev, u8 portnum)
 
 exit_es:
         /* Clear implementation specific error status bits */
-        rio_mport_read_config_32(mport, destid, hopcount,
-                                 TSI578_SP_INT_STATUS(portnum), &intstat);
+        rio_read_config_32(rdev, TSI578_SP_INT_STATUS(portnum), &intstat);
         pr_debug("TSI578[%x:%x] SP%d_INT_STATUS=0x%08x\n",
-                 destid, hopcount, portnum, intstat);
+                 rdev->destid, rdev->hopcount, portnum, intstat);
 
         if (intstat & 0x10000) {
-                rio_mport_read_config_32(mport, destid, hopcount,
+                rio_read_config_32(rdev,
                                 TSI578_SP_LUT_PEINF(portnum), &regval);
                 regval = (mport->sys_size) ? (regval >> 16) : (regval >> 24);
                 route_port = rdev->rswitch->route_table[regval];
                 pr_debug("RIO: TSI578[%s] P%d LUT Parity Error (destID=%d)\n",
                         rio_name(rdev), portnum, regval);
-                tsi57x_route_add_entry(mport, destid, hopcount,
+                tsi57x_route_add_entry(mport, rdev->destid, rdev->hopcount,
                                 RIO_GLOBAL_TABLE, regval, route_port);
         }
 
-        rio_mport_write_config_32(mport, destid, hopcount,
-                                  TSI578_SP_INT_STATUS(portnum),
-                                  intstat & 0x000700bd);
+        rio_write_config_32(rdev, TSI578_SP_INT_STATUS(portnum),
+                            intstat & 0x000700bd);
 
         return 0;
 }
diff --git a/drivers/regulator/88pm8607.c b/drivers/regulator/88pm8607.c
index 2ce2eb71d0f..dd6308499bd 100644
--- a/drivers/regulator/88pm8607.c
+++ b/drivers/regulator/88pm8607.c
@@ -249,7 +249,7 @@ static int choose_voltage(struct regulator_dev *rdev, int min_uV, int max_uV)
 }
 
 static int pm8607_set_voltage(struct regulator_dev *rdev,
-                              int min_uV, int max_uV)
+                              int min_uV, int max_uV, unsigned *selector)
 {
         struct pm8607_regulator_info *info = rdev_get_drvdata(rdev);
         uint8_t val, mask;
@@ -263,6 +263,7 @@ static int pm8607_set_voltage(struct regulator_dev *rdev,
         ret = choose_voltage(rdev, min_uV, max_uV);
         if (ret < 0)
                 return -EINVAL;
+        *selector = ret;
         val = (uint8_t)(ret << info->vol_shift);
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index dd30e883d4a..e1d943619ab 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -186,13 +186,25 @@ config REGULATOR_PCAP
          This driver provides support for the voltage regulators of the
          PCAP2 PMIC.
 
+config REGULATOR_MC13XXX_CORE
+        tristate
+
 config REGULATOR_MC13783
         tristate "Support regulators on Freescale MC13783 PMIC"
         depends on MFD_MC13783
+        select REGULATOR_MC13XXX_CORE
         help
           Say y here to support the regulators found on the Freescale MC13783
           PMIC.
 
+config REGULATOR_MC13892
+        tristate "Support regulators on Freescale MC13892 PMIC"
+        depends on MFD_MC13XXX
+        select REGULATOR_MC13XXX_CORE
+        help
+          Say y here to support the regulators found on the Freescale MC13892
+          PMIC.
+
 config REGULATOR_AB3100
         tristate "ST-Ericsson AB3100 Regulator functions"
         depends on AB3100_CORE
@@ -250,5 +262,15 @@ config REGULATOR_TPS6586X
         help
           This driver supports TPS6586X voltage regulator chips.
 
+config REGULATOR_TPS6524X
+        tristate "TI TPS6524X Power regulators"
+        depends on SPI
+        help
+          This driver supports TPS6524X voltage regulator chips. TPS6524X
+          provides three step-down converters and two general-purpose LDO
+          voltage regulators.  This device is interfaced using a customized
+          serial interface currently supported on the sequencer serial
+          port controller.
+
 endif
 
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index bff81573678..0b5e88c2b8d 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -30,10 +30,13 @@ obj-$(CONFIG_REGULATOR_DA903X)	+= da903x.o
 obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
 obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
 obj-$(CONFIG_REGULATOR_MC13783) += mc13783-regulator.o
+obj-$(CONFIG_REGULATOR_MC13892) += mc13892-regulator.o
+obj-$(CONFIG_REGULATOR_MC13XXX_CORE) +=  mc13xxx-regulator-core.o
 obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o
 
 obj-$(CONFIG_REGULATOR_TPS65023) += tps65023-regulator.o
 obj-$(CONFIG_REGULATOR_TPS6507X) += tps6507x-regulator.o
+obj-$(CONFIG_REGULATOR_TPS6524X) += tps6524x-regulator.o
 obj-$(CONFIG_REGULATOR_88PM8607) += 88pm8607.o
 obj-$(CONFIG_REGULATOR_ISL6271A) += isl6271a-regulator.o
 obj-$(CONFIG_REGULATOR_AB8500)  += ab8500.o
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index b349266a43d..ed6feaf9398 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -362,7 +362,8 @@ static int ab3100_get_best_voltage_index(struct regulator_dev *reg,
 }
 
 static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
-                                        int min_uV, int max_uV)
+                                        int min_uV, int max_uV,
+                                        unsigned *selector)
 {
         struct ab3100_regulator *abreg = reg->reg_data;
         u8 regval;
@@ -373,6 +374,8 @@ static int ab3100_set_voltage_regulator(struct regulator_dev *reg,
         if (bestindex < 0)
                 return bestindex;
 
+        *selector = bestindex;
+
         err = abx500_get_register_interruptible(abreg->dev, 0,
                                                 abreg->regreg, &regval);
         if (err) {
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index db6b70f2051..d9a052c53ae 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -3,18 +3,13 @@
  *
  * License Terms: GNU General Public License v2
  *
- * Author: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
+ * Authors: Sundar Iyer <sundar.iyer@stericsson.com> for ST-Ericsson
+ *          Bengt Jonsson <bengt.g.jonsson@stericsson.com> for ST-Ericsson
  *
  * AB8500 peripheral regulators
  *
- * AB8500 supports the following regulators,
- * LDOs - VAUDIO, VANAMIC2/2, VDIGMIC, VINTCORE12, VTVOUT,
- *        VAUX1/2/3, VANA
- *
- * for DB8500 cut 1.0 and previous versions of the silicon, all accesses
- * to registers are through the DB8500 SPI. In cut 1.1 onwards, these
- * accesses are through the DB8500 PRCMU I2C
- *
+ * AB8500 supports the following regulators:
+ *   VAUX1/2/3, VINTCORE, VTVOUT, VAUDIO, VAMIC1/2, VDMIC, VANA
  */
 #include <linux/init.h>
 #include <linux/kernel.h>
@@ -28,38 +23,37 @@
 
 /**
  * struct ab8500_regulator_info - ab8500 regulator information
+ * @dev: device pointer
  * @desc: regulator description
- * @ab8500: ab8500 parent
  * @regulator_dev: regulator device
  * @max_uV: maximum voltage (for variable voltage supplies)
  * @min_uV: minimum voltage (for variable voltage supplies)
  * @fixed_uV: typical voltage (for fixed voltage supplies)
  * @update_bank: bank to control on/off
  * @update_reg: register to control on/off
- * @mask: mask to enable/disable regulator
- * @enable: bits to enable the regulator in normal(high power) mode
+ * @update_mask: mask to enable/disable regulator
+ * @update_val_enable: bits to enable the regulator in normal (high power) mode
  * @voltage_bank: bank to control regulator voltage
  * @voltage_reg: register to control regulator voltage
  * @voltage_mask: mask to control regulator voltage
- * @supported_voltages: supported voltage table
+ * @voltages: supported voltage table
  * @voltages_len: number of supported voltages for the regulator
  */
 struct ab8500_regulator_info {
         struct device           *dev;
         struct regulator_desc   desc;
-        struct ab8500           *ab8500;
         struct regulator_dev    *regulator;
         int max_uV;
         int min_uV;
         int fixed_uV;
         u8 update_bank;
         u8 update_reg;
-        u8 mask;
-        u8 enable;
+        u8 update_mask;
+        u8 update_val_enable;
         u8 voltage_bank;
         u8 voltage_reg;
         u8 voltage_mask;
-        int const *supported_voltages;
+        int const *voltages;
         int voltages_len;
 };
 
@@ -83,6 +77,17 @@ static const int ldo_vauxn_voltages[] = {
         3300000,
 };
 
+static const int ldo_vaux3_voltages[] = {
+        1200000,
+        1500000,
+        1800000,
+        2100000,
+        2500000,
+        2750000,
+        2790000,
+        2910000,
+};
+
 static const int ldo_vintcore_voltages[] = {
         1200000,
         1225000,
@@ -95,57 +100,80 @@ static const int ldo_vintcore_voltages[] = {
 
 static int ab8500_regulator_enable(struct regulator_dev *rdev)
 {
-        int regulator_id, ret;
+        int ret;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         ret = abx500_mask_and_set_register_interruptible(info->dev,
-                info->update_bank, info->update_reg, info->mask, info->enable);
+                info->update_bank, info->update_reg,
+                info->update_mask, info->update_val_enable);
         if (ret < 0)
                 dev_err(rdev_get_dev(rdev),
                         "couldn't set enable bits for regulator\n");
+
+        dev_vdbg(rdev_get_dev(rdev),
+                "%s-enable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
+                info->desc.name, info->update_bank, info->update_reg,
+                info->update_mask, info->update_val_enable);
+
         return ret;
 }
 
 static int ab8500_regulator_disable(struct regulator_dev *rdev)
 {
-        int regulator_id, ret;
+        int ret;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         ret = abx500_mask_and_set_register_interruptible(info->dev,
-                info->update_bank, info->update_reg, info->mask, 0x0);
+                info->update_bank, info->update_reg,
+                info->update_mask, 0x0);
         if (ret < 0)
                 dev_err(rdev_get_dev(rdev),
                         "couldn't set disable bits for regulator\n");
+
+        dev_vdbg(rdev_get_dev(rdev),
+                "%s-disable (bank, reg, mask, value): 0x%x, 0x%x, 0x%x, 0x%x\n",
+                info->desc.name, info->update_bank, info->update_reg,
+                info->update_mask, 0x0);
+
         return ret;
 }
 
 static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 {
-        int regulator_id, ret;
+        int ret;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-        u8 value;
+        u8 regval;
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         ret = abx500_get_register_interruptible(info->dev,
-                info->update_bank, info->update_reg, &value);
+                info->update_bank, info->update_reg, &regval);
         if (ret < 0) {
                 dev_err(rdev_get_dev(rdev),
                         "couldn't read 0x%x register\n", info->update_reg);
                 return ret;
         }
 
-        if (value & info->mask)
+        dev_vdbg(rdev_get_dev(rdev),
+                "%s-is_enabled (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
+                " 0x%x\n",
+                info->desc.name, info->update_bank, info->update_reg,
+                info->update_mask, regval);
+
+        if (regval & info->update_mask)
                 return true;
         else
                 return false;
@@ -153,12 +181,12 @@ static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
 
 static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
 {
-        int regulator_id;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         /* return the uV for the fixed regulators */
         if (info->fixed_uV)
@@ -167,33 +195,40 @@ static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
         if (selector >= info->voltages_len)
                 return -EINVAL;
 
-        return info->supported_voltages[selector];
+        return info->voltages[selector];
 }
 
 static int ab8500_regulator_get_voltage(struct regulator_dev *rdev)
 {
-        int regulator_id, ret;
+        int ret, val;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-        u8 value;
+        u8 regval;
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
-        ret = abx500_get_register_interruptible(info->dev, info->voltage_bank,
-                info->voltage_reg, &value);
+        ret = abx500_get_register_interruptible(info->dev,
+                        info->voltage_bank, info->voltage_reg, &regval);
         if (ret < 0) {
                 dev_err(rdev_get_dev(rdev),
                         "couldn't read voltage reg for regulator\n");
                 return ret;
         }
 
+        dev_vdbg(rdev_get_dev(rdev),
+                "%s-get_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
+                " 0x%x\n",
+                info->desc.name, info->voltage_bank, info->voltage_reg,
+                info->voltage_mask, regval);
+
         /* vintcore has a different layout */
-        value &= info->voltage_mask;
-        if (regulator_id == AB8500_LDO_INTCORE)
-                ret = info->supported_voltages[value >> 0x3];
+        val = regval & info->voltage_mask;
+        if (info->desc.id == AB8500_LDO_INTCORE)
+                ret = info->voltages[val >> 0x3];
         else
-                ret = info->supported_voltages[value];
+                ret = info->voltages[val];
 
         return ret;
 }
@@ -206,8 +241,8 @@ static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
 
         /* check the supported voltage */
         for (i = 0; i < info->voltages_len; i++) {
-                if ((info->supported_voltages[i] >= min_uV) &&
-                    (info->supported_voltages[i] <= max_uV))
+                if ((info->voltages[i] >= min_uV) &&
+                    (info->voltages[i] <= max_uV))
                         return i;
         }
 
@@ -215,14 +250,17 @@ static int ab8500_get_best_voltage_index(struct regulator_dev *rdev,
 }
 
 static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
-                int min_uV, int max_uV)
+                                        int min_uV, int max_uV,
+                                        unsigned *selector)
 {
-        int regulator_id, ret;
+        int ret;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
+        u8 regval;
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         /* get the appropriate voltages within the range */
         ret = ab8500_get_best_voltage_index(rdev, min_uV, max_uV);
@@ -232,14 +270,23 @@ static int ab8500_regulator_set_voltage(struct regulator_dev *rdev,
                 return ret;
         }
 
+        *selector = ret;
+
         /* set the registers for the request */
+        regval = (u8)ret;
         ret = abx500_mask_and_set_register_interruptible(info->dev,
-                info->voltage_bank, info->voltage_reg,
-                info->voltage_mask, (u8)ret);
+                        info->voltage_bank, info->voltage_reg,
+                        info->voltage_mask, regval);
         if (ret < 0)
                 dev_err(rdev_get_dev(rdev),
                 "couldn't set voltage reg for regulator\n");
 
+        dev_vdbg(rdev_get_dev(rdev),
+                "%s-set_voltage (bank, reg, mask, value): 0x%x, 0x%x, 0x%x,"
+                " 0x%x\n",
+                info->desc.name, info->voltage_bank, info->voltage_reg,
+                info->voltage_mask, regval);
+
         return ret;
 }
 
@@ -254,17 +301,17 @@ static struct regulator_ops ab8500_regulator_ops = {
 
 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 {
-        int regulator_id;
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
 
-        regulator_id = rdev_get_id(rdev);
-        if (regulator_id >= AB8500_NUM_REGULATORS)
+        if (info == NULL) {
+                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
                 return -EINVAL;
+        }
 
         return info->fixed_uV;
 }
 
-static struct regulator_ops ab8500_ldo_fixed_ops = {
+static struct regulator_ops ab8500_regulator_fixed_ops = {
         .enable         = ab8500_regulator_enable,
         .disable        = ab8500_regulator_disable,
         .is_enabled     = ab8500_regulator_is_enabled,
@@ -272,88 +319,197 @@ static struct regulator_ops ab8500_ldo_fixed_ops = {
         .list_voltage   = ab8500_list_voltage,
 };
 
-#define AB8500_LDO(_id, min, max, bank, reg, reg_mask,          \
-                reg_enable, volt_bank, volt_reg, volt_mask,     \
-                voltages, len_volts)                            \
-{                                                               \
-        .desc   = {                                             \
-                .name   = "LDO-" #_id,                          \
-                .ops    = &ab8500_regulator_ops,                \
-                .type   = REGULATOR_VOLTAGE,                    \
-                .id     = AB8500_LDO_##_id,                     \
-                .owner  = THIS_MODULE,                          \
-        },                                                      \
-        .min_uV         = (min) * 1000,                         \
-        .max_uV         = (max) * 1000,                         \
-        .update_bank    = bank,                                 \
-        .update_reg     = reg,                                  \
-        .mask           = reg_mask,                             \
-        .enable         = reg_enable,                           \
-        .voltage_bank   = volt_bank,                            \
-        .voltage_reg    = volt_reg,                             \
-        .voltage_mask   = volt_mask,                            \
-        .supported_voltages = voltages,                         \
-        .voltages_len   = len_volts,                            \
-        .fixed_uV       = 0,                                    \
-}
-
-#define AB8500_FIXED_LDO(_id, fixed, bank, reg,         \
-                        reg_mask, reg_enable)           \
-{                                                       \
-        .desc   = {                                     \
-                .name   = "LDO-" #_id,                  \
-                .ops    = &ab8500_ldo_fixed_ops,        \
-                .type   = REGULATOR_VOLTAGE,            \
-                .id     = AB8500_LDO_##_id,             \
-                .owner  = THIS_MODULE,                  \
-        },                                              \
-        .fixed_uV       = fixed * 1000,                 \
-        .update_bank    = bank,                         \
-        .update_reg     = reg,                          \
-        .mask           = reg_mask,                     \
-        .enable         = reg_enable,                   \
-}
-
-static struct ab8500_regulator_info ab8500_regulator_info[] = {
+static struct ab8500_regulator_info
+                ab8500_regulator_info[AB8500_NUM_REGULATORS] = {
         /*
-         * Variable Voltage LDOs
-         * name, min uV, max uV, ctrl bank, ctrl reg, reg mask, enable mask,
-         *      volt ctrl bank, volt ctrl reg, volt ctrl mask, volt table,
-         *      num supported volts
+         * Variable Voltage Regulators
+         *   name, min mV, max mV,
+         *   update bank, reg, mask, enable val
+         *   volt bank, reg, mask, table, table length
          */
-        AB8500_LDO(AUX1, 1100, 3300, 0x04, 0x09, 0x3, 0x1, 0x04, 0x1f, 0xf,
-                        ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
-        AB8500_LDO(AUX2, 1100, 3300, 0x04, 0x09, 0xc, 0x4, 0x04, 0x20, 0xf,
-                        ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
-        AB8500_LDO(AUX3, 1100, 3300, 0x04, 0x0a, 0x3, 0x1, 0x04, 0x21, 0xf,
-                        ldo_vauxn_voltages, ARRAY_SIZE(ldo_vauxn_voltages)),
-        AB8500_LDO(INTCORE, 1100, 3300, 0x03, 0x80, 0x4, 0x4, 0x03, 0x80, 0x38,
-                ldo_vintcore_voltages, ARRAY_SIZE(ldo_vintcore_voltages)),
+        [AB8500_LDO_AUX1] = {
+                .desc = {
+                        .name           = "LDO-AUX1",
+                        .ops            = &ab8500_regulator_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_AUX1,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                },
+                .min_uV                 = 1100000,
+                .max_uV                 = 3300000,
+                .update_bank            = 0x04,
+                .update_reg             = 0x09,
+                .update_mask            = 0x03,
+                .update_val_enable      = 0x01,
+                .voltage_bank           = 0x04,
+                .voltage_reg            = 0x1f,
+                .voltage_mask           = 0x0f,
+                .voltages               = ldo_vauxn_voltages,
+                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
+        },
+        [AB8500_LDO_AUX2] = {
+                .desc = {
+                        .name           = "LDO-AUX2",
+                        .ops            = &ab8500_regulator_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_AUX2,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                },
+                .min_uV                 = 1100000,
+                .max_uV                 = 3300000,
+                .update_bank            = 0x04,
+                .update_reg             = 0x09,
+                .update_mask            = 0x0c,
+                .update_val_enable      = 0x04,
+                .voltage_bank           = 0x04,
+                .voltage_reg            = 0x20,
+                .voltage_mask           = 0x0f,
+                .voltages               = ldo_vauxn_voltages,
+                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
+        },
+        [AB8500_LDO_AUX3] = {
+                .desc = {
+                        .name           = "LDO-AUX3",
+                        .ops            = &ab8500_regulator_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_AUX3,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
+                },
+                .min_uV                 = 1100000,
+                .max_uV                 = 3300000,
+                .update_bank            = 0x04,
+                .update_reg             = 0x0a,
+                .update_mask            = 0x03,
+                .update_val_enable      = 0x01,
+                .voltage_bank           = 0x04,
+                .voltage_reg            = 0x21,
+                .voltage_mask           = 0x07,
+                .voltages               = ldo_vaux3_voltages,
+                .voltages_len           = ARRAY_SIZE(ldo_vaux3_voltages),
+        },
+        [AB8500_LDO_INTCORE] = {
+                .desc = {
+                        .name           = "LDO-INTCORE",
+                        .ops            = &ab8500_regulator_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_INTCORE,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
+                },
+                .min_uV                 = 1100000,
+                .max_uV                 = 3300000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x80,
+                .update_mask            = 0x44,
+                .update_val_enable      = 0x04,
+                .voltage_bank           = 0x03,
+                .voltage_reg            = 0x80,
+                .voltage_mask           = 0x38,
+                .voltages               = ldo_vintcore_voltages,
+                .voltages_len           = ARRAY_SIZE(ldo_vintcore_voltages),
+        },
 
         /*
-         * Fixed Voltage LDOs
-         *               name,  o/p uV, ctrl bank, ctrl reg, enable, disable
+         * Fixed Voltage Regulators
+         *   name, fixed mV,
+         *   update bank, reg, mask, enable val
          */
-        AB8500_FIXED_LDO(TVOUT,   2000, 0x03,      0x80,     0x2,    0x2),
-        AB8500_FIXED_LDO(AUDIO,   2000, 0x03,      0x83,     0x2,    0x2),
-        AB8500_FIXED_LDO(ANAMIC1, 2050, 0x03,      0x83,     0x4,    0x4),
-        AB8500_FIXED_LDO(ANAMIC2, 2050, 0x03,      0x83,     0x8,    0x8),
-        AB8500_FIXED_LDO(DMIC,    1800, 0x03,      0x83,     0x10,   0x10),
-        AB8500_FIXED_LDO(ANA,     1200, 0x03,      0x83,     0xc,    0x4),
-};
+        [AB8500_LDO_TVOUT] = {
+                .desc = {
+                        .name           = "LDO-TVOUT",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_TVOUT,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 2000000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x80,
+                .update_mask            = 0x82,
+                .update_val_enable      = 0x02,
+        },
+        [AB8500_LDO_AUDIO] = {
+                .desc = {
+                        .name           = "LDO-AUDIO",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_AUDIO,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 2000000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x83,
+                .update_mask            = 0x02,
+                .update_val_enable      = 0x02,
+        },
+        [AB8500_LDO_ANAMIC1] = {
+                .desc = {
+                        .name           = "LDO-ANAMIC1",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_ANAMIC1,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 2050000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x83,
+                .update_mask            = 0x08,
+                .update_val_enable      = 0x08,
+        },
+        [AB8500_LDO_ANAMIC2] = {
+                .desc = {
+                        .name           = "LDO-ANAMIC2",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_ANAMIC2,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 2050000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x83,
+                .update_mask            = 0x10,
+                .update_val_enable      = 0x10,
+        },
+        [AB8500_LDO_DMIC] = {
+                .desc = {
+                        .name           = "LDO-DMIC",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_DMIC,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 1800000,
+                .update_bank            = 0x03,
+                .update_reg             = 0x83,
+                .update_mask            = 0x04,
+                .update_val_enable      = 0x04,
+        },
+        [AB8500_LDO_ANA] = {
+                .desc = {
+                        .name           = "LDO-ANA",
+                        .ops            = &ab8500_regulator_fixed_ops,
+                        .type           = REGULATOR_VOLTAGE,
+                        .id             = AB8500_LDO_ANA,
+                        .owner          = THIS_MODULE,
+                        .n_voltages     = 1,
+                },
+                .fixed_uV               = 1200000,
+                .update_bank            = 0x04,
+                .update_reg             = 0x06,
+                .update_mask            = 0x0c,
+                .update_val_enable      = 0x04,
+        },
 
-static inline struct ab8500_regulator_info *find_regulator_info(int id)
-{
-        struct ab8500_regulator_info *info;
-        int i;
 
-        for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
-                info = &ab8500_regulator_info[i];
-                if (info->desc.id == id)
-                        return info;
-        }
-        return NULL;
-}
+};
 
 static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
 {
@@ -366,6 +522,16 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
                 return -EINVAL;
         }
         pdata = dev_get_platdata(ab8500->dev);
+        if (!pdata) {
+                dev_err(&pdev->dev, "null pdata\n");
+                return -EINVAL;
+        }
+
+        /* make sure the platform data has the correct size */
+        if (pdata->num_regulator != ARRAY_SIZE(ab8500_regulator_info)) {
+                dev_err(&pdev->dev, "platform configuration error\n");
+                return -EINVAL;
+        }
 
         /* register all regulators */
         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
@@ -374,10 +540,22 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
                 /* assign per-regulator data */
                 info = &ab8500_regulator_info[i];
                 info->dev = &pdev->dev;
-                info->ab8500 = ab8500;
 
+                /* fix for hardware before ab8500v2.0 */
+                if (abx500_get_chip_id(info->dev) < 0x20) {
+                        if (info->desc.id == AB8500_LDO_AUX3) {
+                                info->desc.n_voltages =
+                                        ARRAY_SIZE(ldo_vauxn_voltages);
+                                info->voltages = ldo_vauxn_voltages;
+                                info->voltages_len =
+                                        ARRAY_SIZE(ldo_vauxn_voltages);
+                                info->voltage_mask = 0xf;
+                        }
+                }
+
+                /* register regulator with framework */
                 info->regulator = regulator_register(&info->desc, &pdev->dev,
-                                pdata->regulator[i], info);
+                                &pdata->regulator[i], info);
                 if (IS_ERR(info->regulator)) {
                         err = PTR_ERR(info->regulator);
                         dev_err(&pdev->dev, "failed to register regulator %s\n",
@@ -389,6 +567,9 @@ static __devinit int ab8500_regulator_probe(struct platform_device *pdev)
                         }
                         return err;
                 }
+
+                dev_vdbg(rdev_get_dev(info->regulator),
+                        "%s-probed\n", info->desc.name);
         }
 
         return 0;
@@ -401,6 +582,10 @@ static __devexit int ab8500_regulator_remove(struct platform_device *pdev)
         for (i = 0; i < ARRAY_SIZE(ab8500_regulator_info); i++) {
                 struct ab8500_regulator_info *info = NULL;
                 info = &ab8500_regulator_info[i];
+
+                dev_vdbg(rdev_get_dev(info->regulator),
+                        "%s-remove\n", info->desc.name);
+
                 regulator_unregister(info->regulator);
         }
 
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index ba521f0f0fa..9fa20957847 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -13,8 +13,11 @@
  *
  */
 
+#define pr_fmt(fmt) "%s: " fmt, __func__
+
 #include <linux/kernel.h>
 #include <linux/init.h>
+#include <linux/debugfs.h>
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/err.h>
@@ -25,16 +28,30 @@
 #include <linux/regulator/driver.h>
 #include <linux/regulator/machine.h>
 
+#define CREATE_TRACE_POINTS
+#include <trace/events/regulator.h>
+
 #include "dummy.h"
 
-#define REGULATOR_VERSION "0.5"
+#define rdev_err(rdev, fmt, ...)                                        \
+        pr_err("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
+#define rdev_warn(rdev, fmt, ...)                                       \
+        pr_warn("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
+#define rdev_info(rdev, fmt, ...)                                       \
+        pr_info("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
+#define rdev_dbg(rdev, fmt, ...)                                        \
+        pr_debug("%s: " fmt, rdev_get_name(rdev), ##__VA_ARGS__)
 
 static DEFINE_MUTEX(regulator_list_mutex);
 static LIST_HEAD(regulator_list);
 static LIST_HEAD(regulator_map_list);
-static int has_full_constraints;
+static bool has_full_constraints;
 static bool board_wants_dummy_regulator;
 
+#ifdef CONFIG_DEBUG_FS
+static struct dentry *debugfs_root;
+#endif
+
 /*
  * struct regulator_map
  *
@@ -71,6 +88,8 @@ static int _regulator_get_current_limit(struct regulator_dev *rdev);
 static unsigned int _regulator_get_mode(struct regulator_dev *rdev);
 static void _notifier_call_chain(struct regulator_dev *rdev,
                                   unsigned long event, void *data);
+static int _regulator_do_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV);
 
 static const char *rdev_get_name(struct regulator_dev *rdev)
 {
@@ -111,13 +130,11 @@ static int regulator_check_voltage(struct regulator_dev *rdev,
         BUG_ON(*min_uV > *max_uV);
 
         if (!rdev->constraints) {
-                printk(KERN_ERR "%s: no constraints for %s\n", __func__,
-                       rdev_get_name(rdev));
+                rdev_err(rdev, "no constraints\n");
                 return -ENODEV;
         }
         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_VOLTAGE)) {
-                printk(KERN_ERR "%s: operation not allowed for %s\n",
-                       __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "operation not allowed\n");
                 return -EPERM;
         }
 
@@ -132,6 +149,27 @@ static int regulator_check_voltage(struct regulator_dev *rdev,
         return 0;
 }
 
+/* Make sure we select a voltage that suits the needs of all
+ * regulator consumers
+ */
+static int regulator_check_consumers(struct regulator_dev *rdev,
+                                     int *min_uV, int *max_uV)
+{
+        struct regulator *regulator;
+
+        list_for_each_entry(regulator, &rdev->consumer_list, list) {
+                if (*max_uV > regulator->max_uV)
+                        *max_uV = regulator->max_uV;
+                if (*min_uV < regulator->min_uV)
+                        *min_uV = regulator->min_uV;
+        }
+
+        if (*min_uV > *max_uV)
+                return -EINVAL;
+
+        return 0;
+}
+
 /* current constraint check */
 static int regulator_check_current_limit(struct regulator_dev *rdev,
                                         int *min_uA, int *max_uA)
@@ -139,13 +177,11 @@ static int regulator_check_current_limit(struct regulator_dev *rdev,
         BUG_ON(*min_uA > *max_uA);
 
         if (!rdev->constraints) {
-                printk(KERN_ERR "%s: no constraints for %s\n", __func__,
-                       rdev_get_name(rdev));
+                rdev_err(rdev, "no constraints\n");
                 return -ENODEV;
         }
         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_CURRENT)) {
-                printk(KERN_ERR "%s: operation not allowed for %s\n",
-                       __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "operation not allowed\n");
                 return -EPERM;
         }
 
@@ -174,18 +210,15 @@ static int regulator_check_mode(struct regulator_dev *rdev, int mode)
         }
 
         if (!rdev->constraints) {
-                printk(KERN_ERR "%s: no constraints for %s\n", __func__,
-                       rdev_get_name(rdev));
+                rdev_err(rdev, "no constraints\n");
                 return -ENODEV;
         }
         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_MODE)) {
-                printk(KERN_ERR "%s: operation not allowed for %s\n",
-                       __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "operation not allowed\n");
                 return -EPERM;
         }
         if (!(rdev->constraints->valid_modes_mask & mode)) {
-                printk(KERN_ERR "%s: invalid mode %x for %s\n",
-                       __func__, mode, rdev_get_name(rdev));
+                rdev_err(rdev, "invalid mode %x\n", mode);
                 return -EINVAL;
         }
         return 0;
@@ -195,13 +228,11 @@ static int regulator_check_mode(struct regulator_dev *rdev, int mode)
 static int regulator_check_drms(struct regulator_dev *rdev)
 {
         if (!rdev->constraints) {
-                printk(KERN_ERR "%s: no constraints for %s\n", __func__,
-                       rdev_get_name(rdev));
+                rdev_err(rdev, "no constraints\n");
                 return -ENODEV;
         }
         if (!(rdev->constraints->valid_ops_mask & REGULATOR_CHANGE_DRMS)) {
-                printk(KERN_ERR "%s: operation not allowed for %s\n",
-                       __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "operation not allowed\n");
                 return -EPERM;
         }
         return 0;
@@ -553,18 +584,21 @@ static void drms_uA_update(struct regulator_dev *rdev)
 
         err = regulator_check_drms(rdev);
         if (err < 0 || !rdev->desc->ops->get_optimum_mode ||
-            !rdev->desc->ops->get_voltage || !rdev->desc->ops->set_mode)
+            (!rdev->desc->ops->get_voltage &&
+             !rdev->desc->ops->get_voltage_sel) ||
+            !rdev->desc->ops->set_mode)
                 return;
 
         /* get output voltage */
-        output_uV = rdev->desc->ops->get_voltage(rdev);
+        output_uV = _regulator_get_voltage(rdev);
         if (output_uV <= 0)
                 return;
 
         /* get input voltage */
-        if (rdev->supply && rdev->supply->desc->ops->get_voltage)
-                input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
-        else
+        input_uV = 0;
+        if (rdev->supply)
+                input_uV = _regulator_get_voltage(rdev);
+        if (input_uV <= 0)
                 input_uV = rdev->constraints->input_uV;
         if (input_uV <= 0)
                 return;
@@ -598,20 +632,17 @@ static int suspend_set_state(struct regulator_dev *rdev,
          */
         if (!rstate->enabled && !rstate->disabled) {
                 if (can_set_state)
-                        printk(KERN_WARNING "%s: No configuration for %s\n",
-                               __func__, rdev_get_name(rdev));
+                        rdev_warn(rdev, "No configuration\n");
                 return 0;
         }
 
         if (rstate->enabled && rstate->disabled) {
-                printk(KERN_ERR "%s: invalid configuration for %s\n",
-                       __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "invalid configuration\n");
                 return -EINVAL;
         }
 
         if (!can_set_state) {
-                printk(KERN_ERR "%s: no way to set suspend state\n",
-                        __func__);
+                rdev_err(rdev, "no way to set suspend state\n");
                 return -EINVAL;
         }
 
@@ -620,15 +651,14 @@ static int suspend_set_state(struct regulator_dev *rdev,
         else
                 ret = rdev->desc->ops->set_suspend_disable(rdev);
         if (ret < 0) {
-                printk(KERN_ERR "%s: failed to enabled/disable\n", __func__);
+                rdev_err(rdev, "failed to enabled/disable\n");
                 return ret;
         }
 
         if (rdev->desc->ops->set_suspend_voltage && rstate->uV > 0) {
                 ret = rdev->desc->ops->set_suspend_voltage(rdev, rstate->uV);
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to set voltage\n",
-                                __func__);
+                        rdev_err(rdev, "failed to set voltage\n");
                         return ret;
                 }
         }
@@ -636,7 +666,7 @@ static int suspend_set_state(struct regulator_dev *rdev,
         if (rdev->desc->ops->set_suspend_mode && rstate->mode > 0) {
                 ret = rdev->desc->ops->set_suspend_mode(rdev, rstate->mode);
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to set mode\n", __func__);
+                        rdev_err(rdev, "failed to set mode\n");
                         return ret;
                 }
         }
@@ -714,29 +744,27 @@ static void print_constraints(struct regulator_dev *rdev)
         if (constraints->valid_modes_mask & REGULATOR_MODE_STANDBY)
                 count += sprintf(buf + count, "standby");
 
-        printk(KERN_INFO "regulator: %s: %s\n", rdev_get_name(rdev), buf);
+        rdev_info(rdev, "%s\n", buf);
 }
 
 static int machine_constraints_voltage(struct regulator_dev *rdev,
         struct regulation_constraints *constraints)
 {
         struct regulator_ops *ops = rdev->desc->ops;
-        const char *name = rdev_get_name(rdev);
         int ret;
 
         /* do we need to apply the constraint voltage */
         if (rdev->constraints->apply_uV &&
-                rdev->constraints->min_uV == rdev->constraints->max_uV &&
-                ops->set_voltage) {
-                ret = ops->set_voltage(rdev,
-                        rdev->constraints->min_uV, rdev->constraints->max_uV);
-                        if (ret < 0) {
-                                printk(KERN_ERR "%s: failed to apply %duV constraint to %s\n",
-                                       __func__,
-                                       rdev->constraints->min_uV, name);
-                                rdev->constraints = NULL;
-                                return ret;
-                        }
+            rdev->constraints->min_uV == rdev->constraints->max_uV) {
+                ret = _regulator_do_set_voltage(rdev,
+                                                rdev->constraints->min_uV,
+                                                rdev->constraints->max_uV);
+                if (ret < 0) {
+                        rdev_err(rdev, "failed to apply %duV constraint\n",
+                                 rdev->constraints->min_uV);
+                        rdev->constraints = NULL;
+                        return ret;
+                }
         }
 
         /* constrain machine-level voltage specs to fit
@@ -765,8 +793,7 @@ static int machine_constraints_voltage(struct regulator_dev *rdev,
 
                 /* else require explicit machine-level constraints */
                 if (cmin <= 0 || cmax <= 0 || cmax < cmin) {
-                        pr_err("%s: %s '%s' voltage constraints\n",
-                                       __func__, "invalid", name);
+                        rdev_err(rdev, "invalid voltage constraints\n");
                         return -EINVAL;
                 }
 
@@ -787,22 +814,19 @@ static int machine_constraints_voltage(struct regulator_dev *rdev,
 
                 /* final: [min_uV..max_uV] valid iff constraints valid */
                 if (max_uV < min_uV) {
-                        pr_err("%s: %s '%s' voltage constraints\n",
-                                       __func__, "unsupportable", name);
+                        rdev_err(rdev, "unsupportable voltage constraints\n");
                         return -EINVAL;
                 }
 
                 /* use regulator's subset of machine constraints */
                 if (constraints->min_uV < min_uV) {
-                        pr_debug("%s: override '%s' %s, %d -> %d\n",
-                                       __func__, name, "min_uV",
-                                        constraints->min_uV, min_uV);
+                        rdev_dbg(rdev, "override min_uV, %d -> %d\n",
+                                 constraints->min_uV, min_uV);
                         constraints->min_uV = min_uV;
                 }
                 if (constraints->max_uV > max_uV) {
-                        pr_debug("%s: override '%s' %s, %d -> %d\n",
-                                       __func__, name, "max_uV",
-                                        constraints->max_uV, max_uV);
+                        rdev_dbg(rdev, "override max_uV, %d -> %d\n",
+                                 constraints->max_uV, max_uV);
                         constraints->max_uV = max_uV;
                 }
         }
@@ -822,26 +846,25 @@ static int machine_constraints_voltage(struct regulator_dev *rdev,
  * set_mode.
  */
 static int set_machine_constraints(struct regulator_dev *rdev,
-        struct regulation_constraints *constraints)
+        const struct regulation_constraints *constraints)
 {
         int ret = 0;
-        const char *name;
         struct regulator_ops *ops = rdev->desc->ops;
 
-        rdev->constraints = constraints;
-
-        name = rdev_get_name(rdev);
+        rdev->constraints = kmemdup(constraints, sizeof(*constraints),
+                                    GFP_KERNEL);
+        if (!rdev->constraints)
+                return -ENOMEM;
 
-        ret = machine_constraints_voltage(rdev, constraints);
+        ret = machine_constraints_voltage(rdev, rdev->constraints);
         if (ret != 0)
                 goto out;
 
         /* do we need to setup our suspend state */
         if (constraints->initial_state) {
-                ret = suspend_prepare(rdev, constraints->initial_state);
+                ret = suspend_prepare(rdev, rdev->constraints->initial_state);
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to set suspend state for %s\n",
-                               __func__, name);
+                        rdev_err(rdev, "failed to set suspend state\n");
                         rdev->constraints = NULL;
                         goto out;
                 }
@@ -849,17 +872,14 @@ static int set_machine_constraints(struct regulator_dev *rdev,
 
         if (constraints->initial_mode) {
                 if (!ops->set_mode) {
-                        printk(KERN_ERR "%s: no set_mode operation for %s\n",
-                               __func__, name);
+                        rdev_err(rdev, "no set_mode operation\n");
                         ret = -EINVAL;
                         goto out;
                 }
 
-                ret = ops->set_mode(rdev, constraints->initial_mode);
+                ret = ops->set_mode(rdev, rdev->constraints->initial_mode);
                 if (ret < 0) {
-                        printk(KERN_ERR
-                               "%s: failed to set initial mode for %s: %d\n",
-                               __func__, name, ret);
+                        rdev_err(rdev, "failed to set initial mode: %d\n", ret);
                         goto out;
                 }
         }
@@ -867,11 +887,11 @@ static int set_machine_constraints(struct regulator_dev *rdev,
         /* If the constraints say the regulator should be on at this point
          * and we have control then make sure it is enabled.
          */
-        if ((constraints->always_on || constraints->boot_on) && ops->enable) {
+        if ((rdev->constraints->always_on || rdev->constraints->boot_on) &&
+            ops->enable) {
                 ret = ops->enable(rdev);
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to enable %s\n",
-                               __func__, name);
+                        rdev_err(rdev, "failed to enable\n");
                         rdev->constraints = NULL;
                         goto out;
                 }
@@ -899,9 +919,8 @@ static int set_supply(struct regulator_dev *rdev,
         err = sysfs_create_link(&rdev->dev.kobj, &supply_rdev->dev.kobj,
                                 "supply");
         if (err) {
-                printk(KERN_ERR
-                       "%s: could not add device link %s err %d\n",
-                       __func__, supply_rdev->dev.kobj.name, err);
+                rdev_err(rdev, "could not add device link %s err %d\n",
+                         supply_rdev->dev.kobj.name, err);
                        goto out;
         }
         rdev->supply = supply_rdev;
@@ -957,10 +976,10 @@ static int set_consumer_device_supply(struct regulator_dev *rdev,
                         continue;
 
                 dev_dbg(consumer_dev, "%s/%s is '%s' supply; fail %s/%s\n",
-                                dev_name(&node->regulator->dev),
-                                node->regulator->desc->name,
-                                supply,
-                                dev_name(&rdev->dev), rdev_get_name(rdev));
+                        dev_name(&node->regulator->dev),
+                        node->regulator->desc->name,
+                        supply,
+                        dev_name(&rdev->dev), rdev_get_name(rdev));
                 return -EBUSY;
         }
 
@@ -1031,8 +1050,7 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
                 regulator->dev_attr.show = device_requested_uA_show;
                 err = device_create_file(dev, &regulator->dev_attr);
                 if (err < 0) {
-                        printk(KERN_WARNING "%s: could not add regulator_dev"
-                                " load sysfs\n", __func__);
+                        rdev_warn(rdev, "could not add regulator_dev requested microamps sysfs entry\n");
                         goto attr_name_err;
                 }
 
@@ -1049,9 +1067,8 @@ static struct regulator *create_regulator(struct regulator_dev *rdev,
                 err = sysfs_create_link(&rdev->dev.kobj, &dev->kobj,
                                         buf);
                 if (err) {
-                        printk(KERN_WARNING
-                               "%s: could not add device link %s err %d\n",
-                               __func__, dev->kobj.name, err);
+                        rdev_warn(rdev, "could not add device link %s err %d\n",
+                                  dev->kobj.name, err);
                         goto link_name_err;
                 }
         }
@@ -1088,7 +1105,7 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
         int ret;
 
         if (id == NULL) {
-                printk(KERN_ERR "regulator: get() with no identifier\n");
+                pr_err("get() with no identifier\n");
                 return regulator;
         }
 
@@ -1122,8 +1139,8 @@ static struct regulator *_regulator_get(struct device *dev, const char *id,
          * substitute in a dummy regulator so consumers can continue.
          */
         if (!has_full_constraints) {
-                pr_warning("%s supply %s not found, using dummy regulator\n",
-                           devname, id);
+                pr_warn("%s supply %s not found, using dummy regulator\n",
+                        devname, id);
                 rdev = dummy_regulator_rdev;
                 goto found;
         }
@@ -1274,8 +1291,7 @@ static int _regulator_enable(struct regulator_dev *rdev)
                         ret = _regulator_enable(rdev->supply);
                         mutex_unlock(&rdev->supply->mutex);
                         if (ret < 0) {
-                                printk(KERN_ERR "%s: failed to enable %s: %d\n",
-                                       __func__, rdev_get_name(rdev), ret);
+                                rdev_err(rdev, "failed to enable: %d\n", ret);
                                 return ret;
                         }
                 }
@@ -1302,13 +1318,13 @@ static int _regulator_enable(struct regulator_dev *rdev)
                         if (ret >= 0) {
                                 delay = ret;
                         } else {
-                                printk(KERN_WARNING
-                                        "%s: enable_time() failed for %s: %d\n",
-                                        __func__, rdev_get_name(rdev),
-                                        ret);
+                                rdev_warn(rdev, "enable_time() failed: %d\n",
+                                           ret);
                                 delay = 0;
                         }
 
+                        trace_regulator_enable(rdev_get_name(rdev));
+
                         /* Allow the regulator to ramp; it would be useful
                          * to extend this for bulk operations so that the
                          * regulators can ramp together.  */
@@ -1316,6 +1332,8 @@ static int _regulator_enable(struct regulator_dev *rdev)
                         if (ret < 0)
                                 return ret;
 
+                        trace_regulator_enable_delay(rdev_get_name(rdev));
+
                         if (delay >= 1000) {
                                 mdelay(delay / 1000);
                                 udelay(delay % 1000);
@@ -1323,9 +1341,10 @@ static int _regulator_enable(struct regulator_dev *rdev)
                                 udelay(delay);
                         }
 
+                        trace_regulator_enable_complete(rdev_get_name(rdev));
+
                 } else if (ret < 0) {
-                        printk(KERN_ERR "%s: is_enabled() failed for %s: %d\n",
-                               __func__, rdev_get_name(rdev), ret);
+                        rdev_err(rdev, "is_enabled() failed: %d\n", ret);
                         return ret;
                 }
                 /* Fallthrough on positive return values - already enabled */
@@ -1367,8 +1386,7 @@ static int _regulator_disable(struct regulator_dev *rdev,
         *supply_rdev_ptr = NULL;
 
         if (WARN(rdev->use_count <= 0,
-                        "unbalanced disables for %s\n",
-                        rdev_get_name(rdev)))
+                 "unbalanced disables for %s\n", rdev_get_name(rdev)))
                 return -EIO;
 
         /* are we the last user and permitted to disable ? */
@@ -1378,13 +1396,16 @@ static int _regulator_disable(struct regulator_dev *rdev,
                 /* we are last user */
                 if (_regulator_can_change_status(rdev) &&
                     rdev->desc->ops->disable) {
+                        trace_regulator_disable(rdev_get_name(rdev));
+
                         ret = rdev->desc->ops->disable(rdev);
                         if (ret < 0) {
-                                printk(KERN_ERR "%s: failed to disable %s\n",
-                                       __func__, rdev_get_name(rdev));
+                                rdev_err(rdev, "failed to disable\n");
                                 return ret;
                         }
 
+                        trace_regulator_disable_complete(rdev_get_name(rdev));
+
                         _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
                                              NULL);
                 }
@@ -1451,8 +1472,7 @@ static int _regulator_force_disable(struct regulator_dev *rdev,
                 /* ah well, who wants to live forever... */
                 ret = rdev->desc->ops->disable(rdev);
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to force disable %s\n",
-                               __func__, rdev_get_name(rdev));
+                        rdev_err(rdev, "failed to force disable\n");
                         return ret;
                 }
                 /* notify other consumers that power has been forced off */
@@ -1605,6 +1625,62 @@ int regulator_is_supported_voltage(struct regulator *regulator,
         return 0;
 }
 
+static int _regulator_do_set_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
+{
+        int ret;
+        unsigned int selector;
+
+        trace_regulator_set_voltage(rdev_get_name(rdev), min_uV, max_uV);
+
+        if (rdev->desc->ops->set_voltage) {
+                ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV,
+                                                   &selector);
+
+                if (rdev->desc->ops->list_voltage)
+                        selector = rdev->desc->ops->list_voltage(rdev,
+                                                                 selector);
+                else
+                        selector = -1;
+        } else if (rdev->desc->ops->set_voltage_sel) {
+                int best_val = INT_MAX;
+                int i;
+
+                selector = 0;
+
+                /* Find the smallest voltage that falls within the specified
+                 * range.
+                 */
+                for (i = 0; i < rdev->desc->n_voltages; i++) {
+                        ret = rdev->desc->ops->list_voltage(rdev, i);
+                        if (ret < 0)
+                                continue;
+
+                        if (ret < best_val && ret >= min_uV && ret <= max_uV) {
+                                best_val = ret;
+                                selector = i;
+                        }
+                }
+
+                if (best_val != INT_MAX) {
+                        ret = rdev->desc->ops->set_voltage_sel(rdev, selector);
+                        selector = best_val;
+                } else {
+                        ret = -EINVAL;
+                }
+        } else {
+                ret = -EINVAL;
+        }
+
+        if (ret == 0)
+                _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE,
+                                     NULL);
+
+        trace_regulator_set_voltage_complete(rdev_get_name(rdev), selector);
+
+        return ret;
+}
+
 /**
  * regulator_set_voltage - set regulator output voltage
  * @regulator: regulator source
@@ -1626,12 +1702,20 @@ int regulator_is_supported_voltage(struct regulator *regulator,
 int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
 {
         struct regulator_dev *rdev = regulator->rdev;
-        int ret;
+        int ret = 0;
 
         mutex_lock(&rdev->mutex);
 
+        /* If we're setting the same range as last time the change
+         * should be a noop (some cpufreq implementations use the same
+         * voltage for multiple frequencies, for example).
+         */
+        if (regulator->min_uV == min_uV && regulator->max_uV == max_uV)
+                goto out;
+
         /* sanity check */
-        if (!rdev->desc->ops->set_voltage) {
+        if (!rdev->desc->ops->set_voltage &&
+            !rdev->desc->ops->set_voltage_sel) {
                 ret = -EINVAL;
                 goto out;
         }
@@ -1642,18 +1726,76 @@ int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV)
                 goto out;
         regulator->min_uV = min_uV;
         regulator->max_uV = max_uV;
-        ret = rdev->desc->ops->set_voltage(rdev, min_uV, max_uV);
+
+        ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
+        if (ret < 0)
+                goto out;
+
+        ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
 
 out:
-        _notifier_call_chain(rdev, REGULATOR_EVENT_VOLTAGE_CHANGE, NULL);
         mutex_unlock(&rdev->mutex);
         return ret;
 }
 EXPORT_SYMBOL_GPL(regulator_set_voltage);
 
+/**
+ * regulator_sync_voltage - re-apply last regulator output voltage
+ * @regulator: regulator source
+ *
+ * Re-apply the last configured voltage.  This is intended to be used
+ * where some external control source the consumer is cooperating with
+ * has caused the configured voltage to change.
+ */
+int regulator_sync_voltage(struct regulator *regulator)
+{
+        struct regulator_dev *rdev = regulator->rdev;
+        int ret, min_uV, max_uV;
+
+        mutex_lock(&rdev->mutex);
+
+        if (!rdev->desc->ops->set_voltage &&
+            !rdev->desc->ops->set_voltage_sel) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        /* This is only going to work if we've had a voltage configured. */
+        if (!regulator->min_uV && !regulator->max_uV) {
+                ret = -EINVAL;
+                goto out;
+        }
+
+        min_uV = regulator->min_uV;
+        max_uV = regulator->max_uV;
+
+        /* This should be a paranoia check... */
+        ret = regulator_check_voltage(rdev, &min_uV, &max_uV);
+        if (ret < 0)
+                goto out;
+
+        ret = regulator_check_consumers(rdev, &min_uV, &max_uV);
+        if (ret < 0)
+                goto out;
+
+        ret = _regulator_do_set_voltage(rdev, min_uV, max_uV);
+
+out:
+        mutex_unlock(&rdev->mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(regulator_sync_voltage);
+
 static int _regulator_get_voltage(struct regulator_dev *rdev)
 {
-        /* sanity check */
+        int sel;
+
+        if (rdev->desc->ops->get_voltage_sel) {
+                sel = rdev->desc->ops->get_voltage_sel(rdev);
+                if (sel < 0)
+                        return sel;
+                return rdev->desc->ops->list_voltage(rdev, sel);
+        }
         if (rdev->desc->ops->get_voltage)
                 return rdev->desc->ops->get_voltage(rdev);
         else
@@ -1880,21 +2022,20 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
                 goto out;
 
         /* get output voltage */
-        output_uV = rdev->desc->ops->get_voltage(rdev);
+        output_uV = _regulator_get_voltage(rdev);
         if (output_uV <= 0) {
-                printk(KERN_ERR "%s: invalid output voltage found for %s\n",
-                        __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "invalid output voltage found\n");
                 goto out;
         }
 
         /* get input voltage */
-        if (rdev->supply && rdev->supply->desc->ops->get_voltage)
-                input_uV = rdev->supply->desc->ops->get_voltage(rdev->supply);
-        else
+        input_uV = 0;
+        if (rdev->supply)
+                input_uV = _regulator_get_voltage(rdev->supply);
+        if (input_uV <= 0)
                 input_uV = rdev->constraints->input_uV;
         if (input_uV <= 0) {
-                printk(KERN_ERR "%s: invalid input voltage found for %s\n",
-                        __func__, rdev_get_name(rdev));
+                rdev_err(rdev, "invalid input voltage found\n");
                 goto out;
         }
 
@@ -1907,16 +2048,14 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
                                                  total_uA_load);
         ret = regulator_check_mode(rdev, mode);
         if (ret < 0) {
-                printk(KERN_ERR "%s: failed to get optimum mode for %s @"
-                        " %d uA %d -> %d uV\n", __func__, rdev_get_name(rdev),
-                        total_uA_load, input_uV, output_uV);
+                rdev_err(rdev, "failed to get optimum mode @ %d uA %d -> %d uV\n",
+                         total_uA_load, input_uV, output_uV);
                 goto out;
         }
 
         ret = rdev->desc->ops->set_mode(rdev, mode);
         if (ret < 0) {
-                printk(KERN_ERR "%s: failed to set optimum mode %x for %s\n",
-                        __func__, mode, rdev_get_name(rdev));
+                rdev_err(rdev, "failed to set optimum mode %x\n", mode);
                 goto out;
         }
         ret = mode;
@@ -2047,7 +2186,7 @@ int regulator_bulk_enable(int num_consumers,
         return 0;
 
 err:
-        printk(KERN_ERR "Failed to enable %s: %d\n", consumers[i].supply, ret);
+        pr_err("Failed to enable %s: %d\n", consumers[i].supply, ret);
         for (--i; i >= 0; --i)
                 regulator_disable(consumers[i].consumer);
 
@@ -2082,8 +2221,7 @@ int regulator_bulk_disable(int num_consumers,
         return 0;
 
 err:
-        printk(KERN_ERR "Failed to disable %s: %d\n", consumers[i].supply,
-               ret);
+        pr_err("Failed to disable %s: %d\n", consumers[i].supply, ret);
         for (--i; i >= 0; --i)
                 regulator_enable(consumers[i].consumer);
 
@@ -2166,7 +2304,7 @@ static int add_regulator_attributes(struct regulator_dev *rdev)
         int                     status = 0;
 
         /* some attributes need specific methods to be displayed */
-        if (ops->get_voltage) {
+        if (ops->get_voltage || ops->get_voltage_sel) {
                 status = device_create_file(dev, &dev_attr_microvolts);
                 if (status < 0)
                         return status;
@@ -2207,7 +2345,7 @@ static int add_regulator_attributes(struct regulator_dev *rdev)
                 return status;
 
         /* constraints need specific supporting methods */
-        if (ops->set_voltage) {
+        if (ops->set_voltage || ops->set_voltage_sel) {
                 status = device_create_file(dev, &dev_attr_min_microvolts);
                 if (status < 0)
                         return status;
@@ -2271,6 +2409,23 @@ static int add_regulator_attributes(struct regulator_dev *rdev)
         return status;
 }
 
+static void rdev_init_debugfs(struct regulator_dev *rdev)
+{
+#ifdef CONFIG_DEBUG_FS
+        rdev->debugfs = debugfs_create_dir(rdev_get_name(rdev), debugfs_root);
+        if (IS_ERR(rdev->debugfs) || !rdev->debugfs) {
+                rdev_warn(rdev, "Failed to create debugfs directory\n");
+                rdev->debugfs = NULL;
+                return;
+        }
+
+        debugfs_create_u32("use_count", 0444, rdev->debugfs,
+                           &rdev->use_count);
+        debugfs_create_u32("open_count", 0444, rdev->debugfs,
+                           &rdev->open_count);
+#endif
+}
+
 /**
  * regulator_register - register regulator
  * @regulator_desc: regulator to register
@@ -2282,7 +2437,7 @@ static int add_regulator_attributes(struct regulator_dev *rdev)
  * Returns 0 on success.
  */
 struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
-        struct device *dev, struct regulator_init_data *init_data,
+        struct device *dev, const struct regulator_init_data *init_data,
         void *driver_data)
 {
         static atomic_t regulator_no = ATOMIC_INIT(0);
@@ -2302,6 +2457,22 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
         if (!init_data)
                 return ERR_PTR(-EINVAL);
 
+        /* Only one of each should be implemented */
+        WARN_ON(regulator_desc->ops->get_voltage &&
+                regulator_desc->ops->get_voltage_sel);
+        WARN_ON(regulator_desc->ops->set_voltage &&
+                regulator_desc->ops->set_voltage_sel);
+
+        /* If we're using selectors we must implement list_voltage. */
+        if (regulator_desc->ops->get_voltage_sel &&
+            !regulator_desc->ops->list_voltage) {
+                return ERR_PTR(-EINVAL);
+        }
+        if (regulator_desc->ops->set_voltage_sel &&
+            !regulator_desc->ops->list_voltage) {
+                return ERR_PTR(-EINVAL);
+        }
+
         rdev = kzalloc(sizeof(struct regulator_dev), GFP_KERNEL);
         if (rdev == NULL)
                 return ERR_PTR(-ENOMEM);
@@ -2399,6 +2570,8 @@ struct regulator_dev *regulator_register(struct regulator_desc *regulator_desc,
         }
 
         list_add(&rdev->list, &regulator_list);
+
+        rdev_init_debugfs(rdev);
 out:
         mutex_unlock(&regulator_list_mutex);
         return rdev;
@@ -2431,12 +2604,16 @@ void regulator_unregister(struct regulator_dev *rdev)
                 return;
 
         mutex_lock(&regulator_list_mutex);
+#ifdef CONFIG_DEBUG_FS
+        debugfs_remove_recursive(rdev->debugfs);
+#endif
         WARN_ON(rdev->open_count);
         unset_regulator_supplies(rdev);
         list_del(&rdev->list);
         if (rdev->supply)
                 sysfs_remove_link(&rdev->dev.kobj, "supply");
         device_unregister(&rdev->dev);
+        kfree(rdev->constraints);
         mutex_unlock(&regulator_list_mutex);
 }
 EXPORT_SYMBOL_GPL(regulator_unregister);
@@ -2465,8 +2642,7 @@ int regulator_suspend_prepare(suspend_state_t state)
                 mutex_unlock(&rdev->mutex);
 
                 if (ret < 0) {
-                        printk(KERN_ERR "%s: failed to prepare %s\n",
-                                __func__, rdev_get_name(rdev));
+                        rdev_err(rdev, "failed to prepare\n");
                         goto out;
                 }
         }
@@ -2572,10 +2748,16 @@ static int __init regulator_init(void)
 {
         int ret;
 
-        printk(KERN_INFO "regulator: core version %s\n", REGULATOR_VERSION);
-
         ret = class_register(&regulator_class);
 
+#ifdef CONFIG_DEBUG_FS
+        debugfs_root = debugfs_create_dir("regulator", NULL);
+        if (IS_ERR(debugfs_root) || !debugfs_root) {
+                pr_warn("regulator: Failed to create debugfs directory\n");
+                debugfs_root = NULL;
+        }
+#endif
+
         regulator_dummy_init();
 
         return ret;
@@ -2590,7 +2772,6 @@ static int __init regulator_init_complete(void)
         struct regulator_ops *ops;
         struct regulation_constraints *c;
         int enabled, ret;
-        const char *name;
 
         mutex_lock(&regulator_list_mutex);
 
@@ -2602,8 +2783,6 @@ static int __init regulator_init_complete(void)
                 ops = rdev->desc->ops;
                 c = rdev->constraints;
 
-                name = rdev_get_name(rdev);
-
                 if (!ops->disable || (c && c->always_on))
                         continue;
 
@@ -2624,13 +2803,10 @@ static int __init regulator_init_complete(void)
                 if (has_full_constraints) {
                         /* We log since this may kill the system if it
                          * goes wrong. */
-                        printk(KERN_INFO "%s: disabling %s\n",
-                               __func__, name);
+                        rdev_info(rdev, "disabling\n");
                         ret = ops->disable(rdev);
                         if (ret != 0) {
-                                printk(KERN_ERR
-                                       "%s: couldn't disable %s: %d\n",
-                                       __func__, name, ret);
+                                rdev_err(rdev, "couldn't disable: %d\n", ret);
                         }
                 } else {
                         /* The intention is that in future we will
@@ -2638,9 +2814,7 @@ static int __init regulator_init_complete(void)
                          * so warn even if we aren't going to do
                          * anything here.
                          */
-                        printk(KERN_WARNING
-                               "%s: incomplete constraints, leaving %s on\n",
-                               __func__, name);
+                        rdev_warn(rdev, "incomplete constraints, leaving on\n");
                 }
 
 unlock:
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c
index f8c4661a7a8..362e0822108 100644
--- a/drivers/regulator/da903x.c
+++ b/drivers/regulator/da903x.c
@@ -107,7 +107,7 @@ static inline int check_range(struct da903x_regulator_info *info,
 
 /* DA9030/DA9034 common operations */
 static int da903x_set_ldo_voltage(struct regulator_dev *rdev,
-                                  int min_uV, int max_uV)
+                                  int min_uV, int max_uV, unsigned *selector)
 {
         struct da903x_regulator_info *info = rdev_get_drvdata(rdev);
         struct device *da9034_dev = to_da903x_dev(rdev);
@@ -119,6 +119,7 @@ static int da903x_set_ldo_voltage(struct regulator_dev *rdev,
         }
 
         val = (min_uV - info->min_uV + info->step_uV - 1) / info->step_uV;
+        *selector = val;
         val <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
@@ -187,7 +188,8 @@ static int da903x_list_voltage(struct regulator_dev *rdev, unsigned selector)
 
 /* DA9030 specific operations */
 static int da9030_set_ldo1_15_voltage(struct regulator_dev *rdev,
-                                       int min_uV, int max_uV)
+                                      int min_uV, int max_uV,
+                                      unsigned *selector)
 {
         struct da903x_regulator_info *info = rdev_get_drvdata(rdev);
         struct device *da903x_dev = to_da903x_dev(rdev);
@@ -200,6 +202,7 @@ static int da9030_set_ldo1_15_voltage(struct regulator_dev *rdev,
         }
 
         val = (min_uV - info->min_uV + info->step_uV - 1) / info->step_uV;
+        *selector = val;
         val <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
         val |= DA9030_LDO_UNLOCK; /* have to set UNLOCK bits */
@@ -214,7 +217,8 @@ static int da9030_set_ldo1_15_voltage(struct regulator_dev *rdev,
 }
 
 static int da9030_set_ldo14_voltage(struct regulator_dev *rdev,
-                                  int min_uV, int max_uV)
+                                    int min_uV, int max_uV,
+                                    unsigned *selector)
 {
         struct da903x_regulator_info *info = rdev_get_drvdata(rdev);
         struct device *da903x_dev = to_da903x_dev(rdev);
@@ -234,6 +238,7 @@ static int da9030_set_ldo14_voltage(struct regulator_dev *rdev,
                 val = (min_uV - thresh + info->step_uV - 1) / info->step_uV;
         }
 
+        *selector = val;
         val <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
@@ -263,7 +268,7 @@ static int da9030_get_ldo14_voltage(struct regulator_dev *rdev)
 
 /* DA9034 specific operations */
 static int da9034_set_dvc_voltage(struct regulator_dev *rdev,
-                                  int min_uV, int max_uV)
+                                  int min_uV, int max_uV, unsigned *selector)
 {
         struct da903x_regulator_info *info = rdev_get_drvdata(rdev);
         struct device *da9034_dev = to_da903x_dev(rdev);
@@ -276,6 +281,7 @@ static int da9034_set_dvc_voltage(struct regulator_dev *rdev,
         }
 
         val = (min_uV - info->min_uV + info->step_uV - 1) / info->step_uV;
+        *selector = val;
         val <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
@@ -289,7 +295,7 @@ static int da9034_set_dvc_voltage(struct regulator_dev *rdev,
 }
 
 static int da9034_set_ldo12_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct da903x_regulator_info *info = rdev_get_drvdata(rdev);
         struct device *da9034_dev = to_da903x_dev(rdev);
@@ -302,6 +308,7 @@ static int da9034_set_ldo12_voltage(struct regulator_dev *rdev,
 
         val = (min_uV - info->min_uV + info->step_uV - 1) / info->step_uV;
         val = (val >= 20) ? val - 12 : ((val > 7) ? 8 : val);
+        *selector = val;
         val <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index b8cc6389a54..e4b3592e817 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -58,7 +58,9 @@ out:
         return data;
 }
 
-static int isl6271a_set_voltage(struct regulator_dev *dev, int minuV, int maxuV)
+static int isl6271a_set_voltage(struct regulator_dev *dev,
+                                int minuV, int maxuV,
+                                unsigned *selector)
 {
         struct isl_pmic *pmic = rdev_get_drvdata(dev);
         int vsel, err, data;
@@ -78,6 +80,8 @@ static int isl6271a_set_voltage(struct regulator_dev *dev, int minuV, int maxuV)
         /* Convert the microvolts to data for the chip */
         data = (vsel - ISL6271A_VOLTAGE_MIN) / ISL6271A_VOLTAGE_STEP;
 
+        *selector = data;
+
         mutex_lock(&pmic->mtx);
 
         err = i2c_smbus_write_byte(pmic->client, data);
@@ -169,7 +173,7 @@ static int __devinit isl6271a_probe(struct i2c_client *i2c,
                                                 init_data, pmic);
                 if (IS_ERR(pmic->rdev[i])) {
                         dev_err(&i2c->dev, "failed to register %s\n", id->name);
-                        err = PTR_ERR(pmic->rdev);
+                        err = PTR_ERR(pmic->rdev[i]);
                         goto error;
                 }
         }
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 3bb82b624e1..0f22ef12601 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -168,7 +168,8 @@ static int lp3971_ldo_get_voltage(struct regulator_dev *dev)
 }
 
 static int lp3971_ldo_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                  int min_uV, int max_uV,
+                                  unsigned int *selector)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
         int ldo = rdev_get_id(dev) - LP3971_LDO1;
@@ -187,6 +188,8 @@ static int lp3971_ldo_set_voltage(struct regulator_dev *dev,
         if (val > LDO_VOL_MAX_IDX || vol_map[val] > max_vol)
                 return -EINVAL;
 
+        *selector = val;
+
         return lp3971_set_bits(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo),
                         LDO_VOL_CONTR_MASK << LDO_VOL_CONTR_SHIFT(ldo),
                         val << LDO_VOL_CONTR_SHIFT(ldo));
@@ -256,7 +259,8 @@ static int lp3971_dcdc_get_voltage(struct regulator_dev *dev)
 }
 
 static int lp3971_dcdc_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                   int min_uV, int max_uV,
+                                   unsigned int *selector)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
         int buck = rdev_get_id(dev) - LP3971_DCDC1;
@@ -277,6 +281,8 @@ static int lp3971_dcdc_set_voltage(struct regulator_dev *dev,
         if (val > BUCK_TARGET_VOL_MAX_IDX || vol_map[val] > max_vol)
                 return -EINVAL;
 
+        *selector = val;
+
         ret = lp3971_set_bits(lp3971, LP3971_BUCK_TARGET_VOL1_REG(buck),
                BUCK_TARGET_VOL_MASK, val);
         if (ret)
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
index e07062fd0b4..6aa1b506fb5 100644
--- a/drivers/regulator/lp3972.c
+++ b/drivers/regulator/lp3972.c
@@ -292,7 +292,8 @@ static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
 }
 
 static int lp3972_ldo_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                  int min_uV, int max_uV,
+                                  unsigned int *selector)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
         int ldo = rdev_get_id(dev) - LP3972_LDO1;
@@ -313,6 +314,8 @@ static int lp3972_ldo_set_voltage(struct regulator_dev *dev,
         if (val > LP3972_LDO_VOL_MAX_IDX(ldo) || vol_map[val] > max_vol)
                 return -EINVAL;
 
+        *selector = val;
+
         shift = LP3972_LDO_VOL_CONTR_SHIFT(ldo);
         ret = lp3972_set_bits(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo),
                 LP3972_LDO_VOL_MASK(ldo) << shift, val << shift);
@@ -416,7 +419,8 @@ static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
 }
 
 static int lp3972_dcdc_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                   int min_uV, int max_uV,
+                                   unsigned int *selector)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
         int buck = rdev_get_id(dev) - LP3972_DCDC1;
@@ -438,6 +442,8 @@ static int lp3972_dcdc_set_voltage(struct regulator_dev *dev,
             vol_map[val] > max_vol)
                 return -EINVAL;
 
+        *selector = val;
+
         ret = lp3972_set_bits(lp3972, LP3972_BUCK_VOL1_REG(buck),
                                 LP3972_BUCK_VOL_MASK, val);
         if (ret)
diff --git a/drivers/regulator/max1586.c b/drivers/regulator/max1586.c
index 559cfa271a4..3f49512c513 100644
--- a/drivers/regulator/max1586.c
+++ b/drivers/regulator/max1586.c
@@ -63,12 +63,12 @@ static int max1586_v3_calc_voltage(struct max1586_data *max1586,
         return max1586->min_uV + (selector * range_uV / MAX1586_V3_MAX_VSEL);
 }
 
-static int max1586_v3_set(struct regulator_dev *rdev, int min_uV, int max_uV)
+static int max1586_v3_set(struct regulator_dev *rdev, int min_uV, int max_uV,
+                          unsigned *selector)
 {
         struct max1586_data *max1586 = rdev_get_drvdata(rdev);
         struct i2c_client *client = max1586->client;
         unsigned range_uV = max1586->max_uV - max1586->min_uV;
-        unsigned selector;
         u8 v3_prog;
 
         if (min_uV > max1586->max_uV || max_uV < max1586->min_uV)
@@ -76,15 +76,15 @@ static int max1586_v3_set(struct regulator_dev *rdev, int min_uV, int max_uV)
         if (min_uV < max1586->min_uV)
                 min_uV = max1586->min_uV;
 
-        selector = ((min_uV - max1586->min_uV) * MAX1586_V3_MAX_VSEL +
+        *selector = ((min_uV - max1586->min_uV) * MAX1586_V3_MAX_VSEL +
                         range_uV - 1) / range_uV;
-        if (max1586_v3_calc_voltage(max1586, selector) > max_uV)
+        if (max1586_v3_calc_voltage(max1586, *selector) > max_uV)
                 return -EINVAL;
 
         dev_dbg(&client->dev, "changing voltage v3 to %dmv\n",
-                max1586_v3_calc_voltage(max1586, selector) / 1000);
+                max1586_v3_calc_voltage(max1586, *selector) / 1000);
 
-        v3_prog = I2C_V3_SELECT | (u8) selector;
+        v3_prog = I2C_V3_SELECT | (u8) *selector;
         return i2c_smbus_write_byte(client, v3_prog);
 }
 
@@ -110,10 +110,10 @@ static int max1586_v6_calc_voltage(unsigned selector)
         return voltages_uv[selector];
 }
 
-static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV)
+static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV,
+                          unsigned int *selector)
 {
         struct i2c_client *client = rdev_get_drvdata(rdev);
-        unsigned selector;
         u8 v6_prog;
 
         if (min_uV < MAX1586_V6_MIN_UV || min_uV > MAX1586_V6_MAX_UV)
@@ -122,21 +122,21 @@ static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV)
                 return -EINVAL;
 
         if (min_uV < 1800000)
-                selector = 0;
+                *selector = 0;
         else if (min_uV < 2500000)
-                selector = 1;
+                *selector = 1;
         else if (min_uV < 3000000)
-                selector = 2;
+                *selector = 2;
         else if (min_uV >= 3000000)
-                selector = 3;
+                *selector = 3;
 
-        if (max1586_v6_calc_voltage(selector) > max_uV)
+        if (max1586_v6_calc_voltage(*selector) > max_uV)
                 return -EINVAL;
 
         dev_dbg(&client->dev, "changing voltage v6 to %dmv\n",
-                max1586_v6_calc_voltage(selector) / 1000);
+                max1586_v6_calc_voltage(*selector) / 1000);
 
-        v6_prog = I2C_V6_SELECT | (u8) selector;
+        v6_prog = I2C_V6_SELECT | (u8) *selector;
         return i2c_smbus_write_byte(client, v6_prog);
 }
 
diff --git a/drivers/regulator/max8649.c b/drivers/regulator/max8649.c
index 6b60a9c0366..30eb9e54f7e 100644
--- a/drivers/regulator/max8649.c
+++ b/drivers/regulator/max8649.c
@@ -155,7 +155,7 @@ static int max8649_get_voltage(struct regulator_dev *rdev)
 }
 
 static int max8649_set_voltage(struct regulator_dev *rdev,
-                               int min_uV, int max_uV)
+                               int min_uV, int max_uV, unsigned *selector)
 {
         struct max8649_regulator_info *info = rdev_get_drvdata(rdev);
         unsigned char data, mask;
@@ -168,6 +168,7 @@ static int max8649_set_voltage(struct regulator_dev *rdev,
         data = (min_uV - MAX8649_DCDC_VMIN + MAX8649_DCDC_STEP - 1)
                 / MAX8649_DCDC_STEP;
         mask = MAX8649_VOL_MASK;
+        *selector = data & mask;
 
         return max8649_set_bits(info->i2c, info->vol_reg, mask, data);
 }
diff --git a/drivers/regulator/max8660.c b/drivers/regulator/max8660.c
index c570e6eb0db..33f5d9a492e 100644
--- a/drivers/regulator/max8660.c
+++ b/drivers/regulator/max8660.c
@@ -141,7 +141,8 @@ static int max8660_dcdc_get(struct regulator_dev *rdev)
         return MAX8660_DCDC_MIN_UV + selector * MAX8660_DCDC_STEP;
 }
 
-static int max8660_dcdc_set(struct regulator_dev *rdev, int min_uV, int max_uV)
+static int max8660_dcdc_set(struct regulator_dev *rdev, int min_uV, int max_uV,
+                            unsigned int *s)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 reg, selector, bits;
@@ -154,6 +155,7 @@ static int max8660_dcdc_set(struct regulator_dev *rdev, int min_uV, int max_uV)
 
         selector = (min_uV - (MAX8660_DCDC_MIN_UV - MAX8660_DCDC_STEP + 1))
                         / MAX8660_DCDC_STEP;
+        *s = selector;
 
         ret = max8660_dcdc_list(rdev, selector);
         if (ret < 0 || ret > max_uV)
@@ -196,7 +198,8 @@ static int max8660_ldo5_get(struct regulator_dev *rdev)
         return MAX8660_LDO5_MIN_UV + selector * MAX8660_LDO5_STEP;
 }
 
-static int max8660_ldo5_set(struct regulator_dev *rdev, int min_uV, int max_uV)
+static int max8660_ldo5_set(struct regulator_dev *rdev, int min_uV, int max_uV,
+                            unsigned int *s)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 selector;
@@ -213,6 +216,8 @@ static int max8660_ldo5_set(struct regulator_dev *rdev, int min_uV, int max_uV)
         if (ret < 0 || ret > max_uV)
                 return -EINVAL;
 
+        *s = selector;
+
         ret = max8660_write(max8660, MAX8660_MDTV2, 0, selector);
         if (ret)
                 return ret;
@@ -270,7 +275,8 @@ static int max8660_ldo67_get(struct regulator_dev *rdev)
         return MAX8660_LDO67_MIN_UV + selector * MAX8660_LDO67_STEP;
 }
 
-static int max8660_ldo67_set(struct regulator_dev *rdev, int min_uV, int max_uV)
+static int max8660_ldo67_set(struct regulator_dev *rdev, int min_uV,
+                             int max_uV, unsigned int *s)
 {
         struct max8660 *max8660 = rdev_get_drvdata(rdev);
         u8 selector;
@@ -288,6 +294,8 @@ static int max8660_ldo67_set(struct regulator_dev *rdev, int min_uV, int max_uV)
         if (ret < 0 || ret > max_uV)
                 return -EINVAL;
 
+        *s = selector;
+
         if (rdev_get_id(rdev) == MAX8660_V6)
                 return max8660_write(max8660, MAX8660_L12VCR, 0xf0, selector);
         else
diff --git a/drivers/regulator/max8925-regulator.c b/drivers/regulator/max8925-regulator.c
index 552cad85ae5..8ae147549c6 100644
--- a/drivers/regulator/max8925-regulator.c
+++ b/drivers/regulator/max8925-regulator.c
@@ -55,7 +55,7 @@ static int max8925_list_voltage(struct regulator_dev *rdev, unsigned index)
 }
 
 static int max8925_set_voltage(struct regulator_dev *rdev,
-                               int min_uV, int max_uV)
+                               int min_uV, int max_uV, unsigned int *selector)
 {
         struct max8925_regulator_info *info = rdev_get_drvdata(rdev);
         unsigned char data, mask;
@@ -66,6 +66,7 @@ static int max8925_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
         data = (min_uV - info->min_uV + info->step_uV - 1) / info->step_uV;
+        *selector = data;
         data <<= info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1) << info->vol_shift;
 
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index 0d5dda4fd91..a8f4ecfb084 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -133,7 +133,7 @@ static int max8952_get_voltage(struct regulator_dev *rdev)
 }
 
 static int max8952_set_voltage(struct regulator_dev *rdev,
-                                int min_uV, int max_uV)
+                               int min_uV, int max_uV, unsigned *selector)
 {
         struct max8952_data *max8952 = rdev_get_drvdata(rdev);
         s8 vid = -1, i;
@@ -156,6 +156,7 @@ static int max8952_set_voltage(struct regulator_dev *rdev,
         if (vid >= 0 && vid < MAX8952_NUM_DVS_MODE) {
                 max8952->vid0 = (vid % 2 == 1);
                 max8952->vid1 = (((vid >> 1) % 2) == 1);
+                *selector = vid;
                 gpio_set_value(max8952->pdata->gpio_vid0, max8952->vid0);
                 gpio_set_value(max8952->pdata->gpio_vid1, max8952->vid1);
         } else
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 5c20756db60..7568df6122a 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -304,7 +304,7 @@ static int max8998_get_voltage(struct regulator_dev *rdev)
 }
 
 static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
-                                int min_uV, int max_uV)
+                                   int min_uV, int max_uV, unsigned *selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct i2c_client *i2c = max8998->iodev->i2c;
@@ -331,6 +331,8 @@ static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
         if (desc->min + desc->step*i > max_vol)
                 return -EINVAL;
 
+        *selector = i;
+
         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
         if (ret)
                 return ret;
@@ -352,7 +354,7 @@ static inline void buck2_gpio_set(int gpio, int v)
 }
 
 static int max8998_set_voltage_buck(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct max8998_platform_data *pdata =
@@ -384,6 +386,8 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
         if (desc->min + desc->step*i > max_vol)
                 return -EINVAL;
 
+        *selector = i;
+
         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
         if (ret)
                 return ret;
diff --git a/drivers/regulator/mc13783-regulator.c b/drivers/regulator/mc13783-regulator.c
index ecd99f59dba..3e5d0c3b4e5 100644
--- a/drivers/regulator/mc13783-regulator.c
+++ b/drivers/regulator/mc13783-regulator.c
@@ -1,6 +1,7 @@
 /*
  * Regulator Driver for Freescale MC13783 PMIC
  *
+ * Copyright 2010 Yong Shen <yong.shen@linaro.org>
  * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
  * Copyright 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
  *
@@ -17,6 +18,7 @@
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/err.h>
+#include "mc13xxx.h"
 
 #define MC13783_REG_SWITCHERS5                  29
 #define MC13783_REG_SWITCHERS5_SW3EN                    (1 << 20)
@@ -89,154 +91,106 @@
 #define MC13783_REG_POWERMISC_PWGTSPI_M                 (3 << 15)
 
 
-struct mc13783_regulator {
-        struct regulator_desc desc;
-        int reg;
-        int enable_bit;
-        int vsel_reg;
-        int vsel_shift;
-        int vsel_mask;
-        int const *voltages;
-};
-
 /* Voltage Values */
-static const int const mc13783_sw3_val[] = {
+static const int mc13783_sw3_val[] = {
         5000000, 5000000, 5000000, 5500000,
 };
 
-static const int const mc13783_vaudio_val[] = {
+static const int mc13783_vaudio_val[] = {
         2775000,
 };
 
-static const int const mc13783_viohi_val[] = {
+static const int mc13783_viohi_val[] = {
         2775000,
 };
 
-static const int const mc13783_violo_val[] = {
+static const int mc13783_violo_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int const mc13783_vdig_val[] = {
+static const int mc13783_vdig_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int const mc13783_vgen_val[] = {
+static const int mc13783_vgen_val[] = {
         1200000, 1300000, 1500000, 1800000,
         1100000, 2000000, 2775000, 2400000,
 };
 
-static const int const mc13783_vrfdig_val[] = {
+static const int mc13783_vrfdig_val[] = {
         1200000, 1500000, 1800000, 1875000,
 };
 
-static const int const mc13783_vrfref_val[] = {
+static const int mc13783_vrfref_val[] = {
         2475000, 2600000, 2700000, 2775000,
 };
 
-static const int const mc13783_vrfcp_val[] = {
+static const int mc13783_vrfcp_val[] = {
         2700000, 2775000,
 };
 
-static const int const mc13783_vsim_val[] = {
+static const int mc13783_vsim_val[] = {
         1800000, 2900000, 3000000,
 };
 
-static const int const mc13783_vesim_val[] = {
+static const int mc13783_vesim_val[] = {
         1800000, 2900000,
 };
 
-static const int const mc13783_vcam_val[] = {
+static const int mc13783_vcam_val[] = {
         1500000, 1800000, 2500000, 2550000,
         2600000, 2750000, 2800000, 3000000,
 };
 
-static const int const mc13783_vrfbg_val[] = {
+static const int mc13783_vrfbg_val[] = {
         1250000,
 };
 
-static const int const mc13783_vvib_val[] = {
+static const int mc13783_vvib_val[] = {
         1300000, 1800000, 2000000, 3000000,
 };
 
-static const int const mc13783_vmmc_val[] = {
+static const int mc13783_vmmc_val[] = {
         1600000, 1800000, 2000000, 2600000,
         2700000, 2800000, 2900000, 3000000,
 };
 
-static const int const mc13783_vrf_val[] = {
+static const int mc13783_vrf_val[] = {
         1500000, 1875000, 2700000, 2775000,
 };
 
-static const int const mc13783_gpo_val[] = {
+static const int mc13783_gpo_val[] = {
         3100000,
 };
 
-static const int const mc13783_pwgtdrv_val[] = {
+static const int mc13783_pwgtdrv_val[] = {
         5500000,
 };
 
-static struct regulator_ops mc13783_regulator_ops;
-static struct regulator_ops mc13783_fixed_regulator_ops;
 static struct regulator_ops mc13783_gpo_regulator_ops;
 
-#define MC13783_DEFINE(prefix, _name, _reg, _vsel_reg, _voltages)       \
-        [MC13783_ ## prefix ## _ ## _name] = {                          \
-                .desc = {                                               \
-                        .name = #prefix "_" #_name,                     \
-                        .n_voltages = ARRAY_SIZE(_voltages),            \
-                        .ops = &mc13783_regulator_ops,                  \
-                        .type = REGULATOR_VOLTAGE,                      \
-                        .id = MC13783_ ## prefix ## _ ## _name,         \
-                        .owner = THIS_MODULE,                           \
-                },                                                      \
-                .reg = MC13783_REG_ ## _reg,                            \
-                .enable_bit = MC13783_REG_ ## _reg ## _ ## _name ## EN, \
-                .vsel_reg = MC13783_REG_ ## _vsel_reg,                  \
-                .vsel_shift = MC13783_REG_ ## _vsel_reg ## _ ## _name ## VSEL,\
-                .vsel_mask = MC13783_REG_ ## _vsel_reg ## _ ## _name ## VSEL_M,\
-                .voltages =  _voltages,                                 \
-        }
+#define MC13783_DEFINE(prefix, name, reg, vsel_reg, voltages)   \
+        MC13xxx_DEFINE(MC13783_REG_, name, reg, vsel_reg, voltages, \
+                        mc13xxx_regulator_ops)
 
-#define MC13783_FIXED_DEFINE(prefix, _name, _reg, _voltages)            \
-        [MC13783_ ## prefix ## _ ## _name] = {                          \
-                .desc = {                                               \
-                        .name = #prefix "_" #_name,                     \
-                        .n_voltages = ARRAY_SIZE(_voltages),            \
-                        .ops = &mc13783_fixed_regulator_ops,            \
-                        .type = REGULATOR_VOLTAGE,                      \
-                        .id = MC13783_ ## prefix ## _ ## _name,         \
-                        .owner = THIS_MODULE,                           \
-                },                                                      \
-                .reg = MC13783_REG_ ## _reg,                            \
-                .enable_bit = MC13783_REG_ ## _reg ## _ ## _name ## EN, \
-                .voltages =  _voltages,                                 \
-        }
+#define MC13783_FIXED_DEFINE(prefix, name, reg, voltages)               \
+        MC13xxx_FIXED_DEFINE(MC13783_REG_, name, reg, voltages, \
+                        mc13xxx_fixed_regulator_ops)
 
-#define MC13783_GPO_DEFINE(prefix, _name, _reg,  _voltages)             \
-        [MC13783_ ## prefix ## _ ## _name] = {                          \
-                .desc = {                                               \
-                        .name = #prefix "_" #_name,                     \
-                        .n_voltages = ARRAY_SIZE(_voltages),            \
-                        .ops = &mc13783_gpo_regulator_ops,              \
-                        .type = REGULATOR_VOLTAGE,                      \
-                        .id = MC13783_ ## prefix ## _ ## _name,         \
-                        .owner = THIS_MODULE,                           \
-                },                                                      \
-                .reg = MC13783_REG_ ## _reg,                            \
-                .enable_bit = MC13783_REG_ ## _reg ## _ ## _name ## EN, \
-                .voltages =  _voltages,                                 \
-        }
+#define MC13783_GPO_DEFINE(prefix, name, reg, voltages)         \
+        MC13xxx_GPO_DEFINE(MC13783_REG_, name, reg, voltages, \
+                        mc13783_gpo_regulator_ops)
 
 #define MC13783_DEFINE_SW(_name, _reg, _vsel_reg, _voltages)            \
-        MC13783_DEFINE(SW, _name, _reg, _vsel_reg, _voltages)
+        MC13783_DEFINE(REG, _name, _reg, _vsel_reg, _voltages)
 #define MC13783_DEFINE_REGU(_name, _reg, _vsel_reg, _voltages)          \
-        MC13783_DEFINE(REGU, _name, _reg, _vsel_reg, _voltages)
+        MC13783_DEFINE(REG, _name, _reg, _vsel_reg, _voltages)
 
-static struct mc13783_regulator mc13783_regulators[] = {
+static struct mc13xxx_regulator mc13783_regulators[] = {
         MC13783_DEFINE_SW(SW3, SWITCHERS5, SWITCHERS5, mc13783_sw3_val),
 
-        MC13783_FIXED_DEFINE(REGU, VAUDIO, REGULATORMODE0, mc13783_vaudio_val),
-        MC13783_FIXED_DEFINE(REGU, VIOHI, REGULATORMODE0, mc13783_viohi_val),
+        MC13783_FIXED_DEFINE(REG, VAUDIO, REGULATORMODE0, mc13783_vaudio_val),
+        MC13783_FIXED_DEFINE(REG, VIOHI, REGULATORMODE0, mc13783_viohi_val),
         MC13783_DEFINE_REGU(VIOLO, REGULATORMODE0, REGULATORSETTING0,   \
                             mc13783_violo_val),
         MC13783_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0,    \
@@ -255,7 +209,7 @@ static struct mc13783_regulator mc13783_regulators[] = {
                             mc13783_vesim_val),
         MC13783_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0,    \
                             mc13783_vcam_val),
-        MC13783_FIXED_DEFINE(REGU, VRFBG, REGULATORMODE1, mc13783_vrfbg_val),
+        MC13783_FIXED_DEFINE(REG, VRFBG, REGULATORMODE1, mc13783_vrfbg_val),
         MC13783_DEFINE_REGU(VVIB, REGULATORMODE1, REGULATORSETTING1,    \
                             mc13783_vvib_val),
         MC13783_DEFINE_REGU(VRF1, REGULATORMODE1, REGULATORSETTING1,    \
@@ -266,215 +220,24 @@ static struct mc13783_regulator mc13783_regulators[] = {
                             mc13783_vmmc_val),
         MC13783_DEFINE_REGU(VMMC2, REGULATORMODE1, REGULATORSETTING1,   \
                             mc13783_vmmc_val),
-        MC13783_GPO_DEFINE(REGU, GPO1, POWERMISC, mc13783_gpo_val),
-        MC13783_GPO_DEFINE(REGU, GPO2, POWERMISC, mc13783_gpo_val),
-        MC13783_GPO_DEFINE(REGU, GPO3, POWERMISC, mc13783_gpo_val),
-        MC13783_GPO_DEFINE(REGU, GPO4, POWERMISC, mc13783_gpo_val),
-        MC13783_GPO_DEFINE(REGU, PWGT1SPI, POWERMISC, mc13783_pwgtdrv_val),
-        MC13783_GPO_DEFINE(REGU, PWGT2SPI, POWERMISC, mc13783_pwgtdrv_val),
-};
-
-struct mc13783_regulator_priv {
-        struct mc13783 *mc13783;
-        u32 powermisc_pwgt_state;
-        struct regulator_dev *regulators[];
-};
-
-static int mc13783_regulator_enable(struct regulator_dev *rdev)
-{
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int id = rdev_get_id(rdev);
-        int ret;
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
-
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_rmw(priv->mc13783, mc13783_regulators[id].reg,
-                        mc13783_regulators[id].enable_bit,
-                        mc13783_regulators[id].enable_bit);
-        mc13783_unlock(priv->mc13783);
-
-        return ret;
-}
-
-static int mc13783_regulator_disable(struct regulator_dev *rdev)
-{
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int id = rdev_get_id(rdev);
-        int ret;
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
-
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_rmw(priv->mc13783, mc13783_regulators[id].reg,
-                        mc13783_regulators[id].enable_bit, 0);
-        mc13783_unlock(priv->mc13783);
-
-        return ret;
-}
-
-static int mc13783_regulator_is_enabled(struct regulator_dev *rdev)
-{
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int ret, id = rdev_get_id(rdev);
-        unsigned int val;
-
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_read(priv->mc13783, mc13783_regulators[id].reg, &val);
-        mc13783_unlock(priv->mc13783);
-
-        if (ret)
-                return ret;
-
-        return (val & mc13783_regulators[id].enable_bit) != 0;
-}
-
-static int mc13783_regulator_list_voltage(struct regulator_dev *rdev,
-                                                unsigned selector)
-{
-        int id = rdev_get_id(rdev);
-
-        if (selector >= mc13783_regulators[id].desc.n_voltages)
-                return -EINVAL;
-
-        return mc13783_regulators[id].voltages[selector];
-}
-
-static int mc13783_get_best_voltage_index(struct regulator_dev *rdev,
-                                                int min_uV, int max_uV)
-{
-        int reg_id = rdev_get_id(rdev);
-        int i;
-        int bestmatch;
-        int bestindex;
-
-        /*
-         * Locate the minimum voltage fitting the criteria on
-         * this regulator. The switchable voltages are not
-         * in strict falling order so we need to check them
-         * all for the best match.
-         */
-        bestmatch = INT_MAX;
-        bestindex = -1;
-        for (i = 0; i < mc13783_regulators[reg_id].desc.n_voltages; i++) {
-                if (mc13783_regulators[reg_id].voltages[i] >= min_uV &&
-                    mc13783_regulators[reg_id].voltages[i] < bestmatch) {
-                        bestmatch = mc13783_regulators[reg_id].voltages[i];
-                        bestindex = i;
-                }
-        }
-
-        if (bestindex < 0 || bestmatch > max_uV) {
-                dev_warn(&rdev->dev, "no possible value for %d<=x<=%d uV\n",
-                                min_uV, max_uV);
-                return -EINVAL;
-        }
-        return bestindex;
-}
-
-static int mc13783_regulator_set_voltage(struct regulator_dev *rdev,
-                                                int min_uV, int max_uV)
-{
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int value, id = rdev_get_id(rdev);
-        int ret;
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
-                __func__, id, min_uV, max_uV);
-
-        /* Find the best index */
-        value = mc13783_get_best_voltage_index(rdev, min_uV, max_uV);
-        dev_dbg(rdev_get_dev(rdev), "%s best value: %d \n", __func__, value);
-        if (value < 0)
-                return value;
-
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_rmw(priv->mc13783, mc13783_regulators[id].vsel_reg,
-                        mc13783_regulators[id].vsel_mask,
-                        value << mc13783_regulators[id].vsel_shift);
-        mc13783_unlock(priv->mc13783);
-
-        return ret;
-}
-
-static int mc13783_regulator_get_voltage(struct regulator_dev *rdev)
-{
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
-        int ret, id = rdev_get_id(rdev);
-        unsigned int val;
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
-
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_read(priv->mc13783,
-                                mc13783_regulators[id].vsel_reg, &val);
-        mc13783_unlock(priv->mc13783);
-
-        if (ret)
-                return ret;
-
-        val = (val & mc13783_regulators[id].vsel_mask)
-                >> mc13783_regulators[id].vsel_shift;
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d val: %d\n", __func__, id, val);
-
-        BUG_ON(val < 0 || val > mc13783_regulators[id].desc.n_voltages);
-
-        return mc13783_regulators[id].voltages[val];
-}
-
-static struct regulator_ops mc13783_regulator_ops = {
-        .enable = mc13783_regulator_enable,
-        .disable = mc13783_regulator_disable,
-        .is_enabled = mc13783_regulator_is_enabled,
-        .list_voltage = mc13783_regulator_list_voltage,
-        .set_voltage = mc13783_regulator_set_voltage,
-        .get_voltage = mc13783_regulator_get_voltage,
-};
-
-static int mc13783_fixed_regulator_set_voltage(struct regulator_dev *rdev,
-                                                int min_uV, int max_uV)
-{
-        int id = rdev_get_id(rdev);
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
-                __func__, id, min_uV, max_uV);
-
-        if (min_uV >= mc13783_regulators[id].voltages[0] &&
-            max_uV <= mc13783_regulators[id].voltages[0])
-                return 0;
-        else
-                return -EINVAL;
-}
-
-static int mc13783_fixed_regulator_get_voltage(struct regulator_dev *rdev)
-{
-        int id = rdev_get_id(rdev);
-
-        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
-
-        return mc13783_regulators[id].voltages[0];
-}
-
-static struct regulator_ops mc13783_fixed_regulator_ops = {
-        .enable = mc13783_regulator_enable,
-        .disable = mc13783_regulator_disable,
-        .is_enabled = mc13783_regulator_is_enabled,
-        .list_voltage = mc13783_regulator_list_voltage,
-        .set_voltage = mc13783_fixed_regulator_set_voltage,
-        .get_voltage = mc13783_fixed_regulator_get_voltage,
+        MC13783_GPO_DEFINE(REG, GPO1, POWERMISC, mc13783_gpo_val),
+        MC13783_GPO_DEFINE(REG, GPO2, POWERMISC, mc13783_gpo_val),
+        MC13783_GPO_DEFINE(REG, GPO3, POWERMISC, mc13783_gpo_val),
+        MC13783_GPO_DEFINE(REG, GPO4, POWERMISC, mc13783_gpo_val),
+        MC13783_GPO_DEFINE(REG, PWGT1SPI, POWERMISC, mc13783_pwgtdrv_val),
+        MC13783_GPO_DEFINE(REG, PWGT2SPI, POWERMISC, mc13783_pwgtdrv_val),
 };
 
-static int mc13783_powermisc_rmw(struct mc13783_regulator_priv *priv, u32 mask,
-                                 u32 val)
+static int mc13783_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
+                u32 val)
 {
-        struct mc13783 *mc13783 = priv->mc13783;
+        struct mc13xxx *mc13783 = priv->mc13xxx;
         int ret;
         u32 valread;
 
         BUG_ON(val & ~mask);
 
-        ret = mc13783_reg_read(mc13783, MC13783_REG_POWERMISC, &valread);
+        ret = mc13xxx_reg_read(mc13783, MC13783_REG_POWERMISC, &valread);
         if (ret)
                 return ret;
 
@@ -489,34 +252,36 @@ static int mc13783_powermisc_rmw(struct mc13783_regulator_priv *priv, u32 mask,
         valread = (valread & ~MC13783_REG_POWERMISC_PWGTSPI_M) |
                                                 priv->powermisc_pwgt_state;
 
-        return mc13783_reg_write(mc13783, MC13783_REG_POWERMISC, valread);
+        return mc13xxx_reg_write(mc13783, MC13783_REG_POWERMISC, valread);
 }
 
 static int mc13783_gpo_regulator_enable(struct regulator_dev *rdev)
 {
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
         int id = rdev_get_id(rdev);
         int ret;
-        u32 en_val = mc13783_regulators[id].enable_bit;
+        u32 en_val = mc13xxx_regulators[id].enable_bit;
 
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
 
         /* Power Gate enable value is 0 */
-        if (id == MC13783_REGU_PWGT1SPI ||
-            id == MC13783_REGU_PWGT2SPI)
+        if (id == MC13783_REG_PWGT1SPI ||
+            id == MC13783_REG_PWGT2SPI)
                 en_val = 0;
 
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_powermisc_rmw(priv, mc13783_regulators[id].enable_bit,
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
                                         en_val);
-        mc13783_unlock(priv->mc13783);
+        mc13xxx_unlock(priv->mc13xxx);
 
         return ret;
 }
 
 static int mc13783_gpo_regulator_disable(struct regulator_dev *rdev)
 {
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
         int id = rdev_get_id(rdev);
         int ret;
         u32 dis_val = 0;
@@ -524,27 +289,28 @@ static int mc13783_gpo_regulator_disable(struct regulator_dev *rdev)
         dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
 
         /* Power Gate disable value is 1 */
-        if (id == MC13783_REGU_PWGT1SPI ||
-            id == MC13783_REGU_PWGT2SPI)
-                dis_val = mc13783_regulators[id].enable_bit;
+        if (id == MC13783_REG_PWGT1SPI ||
+            id == MC13783_REG_PWGT2SPI)
+                dis_val = mc13xxx_regulators[id].enable_bit;
 
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_powermisc_rmw(priv, mc13783_regulators[id].enable_bit,
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13783_powermisc_rmw(priv, mc13xxx_regulators[id].enable_bit,
                                         dis_val);
-        mc13783_unlock(priv->mc13783);
+        mc13xxx_unlock(priv->mc13xxx);
 
         return ret;
 }
 
 static int mc13783_gpo_regulator_is_enabled(struct regulator_dev *rdev)
 {
-        struct mc13783_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
         int ret, id = rdev_get_id(rdev);
         unsigned int val;
 
-        mc13783_lock(priv->mc13783);
-        ret = mc13783_reg_read(priv->mc13783, mc13783_regulators[id].reg, &val);
-        mc13783_unlock(priv->mc13783);
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx, mc13xxx_regulators[id].reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
 
         if (ret)
                 return ret;
@@ -554,22 +320,22 @@ static int mc13783_gpo_regulator_is_enabled(struct regulator_dev *rdev)
         val = (val & ~MC13783_REG_POWERMISC_PWGTSPI_M) |
               (priv->powermisc_pwgt_state ^ MC13783_REG_POWERMISC_PWGTSPI_M);
 
-        return (val & mc13783_regulators[id].enable_bit) != 0;
+        return (val & mc13xxx_regulators[id].enable_bit) != 0;
 }
 
 static struct regulator_ops mc13783_gpo_regulator_ops = {
         .enable = mc13783_gpo_regulator_enable,
         .disable = mc13783_gpo_regulator_disable,
         .is_enabled = mc13783_gpo_regulator_is_enabled,
-        .list_voltage = mc13783_regulator_list_voltage,
-        .set_voltage = mc13783_fixed_regulator_set_voltage,
-        .get_voltage = mc13783_fixed_regulator_get_voltage,
+        .list_voltage = mc13xxx_regulator_list_voltage,
+        .set_voltage = mc13xxx_fixed_regulator_set_voltage,
+        .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
 
 static int __devinit mc13783_regulator_probe(struct platform_device *pdev)
 {
-        struct mc13783_regulator_priv *priv;
-        struct mc13783 *mc13783 = dev_get_drvdata(pdev->dev.parent);
+        struct mc13xxx_regulator_priv *priv;
+        struct mc13xxx *mc13783 = dev_get_drvdata(pdev->dev.parent);
         struct mc13783_regulator_platform_data *pdata =
                 dev_get_platdata(&pdev->dev);
         struct mc13783_regulator_init_data *init_data;
@@ -583,7 +349,8 @@ static int __devinit mc13783_regulator_probe(struct platform_device *pdev)
         if (!priv)
                 return -ENOMEM;
 
-        priv->mc13783 = mc13783;
+        priv->mc13xxx_regulators = mc13783_regulators;
+        priv->mc13xxx = mc13783;
 
         for (i = 0; i < pdata->num_regulators; i++) {
                 init_data = &pdata->regulators[i];
@@ -613,7 +380,7 @@ err:
 
 static int __devexit mc13783_regulator_remove(struct platform_device *pdev)
 {
-        struct mc13783_regulator_priv *priv = platform_get_drvdata(pdev);
+        struct mc13xxx_regulator_priv *priv = platform_get_drvdata(pdev);
         struct mc13783_regulator_platform_data *pdata =
                 dev_get_platdata(&pdev->dev);
         int i;
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c
new file mode 100644
index 00000000000..1b8f7398a4a
--- /dev/null
+++ b/drivers/regulator/mc13892-regulator.c
@@ -0,0 +1,635 @@
+/*
+ * Regulator Driver for Freescale MC13892 PMIC
+ *
+ * Copyright 2010 Yong Shen <yong.shen@linaro.org>
+ *
+ * Based on draft driver from Arnaud Patard <arnaud.patard@rtp-net.org>
+ *
+ * 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/mfd/mc13892.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/driver.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include "mc13xxx.h"
+
+#define MC13892_REVISION                        7
+
+#define MC13892_POWERCTL0                       13
+#define MC13892_POWERCTL0_USEROFFSPI            3
+#define MC13892_POWERCTL0_VCOINCELLVSEL         20
+#define MC13892_POWERCTL0_VCOINCELLVSEL_M       (7<<20)
+#define MC13892_POWERCTL0_VCOINCELLEN           (1<<23)
+
+#define MC13892_SWITCHERS0_SWxHI                (1<<23)
+
+#define MC13892_SWITCHERS0                      24
+#define MC13892_SWITCHERS0_SW1VSEL              0
+#define MC13892_SWITCHERS0_SW1VSEL_M            (0x1f<<0)
+#define MC13892_SWITCHERS0_SW1HI                (1<<23)
+#define MC13892_SWITCHERS0_SW1EN                0
+
+#define MC13892_SWITCHERS1                      25
+#define MC13892_SWITCHERS1_SW2VSEL              0
+#define MC13892_SWITCHERS1_SW2VSEL_M            (0x1f<<0)
+#define MC13892_SWITCHERS1_SW2HI                (1<<23)
+#define MC13892_SWITCHERS1_SW2EN                0
+
+#define MC13892_SWITCHERS2                      26
+#define MC13892_SWITCHERS2_SW3VSEL              0
+#define MC13892_SWITCHERS2_SW3VSEL_M            (0x1f<<0)
+#define MC13892_SWITCHERS2_SW3HI                (1<<23)
+#define MC13892_SWITCHERS2_SW3EN                0
+
+#define MC13892_SWITCHERS3                      27
+#define MC13892_SWITCHERS3_SW4VSEL              0
+#define MC13892_SWITCHERS3_SW4VSEL_M            (0x1f<<0)
+#define MC13892_SWITCHERS3_SW4HI                (1<<23)
+#define MC13892_SWITCHERS3_SW4EN                0
+
+#define MC13892_SWITCHERS4                      28
+#define MC13892_SWITCHERS4_SW1MODE              0
+#define MC13892_SWITCHERS4_SW1MODE_AUTO         (8<<0)
+#define MC13892_SWITCHERS4_SW1MODE_M            (0xf<<0)
+#define MC13892_SWITCHERS4_SW2MODE              10
+#define MC13892_SWITCHERS4_SW2MODE_AUTO         (8<<10)
+#define MC13892_SWITCHERS4_SW2MODE_M            (0xf<<10)
+
+#define MC13892_SWITCHERS5                      29
+#define MC13892_SWITCHERS5_SW3MODE              0
+#define MC13892_SWITCHERS5_SW3MODE_AUTO         (8<<0)
+#define MC13892_SWITCHERS5_SW3MODE_M            (0xf<<0)
+#define MC13892_SWITCHERS5_SW4MODE              8
+#define MC13892_SWITCHERS5_SW4MODE_AUTO         (8<<8)
+#define MC13892_SWITCHERS5_SW4MODE_M            (0xf<<8)
+#define MC13892_SWITCHERS5_SWBSTEN              (1<<20)
+
+#define MC13892_REGULATORSETTING0               30
+#define MC13892_REGULATORSETTING0_VGEN1VSEL     0
+#define MC13892_REGULATORSETTING0_VDIGVSEL      4
+#define MC13892_REGULATORSETTING0_VGEN2VSEL     6
+#define MC13892_REGULATORSETTING0_VPLLVSEL      9
+#define MC13892_REGULATORSETTING0_VUSB2VSEL     11
+#define MC13892_REGULATORSETTING0_VGEN3VSEL     14
+#define MC13892_REGULATORSETTING0_VCAMVSEL      16
+
+#define MC13892_REGULATORSETTING0_VGEN1VSEL_M   (3<<0)
+#define MC13892_REGULATORSETTING0_VDIGVSEL_M    (3<<4)
+#define MC13892_REGULATORSETTING0_VGEN2VSEL_M   (7<<6)
+#define MC13892_REGULATORSETTING0_VPLLVSEL_M    (3<<9)
+#define MC13892_REGULATORSETTING0_VUSB2VSEL_M   (3<<11)
+#define MC13892_REGULATORSETTING0_VGEN3VSEL_M   (1<<14)
+#define MC13892_REGULATORSETTING0_VCAMVSEL_M    (3<<16)
+
+#define MC13892_REGULATORSETTING1               31
+#define MC13892_REGULATORSETTING1_VVIDEOVSEL    2
+#define MC13892_REGULATORSETTING1_VAUDIOVSEL    4
+#define MC13892_REGULATORSETTING1_VSDVSEL       6
+
+#define MC13892_REGULATORSETTING1_VVIDEOVSEL_M  (3<<2)
+#define MC13892_REGULATORSETTING1_VAUDIOVSEL_M  (3<<4)
+#define MC13892_REGULATORSETTING1_VSDVSEL_M     (7<<6)
+
+#define MC13892_REGULATORMODE0                  32
+#define MC13892_REGULATORMODE0_VGEN1EN          (1<<0)
+#define MC13892_REGULATORMODE0_VGEN1STDBY       (1<<1)
+#define MC13892_REGULATORMODE0_VGEN1MODE        (1<<2)
+#define MC13892_REGULATORMODE0_VIOHIEN          (1<<3)
+#define MC13892_REGULATORMODE0_VIOHISTDBY       (1<<4)
+#define MC13892_REGULATORMODE0_VIOHIMODE        (1<<5)
+#define MC13892_REGULATORMODE0_VDIGEN           (1<<9)
+#define MC13892_REGULATORMODE0_VDIGSTDBY        (1<<10)
+#define MC13892_REGULATORMODE0_VDIGMODE         (1<<11)
+#define MC13892_REGULATORMODE0_VGEN2EN          (1<<12)
+#define MC13892_REGULATORMODE0_VGEN2STDBY       (1<<13)
+#define MC13892_REGULATORMODE0_VGEN2MODE        (1<<14)
+#define MC13892_REGULATORMODE0_VPLLEN           (1<<15)
+#define MC13892_REGULATORMODE0_VPLLSTDBY        (1<<16)
+#define MC13892_REGULATORMODE0_VPLLMODE         (1<<17)
+#define MC13892_REGULATORMODE0_VUSB2EN          (1<<18)
+#define MC13892_REGULATORMODE0_VUSB2STDBY       (1<<19)
+#define MC13892_REGULATORMODE0_VUSB2MODE        (1<<20)
+
+#define MC13892_REGULATORMODE1                  33
+#define MC13892_REGULATORMODE1_VGEN3EN          (1<<0)
+#define MC13892_REGULATORMODE1_VGEN3STDBY       (1<<1)
+#define MC13892_REGULATORMODE1_VGEN3MODE        (1<<2)
+#define MC13892_REGULATORMODE1_VCAMEN           (1<<6)
+#define MC13892_REGULATORMODE1_VCAMSTDBY        (1<<7)
+#define MC13892_REGULATORMODE1_VCAMMODE         (1<<8)
+#define MC13892_REGULATORMODE1_VCAMCONFIGEN     (1<<9)
+#define MC13892_REGULATORMODE1_VVIDEOEN         (1<<12)
+#define MC13892_REGULATORMODE1_VVIDEOSTDBY      (1<<13)
+#define MC13892_REGULATORMODE1_VVIDEOMODE       (1<<14)
+#define MC13892_REGULATORMODE1_VAUDIOEN         (1<<15)
+#define MC13892_REGULATORMODE1_VAUDIOSTDBY      (1<<16)
+#define MC13892_REGULATORMODE1_VAUDIOMODE       (1<<17)
+#define MC13892_REGULATORMODE1_VSDEN            (1<<18)
+#define MC13892_REGULATORMODE1_VSDSTDBY         (1<<19)
+#define MC13892_REGULATORMODE1_VSDMODE          (1<<20)
+
+#define MC13892_POWERMISC                       34
+#define MC13892_POWERMISC_GPO1EN                (1<<6)
+#define MC13892_POWERMISC_GPO2EN                (1<<8)
+#define MC13892_POWERMISC_GPO3EN                (1<<10)
+#define MC13892_POWERMISC_GPO4EN                (1<<12)
+#define MC13892_POWERMISC_PWGT1SPIEN            (1<<15)
+#define MC13892_POWERMISC_PWGT2SPIEN            (1<<16)
+#define MC13892_POWERMISC_GPO4ADINEN            (1<<21)
+
+#define MC13892_POWERMISC_PWGTSPI_M             (3 << 15)
+
+#define MC13892_USB1                            50
+#define MC13892_USB1_VUSBEN                     (1<<3)
+
+static const int mc13892_vcoincell[] = {
+        2500000, 2700000, 2800000, 2900000, 3000000, 3100000,
+        3200000, 3300000,
+};
+
+static const int mc13892_sw1[] = {
+        600000,   625000,  650000,  675000,  700000,  725000,
+        750000,   775000,  800000,  825000,  850000,  875000,
+        900000,   925000,  950000,  975000, 1000000, 1025000,
+        1050000, 1075000, 1100000, 1125000, 1150000, 1175000,
+        1200000, 1225000, 1250000, 1275000, 1300000, 1325000,
+        1350000, 1375000
+};
+
+static const int mc13892_sw[] = {
+        600000,   625000,  650000,  675000,  700000,  725000,
+        750000,   775000,  800000,  825000,  850000,  875000,
+        900000,   925000,  950000,  975000, 1000000, 1025000,
+        1050000, 1075000, 1100000, 1125000, 1150000, 1175000,
+        1200000, 1225000, 1250000, 1275000, 1300000, 1325000,
+        1350000, 1375000, 1400000, 1425000, 1450000, 1475000,
+        1500000, 1525000, 1550000, 1575000, 1600000, 1625000,
+        1650000, 1675000, 1700000, 1725000, 1750000, 1775000,
+        1800000, 1825000, 1850000, 1875000
+};
+
+static const int mc13892_swbst[] = {
+        5000000,
+};
+
+static const int mc13892_viohi[] = {
+        2775000,
+};
+
+static const int mc13892_vpll[] = {
+        1050000, 1250000, 1650000, 1800000,
+};
+
+static const int mc13892_vdig[] = {
+        1050000, 1250000, 1650000, 1800000,
+};
+
+static const int mc13892_vsd[] = {
+        1800000, 2000000, 2600000, 2700000,
+        2800000, 2900000, 3000000, 3150000,
+};
+
+static const int mc13892_vusb2[] = {
+        2400000, 2600000, 2700000, 2775000,
+};
+
+static const int mc13892_vvideo[] = {
+        2700000, 2775000, 2500000, 2600000,
+};
+
+static const int mc13892_vaudio[] = {
+        2300000, 2500000, 2775000, 3000000,
+};
+
+static const int mc13892_vcam[] = {
+        2500000, 2600000, 2750000, 3000000,
+};
+
+static const int mc13892_vgen1[] = {
+        1200000, 1500000, 2775000, 3150000,
+};
+
+static const int mc13892_vgen2[] = {
+        1200000, 1500000, 1600000, 1800000,
+        2700000, 2800000, 3000000, 3150000,
+};
+
+static const int mc13892_vgen3[] = {
+        1800000, 2900000,
+};
+
+static const int mc13892_vusb[] = {
+        3300000,
+};
+
+static const int mc13892_gpo[] = {
+        2750000,
+};
+
+static const int mc13892_pwgtdrv[] = {
+        5000000,
+};
+
+static struct regulator_ops mc13892_gpo_regulator_ops;
+/* sw regulators need special care due to the "hi bit" */
+static struct regulator_ops mc13892_sw_regulator_ops;
+
+
+#define MC13892_FIXED_DEFINE(name, reg, voltages)               \
+        MC13xxx_FIXED_DEFINE(MC13892_, name, reg, voltages,     \
+                        mc13xxx_fixed_regulator_ops)
+
+#define MC13892_GPO_DEFINE(name, reg, voltages)                 \
+        MC13xxx_GPO_DEFINE(MC13892_, name, reg, voltages,       \
+                        mc13892_gpo_regulator_ops)
+
+#define MC13892_SW_DEFINE(name, reg, vsel_reg, voltages)        \
+        MC13xxx_DEFINE(MC13892_, name, reg, vsel_reg, voltages, \
+                        mc13892_sw_regulator_ops)
+
+#define MC13892_DEFINE_REGU(name, reg, vsel_reg, voltages)      \
+        MC13xxx_DEFINE(MC13892_, name, reg, vsel_reg, voltages, \
+                        mc13xxx_regulator_ops)
+
+static struct mc13xxx_regulator mc13892_regulators[] = {
+        MC13892_DEFINE_REGU(VCOINCELL, POWERCTL0, POWERCTL0, mc13892_vcoincell),
+        MC13892_SW_DEFINE(SW1, SWITCHERS0, SWITCHERS0, mc13892_sw1),
+        MC13892_SW_DEFINE(SW2, SWITCHERS1, SWITCHERS1, mc13892_sw),
+        MC13892_SW_DEFINE(SW3, SWITCHERS2, SWITCHERS2, mc13892_sw),
+        MC13892_SW_DEFINE(SW4, SWITCHERS3, SWITCHERS3, mc13892_sw),
+        MC13892_FIXED_DEFINE(SWBST, SWITCHERS5, mc13892_swbst),
+        MC13892_FIXED_DEFINE(VIOHI, REGULATORMODE0, mc13892_viohi),
+        MC13892_DEFINE_REGU(VPLL, REGULATORMODE0, REGULATORSETTING0,    \
+                mc13892_vpll),
+        MC13892_DEFINE_REGU(VDIG, REGULATORMODE0, REGULATORSETTING0,    \
+                mc13892_vdig),
+        MC13892_DEFINE_REGU(VSD, REGULATORMODE1, REGULATORSETTING1,     \
+                mc13892_vsd),
+        MC13892_DEFINE_REGU(VUSB2, REGULATORMODE0, REGULATORSETTING0,   \
+                mc13892_vusb2),
+        MC13892_DEFINE_REGU(VVIDEO, REGULATORMODE1, REGULATORSETTING1,  \
+                mc13892_vvideo),
+        MC13892_DEFINE_REGU(VAUDIO, REGULATORMODE1, REGULATORSETTING1,  \
+                mc13892_vaudio),
+        MC13892_DEFINE_REGU(VCAM, REGULATORMODE1, REGULATORSETTING0,    \
+                mc13892_vcam),
+        MC13892_DEFINE_REGU(VGEN1, REGULATORMODE0, REGULATORSETTING0,   \
+                mc13892_vgen1),
+        MC13892_DEFINE_REGU(VGEN2, REGULATORMODE0, REGULATORSETTING0,   \
+                mc13892_vgen2),
+        MC13892_DEFINE_REGU(VGEN3, REGULATORMODE1, REGULATORSETTING0,   \
+                mc13892_vgen3),
+        MC13892_FIXED_DEFINE(VUSB, USB1, mc13892_vusb),
+        MC13892_GPO_DEFINE(GPO1, POWERMISC, mc13892_gpo),
+        MC13892_GPO_DEFINE(GPO2, POWERMISC, mc13892_gpo),
+        MC13892_GPO_DEFINE(GPO3, POWERMISC, mc13892_gpo),
+        MC13892_GPO_DEFINE(GPO4, POWERMISC, mc13892_gpo),
+        MC13892_GPO_DEFINE(PWGT1SPI, POWERMISC, mc13892_pwgtdrv),
+        MC13892_GPO_DEFINE(PWGT2SPI, POWERMISC, mc13892_pwgtdrv),
+};
+
+static int mc13892_powermisc_rmw(struct mc13xxx_regulator_priv *priv, u32 mask,
+                                 u32 val)
+{
+        struct mc13xxx *mc13892 = priv->mc13xxx;
+        int ret;
+        u32 valread;
+
+        BUG_ON(val & ~mask);
+
+        ret = mc13xxx_reg_read(mc13892, MC13892_POWERMISC, &valread);
+        if (ret)
+                return ret;
+
+        /* Update the stored state for Power Gates. */
+        priv->powermisc_pwgt_state =
+                (priv->powermisc_pwgt_state & ~mask) | val;
+        priv->powermisc_pwgt_state &= MC13892_POWERMISC_PWGTSPI_M;
+
+        /* Construct the new register value */
+        valread = (valread & ~mask) | val;
+        /* Overwrite the PWGTxEN with the stored version */
+        valread = (valread & ~MC13892_POWERMISC_PWGTSPI_M) |
+                priv->powermisc_pwgt_state;
+
+        return mc13xxx_reg_write(mc13892, MC13892_POWERMISC, valread);
+}
+
+static int mc13892_gpo_regulator_enable(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
+        int ret;
+        u32 en_val = mc13892_regulators[id].enable_bit;
+        u32 mask = mc13892_regulators[id].enable_bit;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        /* Power Gate enable value is 0 */
+        if (id == MC13892_PWGT1SPI || id == MC13892_PWGT2SPI)
+                en_val = 0;
+
+        if (id == MC13892_GPO4)
+                mask |= MC13892_POWERMISC_GPO4ADINEN;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13892_powermisc_rmw(priv, mask, en_val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static int mc13892_gpo_regulator_disable(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
+        int ret;
+        u32 dis_val = 0;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        /* Power Gate disable value is 1 */
+        if (id == MC13892_PWGT1SPI || id == MC13892_PWGT2SPI)
+                dis_val = mc13892_regulators[id].enable_bit;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13892_powermisc_rmw(priv, mc13892_regulators[id].enable_bit,
+                dis_val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static int mc13892_gpo_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx, mc13892_regulators[id].reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        if (ret)
+                return ret;
+
+        /* Power Gates state is stored in powermisc_pwgt_state
+         * where the meaning of bits is negated */
+        val = (val & ~MC13892_POWERMISC_PWGTSPI_M) |
+                (priv->powermisc_pwgt_state ^ MC13892_POWERMISC_PWGTSPI_M);
+
+        return (val & mc13892_regulators[id].enable_bit) != 0;
+}
+
+
+static struct regulator_ops mc13892_gpo_regulator_ops = {
+        .enable = mc13892_gpo_regulator_enable,
+        .disable = mc13892_gpo_regulator_disable,
+        .is_enabled = mc13892_gpo_regulator_is_enabled,
+        .list_voltage = mc13xxx_regulator_list_voltage,
+        .set_voltage = mc13xxx_fixed_regulator_set_voltage,
+        .get_voltage = mc13xxx_fixed_regulator_get_voltage,
+};
+
+static int mc13892_sw_regulator_get_voltage(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val, hi;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx,
+                mc13892_regulators[id].vsel_reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
+        if (ret)
+                return ret;
+
+        hi  = val & MC13892_SWITCHERS0_SWxHI;
+        val = (val & mc13892_regulators[id].vsel_mask)
+                >> mc13892_regulators[id].vsel_shift;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d val: %d\n", __func__, id, val);
+
+        if (hi)
+                val = (25000 * val) + 1100000;
+        else
+                val = (25000 * val) + 600000;
+
+        return val;
+}
+
+static int mc13892_sw_regulator_set_voltage(struct regulator_dev *rdev,
+                int min_uV, int max_uV, unsigned *selector)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int hi, value, val, mask, id = rdev_get_id(rdev);
+        int ret;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
+                __func__, id, min_uV, max_uV);
+
+        /* Find the best index */
+        value = mc13xxx_get_best_voltage_index(rdev, min_uV, max_uV);
+        dev_dbg(rdev_get_dev(rdev), "%s best value: %d\n", __func__, value);
+        if (value < 0)
+                return value;
+
+        value = mc13892_regulators[id].voltages[value];
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx,
+                mc13892_regulators[id].vsel_reg, &val);
+        if (ret)
+                goto err;
+
+        hi  = val & MC13892_SWITCHERS0_SWxHI;
+        if (value > 1375)
+                hi = 1;
+        if (value < 1100)
+                hi = 0;
+
+        if (hi) {
+                value = (value - 1100000) / 25000;
+                value |= MC13892_SWITCHERS0_SWxHI;
+        } else
+                value = (value - 600000) / 25000;
+
+        mask = mc13892_regulators[id].vsel_mask | MC13892_SWITCHERS0_SWxHI;
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].vsel_reg,
+                        mask, value << mc13892_regulators[id].vsel_shift);
+err:
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static struct regulator_ops mc13892_sw_regulator_ops = {
+        .is_enabled = mc13xxx_sw_regulator_is_enabled,
+        .list_voltage = mc13xxx_regulator_list_voltage,
+        .set_voltage = mc13892_sw_regulator_set_voltage,
+        .get_voltage = mc13892_sw_regulator_get_voltage,
+};
+
+static int mc13892_vcam_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        unsigned int en_val = 0;
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int ret, id = rdev_get_id(rdev);
+
+        if (mode == REGULATOR_MODE_FAST)
+                en_val = MC13892_REGULATORMODE1_VCAMCONFIGEN;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13892_regulators[id].reg,
+                MC13892_REGULATORMODE1_VCAMCONFIGEN, en_val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static unsigned int mc13892_vcam_get_mode(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx, mc13892_regulators[id].reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        if (ret)
+                return ret;
+
+        if (val & MC13892_REGULATORMODE1_VCAMCONFIGEN)
+                return REGULATOR_MODE_FAST;
+
+        return REGULATOR_MODE_NORMAL;
+}
+
+
+static int __devinit mc13892_regulator_probe(struct platform_device *pdev)
+{
+        struct mc13xxx_regulator_priv *priv;
+        struct mc13xxx *mc13892 = dev_get_drvdata(pdev->dev.parent);
+        struct mc13xxx_regulator_platform_data *pdata =
+                dev_get_platdata(&pdev->dev);
+        struct mc13xxx_regulator_init_data *init_data;
+        int i, ret;
+        u32 val;
+
+        priv = kzalloc(sizeof(*priv) +
+                pdata->num_regulators * sizeof(priv->regulators[0]),
+                GFP_KERNEL);
+        if (!priv)
+                return -ENOMEM;
+
+        priv->mc13xxx_regulators = mc13892_regulators;
+        priv->mc13xxx = mc13892;
+
+        mc13xxx_lock(mc13892);
+        ret = mc13xxx_reg_read(mc13892, MC13892_REVISION, &val);
+        if (ret)
+                goto err_free;
+
+        /* enable switch auto mode */
+        if ((val & 0x0000FFFF) == 0x45d0) {
+                ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS4,
+                        MC13892_SWITCHERS4_SW1MODE_M |
+                        MC13892_SWITCHERS4_SW2MODE_M,
+                        MC13892_SWITCHERS4_SW1MODE_AUTO |
+                        MC13892_SWITCHERS4_SW2MODE_AUTO);
+                if (ret)
+                        goto err_free;
+
+                ret = mc13xxx_reg_rmw(mc13892, MC13892_SWITCHERS5,
+                        MC13892_SWITCHERS5_SW3MODE_M |
+                        MC13892_SWITCHERS5_SW4MODE_M,
+                        MC13892_SWITCHERS5_SW3MODE_AUTO |
+                        MC13892_SWITCHERS5_SW4MODE_AUTO);
+                if (ret)
+                        goto err_free;
+        }
+        mc13xxx_unlock(mc13892);
+
+        mc13892_regulators[MC13892_VCAM].desc.ops->set_mode
+                = mc13892_vcam_set_mode;
+        mc13892_regulators[MC13892_VCAM].desc.ops->get_mode
+                = mc13892_vcam_get_mode;
+        for (i = 0; i < pdata->num_regulators; i++) {
+                init_data = &pdata->regulators[i];
+                priv->regulators[i] = regulator_register(
+                        &mc13892_regulators[init_data->id].desc,
+                        &pdev->dev, init_data->init_data, priv);
+
+                if (IS_ERR(priv->regulators[i])) {
+                        dev_err(&pdev->dev, "failed to register regulator %s\n",
+                                mc13892_regulators[i].desc.name);
+                        ret = PTR_ERR(priv->regulators[i]);
+                        goto err;
+                }
+        }
+
+        platform_set_drvdata(pdev, priv);
+
+        return 0;
+err:
+        while (--i >= 0)
+                regulator_unregister(priv->regulators[i]);
+
+err_free:
+        mc13xxx_unlock(mc13892);
+        kfree(priv);
+
+        return ret;
+}
+
+static int __devexit mc13892_regulator_remove(struct platform_device *pdev)
+{
+        struct mc13xxx_regulator_priv *priv = platform_get_drvdata(pdev);
+        struct mc13xxx_regulator_platform_data *pdata =
+                dev_get_platdata(&pdev->dev);
+        int i;
+
+        platform_set_drvdata(pdev, NULL);
+
+        for (i = 0; i < pdata->num_regulators; i++)
+                regulator_unregister(priv->regulators[i]);
+
+        kfree(priv);
+        return 0;
+}
+
+static struct platform_driver mc13892_regulator_driver = {
+        .driver = {
+                .name   = "mc13892-regulator",
+                .owner  = THIS_MODULE,
+        },
+        .remove = __devexit_p(mc13892_regulator_remove),
+        .probe  = mc13892_regulator_probe,
+};
+
+static int __init mc13892_regulator_init(void)
+{
+        return platform_driver_register(&mc13892_regulator_driver);
+}
+subsys_initcall(mc13892_regulator_init);
+
+static void __exit mc13892_regulator_exit(void)
+{
+        platform_driver_unregister(&mc13892_regulator_driver);
+}
+module_exit(mc13892_regulator_exit);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Yong Shen <yong.shen@linaro.org>");
+MODULE_DESCRIPTION("Regulator Driver for Freescale MC13892 PMIC");
+MODULE_ALIAS("platform:mc13892-regulator");
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
new file mode 100644
index 00000000000..f53d31b950d
--- /dev/null
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -0,0 +1,241 @@
+/*
+ * Regulator Driver for Freescale MC13xxx PMIC
+ *
+ * Copyright 2010 Yong Shen <yong.shen@linaro.org>
+ *
+ * Based on mc13783 regulator driver :
+ * Copyright (C) 2008 Sascha Hauer, Pengutronix <s.hauer@pengutronix.de>
+ * Copyright 2009 Alberto Panizzo <maramaopercheseimorto@gmail.com>
+ *
+ * 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.
+ *
+ * Regs infos taken from mc13xxx drivers from freescale and mc13xxx.pdf file
+ * from freescale
+ */
+
+#include <linux/mfd/mc13xxx.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/driver.h>
+#include <linux/platform_device.h>
+#include <linux/kernel.h>
+#include <linux/slab.h>
+#include <linux/init.h>
+#include <linux/err.h>
+#include "mc13xxx.h"
+
+static int mc13xxx_regulator_enable(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int id = rdev_get_id(rdev);
+        int ret;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13xxx_regulators[id].reg,
+                        mc13xxx_regulators[id].enable_bit,
+                        mc13xxx_regulators[id].enable_bit);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static int mc13xxx_regulator_disable(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int id = rdev_get_id(rdev);
+        int ret;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13xxx_regulators[id].reg,
+                        mc13xxx_regulators[id].enable_bit, 0);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static int mc13xxx_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx, mc13xxx_regulators[id].reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        if (ret)
+                return ret;
+
+        return (val & mc13xxx_regulators[id].enable_bit) != 0;
+}
+
+int mc13xxx_regulator_list_voltage(struct regulator_dev *rdev,
+                                                unsigned selector)
+{
+        int id = rdev_get_id(rdev);
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+
+        if (selector >= mc13xxx_regulators[id].desc.n_voltages)
+                return -EINVAL;
+
+        return mc13xxx_regulators[id].voltages[selector];
+}
+EXPORT_SYMBOL_GPL(mc13xxx_regulator_list_voltage);
+
+int mc13xxx_get_best_voltage_index(struct regulator_dev *rdev,
+                                                int min_uV, int max_uV)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int reg_id = rdev_get_id(rdev);
+        int i;
+        int bestmatch;
+        int bestindex;
+
+        /*
+         * Locate the minimum voltage fitting the criteria on
+         * this regulator. The switchable voltages are not
+         * in strict falling order so we need to check them
+         * all for the best match.
+         */
+        bestmatch = INT_MAX;
+        bestindex = -1;
+        for (i = 0; i < mc13xxx_regulators[reg_id].desc.n_voltages; i++) {
+                if (mc13xxx_regulators[reg_id].voltages[i] >= min_uV &&
+                    mc13xxx_regulators[reg_id].voltages[i] < bestmatch) {
+                        bestmatch = mc13xxx_regulators[reg_id].voltages[i];
+                        bestindex = i;
+                }
+        }
+
+        if (bestindex < 0 || bestmatch > max_uV) {
+                dev_warn(&rdev->dev, "no possible value for %d<=x<=%d uV\n",
+                                min_uV, max_uV);
+                return -EINVAL;
+        }
+        return bestindex;
+}
+EXPORT_SYMBOL_GPL(mc13xxx_get_best_voltage_index);
+
+static int mc13xxx_regulator_set_voltage(struct regulator_dev *rdev, int min_uV,
+                int max_uV, unsigned *selector)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int value, id = rdev_get_id(rdev);
+        int ret;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
+                __func__, id, min_uV, max_uV);
+
+        /* Find the best index */
+        value = mc13xxx_get_best_voltage_index(rdev, min_uV, max_uV);
+        dev_dbg(rdev_get_dev(rdev), "%s best value: %d\n", __func__, value);
+        if (value < 0)
+                return value;
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_rmw(priv->mc13xxx, mc13xxx_regulators[id].vsel_reg,
+                        mc13xxx_regulators[id].vsel_mask,
+                        value << mc13xxx_regulators[id].vsel_shift);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        return ret;
+}
+
+static int mc13xxx_regulator_get_voltage(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int ret, id = rdev_get_id(rdev);
+        unsigned int val;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        mc13xxx_lock(priv->mc13xxx);
+        ret = mc13xxx_reg_read(priv->mc13xxx,
+                                mc13xxx_regulators[id].vsel_reg, &val);
+        mc13xxx_unlock(priv->mc13xxx);
+
+        if (ret)
+                return ret;
+
+        val = (val & mc13xxx_regulators[id].vsel_mask)
+                >> mc13xxx_regulators[id].vsel_shift;
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d val: %d\n", __func__, id, val);
+
+        BUG_ON(val < 0 || val > mc13xxx_regulators[id].desc.n_voltages);
+
+        return mc13xxx_regulators[id].voltages[val];
+}
+
+struct regulator_ops mc13xxx_regulator_ops = {
+        .enable = mc13xxx_regulator_enable,
+        .disable = mc13xxx_regulator_disable,
+        .is_enabled = mc13xxx_regulator_is_enabled,
+        .list_voltage = mc13xxx_regulator_list_voltage,
+        .set_voltage = mc13xxx_regulator_set_voltage,
+        .get_voltage = mc13xxx_regulator_get_voltage,
+};
+EXPORT_SYMBOL_GPL(mc13xxx_regulator_ops);
+
+int mc13xxx_fixed_regulator_set_voltage(struct regulator_dev *rdev, int min_uV,
+               int max_uV, unsigned *selector)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int id = rdev_get_id(rdev);
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d min_uV: %d max_uV: %d\n",
+                __func__, id, min_uV, max_uV);
+
+        if (min_uV >= mc13xxx_regulators[id].voltages[0] &&
+            max_uV <= mc13xxx_regulators[id].voltages[0])
+                return 0;
+        else
+                return -EINVAL;
+}
+EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_set_voltage);
+
+int mc13xxx_fixed_regulator_get_voltage(struct regulator_dev *rdev)
+{
+        struct mc13xxx_regulator_priv *priv = rdev_get_drvdata(rdev);
+        struct mc13xxx_regulator *mc13xxx_regulators = priv->mc13xxx_regulators;
+        int id = rdev_get_id(rdev);
+
+        dev_dbg(rdev_get_dev(rdev), "%s id: %d\n", __func__, id);
+
+        return mc13xxx_regulators[id].voltages[0];
+}
+EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_get_voltage);
+
+struct regulator_ops mc13xxx_fixed_regulator_ops = {
+        .enable = mc13xxx_regulator_enable,
+        .disable = mc13xxx_regulator_disable,
+        .is_enabled = mc13xxx_regulator_is_enabled,
+        .list_voltage = mc13xxx_regulator_list_voltage,
+        .set_voltage = mc13xxx_fixed_regulator_set_voltage,
+        .get_voltage = mc13xxx_fixed_regulator_get_voltage,
+};
+EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_ops);
+
+int mc13xxx_sw_regulator_is_enabled(struct regulator_dev *rdev)
+{
+        return 1;
+}
+EXPORT_SYMBOL_GPL(mc13xxx_sw_regulator_is_enabled);
+
+MODULE_LICENSE("GPL v2");
+MODULE_AUTHOR("Yong Shen <yong.shen@linaro.org>");
+MODULE_DESCRIPTION("Regulator Driver for Freescale MC13xxx PMIC");
+MODULE_ALIAS("mc13xxx-regulator-core");
diff --git a/drivers/regulator/mc13xxx.h b/drivers/regulator/mc13xxx.h
new file mode 100644
index 00000000000..27758267e12
--- /dev/null
+++ b/drivers/regulator/mc13xxx.h
@@ -0,0 +1,101 @@
+/*
+ * mc13xxx.h - regulators for the Freescale mc13xxx PMIC
+ *
+ *  Copyright (C) 2010 Yong Shen <yong.shen@linaro.org>
+ *
+ * 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 __LINUX_REGULATOR_MC13XXX_H
+#define __LINUX_REGULATOR_MC13XXX_H
+
+#include <linux/regulator/driver.h>
+
+struct mc13xxx_regulator {
+        struct regulator_desc desc;
+        int reg;
+        int enable_bit;
+        int vsel_reg;
+        int vsel_shift;
+        int vsel_mask;
+        int hi_bit;
+        int const *voltages;
+};
+
+struct mc13xxx_regulator_priv {
+        struct mc13xxx *mc13xxx;
+        u32 powermisc_pwgt_state;
+        struct mc13xxx_regulator *mc13xxx_regulators;
+        struct regulator_dev *regulators[];
+};
+
+extern int mc13xxx_sw_regulator(struct regulator_dev *rdev);
+extern int mc13xxx_sw_regulator_is_enabled(struct regulator_dev *rdev);
+extern int mc13xxx_get_best_voltage_index(struct regulator_dev *rdev,
+                                                int min_uV, int max_uV);
+extern int mc13xxx_regulator_list_voltage(struct regulator_dev *rdev,
+                                                unsigned selector);
+extern int mc13xxx_fixed_regulator_set_voltage(struct regulator_dev *rdev,
+                int min_uV, int max_uV, unsigned *selector);
+extern int mc13xxx_fixed_regulator_get_voltage(struct regulator_dev *rdev);
+
+extern struct regulator_ops mc13xxx_regulator_ops;
+extern struct regulator_ops mc13xxx_fixed_regulator_ops;
+
+#define MC13xxx_DEFINE(prefix, _name, _reg, _vsel_reg, _voltages, _ops) \
+        [prefix ## _name] = {                           \
+                .desc = {                                               \
+                        .name = #prefix "_" #_name,                     \
+                        .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .ops = &_ops,                   \
+                        .type = REGULATOR_VOLTAGE,                      \
+                        .id = prefix ## _name,          \
+                        .owner = THIS_MODULE,                           \
+                },                                                      \
+                .reg = prefix ## _reg,                          \
+                .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
+                .vsel_reg = prefix ## _vsel_reg,                        \
+                .vsel_shift = prefix ## _vsel_reg ## _ ## _name ## VSEL,\
+                .vsel_mask = prefix ## _vsel_reg ## _ ## _name ## VSEL_M,\
+                .voltages =  _voltages,                                 \
+        }
+
+#define MC13xxx_FIXED_DEFINE(prefix, _name, _reg, _voltages, _ops)      \
+        [prefix ## _name] = {                           \
+                .desc = {                                               \
+                        .name = #prefix "_" #_name,                     \
+                        .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .ops = &_ops,           \
+                        .type = REGULATOR_VOLTAGE,                      \
+                        .id = prefix ## _name,          \
+                        .owner = THIS_MODULE,                           \
+                },                                                      \
+                .reg = prefix ## _reg,                          \
+                .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
+                .voltages =  _voltages,                                 \
+        }
+
+#define MC13xxx_GPO_DEFINE(prefix, _name, _reg,  _voltages, _ops)       \
+        [prefix ## _name] = {                           \
+                .desc = {                                               \
+                        .name = #prefix "_" #_name,                     \
+                        .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .ops = &_ops,           \
+                        .type = REGULATOR_VOLTAGE,                      \
+                        .id = prefix ## _name,          \
+                        .owner = THIS_MODULE,                           \
+                },                                                      \
+                .reg = prefix ## _reg,                          \
+                .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
+                .voltages =  _voltages,                                 \
+        }
+
+#define MC13xxx_DEFINE_SW(_name, _reg, _vsel_reg, _voltages, ops)       \
+        MC13xxx_DEFINE(SW, _name, _reg, _vsel_reg, _voltages, ops)
+#define MC13xxx_DEFINE_REGU(_name, _reg, _vsel_reg, _voltages, ops)     \
+        MC13xxx_DEFINE(REGU, _name, _reg, _vsel_reg, _voltages, ops)
+
+#endif
diff --git a/drivers/regulator/pcap-regulator.c b/drivers/regulator/pcap-regulator.c
index 29d0566379a..31f6e11a7f1 100644
--- a/drivers/regulator/pcap-regulator.c
+++ b/drivers/regulator/pcap-regulator.c
@@ -151,7 +151,8 @@ static struct pcap_regulator vreg_table[] = {
 };
 
 static int pcap_regulator_set_voltage(struct regulator_dev *rdev,
-                                                int min_uV, int max_uV)
+                                      int min_uV, int max_uV,
+                                      unsigned *selector)
 {
         struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
         void *pcap = rdev_get_drvdata(rdev);
@@ -170,10 +171,12 @@ static int pcap_regulator_set_voltage(struct regulator_dev *rdev,
                         i = 0;
 
                 uV = vreg->voltage_table[i] * 1000;
-                if (min_uV <= uV && uV <= max_uV)
+                if (min_uV <= uV && uV <= max_uV) {
+                        *selector = i;
                         return ezx_pcap_set_bits(pcap, vreg->reg,
                                         (vreg->n_voltages - 1) << vreg->index,
                                         i << vreg->index);
+                }
 
                 if (i == 0 && rdev_get_id(rdev) == V1)
                         i = vreg->n_voltages - 1;
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
index c8f41dc05b7..69a11d9dd87 100644
--- a/drivers/regulator/pcf50633-regulator.c
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -108,7 +108,8 @@ static unsigned int ldo_voltage_value(u8 bits)
 }
 
 static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
-                                                int min_uV, int max_uV)
+                                          int min_uV, int max_uV,
+                                          unsigned *selector)
 {
         struct pcf50633 *pcf;
         int regulator_id, millivolts;
@@ -147,6 +148,8 @@ static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
+        *selector = volt_bits;
+
         return pcf50633_reg_write(pcf, regnr, volt_bits);
 }
 
diff --git a/drivers/regulator/tps65023-regulator.c b/drivers/regulator/tps65023-regulator.c
index cd6d4fc9d74..60a7ca5409e 100644
--- a/drivers/regulator/tps65023-regulator.c
+++ b/drivers/regulator/tps65023-regulator.c
@@ -321,7 +321,8 @@ static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
 }
 
 static int tps65023_dcdc_set_voltage(struct regulator_dev *dev,
-                                int min_uV, int max_uV)
+                                     int min_uV, int max_uV,
+                                     unsigned *selector)
 {
         struct tps_pmic *tps = rdev_get_drvdata(dev);
         int dcdc = rdev_get_id(dev);
@@ -346,6 +347,8 @@ static int tps65023_dcdc_set_voltage(struct regulator_dev *dev,
                         break;
         }
 
+        *selector = vsel;
+
         /* write to the register in case we found a match */
         if (vsel == tps->info[dcdc]->table_len)
                 return -EINVAL;
@@ -371,7 +374,7 @@ static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
 }
 
 static int tps65023_ldo_set_voltage(struct regulator_dev *dev,
-                                int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct tps_pmic *tps = rdev_get_drvdata(dev);
         int data, vsel, ldo = rdev_get_id(dev);
@@ -396,6 +399,8 @@ static int tps65023_ldo_set_voltage(struct regulator_dev *dev,
         if (vsel == tps->info[ldo]->table_len)
                 return -EINVAL;
 
+        *selector = vsel;
+
         data = tps_65023_reg_read(tps, TPS65023_REG_LDO_CTRL);
         if (data < 0)
                 return data;
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index 020f5878d7f..06475529059 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -369,7 +369,8 @@ static int tps6507x_pmic_dcdc_get_voltage(struct regulator_dev *dev)
 }
 
 static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev,
-                                int min_uV, int max_uV)
+                                          int min_uV, int max_uV,
+                                          unsigned *selector)
 {
         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, vsel, dcdc = rdev_get_id(dev);
@@ -415,6 +416,8 @@ static int tps6507x_pmic_dcdc_set_voltage(struct regulator_dev *dev,
         if (vsel == tps->info[dcdc]->table_len)
                 return -EINVAL;
 
+        *selector = vsel;
+
         data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
@@ -450,7 +453,8 @@ static int tps6507x_pmic_ldo_get_voltage(struct regulator_dev *dev)
 }
 
 static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev,
-                                int min_uV, int max_uV)
+                                         int min_uV, int max_uV,
+                                         unsigned *selector)
 {
         struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
         int data, vsel, ldo = rdev_get_id(dev);
@@ -483,6 +487,8 @@ static int tps6507x_pmic_ldo_set_voltage(struct regulator_dev *dev,
         if (vsel == tps->info[ldo]->table_len)
                 return -EINVAL;
 
+        *selector = vsel;
+
         data = tps6507x_pmic_reg_read(tps, reg);
         if (data < 0)
                 return data;
diff --git a/drivers/regulator/tps6524x-regulator.c b/drivers/regulator/tps6524x-regulator.c
new file mode 100644
index 00000000000..176a6be5a8c
--- /dev/null
+++ b/drivers/regulator/tps6524x-regulator.c
@@ -0,0 +1,693 @@
+/*
+ * Regulator driver for TPS6524x PMIC
+ *
+ * Copyright (C) 2010 Texas Instruments
+ *
+ * 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.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
+ * whether express or implied; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/err.h>
+#include <linux/errno.h>
+#include <linux/slab.h>
+#include <linux/spi/spi.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+
+#define REG_LDO_SET             0x0
+#define LDO_ILIM_MASK           1       /* 0 = 400-800, 1 = 900-1500 */
+#define LDO_VSEL_MASK           0x0f
+#define LDO2_ILIM_SHIFT         12
+#define LDO2_VSEL_SHIFT         4
+#define LDO1_ILIM_SHIFT         8
+#define LDO1_VSEL_SHIFT         0
+
+#define REG_BLOCK_EN            0x1
+#define BLOCK_MASK              1
+#define BLOCK_LDO1_SHIFT        0
+#define BLOCK_LDO2_SHIFT        1
+#define BLOCK_LCD_SHIFT         2
+#define BLOCK_USB_SHIFT         3
+
+#define REG_DCDC_SET            0x2
+#define DCDC_VDCDC_MASK         0x1f
+#define DCDC_VDCDC1_SHIFT       0
+#define DCDC_VDCDC2_SHIFT       5
+#define DCDC_VDCDC3_SHIFT       10
+
+#define REG_DCDC_EN             0x3
+#define DCDCDCDC_EN_MASK        0x1
+#define DCDCDCDC1_EN_SHIFT      0
+#define DCDCDCDC1_PG_MSK        BIT(1)
+#define DCDCDCDC2_EN_SHIFT      2
+#define DCDCDCDC2_PG_MSK        BIT(3)
+#define DCDCDCDC3_EN_SHIFT      4
+#define DCDCDCDC3_PG_MSK        BIT(5)
+
+#define REG_USB                 0x4
+#define USB_ILIM_SHIFT          0
+#define USB_ILIM_MASK           0x3
+#define USB_TSD_SHIFT           2
+#define USB_TSD_MASK            0x3
+#define USB_TWARN_SHIFT         4
+#define USB_TWARN_MASK          0x3
+#define USB_IWARN_SD            BIT(6)
+#define USB_FAST_LOOP           BIT(7)
+
+#define REG_ALARM               0x5
+#define ALARM_LDO1              BIT(0)
+#define ALARM_DCDC1             BIT(1)
+#define ALARM_DCDC2             BIT(2)
+#define ALARM_DCDC3             BIT(3)
+#define ALARM_LDO2              BIT(4)
+#define ALARM_USB_WARN          BIT(5)
+#define ALARM_USB_ALARM         BIT(6)
+#define ALARM_LCD               BIT(9)
+#define ALARM_TEMP_WARM         BIT(10)
+#define ALARM_TEMP_HOT          BIT(11)
+#define ALARM_NRST              BIT(14)
+#define ALARM_POWERUP           BIT(15)
+
+#define REG_INT_ENABLE          0x6
+#define INT_LDO1                BIT(0)
+#define INT_DCDC1               BIT(1)
+#define INT_DCDC2               BIT(2)
+#define INT_DCDC3               BIT(3)
+#define INT_LDO2                BIT(4)
+#define INT_USB_WARN            BIT(5)
+#define INT_USB_ALARM           BIT(6)
+#define INT_LCD                 BIT(9)
+#define INT_TEMP_WARM           BIT(10)
+#define INT_TEMP_HOT            BIT(11)
+#define INT_GLOBAL_EN           BIT(15)
+
+#define REG_INT_STATUS          0x7
+#define STATUS_LDO1             BIT(0)
+#define STATUS_DCDC1            BIT(1)
+#define STATUS_DCDC2            BIT(2)
+#define STATUS_DCDC3            BIT(3)
+#define STATUS_LDO2             BIT(4)
+#define STATUS_USB_WARN         BIT(5)
+#define STATUS_USB_ALARM        BIT(6)
+#define STATUS_LCD              BIT(9)
+#define STATUS_TEMP_WARM        BIT(10)
+#define STATUS_TEMP_HOT         BIT(11)
+
+#define REG_SOFTWARE_RESET      0xb
+#define REG_WRITE_ENABLE        0xd
+#define REG_REV_ID              0xf
+
+#define N_DCDC                  3
+#define N_LDO                   2
+#define N_SWITCH                2
+#define N_REGULATORS            (3 /* DCDC */ + \
+                                 2 /* LDO */  + \
+                                 2 /* switch */)
+
+#define FIXED_ILIMSEL           BIT(0)
+#define FIXED_VOLTAGE           BIT(1)
+
+#define CMD_READ(reg)           ((reg) << 6)
+#define CMD_WRITE(reg)          (BIT(5) | (reg) << 6)
+#define STAT_CLK                BIT(3)
+#define STAT_WRITE              BIT(2)
+#define STAT_INVALID            BIT(1)
+#define STAT_WP                 BIT(0)
+
+struct field {
+        int             reg;
+        int             shift;
+        int             mask;
+};
+
+struct supply_info {
+        const char      *name;
+        int             n_voltages;
+        const int       *voltages;
+        int             fixed_voltage;
+        int             n_ilimsels;
+        const int       *ilimsels;
+        int             fixed_ilimsel;
+        int             flags;
+        struct field    enable, voltage, ilimsel;
+};
+
+struct tps6524x {
+        struct device           *dev;
+        struct spi_device       *spi;
+        struct mutex            lock;
+        struct regulator_desc   desc[N_REGULATORS];
+        struct regulator_dev    *rdev[N_REGULATORS];
+};
+
+static int __read_reg(struct tps6524x *hw, int reg)
+{
+        int error = 0;
+        u16 cmd = CMD_READ(reg), in;
+        u8 status;
+        struct spi_message m;
+        struct spi_transfer t[3];
+
+        spi_message_init(&m);
+        memset(t, 0, sizeof(t));
+
+        t[0].tx_buf = &cmd;
+        t[0].len = 2;
+        t[0].bits_per_word = 12;
+        spi_message_add_tail(&t[0], &m);
+
+        t[1].rx_buf = &in;
+        t[1].len = 2;
+        t[1].bits_per_word = 16;
+        spi_message_add_tail(&t[1], &m);
+
+        t[2].rx_buf = &status;
+        t[2].len = 1;
+        t[2].bits_per_word = 4;
+        spi_message_add_tail(&t[2], &m);
+
+        error = spi_sync(hw->spi, &m);
+        if (error < 0)
+                return error;
+
+        dev_dbg(hw->dev, "read reg %d, data %x, status %x\n",
+                reg, in, status);
+
+        if (!(status & STAT_CLK) || (status & STAT_WRITE))
+                return -EIO;
+
+        if (status & STAT_INVALID)
+                return -EINVAL;
+
+        return in;
+}
+
+static int read_reg(struct tps6524x *hw, int reg)
+{
+        int ret;
+
+        mutex_lock(&hw->lock);
+        ret = __read_reg(hw, reg);
+        mutex_unlock(&hw->lock);
+
+        return ret;
+}
+
+static int __write_reg(struct tps6524x *hw, int reg, int val)
+{
+        int error = 0;
+        u16 cmd = CMD_WRITE(reg), out = val;
+        u8 status;
+        struct spi_message m;
+        struct spi_transfer t[3];
+
+        spi_message_init(&m);
+        memset(t, 0, sizeof(t));
+
+        t[0].tx_buf = &cmd;
+        t[0].len = 2;
+        t[0].bits_per_word = 12;
+        spi_message_add_tail(&t[0], &m);
+
+        t[1].tx_buf = &out;
+        t[1].len = 2;
+        t[1].bits_per_word = 16;
+        spi_message_add_tail(&t[1], &m);
+
+        t[2].rx_buf = &status;
+        t[2].len = 1;
+        t[2].bits_per_word = 4;
+        spi_message_add_tail(&t[2], &m);
+
+        error = spi_sync(hw->spi, &m);
+        if (error < 0)
+                return error;
+
+        dev_dbg(hw->dev, "wrote reg %d, data %x, status %x\n",
+                reg, out, status);
+
+        if (!(status & STAT_CLK) || !(status & STAT_WRITE))
+                return -EIO;
+
+        if (status & (STAT_INVALID | STAT_WP))
+                return -EINVAL;
+
+        return error;
+}
+
+static int __rmw_reg(struct tps6524x *hw, int reg, int mask, int val)
+{
+        int ret;
+
+        ret = __read_reg(hw, reg);
+        if (ret < 0)
+                return ret;
+
+        ret &= ~mask;
+        ret |= val;
+
+        ret = __write_reg(hw, reg, ret);
+
+        return (ret < 0) ? ret : 0;
+}
+
+static int rmw_protect(struct tps6524x *hw, int reg, int mask, int val)
+{
+        int ret;
+
+        mutex_lock(&hw->lock);
+
+        ret = __write_reg(hw, REG_WRITE_ENABLE, 1);
+        if (ret) {
+                dev_err(hw->dev, "failed to set write enable\n");
+                goto error;
+        }
+
+        ret = __rmw_reg(hw, reg, mask, val);
+        if (ret)
+                dev_err(hw->dev, "failed to rmw register %d\n", reg);
+
+        ret = __write_reg(hw, REG_WRITE_ENABLE, 0);
+        if (ret) {
+                dev_err(hw->dev, "failed to clear write enable\n");
+                goto error;
+        }
+
+error:
+        mutex_unlock(&hw->lock);
+
+        return ret;
+}
+
+static int read_field(struct tps6524x *hw, const struct field *field)
+{
+        int tmp;
+
+        tmp = read_reg(hw, field->reg);
+        if (tmp < 0)
+                return tmp;
+
+        return (tmp >> field->shift) & field->mask;
+}
+
+static int write_field(struct tps6524x *hw, const struct field *field,
+                       int val)
+{
+        if (val & ~field->mask)
+                return -EOVERFLOW;
+
+        return rmw_protect(hw, field->reg,
+                                    field->mask << field->shift,
+                                    val << field->shift);
+}
+
+static const int dcdc1_voltages[] = {
+         800000,  825000,  850000,  875000,
+         900000,  925000,  950000,  975000,
+        1000000, 1025000, 1050000, 1075000,
+        1100000, 1125000, 1150000, 1175000,
+        1200000, 1225000, 1250000, 1275000,
+        1300000, 1325000, 1350000, 1375000,
+        1400000, 1425000, 1450000, 1475000,
+        1500000, 1525000, 1550000, 1575000,
+};
+
+static const int dcdc2_voltages[] = {
+        1400000, 1450000, 1500000, 1550000,
+        1600000, 1650000, 1700000, 1750000,
+        1800000, 1850000, 1900000, 1950000,
+        2000000, 2050000, 2100000, 2150000,
+        2200000, 2250000, 2300000, 2350000,
+        2400000, 2450000, 2500000, 2550000,
+        2600000, 2650000, 2700000, 2750000,
+        2800000, 2850000, 2900000, 2950000,
+};
+
+static const int dcdc3_voltages[] = {
+        2400000, 2450000, 2500000, 2550000, 2600000,
+        2650000, 2700000, 2750000, 2800000, 2850000,
+        2900000, 2950000, 3000000, 3050000, 3100000,
+        3150000, 3200000, 3250000, 3300000, 3350000,
+        3400000, 3450000, 3500000, 3550000, 3600000,
+};
+
+static const int ldo1_voltages[] = {
+        4300000, 4350000, 4400000, 4450000,
+        4500000, 4550000, 4600000, 4650000,
+        4700000, 4750000, 4800000, 4850000,
+        4900000, 4950000, 5000000, 5050000,
+};
+
+static const int ldo2_voltages[] = {
+        1100000, 1150000, 1200000, 1250000,
+        1300000, 1700000, 1750000, 1800000,
+        1850000, 1900000, 3150000, 3200000,
+        3250000, 3300000, 3350000, 3400000,
+};
+
+static const int ldo_ilimsel[] = {
+        400000, 1500000
+};
+
+static const int usb_ilimsel[] = {
+        200000, 400000, 800000, 1000000
+};
+
+#define __MK_FIELD(_reg, _mask, _shift) \
+        { .reg = (_reg), .mask = (_mask), .shift = (_shift), }
+
+static const struct supply_info supply_info[N_REGULATORS] = {
+        {
+                .name           = "DCDC1",
+                .flags          = FIXED_ILIMSEL,
+                .n_voltages     = ARRAY_SIZE(dcdc1_voltages),
+                .voltages       = dcdc1_voltages,
+                .fixed_ilimsel  = 2400000,
+                .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
+                                             DCDCDCDC1_EN_SHIFT),
+                .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
+                                             DCDC_VDCDC1_SHIFT),
+        },
+        {
+                .name           = "DCDC2",
+                .flags          = FIXED_ILIMSEL,
+                .n_voltages     = ARRAY_SIZE(dcdc2_voltages),
+                .voltages       = dcdc2_voltages,
+                .fixed_ilimsel  = 1200000,
+                .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
+                                             DCDCDCDC2_EN_SHIFT),
+                .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
+                                             DCDC_VDCDC2_SHIFT),
+        },
+        {
+                .name           = "DCDC3",
+                .flags          = FIXED_ILIMSEL,
+                .n_voltages     = ARRAY_SIZE(dcdc3_voltages),
+                .voltages       = dcdc3_voltages,
+                .fixed_ilimsel  = 1200000,
+                .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
+                                        DCDCDCDC3_EN_SHIFT),
+                .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
+                                             DCDC_VDCDC3_SHIFT),
+        },
+        {
+                .name           = "LDO1",
+                .n_voltages     = ARRAY_SIZE(ldo1_voltages),
+                .voltages       = ldo1_voltages,
+                .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
+                .ilimsels       = ldo_ilimsel,
+                .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
+                                             BLOCK_LDO1_SHIFT),
+                .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
+                                             LDO1_VSEL_SHIFT),
+                .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
+                                             LDO1_ILIM_SHIFT),
+        },
+        {
+                .name           = "LDO2",
+                .n_voltages     = ARRAY_SIZE(ldo2_voltages),
+                .voltages       = ldo2_voltages,
+                .n_ilimsels     = ARRAY_SIZE(ldo_ilimsel),
+                .ilimsels       = ldo_ilimsel,
+                .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
+                                             BLOCK_LDO2_SHIFT),
+                .voltage        = __MK_FIELD(REG_LDO_SET, LDO_VSEL_MASK,
+                                             LDO2_VSEL_SHIFT),
+                .ilimsel        = __MK_FIELD(REG_LDO_SET, LDO_ILIM_MASK,
+                                             LDO2_ILIM_SHIFT),
+        },
+        {
+                .name           = "USB",
+                .flags          = FIXED_VOLTAGE,
+                .fixed_voltage  = 5000000,
+                .n_ilimsels     = ARRAY_SIZE(usb_ilimsel),
+                .ilimsels       = usb_ilimsel,
+                .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
+                                             BLOCK_USB_SHIFT),
+                .ilimsel        = __MK_FIELD(REG_USB, USB_ILIM_MASK,
+                                             USB_ILIM_SHIFT),
+        },
+        {
+                .name           = "LCD",
+                .flags          = FIXED_VOLTAGE | FIXED_ILIMSEL,
+                .fixed_voltage  = 5000000,
+                .fixed_ilimsel  =  400000,
+                .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
+                                             BLOCK_LCD_SHIFT),
+        },
+};
+
+static int list_voltage(struct regulator_dev *rdev, unsigned selector)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        if (info->flags & FIXED_VOLTAGE)
+                return selector ? -EINVAL : info->fixed_voltage;
+
+        return ((selector < info->n_voltages) ?
+                info->voltages[selector] : -EINVAL);
+}
+
+static int set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
+                       unsigned *selector)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+        unsigned i;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        if (info->flags & FIXED_VOLTAGE)
+                return -EINVAL;
+
+        for (i = 0; i < info->n_voltages; i++)
+                if (min_uV <= info->voltages[i] &&
+                    max_uV >= info->voltages[i])
+                        break;
+
+        if (i >= info->n_voltages)
+                i = info->n_voltages - 1;
+
+        *selector = info->voltages[i];
+
+        return write_field(hw, &info->voltage, i);
+}
+
+static int get_voltage(struct regulator_dev *rdev)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+        int ret;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        if (info->flags & FIXED_VOLTAGE)
+                return info->fixed_voltage;
+
+        ret = read_field(hw, &info->voltage);
+        if (ret < 0)
+                return ret;
+        if (WARN_ON(ret >= info->n_voltages))
+                return -EIO;
+
+        return info->voltages[ret];
+}
+
+static int set_current_limit(struct regulator_dev *rdev, int min_uA,
+                             int max_uA)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+        int i;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        if (info->flags & FIXED_ILIMSEL)
+                return -EINVAL;
+
+        for (i = 0; i < info->n_ilimsels; i++)
+                if (min_uA <= info->ilimsels[i] &&
+                    max_uA >= info->ilimsels[i])
+                        break;
+
+        if (i >= info->n_ilimsels)
+                return -EINVAL;
+
+        return write_field(hw, &info->ilimsel, i);
+}
+
+static int get_current_limit(struct regulator_dev *rdev)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+        int ret;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        if (info->flags & FIXED_ILIMSEL)
+                return info->fixed_ilimsel;
+
+        ret = read_field(hw, &info->ilimsel);
+        if (ret < 0)
+                return ret;
+        if (WARN_ON(ret >= info->n_ilimsels))
+                return -EIO;
+
+        return info->ilimsels[ret];
+}
+
+static int enable_supply(struct regulator_dev *rdev)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        return write_field(hw, &info->enable, 1);
+}
+
+static int disable_supply(struct regulator_dev *rdev)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        return write_field(hw, &info->enable, 0);
+}
+
+static int is_supply_enabled(struct regulator_dev *rdev)
+{
+        const struct supply_info *info;
+        struct tps6524x *hw;
+
+        hw      = rdev_get_drvdata(rdev);
+        info    = &supply_info[rdev_get_id(rdev)];
+
+        return read_field(hw, &info->enable);
+}
+
+static struct regulator_ops regulator_ops = {
+        .is_enabled             = is_supply_enabled,
+        .enable                 = enable_supply,
+        .disable                = disable_supply,
+        .get_voltage            = get_voltage,
+        .set_voltage            = set_voltage,
+        .list_voltage           = list_voltage,
+        .set_current_limit      = set_current_limit,
+        .get_current_limit      = get_current_limit,
+};
+
+static int __devexit pmic_remove(struct spi_device *spi)
+{
+        struct tps6524x *hw = spi_get_drvdata(spi);
+        int i;
+
+        if (!hw)
+                return 0;
+        for (i = 0; i < N_REGULATORS; i++) {
+                if (hw->rdev[i])
+                        regulator_unregister(hw->rdev[i]);
+                hw->rdev[i] = NULL;
+        }
+        spi_set_drvdata(spi, NULL);
+        kfree(hw);
+        return 0;
+}
+
+static int __devinit pmic_probe(struct spi_device *spi)
+{
+        struct tps6524x *hw;
+        struct device *dev = &spi->dev;
+        const struct supply_info *info = supply_info;
+        struct regulator_init_data *init_data;
+        int ret = 0, i;
+
+        init_data = dev->platform_data;
+        if (!init_data) {
+                dev_err(dev, "could not find regulator platform data\n");
+                return -EINVAL;
+        }
+
+        hw = kzalloc(sizeof(struct tps6524x), GFP_KERNEL);
+        if (!hw) {
+                dev_err(dev, "cannot allocate regulator private data\n");
+                return -ENOMEM;
+        }
+        spi_set_drvdata(spi, hw);
+
+        memset(hw, 0, sizeof(struct tps6524x));
+        hw->dev = dev;
+        hw->spi = spi_dev_get(spi);
+        mutex_init(&hw->lock);
+
+        for (i = 0; i < N_REGULATORS; i++, info++, init_data++) {
+                hw->desc[i].name        = info->name;
+                hw->desc[i].id          = i;
+                hw->desc[i].n_voltages  = info->n_voltages;
+                hw->desc[i].ops         = &regulator_ops;
+                hw->desc[i].type        = REGULATOR_VOLTAGE;
+                hw->desc[i].owner       = THIS_MODULE;
+
+                if (info->flags & FIXED_VOLTAGE)
+                        hw->desc[i].n_voltages = 1;
+
+                hw->rdev[i] = regulator_register(&hw->desc[i], dev,
+                                                 init_data, hw);
+                if (IS_ERR(hw->rdev[i])) {
+                        ret = PTR_ERR(hw->rdev[i]);
+                        hw->rdev[i] = NULL;
+                        goto fail;
+                }
+        }
+
+        return 0;
+
+fail:
+        pmic_remove(spi);
+        return ret;
+}
+
+static struct spi_driver pmic_driver = {
+        .probe          = pmic_probe,
+        .remove         = __devexit_p(pmic_remove),
+        .driver         = {
+                .name   = "tps6524x",
+                .owner  = THIS_MODULE,
+        },
+};
+
+static int __init pmic_driver_init(void)
+{
+        return spi_register_driver(&pmic_driver);
+}
+module_init(pmic_driver_init);
+
+static void __exit pmic_driver_exit(void)
+{
+        spi_unregister_driver(&pmic_driver);
+}
+module_exit(pmic_driver_exit);
+
+MODULE_DESCRIPTION("TPS6524X PMIC Driver");
+MODULE_AUTHOR("Cyril Chemparathy");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("spi:tps6524x");
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index 6d20b0454a1..bb04a75a4c9 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -85,7 +85,8 @@ static int tps6586x_ldo_list_voltage(struct regulator_dev *rdev,
 
 static int __tps6586x_ldo_set_voltage(struct device *parent,
                                       struct tps6586x_regulator *ri,
-                                      int min_uV, int max_uV)
+                                      int min_uV, int max_uV,
+                                      unsigned *selector)
 {
         int val, uV;
         uint8_t mask;
@@ -100,6 +101,8 @@ static int __tps6586x_ldo_set_voltage(struct device *parent,
                 /* use the first in-range value */
                 if (min_uV <= uV && uV <= max_uV) {
 
+                        *selector = val;
+
                         val <<= ri->volt_shift;
                         mask = ((1 << ri->volt_nbits) - 1) << ri->volt_shift;
 
@@ -111,12 +114,13 @@ static int __tps6586x_ldo_set_voltage(struct device *parent,
 }
 
 static int tps6586x_ldo_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
         struct device *parent = to_tps6586x_dev(rdev);
 
-        return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV);
+        return __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
+                                          selector);
 }
 
 static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
@@ -140,13 +144,14 @@ static int tps6586x_ldo_get_voltage(struct regulator_dev *rdev)
 }
 
 static int tps6586x_dvm_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct tps6586x_regulator *ri = rdev_get_drvdata(rdev);
         struct device *parent = to_tps6586x_dev(rdev);
         int ret;
 
-        ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV);
+        ret = __tps6586x_ldo_set_voltage(parent, ri, min_uV, max_uV,
+                                         selector);
         if (ret)
                 return ret;
 
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index a57262a4fa6..bd332cf1cc3 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -329,7 +329,8 @@ static int twl4030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
 }
 
 static int
-twl4030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV)
+twl4030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
+                       unsigned *selector)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
         int                     vsel;
@@ -345,9 +346,11 @@ twl4030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV)
                 /* REVISIT for VAUX2, first match may not be best/lowest */
 
                 /* use the first in-range value */
-                if (min_uV <= uV && uV <= max_uV)
+                if (min_uV <= uV && uV <= max_uV) {
+                        *selector = vsel;
                         return twlreg_write(info, TWL_MODULE_PM_RECEIVER,
                                                         VREG_VOLTAGE, vsel);
+                }
         }
 
         return -EDOM;
@@ -389,7 +392,8 @@ static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
 }
 
 static int
-twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV)
+twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
+                       unsigned *selector)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
         int                     vsel;
@@ -402,6 +406,7 @@ twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV)
          * mV = 1000mv + 100mv * (vsel - 1)
          */
         vsel = (min_uV/1000 - 1000)/100 + 1;
+        *selector = vsel;
         return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE, vsel);
 
 }
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index dbfaf5945e4..8b0d2c4bde9 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -302,7 +302,7 @@ static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state)
 }
 
 static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV, unsigned *selector)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
@@ -314,6 +314,8 @@ static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
         if (vsel < 0)
                 return vsel;
 
+        *selector = vsel;
+
         /* If this value is already set then do a GPIO update if we can */
         if (dcdc->dvs_gpio && dcdc->on_vsel == vsel)
                 return wm831x_buckv_set_dvs(rdev, 0);
@@ -375,14 +377,14 @@ static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev,
         return wm831x_set_bits(wm831x, reg, WM831X_DC1_SLP_VSEL_MASK, vsel);
 }
 
-static int wm831x_buckv_get_voltage(struct regulator_dev *rdev)
+static int wm831x_buckv_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
 
         if (dcdc->dvs_gpio && dcdc->dvs_gpio_state)
-                return wm831x_buckv_list_voltage(rdev, dcdc->dvs_vsel);
+                return dcdc->dvs_vsel;
         else
-                return wm831x_buckv_list_voltage(rdev, dcdc->on_vsel);
+                return dcdc->on_vsel;
 }
 
 /* Current limit options */
@@ -424,7 +426,7 @@ static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_buckv_ops = {
         .set_voltage = wm831x_buckv_set_voltage,
-        .get_voltage = wm831x_buckv_get_voltage,
+        .get_voltage_sel = wm831x_buckv_get_voltage_sel,
         .list_voltage = wm831x_buckv_list_voltage,
         .set_suspend_voltage = wm831x_buckv_set_suspend_voltage,
         .set_current_limit = wm831x_buckv_set_current_limit,
@@ -636,7 +638,7 @@ static int wm831x_buckp_list_voltage(struct regulator_dev *rdev,
 }
 
 static int wm831x_buckp_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                        int min_uV, int max_uV)
+                                        int min_uV, int max_uV, int *selector)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
@@ -650,16 +652,20 @@ static int wm831x_buckp_set_voltage_int(struct regulator_dev *rdev, int reg,
         if (wm831x_buckp_list_voltage(rdev, vsel) > max_uV)
                 return -EINVAL;
 
+        *selector = vsel;
+
         return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, vsel);
 }
 
 static int wm831x_buckp_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV)
+                                    int min_uV, int max_uV,
+                                    unsigned *selector)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         u16 reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
 
-        return wm831x_buckp_set_voltage_int(rdev, reg, min_uV, max_uV);
+        return wm831x_buckp_set_voltage_int(rdev, reg, min_uV, max_uV,
+                                            selector);
 }
 
 static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev,
@@ -667,11 +673,12 @@ static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev,
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
+        unsigned selector;
 
-        return wm831x_buckp_set_voltage_int(rdev, reg, uV, uV);
+        return wm831x_buckp_set_voltage_int(rdev, reg, uV, uV, &selector);
 }
 
-static int wm831x_buckp_get_voltage(struct regulator_dev *rdev)
+static int wm831x_buckp_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
@@ -682,12 +689,12 @@ static int wm831x_buckp_get_voltage(struct regulator_dev *rdev)
         if (val < 0)
                 return val;
 
-        return wm831x_buckp_list_voltage(rdev, val & WM831X_DC3_ON_VSEL_MASK);
+        return val & WM831X_DC3_ON_VSEL_MASK;
 }
 
 static struct regulator_ops wm831x_buckp_ops = {
         .set_voltage = wm831x_buckp_set_voltage,
-        .get_voltage = wm831x_buckp_get_voltage,
+        .get_voltage_sel = wm831x_buckp_get_voltage_sel,
         .list_voltage = wm831x_buckp_list_voltage,
         .set_suspend_voltage = wm831x_buckp_set_suspend_voltage,
 
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index 9edf8f69234..c94fc5b7cd5 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -113,7 +113,8 @@ static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
 }
 
 static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                         int min_uV, int max_uV)
+                                         int min_uV, int max_uV,
+                                         unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -133,16 +134,20 @@ static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
         if (ret < min_uV || ret > max_uV)
                 return -EINVAL;
 
+        *selector = vsel;
+
         return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, vsel);
 }
 
 static int wm831x_gp_ldo_set_voltage(struct regulator_dev *rdev,
-                                     int min_uV, int max_uV)
+                                     int min_uV, int max_uV,
+                                     unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
 
-        return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+        return wm831x_gp_ldo_set_voltage_int(rdev, reg, min_uV, max_uV,
+                                             selector);
 }
 
 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
@@ -150,11 +155,12 @@ static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+        unsigned int selector;
 
-        return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV);
+        return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
 }
 
-static int wm831x_gp_ldo_get_voltage(struct regulator_dev *rdev)
+static int wm831x_gp_ldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -167,7 +173,7 @@ static int wm831x_gp_ldo_get_voltage(struct regulator_dev *rdev)
 
         ret &= WM831X_LDO1_ON_VSEL_MASK;
 
-        return wm831x_gp_ldo_list_voltage(rdev, ret);
+        return ret;
 }
 
 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
@@ -287,7 +293,7 @@ static unsigned int wm831x_gp_ldo_get_optimum_mode(struct regulator_dev *rdev,
 
 static struct regulator_ops wm831x_gp_ldo_ops = {
         .list_voltage = wm831x_gp_ldo_list_voltage,
-        .get_voltage = wm831x_gp_ldo_get_voltage,
+        .get_voltage_sel = wm831x_gp_ldo_get_voltage_sel,
         .set_voltage = wm831x_gp_ldo_set_voltage,
         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
         .get_mode = wm831x_gp_ldo_get_mode,
@@ -413,7 +419,8 @@ static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
 }
 
 static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                         int min_uV, int max_uV)
+                                       int min_uV, int max_uV,
+                                       unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -433,16 +440,19 @@ static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
         if (ret < min_uV || ret > max_uV)
                 return -EINVAL;
 
+        *selector = vsel;
+
         return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, vsel);
 }
 
 static int wm831x_aldo_set_voltage(struct regulator_dev *rdev,
-                                     int min_uV, int max_uV)
+                                   int min_uV, int max_uV, unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_LDO_ON_CONTROL;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+        return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV,
+                                           selector);
 }
 
 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
@@ -450,11 +460,12 @@ static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+        unsigned int selector;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV);
+        return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV, &selector);
 }
 
-static int wm831x_aldo_get_voltage(struct regulator_dev *rdev)
+static int wm831x_aldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -467,7 +478,7 @@ static int wm831x_aldo_get_voltage(struct regulator_dev *rdev)
 
         ret &= WM831X_LDO7_ON_VSEL_MASK;
 
-        return wm831x_aldo_list_voltage(rdev, ret);
+        return ret;
 }
 
 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
@@ -548,7 +559,7 @@ static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_aldo_ops = {
         .list_voltage = wm831x_aldo_list_voltage,
-        .get_voltage = wm831x_aldo_get_voltage,
+        .get_voltage_sel = wm831x_aldo_get_voltage_sel,
         .set_voltage = wm831x_aldo_set_voltage,
         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
         .get_mode = wm831x_aldo_get_mode,
@@ -666,7 +677,8 @@ static int wm831x_alive_ldo_list_voltage(struct regulator_dev *rdev,
 
 static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
                                             int reg,
-                                            int min_uV, int max_uV)
+                                            int min_uV, int max_uV,
+                                            unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -680,16 +692,20 @@ static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
         if (ret < min_uV || ret > max_uV)
                 return -EINVAL;
 
+        *selector = vsel;
+
         return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, vsel);
 }
 
 static int wm831x_alive_ldo_set_voltage(struct regulator_dev *rdev,
-                                     int min_uV, int max_uV)
+                                        int min_uV, int max_uV,
+                                        unsigned *selector)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_ALIVE_LDO_ON_CONTROL;
 
-        return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV);
+        return wm831x_alive_ldo_set_voltage_int(rdev, reg, min_uV, max_uV,
+                                                selector);
 }
 
 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
@@ -697,11 +713,12 @@ static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
+        unsigned selector;
 
-        return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV);
+        return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
 }
 
-static int wm831x_alive_ldo_get_voltage(struct regulator_dev *rdev)
+static int wm831x_alive_ldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = ldo->wm831x;
@@ -714,7 +731,7 @@ static int wm831x_alive_ldo_get_voltage(struct regulator_dev *rdev)
 
         ret &= WM831X_LDO11_ON_VSEL_MASK;
 
-        return wm831x_alive_ldo_list_voltage(rdev, ret);
+        return ret;
 }
 
 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
@@ -736,7 +753,7 @@ static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_alive_ldo_ops = {
         .list_voltage = wm831x_alive_ldo_list_voltage,
-        .get_voltage = wm831x_alive_ldo_get_voltage,
+        .get_voltage_sel = wm831x_alive_ldo_get_voltage_sel,
         .set_voltage = wm831x_alive_ldo_set_voltage,
         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
         .get_status = wm831x_alive_ldo_get_status,
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index fe4b8a8a9df..1bcb22c4409 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -360,7 +360,7 @@ int wm8350_isink_set_flash(struct wm8350 *wm8350, int isink, u16 mode,
 EXPORT_SYMBOL_GPL(wm8350_isink_set_flash);
 
 static int wm8350_dcdc_set_voltage(struct regulator_dev *rdev, int min_uV,
-        int max_uV)
+                                   int max_uV, unsigned *selector)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
         int volt_reg, dcdc = rdev_get_id(rdev), mV,
@@ -397,17 +397,18 @@ static int wm8350_dcdc_set_voltage(struct regulator_dev *rdev, int min_uV,
                 return -EINVAL;
         }
 
+        *selector = mV;
+
         /* all DCDCs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
         wm8350_reg_write(wm8350, volt_reg, val | mV);
         return 0;
 }
 
-static int wm8350_dcdc_get_voltage(struct regulator_dev *rdev)
+static int wm8350_dcdc_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
         int volt_reg, dcdc = rdev_get_id(rdev);
-        u16 val;
 
         switch (dcdc) {
         case WM8350_DCDC_1:
@@ -429,8 +430,7 @@ static int wm8350_dcdc_get_voltage(struct regulator_dev *rdev)
         }
 
         /* all DCDCs have same mV bits */
-        val = wm8350_reg_read(wm8350, volt_reg) & WM8350_DC1_VSEL_MASK;
-        return wm8350_dcdc_val_to_mvolts(val) * 1000;
+        return wm8350_reg_read(wm8350, volt_reg) & WM8350_DC1_VSEL_MASK;
 }
 
 static int wm8350_dcdc_list_voltage(struct regulator_dev *rdev,
@@ -754,7 +754,7 @@ static int wm8350_ldo_set_suspend_disable(struct regulator_dev *rdev)
 }
 
 static int wm8350_ldo_set_voltage(struct regulator_dev *rdev, int min_uV,
-        int max_uV)
+                                  int max_uV, unsigned *selector)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
         int volt_reg, ldo = rdev_get_id(rdev), mV, min_mV = min_uV / 1000,
@@ -797,17 +797,18 @@ static int wm8350_ldo_set_voltage(struct regulator_dev *rdev, int min_uV,
                 return -EINVAL;
         }
 
+        *selector = mV;
+
         /* all LDOs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
         wm8350_reg_write(wm8350, volt_reg, val | mV);
         return 0;
 }
 
-static int wm8350_ldo_get_voltage(struct regulator_dev *rdev)
+static int wm8350_ldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
         int volt_reg, ldo = rdev_get_id(rdev);
-        u16 val;
 
         switch (ldo) {
         case WM8350_LDO_1:
@@ -827,8 +828,7 @@ static int wm8350_ldo_get_voltage(struct regulator_dev *rdev)
         }
 
         /* all LDOs have same mV bits */
-        val = wm8350_reg_read(wm8350, volt_reg) & WM8350_LDO1_VSEL_MASK;
-        return wm8350_ldo_val_to_mvolts(val) * 1000;
+        return wm8350_reg_read(wm8350, volt_reg) & WM8350_LDO1_VSEL_MASK;
 }
 
 static int wm8350_ldo_list_voltage(struct regulator_dev *rdev,
@@ -1225,7 +1225,7 @@ static int wm8350_ldo_is_enabled(struct regulator_dev *rdev)
 
 static struct regulator_ops wm8350_dcdc_ops = {
         .set_voltage = wm8350_dcdc_set_voltage,
-        .get_voltage = wm8350_dcdc_get_voltage,
+        .get_voltage_sel = wm8350_dcdc_get_voltage_sel,
         .list_voltage = wm8350_dcdc_list_voltage,
         .enable = wm8350_dcdc_enable,
         .disable = wm8350_dcdc_disable,
@@ -1249,7 +1249,7 @@ static struct regulator_ops wm8350_dcdc2_5_ops = {
 
 static struct regulator_ops wm8350_ldo_ops = {
         .set_voltage = wm8350_ldo_set_voltage,
-        .get_voltage = wm8350_ldo_get_voltage,
+        .get_voltage_sel = wm8350_ldo_get_voltage_sel,
         .list_voltage = wm8350_ldo_list_voltage,
         .enable = wm8350_ldo_enable,
         .disable = wm8350_ldo_disable,
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 924c7eb29ee..b42d01cef35 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -67,7 +67,7 @@ static int wm8400_ldo_get_voltage(struct regulator_dev *dev)
 }
 
 static int wm8400_ldo_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                  int min_uV, int max_uV, unsigned *selector)
 {
         struct wm8400 *wm8400 = rdev_get_drvdata(dev);
         u16 val;
@@ -93,6 +93,8 @@ static int wm8400_ldo_set_voltage(struct regulator_dev *dev,
                 val += 0xf;
         }
 
+        *selector = val;
+
         return wm8400_set_bits(wm8400, WM8400_LDO1_CONTROL + rdev_get_id(dev),
                                WM8400_LDO1_VSEL_MASK, val);
 }
@@ -156,7 +158,7 @@ static int wm8400_dcdc_get_voltage(struct regulator_dev *dev)
 }
 
 static int wm8400_dcdc_set_voltage(struct regulator_dev *dev,
-                                  int min_uV, int max_uV)
+                                   int min_uV, int max_uV, unsigned *selector)
 {
         struct wm8400 *wm8400 = rdev_get_drvdata(dev);
         u16 val;
@@ -171,6 +173,8 @@ static int wm8400_dcdc_set_voltage(struct regulator_dev *dev,
                 return -EINVAL;
         BUG_ON(850000 + (25000 * val) < min_uV);
 
+        *selector = val;
+
         return wm8400_set_bits(wm8400, WM8400_DCDC1_CONTROL_1 + offset,
                                WM8400_DC1_VSEL_MASK, val);
 }
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index 03713bc66e4..594f88eb60c 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -86,7 +86,7 @@ static int wm8994_ldo1_list_voltage(struct regulator_dev *rdev,
         return (selector * 100000) + 2400000;
 }
 
-static int wm8994_ldo1_get_voltage(struct regulator_dev *rdev)
+static int wm8994_ldo1_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
         int val;
@@ -95,13 +95,11 @@ static int wm8994_ldo1_get_voltage(struct regulator_dev *rdev)
         if (val < 0)
                 return val;
 
-        val = (val & WM8994_LDO1_VSEL_MASK) >> WM8994_LDO1_VSEL_SHIFT;
-
-        return wm8994_ldo1_list_voltage(rdev, val);
+        return (val & WM8994_LDO1_VSEL_MASK) >> WM8994_LDO1_VSEL_SHIFT;
 }
 
 static int wm8994_ldo1_set_voltage(struct regulator_dev *rdev,
-                                   int min_uV, int max_uV)
+                                   int min_uV, int max_uV, unsigned *s)
 {
         struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
         int selector, v;
@@ -111,6 +109,7 @@ static int wm8994_ldo1_set_voltage(struct regulator_dev *rdev,
         if (v < 0 || v > max_uV)
                 return -EINVAL;
 
+        *s = selector;
         selector <<= WM8994_LDO1_VSEL_SHIFT;
 
         return wm8994_set_bits(ldo->wm8994, WM8994_LDO_1,
@@ -124,7 +123,7 @@ static struct regulator_ops wm8994_ldo1_ops = {
         .enable_time = wm8994_ldo_enable_time,
 
         .list_voltage = wm8994_ldo1_list_voltage,
-        .get_voltage = wm8994_ldo1_get_voltage,
+        .get_voltage_sel = wm8994_ldo1_get_voltage_sel,
         .set_voltage = wm8994_ldo1_set_voltage,
 };
 
@@ -137,7 +136,7 @@ static int wm8994_ldo2_list_voltage(struct regulator_dev *rdev,
         return (selector * 100000) + 900000;
 }
 
-static int wm8994_ldo2_get_voltage(struct regulator_dev *rdev)
+static int wm8994_ldo2_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
         int val;
@@ -146,13 +145,11 @@ static int wm8994_ldo2_get_voltage(struct regulator_dev *rdev)
         if (val < 0)
                 return val;
 
-        val = (val & WM8994_LDO2_VSEL_MASK) >> WM8994_LDO2_VSEL_SHIFT;
-
-        return wm8994_ldo2_list_voltage(rdev, val);
+        return (val & WM8994_LDO2_VSEL_MASK) >> WM8994_LDO2_VSEL_SHIFT;
 }
 
 static int wm8994_ldo2_set_voltage(struct regulator_dev *rdev,
-                                   int min_uV, int max_uV)
+                                   int min_uV, int max_uV, unsigned *s)
 {
         struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
         int selector, v;
@@ -162,6 +159,7 @@ static int wm8994_ldo2_set_voltage(struct regulator_dev *rdev,
         if (v < 0 || v > max_uV)
                 return -EINVAL;
 
+        *s = selector;
         selector <<= WM8994_LDO2_VSEL_SHIFT;
 
         return wm8994_set_bits(ldo->wm8994, WM8994_LDO_2,
@@ -175,7 +173,7 @@ static struct regulator_ops wm8994_ldo2_ops = {
         .enable_time = wm8994_ldo_enable_time,
 
         .list_voltage = wm8994_ldo2_list_voltage,
-        .get_voltage = wm8994_ldo2_get_voltage,
+        .get_voltage_sel = wm8994_ldo2_get_voltage_sel,
         .set_voltage = wm8994_ldo2_set_voltage,
 };
 
diff --git a/drivers/rtc/rtc-cmos.c b/drivers/rtc/rtc-cmos.c
index 7e6ce626b7f..c7ff8df347e 100644
--- a/drivers/rtc/rtc-cmos.c
+++ b/drivers/rtc/rtc-cmos.c
@@ -36,6 +36,7 @@
 #include <linux/platform_device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/log2.h>
+#include <linux/pm.h>
 
 /* this is for "generic access to PC-style RTC" using CMOS_READ/CMOS_WRITE */
 #include <asm-generic/rtc.h>
@@ -851,7 +852,7 @@ static void __exit cmos_do_remove(struct device *dev)
 
 #ifdef  CONFIG_PM
 
-static int cmos_suspend(struct device *dev, pm_message_t mesg)
+static int cmos_suspend(struct device *dev)
 {
         struct cmos_rtc *cmos = dev_get_drvdata(dev);
         unsigned char   tmp;
@@ -899,7 +900,7 @@ static int cmos_suspend(struct device *dev, pm_message_t mesg)
  */
 static inline int cmos_poweroff(struct device *dev)
 {
-        return cmos_suspend(dev, PMSG_HIBERNATE);
+        return cmos_suspend(dev);
 }
 
 static int cmos_resume(struct device *dev)
@@ -946,9 +947,9 @@ static int cmos_resume(struct device *dev)
         return 0;
 }
 
+static SIMPLE_DEV_PM_OPS(cmos_pm_ops, cmos_suspend, cmos_resume);
+
 #else
-#define cmos_suspend    NULL
-#define cmos_resume     NULL
 
 static inline int cmos_poweroff(struct device *dev)
 {
@@ -1078,7 +1079,7 @@ static void __exit cmos_pnp_remove(struct pnp_dev *pnp)
 
 static int cmos_pnp_suspend(struct pnp_dev *pnp, pm_message_t mesg)
 {
-        return cmos_suspend(&pnp->dev, mesg);
+        return cmos_suspend(&pnp->dev);
 }
 
 static int cmos_pnp_resume(struct pnp_dev *pnp)
@@ -1158,8 +1159,9 @@ static struct platform_driver cmos_platform_driver = {
         .shutdown       = cmos_platform_shutdown,
         .driver = {
                 .name           = (char *) driver_name,
-                .suspend        = cmos_suspend,
-                .resume         = cmos_resume,
+#ifdef CONFIG_PM
+                .pm             = &cmos_pm_ops,
+#endif
         }
 };
 
diff --git a/drivers/rtc/rtc-max6902.c b/drivers/rtc/rtc-max6902.c
index 657403ebd54..0ec3f588a25 100644
--- a/drivers/rtc/rtc-max6902.c
+++ b/drivers/rtc/rtc-max6902.c
@@ -139,12 +139,13 @@ static int __devinit max6902_probe(struct spi_device *spi)
         if (IS_ERR(rtc))
                 return PTR_ERR(rtc);
 
+        dev_set_drvdata(&spi->dev, rtc);
         return 0;
 }
 
 static int __devexit max6902_remove(struct spi_device *spi)
 {
-        struct rtc_device *rtc = platform_get_drvdata(spi);
+        struct rtc_device *rtc = dev_get_drvdata(&spi->dev);
 
         rtc_device_unregister(rtc);
         return 0;
diff --git a/drivers/rtc/rtc-omap.c b/drivers/rtc/rtc-omap.c
index 73377b0d65d..e72b523c79a 100644
--- a/drivers/rtc/rtc-omap.c
+++ b/drivers/rtc/rtc-omap.c
@@ -429,13 +429,14 @@ fail1:
 fail0:
         iounmap(rtc_base);
 fail:
-        release_resource(mem);
+        release_mem_region(mem->start, resource_size(mem));
         return -EIO;
 }
 
 static int __exit omap_rtc_remove(struct platform_device *pdev)
 {
         struct rtc_device       *rtc = platform_get_drvdata(pdev);
+        struct resource         *mem = dev_get_drvdata(&rtc->dev);
 
         device_init_wakeup(&pdev->dev, 0);
 
@@ -447,8 +448,9 @@ static int __exit omap_rtc_remove(struct platform_device *pdev)
         if (omap_rtc_timer != omap_rtc_alarm)
                 free_irq(omap_rtc_alarm, rtc);
 
-        release_resource(dev_get_drvdata(&rtc->dev));
         rtc_device_unregister(rtc);
+        iounmap(rtc_base);
+        release_mem_region(mem->start, resource_size(mem));
         return 0;
 }
 
diff --git a/drivers/s390/net/lcs.c b/drivers/s390/net/lcs.c
index 09e7a053c84..30b2a820e67 100644
--- a/drivers/s390/net/lcs.c
+++ b/drivers/s390/net/lcs.c
@@ -841,7 +841,7 @@ lcs_notify_lancmd_waiters(struct lcs_card *card, struct lcs_cmd *cmd)
 }
 
 /**
- * Emit buffer of a lan comand.
+ * Emit buffer of a lan command.
  */
 static void
 lcs_lancmd_timeout(unsigned long data)
diff --git a/drivers/s390/scsi/zfcp_cfdc.c b/drivers/s390/scsi/zfcp_cfdc.c
index 46342fee394..303dde09d29 100644
--- a/drivers/s390/scsi/zfcp_cfdc.c
+++ b/drivers/s390/scsi/zfcp_cfdc.c
@@ -317,7 +317,7 @@ static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table)
 
 /**
  * zfcp_cfdc_port_denied - Process "access denied" for port
- * @port: The port where the acces has been denied
+ * @port: The port where the access has been denied
  * @qual: The FSF status qualifier for the access denied FSF status
  */
 void zfcp_cfdc_port_denied(struct zfcp_port *port,
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index dc5ac6e528c..a391090a17c 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -416,7 +416,7 @@ static u8 orc_load_firmware(struct orc_host * host)
         /* Go back and check they match */
 
         outb(PRGMRST | DOWNLOAD, host->base + ORC_RISCCTL);     /* Reset program count 0 */
-        bios_addr -= 0x1000;    /* Reset the BIOS adddress      */
+        bios_addr -= 0x1000;    /* Reset the BIOS address */
         for (i = 0, data32_ptr = (u8 *) & data32;       /* Check the code       */
              i < 0x1000;        /* Firmware code size = 4K      */
              i++, bios_addr++) {
diff --git a/drivers/scsi/aacraid/commsup.c b/drivers/scsi/aacraid/commsup.c
index afc9aeba5ed..060ac4bd5a1 100644
--- a/drivers/scsi/aacraid/commsup.c
+++ b/drivers/scsi/aacraid/commsup.c
@@ -91,7 +91,7 @@ void aac_fib_map_free(struct aac_dev *dev)
  *      aac_fib_setup   -       setup the fibs
  *      @dev: Adapter to set up
  *
- *      Allocate the PCI space for the fibs, map it and then intialise the
+ *      Allocate the PCI space for the fibs, map it and then initialise the
  *      fib area, the unmapped fib data and also the free list
  */
 
diff --git a/drivers/scsi/aic7xxx_old/aic7xxx.seq b/drivers/scsi/aic7xxx_old/aic7xxx.seq
index 5997e7c3a19..1565be9ebd4 100644
--- a/drivers/scsi/aic7xxx_old/aic7xxx.seq
+++ b/drivers/scsi/aic7xxx_old/aic7xxx.seq
@@ -1178,7 +1178,7 @@ notFound:
 /*
  * Retrieve an SCB by SCBID first searching the disconnected list falling
  * back to DMA'ing the SCB down from the host.  This routine assumes that
- * ARG_1 is the SCBID of interrest and that SINDEX is the position in the
+ * ARG_1 is the SCBID of interest and that SINDEX is the position in the
  * disconnected list to start the search from.  If SINDEX is SCB_LIST_NULL,
  * we go directly to the host for the SCB.
  */
diff --git a/drivers/scsi/aic94xx/aic94xx_reg_def.h b/drivers/scsi/aic94xx/aic94xx_reg_def.h
index 28aaf349c11..40273a747d2 100644
--- a/drivers/scsi/aic94xx/aic94xx_reg_def.h
+++ b/drivers/scsi/aic94xx/aic94xx_reg_def.h
@@ -1689,7 +1689,7 @@
 #define         PHY_START_CAL           0x01
 
 /*
- * HST_PCIX2 Registers, Addresss Range: (0x00-0xFC)
+ * HST_PCIX2 Registers, Address Range: (0x00-0xFC)
  */
 #define PCIX_REG_BASE_ADR               0xB8040000
 
@@ -1802,7 +1802,7 @@
 #define PCIC_TP_CTRL    0xFC
 
 /*
- * EXSI Registers, Addresss Range: (0x00-0xFC)
+ * EXSI Registers, Address Range: (0x00-0xFC)
  */
 #define EXSI_REG_BASE_ADR               REG_BASE_ADDR_EXSI
 
diff --git a/drivers/scsi/aic94xx/aic94xx_scb.c b/drivers/scsi/aic94xx/aic94xx_scb.c
index c43698b1cb6..29593275201 100644
--- a/drivers/scsi/aic94xx/aic94xx_scb.c
+++ b/drivers/scsi/aic94xx/aic94xx_scb.c
@@ -867,7 +867,7 @@ void asd_build_initiate_link_adm_task(struct asd_ascb *ascb, int phy_id,
  * resources they have with this SCB, and then call this one at the
  * end of their timeout function.  To do this, one should initialize
  * the ascb->timer.{function, data, expires} prior to calling the post
- * funcion.  The timer is started by the post function.
+ * function. The timer is started by the post function.
  */
 void asd_ascb_timedout(unsigned long data)
 {
diff --git a/drivers/scsi/aic94xx/aic94xx_seq.c b/drivers/scsi/aic94xx/aic94xx_seq.c
index 74374618010..390168f62a1 100644
--- a/drivers/scsi/aic94xx/aic94xx_seq.c
+++ b/drivers/scsi/aic94xx/aic94xx_seq.c
@@ -797,7 +797,7 @@ static void asd_init_lseq_mdp(struct asd_ha_struct *asd_ha,  int lseq)
                 int j;
                 /* Start from Page 1 of Mode 0 and 1. */
                 moffs = LSEQ_PAGE_SIZE + i*LSEQ_MODE_SCRATCH_SIZE;
-                /* All the fields of page 1 can be intialized to 0. */
+                /* All the fields of page 1 can be initialized to 0. */
                 for (j = 0; j < LSEQ_PAGE_SIZE; j += 4)
                         asd_write_reg_dword(asd_ha, LmSCRATCH(lseq)+moffs+j,0);
         }
@@ -938,7 +938,7 @@ static void asd_init_cseq_cio(struct asd_ha_struct *asd_ha)
         asd_write_reg_dword(asd_ha, SCBPRO, 0);
         asd_write_reg_dword(asd_ha, CSEQCON, 0);
 
-        /* Intialize CSEQ Mode 11 Interrupt Vectors.
+        /* Initialize CSEQ Mode 11 Interrupt Vectors.
          * The addresses are 16 bit wide and in dword units.
          * The values of their macros are in byte units.
          * Thus we have to divide by 4. */
@@ -961,7 +961,7 @@ static void asd_init_cseq_cio(struct asd_ha_struct *asd_ha)
         asd_write_reg_word(asd_ha, CPRGMCNT, cseq_idle_loop);
 
         for (i = 0; i < 8; i++) {
-                /* Intialize Mode n Link m Interrupt Enable. */
+                /* Initialize Mode n Link m Interrupt Enable. */
                 asd_write_reg_dword(asd_ha, CMnINTEN(i), EN_CMnRSPMBXF);
                 /* Initialize Mode n Request Mailbox. */
                 asd_write_reg_dword(asd_ha, CMnREQMBX(i), 0);
diff --git a/drivers/scsi/bfa/bfa_fcpim.c b/drivers/scsi/bfa/bfa_fcpim.c
index 9c410b21db6..c0353cdca92 100644
--- a/drivers/scsi/bfa/bfa_fcpim.c
+++ b/drivers/scsi/bfa/bfa_fcpim.c
@@ -1838,7 +1838,7 @@ bfa_ioim_sm_cleanup_qfull(struct bfa_ioim_s *ioim, enum bfa_ioim_event event)
 
         case BFA_IOIM_SM_ABORT:
                 /*
-                 * IO is alraedy being cleaned up implicitly
+                 * IO is already being cleaned up implicitly
                  */
                 ioim->io_cbfn = __bfa_cb_ioim_abort;
                 break;
diff --git a/drivers/scsi/bfa/bfa_fcs_lport.c b/drivers/scsi/bfa/bfa_fcs_lport.c
index 4e2eb92ba02..43fa986bb58 100644
--- a/drivers/scsi/bfa/bfa_fcs_lport.c
+++ b/drivers/scsi/bfa/bfa_fcs_lport.c
@@ -5646,7 +5646,7 @@ bfa_cb_lps_fdisc_comp(void *bfad, void *uarg, bfa_status_t status)
         switch (status) {
         case BFA_STATUS_OK:
                 /*
-                 * Initialiaze the V-Port fields
+                 * Initialize the V-Port fields
                  */
                 __vport_fcid(vport) = vport->lps->lp_pid;
                 vport->vport_stats.fdisc_accepts++;
diff --git a/drivers/scsi/dc395x.c b/drivers/scsi/dc395x.c
index 8f1b5c8bf90..b0f8523e665 100644
--- a/drivers/scsi/dc395x.c
+++ b/drivers/scsi/dc395x.c
@@ -3796,7 +3796,7 @@ static struct DeviceCtlBlk *device_alloc(struct AdapterCtlBlk *acb,
  * adapter_add_device - Adds the device instance to the adaptor instance.
  *
  * @acb: The adapter device to be updated
- * @dcb: A newly created and intialised device instance to add.
+ * @dcb: A newly created and initialised device instance to add.
  **/
 static void adapter_add_device(struct AdapterCtlBlk *acb,
                 struct DeviceCtlBlk *dcb)
@@ -4498,7 +4498,7 @@ static void __devinit adapter_init_chip(struct AdapterCtlBlk *acb)
  * init_adapter - Grab the resource for the card, setup the adapter
  * information, set the card into a known state, create the various
  * tables etc etc. This basically gets all adapter information all up
- * to date, intialised and gets the chip in sync with it.
+ * to date, initialised and gets the chip in sync with it.
  *
  * @host:       This hosts adapter structure
  * @io_port:    The base I/O port
@@ -4789,7 +4789,7 @@ static void banner_display(void)
  * that it finds in the system. The pci_dev strcuture indicates which
  * instance we are being called from.
  * 
- * @dev: The PCI device to intialize.
+ * @dev: The PCI device to initialize.
  * @id: Looks like a pointer to the entry in our pci device table
  * that was actually matched by the PCI subsystem.
  *
@@ -4860,7 +4860,7 @@ fail:
  * dc395x_remove_one - Called to remove a single instance of the
  * adapter.
  *
- * @dev: The PCI device to intialize.
+ * @dev: The PCI device to initialize.
  **/
 static void __devexit dc395x_remove_one(struct pci_dev *dev)
 {
diff --git a/drivers/scsi/libfc/fc_fcp.c b/drivers/scsi/libfc/fc_fcp.c
index cdc06cda76e..5962d1a5a67 100644
--- a/drivers/scsi/libfc/fc_fcp.c
+++ b/drivers/scsi/libfc/fc_fcp.c
@@ -1250,7 +1250,7 @@ static void fc_lun_reset_send(unsigned long data)
 /**
  * fc_lun_reset() - Send a LUN RESET command to a device
  *                  and wait for the reply
- * @lport: The local port to sent the comand on
+ * @lport: The local port to sent the command on
  * @fsp:   The FCP packet that identifies the LUN to be reset
  * @id:    The SCSI command ID
  * @lun:   The LUN ID to be reset
diff --git a/drivers/scsi/lpfc/lpfc_attr.c b/drivers/scsi/lpfc/lpfc_attr.c
index c06491b5862..3512abb8a58 100644
--- a/drivers/scsi/lpfc/lpfc_attr.c
+++ b/drivers/scsi/lpfc/lpfc_attr.c
@@ -1335,7 +1335,7 @@ lpfc_##attr##_show(struct device *dev, struct device_attribute *attr, \
 }
 
 /**
- * lpfc_param_init - Intializes a cfg attribute
+ * lpfc_param_init - Initializes a cfg attribute
  *
  * Description:
  * Macro that given an attr e.g. hba_queue_depth expands
diff --git a/drivers/scsi/lpfc/lpfc_hbadisc.c b/drivers/scsi/lpfc/lpfc_hbadisc.c
index f9f160ab2ee..bb015960dbc 100644
--- a/drivers/scsi/lpfc/lpfc_hbadisc.c
+++ b/drivers/scsi/lpfc/lpfc_hbadisc.c
@@ -2852,7 +2852,7 @@ lpfc_mbx_process_link_up(struct lpfc_hba *phba, struct lpfc_mbx_read_top *la)
                         if (unlikely(!fcf_record)) {
                                 lpfc_printf_log(phba, KERN_ERR,
                                         LOG_MBOX | LOG_SLI,
-                                        "2554 Could not allocate memmory for "
+                                        "2554 Could not allocate memory for "
                                         "fcf record\n");
                                 rc = -ENODEV;
                                 goto out;
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index 462242dcdd0..6d0b36aa338 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -8071,7 +8071,7 @@ lpfc_pci_remove_one_s3(struct pci_dev *pdev)
          * the HBA.
          */
 
-        /* HBA interrupt will be diabled after this call */
+        /* HBA interrupt will be disabled after this call */
         lpfc_sli_hba_down(phba);
         /* Stop kthread signal shall trigger work_done one more time */
         kthread_stop(phba->worker_thread);
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 634b2fea9c4..a359d2b873c 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -10172,7 +10172,7 @@ lpfc_sli4_intr_handler(int irq, void *dev_id)
  * lpfc_sli4_queue_free - free a queue structure and associated memory
  * @queue: The queue structure to free.
  *
- * This function frees a queue structure and the DMAable memeory used for
+ * This function frees a queue structure and the DMAable memory used for
  * the host resident queue. This function must be called after destroying the
  * queue on the HBA.
  **/
diff --git a/drivers/scsi/megaraid.h b/drivers/scsi/megaraid.h
index f5644745e24..853411911b2 100644
--- a/drivers/scsi/megaraid.h
+++ b/drivers/scsi/megaraid.h
@@ -13,7 +13,7 @@
  */
 
 /*
- * Comand coalescing - This feature allows the driver to be able to combine
+ * Command coalescing - This feature allows the driver to be able to combine
  * two or more commands and issue as one command in order to boost I/O
  * performance. Useful if the nature of the I/O is sequential. It is not very
  * useful for random natured I/Os.
diff --git a/drivers/scsi/megaraid/megaraid_mm.c b/drivers/scsi/megaraid/megaraid_mm.c
index a7008c0c24f..25506c77738 100644
--- a/drivers/scsi/megaraid/megaraid_mm.c
+++ b/drivers/scsi/megaraid/megaraid_mm.c
@@ -224,7 +224,7 @@ mraid_mm_unlocked_ioctl(struct file *filep, unsigned int cmd,
 {
         int err;
 
-        /* inconsistant: mraid_mm_compat_ioctl doesn't take the BKL */
+        /* inconsistent: mraid_mm_compat_ioctl doesn't take the BKL */
         mutex_lock(&mraid_mm_mutex);
         err = mraid_mm_ioctl(filep, cmd, arg);
         mutex_unlock(&mraid_mm_mutex);
diff --git a/drivers/scsi/pm8001/pm8001_init.c b/drivers/scsi/pm8001/pm8001_init.c
index f8c86b28f03..b95285f3383 100644
--- a/drivers/scsi/pm8001/pm8001_init.c
+++ b/drivers/scsi/pm8001/pm8001_init.c
@@ -603,7 +603,7 @@ static u32 pm8001_request_irq(struct pm8001_hba_info *pm8001_ha)
 #endif
 
 intx:
-        /* intialize the INT-X interrupt */
+        /* initialize the INT-X interrupt */
         rc = request_irq(pdev->irq, irq_handler, IRQF_SHARED, DRV_NAME,
                 SHOST_TO_SAS_HA(pm8001_ha->shost));
         return rc;
diff --git a/drivers/scsi/scsi_netlink.c b/drivers/scsi/scsi_netlink.c
index d53e6503c6d..a2ed201885a 100644
--- a/drivers/scsi/scsi_netlink.c
+++ b/drivers/scsi/scsi_netlink.c
@@ -477,7 +477,7 @@ EXPORT_SYMBOL_GPL(scsi_nl_remove_driver);
 
 
 /**
- * scsi_netlink_init - Called by SCSI subsystem to intialize
+ * scsi_netlink_init - Called by SCSI subsystem to initialize
  *      the SCSI transport netlink interface
  *
  **/
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 4c68d36f9ac..490ce213204 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -864,13 +864,15 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)
 
         error = device_add(&sdev->sdev_gendev);
         if (error) {
-                printk(KERN_INFO "error 1\n");
+                sdev_printk(KERN_INFO, sdev,
+                                "failed to add device: %d\n", error);
                 return error;
         }
         device_enable_async_suspend(&sdev->sdev_dev);
         error = device_add(&sdev->sdev_dev);
         if (error) {
-                printk(KERN_INFO "error 2\n");
+                sdev_printk(KERN_INFO, sdev,
+                                "failed to add class device: %d\n", error);
                 device_del(&sdev->sdev_gendev);
                 return error;
         }
diff --git a/drivers/scsi/sym53c8xx_2/sym_glue.c b/drivers/scsi/sym53c8xx_2/sym_glue.c
index 6b97ded9d45..b4543f575f4 100644
--- a/drivers/scsi/sym53c8xx_2/sym_glue.c
+++ b/drivers/scsi/sym53c8xx_2/sym_glue.c
@@ -1866,7 +1866,7 @@ static pci_ers_result_t sym2_io_slot_dump(struct pci_dev *pdev)
  *
  * This routine is similar to sym_set_workarounds(), except
  * that, at this point, we already know that the device was
- * successfully intialized at least once before, and so most
+ * successfully initialized at least once before, and so most
  * of the steps taken there are un-needed here.
  */
 static void sym2_reset_workarounds(struct pci_dev *pdev)
diff --git a/drivers/spi/atmel_spi.c b/drivers/spi/atmel_spi.c
index a067046c9da..1a478bf88c9 100644
--- a/drivers/spi/atmel_spi.c
+++ b/drivers/spi/atmel_spi.c
@@ -341,9 +341,9 @@ static void atmel_spi_next_message(struct spi_master *master)
 /*
  * For DMA, tx_buf/tx_dma have the same relationship as rx_buf/rx_dma:
  *  - The buffer is either valid for CPU access, else NULL
- *  - If the buffer is valid, so is its DMA addresss
+ *  - If the buffer is valid, so is its DMA address
  *
- * This driver manages the dma addresss unless message->is_dma_mapped.
+ * This driver manages the dma address unless message->is_dma_mapped.
  */
 static int
 atmel_spi_dma_map_xfer(struct atmel_spi *as, struct spi_transfer *xfer)
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 4e6245e6799..603428213d2 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -38,7 +38,7 @@
 
 
 /*
- * This supports acccess to SPI devices using normal userspace I/O calls.
+ * This supports access to SPI devices using normal userspace I/O calls.
  * Note that while traditional UNIX/POSIX I/O semantics are half duplex,
  * and often mask message boundaries, full SPI support requires full duplex
  * transfers.  There are several kinds of internal message boundaries to
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index e2d58690343..5c8fcfc42c3 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -123,6 +123,8 @@ source "drivers/staging/sep/Kconfig"
 
 source "drivers/staging/iio/Kconfig"
 
+source "drivers/staging/cs5535_gpio/Kconfig"
+
 source "drivers/staging/zram/Kconfig"
 
 source "drivers/staging/wlags49_h2/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index c7d222413c0..d5388631782 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -44,6 +44,7 @@ obj-$(CONFIG_VME_BUS)		+= vme/
 obj-$(CONFIG_MRST_RAR_HANDLER)  += memrar/
 obj-$(CONFIG_DX_SEP)            += sep/
 obj-$(CONFIG_IIO)               += iio/
+obj-$(CONFIG_CS5535_GPIO)       += cs5535_gpio/
 obj-$(CONFIG_ZRAM)              += zram/
 obj-$(CONFIG_WLAGS49_H2)        += wlags49_h2/
 obj-$(CONFIG_WLAGS49_H25)       += wlags49_h25/
diff --git a/drivers/staging/cs5535_gpio/Kconfig b/drivers/staging/cs5535_gpio/Kconfig
new file mode 100644
index 00000000000..a1b3a8d2b86
--- /dev/null
+++ b/drivers/staging/cs5535_gpio/Kconfig
@@ -0,0 +1,11 @@
+config CS5535_GPIO
+        tristate "AMD CS5535/CS5536 GPIO (Geode Companion Device)"
+        depends on X86_32
+        help
+          Note: this driver is DEPRECATED.  Please use the cs5535-gpio module
+          in the GPIO section instead (CONFIG_GPIO_CS5535).
+
+          Give userspace access to the GPIO pins on the AMD CS5535 and
+          CS5536 Geode companion devices.
+
+          If compiled as a module, it will be called cs5535_gpio.
diff --git a/drivers/staging/cs5535_gpio/Makefile b/drivers/staging/cs5535_gpio/Makefile
new file mode 100644
index 00000000000..d67c4b85f19
--- /dev/null
+++ b/drivers/staging/cs5535_gpio/Makefile
@@ -0,0 +1 @@
+obj-$(CONFIG_CS5535_GPIO)       += cs5535_gpio.o
diff --git a/drivers/staging/cs5535_gpio/TODO b/drivers/staging/cs5535_gpio/TODO
new file mode 100644
index 00000000000..98d1cd1e236
--- /dev/null
+++ b/drivers/staging/cs5535_gpio/TODO
@@ -0,0 +1,6 @@
+This is an obsolete driver for some the CS5535 and CS5536 southbridge GPIOs.
+It has been replaced by a driver that makes use of the Linux GPIO subsystem.
+Please switch to that driver, and let dilinger@queued.net know if there's
+anything missing from the new driver.
+
+This driver is scheduled for removal in 2.6.40.
diff --git a/drivers/char/cs5535_gpio.c b/drivers/staging/cs5535_gpio/cs5535_gpio.c
index 0cf1e5fad9a..0cf1e5fad9a 100644
--- a/drivers/char/cs5535_gpio.c
+++ b/drivers/staging/cs5535_gpio/cs5535_gpio.c
diff --git a/drivers/staging/msm/msm_fb_bl.c b/drivers/staging/msm/msm_fb_bl.c
index 033fc9486e0..2a8077511fc 100644
--- a/drivers/staging/msm/msm_fb_bl.c
+++ b/drivers/staging/msm/msm_fb_bl.c
@@ -42,7 +42,7 @@ static int msm_fb_bl_update_status(struct backlight_device *pbd)
         return 0;
 }
 
-static struct backlight_ops msm_fb_bl_ops = {
+static const struct backlight_ops msm_fb_bl_ops = {
         .get_brightness = msm_fb_bl_get_brightness,
         .update_status = msm_fb_bl_update_status,
 };
diff --git a/drivers/staging/olpc_dcon/TODO b/drivers/staging/olpc_dcon/TODO
index ac2d3d02371..35f9cda7be1 100644
--- a/drivers/staging/olpc_dcon/TODO
+++ b/drivers/staging/olpc_dcon/TODO
@@ -1,6 +1,5 @@
 TODO:
         - checkpatch.pl cleanups
-        - port geode gpio calls to newer cs5535 API
         - see if vx855 gpio API can be made similar enough to cs5535 so we can
           share more code
         - allow simultaneous XO-1 and XO-1.5 support
diff --git a/drivers/staging/olpc_dcon/olpc_dcon.c b/drivers/staging/olpc_dcon/olpc_dcon.c
index 4ca45ec7fd8..9f26dc9408b 100644
--- a/drivers/staging/olpc_dcon/olpc_dcon.c
+++ b/drivers/staging/olpc_dcon/olpc_dcon.c
@@ -27,7 +27,6 @@
 #include <asm/uaccess.h>
 #include <linux/ctype.h>
 #include <linux/reboot.h>
-#include <linux/gpio.h>
 #include <asm/tsc.h>
 #include <asm/olpc.h>
 
@@ -49,7 +48,7 @@ struct dcon_platform_data {
         int (*init)(void);
         void (*bus_stabilize_wiggle)(void);
         void (*set_dconload)(int);
-        int (*read_status)(void);
+        u8 (*read_status)(void);
 };
 
 static struct dcon_platform_data *pdata;
@@ -615,7 +614,7 @@ static struct device_attribute dcon_device_files[] = {
         __ATTR(resumeline, 0644, dcon_resumeline_show, dcon_resumeline_store),
 };
 
-static struct backlight_ops dcon_bl_ops = {
+static const struct backlight_ops dcon_bl_ops = {
         .get_brightness = dconbl_get,
         .update_status = dconbl_set
 };
diff --git a/drivers/staging/olpc_dcon/olpc_dcon.h b/drivers/staging/olpc_dcon/olpc_dcon.h
index 6453ca4ba0e..e566d213da2 100644
--- a/drivers/staging/olpc_dcon/olpc_dcon.h
+++ b/drivers/staging/olpc_dcon/olpc_dcon.h
@@ -29,26 +29,6 @@
 #define DCON_REG_SCAN_INT       9
 #define DCON_REG_BRIGHT         10
 
-/* GPIO registers (CS5536) */
-
-#define MSR_LBAR_GPIO           0x5140000C
-
-#define GPIOx_OUT_VAL     0x00
-#define GPIOx_OUT_EN      0x04
-#define GPIOx_IN_EN       0x20
-#define GPIOx_INV_EN      0x24
-#define GPIOx_IN_FLTR_EN  0x28
-#define GPIOx_EVNTCNT_EN  0x2C
-#define GPIOx_READ_BACK   0x30
-#define GPIOx_EVNT_EN     0x38
-#define GPIOx_NEGEDGE_EN  0x44
-#define GPIOx_NEGEDGE_STS 0x4C
-#define GPIO_FLT7_AMNT    0xD8
-#define GPIO_MAP_X        0xE0
-#define GPIO_MAP_Y        0xE4
-#define GPIO_FE7_SEL      0xF7
-
-
 /* Status values */
 
 #define DCONSTAT_SCANINT        0
diff --git a/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c b/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c
index 779fb7d7b30..043198dc6ff 100644
--- a/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c
+++ b/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c
@@ -10,54 +10,70 @@
  * modify it under the terms of version 2 of the GNU General Public
  * License as published by the Free Software Foundation.
  */
-
+#include <linux/cs5535.h>
+#include <linux/gpio.h>
 #include <asm/olpc.h>
 
 #include "olpc_dcon.h"
 
-/* Base address of the GPIO registers */
-static unsigned long gpio_base;
-
-/*
- * List of GPIOs that we care about:
- * (in)  GPIO12   -- DCONBLANK
- * (in)  GPIO[56] -- DCONSTAT[01]
- * (out) GPIO11   -- DCONLOAD
- */
-
-#define IN_GPIOS ((1<<5) | (1<<6) | (1<<7) | (1<<12))
-#define OUT_GPIOS (1<<11)
-
 static int dcon_init_xo_1(void)
 {
-        unsigned long lo, hi;
         unsigned char lob;
 
-        rdmsr(MSR_LBAR_GPIO, lo, hi);
-
-        /* Check the mask and whether GPIO is enabled (sanity check) */
-        if (hi != 0x0000f001) {
-                printk(KERN_ERR "GPIO not enabled -- cannot use DCON\n");
-                return -ENODEV;
+        if (gpio_request(OLPC_GPIO_DCON_STAT0, "OLPC-DCON")) {
+                printk(KERN_ERR "olpc-dcon: failed to request STAT0 GPIO\n");
+                return -EIO;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_STAT1, "OLPC-DCON")) {
+                printk(KERN_ERR "olpc-dcon: failed to request STAT1 GPIO\n");
+                goto err_gp_stat1;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_IRQ, "OLPC-DCON")) {
+                printk(KERN_ERR "olpc-dcon: failed to request IRQ GPIO\n");
+                goto err_gp_irq;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_LOAD, "OLPC-DCON")) {
+                printk(KERN_ERR "olpc-dcon: failed to request LOAD GPIO\n");
+                goto err_gp_load;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_BLANK, "OLPC-DCON")) {
+                printk(KERN_ERR "olpc-dcon: failed to request BLANK GPIO\n");
+                goto err_gp_blank;
         }
-
-        /* Mask off the IO base address */
-        gpio_base = lo & 0x0000ff00;
 
         /* Turn off the event enable for GPIO7 just to be safe */
-        outl(1 << (16+7), gpio_base + GPIOx_EVNT_EN);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
+
+        /*
+         * Determine the current state by reading the GPIO bit; earlier
+         * stages of the boot process have established the state.
+         *
+         * Note that we read GPIO_OUPUT_VAL rather than GPIO_READ_BACK here;
+         * this is because OFW will disable input for the pin and set a value..
+         * READ_BACK will only contain a valid value if input is enabled and
+         * then a value is set.  So, future readings of the pin can use
+         * READ_BACK, but the first one cannot.  Awesome, huh?
+         */
+        dcon_source = cs5535_gpio_isset(OLPC_GPIO_DCON_LOAD, GPIO_OUTPUT_VAL)
+                ? DCON_SOURCE_CPU
+                : DCON_SOURCE_DCON;
+        dcon_pending = dcon_source;
 
         /* Set the directions for the GPIO pins */
-        outl(OUT_GPIOS | (IN_GPIOS << 16), gpio_base + GPIOx_OUT_EN);
-        outl(IN_GPIOS | (OUT_GPIOS << 16), gpio_base + GPIOx_IN_EN);
+        gpio_direction_input(OLPC_GPIO_DCON_STAT0);
+        gpio_direction_input(OLPC_GPIO_DCON_STAT1);
+        gpio_direction_input(OLPC_GPIO_DCON_IRQ);
+        gpio_direction_input(OLPC_GPIO_DCON_BLANK);
+        gpio_direction_output(OLPC_GPIO_DCON_LOAD,
+                        dcon_source == DCON_SOURCE_CPU);
 
         /* Set up the interrupt mappings */
 
         /* Set the IRQ to pair 2 */
-        geode_gpio_event_irq(OLPC_GPIO_DCON_IRQ, 2);
+        cs5535_gpio_setup_event(OLPC_GPIO_DCON_IRQ, 2, 0);
 
         /* Enable group 2 to trigger the DCON interrupt */
-        geode_gpio_set_irq(2, DCON_IRQ);
+        cs5535_gpio_set_irq(2, DCON_IRQ);
 
         /* Select edge level for interrupt (in PIC) */
         lob = inb(0x4d0);
@@ -65,52 +81,61 @@ static int dcon_init_xo_1(void)
         outb(lob, 0x4d0);
 
         /* Register the interupt handler */
-        if (request_irq(DCON_IRQ, &dcon_interrupt, 0, "DCON", &dcon_driver))
-                return -EIO;
+        if (request_irq(DCON_IRQ, &dcon_interrupt, 0, "DCON", &dcon_driver)) {
+                printk(KERN_ERR "olpc-dcon: failed to request DCON's irq\n");
+                goto err_req_irq;
+        }
 
         /* Clear INV_EN for GPIO7 (DCONIRQ) */
-        outl((1<<(16+7)), gpio_base + GPIOx_INV_EN);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_INVERT);
 
         /* Enable filter for GPIO12 (DCONBLANK) */
-        outl(1<<(12), gpio_base + GPIOx_IN_FLTR_EN);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_FILTER);
 
         /* Disable filter for GPIO7 */
-        outl(1<<(16+7), gpio_base + GPIOx_IN_FLTR_EN);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_FILTER);
 
         /* Disable event counter for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
-
-        outl(1<<(16+7), gpio_base + GPIOx_EVNTCNT_EN);
-        outl(1<<(16+12), gpio_base + GPIOx_EVNTCNT_EN);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_EVENT_COUNT);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_EVENT_COUNT);
 
         /* Add GPIO12 to the Filter Event Pair #7 */
-        outb(12, gpio_base + GPIO_FE7_SEL);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_FE7_SEL);
 
         /* Turn off negative Edge Enable for GPIO12 */
-        outl(1<<(16+12), gpio_base + GPIOx_NEGEDGE_EN);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_EN);
 
         /* Enable negative Edge Enable for GPIO7 */
-        outl(1<<7, gpio_base + GPIOx_NEGEDGE_EN);
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_EN);
 
         /* Zero the filter amount for Filter Event Pair #7 */
-        outw(0, gpio_base + GPIO_FLT7_AMNT);
+        cs5535_gpio_set(0, GPIO_FLTR7_AMOUNT);
 
         /* Clear the negative edge status for GPIO7 and GPIO12 */
-        outl((1<<7) | (1<<12), gpio_base+0x4c);
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_STS);
 
         /* FIXME:  Clear the posiitive status as well, just to be sure */
-        outl((1<<7) | (1<<12), gpio_base+0x48);
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_POSITIVE_EDGE_STS);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_POSITIVE_EDGE_STS);
 
         /* Enable events for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
-        outl((1<<(7))|(1<<12), gpio_base + GPIOx_EVNT_EN);
-
-        /* Determine the current state by reading the GPIO bit */
-        /* Earlier stages of the boot process have established the state */
-        dcon_source = inl(gpio_base + GPIOx_OUT_VAL) & (1<<11)
-                ? DCON_SOURCE_CPU
-                : DCON_SOURCE_DCON;
-        dcon_pending = dcon_source;
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_EVENTS_ENABLE);
 
         return 0;
+
+err_req_irq:
+        gpio_free(OLPC_GPIO_DCON_BLANK);
+err_gp_blank:
+        gpio_free(OLPC_GPIO_DCON_LOAD);
+err_gp_load:
+        gpio_free(OLPC_GPIO_DCON_IRQ);
+err_gp_irq:
+        gpio_free(OLPC_GPIO_DCON_STAT1);
+err_gp_stat1:
+        gpio_free(OLPC_GPIO_DCON_STAT0);
+        return -EIO;
 }
 
 static void dcon_wiggle_xo_1(void)
@@ -128,37 +153,44 @@ static void dcon_wiggle_xo_1(void)
          * simultaneously set AUX1 IN/OUT to GPIO14; ditto for SMB_DATA and
          * GPIO15.
          */
-        geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_VAL);
-        geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_ENABLE);
-        geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
-        geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX2);
-        geode_gpio_clear(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_VAL);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_ENABLE);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_ENABLE);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX2);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX2);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
 
         for (x = 0; x < 16; x++) {
                 udelay(5);
-                geode_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+                cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
                 udelay(5);
-                geode_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+                cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
         }
         udelay(5);
-        geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
-        geode_gpio_set(OLPC_GPIO_SMB_CLK|OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
 }
 
 static void dcon_set_dconload_1(int val)
 {
-        if (val)        
-                outl(1<<11, gpio_base + GPIOx_OUT_VAL);
-        else
-                outl(1<<(11 + 16), gpio_base + GPIOx_OUT_VAL);
+        gpio_set_value(OLPC_GPIO_DCON_LOAD, val);
 }
 
-static int dcon_read_status_xo_1(void)
+static u8 dcon_read_status_xo_1(void)
 {
-        int status = inl(gpio_base + GPIOx_READ_BACK) >> 5;
-        
+        u8 status;
+
+        status = gpio_get_value(OLPC_GPIO_DCON_STAT0);
+        status |= gpio_get_value(OLPC_GPIO_DCON_STAT1) << 1;
+
         /* Clear the negative edge status for GPIO7 */
-        outl(1 << 7, gpio_base + GPIOx_NEGEDGE_STS);
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
 
         return status;
 }
diff --git a/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c b/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c
index cca6a235ef9..4f56098bb36 100644
--- a/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c
+++ b/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c
@@ -195,9 +195,9 @@ static void dcon_set_dconload_xo_1_5(int val)
         }
 }
 
-static int dcon_read_status_xo_1_5(void) 
+static u8 dcon_read_status_xo_1_5(void)
 {
-        int status;
+        u8 status;
         
         if (!dcon_was_irq())
                 return -1;
diff --git a/drivers/staging/samsung-laptop/samsung-laptop.c b/drivers/staging/samsung-laptop/samsung-laptop.c
index ac2bf11e111..701e8d52a9f 100644
--- a/drivers/staging/samsung-laptop/samsung-laptop.c
+++ b/drivers/staging/samsung-laptop/samsung-laptop.c
@@ -269,7 +269,7 @@ static int update_status(struct backlight_device *bd)
         return 0;
 }
 
-static struct backlight_ops backlight_ops = {
+static const struct backlight_ops backlight_ops = {
         .get_brightness = get_brightness,
         .update_status  = update_status,
 };
diff --git a/drivers/telephony/ixj.c b/drivers/telephony/ixj.c
index 0d236f4bb8c..b00101972f2 100644
--- a/drivers/telephony/ixj.c
+++ b/drivers/telephony/ixj.c
@@ -284,12 +284,11 @@ static int samplerate = 100;
 
 module_param(ixjdebug, int, 0);
 
-static struct pci_device_id ixj_pci_tbl[] __devinitdata = {
+static DEFINE_PCI_DEVICE_TABLE(ixj_pci_tbl) = {
         { PCI_VENDOR_ID_QUICKNET, PCI_DEVICE_ID_QUICKNET_XJ,
           PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
         { }
 };
-
 MODULE_DEVICE_TABLE(pci, ixj_pci_tbl);
 
 /************************************************************************
@@ -6581,7 +6580,8 @@ static long do_ixj_ioctl(struct file *file_p, unsigned int cmd, unsigned long ar
         case IXJCTL_SET_FILTER:
                 if (copy_from_user(&jf, argp, sizeof(jf))) 
                         retval = -EFAULT;
-                retval = ixj_init_filter(j, &jf);
+                else
+                        retval = ixj_init_filter(j, &jf);
                 break;
         case IXJCTL_SET_FILTER_RAW:
                 if (copy_from_user(&jfr, argp, sizeof(jfr))) 
diff --git a/drivers/usb/gadget/imx_udc.c b/drivers/usb/gadget/imx_udc.c
index 1210534822d..5408186afc3 100644
--- a/drivers/usb/gadget/imx_udc.c
+++ b/drivers/usb/gadget/imx_udc.c
@@ -1320,7 +1320,7 @@ static struct imx_udc_struct controller = {
 };
 
 /*******************************************************************************
- * USB gadged driver functions
+ * USB gadget driver functions
  *******************************************************************************
  */
 int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
diff --git a/drivers/usb/gadget/langwell_udc.c b/drivers/usb/gadget/langwell_udc.c
index 777972454e3..1eca8b47ce3 100644
--- a/drivers/usb/gadget/langwell_udc.c
+++ b/drivers/usb/gadget/langwell_udc.c
@@ -3086,7 +3086,7 @@ static void langwell_udc_remove(struct pci_dev *pdev)
 
         kfree(dev->ep);
 
-        /* diable IRQ handler */
+        /* disable IRQ handler */
         if (dev->got_irq)
                 free_irq(pdev->irq, dev);
 
@@ -3406,7 +3406,7 @@ static int langwell_udc_suspend(struct pci_dev *pdev, pm_message_t state)
         /* disable interrupt and set controller to stop state */
         langwell_udc_stop(dev);
 
-        /* diable IRQ handler */
+        /* disable IRQ handler */
         if (dev->got_irq)
                 free_irq(pdev->irq, dev);
         dev->got_irq = 0;
diff --git a/drivers/usb/host/fhci-hcd.c b/drivers/usb/host/fhci-hcd.c
index 20092a27a1e..12fd184226f 100644
--- a/drivers/usb/host/fhci-hcd.c
+++ b/drivers/usb/host/fhci-hcd.c
@@ -98,13 +98,13 @@ void fhci_usb_enable_interrupt(struct fhci_usb *usb)
         usb->intr_nesting_cnt--;
 }
 
-/* diable the usb interrupt */
+/* disable the usb interrupt */
 void fhci_usb_disable_interrupt(struct fhci_usb *usb)
 {
         struct fhci_hcd *fhci = usb->fhci;
 
         if (usb->intr_nesting_cnt == 0) {
-                /* diable the timer interrupt */
+                /* disable the timer interrupt */
                 disable_irq_nosync(fhci->timer->irq);
 
                 /* disable the usb interrupt */
diff --git a/drivers/usb/host/fhci-tds.c b/drivers/usb/host/fhci-tds.c
index 7be548ca218..38fe058fbe6 100644
--- a/drivers/usb/host/fhci-tds.c
+++ b/drivers/usb/host/fhci-tds.c
@@ -271,8 +271,8 @@ void fhci_init_ep_registers(struct fhci_usb *usb, struct endpoint *ep,
 
 /*
  * Collect the submitted frames and inform the application about them
- * It is also prepearing the TDs for new frames. If the Tx interrupts
- * are diabled, the application should call that routine to get
+ * It is also preparing the TDs for new frames. If the Tx interrupts
+ * are disabled, the application should call that routine to get
  * confirmation about the submitted frames. Otherwise, the routine is
  * called frome the interrupt service routine during the Tx interrupt.
  * In that case the application is informed by calling the application
diff --git a/drivers/usb/host/imx21-hcd.c b/drivers/usb/host/imx21-hcd.c
index e49b75a7800..f90d003f230 100644
--- a/drivers/usb/host/imx21-hcd.c
+++ b/drivers/usb/host/imx21-hcd.c
@@ -1658,7 +1658,7 @@ static int imx21_hc_reset(struct usb_hcd *hcd)
 
         spin_lock_irqsave(&imx21->lock, flags);
 
-        /* Reset the Host controler modules */
+        /* Reset the Host controller modules */
         writel(USBOTG_RST_RSTCTRL | USBOTG_RST_RSTRH |
                 USBOTG_RST_RSTHSIE | USBOTG_RST_RSTHC,
                 imx21->regs + USBOTG_RST_CTRL);
diff --git a/drivers/usb/host/oxu210hp-hcd.c b/drivers/usb/host/oxu210hp-hcd.c
index 32149be4ad8..e0cb12b573f 100644
--- a/drivers/usb/host/oxu210hp-hcd.c
+++ b/drivers/usb/host/oxu210hp-hcd.c
@@ -3094,7 +3094,7 @@ static int oxu_hub_status_data(struct usb_hcd *hcd, char *buf)
 
         /* Some boards (mostly VIA?) report bogus overcurrent indications,
          * causing massive log spam unless we completely ignore them.  It
-         * may be relevant that VIA VT8235 controlers, where PORT_POWER is
+         * may be relevant that VIA VT8235 controllers, where PORT_POWER is
          * always set, seem to clear PORT_OCC and PORT_CSC when writing to
          * PORT_POWER; that's surprising, but maybe within-spec.
          */
diff --git a/drivers/usb/misc/adutux.c b/drivers/usb/misc/adutux.c
index 44f8b922505..a6afd15f6a4 100644
--- a/drivers/usb/misc/adutux.c
+++ b/drivers/usb/misc/adutux.c
@@ -717,7 +717,7 @@ static int adu_probe(struct usb_interface *interface,
                 goto exit;
         }
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL);
         if (dev == NULL) {
                 dev_err(&interface->dev, "Out of memory\n");
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index c9078e4e1f4..e573e470401 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -769,7 +769,7 @@ static int iowarrior_probe(struct usb_interface *interface,
         int i;
         int retval = -ENOMEM;
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(struct iowarrior), GFP_KERNEL);
         if (dev == NULL) {
                 dev_err(&interface->dev, "Out of memory\n");
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index edffef64233..eefb8275bb7 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -642,7 +642,7 @@ static int ld_usb_probe(struct usb_interface *intf, const struct usb_device_id *
         int i;
         int retval = -ENOMEM;
 
-        /* allocate memory for our device state and intialize it */
+        /* allocate memory for our device state and initialize it */
 
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 9b162dfaa4f..ed58c6c8f15 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1684,7 +1684,7 @@ static inline void __init musb_g_init_endpoints(struct musb *musb)
         struct musb_hw_ep       *hw_ep;
         unsigned                count = 0;
 
-        /* intialize endpoint list just once */
+        /* initialize endpoint list just once */
         INIT_LIST_HEAD(&(musb->g.ep_list));
 
         for (epnum = 0, hw_ep = musb->endpoints;
@@ -1765,7 +1765,7 @@ void musb_gadget_cleanup(struct musb *musb)
  *
  * -EINVAL something went wrong (not driver)
  * -EBUSY another gadget is already using the controller
- * -ENOMEM no memeory to perform the operation
+ * -ENOMEM no memory to perform the operation
  *
  * @param driver the gadget driver
  * @param bind the driver's bind function
diff --git a/drivers/usb/wusbcore/wa-rpipe.c b/drivers/usb/wusbcore/wa-rpipe.c
index c7b1d8108de..8cb9d80207f 100644
--- a/drivers/usb/wusbcore/wa-rpipe.c
+++ b/drivers/usb/wusbcore/wa-rpipe.c
@@ -49,7 +49,7 @@
  *
  *  USB Stack port number    4 (1 based)
  *  WUSB code port index     3 (0 based)
- *  USB Addresss             5 (2 based -- 0 is for default, 1 for root hub)
+ *  USB Address             5 (2 based -- 0 is for default, 1 for root hub)
  *
  *  Now, because we don't use the concept as default address exactly
  *  like the (wired) USB code does, we need to kind of skip it. So we
diff --git a/drivers/video/atmel_lcdfb.c b/drivers/video/atmel_lcdfb.c
index 8dce2512633..bac16345021 100644
--- a/drivers/video/atmel_lcdfb.c
+++ b/drivers/video/atmel_lcdfb.c
@@ -111,7 +111,7 @@ static int atmel_bl_get_brightness(struct backlight_device *bl)
         return lcdc_readl(sinfo, ATMEL_LCDC_CONTRAST_VAL);
 }
 
-static struct backlight_ops atmel_lcdc_bl_ops = {
+static const struct backlight_ops atmel_lcdc_bl_ops = {
         .update_status = atmel_bl_update_status,
         .get_brightness = atmel_bl_get_brightness,
 };
diff --git a/drivers/video/aty/aty128fb.c b/drivers/video/aty/aty128fb.c
index 34a0851bcbf..dd9de2e8058 100644
--- a/drivers/video/aty/aty128fb.c
+++ b/drivers/video/aty/aty128fb.c
@@ -1786,7 +1786,7 @@ static int aty128_bl_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops aty128_bl_data = {
+static const struct backlight_ops aty128_bl_data = {
         .get_brightness = aty128_bl_get_brightness,
         .update_status  = aty128_bl_update_status,
 };
diff --git a/drivers/video/aty/atyfb_base.c b/drivers/video/aty/atyfb_base.c
index 5a3ce3ad1ec..767ab4fb1a0 100644
--- a/drivers/video/aty/atyfb_base.c
+++ b/drivers/video/aty/atyfb_base.c
@@ -2221,7 +2221,7 @@ static int aty_bl_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops aty_bl_data = {
+static const struct backlight_ops aty_bl_data = {
         .get_brightness = aty_bl_get_brightness,
         .update_status  = aty_bl_update_status,
 };
diff --git a/drivers/video/aty/radeon_backlight.c b/drivers/video/aty/radeon_backlight.c
index 256966e9667..9b811ddbce8 100644
--- a/drivers/video/aty/radeon_backlight.c
+++ b/drivers/video/aty/radeon_backlight.c
@@ -128,7 +128,7 @@ static int radeon_bl_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops radeon_bl_data = {
+static const struct backlight_ops radeon_bl_data = {
         .get_brightness = radeon_bl_get_brightness,
         .update_status  = radeon_bl_update_status,
 };
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index 38ffc3fbcbe..c789c46e38a 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -155,7 +155,7 @@ out:
         return -EINVAL;
 }
 
-static struct backlight_ops pm860x_backlight_ops = {
+static const struct backlight_ops pm860x_backlight_ops = {
         .options        = BL_CORE_SUSPENDRESUME,
         .update_status  = pm860x_backlight_update_status,
         .get_brightness = pm860x_backlight_get_brightness,
diff --git a/drivers/video/backlight/l4f00242t03.c b/drivers/video/backlight/l4f00242t03.c
index c67801e57aa..98ad3e5f7c8 100644
--- a/drivers/video/backlight/l4f00242t03.c
+++ b/drivers/video/backlight/l4f00242t03.c
@@ -25,7 +25,7 @@
 struct l4f00242t03_priv {
         struct spi_device       *spi;
         struct lcd_device       *ld;
-        int lcd_on:1;
+        int lcd_state;
         struct regulator *io_reg;
         struct regulator *core_reg;
 };
@@ -62,11 +62,36 @@ static void l4f00242t03_lcd_init(struct spi_device *spi)
                 regulator_enable(priv->core_reg);
         }
 
+        l4f00242t03_reset(pdata->reset_gpio);
+
         gpio_set_value(pdata->data_enable_gpio, 1);
         msleep(60);
         spi_write(spi, (const u8 *)cmd, ARRAY_SIZE(cmd) * sizeof(u16));
 }
 
+static void l4f00242t03_lcd_powerdown(struct spi_device *spi)
+{
+        struct l4f00242t03_pdata *pdata = spi->dev.platform_data;
+        struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
+
+        dev_dbg(&spi->dev, "Powering down LCD\n");
+
+        gpio_set_value(pdata->data_enable_gpio, 0);
+
+        if (priv->io_reg)
+                regulator_disable(priv->io_reg);
+
+        if (priv->core_reg)
+                regulator_disable(priv->core_reg);
+}
+
+static int l4f00242t03_lcd_power_get(struct lcd_device *ld)
+{
+        struct l4f00242t03_priv *priv = lcd_get_data(ld);
+
+        return priv->lcd_state;
+}
+
 static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
 {
         struct l4f00242t03_priv *priv = lcd_get_data(ld);
@@ -79,35 +104,54 @@ static int l4f00242t03_lcd_power_set(struct lcd_device *ld, int power)
         const u16 disoff = 0x28;
 
         if (power <= FB_BLANK_NORMAL) {
-                if (priv->lcd_on)
-                        return 0;
-
-                dev_dbg(&spi->dev, "turning on LCD\n");
-
-                spi_write(spi, (const u8 *)&slpout, sizeof(u16));
-                msleep(60);
-                spi_write(spi, (const u8 *)&dison, sizeof(u16));
-
-                priv->lcd_on = 1;
+                if (priv->lcd_state <= FB_BLANK_NORMAL) {
+                        /* Do nothing, the LCD is running */
+                } else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
+                        dev_dbg(&spi->dev, "Resuming LCD\n");
+
+                        spi_write(spi, (const u8 *)&slpout, sizeof(u16));
+                        msleep(60);
+                        spi_write(spi, (const u8 *)&dison, sizeof(u16));
+                } else {
+                        /* priv->lcd_state == FB_BLANK_POWERDOWN */
+                        l4f00242t03_lcd_init(spi);
+                        priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
+                        l4f00242t03_lcd_power_set(priv->ld, power);
+                }
+        } else if (power < FB_BLANK_POWERDOWN) {
+                if (priv->lcd_state <= FB_BLANK_NORMAL) {
+                        /* Send the display in standby */
+                        dev_dbg(&spi->dev, "Standby the LCD\n");
+
+                        spi_write(spi, (const u8 *)&disoff, sizeof(u16));
+                        msleep(60);
+                        spi_write(spi, (const u8 *)&slpin, sizeof(u16));
+                } else if (priv->lcd_state < FB_BLANK_POWERDOWN) {
+                        /* Do nothing, the LCD is already in standby */
+                } else {
+                        /* priv->lcd_state == FB_BLANK_POWERDOWN */
+                        l4f00242t03_lcd_init(spi);
+                        priv->lcd_state = FB_BLANK_UNBLANK;
+                        l4f00242t03_lcd_power_set(ld, power);
+                }
         } else {
-                if (!priv->lcd_on)
-                        return 0;
-
-                dev_dbg(&spi->dev, "turning off LCD\n");
-
-                spi_write(spi, (const u8 *)&disoff, sizeof(u16));
-                msleep(60);
-                spi_write(spi, (const u8 *)&slpin, sizeof(u16));
-
-                priv->lcd_on = 0;
+                /* power == FB_BLANK_POWERDOWN */
+                if (priv->lcd_state != FB_BLANK_POWERDOWN) {
+                        /* Clear the screen before shutting down */
+                        spi_write(spi, (const u8 *)&disoff, sizeof(u16));
+                        msleep(60);
+                        l4f00242t03_lcd_powerdown(spi);
+                }
         }
 
+        priv->lcd_state = power;
+
         return 0;
 }
 
 static struct lcd_ops l4f_ops = {
         .set_power      = l4f00242t03_lcd_power_set,
-        .get_power      = NULL,
+        .get_power      = l4f00242t03_lcd_power_get,
 };
 
 static int __devinit l4f00242t03_probe(struct spi_device *spi)
@@ -185,9 +229,9 @@ static int __devinit l4f00242t03_probe(struct spi_device *spi)
         }
 
         /* Init the LCD */
-        l4f00242t03_reset(pdata->reset_gpio);
         l4f00242t03_lcd_init(spi);
-        l4f00242t03_lcd_power_set(priv->ld, 1);
+        priv->lcd_state = FB_BLANK_VSYNC_SUSPEND;
+        l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_UNBLANK);
 
         dev_info(&spi->dev, "Epson l4f00242t03 lcd probed.\n");
 
@@ -214,9 +258,11 @@ static int __devexit l4f00242t03_remove(struct spi_device *spi)
         struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
         struct l4f00242t03_pdata *pdata = priv->spi->dev.platform_data;
 
-        l4f00242t03_lcd_power_set(priv->ld, 0);
+        l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
         lcd_device_unregister(priv->ld);
 
+        dev_set_drvdata(&spi->dev, NULL);
+
         gpio_free(pdata->data_enable_gpio);
         gpio_free(pdata->reset_gpio);
 
@@ -230,6 +276,15 @@ static int __devexit l4f00242t03_remove(struct spi_device *spi)
         return 0;
 }
 
+static void l4f00242t03_shutdown(struct spi_device *spi)
+{
+        struct l4f00242t03_priv *priv = dev_get_drvdata(&spi->dev);
+
+        if (priv)
+                l4f00242t03_lcd_power_set(priv->ld, FB_BLANK_POWERDOWN);
+
+}
+
 static struct spi_driver l4f00242t03_driver = {
         .driver = {
                 .name   = "l4f00242t03",
@@ -237,6 +292,7 @@ static struct spi_driver l4f00242t03_driver = {
         },
         .probe          = l4f00242t03_probe,
         .remove         = __devexit_p(l4f00242t03_remove),
+        .shutdown       = l4f00242t03_shutdown,
 };
 
 static __init int l4f00242t03_init(void)
diff --git a/drivers/video/backlight/max8925_bl.c b/drivers/video/backlight/max8925_bl.c
index b2b2c7ba1f6..209acc105cb 100644
--- a/drivers/video/backlight/max8925_bl.c
+++ b/drivers/video/backlight/max8925_bl.c
@@ -92,7 +92,7 @@ static int max8925_backlight_get_brightness(struct backlight_device *bl)
         return ret;
 }
 
-static struct backlight_ops max8925_backlight_ops = {
+static const struct backlight_ops max8925_backlight_ops = {
         .options        = BL_CORE_SUSPENDRESUME,
         .update_status  = max8925_backlight_update_status,
         .get_brightness = max8925_backlight_get_brightness,
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 915448ec75b..c97491b8b39 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -375,7 +375,8 @@ static const char *vgacon_startup(void)
         u16 saved1, saved2;
         volatile u16 *p;
 
-        if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB) {
+        if (screen_info.orig_video_isVGA == VIDEO_TYPE_VLFB ||
+            screen_info.orig_video_isVGA == VIDEO_TYPE_EFI) {
               no_vga:
 #ifdef CONFIG_DUMMY_CONSOLE
                 conswitchp = &dummy_con;
diff --git a/drivers/video/nvidia/nv_backlight.c b/drivers/video/nvidia/nv_backlight.c
index 2fb552a6f32..6aac6d1b937 100644
--- a/drivers/video/nvidia/nv_backlight.c
+++ b/drivers/video/nvidia/nv_backlight.c
@@ -87,7 +87,7 @@ static int nvidia_bl_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops nvidia_bl_ops = {
+static const struct backlight_ops nvidia_bl_ops = {
         .get_brightness = nvidia_bl_get_brightness,
         .update_status  = nvidia_bl_update_status,
 };
diff --git a/drivers/video/omap2/displays/panel-taal.c b/drivers/video/omap2/displays/panel-taal.c
index e1c765d1141..61026f96ad2 100644
--- a/drivers/video/omap2/displays/panel-taal.c
+++ b/drivers/video/omap2/displays/panel-taal.c
@@ -465,7 +465,7 @@ static int taal_bl_get_intensity(struct backlight_device *dev)
         return 0;
 }
 
-static struct backlight_ops taal_bl_ops = {
+static const struct backlight_ops taal_bl_ops = {
         .get_brightness = taal_bl_get_intensity,
         .update_status  = taal_bl_update_status,
 };
diff --git a/drivers/video/riva/fbdev.c b/drivers/video/riva/fbdev.c
index 618f36bec10..da388186d61 100644
--- a/drivers/video/riva/fbdev.c
+++ b/drivers/video/riva/fbdev.c
@@ -331,7 +331,7 @@ static int riva_bl_get_brightness(struct backlight_device *bd)
         return bd->props.brightness;
 }
 
-static struct backlight_ops riva_bl_ops = {
+static const struct backlight_ops riva_bl_ops = {
         .get_brightness = riva_bl_get_brightness,
         .update_status  = riva_bl_update_status,
 };
diff --git a/drivers/video/sstfb.c b/drivers/video/sstfb.c
index dee64c3b1e6..2ab704118c4 100644
--- a/drivers/video/sstfb.c
+++ b/drivers/video/sstfb.c
@@ -536,7 +536,7 @@ static int sstfb_set_par(struct fb_info *info)
         fbiinit2 = sst_read(FBIINIT2);
         fbiinit3 = sst_read(FBIINIT3);
 
-        /* everything is reset. we enable fbiinit2/3 remap : dac acces ok */
+        /* everything is reset. we enable fbiinit2/3 remap : dac access ok */
         pci_write_config_dword(sst_dev, PCI_INIT_ENABLE,
                                PCI_EN_INIT_WR | PCI_REMAP_DAC );
 
diff --git a/drivers/w1/slaves/Kconfig b/drivers/w1/slaves/Kconfig
index 1f51366417b..f0c909625bd 100644
--- a/drivers/w1/slaves/Kconfig
+++ b/drivers/w1/slaves/Kconfig
@@ -16,6 +16,17 @@ config W1_SLAVE_SMEM
           Say Y here if you want to connect 1-wire
           simple 64bit memory rom(ds2401/ds2411/ds1990*) to your wire.
 
+config W1_SLAVE_DS2423
+        tristate "Counter 1-wire device (DS2423)"
+        select CRC16
+        help
+          If you enable this you can read the counter values available
+          in the DS2423 chipset from the w1_slave file under the
+          sys file system.
+
+          Say Y here if you want to use a 1-wire
+          counter family device (DS2423).
+
 config W1_SLAVE_DS2431
         tristate "1kb EEPROM family support (DS2431)"
         help
diff --git a/drivers/w1/slaves/Makefile b/drivers/w1/slaves/Makefile
index f1f51f19b12..3c76350a24f 100644
--- a/drivers/w1/slaves/Makefile
+++ b/drivers/w1/slaves/Makefile
@@ -4,6 +4,7 @@
 
 obj-$(CONFIG_W1_SLAVE_THERM)    += w1_therm.o
 obj-$(CONFIG_W1_SLAVE_SMEM)     += w1_smem.o
+obj-$(CONFIG_W1_SLAVE_DS2423)   += w1_ds2423.o
 obj-$(CONFIG_W1_SLAVE_DS2431)   += w1_ds2431.o
 obj-$(CONFIG_W1_SLAVE_DS2433)   += w1_ds2433.o
 obj-$(CONFIG_W1_SLAVE_DS2760)   += w1_ds2760.o
diff --git a/drivers/w1/slaves/w1_ds2423.c b/drivers/w1/slaves/w1_ds2423.c
new file mode 100644
index 00000000000..7a7dbe5026f
--- /dev/null
+++ b/drivers/w1/slaves/w1_ds2423.c
@@ -0,0 +1,166 @@
+/*
+ *      w1_ds2423.c
+ *
+ * Copyright (c) 2010 Mika Laitio <lamikr@pilppa.org>
+ *
+ * This driver will read and write the value of 4 counters to w1_slave file in
+ * sys filesystem.
+ * Inspired by the w1_therm and w1_ds2431 drivers.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the therms 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/kernel.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/types.h>
+#include <linux/delay.h>
+#include <linux/crc16.h>
+
+#include "../w1.h"
+#include "../w1_int.h"
+#include "../w1_family.h"
+
+#define CRC16_VALID     0xb001
+#define CRC16_INIT      0
+
+#define COUNTER_COUNT 4
+#define READ_BYTE_COUNT 42
+
+static ssize_t w1_counter_read(struct device *device,
+        struct device_attribute *attr, char *buf);
+
+static struct device_attribute w1_counter_attr =
+        __ATTR(w1_slave, S_IRUGO, w1_counter_read, NULL);
+
+static ssize_t w1_counter_read(struct device *device,
+        struct device_attribute *attr, char *out_buf)
+{
+        struct w1_slave *sl = dev_to_w1_slave(device);
+        struct w1_master *dev = sl->master;
+        u8 rbuf[COUNTER_COUNT * READ_BYTE_COUNT];
+        u8 wrbuf[3];
+        int rom_addr;
+        int read_byte_count;
+        int result;
+        ssize_t c;
+        int ii;
+        int p;
+        int crc;
+
+        c               = PAGE_SIZE;
+        rom_addr        = (12 << 5) + 31;
+        wrbuf[0]        = 0xA5;
+        wrbuf[1]        = rom_addr & 0xFF;
+        wrbuf[2]        = rom_addr >> 8;
+        mutex_lock(&dev->mutex);
+        if (!w1_reset_select_slave(sl)) {
+                w1_write_block(dev, wrbuf, 3);
+                read_byte_count = 0;
+                for (p = 0; p < 4; p++) {
+                        /*
+                         * 1 byte for first bytes in ram page read
+                         * 4 bytes for counter
+                         * 4 bytes for zero bits
+                         * 2 bytes for crc
+                         * 31 remaining bytes from the ram page
+                         */
+                        read_byte_count += w1_read_block(dev,
+                                rbuf + (p * READ_BYTE_COUNT), READ_BYTE_COUNT);
+                        for (ii = 0; ii < READ_BYTE_COUNT; ++ii)
+                                c -= snprintf(out_buf + PAGE_SIZE - c,
+                                        c, "%02x ",
+                                        rbuf[(p * READ_BYTE_COUNT) + ii]);
+                        if (read_byte_count != (p + 1) * READ_BYTE_COUNT) {
+                                dev_warn(device,
+                                        "w1_counter_read() returned %u bytes "
+                                        "instead of %d bytes wanted.\n",
+                                        read_byte_count,
+                                        READ_BYTE_COUNT);
+                                c -= snprintf(out_buf + PAGE_SIZE - c,
+                                        c, "crc=NO\n");
+                        } else {
+                                if (p == 0) {
+                                        crc = crc16(CRC16_INIT, wrbuf, 3);
+                                        crc = crc16(crc, rbuf, 11);
+                                } else {
+                                        /*
+                                         * DS2423 calculates crc from all bytes
+                                         * read after the previous crc bytes.
+                                         */
+                                        crc = crc16(CRC16_INIT,
+                                                (rbuf + 11) +
+                                                ((p - 1) * READ_BYTE_COUNT),
+                                                READ_BYTE_COUNT);
+                                }
+                                if (crc == CRC16_VALID) {
+                                        result = 0;
+                                        for (ii = 4; ii > 0; ii--) {
+                                                result <<= 8;
+                                                result |= rbuf[(p *
+                                                        READ_BYTE_COUNT) + ii];
+                                        }
+                                        c -= snprintf(out_buf + PAGE_SIZE - c,
+                                                c, "crc=YES c=%d\n", result);
+                                } else {
+                                        c -= snprintf(out_buf + PAGE_SIZE - c,
+                                                c, "crc=NO\n");
+                                }
+                        }
+                }
+        } else {
+                c -= snprintf(out_buf + PAGE_SIZE - c, c, "Connection error");
+        }
+        mutex_unlock(&dev->mutex);
+        return PAGE_SIZE - c;
+}
+
+static int w1_f1d_add_slave(struct w1_slave *sl)
+{
+        return device_create_file(&sl->dev, &w1_counter_attr);
+}
+
+static void w1_f1d_remove_slave(struct w1_slave *sl)
+{
+        device_remove_file(&sl->dev, &w1_counter_attr);
+}
+
+static struct w1_family_ops w1_f1d_fops = {
+        .add_slave      = w1_f1d_add_slave,
+        .remove_slave   = w1_f1d_remove_slave,
+};
+
+static struct w1_family w1_family_1d = {
+        .fid = W1_COUNTER_DS2423,
+        .fops = &w1_f1d_fops,
+};
+
+static int __init w1_f1d_init(void)
+{
+        return w1_register_family(&w1_family_1d);
+}
+
+static void __exit w1_f1d_exit(void)
+{
+        w1_unregister_family(&w1_family_1d);
+}
+
+module_init(w1_f1d_init);
+module_exit(w1_f1d_exit);
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Mika Laitio <lamikr@pilppa.org>");
+MODULE_DESCRIPTION("w1 family 1d driver for DS2423, 4 counters and 4kb ram");
diff --git a/drivers/w1/w1_family.h b/drivers/w1/w1_family.h
index 3ca1b9298f2..f3b636d7caf 100644
--- a/drivers/w1/w1_family.h
+++ b/drivers/w1/w1_family.h
@@ -30,6 +30,7 @@
 #define W1_FAMILY_SMEM_01       0x01
 #define W1_FAMILY_SMEM_81       0x81
 #define W1_THERM_DS18S20        0x10
+#define W1_COUNTER_DS2423       0x1D
 #define W1_THERM_DS1822         0x22
 #define W1_EEPROM_DS2433        0x23
 #define W1_THERM_DS18B20        0x28
diff --git a/drivers/xen/Kconfig b/drivers/xen/Kconfig
index 6e6180ccd72..5a48ce996de 100644
--- a/drivers/xen/Kconfig
+++ b/drivers/xen/Kconfig
@@ -29,6 +29,14 @@ config XEN_DEV_EVTCHN
           firing.
           If in doubt, say yes.
 
+config XEN_BACKEND
+        bool "Backend driver support"
+        depends on XEN_DOM0
+        default y
+        help
+          Support for backend device drivers that provide I/O services
+          to other virtual machines.
+
 config XENFS
         tristate "Xen filesystem"
         default y
@@ -62,6 +70,9 @@ config XEN_SYS_HYPERVISOR
          virtual environment, /sys/hypervisor will still be present,
          but will have no xen contents.
 
+config XEN_XENBUS_FRONTEND
+       tristate
+
 config XEN_PLATFORM_PCI
         tristate "xen platform pci device driver"
         depends on XEN_PVHVM
diff --git a/drivers/xen/xenbus/Makefile b/drivers/xen/xenbus/Makefile
index 5571f5b8422..8dca685358b 100644
--- a/drivers/xen/xenbus/Makefile
+++ b/drivers/xen/xenbus/Makefile
@@ -5,3 +5,8 @@ xenbus-objs += xenbus_client.o
 xenbus-objs += xenbus_comms.o
 xenbus-objs += xenbus_xs.o
 xenbus-objs += xenbus_probe.o
+
+xenbus-be-objs-$(CONFIG_XEN_BACKEND) += xenbus_probe_backend.o
+xenbus-objs += $(xenbus-be-objs-y)
+
+obj-$(CONFIG_XEN_XENBUS_FRONTEND) += xenbus_probe_frontend.o
diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c
index deb9c4ba3a9..baa65e7fbbc 100644
--- a/drivers/xen/xenbus/xenbus_probe.c
+++ b/drivers/xen/xenbus/xenbus_probe.c
@@ -56,7 +56,6 @@
 #include <xen/events.h>
 #include <xen/page.h>
 
-#include <xen/platform_pci.h>
 #include <xen/hvm.h>
 
 #include "xenbus_comms.h"
@@ -73,15 +72,6 @@ static unsigned long xen_store_mfn;
 
 static BLOCKING_NOTIFIER_HEAD(xenstore_chain);
 
-static void wait_for_devices(struct xenbus_driver *xendrv);
-
-static int xenbus_probe_frontend(const char *type, const char *name);
-
-static void xenbus_dev_shutdown(struct device *_dev);
-
-static int xenbus_dev_suspend(struct device *dev, pm_message_t state);
-static int xenbus_dev_resume(struct device *dev);
-
 /* If something in array of ids matches this device, return it. */
 static const struct xenbus_device_id *
 match_device(const struct xenbus_device_id *arr, struct xenbus_device *dev)
@@ -102,34 +92,7 @@ int xenbus_match(struct device *_dev, struct device_driver *_drv)
 
         return match_device(drv->ids, to_xenbus_device(_dev)) != NULL;
 }
-
-static int xenbus_uevent(struct device *_dev, struct kobj_uevent_env *env)
-{
-        struct xenbus_device *dev = to_xenbus_device(_dev);
-
-        if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
-                return -ENOMEM;
-
-        return 0;
-}
-
-/* device/<type>/<id> => <type>-<id> */
-static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
-{
-        nodename = strchr(nodename, '/');
-        if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
-                printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);
-                return -EINVAL;
-        }
-
-        strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
-        if (!strchr(bus_id, '/')) {
-                printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);
-                return -EINVAL;
-        }
-        *strchr(bus_id, '/') = '-';
-        return 0;
-}
+EXPORT_SYMBOL_GPL(xenbus_match);
 
 
 static void free_otherend_details(struct xenbus_device *dev)
@@ -149,7 +112,30 @@ static void free_otherend_watch(struct xenbus_device *dev)
 }
 
 
-int read_otherend_details(struct xenbus_device *xendev,
+static int talk_to_otherend(struct xenbus_device *dev)
+{
+        struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
+
+        free_otherend_watch(dev);
+        free_otherend_details(dev);
+
+        return drv->read_otherend_details(dev);
+}
+
+
+
+static int watch_otherend(struct xenbus_device *dev)
+{
+        struct xen_bus_type *bus =
+                container_of(dev->dev.bus, struct xen_bus_type, bus);
+
+        return xenbus_watch_pathfmt(dev, &dev->otherend_watch,
+                                    bus->otherend_changed,
+                                    "%s/%s", dev->otherend, "state");
+}
+
+
+int xenbus_read_otherend_details(struct xenbus_device *xendev,
                                  char *id_node, char *path_node)
 {
         int err = xenbus_gather(XBT_NIL, xendev->nodename,
@@ -174,39 +160,11 @@ int read_otherend_details(struct xenbus_device *xendev,
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(xenbus_read_otherend_details);
 
-
-static int read_backend_details(struct xenbus_device *xendev)
-{
-        return read_otherend_details(xendev, "backend-id", "backend");
-}
-
-static struct device_attribute xenbus_dev_attrs[] = {
-        __ATTR_NULL
-};
-
-/* Bus type for frontend drivers. */
-static struct xen_bus_type xenbus_frontend = {
-        .root = "device",
-        .levels = 2,            /* device/type/<id> */
-        .get_bus_id = frontend_bus_id,
-        .probe = xenbus_probe_frontend,
-        .bus = {
-                .name      = "xen",
-                .match     = xenbus_match,
-                .uevent    = xenbus_uevent,
-                .probe     = xenbus_dev_probe,
-                .remove    = xenbus_dev_remove,
-                .shutdown  = xenbus_dev_shutdown,
-                .dev_attrs = xenbus_dev_attrs,
-
-                .suspend   = xenbus_dev_suspend,
-                .resume    = xenbus_dev_resume,
-        },
-};
-
-static void otherend_changed(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
+void xenbus_otherend_changed(struct xenbus_watch *watch,
+                             const char **vec, unsigned int len,
+                             int ignore_on_shutdown)
 {
         struct xenbus_device *dev =
                 container_of(watch, struct xenbus_device, otherend_watch);
@@ -234,11 +192,7 @@ static void otherend_changed(struct xenbus_watch *watch,
          * work that can fail e.g., when the rootfs is gone.
          */
         if (system_state > SYSTEM_RUNNING) {
-                struct xen_bus_type *bus = bus;
-                bus = container_of(dev->dev.bus, struct xen_bus_type, bus);
-                /* If we're frontend, drive the state machine to Closed. */
-                /* This should cause the backend to release our resources. */
-                if ((bus == &xenbus_frontend) && (state == XenbusStateClosing))
+                if (ignore_on_shutdown && (state == XenbusStateClosing))
                         xenbus_frontend_closed(dev);
                 return;
         }
@@ -246,25 +200,7 @@ static void otherend_changed(struct xenbus_watch *watch,
         if (drv->otherend_changed)
                 drv->otherend_changed(dev, state);
 }
-
-
-static int talk_to_otherend(struct xenbus_device *dev)
-{
-        struct xenbus_driver *drv = to_xenbus_driver(dev->dev.driver);
-
-        free_otherend_watch(dev);
-        free_otherend_details(dev);
-
-        return drv->read_otherend_details(dev);
-}
-
-
-static int watch_otherend(struct xenbus_device *dev)
-{
-        return xenbus_watch_pathfmt(dev, &dev->otherend_watch, otherend_changed,
-                                    "%s/%s", dev->otherend, "state");
-}
-
+EXPORT_SYMBOL_GPL(xenbus_otherend_changed);
 
 int xenbus_dev_probe(struct device *_dev)
 {
@@ -308,8 +244,9 @@ int xenbus_dev_probe(struct device *_dev)
 fail:
         xenbus_dev_error(dev, err, "xenbus_dev_probe on %s", dev->nodename);
         xenbus_switch_state(dev, XenbusStateClosed);
-        return -ENODEV;
+        return err;
 }
+EXPORT_SYMBOL_GPL(xenbus_dev_probe);
 
 int xenbus_dev_remove(struct device *_dev)
 {
@@ -327,8 +264,9 @@ int xenbus_dev_remove(struct device *_dev)
         xenbus_switch_state(dev, XenbusStateClosed);
         return 0;
 }
+EXPORT_SYMBOL_GPL(xenbus_dev_remove);
 
-static void xenbus_dev_shutdown(struct device *_dev)
+void xenbus_dev_shutdown(struct device *_dev)
 {
         struct xenbus_device *dev = to_xenbus_device(_dev);
         unsigned long timeout = 5*HZ;
@@ -349,6 +287,7 @@ static void xenbus_dev_shutdown(struct device *_dev)
  out:
         put_device(&dev->dev);
 }
+EXPORT_SYMBOL_GPL(xenbus_dev_shutdown);
 
 int xenbus_register_driver_common(struct xenbus_driver *drv,
                                   struct xen_bus_type *bus,
@@ -362,25 +301,7 @@ int xenbus_register_driver_common(struct xenbus_driver *drv,
 
         return driver_register(&drv->driver);
 }
-
-int __xenbus_register_frontend(struct xenbus_driver *drv,
-                               struct module *owner, const char *mod_name)
-{
-        int ret;
-
-        drv->read_otherend_details = read_backend_details;
-
-        ret = xenbus_register_driver_common(drv, &xenbus_frontend,
-                                            owner, mod_name);
-        if (ret)
-                return ret;
-
-        /* If this driver is loaded as a module wait for devices to attach. */
-        wait_for_devices(drv);
-
-        return 0;
-}
-EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
+EXPORT_SYMBOL_GPL(xenbus_register_driver_common);
 
 void xenbus_unregister_driver(struct xenbus_driver *drv)
 {
@@ -551,24 +472,7 @@ fail:
         kfree(xendev);
         return err;
 }
-
-/* device/<typename>/<name> */
-static int xenbus_probe_frontend(const char *type, const char *name)
-{
-        char *nodename;
-        int err;
-
-        nodename = kasprintf(GFP_KERNEL, "%s/%s/%s",
-                             xenbus_frontend.root, type, name);
-        if (!nodename)
-                return -ENOMEM;
-
-        DPRINTK("%s", nodename);
-
-        err = xenbus_probe_node(&xenbus_frontend, type, nodename);
-        kfree(nodename);
-        return err;
-}
+EXPORT_SYMBOL_GPL(xenbus_probe_node);
 
 static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
 {
@@ -582,10 +486,11 @@ static int xenbus_probe_device_type(struct xen_bus_type *bus, const char *type)
                 return PTR_ERR(dir);
 
         for (i = 0; i < dir_n; i++) {
-                err = bus->probe(type, dir[i]);
+                err = bus->probe(bus, type, dir[i]);
                 if (err)
                         break;
         }
+
         kfree(dir);
         return err;
 }
@@ -605,9 +510,11 @@ int xenbus_probe_devices(struct xen_bus_type *bus)
                 if (err)
                         break;
         }
+
         kfree(dir);
         return err;
 }
+EXPORT_SYMBOL_GPL(xenbus_probe_devices);
 
 static unsigned int char_count(const char *str, char c)
 {
@@ -670,32 +577,18 @@ void xenbus_dev_changed(const char *node, struct xen_bus_type *bus)
 }
 EXPORT_SYMBOL_GPL(xenbus_dev_changed);
 
-static void frontend_changed(struct xenbus_watch *watch,
-                             const char **vec, unsigned int len)
-{
-        DPRINTK("");
-
-        xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
-}
-
-/* We watch for devices appearing and vanishing. */
-static struct xenbus_watch fe_watch = {
-        .node = "device",
-        .callback = frontend_changed,
-};
-
-static int xenbus_dev_suspend(struct device *dev, pm_message_t state)
+int xenbus_dev_suspend(struct device *dev, pm_message_t state)
 {
         int err = 0;
         struct xenbus_driver *drv;
-        struct xenbus_device *xdev;
+        struct xenbus_device *xdev
+                = container_of(dev, struct xenbus_device, dev);
 
-        DPRINTK("");
+        DPRINTK("%s", xdev->nodename);
 
         if (dev->driver == NULL)
                 return 0;
         drv = to_xenbus_driver(dev->driver);
-        xdev = container_of(dev, struct xenbus_device, dev);
         if (drv->suspend)
                 err = drv->suspend(xdev, state);
         if (err)
@@ -703,21 +596,20 @@ static int xenbus_dev_suspend(struct device *dev, pm_message_t state)
                        "xenbus: suspend %s failed: %i\n", dev_name(dev), err);
         return 0;
 }
+EXPORT_SYMBOL_GPL(xenbus_dev_suspend);
 
-static int xenbus_dev_resume(struct device *dev)
+int xenbus_dev_resume(struct device *dev)
 {
         int err;
         struct xenbus_driver *drv;
-        struct xenbus_device *xdev;
+        struct xenbus_device *xdev
+                = container_of(dev, struct xenbus_device, dev);
 
-        DPRINTK("");
+        DPRINTK("%s", xdev->nodename);
 
         if (dev->driver == NULL)
                 return 0;
-
         drv = to_xenbus_driver(dev->driver);
-        xdev = container_of(dev, struct xenbus_device, dev);
-
         err = talk_to_otherend(xdev);
         if (err) {
                 printk(KERN_WARNING
@@ -748,6 +640,7 @@ static int xenbus_dev_resume(struct device *dev)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(xenbus_dev_resume);
 
 /* A flag to determine if xenstored is 'ready' (i.e. has started) */
 int xenstored_ready = 0;
@@ -776,11 +669,6 @@ void xenbus_probe(struct work_struct *unused)
 {
         xenstored_ready = 1;
 
-        /* Enumerate devices in xenstore and watch for changes. */
-        xenbus_probe_devices(&xenbus_frontend);
-        register_xenbus_watch(&fe_watch);
-        xenbus_backend_probe_and_watch();
-
         /* Notify others that xenstore is up */
         blocking_notifier_call_chain(&xenstore_chain, 0, NULL);
 }
@@ -809,16 +697,7 @@ static int __init xenbus_init(void)
 
         err = -ENODEV;
         if (!xen_domain())
-                goto out_error;
-
-        /* Register ourselves with the kernel bus subsystem */
-        err = bus_register(&xenbus_frontend.bus);
-        if (err)
-                goto out_error;
-
-        err = xenbus_backend_bus_register();
-        if (err)
-                goto out_unreg_front;
+                return err;
 
         /*
          * Domain0 doesn't have a store_evtchn or store_mfn yet.
@@ -874,7 +753,7 @@ static int __init xenbus_init(void)
         if (err) {
                 printk(KERN_WARNING
                        "XENBUS: Error initializing xenstore comms: %i\n", err);
-                goto out_unreg_back;
+                goto out_error;
         }
 
 #ifdef CONFIG_XEN_COMPAT_XENFS
@@ -887,133 +766,13 @@ static int __init xenbus_init(void)
 
         return 0;
 
-  out_unreg_back:
-        xenbus_backend_bus_unregister();
-
-  out_unreg_front:
-        bus_unregister(&xenbus_frontend.bus);
-
   out_error:
         if (page != 0)
                 free_page(page);
+
         return err;
 }
 
 postcore_initcall(xenbus_init);
 
 MODULE_LICENSE("GPL");
-
-static int is_device_connecting(struct device *dev, void *data)
-{
-        struct xenbus_device *xendev = to_xenbus_device(dev);
-        struct device_driver *drv = data;
-        struct xenbus_driver *xendrv;
-
-        /*
-         * A device with no driver will never connect. We care only about
-         * devices which should currently be in the process of connecting.
-         */
-        if (!dev->driver)
-                return 0;
-
-        /* Is this search limited to a particular driver? */
-        if (drv && (dev->driver != drv))
-                return 0;
-
-        xendrv = to_xenbus_driver(dev->driver);
-        return (xendev->state < XenbusStateConnected ||
-                (xendev->state == XenbusStateConnected &&
-                 xendrv->is_ready && !xendrv->is_ready(xendev)));
-}
-
-static int exists_connecting_device(struct device_driver *drv)
-{
-        return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                                is_device_connecting);
-}
-
-static int print_device_status(struct device *dev, void *data)
-{
-        struct xenbus_device *xendev = to_xenbus_device(dev);
-        struct device_driver *drv = data;
-
-        /* Is this operation limited to a particular driver? */
-        if (drv && (dev->driver != drv))
-                return 0;
-
-        if (!dev->driver) {
-                /* Information only: is this too noisy? */
-                printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
-                       xendev->nodename);
-        } else if (xendev->state < XenbusStateConnected) {
-                enum xenbus_state rstate = XenbusStateUnknown;
-                if (xendev->otherend)
-                        rstate = xenbus_read_driver_state(xendev->otherend);
-                printk(KERN_WARNING "XENBUS: Timeout connecting "
-                       "to device: %s (local state %d, remote state %d)\n",
-                       xendev->nodename, xendev->state, rstate);
-        }
-
-        return 0;
-}
-
-/* We only wait for device setup after most initcalls have run. */
-static int ready_to_wait_for_devices;
-
-/*
- * On a 5-minute timeout, wait for all devices currently configured.  We need
- * to do this to guarantee that the filesystems and / or network devices
- * needed for boot are available, before we can allow the boot to proceed.
- *
- * This needs to be on a late_initcall, to happen after the frontend device
- * drivers have been initialised, but before the root fs is mounted.
- *
- * A possible improvement here would be to have the tools add a per-device
- * flag to the store entry, indicating whether it is needed at boot time.
- * This would allow people who knew what they were doing to accelerate their
- * boot slightly, but of course needs tools or manual intervention to set up
- * those flags correctly.
- */
-static void wait_for_devices(struct xenbus_driver *xendrv)
-{
-        unsigned long start = jiffies;
-        struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
-        unsigned int seconds_waited = 0;
-
-        if (!ready_to_wait_for_devices || !xen_domain())
-                return;
-
-        while (exists_connecting_device(drv)) {
-                if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
-                        if (!seconds_waited)
-                                printk(KERN_WARNING "XENBUS: Waiting for "
-                                       "devices to initialise: ");
-                        seconds_waited += 5;
-                        printk("%us...", 300 - seconds_waited);
-                        if (seconds_waited == 300)
-                                break;
-                }
-
-                schedule_timeout_interruptible(HZ/10);
-        }
-
-        if (seconds_waited)
-                printk("\n");
-
-        bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
-                         print_device_status);
-}
-
-#ifndef MODULE
-static int __init boot_wait_for_devices(void)
-{
-        if (xen_hvm_domain() && !xen_platform_pci_unplug)
-                return -ENODEV;
-
-        ready_to_wait_for_devices = 1;
-        wait_for_devices(NULL);
-        return 0;
-}
-
-late_initcall(boot_wait_for_devices);
-#endif
diff --git a/drivers/xen/xenbus/xenbus_probe.h b/drivers/xen/xenbus/xenbus_probe.h
index 6c5e3185a6a..24665812316 100644
--- a/drivers/xen/xenbus/xenbus_probe.h
+++ b/drivers/xen/xenbus/xenbus_probe.h
@@ -36,26 +36,15 @@
 
 #define XEN_BUS_ID_SIZE                 20
 
-#ifdef CONFIG_XEN_BACKEND
-extern void xenbus_backend_suspend(int (*fn)(struct device *, void *));
-extern void xenbus_backend_resume(int (*fn)(struct device *, void *));
-extern void xenbus_backend_probe_and_watch(void);
-extern int xenbus_backend_bus_register(void);
-extern void xenbus_backend_bus_unregister(void);
-#else
-static inline void xenbus_backend_suspend(int (*fn)(struct device *, void *)) {}
-static inline void xenbus_backend_resume(int (*fn)(struct device *, void *)) {}
-static inline void xenbus_backend_probe_and_watch(void) {}
-static inline int xenbus_backend_bus_register(void) { return 0; }
-static inline void xenbus_backend_bus_unregister(void) {}
-#endif
-
 struct xen_bus_type
 {
         char *root;
         unsigned int levels;
         int (*get_bus_id)(char bus_id[XEN_BUS_ID_SIZE], const char *nodename);
-        int (*probe)(const char *type, const char *dir);
+        int (*probe)(struct xen_bus_type *bus, const char *type,
+                     const char *dir);
+        void (*otherend_changed)(struct xenbus_watch *watch, const char **vec,
+                                 unsigned int len);
         struct bus_type bus;
 };
 
@@ -73,4 +62,16 @@ extern int xenbus_probe_devices(struct xen_bus_type *bus);
 
 extern void xenbus_dev_changed(const char *node, struct xen_bus_type *bus);
 
+extern void xenbus_dev_shutdown(struct device *_dev);
+
+extern int xenbus_dev_suspend(struct device *dev, pm_message_t state);
+extern int xenbus_dev_resume(struct device *dev);
+
+extern void xenbus_otherend_changed(struct xenbus_watch *watch,
+                                    const char **vec, unsigned int len,
+                                    int ignore_on_shutdown);
+
+extern int xenbus_read_otherend_details(struct xenbus_device *xendev,
+                                        char *id_node, char *path_node);
+
 #endif
diff --git a/drivers/xen/xenbus/xenbus_probe_backend.c b/drivers/xen/xenbus/xenbus_probe_backend.c
new file mode 100644
index 00000000000..6cf467bf63e
--- /dev/null
+++ b/drivers/xen/xenbus/xenbus_probe_backend.c
@@ -0,0 +1,276 @@
+/******************************************************************************
+ * Talks to Xen Store to figure out what devices we have (backend half).
+ *
+ * Copyright (C) 2005 Rusty Russell, IBM Corporation
+ * Copyright (C) 2005 Mike Wray, Hewlett-Packard
+ * Copyright (C) 2005, 2006 XenSource Ltd
+ * Copyright (C) 2007 Solarflare Communications, Inc.
+ *
+ * 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; or, when distributed
+ * separately from the Linux kernel or incorporated into other
+ * software packages, subject to the following license:
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this source file (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use, copy, modify,
+ * merge, publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+ * IN THE SOFTWARE.
+ */
+
+#define DPRINTK(fmt, args...)                           \
+        pr_debug("xenbus_probe (%s:%d) " fmt ".\n",     \
+                 __func__, __LINE__, ##args)
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+#include <linux/fcntl.h>
+#include <linux/mm.h>
+#include <linux/notifier.h>
+
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/xen/hypervisor.h>
+#include <asm/hypervisor.h>
+#include <xen/xenbus.h>
+#include <xen/features.h>
+
+#include "xenbus_comms.h"
+#include "xenbus_probe.h"
+
+/* backend/<type>/<fe-uuid>/<id> => <type>-<fe-domid>-<id> */
+static int backend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
+{
+        int domid, err;
+        const char *devid, *type, *frontend;
+        unsigned int typelen;
+
+        type = strchr(nodename, '/');
+        if (!type)
+                return -EINVAL;
+        type++;
+        typelen = strcspn(type, "/");
+        if (!typelen || type[typelen] != '/')
+                return -EINVAL;
+
+        devid = strrchr(nodename, '/') + 1;
+
+        err = xenbus_gather(XBT_NIL, nodename, "frontend-id", "%i", &domid,
+                            "frontend", NULL, &frontend,
+                            NULL);
+        if (err)
+                return err;
+        if (strlen(frontend) == 0)
+                err = -ERANGE;
+        if (!err && !xenbus_exists(XBT_NIL, frontend, ""))
+                err = -ENOENT;
+        kfree(frontend);
+
+        if (err)
+                return err;
+
+        if (snprintf(bus_id, XEN_BUS_ID_SIZE, "%.*s-%i-%s",
+                     typelen, type, domid, devid) >= XEN_BUS_ID_SIZE)
+                return -ENOSPC;
+        return 0;
+}
+
+static int xenbus_uevent_backend(struct device *dev,
+                                 struct kobj_uevent_env *env)
+{
+        struct xenbus_device *xdev;
+        struct xenbus_driver *drv;
+        struct xen_bus_type *bus;
+
+        DPRINTK("");
+
+        if (dev == NULL)
+                return -ENODEV;
+
+        xdev = to_xenbus_device(dev);
+        bus = container_of(xdev->dev.bus, struct xen_bus_type, bus);
+        if (xdev == NULL)
+                return -ENODEV;
+
+        /* stuff we want to pass to /sbin/hotplug */
+        if (add_uevent_var(env, "XENBUS_TYPE=%s", xdev->devicetype))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "XENBUS_PATH=%s", xdev->nodename))
+                return -ENOMEM;
+
+        if (add_uevent_var(env, "XENBUS_BASE_PATH=%s", bus->root))
+                return -ENOMEM;
+
+        if (dev->driver) {
+                drv = to_xenbus_driver(dev->driver);
+                if (drv && drv->uevent)
+                        return drv->uevent(xdev, env);
+        }
+
+        return 0;
+}
+
+/* backend/<typename>/<frontend-uuid>/<name> */
+static int xenbus_probe_backend_unit(struct xen_bus_type *bus,
+                                     const char *dir,
+                                     const char *type,
+                                     const char *name)
+{
+        char *nodename;
+        int err;
+
+        nodename = kasprintf(GFP_KERNEL, "%s/%s", dir, name);
+        if (!nodename)
+                return -ENOMEM;
+
+        DPRINTK("%s\n", nodename);
+
+        err = xenbus_probe_node(bus, type, nodename);
+        kfree(nodename);
+        return err;
+}
+
+/* backend/<typename>/<frontend-domid> */
+static int xenbus_probe_backend(struct xen_bus_type *bus, const char *type,
+                                const char *domid)
+{
+        char *nodename;
+        int err = 0;
+        char **dir;
+        unsigned int i, dir_n = 0;
+
+        DPRINTK("");
+
+        nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, domid);
+        if (!nodename)
+                return -ENOMEM;
+
+        dir = xenbus_directory(XBT_NIL, nodename, "", &dir_n);
+        if (IS_ERR(dir)) {
+                kfree(nodename);
+                return PTR_ERR(dir);
+        }
+
+        for (i = 0; i < dir_n; i++) {
+                err = xenbus_probe_backend_unit(bus, nodename, type, dir[i]);
+                if (err)
+                        break;
+        }
+        kfree(dir);
+        kfree(nodename);
+        return err;
+}
+
+static void frontend_changed(struct xenbus_watch *watch,
+                            const char **vec, unsigned int len)
+{
+        xenbus_otherend_changed(watch, vec, len, 0);
+}
+
+static struct device_attribute xenbus_backend_dev_attrs[] = {
+        __ATTR_NULL
+};
+
+static struct xen_bus_type xenbus_backend = {
+        .root = "backend",
+        .levels = 3,            /* backend/type/<frontend>/<id> */
+        .get_bus_id = backend_bus_id,
+        .probe = xenbus_probe_backend,
+        .otherend_changed = frontend_changed,
+        .bus = {
+                .name           = "xen-backend",
+                .match          = xenbus_match,
+                .uevent         = xenbus_uevent_backend,
+                .probe          = xenbus_dev_probe,
+                .remove         = xenbus_dev_remove,
+                .shutdown       = xenbus_dev_shutdown,
+                .dev_attrs      = xenbus_backend_dev_attrs,
+        },
+};
+
+static void backend_changed(struct xenbus_watch *watch,
+                            const char **vec, unsigned int len)
+{
+        DPRINTK("");
+
+        xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_backend);
+}
+
+static struct xenbus_watch be_watch = {
+        .node = "backend",
+        .callback = backend_changed,
+};
+
+static int read_frontend_details(struct xenbus_device *xendev)
+{
+        return xenbus_read_otherend_details(xendev, "frontend-id", "frontend");
+}
+
+int xenbus_dev_is_online(struct xenbus_device *dev)
+{
+        int rc, val;
+
+        rc = xenbus_scanf(XBT_NIL, dev->nodename, "online", "%d", &val);
+        if (rc != 1)
+                val = 0; /* no online node present */
+
+        return val;
+}
+EXPORT_SYMBOL_GPL(xenbus_dev_is_online);
+
+int __xenbus_register_backend(struct xenbus_driver *drv,
+                              struct module *owner, const char *mod_name)
+{
+        drv->read_otherend_details = read_frontend_details;
+
+        return xenbus_register_driver_common(drv, &xenbus_backend,
+                                             owner, mod_name);
+}
+EXPORT_SYMBOL_GPL(__xenbus_register_backend);
+
+static int backend_probe_and_watch(struct notifier_block *notifier,
+                                   unsigned long event,
+                                   void *data)
+{
+        /* Enumerate devices in xenstore and watch for changes. */
+        xenbus_probe_devices(&xenbus_backend);
+        register_xenbus_watch(&be_watch);
+
+        return NOTIFY_DONE;
+}
+
+static int __init xenbus_probe_backend_init(void)
+{
+        static struct notifier_block xenstore_notifier = {
+                .notifier_call = backend_probe_and_watch
+        };
+        int err;
+
+        DPRINTK("");
+
+        /* Register ourselves with the kernel bus subsystem */
+        err = bus_register(&xenbus_backend.bus);
+        if (err)
+                return err;
+
+        register_xenstore_notifier(&xenstore_notifier);
+
+        return 0;
+}
+subsys_initcall(xenbus_probe_backend_init);
diff --git a/drivers/xen/xenbus/xenbus_probe_frontend.c b/drivers/xen/xenbus/xenbus_probe_frontend.c
new file mode 100644
index 00000000000..5bcc2d6cf12
--- /dev/null
+++ b/drivers/xen/xenbus/xenbus_probe_frontend.c
@@ -0,0 +1,294 @@
+#define DPRINTK(fmt, args...)                           \
+        pr_debug("xenbus_probe (%s:%d) " fmt ".\n",     \
+                 __func__, __LINE__, ##args)
+
+#include <linux/kernel.h>
+#include <linux/err.h>
+#include <linux/string.h>
+#include <linux/ctype.h>
+#include <linux/fcntl.h>
+#include <linux/mm.h>
+#include <linux/proc_fs.h>
+#include <linux/notifier.h>
+#include <linux/kthread.h>
+#include <linux/mutex.h>
+#include <linux/io.h>
+
+#include <asm/page.h>
+#include <asm/pgtable.h>
+#include <asm/xen/hypervisor.h>
+#include <xen/xenbus.h>
+#include <xen/events.h>
+#include <xen/page.h>
+
+#include <xen/platform_pci.h>
+
+#include "xenbus_comms.h"
+#include "xenbus_probe.h"
+
+
+/* device/<type>/<id> => <type>-<id> */
+static int frontend_bus_id(char bus_id[XEN_BUS_ID_SIZE], const char *nodename)
+{
+        nodename = strchr(nodename, '/');
+        if (!nodename || strlen(nodename + 1) >= XEN_BUS_ID_SIZE) {
+                printk(KERN_WARNING "XENBUS: bad frontend %s\n", nodename);
+                return -EINVAL;
+        }
+
+        strlcpy(bus_id, nodename + 1, XEN_BUS_ID_SIZE);
+        if (!strchr(bus_id, '/')) {
+                printk(KERN_WARNING "XENBUS: bus_id %s no slash\n", bus_id);
+                return -EINVAL;
+        }
+        *strchr(bus_id, '/') = '-';
+        return 0;
+}
+
+/* device/<typename>/<name> */
+static int xenbus_probe_frontend(struct xen_bus_type *bus, const char *type,
+                                 const char *name)
+{
+        char *nodename;
+        int err;
+
+        nodename = kasprintf(GFP_KERNEL, "%s/%s/%s", bus->root, type, name);
+        if (!nodename)
+                return -ENOMEM;
+
+        DPRINTK("%s", nodename);
+
+        err = xenbus_probe_node(bus, type, nodename);
+        kfree(nodename);
+        return err;
+}
+
+static int xenbus_uevent_frontend(struct device *_dev,
+                                  struct kobj_uevent_env *env)
+{
+        struct xenbus_device *dev = to_xenbus_device(_dev);
+
+        if (add_uevent_var(env, "MODALIAS=xen:%s", dev->devicetype))
+                return -ENOMEM;
+
+        return 0;
+}
+
+
+static void backend_changed(struct xenbus_watch *watch,
+                            const char **vec, unsigned int len)
+{
+        xenbus_otherend_changed(watch, vec, len, 1);
+}
+
+static struct device_attribute xenbus_frontend_dev_attrs[] = {
+        __ATTR_NULL
+};
+
+static struct xen_bus_type xenbus_frontend = {
+        .root = "device",
+        .levels = 2,            /* device/type/<id> */
+        .get_bus_id = frontend_bus_id,
+        .probe = xenbus_probe_frontend,
+        .otherend_changed = backend_changed,
+        .bus = {
+                .name           = "xen",
+                .match          = xenbus_match,
+                .uevent         = xenbus_uevent_frontend,
+                .probe          = xenbus_dev_probe,
+                .remove         = xenbus_dev_remove,
+                .shutdown       = xenbus_dev_shutdown,
+                .dev_attrs      = xenbus_frontend_dev_attrs,
+
+                .suspend        = xenbus_dev_suspend,
+                .resume         = xenbus_dev_resume,
+        },
+};
+
+static void frontend_changed(struct xenbus_watch *watch,
+                             const char **vec, unsigned int len)
+{
+        DPRINTK("");
+
+        xenbus_dev_changed(vec[XS_WATCH_PATH], &xenbus_frontend);
+}
+
+
+/* We watch for devices appearing and vanishing. */
+static struct xenbus_watch fe_watch = {
+        .node = "device",
+        .callback = frontend_changed,
+};
+
+static int read_backend_details(struct xenbus_device *xendev)
+{
+        return xenbus_read_otherend_details(xendev, "backend-id", "backend");
+}
+
+static int is_device_connecting(struct device *dev, void *data)
+{
+        struct xenbus_device *xendev = to_xenbus_device(dev);
+        struct device_driver *drv = data;
+        struct xenbus_driver *xendrv;
+
+        /*
+         * A device with no driver will never connect. We care only about
+         * devices which should currently be in the process of connecting.
+         */
+        if (!dev->driver)
+                return 0;
+
+        /* Is this search limited to a particular driver? */
+        if (drv && (dev->driver != drv))
+                return 0;
+
+        xendrv = to_xenbus_driver(dev->driver);
+        return (xendev->state < XenbusStateConnected ||
+                (xendev->state == XenbusStateConnected &&
+                 xendrv->is_ready && !xendrv->is_ready(xendev)));
+}
+
+static int exists_connecting_device(struct device_driver *drv)
+{
+        return bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
+                                is_device_connecting);
+}
+
+static int print_device_status(struct device *dev, void *data)
+{
+        struct xenbus_device *xendev = to_xenbus_device(dev);
+        struct device_driver *drv = data;
+
+        /* Is this operation limited to a particular driver? */
+        if (drv && (dev->driver != drv))
+                return 0;
+
+        if (!dev->driver) {
+                /* Information only: is this too noisy? */
+                printk(KERN_INFO "XENBUS: Device with no driver: %s\n",
+                       xendev->nodename);
+        } else if (xendev->state < XenbusStateConnected) {
+                enum xenbus_state rstate = XenbusStateUnknown;
+                if (xendev->otherend)
+                        rstate = xenbus_read_driver_state(xendev->otherend);
+                printk(KERN_WARNING "XENBUS: Timeout connecting "
+                       "to device: %s (local state %d, remote state %d)\n",
+                       xendev->nodename, xendev->state, rstate);
+        }
+
+        return 0;
+}
+
+/* We only wait for device setup after most initcalls have run. */
+static int ready_to_wait_for_devices;
+
+/*
+ * On a 5-minute timeout, wait for all devices currently configured.  We need
+ * to do this to guarantee that the filesystems and / or network devices
+ * needed for boot are available, before we can allow the boot to proceed.
+ *
+ * This needs to be on a late_initcall, to happen after the frontend device
+ * drivers have been initialised, but before the root fs is mounted.
+ *
+ * A possible improvement here would be to have the tools add a per-device
+ * flag to the store entry, indicating whether it is needed at boot time.
+ * This would allow people who knew what they were doing to accelerate their
+ * boot slightly, but of course needs tools or manual intervention to set up
+ * those flags correctly.
+ */
+static void wait_for_devices(struct xenbus_driver *xendrv)
+{
+        unsigned long start = jiffies;
+        struct device_driver *drv = xendrv ? &xendrv->driver : NULL;
+        unsigned int seconds_waited = 0;
+
+        if (!ready_to_wait_for_devices || !xen_domain())
+                return;
+
+        while (exists_connecting_device(drv)) {
+                if (time_after(jiffies, start + (seconds_waited+5)*HZ)) {
+                        if (!seconds_waited)
+                                printk(KERN_WARNING "XENBUS: Waiting for "
+                                       "devices to initialise: ");
+                        seconds_waited += 5;
+                        printk("%us...", 300 - seconds_waited);
+                        if (seconds_waited == 300)
+                                break;
+                }
+
+                schedule_timeout_interruptible(HZ/10);
+        }
+
+        if (seconds_waited)
+                printk("\n");
+
+        bus_for_each_dev(&xenbus_frontend.bus, NULL, drv,
+                         print_device_status);
+}
+
+int __xenbus_register_frontend(struct xenbus_driver *drv,
+                               struct module *owner, const char *mod_name)
+{
+        int ret;
+
+        drv->read_otherend_details = read_backend_details;
+
+        ret = xenbus_register_driver_common(drv, &xenbus_frontend,
+                                            owner, mod_name);
+        if (ret)
+                return ret;
+
+        /* If this driver is loaded as a module wait for devices to attach. */
+        wait_for_devices(drv);
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(__xenbus_register_frontend);
+
+static int frontend_probe_and_watch(struct notifier_block *notifier,
+                                   unsigned long event,
+                                   void *data)
+{
+        /* Enumerate devices in xenstore and watch for changes. */
+        xenbus_probe_devices(&xenbus_frontend);
+        register_xenbus_watch(&fe_watch);
+
+        return NOTIFY_DONE;
+}
+
+
+static int __init xenbus_probe_frontend_init(void)
+{
+        static struct notifier_block xenstore_notifier = {
+                .notifier_call = frontend_probe_and_watch
+        };
+        int err;
+
+        DPRINTK("");
+
+        /* Register ourselves with the kernel bus subsystem */
+        err = bus_register(&xenbus_frontend.bus);
+        if (err)
+                return err;
+
+        register_xenstore_notifier(&xenstore_notifier);
+
+        return 0;
+}
+subsys_initcall(xenbus_probe_frontend_init);
+
+#ifndef MODULE
+static int __init boot_wait_for_devices(void)
+{
+        if (xen_hvm_domain() && !xen_platform_pci_unplug)
+                return -ENODEV;
+
+        ready_to_wait_for_devices = 1;
+        wait_for_devices(NULL);
+        return 0;
+}
+
+late_initcall(boot_wait_for_devices);
+#endif
+
+MODULE_LICENSE("GPL");