Merge branch 'regulator-drivers' into regulator-next

205 files changed, 6500 insertions, 3287 deletions

diff --git a/drivers/acpi/acpica/hwsleep.c b/drivers/acpi/acpica/hwsleep.c
index 0ed85cac3231..615996a36bed 100644
--- a/drivers/acpi/acpica/hwsleep.c
+++ b/drivers/acpi/acpica/hwsleep.c
@@ -95,18 +95,6 @@ acpi_status acpi_hw_legacy_sleep(u8 sleep_state, u8 flags)
                 return_ACPI_STATUS(status);
         }
 
-        if (sleep_state != ACPI_STATE_S5) {
-                /*
-                 * Disable BM arbitration. This feature is contained within an
-                 * optional register (PM2 Control), so ignore a BAD_ADDRESS
-                 * exception.
-                 */
-                status = acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
-                if (ACPI_FAILURE(status) && (status != AE_BAD_ADDRESS)) {
-                        return_ACPI_STATUS(status);
-                }
-        }
-
         /*
          * 1) Disable/Clear all GPEs
          * 2) Enable all wakeup GPEs
@@ -364,16 +352,6 @@ acpi_status acpi_hw_legacy_wake(u8 sleep_state, u8 flags)
                                     [ACPI_EVENT_POWER_BUTTON].
                                     status_register_id, ACPI_CLEAR_STATUS);
 
-        /*
-         * Enable BM arbitration. This feature is contained within an
-         * optional register (PM2 Control), so ignore a BAD_ADDRESS
-         * exception.
-         */
-        status = acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
-        if (ACPI_FAILURE(status) && (status != AE_BAD_ADDRESS)) {
-                return_ACPI_STATUS(status);
-        }
-
         acpi_hw_execute_sleep_method(METHOD_PATHNAME__SST, ACPI_SST_WORKING);
         return_ACPI_STATUS(status);
 }
diff --git a/drivers/acpi/acpica/nspredef.c b/drivers/acpi/acpica/nspredef.c
index 23ce09686418..fe6626035495 100644
--- a/drivers/acpi/acpica/nspredef.c
+++ b/drivers/acpi/acpica/nspredef.c
@@ -638,7 +638,7 @@ acpi_ns_check_package(struct acpi_predefined_data *data,
                         /* Create the new outer package and populate it */
 
                         status =
-                            acpi_ns_wrap_with_package(data, *elements,
+                            acpi_ns_wrap_with_package(data, return_object,
                                                       return_object_ptr);
                         if (ACPI_FAILURE(status)) {
                                 return (status);
diff --git a/drivers/acpi/processor_core.c b/drivers/acpi/processor_core.c
index c850de4c9a14..eff722278ff5 100644
--- a/drivers/acpi/processor_core.c
+++ b/drivers/acpi/processor_core.c
@@ -189,10 +189,12 @@ int acpi_get_cpuid(acpi_handle handle, int type, u32 acpi_id)
                  *     Processor (CPU3, 0x03, 0x00000410, 0x06) {}
                  * }
                  *
-                 * Ignores apic_id and always return 0 for CPU0's handle.
+                 * Ignores apic_id and always returns 0 for the processor
+                 * handle with acpi id 0 if nr_cpu_ids is 1.
+                 * This should be the case if SMP tables are not found.
                  * Return -1 for other CPU's handle.
                  */
-                if (acpi_id == 0)
+                if (nr_cpu_ids <= 1 && acpi_id == 0)
                         return acpi_id;
                 else
                         return apic_id;
diff --git a/drivers/block/drbd/drbd_bitmap.c b/drivers/block/drbd/drbd_bitmap.c
index b5c5ff53cb57..fcb956bb4b4c 100644
--- a/drivers/block/drbd/drbd_bitmap.c
+++ b/drivers/block/drbd/drbd_bitmap.c
@@ -1475,10 +1475,17 @@ void _drbd_bm_set_bits(struct drbd_conf *mdev, const unsigned long s, const unsi
                 first_word = 0;
                 spin_lock_irq(&b->bm_lock);
         }
-
         /* last page (respectively only page, for first page == last page) */
         last_word = MLPP(el >> LN2_BPL);
-        bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
+
+        /* consider bitmap->bm_bits = 32768, bitmap->bm_number_of_pages = 1. (or multiples).
+         * ==> e = 32767, el = 32768, last_page = 2,
+         * and now last_word = 0.
+         * We do not want to touch last_page in this case,
+         * as we did not allocate it, it is not present in bitmap->bm_pages.
+         */
+        if (last_word)
+                bm_set_full_words_within_one_page(mdev->bitmap, last_page, first_word, last_word);
 
         /* possibly trailing bits.
          * example: (e & 63) == 63, el will be e+1.
diff --git a/drivers/block/drbd/drbd_req.c b/drivers/block/drbd/drbd_req.c
index 9c5c84946b05..8e93a6ac9bb6 100644
--- a/drivers/block/drbd/drbd_req.c
+++ b/drivers/block/drbd/drbd_req.c
@@ -472,12 +472,17 @@ int __req_mod(struct drbd_request *req, enum drbd_req_event what,
                 req->rq_state |= RQ_LOCAL_COMPLETED;
                 req->rq_state &= ~RQ_LOCAL_PENDING;
 
-                D_ASSERT(!(req->rq_state & RQ_NET_MASK));
+                if (req->rq_state & RQ_LOCAL_ABORTED) {
+                        _req_may_be_done(req, m);
+                        break;
+                }
 
                 __drbd_chk_io_error(mdev, false);
 
         goto_queue_for_net_read:
 
+                D_ASSERT(!(req->rq_state & RQ_NET_MASK));
+
                 /* no point in retrying if there is no good remote data,
                  * or we have no connection. */
                 if (mdev->state.pdsk != D_UP_TO_DATE) {
@@ -765,6 +770,40 @@ static int drbd_may_do_local_read(struct drbd_conf *mdev, sector_t sector, int s
         return 0 == drbd_bm_count_bits(mdev, sbnr, ebnr);
 }
 
+static void maybe_pull_ahead(struct drbd_conf *mdev)
+{
+        int congested = 0;
+
+        /* If I don't even have good local storage, we can not reasonably try
+         * to pull ahead of the peer. We also need the local reference to make
+         * sure mdev->act_log is there.
+         * Note: caller has to make sure that net_conf is there.
+         */
+        if (!get_ldev_if_state(mdev, D_UP_TO_DATE))
+                return;
+
+        if (mdev->net_conf->cong_fill &&
+            atomic_read(&mdev->ap_in_flight) >= mdev->net_conf->cong_fill) {
+                dev_info(DEV, "Congestion-fill threshold reached\n");
+                congested = 1;
+        }
+
+        if (mdev->act_log->used >= mdev->net_conf->cong_extents) {
+                dev_info(DEV, "Congestion-extents threshold reached\n");
+                congested = 1;
+        }
+
+        if (congested) {
+                queue_barrier(mdev); /* last barrier, after mirrored writes */
+
+                if (mdev->net_conf->on_congestion == OC_PULL_AHEAD)
+                        _drbd_set_state(_NS(mdev, conn, C_AHEAD), 0, NULL);
+                else  /*mdev->net_conf->on_congestion == OC_DISCONNECT */
+                        _drbd_set_state(_NS(mdev, conn, C_DISCONNECTING), 0, NULL);
+        }
+        put_ldev(mdev);
+}
+
 static int drbd_make_request_common(struct drbd_conf *mdev, struct bio *bio, unsigned long start_time)
 {
         const int rw = bio_rw(bio);
@@ -972,29 +1011,8 @@ allocate_barrier:
                 _req_mod(req, queue_for_send_oos);
 
         if (remote &&
-            mdev->net_conf->on_congestion != OC_BLOCK && mdev->agreed_pro_version >= 96) {
-                int congested = 0;
-
-                if (mdev->net_conf->cong_fill &&
-                    atomic_read(&mdev->ap_in_flight) >= mdev->net_conf->cong_fill) {
-                        dev_info(DEV, "Congestion-fill threshold reached\n");
-                        congested = 1;
-                }
-
-                if (mdev->act_log->used >= mdev->net_conf->cong_extents) {
-                        dev_info(DEV, "Congestion-extents threshold reached\n");
-                        congested = 1;
-                }
-
-                if (congested) {
-                        queue_barrier(mdev); /* last barrier, after mirrored writes */
-
-                        if (mdev->net_conf->on_congestion == OC_PULL_AHEAD)
-                                _drbd_set_state(_NS(mdev, conn, C_AHEAD), 0, NULL);
-                        else  /*mdev->net_conf->on_congestion == OC_DISCONNECT */
-                                _drbd_set_state(_NS(mdev, conn, C_DISCONNECTING), 0, NULL);
-                }
-        }
+            mdev->net_conf->on_congestion != OC_BLOCK && mdev->agreed_pro_version >= 96)
+                maybe_pull_ahead(mdev);
 
         spin_unlock_irq(&mdev->req_lock);
         kfree(b); /* if someone else has beaten us to it... */
diff --git a/drivers/block/floppy.c b/drivers/block/floppy.c
index cce7df367b79..553f43a90953 100644
--- a/drivers/block/floppy.c
+++ b/drivers/block/floppy.c
@@ -671,6 +671,7 @@ static void __reschedule_timeout(int drive, const char *message)
 
         if (drive == current_reqD)
                 drive = current_drive;
+        __cancel_delayed_work(&fd_timeout);
 
         if (drive < 0 || drive >= N_DRIVE) {
                 delay = 20UL * HZ;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index bbca966f8f66..3bba65510d23 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1597,14 +1597,12 @@ static int loop_add(struct loop_device **l, int i)
         struct gendisk *disk;
         int err;
 
+        err = -ENOMEM;
         lo = kzalloc(sizeof(*lo), GFP_KERNEL);
-        if (!lo) {
-                err = -ENOMEM;
+        if (!lo)
                 goto out;
-        }
 
-        err = idr_pre_get(&loop_index_idr, GFP_KERNEL);
-        if (err < 0)
+        if (!idr_pre_get(&loop_index_idr, GFP_KERNEL))
                 goto out_free_dev;
 
         if (i >= 0) {
diff --git a/drivers/block/mtip32xx/mtip32xx.c b/drivers/block/mtip32xx/mtip32xx.c
index 264bc77dcb91..a8fddeb3d638 100644
--- a/drivers/block/mtip32xx/mtip32xx.c
+++ b/drivers/block/mtip32xx/mtip32xx.c
@@ -37,6 +37,7 @@
 #include <linux/kthread.h>
 #include <../drivers/ata/ahci.h>
 #include <linux/export.h>
+#include <linux/debugfs.h>
 #include "mtip32xx.h"
 
 #define HW_CMD_SLOT_SZ          (MTIP_MAX_COMMAND_SLOTS * 32)
@@ -85,6 +86,7 @@ static int instance;
  * allocated in mtip_init().
  */
 static int mtip_major;
+static struct dentry *dfs_parent;
 
 static DEFINE_SPINLOCK(rssd_index_lock);
 static DEFINE_IDA(rssd_index_ida);
@@ -2546,7 +2548,7 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd,
 }
 
 /*
- * Sysfs register/status dump.
+ * Sysfs status dump.
  *
  * @dev  Pointer to the device structure, passed by the kernrel.
  * @attr Pointer to the device_attribute structure passed by the kernel.
@@ -2555,45 +2557,68 @@ static struct scatterlist *mtip_hw_get_scatterlist(struct driver_data *dd,
  * return value
  *      The size, in bytes, of the data copied into buf.
  */
-static ssize_t mtip_hw_show_registers(struct device *dev,
+static ssize_t mtip_hw_show_status(struct device *dev,
                                 struct device_attribute *attr,
                                 char *buf)
 {
-        u32 group_allocated;
         struct driver_data *dd = dev_to_disk(dev)->private_data;
         int size = 0;
+
+        if (test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag))
+                size += sprintf(buf, "%s", "thermal_shutdown\n");
+        else if (test_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag))
+                size += sprintf(buf, "%s", "write_protect\n");
+        else
+                size += sprintf(buf, "%s", "online\n");
+
+        return size;
+}
+
+static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL);
+
+static ssize_t mtip_hw_read_registers(struct file *f, char __user *ubuf,
+                                  size_t len, loff_t *offset)
+{
+        struct driver_data *dd =  (struct driver_data *)f->private_data;
+        char buf[MTIP_DFS_MAX_BUF_SIZE];
+        u32 group_allocated;
+        int size = *offset;
         int n;
 
-        size += sprintf(&buf[size], "Hardware\n--------\n");
-        size += sprintf(&buf[size], "S ACTive      : [ 0x");
+        if (!len || size)
+                return 0;
+
+        if (size < 0)
+                return -EINVAL;
+
+        size += sprintf(&buf[size], "H/ S ACTive      : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                          readl(dd->port->s_active[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "Command Issue : [ 0x");
+        size += sprintf(&buf[size], "H/ Command Issue : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                         readl(dd->port->cmd_issue[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "Completed     : [ 0x");
+        size += sprintf(&buf[size], "H/ Completed     : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--)
                 size += sprintf(&buf[size], "%08X ",
                                 readl(dd->port->completed[n]));
 
         size += sprintf(&buf[size], "]\n");
-        size += sprintf(&buf[size], "PORT IRQ STAT : [ 0x%08X ]\n",
+        size += sprintf(&buf[size], "H/ PORT IRQ STAT : [ 0x%08X ]\n",
                                 readl(dd->port->mmio + PORT_IRQ_STAT));
-        size += sprintf(&buf[size], "HOST IRQ STAT : [ 0x%08X ]\n",
+        size += sprintf(&buf[size], "H/ HOST IRQ STAT : [ 0x%08X ]\n",
                                 readl(dd->mmio + HOST_IRQ_STAT));
         size += sprintf(&buf[size], "\n");
 
-        size += sprintf(&buf[size], "Local\n-----\n");
-        size += sprintf(&buf[size], "Allocated    : [ 0x");
+        size += sprintf(&buf[size], "L/ Allocated     : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--) {
                 if (sizeof(long) > sizeof(u32))
@@ -2605,7 +2630,7 @@ static ssize_t mtip_hw_show_registers(struct device *dev,
         }
         size += sprintf(&buf[size], "]\n");
 
-        size += sprintf(&buf[size], "Commands in Q: [ 0x");
+        size += sprintf(&buf[size], "L/ Commands in Q : [ 0x");
 
         for (n = dd->slot_groups-1; n >= 0; n--) {
                 if (sizeof(long) > sizeof(u32))
@@ -2617,44 +2642,53 @@ static ssize_t mtip_hw_show_registers(struct device *dev,
         }
         size += sprintf(&buf[size], "]\n");
 
-        return size;
+        *offset = size <= len ? size : len;
+        size = copy_to_user(ubuf, buf, *offset);
+        if (size)
+                return -EFAULT;
+
+        return *offset;
 }
 
-static ssize_t mtip_hw_show_status(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
+static ssize_t mtip_hw_read_flags(struct file *f, char __user *ubuf,
+                                  size_t len, loff_t *offset)
 {
-        struct driver_data *dd = dev_to_disk(dev)->private_data;
-        int size = 0;
+        struct driver_data *dd =  (struct driver_data *)f->private_data;
+        char buf[MTIP_DFS_MAX_BUF_SIZE];
+        int size = *offset;
 
-        if (test_bit(MTIP_DDF_OVER_TEMP_BIT, &dd->dd_flag))
-                size += sprintf(buf, "%s", "thermal_shutdown\n");
-        else if (test_bit(MTIP_DDF_WRITE_PROTECT_BIT, &dd->dd_flag))
-                size += sprintf(buf, "%s", "write_protect\n");
-        else
-                size += sprintf(buf, "%s", "online\n");
-
-        return size;
-}
+        if (!len || size)
+                return 0;
 
-static ssize_t mtip_hw_show_flags(struct device *dev,
-                                struct device_attribute *attr,
-                                char *buf)
-{
-        struct driver_data *dd = dev_to_disk(dev)->private_data;
-        int size = 0;
+        if (size < 0)
+                return -EINVAL;
 
-        size += sprintf(&buf[size], "Flag in port struct : [ %08lX ]\n",
+        size += sprintf(&buf[size], "Flag-port : [ %08lX ]\n",
                                                         dd->port->flags);
-        size += sprintf(&buf[size], "Flag in dd struct   : [ %08lX ]\n",
+        size += sprintf(&buf[size], "Flag-dd   : [ %08lX ]\n",
                                                         dd->dd_flag);
 
-        return size;
+        *offset = size <= len ? size : len;
+        size = copy_to_user(ubuf, buf, *offset);
+        if (size)
+                return -EFAULT;
+
+        return *offset;
 }
 
-static DEVICE_ATTR(registers, S_IRUGO, mtip_hw_show_registers, NULL);
-static DEVICE_ATTR(status, S_IRUGO, mtip_hw_show_status, NULL);
-static DEVICE_ATTR(flags, S_IRUGO, mtip_hw_show_flags, NULL);
+static const struct file_operations mtip_regs_fops = {
+        .owner  = THIS_MODULE,
+        .open   = simple_open,
+        .read   = mtip_hw_read_registers,
+        .llseek = no_llseek,
+};
+
+static const struct file_operations mtip_flags_fops = {
+        .owner  = THIS_MODULE,
+        .open   = simple_open,
+        .read   = mtip_hw_read_flags,
+        .llseek = no_llseek,
+};
 
 /*
  * Create the sysfs related attributes.
@@ -2671,15 +2705,9 @@ static int mtip_hw_sysfs_init(struct driver_data *dd, struct kobject *kobj)
         if (!kobj || !dd)
                 return -EINVAL;
 
-        if (sysfs_create_file(kobj, &dev_attr_registers.attr))
-                dev_warn(&dd->pdev->dev,
-                        "Error creating 'registers' sysfs entry\n");
         if (sysfs_create_file(kobj, &dev_attr_status.attr))
                 dev_warn(&dd->pdev->dev,
                         "Error creating 'status' sysfs entry\n");
-        if (sysfs_create_file(kobj, &dev_attr_flags.attr))
-                dev_warn(&dd->pdev->dev,
-                        "Error creating 'flags' sysfs entry\n");
         return 0;
 }
 
@@ -2698,13 +2726,39 @@ static int mtip_hw_sysfs_exit(struct driver_data *dd, struct kobject *kobj)
         if (!kobj || !dd)
                 return -EINVAL;
 
-        sysfs_remove_file(kobj, &dev_attr_registers.attr);
         sysfs_remove_file(kobj, &dev_attr_status.attr);
-        sysfs_remove_file(kobj, &dev_attr_flags.attr);
 
         return 0;
 }
 
+static int mtip_hw_debugfs_init(struct driver_data *dd)
+{
+        if (!dfs_parent)
+                return -1;
+
+        dd->dfs_node = debugfs_create_dir(dd->disk->disk_name, dfs_parent);
+        if (IS_ERR_OR_NULL(dd->dfs_node)) {
+                dev_warn(&dd->pdev->dev,
+                        "Error creating node %s under debugfs\n",
+                                                dd->disk->disk_name);
+                dd->dfs_node = NULL;
+                return -1;
+        }
+
+        debugfs_create_file("flags", S_IRUGO, dd->dfs_node, dd,
+                                                        &mtip_flags_fops);
+        debugfs_create_file("registers", S_IRUGO, dd->dfs_node, dd,
+                                                        &mtip_regs_fops);
+
+        return 0;
+}
+
+static void mtip_hw_debugfs_exit(struct driver_data *dd)
+{
+        debugfs_remove_recursive(dd->dfs_node);
+}
+
+
 /*
  * Perform any init/resume time hardware setup
  *
@@ -3730,6 +3784,7 @@ skip_create_disk:
                 mtip_hw_sysfs_init(dd, kobj);
                 kobject_put(kobj);
         }
+        mtip_hw_debugfs_init(dd);
 
         if (dd->mtip_svc_handler) {
                 set_bit(MTIP_DDF_INIT_DONE_BIT, &dd->dd_flag);
@@ -3755,6 +3810,8 @@ start_service_thread:
         return rv;
 
 kthread_run_error:
+        mtip_hw_debugfs_exit(dd);
+
         /* Delete our gendisk. This also removes the device from /dev */
         del_gendisk(dd->disk);
 
@@ -3805,6 +3862,7 @@ static int mtip_block_remove(struct driver_data *dd)
                         kobject_put(kobj);
                 }
         }
+        mtip_hw_debugfs_exit(dd);
 
         /*
          * Delete our gendisk structure. This also removes the device
@@ -4152,10 +4210,20 @@ static int __init mtip_init(void)
         }
         mtip_major = error;
 
+        if (!dfs_parent) {
+                dfs_parent = debugfs_create_dir("rssd", NULL);
+                if (IS_ERR_OR_NULL(dfs_parent)) {
+                        printk(KERN_WARNING "Error creating debugfs parent\n");
+                        dfs_parent = NULL;
+                }
+        }
+
         /* Register our PCI operations. */
         error = pci_register_driver(&mtip_pci_driver);
-        if (error)
+        if (error) {
+                debugfs_remove(dfs_parent);
                 unregister_blkdev(mtip_major, MTIP_DRV_NAME);
+        }
 
         return error;
 }
@@ -4172,6 +4240,8 @@ static int __init mtip_init(void)
  */
 static void __exit mtip_exit(void)
 {
+        debugfs_remove_recursive(dfs_parent);
+
         /* Release the allocated major block device number. */
         unregister_blkdev(mtip_major, MTIP_DRV_NAME);
 
diff --git a/drivers/block/mtip32xx/mtip32xx.h b/drivers/block/mtip32xx/mtip32xx.h
index b2c88da26b2a..f51fc23d17bb 100644
--- a/drivers/block/mtip32xx/mtip32xx.h
+++ b/drivers/block/mtip32xx/mtip32xx.h
@@ -26,7 +26,6 @@
 #include <linux/ata.h>
 #include <linux/interrupt.h>
 #include <linux/genhd.h>
-#include <linux/version.h>
 
 /* Offset of Subsystem Device ID in pci confoguration space */
 #define PCI_SUBSYSTEM_DEVICEID  0x2E
@@ -111,6 +110,8 @@
  #define dbg_printk(format, arg...)
 #endif
 
+#define MTIP_DFS_MAX_BUF_SIZE 1024
+
 #define __force_bit2int (unsigned int __force)
 
 enum {
@@ -447,6 +448,8 @@ struct driver_data {
         unsigned long dd_flag; /* NOTE: use atomic bit operations on this */
 
         struct task_struct *mtip_svc_handler; /* task_struct of svc thd */
+
+        struct dentry *dfs_node;
 };
 
 #endif
diff --git a/drivers/block/umem.c b/drivers/block/umem.c
index aa2712060bfb..9a72277a31df 100644
--- a/drivers/block/umem.c
+++ b/drivers/block/umem.c
@@ -513,6 +513,44 @@ static void process_page(unsigned long data)
         }
 }
 
+struct mm_plug_cb {
+        struct blk_plug_cb cb;
+        struct cardinfo *card;
+};
+
+static void mm_unplug(struct blk_plug_cb *cb)
+{
+        struct mm_plug_cb *mmcb = container_of(cb, struct mm_plug_cb, cb);
+
+        spin_lock_irq(&mmcb->card->lock);
+        activate(mmcb->card);
+        spin_unlock_irq(&mmcb->card->lock);
+        kfree(mmcb);
+}
+
+static int mm_check_plugged(struct cardinfo *card)
+{
+        struct blk_plug *plug = current->plug;
+        struct mm_plug_cb *mmcb;
+
+        if (!plug)
+                return 0;
+
+        list_for_each_entry(mmcb, &plug->cb_list, cb.list) {
+                if (mmcb->cb.callback == mm_unplug && mmcb->card == card)
+                        return 1;
+        }
+        /* Not currently on the callback list */
+        mmcb = kmalloc(sizeof(*mmcb), GFP_ATOMIC);
+        if (!mmcb)
+                return 0;
+
+        mmcb->card = card;
+        mmcb->cb.callback = mm_unplug;
+        list_add(&mmcb->cb.list, &plug->cb_list);
+        return 1;
+}
+
 static void mm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct cardinfo *card = q->queuedata;
@@ -523,6 +561,8 @@ static void mm_make_request(struct request_queue *q, struct bio *bio)
         *card->biotail = bio;
         bio->bi_next = NULL;
         card->biotail = &bio->bi_next;
+        if (bio->bi_rw & REQ_SYNC || !mm_check_plugged(card))
+                activate(card);
         spin_unlock_irq(&card->lock);
 
         return;
diff --git a/drivers/block/xen-blkback/common.h b/drivers/block/xen-blkback/common.h
index 773cf27dc23f..9ad3b5ec1dc1 100644
--- a/drivers/block/xen-blkback/common.h
+++ b/drivers/block/xen-blkback/common.h
@@ -257,6 +257,7 @@ static inline void blkif_get_x86_32_req(struct blkif_request *dst,
                 break;
         case BLKIF_OP_DISCARD:
                 dst->u.discard.flag = src->u.discard.flag;
+                dst->u.discard.id = src->u.discard.id;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
@@ -287,6 +288,7 @@ static inline void blkif_get_x86_64_req(struct blkif_request *dst,
                 break;
         case BLKIF_OP_DISCARD:
                 dst->u.discard.flag = src->u.discard.flag;
+                dst->u.discard.id = src->u.discard.id;
                 dst->u.discard.sector_number = src->u.discard.sector_number;
                 dst->u.discard.nr_sectors = src->u.discard.nr_sectors;
                 break;
diff --git a/drivers/block/xen-blkfront.c b/drivers/block/xen-blkfront.c
index 60eed4bdd2e4..e4fb3374dcd2 100644
--- a/drivers/block/xen-blkfront.c
+++ b/drivers/block/xen-blkfront.c
@@ -141,14 +141,36 @@ static int get_id_from_freelist(struct blkfront_info *info)
         return free;
 }
 
-static void add_id_to_freelist(struct blkfront_info *info,
+static int add_id_to_freelist(struct blkfront_info *info,
                                unsigned long id)
 {
+        if (info->shadow[id].req.u.rw.id != id)
+                return -EINVAL;
+        if (info->shadow[id].request == NULL)
+                return -EINVAL;
         info->shadow[id].req.u.rw.id  = info->shadow_free;
         info->shadow[id].request = NULL;
         info->shadow_free = id;
+        return 0;
 }
 
+static const char *op_name(int op)
+{
+        static const char *const names[] = {
+                [BLKIF_OP_READ] = "read",
+                [BLKIF_OP_WRITE] = "write",
+                [BLKIF_OP_WRITE_BARRIER] = "barrier",
+                [BLKIF_OP_FLUSH_DISKCACHE] = "flush",
+                [BLKIF_OP_DISCARD] = "discard" };
+
+        if (op < 0 || op >= ARRAY_SIZE(names))
+                return "unknown";
+
+        if (!names[op])
+                return "reserved";
+
+        return names[op];
+}
 static int xlbd_reserve_minors(unsigned int minor, unsigned int nr)
 {
         unsigned int end = minor + nr;
@@ -746,20 +768,36 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
 
                 bret = RING_GET_RESPONSE(&info->ring, i);
                 id   = bret->id;
+                /*
+                 * The backend has messed up and given us an id that we would
+                 * never have given to it (we stamp it up to BLK_RING_SIZE -
+                 * look in get_id_from_freelist.
+                 */
+                if (id >= BLK_RING_SIZE) {
+                        WARN(1, "%s: response to %s has incorrect id (%ld)\n",
+                             info->gd->disk_name, op_name(bret->operation), id);
+                        /* We can't safely get the 'struct request' as
+                         * the id is busted. */
+                        continue;
+                }
                 req  = info->shadow[id].request;
 
                 if (bret->operation != BLKIF_OP_DISCARD)
                         blkif_completion(&info->shadow[id]);
 
-                add_id_to_freelist(info, id);
+                if (add_id_to_freelist(info, id)) {
+                        WARN(1, "%s: response to %s (id %ld) couldn't be recycled!\n",
+                             info->gd->disk_name, op_name(bret->operation), id);
+                        continue;
+                }
 
                 error = (bret->status == BLKIF_RSP_OKAY) ? 0 : -EIO;
                 switch (bret->operation) {
                 case BLKIF_OP_DISCARD:
                         if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
                                 struct request_queue *rq = info->rq;
-                                printk(KERN_WARNING "blkfront: %s: discard op failed\n",
-                                           info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: %s op failed\n",
+                                           info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                                 info->feature_discard = 0;
                                 info->feature_secdiscard = 0;
@@ -771,18 +809,14 @@ static irqreturn_t blkif_interrupt(int irq, void *dev_id)
                 case BLKIF_OP_FLUSH_DISKCACHE:
                 case BLKIF_OP_WRITE_BARRIER:
                         if (unlikely(bret->status == BLKIF_RSP_EOPNOTSUPP)) {
-                                printk(KERN_WARNING "blkfront: %s: write %s op failed\n",
-                                       info->flush_op == BLKIF_OP_WRITE_BARRIER ?
-                                       "barrier" :  "flush disk cache",
-                                       info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: %s op failed\n",
+                                       info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                         }
                         if (unlikely(bret->status == BLKIF_RSP_ERROR &&
                                      info->shadow[id].req.u.rw.nr_segments == 0)) {
-                                printk(KERN_WARNING "blkfront: %s: empty write %s op failed\n",
-                                       info->flush_op == BLKIF_OP_WRITE_BARRIER ?
-                                       "barrier" :  "flush disk cache",
-                                       info->gd->disk_name);
+                                printk(KERN_WARNING "blkfront: %s: empty %s op failed\n",
+                                       info->gd->disk_name, op_name(bret->operation));
                                 error = -EOPNOTSUPP;
                         }
                         if (unlikely(error)) {
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index dcbe05616090..9a1eb0cfa95f 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1067,26 +1067,24 @@ static int __clk_set_parent(struct clk *clk, struct clk *parent)
 
         old_parent = clk->parent;
 
-        /* find index of new parent clock using cached parent ptrs */
-        if (clk->parents)
-                for (i = 0; i < clk->num_parents; i++)
-                        if (clk->parents[i] == parent)
-                                break;
-        else
+        if (!clk->parents)
                 clk->parents = kzalloc((sizeof(struct clk*) * clk->num_parents),
                                                                 GFP_KERNEL);
 
         /*
-         * find index of new parent clock using string name comparison
-         * also try to cache the parent to avoid future calls to __clk_lookup
+         * find index of new parent clock using cached parent ptrs,
+         * or if not yet cached, use string name comparison and cache
+         * them now to avoid future calls to __clk_lookup.
          */
-        if (i == clk->num_parents)
-                for (i = 0; i < clk->num_parents; i++)
-                        if (!strcmp(clk->parent_names[i], parent->name)) {
-                                if (clk->parents)
-                                        clk->parents[i] = __clk_lookup(parent->name);
-                                break;
-                        }
+        for (i = 0; i < clk->num_parents; i++) {
+                if (clk->parents && clk->parents[i] == parent)
+                        break;
+                else if (!strcmp(clk->parent_names[i], parent->name)) {
+                        if (clk->parents)
+                                clk->parents[i] = __clk_lookup(parent->name);
+                        break;
+                }
+        }
 
         if (i == clk->num_parents) {
                 pr_debug("%s: clock %s is not a possible parent of clock %s\n",
diff --git a/drivers/gpio/Kconfig b/drivers/gpio/Kconfig
index c4067d0141f7..542f0c04b695 100644
--- a/drivers/gpio/Kconfig
+++ b/drivers/gpio/Kconfig
@@ -136,7 +136,7 @@ config GPIO_MPC8XXX
 
 config GPIO_MSM_V1
         tristate "Qualcomm MSM GPIO v1"
-        depends on GPIOLIB && ARCH_MSM
+        depends on GPIOLIB && ARCH_MSM && (ARCH_MSM7X00A || ARCH_MSM7X30 || ARCH_QSD8X50)
         help
           Say yes here to support the GPIO interface on ARM v6 based
           Qualcomm MSM chips.  Most of the pins on the MSM can be
diff --git a/drivers/gpio/devres.c b/drivers/gpio/devres.c
index 9e9947cb86a3..1077754f8289 100644
--- a/drivers/gpio/devres.c
+++ b/drivers/gpio/devres.c
@@ -98,6 +98,7 @@ int devm_gpio_request_one(struct device *dev, unsigned gpio,
 
         return 0;
 }
+EXPORT_SYMBOL(devm_gpio_request_one);
 
 /**
  *      devm_gpio_free - free an interrupt
diff --git a/drivers/gpio/gpio-mxc.c b/drivers/gpio/gpio-mxc.c
index c337143b18f8..c89c4c1e668d 100644
--- a/drivers/gpio/gpio-mxc.c
+++ b/drivers/gpio/gpio-mxc.c
@@ -398,10 +398,12 @@ static int __devinit mxc_gpio_probe(struct platform_device *pdev)
         writel(~0, port->base + GPIO_ISR);
 
         if (mxc_gpio_hwtype == IMX21_GPIO) {
-                /* setup one handler for all GPIO interrupts */
-                if (pdev->id == 0)
-                        irq_set_chained_handler(port->irq,
-                                                mx2_gpio_irq_handler);
+                /*
+                 * Setup one handler for all GPIO interrupts. Actually setting
+                 * the handler is needed only once, but doing it for every port
+                 * is more robust and easier.
+                 */
+                irq_set_chained_handler(port->irq, mx2_gpio_irq_handler);
         } else {
                 /* setup one handler for each entry */
                 irq_set_chained_handler(port->irq, mx3_gpio_irq_handler);
diff --git a/drivers/gpio/gpio-omap.c b/drivers/gpio/gpio-omap.c
index c4ed1722734c..4fbc208c32cf 100644
--- a/drivers/gpio/gpio-omap.c
+++ b/drivers/gpio/gpio-omap.c
@@ -174,12 +174,22 @@ static inline void _gpio_dbck_enable(struct gpio_bank *bank)
         if (bank->dbck_enable_mask && !bank->dbck_enabled) {
                 clk_enable(bank->dbck);
                 bank->dbck_enabled = true;
+
+                __raw_writel(bank->dbck_enable_mask,
+                             bank->base + bank->regs->debounce_en);
         }
 }
 
 static inline void _gpio_dbck_disable(struct gpio_bank *bank)
 {
         if (bank->dbck_enable_mask && bank->dbck_enabled) {
+                /*
+                 * Disable debounce before cutting it's clock. If debounce is
+                 * enabled but the clock is not, GPIO module seems to be unable
+                 * to detect events and generate interrupts at least on OMAP3.
+                 */
+                __raw_writel(0, bank->base + bank->regs->debounce_en);
+
                 clk_disable(bank->dbck);
                 bank->dbck_enabled = false;
         }
@@ -1081,7 +1091,6 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         bank->is_mpuio = pdata->is_mpuio;
         bank->non_wakeup_gpios = pdata->non_wakeup_gpios;
         bank->loses_context = pdata->loses_context;
-        bank->get_context_loss_count = pdata->get_context_loss_count;
         bank->regs = pdata->regs;
 #ifdef CONFIG_OF_GPIO
         bank->chip.of_node = of_node_get(node);
@@ -1135,6 +1144,9 @@ static int __devinit omap_gpio_probe(struct platform_device *pdev)
         omap_gpio_chip_init(bank);
         omap_gpio_show_rev(bank);
 
+        if (bank->loses_context)
+                bank->get_context_loss_count = pdata->get_context_loss_count;
+
         pm_runtime_put(bank->dev);
 
         list_add_tail(&bank->node, &omap_gpio_list);
diff --git a/drivers/gpio/gpio-sta2x11.c b/drivers/gpio/gpio-sta2x11.c
index 38416be8ba11..6064fb376e11 100644
--- a/drivers/gpio/gpio-sta2x11.c
+++ b/drivers/gpio/gpio-sta2x11.c
@@ -383,8 +383,9 @@ static int __devinit gsta_probe(struct platform_device *dev)
         }
         spin_lock_init(&chip->lock);
         gsta_gpio_setup(chip);
-        for (i = 0; i < GSTA_NR_GPIO; i++)
-                gsta_set_config(chip, i, gpio_pdata->pinconfig[i]);
+        if (gpio_pdata)
+                for (i = 0; i < GSTA_NR_GPIO; i++)
+                        gsta_set_config(chip, i, gpio_pdata->pinconfig[i]);
 
         /* 384 was used in previous code: be compatible for other drivers */
         err = irq_alloc_descs(-1, 384, GSTA_NR_GPIO, NUMA_NO_NODE);
diff --git a/drivers/gpio/gpio-tps65910.c b/drivers/gpio/gpio-tps65910.c
index c1ad2884f2ed..11f29c82253c 100644
--- a/drivers/gpio/gpio-tps65910.c
+++ b/drivers/gpio/gpio-tps65910.c
@@ -149,6 +149,9 @@ static int __devinit tps65910_gpio_probe(struct platform_device *pdev)
         tps65910_gpio->gpio_chip.set    = tps65910_gpio_set;
         tps65910_gpio->gpio_chip.get    = tps65910_gpio_get;
         tps65910_gpio->gpio_chip.dev = &pdev->dev;
+#ifdef CONFIG_OF_GPIO
+        tps65910_gpio->gpio_chip.of_node = tps65910->dev->of_node;
+#endif
         if (pdata && pdata->gpio_base)
                 tps65910_gpio->gpio_chip.base = pdata->gpio_base;
         else
diff --git a/drivers/gpio/gpio-wm8994.c b/drivers/gpio/gpio-wm8994.c
index 92ea5350dfe9..aa61ad2fcaaa 100644
--- a/drivers/gpio/gpio-wm8994.c
+++ b/drivers/gpio/gpio-wm8994.c
@@ -89,8 +89,11 @@ static int wm8994_gpio_direction_out(struct gpio_chip *chip,
         struct wm8994_gpio *wm8994_gpio = to_wm8994_gpio(chip);
         struct wm8994 *wm8994 = wm8994_gpio->wm8994;
 
+        if (value)
+                value = WM8994_GPN_LVL;
+
         return wm8994_set_bits(wm8994, WM8994_GPIO_1 + offset,
-                               WM8994_GPN_DIR, 0);
+                               WM8994_GPN_DIR | WM8994_GPN_LVL, value);
 }
 
 static void wm8994_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 5873e481e5d2..a8743c399e83 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -1039,6 +1039,24 @@ mode_in_range(const struct drm_display_mode *mode, struct edid *edid,
         return true;
 }
 
+static bool valid_inferred_mode(const struct drm_connector *connector,
+                                const struct drm_display_mode *mode)
+{
+        struct drm_display_mode *m;
+        bool ok = false;
+
+        list_for_each_entry(m, &connector->probed_modes, head) {
+                if (mode->hdisplay == m->hdisplay &&
+                    mode->vdisplay == m->vdisplay &&
+                    drm_mode_vrefresh(mode) == drm_mode_vrefresh(m))
+                        return false; /* duplicated */
+                if (mode->hdisplay <= m->hdisplay &&
+                    mode->vdisplay <= m->vdisplay)
+                        ok = true;
+        }
+        return ok;
+}
+
 static int
 drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         struct detailed_timing *timing)
@@ -1048,7 +1066,8 @@ drm_dmt_modes_for_range(struct drm_connector *connector, struct edid *edid,
         struct drm_device *dev = connector->dev;
 
         for (i = 0; i < drm_num_dmt_modes; i++) {
-                if (mode_in_range(drm_dmt_modes + i, edid, timing)) {
+                if (mode_in_range(drm_dmt_modes + i, edid, timing) &&
+                    valid_inferred_mode(connector, drm_dmt_modes + i)) {
                         newmode = drm_mode_duplicate(dev, &drm_dmt_modes[i]);
                         if (newmode) {
                                 drm_mode_probed_add(connector, newmode);
@@ -1088,7 +1107,8 @@ drm_gtf_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         return modes;
 
                 fixup_mode_1366x768(newmode);
-                if (!mode_in_range(newmode, edid, timing)) {
+                if (!mode_in_range(newmode, edid, timing) ||
+                    !valid_inferred_mode(connector, newmode)) {
                         drm_mode_destroy(dev, newmode);
                         continue;
                 }
@@ -1116,7 +1136,8 @@ drm_cvt_modes_for_range(struct drm_connector *connector, struct edid *edid,
                         return modes;
 
                 fixup_mode_1366x768(newmode);
-                if (!mode_in_range(newmode, edid, timing)) {
+                if (!mode_in_range(newmode, edid, timing) ||
+                    !valid_inferred_mode(connector, newmode)) {
                         drm_mode_destroy(dev, newmode);
                         continue;
                 }
diff --git a/drivers/gpu/drm/i915/i915_dma.c b/drivers/gpu/drm/i915/i915_dma.c
index f94792626b94..36822b924eb1 100644
--- a/drivers/gpu/drm/i915/i915_dma.c
+++ b/drivers/gpu/drm/i915/i915_dma.c
@@ -1401,6 +1401,27 @@ i915_mtrr_setup(struct drm_i915_private *dev_priv, unsigned long base,
         }
 }
 
+static void i915_kick_out_firmware_fb(struct drm_i915_private *dev_priv)
+{
+        struct apertures_struct *ap;
+        struct pci_dev *pdev = dev_priv->dev->pdev;
+        bool primary;
+
+        ap = alloc_apertures(1);
+        if (!ap)
+                return;
+
+        ap->ranges[0].base = dev_priv->dev->agp->base;
+        ap->ranges[0].size =
+                dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
+        primary =
+                pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
+
+        remove_conflicting_framebuffers(ap, "inteldrmfb", primary);
+
+        kfree(ap);
+}
+
 /**
  * i915_driver_load - setup chip and create an initial config
  * @dev: DRM device
@@ -1446,6 +1467,15 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto free_priv;
         }
 
+        dev_priv->mm.gtt = intel_gtt_get();
+        if (!dev_priv->mm.gtt) {
+                DRM_ERROR("Failed to initialize GTT\n");
+                ret = -ENODEV;
+                goto put_bridge;
+        }
+
+        i915_kick_out_firmware_fb(dev_priv);
+
         pci_set_master(dev->pdev);
 
         /* overlay on gen2 is broken and can't address above 1G */
@@ -1471,13 +1501,6 @@ int i915_driver_load(struct drm_device *dev, unsigned long flags)
                 goto put_bridge;
         }
 
-        dev_priv->mm.gtt = intel_gtt_get();
-        if (!dev_priv->mm.gtt) {
-                DRM_ERROR("Failed to initialize GTT\n");
-                ret = -ENODEV;
-                goto out_rmmap;
-        }
-
         aperture_size = dev_priv->mm.gtt->gtt_mappable_entries << PAGE_SHIFT;
 
         dev_priv->mm.gtt_mapping =
diff --git a/drivers/gpu/drm/radeon/radeon_gart.c b/drivers/gpu/drm/radeon/radeon_gart.c
index 59d44937dd9f..84b648a7ddd8 100644
--- a/drivers/gpu/drm/radeon/radeon_gart.c
+++ b/drivers/gpu/drm/radeon/radeon_gart.c
@@ -289,8 +289,9 @@ int radeon_vm_manager_init(struct radeon_device *rdev)
         rdev->vm_manager.enabled = false;
 
         /* mark first vm as always in use, it's the system one */
+        /* allocate enough for 2 full VM pts */
         r = radeon_sa_bo_manager_init(rdev, &rdev->vm_manager.sa_manager,
-                                      rdev->vm_manager.max_pfn * 8,
+                                      rdev->vm_manager.max_pfn * 8 * 2,
                                       RADEON_GEM_DOMAIN_VRAM);
         if (r) {
                 dev_err(rdev->dev, "failed to allocate vm bo (%dKB)\n",
@@ -633,7 +634,15 @@ int radeon_vm_init(struct radeon_device *rdev, struct radeon_vm *vm)
         mutex_init(&vm->mutex);
         INIT_LIST_HEAD(&vm->list);
         INIT_LIST_HEAD(&vm->va);
-        vm->last_pfn = 0;
+        /* SI requires equal sized PTs for all VMs, so always set
+         * last_pfn to max_pfn.  cayman allows variable sized
+         * pts so we can grow then as needed.  Once we switch
+         * to two level pts we can unify this again.
+         */
+        if (rdev->family >= CHIP_TAHITI)
+                vm->last_pfn = rdev->vm_manager.max_pfn;
+        else
+                vm->last_pfn = 0;
         /* map the ib pool buffer at 0 in virtual address space, set
          * read only
          */
diff --git a/drivers/gpu/drm/radeon/radeon_gem.c b/drivers/gpu/drm/radeon/radeon_gem.c
index f28bd4b7ef98..21ec9f5653ce 100644
--- a/drivers/gpu/drm/radeon/radeon_gem.c
+++ b/drivers/gpu/drm/radeon/radeon_gem.c
@@ -292,6 +292,7 @@ int radeon_gem_mmap_ioctl(struct drm_device *dev, void *data,
 int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
                           struct drm_file *filp)
 {
+        struct radeon_device *rdev = dev->dev_private;
         struct drm_radeon_gem_busy *args = data;
         struct drm_gem_object *gobj;
         struct radeon_bo *robj;
@@ -317,13 +318,14 @@ int radeon_gem_busy_ioctl(struct drm_device *dev, void *data,
                 break;
         }
         drm_gem_object_unreference_unlocked(gobj);
-        r = radeon_gem_handle_lockup(robj->rdev, r);
+        r = radeon_gem_handle_lockup(rdev, r);
         return r;
 }
 
 int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
                               struct drm_file *filp)
 {
+        struct radeon_device *rdev = dev->dev_private;
         struct drm_radeon_gem_wait_idle *args = data;
         struct drm_gem_object *gobj;
         struct radeon_bo *robj;
@@ -336,10 +338,10 @@ int radeon_gem_wait_idle_ioctl(struct drm_device *dev, void *data,
         robj = gem_to_radeon_bo(gobj);
         r = radeon_bo_wait(robj, NULL, false);
         /* callback hw specific functions if any */
-        if (robj->rdev->asic->ioctl_wait_idle)
-                robj->rdev->asic->ioctl_wait_idle(robj->rdev, robj);
+        if (rdev->asic->ioctl_wait_idle)
+                robj->rdev->asic->ioctl_wait_idle(rdev, robj);
         drm_gem_object_unreference_unlocked(gobj);
-        r = radeon_gem_handle_lockup(robj->rdev, r);
+        r = radeon_gem_handle_lockup(rdev, r);
         return r;
 }
 
diff --git a/drivers/gpu/drm/radeon/si.c b/drivers/gpu/drm/radeon/si.c
index c7b61f16ecfd..0b0279291a73 100644
--- a/drivers/gpu/drm/radeon/si.c
+++ b/drivers/gpu/drm/radeon/si.c
@@ -2365,12 +2365,12 @@ int si_pcie_gart_enable(struct radeon_device *rdev)
         WREG32(0x15DC, 0);
 
         /* empty context1-15 */
-        /* FIXME start with 1G, once using 2 level pt switch to full
+        /* FIXME start with 4G, once using 2 level pt switch to full
          * vm size space
          */
         /* set vm size, must be a multiple of 4 */
         WREG32(VM_CONTEXT1_PAGE_TABLE_START_ADDR, 0);
-        WREG32(VM_CONTEXT1_PAGE_TABLE_END_ADDR, (1 << 30) / RADEON_GPU_PAGE_SIZE);
+        WREG32(VM_CONTEXT1_PAGE_TABLE_END_ADDR, rdev->vm_manager.max_pfn);
         for (i = 1; i < 16; i++) {
                 if (i < 8)
                         WREG32(VM_CONTEXT0_PAGE_TABLE_BASE_ADDR + (i << 2),
diff --git a/drivers/hid/hid-apple.c b/drivers/hid/hid-apple.c
index fa10f847f7db..585344b6d338 100644
--- a/drivers/hid/hid-apple.c
+++ b/drivers/hid/hid-apple.c
@@ -517,6 +517,12 @@ static const struct hid_device_id apple_devices[] = {
                 .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
                 .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
+                .driver_data = APPLE_HAS_FN },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
+                .driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
+                .driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
                 .driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index 6ac0286b5375..4c87276c8ddb 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1503,6 +1503,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO) },
         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS) },
@@ -1995,6 +1998,7 @@ static const struct hid_device_id hid_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_MCT) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HYBRID) },
         { HID_USB_DEVICE(USB_VENDOR_ID_LD, USB_DEVICE_ID_LD_HEATCONTROL) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MADCATZ, USB_DEVICE_ID_MADCATZ_BEATPAD) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1024LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MCC, USB_DEVICE_ID_MCC_PMD1208LS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROCHIP, USB_DEVICE_ID_PICKIT1) },
@@ -2089,6 +2093,9 @@ static const struct hid_device_id hid_mouse_ignore_list[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ANSI) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_ISO) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING6A_JIS) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_ISO) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING7_JIS) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY) },
         { HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY) },
         { }
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index d1cdd2d28409..875ff451842b 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -125,6 +125,9 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ANSI    0x024c
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_ISO     0x024d
 #define USB_DEVICE_ID_APPLE_WELLSPRING6_JIS     0x024e
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI    0x0262
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO     0x0263
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS     0x0264
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI  0x0239
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO   0x023a
 #define USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS   0x023b
@@ -518,6 +521,9 @@
 #define USB_DEVICE_ID_CRYSTALTOUCH      0x0006
 #define USB_DEVICE_ID_CRYSTALTOUCH_DUAL 0x0007
 
+#define USB_VENDOR_ID_MADCATZ           0x0738
+#define USB_DEVICE_ID_MADCATZ_BEATPAD   0x4540
+
 #define USB_VENDOR_ID_MCC               0x09db
 #define USB_DEVICE_ID_MCC_PMD1024LS     0x0076
 #define USB_DEVICE_ID_MCC_PMD1208LS     0x007a
diff --git a/drivers/hwmon/it87.c b/drivers/hwmon/it87.c
index e7701d99f8e8..f1de3979181f 100644
--- a/drivers/hwmon/it87.c
+++ b/drivers/hwmon/it87.c
@@ -2341,7 +2341,7 @@ static void __devinit it87_init_device(struct platform_device *pdev)
 
         /* Start monitoring */
         it87_write_value(data, IT87_REG_CONFIG,
-                         (it87_read_value(data, IT87_REG_CONFIG) & 0x36)
+                         (it87_read_value(data, IT87_REG_CONFIG) & 0x3e)
                          | (update_vbat ? 0x41 : 0x01));
 }
 
diff --git a/drivers/hwspinlock/hwspinlock_core.c b/drivers/hwspinlock/hwspinlock_core.c
index 61c9cf15fa52..1201a15784c3 100644
--- a/drivers/hwspinlock/hwspinlock_core.c
+++ b/drivers/hwspinlock/hwspinlock_core.c
@@ -345,7 +345,7 @@ int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
                 spin_lock_init(&hwlock->lock);
                 hwlock->bank = bank;
 
-                ret = hwspin_lock_register_single(hwlock, i);
+                ret = hwspin_lock_register_single(hwlock, base_id + i);
                 if (ret)
                         goto reg_failed;
         }
@@ -354,7 +354,7 @@ int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
 
 reg_failed:
         while (--i >= 0)
-                hwspin_lock_unregister_single(i);
+                hwspin_lock_unregister_single(base_id + i);
         return ret;
 }
 EXPORT_SYMBOL_GPL(hwspin_lock_register);
diff --git a/drivers/input/joystick/as5011.c b/drivers/input/joystick/as5011.c
index 57d19d4e0a2d..c96653b58867 100644
--- a/drivers/input/joystick/as5011.c
+++ b/drivers/input/joystick/as5011.c
@@ -282,7 +282,8 @@ static int __devinit as5011_probe(struct i2c_client *client,
 
         error = request_threaded_irq(as5011->button_irq,
                                      NULL, as5011_button_interrupt,
-                                     IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_RISING |
+                                        IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      "as5011_button", as5011);
         if (error < 0) {
                 dev_err(&client->dev,
@@ -296,7 +297,7 @@ static int __devinit as5011_probe(struct i2c_client *client,
 
         error = request_threaded_irq(as5011->axis_irq, NULL,
                                      as5011_axis_interrupt,
-                                     plat_data->axis_irqflags,
+                                     plat_data->axis_irqflags | IRQF_ONESHOT,
                                      "as5011_joystick", as5011);
         if (error) {
                 dev_err(&client->dev,
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index ee16fb67b7ae..83811e45d633 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -142,6 +142,7 @@ static const struct xpad_device {
         { 0x0c12, 0x880a, "Pelican Eclipse PL-2023", 0, XTYPE_XBOX },
         { 0x0c12, 0x8810, "Zeroplus Xbox Controller", 0, XTYPE_XBOX },
         { 0x0c12, 0x9902, "HAMA VibraX - *FAULTY HARDWARE*", 0, XTYPE_XBOX },
+        { 0x0d2f, 0x0002, "Andamiro Pump It Up pad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
         { 0x0e4c, 0x1097, "Radica Gamester Controller", 0, XTYPE_XBOX },
         { 0x0e4c, 0x2390, "Radica Games Jtech Controller", 0, XTYPE_XBOX },
         { 0x0e6f, 0x0003, "Logic3 Freebird wireless Controller", 0, XTYPE_XBOX },
@@ -164,6 +165,7 @@ static const struct xpad_device {
         { 0x1bad, 0x0003, "Harmonix Rock Band Drumkit", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0f0d, 0x0016, "Hori Real Arcade Pro.EX", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0f0d, 0x000d, "Hori Fighting Stick EX2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
+        { 0x1689, 0xfd00, "Razer Onza Tournament Edition", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
         { 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX },
         { 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN }
 };
@@ -238,12 +240,14 @@ static struct usb_device_id xpad_table [] = {
         XPAD_XBOX360_VENDOR(0x045e),            /* Microsoft X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x046d),            /* Logitech X-Box 360 style controllers */
         XPAD_XBOX360_VENDOR(0x0738),            /* Mad Catz X-Box 360 controllers */
+        { USB_DEVICE(0x0738, 0x4540) },         /* Mad Catz Beat Pad */
         XPAD_XBOX360_VENDOR(0x0e6f),            /* 0x0e6f X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x12ab),            /* X-Box 360 dance pads */
         XPAD_XBOX360_VENDOR(0x1430),            /* RedOctane X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x146b),            /* BigBen Interactive Controllers */
         XPAD_XBOX360_VENDOR(0x1bad),            /* Harminix Rock Band Guitar and Drums */
-        XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
+        XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
+        XPAD_XBOX360_VENDOR(0x1689),            /* Razer Onza */
         { }
 };
 
diff --git a/drivers/input/keyboard/mcs_touchkey.c b/drivers/input/keyboard/mcs_touchkey.c
index 64a0ca4c92f3..0d77f6c84950 100644
--- a/drivers/input/keyboard/mcs_touchkey.c
+++ b/drivers/input/keyboard/mcs_touchkey.c
@@ -178,7 +178,8 @@ static int __devinit mcs_touchkey_probe(struct i2c_client *client,
         }
 
         error = request_threaded_irq(client->irq, NULL, mcs_touchkey_interrupt,
-                        IRQF_TRIGGER_FALLING, client->dev.driver->name, data);
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                     client->dev.driver->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
                 goto err_free_mem;
diff --git a/drivers/input/keyboard/mpr121_touchkey.c b/drivers/input/keyboard/mpr121_touchkey.c
index caa218a51b5a..7613f1cac951 100644
--- a/drivers/input/keyboard/mpr121_touchkey.c
+++ b/drivers/input/keyboard/mpr121_touchkey.c
@@ -248,7 +248,7 @@ static int __devinit mpr_touchkey_probe(struct i2c_client *client,
 
         error = request_threaded_irq(client->irq, NULL,
                                      mpr_touchkey_interrupt,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->dev.driver->name, mpr121);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
diff --git a/drivers/input/keyboard/qt1070.c b/drivers/input/keyboard/qt1070.c
index 0b7b2f891752..ca68f2992d72 100644
--- a/drivers/input/keyboard/qt1070.c
+++ b/drivers/input/keyboard/qt1070.c
@@ -201,7 +201,8 @@ static int __devinit qt1070_probe(struct i2c_client *client,
         msleep(QT1070_RESET_TIME);
 
         err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
-                IRQF_TRIGGER_NONE, client->dev.driver->name, data);
+                                   IRQF_TRIGGER_NONE | IRQF_ONESHOT,
+                                   client->dev.driver->name, data);
         if (err) {
                 dev_err(&client->dev, "fail to request irq\n");
                 goto err_free_mem;
diff --git a/drivers/input/keyboard/tca6416-keypad.c b/drivers/input/keyboard/tca6416-keypad.c
index 3afea3f89718..c355cdde8d22 100644
--- a/drivers/input/keyboard/tca6416-keypad.c
+++ b/drivers/input/keyboard/tca6416-keypad.c
@@ -278,7 +278,8 @@ static int __devinit tca6416_keypad_probe(struct i2c_client *client,
 
                 error = request_threaded_irq(chip->irqnum, NULL,
                                              tca6416_keys_isr,
-                                             IRQF_TRIGGER_FALLING,
+                                             IRQF_TRIGGER_FALLING |
+                                                IRQF_ONESHOT,
                                              "tca6416-keypad", chip);
                 if (error) {
                         dev_dbg(&client->dev,
diff --git a/drivers/input/keyboard/tca8418_keypad.c b/drivers/input/keyboard/tca8418_keypad.c
index 5f87b28b3192..893869b29ed9 100644
--- a/drivers/input/keyboard/tca8418_keypad.c
+++ b/drivers/input/keyboard/tca8418_keypad.c
@@ -360,7 +360,7 @@ static int __devinit tca8418_keypad_probe(struct i2c_client *client,
                 client->irq = gpio_to_irq(client->irq);
 
         error = request_threaded_irq(client->irq, NULL, tca8418_irq_handler,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->name, keypad_data);
         if (error) {
                 dev_dbg(&client->dev,
diff --git a/drivers/input/keyboard/tnetv107x-keypad.c b/drivers/input/keyboard/tnetv107x-keypad.c
index a4a445fb7020..4c34f21fbe2d 100644
--- a/drivers/input/keyboard/tnetv107x-keypad.c
+++ b/drivers/input/keyboard/tnetv107x-keypad.c
@@ -227,15 +227,15 @@ static int __devinit keypad_probe(struct platform_device *pdev)
                 goto error_clk;
         }
 
-        error = request_threaded_irq(kp->irq_press, NULL, keypad_irq, 0,
-                                     dev_name(dev), kp);
+        error = request_threaded_irq(kp->irq_press, NULL, keypad_irq,
+                                     IRQF_ONESHOT, dev_name(dev), kp);
         if (error < 0) {
                 dev_err(kp->dev, "Could not allocate keypad press key irq\n");
                 goto error_irq_press;
         }
 
-        error = request_threaded_irq(kp->irq_release, NULL, keypad_irq, 0,
-                                     dev_name(dev), kp);
+        error = request_threaded_irq(kp->irq_release, NULL, keypad_irq,
+                                     IRQF_ONESHOT, dev_name(dev), kp);
         if (error < 0) {
                 dev_err(kp->dev, "Could not allocate keypad release key irq\n");
                 goto error_irq_release;
diff --git a/drivers/input/misc/ad714x.c b/drivers/input/misc/ad714x.c
index 0ac75bbad4d6..2e5d5e1de647 100644
--- a/drivers/input/misc/ad714x.c
+++ b/drivers/input/misc/ad714x.c
@@ -972,6 +972,7 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
         struct ad714x_platform_data *plat_data = dev->platform_data;
         struct ad714x_chip *ad714x;
         void *drv_mem;
+        unsigned long irqflags;
 
         struct ad714x_button_drv *bt_drv;
         struct ad714x_slider_drv *sd_drv;
@@ -1162,10 +1163,11 @@ struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
                 alloc_idx++;
         }
 
+        irqflags = plat_data->irqflags ?: IRQF_TRIGGER_FALLING;
+        irqflags |= IRQF_ONESHOT;
+
         error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
-                                plat_data->irqflags ?
-                                        plat_data->irqflags : IRQF_TRIGGER_FALLING,
-                                "ad714x_captouch", ad714x);
+                                     irqflags, "ad714x_captouch", ad714x);
         if (error) {
                 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
                 goto err_unreg_dev;
diff --git a/drivers/input/misc/dm355evm_keys.c b/drivers/input/misc/dm355evm_keys.c
index 35083c6836c3..c1313d8535c3 100644
--- a/drivers/input/misc/dm355evm_keys.c
+++ b/drivers/input/misc/dm355evm_keys.c
@@ -213,7 +213,8 @@ static int __devinit dm355evm_keys_probe(struct platform_device *pdev)
         /* REVISIT:  flush the event queue? */
 
         status = request_threaded_irq(keys->irq, NULL, dm355evm_keys_irq,
-                        IRQF_TRIGGER_FALLING, dev_name(&pdev->dev), keys);
+                                      IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+                                      dev_name(&pdev->dev), keys);
         if (status < 0)
                 goto fail2;
 
diff --git a/drivers/input/mouse/bcm5974.c b/drivers/input/mouse/bcm5974.c
index 2cf681d98c0d..d528c23e194f 100644
--- a/drivers/input/mouse/bcm5974.c
+++ b/drivers/input/mouse/bcm5974.c
@@ -79,6 +79,10 @@
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI   0x0252
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO    0x0253
 #define USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS    0x0254
+/* MacbookPro10,1 (unibody, June 2012) */
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI    0x0262
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_ISO     0x0263
+#define USB_DEVICE_ID_APPLE_WELLSPRING7_JIS     0x0264
 
 #define BCM5974_DEVICE(prod) {                                  \
         .match_flags = (USB_DEVICE_ID_MATCH_DEVICE |            \
@@ -128,6 +132,10 @@ static const struct usb_device_id bcm5974_table[] = {
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ANSI),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_ISO),
         BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING5A_JIS),
+        /* MacbookPro10,1 */
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_ISO),
+        BCM5974_DEVICE(USB_DEVICE_ID_APPLE_WELLSPRING7_JIS),
         /* Terminating entry */
         {}
 };
@@ -354,6 +362,18 @@ static const struct bcm5974_config bcm5974_config_table[] = {
                 { DIM_X, DIM_X / SN_COORD, -4620, 5140 },
                 { DIM_Y, DIM_Y / SN_COORD, -150, 6600 }
         },
+        {
+                USB_DEVICE_ID_APPLE_WELLSPRING7_ANSI,
+                USB_DEVICE_ID_APPLE_WELLSPRING7_ISO,
+                USB_DEVICE_ID_APPLE_WELLSPRING7_JIS,
+                HAS_INTEGRATED_BUTTON,
+                0x84, sizeof(struct bt_data),
+                0x81, TYPE2, FINGER_TYPE2, FINGER_TYPE2 + SIZEOF_ALL_FINGERS,
+                { DIM_PRESSURE, DIM_PRESSURE / SN_PRESSURE, 0, 300 },
+                { DIM_WIDTH, DIM_WIDTH / SN_WIDTH, 0, 2048 },
+                { DIM_X, DIM_X / SN_COORD, -4750, 5280 },
+                { DIM_Y, DIM_Y / SN_COORD, -150, 6730 }
+        },
         {}
 };
 
diff --git a/drivers/input/tablet/wacom_sys.c b/drivers/input/tablet/wacom_sys.c
index cad5602d3ce4..8b31473a81fe 100644
--- a/drivers/input/tablet/wacom_sys.c
+++ b/drivers/input/tablet/wacom_sys.c
@@ -216,7 +216,7 @@ static void wacom_retrieve_report_data(struct usb_interface *intf,
 
                 rep_data[0] = 12;
                 result = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
-                                          rep_data[0], &rep_data, 2,
+                                          rep_data[0], rep_data, 2,
                                           WAC_MSG_RETRIES);
 
                 if (result >= 0 && rep_data[1] > 2)
@@ -401,7 +401,9 @@ static int wacom_parse_hid(struct usb_interface *intf,
                                 break;
 
                         case HID_USAGE_CONTACTMAX:
-                                wacom_retrieve_report_data(intf, features);
+                                /* leave touch_max as is if predefined */
+                                if (!features->touch_max)
+                                        wacom_retrieve_report_data(intf, features);
                                 i++;
                                 break;
                         }
diff --git a/drivers/input/touchscreen/ad7879.c b/drivers/input/touchscreen/ad7879.c
index e2482b40da51..bd4eb4277697 100644
--- a/drivers/input/touchscreen/ad7879.c
+++ b/drivers/input/touchscreen/ad7879.c
@@ -597,7 +597,7 @@ struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
                         AD7879_TMR(ts->pen_down_acc_interval);
 
         err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
-                                   IRQF_TRIGGER_FALLING,
+                                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                    dev_name(dev), ts);
         if (err) {
                 dev_err(dev, "irq %d busy?\n", ts->irq);
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 42e645062c20..25fd0561a17d 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -1149,7 +1149,8 @@ static int __devinit mxt_probe(struct i2c_client *client,
                 goto err_free_object;
 
         error = request_threaded_irq(client->irq, NULL, mxt_interrupt,
-                        pdata->irqflags, client->dev.driver->name, data);
+                                     pdata->irqflags | IRQF_ONESHOT,
+                                     client->dev.driver->name, data);
         if (error) {
                 dev_err(&client->dev, "Failed to register interrupt\n");
                 goto err_free_object;
diff --git a/drivers/input/touchscreen/bu21013_ts.c b/drivers/input/touchscreen/bu21013_ts.c
index f2d03c06c2da..5c487d23f11c 100644
--- a/drivers/input/touchscreen/bu21013_ts.c
+++ b/drivers/input/touchscreen/bu21013_ts.c
@@ -509,7 +509,8 @@ static int __devinit bu21013_probe(struct i2c_client *client,
         input_set_drvdata(in_dev, bu21013_data);
 
         error = request_threaded_irq(pdata->irq, NULL, bu21013_gpio_irq,
-                                     IRQF_TRIGGER_FALLING | IRQF_SHARED,
+                                     IRQF_TRIGGER_FALLING | IRQF_SHARED |
+                                        IRQF_ONESHOT,
                                      DRIVER_TP, bu21013_data);
         if (error) {
                 dev_err(&client->dev, "request irq %d failed\n", pdata->irq);
diff --git a/drivers/input/touchscreen/cy8ctmg110_ts.c b/drivers/input/touchscreen/cy8ctmg110_ts.c
index 237753ad1031..464f1bf4b61d 100644
--- a/drivers/input/touchscreen/cy8ctmg110_ts.c
+++ b/drivers/input/touchscreen/cy8ctmg110_ts.c
@@ -251,7 +251,8 @@ static int __devinit cy8ctmg110_probe(struct i2c_client *client,
         }
 
         err = request_threaded_irq(client->irq, NULL, cy8ctmg110_irq_thread,
-                                   IRQF_TRIGGER_RISING, "touch_reset_key", ts);
+                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                   "touch_reset_key", ts);
         if (err < 0) {
                 dev_err(&client->dev,
                         "irq %d busy? error %d\n", client->irq, err);
diff --git a/drivers/input/touchscreen/intel-mid-touch.c b/drivers/input/touchscreen/intel-mid-touch.c
index 3cd7a837f82b..cf299377fc49 100644
--- a/drivers/input/touchscreen/intel-mid-touch.c
+++ b/drivers/input/touchscreen/intel-mid-touch.c
@@ -620,7 +620,7 @@ static int __devinit mrstouch_probe(struct platform_device *pdev)
                              MRST_PRESSURE_MIN, MRST_PRESSURE_MAX, 0, 0);
 
         err = request_threaded_irq(tsdev->irq, NULL, mrstouch_pendet_irq,
-                                   0, "mrstouch", tsdev);
+                                   IRQF_ONESHOT, "mrstouch", tsdev);
         if (err) {
                 dev_err(tsdev->dev, "unable to allocate irq\n");
                 goto err_free_mem;
diff --git a/drivers/input/touchscreen/pixcir_i2c_ts.c b/drivers/input/touchscreen/pixcir_i2c_ts.c
index 72f6ba3a4709..953b4c105cad 100644
--- a/drivers/input/touchscreen/pixcir_i2c_ts.c
+++ b/drivers/input/touchscreen/pixcir_i2c_ts.c
@@ -165,7 +165,7 @@ static int __devinit pixcir_i2c_ts_probe(struct i2c_client *client,
         input_set_drvdata(input, tsdata);
 
         error = request_threaded_irq(client->irq, NULL, pixcir_ts_isr,
-                                     IRQF_TRIGGER_FALLING,
+                                     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                                      client->name, tsdata);
         if (error) {
                 dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
diff --git a/drivers/input/touchscreen/tnetv107x-ts.c b/drivers/input/touchscreen/tnetv107x-ts.c
index 7e7488097359..368d2c6cf780 100644
--- a/drivers/input/touchscreen/tnetv107x-ts.c
+++ b/drivers/input/touchscreen/tnetv107x-ts.c
@@ -297,7 +297,7 @@ static int __devinit tsc_probe(struct platform_device *pdev)
                 goto error_clk;
         }
 
-        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, 0,
+        error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, IRQF_ONESHOT,
                                      dev_name(dev), ts);
         if (error < 0) {
                 dev_err(ts->dev, "Could not allocate ts irq\n");
diff --git a/drivers/input/touchscreen/tsc2005.c b/drivers/input/touchscreen/tsc2005.c
index b6adeaee9cc5..5ce3fa8ce646 100644
--- a/drivers/input/touchscreen/tsc2005.c
+++ b/drivers/input/touchscreen/tsc2005.c
@@ -650,7 +650,8 @@ static int __devinit tsc2005_probe(struct spi_device *spi)
         tsc2005_stop_scan(ts);
 
         error = request_threaded_irq(spi->irq, NULL, tsc2005_irq_thread,
-                                     IRQF_TRIGGER_RISING, "tsc2005", ts);
+                                     IRQF_TRIGGER_RISING | IRQF_ONESHOT,
+                                     "tsc2005", ts);
         if (error) {
                 dev_err(&spi->dev, "Failed to request irq, err: %d\n", error);
                 goto err_free_mem;
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index a2e418cba0ff..625626391f2d 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -83,6 +83,8 @@ static struct iommu_ops amd_iommu_ops;
 static ATOMIC_NOTIFIER_HEAD(ppr_notifier);
 int amd_iommu_max_glx_val = -1;
 
+static struct dma_map_ops amd_iommu_dma_ops;
+
 /*
  * general struct to manage commands send to an IOMMU
  */
@@ -402,7 +404,7 @@ static void amd_iommu_stats_init(void)
                 return;
 
         de_fflush  = debugfs_create_bool("fullflush", 0444, stats_dir,
-                                         (u32 *)&amd_iommu_unmap_flush);
+                                         &amd_iommu_unmap_flush);
 
         amd_iommu_stats_add(&compl_wait);
         amd_iommu_stats_add(&cnt_map_single);
@@ -2267,6 +2269,13 @@ static int device_change_notifier(struct notifier_block *nb,
                 list_add_tail(&dma_domain->list, &iommu_pd_list);
                 spin_unlock_irqrestore(&iommu_pd_list_lock, flags);
 
+                dev_data = get_dev_data(dev);
+
+                if (!dev_data->passthrough)
+                        dev->archdata.dma_ops = &amd_iommu_dma_ops;
+                else
+                        dev->archdata.dma_ops = &nommu_dma_ops;
+
                 break;
         case BUS_NOTIFY_DEL_DEVICE:
 
diff --git a/drivers/iommu/amd_iommu_init.c b/drivers/iommu/amd_iommu_init.c
index 542024ba6dba..a33612f3206f 100644
--- a/drivers/iommu/amd_iommu_init.c
+++ b/drivers/iommu/amd_iommu_init.c
@@ -129,7 +129,7 @@ u16 amd_iommu_last_bdf;			/* largest PCI device id we have
                                            to handle */
 LIST_HEAD(amd_iommu_unity_map);         /* a list of required unity mappings
                                            we find in ACPI */
-bool amd_iommu_unmap_flush;             /* if true, flush on every unmap */
+u32 amd_iommu_unmap_flush;              /* if true, flush on every unmap */
 
 LIST_HEAD(amd_iommu_list);              /* list of all AMD IOMMUs in the
                                            system */
@@ -1641,6 +1641,8 @@ static int __init amd_iommu_init(void)
 
         amd_iommu_init_api();
 
+        x86_platform.iommu_shutdown = disable_iommus;
+
         if (iommu_pass_through)
                 goto out;
 
@@ -1649,8 +1651,6 @@ static int __init amd_iommu_init(void)
         else
                 printk(KERN_INFO "AMD-Vi: Lazy IO/TLB flushing enabled\n");
 
-        x86_platform.iommu_shutdown = disable_iommus;
-
 out:
         return ret;
 
diff --git a/drivers/iommu/amd_iommu_types.h b/drivers/iommu/amd_iommu_types.h
index 24355559a2ad..c1b1d489817e 100644
--- a/drivers/iommu/amd_iommu_types.h
+++ b/drivers/iommu/amd_iommu_types.h
@@ -652,7 +652,7 @@ extern unsigned long *amd_iommu_pd_alloc_bitmap;
  * If true, the addresses will be flushed on unmap time, not when
  * they are reused
  */
-extern bool amd_iommu_unmap_flush;
+extern u32 amd_iommu_unmap_flush;
 
 /* Smallest number of PASIDs supported by any IOMMU in the system */
 extern u32 amd_iommu_max_pasids;
diff --git a/drivers/iommu/tegra-smmu.c b/drivers/iommu/tegra-smmu.c
index ecd679043d77..3f3d09d560ea 100644
--- a/drivers/iommu/tegra-smmu.c
+++ b/drivers/iommu/tegra-smmu.c
@@ -550,13 +550,13 @@ static int alloc_pdir(struct smmu_as *as)
                 return 0;
 
         as->pte_count = devm_kzalloc(smmu->dev,
-                     sizeof(as->pte_count[0]) * SMMU_PDIR_COUNT, GFP_KERNEL);
+                     sizeof(as->pte_count[0]) * SMMU_PDIR_COUNT, GFP_ATOMIC);
         if (!as->pte_count) {
                 dev_err(smmu->dev,
                         "failed to allocate smmu_device PTE cunters\n");
                 return -ENOMEM;
         }
-        as->pdir_page = alloc_page(GFP_KERNEL | __GFP_DMA);
+        as->pdir_page = alloc_page(GFP_ATOMIC | __GFP_DMA);
         if (!as->pdir_page) {
                 dev_err(smmu->dev,
                         "failed to allocate smmu_device page directory\n");
diff --git a/drivers/leds/ledtrig-heartbeat.c b/drivers/leds/ledtrig-heartbeat.c
index 41dc76db4311..a019fbb70880 100644
--- a/drivers/leds/ledtrig-heartbeat.c
+++ b/drivers/leds/ledtrig-heartbeat.c
@@ -21,6 +21,8 @@
 #include <linux/reboot.h>
 #include "leds.h"
 
+static int panic_heartbeats;
+
 struct heartbeat_trig_data {
         unsigned int phase;
         unsigned int period;
@@ -34,6 +36,11 @@ static void led_heartbeat_function(unsigned long data)
         unsigned long brightness = LED_OFF;
         unsigned long delay = 0;
 
+        if (unlikely(panic_heartbeats)) {
+                led_set_brightness(led_cdev, LED_OFF);
+                return;
+        }
+
         /* acts like an actual heart beat -- ie thump-thump-pause... */
         switch (heartbeat_data->phase) {
         case 0:
@@ -111,12 +118,19 @@ static int heartbeat_reboot_notifier(struct notifier_block *nb,
         return NOTIFY_DONE;
 }
 
+static int heartbeat_panic_notifier(struct notifier_block *nb,
+                                     unsigned long code, void *unused)
+{
+        panic_heartbeats = 1;
+        return NOTIFY_DONE;
+}
+
 static struct notifier_block heartbeat_reboot_nb = {
         .notifier_call = heartbeat_reboot_notifier,
 };
 
 static struct notifier_block heartbeat_panic_nb = {
-        .notifier_call = heartbeat_reboot_notifier,
+        .notifier_call = heartbeat_panic_notifier,
 };
 
 static int __init heartbeat_trig_init(void)
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index 37fdaf81bd1f..ce59824fb414 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -2292,6 +2292,13 @@ static int process_reserve_metadata_snap_mesg(unsigned argc, char **argv, struct
         if (r)
                 return r;
 
+        r = dm_pool_commit_metadata(pool->pmd);
+        if (r) {
+                DMERR("%s: dm_pool_commit_metadata() failed, error = %d",
+                      __func__, r);
+                return r;
+        }
+
         r = dm_pool_reserve_metadata_snap(pool->pmd);
         if (r)
                 DMWARN("reserve_metadata_snap message failed.");
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 1c2f9048e1ae..a4c219e3c859 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -5784,8 +5784,7 @@ static int add_new_disk(struct mddev * mddev, mdu_disk_info_t *info)
                         super_types[mddev->major_version].
                                 validate_super(mddev, rdev);
                 if ((info->state & (1<<MD_DISK_SYNC)) &&
-                    (!test_bit(In_sync, &rdev->flags) ||
-                     rdev->raid_disk != info->raid_disk)) {
+                     rdev->raid_disk != info->raid_disk) {
                         /* This was a hot-add request, but events doesn't
                          * match, so reject it.
                          */
@@ -6751,7 +6750,7 @@ struct md_thread *md_register_thread(void (*run) (struct mddev *), struct mddev
         thread->tsk = kthread_run(md_thread, thread,
                                   "%s_%s",
                                   mdname(thread->mddev),
-                                  name ?: mddev->pers->name);
+                                  name);
         if (IS_ERR(thread->tsk)) {
                 kfree(thread);
                 return NULL;
@@ -7298,6 +7297,7 @@ void md_do_sync(struct mddev *mddev)
         int skipped = 0;
         struct md_rdev *rdev;
         char *desc;
+        struct blk_plug plug;
 
         /* just incase thread restarts... */
         if (test_bit(MD_RECOVERY_DONE, &mddev->recovery))
@@ -7447,6 +7447,7 @@ void md_do_sync(struct mddev *mddev)
         }
         mddev->curr_resync_completed = j;
 
+        blk_start_plug(&plug);
         while (j < max_sectors) {
                 sector_t sectors;
 
@@ -7552,6 +7553,7 @@ void md_do_sync(struct mddev *mddev)
          * this also signals 'finished resyncing' to md_stop
          */
  out:
+        blk_finish_plug(&plug);
         wait_event(mddev->recovery_wait, !atomic_read(&mddev->recovery_active));
 
         /* tell personality that we are finished */
diff --git a/drivers/md/multipath.c b/drivers/md/multipath.c
index 9339e67fcc79..61a1833ebaf3 100644
--- a/drivers/md/multipath.c
+++ b/drivers/md/multipath.c
@@ -474,7 +474,8 @@ static int multipath_run (struct mddev *mddev)
         }
 
         {
-                mddev->thread = md_register_thread(multipathd, mddev, NULL);
+                mddev->thread = md_register_thread(multipathd, mddev,
+                                                   "multipath");
                 if (!mddev->thread) {
                         printk(KERN_ERR "multipath: couldn't allocate thread"
                                 " for %s\n", mdname(mddev));
diff --git a/drivers/md/persistent-data/dm-space-map-checker.c b/drivers/md/persistent-data/dm-space-map-checker.c
index 50ed53bf4aa2..fc90c11620ad 100644
--- a/drivers/md/persistent-data/dm-space-map-checker.c
+++ b/drivers/md/persistent-data/dm-space-map-checker.c
@@ -8,6 +8,7 @@
 
 #include <linux/device-mapper.h>
 #include <linux/export.h>
+#include <linux/vmalloc.h>
 
 #ifdef CONFIG_DM_DEBUG_SPACE_MAPS
 
@@ -89,13 +90,23 @@ static int ca_create(struct count_array *ca, struct dm_space_map *sm)
 
         ca->nr = nr_blocks;
         ca->nr_free = nr_blocks;
-        ca->counts = kzalloc(sizeof(*ca->counts) * nr_blocks, GFP_KERNEL);
-        if (!ca->counts)
-                return -ENOMEM;
+
+        if (!nr_blocks)
+                ca->counts = NULL;
+        else {
+                ca->counts = vzalloc(sizeof(*ca->counts) * nr_blocks);
+                if (!ca->counts)
+                        return -ENOMEM;
+        }
 
         return 0;
 }
 
+static void ca_destroy(struct count_array *ca)
+{
+        vfree(ca->counts);
+}
+
 static int ca_load(struct count_array *ca, struct dm_space_map *sm)
 {
         int r;
@@ -126,12 +137,14 @@ static int ca_load(struct count_array *ca, struct dm_space_map *sm)
 static int ca_extend(struct count_array *ca, dm_block_t extra_blocks)
 {
         dm_block_t nr_blocks = ca->nr + extra_blocks;
-        uint32_t *counts = kzalloc(sizeof(*counts) * nr_blocks, GFP_KERNEL);
+        uint32_t *counts = vzalloc(sizeof(*counts) * nr_blocks);
         if (!counts)
                 return -ENOMEM;
 
-        memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
-        kfree(ca->counts);
+        if (ca->counts) {
+                memcpy(counts, ca->counts, sizeof(*counts) * ca->nr);
+                ca_destroy(ca);
+        }
         ca->nr = nr_blocks;
         ca->nr_free += extra_blocks;
         ca->counts = counts;
@@ -151,11 +164,6 @@ static int ca_commit(struct count_array *old, struct count_array *new)
         return 0;
 }
 
-static void ca_destroy(struct count_array *ca)
-{
-        kfree(ca->counts);
-}
-
 /*----------------------------------------------------------------*/
 
 struct sm_checker {
@@ -343,25 +351,25 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
         int r;
         struct sm_checker *smc;
 
-        if (!sm)
-                return NULL;
+        if (IS_ERR_OR_NULL(sm))
+                return ERR_PTR(-EINVAL);
 
         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
         if (!smc)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
         r = ca_create(&smc->old_counts, sm);
         if (r) {
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_create(&smc->counts, sm);
         if (r) {
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         smc->real_sm = sm;
@@ -371,7 +379,7 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
                 ca_destroy(&smc->counts);
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_commit(&smc->old_counts, &smc->counts);
@@ -379,7 +387,7 @@ struct dm_space_map *dm_sm_checker_create(struct dm_space_map *sm)
                 ca_destroy(&smc->counts);
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         return &smc->sm;
@@ -391,25 +399,25 @@ struct dm_space_map *dm_sm_checker_create_fresh(struct dm_space_map *sm)
         int r;
         struct sm_checker *smc;
 
-        if (!sm)
-                return NULL;
+        if (IS_ERR_OR_NULL(sm))
+                return ERR_PTR(-EINVAL);
 
         smc = kmalloc(sizeof(*smc), GFP_KERNEL);
         if (!smc)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         memcpy(&smc->sm, &ops_, sizeof(smc->sm));
         r = ca_create(&smc->old_counts, sm);
         if (r) {
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         r = ca_create(&smc->counts, sm);
         if (r) {
                 ca_destroy(&smc->old_counts);
                 kfree(smc);
-                return NULL;
+                return ERR_PTR(r);
         }
 
         smc->real_sm = sm;
diff --git a/drivers/md/persistent-data/dm-space-map-disk.c b/drivers/md/persistent-data/dm-space-map-disk.c
index fc469ba9f627..3d0ed5332883 100644
--- a/drivers/md/persistent-data/dm-space-map-disk.c
+++ b/drivers/md/persistent-data/dm-space-map-disk.c
@@ -290,7 +290,16 @@ struct dm_space_map *dm_sm_disk_create(struct dm_transaction_manager *tm,
                                        dm_block_t nr_blocks)
 {
         struct dm_space_map *sm = dm_sm_disk_create_real(tm, nr_blocks);
-        return dm_sm_checker_create_fresh(sm);
+        struct dm_space_map *smc;
+
+        if (IS_ERR_OR_NULL(sm))
+                return sm;
+
+        smc = dm_sm_checker_create_fresh(sm);
+        if (IS_ERR(smc))
+                dm_sm_destroy(sm);
+
+        return smc;
 }
 EXPORT_SYMBOL_GPL(dm_sm_disk_create);
 
diff --git a/drivers/md/persistent-data/dm-transaction-manager.c b/drivers/md/persistent-data/dm-transaction-manager.c
index 400fe144c0cd..e5604b32d91f 100644
--- a/drivers/md/persistent-data/dm-transaction-manager.c
+++ b/drivers/md/persistent-data/dm-transaction-manager.c
@@ -138,6 +138,9 @@ EXPORT_SYMBOL_GPL(dm_tm_create_non_blocking_clone);
 
 void dm_tm_destroy(struct dm_transaction_manager *tm)
 {
+        if (!tm->is_clone)
+                wipe_shadow_table(tm);
+
         kfree(tm);
 }
 EXPORT_SYMBOL_GPL(dm_tm_destroy);
@@ -344,8 +347,10 @@ static int dm_tm_create_internal(struct dm_block_manager *bm,
                 }
 
                 *sm = dm_sm_checker_create(inner);
-                if (!*sm)
+                if (IS_ERR(*sm)) {
+                        r = PTR_ERR(*sm);
                         goto bad2;
+                }
 
         } else {
                 r = dm_bm_write_lock(dm_tm_get_bm(*tm), sb_location,
@@ -364,8 +369,10 @@ static int dm_tm_create_internal(struct dm_block_manager *bm,
                 }
 
                 *sm = dm_sm_checker_create(inner);
-                if (!*sm)
+                if (IS_ERR(*sm)) {
+                        r = PTR_ERR(*sm);
                         goto bad2;
+                }
         }
 
         return 0;
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index a9c7981ddd24..240ff3125040 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -517,8 +517,8 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                 int bad_sectors;
 
                 int disk = start_disk + i;
-                if (disk >= conf->raid_disks)
-                        disk -= conf->raid_disks;
+                if (disk >= conf->raid_disks * 2)
+                        disk -= conf->raid_disks * 2;
 
                 rdev = rcu_dereference(conf->mirrors[disk].rdev);
                 if (r1_bio->bios[disk] == IO_BLOCKED
@@ -883,7 +883,6 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         const unsigned long do_sync = (bio->bi_rw & REQ_SYNC);
         const unsigned long do_flush_fua = (bio->bi_rw & (REQ_FLUSH | REQ_FUA));
         struct md_rdev *blocked_rdev;
-        int plugged;
         int first_clone;
         int sectors_handled;
         int max_sectors;
@@ -1034,7 +1033,6 @@ read_again:
          * the bad blocks.  Each set of writes gets it's own r1bio
          * with a set of bios attached.
          */
-        plugged = mddev_check_plugged(mddev);
 
         disks = conf->raid_disks * 2;
  retry_write:
@@ -1191,6 +1189,8 @@ read_again:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
         }
         /* Mustn't call r1_bio_write_done before this next test,
          * as it could result in the bio being freed.
@@ -1213,9 +1213,6 @@ read_again:
 
         /* In case raid1d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
-
-        if (do_sync || !bitmap || !plugged)
-                md_wakeup_thread(mddev->thread);
 }
 
 static void status(struct seq_file *seq, struct mddev *mddev)
@@ -2488,9 +2485,10 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr, int *skipp
          */
         if (test_bit(MD_RECOVERY_REQUESTED, &mddev->recovery)) {
                 atomic_set(&r1_bio->remaining, read_targets);
-                for (i = 0; i < conf->raid_disks * 2; i++) {
+                for (i = 0; i < conf->raid_disks * 2 && read_targets; i++) {
                         bio = r1_bio->bios[i];
                         if (bio->bi_end_io == end_sync_read) {
+                                read_targets--;
                                 md_sync_acct(bio->bi_bdev, nr_sectors);
                                 generic_make_request(bio);
                         }
@@ -2621,7 +2619,7 @@ static struct r1conf *setup_conf(struct mddev *mddev)
                 goto abort;
         }
         err = -ENOMEM;
-        conf->thread = md_register_thread(raid1d, mddev, NULL);
+        conf->thread = md_register_thread(raid1d, mddev, "raid1");
         if (!conf->thread) {
                 printk(KERN_ERR
                        "md/raid1:%s: couldn't allocate thread\n",
diff --git a/drivers/md/raid10.c b/drivers/md/raid10.c
index 99ae6068e456..8da6282254c3 100644
--- a/drivers/md/raid10.c
+++ b/drivers/md/raid10.c
@@ -1039,7 +1039,6 @@ static void make_request(struct mddev *mddev, struct bio * bio)
         const unsigned long do_fua = (bio->bi_rw & REQ_FUA);
         unsigned long flags;
         struct md_rdev *blocked_rdev;
-        int plugged;
         int sectors_handled;
         int max_sectors;
         int sectors;
@@ -1239,7 +1238,6 @@ read_again:
          * of r10_bios is recored in bio->bi_phys_segments just as with
          * the read case.
          */
-        plugged = mddev_check_plugged(mddev);
 
         r10_bio->read_slot = -1; /* make sure repl_bio gets freed */
         raid10_find_phys(conf, r10_bio);
@@ -1396,6 +1394,8 @@ retry_write:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
 
                 if (!r10_bio->devs[i].repl_bio)
                         continue;
@@ -1423,6 +1423,8 @@ retry_write:
                 bio_list_add(&conf->pending_bio_list, mbio);
                 conf->pending_count++;
                 spin_unlock_irqrestore(&conf->device_lock, flags);
+                if (!mddev_check_plugged(mddev))
+                        md_wakeup_thread(mddev->thread);
         }
 
         /* Don't remove the bias on 'remaining' (one_write_done) until
@@ -1448,9 +1450,6 @@ retry_write:
 
         /* In case raid10d snuck in to freeze_array */
         wake_up(&conf->wait_barrier);
-
-        if (do_sync || !mddev->bitmap || !plugged)
-                md_wakeup_thread(mddev->thread);
 }
 
 static void status(struct seq_file *seq, struct mddev *mddev)
@@ -2310,7 +2309,7 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
                         if (r10_sync_page_io(rdev,
                                              r10_bio->devs[sl].addr +
                                              sect,
-                                             s<<9, conf->tmppage, WRITE)
+                                             s, conf->tmppage, WRITE)
                             == 0) {
                                 /* Well, this device is dead */
                                 printk(KERN_NOTICE
@@ -2349,7 +2348,7 @@ static void fix_read_error(struct r10conf *conf, struct mddev *mddev, struct r10
                         switch (r10_sync_page_io(rdev,
                                              r10_bio->devs[sl].addr +
                                              sect,
-                                             s<<9, conf->tmppage,
+                                             s, conf->tmppage,
                                                  READ)) {
                         case 0:
                                 /* Well, this device is dead */
@@ -2512,7 +2511,7 @@ read_more:
         slot = r10_bio->read_slot;
         printk_ratelimited(
                 KERN_ERR
-                "md/raid10:%s: %s: redirecting"
+                "md/raid10:%s: %s: redirecting "
                 "sector %llu to another mirror\n",
                 mdname(mddev),
                 bdevname(rdev->bdev, b),
@@ -2661,7 +2660,8 @@ static void raid10d(struct mddev *mddev)
         blk_start_plug(&plug);
         for (;;) {
 
-                flush_pending_writes(conf);
+                if (atomic_read(&mddev->plug_cnt) == 0)
+                        flush_pending_writes(conf);
 
                 spin_lock_irqsave(&conf->device_lock, flags);
                 if (list_empty(head)) {
@@ -2890,6 +2890,12 @@ static sector_t sync_request(struct mddev *mddev, sector_t sector_nr,
                         /* want to reconstruct this device */
                         rb2 = r10_bio;
                         sect = raid10_find_virt(conf, sector_nr, i);
+                        if (sect >= mddev->resync_max_sectors) {
+                                /* last stripe is not complete - don't
+                                 * try to recover this sector.
+                                 */
+                                continue;
+                        }
                         /* Unless we are doing a full sync, or a replacement
                          * we only need to recover the block if it is set in
                          * the bitmap
@@ -3421,7 +3427,7 @@ static struct r10conf *setup_conf(struct mddev *mddev)
         spin_lock_init(&conf->resync_lock);
         init_waitqueue_head(&conf->wait_barrier);
 
-        conf->thread = md_register_thread(raid10d, mddev, NULL);
+        conf->thread = md_register_thread(raid10d, mddev, "raid10");
         if (!conf->thread)
                 goto out;
 
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index d26767246d26..04348d76bb30 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -196,12 +196,14 @@ static void __release_stripe(struct r5conf *conf, struct stripe_head *sh)
                 BUG_ON(!list_empty(&sh->lru));
                 BUG_ON(atomic_read(&conf->active_stripes)==0);
                 if (test_bit(STRIPE_HANDLE, &sh->state)) {
-                        if (test_bit(STRIPE_DELAYED, &sh->state))
+                        if (test_bit(STRIPE_DELAYED, &sh->state) &&
+                            !test_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
                                 list_add_tail(&sh->lru, &conf->delayed_list);
                         else if (test_bit(STRIPE_BIT_DELAY, &sh->state) &&
                                    sh->bm_seq - conf->seq_write > 0)
                                 list_add_tail(&sh->lru, &conf->bitmap_list);
                         else {
+                                clear_bit(STRIPE_DELAYED, &sh->state);
                                 clear_bit(STRIPE_BIT_DELAY, &sh->state);
                                 list_add_tail(&sh->lru, &conf->handle_list);
                         }
@@ -606,6 +608,12 @@ static void ops_run_io(struct stripe_head *sh, struct stripe_head_state *s)
                                          * a chance*/
                                         md_check_recovery(conf->mddev);
                                 }
+                                /*
+                                 * Because md_wait_for_blocked_rdev
+                                 * will dec nr_pending, we must
+                                 * increment it first.
+                                 */
+                                atomic_inc(&rdev->nr_pending);
                                 md_wait_for_blocked_rdev(rdev, conf->mddev);
                         } else {
                                 /* Acknowledged bad block - skip the write */
@@ -1737,6 +1745,7 @@ static void raid5_end_read_request(struct bio * bi, int error)
         } else {
                 const char *bdn = bdevname(rdev->bdev, b);
                 int retry = 0;
+                int set_bad = 0;
 
                 clear_bit(R5_UPTODATE, &sh->dev[i].flags);
                 atomic_inc(&rdev->read_errors);
@@ -1748,7 +1757,8 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (conf->mddev->degraded >= conf->max_degraded)
+                else if (conf->mddev->degraded >= conf->max_degraded) {
+                        set_bad = 1;
                         printk_ratelimited(
                                 KERN_WARNING
                                 "md/raid:%s: read error not correctable "
@@ -1756,8 +1766,9 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (test_bit(R5_ReWrite, &sh->dev[i].flags))
+                } else if (test_bit(R5_ReWrite, &sh->dev[i].flags)) {
                         /* Oh, no!!! */
+                        set_bad = 1;
                         printk_ratelimited(
                                 KERN_WARNING
                                 "md/raid:%s: read error NOT corrected!! "
@@ -1765,7 +1776,7 @@ static void raid5_end_read_request(struct bio * bi, int error)
                                 mdname(conf->mddev),
                                 (unsigned long long)s,
                                 bdn);
-                else if (atomic_read(&rdev->read_errors)
+                } else if (atomic_read(&rdev->read_errors)
                          > conf->max_nr_stripes)
                         printk(KERN_WARNING
                                "md/raid:%s: Too many read errors, failing device %s.\n",
@@ -1777,7 +1788,11 @@ static void raid5_end_read_request(struct bio * bi, int error)
                 else {
                         clear_bit(R5_ReadError, &sh->dev[i].flags);
                         clear_bit(R5_ReWrite, &sh->dev[i].flags);
-                        md_error(conf->mddev, rdev);
+                        if (!(set_bad
+                              && test_bit(In_sync, &rdev->flags)
+                              && rdev_set_badblocks(
+                                      rdev, sh->sector, STRIPE_SECTORS, 0)))
+                                md_error(conf->mddev, rdev);
                 }
         }
         rdev_dec_pending(rdev, conf->mddev);
@@ -3582,8 +3597,18 @@ static void handle_stripe(struct stripe_head *sh)
 
 finish:
         /* wait for this device to become unblocked */
-        if (conf->mddev->external && unlikely(s.blocked_rdev))
-                md_wait_for_blocked_rdev(s.blocked_rdev, conf->mddev);
+        if (unlikely(s.blocked_rdev)) {
+                if (conf->mddev->external)
+                        md_wait_for_blocked_rdev(s.blocked_rdev,
+                                                 conf->mddev);
+                else
+                        /* Internal metadata will immediately
+                         * be written by raid5d, so we don't
+                         * need to wait here.
+                         */
+                        rdev_dec_pending(s.blocked_rdev,
+                                         conf->mddev);
+        }
 
         if (s.handle_bad_blocks)
                 for (i = disks; i--; ) {
@@ -3881,8 +3906,6 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                 raid_bio->bi_next = (void*)rdev;
                 align_bi->bi_bdev =  rdev->bdev;
                 align_bi->bi_flags &= ~(1 << BIO_SEG_VALID);
-                /* No reshape active, so we can trust rdev->data_offset */
-                align_bi->bi_sector += rdev->data_offset;
 
                 if (!bio_fits_rdev(align_bi) ||
                     is_badblock(rdev, align_bi->bi_sector, align_bi->bi_size>>9,
@@ -3893,6 +3916,9 @@ static int chunk_aligned_read(struct mddev *mddev, struct bio * raid_bio)
                         return 0;
                 }
 
+                /* No reshape active, so we can trust rdev->data_offset */
+                align_bi->bi_sector += rdev->data_offset;
+
                 spin_lock_irq(&conf->device_lock);
                 wait_event_lock_irq(conf->wait_for_stripe,
                                     conf->quiesce == 0,
@@ -3971,7 +3997,6 @@ static void make_request(struct mddev *mddev, struct bio * bi)
         struct stripe_head *sh;
         const int rw = bio_data_dir(bi);
         int remaining;
-        int plugged;
 
         if (unlikely(bi->bi_rw & REQ_FLUSH)) {
                 md_flush_request(mddev, bi);
@@ -3990,7 +4015,6 @@ static void make_request(struct mddev *mddev, struct bio * bi)
         bi->bi_next = NULL;
         bi->bi_phys_segments = 1;       /* over-loaded to count active stripes */
 
-        plugged = mddev_check_plugged(mddev);
         for (;logical_sector < last_sector; logical_sector += STRIPE_SECTORS) {
                 DEFINE_WAIT(w);
                 int previous;
@@ -4092,6 +4116,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
                         if ((bi->bi_rw & REQ_SYNC) &&
                             !test_and_set_bit(STRIPE_PREREAD_ACTIVE, &sh->state))
                                 atomic_inc(&conf->preread_active_stripes);
+                        mddev_check_plugged(mddev);
                         release_stripe(sh);
                 } else {
                         /* cannot get stripe for read-ahead, just give-up */
@@ -4099,10 +4124,7 @@ static void make_request(struct mddev *mddev, struct bio * bi)
                         finish_wait(&conf->wait_for_overlap, &w);
                         break;
                 }
-                        
         }
-        if (!plugged)
-                md_wakeup_thread(mddev->thread);
 
         spin_lock_irq(&conf->device_lock);
         remaining = raid5_dec_bi_phys_segments(bi);
@@ -4823,6 +4845,7 @@ static struct r5conf *setup_conf(struct mddev *mddev)
         int raid_disk, memory, max_disks;
         struct md_rdev *rdev;
         struct disk_info *disk;
+        char pers_name[6];
 
         if (mddev->new_level != 5
             && mddev->new_level != 4
@@ -4946,7 +4969,8 @@ static struct r5conf *setup_conf(struct mddev *mddev)
                 printk(KERN_INFO "md/raid:%s: allocated %dkB\n",
                        mdname(mddev), memory);
 
-        conf->thread = md_register_thread(raid5d, mddev, NULL);
+        sprintf(pers_name, "raid%d", mddev->new_level);
+        conf->thread = md_register_thread(raid5d, mddev, pers_name);
         if (!conf->thread) {
                 printk(KERN_ERR
                        "md/raid:%s: couldn't allocate thread.\n",
@@ -5465,10 +5489,9 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
         if (rdev->saved_raid_disk >= 0 &&
             rdev->saved_raid_disk >= first &&
             conf->disks[rdev->saved_raid_disk].rdev == NULL)
-                disk = rdev->saved_raid_disk;
-        else
-                disk = first;
-        for ( ; disk <= last ; disk++) {
+                first = rdev->saved_raid_disk;
+
+        for (disk = first; disk <= last; disk++) {
                 p = conf->disks + disk;
                 if (p->rdev == NULL) {
                         clear_bit(In_sync, &rdev->flags);
@@ -5477,8 +5500,11 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                         if (rdev->saved_raid_disk != disk)
                                 conf->fullsync = 1;
                         rcu_assign_pointer(p->rdev, rdev);
-                        break;
+                        goto out;
                 }
+        }
+        for (disk = first; disk <= last; disk++) {
+                p = conf->disks + disk;
                 if (test_bit(WantReplacement, &p->rdev->flags) &&
                     p->replacement == NULL) {
                         clear_bit(In_sync, &rdev->flags);
@@ -5490,6 +5516,7 @@ static int raid5_add_disk(struct mddev *mddev, struct md_rdev *rdev)
                         break;
                 }
         }
+out:
         print_raid5_conf(conf);
         return err;
 }
diff --git a/drivers/media/dvb/dvb-core/dvbdev.c b/drivers/media/dvb/dvb-core/dvbdev.c
index 00a67326c193..39eab73b01ae 100644
--- a/drivers/media/dvb/dvb-core/dvbdev.c
+++ b/drivers/media/dvb/dvb-core/dvbdev.c
@@ -243,6 +243,7 @@ int dvb_register_device(struct dvb_adapter *adap, struct dvb_device **pdvbdev,
         if (minor == MAX_DVB_MINORS) {
                 kfree(dvbdevfops);
                 kfree(dvbdev);
+                up_write(&minor_rwsem);
                 mutex_unlock(&dvbdev_register_lock);
                 return -EINVAL;
         }
diff --git a/drivers/media/rc/winbond-cir.c b/drivers/media/rc/winbond-cir.c
index 342c2c8c1ddf..54ee34872d14 100644
--- a/drivers/media/rc/winbond-cir.c
+++ b/drivers/media/rc/winbond-cir.c
@@ -232,7 +232,7 @@ MODULE_PARM_DESC(invert, "Invert the signal from the IR receiver");
 
 static bool txandrx; /* default = 0 */
 module_param(txandrx, bool, 0444);
-MODULE_PARM_DESC(invert, "Allow simultaneous TX and RX");
+MODULE_PARM_DESC(txandrx, "Allow simultaneous TX and RX");
 
 static unsigned int wake_sc = 0x800F040C;
 module_param(wake_sc, uint, 0644);
@@ -1032,6 +1032,8 @@ wbcir_probe(struct pnp_dev *device, const struct pnp_device_id *dev_id)
         data->dev->tx_ir = wbcir_tx;
         data->dev->priv = data;
         data->dev->dev.parent = &device->dev;
+        data->dev->timeout = MS_TO_NS(100);
+        data->dev->allowed_protos = RC_TYPE_ALL;
 
         if (!request_region(data->wbase, WAKEUP_IOMEM_LEN, DRVNAME)) {
                 dev_err(dev, "Region 0x%lx-0x%lx already in use!\n",
diff --git a/drivers/media/video/cx231xx/cx231xx-audio.c b/drivers/media/video/cx231xx/cx231xx-audio.c
index 068f78dc5d13..b4c99c7270cf 100644
--- a/drivers/media/video/cx231xx/cx231xx-audio.c
+++ b/drivers/media/video/cx231xx/cx231xx-audio.c
@@ -307,7 +307,7 @@ static int cx231xx_init_audio_isoc(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvisocpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = URB_ISO_ASAP;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->interval = 1;
                 urb->complete = cx231xx_audio_isocirq;
@@ -368,7 +368,7 @@ static int cx231xx_init_audio_bulk(struct cx231xx *dev)
                 urb->context = dev;
                 urb->pipe = usb_rcvbulkpipe(dev->udev,
                                                 dev->adev.end_point_addr);
-                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = 0;
                 urb->transfer_buffer = dev->adev.transfer_buffer[i];
                 urb->complete = cx231xx_audio_bulkirq;
                 urb->transfer_buffer_length = sb_size;
diff --git a/drivers/media/video/cx231xx/cx231xx-vbi.c b/drivers/media/video/cx231xx/cx231xx-vbi.c
index 3d15314e1f88..ac7db52f404f 100644
--- a/drivers/media/video/cx231xx/cx231xx-vbi.c
+++ b/drivers/media/video/cx231xx/cx231xx-vbi.c
@@ -448,7 +448,7 @@ int cx231xx_init_vbi_isoc(struct cx231xx *dev, int max_packets,
                         return -ENOMEM;
                 }
                 dev->vbi_mode.bulk_ctl.urb[i] = urb;
-                urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP;
+                urb->transfer_flags = 0;
 
                 dev->vbi_mode.bulk_ctl.transfer_buffer[i] =
                     kzalloc(sb_size, GFP_KERNEL);
diff --git a/drivers/media/video/cx23885/cx23885-cards.c b/drivers/media/video/cx23885/cx23885-cards.c
index 13739e002a63..080e11157e5f 100644
--- a/drivers/media/video/cx23885/cx23885-cards.c
+++ b/drivers/media/video/cx23885/cx23885-cards.c
@@ -127,22 +127,37 @@ struct cx23885_board cx23885_boards[] = {
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1250] = {
                 .name           = "Hauppauge WinTV-HVR1250",
+                .porta          = CX23885_ANALOG_VIDEO,
                 .portc          = CX23885_MPEG_DVB,
+#ifdef MT2131_NO_ANALOG_SUPPORT_YET
+                .tuner_type     = TUNER_PHILIPS_TDA8290,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .tuner_bus      = 1,
+#endif
+                .force_bff      = 1,
                 .input          = {{
+#ifdef MT2131_NO_ANALOG_SUPPORT_YET
                         .type   = CX23885_VMUX_TELEVISION,
-                        .vmux   = 0,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1,
+                        .amux   = CX25840_AUDIO8,
                         .gpio0  = 0xff00,
                 }, {
-                        .type   = CX23885_VMUX_DEBUG,
-                        .vmux   = 0,
-                        .gpio0  = 0xff01,
-                }, {
+#endif
                         .type   = CX23885_VMUX_COMPOSITE1,
-                        .vmux   = 1,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN6_CH1,
+                        .amux   = CX25840_AUDIO7,
                         .gpio0  = 0xff02,
                 }, {
                         .type   = CX23885_VMUX_SVIDEO,
-                        .vmux   = 2,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
                         .gpio0  = 0xff02,
                 } },
         },
@@ -267,7 +282,55 @@ struct cx23885_board cx23885_boards[] = {
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1255] = {
                 .name           = "Hauppauge WinTV-HVR1255",
+                .porta          = CX23885_ANALOG_VIDEO,
+                .portc          = CX23885_MPEG_DVB,
+                .tuner_type     = TUNER_ABSENT,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .force_bff      = 1,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1 |
+                                        CX25840_DIF_ON,
+                        .amux   = CX25840_AUDIO8,
+                }, {
+                        .type   = CX23885_VMUX_COMPOSITE1,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN6_CH1,
+                        .amux   = CX25840_AUDIO7,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
+                } },
+        },
+        [CX23885_BOARD_HAUPPAUGE_HVR1255_22111] = {
+                .name           = "Hauppauge WinTV-HVR1255",
+                .porta          = CX23885_ANALOG_VIDEO,
                 .portc          = CX23885_MPEG_DVB,
+                .tuner_type     = TUNER_ABSENT,
+                .tuner_addr     = 0x42, /* 0x84 >> 1 */
+                .force_bff      = 1,
+                .input          = {{
+                        .type   = CX23885_VMUX_TELEVISION,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN5_CH2 |
+                                        CX25840_VIN2_CH1 |
+                                        CX25840_DIF_ON,
+                        .amux   = CX25840_AUDIO8,
+                }, {
+                        .type   = CX23885_VMUX_SVIDEO,
+                        .vmux   =       CX25840_VIN7_CH3 |
+                                        CX25840_VIN4_CH2 |
+                                        CX25840_VIN8_CH1 |
+                                        CX25840_SVIDEO_ON,
+                        .amux   = CX25840_AUDIO7,
+                } },
         },
         [CX23885_BOARD_HAUPPAUGE_HVR1210] = {
                 .name           = "Hauppauge WinTV-HVR1210",
@@ -624,7 +687,7 @@ struct cx23885_subid cx23885_subids[] = {
         }, {
                 .subvendor = 0x0070,
                 .subdevice = 0x2259,
-                .card      = CX23885_BOARD_HAUPPAUGE_HVR1255,
+                .card      = CX23885_BOARD_HAUPPAUGE_HVR1255_22111,
         }, {
                 .subvendor = 0x0070,
                 .subdevice = 0x2291,
@@ -900,7 +963,7 @@ int cx23885_tuner_callback(void *priv, int component, int command, int arg)
         struct cx23885_dev *dev = port->dev;
         u32 bitmask = 0;
 
-        if (command == XC2028_RESET_CLK)
+        if ((command == XC2028_RESET_CLK) || (command == XC2028_I2C_FLUSH))
                 return 0;
 
         if (command != 0) {
@@ -1130,6 +1193,7 @@ void cx23885_gpio_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
                 /* GPIO-5 RF Control: 0 = RF1 Terrestrial, 1 = RF2 Cable */
                 /* GPIO-6 I2C Gate which can isolate the demod from the bus */
@@ -1267,6 +1331,7 @@ int cx23885_ir_init(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1400:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
                 /* FIXME: Implement me */
                 break;
@@ -1424,6 +1489,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
@@ -1511,6 +1577,7 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1275:
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1210:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
         case CX23885_BOARD_HAUPPAUGE_HVR1290:
@@ -1526,10 +1593,10 @@ void cx23885_card_setup(struct cx23885_dev *dev)
          */
         switch (dev->board) {
         case CX23885_BOARD_TEVII_S470:
-        case CX23885_BOARD_HAUPPAUGE_HVR1250:
                 /* Currently only enabled for the integrated IR controller */
                 if (!enable_885_ir)
                         break;
+        case CX23885_BOARD_HAUPPAUGE_HVR1250:
         case CX23885_BOARD_HAUPPAUGE_HVR1800:
         case CX23885_BOARD_HAUPPAUGE_HVR1800lp:
         case CX23885_BOARD_HAUPPAUGE_HVR1700:
@@ -1539,6 +1606,8 @@ void cx23885_card_setup(struct cx23885_dev *dev)
         case CX23885_BOARD_NETUP_DUAL_DVBS2_CI:
         case CX23885_BOARD_NETUP_DUAL_DVB_T_C_CI_RF:
         case CX23885_BOARD_COMPRO_VIDEOMATE_E800:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1270:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
         case CX23885_BOARD_MYGICA_X8506:
diff --git a/drivers/media/video/cx23885/cx23885-dvb.c b/drivers/media/video/cx23885/cx23885-dvb.c
index a80a92c47455..cd542684ba02 100644
--- a/drivers/media/video/cx23885/cx23885-dvb.c
+++ b/drivers/media/video/cx23885/cx23885-dvb.c
@@ -712,6 +712,7 @@ static int dvb_register(struct cx23885_tsport *port)
                 }
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
                 i2c_bus = &dev->i2c_bus[0];
                 fe0->dvb.frontend = dvb_attach(s5h1411_attach,
                                                &hcw_s5h1411_config,
@@ -721,6 +722,11 @@ static int dvb_register(struct cx23885_tsport *port)
                                    0x60, &dev->i2c_bus[1].i2c_adap,
                                    &hauppauge_tda18271_config);
                 }
+
+                tda18271_attach(&dev->ts1.analog_fe,
+                        0x60, &dev->i2c_bus[1].i2c_adap,
+                        &hauppauge_tda18271_config);
+
                 break;
         case CX23885_BOARD_HAUPPAUGE_HVR1800:
                 i2c_bus = &dev->i2c_bus[0];
diff --git a/drivers/media/video/cx23885/cx23885-video.c b/drivers/media/video/cx23885/cx23885-video.c
index c654bdc7ccb2..22f8e7fbd665 100644
--- a/drivers/media/video/cx23885/cx23885-video.c
+++ b/drivers/media/video/cx23885/cx23885-video.c
@@ -505,6 +505,9 @@ static int cx23885_video_mux(struct cx23885_dev *dev, unsigned int input)
 
         if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1800) ||
                 (dev->board == CX23885_BOARD_MPX885) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1250) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
+                (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111) ||
                 (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)) {
                 /* Configure audio routing */
                 v4l2_subdev_call(dev->sd_cx25840, audio, s_routing,
@@ -1578,7 +1581,9 @@ static int cx23885_set_freq_via_ops(struct cx23885_dev *dev,
 
         fe = vfe->dvb.frontend;
 
-        if (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850)
+        if ((dev->board == CX23885_BOARD_HAUPPAUGE_HVR1850) ||
+            (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255) ||
+            (dev->board == CX23885_BOARD_HAUPPAUGE_HVR1255_22111))
                 fe = &dev->ts1.analog_fe;
 
         if (fe && fe->ops.tuner_ops.set_analog_params) {
@@ -1608,6 +1613,8 @@ int cx23885_set_frequency(struct file *file, void *priv,
         int ret;
 
         switch (dev->board) {
+        case CX23885_BOARD_HAUPPAUGE_HVR1255:
+        case CX23885_BOARD_HAUPPAUGE_HVR1255_22111:
         case CX23885_BOARD_HAUPPAUGE_HVR1850:
                 ret = cx23885_set_freq_via_ops(dev, f);
                 break;
diff --git a/drivers/media/video/cx23885/cx23885.h b/drivers/media/video/cx23885/cx23885.h
index d884784a1c85..13c37ec07ae7 100644
--- a/drivers/media/video/cx23885/cx23885.h
+++ b/drivers/media/video/cx23885/cx23885.h
@@ -90,6 +90,7 @@
 #define CX23885_BOARD_MYGICA_X8507             33
 #define CX23885_BOARD_TERRATEC_CINERGY_T_PCIE_DUAL 34
 #define CX23885_BOARD_TEVII_S471               35
+#define CX23885_BOARD_HAUPPAUGE_HVR1255_22111  36
 
 #define GPIO_0 0x00000001
 #define GPIO_1 0x00000002
diff --git a/drivers/media/video/cx25840/cx25840-core.c b/drivers/media/video/cx25840/cx25840-core.c
index fc1ff69cffd0..d8eac3e30a7e 100644
--- a/drivers/media/video/cx25840/cx25840-core.c
+++ b/drivers/media/video/cx25840/cx25840-core.c
@@ -84,7 +84,7 @@ MODULE_PARM_DESC(debug, "Debugging messages [0=Off (default) 1=On]");
 
 
 /* ----------------------------------------------------------------------- */
-static void cx23885_std_setup(struct i2c_client *client);
+static void cx23888_std_setup(struct i2c_client *client);
 
 int cx25840_write(struct i2c_client *client, u16 addr, u8 value)
 {
@@ -638,10 +638,13 @@ static void cx23885_initialize(struct i2c_client *client)
         finish_wait(&state->fw_wait, &wait);
         destroy_workqueue(q);
 
-        /* Call the cx23885 specific std setup func, we no longer rely on
+        /* Call the cx23888 specific std setup func, we no longer rely on
          * the generic cx24840 func.
          */
-        cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
+        else
+                cx25840_std_setup(client);
 
         /* (re)set input */
         set_input(client, state->vid_input, state->aud_input);
@@ -1103,9 +1106,23 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
 
                         cx25840_write4(client, 0x410, 0xffff0dbf);
                         cx25840_write4(client, 0x414, 0x00137d03);
-                        cx25840_write4(client, 0x418, 0x01008080);
+
+                        /* on the 887, 0x418 is HSCALE_CTRL, on the 888 it is 
+                           CHROMA_CTRL */
+                        if (is_cx23888(state))
+                                cx25840_write4(client, 0x418, 0x01008080);
+                        else
+                                cx25840_write4(client, 0x418, 0x01000000);
+
                         cx25840_write4(client, 0x41c, 0x00000000);
-                        cx25840_write4(client, 0x420, 0x001c3e0f);
+
+                        /* on the 887, 0x420 is CHROMA_CTRL, on the 888 it is 
+                           CRUSH_CTRL */
+                        if (is_cx23888(state))
+                                cx25840_write4(client, 0x420, 0x001c3e0f);
+                        else
+                                cx25840_write4(client, 0x420, 0x001c8282);
+
                         cx25840_write4(client, 0x42c, 0x42600000);
                         cx25840_write4(client, 0x430, 0x0000039b);
                         cx25840_write4(client, 0x438, 0x00000000);
@@ -1233,7 +1250,7 @@ static int set_input(struct i2c_client *client, enum cx25840_video_input vid_inp
                 cx25840_write4(client, 0x8d0, 0x1f063870);
         }
 
-        if (is_cx2388x(state)) {
+        if (is_cx23888(state)) {
                 /* HVR1850 */
                 /* AUD_IO_CTRL - I2S Input, Parallel1*/
                 /*  - Channel 1 src - Parallel1 (Merlin out) */
@@ -1298,8 +1315,8 @@ static int set_v4lstd(struct i2c_client *client)
         }
         cx25840_and_or(client, 0x400, ~0xf, fmt);
         cx25840_and_or(client, 0x403, ~0x3, pal_m);
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
         else
                 cx25840_std_setup(client);
         if (!is_cx2583x(state))
@@ -1312,6 +1329,7 @@ static int set_v4lstd(struct i2c_client *client)
 static int cx25840_s_ctrl(struct v4l2_ctrl *ctrl)
 {
         struct v4l2_subdev *sd = to_sd(ctrl);
+        struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
         switch (ctrl->id) {
@@ -1324,12 +1342,20 @@ static int cx25840_s_ctrl(struct v4l2_ctrl *ctrl)
                 break;
 
         case V4L2_CID_SATURATION:
-                cx25840_write(client, 0x420, ctrl->val << 1);
-                cx25840_write(client, 0x421, ctrl->val << 1);
+                if (is_cx23888(state)) {
+                        cx25840_write(client, 0x418, ctrl->val << 1);
+                        cx25840_write(client, 0x419, ctrl->val << 1);
+                } else {
+                        cx25840_write(client, 0x420, ctrl->val << 1);
+                        cx25840_write(client, 0x421, ctrl->val << 1);
+                }
                 break;
 
         case V4L2_CID_HUE:
-                cx25840_write(client, 0x422, ctrl->val);
+                if (is_cx23888(state))
+                        cx25840_write(client, 0x41a, ctrl->val);
+                else
+                        cx25840_write(client, 0x422, ctrl->val);
                 break;
 
         default:
@@ -1354,11 +1380,21 @@ static int cx25840_s_mbus_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt
         fmt->field = V4L2_FIELD_INTERLACED;
         fmt->colorspace = V4L2_COLORSPACE_SMPTE170M;
 
-        Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
-        Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
+        if (is_cx23888(state)) {
+                Vsrc = (cx25840_read(client, 0x42a) & 0x3f) << 4;
+                Vsrc |= (cx25840_read(client, 0x429) & 0xf0) >> 4;
+        } else {
+                Vsrc = (cx25840_read(client, 0x476) & 0x3f) << 4;
+                Vsrc |= (cx25840_read(client, 0x475) & 0xf0) >> 4;
+        }
 
-        Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
-        Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
+        if (is_cx23888(state)) {
+                Hsrc = (cx25840_read(client, 0x426) & 0x3f) << 4;
+                Hsrc |= (cx25840_read(client, 0x425) & 0xf0) >> 4;
+        } else {
+                Hsrc = (cx25840_read(client, 0x472) & 0x3f) << 4;
+                Hsrc |= (cx25840_read(client, 0x471) & 0xf0) >> 4;
+        }
 
         Vlines = fmt->height + (is_50Hz ? 4 : 7);
 
@@ -1782,8 +1818,8 @@ static int cx25840_s_video_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
 
         return set_input(client, input, state->aud_input);
 }
@@ -1794,8 +1830,8 @@ static int cx25840_s_audio_routing(struct v4l2_subdev *sd,
         struct cx25840_state *state = to_state(sd);
         struct i2c_client *client = v4l2_get_subdevdata(sd);
 
-        if (is_cx2388x(state))
-                cx23885_std_setup(client);
+        if (is_cx23888(state))
+                cx23888_std_setup(client);
         return set_input(client, state->vid_input, input);
 }
 
@@ -4939,7 +4975,7 @@ void cx23885_dif_setup(struct i2c_client *client, u32 ifHz)
         }
 }
 
-static void cx23885_std_setup(struct i2c_client *client)
+static void cx23888_std_setup(struct i2c_client *client)
 {
         struct cx25840_state *state = to_state(i2c_get_clientdata(client));
         v4l2_std_id std = state->std;
diff --git a/drivers/media/video/em28xx/em28xx-cards.c b/drivers/media/video/em28xx/em28xx-cards.c
index 92da7c28b6f0..862c6575c557 100644
--- a/drivers/media/video/em28xx/em28xx-cards.c
+++ b/drivers/media/video/em28xx/em28xx-cards.c
@@ -2893,7 +2893,7 @@ static void request_module_async(struct work_struct *work)
 
         if (dev->board.has_dvb)
                 request_module("em28xx-dvb");
-        if (dev->board.has_ir_i2c && !disable_ir)
+        if (dev->board.ir_codes && !disable_ir)
                 request_module("em28xx-rc");
 }
 
diff --git a/drivers/media/video/gspca/sn9c20x.c b/drivers/media/video/gspca/sn9c20x.c
index 6c31e46a1fd2..b9c6f17eabb2 100644
--- a/drivers/media/video/gspca/sn9c20x.c
+++ b/drivers/media/video/gspca/sn9c20x.c
@@ -2070,10 +2070,13 @@ static int sd_start(struct gspca_dev *gspca_dev)
         set_gamma(gspca_dev, v4l2_ctrl_g_ctrl(sd->gamma));
         set_redblue(gspca_dev, v4l2_ctrl_g_ctrl(sd->blue),
                         v4l2_ctrl_g_ctrl(sd->red));
-        set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain));
-        set_exposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure));
-        set_hvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip),
-                        v4l2_ctrl_g_ctrl(sd->vflip));
+        if (sd->gain)
+                set_gain(gspca_dev, v4l2_ctrl_g_ctrl(sd->gain));
+        if (sd->exposure)
+                set_exposure(gspca_dev, v4l2_ctrl_g_ctrl(sd->exposure));
+        if (sd->hflip)
+                set_hvflip(gspca_dev, v4l2_ctrl_g_ctrl(sd->hflip),
+                                v4l2_ctrl_g_ctrl(sd->vflip));
 
         reg_w1(gspca_dev, 0x1007, 0x20);
         reg_w1(gspca_dev, 0x1061, 0x03);
@@ -2176,7 +2179,7 @@ static void sd_dqcallback(struct gspca_dev *gspca_dev)
         struct sd *sd = (struct sd *) gspca_dev;
         int avg_lum;
 
-        if (!v4l2_ctrl_g_ctrl(sd->autogain))
+        if (sd->autogain == NULL || !v4l2_ctrl_g_ctrl(sd->autogain))
                 return;
 
         avg_lum = atomic_read(&sd->avg_lum);
diff --git a/drivers/media/video/mx2_camera.c b/drivers/media/video/mx2_camera.c
index 41f9a254b245..637bde8aca28 100644
--- a/drivers/media/video/mx2_camera.c
+++ b/drivers/media/video/mx2_camera.c
@@ -83,6 +83,7 @@
 #define CSICR1_INV_DATA         (1 << 3)
 #define CSICR1_INV_PCLK         (1 << 2)
 #define CSICR1_REDGE            (1 << 1)
+#define CSICR1_FMT_MASK         (CSICR1_PACK_DIR | CSICR1_SWAP16_EN)
 
 #define SHIFT_STATFF_LEVEL      22
 #define SHIFT_RXFF_LEVEL        19
@@ -230,6 +231,7 @@ struct mx2_prp_cfg {
         u32 src_pixel;
         u32 ch1_pixel;
         u32 irq_flags;
+        u32 csicr1;
 };
 
 /* prp resizing parameters */
@@ -330,6 +332,7 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                         .ch1_pixel      = 0x2ca00565, /* RGB565 */
                         .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH1WERR |
                                                 PRP_INTR_CH1FC | PRP_INTR_LBOVF,
+                        .csicr1         = 0,
                 }
         },
         {
@@ -343,6 +346,21 @@ static struct mx2_fmt_cfg mx27_emma_prp_table[] = {
                         .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH2WERR |
                                         PRP_INTR_CH2FC | PRP_INTR_LBOVF |
                                         PRP_INTR_CH2OVF,
+                        .csicr1         = CSICR1_PACK_DIR,
+                }
+        },
+        {
+                .in_fmt         = V4L2_MBUS_FMT_UYVY8_2X8,
+                .out_fmt        = V4L2_PIX_FMT_YUV420,
+                .cfg            = {
+                        .channel        = 2,
+                        .in_fmt         = PRP_CNTL_DATA_IN_YUV422,
+                        .out_fmt        = PRP_CNTL_CH2_OUT_YUV420,
+                        .src_pixel      = 0x22000888, /* YUV422 (YUYV) */
+                        .irq_flags      = PRP_INTR_RDERR | PRP_INTR_CH2WERR |
+                                        PRP_INTR_CH2FC | PRP_INTR_LBOVF |
+                                        PRP_INTR_CH2OVF,
+                        .csicr1         = CSICR1_SWAP16_EN,
                 }
         },
 };
@@ -1015,14 +1033,14 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
                 return ret;
         }
 
+        csicr1 = (csicr1 & ~CSICR1_FMT_MASK) | pcdev->emma_prp->cfg.csicr1;
+
         if (common_flags & V4L2_MBUS_PCLK_SAMPLE_RISING)
                 csicr1 |= CSICR1_REDGE;
         if (common_flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH)
                 csicr1 |= CSICR1_SOF_POL;
         if (common_flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH)
                 csicr1 |= CSICR1_HSYNC_POL;
-        if (pcdev->platform_flags & MX2_CAMERA_SWAP16)
-                csicr1 |= CSICR1_SWAP16_EN;
         if (pcdev->platform_flags & MX2_CAMERA_EXT_VSYNC)
                 csicr1 |= CSICR1_EXT_VSYNC;
         if (pcdev->platform_flags & MX2_CAMERA_CCIR)
@@ -1033,8 +1051,6 @@ static int mx2_camera_set_bus_param(struct soc_camera_device *icd)
                 csicr1 |= CSICR1_GCLK_MODE;
         if (pcdev->platform_flags & MX2_CAMERA_INV_DATA)
                 csicr1 |= CSICR1_INV_DATA;
-        if (pcdev->platform_flags & MX2_CAMERA_PACK_DIR_MSB)
-                csicr1 |= CSICR1_PACK_DIR;
 
         pcdev->csicr1 = csicr1;
 
@@ -1109,7 +1125,8 @@ static int mx2_camera_get_formats(struct soc_camera_device *icd,
                 return 0;
         }
 
-        if (code == V4L2_MBUS_FMT_YUYV8_2X8) {
+        if (code == V4L2_MBUS_FMT_YUYV8_2X8 ||
+            code == V4L2_MBUS_FMT_UYVY8_2X8) {
                 formats++;
                 if (xlate) {
                         /*
diff --git a/drivers/media/video/omap3isp/isppreview.c b/drivers/media/video/omap3isp/isppreview.c
index 8a4935ecc655..dd91da26f1b0 100644
--- a/drivers/media/video/omap3isp/isppreview.c
+++ b/drivers/media/video/omap3isp/isppreview.c
@@ -888,12 +888,12 @@ static const struct preview_update update_attrs[] = {
                 preview_config_contrast,
                 NULL,
                 offsetof(struct prev_params, contrast),
-                0, true,
+                0, 0, true,
         }, /* OMAP3ISP_PREV_BRIGHTNESS */ {
                 preview_config_brightness,
                 NULL,
                 offsetof(struct prev_params, brightness),
-                0, true,
+                0, 0, true,
         },
 };
 
@@ -1102,7 +1102,7 @@ static void preview_config_input_size(struct isp_prev_device *prev, u32 active)
         unsigned int elv = prev->crop.top + prev->crop.height - 1;
         u32 features;
 
-        if (format->code == V4L2_MBUS_FMT_Y10_1X10) {
+        if (format->code != V4L2_MBUS_FMT_Y10_1X10) {
                 sph -= 2;
                 eph += 2;
                 slv -= 2;
diff --git a/drivers/media/video/pms.c b/drivers/media/video/pms.c
index c370c2d87c17..b4c679b3fb0f 100644
--- a/drivers/media/video/pms.c
+++ b/drivers/media/video/pms.c
@@ -26,6 +26,7 @@
 #include <linux/fs.h>
 #include <linux/kernel.h>
 #include <linux/mm.h>
+#include <linux/slab.h>
 #include <linux/ioport.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
diff --git a/drivers/media/video/s5p-fimc/fimc-capture.c b/drivers/media/video/s5p-fimc/fimc-capture.c
index 354574591908..725812aa0c30 100644
--- a/drivers/media/video/s5p-fimc/fimc-capture.c
+++ b/drivers/media/video/s5p-fimc/fimc-capture.c
@@ -350,7 +350,8 @@ static int queue_setup(struct vb2_queue *vq, const struct v4l2_format *pfmt,
                 if (pixm)
                         sizes[i] = max(size, pixm->plane_fmt[i].sizeimage);
                 else
-                        sizes[i] = size;
+                        sizes[i] = max_t(u32, size, frame->payload[i]);
+
                 allocators[i] = ctx->fimc_dev->alloc_ctx;
         }
 
@@ -479,37 +480,39 @@ static int fimc_capture_set_default_format(struct fimc_dev *fimc);
 static int fimc_capture_open(struct file *file)
 {
         struct fimc_dev *fimc = video_drvdata(file);
-        int ret = v4l2_fh_open(file);
-
-        if (ret)
-                return ret;
+        int ret;
 
         dbg("pid: %d, state: 0x%lx", task_pid_nr(current), fimc->state);
 
-        /* Return if the corresponding video mem2mem node is already opened. */
         if (fimc_m2m_active(fimc))
                 return -EBUSY;
 
         set_bit(ST_CAPT_BUSY, &fimc->state);
-        pm_runtime_get_sync(&fimc->pdev->dev);
+        ret = pm_runtime_get_sync(&fimc->pdev->dev);
+        if (ret < 0)
+                return ret;
 
-        if (++fimc->vid_cap.refcnt == 1) {
-                ret = fimc_pipeline_initialize(&fimc->pipeline,
-                               &fimc->vid_cap.vfd->entity, true);
-                if (ret < 0) {
-                        dev_err(&fimc->pdev->dev,
-                                "Video pipeline initialization failed\n");
-                        pm_runtime_put_sync(&fimc->pdev->dev);
-                        fimc->vid_cap.refcnt--;
-                        v4l2_fh_release(file);
-                        clear_bit(ST_CAPT_BUSY, &fimc->state);
-                        return ret;
-                }
-                ret = fimc_capture_ctrls_create(fimc);
+        ret = v4l2_fh_open(file);
+        if (ret)
+                return ret;
 
-                if (!ret && !fimc->vid_cap.user_subdev_api)
-                        ret = fimc_capture_set_default_format(fimc);
+        if (++fimc->vid_cap.refcnt != 1)
+                return 0;
+
+        ret = fimc_pipeline_initialize(&fimc->pipeline,
+                                       &fimc->vid_cap.vfd->entity, true);
+        if (ret < 0) {
+                clear_bit(ST_CAPT_BUSY, &fimc->state);
+                pm_runtime_put_sync(&fimc->pdev->dev);
+                fimc->vid_cap.refcnt--;
+                v4l2_fh_release(file);
+                return ret;
         }
+        ret = fimc_capture_ctrls_create(fimc);
+
+        if (!ret && !fimc->vid_cap.user_subdev_api)
+                ret = fimc_capture_set_default_format(fimc);
+
         return ret;
 }
 
@@ -818,9 +821,6 @@ static int fimc_cap_g_fmt_mplane(struct file *file, void *fh,
         struct fimc_dev *fimc = video_drvdata(file);
         struct fimc_ctx *ctx = fimc->vid_cap.ctx;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
-
         return fimc_fill_format(&ctx->d_frame, f);
 }
 
@@ -833,9 +833,6 @@ static int fimc_cap_try_fmt_mplane(struct file *file, void *fh,
         struct v4l2_mbus_framefmt mf;
         struct fimc_fmt *ffmt = NULL;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
-
         if (pix->pixelformat == V4L2_PIX_FMT_JPEG) {
                 fimc_capture_try_format(ctx, &pix->width, &pix->height,
                                         NULL, &pix->pixelformat,
@@ -887,8 +884,6 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
         struct fimc_fmt *s_fmt = NULL;
         int ret, i;
 
-        if (f->type != V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE)
-                return -EINVAL;
         if (vb2_is_busy(&fimc->vid_cap.vbq))
                 return -EBUSY;
 
@@ -924,10 +919,10 @@ static int fimc_capture_set_format(struct fimc_dev *fimc, struct v4l2_format *f)
                 pix->width  = mf->width;
                 pix->height = mf->height;
         }
+
         fimc_adjust_mplane_format(ff->fmt, pix->width, pix->height, pix);
         for (i = 0; i < ff->fmt->colplanes; i++)
-                ff->payload[i] =
-                        (pix->width * pix->height * ff->fmt->depth[i]) / 8;
+                ff->payload[i] = pix->plane_fmt[i].sizeimage;
 
         set_frame_bounds(ff, pix->width, pix->height);
         /* Reset the composition rectangle if not yet configured */
@@ -1045,18 +1040,22 @@ static int fimc_cap_streamon(struct file *file, void *priv,
 {
         struct fimc_dev *fimc = video_drvdata(file);
         struct fimc_pipeline *p = &fimc->pipeline;
+        struct v4l2_subdev *sd = p->subdevs[IDX_SENSOR];
         int ret;
 
         if (fimc_capture_active(fimc))
                 return -EBUSY;
 
-        media_entity_pipeline_start(&p->subdevs[IDX_SENSOR]->entity,
-                                    p->m_pipeline);
+        ret = media_entity_pipeline_start(&sd->entity, p->m_pipeline);
+        if (ret < 0)
+                return ret;
 
         if (fimc->vid_cap.user_subdev_api) {
                 ret = fimc_pipeline_validate(fimc);
-                if (ret)
+                if (ret < 0) {
+                        media_entity_pipeline_stop(&sd->entity);
                         return ret;
+                }
         }
         return vb2_streamon(&fimc->vid_cap.vbq, type);
 }
diff --git a/drivers/media/video/s5p-fimc/fimc-core.c b/drivers/media/video/s5p-fimc/fimc-core.c
index 92fc5a20fb76..a4646ca1d56f 100644
--- a/drivers/media/video/s5p-fimc/fimc-core.c
+++ b/drivers/media/video/s5p-fimc/fimc-core.c
@@ -153,7 +153,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 2,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr",
+                .name           = "YUV 4:2:0 non-contig. 2p, Y/CbCr",
                 .fourcc         = V4L2_PIX_FMT_NV12M,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 4 },
@@ -161,7 +161,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 2,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 3-planar, Y/Cb/Cr",
+                .name           = "YUV 4:2:0 non-contig. 3p, Y/Cb/Cr",
                 .fourcc         = V4L2_PIX_FMT_YUV420M,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 2, 2 },
@@ -169,7 +169,7 @@ static struct fimc_fmt fimc_formats[] = {
                 .colplanes      = 3,
                 .flags          = FMT_FLAGS_M2M,
         }, {
-                .name           = "YUV 4:2:0 non-contiguous 2-planar, Y/CbCr, tiled",
+                .name           = "YUV 4:2:0 non-contig. 2p, tiled",
                 .fourcc         = V4L2_PIX_FMT_NV12MT,
                 .color          = FIMC_FMT_YCBCR420,
                 .depth          = { 8, 4 },
@@ -641,7 +641,7 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
         if (!ctrls->ready)
                 return;
 
-        mutex_lock(&ctrls->handler.lock);
+        mutex_lock(ctrls->handler.lock);
         v4l2_ctrl_activate(ctrls->rotate, active);
         v4l2_ctrl_activate(ctrls->hflip, active);
         v4l2_ctrl_activate(ctrls->vflip, active);
@@ -660,7 +660,7 @@ void fimc_ctrls_activate(struct fimc_ctx *ctx, bool active)
                 ctx->hflip    = 0;
                 ctx->vflip    = 0;
         }
-        mutex_unlock(&ctrls->handler.lock);
+        mutex_unlock(ctrls->handler.lock);
 }
 
 /* Update maximum value of the alpha color control */
@@ -741,8 +741,8 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
         pix->width = width;
 
         for (i = 0; i < pix->num_planes; ++i) {
-                u32 bpl = pix->plane_fmt[i].bytesperline;
-                u32 *sizeimage = &pix->plane_fmt[i].sizeimage;
+                struct v4l2_plane_pix_format *plane_fmt = &pix->plane_fmt[i];
+                u32 bpl = plane_fmt->bytesperline;
 
                 if (fmt->colplanes > 1 && (bpl == 0 || bpl < pix->width))
                         bpl = pix->width; /* Planar */
@@ -754,8 +754,9 @@ void fimc_adjust_mplane_format(struct fimc_fmt *fmt, u32 width, u32 height,
                 if (i == 0) /* Same bytesperline for each plane. */
                         bytesperline = bpl;
 
-                pix->plane_fmt[i].bytesperline = bytesperline;
-                *sizeimage = (pix->width * pix->height * fmt->depth[i]) / 8;
+                plane_fmt->bytesperline = bytesperline;
+                plane_fmt->sizeimage = max((pix->width * pix->height *
+                                   fmt->depth[i]) / 8, plane_fmt->sizeimage);
         }
 }
 
diff --git a/drivers/media/video/s5p-fimc/fimc-lite.c b/drivers/media/video/s5p-fimc/fimc-lite.c
index 400d701aef04..74ff310db30c 100644
--- a/drivers/media/video/s5p-fimc/fimc-lite.c
+++ b/drivers/media/video/s5p-fimc/fimc-lite.c
@@ -451,34 +451,44 @@ static void fimc_lite_clear_event_counters(struct fimc_lite *fimc)
 static int fimc_lite_open(struct file *file)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        int ret = v4l2_fh_open(file);
+        int ret;
 
-        if (ret)
-                return ret;
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
 
         set_bit(ST_FLITE_IN_USE, &fimc->state);
-        pm_runtime_get_sync(&fimc->pdev->dev);
+        ret = pm_runtime_get_sync(&fimc->pdev->dev);
+        if (ret < 0)
+                goto done;
 
-        if (++fimc->ref_count != 1 || fimc->out_path != FIMC_IO_DMA)
-                return ret;
+        ret = v4l2_fh_open(file);
+        if (ret < 0)
+                goto done;
 
-        ret = fimc_pipeline_initialize(&fimc->pipeline, &fimc->vfd->entity,
-                                       true);
-        if (ret < 0) {
-                v4l2_err(fimc->vfd, "Video pipeline initialization failed\n");
-                pm_runtime_put_sync(&fimc->pdev->dev);
-                fimc->ref_count--;
-                v4l2_fh_release(file);
-                clear_bit(ST_FLITE_IN_USE, &fimc->state);
-        }
+        if (++fimc->ref_count == 1 && fimc->out_path == FIMC_IO_DMA) {
+                ret = fimc_pipeline_initialize(&fimc->pipeline,
+                                               &fimc->vfd->entity, true);
+                if (ret < 0) {
+                        pm_runtime_put_sync(&fimc->pdev->dev);
+                        fimc->ref_count--;
+                        v4l2_fh_release(file);
+                        clear_bit(ST_FLITE_IN_USE, &fimc->state);
+                }
 
-        fimc_lite_clear_event_counters(fimc);
+                fimc_lite_clear_event_counters(fimc);
+        }
+done:
+        mutex_unlock(&fimc->lock);
         return ret;
 }
 
 static int fimc_lite_close(struct file *file)
 {
         struct fimc_lite *fimc = video_drvdata(file);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
 
         if (--fimc->ref_count == 0 && fimc->out_path == FIMC_IO_DMA) {
                 clear_bit(ST_FLITE_IN_USE, &fimc->state);
@@ -492,20 +502,39 @@ static int fimc_lite_close(struct file *file)
         if (fimc->ref_count == 0)
                 vb2_queue_release(&fimc->vb_queue);
 
-        return v4l2_fh_release(file);
+        ret = v4l2_fh_release(file);
+
+        mutex_unlock(&fimc->lock);
+        return ret;
 }
 
 static unsigned int fimc_lite_poll(struct file *file,
                                    struct poll_table_struct *wait)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        return vb2_poll(&fimc->vb_queue, file, wait);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return POLL_ERR;
+
+        ret = vb2_poll(&fimc->vb_queue, file, wait);
+        mutex_unlock(&fimc->lock);
+
+        return ret;
 }
 
 static int fimc_lite_mmap(struct file *file, struct vm_area_struct *vma)
 {
         struct fimc_lite *fimc = video_drvdata(file);
-        return vb2_mmap(&fimc->vb_queue, vma);
+        int ret;
+
+        if (mutex_lock_interruptible(&fimc->lock))
+                return -ERESTARTSYS;
+
+        ret = vb2_mmap(&fimc->vb_queue, vma);
+        mutex_unlock(&fimc->lock);
+
+        return ret;
 }
 
 static const struct v4l2_file_operations fimc_lite_fops = {
@@ -762,7 +791,9 @@ static int fimc_lite_streamon(struct file *file, void *priv,
         if (fimc_lite_active(fimc))
                 return -EBUSY;
 
-        media_entity_pipeline_start(&sensor->entity, p->m_pipeline);
+        ret = media_entity_pipeline_start(&sensor->entity, p->m_pipeline);
+        if (ret < 0)
+                return ret;
 
         ret = fimc_pipeline_validate(fimc);
         if (ret) {
@@ -1508,7 +1539,7 @@ static int fimc_lite_suspend(struct device *dev)
                 return 0;
 
         ret = fimc_lite_stop_capture(fimc, suspend);
-        if (ret)
+        if (ret < 0 || !fimc_lite_active(fimc))
                 return ret;
 
         return fimc_pipeline_shutdown(&fimc->pipeline);
diff --git a/drivers/media/video/s5p-fimc/fimc-mdevice.c b/drivers/media/video/s5p-fimc/fimc-mdevice.c
index 6753c45631b8..52cef4865423 100644
--- a/drivers/media/video/s5p-fimc/fimc-mdevice.c
+++ b/drivers/media/video/s5p-fimc/fimc-mdevice.c
@@ -193,9 +193,13 @@ int __fimc_pipeline_shutdown(struct fimc_pipeline *p)
 
 int fimc_pipeline_shutdown(struct fimc_pipeline *p)
 {
-        struct media_entity *me = &p->subdevs[IDX_SENSOR]->entity;
+        struct media_entity *me;
         int ret;
 
+        if (!p || !p->subdevs[IDX_SENSOR])
+                return -EINVAL;
+
+        me = &p->subdevs[IDX_SENSOR]->entity;
         mutex_lock(&me->parent->graph_mutex);
         ret = __fimc_pipeline_shutdown(p);
         mutex_unlock(&me->parent->graph_mutex);
@@ -498,12 +502,12 @@ static void fimc_md_unregister_entities(struct fimc_md *fmd)
  * @source: the source entity to create links to all fimc entities from
  * @sensor: sensor subdev linked to FIMC[fimc_id] entity, may be null
  * @pad: the source entity pad index
- * @fimc_id: index of the fimc device for which link should be enabled
+ * @link_mask: bitmask of the fimc devices for which link should be enabled
  */
 static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                                             struct media_entity *source,
                                             struct v4l2_subdev *sensor,
-                                            int pad, int fimc_id)
+                                            int pad, int link_mask)
 {
         struct fimc_sensor_info *s_info;
         struct media_entity *sink;
@@ -520,7 +524,7 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                 if (!fmd->fimc[i]->variant->has_cam_if)
                         continue;
 
-                flags = (i == fimc_id) ? MEDIA_LNK_FL_ENABLED : 0;
+                flags = ((1 << i) & link_mask) ? MEDIA_LNK_FL_ENABLED : 0;
 
                 sink = &fmd->fimc[i]->vid_cap.subdev.entity;
                 ret = media_entity_create_link(source, pad, sink,
@@ -552,7 +556,10 @@ static int __fimc_md_create_fimc_sink_links(struct fimc_md *fmd,
                 if (!fmd->fimc_lite[i])
                         continue;
 
-                flags = (i == fimc_id) ? MEDIA_LNK_FL_ENABLED : 0;
+                if (link_mask & (1 << (i + FIMC_MAX_DEVS)))
+                        flags = MEDIA_LNK_FL_ENABLED;
+                else
+                        flags = 0;
 
                 sink = &fmd->fimc_lite[i]->subdev.entity;
                 ret = media_entity_create_link(source, pad, sink,
@@ -614,9 +621,8 @@ static int fimc_md_create_links(struct fimc_md *fmd)
         struct s5p_fimc_isp_info *pdata;
         struct fimc_sensor_info *s_info;
         struct media_entity *source, *sink;
-        int i, pad, fimc_id = 0;
-        int ret = 0;
-        u32 flags;
+        int i, pad, fimc_id = 0, ret = 0;
+        u32 flags, link_mask = 0;
 
         for (i = 0; i < fmd->num_sensors; i++) {
                 if (fmd->sensor[i].subdev == NULL)
@@ -668,19 +674,20 @@ static int fimc_md_create_links(struct fimc_md *fmd)
                 if (source == NULL)
                         continue;
 
+                link_mask = 1 << fimc_id++;
                 ret = __fimc_md_create_fimc_sink_links(fmd, source, sensor,
-                                                       pad, fimc_id++);
+                                                       pad, link_mask);
         }
 
-        fimc_id = 0;
         for (i = 0; i < ARRAY_SIZE(fmd->csis); i++) {
                 if (fmd->csis[i].sd == NULL)
                         continue;
                 source = &fmd->csis[i].sd->entity;
                 pad = CSIS_PAD_SOURCE;
 
+                link_mask = 1 << fimc_id++;
                 ret = __fimc_md_create_fimc_sink_links(fmd, source, NULL,
-                                                       pad, fimc_id++);
+                                                       pad, link_mask);
         }
 
         /* Create immutable links between each FIMC's subdev and video node */
@@ -734,8 +741,8 @@ static void fimc_md_put_clocks(struct fimc_md *fmd)
 }
 
 static int __fimc_md_set_camclk(struct fimc_md *fmd,
-                                         struct fimc_sensor_info *s_info,
-                                         bool on)
+                                struct fimc_sensor_info *s_info,
+                                bool on)
 {
         struct s5p_fimc_isp_info *pdata = s_info->pdata;
         struct fimc_camclk_info *camclk;
@@ -744,12 +751,10 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
         if (WARN_ON(pdata->clk_id >= FIMC_MAX_CAMCLKS) || fmd == NULL)
                 return -EINVAL;
 
-        if (s_info->clk_on == on)
-                return 0;
         camclk = &fmd->camclk[pdata->clk_id];
 
-        dbg("camclk %d, f: %lu, clk: %p, on: %d",
-            pdata->clk_id, pdata->clk_frequency, camclk, on);
+        dbg("camclk %d, f: %lu, use_count: %d, on: %d",
+            pdata->clk_id, pdata->clk_frequency, camclk->use_count, on);
 
         if (on) {
                 if (camclk->use_count > 0 &&
@@ -760,11 +765,9 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
                         clk_set_rate(camclk->clock, pdata->clk_frequency);
                         camclk->frequency = pdata->clk_frequency;
                         ret = clk_enable(camclk->clock);
+                        dbg("Enabled camclk %d: f: %lu", pdata->clk_id,
+                            clk_get_rate(camclk->clock));
                 }
-                s_info->clk_on = 1;
-                dbg("Enabled camclk %d: f: %lu", pdata->clk_id,
-                    clk_get_rate(camclk->clock));
-
                 return ret;
         }
 
@@ -773,7 +776,6 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
 
         if (--camclk->use_count == 0) {
                 clk_disable(camclk->clock);
-                s_info->clk_on = 0;
                 dbg("Disabled camclk %d", pdata->clk_id);
         }
         return ret;
@@ -789,8 +791,6 @@ static int __fimc_md_set_camclk(struct fimc_md *fmd,
  * devices to which sensors can be attached, either directly or through
  * the MIPI CSI receiver. The clock is allowed here to be used by
  * multiple sensors concurrently if they use same frequency.
- * The per sensor subdev clk_on attribute helps to synchronize accesses
- * to the sclk_cam clocks from the video and media device nodes.
  * This function should only be called when the graph mutex is held.
  */
 int fimc_md_set_camclk(struct v4l2_subdev *sd, bool on)
diff --git a/drivers/media/video/s5p-fimc/fimc-mdevice.h b/drivers/media/video/s5p-fimc/fimc-mdevice.h
index 3b8a3492a176..1f5dbaff5442 100644
--- a/drivers/media/video/s5p-fimc/fimc-mdevice.h
+++ b/drivers/media/video/s5p-fimc/fimc-mdevice.h
@@ -47,7 +47,6 @@ struct fimc_camclk_info {
  * @pdata: sensor's atrributes passed as media device's platform data
  * @subdev: image sensor v4l2 subdev
  * @host: fimc device the sensor is currently linked to
- * @clk_on: sclk_cam clock's state associated with this subdev
  *
  * This data structure applies to image sensor and the writeback subdevs.
  */
@@ -55,7 +54,6 @@ struct fimc_sensor_info {
         struct s5p_fimc_isp_info *pdata;
         struct v4l2_subdev *subdev;
         struct fimc_dev *host;
-        bool clk_on;
 };
 
 /**
diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
index 4dd32fc8fd82..feea867f318c 100644
--- a/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_dec.c
@@ -996,6 +996,7 @@ int s5p_mfc_dec_ctrls_setup(struct s5p_mfc_ctx *ctx)
 
         for (i = 0; i < NUM_CTRLS; i++) {
                 if (IS_MFC51_PRIV(controls[i].id)) {
+                        memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
                         cfg.ops = &s5p_mfc_dec_ctrl_ops;
                         cfg.id = controls[i].id;
                         cfg.min = controls[i].minimum;
diff --git a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
index 03d83340e7fb..158b78989b89 100644
--- a/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
+++ b/drivers/media/video/s5p-mfc/s5p_mfc_enc.c
@@ -1773,6 +1773,7 @@ int s5p_mfc_enc_ctrls_setup(struct s5p_mfc_ctx *ctx)
         }
         for (i = 0; i < NUM_CTRLS; i++) {
                 if (IS_MFC51_PRIV(controls[i].id)) {
+                        memset(&cfg, 0, sizeof(struct v4l2_ctrl_config));
                         cfg.ops = &s5p_mfc_enc_ctrl_ops;
                         cfg.id = controls[i].id;
                         cfg.min = controls[i].minimum;
diff --git a/drivers/media/video/smiapp/smiapp-core.c b/drivers/media/video/smiapp/smiapp-core.c
index e8c93c89265a..9cf5bda35fbe 100644
--- a/drivers/media/video/smiapp/smiapp-core.c
+++ b/drivers/media/video/smiapp/smiapp-core.c
@@ -31,6 +31,7 @@
 #include <linux/device.h>
 #include <linux/gpio.h>
 #include <linux/module.h>
+#include <linux/slab.h>
 #include <linux/regulator/consumer.h>
 #include <linux/slab.h>
 #include <linux/v4l2-mediabus.h>
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index e129c820df7d..92144ed1ad46 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -286,6 +286,7 @@ config TWL6040_CORE
         depends on I2C=y && GENERIC_HARDIRQS
         select MFD_CORE
         select REGMAP_I2C
+        select IRQ_DOMAIN
         default n
         help
           Say yes here if you want support for Texas Instruments TWL6040 audio
diff --git a/drivers/mfd/ab5500-core.h b/drivers/mfd/ab5500-core.h
deleted file mode 100644
index 63b30b17e4f3..000000000000
--- a/drivers/mfd/ab5500-core.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
- * Copyright (C) 2011 ST-Ericsson
- * License terms: GNU General Public License (GPL) version 2
- * Shared definitions and data structures for the AB5500 MFD driver
- */
-
-/* Read/write operation values. */
-#define AB5500_PERM_RD (0x01)
-#define AB5500_PERM_WR (0x02)
-
-/* Read/write permissions. */
-#define AB5500_PERM_RO (AB5500_PERM_RD)
-#define AB5500_PERM_RW (AB5500_PERM_RD | AB5500_PERM_WR)
-
-#define AB5500_MASK_BASE (0x60)
-#define AB5500_MASK_END (0x79)
-#define AB5500_CHIP_ID (0x20)
-
-/**
- * struct ab5500_reg_range
- * @first: the first address of the range
- * @last: the last address of the range
- * @perm: access permissions for the range
- */
-struct ab5500_reg_range {
-        u8 first;
-        u8 last;
-        u8 perm;
-};
-
-/**
- * struct ab5500_i2c_ranges
- * @count: the number of ranges in the list
- * @range: the list of register ranges
- */
-struct ab5500_i2c_ranges {
-        u8 nranges;
-        u8 bankid;
-        const struct ab5500_reg_range *range;
-};
-
-/**
- * struct ab5500_i2c_banks
- * @count: the number of ranges in the list
- * @range: the list of register ranges
- */
-struct ab5500_i2c_banks {
-        u8 nbanks;
-        const struct ab5500_i2c_ranges *bank;
-};
-
-/**
- * struct ab5500_bank
- * @slave_addr: I2C slave_addr found in AB5500 specification
- * @name: Documentation name of the bank. For reference
- */
-struct ab5500_bank {
-        u8 slave_addr;
-        const char *name;
-};
-
-static const struct ab5500_bank bankinfo[AB5500_NUM_BANKS] = {
-        [AB5500_BANK_VIT_IO_I2C_CLK_TST_OTP] = {
-                AB5500_ADDR_VIT_IO_I2C_CLK_TST_OTP, "VIT_IO_I2C_CLK_TST_OTP"},
-        [AB5500_BANK_VDDDIG_IO_I2C_CLK_TST] = {
-                AB5500_ADDR_VDDDIG_IO_I2C_CLK_TST, "VDDDIG_IO_I2C_CLK_TST"},
-        [AB5500_BANK_VDENC] = {AB5500_ADDR_VDENC, "VDENC"},
-        [AB5500_BANK_SIM_USBSIM] = {AB5500_ADDR_SIM_USBSIM, "SIM_USBSIM"},
-        [AB5500_BANK_LED] = {AB5500_ADDR_LED, "LED"},
-        [AB5500_BANK_ADC] = {AB5500_ADDR_ADC, "ADC"},
-        [AB5500_BANK_RTC] = {AB5500_ADDR_RTC, "RTC"},
-        [AB5500_BANK_STARTUP] = {AB5500_ADDR_STARTUP, "STARTUP"},
-        [AB5500_BANK_DBI_ECI] = {AB5500_ADDR_DBI_ECI, "DBI-ECI"},
-        [AB5500_BANK_CHG] = {AB5500_ADDR_CHG, "CHG"},
-        [AB5500_BANK_FG_BATTCOM_ACC] = {
-                AB5500_ADDR_FG_BATTCOM_ACC, "FG_BATCOM_ACC"},
-        [AB5500_BANK_USB] = {AB5500_ADDR_USB, "USB"},
-        [AB5500_BANK_IT] = {AB5500_ADDR_IT, "IT"},
-        [AB5500_BANK_VIBRA] = {AB5500_ADDR_VIBRA, "VIBRA"},
-        [AB5500_BANK_AUDIO_HEADSETUSB] = {
-                AB5500_ADDR_AUDIO_HEADSETUSB, "AUDIO_HEADSETUSB"},
-};
-
-int ab5500_get_register_interruptible_raw(struct ab5500 *ab, u8 bank, u8 reg,
-        u8 *value);
-int ab5500_mask_and_set_register_interruptible_raw(struct ab5500 *ab, u8 bank,
-        u8 reg, u8 bitmask, u8 bitvalues);
diff --git a/drivers/mfd/mc13xxx-spi.c b/drivers/mfd/mc13xxx-spi.c
index 3fcdab3eb8eb..03df422feb76 100644
--- a/drivers/mfd/mc13xxx-spi.c
+++ b/drivers/mfd/mc13xxx-spi.c
@@ -49,10 +49,72 @@ static struct regmap_config mc13xxx_regmap_spi_config = {
         .reg_bits = 7,
         .pad_bits = 1,
         .val_bits = 24,
+        .write_flag_mask = 0x80,
 
         .max_register = MC13XXX_NUMREGS,
 
         .cache_type = REGCACHE_NONE,
+        .use_single_rw = 1,
+};
+
+static int mc13xxx_spi_read(void *context, const void *reg, size_t reg_size,
+                                void *val, size_t val_size)
+{
+        unsigned char w[4] = { *((unsigned char *) reg), 0, 0, 0};
+        unsigned char r[4];
+        unsigned char *p = val;
+        struct device *dev = context;
+        struct spi_device *spi = to_spi_device(dev);
+        struct spi_transfer t = {
+                .tx_buf = w,
+                .rx_buf = r,
+                .len = 4,
+        };
+
+        struct spi_message m;
+        int ret;
+
+        if (val_size != 3 || reg_size != 1)
+                return -ENOTSUPP;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        ret = spi_sync(spi, &m);
+
+        memcpy(p, &r[1], 3);
+
+        return ret;
+}
+
+static int mc13xxx_spi_write(void *context, const void *data, size_t count)
+{
+        struct device *dev = context;
+        struct spi_device *spi = to_spi_device(dev);
+
+        if (count != 4)
+                return -ENOTSUPP;
+
+        return spi_write(spi, data, count);
+}
+
+/*
+ * We cannot use regmap-spi generic bus implementation here.
+ * The MC13783 chip will get corrupted if CS signal is deasserted
+ * and on i.Mx31 SoC (the target SoC for MC13783 PMIC) the SPI controller
+ * has the following errata (DSPhl22960):
+ * "The CSPI negates SS when the FIFO becomes empty with
+ * SSCTL= 0. Software cannot guarantee that the FIFO will not
+ * drain because of higher priority interrupts and the
+ * non-realtime characteristics of the operating system. As a
+ * result, the SS will negate before all of the data has been
+ * transferred to/from the peripheral."
+ * We workaround this by accessing the SPI controller with a
+ * single transfert.
+ */
+
+static struct regmap_bus regmap_mc13xxx_bus = {
+        .write = mc13xxx_spi_write,
+        .read = mc13xxx_spi_read,
 };
 
 static int mc13xxx_spi_probe(struct spi_device *spi)
@@ -73,12 +135,13 @@ static int mc13xxx_spi_probe(struct spi_device *spi)
 
         dev_set_drvdata(&spi->dev, mc13xxx);
         spi->mode = SPI_MODE_0 | SPI_CS_HIGH;
-        spi->bits_per_word = 32;
 
         mc13xxx->dev = &spi->dev;
         mutex_init(&mc13xxx->lock);
 
-        mc13xxx->regmap = regmap_init_spi(spi, &mc13xxx_regmap_spi_config);
+        mc13xxx->regmap = regmap_init(&spi->dev, &regmap_mc13xxx_bus, &spi->dev,
+                                        &mc13xxx_regmap_spi_config);
+
         if (IS_ERR(mc13xxx->regmap)) {
                 ret = PTR_ERR(mc13xxx->regmap);
                 dev_err(mc13xxx->dev, "Failed to initialize register map: %d\n",
diff --git a/drivers/mfd/omap-usb-host.c b/drivers/mfd/omap-usb-host.c
index 7e96bb229724..41088ecbb2a9 100644
--- a/drivers/mfd/omap-usb-host.c
+++ b/drivers/mfd/omap-usb-host.c
@@ -25,6 +25,7 @@
 #include <linux/clk.h>
 #include <linux/dma-mapping.h>
 #include <linux/spinlock.h>
+#include <linux/gpio.h>
 #include <plat/cpu.h>
 #include <plat/usb.h>
 #include <linux/pm_runtime.h>
@@ -500,8 +501,21 @@ static void omap_usbhs_init(struct device *dev)
         dev_dbg(dev, "starting TI HSUSB Controller\n");
 
         pm_runtime_get_sync(dev);
-        spin_lock_irqsave(&omap->lock, flags);
 
+        if (pdata->ehci_data->phy_reset) {
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_request_one(pdata->ehci_data->reset_gpio_port[0],
+                                         GPIOF_OUT_INIT_LOW, "USB1 PHY reset");
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_request_one(pdata->ehci_data->reset_gpio_port[1],
+                                         GPIOF_OUT_INIT_LOW, "USB2 PHY reset");
+
+                /* Hold the PHY in RESET for enough time till DIR is high */
+                udelay(10);
+        }
+
+        spin_lock_irqsave(&omap->lock, flags);
         omap->usbhs_rev = usbhs_read(omap->uhh_base, OMAP_UHH_REVISION);
         dev_dbg(dev, "OMAP UHH_REVISION 0x%x\n", omap->usbhs_rev);
 
@@ -581,9 +595,39 @@ static void omap_usbhs_init(struct device *dev)
         }
 
         spin_unlock_irqrestore(&omap->lock, flags);
+
+        if (pdata->ehci_data->phy_reset) {
+                /* Hold the PHY in RESET for enough time till
+                 * PHY is settled and ready
+                 */
+                udelay(10);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_set_value_cansleep
+                                (pdata->ehci_data->reset_gpio_port[0], 1);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_set_value_cansleep
+                                (pdata->ehci_data->reset_gpio_port[1], 1);
+        }
+
         pm_runtime_put_sync(dev);
 }
 
+static void omap_usbhs_deinit(struct device *dev)
+{
+        struct usbhs_hcd_omap           *omap = dev_get_drvdata(dev);
+        struct usbhs_omap_platform_data *pdata = &omap->platdata;
+
+        if (pdata->ehci_data->phy_reset) {
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[0]))
+                        gpio_free(pdata->ehci_data->reset_gpio_port[0]);
+
+                if (gpio_is_valid(pdata->ehci_data->reset_gpio_port[1]))
+                        gpio_free(pdata->ehci_data->reset_gpio_port[1]);
+        }
+}
+
 
 /**
  * usbhs_omap_probe - initialize TI-based HCDs
@@ -767,6 +811,7 @@ static int __devinit usbhs_omap_probe(struct platform_device *pdev)
         goto end_probe;
 
 err_alloc:
+        omap_usbhs_deinit(&pdev->dev);
         iounmap(omap->tll_base);
 
 err_tll:
@@ -818,6 +863,7 @@ static int __devexit usbhs_omap_remove(struct platform_device *pdev)
 {
         struct usbhs_hcd_omap *omap = platform_get_drvdata(pdev);
 
+        omap_usbhs_deinit(&pdev->dev);
         iounmap(omap->tll_base);
         iounmap(omap->uhh_base);
         clk_put(omap->init_60m_fclk);
diff --git a/drivers/mfd/palmas.c b/drivers/mfd/palmas.c
index 00c0aba7eba0..c4a69f193a1d 100644
--- a/drivers/mfd/palmas.c
+++ b/drivers/mfd/palmas.c
@@ -356,7 +356,14 @@ static int __devinit palmas_i2c_probe(struct i2c_client *i2c,
                 }
         }
 
-        ret = regmap_add_irq_chip(palmas->regmap[1], palmas->irq,
+        /* Change IRQ into clear on read mode for efficiency */
+        slave = PALMAS_BASE_TO_SLAVE(PALMAS_INTERRUPT_BASE);
+        addr = PALMAS_BASE_TO_REG(PALMAS_INTERRUPT_BASE, PALMAS_INT_CTRL);
+        reg = PALMAS_INT_CTRL_INT_CLEAR;
+
+        regmap_write(palmas->regmap[slave], addr, reg);
+
+        ret = regmap_add_irq_chip(palmas->regmap[slave], palmas->irq,
                         IRQF_ONESHOT | IRQF_TRIGGER_LOW, -1, &palmas_irq_chip,
                         &palmas->irq_data);
         if (ret < 0)
@@ -441,6 +448,9 @@ static int __devinit palmas_i2c_probe(struct i2c_client *i2c,
                 goto err;
         }
 
+        children[PALMAS_PMIC_ID].platform_data = pdata->pmic_pdata;
+        children[PALMAS_PMIC_ID].pdata_size = sizeof(*pdata->pmic_pdata);
+
         ret = mfd_add_devices(palmas->dev, -1,
                               children, ARRAY_SIZE(palmas_children),
                               NULL, regmap_irq_chip_get_base(palmas->irq_data));
@@ -472,6 +482,7 @@ static const struct i2c_device_id palmas_i2c_id[] = {
         { "twl6035", },
         { "twl6037", },
         { "tps65913", },
+        { /* end */ }
 };
 MODULE_DEVICE_TABLE(i2c, palmas_i2c_id);
 
diff --git a/drivers/mfd/tps65217.c b/drivers/mfd/tps65217.c
index db194e433c08..61c097a98f5d 100644
--- a/drivers/mfd/tps65217.c
+++ b/drivers/mfd/tps65217.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/regmap.h>
 #include <linux/err.h>
+#include <linux/regulator/of_regulator.h>
 
 #include <linux/mfd/core.h>
 #include <linux/mfd/tps65217.h>
@@ -132,6 +133,61 @@ int tps65217_clear_bits(struct tps65217 *tps, unsigned int reg,
 }
 EXPORT_SYMBOL_GPL(tps65217_clear_bits);
 
+#ifdef CONFIG_OF
+static struct of_regulator_match reg_matches[] = {
+        { .name = "dcdc1", .driver_data = (void *)TPS65217_DCDC_1 },
+        { .name = "dcdc2", .driver_data = (void *)TPS65217_DCDC_2 },
+        { .name = "dcdc3", .driver_data = (void *)TPS65217_DCDC_3 },
+        { .name = "ldo1", .driver_data = (void *)TPS65217_LDO_1 },
+        { .name = "ldo2", .driver_data = (void *)TPS65217_LDO_2 },
+        { .name = "ldo3", .driver_data = (void *)TPS65217_LDO_3 },
+        { .name = "ldo4", .driver_data = (void *)TPS65217_LDO_4 },
+};
+
+static struct tps65217_board *tps65217_parse_dt(struct i2c_client *client)
+{
+        struct device_node *node = client->dev.of_node;
+        struct tps65217_board *pdata;
+        struct device_node *regs;
+        int count = ARRAY_SIZE(reg_matches);
+        int ret, i;
+
+        regs = of_find_node_by_name(node, "regulators");
+        if (!regs)
+                return NULL;
+
+        ret = of_regulator_match(&client->dev, regs, reg_matches, count);
+        of_node_put(regs);
+        if ((ret < 0) || (ret > count))
+                return NULL;
+
+        count = ret;
+        pdata = devm_kzalloc(&client->dev, count * sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return NULL;
+
+        for (i = 0; i < count; i++) {
+                if (!reg_matches[i].init_data || !reg_matches[i].of_node)
+                        continue;
+
+                pdata->tps65217_init_data[i] = reg_matches[i].init_data;
+                pdata->of_node[i] = reg_matches[i].of_node;
+        }
+
+        return pdata;
+}
+
+static struct of_device_id tps65217_of_match[] = {
+        { .compatible = "ti,tps65217", },
+        { },
+};
+#else
+static struct tps65217_board *tps65217_parse_dt(struct i2c_client *client)
+{
+        return NULL;
+}
+#endif
+
 static struct regmap_config tps65217_regmap_config = {
         .reg_bits = 8,
         .val_bits = 8,
@@ -141,10 +197,14 @@ static int __devinit tps65217_probe(struct i2c_client *client,
                                 const struct i2c_device_id *ids)
 {
         struct tps65217 *tps;
+        struct regulator_init_data *reg_data;
         struct tps65217_board *pdata = client->dev.platform_data;
         int i, ret;
         unsigned int version;
 
+        if (!pdata && client->dev.of_node)
+                pdata = tps65217_parse_dt(client);
+
         tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
         if (!tps)
                 return -ENOMEM;
@@ -182,8 +242,9 @@ static int __devinit tps65217_probe(struct i2c_client *client,
                 }
 
                 pdev->dev.parent = tps->dev;
-                platform_device_add_data(pdev, &pdata->tps65217_init_data[i],
-                                        sizeof(pdata->tps65217_init_data[i]));
+                pdev->dev.of_node = pdata->of_node[i];
+                reg_data = pdata->tps65217_init_data[i];
+                platform_device_add_data(pdev, reg_data, sizeof(*reg_data));
                 tps->regulator_pdev[i] = pdev;
 
                 platform_device_add(pdev);
@@ -212,6 +273,8 @@ MODULE_DEVICE_TABLE(i2c, tps65217_id_table);
 static struct i2c_driver tps65217_driver = {
         .driver         = {
                 .name   = "tps65217",
+                .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(tps65217_of_match),
         },
         .id_table       = tps65217_id_table,
         .probe          = tps65217_probe,
diff --git a/drivers/misc/mei/main.c b/drivers/misc/mei/main.c
index 7de13891e49e..783fcd7365bc 100644
--- a/drivers/misc/mei/main.c
+++ b/drivers/misc/mei/main.c
@@ -1147,7 +1147,7 @@ static int mei_pci_resume(struct device *device)
                 err = request_threaded_irq(pdev->irq,
                         NULL,
                         mei_interrupt_thread_handler,
-                        0, mei_driver_name, dev);
+                        IRQF_ONESHOT, mei_driver_name, dev);
         else
                 err = request_threaded_irq(pdev->irq,
                         mei_interrupt_quick_handler,
diff --git a/drivers/misc/sgi-xp/xpc_uv.c b/drivers/misc/sgi-xp/xpc_uv.c
index 17bbacb1b4b1..87b251ab6ec5 100644
--- a/drivers/misc/sgi-xp/xpc_uv.c
+++ b/drivers/misc/sgi-xp/xpc_uv.c
@@ -452,9 +452,9 @@ xpc_handle_activate_mq_msg_uv(struct xpc_partition *part,
 
                 if (msg->activate_gru_mq_desc_gpa !=
                     part_uv->activate_gru_mq_desc_gpa) {
-                        spin_lock_irqsave(&part_uv->flags_lock, irq_flags);
+                        spin_lock(&part_uv->flags_lock);
                         part_uv->flags &= ~XPC_P_CACHED_ACTIVATE_GRU_MQ_DESC_UV;
-                        spin_unlock_irqrestore(&part_uv->flags_lock, irq_flags);
+                        spin_unlock(&part_uv->flags_lock);
                         part_uv->activate_gru_mq_desc_gpa =
                             msg->activate_gru_mq_desc_gpa;
                 }
diff --git a/drivers/mmc/core/cd-gpio.c b/drivers/mmc/core/cd-gpio.c
index f13e38deceac..8f5dc08d6598 100644
--- a/drivers/mmc/core/cd-gpio.c
+++ b/drivers/mmc/core/cd-gpio.c
@@ -50,8 +50,8 @@ int mmc_cd_gpio_request(struct mmc_host *host, unsigned int gpio)
                 goto egpioreq;
 
         ret = request_threaded_irq(irq, NULL, mmc_cd_gpio_irqt,
-                                   IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
-                                   cd->label, host);
+                                   IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING |
+                                   IRQF_ONESHOT, cd->label, host);
         if (ret < 0)
                 goto eirqreq;
 
diff --git a/drivers/mmc/core/mmc.c b/drivers/mmc/core/mmc.c
index 258b203397aa..4f4489aa6bae 100644
--- a/drivers/mmc/core/mmc.c
+++ b/drivers/mmc/core/mmc.c
@@ -717,10 +717,6 @@ static int mmc_select_powerclass(struct mmc_card *card,
                                  card->ext_csd.generic_cmd6_time);
         }
 
-        if (err)
-                pr_err("%s: power class selection for ext_csd_bus_width %d"
-                       " failed\n", mmc_hostname(card->host), bus_width);
-
         return err;
 }
 
@@ -1104,7 +1100,9 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                                 EXT_CSD_BUS_WIDTH_8 : EXT_CSD_BUS_WIDTH_4;
                 err = mmc_select_powerclass(card, ext_csd_bits, ext_csd);
                 if (err)
-                        goto err;
+                        pr_warning("%s: power class selection to bus width %d"
+                                   " failed\n", mmc_hostname(card->host),
+                                   1 << bus_width);
         }
 
         /*
@@ -1136,7 +1134,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][0],
                                                     ext_csd);
                         if (err)
-                                goto err;
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
@@ -1164,7 +1165,10 @@ static int mmc_init_card(struct mmc_host *host, u32 ocr,
                         err = mmc_select_powerclass(card, ext_csd_bits[idx][1],
                                                     ext_csd);
                         if (err)
-                                goto err;
+                                pr_warning("%s: power class selection to "
+                                           "bus width %d ddr %d failed\n",
+                                           mmc_hostname(card->host),
+                                           1 << bus_width, ddr);
 
                         err = mmc_switch(card, EXT_CSD_CMD_SET_NORMAL,
                                          EXT_CSD_BUS_WIDTH,
diff --git a/drivers/mtd/nand/cafe_nand.c b/drivers/mtd/nand/cafe_nand.c
index 41371ba1a811..f3f6cfedd69e 100644
--- a/drivers/mtd/nand/cafe_nand.c
+++ b/drivers/mtd/nand/cafe_nand.c
@@ -102,7 +102,7 @@ static const char *part_probes[] = { "cmdlinepart", "RedBoot", NULL };
 static int cafe_device_ready(struct mtd_info *mtd)
 {
         struct cafe_priv *cafe = mtd->priv;
-        int result = !!(cafe_readl(cafe, NAND_STATUS) | 0x40000000);
+        int result = !!(cafe_readl(cafe, NAND_STATUS) & 0x40000000);
         uint32_t irqs = cafe_readl(cafe, NAND_IRQ);
 
         cafe_writel(cafe, irqs, NAND_IRQ);
diff --git a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
index a05b7b444d4f..a6cad5caba78 100644
--- a/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
+++ b/drivers/mtd/nand/gpmi-nand/gpmi-nand.c
@@ -920,12 +920,12 @@ static int gpmi_ecc_read_page(struct mtd_info *mtd, struct nand_chip *chip,
                  */
                 memset(chip->oob_poi, ~0, mtd->oobsize);
                 chip->oob_poi[0] = ((uint8_t *) auxiliary_virt)[0];
-
-                read_page_swap_end(this, buf, mtd->writesize,
-                                this->payload_virt, this->payload_phys,
-                                nfc_geo->payload_size,
-                                payload_virt, payload_phys);
         }
+
+        read_page_swap_end(this, buf, mtd->writesize,
+                        this->payload_virt, this->payload_phys,
+                        nfc_geo->payload_size,
+                        payload_virt, payload_phys);
 exit_nfc:
         return ret;
 }
diff --git a/drivers/mtd/nand/mxc_nand.c b/drivers/mtd/nand/mxc_nand.c
index c58e6a93f445..6acc790c2fbb 100644
--- a/drivers/mtd/nand/mxc_nand.c
+++ b/drivers/mtd/nand/mxc_nand.c
@@ -273,6 +273,26 @@ static struct nand_ecclayout nandv2_hw_eccoob_4k = {
 
 static const char *part_probes[] = { "RedBoot", "cmdlinepart", "ofpart", NULL };
 
+static void memcpy32_fromio(void *trg, const void __iomem  *src, size_t size)
+{
+        int i;
+        u32 *t = trg;
+        const __iomem u32 *s = src;
+
+        for (i = 0; i < (size >> 2); i++)
+                *t++ = __raw_readl(s++);
+}
+
+static void memcpy32_toio(void __iomem *trg, const void *src, int size)
+{
+        int i;
+        u32 __iomem *t = trg;
+        const u32 *s = src;
+
+        for (i = 0; i < (size >> 2); i++)
+                __raw_writel(*s++, t++);
+}
+
 static int check_int_v3(struct mxc_nand_host *host)
 {
         uint32_t tmp;
@@ -519,7 +539,7 @@ static void send_read_id_v3(struct mxc_nand_host *host)
 
         wait_op_done(host, true);
 
-        memcpy_fromio(host->data_buf, host->main_area0, 16);
+        memcpy32_fromio(host->data_buf, host->main_area0, 16);
 }
 
 /* Request the NANDFC to perform a read of the NAND device ID. */
@@ -535,7 +555,7 @@ static void send_read_id_v1_v2(struct mxc_nand_host *host)
         /* Wait for operation to complete */
         wait_op_done(host, true);
 
-        memcpy_fromio(host->data_buf, host->main_area0, 16);
+        memcpy32_fromio(host->data_buf, host->main_area0, 16);
 
         if (this->options & NAND_BUSWIDTH_16) {
                 /* compress the ID info */
@@ -797,16 +817,16 @@ static void copy_spare(struct mtd_info *mtd, bool bfrom)
 
         if (bfrom) {
                 for (i = 0; i < n - 1; i++)
-                        memcpy_fromio(d + i * j, s + i * t, j);
+                        memcpy32_fromio(d + i * j, s + i * t, j);
 
                 /* the last section */
-                memcpy_fromio(d + i * j, s + i * t, mtd->oobsize - i * j);
+                memcpy32_fromio(d + i * j, s + i * t, mtd->oobsize - i * j);
         } else {
                 for (i = 0; i < n - 1; i++)
-                        memcpy_toio(&s[i * t], &d[i * j], j);
+                        memcpy32_toio(&s[i * t], &d[i * j], j);
 
                 /* the last section */
-                memcpy_toio(&s[i * t], &d[i * j], mtd->oobsize - i * j);
+                memcpy32_toio(&s[i * t], &d[i * j], mtd->oobsize - i * j);
         }
 }
 
@@ -1070,7 +1090,8 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
 
                 host->devtype_data->send_page(mtd, NFC_OUTPUT);
 
-                memcpy_fromio(host->data_buf, host->main_area0, mtd->writesize);
+                memcpy32_fromio(host->data_buf, host->main_area0,
+                                mtd->writesize);
                 copy_spare(mtd, true);
                 break;
 
@@ -1086,7 +1107,7 @@ static void mxc_nand_command(struct mtd_info *mtd, unsigned command,
                 break;
 
         case NAND_CMD_PAGEPROG:
-                memcpy_toio(host->main_area0, host->data_buf, mtd->writesize);
+                memcpy32_toio(host->main_area0, host->data_buf, mtd->writesize);
                 copy_spare(mtd, false);
                 host->devtype_data->send_page(mtd, NFC_INPUT);
                 host->devtype_data->send_cmd(host, command, true);
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index d47586cf64ce..a11253a0fcab 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -3501,6 +3501,13 @@ int nand_scan_tail(struct mtd_info *mtd)
         /* propagate ecc info to mtd_info */
         mtd->ecclayout = chip->ecc.layout;
         mtd->ecc_strength = chip->ecc.strength;
+        /*
+         * Initialize bitflip_threshold to its default prior scan_bbt() call.
+         * scan_bbt() might invoke mtd_read(), thus bitflip_threshold must be
+         * properly set.
+         */
+        if (!mtd->bitflip_threshold)
+                mtd->bitflip_threshold = mtd->ecc_strength;
 
         /* Check, if we should skip the bad block table scan */
         if (chip->options & NAND_SKIP_BBTSCAN)
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 6cc8fbfabb8e..cf0cd3146817 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -28,7 +28,7 @@
 #include <linux/module.h>
 #include <linux/moduleparam.h>
 #include <linux/vmalloc.h>
-#include <asm/div64.h>
+#include <linux/math64.h>
 #include <linux/slab.h>
 #include <linux/errno.h>
 #include <linux/string.h>
@@ -546,12 +546,6 @@ static char *get_partition_name(int i)
         return kstrdup(buf, GFP_KERNEL);
 }
 
-static uint64_t divide(uint64_t n, uint32_t d)
-{
-        do_div(n, d);
-        return n;
-}
-
 /*
  * Initialize the nandsim structure.
  *
@@ -580,7 +574,7 @@ static int init_nandsim(struct mtd_info *mtd)
         ns->geom.oobsz    = mtd->oobsize;
         ns->geom.secsz    = mtd->erasesize;
         ns->geom.pgszoob  = ns->geom.pgsz + ns->geom.oobsz;
-        ns->geom.pgnum    = divide(ns->geom.totsz, ns->geom.pgsz);
+        ns->geom.pgnum    = div_u64(ns->geom.totsz, ns->geom.pgsz);
         ns->geom.totszoob = ns->geom.totsz + (uint64_t)ns->geom.pgnum * ns->geom.oobsz;
         ns->geom.secshift = ffs(ns->geom.secsz) - 1;
         ns->geom.pgshift  = chip->page_shift;
@@ -921,7 +915,7 @@ static int setup_wear_reporting(struct mtd_info *mtd)
 
         if (!rptwear)
                 return 0;
-        wear_eb_count = divide(mtd->size, mtd->erasesize);
+        wear_eb_count = div_u64(mtd->size, mtd->erasesize);
         mem = wear_eb_count * sizeof(unsigned long);
         if (mem / sizeof(unsigned long) != wear_eb_count) {
                 NS_ERR("Too many erase blocks for wear reporting\n");
diff --git a/drivers/net/ethernet/freescale/gianfar.c b/drivers/net/ethernet/freescale/gianfar.c
index 0741aded9eb0..f2db8fca46a1 100644
--- a/drivers/net/ethernet/freescale/gianfar.c
+++ b/drivers/net/ethernet/freescale/gianfar.c
@@ -1804,18 +1804,16 @@ void gfar_configure_coalescing(struct gfar_private *priv,
         if (priv->mode == MQ_MG_MODE) {
                 baddr = &regs->txic0;
                 for_each_set_bit(i, &tx_mask, priv->num_tx_queues) {
-                        if (likely(priv->tx_queue[i]->txcoalescing)) {
-                                gfar_write(baddr + i, 0);
+                        gfar_write(baddr + i, 0);
+                        if (likely(priv->tx_queue[i]->txcoalescing))
                                 gfar_write(baddr + i, priv->tx_queue[i]->txic);
-                        }
                 }
 
                 baddr = &regs->rxic0;
                 for_each_set_bit(i, &rx_mask, priv->num_rx_queues) {
-                        if (likely(priv->rx_queue[i]->rxcoalescing)) {
-                                gfar_write(baddr + i, 0);
+                        gfar_write(baddr + i, 0);
+                        if (likely(priv->rx_queue[i]->rxcoalescing))
                                 gfar_write(baddr + i, priv->rx_queue[i]->rxic);
-                        }
                 }
         }
 }
diff --git a/drivers/net/ethernet/intel/e1000e/defines.h b/drivers/net/ethernet/intel/e1000e/defines.h
index 351a4097b2ba..76edbc1be33b 100644
--- a/drivers/net/ethernet/intel/e1000e/defines.h
+++ b/drivers/net/ethernet/intel/e1000e/defines.h
@@ -103,6 +103,7 @@
 #define E1000_RXD_ERR_SEQ       0x04    /* Sequence Error */
 #define E1000_RXD_ERR_CXE       0x10    /* Carrier Extension Error */
 #define E1000_RXD_ERR_TCPE      0x20    /* TCP/UDP Checksum Error */
+#define E1000_RXD_ERR_IPE       0x40    /* IP Checksum Error */
 #define E1000_RXD_ERR_RXE       0x80    /* Rx Data Error */
 #define E1000_RXD_SPC_VLAN_MASK 0x0FFF  /* VLAN ID is in lower 12 bits */
 
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 31d37a2b5ba8..623e30b9964d 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -496,7 +496,7 @@ static void e1000_receive_skb(struct e1000_adapter *adapter,
  * @sk_buff: socket buffer with received data
  **/
 static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
-                              __le16 csum, struct sk_buff *skb)
+                              struct sk_buff *skb)
 {
         u16 status = (u16)status_err;
         u8 errors = (u8)(status_err >> 24);
@@ -511,8 +511,8 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
         if (status & E1000_RXD_STAT_IXSM)
                 return;
 
-        /* TCP/UDP checksum error bit is set */
-        if (errors & E1000_RXD_ERR_TCPE) {
+        /* TCP/UDP checksum error bit or IP checksum error bit is set */
+        if (errors & (E1000_RXD_ERR_TCPE | E1000_RXD_ERR_IPE)) {
                 /* let the stack verify checksum errors */
                 adapter->hw_csum_err++;
                 return;
@@ -523,19 +523,7 @@ static void e1000_rx_checksum(struct e1000_adapter *adapter, u32 status_err,
                 return;
 
         /* It must be a TCP or UDP packet with a valid checksum */
-        if (status & E1000_RXD_STAT_TCPCS) {
-                /* TCP checksum is good */
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
-        } else {
-                /*
-                 * IP fragment with UDP payload
-                 * Hardware complements the payload checksum, so we undo it
-                 * and then put the value in host order for further stack use.
-                 */
-                __sum16 sum = (__force __sum16)swab16((__force u16)csum);
-                skb->csum = csum_unfold(~sum);
-                skb->ip_summed = CHECKSUM_COMPLETE;
-        }
+        skb->ip_summed = CHECKSUM_UNNECESSARY;
         adapter->hw_csum_good++;
 }
 
@@ -954,8 +942,7 @@ static bool e1000_clean_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                 skb_put(skb, length);
 
                 /* Receive Checksum Offload */
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -1341,8 +1328,7 @@ copydone:
                 total_rx_bytes += skb->len;
                 total_rx_packets++;
 
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -1512,9 +1498,8 @@ static bool e1000_clean_jumbo_rx_irq(struct e1000_ring *rx_ring, int *work_done,
                         }
                 }
 
-                /* Receive Checksum Offload XXX recompute due to CRC strip? */
-                e1000_rx_checksum(adapter, staterr,
-                                  rx_desc->wb.lower.hi_dword.csum_ip.csum, skb);
+                /* Receive Checksum Offload */
+                e1000_rx_checksum(adapter, staterr, skb);
 
                 e1000_rx_hash(netdev, rx_desc->wb.lower.hi_dword.rss, skb);
 
@@ -3098,19 +3083,10 @@ static void e1000_configure_rx(struct e1000_adapter *adapter)
 
         /* Enable Receive Checksum Offload for TCP and UDP */
         rxcsum = er32(RXCSUM);
-        if (adapter->netdev->features & NETIF_F_RXCSUM) {
+        if (adapter->netdev->features & NETIF_F_RXCSUM)
                 rxcsum |= E1000_RXCSUM_TUOFL;
-
-                /*
-                 * IPv4 payload checksum for UDP fragments must be
-                 * used in conjunction with packet-split.
-                 */
-                if (adapter->rx_ps_pages)
-                        rxcsum |= E1000_RXCSUM_IPPCSE;
-        } else {
+        else
                 rxcsum &= ~E1000_RXCSUM_TUOFL;
-                /* no need to clear IPPCSE as it defaults to 0 */
-        }
         ew32(RXCSUM, rxcsum);
 
         if (adapter->hw.mac.type == e1000_pch2lan) {
@@ -5241,22 +5217,10 @@ static int e1000_change_mtu(struct net_device *netdev, int new_mtu)
         int max_frame = new_mtu + ETH_HLEN + ETH_FCS_LEN;
 
         /* Jumbo frame support */
-        if (max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) {
-                if (!(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
-                        e_err("Jumbo Frames not supported.\n");
-                        return -EINVAL;
-                }
-
-                /*
-                 * IP payload checksum (enabled with jumbos/packet-split when
-                 * Rx checksum is enabled) and generation of RSS hash is
-                 * mutually exclusive in the hardware.
-                 */
-                if ((netdev->features & NETIF_F_RXCSUM) &&
-                    (netdev->features & NETIF_F_RXHASH)) {
-                        e_err("Jumbo frames cannot be enabled when both receive checksum offload and receive hashing are enabled.  Disable one of the receive offload features before enabling jumbos.\n");
-                        return -EINVAL;
-                }
+        if ((max_frame > ETH_FRAME_LEN + ETH_FCS_LEN) &&
+            !(adapter->flags & FLAG_HAS_JUMBO_FRAMES)) {
+                e_err("Jumbo Frames not supported.\n");
+                return -EINVAL;
         }
 
         /* Supported frame sizes */
@@ -6030,17 +5994,6 @@ static int e1000_set_features(struct net_device *netdev,
                          NETIF_F_RXALL)))
                 return 0;
 
-        /*
-         * IP payload checksum (enabled with jumbos/packet-split when Rx
-         * checksum is enabled) and generation of RSS hash is mutually
-         * exclusive in the hardware.
-         */
-        if (adapter->rx_ps_pages &&
-            (features & NETIF_F_RXCSUM) && (features & NETIF_F_RXHASH)) {
-                e_err("Enabling both receive checksum offload and receive hashing is not possible with jumbo frames.  Disable jumbos or enable only one of the receive offload features.\n");
-                return -EINVAL;
-        }
-
         if (changed & NETIF_F_RXFCS) {
                 if (features & NETIF_F_RXFCS) {
                         adapter->flags2 &= ~FLAG2_CRC_STRIPPING;
diff --git a/drivers/net/ethernet/intel/igbvf/ethtool.c b/drivers/net/ethernet/intel/igbvf/ethtool.c
index 8ce67064b9c5..90eef07943f4 100644
--- a/drivers/net/ethernet/intel/igbvf/ethtool.c
+++ b/drivers/net/ethernet/intel/igbvf/ethtool.c
@@ -357,21 +357,28 @@ static int igbvf_set_coalesce(struct net_device *netdev,
         struct igbvf_adapter *adapter = netdev_priv(netdev);
         struct e1000_hw *hw = &adapter->hw;
 
-        if ((ec->rx_coalesce_usecs > IGBVF_MAX_ITR_USECS) ||
-            ((ec->rx_coalesce_usecs > 3) &&
-             (ec->rx_coalesce_usecs < IGBVF_MIN_ITR_USECS)) ||
-            (ec->rx_coalesce_usecs == 2))
-                return -EINVAL;
-
-        /* convert to rate of irq's per second */
-        if (ec->rx_coalesce_usecs && ec->rx_coalesce_usecs <= 3) {
+        if ((ec->rx_coalesce_usecs >= IGBVF_MIN_ITR_USECS) &&
+             (ec->rx_coalesce_usecs <= IGBVF_MAX_ITR_USECS)) {
+                adapter->current_itr = ec->rx_coalesce_usecs << 2;
+                adapter->requested_itr = 1000000000 /
+                                        (adapter->current_itr * 256);
+        } else if ((ec->rx_coalesce_usecs == 3) ||
+                   (ec->rx_coalesce_usecs == 2)) {
                 adapter->current_itr = IGBVF_START_ITR;
                 adapter->requested_itr = ec->rx_coalesce_usecs;
-        } else {
-                adapter->current_itr = ec->rx_coalesce_usecs << 2;
+        } else if (ec->rx_coalesce_usecs == 0) {
+                /*
+                 * The user's desire is to turn off interrupt throttling
+                 * altogether, but due to HW limitations, we can't do that.
+                 * Instead we set a very small value in EITR, which would
+                 * allow ~967k interrupts per second, but allow the adapter's
+                 * internal clocking to still function properly.
+                 */
+                adapter->current_itr = 4;
                 adapter->requested_itr = 1000000000 /
                                         (adapter->current_itr * 256);
-        }
+        } else
+                return -EINVAL;
 
         writel(adapter->current_itr,
                hw->hw_addr + adapter->rx_ring->itr_register);
diff --git a/drivers/net/ethernet/ti/davinci_cpdma.c b/drivers/net/ethernet/ti/davinci_cpdma.c
index d614c374ed9d..3b5c4571b55e 100644
--- a/drivers/net/ethernet/ti/davinci_cpdma.c
+++ b/drivers/net/ethernet/ti/davinci_cpdma.c
@@ -15,6 +15,7 @@
 #include <linux/kernel.h>
 #include <linux/spinlock.h>
 #include <linux/device.h>
+#include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/err.h>
 #include <linux/dma-mapping.h>
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 3767a1225860..b01960fcfbc9 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -197,6 +197,10 @@ err:
 static int qmi_wwan_cdc_wdm_manage_power(struct usb_interface *intf, int on)
 {
         struct usbnet *dev = usb_get_intfdata(intf);
+
+        /* can be called while disconnecting */
+        if (!dev)
+                return 0;
         return qmi_wwan_manage_power(dev, on);
 }
 
diff --git a/drivers/net/wireless/ath/ath.h b/drivers/net/wireless/ath/ath.h
index c54b7d37bff1..420d69b2674c 100644
--- a/drivers/net/wireless/ath/ath.h
+++ b/drivers/net/wireless/ath/ath.h
@@ -143,6 +143,7 @@ struct ath_common {
         u32 keymax;
         DECLARE_BITMAP(keymap, ATH_KEYMAX);
         DECLARE_BITMAP(tkip_keymap, ATH_KEYMAX);
+        DECLARE_BITMAP(ccmp_keymap, ATH_KEYMAX);
         enum ath_crypt_caps crypt_caps;
 
         unsigned int clockrate;
diff --git a/drivers/net/wireless/ath/ath9k/hw.c b/drivers/net/wireless/ath/ath9k/hw.c
index 1c68e564f503..995ca8e1302e 100644
--- a/drivers/net/wireless/ath/ath9k/hw.c
+++ b/drivers/net/wireless/ath/ath9k/hw.c
@@ -622,7 +622,7 @@ static int __ath9k_hw_init(struct ath_hw *ah)
 
         if (NR_CPUS > 1 && ah->config.serialize_regmode == SER_REG_MODE_AUTO) {
                 if (ah->hw_version.macVersion == AR_SREV_VERSION_5416_PCI ||
-                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah)) &&
+                    ((AR_SREV_9160(ah) || AR_SREV_9280(ah) || AR_SREV_9287(ah)) &&
                      !ah->is_pciexpress)) {
                         ah->config.serialize_regmode =
                                 SER_REG_MODE_ON;
diff --git a/drivers/net/wireless/ath/ath9k/recv.c b/drivers/net/wireless/ath/ath9k/recv.c
index e1fcc68124dc..0735aeb3b26c 100644
--- a/drivers/net/wireless/ath/ath9k/recv.c
+++ b/drivers/net/wireless/ath/ath9k/recv.c
@@ -695,9 +695,9 @@ static bool ath_edma_get_buffers(struct ath_softc *sc,
                         __skb_unlink(skb, &rx_edma->rx_fifo);
                         list_add_tail(&bf->list, &sc->rx.rxbuf);
                         ath_rx_edma_buf_link(sc, qtype);
-                } else {
-                        bf = NULL;
                 }
+
+                bf = NULL;
         }
 
         *dest = bf;
@@ -822,7 +822,8 @@ static bool ath9k_rx_accept(struct ath_common *common,
          * descriptor does contain a valid key index. This has been observed
          * mostly with CCMP encryption.
          */
-        if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID)
+        if (rx_stats->rs_keyix == ATH9K_RXKEYIX_INVALID ||
+            !test_bit(rx_stats->rs_keyix, common->ccmp_keymap))
                 rx_stats->rs_status &= ~ATH9K_RXERR_KEYMISS;
 
         if (!rx_stats->rs_datalen) {
diff --git a/drivers/net/wireless/ath/key.c b/drivers/net/wireless/ath/key.c
index 0e81904956cf..5c54aa43ca2d 100644
--- a/drivers/net/wireless/ath/key.c
+++ b/drivers/net/wireless/ath/key.c
@@ -556,6 +556,9 @@ int ath_key_config(struct ath_common *common,
                 return -EIO;
 
         set_bit(idx, common->keymap);
+        if (key->cipher == WLAN_CIPHER_SUITE_CCMP)
+                set_bit(idx, common->ccmp_keymap);
+
         if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
                 set_bit(idx + 64, common->keymap);
                 set_bit(idx, common->tkip_keymap);
@@ -582,6 +585,7 @@ void ath_key_delete(struct ath_common *common, struct ieee80211_key_conf *key)
                 return;
 
         clear_bit(key->hw_key_idx, common->keymap);
+        clear_bit(key->hw_key_idx, common->ccmp_keymap);
         if (key->cipher != WLAN_CIPHER_SUITE_TKIP)
                 return;
 
diff --git a/drivers/net/wireless/iwlwifi/iwl-mac80211.c b/drivers/net/wireless/iwlwifi/iwl-mac80211.c
index 3ee23134c02b..013680332f07 100644
--- a/drivers/net/wireless/iwlwifi/iwl-mac80211.c
+++ b/drivers/net/wireless/iwlwifi/iwl-mac80211.c
@@ -796,6 +796,18 @@ int iwlagn_mac_sta_state(struct ieee80211_hw *hw,
         switch (op) {
         case ADD:
                 ret = iwlagn_mac_sta_add(hw, vif, sta);
+                if (ret)
+                        break;
+                /*
+                 * Clear the in-progress flag, the AP station entry was added
+                 * but we'll initialize LQ only when we've associated (which
+                 * would also clear the in-progress flag). This is necessary
+                 * in case we never initialize LQ because association fails.
+                 */
+                spin_lock_bh(&priv->sta_lock);
+                priv->stations[iwl_sta_id(sta)].used &=
+                        ~IWL_STA_UCODE_INPROGRESS;
+                spin_unlock_bh(&priv->sta_lock);
                 break;
         case REMOVE:
                 ret = iwlagn_mac_sta_remove(hw, vif, sta);
diff --git a/drivers/net/wireless/mwifiex/11n_rxreorder.c b/drivers/net/wireless/mwifiex/11n_rxreorder.c
index 9c44088054dd..900ee129e825 100644
--- a/drivers/net/wireless/mwifiex/11n_rxreorder.c
+++ b/drivers/net/wireless/mwifiex/11n_rxreorder.c
@@ -256,7 +256,8 @@ mwifiex_11n_create_rx_reorder_tbl(struct mwifiex_private *priv, u8 *ta,
         else
                 last_seq = priv->rx_seq[tid];
 
-        if (last_seq >= new_node->start_win)
+        if (last_seq != MWIFIEX_DEF_11N_RX_SEQ_NUM &&
+            last_seq >= new_node->start_win)
                 new_node->start_win = last_seq + 1;
 
         new_node->win_size = win_size;
@@ -596,5 +597,5 @@ void mwifiex_11n_cleanup_reorder_tbl(struct mwifiex_private *priv)
         spin_unlock_irqrestore(&priv->rx_reorder_tbl_lock, flags);
 
         INIT_LIST_HEAD(&priv->rx_reorder_tbl_ptr);
-        memset(priv->rx_seq, 0, sizeof(priv->rx_seq));
+        mwifiex_reset_11n_rx_seq_num(priv);
 }
diff --git a/drivers/net/wireless/mwifiex/11n_rxreorder.h b/drivers/net/wireless/mwifiex/11n_rxreorder.h
index f1bffebabc60..6c9815a0f5d8 100644
--- a/drivers/net/wireless/mwifiex/11n_rxreorder.h
+++ b/drivers/net/wireless/mwifiex/11n_rxreorder.h
@@ -37,6 +37,13 @@
 
 #define ADDBA_RSP_STATUS_ACCEPT 0
 
+#define MWIFIEX_DEF_11N_RX_SEQ_NUM      0xffff
+
+static inline void mwifiex_reset_11n_rx_seq_num(struct mwifiex_private *priv)
+{
+        memset(priv->rx_seq, 0xff, sizeof(priv->rx_seq));
+}
+
 int mwifiex_11n_rx_reorder_pkt(struct mwifiex_private *,
                                u16 seqNum,
                                u16 tid, u8 *ta,
diff --git a/drivers/net/wireless/mwifiex/ie.c b/drivers/net/wireless/mwifiex/ie.c
index ceb82cd749cc..383820a52beb 100644
--- a/drivers/net/wireless/mwifiex/ie.c
+++ b/drivers/net/wireless/mwifiex/ie.c
@@ -213,6 +213,7 @@ mwifiex_update_uap_custom_ie(struct mwifiex_private *priv,
                 /* save assoc resp ie index after auto-indexing */
                 *assoc_idx = *((u16 *)pos);
 
+        kfree(ap_custom_ie);
         return ret;
 }
 
diff --git a/drivers/net/wireless/mwifiex/sdio.c b/drivers/net/wireless/mwifiex/sdio.c
index e0377473282f..fc8a9bfa1248 100644
--- a/drivers/net/wireless/mwifiex/sdio.c
+++ b/drivers/net/wireless/mwifiex/sdio.c
@@ -978,10 +978,10 @@ static int mwifiex_decode_rx_packet(struct mwifiex_adapter *adapter,
                 dev_dbg(adapter->dev, "info: --- Rx: Event ---\n");
                 adapter->event_cause = *(u32 *) skb->data;
 
-                skb_pull(skb, MWIFIEX_EVENT_HEADER_LEN);
-
                 if ((skb->len > 0) && (skb->len  < MAX_EVENT_SIZE))
-                        memcpy(adapter->event_body, skb->data, skb->len);
+                        memcpy(adapter->event_body,
+                               skb->data + MWIFIEX_EVENT_HEADER_LEN,
+                               skb->len);
 
                 /* event cause has been saved to adapter->event_cause */
                 adapter->event_received = true;
diff --git a/drivers/net/wireless/mwifiex/sta_event.c b/drivers/net/wireless/mwifiex/sta_event.c
index 4ace5a3dcd23..11e731f3581c 100644
--- a/drivers/net/wireless/mwifiex/sta_event.c
+++ b/drivers/net/wireless/mwifiex/sta_event.c
@@ -406,9 +406,9 @@ int mwifiex_process_sta_event(struct mwifiex_private *priv)
                 break;
 
         case EVENT_UAP_STA_ASSOC:
-                skb_pull(adapter->event_skb, MWIFIEX_UAP_EVENT_EXTRA_HEADER);
                 memset(&sinfo, 0, sizeof(sinfo));
-                event = (struct mwifiex_assoc_event *)adapter->event_skb->data;
+                event = (struct mwifiex_assoc_event *)
+                        (adapter->event_body + MWIFIEX_UAP_EVENT_EXTRA_HEADER);
                 if (le16_to_cpu(event->type) == TLV_TYPE_UAP_MGMT_FRAME) {
                         len = -1;
 
@@ -433,9 +433,8 @@ int mwifiex_process_sta_event(struct mwifiex_private *priv)
                                  GFP_KERNEL);
                 break;
         case EVENT_UAP_STA_DEAUTH:
-                skb_pull(adapter->event_skb, MWIFIEX_UAP_EVENT_EXTRA_HEADER);
-                cfg80211_del_sta(priv->netdev, adapter->event_skb->data,
-                                 GFP_KERNEL);
+                cfg80211_del_sta(priv->netdev, adapter->event_body +
+                                 MWIFIEX_UAP_EVENT_EXTRA_HEADER, GFP_KERNEL);
                 break;
         case EVENT_UAP_BSS_IDLE:
                 priv->media_connected = false;
diff --git a/drivers/net/wireless/mwifiex/usb.c b/drivers/net/wireless/mwifiex/usb.c
index 49ebf20c56eb..22a5916564b8 100644
--- a/drivers/net/wireless/mwifiex/usb.c
+++ b/drivers/net/wireless/mwifiex/usb.c
@@ -49,6 +49,7 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
         struct device *dev = adapter->dev;
         u32 recv_type;
         __le32 tmp;
+        int ret;
 
         if (adapter->hs_activated)
                 mwifiex_process_hs_config(adapter);
@@ -69,16 +70,19 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
                 case MWIFIEX_USB_TYPE_CMD:
                         if (skb->len > MWIFIEX_SIZE_OF_CMD_BUFFER) {
                                 dev_err(dev, "CMD: skb->len too large\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         } else if (!adapter->curr_cmd) {
                                 dev_dbg(dev, "CMD: no curr_cmd\n");
                                 if (adapter->ps_state == PS_STATE_SLEEP_CFM) {
                                         mwifiex_process_sleep_confirm_resp(
                                                         adapter, skb->data,
                                                         skb->len);
-                                        return 0;
+                                        ret = 0;
+                                        goto exit_restore_skb;
                                 }
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
 
                         adapter->curr_cmd->resp_skb = skb;
@@ -87,20 +91,22 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
                 case MWIFIEX_USB_TYPE_EVENT:
                         if (skb->len < sizeof(u32)) {
                                 dev_err(dev, "EVENT: skb->len too small\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
                         skb_copy_from_linear_data(skb, &tmp, sizeof(u32));
                         adapter->event_cause = le32_to_cpu(tmp);
-                        skb_pull(skb, sizeof(u32));
                         dev_dbg(dev, "event_cause %#x\n", adapter->event_cause);
 
                         if (skb->len > MAX_EVENT_SIZE) {
                                 dev_err(dev, "EVENT: event body too large\n");
-                                return -1;
+                                ret = -1;
+                                goto exit_restore_skb;
                         }
 
-                        skb_copy_from_linear_data(skb, adapter->event_body,
-                                                  skb->len);
+                        memcpy(adapter->event_body, skb->data +
+                               MWIFIEX_EVENT_HEADER_LEN, skb->len);
+
                         adapter->event_received = true;
                         adapter->event_skb = skb;
                         break;
@@ -124,6 +130,12 @@ static int mwifiex_usb_recv(struct mwifiex_adapter *adapter,
         }
 
         return -EINPROGRESS;
+
+exit_restore_skb:
+        /* The buffer will be reused for further cmds/events */
+        skb_push(skb, INTF_HEADER_LEN);
+
+        return ret;
 }
 
 static void mwifiex_usb_rx_complete(struct urb *urb)
diff --git a/drivers/net/wireless/mwifiex/wmm.c b/drivers/net/wireless/mwifiex/wmm.c
index f3fc65515857..3fa4d4176993 100644
--- a/drivers/net/wireless/mwifiex/wmm.c
+++ b/drivers/net/wireless/mwifiex/wmm.c
@@ -404,6 +404,8 @@ mwifiex_wmm_init(struct mwifiex_adapter *adapter)
                 priv->add_ba_param.tx_win_size = MWIFIEX_AMPDU_DEF_TXWINSIZE;
                 priv->add_ba_param.rx_win_size = MWIFIEX_AMPDU_DEF_RXWINSIZE;
 
+                mwifiex_reset_11n_rx_seq_num(priv);
+
                 atomic_set(&priv->wmm.tx_pkts_queued, 0);
                 atomic_set(&priv->wmm.highest_queued_prio, HIGH_PRIO_TID);
         }
@@ -1221,6 +1223,7 @@ mwifiex_dequeue_tx_packet(struct mwifiex_adapter *adapter)
 
         if (!ptr->is_11n_enabled ||
             mwifiex_is_ba_stream_setup(priv, ptr, tid) ||
+            priv->wps.session_enable ||
             ((priv->sec_info.wpa_enabled ||
               priv->sec_info.wpa2_enabled) &&
              !priv->wpa_is_gtk_set)) {
diff --git a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
index d228358e6a40..9970c2b1b199 100644
--- a/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
+++ b/drivers/net/wireless/rtlwifi/rtl8192cu/sw.c
@@ -301,9 +301,11 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x07b8, 0x8188, rtl92cu_hal_cfg)}, /*Abocom - Abocom*/
         {RTL_USB_DEVICE(0x07b8, 0x8189, rtl92cu_hal_cfg)}, /*Funai - Abocom*/
         {RTL_USB_DEVICE(0x0846, 0x9041, rtl92cu_hal_cfg)}, /*NetGear WNA1000M*/
+        {RTL_USB_DEVICE(0x0bda, 0x5088, rtl92cu_hal_cfg)}, /*Thinkware-CC&C*/
         {RTL_USB_DEVICE(0x0df6, 0x0052, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
         {RTL_USB_DEVICE(0x0df6, 0x005c, rtl92cu_hal_cfg)}, /*Sitecom - Edimax*/
         {RTL_USB_DEVICE(0x0eb0, 0x9071, rtl92cu_hal_cfg)}, /*NO Brand - Etop*/
+        {RTL_USB_DEVICE(0x4856, 0x0091, rtl92cu_hal_cfg)}, /*NetweeN - Feixun*/
         /* HP - Lite-On ,8188CUS Slim Combo */
         {RTL_USB_DEVICE(0x103c, 0x1629, rtl92cu_hal_cfg)},
         {RTL_USB_DEVICE(0x13d3, 0x3357, rtl92cu_hal_cfg)}, /* AzureWave */
@@ -346,6 +348,7 @@ static struct usb_device_id rtl8192c_usb_ids[] = {
         {RTL_USB_DEVICE(0x07b8, 0x8178, rtl92cu_hal_cfg)}, /*Funai -Abocom*/
         {RTL_USB_DEVICE(0x0846, 0x9021, rtl92cu_hal_cfg)}, /*Netgear-Sercomm*/
         {RTL_USB_DEVICE(0x0b05, 0x17ab, rtl92cu_hal_cfg)}, /*ASUS-Edimax*/
+        {RTL_USB_DEVICE(0x0bda, 0x8186, rtl92cu_hal_cfg)}, /*Realtek 92CE-VAU*/
         {RTL_USB_DEVICE(0x0df6, 0x0061, rtl92cu_hal_cfg)}, /*Sitecom-Edimax*/
         {RTL_USB_DEVICE(0x0e66, 0x0019, rtl92cu_hal_cfg)}, /*Hawking-Edimax*/
         {RTL_USB_DEVICE(0x2001, 0x3307, rtl92cu_hal_cfg)}, /*D-Link-Cameo*/
diff --git a/drivers/net/wireless/ti/wlcore/Kconfig b/drivers/net/wireless/ti/wlcore/Kconfig
index 54156b0b5c2d..d7b907e67170 100644
--- a/drivers/net/wireless/ti/wlcore/Kconfig
+++ b/drivers/net/wireless/ti/wlcore/Kconfig
@@ -1,7 +1,6 @@
 config WLCORE
         tristate "TI wlcore support"
         depends on WL_TI && GENERIC_HARDIRQS && MAC80211
-        depends on INET
         select FW_LOADER
         ---help---
           This module contains the main code for TI WLAN chips.  It abstracts
diff --git a/drivers/of/platform.c b/drivers/of/platform.c
index 343ad29e211c..e44f8c2d239d 100644
--- a/drivers/of/platform.c
+++ b/drivers/of/platform.c
@@ -317,10 +317,9 @@ static const struct of_dev_auxdata *of_dev_lookup(const struct of_dev_auxdata *l
         for(; lookup->compatible != NULL; lookup++) {
                 if (!of_device_is_compatible(np, lookup->compatible))
                         continue;
-                if (of_address_to_resource(np, 0, &res))
-                        continue;
-                if (res.start != lookup->phys_addr)
-                        continue;
+                if (!of_address_to_resource(np, 0, &res))
+                        if (res.start != lookup->phys_addr)
+                                continue;
                 pr_debug("%s: devname=%s\n", np->full_name, lookup->name);
                 return lookup;
         }
@@ -462,4 +461,5 @@ int of_platform_populate(struct device_node *root,
         of_node_put(root);
         return rc;
 }
+EXPORT_SYMBOL_GPL(of_platform_populate);
 #endif /* CONFIG_OF_ADDRESS */
diff --git a/drivers/pci/pci-driver.c b/drivers/pci/pci-driver.c
index bf0cee629b60..099f46cd8e87 100644
--- a/drivers/pci/pci-driver.c
+++ b/drivers/pci/pci-driver.c
@@ -748,6 +748,18 @@ static int pci_pm_suspend_noirq(struct device *dev)
 
         pci_pm_set_unknown_state(pci_dev);
 
+        /*
+         * Some BIOSes from ASUS have a bug: If a USB EHCI host controller's
+         * PCI COMMAND register isn't 0, the BIOS assumes that the controller
+         * hasn't been quiesced and tries to turn it off.  If the controller
+         * is already in D3, this can hang or cause memory corruption.
+         *
+         * Since the value of the COMMAND register doesn't matter once the
+         * device has been suspended, we can safely set it to 0 here.
+         */
+        if (pci_dev->class == PCI_CLASS_SERIAL_USB_EHCI)
+                pci_write_config_word(pci_dev, PCI_COMMAND, 0);
+
         return 0;
 }
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index 77cb54a65cde..447e83472c01 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -1744,11 +1744,6 @@ int pci_prepare_to_sleep(struct pci_dev *dev)
         if (target_state == PCI_POWER_ERROR)
                 return -EIO;
 
-        /* Some devices mustn't be in D3 during system sleep */
-        if (target_state == PCI_D3hot &&
-                        (dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP))
-                return 0;
-
         pci_enable_wake(dev, target_state, device_may_wakeup(&dev->dev));
 
         error = pci_set_power_state(dev, target_state);
diff --git a/drivers/pci/quirks.c b/drivers/pci/quirks.c
index 194b243a2817..2a7521677541 100644
--- a/drivers/pci/quirks.c
+++ b/drivers/pci/quirks.c
@@ -2929,32 +2929,6 @@ static void __devinit disable_igfx_irq(struct pci_dev *dev)
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x0102, disable_igfx_irq);
 DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x010a, disable_igfx_irq);
 
-/*
- * The Intel 6 Series/C200 Series chipset's EHCI controllers on many
- * ASUS motherboards will cause memory corruption or a system crash
- * if they are in D3 while the system is put into S3 sleep.
- */
-static void __devinit asus_ehci_no_d3(struct pci_dev *dev)
-{
-        const char *sys_info;
-        static const char good_Asus_board[] = "P8Z68-V";
-
-        if (dev->dev_flags & PCI_DEV_FLAGS_NO_D3_DURING_SLEEP)
-                return;
-        if (dev->subsystem_vendor != PCI_VENDOR_ID_ASUSTEK)
-                return;
-        sys_info = dmi_get_system_info(DMI_BOARD_NAME);
-        if (sys_info && memcmp(sys_info, good_Asus_board,
-                        sizeof(good_Asus_board) - 1) == 0)
-                return;
-
-        dev_info(&dev->dev, "broken D3 during system sleep on ASUS\n");
-        dev->dev_flags |= PCI_DEV_FLAGS_NO_D3_DURING_SLEEP;
-        device_set_wakeup_capable(&dev->dev, false);
-}
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c26, asus_ehci_no_d3);
-DECLARE_PCI_FIXUP_FINAL(PCI_VENDOR_ID_INTEL, 0x1c2d, asus_ehci_no_d3);
-
 static void pci_do_fixups(struct pci_dev *dev, struct pci_fixup *f,
                           struct pci_fixup *end)
 {
diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index c86b8864e411..f34c3be6c9fe 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -20,6 +20,7 @@ menuconfig REGULATOR
 
           If unsure, say no.
 
+
 if REGULATOR
 
 config REGULATOR_DEBUG
@@ -88,6 +89,13 @@ config REGULATOR_AAT2870
           If you have a AnalogicTech AAT2870 say Y to enable the
           regulator driver.
 
+config REGULATOR_ARIZONA
+        tristate "Wolfson Arizona class devices"
+        depends on MFD_ARIZONA
+        help
+          Support for the regulators found on Wolfson Arizona class
+          devices.
+
 config REGULATOR_DA903X
         tristate "Dialog Semiconductor DA9030/DA9034 regulators"
         depends on PMIC_DA903X
@@ -195,6 +203,14 @@ config REGULATOR_MAX8998
           via I2C bus. The provided regulator is suitable for S3C6410
           and S5PC1XX chips to control VCC_CORE and VCC_USIM voltages.
 
+config REGULATOR_MAX77686
+        tristate "Maxim 77686 regulator"
+        depends on MFD_MAX77686
+        help
+          This driver controls a Maxim 77686 regulator
+          via I2C bus. The provided regulator is suitable for
+          Exynos-4 chips to control VARM and VINT voltages.
+
 config REGULATOR_PCAP
         tristate "Motorola PCAP2 regulator driver"
         depends on EZX_PCAP
@@ -216,6 +232,19 @@ config REGULATOR_LP3972
          Say Y here to support the voltage regulators and convertors
          on National Semiconductors LP3972 PMIC
 
+config REGULATOR_LP872X
+        bool "TI/National Semiconductor LP8720/LP8725 voltage regulators"
+        depends on I2C=y
+        select REGMAP_I2C
+        help
+          This driver supports LP8720/LP8725 PMIC
+
+config REGULATOR_LP8788
+        bool "TI LP8788 Power Regulators"
+        depends on MFD_LP8788
+        help
+          This driver supports LP8788 voltage regulator chip.
+
 config REGULATOR_PCF50633
         tristate "NXP PCF50633 regulator driver"
         depends on MFD_PCF50633
@@ -233,6 +262,14 @@ config REGULATOR_RC5T583
           through regulator interface. The device supports multiple DCDC/LDO
           outputs which can be controlled by i2c communication.
 
+config REGULATOR_S2MPS11
+        tristate "Samsung S2MPS11 voltage regulator"
+        depends on MFD_SEC_CORE
+        help
+         This driver supports a Samsung S2MPS11 voltage output regulator
+         via I2C bus. S2MPS11 is comprised of high efficient Buck converters
+         including Dual-Phase Buck converter, Buck-Boost converter, various LDOs.
+
 config REGULATOR_S5M8767
         tristate "Samsung S5M8767A voltage regulator"
         depends on MFD_S5M_CORE
diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index 977fd46909ab..3342615cf25e 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -15,6 +15,7 @@ obj-$(CONFIG_REGULATOR_AB3100) += ab3100.o
 obj-$(CONFIG_REGULATOR_AB8500)  += ab8500.o
 obj-$(CONFIG_REGULATOR_AD5398) += ad5398.o
 obj-$(CONFIG_REGULATOR_ANATOP) += anatop-regulator.o
+obj-$(CONFIG_REGULATOR_ARIZONA) += arizona-micsupp.o arizona-ldo1.o
 obj-$(CONFIG_REGULATOR_DA903X)  += da903x.o
 obj-$(CONFIG_REGULATOR_DA9052)  += da9052-regulator.o
 obj-$(CONFIG_REGULATOR_DBX500_PRCMU) += dbx500-prcmu.o
@@ -23,6 +24,9 @@ obj-$(CONFIG_REGULATOR_GPIO) += gpio-regulator.o
 obj-$(CONFIG_REGULATOR_ISL6271A) += isl6271a-regulator.o
 obj-$(CONFIG_REGULATOR_LP3971) += lp3971.o
 obj-$(CONFIG_REGULATOR_LP3972) += lp3972.o
+obj-$(CONFIG_REGULATOR_LP872X) += lp872x.o
+obj-$(CONFIG_REGULATOR_LP8788) += lp8788-buck.o
+obj-$(CONFIG_REGULATOR_LP8788) += lp8788-ldo.o
 obj-$(CONFIG_REGULATOR_MAX1586) += max1586.o
 obj-$(CONFIG_REGULATOR_MAX8649) += max8649.o
 obj-$(CONFIG_REGULATOR_MAX8660) += max8660.o
@@ -30,6 +34,7 @@ obj-$(CONFIG_REGULATOR_MAX8925) += max8925-regulator.o
 obj-$(CONFIG_REGULATOR_MAX8952) += max8952.o
 obj-$(CONFIG_REGULATOR_MAX8997) += max8997.o
 obj-$(CONFIG_REGULATOR_MAX8998) += max8998.o
+obj-$(CONFIG_REGULATOR_MAX77686) += max77686.o
 obj-$(CONFIG_REGULATOR_MC13783) += mc13783-regulator.o
 obj-$(CONFIG_REGULATOR_MC13892) += mc13892-regulator.o
 obj-$(CONFIG_REGULATOR_MC13XXX_CORE) +=  mc13xxx-regulator-core.o
@@ -37,6 +42,7 @@ obj-$(CONFIG_REGULATOR_PALMAS) += palmas-regulator.o
 obj-$(CONFIG_REGULATOR_PCAP) += pcap-regulator.o
 obj-$(CONFIG_REGULATOR_PCF50633) += pcf50633-regulator.o
 obj-$(CONFIG_REGULATOR_RC5T583)  += rc5t583-regulator.o
+obj-$(CONFIG_REGULATOR_S2MPS11) += s2mps11.o
 obj-$(CONFIG_REGULATOR_S5M8767) += s5m8767.o
 obj-$(CONFIG_REGULATOR_TPS6105X) += tps6105x-regulator.o
 obj-$(CONFIG_REGULATOR_TPS62360) += tps62360-regulator.o
diff --git a/drivers/regulator/aat2870-regulator.c b/drivers/regulator/aat2870-regulator.c
index 06776ca945f2..6f45bfd22e83 100644
--- a/drivers/regulator/aat2870-regulator.c
+++ b/drivers/regulator/aat2870-regulator.c
@@ -33,11 +33,6 @@ struct aat2870_regulator {
         struct aat2870_data *aat2870;
         struct regulator_desc desc;
 
-        const int *voltages; /* uV */
-
-        int min_uV;
-        int max_uV;
-
         u8 enable_addr;
         u8 enable_shift;
         u8 enable_mask;
@@ -47,14 +42,6 @@ struct aat2870_regulator {
         u8 voltage_mask;
 };
 
-static int aat2870_ldo_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        struct aat2870_regulator *ri = rdev_get_drvdata(rdev);
-
-        return ri->voltages[selector];
-}
-
 static int aat2870_ldo_set_voltage_sel(struct regulator_dev *rdev,
                                        unsigned selector)
 {
@@ -111,7 +98,7 @@ static int aat2870_ldo_is_enabled(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops aat2870_ldo_ops = {
-        .list_voltage = aat2870_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = aat2870_ldo_set_voltage_sel,
         .get_voltage_sel = aat2870_ldo_get_voltage_sel,
         .enable = aat2870_ldo_enable,
@@ -119,7 +106,7 @@ static struct regulator_ops aat2870_ldo_ops = {
         .is_enabled = aat2870_ldo_is_enabled,
 };
 
-static const int aat2870_ldo_voltages[] = {
+static const unsigned int aat2870_ldo_voltages[] = {
         1200000, 1300000, 1500000, 1600000,
         1800000, 2000000, 2200000, 2500000,
         2600000, 2700000, 2800000, 2900000,
@@ -132,13 +119,11 @@ static const int aat2870_ldo_voltages[] = {
                         .name = #ids,                   \
                         .id = AAT2870_ID_##ids,         \
                         .n_voltages = ARRAY_SIZE(aat2870_ldo_voltages), \
+                        .volt_table = aat2870_ldo_voltages, \
                         .ops = &aat2870_ldo_ops,        \
                         .type = REGULATOR_VOLTAGE,      \
                         .owner = THIS_MODULE,           \
                 },                                      \
-                .voltages = aat2870_ldo_voltages,       \
-                .min_uV = 1200000,                      \
-                .max_uV = 3300000,                      \
         }
 
 static struct aat2870_regulator aat2870_regulators[] = {
diff --git a/drivers/regulator/ab3100.c b/drivers/regulator/ab3100.c
index 03f4d9c604ec..182b553059c9 100644
--- a/drivers/regulator/ab3100.c
+++ b/drivers/regulator/ab3100.c
@@ -43,20 +43,12 @@
  * @dev: handle to the device
  * @plfdata: AB3100 platform data passed in at probe time
  * @regreg: regulator register number in the AB3100
- * @fixed_voltage: a fixed voltage for this regulator, if this
- *          0 the voltages array is used instead.
- * @typ_voltages: an array of available typical voltages for
- *          this regulator
- * @voltages_len: length of the array of available voltages
  */
 struct ab3100_regulator {
         struct regulator_dev *rdev;
         struct device *dev;
         struct ab3100_platform_data *plfdata;
         u8 regreg;
-        int fixed_voltage;
-        int const *typ_voltages;
-        u8 voltages_len;
 };
 
 /* The order in which registers are initialized */
@@ -80,7 +72,7 @@ static const u8 ab3100_reg_init_order[AB3100_NUM_REGULATORS+2] = {
 #define LDO_C_VOLTAGE 2650000
 #define LDO_D_VOLTAGE 2650000
 
-static const int ldo_e_buck_typ_voltages[] = {
+static const unsigned int ldo_e_buck_typ_voltages[] = {
         1800000,
         1400000,
         1300000,
@@ -90,7 +82,7 @@ static const int ldo_e_buck_typ_voltages[] = {
         900000,
 };
 
-static const int ldo_f_typ_voltages[] = {
+static const unsigned int ldo_f_typ_voltages[] = {
         1800000,
         1400000,
         1300000,
@@ -101,21 +93,21 @@ static const int ldo_f_typ_voltages[] = {
         2650000,
 };
 
-static const int ldo_g_typ_voltages[] = {
+static const unsigned int ldo_g_typ_voltages[] = {
         2850000,
         2750000,
         1800000,
         1500000,
 };
 
-static const int ldo_h_typ_voltages[] = {
+static const unsigned int ldo_h_typ_voltages[] = {
         2750000,
         1800000,
         1500000,
         1200000,
 };
 
-static const int ldo_k_typ_voltages[] = {
+static const unsigned int ldo_k_typ_voltages[] = {
         2750000,
         1800000,
 };
@@ -126,40 +118,27 @@ static struct ab3100_regulator
 ab3100_regulators[AB3100_NUM_REGULATORS] = {
         {
                 .regreg = AB3100_LDO_A,
-                .fixed_voltage = LDO_A_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_C,
-                .fixed_voltage = LDO_C_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_D,
-                .fixed_voltage = LDO_D_VOLTAGE,
         },
         {
                 .regreg = AB3100_LDO_E,
-                .typ_voltages = ldo_e_buck_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_F,
-                .typ_voltages = ldo_f_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_f_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_G,
-                .typ_voltages = ldo_g_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_g_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_H,
-                .typ_voltages = ldo_h_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_h_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_K,
-                .typ_voltages = ldo_k_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_k_typ_voltages),
         },
         {
                 .regreg = AB3100_LDO_EXT,
@@ -167,8 +146,6 @@ ab3100_regulators[AB3100_NUM_REGULATORS] = {
         },
         {
                 .regreg = AB3100_BUCK,
-                .typ_voltages = ldo_e_buck_typ_voltages,
-                .voltages_len = ARRAY_SIZE(ldo_e_buck_typ_voltages),
         },
 };
 
@@ -178,7 +155,7 @@ ab3100_regulators[AB3100_NUM_REGULATORS] = {
  */
 static int ab3100_enable_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         int err;
         u8 regval;
 
@@ -209,7 +186,7 @@ static int ab3100_enable_regulator(struct regulator_dev *reg)
 
 static int ab3100_disable_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         int err;
         u8 regval;
 
@@ -242,7 +219,7 @@ static int ab3100_disable_regulator(struct regulator_dev *reg)
 
 static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
@@ -257,26 +234,12 @@ static int ab3100_is_enabled_regulator(struct regulator_dev *reg)
         return regval & AB3100_REG_ON_MASK;
 }
 
-static int ab3100_list_voltage_regulator(struct regulator_dev *reg,
-                                         unsigned selector)
-{
-        struct ab3100_regulator *abreg = reg->reg_data;
-
-        if (selector >= abreg->voltages_len)
-                return -EINVAL;
-        return abreg->typ_voltages[selector];
-}
-
 static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
-        /* Return the voltage for fixed regulators immediately */
-        if (abreg->fixed_voltage)
-                return abreg->fixed_voltage;
-
         /*
          * For variable types, read out setting and index into
          * supplied voltage list.
@@ -294,20 +257,20 @@ static int ab3100_get_voltage_regulator(struct regulator_dev *reg)
         regval &= 0xE0;
         regval >>= 5;
 
-        if (regval >= abreg->voltages_len) {
+        if (regval >= reg->desc->n_voltages) {
                 dev_err(&reg->dev,
                         "regulator register %02x contains an illegal voltage setting\n",
                         abreg->regreg);
                 return -EINVAL;
         }
 
-        return abreg->typ_voltages[regval];
+        return reg->desc->volt_table[regval];
 }
 
 static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
                                             unsigned selector)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
 
@@ -336,7 +299,7 @@ static int ab3100_set_voltage_regulator_sel(struct regulator_dev *reg,
 static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
                                                 int uV)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
         u8 regval;
         int err;
         int bestindex;
@@ -379,42 +342,22 @@ static int ab3100_set_suspend_voltage_regulator(struct regulator_dev *reg,
  */
 static int ab3100_get_voltage_regulator_external(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
+        struct ab3100_regulator *abreg = rdev_get_drvdata(reg);
 
         return abreg->plfdata->external_voltage;
 }
 
-static int ab3100_enable_time_regulator(struct regulator_dev *reg)
+static int ab3100_get_fixed_voltage_regulator(struct regulator_dev *reg)
 {
-        struct ab3100_regulator *abreg = reg->reg_data;
-
-        /* Per-regulator power on delay from spec */
-        switch (abreg->regreg) {
-        case AB3100_LDO_A: /* Fallthrough */
-        case AB3100_LDO_C: /* Fallthrough */
-        case AB3100_LDO_D: /* Fallthrough */
-        case AB3100_LDO_E: /* Fallthrough */
-        case AB3100_LDO_H: /* Fallthrough */
-        case AB3100_LDO_K:
-                return 200;
-        case AB3100_LDO_F:
-                return 600;
-        case AB3100_LDO_G:
-                return 400;
-        case AB3100_BUCK:
-                return 1000;
-        default:
-                break;
-        }
-        return 0;
+        return reg->desc->min_uV;
 }
 
 static struct regulator_ops regulator_ops_fixed = {
+        .list_voltage = regulator_list_voltage_linear,
         .enable      = ab3100_enable_regulator,
         .disable     = ab3100_disable_regulator,
         .is_enabled  = ab3100_is_enabled_regulator,
-        .get_voltage = ab3100_get_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .get_voltage = ab3100_get_fixed_voltage_regulator,
 };
 
 static struct regulator_ops regulator_ops_variable = {
@@ -423,8 +366,7 @@ static struct regulator_ops regulator_ops_variable = {
         .is_enabled  = ab3100_is_enabled_regulator,
         .get_voltage = ab3100_get_voltage_regulator,
         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
-        .list_voltage = ab3100_list_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static struct regulator_ops regulator_ops_variable_sleepable = {
@@ -434,8 +376,7 @@ static struct regulator_ops regulator_ops_variable_sleepable = {
         .get_voltage = ab3100_get_voltage_regulator,
         .set_voltage_sel = ab3100_set_voltage_regulator_sel,
         .set_suspend_voltage = ab3100_set_suspend_voltage_regulator,
-        .list_voltage = ab3100_list_voltage_regulator,
-        .enable_time = ab3100_enable_time_regulator,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 /*
@@ -457,62 +398,81 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
                 .name = "LDO_A",
                 .id   = AB3100_LDO_A,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_A_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_C",
                 .id   = AB3100_LDO_C,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_C_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_D",
                 .id   = AB3100_LDO_D,
                 .ops  = &regulator_ops_fixed,
+                .n_voltages = 1,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .min_uV = LDO_D_VOLTAGE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_E",
                 .id   = AB3100_LDO_E,
                 .ops  = &regulator_ops_variable_sleepable,
                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
+                .volt_table = ldo_e_buck_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_F",
                 .id   = AB3100_LDO_F,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_f_typ_voltages),
+                .volt_table = ldo_f_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 600,
         },
         {
                 .name = "LDO_G",
                 .id   = AB3100_LDO_G,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_g_typ_voltages),
+                .volt_table = ldo_g_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 400,
         },
         {
                 .name = "LDO_H",
                 .id   = AB3100_LDO_H,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_h_typ_voltages),
+                .volt_table = ldo_h_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_K",
                 .id   = AB3100_LDO_K,
                 .ops  = &regulator_ops_variable,
                 .n_voltages = ARRAY_SIZE(ldo_k_typ_voltages),
+                .volt_table = ldo_k_typ_voltages,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 200,
         },
         {
                 .name = "LDO_EXT",
@@ -528,6 +488,7 @@ ab3100_regulator_desc[AB3100_NUM_REGULATORS] = {
                 .n_voltages = ARRAY_SIZE(ldo_e_buck_typ_voltages),
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
+                .enable_time = 1000,
         },
 };
 
diff --git a/drivers/regulator/ab8500.c b/drivers/regulator/ab8500.c
index a739f5ca936a..13d424fc1c14 100644
--- a/drivers/regulator/ab8500.c
+++ b/drivers/regulator/ab8500.c
@@ -30,9 +30,6 @@
  * @dev: device pointer
  * @desc: regulator description
  * @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
  * @update_mask: mask to enable/disable regulator
@@ -40,17 +37,12 @@
  * @voltage_bank: bank to control regulator voltage
  * @voltage_reg: register to control regulator voltage
  * @voltage_mask: mask to control regulator voltage
- * @voltages: supported voltage table
- * @voltages_len: number of supported voltages for the regulator
  * @delay: startup/set voltage delay in us
  */
 struct ab8500_regulator_info {
         struct device           *dev;
         struct regulator_desc   desc;
         struct regulator_dev    *regulator;
-        int max_uV;
-        int min_uV;
-        int fixed_uV;
         u8 update_bank;
         u8 update_reg;
         u8 update_mask;
@@ -58,13 +50,11 @@ struct ab8500_regulator_info {
         u8 voltage_bank;
         u8 voltage_reg;
         u8 voltage_mask;
-        int const *voltages;
-        int voltages_len;
         unsigned int delay;
 };
 
 /* voltage tables for the vauxn/vintcore supplies */
-static const int ldo_vauxn_voltages[] = {
+static const unsigned int ldo_vauxn_voltages[] = {
         1100000,
         1200000,
         1300000,
@@ -83,7 +73,7 @@ static const int ldo_vauxn_voltages[] = {
         3300000,
 };
 
-static const int ldo_vaux3_voltages[] = {
+static const unsigned int ldo_vaux3_voltages[] = {
         1200000,
         1500000,
         1800000,
@@ -94,7 +84,7 @@ static const int ldo_vaux3_voltages[] = {
         2910000,
 };
 
-static const int ldo_vintcore_voltages[] = {
+static const unsigned int ldo_vintcore_voltages[] = {
         1200000,
         1225000,
         1250000,
@@ -185,25 +175,6 @@ static int ab8500_regulator_is_enabled(struct regulator_dev *rdev)
                 return false;
 }
 
-static int ab8500_list_voltage(struct regulator_dev *rdev, unsigned selector)
-{
-        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-
-        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)
-                return info->fixed_uV;
-
-        if (selector >= info->voltages_len)
-                return -EINVAL;
-
-        return info->voltages[selector];
-}
-
 static int ab8500_regulator_get_voltage_sel(struct regulator_dev *rdev)
 {
         int ret, val;
@@ -279,14 +250,7 @@ static int ab8500_regulator_set_voltage_time_sel(struct regulator_dev *rdev,
                                              unsigned int new_sel)
 {
         struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-        int ret;
 
-        /* If the regulator isn't on, it won't take time here */
-        ret = ab8500_regulator_is_enabled(rdev);
-        if (ret < 0)
-                return ret;
-        if (!ret)
-                return 0;
         return info->delay;
 }
 
@@ -296,21 +260,14 @@ static struct regulator_ops ab8500_regulator_ops = {
         .is_enabled     = ab8500_regulator_is_enabled,
         .get_voltage_sel = ab8500_regulator_get_voltage_sel,
         .set_voltage_sel = ab8500_regulator_set_voltage_sel,
-        .list_voltage   = ab8500_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
         .enable_time    = ab8500_regulator_enable_time,
         .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 };
 
 static int ab8500_fixed_get_voltage(struct regulator_dev *rdev)
 {
-        struct ab8500_regulator_info *info = rdev_get_drvdata(rdev);
-
-        if (info == NULL) {
-                dev_err(rdev_get_dev(rdev), "regulator info null pointer\n");
-                return -EINVAL;
-        }
-
-        return info->fixed_uV;
+        return rdev->desc->min_uV;
 }
 
 static struct regulator_ops ab8500_regulator_fixed_ops = {
@@ -318,9 +275,8 @@ static struct regulator_ops ab8500_regulator_fixed_ops = {
         .disable        = ab8500_regulator_disable,
         .is_enabled     = ab8500_regulator_is_enabled,
         .get_voltage    = ab8500_fixed_get_voltage,
-        .list_voltage   = ab8500_list_voltage,
+        .list_voltage   = regulator_list_voltage_linear,
         .enable_time    = ab8500_regulator_enable_time,
-        .set_voltage_time_sel = ab8500_regulator_set_voltage_time_sel,
 };
 
 static struct ab8500_regulator_info
@@ -329,7 +285,7 @@ static struct ab8500_regulator_info
          * Variable Voltage Regulators
          *   name, min mV, max mV,
          *   update bank, reg, mask, enable val
-         *   volt bank, reg, mask, table, table length
+         *   volt bank, reg, mask
          */
         [AB8500_LDO_AUX1] = {
                 .desc = {
@@ -339,9 +295,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX1,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                        .volt_table     = ldo_vauxn_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x09,
                 .update_mask            = 0x03,
@@ -349,8 +304,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x1f,
                 .voltage_mask           = 0x0f,
-                .voltages               = ldo_vauxn_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
         },
         [AB8500_LDO_AUX2] = {
                 .desc = {
@@ -360,9 +313,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX2,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vauxn_voltages),
+                        .volt_table     = ldo_vauxn_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x09,
                 .update_mask            = 0x0c,
@@ -370,8 +322,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x20,
                 .voltage_mask           = 0x0f,
-                .voltages               = ldo_vauxn_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vauxn_voltages),
         },
         [AB8500_LDO_AUX3] = {
                 .desc = {
@@ -381,9 +331,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUX3,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vaux3_voltages),
+                        .volt_table     = ldo_vaux3_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x0a,
                 .update_mask            = 0x03,
@@ -391,8 +340,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x04,
                 .voltage_reg            = 0x21,
                 .voltage_mask           = 0x07,
-                .voltages               = ldo_vaux3_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vaux3_voltages),
         },
         [AB8500_LDO_INTCORE] = {
                 .desc = {
@@ -402,9 +349,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_INTCORE,
                         .owner          = THIS_MODULE,
                         .n_voltages     = ARRAY_SIZE(ldo_vintcore_voltages),
+                        .volt_table     = ldo_vintcore_voltages,
                 },
-                .min_uV                 = 1100000,
-                .max_uV                 = 3300000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x80,
                 .update_mask            = 0x44,
@@ -412,8 +358,6 @@ static struct ab8500_regulator_info
                 .voltage_bank           = 0x03,
                 .voltage_reg            = 0x80,
                 .voltage_mask           = 0x38,
-                .voltages               = ldo_vintcore_voltages,
-                .voltages_len           = ARRAY_SIZE(ldo_vintcore_voltages),
         },
 
         /*
@@ -429,9 +373,9 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_TVOUT,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2000000,
                 },
                 .delay                  = 10000,
-                .fixed_uV               = 2000000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x80,
                 .update_mask            = 0x82,
@@ -445,8 +389,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_USB,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 3300000,
                 },
-                .fixed_uV               = 3300000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x82,
                 .update_mask            = 0x03,
@@ -460,8 +404,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_AUDIO,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2000000,
                 },
-                .fixed_uV               = 2000000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x02,
@@ -475,8 +419,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANAMIC1,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2050000,
                 },
-                .fixed_uV               = 2050000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x08,
@@ -490,8 +434,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANAMIC2,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 2050000,
                 },
-                .fixed_uV               = 2050000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x10,
@@ -505,8 +449,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_DMIC,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 1800000,
                 },
-                .fixed_uV               = 1800000,
                 .update_bank            = 0x03,
                 .update_reg             = 0x83,
                 .update_mask            = 0x04,
@@ -520,8 +464,8 @@ static struct ab8500_regulator_info
                         .id             = AB8500_LDO_ANA,
                         .owner          = THIS_MODULE,
                         .n_voltages     = 1,
+                        .min_uV         = 1200000,
                 },
-                .fixed_uV               = 1200000,
                 .update_bank            = 0x04,
                 .update_reg             = 0x06,
                 .update_mask            = 0x0c,
@@ -769,9 +713,7 @@ static __devinit int ab8500_regulator_register(struct platform_device *pdev,
                 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->desc.volt_table = ldo_vauxn_voltages;
                         info->voltage_mask = 0xf;
                 }
         }
diff --git a/drivers/regulator/ad5398.c b/drivers/regulator/ad5398.c
index 46d05f38baf8..f123f7e3b752 100644
--- a/drivers/regulator/ad5398.c
+++ b/drivers/regulator/ad5398.c
@@ -89,9 +89,12 @@ static int ad5398_set_current_limit(struct regulator_dev *rdev, int min_uA, int
         unsigned short data;
         int ret;
 
-        if (min_uA > chip->max_uA || min_uA < chip->min_uA)
-                return -EINVAL;
-        if (max_uA > chip->max_uA || max_uA < chip->min_uA)
+        if (min_uA < chip->min_uA)
+                min_uA = chip->min_uA;
+        if (max_uA > chip->max_uA)
+                max_uA = chip->max_uA;
+
+        if (min_uA > chip->max_uA || max_uA < chip->min_uA)
                 return -EINVAL;
 
         selector = DIV_ROUND_UP((min_uA - chip->min_uA) * chip->current_level,
diff --git a/drivers/regulator/anatop-regulator.c b/drivers/regulator/anatop-regulator.c
index e82e7eaac0f1..e9c2085f9dfb 100644
--- a/drivers/regulator/anatop-regulator.c
+++ b/drivers/regulator/anatop-regulator.c
@@ -43,33 +43,15 @@ struct anatop_regulator {
         struct regulator_init_data *initdata;
 };
 
-static int anatop_set_voltage(struct regulator_dev *reg, int min_uV,
-                                  int max_uV, unsigned *selector)
+static int anatop_set_voltage_sel(struct regulator_dev *reg, unsigned selector)
 {
         struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-        u32 val, sel, mask;
-        int uv;
-
-        uv = min_uV;
-        dev_dbg(&reg->dev, "%s: uv %d, min %d, max %d\n", __func__,
-                uv, anatop_reg->min_voltage,
-                anatop_reg->max_voltage);
-
-        if (uv < anatop_reg->min_voltage) {
-                if (max_uV > anatop_reg->min_voltage)
-                        uv = anatop_reg->min_voltage;
-                else
-                        return -EINVAL;
-        }
+        u32 val, mask;
 
         if (!anatop_reg->control_reg)
                 return -ENOTSUPP;
 
-        sel = DIV_ROUND_UP(uv - anatop_reg->min_voltage, 25000);
-        if (sel * 25000 + anatop_reg->min_voltage > anatop_reg->max_voltage)
-                return -EINVAL;
-        val = anatop_reg->min_bit_val + sel;
-        *selector = sel;
+        val = anatop_reg->min_bit_val + selector;
         dev_dbg(&reg->dev, "%s: calculated val %d\n", __func__, val);
         mask = ((1 << anatop_reg->vol_bit_width) - 1) <<
                 anatop_reg->vol_bit_shift;
@@ -94,21 +76,11 @@ static int anatop_get_voltage_sel(struct regulator_dev *reg)
         return val - anatop_reg->min_bit_val;
 }
 
-static int anatop_list_voltage(struct regulator_dev *reg, unsigned selector)
-{
-        struct anatop_regulator *anatop_reg = rdev_get_drvdata(reg);
-        int uv;
-
-        uv = anatop_reg->min_voltage + selector * 25000;
-        dev_dbg(&reg->dev, "vddio = %d, selector = %u\n", uv, selector);
-
-        return uv;
-}
-
 static struct regulator_ops anatop_rops = {
-        .set_voltage     = anatop_set_voltage,
+        .set_voltage_sel = anatop_set_voltage_sel,
         .get_voltage_sel = anatop_get_voltage_sel,
-        .list_voltage    = anatop_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
 };
 
 static int __devinit anatop_regulator_probe(struct platform_device *pdev)
@@ -176,6 +148,8 @@ static int __devinit anatop_regulator_probe(struct platform_device *pdev)
 
         rdesc->n_voltages = (sreg->max_voltage - sreg->min_voltage)
                 / 25000 + 1;
+        rdesc->min_uV = sreg->min_voltage;
+        rdesc->uV_step = 25000;
 
         config.dev = &pdev->dev;
         config.init_data = initdata;
diff --git a/drivers/regulator/arizona-ldo1.c b/drivers/regulator/arizona-ldo1.c
new file mode 100644
index 000000000000..c8f95c07adb6
--- /dev/null
+++ b/drivers/regulator/arizona-ldo1.c
@@ -0,0 +1,138 @@
+/*
+ * arizona-ldo1.c  --  LDO1 supply for Arizona devices
+ *
+ * Copyright 2012 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+struct arizona_ldo1 {
+        struct regulator_dev *regulator;
+        struct arizona *arizona;
+
+        struct regulator_consumer_supply supply;
+        struct regulator_init_data init_data;
+};
+
+static struct regulator_ops arizona_ldo1_ops = {
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+};
+
+static const struct regulator_desc arizona_ldo1 = {
+        .name = "LDO1",
+        .supply_name = "LDOVDD",
+        .type = REGULATOR_VOLTAGE,
+        .ops = &arizona_ldo1_ops,
+
+        .vsel_reg = ARIZONA_LDO1_CONTROL_1,
+        .vsel_mask = ARIZONA_LDO1_VSEL_MASK,
+        .min_uV = 900000,
+        .uV_step = 50000,
+        .n_voltages = 7,
+
+        .owner = THIS_MODULE,
+};
+
+static const struct regulator_init_data arizona_ldo1_default = {
+        .constraints = {
+                .valid_ops_mask = REGULATOR_CHANGE_STATUS,
+        },
+        .num_consumer_supplies = 1,
+};
+
+static __devinit int arizona_ldo1_probe(struct platform_device *pdev)
+{
+        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
+        struct arizona_ldo1 *ldo1;
+        int ret;
+
+        ldo1 = devm_kzalloc(&pdev->dev, sizeof(*ldo1), GFP_KERNEL);
+        if (ldo1 == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        ldo1->arizona = arizona;
+
+        /*
+         * Since the chip usually supplies itself we provide some
+         * default init_data for it.  This will be overridden with
+         * platform data if provided.
+         */
+        ldo1->init_data = arizona_ldo1_default;
+        ldo1->init_data.consumer_supplies = &ldo1->supply;
+        ldo1->supply.supply = "DCVDD";
+        ldo1->supply.dev_name = dev_name(arizona->dev);
+
+        config.dev = arizona->dev;
+        config.driver_data = ldo1;
+        config.regmap = arizona->regmap;
+        config.ena_gpio = arizona->pdata.ldoena;
+
+        if (arizona->pdata.ldo1)
+                config.init_data = arizona->pdata.ldo1;
+        else
+                config.init_data = &ldo1->init_data;
+
+        ldo1->regulator = regulator_register(&arizona_ldo1, &config);
+        if (IS_ERR(ldo1->regulator)) {
+                ret = PTR_ERR(ldo1->regulator);
+                dev_err(arizona->dev, "Failed to register LDO1 supply: %d\n",
+                        ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, ldo1);
+
+        return 0;
+}
+
+static __devexit int arizona_ldo1_remove(struct platform_device *pdev)
+{
+        struct arizona_ldo1 *ldo1 = platform_get_drvdata(pdev);
+
+        regulator_unregister(ldo1->regulator);
+
+        return 0;
+}
+
+static struct platform_driver arizona_ldo1_driver = {
+        .probe = arizona_ldo1_probe,
+        .remove = __devexit_p(arizona_ldo1_remove),
+        .driver         = {
+                .name   = "arizona-ldo1",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(arizona_ldo1_driver);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("Arizona LDO1 driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:arizona-ldo1");
diff --git a/drivers/regulator/arizona-micsupp.c b/drivers/regulator/arizona-micsupp.c
new file mode 100644
index 000000000000..450a069aa9b6
--- /dev/null
+++ b/drivers/regulator/arizona-micsupp.c
@@ -0,0 +1,188 @@
+/*
+ * arizona-micsupp.c  --  Microphone supply for Arizona devices
+ *
+ * Copyright 2012 Wolfson Microelectronics PLC.
+ *
+ * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ */
+
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/bitops.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+
+#include <linux/mfd/arizona/core.h>
+#include <linux/mfd/arizona/pdata.h>
+#include <linux/mfd/arizona/registers.h>
+
+#define ARIZONA_MICSUPP_MAX_SELECTOR 0x1f
+
+struct arizona_micsupp {
+        struct regulator_dev *regulator;
+        struct arizona *arizona;
+
+        struct regulator_consumer_supply supply;
+        struct regulator_init_data init_data;
+};
+
+static int arizona_micsupp_list_voltage(struct regulator_dev *rdev,
+                                        unsigned int selector)
+{
+        if (selector > ARIZONA_MICSUPP_MAX_SELECTOR)
+                return -EINVAL;
+
+        if (selector == ARIZONA_MICSUPP_MAX_SELECTOR)
+                return 3300000;
+        else
+                return (selector * 50000) + 1700000;
+}
+
+static int arizona_micsupp_map_voltage(struct regulator_dev *rdev,
+                                       int min_uV, int max_uV)
+{
+        unsigned int voltage;
+        int selector;
+
+        if (min_uV < 1700000)
+                min_uV = 1700000;
+
+        if (min_uV > 3200000)
+                selector = ARIZONA_MICSUPP_MAX_SELECTOR;
+        else
+                selector = DIV_ROUND_UP(min_uV - 1700000, 50000);
+
+        if (selector < 0)
+                return -EINVAL;
+
+        voltage = arizona_micsupp_list_voltage(rdev, selector);
+        if (voltage < min_uV || voltage > max_uV)
+                return -EINVAL;
+
+        return selector;
+}
+
+static struct regulator_ops arizona_micsupp_ops = {
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+
+        .list_voltage = arizona_micsupp_list_voltage,
+        .map_voltage = arizona_micsupp_map_voltage,
+
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+};
+
+static const struct regulator_desc arizona_micsupp = {
+        .name = "MICVDD",
+        .supply_name = "CPVDD",
+        .type = REGULATOR_VOLTAGE,
+        .n_voltages = ARIZONA_MICSUPP_MAX_SELECTOR + 1,
+        .ops = &arizona_micsupp_ops,
+
+        .vsel_reg = ARIZONA_LDO2_CONTROL_1,
+        .vsel_mask = ARIZONA_LDO2_VSEL_MASK,
+        .enable_reg = ARIZONA_MIC_CHARGE_PUMP_1,
+        .enable_mask = ARIZONA_CPMIC_ENA,
+
+        .owner = THIS_MODULE,
+};
+
+static const struct regulator_init_data arizona_micsupp_default = {
+        .constraints = {
+                .valid_ops_mask = REGULATOR_CHANGE_STATUS |
+                                REGULATOR_CHANGE_VOLTAGE,
+                .min_uV = 1700000,
+                .max_uV = 3300000,
+        },
+
+        .num_consumer_supplies = 1,
+};
+
+static __devinit int arizona_micsupp_probe(struct platform_device *pdev)
+{
+        struct arizona *arizona = dev_get_drvdata(pdev->dev.parent);
+        struct regulator_config config = { };
+        struct arizona_micsupp *micsupp;
+        int ret;
+
+        micsupp = devm_kzalloc(&pdev->dev, sizeof(*micsupp), GFP_KERNEL);
+        if (micsupp == NULL) {
+                dev_err(&pdev->dev, "Unable to allocate private data\n");
+                return -ENOMEM;
+        }
+
+        micsupp->arizona = arizona;
+
+        /*
+         * Since the chip usually supplies itself we provide some
+         * default init_data for it.  This will be overridden with
+         * platform data if provided.
+         */
+        micsupp->init_data = arizona_micsupp_default;
+        micsupp->init_data.consumer_supplies = &micsupp->supply;
+        micsupp->supply.supply = "MICVDD";
+        micsupp->supply.dev_name = dev_name(arizona->dev);
+
+        config.dev = arizona->dev;
+        config.driver_data = micsupp;
+        config.regmap = arizona->regmap;
+
+        if (arizona->pdata.micvdd)
+                config.init_data = arizona->pdata.micvdd;
+        else
+                config.init_data = &micsupp->init_data;
+
+        /* Default to regulated mode until the API supports bypass */
+        regmap_update_bits(arizona->regmap, ARIZONA_MIC_CHARGE_PUMP_1,
+                           ARIZONA_CPMIC_BYPASS, 0);
+
+        micsupp->regulator = regulator_register(&arizona_micsupp, &config);
+        if (IS_ERR(micsupp->regulator)) {
+                ret = PTR_ERR(micsupp->regulator);
+                dev_err(arizona->dev, "Failed to register mic supply: %d\n",
+                        ret);
+                return ret;
+        }
+
+        platform_set_drvdata(pdev, micsupp);
+
+        return 0;
+}
+
+static __devexit int arizona_micsupp_remove(struct platform_device *pdev)
+{
+        struct arizona_micsupp *micsupp = platform_get_drvdata(pdev);
+
+        regulator_unregister(micsupp->regulator);
+
+        return 0;
+}
+
+static struct platform_driver arizona_micsupp_driver = {
+        .probe = arizona_micsupp_probe,
+        .remove = __devexit_p(arizona_micsupp_remove),
+        .driver         = {
+                .name   = "arizona-micsupp",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(arizona_micsupp_driver);
+
+/* Module information */
+MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>");
+MODULE_DESCRIPTION("Arizona microphone supply driver");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:arizona-micsupp");
diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
index e8ee20095a19..2e31dffbefe7 100644
--- a/drivers/regulator/core.c
+++ b/drivers/regulator/core.c
@@ -23,6 +23,7 @@
 #include <linux/mutex.h>
 #include <linux/suspend.h>
 #include <linux/delay.h>
+#include <linux/gpio.h>
 #include <linux/of.h>
 #include <linux/regmap.h>
 #include <linux/regulator/of_regulator.h>
@@ -936,6 +937,14 @@ static int set_machine_constraints(struct regulator_dev *rdev,
                 }
         }
 
+        if (rdev->constraints->ramp_delay && ops->set_ramp_delay) {
+                ret = ops->set_ramp_delay(rdev, rdev->constraints->ramp_delay);
+                if (ret < 0) {
+                        rdev_err(rdev, "failed to set ramp_delay\n");
+                        goto out;
+                }
+        }
+
         print_constraints(rdev);
         return 0;
 out:
@@ -1125,7 +1134,7 @@ overflow_err:
 static int _regulator_get_enable_time(struct regulator_dev *rdev)
 {
         if (!rdev->desc->ops->enable_time)
-                return 0;
+                return rdev->desc->enable_time;
         return rdev->desc->ops->enable_time(rdev);
 }
 
@@ -1407,10 +1416,54 @@ void devm_regulator_put(struct regulator *regulator)
 }
 EXPORT_SYMBOL_GPL(devm_regulator_put);
 
+static int _regulator_do_enable(struct regulator_dev *rdev)
+{
+        int ret, delay;
+
+        /* Query before enabling in case configuration dependent.  */
+        ret = _regulator_get_enable_time(rdev);
+        if (ret >= 0) {
+                delay = ret;
+        } else {
+                rdev_warn(rdev, "enable_time() failed: %d\n", ret);
+                delay = 0;
+        }
+
+        trace_regulator_enable(rdev_get_name(rdev));
+
+        if (rdev->ena_gpio) {
+                gpio_set_value_cansleep(rdev->ena_gpio,
+                                        !rdev->ena_gpio_invert);
+                rdev->ena_gpio_state = 1;
+        } else if (rdev->desc->ops->enable) {
+                ret = rdev->desc->ops->enable(rdev);
+                if (ret < 0)
+                        return ret;
+        } else {
+                return -EINVAL;
+        }
+
+        /* Allow the regulator to ramp; it would be useful to extend
+         * this for bulk operations so that the regulators can ramp
+         * together.  */
+        trace_regulator_enable_delay(rdev_get_name(rdev));
+
+        if (delay >= 1000) {
+                mdelay(delay / 1000);
+                udelay(delay % 1000);
+        } else if (delay) {
+                udelay(delay);
+        }
+
+        trace_regulator_enable_complete(rdev_get_name(rdev));
+
+        return 0;
+}
+
 /* locks held by regulator_enable() */
 static int _regulator_enable(struct regulator_dev *rdev)
 {
-        int ret, delay;
+        int ret;
 
         /* check voltage and requested load before enabling */
         if (rdev->constraints &&
@@ -1424,40 +1477,10 @@ static int _regulator_enable(struct regulator_dev *rdev)
                         if (!_regulator_can_change_status(rdev))
                                 return -EPERM;
 
-                        if (!rdev->desc->ops->enable)
-                                return -EINVAL;
-
-                        /* Query before enabling in case configuration
-                         * dependent.  */
-                        ret = _regulator_get_enable_time(rdev);
-                        if (ret >= 0) {
-                                delay = ret;
-                        } else {
-                                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.  */
-                        ret = rdev->desc->ops->enable(rdev);
+                        ret = _regulator_do_enable(rdev);
                         if (ret < 0)
                                 return ret;
 
-                        trace_regulator_enable_delay(rdev_get_name(rdev));
-
-                        if (delay >= 1000) {
-                                mdelay(delay / 1000);
-                                udelay(delay % 1000);
-                        } else if (delay) {
-                                udelay(delay);
-                        }
-
-                        trace_regulator_enable_complete(rdev_get_name(rdev));
-
                 } else if (ret < 0) {
                         rdev_err(rdev, "is_enabled() failed: %d\n", ret);
                         return ret;
@@ -1506,6 +1529,30 @@ int regulator_enable(struct regulator *regulator)
 }
 EXPORT_SYMBOL_GPL(regulator_enable);
 
+static int _regulator_do_disable(struct regulator_dev *rdev)
+{
+        int ret;
+
+        trace_regulator_disable(rdev_get_name(rdev));
+
+        if (rdev->ena_gpio) {
+                gpio_set_value_cansleep(rdev->ena_gpio,
+                                        rdev->ena_gpio_invert);
+                rdev->ena_gpio_state = 0;
+
+        } else if (rdev->desc->ops->disable) {
+                ret = rdev->desc->ops->disable(rdev);
+                if (ret != 0)
+                        return ret;
+        }
+
+        trace_regulator_disable_complete(rdev_get_name(rdev));
+
+        _notifier_call_chain(rdev, REGULATOR_EVENT_DISABLE,
+                             NULL);
+        return 0;
+}
+
 /* locks held by regulator_disable() */
 static int _regulator_disable(struct regulator_dev *rdev)
 {
@@ -1520,20 +1567,12 @@ static int _regulator_disable(struct regulator_dev *rdev)
             (rdev->constraints && !rdev->constraints->always_on)) {
 
                 /* 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 (_regulator_can_change_status(rdev)) {
+                        ret = _regulator_do_disable(rdev);
                         if (ret < 0) {
                                 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);
                 }
 
                 rdev->use_count = 0;
@@ -1751,6 +1790,10 @@ EXPORT_SYMBOL_GPL(regulator_disable_regmap);
 
 static int _regulator_is_enabled(struct regulator_dev *rdev)
 {
+        /* A GPIO control always takes precedence */
+        if (rdev->ena_gpio)
+                return rdev->ena_gpio_state;
+
         /* If we don't know then assume that the regulator is always on */
         if (!rdev->desc->ops->is_enabled)
                 return 1;
@@ -2019,6 +2062,14 @@ int regulator_map_voltage_linear(struct regulator_dev *rdev,
 {
         int ret, voltage;
 
+        /* Allow uV_step to be 0 for fixed voltage */
+        if (rdev->desc->n_voltages == 1 && rdev->desc->uV_step == 0) {
+                if (min_uV <= rdev->desc->min_uV && rdev->desc->min_uV <= max_uV)
+                        return 0;
+                else
+                        return -EINVAL;
+        }
+
         if (!rdev->desc->uV_step) {
                 BUG_ON(!rdev->desc->uV_step);
                 return -EINVAL;
@@ -2240,6 +2291,46 @@ int regulator_set_voltage_time(struct regulator *regulator,
 EXPORT_SYMBOL_GPL(regulator_set_voltage_time);
 
 /**
+ *regulator_set_voltage_time_sel - get raise/fall time
+ * @regulator: regulator source
+ * @old_selector: selector for starting voltage
+ * @new_selector: selector for target voltage
+ *
+ * Provided with the starting and target voltage selectors, this function
+ * returns time in microseconds required to rise or fall to this new voltage
+ *
+ * Drivers providing ramp_delay in regulation_constraints can use this as their
+ * set_voltage_time_sel() operation.
+ */
+int regulator_set_voltage_time_sel(struct regulator_dev *rdev,
+                                   unsigned int old_selector,
+                                   unsigned int new_selector)
+{
+        unsigned int ramp_delay = 0;
+        int old_volt, new_volt;
+
+        if (rdev->constraints->ramp_delay)
+                ramp_delay = rdev->constraints->ramp_delay;
+        else if (rdev->desc->ramp_delay)
+                ramp_delay = rdev->desc->ramp_delay;
+
+        if (ramp_delay == 0) {
+                rdev_warn(rdev, "ramp_delay not set\n");
+                return 0;
+        }
+
+        /* sanity check */
+        if (!rdev->desc->ops->list_voltage)
+                return -EINVAL;
+
+        old_volt = rdev->desc->ops->list_voltage(rdev, old_selector);
+        new_volt = rdev->desc->ops->list_voltage(rdev, new_selector);
+
+        return DIV_ROUND_UP(abs(new_volt - old_volt), ramp_delay);
+}
+EXPORT_SYMBOL_GPL(regulator_set_voltage_time_sel);
+
+/**
  * regulator_sync_voltage - re-apply last regulator output voltage
  * @regulator: regulator source
  *
@@ -2510,9 +2601,12 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
 {
         struct regulator_dev *rdev = regulator->rdev;
         struct regulator *consumer;
-        int ret, output_uV, input_uV, total_uA_load = 0;
+        int ret, output_uV, input_uV = 0, total_uA_load = 0;
         unsigned int mode;
 
+        if (rdev->supply)
+                input_uV = regulator_get_voltage(rdev->supply);
+
         mutex_lock(&rdev->mutex);
 
         /*
@@ -2545,10 +2639,7 @@ int regulator_set_optimum_mode(struct regulator *regulator, int uA_load)
                 goto out;
         }
 
-        /* get input voltage */
-        input_uV = 0;
-        if (rdev->supply)
-                input_uV = regulator_get_voltage(rdev->supply);
+        /* No supply? Use constraint voltage */
         if (input_uV <= 0)
                 input_uV = rdev->constraints->input_uV;
         if (input_uV <= 0) {
@@ -3126,6 +3217,26 @@ regulator_register(const struct regulator_desc *regulator_desc,
 
         dev_set_drvdata(&rdev->dev, rdev);
 
+        if (config->ena_gpio) {
+                ret = gpio_request_one(config->ena_gpio,
+                                       GPIOF_DIR_OUT | config->ena_gpio_flags,
+                                       rdev_get_name(rdev));
+                if (ret != 0) {
+                        rdev_err(rdev, "Failed to request enable GPIO%d: %d\n",
+                                 config->ena_gpio, ret);
+                        goto clean;
+                }
+
+                rdev->ena_gpio = config->ena_gpio;
+                rdev->ena_gpio_invert = config->ena_gpio_invert;
+
+                if (config->ena_gpio_flags & GPIOF_OUT_INIT_HIGH)
+                        rdev->ena_gpio_state = 1;
+
+                if (rdev->ena_gpio_invert)
+                        rdev->ena_gpio_state = !rdev->ena_gpio_state;
+        }
+
         /* set regulator constraints */
         if (init_data)
                 constraints = &init_data->constraints;
@@ -3194,6 +3305,8 @@ unset_supplies:
 scrub:
         if (rdev->supply)
                 regulator_put(rdev->supply);
+        if (rdev->ena_gpio)
+                gpio_free(rdev->ena_gpio);
         kfree(rdev->constraints);
         device_unregister(&rdev->dev);
         /* device core frees rdev */
@@ -3227,6 +3340,8 @@ void regulator_unregister(struct regulator_dev *rdev)
         unset_regulator_supplies(rdev);
         list_del(&rdev->list);
         kfree(rdev->constraints);
+        if (rdev->ena_gpio)
+                gpio_free(rdev->ena_gpio);
         device_unregister(&rdev->dev);
         mutex_unlock(&regulator_list_mutex);
 }
diff --git a/drivers/regulator/da903x.c b/drivers/regulator/da903x.c
index 1005f5f7e603..36c5b92fe0af 100644
--- a/drivers/regulator/da903x.c
+++ b/drivers/regulator/da903x.c
@@ -107,6 +107,9 @@ static int da903x_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
         struct device *da9034_dev = to_da903x_dev(rdev);
         uint8_t val, mask;
 
+        if (rdev->desc->n_voltages == 1)
+                return -EINVAL;
+
         val = selector << info->vol_shift;
         mask = ((1 << info->vol_nbits) - 1)  << info->vol_shift;
 
@@ -120,6 +123,9 @@ static int da903x_get_voltage_sel(struct regulator_dev *rdev)
         uint8_t val, mask;
         int ret;
 
+        if (rdev->desc->n_voltages == 1)
+                return 0;
+
         ret = da903x_read(da9034_dev, info->vol_reg, &val);
         if (ret)
                 return ret;
diff --git a/drivers/regulator/da9052-regulator.c b/drivers/regulator/da9052-regulator.c
index 88976d8d44ed..903299cf15cf 100644
--- a/drivers/regulator/da9052-regulator.c
+++ b/drivers/regulator/da9052-regulator.c
@@ -405,12 +405,12 @@ static int __devinit da9052_regulator_probe(struct platform_device *pdev)
                 if (!nproot)
                         return -ENODEV;
 
-                for (np = of_get_next_child(nproot, NULL); np;
-                     np = of_get_next_child(nproot, np)) {
+                for_each_child_of_node(nproot, np) {
                         if (!of_node_cmp(np->name,
                                          regulator->info->reg_desc.name)) {
                                 config.init_data = of_get_regulator_init_data(
                                         &pdev->dev, np);
+                                config.of_node = np;
                                 break;
                         }
                 }
diff --git a/drivers/regulator/fixed.c b/drivers/regulator/fixed.c
index f09fe7b20e82..185468c4d38f 100644
--- a/drivers/regulator/fixed.c
+++ b/drivers/regulator/fixed.c
@@ -35,10 +35,6 @@ struct fixed_voltage_data {
         struct regulator_desc desc;
         struct regulator_dev *dev;
         int microvolts;
-        int gpio;
-        unsigned startup_delay;
-        bool enable_high;
-        bool is_enabled;
 };
 
 
@@ -61,11 +57,11 @@ of_get_fixed_voltage_config(struct device *dev)
         config = devm_kzalloc(dev, sizeof(struct fixed_voltage_config),
                                                                  GFP_KERNEL);
         if (!config)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         config->init_data = of_get_regulator_init_data(dev, dev->of_node);
         if (!config->init_data)
-                return NULL;
+                return ERR_PTR(-EINVAL);
 
         init_data = config->init_data;
         init_data->constraints.apply_uV = 0;
@@ -76,13 +72,26 @@ of_get_fixed_voltage_config(struct device *dev)
         } else {
                 dev_err(dev,
                          "Fixed regulator specified with variable voltages\n");
-                return NULL;
+                return ERR_PTR(-EINVAL);
         }
 
         if (init_data->constraints.boot_on)
                 config->enabled_at_boot = true;
 
         config->gpio = of_get_named_gpio(np, "gpio", 0);
+        /*
+         * of_get_named_gpio() currently returns ENODEV rather than
+         * EPROBE_DEFER. This code attempts to be compatible with both
+         * for now; the ENODEV check can be removed once the API is fixed.
+         * of_get_named_gpio() doesn't differentiate between a missing
+         * property (which would be fine here, since the GPIO is optional)
+         * and some other error. Patches have been posted for both issues.
+         * Once they are check in, we should replace this with:
+         * if (config->gpio < 0 && config->gpio != -ENOENT)
+         */
+        if ((config->gpio == -ENODEV) || (config->gpio == -EPROBE_DEFER))
+                return ERR_PTR(-EPROBE_DEFER);
+
         delay = of_get_property(np, "startup-delay-us", NULL);
         if (delay)
                 config->startup_delay = be32_to_cpu(*delay);
@@ -93,41 +102,10 @@ of_get_fixed_voltage_config(struct device *dev)
         if (of_find_property(np, "gpio-open-drain", NULL))
                 config->gpio_is_open_drain = true;
 
-        return config;
-}
-
-static int fixed_voltage_is_enabled(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        return data->is_enabled;
-}
-
-static int fixed_voltage_enable(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        gpio_set_value_cansleep(data->gpio, data->enable_high);
-        data->is_enabled = true;
-
-        return 0;
-}
-
-static int fixed_voltage_disable(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        gpio_set_value_cansleep(data->gpio, !data->enable_high);
-        data->is_enabled = false;
-
-        return 0;
-}
+        if (of_find_property(np, "vin-supply", NULL))
+                config->input_supply = "vin";
 
-static int fixed_voltage_enable_time(struct regulator_dev *dev)
-{
-        struct fixed_voltage_data *data = rdev_get_drvdata(dev);
-
-        return data->startup_delay;
+        return config;
 }
 
 static int fixed_voltage_get_voltage(struct regulator_dev *dev)
@@ -151,15 +129,6 @@ static int fixed_voltage_list_voltage(struct regulator_dev *dev,
         return data->microvolts;
 }
 
-static struct regulator_ops fixed_voltage_gpio_ops = {
-        .is_enabled = fixed_voltage_is_enabled,
-        .enable = fixed_voltage_enable,
-        .disable = fixed_voltage_disable,
-        .enable_time = fixed_voltage_enable_time,
-        .get_voltage = fixed_voltage_get_voltage,
-        .list_voltage = fixed_voltage_list_voltage,
-};
-
 static struct regulator_ops fixed_voltage_ops = {
         .get_voltage = fixed_voltage_get_voltage,
         .list_voltage = fixed_voltage_list_voltage,
@@ -172,10 +141,13 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         struct regulator_config cfg = { };
         int ret;
 
-        if (pdev->dev.of_node)
+        if (pdev->dev.of_node) {
                 config = of_get_fixed_voltage_config(&pdev->dev);
-        else
+                if (IS_ERR(config))
+                        return PTR_ERR(config);
+        } else {
                 config = pdev->dev.platform_data;
+        }
 
         if (!config)
                 return -ENOMEM;
@@ -196,59 +168,44 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         }
         drvdata->desc.type = REGULATOR_VOLTAGE;
         drvdata->desc.owner = THIS_MODULE;
+        drvdata->desc.ops = &fixed_voltage_ops;
 
-        if (config->microvolts)
-                drvdata->desc.n_voltages = 1;
+        drvdata->desc.enable_time = config->startup_delay;
 
-        drvdata->microvolts = config->microvolts;
-        drvdata->gpio = config->gpio;
-        drvdata->startup_delay = config->startup_delay;
-
-        if (gpio_is_valid(config->gpio)) {
-                int gpio_flag;
-                drvdata->enable_high = config->enable_high;
-
-                /* FIXME: Remove below print warning
-                 *
-                 * config->gpio must be set to -EINVAL by platform code if
-                 * GPIO control is not required. However, early adopters
-                 * not requiring GPIO control may forget to initialize
-                 * config->gpio to -EINVAL. This will cause GPIO 0 to be used
-                 * for GPIO control.
-                 *
-                 * This warning will be removed once there are a couple of users
-                 * for this driver.
-                 */
-                if (!config->gpio)
-                        dev_warn(&pdev->dev,
-                                "using GPIO 0 for regulator enable control\n");
-
-                /*
-                 * set output direction without changing state
-                 * to prevent glitch
-                 */
-                drvdata->is_enabled = config->enabled_at_boot;
-                ret = drvdata->is_enabled ?
-                                config->enable_high : !config->enable_high;
-                gpio_flag = ret ? GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-
-                if (config->gpio_is_open_drain)
-                        gpio_flag |= GPIOF_OPEN_DRAIN;
-
-                ret = gpio_request_one(config->gpio, gpio_flag,
-                                                config->supply_name);
-                if (ret) {
+        if (config->input_supply) {
+                drvdata->desc.supply_name = kstrdup(config->input_supply,
+                                                        GFP_KERNEL);
+                if (!drvdata->desc.supply_name) {
                         dev_err(&pdev->dev,
-                           "Could not obtain regulator enable GPIO %d: %d\n",
-                                                        config->gpio, ret);
+                                "Failed to allocate input supply\n");
+                        ret = -ENOMEM;
                         goto err_name;
                 }
+        }
+
+        if (config->microvolts)
+                drvdata->desc.n_voltages = 1;
 
-                drvdata->desc.ops = &fixed_voltage_gpio_ops;
+        drvdata->microvolts = config->microvolts;
 
+        if (config->gpio >= 0)
+                cfg.ena_gpio = config->gpio;
+        cfg.ena_gpio_invert = !config->enable_high;
+        if (config->enabled_at_boot) {
+                if (config->enable_high) {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                } else {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                }
         } else {
-                drvdata->desc.ops = &fixed_voltage_ops;
+                if (config->enable_high) {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                } else {
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                }
         }
+        if (config->gpio_is_open_drain)
+                cfg.ena_gpio_flags |= GPIOF_OPEN_DRAIN;
 
         cfg.dev = &pdev->dev;
         cfg.init_data = config->init_data;
@@ -259,7 +216,7 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
                 dev_err(&pdev->dev, "Failed to register regulator: %d\n", ret);
-                goto err_gpio;
+                goto err_input;
         }
 
         platform_set_drvdata(pdev, drvdata);
@@ -269,9 +226,8 @@ static int __devinit reg_fixed_voltage_probe(struct platform_device *pdev)
 
         return 0;
 
-err_gpio:
-        if (gpio_is_valid(config->gpio))
-                gpio_free(config->gpio);
+err_input:
+        kfree(drvdata->desc.supply_name);
 err_name:
         kfree(drvdata->desc.name);
 err:
@@ -283,8 +239,7 @@ static int __devexit reg_fixed_voltage_remove(struct platform_device *pdev)
         struct fixed_voltage_data *drvdata = platform_get_drvdata(pdev);
 
         regulator_unregister(drvdata->dev);
-        if (gpio_is_valid(drvdata->gpio))
-                gpio_free(drvdata->gpio);
+        kfree(drvdata->desc.supply_name);
         kfree(drvdata->desc.name);
 
         return 0;
@@ -296,8 +251,6 @@ static const struct of_device_id fixed_of_match[] __devinitconst = {
         {},
 };
 MODULE_DEVICE_TABLE(of, fixed_of_match);
-#else
-#define fixed_of_match NULL
 #endif
 
 static struct platform_driver regulator_fixed_voltage_driver = {
@@ -306,7 +259,7 @@ static struct platform_driver regulator_fixed_voltage_driver = {
         .driver         = {
                 .name           = "reg-fixed-voltage",
                 .owner          = THIS_MODULE,
-                .of_match_table = fixed_of_match,
+                .of_match_table = of_match_ptr(fixed_of_match),
         },
 };
 
diff --git a/drivers/regulator/gpio-regulator.c b/drivers/regulator/gpio-regulator.c
index 242851a4c1a6..34b67bee9323 100644
--- a/drivers/regulator/gpio-regulator.c
+++ b/drivers/regulator/gpio-regulator.c
@@ -36,11 +36,6 @@ struct gpio_regulator_data {
         struct regulator_desc desc;
         struct regulator_dev *dev;
 
-        int enable_gpio;
-        bool enable_high;
-        bool is_enabled;
-        unsigned startup_delay;
-
         struct gpio *gpios;
         int nr_gpios;
 
@@ -50,44 +45,6 @@ struct gpio_regulator_data {
         int state;
 };
 
-static int gpio_regulator_is_enabled(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        return data->is_enabled;
-}
-
-static int gpio_regulator_enable(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        if (gpio_is_valid(data->enable_gpio)) {
-                gpio_set_value_cansleep(data->enable_gpio, data->enable_high);
-                data->is_enabled = true;
-        }
-
-        return 0;
-}
-
-static int gpio_regulator_disable(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        if (gpio_is_valid(data->enable_gpio)) {
-                gpio_set_value_cansleep(data->enable_gpio, !data->enable_high);
-                data->is_enabled = false;
-        }
-
-        return 0;
-}
-
-static int gpio_regulator_enable_time(struct regulator_dev *dev)
-{
-        struct gpio_regulator_data *data = rdev_get_drvdata(dev);
-
-        return data->startup_delay;
-}
-
 static int gpio_regulator_get_value(struct regulator_dev *dev)
 {
         struct gpio_regulator_data *data = rdev_get_drvdata(dev);
@@ -153,20 +110,12 @@ static int gpio_regulator_set_current_limit(struct regulator_dev *dev,
 }
 
 static struct regulator_ops gpio_regulator_voltage_ops = {
-        .is_enabled = gpio_regulator_is_enabled,
-        .enable = gpio_regulator_enable,
-        .disable = gpio_regulator_disable,
-        .enable_time = gpio_regulator_enable_time,
         .get_voltage = gpio_regulator_get_value,
         .set_voltage = gpio_regulator_set_voltage,
         .list_voltage = gpio_regulator_list_voltage,
 };
 
 static struct regulator_ops gpio_regulator_current_ops = {
-        .is_enabled = gpio_regulator_is_enabled,
-        .enable = gpio_regulator_enable,
-        .disable = gpio_regulator_disable,
-        .enable_time = gpio_regulator_enable_time,
         .get_current_limit = gpio_regulator_get_value,
         .set_current_limit = gpio_regulator_set_current_limit,
 };
@@ -213,6 +162,7 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
         drvdata->nr_states = config->nr_states;
 
         drvdata->desc.owner = THIS_MODULE;
+        drvdata->desc.enable_time = config->startup_delay;
 
         /* handle regulator type*/
         switch (config->type) {
@@ -232,52 +182,12 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
                 break;
         }
 
-        drvdata->enable_gpio = config->enable_gpio;
-        drvdata->startup_delay = config->startup_delay;
-
-        if (gpio_is_valid(config->enable_gpio)) {
-                drvdata->enable_high = config->enable_high;
-
-                ret = gpio_request(config->enable_gpio, config->supply_name);
-                if (ret) {
-                        dev_err(&pdev->dev,
-                           "Could not obtain regulator enable GPIO %d: %d\n",
-                                                config->enable_gpio, ret);
-                        goto err_memstate;
-                }
-
-                /* set output direction without changing state
-                 * to prevent glitch
-                 */
-                if (config->enabled_at_boot) {
-                        drvdata->is_enabled = true;
-                        ret = gpio_direction_output(config->enable_gpio,
-                                                    config->enable_high);
-                } else {
-                        drvdata->is_enabled = false;
-                        ret = gpio_direction_output(config->enable_gpio,
-                                                    !config->enable_high);
-                }
-
-                if (ret) {
-                        dev_err(&pdev->dev,
-                           "Could not configure regulator enable GPIO %d direction: %d\n",
-                                                config->enable_gpio, ret);
-                        goto err_enablegpio;
-                }
-        } else {
-                /* Regulator without GPIO control is considered
-                 * always enabled
-                 */
-                drvdata->is_enabled = true;
-        }
-
         drvdata->nr_gpios = config->nr_gpios;
         ret = gpio_request_array(drvdata->gpios, drvdata->nr_gpios);
         if (ret) {
                 dev_err(&pdev->dev,
                    "Could not obtain regulator setting GPIOs: %d\n", ret);
-                goto err_enablegpio;
+                goto err_memstate;
         }
 
         /* build initial state from gpio init data. */
@@ -292,6 +202,21 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
         cfg.init_data = config->init_data;
         cfg.driver_data = drvdata;
 
+        if (config->enable_gpio >= 0)
+                cfg.ena_gpio = config->enable_gpio;
+        cfg.ena_gpio_invert = !config->enable_high;
+        if (config->enabled_at_boot) {
+                if (config->enable_high)
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+                else
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+        } else {
+                if (config->enable_high)
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_LOW;
+                else
+                        cfg.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+        }
+
         drvdata->dev = regulator_register(&drvdata->desc, &cfg);
         if (IS_ERR(drvdata->dev)) {
                 ret = PTR_ERR(drvdata->dev);
@@ -305,9 +230,6 @@ static int __devinit gpio_regulator_probe(struct platform_device *pdev)
 
 err_stategpio:
         gpio_free_array(drvdata->gpios, drvdata->nr_gpios);
-err_enablegpio:
-        if (gpio_is_valid(config->enable_gpio))
-                gpio_free(config->enable_gpio);
 err_memstate:
         kfree(drvdata->states);
 err_memgpio:
@@ -329,9 +251,6 @@ static int __devexit gpio_regulator_remove(struct platform_device *pdev)
         kfree(drvdata->states);
         kfree(drvdata->gpios);
 
-        if (gpio_is_valid(drvdata->enable_gpio))
-                gpio_free(drvdata->enable_gpio);
-
         kfree(drvdata->desc.name);
 
         return 0;
diff --git a/drivers/regulator/isl6271a-regulator.c b/drivers/regulator/isl6271a-regulator.c
index 56d273f25603..1d145a07ada9 100644
--- a/drivers/regulator/isl6271a-regulator.c
+++ b/drivers/regulator/isl6271a-regulator.c
@@ -75,19 +75,12 @@ static struct regulator_ops isl_core_ops = {
 
 static int isl6271a_get_fixed_voltage(struct regulator_dev *dev)
 {
-        int id = rdev_get_id(dev);
-        return (id == 1) ? 1100000 : 1300000;
-}
-
-static int isl6271a_list_fixed_voltage(struct regulator_dev *dev, unsigned selector)
-{
-        int id = rdev_get_id(dev);
-        return (id == 1) ? 1100000 : 1300000;
+        return dev->desc->min_uV;
 }
 
 static struct regulator_ops isl_fixed_ops = {
         .get_voltage    = isl6271a_get_fixed_voltage,
-        .list_voltage   = isl6271a_list_fixed_voltage,
+        .list_voltage   = regulator_list_voltage_linear,
 };
 
 static const struct regulator_desc isl_rd[] = {
@@ -107,6 +100,7 @@ static const struct regulator_desc isl_rd[] = {
                 .ops            = &isl_fixed_ops,
                 .type           = REGULATOR_VOLTAGE,
                 .owner          = THIS_MODULE,
+                .min_uV         = 1100000,
         }, {
                 .name           = "LDO2",
                 .id             = 2,
@@ -114,6 +108,7 @@ static const struct regulator_desc isl_rd[] = {
                 .ops            = &isl_fixed_ops,
                 .type           = REGULATOR_VOLTAGE,
                 .owner          = THIS_MODULE,
+                .min_uV         = 1300000,
         },
 };
 
diff --git a/drivers/regulator/lp3971.c b/drivers/regulator/lp3971.c
index 981bea9cb9d7..7c6e3b8ff484 100644
--- a/drivers/regulator/lp3971.c
+++ b/drivers/regulator/lp3971.c
@@ -65,11 +65,11 @@ static const int buck_base_addr[] = {
 #define LP3971_BUCK_TARGET_VOL1_REG(x) (buck_base_addr[x])
 #define LP3971_BUCK_TARGET_VOL2_REG(x) (buck_base_addr[x]+1)
 
-static const int buck_voltage_map[] = {
-           0,  800,  850,  900,  950, 1000, 1050, 1100,
-        1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
-        1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
-        3000, 3300,
+static const unsigned int buck_voltage_map[] = {
+              0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
+        3000000, 3300000,
 };
 
 #define BUCK_TARGET_VOL_MASK 0x3f
@@ -98,39 +98,19 @@ static const int buck_voltage_map[] = {
 #define LDO_VOL_CONTR_SHIFT(x) ((x & 1) << 2)
 #define LDO_VOL_CONTR_MASK 0x0f
 
-static const int ldo45_voltage_map[] = {
-        1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
-        1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
+static const unsigned int ldo45_voltage_map[] = {
+        1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
+        1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
 };
 
-static const int ldo123_voltage_map[] = {
-        1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
-        2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+static const unsigned int ldo123_voltage_map[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
 };
 
-static const int *ldo_voltage_map[] = {
-        ldo123_voltage_map, /* LDO1 */
-        ldo123_voltage_map, /* LDO2 */
-        ldo123_voltage_map, /* LDO3 */
-        ldo45_voltage_map, /* LDO4 */
-        ldo45_voltage_map, /* LDO5 */
-};
-
-#define LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[(x - LP3971_LDO1)])
-
 #define LDO_VOL_MIN_IDX 0x00
 #define LDO_VOL_MAX_IDX 0x0f
 
-static int lp3971_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int ldo = rdev_get_id(dev) - LP3971_LDO1;
-
-        if (index > LDO_VOL_MAX_IDX)
-                return -EINVAL;
-
-        return 1000 * LDO_VOL_VALUE_MAP(ldo)[index];
-}
-
 static int lp3971_ldo_is_enabled(struct regulator_dev *dev)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
@@ -169,7 +149,7 @@ static int lp3971_ldo_get_voltage(struct regulator_dev *dev)
         reg = lp3971_reg_read(lp3971, LP3971_LDO_VOL_CONTR_REG(ldo));
         val = (reg >> LDO_VOL_CONTR_SHIFT(ldo)) & LDO_VOL_CONTR_MASK;
 
-        return 1000 * LDO_VOL_VALUE_MAP(ldo)[val];
+        return dev->desc->volt_table[val];
 }
 
 static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
@@ -184,7 +164,7 @@ static int lp3971_ldo_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3971_ldo_ops = {
-        .list_voltage = lp3971_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3971_ldo_is_enabled,
         .enable = lp3971_ldo_enable,
         .disable = lp3971_ldo_disable,
@@ -192,14 +172,6 @@ static struct regulator_ops lp3971_ldo_ops = {
         .set_voltage_sel = lp3971_ldo_set_voltage_sel,
 };
 
-static int lp3971_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        if (index < BUCK_TARGET_VOL_MIN_IDX || index > BUCK_TARGET_VOL_MAX_IDX)
-                return -EINVAL;
-
-        return 1000 * buck_voltage_map[index];
-}
-
 static int lp3971_dcdc_is_enabled(struct regulator_dev *dev)
 {
         struct lp3971 *lp3971 = rdev_get_drvdata(dev);
@@ -240,7 +212,7 @@ static int lp3971_dcdc_get_voltage(struct regulator_dev *dev)
         reg &= BUCK_TARGET_VOL_MASK;
 
         if (reg <= BUCK_TARGET_VOL_MAX_IDX)
-                val = 1000 * buck_voltage_map[reg];
+                val = buck_voltage_map[reg];
         else {
                 val = 0;
                 dev_warn(&dev->dev, "chip reported incorrect voltage value.\n");
@@ -273,7 +245,7 @@ static int lp3971_dcdc_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3971_dcdc_ops = {
-        .list_voltage = lp3971_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3971_dcdc_is_enabled,
         .enable = lp3971_dcdc_enable,
         .disable = lp3971_dcdc_disable,
@@ -287,6 +259,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO1,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -295,6 +268,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO2,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -303,6 +277,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO3,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo123_voltage_map),
+                .volt_table = ldo123_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -311,6 +286,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO4,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
+                .volt_table = ldo45_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -319,6 +295,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_LDO5,
                 .ops = &lp3971_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo45_voltage_map),
+                .volt_table = ldo45_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -327,6 +304,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC1,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -335,6 +313,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC2,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -343,6 +322,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3971_DCDC3,
                 .ops = &lp3971_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck_voltage_map),
+                .volt_table = buck_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
diff --git a/drivers/regulator/lp3972.c b/drivers/regulator/lp3972.c
index de073df7d344..3cdc755d9b22 100644
--- a/drivers/regulator/lp3972.c
+++ b/drivers/regulator/lp3972.c
@@ -74,54 +74,40 @@ struct lp3972 {
 #define LP3972_OVER2_LDO4_EN    BIT(4)
 #define LP3972_OVER1_S_EN       BIT(2)
 
-static const int ldo1_voltage_map[] = {
-        1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
-        1900, 1925, 1950, 1975, 2000,
+static const unsigned int ldo1_voltage_map[] = {
+        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
+        1900000, 1925000, 1950000, 1975000, 2000000,
 };
 
-static const int ldo23_voltage_map[] = {
-        1800, 1900, 2000, 2100, 2200, 2300, 2400, 2500,
-        2600, 2700, 2800, 2900, 3000, 3100, 3200, 3300,
+static const unsigned int ldo23_voltage_map[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3100000, 3200000, 3300000,
 };
 
-static const int ldo4_voltage_map[] = {
-        1000, 1050, 1100, 1150, 1200, 1250, 1300, 1350,
-        1400, 1500, 1800, 1900, 2500, 2800, 3000, 3300,
+static const unsigned int ldo4_voltage_map[] = {
+        1000000, 1050000, 1100000, 1150000, 1200000, 1250000, 1300000, 1350000,
+        1400000, 1500000, 1800000, 1900000, 2500000, 2800000, 3000000, 3300000,
 };
 
-static const int ldo5_voltage_map[] = {
-           0,    0,    0,    0,    0,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int ldo5_voltage_map[] = {
+              0,       0,       0,       0,       0,  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,
 };
 
-static const int buck1_voltage_map[] = {
-         725,  750,  775,  800,  825,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int buck1_voltage_map[] = {
+         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,
 };
 
-static const int buck23_voltage_map[] = {
-           0,  800,  850,  900,  950, 1000, 1050, 1100,
-        1150, 1200, 1250, 1300, 1350, 1400, 1450, 1500,
-        1550, 1600, 1650, 1700, 1800, 1900, 2500, 2800,
-        3000, 3300,
-};
-
-static const int *ldo_voltage_map[] = {
-        ldo1_voltage_map,
-        ldo23_voltage_map,
-        ldo23_voltage_map,
-        ldo4_voltage_map,
-        ldo5_voltage_map,
-};
-
-static const int *buck_voltage_map[] = {
-        buck1_voltage_map,
-        buck23_voltage_map,
-        buck23_voltage_map,
+static const unsigned int buck23_voltage_map[] = {
+              0,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1800000, 1900000, 2500000, 2800000,
+        3000000, 3300000,
 };
 
 static const int ldo_output_enable_mask[] = {
@@ -160,7 +146,6 @@ static const int buck_base_addr[] = {
         LP3972_B3TV_REG,
 };
 
-#define LP3972_LDO_VOL_VALUE_MAP(x) (ldo_voltage_map[x])
 #define LP3972_LDO_OUTPUT_ENABLE_MASK(x) (ldo_output_enable_mask[x])
 #define LP3972_LDO_OUTPUT_ENABLE_REG(x) (ldo_output_enable_addr[x])
 
@@ -177,7 +162,6 @@ static const int buck_base_addr[] = {
 #define LP3972_LDO_VOL_MIN_IDX(x) (((x) == 4) ? 0x05 : 0x00)
 #define LP3972_LDO_VOL_MAX_IDX(x) ((x) ? (((x) == 4) ? 0x1f : 0x0f) : 0x0c)
 
-#define LP3972_BUCK_VOL_VALUE_MAP(x) (buck_voltage_map[x])
 #define LP3972_BUCK_VOL_ENABLE_REG(x) (buck_vol_enable_addr[x])
 #define LP3972_BUCK_VOL1_REG(x) (buck_base_addr[x])
 #define LP3972_BUCK_VOL_MASK 0x1f
@@ -242,17 +226,6 @@ static int lp3972_set_bits(struct lp3972 *lp3972, u8 reg, u16 mask, u16 val)
         return ret;
 }
 
-static int lp3972_ldo_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int ldo = rdev_get_id(dev) - LP3972_LDO1;
-
-        if (index < LP3972_LDO_VOL_MIN_IDX(ldo) ||
-            index > LP3972_LDO_VOL_MAX_IDX(ldo))
-                return -EINVAL;
-
-        return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[index];
-}
-
 static int lp3972_ldo_is_enabled(struct regulator_dev *dev)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
@@ -294,7 +267,7 @@ static int lp3972_ldo_get_voltage(struct regulator_dev *dev)
         reg = lp3972_reg_read(lp3972, LP3972_LDO_VOL_CONTR_REG(ldo));
         val = (reg >> LP3972_LDO_VOL_CONTR_SHIFT(ldo)) & mask;
 
-        return 1000 * LP3972_LDO_VOL_VALUE_MAP(ldo)[val];
+        return dev->desc->volt_table[val];
 }
 
 static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
@@ -337,7 +310,7 @@ static int lp3972_ldo_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3972_ldo_ops = {
-        .list_voltage = lp3972_ldo_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3972_ldo_is_enabled,
         .enable = lp3972_ldo_enable,
         .disable = lp3972_ldo_disable,
@@ -345,17 +318,6 @@ static struct regulator_ops lp3972_ldo_ops = {
         .set_voltage_sel = lp3972_ldo_set_voltage_sel,
 };
 
-static int lp3972_dcdc_list_voltage(struct regulator_dev *dev, unsigned index)
-{
-        int buck = rdev_get_id(dev) - LP3972_DCDC1;
-
-        if (index < LP3972_BUCK_VOL_MIN_IDX(buck) ||
-            index > LP3972_BUCK_VOL_MAX_IDX(buck))
-                return -EINVAL;
-
-        return 1000 * buck_voltage_map[buck][index];
-}
-
 static int lp3972_dcdc_is_enabled(struct regulator_dev *dev)
 {
         struct lp3972 *lp3972 = rdev_get_drvdata(dev);
@@ -401,7 +363,7 @@ static int lp3972_dcdc_get_voltage(struct regulator_dev *dev)
         reg = lp3972_reg_read(lp3972, LP3972_BUCK_VOL1_REG(buck));
         reg &= LP3972_BUCK_VOL_MASK;
         if (reg <= LP3972_BUCK_VOL_MAX_IDX(buck))
-                val = 1000 * buck_voltage_map[buck][reg];
+                val = dev->desc->volt_table[reg];
         else {
                 val = 0;
                 dev_warn(&dev->dev, "chip reported incorrect voltage value."
@@ -436,7 +398,7 @@ static int lp3972_dcdc_set_voltage_sel(struct regulator_dev *dev,
 }
 
 static struct regulator_ops lp3972_dcdc_ops = {
-        .list_voltage = lp3972_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .is_enabled = lp3972_dcdc_is_enabled,
         .enable = lp3972_dcdc_enable,
         .disable = lp3972_dcdc_disable,
@@ -450,6 +412,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO1,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo1_voltage_map),
+                .volt_table = ldo1_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -458,6 +421,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO2,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+                .volt_table = ldo23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -466,6 +430,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO3,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo23_voltage_map),
+                .volt_table = ldo23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -474,6 +439,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO4,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo4_voltage_map),
+                .volt_table = ldo4_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -482,6 +448,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_LDO5,
                 .ops = &lp3972_ldo_ops,
                 .n_voltages = ARRAY_SIZE(ldo5_voltage_map),
+                .volt_table = ldo5_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -490,6 +457,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC1,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck1_voltage_map),
+                .volt_table = buck1_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -498,6 +466,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC2,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+                .volt_table = buck23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
@@ -506,6 +475,7 @@ static const struct regulator_desc regulators[] = {
                 .id = LP3972_DCDC3,
                 .ops = &lp3972_dcdc_ops,
                 .n_voltages = ARRAY_SIZE(buck23_voltage_map),
+                .volt_table = buck23_voltage_map,
                 .type = REGULATOR_VOLTAGE,
                 .owner = THIS_MODULE,
         },
diff --git a/drivers/regulator/lp872x.c b/drivers/regulator/lp872x.c
new file mode 100644
index 000000000000..212c38eaba70
--- /dev/null
+++ b/drivers/regulator/lp872x.c
@@ -0,0 +1,943 @@
+/*
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/regmap.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/regulator/lp872x.h>
+#include <linux/regulator/driver.h>
+#include <linux/platform_device.h>
+
+/* Registers : LP8720/8725 shared */
+#define LP872X_GENERAL_CFG              0x00
+#define LP872X_LDO1_VOUT                0x01
+#define LP872X_LDO2_VOUT                0x02
+#define LP872X_LDO3_VOUT                0x03
+#define LP872X_LDO4_VOUT                0x04
+#define LP872X_LDO5_VOUT                0x05
+
+/* Registers : LP8720 */
+#define LP8720_BUCK_VOUT1               0x06
+#define LP8720_BUCK_VOUT2               0x07
+#define LP8720_ENABLE                   0x08
+
+/* Registers : LP8725 */
+#define LP8725_LILO1_VOUT               0x06
+#define LP8725_LILO2_VOUT               0x07
+#define LP8725_BUCK1_VOUT1              0x08
+#define LP8725_BUCK1_VOUT2              0x09
+#define LP8725_BUCK2_VOUT1              0x0A
+#define LP8725_BUCK2_VOUT2              0x0B
+#define LP8725_BUCK_CTRL                0x0C
+#define LP8725_LDO_CTRL                 0x0D
+
+/* Mask/shift : LP8720/LP8725 shared */
+#define LP872X_VOUT_M                   0x1F
+#define LP872X_START_DELAY_M            0xE0
+#define LP872X_START_DELAY_S            5
+#define LP872X_EN_LDO1_M                BIT(0)
+#define LP872X_EN_LDO2_M                BIT(1)
+#define LP872X_EN_LDO3_M                BIT(2)
+#define LP872X_EN_LDO4_M                BIT(3)
+#define LP872X_EN_LDO5_M                BIT(4)
+
+/* Mask/shift : LP8720 */
+#define LP8720_TIMESTEP_S               0               /* Addr 00h */
+#define LP8720_TIMESTEP_M               BIT(0)
+#define LP8720_EXT_DVS_M                BIT(2)
+#define LP8720_BUCK_FPWM_S              5               /* Addr 07h */
+#define LP8720_BUCK_FPWM_M              BIT(5)
+#define LP8720_EN_BUCK_M                BIT(5)          /* Addr 08h */
+#define LP8720_DVS_SEL_M                BIT(7)
+
+/* Mask/shift : LP8725 */
+#define LP8725_TIMESTEP_M               0xC0            /* Addr 00h */
+#define LP8725_TIMESTEP_S               6
+#define LP8725_BUCK1_EN_M               BIT(0)
+#define LP8725_DVS1_M                   BIT(2)
+#define LP8725_DVS2_M                   BIT(3)
+#define LP8725_BUCK2_EN_M               BIT(4)
+#define LP8725_BUCK_CL_M                0xC0            /* Addr 09h, 0Bh */
+#define LP8725_BUCK_CL_S                6
+#define LP8725_BUCK1_FPWM_S             1               /* Addr 0Ch */
+#define LP8725_BUCK1_FPWM_M             BIT(1)
+#define LP8725_BUCK2_FPWM_S             5
+#define LP8725_BUCK2_FPWM_M             BIT(5)
+#define LP8725_EN_LILO1_M               BIT(5)          /* Addr 0Dh */
+#define LP8725_EN_LILO2_M               BIT(6)
+
+/* PWM mode */
+#define LP872X_FORCE_PWM                1
+#define LP872X_AUTO_PWM                 0
+
+#define LP8720_NUM_REGULATORS           6
+#define LP8725_NUM_REGULATORS           9
+#define EXTERN_DVS_USED                 0
+#define MAX_DELAY                       6
+
+/* dump registers in regmap-debugfs */
+#define MAX_REGISTERS                   0x0F
+
+enum lp872x_id {
+        LP8720,
+        LP8725,
+};
+
+struct lp872x {
+        struct regmap *regmap;
+        struct device *dev;
+        enum lp872x_id chipid;
+        struct lp872x_platform_data *pdata;
+        struct regulator_dev **regulators;
+        int num_regulators;
+        enum lp872x_dvs_state dvs_pin;
+        int dvs_gpio;
+};
+
+/* LP8720/LP8725 shared voltage table for LDOs */
+static const unsigned int lp872x_ldo_vtbl[] = {
+        1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
+        1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
+        2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
+        2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
+};
+
+/* LP8720 LDO4 voltage table */
+static const unsigned int lp8720_ldo4_vtbl[] = {
+         800000,  850000,  900000, 1000000, 1100000, 1200000, 1250000, 1300000,
+        1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
+        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
+        2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
+};
+
+/* LP8725 LILO(Low Input Low Output) voltage table */
+static const unsigned int lp8725_lilo_vtbl[] = {
+         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
+        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
+};
+
+/* LP8720 BUCK voltage table */
+#define EXT_R           0       /* external resistor divider */
+static const unsigned int lp8720_buck_vtbl[] = {
+          EXT_R,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
+        1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
+};
+
+/* LP8725 BUCK voltage table */
+static const unsigned int lp8725_buck_vtbl[] = {
+         800000,  850000,  900000,  950000, 1000000, 1050000, 1100000, 1150000,
+        1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
+        1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
+        2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
+};
+
+/* LP8725 BUCK current limit */
+static const unsigned int lp8725_buck_uA[] = {
+        460000, 780000, 1050000, 1370000,
+};
+
+static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
+{
+        int ret;
+        unsigned int val;
+
+        ret = regmap_read(lp->regmap, addr, &val);
+        if (ret < 0) {
+                dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
+                return ret;
+        }
+
+        *data = (u8)val;
+        return 0;
+}
+
+static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
+{
+        return regmap_write(lp->regmap, addr, data);
+}
+
+static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
+                                unsigned int mask, u8 data)
+{
+        return regmap_update_bits(lp->regmap, addr, mask, data);
+}
+
+static int _rdev_to_offset(struct regulator_dev *rdev)
+{
+        enum lp872x_regulator_id id = rdev_get_id(rdev);
+
+        switch (id) {
+        case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
+                return id;
+        case LP8725_ID_LDO1 ... LP8725_ID_BUCK2:
+                return id - LP8725_ID_BASE;
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp872x_get_timestep_usec(struct lp872x *lp)
+{
+        enum lp872x_id chip = lp->chipid;
+        u8 val, mask, shift;
+        int *time_usec, size, ret;
+        int lp8720_time_usec[] = { 25, 50 };
+        int lp8725_time_usec[] = { 32, 64, 128, 256 };
+
+        switch (chip) {
+        case LP8720:
+                mask = LP8720_TIMESTEP_M;
+                shift = LP8720_TIMESTEP_S;
+                time_usec = &lp8720_time_usec[0];
+                size = ARRAY_SIZE(lp8720_time_usec);
+                break;
+        case LP8725:
+                mask = LP8725_TIMESTEP_M;
+                shift = LP8725_TIMESTEP_S;
+                time_usec = &lp8725_time_usec[0];
+                size = ARRAY_SIZE(lp8725_time_usec);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
+        if (ret)
+                return -EINVAL;
+
+        val = (val & mask) >> shift;
+        if (val >= size)
+                return -EINVAL;
+
+        return *(time_usec + val);
+}
+
+static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id regulator = rdev_get_id(rdev);
+        int time_step_us = lp872x_get_timestep_usec(lp);
+        int ret, offset;
+        u8 addr, val;
+
+        if (time_step_us < 0)
+                return -EINVAL;
+
+        switch (regulator) {
+        case LP8720_ID_LDO1 ... LP8720_ID_LDO5:
+        case LP8725_ID_LDO1 ... LP8725_ID_LILO2:
+                offset = _rdev_to_offset(rdev);
+                if (offset < 0)
+                        return -EINVAL;
+
+                addr = LP872X_LDO1_VOUT + offset;
+                break;
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT1;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT1;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT1;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
+
+        return val > MAX_DELAY ? 0 : val * time_step_us;
+}
+
+static void lp872x_set_dvs(struct lp872x *lp, int gpio)
+{
+        enum lp872x_dvs_sel dvs_sel = lp->pdata->dvs->vsel;
+        enum lp872x_dvs_state state;
+
+        state = dvs_sel == SEL_V1 ? DVS_HIGH : DVS_LOW;
+        gpio_set_value(gpio, state);
+        lp->dvs_pin = state;
+}
+
+static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
+                                enum lp872x_regulator_id buck)
+{
+        u8 val, addr;
+
+        if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
+                return 0;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                if (val & LP8720_EXT_DVS_M) {
+                        addr = (lp->dvs_pin == DVS_HIGH) ?
+                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
+                } else {
+                        if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
+                                return 0;
+
+                        addr = val & LP8720_DVS_SEL_M ?
+                                LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
+                }
+                break;
+        case LP8725_ID_BUCK1:
+                if (val & LP8725_DVS1_M)
+                        addr = LP8725_BUCK1_VOUT1;
+                else
+                        addr = (lp->dvs_pin == DVS_HIGH) ?
+                                LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr =  val & LP8725_DVS2_M ?
+                        LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return 0;
+        }
+
+        return addr;
+}
+
+static bool lp872x_is_valid_buck_addr(u8 addr)
+{
+        switch (addr) {
+        case LP8720_BUCK_VOUT1:
+        case LP8720_BUCK_VOUT2:
+        case LP8725_BUCK1_VOUT1:
+        case LP8725_BUCK1_VOUT2:
+        case LP8725_BUCK2_VOUT1:
+        case LP8725_BUCK2_VOUT2:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask = LP872X_VOUT_M;
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+
+        if (dvs && gpio_is_valid(dvs->gpio))
+                lp872x_set_dvs(lp, dvs->gpio);
+
+        addr = lp872x_select_buck_vout_addr(lp, buck);
+        if (!lp872x_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        return lp872x_update_bits(lp, addr, mask, selector);
+}
+
+static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, val;
+        int ret;
+
+        addr = lp872x_select_buck_vout_addr(lp, buck);
+        if (!lp872x_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & LP872X_VOUT_M;
+}
+
+static int lp8725_buck_set_current_limit(struct regulator_dev *rdev,
+                                        int min_uA, int max_uA)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        int i, max = ARRAY_SIZE(lp8725_buck_uA);
+        u8 addr, val;
+
+        switch (buck) {
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        for (i = 0 ; i < max ; i++)
+                if (lp8725_buck_uA[i] >= min_uA &&
+                        lp8725_buck_uA[i] <= max_uA)
+                        break;
+
+        if (i == max)
+                return -EINVAL;
+
+        val = i << LP8725_BUCK_CL_S;
+
+        return lp872x_update_bits(lp, addr, LP8725_BUCK_CL_M, val);
+}
+
+static int lp8725_buck_get_current_limit(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, val;
+        int ret;
+
+        switch (buck) {
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK1_VOUT2;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK2_VOUT2;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        val = (val & LP8725_BUCK_CL_M) >> LP8725_BUCK_CL_S;
+
+        return (val < ARRAY_SIZE(lp8725_buck_uA)) ?
+                        lp8725_buck_uA[val] : -EINVAL;
+}
+
+static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask, shift, val;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT2;
+                mask = LP8720_BUCK_FPWM_M;
+                shift = LP8720_BUCK_FPWM_S;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK1_FPWM_M;
+                shift = LP8725_BUCK1_FPWM_S;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK2_FPWM_M;
+                shift = LP8725_BUCK2_FPWM_S;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (mode == REGULATOR_MODE_FAST)
+                val = LP872X_FORCE_PWM << shift;
+        else if (mode == REGULATOR_MODE_NORMAL)
+                val = LP872X_AUTO_PWM << shift;
+        else
+                return -EINVAL;
+
+        return lp872x_update_bits(lp, addr, mask, val);
+}
+
+static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
+{
+        struct lp872x *lp = rdev_get_drvdata(rdev);
+        enum lp872x_regulator_id buck = rdev_get_id(rdev);
+        u8 addr, mask, val;
+        int ret;
+
+        switch (buck) {
+        case LP8720_ID_BUCK:
+                addr = LP8720_BUCK_VOUT2;
+                mask = LP8720_BUCK_FPWM_M;
+                break;
+        case LP8725_ID_BUCK1:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK1_FPWM_M;
+                break;
+        case LP8725_ID_BUCK2:
+                addr = LP8725_BUCK_CTRL;
+                mask = LP8725_BUCK2_FPWM_M;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        ret = lp872x_read_byte(lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
+}
+
+static struct regulator_ops lp872x_ldo_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+};
+
+static struct regulator_ops lp8720_buck_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp872x_buck_set_voltage_sel,
+        .get_voltage_sel = lp872x_buck_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+        .set_mode = lp872x_buck_set_mode,
+        .get_mode = lp872x_buck_get_mode,
+};
+
+static struct regulator_ops lp8725_buck_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp872x_buck_set_voltage_sel,
+        .get_voltage_sel = lp872x_buck_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp872x_regulator_enable_time,
+        .set_mode = lp872x_buck_set_mode,
+        .get_mode = lp872x_buck_get_mode,
+        .set_current_limit = lp8725_buck_set_current_limit,
+        .get_current_limit = lp8725_buck_get_current_limit,
+};
+
+static struct regulator_desc lp8720_regulator_desc[] = {
+        {
+                .name = "ldo1",
+                .id = LP8720_ID_LDO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO1_M,
+        },
+        {
+                .name = "ldo2",
+                .id = LP8720_ID_LDO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO2_M,
+        },
+        {
+                .name = "ldo3",
+                .id = LP8720_ID_LDO3,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO3_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO3_M,
+        },
+        {
+                .name = "ldo4",
+                .id = LP8720_ID_LDO4,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
+                .volt_table = lp8720_ldo4_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO4_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO4_M,
+        },
+        {
+                .name = "ldo5",
+                .id = LP8720_ID_LDO5,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO5_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP872X_EN_LDO5_M,
+        },
+        {
+                .name = "buck",
+                .id = LP8720_ID_BUCK,
+                .ops = &lp8720_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
+                .volt_table = lp8720_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8720_ENABLE,
+                .enable_mask = LP8720_EN_BUCK_M,
+        },
+};
+
+static struct regulator_desc lp8725_regulator_desc[] = {
+        {
+                .name = "ldo1",
+                .id = LP8725_ID_LDO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO1_M,
+        },
+        {
+                .name = "ldo2",
+                .id = LP8725_ID_LDO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO2_M,
+        },
+        {
+                .name = "ldo3",
+                .id = LP8725_ID_LDO3,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO3_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO3_M,
+        },
+        {
+                .name = "ldo4",
+                .id = LP8725_ID_LDO4,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO4_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO4_M,
+        },
+        {
+                .name = "ldo5",
+                .id = LP8725_ID_LDO5,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
+                .volt_table = lp872x_ldo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP872X_LDO5_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP872X_EN_LDO5_M,
+        },
+        {
+                .name = "lilo1",
+                .id = LP8725_ID_LILO1,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
+                .volt_table = lp8725_lilo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8725_LILO1_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP8725_EN_LILO1_M,
+        },
+        {
+                .name = "lilo2",
+                .id = LP8725_ID_LILO2,
+                .ops = &lp872x_ldo_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
+                .volt_table = lp8725_lilo_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8725_LILO2_VOUT,
+                .vsel_mask = LP872X_VOUT_M,
+                .enable_reg = LP8725_LDO_CTRL,
+                .enable_mask = LP8725_EN_LILO2_M,
+        },
+        {
+                .name = "buck1",
+                .id = LP8725_ID_BUCK1,
+                .ops = &lp8725_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
+                .volt_table = lp8725_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP872X_GENERAL_CFG,
+                .enable_mask = LP8725_BUCK1_EN_M,
+        },
+        {
+                .name = "buck2",
+                .id = LP8725_ID_BUCK2,
+                .ops = &lp8725_buck_ops,
+                .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
+                .volt_table = lp8725_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP872X_GENERAL_CFG,
+                .enable_mask = LP8725_BUCK2_EN_M,
+        },
+};
+
+static int lp872x_check_dvs_validity(struct lp872x *lp)
+{
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+        u8 val = 0;
+        int ret;
+
+        ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
+        if (ret)
+                return ret;
+
+        ret = 0;
+        if (lp->chipid == LP8720) {
+                if (val & LP8720_EXT_DVS_M)
+                        ret = dvs ? 0 : -EINVAL;
+        } else {
+                if ((val & LP8725_DVS1_M) == EXTERN_DVS_USED)
+                        ret = dvs ? 0 : -EINVAL;
+        }
+
+        return ret;
+}
+
+static int lp872x_init_dvs(struct lp872x *lp)
+{
+        int ret, gpio;
+        struct lp872x_dvs *dvs = lp->pdata->dvs;
+        enum lp872x_dvs_state pinstate;
+
+        ret = lp872x_check_dvs_validity(lp);
+        if (ret) {
+                dev_warn(lp->dev, "invalid dvs data: %d\n", ret);
+                return ret;
+        }
+
+        gpio = dvs->gpio;
+        if (!gpio_is_valid(gpio)) {
+                dev_err(lp->dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        pinstate = dvs->init_state;
+        ret = devm_gpio_request_one(lp->dev, gpio, pinstate, "LP872X DVS");
+        if (ret) {
+                dev_err(lp->dev, "gpio request err: %d\n", ret);
+                return ret;
+        }
+
+        lp->dvs_pin = pinstate;
+        lp->dvs_gpio = gpio;
+
+        return 0;
+}
+
+static int lp872x_config(struct lp872x *lp)
+{
+        struct lp872x_platform_data *pdata = lp->pdata;
+        int ret;
+
+        if (!pdata->update_config)
+                return 0;
+
+        ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
+        if (ret)
+                return ret;
+
+        return lp872x_init_dvs(lp);
+}
+
+static struct regulator_init_data
+*lp872x_find_regulator_init_data(int id, struct lp872x *lp)
+{
+        int i;
+
+        for (i = 0; i < lp->num_regulators; i++) {
+                if (lp->pdata->regulator_data[i].id == id)
+                        return lp->pdata->regulator_data[i].init_data;
+        }
+
+        return NULL;
+}
+
+static int lp872x_regulator_register(struct lp872x *lp)
+{
+        struct regulator_desc *desc;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int i, ret;
+
+        for (i = 0 ; i < lp->num_regulators ; i++) {
+                desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
+                                                &lp8725_regulator_desc[i];
+
+                cfg.dev = lp->dev;
+                cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
+                cfg.driver_data = lp;
+                cfg.regmap = lp->regmap;
+
+                rdev = regulator_register(desc, &cfg);
+                if (IS_ERR(rdev)) {
+                        dev_err(lp->dev, "regulator register err");
+                        ret =  PTR_ERR(rdev);
+                        goto err;
+                }
+
+                *(lp->regulators + i) = rdev;
+        }
+
+        return 0;
+err:
+        while (--i >= 0) {
+                rdev = *(lp->regulators + i);
+                regulator_unregister(rdev);
+        }
+        return ret;
+}
+
+static void lp872x_regulator_unregister(struct lp872x *lp)
+{
+        struct regulator_dev *rdev;
+        int i;
+
+        for (i = 0 ; i < lp->num_regulators ; i++) {
+                rdev = *(lp->regulators + i);
+                regulator_unregister(rdev);
+        }
+}
+
+static const struct regmap_config lp872x_regmap_config = {
+        .reg_bits = 8,
+        .val_bits = 8,
+        .max_register = MAX_REGISTERS,
+};
+
+static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
+{
+        struct lp872x *lp;
+        struct lp872x_platform_data *pdata = cl->dev.platform_data;
+        int ret, size, num_regulators;
+        const int lp872x_num_regulators[] = {
+                [LP8720] = LP8720_NUM_REGULATORS,
+                [LP8725] = LP8725_NUM_REGULATORS,
+        };
+
+        if (!pdata) {
+                dev_err(&cl->dev, "no platform data\n");
+                return -EINVAL;
+        }
+
+        lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
+        if (!lp)
+                goto err_mem;
+
+        num_regulators = lp872x_num_regulators[id->driver_data];
+        size = sizeof(struct regulator_dev *) * num_regulators;
+
+        lp->regulators = devm_kzalloc(&cl->dev, size, GFP_KERNEL);
+        if (!lp->regulators)
+                goto err_mem;
+
+        lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
+        if (IS_ERR(lp->regmap)) {
+                ret = PTR_ERR(lp->regmap);
+                dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
+                goto err_dev;
+        }
+
+        lp->dev = &cl->dev;
+        lp->pdata = pdata;
+        lp->chipid = id->driver_data;
+        lp->num_regulators = num_regulators;
+        i2c_set_clientdata(cl, lp);
+
+        ret = lp872x_config(lp);
+        if (ret)
+                goto err_dev;
+
+        return lp872x_regulator_register(lp);
+
+err_mem:
+        return -ENOMEM;
+err_dev:
+        return ret;
+}
+
+static int __devexit lp872x_remove(struct i2c_client *cl)
+{
+        struct lp872x *lp = i2c_get_clientdata(cl);
+
+        lp872x_regulator_unregister(lp);
+        return 0;
+}
+
+static const struct i2c_device_id lp872x_ids[] = {
+        {"lp8720", LP8720},
+        {"lp8725", LP8725},
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, lp872x_ids);
+
+static struct i2c_driver lp872x_driver = {
+        .driver = {
+                .name = "lp872x",
+                .owner = THIS_MODULE,
+        },
+        .probe = lp872x_probe,
+        .remove = __devexit_p(lp872x_remove),
+        .id_table = lp872x_ids,
+};
+
+module_i2c_driver(lp872x_driver);
+
+MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/lp8788-buck.c b/drivers/regulator/lp8788-buck.c
new file mode 100644
index 000000000000..6356e821400f
--- /dev/null
+++ b/drivers/regulator/lp8788-buck.c
@@ -0,0 +1,629 @@
+/*
+ * TI LP8788 MFD - buck regulator driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/mfd/lp8788.h>
+#include <linux/gpio.h>
+
+/* register address */
+#define LP8788_EN_BUCK                  0x0C
+#define LP8788_BUCK_DVS_SEL             0x1D
+#define LP8788_BUCK1_VOUT0              0x1E
+#define LP8788_BUCK1_VOUT1              0x1F
+#define LP8788_BUCK1_VOUT2              0x20
+#define LP8788_BUCK1_VOUT3              0x21
+#define LP8788_BUCK2_VOUT0              0x22
+#define LP8788_BUCK2_VOUT1              0x23
+#define LP8788_BUCK2_VOUT2              0x24
+#define LP8788_BUCK2_VOUT3              0x25
+#define LP8788_BUCK3_VOUT               0x26
+#define LP8788_BUCK4_VOUT               0x27
+#define LP8788_BUCK1_TIMESTEP           0x28
+#define LP8788_BUCK_PWM                 0x2D
+
+/* mask/shift bits */
+#define LP8788_EN_BUCK1_M               BIT(0)  /* Addr 0Ch */
+#define LP8788_EN_BUCK2_M               BIT(1)
+#define LP8788_EN_BUCK3_M               BIT(2)
+#define LP8788_EN_BUCK4_M               BIT(3)
+#define LP8788_BUCK1_DVS_SEL_M          0x04    /* Addr 1Dh */
+#define LP8788_BUCK1_DVS_M              0x03
+#define LP8788_BUCK1_DVS_S              0
+#define LP8788_BUCK2_DVS_SEL_M          0x40
+#define LP8788_BUCK2_DVS_M              0x30
+#define LP8788_BUCK2_DVS_S              4
+#define LP8788_BUCK1_DVS_I2C            BIT(2)
+#define LP8788_BUCK2_DVS_I2C            BIT(6)
+#define LP8788_BUCK1_DVS_PIN            (0 << 2)
+#define LP8788_BUCK2_DVS_PIN            (0 << 6)
+#define LP8788_VOUT_M                   0x1F    /* Addr 1Eh ~ 27h */
+#define LP8788_STARTUP_TIME_M           0xF8    /* Addr 28h ~ 2Bh */
+#define LP8788_STARTUP_TIME_S           3
+#define LP8788_FPWM_BUCK1_M             BIT(0)  /* Addr 2Dh */
+#define LP8788_FPWM_BUCK1_S             0
+#define LP8788_FPWM_BUCK2_M             BIT(1)
+#define LP8788_FPWM_BUCK2_S             1
+#define LP8788_FPWM_BUCK3_M             BIT(2)
+#define LP8788_FPWM_BUCK3_S             2
+#define LP8788_FPWM_BUCK4_M             BIT(3)
+#define LP8788_FPWM_BUCK4_S             3
+
+#define INVALID_ADDR                    0xFF
+#define LP8788_FORCE_PWM                1
+#define LP8788_AUTO_PWM                 0
+#define PIN_LOW                         0
+#define PIN_HIGH                        1
+#define ENABLE_TIME_USEC                32
+
+enum lp8788_dvs_state {
+        DVS_LOW  = GPIOF_OUT_INIT_LOW,
+        DVS_HIGH = GPIOF_OUT_INIT_HIGH,
+};
+
+enum lp8788_dvs_mode {
+        REGISTER,
+        EXTPIN,
+};
+
+enum lp8788_buck_id {
+        BUCK1,
+        BUCK2,
+        BUCK3,
+        BUCK4,
+};
+
+struct lp8788_pwm_map {
+        u8 mask;
+        u8 shift;
+};
+
+struct lp8788_buck {
+        struct lp8788 *lp;
+        struct regulator_dev *regulator;
+        struct lp8788_pwm_map *pmap;
+        void *dvs;
+};
+
+/* BUCK 1 ~ 4 voltage table */
+static const int lp8788_buck_vtbl[] = {
+         500000,  800000,  850000,  900000,  950000, 1000000, 1050000, 1100000,
+        1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
+        1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
+        1950000, 2000000,
+};
+
+/* buck pwm mode selection : used for set/get_mode in regulator ops
+ * @forced pwm : fast mode
+ * @auto pwm   : normal mode
+ */
+static struct lp8788_pwm_map buck_pmap[] = {
+        [BUCK1] = {
+                .mask = LP8788_FPWM_BUCK1_M,
+                .shift = LP8788_FPWM_BUCK1_S,
+        },
+        [BUCK2] = {
+                .mask = LP8788_FPWM_BUCK2_M,
+                .shift = LP8788_FPWM_BUCK2_S,
+        },
+        [BUCK3] = {
+                .mask = LP8788_FPWM_BUCK3_M,
+                .shift = LP8788_FPWM_BUCK3_S,
+        },
+        [BUCK4] = {
+                .mask = LP8788_FPWM_BUCK4_M,
+                .shift = LP8788_FPWM_BUCK4_S,
+        },
+};
+
+static const u8 buck1_vout_addr[] = {
+        LP8788_BUCK1_VOUT0, LP8788_BUCK1_VOUT1,
+        LP8788_BUCK1_VOUT2, LP8788_BUCK1_VOUT3,
+};
+
+static const u8 buck2_vout_addr[] = {
+        LP8788_BUCK2_VOUT0, LP8788_BUCK2_VOUT1,
+        LP8788_BUCK2_VOUT2, LP8788_BUCK2_VOUT3,
+};
+
+static void lp8788_buck1_set_dvs(struct lp8788_buck *buck)
+{
+        struct lp8788_buck1_dvs *dvs = (struct lp8788_buck1_dvs *)buck->dvs;
+        enum lp8788_dvs_state pinstate;
+
+        if (!dvs)
+                return;
+
+        pinstate = dvs->vsel == DVS_SEL_V0 ? DVS_LOW : DVS_HIGH;
+        if (gpio_is_valid(dvs->gpio))
+                gpio_set_value(dvs->gpio, pinstate);
+}
+
+static void lp8788_buck2_set_dvs(struct lp8788_buck *buck)
+{
+        struct lp8788_buck2_dvs *dvs = (struct lp8788_buck2_dvs *)buck->dvs;
+        enum lp8788_dvs_state pin1, pin2;
+
+        if (!dvs)
+                return;
+
+        switch (dvs->vsel) {
+        case DVS_SEL_V0:
+                pin1 = DVS_LOW;
+                pin2 = DVS_LOW;
+                break;
+        case DVS_SEL_V1:
+                pin1 = DVS_HIGH;
+                pin2 = DVS_LOW;
+                break;
+        case DVS_SEL_V2:
+                pin1 = DVS_LOW;
+                pin2 = DVS_HIGH;
+                break;
+        case DVS_SEL_V3:
+                pin1 = DVS_HIGH;
+                pin2 = DVS_HIGH;
+                break;
+        default:
+                return;
+        }
+
+        if (gpio_is_valid(dvs->gpio[0]))
+                gpio_set_value(dvs->gpio[0], pin1);
+
+        if (gpio_is_valid(dvs->gpio[1]))
+                gpio_set_value(dvs->gpio[1], pin2);
+}
+
+static void lp8788_set_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        switch (id) {
+        case BUCK1:
+                lp8788_buck1_set_dvs(buck);
+                break;
+        case BUCK2:
+                lp8788_buck2_set_dvs(buck);
+                break;
+        default:
+                break;
+        }
+}
+
+static enum lp8788_dvs_mode
+lp8788_get_buck_dvs_ctrl_mode(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        u8 val, mask;
+
+        switch (id) {
+        case BUCK1:
+                mask = LP8788_BUCK1_DVS_SEL_M;
+                break;
+        case BUCK2:
+                mask = LP8788_BUCK2_DVS_SEL_M;
+                break;
+        default:
+                return REGISTER;
+        }
+
+        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+
+        return val & mask ? REGISTER : EXTPIN;
+}
+
+static bool lp8788_is_valid_buck_addr(u8 addr)
+{
+        switch (addr) {
+        case LP8788_BUCK1_VOUT0:
+        case LP8788_BUCK1_VOUT1:
+        case LP8788_BUCK1_VOUT2:
+        case LP8788_BUCK1_VOUT3:
+        case LP8788_BUCK2_VOUT0:
+        case LP8788_BUCK2_VOUT1:
+        case LP8788_BUCK2_VOUT2:
+        case LP8788_BUCK2_VOUT3:
+                return true;
+        default:
+                return false;
+        }
+}
+
+static u8 lp8788_select_buck_vout_addr(struct lp8788_buck *buck,
+                                        enum lp8788_buck_id id)
+{
+        enum lp8788_dvs_mode mode = lp8788_get_buck_dvs_ctrl_mode(buck, id);
+        struct lp8788_buck1_dvs *b1_dvs;
+        struct lp8788_buck2_dvs *b2_dvs;
+        u8 val, idx, addr;
+        int pin1, pin2;
+
+        switch (id) {
+        case BUCK1:
+                if (mode == EXTPIN) {
+                        b1_dvs = (struct lp8788_buck1_dvs *)buck->dvs;
+                        if (!b1_dvs)
+                                goto err;
+
+                        idx = gpio_get_value(b1_dvs->gpio) ? 1 : 0;
+                } else {
+                        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+                        idx = (val & LP8788_BUCK1_DVS_M) >> LP8788_BUCK1_DVS_S;
+                }
+                addr = buck1_vout_addr[idx];
+                break;
+        case BUCK2:
+                if (mode == EXTPIN) {
+                        b2_dvs = (struct lp8788_buck2_dvs *)buck->dvs;
+                        if (!b2_dvs)
+                                goto err;
+
+                        pin1 = gpio_get_value(b2_dvs->gpio[0]);
+                        pin2 = gpio_get_value(b2_dvs->gpio[1]);
+
+                        if (pin1 == PIN_LOW && pin2 == PIN_LOW)
+                                idx = 0;
+                        else if (pin1 == PIN_LOW && pin2 == PIN_HIGH)
+                                idx = 2;
+                        else if (pin1 == PIN_HIGH && pin2 == PIN_LOW)
+                                idx = 1;
+                        else
+                                idx = 3;
+                } else {
+                        lp8788_read_byte(buck->lp, LP8788_BUCK_DVS_SEL, &val);
+                        idx = (val & LP8788_BUCK2_DVS_M) >> LP8788_BUCK2_DVS_S;
+                }
+                addr = buck2_vout_addr[idx];
+                break;
+        default:
+                goto err;
+        }
+
+        return addr;
+err:
+        return INVALID_ADDR;
+}
+
+static int lp8788_buck12_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        u8 addr;
+
+        if (buck->dvs)
+                lp8788_set_dvs(buck, id);
+
+        addr = lp8788_select_buck_vout_addr(buck, id);
+        if (!lp8788_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        return lp8788_update_bits(buck->lp, addr, LP8788_VOUT_M, selector);
+}
+
+static int lp8788_buck12_get_voltage_sel(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        int ret;
+        u8 val, addr;
+
+        addr = lp8788_select_buck_vout_addr(buck, id);
+        if (!lp8788_is_valid_buck_addr(addr))
+                return -EINVAL;
+
+        ret = lp8788_read_byte(buck->lp, addr, &val);
+        if (ret)
+                return ret;
+
+        return val & LP8788_VOUT_M;
+}
+
+static int lp8788_buck_enable_time(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        enum lp8788_buck_id id = rdev_get_id(rdev);
+        u8 val, addr = LP8788_BUCK1_TIMESTEP + id;
+
+        if (lp8788_read_byte(buck->lp, addr, &val))
+                return -EINVAL;
+
+        val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
+
+        return ENABLE_TIME_USEC * val;
+}
+
+static int lp8788_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        struct lp8788_pwm_map *pmap = buck->pmap;
+        u8 val;
+
+        if (!pmap)
+                return -EINVAL;
+
+        switch (mode) {
+        case REGULATOR_MODE_FAST:
+                val = LP8788_FORCE_PWM << pmap->shift;
+                break;
+        case REGULATOR_MODE_NORMAL:
+                val = LP8788_AUTO_PWM << pmap->shift;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_PWM, pmap->mask, val);
+}
+
+static unsigned int lp8788_buck_get_mode(struct regulator_dev *rdev)
+{
+        struct lp8788_buck *buck = rdev_get_drvdata(rdev);
+        struct lp8788_pwm_map *pmap = buck->pmap;
+        u8 val;
+        int ret;
+
+        if (!pmap)
+                return -EINVAL;
+
+        ret = lp8788_read_byte(buck->lp, LP8788_BUCK_PWM, &val);
+        if (ret)
+                return ret;
+
+        return val & pmap->mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
+}
+
+static struct regulator_ops lp8788_buck12_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = lp8788_buck12_set_voltage_sel,
+        .get_voltage_sel = lp8788_buck12_get_voltage_sel,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp8788_buck_enable_time,
+        .set_mode = lp8788_buck_set_mode,
+        .get_mode = lp8788_buck_get_mode,
+};
+
+static struct regulator_ops lp8788_buck34_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
+        .enable_time = lp8788_buck_enable_time,
+        .set_mode = lp8788_buck_set_mode,
+        .get_mode = lp8788_buck_get_mode,
+};
+
+static struct regulator_desc lp8788_buck_desc[] = {
+        {
+                .name = "buck1",
+                .id = BUCK1,
+                .ops = &lp8788_buck12_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK1_M,
+        },
+        {
+                .name = "buck2",
+                .id = BUCK2,
+                .ops = &lp8788_buck12_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK2_M,
+        },
+        {
+                .name = "buck3",
+                .id = BUCK3,
+                .ops = &lp8788_buck34_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_BUCK3_VOUT,
+                .vsel_mask = LP8788_VOUT_M,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK3_M,
+        },
+        {
+                .name = "buck4",
+                .id = BUCK4,
+                .ops = &lp8788_buck34_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_buck_vtbl),
+                .volt_table = lp8788_buck_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_BUCK4_VOUT,
+                .vsel_mask = LP8788_VOUT_M,
+                .enable_reg = LP8788_EN_BUCK,
+                .enable_mask = LP8788_EN_BUCK4_M,
+        },
+};
+
+static int lp8788_set_default_dvs_ctrl_mode(struct lp8788 *lp,
+                                        enum lp8788_buck_id id)
+{
+        u8 mask, val;
+
+        switch (id) {
+        case BUCK1:
+                mask = LP8788_BUCK1_DVS_SEL_M;
+                val  = LP8788_BUCK1_DVS_I2C;
+                break;
+        case BUCK2:
+                mask = LP8788_BUCK2_DVS_SEL_M;
+                val  = LP8788_BUCK2_DVS_I2C;
+                break;
+        default:
+                return 0;
+        }
+
+        return lp8788_update_bits(lp, LP8788_BUCK_DVS_SEL, mask, val);
+}
+
+static int _gpio_request(struct lp8788_buck *buck, int gpio, char *name)
+{
+        struct device *dev = buck->lp->dev;
+
+        if (!gpio_is_valid(gpio)) {
+                dev_err(dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        return devm_gpio_request_one(dev, gpio, DVS_LOW, name);
+}
+
+static int lp8788_dvs_gpio_request(struct lp8788_buck *buck,
+                                enum lp8788_buck_id id)
+{
+        struct lp8788_platform_data *pdata = buck->lp->pdata;
+        char *b1_name = "LP8788_B1_DVS";
+        char *b2_name[] = { "LP8788_B2_DVS1", "LP8788_B2_DVS2" };
+        int i, gpio, ret;
+
+        switch (id) {
+        case BUCK1:
+                gpio = pdata->buck1_dvs->gpio;
+                ret = _gpio_request(buck, gpio, b1_name);
+                if (ret)
+                        return ret;
+
+                buck->dvs = pdata->buck1_dvs;
+                break;
+        case BUCK2:
+                for (i = 0 ; i < LP8788_NUM_BUCK2_DVS ; i++) {
+                        gpio = pdata->buck2_dvs->gpio[i];
+                        ret = _gpio_request(buck, gpio, b2_name[i]);
+                        if (ret)
+                                return ret;
+                }
+                buck->dvs = pdata->buck2_dvs;
+                break;
+        default:
+                break;
+        }
+
+        return 0;
+}
+
+static int lp8788_init_dvs(struct lp8788_buck *buck, enum lp8788_buck_id id)
+{
+        struct lp8788_platform_data *pdata = buck->lp->pdata;
+        u8 mask[] = { LP8788_BUCK1_DVS_SEL_M, LP8788_BUCK2_DVS_SEL_M };
+        u8 val[]  = { LP8788_BUCK1_DVS_PIN, LP8788_BUCK2_DVS_PIN };
+
+        /* no dvs for buck3, 4 */
+        if (id == BUCK3 || id == BUCK4)
+                return 0;
+
+        /* no dvs platform data, then dvs will be selected by I2C registers */
+        if (!pdata)
+                goto set_default_dvs_mode;
+
+        if ((id == BUCK1 && !pdata->buck1_dvs) ||
+                (id == BUCK2 && !pdata->buck2_dvs))
+                goto set_default_dvs_mode;
+
+        if (lp8788_dvs_gpio_request(buck, id))
+                goto set_default_dvs_mode;
+
+        return lp8788_update_bits(buck->lp, LP8788_BUCK_DVS_SEL, mask[id],
+                                val[id]);
+
+set_default_dvs_mode:
+        return lp8788_set_default_dvs_ctrl_mode(buck->lp, id);
+}
+
+static __devinit int lp8788_buck_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_buck *buck;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        buck = devm_kzalloc(lp->dev, sizeof(struct lp8788_buck), GFP_KERNEL);
+        if (!buck)
+                return -ENOMEM;
+
+        buck->lp = lp;
+        buck->pmap = &buck_pmap[id];
+
+        ret = lp8788_init_dvs(buck, id);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->buck_data[id] : NULL;
+        cfg.driver_data = buck;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_buck_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "BUCK%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        buck->regulator = rdev;
+        platform_set_drvdata(pdev, buck);
+
+        return 0;
+}
+
+static int __devexit lp8788_buck_remove(struct platform_device *pdev)
+{
+        struct lp8788_buck *buck = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(buck->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_buck_driver = {
+        .probe = lp8788_buck_probe,
+        .remove = __devexit_p(lp8788_buck_remove),
+        .driver = {
+                .name = LP8788_DEV_BUCK,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init lp8788_buck_init(void)
+{
+        return platform_driver_register(&lp8788_buck_driver);
+}
+subsys_initcall(lp8788_buck_init);
+
+static void __exit lp8788_buck_exit(void)
+{
+        platform_driver_unregister(&lp8788_buck_driver);
+}
+module_exit(lp8788_buck_exit);
+
+MODULE_DESCRIPTION("TI LP8788 BUCK Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lp8788-buck");
diff --git a/drivers/regulator/lp8788-ldo.c b/drivers/regulator/lp8788-ldo.c
new file mode 100644
index 000000000000..d2122e41a96d
--- /dev/null
+++ b/drivers/regulator/lp8788-ldo.c
@@ -0,0 +1,842 @@
+/*
+ * TI LP8788 MFD - ldo regulator driver
+ *
+ * Copyright 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.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.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/gpio.h>
+#include <linux/mfd/lp8788.h>
+
+/* register address */
+#define LP8788_EN_LDO_A                 0x0D    /* DLDO 1 ~ 8 */
+#define LP8788_EN_LDO_B                 0x0E    /* DLDO 9 ~ 12, ALDO 1 ~ 4 */
+#define LP8788_EN_LDO_C                 0x0F    /* ALDO 5 ~ 10 */
+#define LP8788_EN_SEL                   0x10
+#define LP8788_DLDO1_VOUT               0x2E
+#define LP8788_DLDO2_VOUT               0x2F
+#define LP8788_DLDO3_VOUT               0x30
+#define LP8788_DLDO4_VOUT               0x31
+#define LP8788_DLDO5_VOUT               0x32
+#define LP8788_DLDO6_VOUT               0x33
+#define LP8788_DLDO7_VOUT               0x34
+#define LP8788_DLDO8_VOUT               0x35
+#define LP8788_DLDO9_VOUT               0x36
+#define LP8788_DLDO10_VOUT              0x37
+#define LP8788_DLDO11_VOUT              0x38
+#define LP8788_DLDO12_VOUT              0x39
+#define LP8788_ALDO1_VOUT               0x3A
+#define LP8788_ALDO2_VOUT               0x3B
+#define LP8788_ALDO3_VOUT               0x3C
+#define LP8788_ALDO4_VOUT               0x3D
+#define LP8788_ALDO5_VOUT               0x3E
+#define LP8788_ALDO6_VOUT               0x3F
+#define LP8788_ALDO7_VOUT               0x40
+#define LP8788_ALDO8_VOUT               0x41
+#define LP8788_ALDO9_VOUT               0x42
+#define LP8788_ALDO10_VOUT              0x43
+#define LP8788_DLDO1_TIMESTEP           0x44
+
+/* mask/shift bits */
+#define LP8788_EN_DLDO1_M               BIT(0)  /* Addr 0Dh ~ 0Fh */
+#define LP8788_EN_DLDO2_M               BIT(1)
+#define LP8788_EN_DLDO3_M               BIT(2)
+#define LP8788_EN_DLDO4_M               BIT(3)
+#define LP8788_EN_DLDO5_M               BIT(4)
+#define LP8788_EN_DLDO6_M               BIT(5)
+#define LP8788_EN_DLDO7_M               BIT(6)
+#define LP8788_EN_DLDO8_M               BIT(7)
+#define LP8788_EN_DLDO9_M               BIT(0)
+#define LP8788_EN_DLDO10_M              BIT(1)
+#define LP8788_EN_DLDO11_M              BIT(2)
+#define LP8788_EN_DLDO12_M              BIT(3)
+#define LP8788_EN_ALDO1_M               BIT(4)
+#define LP8788_EN_ALDO2_M               BIT(5)
+#define LP8788_EN_ALDO3_M               BIT(6)
+#define LP8788_EN_ALDO4_M               BIT(7)
+#define LP8788_EN_ALDO5_M               BIT(0)
+#define LP8788_EN_ALDO6_M               BIT(1)
+#define LP8788_EN_ALDO7_M               BIT(2)
+#define LP8788_EN_ALDO8_M               BIT(3)
+#define LP8788_EN_ALDO9_M               BIT(4)
+#define LP8788_EN_ALDO10_M              BIT(5)
+#define LP8788_EN_SEL_DLDO911_M         BIT(0)  /* Addr 10h */
+#define LP8788_EN_SEL_DLDO7_M           BIT(1)
+#define LP8788_EN_SEL_ALDO7_M           BIT(2)
+#define LP8788_EN_SEL_ALDO5_M           BIT(3)
+#define LP8788_EN_SEL_ALDO234_M         BIT(4)
+#define LP8788_EN_SEL_ALDO1_M           BIT(5)
+#define LP8788_VOUT_5BIT_M              0x1F    /* Addr 2Eh ~ 43h */
+#define LP8788_VOUT_4BIT_M              0x0F
+#define LP8788_VOUT_3BIT_M              0x07
+#define LP8788_VOUT_1BIT_M              0x01
+#define LP8788_STARTUP_TIME_M           0xF8    /* Addr 44h ~ 59h */
+#define LP8788_STARTUP_TIME_S           3
+
+#define ENABLE_TIME_USEC                32
+#define ENABLE                          GPIOF_OUT_INIT_HIGH
+#define DISABLE                         GPIOF_OUT_INIT_LOW
+
+enum lp8788_enable_mode {
+        REGISTER,
+        EXTPIN,
+};
+
+enum lp8788_ldo_id {
+        DLDO1,
+        DLDO2,
+        DLDO3,
+        DLDO4,
+        DLDO5,
+        DLDO6,
+        DLDO7,
+        DLDO8,
+        DLDO9,
+        DLDO10,
+        DLDO11,
+        DLDO12,
+        ALDO1,
+        ALDO2,
+        ALDO3,
+        ALDO4,
+        ALDO5,
+        ALDO6,
+        ALDO7,
+        ALDO8,
+        ALDO9,
+        ALDO10,
+};
+
+struct lp8788_ldo {
+        struct lp8788 *lp;
+        struct regulator_desc *desc;
+        struct regulator_dev *regulator;
+        struct lp8788_ldo_enable_pin *en_pin;
+};
+
+/* DLDO 1, 2, 3, 9 voltage table */
+const int lp8788_dldo1239_vtbl[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 2850000, 2850000, 2850000,
+        2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000,
+        2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000, 2850000,
+};
+
+/* DLDO 4 voltage table */
+static const int lp8788_dldo4_vtbl[] = { 1800000, 3000000 };
+
+/* DLDO 5, 7, 8 and ALDO 6 voltage table */
+static const int lp8788_dldo578_aldo6_vtbl[] = {
+        1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
+        2600000, 2700000, 2800000, 2900000, 3000000, 3000000, 3000000, 3000000,
+};
+
+/* DLDO 6 voltage table */
+static const int lp8788_dldo6_vtbl[] = {
+        3000000, 3100000, 3200000, 3300000, 3400000, 3500000, 3600000, 3600000,
+};
+
+/* DLDO 10, 11 voltage table */
+static const int lp8788_dldo1011_vtbl[] = {
+        1100000, 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000,
+        1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000, 1500000,
+};
+
+/* ALDO 1 voltage table */
+static const int lp8788_aldo1_vtbl[] = { 1800000, 2850000 };
+
+/* ALDO 7 voltage table */
+static const int lp8788_aldo7_vtbl[] = {
+        1200000, 1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1800000,
+};
+
+static enum lp8788_ldo_id lp8788_dldo_id[] = {
+        DLDO1,
+        DLDO2,
+        DLDO3,
+        DLDO4,
+        DLDO5,
+        DLDO6,
+        DLDO7,
+        DLDO8,
+        DLDO9,
+        DLDO10,
+        DLDO11,
+        DLDO12,
+};
+
+static enum lp8788_ldo_id lp8788_aldo_id[] = {
+        ALDO1,
+        ALDO2,
+        ALDO3,
+        ALDO4,
+        ALDO5,
+        ALDO6,
+        ALDO7,
+        ALDO8,
+        ALDO9,
+        ALDO10,
+};
+
+/* DLDO 7, 9 and 11, ALDO 1 ~ 5 and 7
+   : can be enabled either by external pin or by i2c register */
+static enum lp8788_enable_mode
+lp8788_get_ldo_enable_mode(struct lp8788_ldo *ldo, enum lp8788_ldo_id id)
+{
+        int ret;
+        u8 val, mask;
+
+        ret = lp8788_read_byte(ldo->lp, LP8788_EN_SEL, &val);
+        if (ret)
+                return ret;
+
+        switch (id) {
+        case DLDO7:
+                mask =  LP8788_EN_SEL_DLDO7_M;
+                break;
+        case DLDO9:
+        case DLDO11:
+                mask =  LP8788_EN_SEL_DLDO911_M;
+                break;
+        case ALDO1:
+                mask =  LP8788_EN_SEL_ALDO1_M;
+                break;
+        case ALDO2 ... ALDO4:
+                mask =  LP8788_EN_SEL_ALDO234_M;
+                break;
+        case ALDO5:
+                mask =  LP8788_EN_SEL_ALDO5_M;
+                break;
+        case ALDO7:
+                mask =  LP8788_EN_SEL_ALDO7_M;
+                break;
+        default:
+                return REGISTER;
+        }
+
+        return val & mask ? EXTPIN : REGISTER;
+}
+
+static int lp8788_ldo_ctrl_by_extern_pin(struct lp8788_ldo *ldo, int pinstate)
+{
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+
+        if (!pin)
+                return -EINVAL;
+
+        if (gpio_is_valid(pin->gpio))
+                gpio_set_value(pin->gpio, pinstate);
+
+        return 0;
+}
+
+static int lp8788_ldo_is_enabled_by_extern_pin(struct lp8788_ldo *ldo)
+{
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+
+        if (!pin)
+                return -EINVAL;
+
+        return gpio_get_value(pin->gpio) ? 1 : 0;
+}
+
+static int lp8788_ldo_enable(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_ctrl_by_extern_pin(ldo, ENABLE);
+        case REGISTER:
+                return regulator_enable_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_disable(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_ctrl_by_extern_pin(ldo, DISABLE);
+        case REGISTER:
+                return regulator_disable_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_is_enabled(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        enum lp8788_enable_mode mode = lp8788_get_ldo_enable_mode(ldo, id);
+
+        switch (mode) {
+        case EXTPIN:
+                return lp8788_ldo_is_enabled_by_extern_pin(ldo);
+        case REGISTER:
+                return regulator_is_enabled_regmap(rdev);
+        default:
+                return -EINVAL;
+        }
+}
+
+static int lp8788_ldo_enable_time(struct regulator_dev *rdev)
+{
+        struct lp8788_ldo *ldo = rdev_get_drvdata(rdev);
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+        u8 val, addr = LP8788_DLDO1_TIMESTEP + id;
+
+        if (lp8788_read_byte(ldo->lp, addr, &val))
+                return -EINVAL;
+
+        val = (val & LP8788_STARTUP_TIME_M) >> LP8788_STARTUP_TIME_S;
+
+        return ENABLE_TIME_USEC * val;
+}
+
+static int lp8788_ldo_fixed_get_voltage(struct regulator_dev *rdev)
+{
+        enum lp8788_ldo_id id = rdev_get_id(rdev);
+
+        switch (id) {
+        case ALDO2 ... ALDO5:
+                return 2850000;
+        case DLDO12:
+        case ALDO8 ... ALDO9:
+                return 2500000;
+        case ALDO10:
+                return 1100000;
+        default:
+                return -EINVAL;
+        }
+}
+
+static struct regulator_ops lp8788_ldo_voltage_table_ops = {
+        .list_voltage = regulator_list_voltage_table,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .enable = lp8788_ldo_enable,
+        .disable = lp8788_ldo_disable,
+        .is_enabled = lp8788_ldo_is_enabled,
+        .enable_time = lp8788_ldo_enable_time,
+};
+
+static struct regulator_ops lp8788_ldo_voltage_fixed_ops = {
+        .get_voltage = lp8788_ldo_fixed_get_voltage,
+        .enable = lp8788_ldo_enable,
+        .disable = lp8788_ldo_disable,
+        .is_enabled = lp8788_ldo_is_enabled,
+        .enable_time = lp8788_ldo_enable_time,
+};
+
+static struct regulator_desc lp8788_dldo_desc[] = {
+        {
+                .name = "dldo1",
+                .id = DLDO1,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO1_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO1_M,
+        },
+        {
+                .name = "dldo2",
+                .id = DLDO2,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO2_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO2_M,
+        },
+        {
+                .name = "dldo3",
+                .id = DLDO3,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO3_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO3_M,
+        },
+        {
+                .name = "dldo4",
+                .id = DLDO4,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo4_vtbl),
+                .volt_table = lp8788_dldo4_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO4_VOUT,
+                .vsel_mask = LP8788_VOUT_1BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO4_M,
+        },
+        {
+                .name = "dldo5",
+                .id = DLDO5,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO5_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO5_M,
+        },
+        {
+                .name = "dldo6",
+                .id = DLDO6,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo6_vtbl),
+                .volt_table = lp8788_dldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO6_VOUT,
+                .vsel_mask = LP8788_VOUT_3BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO6_M,
+        },
+        {
+                .name = "dldo7",
+                .id = DLDO7,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO7_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO7_M,
+        },
+        {
+                .name = "dldo8",
+                .id = DLDO8,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO8_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_A,
+                .enable_mask = LP8788_EN_DLDO8_M,
+        },
+        {
+                .name = "dldo9",
+                .id = DLDO9,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1239_vtbl),
+                .volt_table = lp8788_dldo1239_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO9_VOUT,
+                .vsel_mask = LP8788_VOUT_5BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO9_M,
+        },
+        {
+                .name = "dldo10",
+                .id = DLDO10,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1011_vtbl),
+                .volt_table = lp8788_dldo1011_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO10_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO10_M,
+        },
+        {
+                .name = "dldo11",
+                .id = DLDO11,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo1011_vtbl),
+                .volt_table = lp8788_dldo1011_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_DLDO11_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO11_M,
+        },
+        {
+                .name = "dldo12",
+                .id = DLDO12,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_DLDO12_M,
+        },
+};
+
+static struct regulator_desc lp8788_aldo_desc[] = {
+        {
+                .name = "aldo1",
+                .id = ALDO1,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_aldo1_vtbl),
+                .volt_table = lp8788_aldo1_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO1_VOUT,
+                .vsel_mask = LP8788_VOUT_1BIT_M,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO1_M,
+        },
+        {
+                .name = "aldo2",
+                .id = ALDO2,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO2_M,
+        },
+        {
+                .name = "aldo3",
+                .id = ALDO3,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO3_M,
+        },
+        {
+                .name = "aldo4",
+                .id = ALDO4,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_B,
+                .enable_mask = LP8788_EN_ALDO4_M,
+        },
+        {
+                .name = "aldo5",
+                .id = ALDO5,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO5_M,
+        },
+        {
+                .name = "aldo6",
+                .id = ALDO6,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_dldo578_aldo6_vtbl),
+                .volt_table = lp8788_dldo578_aldo6_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO6_VOUT,
+                .vsel_mask = LP8788_VOUT_4BIT_M,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO6_M,
+        },
+        {
+                .name = "aldo7",
+                .id = ALDO7,
+                .ops = &lp8788_ldo_voltage_table_ops,
+                .n_voltages = ARRAY_SIZE(lp8788_aldo7_vtbl),
+                .volt_table = lp8788_aldo7_vtbl,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .vsel_reg = LP8788_ALDO7_VOUT,
+                .vsel_mask = LP8788_VOUT_3BIT_M,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO7_M,
+        },
+        {
+                .name = "aldo8",
+                .id = ALDO8,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO8_M,
+        },
+        {
+                .name = "aldo9",
+                .id = ALDO9,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO9_M,
+        },
+        {
+                .name = "aldo10",
+                .id = ALDO10,
+                .ops = &lp8788_ldo_voltage_fixed_ops,
+                .type = REGULATOR_VOLTAGE,
+                .owner = THIS_MODULE,
+                .enable_reg = LP8788_EN_LDO_C,
+                .enable_mask = LP8788_EN_ALDO10_M,
+        },
+};
+
+static int lp8788_gpio_request_ldo_en(struct lp8788_ldo *ldo,
+                                enum lp8788_ext_ldo_en_id id)
+{
+        struct device *dev = ldo->lp->dev;
+        struct lp8788_ldo_enable_pin *pin = ldo->en_pin;
+        int ret, gpio, pinstate;
+        char *name[] = {
+                [EN_ALDO1]   = "LP8788_EN_ALDO1",
+                [EN_ALDO234] = "LP8788_EN_ALDO234",
+                [EN_ALDO5]   = "LP8788_EN_ALDO5",
+                [EN_ALDO7]   = "LP8788_EN_ALDO7",
+                [EN_DLDO7]   = "LP8788_EN_DLDO7",
+                [EN_DLDO911] = "LP8788_EN_DLDO911",
+        };
+
+        gpio = pin->gpio;
+        if (!gpio_is_valid(gpio)) {
+                dev_err(dev, "invalid gpio: %d\n", gpio);
+                return -EINVAL;
+        }
+
+        pinstate = pin->init_state;
+        ret = devm_gpio_request_one(dev, gpio, pinstate, name[id]);
+        if (ret == -EBUSY) {
+                dev_warn(dev, "gpio%d already used\n", gpio);
+                return 0;
+        }
+
+        return ret;
+}
+
+static int lp8788_config_ldo_enable_mode(struct lp8788_ldo *ldo,
+                                        enum lp8788_ldo_id id)
+{
+        int ret;
+        struct lp8788 *lp = ldo->lp;
+        struct lp8788_platform_data *pdata = lp->pdata;
+        enum lp8788_ext_ldo_en_id enable_id;
+        u8 en_mask[] = {
+                [EN_ALDO1]   = LP8788_EN_SEL_ALDO1_M,
+                [EN_ALDO234] = LP8788_EN_SEL_ALDO234_M,
+                [EN_ALDO5]   = LP8788_EN_SEL_ALDO5_M,
+                [EN_ALDO7]   = LP8788_EN_SEL_ALDO7_M,
+                [EN_DLDO7]   = LP8788_EN_SEL_DLDO7_M,
+                [EN_DLDO911] = LP8788_EN_SEL_DLDO911_M,
+        };
+        u8 val[] = {
+                [EN_ALDO1]   = 0 << 5,
+                [EN_ALDO234] = 0 << 4,
+                [EN_ALDO5]   = 0 << 3,
+                [EN_ALDO7]   = 0 << 2,
+                [EN_DLDO7]   = 0 << 1,
+                [EN_DLDO911] = 0 << 0,
+        };
+
+        switch (id) {
+        case DLDO7:
+                enable_id = EN_DLDO7;
+                break;
+        case DLDO9:
+        case DLDO11:
+                enable_id = EN_DLDO911;
+                break;
+        case ALDO1:
+                enable_id = EN_ALDO1;
+                break;
+        case ALDO2 ... ALDO4:
+                enable_id = EN_ALDO234;
+                break;
+        case ALDO5:
+                enable_id = EN_ALDO5;
+                break;
+        case ALDO7:
+                enable_id = EN_ALDO7;
+                break;
+        default:
+                return 0;
+        }
+
+        /* if no platform data for ldo pin, then set default enable mode */
+        if (!pdata || !pdata->ldo_pin || !pdata->ldo_pin[enable_id])
+                goto set_default_ldo_enable_mode;
+
+        ldo->en_pin = pdata->ldo_pin[enable_id];
+
+        ret = lp8788_gpio_request_ldo_en(ldo, enable_id);
+        if (ret)
+                goto set_default_ldo_enable_mode;
+
+        return ret;
+
+set_default_ldo_enable_mode:
+        return lp8788_update_bits(lp, LP8788_EN_SEL, en_mask[enable_id],
+                                val[enable_id]);
+}
+
+static __devinit int lp8788_dldo_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_ldo *ldo;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        ldo = devm_kzalloc(lp->dev, sizeof(struct lp8788_ldo), GFP_KERNEL);
+        if (!ldo)
+                return -ENOMEM;
+
+        ldo->lp = lp;
+        ret = lp8788_config_ldo_enable_mode(ldo, lp8788_dldo_id[id]);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->dldo_data[id] : NULL;
+        cfg.driver_data = ldo;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_dldo_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "DLDO%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        ldo->regulator = rdev;
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+}
+
+static int __devexit lp8788_dldo_remove(struct platform_device *pdev)
+{
+        struct lp8788_ldo *ldo = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(ldo->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_dldo_driver = {
+        .probe = lp8788_dldo_probe,
+        .remove = __devexit_p(lp8788_dldo_remove),
+        .driver = {
+                .name = LP8788_DEV_DLDO,
+                .owner = THIS_MODULE,
+        },
+};
+
+static __devinit int lp8788_aldo_probe(struct platform_device *pdev)
+{
+        struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
+        int id = pdev->id;
+        struct lp8788_ldo *ldo;
+        struct regulator_config cfg = { };
+        struct regulator_dev *rdev;
+        int ret;
+
+        ldo = devm_kzalloc(lp->dev, sizeof(struct lp8788_ldo), GFP_KERNEL);
+        if (!ldo)
+                return -ENOMEM;
+
+        ldo->lp = lp;
+        ret = lp8788_config_ldo_enable_mode(ldo, lp8788_aldo_id[id]);
+        if (ret)
+                return ret;
+
+        cfg.dev = lp->dev;
+        cfg.init_data = lp->pdata ? lp->pdata->aldo_data[id] : NULL;
+        cfg.driver_data = ldo;
+        cfg.regmap = lp->regmap;
+
+        rdev = regulator_register(&lp8788_aldo_desc[id], &cfg);
+        if (IS_ERR(rdev)) {
+                ret = PTR_ERR(rdev);
+                dev_err(lp->dev, "ALDO%d regulator register err = %d\n",
+                                id + 1, ret);
+                return ret;
+        }
+
+        ldo->regulator = rdev;
+        platform_set_drvdata(pdev, ldo);
+
+        return 0;
+}
+
+static int __devexit lp8788_aldo_remove(struct platform_device *pdev)
+{
+        struct lp8788_ldo *ldo = platform_get_drvdata(pdev);
+
+        platform_set_drvdata(pdev, NULL);
+        regulator_unregister(ldo->regulator);
+
+        return 0;
+}
+
+static struct platform_driver lp8788_aldo_driver = {
+        .probe = lp8788_aldo_probe,
+        .remove = __devexit_p(lp8788_aldo_remove),
+        .driver = {
+                .name = LP8788_DEV_ALDO,
+                .owner = THIS_MODULE,
+        },
+};
+
+static int __init lp8788_ldo_init(void)
+{
+        int ret;
+
+        ret = platform_driver_register(&lp8788_dldo_driver);
+        if (ret)
+                return ret;
+
+        return platform_driver_register(&lp8788_aldo_driver);
+}
+subsys_initcall(lp8788_ldo_init);
+
+static void __exit lp8788_ldo_exit(void)
+{
+        platform_driver_unregister(&lp8788_aldo_driver);
+        platform_driver_unregister(&lp8788_dldo_driver);
+}
+module_exit(lp8788_ldo_exit);
+
+MODULE_DESCRIPTION("TI LP8788 LDO Driver");
+MODULE_AUTHOR("Milo Kim");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:lp8788-dldo");
+MODULE_ALIAS("platform:lp8788-aldo");
diff --git a/drivers/regulator/max1586.c b/drivers/regulator/max1586.c
index b9444ee08da9..f67af3c1b963 100644
--- a/drivers/regulator/max1586.c
+++ b/drivers/regulator/max1586.c
@@ -48,6 +48,14 @@ struct max1586_data {
 };
 
 /*
+ * V6 voltage
+ * On I2C bus, sending a "x" byte to the max1586 means :
+ *   set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3)
+ * As regulator framework doesn't accept voltages to be 0V, we use 1uV.
+ */
+static int v6_voltages_uv[] = { 1, 1800000, 2500000, 3000000 };
+
+/*
  * V3 voltage
  * On I2C bus, sending a "x" byte to the max1586 means :
  *   set V3 to 0.700V + (x & 0x1f) * 0.025V
@@ -55,113 +63,49 @@ struct max1586_data {
  * R24 and R25=100kOhm as described in the data sheet.
  * The gain is approximately: 1 + R24/R25 + R24/185.5kOhm
  */
-static int max1586_v3_calc_voltage(struct max1586_data *max1586,
-        unsigned selector)
-{
-        unsigned range_uV = max1586->max_uV - max1586->min_uV;
-
-        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,
-                          unsigned *selector)
+static int max1586_v3_set_voltage_sel(struct regulator_dev *rdev,
+                                      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;
         u8 v3_prog;
 
-        if (min_uV > max1586->max_uV || max_uV < max1586->min_uV)
-                return -EINVAL;
-        if (min_uV < max1586->min_uV)
-                min_uV = max1586->min_uV;
-
-        *selector = DIV_ROUND_UP((min_uV - max1586->min_uV) *
-                                 MAX1586_V3_MAX_VSEL, range_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);
+                regulator_list_voltage_linear(rdev, selector) / 1000);
 
-        v3_prog = I2C_V3_SELECT | (u8) *selector;
+        v3_prog = I2C_V3_SELECT | (u8) selector;
         return i2c_smbus_write_byte(client, v3_prog);
 }
 
-static int max1586_v3_list(struct regulator_dev *rdev, unsigned selector)
-{
-        struct max1586_data *max1586 = rdev_get_drvdata(rdev);
-
-        if (selector > MAX1586_V3_MAX_VSEL)
-                return -EINVAL;
-        return max1586_v3_calc_voltage(max1586, selector);
-}
-
-/*
- * V6 voltage
- * On I2C bus, sending a "x" byte to the max1586 means :
- *   set V6 to either 0V, 1.8V, 2.5V, 3V depending on (x & 0x3)
- * As regulator framework doesn't accept voltages to be 0V, we use 1uV.
- */
-static int max1586_v6_calc_voltage(unsigned selector)
-{
-        static int voltages_uv[] = { 1, 1800000, 2500000, 3000000 };
-
-        return voltages_uv[selector];
-}
-
-static int max1586_v6_set(struct regulator_dev *rdev, int min_uV, int max_uV,
-                          unsigned int *selector)
+static int max1586_v6_set_voltage_sel(struct regulator_dev *rdev,
+                                      unsigned int selector)
 {
         struct i2c_client *client = rdev_get_drvdata(rdev);
         u8 v6_prog;
 
-        if (min_uV < MAX1586_V6_MIN_UV || min_uV > MAX1586_V6_MAX_UV)
-                return -EINVAL;
-        if (max_uV < MAX1586_V6_MIN_UV || max_uV > MAX1586_V6_MAX_UV)
-                return -EINVAL;
-
-        if (min_uV < 1800000)
-                *selector = 0;
-        else if (min_uV < 2500000)
-                *selector = 1;
-        else if (min_uV < 3000000)
-                *selector = 2;
-        else if (min_uV >= 3000000)
-                *selector = 3;
-
-        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);
+                rdev->desc->volt_table[selector] / 1000);
 
-        v6_prog = I2C_V6_SELECT | (u8) *selector;
+        v6_prog = I2C_V6_SELECT | (u8) selector;
         return i2c_smbus_write_byte(client, v6_prog);
 }
 
-static int max1586_v6_list(struct regulator_dev *rdev, unsigned selector)
-{
-        if (selector > MAX1586_V6_MAX_VSEL)
-                return -EINVAL;
-        return max1586_v6_calc_voltage(selector);
-}
-
 /*
  * The Maxim 1586 controls V3 and V6 voltages, but offers no way of reading back
  * the set up value.
  */
 static struct regulator_ops max1586_v3_ops = {
-        .set_voltage = max1586_v3_set,
-        .list_voltage = max1586_v3_list,
+        .set_voltage_sel = max1586_v3_set_voltage_sel,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
 };
 
 static struct regulator_ops max1586_v6_ops = {
-        .set_voltage = max1586_v6_set,
-        .list_voltage = max1586_v6_list,
+        .set_voltage_sel = max1586_v6_set_voltage_sel,
+        .list_voltage = regulator_list_voltage_table,
 };
 
-static const struct regulator_desc max1586_reg[] = {
+static struct regulator_desc max1586_reg[] = {
         {
                 .name = "Output_V3",
                 .id = MAX1586_V3,
@@ -176,6 +120,7 @@ static const struct regulator_desc max1586_reg[] = {
                 .ops = &max1586_v6_ops,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = MAX1586_V6_MAX_VSEL + 1,
+                .volt_table = v6_voltages_uv,
                 .owner = THIS_MODULE,
         },
 };
@@ -213,6 +158,13 @@ static int __devinit max1586_pmic_probe(struct i2c_client *client,
                         goto err;
                 }
 
+                if (id == MAX1586_V3) {
+                        max1586_reg[id].min_uV = max1586->min_uV;
+                        max1586_reg[id].uV_step =
+                                        (max1586->max_uV - max1586->min_uV) /
+                                        MAX1586_V3_MAX_VSEL;
+                }
+
                 config.dev = &client->dev;
                 config.init_data = pdata->subdevs[i].platform_data;
                 config.driver_data = max1586;
diff --git a/drivers/regulator/max77686.c b/drivers/regulator/max77686.c
new file mode 100644
index 000000000000..c564af6f05a3
--- /dev/null
+++ b/drivers/regulator/max77686.c
@@ -0,0 +1,389 @@
+/*
+ * max77686.c - Regulator driver for the Maxim 77686
+ *
+ * Copyright (C) 2012 Samsung Electronics
+ * Chiwoong Byun <woong.byun@smasung.com>
+ * Jonghwa Lee <jonghwa3.lee@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ *
+ * This driver is based on max8997.c
+ */
+
+#include <linux/kernel.h>
+#include <linux/bug.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regulator/of_regulator.h>
+#include <linux/mfd/max77686.h>
+#include <linux/mfd/max77686-private.h>
+
+#define MAX77686_LDO_MINUV      800000
+#define MAX77686_LDO_UVSTEP     50000
+#define MAX77686_LDO_LOW_MINUV  800000
+#define MAX77686_LDO_LOW_UVSTEP 25000
+#define MAX77686_BUCK_MINUV     750000
+#define MAX77686_BUCK_UVSTEP    50000
+#define MAX77686_RAMP_DELAY     100000                  /* uV/us */
+#define MAX77686_DVS_RAMP_DELAY 27500                   /* uV/us */
+#define MAX77686_DVS_MINUV      600000
+#define MAX77686_DVS_UVSTEP     12500
+
+#define MAX77686_OPMODE_SHIFT   6
+#define MAX77686_OPMODE_BUCK234_SHIFT   4
+#define MAX77686_OPMODE_MASK    0x3
+
+#define MAX77686_VSEL_MASK      0x3F
+#define MAX77686_DVS_VSEL_MASK  0xFF
+
+#define MAX77686_RAMP_RATE_MASK 0xC0
+
+#define MAX77686_REGULATORS     MAX77686_REG_MAX
+#define MAX77686_LDOS           26
+
+enum max77686_ramp_rate {
+        RAMP_RATE_13P75MV,
+        RAMP_RATE_27P5MV,
+        RAMP_RATE_55MV,
+        RAMP_RATE_NO_CTRL,      /* 100mV/us */
+};
+
+struct max77686_data {
+        struct regulator_dev **rdev;
+};
+
+static int max77686_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
+{
+        unsigned int ramp_value = RAMP_RATE_NO_CTRL;
+
+        switch (ramp_delay) {
+        case 1 ... 13750:
+                ramp_value = RAMP_RATE_13P75MV;
+                break;
+        case 13751 ... 27500:
+                ramp_value = RAMP_RATE_27P5MV;
+                break;
+        case 27501 ... 55000:
+                ramp_value = RAMP_RATE_55MV;
+                break;
+        case 55001 ... 100000:
+                break;
+        default:
+                pr_warn("%s: ramp_delay: %d not supported, setting 100000\n",
+                        rdev->desc->name, ramp_delay);
+        }
+
+        return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg,
+                                  MAX77686_RAMP_RATE_MASK, ramp_value << 6);
+}
+
+static struct regulator_ops max77686_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+static struct regulator_ops max77686_buck_dvs_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+        .set_ramp_delay         = max77686_set_ramp_delay,
+};
+
+#define regulator_desc_ldo(num)         {                               \
+        .name           = "LDO"#num,                                    \
+        .id             = MAX77686_LDO##num,                            \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_LDO_MINUV,                           \
+        .uV_step        = MAX77686_LDO_UVSTEP,                          \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_SHIFT,                       \
+}
+#define regulator_desc_ldo_low(num)             {                       \
+        .name           = "LDO"#num,                                    \
+        .id             = MAX77686_LDO##num,                            \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_LDO_LOW_MINUV,                       \
+        .uV_step        = MAX77686_LDO_LOW_UVSTEP,                      \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_LDO1CTRL1 + num - 1,             \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_SHIFT,                       \
+}
+#define regulator_desc_buck(num)                {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_BUCK_MINUV,                          \
+        .uV_step        = MAX77686_BUCK_UVSTEP,                         \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_BUCK5OUT + (num - 5) * 2,        \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_BUCK5CTRL + (num - 5) * 2,       \
+        .enable_mask    = MAX77686_OPMODE_MASK,                         \
+}
+#define regulator_desc_buck1(num)               {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_ops,                                \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_BUCK_MINUV,                          \
+        .uV_step        = MAX77686_BUCK_UVSTEP,                         \
+        .ramp_delay     = MAX77686_RAMP_DELAY,                          \
+        .n_voltages     = MAX77686_VSEL_MASK + 1,                       \
+        .vsel_reg       = MAX77686_REG_BUCK1OUT,                        \
+        .vsel_mask      = MAX77686_VSEL_MASK,                           \
+        .enable_reg     = MAX77686_REG_BUCK1CTRL,                       \
+        .enable_mask    = MAX77686_OPMODE_MASK,                         \
+}
+#define regulator_desc_buck_dvs(num)            {                       \
+        .name           = "BUCK"#num,                                   \
+        .id             = MAX77686_BUCK##num,                           \
+        .ops            = &max77686_buck_dvs_ops,                       \
+        .type           = REGULATOR_VOLTAGE,                            \
+        .owner          = THIS_MODULE,                                  \
+        .min_uV         = MAX77686_DVS_MINUV,                           \
+        .uV_step        = MAX77686_DVS_UVSTEP,                          \
+        .ramp_delay     = MAX77686_DVS_RAMP_DELAY,                      \
+        .n_voltages     = MAX77686_DVS_VSEL_MASK + 1,                   \
+        .vsel_reg       = MAX77686_REG_BUCK2DVS1 + (num - 2) * 10,      \
+        .vsel_mask      = MAX77686_DVS_VSEL_MASK,                       \
+        .enable_reg     = MAX77686_REG_BUCK2CTRL1 + (num - 2) * 10,     \
+        .enable_mask    = MAX77686_OPMODE_MASK                          \
+                        << MAX77686_OPMODE_BUCK234_SHIFT,               \
+}
+
+static struct regulator_desc regulators[] = {
+        regulator_desc_ldo_low(1),
+        regulator_desc_ldo_low(2),
+        regulator_desc_ldo(3),
+        regulator_desc_ldo(4),
+        regulator_desc_ldo(5),
+        regulator_desc_ldo_low(6),
+        regulator_desc_ldo_low(7),
+        regulator_desc_ldo_low(8),
+        regulator_desc_ldo(9),
+        regulator_desc_ldo(10),
+        regulator_desc_ldo(11),
+        regulator_desc_ldo(12),
+        regulator_desc_ldo(13),
+        regulator_desc_ldo(14),
+        regulator_desc_ldo_low(15),
+        regulator_desc_ldo(16),
+        regulator_desc_ldo(17),
+        regulator_desc_ldo(18),
+        regulator_desc_ldo(19),
+        regulator_desc_ldo(20),
+        regulator_desc_ldo(21),
+        regulator_desc_ldo(22),
+        regulator_desc_ldo(23),
+        regulator_desc_ldo(24),
+        regulator_desc_ldo(25),
+        regulator_desc_ldo(26),
+        regulator_desc_buck1(1),
+        regulator_desc_buck_dvs(2),
+        regulator_desc_buck_dvs(3),
+        regulator_desc_buck_dvs(4),
+        regulator_desc_buck(5),
+        regulator_desc_buck(6),
+        regulator_desc_buck(7),
+        regulator_desc_buck(8),
+        regulator_desc_buck(9),
+};
+
+#ifdef CONFIG_OF
+static int max77686_pmic_dt_parse_pdata(struct max77686_dev *iodev,
+                                        struct max77686_platform_data *pdata)
+{
+        struct device_node *pmic_np, *regulators_np;
+        struct max77686_regulator_data *rdata;
+        struct of_regulator_match rmatch;
+        unsigned int i;
+
+        pmic_np = iodev->dev->of_node;
+        regulators_np = of_find_node_by_name(pmic_np, "voltage-regulators");
+        if (!regulators_np) {
+                dev_err(iodev->dev, "could not find regulators sub-node\n");
+                return -EINVAL;
+        }
+
+        pdata->num_regulators = ARRAY_SIZE(regulators);
+        rdata = devm_kzalloc(iodev->dev, sizeof(*rdata) *
+                             pdata->num_regulators, GFP_KERNEL);
+        if (!rdata) {
+                dev_err(iodev->dev,
+                        "could not allocate memory for regulator data\n");
+                return -ENOMEM;
+        }
+
+        for (i = 0; i < pdata->num_regulators; i++) {
+                rmatch.name = regulators[i].name;
+                rmatch.init_data = NULL;
+                rmatch.of_node = NULL;
+                of_regulator_match(iodev->dev, regulators_np, &rmatch, 1);
+                rdata[i].initdata = rmatch.init_data;
+        }
+
+        pdata->regulators = rdata;
+
+        return 0;
+}
+#else
+static int max77686_pmic_dt_parse_pdata(struct max77686_dev *iodev,
+                                        struct max77686_platform_data *pdata)
+{
+        return 0;
+}
+#endif /* CONFIG_OF */
+
+static __devinit int max77686_pmic_probe(struct platform_device *pdev)
+{
+        struct max77686_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct max77686_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_dev **rdev;
+        struct max77686_data *max77686;
+        int i,  size;
+        int ret = 0;
+        struct regulator_config config = { };
+
+        dev_dbg(&pdev->dev, "%s\n", __func__);
+
+        if (!pdata) {
+                dev_err(&pdev->dev, "no platform data found for regulator\n");
+                return -ENODEV;
+        }
+
+        if (iodev->dev->of_node) {
+                ret = max77686_pmic_dt_parse_pdata(iodev, pdata);
+                if (ret)
+                        return ret;
+        }
+
+        if (pdata->num_regulators != MAX77686_REGULATORS) {
+                dev_err(&pdev->dev,
+                        "Invalid initial data for regulator's initialiation\n");
+                return -EINVAL;
+        }
+
+        max77686 = devm_kzalloc(&pdev->dev, sizeof(struct max77686_data),
+                                GFP_KERNEL);
+        if (!max77686)
+                return -ENOMEM;
+
+        size = sizeof(struct regulator_dev *) * MAX77686_REGULATORS;
+        max77686->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!max77686->rdev)
+                return -ENOMEM;
+
+        rdev = max77686->rdev;
+        config.dev = &pdev->dev;
+        config.regmap = iodev->regmap;
+        platform_set_drvdata(pdev, max77686);
+
+        for (i = 0; i < MAX77686_REGULATORS; i++) {
+                config.init_data = pdata->regulators[i].initdata;
+
+                rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(rdev[i])) {
+                        ret = PTR_ERR(rdev[i]);
+                        dev_err(&pdev->dev,
+                                "regulator init failed for %d\n", i);
+                                rdev[i] = NULL;
+                                goto err;
+                }
+        }
+
+        return 0;
+err:
+        while (--i >= 0)
+                regulator_unregister(rdev[i]);
+        return ret;
+}
+
+static int __devexit max77686_pmic_remove(struct platform_device *pdev)
+{
+        struct max77686_data *max77686 = platform_get_drvdata(pdev);
+        struct regulator_dev **rdev = max77686->rdev;
+        int i;
+
+        for (i = 0; i < MAX77686_REGULATORS; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return 0;
+}
+
+static const struct platform_device_id max77686_pmic_id[] = {
+        {"max77686-pmic", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(platform, max77686_pmic_id);
+
+static struct platform_driver max77686_pmic_driver = {
+        .driver = {
+                .name = "max77686-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = max77686_pmic_probe,
+        .remove = __devexit_p(max77686_pmic_remove),
+        .id_table = max77686_pmic_id,
+};
+
+static int __init max77686_pmic_init(void)
+{
+        return platform_driver_register(&max77686_pmic_driver);
+}
+subsys_initcall(max77686_pmic_init);
+
+static void __exit max77686_pmic_cleanup(void)
+{
+        platform_driver_unregister(&max77686_pmic_driver);
+}
+module_exit(max77686_pmic_cleanup);
+
+MODULE_DESCRIPTION("MAXIM 77686 Regulator Driver");
+MODULE_AUTHOR("Chiwoong Byun <woong.byun@samsung.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/max8952.c b/drivers/regulator/max8952.c
index 910c9b26d499..355ca7bad9d5 100644
--- a/drivers/regulator/max8952.c
+++ b/drivers/regulator/max8952.c
@@ -51,7 +51,6 @@ struct max8952_data {
 
         bool vid0;
         bool vid1;
-        bool en;
 };
 
 static int max8952_read_reg(struct max8952_data *max8952, u8 reg)
@@ -80,38 +79,6 @@ static int max8952_list_voltage(struct regulator_dev *rdev,
         return (max8952->pdata->dvs_mode[selector] * 10 + 770) * 1000;
 }
 
-static int max8952_is_enabled(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-        return max8952->en;
-}
-
-static int max8952_enable(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-
-        /* If not valid, assume "ALWAYS_HIGH" */
-        if (gpio_is_valid(max8952->pdata->gpio_en))
-                gpio_set_value(max8952->pdata->gpio_en, 1);
-
-        max8952->en = true;
-        return 0;
-}
-
-static int max8952_disable(struct regulator_dev *rdev)
-{
-        struct max8952_data *max8952 = rdev_get_drvdata(rdev);
-
-        /* If not valid, assume "ALWAYS_HIGH" -> not permitted */
-        if (gpio_is_valid(max8952->pdata->gpio_en))
-                gpio_set_value(max8952->pdata->gpio_en, 0);
-        else
-                return -EPERM;
-
-        max8952->en = false;
-        return 0;
-}
-
 static int max8952_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct max8952_data *max8952 = rdev_get_drvdata(rdev);
@@ -146,12 +113,8 @@ static int max8952_set_voltage_sel(struct regulator_dev *rdev,
 
 static struct regulator_ops max8952_ops = {
         .list_voltage           = max8952_list_voltage,
-        .is_enabled             = max8952_is_enabled,
-        .enable                 = max8952_enable,
-        .disable                = max8952_disable,
         .get_voltage_sel        = max8952_get_voltage_sel,
         .set_voltage_sel        = max8952_set_voltage_sel,
-        .set_suspend_disable    = max8952_disable,
 };
 
 static const struct regulator_desc regulator = {
@@ -194,6 +157,10 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
         config.init_data = &pdata->reg_data;
         config.driver_data = max8952;
 
+        config.ena_gpio = pdata->gpio_en;
+        if (pdata->reg_data.constraints.boot_on)
+                config.ena_gpio_flags |= GPIOF_OUT_INIT_HIGH;
+
         max8952->rdev = regulator_register(&regulator, &config);
 
         if (IS_ERR(max8952->rdev)) {
@@ -202,27 +169,9 @@ static int __devinit max8952_pmic_probe(struct i2c_client *client,
                 return ret;
         }
 
-        max8952->en = !!(pdata->reg_data.constraints.boot_on);
         max8952->vid0 = pdata->default_mode & 0x1;
         max8952->vid1 = (pdata->default_mode >> 1) & 0x1;
 
-        if (gpio_is_valid(pdata->gpio_en)) {
-                if (!gpio_request(pdata->gpio_en, "MAX8952 EN"))
-                        gpio_direction_output(pdata->gpio_en, max8952->en);
-                else
-                        err = 1;
-        } else
-                err = 2;
-
-        if (err) {
-                dev_info(max8952->dev, "EN gpio invalid: assume that EN"
-                                "is always High\n");
-                max8952->en = 1;
-                pdata->gpio_en = -1; /* Mark invalid */
-        }
-
-        err = 0;
-
         if (gpio_is_valid(pdata->gpio_vid0) &&
                         gpio_is_valid(pdata->gpio_vid1)) {
                 if (!gpio_request(pdata->gpio_vid0, "MAX8952 VID0"))
@@ -308,7 +257,6 @@ static int __devexit max8952_pmic_remove(struct i2c_client *client)
 
         gpio_free(pdata->gpio_vid0);
         gpio_free(pdata->gpio_vid1);
-        gpio_free(pdata->gpio_en);
         return 0;
 }
 
diff --git a/drivers/regulator/max8997.c b/drivers/regulator/max8997.c
index 704cd49ef375..e39a0c7260dc 100644
--- a/drivers/regulator/max8997.c
+++ b/drivers/regulator/max8997.c
@@ -1025,7 +1025,6 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
          */
         if (pdata->buck1_gpiodvs || pdata->buck2_gpiodvs ||
                         pdata->buck5_gpiodvs) {
-                bool gpio1set = false, gpio2set = false;
 
                 if (!gpio_is_valid(pdata->buck125_gpios[0]) ||
                                 !gpio_is_valid(pdata->buck125_gpios[1]) ||
@@ -1035,40 +1034,20 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                         goto err_out;
                 }
 
-                ret = gpio_request(pdata->buck125_gpios[0],
-                                "MAX8997 SET1");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET1\n");
-                else if (ret)
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[0],
+                                        "MAX8997 SET1");
+                if (ret)
                         goto err_out;
-                else
-                        gpio1set = true;
-
-                ret = gpio_request(pdata->buck125_gpios[1],
-                                "MAX8997 SET2");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET2\n");
-                else if (ret) {
-                        if (gpio1set)
-                                gpio_free(pdata->buck125_gpios[0]);
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[1],
+                                        "MAX8997 SET2");
+                if (ret)
                         goto err_out;
-                } else
-                        gpio2set = true;
 
-                ret = gpio_request(pdata->buck125_gpios[2],
+                ret = devm_gpio_request(&pdev->dev, pdata->buck125_gpios[2],
                                 "MAX8997 SET3");
-                if (ret == -EBUSY)
-                        dev_warn(&pdev->dev, "Duplicated gpio request"
-                                        " on SET3\n");
-                else if (ret) {
-                        if (gpio1set)
-                                gpio_free(pdata->buck125_gpios[0]);
-                        if (gpio2set)
-                                gpio_free(pdata->buck125_gpios[1]);
+                if (ret)
                         goto err_out;
-                }
 
                 gpio_direction_output(pdata->buck125_gpios[0],
                                 (max8997->buck125_gpioindex >> 2)
@@ -1079,7 +1058,6 @@ static __devinit int max8997_pmic_probe(struct platform_device *pdev)
                 gpio_direction_output(pdata->buck125_gpios[2],
                                 (max8997->buck125_gpioindex >> 0)
                                 & 0x1); /* SET3 */
-                ret = 0;
         }
 
         /* DVS-GPIO disabled */
diff --git a/drivers/regulator/max8998.c b/drivers/regulator/max8998.c
index 18bb58b9b96e..5dfa920ff0c8 100644
--- a/drivers/regulator/max8998.c
+++ b/drivers/regulator/max8998.c
@@ -111,27 +111,6 @@ static const struct voltage_map_desc *ldo_voltage_map[] = {
         &buck4_voltage_map_desc,        /* BUCK4 */
 };
 
-static int max8998_list_voltage(struct regulator_dev *rdev,
-                                unsigned int selector)
-{
-        const struct voltage_map_desc *desc;
-        int ldo = rdev_get_id(rdev);
-        int val;
-
-        if (ldo >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[ldo];
-        if (desc == NULL)
-                return -EINVAL;
-
-        val = desc->min + desc->step * selector;
-        if (val > desc->max)
-                return -EINVAL;
-
-        return val * 1000;
-}
-
 static int max8998_get_enable_register(struct regulator_dev *rdev,
                                         int *reg, int *shift)
 {
@@ -297,41 +276,18 @@ static int max8998_get_voltage_sel(struct regulator_dev *rdev)
         return val;
 }
 
-static int max8998_set_voltage_ldo(struct regulator_dev *rdev,
-                                   int min_uV, int max_uV, unsigned *selector)
+static int max8998_set_voltage_ldo_sel(struct regulator_dev *rdev,
+                                       unsigned selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct i2c_client *i2c = max8998->iodev->i2c;
-        int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
-        const struct voltage_map_desc *desc;
-        int ldo = rdev_get_id(rdev);
-        int reg, shift = 0, mask, ret, i;
-
-        if (ldo >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[ldo];
-        if (desc == NULL)
-                return -EINVAL;
-
-        if (max_vol < desc->min || min_vol > desc->max)
-                return -EINVAL;
-
-        if (min_vol < desc->min)
-                min_vol = desc->min;
-
-        i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
-
-        if (desc->min + desc->step*i > max_vol)
-                return -EINVAL;
-
-        *selector = i;
+        int reg, shift = 0, mask, ret;
 
         ret = max8998_get_voltage_register(rdev, &reg, &shift, &mask);
         if (ret)
                 return ret;
 
-        ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
+        ret = max8998_update_reg(i2c, reg, selector<<shift, mask<<shift);
 
         return ret;
 }
@@ -347,41 +303,18 @@ static inline void buck2_gpio_set(int gpio, int v)
         gpio_set_value(gpio, v & 0x1);
 }
 
-static int max8998_set_voltage_buck(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV, unsigned *selector)
+static int max8998_set_voltage_buck_sel(struct regulator_dev *rdev,
+                                        unsigned selector)
 {
         struct max8998_data *max8998 = rdev_get_drvdata(rdev);
         struct max8998_platform_data *pdata =
                 dev_get_platdata(max8998->iodev->dev);
         struct i2c_client *i2c = max8998->iodev->i2c;
-        int min_vol = min_uV / 1000, max_vol = max_uV / 1000;
-        const struct voltage_map_desc *desc;
         int buck = rdev_get_id(rdev);
         int reg, shift = 0, mask, ret;
-        int i, j, previous_sel;
+        int j, previous_sel;
         static u8 buck1_last_val;
 
-        if (buck >= ARRAY_SIZE(ldo_voltage_map))
-                return -EINVAL;
-
-        desc = ldo_voltage_map[buck];
-
-        if (desc == NULL)
-                return -EINVAL;
-
-        if (max_vol < desc->min || min_vol > desc->max)
-                return -EINVAL;
-
-        if (min_vol < desc->min)
-                min_vol = desc->min;
-
-        i = DIV_ROUND_UP(min_vol - desc->min, desc->step);
-
-        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;
@@ -390,19 +323,19 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
 
         /* Check if voltage needs to be changed */
         /* if previous_voltage equal new voltage, return */
-        if (previous_sel == i) {
+        if (previous_sel == selector) {
                 dev_dbg(max8998->dev, "No voltage change, old:%d, new:%d\n",
-                        max8998_list_voltage(rdev, previous_sel),
-                        max8998_list_voltage(rdev, i));
+                        regulator_list_voltage_linear(rdev, previous_sel),
+                        regulator_list_voltage_linear(rdev, selector));
                 return ret;
         }
 
         switch (buck) {
         case MAX8998_BUCK1:
                 dev_dbg(max8998->dev,
-                        "BUCK1, i:%d, buck1_vol1:%d, buck1_vol2:%d\n"
+                        "BUCK1, selector:%d, buck1_vol1:%d, buck1_vol2:%d\n"
                         "buck1_vol3:%d, buck1_vol4:%d\n",
-                        i, max8998->buck1_vol[0], max8998->buck1_vol[1],
+                        selector, max8998->buck1_vol[0], max8998->buck1_vol[1],
                         max8998->buck1_vol[2], max8998->buck1_vol[3]);
 
                 if (gpio_is_valid(pdata->buck1_set1) &&
@@ -411,7 +344,7 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
                         /* check if requested voltage */
                         /* value is already defined */
                         for (j = 0; j < ARRAY_SIZE(max8998->buck1_vol); j++) {
-                                if (max8998->buck1_vol[j] == i) {
+                                if (max8998->buck1_vol[j] == selector) {
                                         max8998->buck1_idx = j;
                                         buck1_gpio_set(pdata->buck1_set1,
                                                        pdata->buck1_set2, j);
@@ -426,11 +359,11 @@ static int max8998_set_voltage_buck(struct regulator_dev *rdev,
                         max8998->buck1_idx = (buck1_last_val % 2) + 2;
                         dev_dbg(max8998->dev, "max8998->buck1_idx:%d\n",
                                 max8998->buck1_idx);
-                        max8998->buck1_vol[max8998->buck1_idx] = i;
+                        max8998->buck1_vol[max8998->buck1_idx] = selector;
                         ret = max8998_get_voltage_register(rdev, &reg,
                                                            &shift,
                                                            &mask);
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                         buck1_gpio_set(pdata->buck1_set1,
                                        pdata->buck1_set2, max8998->buck1_idx);
                         buck1_last_val++;
@@ -440,20 +373,20 @@ buck1_exit:
                                 gpio_get_value(pdata->buck1_set2));
                         break;
                 } else {
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                 }
                 break;
 
         case MAX8998_BUCK2:
                 dev_dbg(max8998->dev,
-                        "BUCK2, i:%d buck2_vol1:%d, buck2_vol2:%d\n"
-                        , i, max8998->buck2_vol[0], max8998->buck2_vol[1]);
+                        "BUCK2, selector:%d buck2_vol1:%d, buck2_vol2:%d\n",
+                        selector, max8998->buck2_vol[0], max8998->buck2_vol[1]);
                 if (gpio_is_valid(pdata->buck2_set3)) {
 
                         /* check if requested voltage */
                         /* value is already defined */
                         for (j = 0; j < ARRAY_SIZE(max8998->buck2_vol); j++) {
-                                if (max8998->buck2_vol[j] == i) {
+                                if (max8998->buck2_vol[j] == selector) {
                                         max8998->buck2_idx = j;
                                         buck2_gpio_set(pdata->buck2_set3, j);
                                         goto buck2_exit;
@@ -465,20 +398,21 @@ buck1_exit:
 
                         max8998_get_voltage_register(rdev,
                                         &reg, &shift, &mask);
-                        ret = max8998_write_reg(i2c, reg, i);
-                        max8998->buck2_vol[max8998->buck2_idx] = i;
+                        ret = max8998_write_reg(i2c, reg, selector);
+                        max8998->buck2_vol[max8998->buck2_idx] = selector;
                         buck2_gpio_set(pdata->buck2_set3, max8998->buck2_idx);
 buck2_exit:
                         dev_dbg(max8998->dev, "%s: SET3:%d\n", i2c->name,
                                 gpio_get_value(pdata->buck2_set3));
                 } else {
-                        ret = max8998_write_reg(i2c, reg, i);
+                        ret = max8998_write_reg(i2c, reg, selector);
                 }
                 break;
 
         case MAX8998_BUCK3:
         case MAX8998_BUCK4:
-                ret = max8998_update_reg(i2c, reg, i<<shift, mask<<shift);
+                ret = max8998_update_reg(i2c, reg, selector<<shift,
+                                         mask<<shift);
                 break;
         }
 
@@ -519,34 +453,30 @@ static int max8998_set_voltage_buck_time_sel(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops max8998_ldo_ops = {
-        .list_voltage           = max8998_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
         .get_voltage_sel        = max8998_get_voltage_sel,
-        .set_voltage            = max8998_set_voltage_ldo,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
+        .set_voltage_sel        = max8998_set_voltage_ldo_sel,
 };
 
 static struct regulator_ops max8998_buck_ops = {
-        .list_voltage           = max8998_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
         .get_voltage_sel        = max8998_get_voltage_sel,
-        .set_voltage            = max8998_set_voltage_buck,
+        .set_voltage_sel        = max8998_set_voltage_buck_sel,
         .set_voltage_time_sel   = max8998_set_voltage_buck_time_sel,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
 };
 
 static struct regulator_ops max8998_others_ops = {
         .is_enabled             = max8998_ldo_is_enabled,
         .enable                 = max8998_ldo_enable,
         .disable                = max8998_ldo_disable,
-        .set_suspend_enable     = max8998_ldo_enable,
-        .set_suspend_disable    = max8998_ldo_disable,
 };
 
 static struct regulator_desc regulators[] = {
@@ -860,7 +790,10 @@ static __devinit int max8998_pmic_probe(struct platform_device *pdev)
                 desc = ldo_voltage_map[id];
                 if (desc && regulators[index].ops != &max8998_others_ops) {
                         int count = (desc->max - desc->min) / desc->step + 1;
+
                         regulators[index].n_voltages = count;
+                        regulators[index].min_uV = desc->min * 1000;
+                        regulators[index].uV_step = desc->step * 1000;
                 }
 
                 config.dev = max8998->dev;
diff --git a/drivers/regulator/mc13783-regulator.c b/drivers/regulator/mc13783-regulator.c
index 7dcdfa283e93..4932e3449fe1 100644
--- a/drivers/regulator/mc13783-regulator.c
+++ b/drivers/regulator/mc13783-regulator.c
@@ -93,78 +93,78 @@
 
 
 /* Voltage Values */
-static const int mc13783_sw3_val[] = {
+static const unsigned int mc13783_sw3_val[] = {
         5000000, 5000000, 5000000, 5500000,
 };
 
-static const int mc13783_vaudio_val[] = {
+static const unsigned int mc13783_vaudio_val[] = {
         2775000,
 };
 
-static const int mc13783_viohi_val[] = {
+static const unsigned int mc13783_viohi_val[] = {
         2775000,
 };
 
-static const int mc13783_violo_val[] = {
+static const unsigned int mc13783_violo_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int mc13783_vdig_val[] = {
+static const unsigned int mc13783_vdig_val[] = {
         1200000, 1300000, 1500000, 1800000,
 };
 
-static const int mc13783_vgen_val[] = {
+static const unsigned int mc13783_vgen_val[] = {
         1200000, 1300000, 1500000, 1800000,
         1100000, 2000000, 2775000, 2400000,
 };
 
-static const int mc13783_vrfdig_val[] = {
+static const unsigned int mc13783_vrfdig_val[] = {
         1200000, 1500000, 1800000, 1875000,
 };
 
-static const int mc13783_vrfref_val[] = {
+static const unsigned int mc13783_vrfref_val[] = {
         2475000, 2600000, 2700000, 2775000,
 };
 
-static const int mc13783_vrfcp_val[] = {
+static const unsigned int mc13783_vrfcp_val[] = {
         2700000, 2775000,
 };
 
-static const int mc13783_vsim_val[] = {
+static const unsigned int mc13783_vsim_val[] = {
         1800000, 2900000, 3000000,
 };
 
-static const int mc13783_vesim_val[] = {
+static const unsigned int mc13783_vesim_val[] = {
         1800000, 2900000,
 };
 
-static const int mc13783_vcam_val[] = {
+static const unsigned int mc13783_vcam_val[] = {
         1500000, 1800000, 2500000, 2550000,
         2600000, 2750000, 2800000, 3000000,
 };
 
-static const int mc13783_vrfbg_val[] = {
+static const unsigned int mc13783_vrfbg_val[] = {
         1250000,
 };
 
-static const int mc13783_vvib_val[] = {
+static const unsigned int mc13783_vvib_val[] = {
         1300000, 1800000, 2000000, 3000000,
 };
 
-static const int mc13783_vmmc_val[] = {
+static const unsigned int mc13783_vmmc_val[] = {
         1600000, 1800000, 2000000, 2600000,
         2700000, 2800000, 2900000, 3000000,
 };
 
-static const int mc13783_vrf_val[] = {
+static const unsigned int mc13783_vrf_val[] = {
         1500000, 1875000, 2700000, 2775000,
 };
 
-static const int mc13783_gpo_val[] = {
+static const unsigned int mc13783_gpo_val[] = {
         3100000,
 };
 
-static const int mc13783_pwgtdrv_val[] = {
+static const unsigned int mc13783_pwgtdrv_val[] = {
         5500000,
 };
 
@@ -328,7 +328,7 @@ 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 = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
         .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
diff --git a/drivers/regulator/mc13892-regulator.c b/drivers/regulator/mc13892-regulator.c
index 970a233dbe46..b388b746452e 100644
--- a/drivers/regulator/mc13892-regulator.c
+++ b/drivers/regulator/mc13892-regulator.c
@@ -150,12 +150,12 @@
 #define MC13892_USB1                            50
 #define MC13892_USB1_VUSBEN                     (1<<3)
 
-static const int mc13892_vcoincell[] = {
+static const unsigned int mc13892_vcoincell[] = {
         2500000, 2700000, 2800000, 2900000, 3000000, 3100000,
         3200000, 3300000,
 };
 
-static const int mc13892_sw1[] = {
+static const unsigned int mc13892_sw1[] = {
         600000,   625000,  650000,  675000,  700000,  725000,
         750000,   775000,  800000,  825000,  850000,  875000,
         900000,   925000,  950000,  975000, 1000000, 1025000,
@@ -164,7 +164,7 @@ static const int mc13892_sw1[] = {
         1350000, 1375000
 };
 
-static const int mc13892_sw[] = {
+static const unsigned int mc13892_sw[] = {
         600000,   625000,  650000,  675000,  700000,  725000,
         750000,   775000,  800000,  825000,  850000,  875000,
         900000,   925000,  950000,  975000, 1000000, 1025000,
@@ -176,65 +176,65 @@ static const int mc13892_sw[] = {
         1800000, 1825000, 1850000, 1875000
 };
 
-static const int mc13892_swbst[] = {
+static const unsigned int mc13892_swbst[] = {
         5000000,
 };
 
-static const int mc13892_viohi[] = {
+static const unsigned int mc13892_viohi[] = {
         2775000,
 };
 
-static const int mc13892_vpll[] = {
+static const unsigned int mc13892_vpll[] = {
         1050000, 1250000, 1650000, 1800000,
 };
 
-static const int mc13892_vdig[] = {
+static const unsigned int mc13892_vdig[] = {
         1050000, 1250000, 1650000, 1800000,
 };
 
-static const int mc13892_vsd[] = {
+static const unsigned int mc13892_vsd[] = {
         1800000, 2000000, 2600000, 2700000,
         2800000, 2900000, 3000000, 3150000,
 };
 
-static const int mc13892_vusb2[] = {
+static const unsigned int mc13892_vusb2[] = {
         2400000, 2600000, 2700000, 2775000,
 };
 
-static const int mc13892_vvideo[] = {
+static const unsigned int mc13892_vvideo[] = {
         2700000, 2775000, 2500000, 2600000,
 };
 
-static const int mc13892_vaudio[] = {
+static const unsigned int mc13892_vaudio[] = {
         2300000, 2500000, 2775000, 3000000,
 };
 
-static const int mc13892_vcam[] = {
+static const unsigned int mc13892_vcam[] = {
         2500000, 2600000, 2750000, 3000000,
 };
 
-static const int mc13892_vgen1[] = {
+static const unsigned int mc13892_vgen1[] = {
         1200000, 1500000, 2775000, 3150000,
 };
 
-static const int mc13892_vgen2[] = {
+static const unsigned int mc13892_vgen2[] = {
         1200000, 1500000, 1600000, 1800000,
         2700000, 2800000, 3000000, 3150000,
 };
 
-static const int mc13892_vgen3[] = {
+static const unsigned int mc13892_vgen3[] = {
         1800000, 2900000,
 };
 
-static const int mc13892_vusb[] = {
+static const unsigned int mc13892_vusb[] = {
         3300000,
 };
 
-static const int mc13892_gpo[] = {
+static const unsigned int mc13892_gpo[] = {
         2750000,
 };
 
-static const int mc13892_pwgtdrv[] = {
+static const unsigned int mc13892_pwgtdrv[] = {
         5000000,
 };
 
@@ -394,7 +394,7 @@ 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,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage = mc13xxx_fixed_regulator_set_voltage,
         .get_voltage = mc13xxx_fixed_regulator_get_voltage,
 };
@@ -436,7 +436,7 @@ static int mc13892_sw_regulator_set_voltage_sel(struct regulator_dev *rdev,
         u32 valread;
         int ret;
 
-        value = mc13892_regulators[id].voltages[selector];
+        value = rdev->desc->volt_table[selector];
 
         mc13xxx_lock(priv->mc13xxx);
         ret = mc13xxx_reg_read(priv->mc13xxx,
@@ -469,8 +469,7 @@ err:
 }
 
 static struct regulator_ops mc13892_sw_regulator_ops = {
-        .is_enabled = mc13xxx_sw_regulator_is_enabled,
-        .list_voltage = mc13xxx_regulator_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = mc13892_sw_regulator_set_voltage_sel,
         .get_voltage = mc13892_sw_regulator_get_voltage,
 };
diff --git a/drivers/regulator/mc13xxx-regulator-core.c b/drivers/regulator/mc13xxx-regulator-core.c
index 4fa9704739bc..d6eda28ca5d0 100644
--- a/drivers/regulator/mc13xxx-regulator-core.c
+++ b/drivers/regulator/mc13xxx-regulator-core.c
@@ -80,20 +80,6 @@ static int mc13xxx_regulator_is_enabled(struct regulator_dev *rdev)
         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);
-
 static int mc13xxx_regulator_set_voltage_sel(struct regulator_dev *rdev,
                                              unsigned selector)
 {
@@ -135,14 +121,14 @@ static int mc13xxx_regulator_get_voltage(struct regulator_dev *rdev)
 
         BUG_ON(val >= mc13xxx_regulators[id].desc.n_voltages);
 
-        return mc13xxx_regulators[id].voltages[val];
+        return rdev->desc->volt_table[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,
+        .list_voltage = regulator_list_voltage_table,
         .set_voltage_sel = mc13xxx_regulator_set_voltage_sel,
         .get_voltage = mc13xxx_regulator_get_voltage,
 };
@@ -151,15 +137,13 @@ 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])
+        if (min_uV <= rdev->desc->volt_table[0] &&
+            rdev->desc->volt_table[0] <= max_uV)
                 return 0;
         else
                 return -EINVAL;
@@ -168,13 +152,11 @@ 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];
+        return rdev->desc->volt_table[0];
 }
 EXPORT_SYMBOL_GPL(mc13xxx_fixed_regulator_get_voltage);
 
@@ -182,18 +164,12 @@ 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,
+        .list_voltage = regulator_list_voltage_table,
         .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);
-
 #ifdef CONFIG_OF
 int __devinit mc13xxx_get_num_regulators_dt(struct platform_device *pdev)
 {
diff --git a/drivers/regulator/mc13xxx.h b/drivers/regulator/mc13xxx.h
index 044aba4d28ec..eaff5510b6df 100644
--- a/drivers/regulator/mc13xxx.h
+++ b/drivers/regulator/mc13xxx.h
@@ -22,7 +22,6 @@ struct mc13xxx_regulator {
         int vsel_shift;
         int vsel_mask;
         int hi_bit;
-        int const *voltages;
 };
 
 struct mc13xxx_regulator_priv {
@@ -33,10 +32,6 @@ struct mc13xxx_regulator_priv {
         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_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);
@@ -68,6 +63,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,                   \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -78,7 +74,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .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)      \
@@ -86,6 +81,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,           \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -93,7 +89,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 },                                                      \
                 .reg = prefix ## _reg,                          \
                 .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
-                .voltages =  _voltages,                                 \
         }
 
 #define MC13xxx_GPO_DEFINE(prefix, _name, _reg,  _voltages, _ops)       \
@@ -101,6 +96,7 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 .desc = {                                               \
                         .name = #_name,                                 \
                         .n_voltages = ARRAY_SIZE(_voltages),            \
+                        .volt_table =  _voltages,                       \
                         .ops = &_ops,           \
                         .type = REGULATOR_VOLTAGE,                      \
                         .id = prefix ## _name,          \
@@ -108,7 +104,6 @@ extern struct regulator_ops mc13xxx_fixed_regulator_ops;
                 },                                                      \
                 .reg = prefix ## _reg,                          \
                 .enable_bit = prefix ## _reg ## _ ## _name ## EN,       \
-                .voltages =  _voltages,                                 \
         }
 
 #define MC13xxx_DEFINE_SW(_name, _reg, _vsel_reg, _voltages, ops)       \
diff --git a/drivers/regulator/of_regulator.c b/drivers/regulator/of_regulator.c
index 56593b75168a..3e4106f2bda9 100644
--- a/drivers/regulator/of_regulator.c
+++ b/drivers/regulator/of_regulator.c
@@ -20,7 +20,7 @@ static void of_get_regulation_constraints(struct device_node *np,
                                         struct regulator_init_data **init_data)
 {
         const __be32 *min_uV, *max_uV, *uV_offset;
-        const __be32 *min_uA, *max_uA;
+        const __be32 *min_uA, *max_uA, *ramp_delay;
         struct regulation_constraints *constraints = &(*init_data)->constraints;
 
         constraints->name = of_get_property(np, "regulator-name", NULL);
@@ -60,6 +60,10 @@ static void of_get_regulation_constraints(struct device_node *np,
                 constraints->always_on = true;
         else /* status change should be possible if not always on. */
                 constraints->valid_ops_mask |= REGULATOR_CHANGE_STATUS;
+
+        ramp_delay = of_get_property(np, "regulator-ramp-delay", NULL);
+        if (ramp_delay)
+                constraints->ramp_delay = be32_to_cpu(*ramp_delay);
 }
 
 /**
@@ -88,15 +92,17 @@ struct regulator_init_data *of_get_regulator_init_data(struct device *dev,
 EXPORT_SYMBOL_GPL(of_get_regulator_init_data);
 
 /**
- * of_regulator_match - extract regulator init data
+ * of_regulator_match - extract regulator init data when node
+ * property "regulator-compatible" matches with the regulator name.
  * @dev: device requesting the data
  * @node: parent device node of the regulators
  * @matches: match table for the regulators
  * @num_matches: number of entries in match table
  *
  * This function uses a match table specified by the regulator driver and
- * looks up the corresponding init data in the device tree. Note that the
- * match table is modified in place.
+ * looks up the corresponding init data in the device tree  if
+ * regulator-compatible matches. Note that the match table is modified
+ * in place.
  *
  * Returns the number of matches found or a negative error code on failure.
  */
@@ -106,27 +112,40 @@ int of_regulator_match(struct device *dev, struct device_node *node,
 {
         unsigned int count = 0;
         unsigned int i;
+        const char *regulator_comp;
+        struct device_node *child;
 
         if (!dev || !node)
                 return -EINVAL;
 
-        for (i = 0; i < num_matches; i++) {
-                struct of_regulator_match *match = &matches[i];
-                struct device_node *child;
-
-                child = of_find_node_by_name(node, match->name);
-                if (!child)
-                        continue;
-
-                match->init_data = of_get_regulator_init_data(dev, child);
-                if (!match->init_data) {
-                        dev_err(dev, "failed to parse DT for regulator %s\n",
+        for_each_child_of_node(node, child) {
+                regulator_comp = of_get_property(child,
+                                        "regulator-compatible", NULL);
+                if (!regulator_comp) {
+                        dev_err(dev, "regulator-compatible is missing for node %s\n",
                                 child->name);
-                        return -EINVAL;
+                        continue;
+                }
+                for (i = 0; i < num_matches; i++) {
+                        struct of_regulator_match *match = &matches[i];
+                        if (match->of_node)
+                                continue;
+
+                        if (strcmp(match->name, regulator_comp))
+                                continue;
+
+                        match->init_data =
+                                of_get_regulator_init_data(dev, child);
+                        if (!match->init_data) {
+                                dev_err(dev,
+                                        "failed to parse DT for regulator %s\n",
+                                        child->name);
+                                return -EINVAL;
+                        }
+                        match->of_node = child;
+                        count++;
+                        break;
                 }
-
-                match->of_node = child;
-                count++;
         }
 
         return count;
diff --git a/drivers/regulator/palmas-regulator.c b/drivers/regulator/palmas-regulator.c
index 795f75a6ac33..17d19fbbc490 100644
--- a/drivers/regulator/palmas-regulator.c
+++ b/drivers/regulator/palmas-regulator.c
@@ -257,8 +257,7 @@ static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode)
         unsigned int reg;
 
         palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, &reg);
-        reg &= ~PALMAS_SMPS12_CTRL_STATUS_MASK;
-        reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT;
+        reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK;
 
         switch (mode) {
         case REGULATOR_MODE_NORMAL:
@@ -374,11 +373,22 @@ static int palmas_set_voltage_smps_sel(struct regulator_dev *dev,
 static int palmas_map_voltage_smps(struct regulator_dev *rdev,
                 int min_uV, int max_uV)
 {
+        struct palmas_pmic *pmic = rdev_get_drvdata(rdev);
+        int id = rdev_get_id(rdev);
         int ret, voltage;
 
-        ret = ((min_uV - 500000) / 10000) + 1;
-        if (ret < 0)
-                return ret;
+        if (min_uV == 0)
+                return 0;
+
+        if (pmic->range[id]) { /* RANGE is x2 */
+                if (min_uV < 1000000)
+                        min_uV = 1000000;
+                ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 1;
+        } else {                /* RANGE is x1 */
+                if (min_uV < 500000)
+                        min_uV = 500000;
+                ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 1;
+        }
 
         /* Map back into a voltage to verify we're still in bounds */
         voltage = palmas_list_voltage_smps(rdev, ret);
@@ -400,19 +410,14 @@ static struct regulator_ops palmas_ops_smps = {
         .map_voltage            = palmas_map_voltage_smps,
 };
 
-static int palmas_list_voltage_smps10(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        return 3750000 + (selector * 1250000);
-}
-
 static struct regulator_ops palmas_ops_smps10 = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
         .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
-        .list_voltage           = palmas_list_voltage_smps10,
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
 };
 
 static int palmas_is_enabled_ldo(struct regulator_dev *dev)
@@ -522,7 +527,15 @@ static int palmas_smps_init(struct palmas *palmas, int id,
         if (ret)
                 return ret;
 
-        if (id != PALMAS_REG_SMPS10) {
+        switch (id) {
+        case PALMAS_REG_SMPS10:
+                if (reg_init->mode_sleep) {
+                        reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
+                        reg |= reg_init->mode_sleep <<
+                                        PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
+                }
+                break;
+        default:
                 if (reg_init->warm_reset)
                         reg |= PALMAS_SMPS12_CTRL_WR_S;
 
@@ -534,14 +547,8 @@ static int palmas_smps_init(struct palmas *palmas, int id,
                         reg |= reg_init->mode_sleep <<
                                         PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT;
                 }
-        } else {
-                if (reg_init->mode_sleep) {
-                        reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK;
-                        reg |= reg_init->mode_sleep <<
-                                        PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT;
-                }
-
         }
+
         ret = palmas_smps_write(palmas, addr, reg);
         if (ret)
                 return ret;
@@ -665,10 +672,8 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                 pmic->desc[id].name = palmas_regs_info[id].name;
                 pmic->desc[id].id = id;
 
-                if (id != PALMAS_REG_SMPS10) {
-                        pmic->desc[id].ops = &palmas_ops_smps;
-                        pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
-                } else {
+                switch (id) {
+                case PALMAS_REG_SMPS10:
                         pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES;
                         pmic->desc[id].ops = &palmas_ops_smps10;
                         pmic->desc[id].vsel_reg = PALMAS_SMPS10_CTRL;
@@ -677,6 +682,12 @@ static __devinit int palmas_probe(struct platform_device *pdev)
                                         PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE,
                                                         PALMAS_SMPS10_STATUS);
                         pmic->desc[id].enable_mask = SMPS10_BOOST_EN;
+                        pmic->desc[id].min_uV = 3750000;
+                        pmic->desc[id].uV_step = 1250000;
+                        break;
+                default:
+                        pmic->desc[id].ops = &palmas_ops_smps;
+                        pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES;
                 }
 
                 pmic->desc[id].type = REGULATOR_VOLTAGE;
diff --git a/drivers/regulator/pcap-regulator.c b/drivers/regulator/pcap-regulator.c
index 8211101121f0..68777acc099f 100644
--- a/drivers/regulator/pcap-regulator.c
+++ b/drivers/regulator/pcap-regulator.c
@@ -18,80 +18,80 @@
 #include <linux/regulator/machine.h>
 #include <linux/mfd/ezx-pcap.h>
 
-static const u16 V1_table[] = {
-        2775, 1275, 1600, 1725, 1825, 1925, 2075, 2275,
+static const unsigned int V1_table[] = {
+        2775000, 1275000, 1600000, 1725000, 1825000, 1925000, 2075000, 2275000,
 };
 
-static const u16 V2_table[] = {
-        2500, 2775,
+static const unsigned int V2_table[] = {
+        2500000, 2775000,
 };
 
-static const u16 V3_table[] = {
-        1075, 1275, 1550, 1725, 1876, 1950, 2075, 2275,
+static const unsigned int V3_table[] = {
+        1075000, 1275000, 1550000, 1725000, 1876000, 1950000, 2075000, 2275000,
 };
 
-static const u16 V4_table[] = {
-        1275, 1550, 1725, 1875, 1950, 2075, 2275, 2775,
+static const unsigned int V4_table[] = {
+        1275000, 1550000, 1725000, 1875000, 1950000, 2075000, 2275000, 2775000,
 };
 
-static const u16 V5_table[] = {
-        1875, 2275, 2475, 2775,
+static const unsigned int V5_table[] = {
+        1875000, 2275000, 2475000, 2775000,
 };
 
-static const u16 V6_table[] = {
-        2475, 2775,
+static const unsigned int V6_table[] = {
+        2475000, 2775000,
 };
 
-static const u16 V7_table[] = {
-        1875, 2775,
+static const unsigned int V7_table[] = {
+        1875000, 2775000,
 };
 
 #define V8_table V4_table
 
-static const u16 V9_table[] = {
-        1575, 1875, 2475, 2775,
+static const unsigned int V9_table[] = {
+        1575000, 1875000, 2475000, 2775000,
 };
 
-static const u16 V10_table[] = {
-        5000,
+static const unsigned int V10_table[] = {
+        5000000,
 };
 
-static const u16 VAUX1_table[] = {
-        1875, 2475, 2775, 3000,
+static const unsigned int VAUX1_table[] = {
+        1875000, 2475000, 2775000, 3000000,
 };
 
 #define VAUX2_table VAUX1_table
 
-static const u16 VAUX3_table[] = {
-        1200, 1200, 1200, 1200, 1400, 1600, 1800, 2000,
-        2200, 2400, 2600, 2800, 3000, 3200, 3400, 3600,
+static const unsigned int VAUX3_table[] = {
+        1200000, 1200000, 1200000, 1200000, 1400000, 1600000, 1800000, 2000000,
+        2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000, 3600000,
 };
 
-static const u16 VAUX4_table[] = {
-        1800, 1800, 3000, 5000,
+static const unsigned int VAUX4_table[] = {
+        1800000, 1800000, 3000000, 5000000,
 };
 
-static const u16 VSIM_table[] = {
-        1875, 3000,
+static const unsigned int VSIM_table[] = {
+        1875000, 3000000,
 };
 
-static const u16 VSIM2_table[] = {
-        1875,
+static const unsigned int VSIM2_table[] = {
+        1875000,
 };
 
-static const u16 VVIB_table[] = {
-        1300, 1800, 2000, 3000,
+static const unsigned int VVIB_table[] = {
+        1300000, 1800000, 2000000, 3000000,
 };
 
-static const u16 SW1_table[] = {
-        900, 950, 1000, 1050, 1100, 1150, 1200, 1250,
-        1300, 1350, 1400, 1450, 1500, 1600, 1875, 2250,
+static const unsigned int SW1_table[] = {
+         900000,  950000, 1000000, 1050000, 1100000, 1150000, 1200000, 1250000,
+        1300000, 1350000, 1400000, 1450000, 1500000, 1600000, 1875000, 2250000,
 };
 
 #define SW2_table SW1_table
 
-static const u16 SW3_table[] = {
-        4000, 4500, 5000, 5500,
+static const unsigned int SW3_table[] = {
+        4000000, 4500000, 5000000, 5500000,
 };
 
 struct pcap_regulator {
@@ -100,8 +100,6 @@ struct pcap_regulator {
         const u8 index;
         const u8 stby;
         const u8 lowpwr;
-        const u8 n_voltages;
-        const u16 *voltage_table;
 };
 
 #define NA 0xff
@@ -113,8 +111,6 @@ struct pcap_regulator {
                 .index          = _index,                               \
                 .stby           = _stby,                                \
                 .lowpwr         = _lowpwr,                              \
-                .n_voltages     = ARRAY_SIZE(_vreg##_table),            \
-                .voltage_table  = _vreg##_table,                        \
         }
 
 static struct pcap_regulator vreg_table[] = {
@@ -157,11 +153,11 @@ static int pcap_regulator_set_voltage_sel(struct regulator_dev *rdev,
         void *pcap = rdev_get_drvdata(rdev);
 
         /* the regulator doesn't support voltage switching */
-        if (vreg->n_voltages == 1)
+        if (rdev->desc->n_voltages == 1)
                 return -EINVAL;
 
         return ezx_pcap_set_bits(pcap, vreg->reg,
-                                 (vreg->n_voltages - 1) << vreg->index,
+                                 (rdev->desc->n_voltages - 1) << vreg->index,
                                  selector << vreg->index);
 }
 
@@ -171,11 +167,11 @@ static int pcap_regulator_get_voltage_sel(struct regulator_dev *rdev)
         void *pcap = rdev_get_drvdata(rdev);
         u32 tmp;
 
-        if (vreg->n_voltages == 1)
+        if (rdev->desc->n_voltages == 1)
                 return 0;
 
         ezx_pcap_read(pcap, vreg->reg, &tmp);
-        tmp = ((tmp >> vreg->index) & (vreg->n_voltages - 1));
+        tmp = ((tmp >> vreg->index) & (rdev->desc->n_voltages - 1));
         return tmp;
 }
 
@@ -214,16 +210,8 @@ static int pcap_regulator_is_enabled(struct regulator_dev *rdev)
         return (tmp >> vreg->en) & 1;
 }
 
-static int pcap_regulator_list_voltage(struct regulator_dev *rdev,
-                                                        unsigned int index)
-{
-        struct pcap_regulator *vreg = &vreg_table[rdev_get_id(rdev)];
-
-        return vreg->voltage_table[index] * 1000;
-}
-
 static struct regulator_ops pcap_regulator_ops = {
-        .list_voltage   = pcap_regulator_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
         .set_voltage_sel = pcap_regulator_set_voltage_sel,
         .get_voltage_sel = pcap_regulator_get_voltage_sel,
         .enable         = pcap_regulator_enable,
@@ -236,6 +224,7 @@ static struct regulator_ops pcap_regulator_ops = {
                 .name           = #_vreg,                       \
                 .id             = _vreg,                        \
                 .n_voltages     = ARRAY_SIZE(_vreg##_table),    \
+                .volt_table     = _vreg##_table,                \
                 .ops            = &pcap_regulator_ops,          \
                 .type           = REGULATOR_VOLTAGE,            \
                 .owner          = THIS_MODULE,                  \
diff --git a/drivers/regulator/pcf50633-regulator.c b/drivers/regulator/pcf50633-regulator.c
index 3c9d14c0017b..092e5cb848a1 100644
--- a/drivers/regulator/pcf50633-regulator.c
+++ b/drivers/regulator/pcf50633-regulator.c
@@ -100,13 +100,12 @@ static unsigned int ldo_voltage_value(u8 bits)
         return 900 + (bits * 100);
 }
 
-static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
-                                          int min_uV, int max_uV,
-                                          unsigned *selector)
+static int pcf50633_regulator_map_voltage(struct regulator_dev *rdev,
+                                          int min_uV, int max_uV)
 {
         struct pcf50633 *pcf;
         int regulator_id, millivolts;
-        u8 volt_bits, regnr;
+        u8 volt_bits;
 
         pcf = rdev_get_drvdata(rdev);
 
@@ -116,15 +115,11 @@ static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
 
         millivolts = min_uV / 1000;
 
-        regnr = rdev->desc->vsel_reg;
-
         switch (regulator_id) {
         case PCF50633_REGULATOR_AUTO:
                 volt_bits = auto_voltage_bits(millivolts);
                 break;
         case PCF50633_REGULATOR_DOWN1:
-                volt_bits = down_voltage_bits(millivolts);
-                break;
         case PCF50633_REGULATOR_DOWN2:
                 volt_bits = down_voltage_bits(millivolts);
                 break;
@@ -142,9 +137,7 @@ static int pcf50633_regulator_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
-        *selector = volt_bits;
-
-        return pcf50633_reg_write(pcf, regnr, volt_bits);
+        return volt_bits;
 }
 
 static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
@@ -159,8 +152,6 @@ static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
                 millivolts = auto_voltage_value(index);
                 break;
         case PCF50633_REGULATOR_DOWN1:
-                millivolts = down_voltage_value(index);
-                break;
         case PCF50633_REGULATOR_DOWN2:
                 millivolts = down_voltage_value(index);
                 break;
@@ -182,9 +173,10 @@ static int pcf50633_regulator_list_voltage(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops pcf50633_regulator_ops = {
-        .set_voltage = pcf50633_regulator_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .list_voltage = pcf50633_regulator_list_voltage,
+        .map_voltage = pcf50633_regulator_map_voltage,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
         .is_enabled = regulator_is_enabled_regmap,
diff --git a/drivers/regulator/rc5t583-regulator.c b/drivers/regulator/rc5t583-regulator.c
index 1d34e64a1307..8bf4e8c9de9a 100644
--- a/drivers/regulator/rc5t583-regulator.c
+++ b/drivers/regulator/rc5t583-regulator.c
@@ -42,7 +42,6 @@ struct rc5t583_regulator_info {
 
         /* Regulator specific turn-on delay  and voltage settling time*/
         int                     enable_uv_per_us;
-        int                     change_uv_per_us;
 
         /* Used by regulator core */
         struct regulator_desc   desc;
@@ -66,25 +65,6 @@ static int rc5t583_regulator_enable_time(struct regulator_dev *rdev)
         return DIV_ROUND_UP(curr_uV, reg->reg_info->enable_uv_per_us);
 }
 
-static int rc5t583_set_voltage_time_sel(struct regulator_dev *rdev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        struct rc5t583_regulator *reg = rdev_get_drvdata(rdev);
-        int old_uV, new_uV;
-        old_uV = regulator_list_voltage_linear(rdev, old_selector);
-
-        if (old_uV < 0)
-                return old_uV;
-
-        new_uV = regulator_list_voltage_linear(rdev, new_selector);
-        if (new_uV < 0)
-                return new_uV;
-
-        return DIV_ROUND_UP(abs(old_uV - new_uV),
-                                reg->reg_info->change_uv_per_us);
-}
-
-
 static struct regulator_ops rc5t583_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
@@ -94,7 +74,7 @@ static struct regulator_ops rc5t583_ops = {
         .set_voltage_sel        = regulator_set_voltage_sel_regmap,
         .list_voltage           = regulator_list_voltage_linear,
         .map_voltage            = regulator_map_voltage_linear,
-        .set_voltage_time_sel   = rc5t583_set_voltage_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
 };
 
 #define RC5T583_REG(_id, _en_reg, _en_bit, _disc_reg, _disc_bit, \
@@ -104,7 +84,6 @@ static struct regulator_ops rc5t583_ops = {
         .disc_bit       = _disc_bit,                            \
         .deepsleep_reg  = RC5T583_REG_##_id##DAC_DS,            \
         .enable_uv_per_us = _enable_mv * 1000,                  \
-        .change_uv_per_us = 40 * 1000,                          \
         .deepsleep_id   = RC5T583_DS_##_id,                     \
         .desc = {                                               \
                 .name = "rc5t583-regulator-"#_id,               \
@@ -119,6 +98,7 @@ static struct regulator_ops rc5t583_ops = {
                 .enable_mask = BIT(_en_bit),                    \
                 .min_uV = _min_mv * 1000,                       \
                 .uV_step = _step_uV,                            \
+                .ramp_delay = 40 * 1000,                        \
         },                                                      \
 }
 
diff --git a/drivers/regulator/s2mps11.c b/drivers/regulator/s2mps11.c
new file mode 100644
index 000000000000..4669dc9ac74a
--- /dev/null
+++ b/drivers/regulator/s2mps11.c
@@ -0,0 +1,363 @@
+/*
+ * s2mps11.c
+ *
+ * Copyright (c) 2012 Samsung Electronics Co., Ltd
+ *              http://www.samsung.com
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ */
+
+#include <linux/bug.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/mfd/samsung/core.h>
+#include <linux/mfd/samsung/s2mps11.h>
+
+struct s2mps11_info {
+        struct regulator_dev **rdev;
+
+        int ramp_delay2;
+        int ramp_delay34;
+        int ramp_delay5;
+        int ramp_delay16;
+        int ramp_delay7810;
+        int ramp_delay9;
+
+        bool buck6_ramp;
+        bool buck2_ramp;
+        bool buck3_ramp;
+        bool buck4_ramp;
+};
+
+static int get_ramp_delay(int ramp_delay)
+{
+        unsigned char cnt = 0;
+
+        ramp_delay /= 6;
+
+        while (true) {
+                ramp_delay = ramp_delay >> 1;
+                if (ramp_delay == 0)
+                        break;
+                cnt++;
+        }
+        return cnt;
+}
+
+static struct regulator_ops s2mps11_ldo_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+static struct regulator_ops s2mps11_buck_ops = {
+        .list_voltage           = regulator_list_voltage_linear,
+        .map_voltage            = regulator_map_voltage_linear,
+        .is_enabled             = regulator_is_enabled_regmap,
+        .enable                 = regulator_enable_regmap,
+        .disable                = regulator_disable_regmap,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel        = regulator_set_voltage_sel_regmap,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
+};
+
+#define regulator_desc_ldo1(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS11_LDO##num,             \
+        .ops            = &s2mps11_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS11_LDO_MIN,              \
+        .uV_step        = S2MPS11_LDO_STEP1,            \
+        .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS11_ENABLE_MASK           \
+}
+#define regulator_desc_ldo2(num)        {               \
+        .name           = "LDO"#num,                    \
+        .id             = S2MPS11_LDO##num,             \
+        .ops            = &s2mps11_ldo_ops,             \
+        .type           = REGULATOR_VOLTAGE,            \
+        .owner          = THIS_MODULE,                  \
+        .min_uV         = S2MPS11_LDO_MIN,              \
+        .uV_step        = S2MPS11_LDO_STEP2,            \
+        .n_voltages     = S2MPS11_LDO_N_VOLTAGES,       \
+        .vsel_reg       = S2MPS11_REG_L1CTRL + num - 1, \
+        .vsel_mask      = S2MPS11_LDO_VSEL_MASK,        \
+        .enable_reg     = S2MPS11_REG_L1CTRL + num - 1, \
+        .enable_mask    = S2MPS11_ENABLE_MASK           \
+}
+
+#define regulator_desc_buck1_4(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS11_BUCK##num,                    \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B1CTRL2 + (num - 1) * 2,  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B1CTRL1 + (num - 1) * 2,  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck5    {                               \
+        .name           = "BUCK5",                              \
+        .id             = S2MPS11_BUCK5,                        \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B5CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B5CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck6_8(num)     {                       \
+        .name           = "BUCK"#num,                           \
+        .id             = S2MPS11_BUCK##num,                    \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN1,                    \
+        .uV_step        = S2MPS11_BUCK_STEP1,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B6CTRL2 + (num - 6) * 2,  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B6CTRL1 + (num - 6) * 2,  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck9    {                               \
+        .name           = "BUCK9",                              \
+        .id             = S2MPS11_BUCK9,                        \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN3,                    \
+        .uV_step        = S2MPS11_BUCK_STEP3,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+#define regulator_desc_buck10   {                               \
+        .name           = "BUCK10",                             \
+        .id             = S2MPS11_BUCK10,                       \
+        .ops            = &s2mps11_buck_ops,                    \
+        .type           = REGULATOR_VOLTAGE,                    \
+        .owner          = THIS_MODULE,                          \
+        .min_uV         = S2MPS11_BUCK_MIN2,                    \
+        .uV_step        = S2MPS11_BUCK_STEP2,                   \
+        .n_voltages     = S2MPS11_BUCK_N_VOLTAGES,              \
+        .vsel_reg       = S2MPS11_REG_B9CTRL2,                  \
+        .vsel_mask      = S2MPS11_BUCK_VSEL_MASK,               \
+        .enable_reg     = S2MPS11_REG_B9CTRL1,                  \
+        .enable_mask    = S2MPS11_ENABLE_MASK                   \
+}
+
+static struct regulator_desc regulators[] = {
+        regulator_desc_ldo2(1),
+        regulator_desc_ldo1(2),
+        regulator_desc_ldo1(3),
+        regulator_desc_ldo1(4),
+        regulator_desc_ldo1(5),
+        regulator_desc_ldo2(6),
+        regulator_desc_ldo1(7),
+        regulator_desc_ldo1(8),
+        regulator_desc_ldo1(9),
+        regulator_desc_ldo1(10),
+        regulator_desc_ldo2(11),
+        regulator_desc_ldo1(12),
+        regulator_desc_ldo1(13),
+        regulator_desc_ldo1(14),
+        regulator_desc_ldo1(15),
+        regulator_desc_ldo1(16),
+        regulator_desc_ldo1(17),
+        regulator_desc_ldo1(18),
+        regulator_desc_ldo1(19),
+        regulator_desc_ldo1(20),
+        regulator_desc_ldo1(21),
+        regulator_desc_ldo2(22),
+        regulator_desc_ldo2(23),
+        regulator_desc_ldo1(24),
+        regulator_desc_ldo1(25),
+        regulator_desc_ldo1(26),
+        regulator_desc_ldo2(27),
+        regulator_desc_ldo1(28),
+        regulator_desc_ldo1(29),
+        regulator_desc_ldo1(30),
+        regulator_desc_ldo1(31),
+        regulator_desc_ldo1(32),
+        regulator_desc_ldo1(33),
+        regulator_desc_ldo1(34),
+        regulator_desc_ldo1(35),
+        regulator_desc_ldo1(36),
+        regulator_desc_ldo1(37),
+        regulator_desc_ldo1(38),
+        regulator_desc_buck1_4(1),
+        regulator_desc_buck1_4(2),
+        regulator_desc_buck1_4(3),
+        regulator_desc_buck1_4(4),
+        regulator_desc_buck5,
+        regulator_desc_buck6_8(6),
+        regulator_desc_buck6_8(7),
+        regulator_desc_buck6_8(8),
+        regulator_desc_buck9,
+        regulator_desc_buck10,
+};
+
+static __devinit int s2mps11_pmic_probe(struct platform_device *pdev)
+{
+        struct sec_pmic_dev *iodev = dev_get_drvdata(pdev->dev.parent);
+        struct sec_platform_data *pdata = dev_get_platdata(iodev->dev);
+        struct regulator_config config = { };
+        struct regulator_dev **rdev;
+        struct s2mps11_info *s2mps11;
+        int i, ret, size;
+        unsigned char ramp_enable, ramp_reg = 0;
+
+        if (!pdata) {
+                dev_err(pdev->dev.parent, "Platform data not supplied\n");
+                return -ENODEV;
+        }
+
+        s2mps11 = devm_kzalloc(&pdev->dev, sizeof(struct s2mps11_info),
+                                GFP_KERNEL);
+        if (!s2mps11)
+                return -ENOMEM;
+
+        size = sizeof(struct regulator_dev *) * S2MPS11_REGULATOR_MAX;
+        s2mps11->rdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
+        if (!s2mps11->rdev) {
+                return -ENOMEM;
+        }
+
+        rdev = s2mps11->rdev;
+        platform_set_drvdata(pdev, s2mps11);
+
+        s2mps11->ramp_delay2 = pdata->buck2_ramp_delay;
+        s2mps11->ramp_delay34 = pdata->buck34_ramp_delay;
+        s2mps11->ramp_delay5 = pdata->buck5_ramp_delay;
+        s2mps11->ramp_delay16 = pdata->buck16_ramp_delay;
+        s2mps11->ramp_delay7810 = pdata->buck7810_ramp_delay;
+        s2mps11->ramp_delay9 = pdata->buck9_ramp_delay;
+
+        s2mps11->buck6_ramp = pdata->buck6_ramp_enable;
+        s2mps11->buck2_ramp = pdata->buck2_ramp_enable;
+        s2mps11->buck3_ramp = pdata->buck3_ramp_enable;
+        s2mps11->buck4_ramp = pdata->buck4_ramp_enable;
+
+        ramp_enable = (s2mps11->buck2_ramp << 3) | (s2mps11->buck3_ramp << 2) |
+                (s2mps11->buck4_ramp << 1) | s2mps11->buck6_ramp ;
+
+        if (ramp_enable) {
+                if (s2mps11->buck2_ramp)
+                        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay2) >> 6;
+                if (s2mps11->buck3_ramp || s2mps11->buck4_ramp)
+                        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay34) >> 4;
+                sec_reg_write(iodev, S2MPS11_REG_RAMP, ramp_reg | ramp_enable);
+        }
+
+        ramp_reg &= 0x00;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay5) >> 6;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay16) >> 4;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay7810) >> 2;
+        ramp_reg |= get_ramp_delay(s2mps11->ramp_delay9);
+        sec_reg_write(iodev, S2MPS11_REG_RAMP_BUCK, ramp_reg);
+
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++) {
+
+                config.dev = &pdev->dev;
+                config.regmap = iodev->regmap;
+                config.init_data = pdata->regulators[i].initdata;
+                config.driver_data = s2mps11;
+
+                rdev[i] = regulator_register(&regulators[i], &config);
+                if (IS_ERR(rdev[i])) {
+                        ret = PTR_ERR(rdev[i]);
+                        dev_err(&pdev->dev, "regulator init failed for %d\n",
+                                i);
+                        rdev[i] = NULL;
+                        goto err;
+                }
+        }
+
+        return 0;
+err:
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return ret;
+}
+
+static int __devexit s2mps11_pmic_remove(struct platform_device *pdev)
+{
+        struct s2mps11_info *s2mps11 = platform_get_drvdata(pdev);
+        struct regulator_dev **rdev = s2mps11->rdev;
+        int i;
+
+        for (i = 0; i < S2MPS11_REGULATOR_MAX; i++)
+                if (rdev[i])
+                        regulator_unregister(rdev[i]);
+
+        return 0;
+}
+
+static const struct platform_device_id s2mps11_pmic_id[] = {
+        { "s2mps11-pmic", 0},
+        { },
+};
+MODULE_DEVICE_TABLE(platform, s2mps11_pmic_id);
+
+static struct platform_driver s2mps11_pmic_driver = {
+        .driver = {
+                .name = "s2mps11-pmic",
+                .owner = THIS_MODULE,
+        },
+        .probe = s2mps11_pmic_probe,
+        .remove = __devexit_p(s2mps11_pmic_remove),
+        .id_table = s2mps11_pmic_id,
+};
+
+static int __init s2mps11_pmic_init(void)
+{
+        return platform_driver_register(&s2mps11_pmic_driver);
+}
+subsys_initcall(s2mps11_pmic_init);
+
+static void __exit s2mps11_pmic_exit(void)
+{
+        platform_driver_unregister(&s2mps11_pmic_driver);
+}
+module_exit(s2mps11_pmic_exit);
+
+/* Module information */
+MODULE_AUTHOR("Sangbeom Kim <sbkim73@samsung.com>");
+MODULE_DESCRIPTION("SAMSUNG S2MPS11 Regulator Driver");
+MODULE_LICENSE("GPL");
diff --git a/drivers/regulator/s5m8767.c b/drivers/regulator/s5m8767.c
index 9caadb482178..102287fa7ecb 100644
--- a/drivers/regulator/s5m8767.c
+++ b/drivers/regulator/s5m8767.c
@@ -41,6 +41,7 @@ struct s5m8767_info {
         u8 buck3_vol[8];
         u8 buck4_vol[8];
         int buck_gpios[3];
+        int buck_ds[3];
         int buck_gpioindex;
 };
 
@@ -120,27 +121,6 @@ static const struct s5m_voltage_desc *reg_voltage_map[] = {
         [S5M8767_BUCK9] = &buck_voltage_val3,
 };
 
-static int s5m8767_list_voltage(struct regulator_dev *rdev,
-                                unsigned int selector)
-{
-        const struct s5m_voltage_desc *desc;
-        int reg_id = rdev_get_id(rdev);
-        int val;
-
-        if (reg_id >= ARRAY_SIZE(reg_voltage_map) || reg_id < 0)
-                return -EINVAL;
-
-        desc = reg_voltage_map[reg_id];
-        if (desc == NULL)
-                return -EINVAL;
-
-        val = desc->min + desc->step * selector;
-        if (val > desc->max)
-                return -EINVAL;
-
-        return val;
-}
-
 static unsigned int s5m8767_opmode_reg[][4] = {
         /* {OFF, ON, LOWPOWER, SUSPEND} */
         /* LDO1 ... LDO28 */
@@ -283,17 +263,17 @@ static int s5m8767_get_voltage_register(struct regulator_dev *rdev, int *_reg)
                 reg = S5M8767_REG_BUCK1CTRL2;
                 break;
         case S5M8767_BUCK2:
-                reg = S5M8767_REG_BUCK2DVS1;
+                reg = S5M8767_REG_BUCK2DVS2;
                 if (s5m8767->buck2_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
         case S5M8767_BUCK3:
-                reg = S5M8767_REG_BUCK3DVS1;
+                reg = S5M8767_REG_BUCK3DVS2;
                 if (s5m8767->buck3_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
         case S5M8767_BUCK4:
-                reg = S5M8767_REG_BUCK4DVS1;
+                reg = S5M8767_REG_BUCK4DVS2;
                 if (s5m8767->buck4_gpiodvs)
                         reg += s5m8767->buck_gpioindex;
                 break;
@@ -357,32 +337,34 @@ static int s5m8767_convert_voltage_to_sel(
         return selector;
 }
 
-static inline void s5m8767_set_high(struct s5m8767_info *s5m8767)
+static inline int s5m8767_set_high(struct s5m8767_info *s5m8767)
 {
         int temp_index = s5m8767->buck_gpioindex;
 
         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
+
+        return 0;
 }
 
-static inline void s5m8767_set_low(struct s5m8767_info *s5m8767)
+static inline int s5m8767_set_low(struct s5m8767_info *s5m8767)
 {
         int temp_index = s5m8767->buck_gpioindex;
 
         gpio_set_value(s5m8767->buck_gpios[2], temp_index & 0x1);
         gpio_set_value(s5m8767->buck_gpios[1], (temp_index >> 1) & 0x1);
         gpio_set_value(s5m8767->buck_gpios[0], (temp_index >> 2) & 0x1);
+
+        return 0;
 }
 
-static int s5m8767_set_voltage(struct regulator_dev *rdev,
-                                int min_uV, int max_uV, unsigned *selector)
+static int s5m8767_set_voltage_sel(struct regulator_dev *rdev,
+                                   unsigned selector)
 {
         struct s5m8767_info *s5m8767 = rdev_get_drvdata(rdev);
-        const struct s5m_voltage_desc *desc;
         int reg_id = rdev_get_id(rdev);
-        int sel, reg, mask, ret = 0, old_index, index = 0;
-        u8 val;
+        int reg, mask, ret = 0, old_index, index = 0;
         u8 *buck234_vol = NULL;
 
         switch (reg_id) {
@@ -407,15 +389,9 @@ static int s5m8767_set_voltage(struct regulator_dev *rdev,
                 return -EINVAL;
         }
 
-        desc = reg_voltage_map[reg_id];
-
-        sel = s5m8767_convert_voltage_to_sel(desc, min_uV, max_uV);
-        if (sel < 0)
-                return sel;
-
         /* buck234_vol != NULL means to control buck234 voltage via DVS GPIO */
         if (buck234_vol) {
-                while (*buck234_vol != sel) {
+                while (*buck234_vol != selector) {
                         buck234_vol++;
                         index++;
                 }
@@ -423,22 +399,16 @@ static int s5m8767_set_voltage(struct regulator_dev *rdev,
                 s5m8767->buck_gpioindex = index;
 
                 if (index > old_index)
-                        s5m8767_set_high(s5m8767);
+                        return s5m8767_set_high(s5m8767);
                 else
-                        s5m8767_set_low(s5m8767);
+                        return s5m8767_set_low(s5m8767);
         } else {
                 ret = s5m8767_get_voltage_register(rdev, &reg);
                 if (ret)
                         return ret;
 
-                s5m_reg_read(s5m8767->iodev, reg, &val);
-                val = (val & ~mask) | sel;
-
-                ret = s5m_reg_write(s5m8767->iodev, reg, val);
+                return s5m_reg_update(s5m8767->iodev, reg, selector, mask);
         }
-
-        *selector = sel;
-        return ret;
 }
 
 static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
@@ -458,15 +428,21 @@ static int s5m8767_set_voltage_time_sel(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops s5m8767_ops = {
-        .list_voltage           = s5m8767_list_voltage,
+        .list_voltage           = regulator_list_voltage_linear,
         .is_enabled             = s5m8767_reg_is_enabled,
         .enable                 = s5m8767_reg_enable,
         .disable                = s5m8767_reg_disable,
         .get_voltage_sel        = s5m8767_get_voltage_sel,
-        .set_voltage            = s5m8767_set_voltage,
+        .set_voltage_sel        = s5m8767_set_voltage_sel,
         .set_voltage_time_sel   = s5m8767_set_voltage_time_sel,
 };
 
+static struct regulator_ops s5m8767_buck78_ops = {
+        .is_enabled             = s5m8767_reg_is_enabled,
+        .enable                 = s5m8767_reg_enable,
+        .disable                = s5m8767_reg_disable,
+};
+
 #define s5m8767_regulator_desc(_name) {         \
         .name           = #_name,               \
         .id             = S5M8767_##_name,      \
@@ -475,6 +451,14 @@ static struct regulator_ops s5m8767_ops = {
         .owner          = THIS_MODULE,          \
 }
 
+#define s5m8767_regulator_buck78_desc(_name) {  \
+        .name           = #_name,               \
+        .id             = S5M8767_##_name,      \
+        .ops            = &s5m8767_buck78_ops,  \
+        .type           = REGULATOR_VOLTAGE,    \
+        .owner          = THIS_MODULE,          \
+}
+
 static struct regulator_desc regulators[] = {
         s5m8767_regulator_desc(LDO1),
         s5m8767_regulator_desc(LDO2),
@@ -510,8 +494,8 @@ static struct regulator_desc regulators[] = {
         s5m8767_regulator_desc(BUCK4),
         s5m8767_regulator_desc(BUCK5),
         s5m8767_regulator_desc(BUCK6),
-        s5m8767_regulator_desc(BUCK7),
-        s5m8767_regulator_desc(BUCK8),
+        s5m8767_regulator_buck78_desc(BUCK7),
+        s5m8767_regulator_buck78_desc(BUCK8),
         s5m8767_regulator_desc(BUCK9),
 };
 
@@ -522,7 +506,7 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         struct regulator_config config = { };
         struct regulator_dev **rdev;
         struct s5m8767_info *s5m8767;
-        int i, ret, size;
+        int i, ret, size, buck_init;
 
         if (!pdata) {
                 dev_err(pdev->dev.parent, "Platform data not supplied\n");
@@ -573,12 +557,37 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         s5m8767->buck_gpios[0] = pdata->buck_gpios[0];
         s5m8767->buck_gpios[1] = pdata->buck_gpios[1];
         s5m8767->buck_gpios[2] = pdata->buck_gpios[2];
+        s5m8767->buck_ds[0] = pdata->buck_ds[0];
+        s5m8767->buck_ds[1] = pdata->buck_ds[1];
+        s5m8767->buck_ds[2] = pdata->buck_ds[2];
+
         s5m8767->ramp_delay = pdata->buck_ramp_delay;
         s5m8767->buck2_ramp = pdata->buck2_ramp_enable;
         s5m8767->buck3_ramp = pdata->buck3_ramp_enable;
         s5m8767->buck4_ramp = pdata->buck4_ramp_enable;
         s5m8767->opmode = pdata->opmode;
 
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck2_init,
+                                                pdata->buck2_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK2DVS2, buck_init);
+
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck3_init,
+                                                pdata->buck3_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK3DVS2, buck_init);
+
+        buck_init = s5m8767_convert_voltage_to_sel(&buck_voltage_val2,
+                                                pdata->buck4_init,
+                                                pdata->buck4_init +
+                                                buck_voltage_val2.step);
+
+        s5m_reg_write(s5m8767->iodev, S5M8767_REG_BUCK4DVS2, buck_init);
+
         for (i = 0; i < 8; i++) {
                 if (s5m8767->buck2_gpiodvs) {
                         s5m8767->buck2_vol[i] =
@@ -608,48 +617,70 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                 }
         }
 
-        if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
-                pdata->buck4_gpiodvs) {
-                if (gpio_is_valid(pdata->buck_gpios[0]) &&
-                        gpio_is_valid(pdata->buck_gpios[1]) &&
-                        gpio_is_valid(pdata->buck_gpios[2])) {
-                        ret = gpio_request(pdata->buck_gpios[0],
-                                                "S5M8767 SET1");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET1\n");
-
-                        ret = gpio_request(pdata->buck_gpios[1],
-                                           "S5M8767 SET2");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET2\n");
-
-                        ret = gpio_request(pdata->buck_gpios[2],
-                                           "S5M8767 SET3");
-                        if (ret == -EBUSY)
-                                dev_warn(&pdev->dev, "Duplicated gpio request for SET3\n");
-                        /* SET1 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[0],
-                                        (s5m8767->buck_gpioindex >> 2) & 0x1);
-                        /* SET2 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[1],
-                                        (s5m8767->buck_gpioindex >> 1) & 0x1);
-                        /* SET3 GPIO */
-                        gpio_direction_output(pdata->buck_gpios[2],
-                                        (s5m8767->buck_gpioindex >> 0) & 0x1);
-                        ret = 0;
-                } else {
-                        dev_err(&pdev->dev, "GPIO NOT VALID\n");
-                        ret = -EINVAL;
+        if (gpio_is_valid(pdata->buck_gpios[0]) &&
+                gpio_is_valid(pdata->buck_gpios[1]) &&
+                gpio_is_valid(pdata->buck_gpios[2])) {
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[0],
+                                        "S5M8767 SET1");
+                if (ret)
                         return ret;
-                }
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[1],
+                                        "S5M8767 SET2");
+                if (ret)
+                        return ret;
+
+                ret = devm_gpio_request(&pdev->dev, pdata->buck_gpios[2],
+                                        "S5M8767 SET3");
+                if (ret)
+                        return ret;
+
+                /* SET1 GPIO */
+                gpio_direction_output(pdata->buck_gpios[0],
+                                (s5m8767->buck_gpioindex >> 2) & 0x1);
+                /* SET2 GPIO */
+                gpio_direction_output(pdata->buck_gpios[1],
+                                (s5m8767->buck_gpioindex >> 1) & 0x1);
+                /* SET3 GPIO */
+                gpio_direction_output(pdata->buck_gpios[2],
+                                (s5m8767->buck_gpioindex >> 0) & 0x1);
+        } else {
+                dev_err(&pdev->dev, "GPIO NOT VALID\n");
+                ret = -EINVAL;
+                return ret;
         }
 
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
-                        (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
-                        (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
-                        (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1), 1 << 1);
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[0], "S5M8767 DS2");
+        if (ret)
+                return ret;
+
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[1], "S5M8767 DS3");
+        if (ret)
+                return ret;
+
+        ret = devm_gpio_request(&pdev->dev, pdata->buck_ds[2], "S5M8767 DS4");
+        if (ret)
+                return ret;
+
+        /* DS2 GPIO */
+        gpio_direction_output(pdata->buck_ds[0], 0x0);
+        /* DS3 GPIO */
+        gpio_direction_output(pdata->buck_ds[1], 0x0);
+        /* DS4 GPIO */
+        gpio_direction_output(pdata->buck_ds[2], 0x0);
+
+        if (pdata->buck2_gpiodvs || pdata->buck3_gpiodvs ||
+           pdata->buck4_gpiodvs) {
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL,
+                                (pdata->buck2_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL,
+                                (pdata->buck3_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+                s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL,
+                                (pdata->buck4_gpiodvs) ? (1 << 1) : (0 << 1),
+                                1 << 1);
+        }
 
         /* Initialize GPIO DVS registers */
         for (i = 0; i < 8; i++) {
@@ -668,9 +699,6 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                                            s5m8767->buck4_vol[i]);
                 }
         }
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK2CTRL, 0x78, 0xff);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK3CTRL, 0x58, 0xff);
-        s5m_reg_update(s5m8767->iodev, S5M8767_REG_BUCK4CTRL, 0x78, 0xff);
 
         if (s5m8767->buck2_ramp)
                 s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP, 0x08, 0x08);
@@ -684,9 +712,13 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
         if (s5m8767->buck2_ramp || s5m8767->buck3_ramp
                 || s5m8767->buck4_ramp) {
                 switch (s5m8767->ramp_delay) {
-                case 15:
+                case 5:
                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
-                                        0xc0, 0xf0);
+                                        0x40, 0xf0);
+                        break;
+                case 10:
+                        s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
+                                        0x90, 0xf0);
                         break;
                 case 25:
                         s5m_reg_update(s5m8767->iodev, S5M8767_REG_DVSRAMP,
@@ -711,9 +743,12 @@ static __devinit int s5m8767_pmic_probe(struct platform_device *pdev)
                 int id = pdata->regulators[i].id;
 
                 desc = reg_voltage_map[id];
-                if (desc)
+                if (desc) {
                         regulators[id].n_voltages =
                                 (desc->max - desc->min) / desc->step + 1;
+                        regulators[id].min_uV = desc->min;
+                        regulators[id].uV_step = desc->step;
+                }
 
                 config.dev = s5m8767->dev;
                 config.init_data = pdata->regulators[i].initdata;
diff --git a/drivers/regulator/tps6105x-regulator.c b/drivers/regulator/tps6105x-regulator.c
index d840d8440a91..1378409efaec 100644
--- a/drivers/regulator/tps6105x-regulator.c
+++ b/drivers/regulator/tps6105x-regulator.c
@@ -20,7 +20,7 @@
 #include <linux/mfd/core.h>
 #include <linux/mfd/tps6105x.h>
 
-static const int tps6105x_voltages[] = {
+static const unsigned int tps6105x_voltages[] = {
         4500000,
         5000000,
         5250000,
@@ -105,22 +105,13 @@ static int tps6105x_regulator_set_voltage_sel(struct regulator_dev *rdev,
         return 0;
 }
 
-static int tps6105x_regulator_list_voltage(struct regulator_dev *rdev,
-                                           unsigned selector)
-{
-        if (selector >= ARRAY_SIZE(tps6105x_voltages))
-                return -EINVAL;
-
-        return tps6105x_voltages[selector];
-}
-
 static struct regulator_ops tps6105x_regulator_ops = {
         .enable         = tps6105x_regulator_enable,
         .disable        = tps6105x_regulator_disable,
         .is_enabled     = tps6105x_regulator_is_enabled,
         .get_voltage_sel = tps6105x_regulator_get_voltage_sel,
         .set_voltage_sel = tps6105x_regulator_set_voltage_sel,
-        .list_voltage   = tps6105x_regulator_list_voltage,
+        .list_voltage   = regulator_list_voltage_table,
 };
 
 static const struct regulator_desc tps6105x_regulator_desc = {
@@ -130,6 +121,7 @@ static const struct regulator_desc tps6105x_regulator_desc = {
         .id             = 0,
         .owner          = THIS_MODULE,
         .n_voltages     = ARRAY_SIZE(tps6105x_voltages),
+        .volt_table     = tps6105x_voltages,
 };
 
 /*
diff --git a/drivers/regulator/tps62360-regulator.c b/drivers/regulator/tps62360-regulator.c
index e534269ed44a..68729a7c8709 100644
--- a/drivers/regulator/tps62360-regulator.c
+++ b/drivers/regulator/tps62360-regulator.c
@@ -65,10 +65,8 @@ struct tps62360_chip {
         struct regulator_desc desc;
         struct regulator_dev *rdev;
         struct regmap *regmap;
-        int chip_id;
         int vsel0_gpio;
         int vsel1_gpio;
-        int voltage_base;
         u8 voltage_reg_mask;
         bool en_internal_pulldn;
         bool en_discharge;
@@ -76,7 +74,6 @@ struct tps62360_chip {
         int lru_index[4];
         int curr_vset_vsel[4];
         int curr_vset_id;
-        int change_uv_per_us;
 };
 
 /*
@@ -175,23 +172,6 @@ static int tps62360_dcdc_set_voltage_sel(struct regulator_dev *dev,
         return 0;
 }
 
-static int tps62360_set_voltage_time_sel(struct regulator_dev *rdev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        struct tps62360_chip *tps = rdev_get_drvdata(rdev);
-        int old_uV, new_uV;
-
-        old_uV = regulator_list_voltage_linear(rdev, old_selector);
-        if (old_uV < 0)
-                return old_uV;
-
-        new_uV = regulator_list_voltage_linear(rdev, new_selector);
-        if (new_uV < 0)
-                return new_uV;
-
-        return DIV_ROUND_UP(abs(old_uV - new_uV), tps->change_uv_per_us);
-}
-
 static int tps62360_set_mode(struct regulator_dev *rdev, unsigned int mode)
 {
         struct tps62360_chip *tps = rdev_get_drvdata(rdev);
@@ -258,7 +238,7 @@ static struct regulator_ops tps62360_dcdc_ops = {
         .set_voltage_sel        = tps62360_dcdc_set_voltage_sel,
         .list_voltage           = regulator_list_voltage_linear,
         .map_voltage            = regulator_map_voltage_linear,
-        .set_voltage_time_sel   = tps62360_set_voltage_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .set_mode               = tps62360_set_mode,
         .get_mode               = tps62360_get_mode,
 };
@@ -301,7 +281,7 @@ static int __devinit tps62360_init_dcdc(struct tps62360_chip *tps,
         ramp_ctrl = (ramp_ctrl >> 4) & 0x7;
 
         /* ramp mV/us = 32/(2^ramp_ctrl) */
-        tps->change_uv_per_us = DIV_ROUND_UP(32000, BIT(ramp_ctrl));
+        tps->desc.ramp_delay = DIV_ROUND_UP(32000, BIT(ramp_ctrl));
         return ret;
 }
 
@@ -408,13 +388,13 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         switch (chip_id) {
         case TPS62360:
         case TPS62362:
-                tps->voltage_base = TPS62360_BASE_VOLTAGE;
+                tps->desc.min_uV = TPS62360_BASE_VOLTAGE;
                 tps->voltage_reg_mask = 0x3F;
                 tps->desc.n_voltages = TPS62360_N_VOLTAGES;
                 break;
         case TPS62361:
         case TPS62363:
-                tps->voltage_base = TPS62361_BASE_VOLTAGE;
+                tps->desc.min_uV = TPS62361_BASE_VOLTAGE;
                 tps->voltage_reg_mask = 0x7F;
                 tps->desc.n_voltages = TPS62361_N_VOLTAGES;
                 break;
@@ -427,7 +407,6 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         tps->desc.ops = &tps62360_dcdc_ops;
         tps->desc.type = REGULATOR_VOLTAGE;
         tps->desc.owner = THIS_MODULE;
-        tps->desc.min_uV = tps->voltage_base;
         tps->desc.uV_step = 10000;
 
         tps->regmap = devm_regmap_init_i2c(client, &tps62360_regmap_config);
@@ -449,24 +428,24 @@ static int __devinit tps62360_probe(struct i2c_client *client,
                 int gpio_flags;
                 gpio_flags = (pdata->vsel0_def_state) ?
                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-                ret = gpio_request_one(tps->vsel0_gpio,
+                ret = devm_gpio_request_one(&client->dev, tps->vsel0_gpio,
                                 gpio_flags, "tps62360-vsel0");
                 if (ret) {
                         dev_err(&client->dev,
                                 "%s(): Could not obtain vsel0 GPIO %d: %d\n",
                                 __func__, tps->vsel0_gpio, ret);
-                        goto err_gpio0;
+                        return ret;
                 }
 
                 gpio_flags = (pdata->vsel1_def_state) ?
                                 GPIOF_OUT_INIT_HIGH : GPIOF_OUT_INIT_LOW;
-                ret = gpio_request_one(tps->vsel1_gpio,
+                ret = devm_gpio_request_one(&client->dev, tps->vsel1_gpio,
                                 gpio_flags, "tps62360-vsel1");
                 if (ret) {
                         dev_err(&client->dev,
                                 "%s(): Could not obtain vsel1 GPIO %d: %d\n",
                                 __func__, tps->vsel1_gpio, ret);
-                        goto err_gpio1;
+                        return ret;
                 }
                 tps->valid_gpios = true;
 
@@ -484,7 +463,7 @@ static int __devinit tps62360_probe(struct i2c_client *client,
         if (ret < 0) {
                 dev_err(tps->dev, "%s(): Init failed with err = %d\n",
                                 __func__, ret);
-                goto err_init;
+                return ret;
         }
 
         config.dev = &client->dev;
@@ -498,21 +477,11 @@ static int __devinit tps62360_probe(struct i2c_client *client,
                 dev_err(tps->dev,
                         "%s(): regulator register failed with err %s\n",
                         __func__, id->name);
-                ret = PTR_ERR(rdev);
-                goto err_init;
+                return PTR_ERR(rdev);
         }
 
         tps->rdev = rdev;
         return 0;
-
-err_init:
-        if (gpio_is_valid(tps->vsel1_gpio))
-                gpio_free(tps->vsel1_gpio);
-err_gpio1:
-        if (gpio_is_valid(tps->vsel0_gpio))
-                gpio_free(tps->vsel0_gpio);
-err_gpio0:
-        return ret;
 }
 
 /**
@@ -525,12 +494,6 @@ static int __devexit tps62360_remove(struct i2c_client *client)
 {
         struct tps62360_chip *tps = i2c_get_clientdata(client);
 
-        if (gpio_is_valid(tps->vsel1_gpio))
-                gpio_free(tps->vsel1_gpio);
-
-        if (gpio_is_valid(tps->vsel0_gpio))
-                gpio_free(tps->vsel0_gpio);
-
         regulator_unregister(tps->rdev);
         return 0;
 }
diff --git a/drivers/regulator/tps65023-regulator.c b/drivers/regulator/tps65023-regulator.c
index 8f1be8586c72..6998d579d07b 100644
--- a/drivers/regulator/tps65023-regulator.c
+++ b/drivers/regulator/tps65023-regulator.c
@@ -69,10 +69,6 @@
 #define TPS65023_REG_CTRL2_DCDC1        BIT(1)
 #define TPS65023_REG_CTRL2_DCDC3        BIT(0)
 
-/* LDO_CTRL bitfields */
-#define TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_id)    ((ldo_id)*4)
-#define TPS65023_LDO_CTRL_LDOx_MASK(ldo_id)     (0x07 << ((ldo_id)*4))
-
 /* Number of step-down converters available */
 #define TPS65023_NUM_DCDC               3
 /* Number of LDO voltage regulators  available */
@@ -91,48 +87,53 @@
 #define TPS65023_MAX_REG_ID             TPS65023_LDO_2
 
 /* Supported voltage values for regulators */
-static const u16 VCORE_VSEL_table[] = {
-        800, 825, 850, 875,
-        900, 925, 950, 975,
-        1000, 1025, 1050, 1075,
-        1100, 1125, 1150, 1175,
-        1200, 1225, 1250, 1275,
-        1300, 1325, 1350, 1375,
-        1400, 1425, 1450, 1475,
-        1500, 1525, 1550, 1600,
+static const unsigned int VCORE_VSEL_table[] = {
+        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, 1600000,
+};
+
+static const unsigned int DCDC_FIXED_3300000_VSEL_table[] = {
+        3300000,
+};
+
+static const unsigned int DCDC_FIXED_1800000_VSEL_table[] = {
+        1800000,
 };
 
 /* Supported voltage values for LDO regulators for tps65020 */
-static const u16 TPS65020_LDO1_VSEL_table[] = {
-        1000, 1050, 1100, 1300,
-        1800, 2500, 3000, 3300,
+static const unsigned int TPS65020_LDO1_VSEL_table[] = {
+        1000000, 1050000, 1100000, 1300000,
+        1800000, 2500000, 3000000, 3300000,
 };
 
-static const u16 TPS65020_LDO2_VSEL_table[] = {
-        1000, 1050, 1100, 1300,
-        1800, 2500, 3000, 3300,
+static const unsigned int TPS65020_LDO2_VSEL_table[] = {
+        1000000, 1050000, 1100000, 1300000,
+        1800000, 2500000, 3000000, 3300000,
 };
 
 /* Supported voltage values for LDO regulators
  * for tps65021 and tps65023 */
-static const u16 TPS65023_LDO1_VSEL_table[] = {
-        1000, 1100, 1300, 1800,
-        2200, 2600, 2800, 3150,
+static const unsigned int TPS65023_LDO1_VSEL_table[] = {
+        1000000, 1100000, 1300000, 1800000,
+        2200000, 2600000, 2800000, 3150000,
 };
 
-static const u16 TPS65023_LDO2_VSEL_table[] = {
-        1050, 1200, 1300, 1800,
-        2500, 2800, 3000, 3300,
+static const unsigned int TPS65023_LDO2_VSEL_table[] = {
+        1050000, 1200000, 1300000, 1800000,
+        2500000, 2800000, 3000000, 3300000,
 };
 
 /* Regulator specific details */
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
-        bool fixed;
         u8 table_len;
-        const u16 *table;
+        const unsigned int *table;
 };
 
 /* PMIC details */
@@ -150,7 +151,7 @@ struct tps_driver_data {
         u8 core_regulator;
 };
 
-static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
+static int tps65023_dcdc_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps_pmic *tps = rdev_get_drvdata(dev);
         int ret;
@@ -164,9 +165,9 @@ static int tps65023_dcdc_get_voltage(struct regulator_dev *dev)
                 if (ret != 0)
                         return ret;
                 data &= (tps->info[dcdc]->table_len - 1);
-                return tps->info[dcdc]->table[data] * 1000;
+                return data;
         } else
-                return tps->info[dcdc]->min_uV;
+                return 0;
 }
 
 static int tps65023_dcdc_set_voltage_sel(struct regulator_dev *dev,
@@ -193,76 +194,14 @@ out:
         return ret;
 }
 
-static int tps65023_ldo_get_voltage(struct regulator_dev *dev)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int data, ldo = rdev_get_id(dev);
-        int ret;
-
-        if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
-                return -EINVAL;
-
-        ret = regmap_read(tps->regmap, TPS65023_REG_LDO_CTRL, &data);
-        if (ret != 0)
-                return ret;
-
-        data >>= (TPS65023_LDO_CTRL_LDOx_SHIFT(ldo - TPS65023_LDO_1));
-        data &= (tps->info[ldo]->table_len - 1);
-        return tps->info[ldo]->table[data] * 1000;
-}
-
-static int tps65023_ldo_set_voltage_sel(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int ldo_index = rdev_get_id(dev) - TPS65023_LDO_1;
-
-        return regmap_update_bits(tps->regmap, TPS65023_REG_LDO_CTRL,
-                        TPS65023_LDO_CTRL_LDOx_MASK(ldo_index),
-                        selector << TPS65023_LDO_CTRL_LDOx_SHIFT(ldo_index));
-}
-
-static int tps65023_dcdc_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int dcdc = rdev_get_id(dev);
-
-        if (dcdc < TPS65023_DCDC_1 || dcdc > TPS65023_DCDC_3)
-                return -EINVAL;
-
-        if (dcdc == tps->core_regulator) {
-                if (selector >= tps->info[dcdc]->table_len)
-                        return -EINVAL;
-                else
-                        return tps->info[dcdc]->table[selector] * 1000;
-        } else
-                return tps->info[dcdc]->min_uV;
-}
-
-static int tps65023_ldo_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps_pmic *tps = rdev_get_drvdata(dev);
-        int ldo = rdev_get_id(dev);
-
-        if (ldo < TPS65023_LDO_1 || ldo > TPS65023_LDO_2)
-                return -EINVAL;
-
-        if (selector >= tps->info[ldo]->table_len)
-                return -EINVAL;
-        else
-                return tps->info[ldo]->table[selector] * 1000;
-}
-
 /* Operations permitted on VDCDCx */
 static struct regulator_ops tps65023_dcdc_ops = {
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
-        .get_voltage = tps65023_dcdc_get_voltage,
+        .get_voltage_sel = tps65023_dcdc_get_voltage_sel,
         .set_voltage_sel = tps65023_dcdc_set_voltage_sel,
-        .list_voltage = tps65023_dcdc_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 /* Operations permitted on LDOx */
@@ -270,9 +209,9 @@ static struct regulator_ops tps65023_ldo_ops = {
         .is_enabled = regulator_is_enabled_regmap,
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
-        .get_voltage = tps65023_ldo_get_voltage,
-        .set_voltage_sel = tps65023_ldo_set_voltage_sel,
-        .list_voltage = tps65023_ldo_list_voltage,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static struct regmap_config tps65023_regmap_config = {
@@ -325,19 +264,28 @@ static int __devinit tps_65023_probe(struct i2c_client *client,
                 tps->desc[i].name = info->name;
                 tps->desc[i].id = i;
                 tps->desc[i].n_voltages = info->table_len;
+                tps->desc[i].volt_table = info->table;
                 tps->desc[i].ops = (i > TPS65023_DCDC_3 ?
                                         &tps65023_ldo_ops : &tps65023_dcdc_ops);
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
 
                 tps->desc[i].enable_reg = TPS65023_REG_REG_CTRL;
-                if (i == TPS65023_LDO_1)
+                switch (i) {
+                case TPS65023_LDO_1:
+                        tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
+                        tps->desc[i].vsel_mask = 0x07;
                         tps->desc[i].enable_mask = 1 << 1;
-                else if (i == TPS65023_LDO_2)
+                        break;
+                case TPS65023_LDO_2:
+                        tps->desc[i].vsel_reg = TPS65023_REG_LDO_CTRL;
+                        tps->desc[i].vsel_mask = 0x70;
                         tps->desc[i].enable_mask = 1 << 2;
-                else /* DCDCx */
+                        break;
+                default: /* DCDCx */
                         tps->desc[i].enable_mask =
                                         1 << (TPS65023_NUM_REGULATOR - i);
+                }
 
                 config.dev = &client->dev;
                 config.init_data = init_data;
@@ -384,35 +332,26 @@ static int __devexit tps_65023_remove(struct i2c_client *client)
 static const struct tps_info tps65020_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV = 3300000,
-                .max_uV = 3300000,
-                .fixed  = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
-
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65020_LDO1_VSEL_table),
                 .table = TPS65020_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65020_LDO2_VSEL_table),
                 .table = TPS65020_LDO2_VSEL_table,
         },
@@ -421,34 +360,26 @@ static const struct tps_info tps65020_regs[] = {
 static const struct tps_info tps65021_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV =  3300000,
-                .max_uV = 3300000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
                 .table = TPS65023_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
                 .table = TPS65023_LDO2_VSEL_table,
         },
@@ -457,34 +388,26 @@ static const struct tps_info tps65021_regs[] = {
 static const struct tps_info tps65023_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV =  800000,
-                .max_uV = 1600000,
                 .table_len = ARRAY_SIZE(VCORE_VSEL_table),
                 .table = VCORE_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV =  3300000,
-                .max_uV = 3300000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_3300000_VSEL_table),
+                .table = DCDC_FIXED_3300000_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV =  1800000,
-                .max_uV = 1800000,
-                .fixed = 1,
+                .table_len = ARRAY_SIZE(DCDC_FIXED_1800000_VSEL_table),
+                .table = DCDC_FIXED_1800000_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3150000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO1_VSEL_table),
                 .table = TPS65023_LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 1050000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(TPS65023_LDO2_VSEL_table),
                 .table = TPS65023_LDO2_VSEL_table,
         },
diff --git a/drivers/regulator/tps6507x-regulator.c b/drivers/regulator/tps6507x-regulator.c
index da38be1016aa..07d01ccdf308 100644
--- a/drivers/regulator/tps6507x-regulator.c
+++ b/drivers/regulator/tps6507x-regulator.c
@@ -43,58 +43,40 @@
 /* Number of total regulators available */
 #define TPS6507X_NUM_REGULATOR          (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO)
 
-/* Supported voltage values for regulators (in milliVolts) */
-static const u16 VDCDCx_VSEL_table[] = {
-        725, 750, 775, 800,
-        825, 850, 875, 900,
-        925, 950, 975, 1000,
-        1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200,
-        1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400,
-        1425, 1450, 1475, 1500,
-        1550, 1600, 1650, 1700,
-        1750, 1800, 1850, 1900,
-        1950, 2000, 2050, 2100,
-        2150, 2200, 2250, 2300,
-        2350, 2400, 2450, 2500,
-        2550, 2600, 2650, 2700,
-        2750, 2800, 2850, 2900,
-        3000, 3100, 3200, 3300,
+/* Supported voltage values for regulators (in microVolts) */
+static const unsigned int VDCDCx_VSEL_table[] = {
+        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,
+        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,
+        3000000, 3100000, 3200000, 3300000,
 };
 
-static const u16 LDO1_VSEL_table[] = {
-        1000, 1100, 1200, 1250,
-        1300, 1350, 1400, 1500,
-        1600, 1800, 2500, 2750,
-        2800, 3000, 3100, 3300,
+static const unsigned int LDO1_VSEL_table[] = {
+        1000000, 1100000, 1200000, 1250000,
+        1300000, 1350000, 1400000, 1500000,
+        1600000, 1800000, 2500000, 2750000,
+        2800000, 3000000, 3100000, 3300000,
 };
 
-static const u16 LDO2_VSEL_table[] = {
-        725, 750, 775, 800,
-        825, 850, 875, 900,
-        925, 950, 975, 1000,
-        1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200,
-        1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400,
-        1425, 1450, 1475, 1500,
-        1550, 1600, 1650, 1700,
-        1750, 1800, 1850, 1900,
-        1950, 2000, 2050, 2100,
-        2150, 2200, 2250, 2300,
-        2350, 2400, 2450, 2500,
-        2550, 2600, 2650, 2700,
-        2750, 2800, 2850, 2900,
-        3000, 3100, 3200, 3300,
-};
+/* The voltage mapping table for LDO2 is the same as VDCDCx */
+#define LDO2_VSEL_table VDCDCx_VSEL_table
 
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
         u8 table_len;
-        const u16 *table;
+        const unsigned int *table;
 
         /* Does DCDC high or the low register defines output voltage? */
         bool defdcdc_default;
@@ -103,36 +85,26 @@ struct tps_info {
 static struct tps_info tps6507x_pmic_regs[] = {
         {
                 .name = "VDCDC1",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "VDCDC2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "VDCDC3",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table),
                 .table = VDCDCx_VSEL_table,
         },
         {
                 .name = "LDO1",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(LDO1_VSEL_table),
                 .table = LDO1_VSEL_table,
         },
         {
                 .name = "LDO2",
-                .min_uV = 725000,
-                .max_uV = 3300000,
                 .table_len = ARRAY_SIZE(LDO2_VSEL_table),
                 .table = LDO2_VSEL_table,
         },
@@ -375,28 +347,13 @@ static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev,
         return tps6507x_pmic_reg_write(tps, reg, data);
 }
 
-static int tps6507x_pmic_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps6507x_pmic *tps = rdev_get_drvdata(dev);
-        int rid = rdev_get_id(dev);
-
-        if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2)
-                return -EINVAL;
-
-        if (selector >= tps->info[rid]->table_len)
-                return -EINVAL;
-        else
-                return tps->info[rid]->table[selector] * 1000;
-}
-
 static struct regulator_ops tps6507x_pmic_ops = {
         .is_enabled = tps6507x_pmic_is_enabled,
         .enable = tps6507x_pmic_enable,
         .disable = tps6507x_pmic_disable,
         .get_voltage_sel = tps6507x_pmic_get_voltage_sel,
         .set_voltage_sel = tps6507x_pmic_set_voltage_sel,
-        .list_voltage = tps6507x_pmic_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
 };
 
 static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
@@ -449,6 +406,7 @@ static __devinit int tps6507x_pmic_probe(struct platform_device *pdev)
                 tps->desc[i].name = info->name;
                 tps->desc[i].id = i;
                 tps->desc[i].n_voltages = info->table_len;
+                tps->desc[i].volt_table = info->table;
                 tps->desc[i].ops = &tps6507x_pmic_ops;
                 tps->desc[i].type = REGULATOR_VOLTAGE;
                 tps->desc[i].owner = THIS_MODULE;
diff --git a/drivers/regulator/tps65217-regulator.c b/drivers/regulator/tps65217-regulator.c
index 9d371d2cbcae..6caa222af77a 100644
--- a/drivers/regulator/tps65217-regulator.c
+++ b/drivers/regulator/tps65217-regulator.c
@@ -26,7 +26,7 @@
 #include <linux/regulator/machine.h>
 #include <linux/mfd/tps65217.h>
 
-#define TPS65217_REGULATOR(_name, _id, _ops, _n)        \
+#define TPS65217_REGULATOR(_name, _id, _ops, _n, _vr, _vm, _em, _t) \
         {                                               \
                 .name           = _name,                \
                 .id             = _id,                  \
@@ -34,23 +34,23 @@
                 .n_voltages     = _n,                   \
                 .type           = REGULATOR_VOLTAGE,    \
                 .owner          = THIS_MODULE,          \
+                .vsel_reg       = _vr,                  \
+                .vsel_mask      = _vm,                  \
+                .enable_reg     = TPS65217_REG_ENABLE,  \
+                .enable_mask    = _em,                  \
+                .volt_table     = _t,                   \
         }                                               \
 
-#define TPS65217_INFO(_nm, _min, _max, _f1, _f2, _t, _n, _em, _vr, _vm) \
+#define TPS65217_INFO(_nm, _min, _max, _f1, _f2)        \
         {                                               \
                 .name           = _nm,                  \
                 .min_uV         = _min,                 \
                 .max_uV         = _max,                 \
                 .vsel_to_uv     = _f1,                  \
                 .uv_to_vsel     = _f2,                  \
-                .table          = _t,                   \
-                .table_len      = _n,                   \
-                .enable_mask    = _em,                  \
-                .set_vout_reg   = _vr,                  \
-                .set_vout_mask  = _vm,                  \
         }
 
-static const int LDO1_VSEL_table[] = {
+static const unsigned int LDO1_VSEL_table[] = {
         1000000, 1100000, 1200000, 1250000,
         1300000, 1350000, 1400000, 1500000,
         1600000, 1800000, 2500000, 2750000,
@@ -78,7 +78,7 @@ static int tps65217_vsel_to_uv1(unsigned int vsel)
 
 static int tps65217_uv_to_vsel1(int uV, unsigned int *vsel)
 {
-        if ((uV < 0) && (uV > 3300000))
+        if (uV < 0 || uV > 3300000)
                 return -EINVAL;
 
         if (uV <= 1500000)
@@ -112,7 +112,7 @@ static int tps65217_vsel_to_uv2(unsigned int vsel)
 
 static int tps65217_uv_to_vsel2(int uV, unsigned int *vsel)
 {
-        if ((uV < 0) && (uV > 3300000))
+        if (uV < 0 || uV > 3300000)
                 return -EINVAL;
 
         if (uV <= 1900000)
@@ -127,46 +127,20 @@ static int tps65217_uv_to_vsel2(int uV, unsigned int *vsel)
 
 static struct tps_info tps65217_pmic_regs[] = {
         TPS65217_INFO("DCDC1", 900000, 1800000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC1_EN,
-                        TPS65217_REG_DEFDCDC1, TPS65217_DEFDCDCX_DCDC_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("DCDC2", 900000, 3300000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC2_EN,
-                        TPS65217_REG_DEFDCDC2, TPS65217_DEFDCDCX_DCDC_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("DCDC3", 900000, 1500000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_DC3_EN,
-                        TPS65217_REG_DEFDCDC3, TPS65217_DEFDCDCX_DCDC_MASK),
-        TPS65217_INFO("LDO1", 1000000, 3300000, NULL, NULL, LDO1_VSEL_table,
-                        16, TPS65217_ENABLE_LDO1_EN, TPS65217_REG_DEFLDO1,
-                        TPS65217_DEFLDO1_LDO1_MASK),
+                        tps65217_uv_to_vsel1),
+        TPS65217_INFO("LDO1", 1000000, 3300000, NULL, NULL),
         TPS65217_INFO("LDO2", 900000, 3300000, tps65217_vsel_to_uv1,
-                        tps65217_uv_to_vsel1, NULL, 64, TPS65217_ENABLE_LDO2_EN,
-                        TPS65217_REG_DEFLDO2, TPS65217_DEFLDO2_LDO2_MASK),
+                        tps65217_uv_to_vsel1),
         TPS65217_INFO("LDO3", 1800000, 3300000, tps65217_vsel_to_uv2,
-                        tps65217_uv_to_vsel2, NULL, 32,
-                        TPS65217_ENABLE_LS1_EN | TPS65217_DEFLDO3_LDO3_EN,
-                        TPS65217_REG_DEFLS1, TPS65217_DEFLDO3_LDO3_MASK),
+                        tps65217_uv_to_vsel2),
         TPS65217_INFO("LDO4", 1800000, 3300000, tps65217_vsel_to_uv2,
-                        tps65217_uv_to_vsel2, NULL, 32,
-                        TPS65217_ENABLE_LS2_EN | TPS65217_DEFLDO4_LDO4_EN,
-                        TPS65217_REG_DEFLS2, TPS65217_DEFLDO4_LDO4_MASK),
+                        tps65217_uv_to_vsel2),
 };
 
-static int tps65217_pmic_is_enabled(struct regulator_dev *dev)
-{
-        int ret;
-        struct tps65217 *tps = rdev_get_drvdata(dev);
-        unsigned int data, rid = rdev_get_id(dev);
-
-        if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
-                return -EINVAL;
-
-        ret = tps65217_reg_read(tps, TPS65217_REG_ENABLE, &data);
-        if (ret)
-                return ret;
-
-        return (data & tps->info[rid]->enable_mask) ? 1 : 0;
-}
-
 static int tps65217_pmic_enable(struct regulator_dev *dev)
 {
         struct tps65217 *tps = rdev_get_drvdata(dev);
@@ -177,9 +151,8 @@ static int tps65217_pmic_enable(struct regulator_dev *dev)
 
         /* Enable the regulator and password protection is level 1 */
         return tps65217_set_bits(tps, TPS65217_REG_ENABLE,
-                                tps->info[rid]->enable_mask,
-                                tps->info[rid]->enable_mask,
-                                TPS65217_PROTECT_L1);
+                                 dev->desc->enable_mask, dev->desc->enable_mask,
+                                 TPS65217_PROTECT_L1);
 }
 
 static int tps65217_pmic_disable(struct regulator_dev *dev)
@@ -192,25 +165,7 @@ static int tps65217_pmic_disable(struct regulator_dev *dev)
 
         /* Disable the regulator and password protection is level 1 */
         return tps65217_clear_bits(tps, TPS65217_REG_ENABLE,
-                        tps->info[rid]->enable_mask, TPS65217_PROTECT_L1);
-}
-
-static int tps65217_pmic_get_voltage_sel(struct regulator_dev *dev)
-{
-        int ret;
-        struct tps65217 *tps = rdev_get_drvdata(dev);
-        unsigned int selector, rid = rdev_get_id(dev);
-
-        if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
-                return -EINVAL;
-
-        ret = tps65217_reg_read(tps, tps->info[rid]->set_vout_reg, &selector);
-        if (ret)
-                return ret;
-
-        selector &= tps->info[rid]->set_vout_mask;
-
-        return selector;
+                                   dev->desc->enable_mask, TPS65217_PROTECT_L1);
 }
 
 static int tps65217_pmic_set_voltage_sel(struct regulator_dev *dev,
@@ -221,8 +176,7 @@ static int tps65217_pmic_set_voltage_sel(struct regulator_dev *dev,
         unsigned int rid = rdev_get_id(dev);
 
         /* Set the voltage based on vsel value and write protect level is 2 */
-        ret = tps65217_set_bits(tps, tps->info[rid]->set_vout_reg,
-                                tps->info[rid]->set_vout_mask,
+        ret = tps65217_set_bits(tps, dev->desc->vsel_reg, dev->desc->vsel_mask,
                                 selector, TPS65217_PROTECT_L2);
 
         /* Set GO bit for DCDCx to initiate voltage transistion */
@@ -252,10 +206,10 @@ static int tps65217_pmic_map_voltage(struct regulator_dev *dev,
         if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
                 return -EINVAL;
 
-        if (min_uV < tps->info[rid]->min_uV || min_uV > tps->info[rid]->max_uV)
-                return -EINVAL;
+        if (min_uV < tps->info[rid]->min_uV)
+                min_uV = tps->info[rid]->min_uV;
 
-        if (max_uV < tps->info[rid]->min_uV || max_uV > tps->info[rid]->max_uV)
+        if (max_uV < tps->info[rid]->min_uV || min_uV > tps->info[rid]->max_uV)
                 return -EINVAL;
 
         ret = tps->info[rid]->uv_to_vsel(min_uV, &sel);
@@ -274,21 +228,18 @@ static int tps65217_pmic_list_voltage(struct regulator_dev *dev,
         if (rid < TPS65217_DCDC_1 || rid > TPS65217_LDO_4)
                 return -EINVAL;
 
-        if (selector >= tps->info[rid]->table_len)
+        if (selector >= dev->desc->n_voltages)
                 return -EINVAL;
 
-        if (tps->info[rid]->table)
-                return tps->info[rid]->table[selector];
-
         return tps->info[rid]->vsel_to_uv(selector);
 }
 
 /* Operations permitted on DCDCx, LDO2, LDO3 and LDO4 */
 static struct regulator_ops tps65217_pmic_ops = {
-        .is_enabled             = tps65217_pmic_is_enabled,
+        .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = tps65217_pmic_enable,
         .disable                = tps65217_pmic_disable,
-        .get_voltage_sel        = tps65217_pmic_get_voltage_sel,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = tps65217_pmic_set_voltage_sel,
         .list_voltage           = tps65217_pmic_list_voltage,
         .map_voltage            = tps65217_pmic_map_voltage,
@@ -296,22 +247,38 @@ static struct regulator_ops tps65217_pmic_ops = {
 
 /* Operations permitted on LDO1 */
 static struct regulator_ops tps65217_pmic_ldo1_ops = {
-        .is_enabled             = tps65217_pmic_is_enabled,
+        .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = tps65217_pmic_enable,
         .disable                = tps65217_pmic_disable,
-        .get_voltage_sel        = tps65217_pmic_get_voltage_sel,
+        .get_voltage_sel        = regulator_get_voltage_sel_regmap,
         .set_voltage_sel        = tps65217_pmic_set_voltage_sel,
-        .list_voltage           = tps65217_pmic_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static const struct regulator_desc regulators[] = {
-        TPS65217_REGULATOR("DCDC1", TPS65217_DCDC_1, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("DCDC2", TPS65217_DCDC_2, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("DCDC3", TPS65217_DCDC_3, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("LDO1", TPS65217_LDO_1, tps65217_pmic_ldo1_ops, 16),
-        TPS65217_REGULATOR("LDO2", TPS65217_LDO_2, tps65217_pmic_ops, 64),
-        TPS65217_REGULATOR("LDO3", TPS65217_LDO_3, tps65217_pmic_ops, 32),
-        TPS65217_REGULATOR("LDO4", TPS65217_LDO_4, tps65217_pmic_ops, 32),
+        TPS65217_REGULATOR("DCDC1", TPS65217_DCDC_1, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC1, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC1_EN, NULL),
+        TPS65217_REGULATOR("DCDC2", TPS65217_DCDC_2, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC2, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC2_EN, NULL),
+        TPS65217_REGULATOR("DCDC3", TPS65217_DCDC_3, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFDCDC3, TPS65217_DEFDCDCX_DCDC_MASK,
+                           TPS65217_ENABLE_DC3_EN, NULL),
+        TPS65217_REGULATOR("LDO1", TPS65217_LDO_1, tps65217_pmic_ldo1_ops, 16,
+                           TPS65217_REG_DEFLDO1, TPS65217_DEFLDO1_LDO1_MASK,
+                           TPS65217_ENABLE_LDO1_EN, LDO1_VSEL_table),
+        TPS65217_REGULATOR("LDO2", TPS65217_LDO_2, tps65217_pmic_ops, 64,
+                           TPS65217_REG_DEFLDO2, TPS65217_DEFLDO2_LDO2_MASK,
+                           TPS65217_ENABLE_LDO2_EN, NULL),
+        TPS65217_REGULATOR("LDO3", TPS65217_LDO_3, tps65217_pmic_ops, 32,
+                           TPS65217_REG_DEFLS1, TPS65217_DEFLDO3_LDO3_MASK,
+                           TPS65217_ENABLE_LS1_EN | TPS65217_DEFLDO3_LDO3_EN,
+                           NULL),
+        TPS65217_REGULATOR("LDO4", TPS65217_LDO_4, tps65217_pmic_ops, 32,
+                           TPS65217_REG_DEFLS2, TPS65217_DEFLDO4_LDO4_MASK,
+                           TPS65217_ENABLE_LS2_EN | TPS65217_DEFLDO4_LDO4_EN,
+                           NULL),
 };
 
 static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
@@ -326,6 +293,7 @@ static int __devinit tps65217_regulator_probe(struct platform_device *pdev)
         tps->info[pdev->id] = info;
 
         config.dev = &pdev->dev;
+        config.of_node = pdev->dev.of_node;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = tps;
 
diff --git a/drivers/regulator/tps6524x-regulator.c b/drivers/regulator/tps6524x-regulator.c
index 1b299aacf22f..947ece933d90 100644
--- a/drivers/regulator/tps6524x-regulator.c
+++ b/drivers/regulator/tps6524x-regulator.c
@@ -110,9 +110,6 @@
 #define N_SWITCH                2
 #define N_REGULATORS            (N_DCDC + N_LDO + N_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)
@@ -129,12 +126,9 @@ struct field {
 struct supply_info {
         const char      *name;
         int             n_voltages;
-        const int       *voltages;
-        int             fixed_voltage;
+        const unsigned int *voltages;
         int             n_ilimsels;
-        const int       *ilimsels;
-        int             fixed_ilimsel;
-        int             flags;
+        const unsigned int *ilimsels;
         struct field    enable, voltage, ilimsel;
 };
 
@@ -307,7 +301,7 @@ static int write_field(struct tps6524x *hw, const struct field *field,
                                     val << field->shift);
 }
 
-static const int dcdc1_voltages[] = {
+static const unsigned int dcdc1_voltages[] = {
          800000,  825000,  850000,  875000,
          900000,  925000,  950000,  975000,
         1000000, 1025000, 1050000, 1075000,
@@ -318,7 +312,7 @@ static const int dcdc1_voltages[] = {
         1500000, 1525000, 1550000, 1575000,
 };
 
-static const int dcdc2_voltages[] = {
+static const unsigned int dcdc2_voltages[] = {
         1400000, 1450000, 1500000, 1550000,
         1600000, 1650000, 1700000, 1750000,
         1800000, 1850000, 1900000, 1950000,
@@ -329,7 +323,7 @@ static const int dcdc2_voltages[] = {
         2800000, 2850000, 2900000, 2950000,
 };
 
-static const int dcdc3_voltages[] = {
+static const unsigned int dcdc3_voltages[] = {
         2400000, 2450000, 2500000, 2550000, 2600000,
         2650000, 2700000, 2750000, 2800000, 2850000,
         2900000, 2950000, 3000000, 3050000, 3100000,
@@ -337,38 +331,54 @@ static const int dcdc3_voltages[] = {
         3400000, 3450000, 3500000, 3550000, 3600000,
 };
 
-static const int ldo1_voltages[] = {
+static const unsigned int ldo1_voltages[] = {
         4300000, 4350000, 4400000, 4450000,
         4500000, 4550000, 4600000, 4650000,
         4700000, 4750000, 4800000, 4850000,
         4900000, 4950000, 5000000, 5050000,
 };
 
-static const int ldo2_voltages[] = {
+static const unsigned int ldo2_voltages[] = {
         1100000, 1150000, 1200000, 1250000,
         1300000, 1700000, 1750000, 1800000,
         1850000, 1900000, 3150000, 3200000,
         3250000, 3300000, 3350000, 3400000,
 };
 
-static const int ldo_ilimsel[] = {
+static const unsigned int fixed_5000000_voltage[] = {
+        5000000
+};
+
+static const unsigned int ldo_ilimsel[] = {
         400000, 1500000
 };
 
-static const int usb_ilimsel[] = {
+static const unsigned int usb_ilimsel[] = {
         200000, 400000, 800000, 1000000
 };
 
+static const unsigned int fixed_2400000_ilimsel[] = {
+        2400000
+};
+
+static const unsigned int fixed_1200000_ilimsel[] = {
+        1200000
+};
+
+static const unsigned int fixed_400000_ilimsel[] = {
+        400000
+};
+
 #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,
+                .n_ilimsels     = ARRAY_SIZE(fixed_2400000_ilimsel),
+                .ilimsels       = fixed_2400000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                              DCDCDCDC1_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -376,10 +386,10 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "DCDC2",
-                .flags          = FIXED_ILIMSEL,
                 .n_voltages     = ARRAY_SIZE(dcdc2_voltages),
                 .voltages       = dcdc2_voltages,
-                .fixed_ilimsel  = 1200000,
+                .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
+                .ilimsels       = fixed_1200000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                              DCDCDCDC2_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -387,10 +397,10 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "DCDC3",
-                .flags          = FIXED_ILIMSEL,
                 .n_voltages     = ARRAY_SIZE(dcdc3_voltages),
                 .voltages       = dcdc3_voltages,
-                .fixed_ilimsel  = 1200000,
+                .n_ilimsels     = ARRAY_SIZE(fixed_1200000_ilimsel),
+                .ilimsels       = fixed_1200000_ilimsel,
                 .enable         = __MK_FIELD(REG_DCDC_EN, DCDCDCDC_EN_MASK,
                                         DCDCDCDC3_EN_SHIFT),
                 .voltage        = __MK_FIELD(REG_DCDC_SET, DCDC_VDCDC_MASK,
@@ -424,8 +434,8 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "USB",
-                .flags          = FIXED_VOLTAGE,
-                .fixed_voltage  = 5000000,
+                .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
+                .voltages       = fixed_5000000_voltage,
                 .n_ilimsels     = ARRAY_SIZE(usb_ilimsel),
                 .ilimsels       = usb_ilimsel,
                 .enable         = __MK_FIELD(REG_BLOCK_EN, BLOCK_MASK,
@@ -435,29 +445,15 @@ static const struct supply_info supply_info[N_REGULATORS] = {
         },
         {
                 .name           = "LCD",
-                .flags          = FIXED_VOLTAGE | FIXED_ILIMSEL,
-                .fixed_voltage  = 5000000,
-                .fixed_ilimsel  =  400000,
+                .n_voltages     = ARRAY_SIZE(fixed_5000000_voltage),
+                .voltages       = fixed_5000000_voltage,
+                .n_ilimsels     = ARRAY_SIZE(fixed_400000_ilimsel),
+                .ilimsels       = fixed_400000_ilimsel,
                 .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_sel(struct regulator_dev *rdev, unsigned selector)
 {
         const struct supply_info *info;
@@ -466,7 +462,7 @@ static int set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_VOLTAGE)
+        if (rdev->desc->n_voltages == 1)
                 return -EINVAL;
 
         return write_field(hw, &info->voltage, selector);
@@ -481,7 +477,7 @@ static int get_voltage_sel(struct regulator_dev *rdev)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_VOLTAGE)
+        if (rdev->desc->n_voltages == 1)
                 return 0;
 
         ret = read_field(hw, &info->voltage);
@@ -503,7 +499,7 @@ static int set_current_limit(struct regulator_dev *rdev, int min_uA,
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_ILIMSEL)
+        if (info->n_ilimsels == 1)
                 return -EINVAL;
 
         for (i = 0; i < info->n_ilimsels; i++)
@@ -526,8 +522,8 @@ static int get_current_limit(struct regulator_dev *rdev)
         hw      = rdev_get_drvdata(rdev);
         info    = &supply_info[rdev_get_id(rdev)];
 
-        if (info->flags & FIXED_ILIMSEL)
-                return info->fixed_ilimsel;
+        if (info->n_ilimsels == 1)
+                return info->ilimsels[0];
 
         ret = read_field(hw, &info->ilimsel);
         if (ret < 0)
@@ -577,7 +573,7 @@ static struct regulator_ops regulator_ops = {
         .disable                = disable_supply,
         .get_voltage_sel        = get_voltage_sel,
         .set_voltage_sel        = set_voltage_sel,
-        .list_voltage           = list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
         .set_current_limit      = set_current_limit,
         .get_current_limit      = get_current_limit,
 };
@@ -629,13 +625,11 @@ static int __devinit pmic_probe(struct spi_device *spi)
                 hw->desc[i].name        = info->name;
                 hw->desc[i].id          = i;
                 hw->desc[i].n_voltages  = info->n_voltages;
+                hw->desc[i].volt_table  = info->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;
-
                 config.dev = dev;
                 config.init_data = init_data;
                 config.driver_data = hw;
diff --git a/drivers/regulator/tps6586x-regulator.c b/drivers/regulator/tps6586x-regulator.c
index c0a214575380..e6da90ab5153 100644
--- a/drivers/regulator/tps6586x-regulator.c
+++ b/drivers/regulator/tps6586x-regulator.c
@@ -63,8 +63,6 @@ struct tps6586x_regulator {
         int enable_bit[2];
         int enable_reg[2];
 
-        int *voltages;
-
         /* for DVM regulators */
         int go_reg;
         int go_bit;
@@ -72,22 +70,9 @@ struct tps6586x_regulator {
 
 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev)
 {
-        return rdev_get_dev(rdev)->parent->parent;
+        return rdev_get_dev(rdev)->parent;
 }
 
-static int tps6586x_list_voltage(struct regulator_dev *rdev, unsigned selector)
-{
-        struct tps6586x_regulator *info = rdev_get_drvdata(rdev);
-        int rid = rdev_get_id(rdev);
-
-        /* LDO0 has minimal voltage 1.2V rather than 1.25V */
-        if ((rid == TPS6586X_ID_LDO_0) && (selector == 0))
-                return (info->voltages[0] - 50) * 1000;
-
-        return info->voltages[selector] * 1000;
-}
-
-
 static int tps6586x_set_voltage_sel(struct regulator_dev *rdev,
                                     unsigned selector)
 {
@@ -168,7 +153,7 @@ static int tps6586x_regulator_is_enabled(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops tps6586x_regulator_ops = {
-        .list_voltage = tps6586x_list_voltage,
+        .list_voltage = regulator_list_voltage_table,
         .get_voltage_sel = tps6586x_get_voltage_sel,
         .set_voltage_sel = tps6586x_set_voltage_sel,
 
@@ -177,39 +162,45 @@ static struct regulator_ops tps6586x_regulator_ops = {
         .disable = tps6586x_regulator_disable,
 };
 
-static int tps6586x_ldo_voltages[] = {
-        1250, 1500, 1800, 2500, 2700, 2850, 3100, 3300,
+static const unsigned int tps6586x_ldo0_voltages[] = {
+        1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
+};
+
+static const unsigned int tps6586x_ldo4_voltages[] = {
+        1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000,
+        1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000,
+        2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000,
+        2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000,
 };
 
-static int tps6586x_ldo4_voltages[] = {
-        1700, 1725, 1750, 1775, 1800, 1825, 1850, 1875,
-        1900, 1925, 1950, 1975, 2000, 2025, 2050, 2075,
-        2100, 2125, 2150, 2175, 2200, 2225, 2250, 2275,
-        2300, 2325, 2350, 2375, 2400, 2425, 2450, 2475,
+static const unsigned int tps6586x_ldo_voltages[] = {
+        1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000,
 };
 
-static int tps6586x_sm2_voltages[] = {
-        3000, 3050, 3100, 3150, 3200, 3250, 3300, 3350,
-        3400, 3450, 3500, 3550, 3600, 3650, 3700, 3750,
-        3800, 3850, 3900, 3950, 4000, 4050, 4100, 4150,
-        4200, 4250, 4300, 4350, 4400, 4450, 4500, 4550,
+static const unsigned int tps6586x_sm2_voltages[] = {
+        3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000,
+        3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000,
+        3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000,
+        4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000,
 };
 
-static int tps6586x_dvm_voltages[] = {
-         725,  750,  775,  800,  825,  850,  875,  900,
-         925,  950,  975, 1000, 1025, 1050, 1075, 1100,
-        1125, 1150, 1175, 1200, 1225, 1250, 1275, 1300,
-        1325, 1350, 1375, 1400, 1425, 1450, 1475, 1500,
+static const unsigned int tps6586x_dvm_voltages[] = {
+         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,
 };
 
-#define TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+#define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits,   \
                            ereg0, ebit0, ereg1, ebit1)                  \
         .desc   = {                                                     \
+                .supply_name = _pin_name,                               \
                 .name   = "REG-" #_id,                                  \
                 .ops    = &tps6586x_regulator_ops,                      \
                 .type   = REGULATOR_VOLTAGE,                            \
                 .id     = TPS6586X_ID_##_id,                            \
                 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages),  \
+                .volt_table = tps6586x_##vdata##_voltages,              \
                 .owner  = THIS_MODULE,                                  \
         },                                                              \
         .volt_reg       = TPS6586X_##vreg,                              \
@@ -218,44 +209,45 @@ static int tps6586x_dvm_voltages[] = {
         .enable_reg[0]  = TPS6586X_SUPPLY##ereg0,                       \
         .enable_bit[0]  = (ebit0),                                      \
         .enable_reg[1]  = TPS6586X_SUPPLY##ereg1,                       \
-        .enable_bit[1]  = (ebit1),                                      \
-        .voltages       = tps6586x_##vdata##_voltages,
+        .enable_bit[1]  = (ebit1),
 
 #define TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
         .go_reg = TPS6586X_##goreg,                                     \
         .go_bit = (gobit),
 
-#define TPS6586X_LDO(_id, vdata, vreg, shift, nbits,                    \
+#define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1)                        \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
                            ereg0, ebit0, ereg1, ebit1)                  \
 }
 
-#define TPS6586X_DVM(_id, vdata, vreg, shift, nbits,                    \
+#define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits,            \
                      ereg0, ebit0, ereg1, ebit1, goreg, gobit)          \
 {                                                                       \
-        TPS6586X_REGULATOR(_id, vdata, vreg, shift, nbits,              \
+        TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits,      \
                            ereg0, ebit0, ereg1, ebit1)                  \
         TPS6586X_REGULATOR_DVM_GOREG(goreg, gobit)                      \
 }
 
 static struct tps6586x_regulator tps6586x_regulator[] = {
-        TPS6586X_LDO(LDO_0, ldo, SUPPLYV1, 5, 3, ENC, 0, END, 0),
-        TPS6586X_LDO(LDO_3, ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
-        TPS6586X_LDO(LDO_5, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
-        TPS6586X_LDO(LDO_6, ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
-        TPS6586X_LDO(LDO_7, ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
-        TPS6586X_LDO(LDO_8, ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
-        TPS6586X_LDO(LDO_9, ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
-        TPS6586X_LDO(LDO_RTC, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
-        TPS6586X_LDO(LDO_1, dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
-        TPS6586X_LDO(SM_2, sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
-
-        TPS6586X_DVM(LDO_2, dvm, LDO2BV1, 0, 5, ENA, 3, ENB, 3, VCC2, 6),
-        TPS6586X_DVM(LDO_4, ldo4, LDO4V1, 0, 5, ENC, 3, END, 3, VCC1, 6),
-        TPS6586X_DVM(SM_0, dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
-        TPS6586X_DVM(SM_1, dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
+        TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0),
+        TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2),
+        TPS6586X_LDO(LDO_5, NULL, ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6),
+        TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4),
+        TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5),
+        TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6),
+        TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7),
+        TPS6586X_LDO(LDO_RTC, NULL, ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7),
+        TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1),
+        TPS6586X_LDO(SM_2, "sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7),
+
+        TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3,
+                                        ENB, 3, VCC2, 6),
+        TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3,
+                                        END, 3, VCC1, 6),
+        TPS6586X_DVM(SM_0, "sm0", dvm, SM0V1, 0, 5, ENA, 1, ENB, 1, VCC1, 2),
+        TPS6586X_DVM(SM_1, "sm1", dvm, SM1V1, 0, 5, ENA, 0, ENB, 0, VCC1, 0),
 };
 
 /*
@@ -362,7 +354,7 @@ static int __devinit tps6586x_regulator_probe(struct platform_device *pdev)
         if (err)
                 return err;
 
-        config.dev = &pdev->dev;
+        config.dev = pdev->dev.parent;
         config.of_node = pdev->dev.of_node;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = ri;
diff --git a/drivers/regulator/tps65910-regulator.c b/drivers/regulator/tps65910-regulator.c
index 6bf864b4bdf6..793adda560c3 100644
--- a/drivers/regulator/tps65910-regulator.c
+++ b/drivers/regulator/tps65910-regulator.c
@@ -31,160 +31,147 @@
                         TPS65910_SLEEP_CONTROL_EXT_INPUT_EN3 |          \
                         TPS65911_SLEEP_CONTROL_EXT_INPUT_SLEEP)
 
-/* supported VIO voltages in millivolts */
-static const u16 VIO_VSEL_table[] = {
-        1500, 1800, 2500, 3300,
+/* supported VIO voltages in microvolts */
+static const unsigned int VIO_VSEL_table[] = {
+        1500000, 1800000, 2500000, 3300000,
 };
 
 /* VSEL tables for TPS65910 specific LDOs and dcdc's */
 
-/* supported VDD3 voltages in millivolts */
-static const u16 VDD3_VSEL_table[] = {
-        5000,
+/* supported VDD3 voltages in microvolts */
+static const unsigned int VDD3_VSEL_table[] = {
+        5000000,
 };
 
-/* supported VDIG1 voltages in millivolts */
-static const u16 VDIG1_VSEL_table[] = {
-        1200, 1500, 1800, 2700,
+/* supported VDIG1 voltages in microvolts */
+static const unsigned int VDIG1_VSEL_table[] = {
+        1200000, 1500000, 1800000, 2700000,
 };
 
-/* supported VDIG2 voltages in millivolts */
-static const u16 VDIG2_VSEL_table[] = {
-        1000, 1100, 1200, 1800,
+/* supported VDIG2 voltages in microvolts */
+static const unsigned int VDIG2_VSEL_table[] = {
+        1000000, 1100000, 1200000, 1800000,
 };
 
-/* supported VPLL voltages in millivolts */
-static const u16 VPLL_VSEL_table[] = {
-        1000, 1100, 1800, 2500,
+/* supported VPLL voltages in microvolts */
+static const unsigned int VPLL_VSEL_table[] = {
+        1000000, 1100000, 1800000, 2500000,
 };
 
-/* supported VDAC voltages in millivolts */
-static const u16 VDAC_VSEL_table[] = {
-        1800, 2600, 2800, 2850,
+/* supported VDAC voltages in microvolts */
+static const unsigned int VDAC_VSEL_table[] = {
+        1800000, 2600000, 2800000, 2850000,
 };
 
-/* supported VAUX1 voltages in millivolts */
-static const u16 VAUX1_VSEL_table[] = {
-        1800, 2500, 2800, 2850,
+/* supported VAUX1 voltages in microvolts */
+static const unsigned int VAUX1_VSEL_table[] = {
+        1800000, 2500000, 2800000, 2850000,
 };
 
-/* supported VAUX2 voltages in millivolts */
-static const u16 VAUX2_VSEL_table[] = {
-        1800, 2800, 2900, 3300,
+/* supported VAUX2 voltages in microvolts */
+static const unsigned int VAUX2_VSEL_table[] = {
+        1800000, 2800000, 2900000, 3300000,
 };
 
-/* supported VAUX33 voltages in millivolts */
-static const u16 VAUX33_VSEL_table[] = {
-        1800, 2000, 2800, 3300,
+/* supported VAUX33 voltages in microvolts */
+static const unsigned int VAUX33_VSEL_table[] = {
+        1800000, 2000000, 2800000, 3300000,
 };
 
-/* supported VMMC voltages in millivolts */
-static const u16 VMMC_VSEL_table[] = {
-        1800, 2800, 3000, 3300,
+/* supported VMMC voltages in microvolts */
+static const unsigned int VMMC_VSEL_table[] = {
+        1800000, 2800000, 3000000, 3300000,
 };
 
 struct tps_info {
         const char *name;
-        unsigned min_uV;
-        unsigned max_uV;
+        const char *vin_name;
         u8 n_voltages;
-        const u16 *voltage_table;
+        const unsigned int *voltage_table;
         int enable_time_us;
 };
 
 static struct tps_info tps65910_regs[] = {
         {
                 .name = "vrtc",
+                .vin_name = "vcc7",
                 .enable_time_us = 2200,
         },
         {
                 .name = "vio",
-                .min_uV = 1500000,
-                .max_uV = 3300000,
+                .vin_name = "vccio",
                 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),
                 .voltage_table = VIO_VSEL_table,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd1",
-                .min_uV = 600000,
-                .max_uV = 4500000,
+                .vin_name = "vcc1",
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd2",
-                .min_uV = 600000,
-                .max_uV = 4500000,
+                .vin_name = "vcc2",
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd3",
-                .min_uV = 5000000,
-                .max_uV = 5000000,
                 .n_voltages = ARRAY_SIZE(VDD3_VSEL_table),
                 .voltage_table = VDD3_VSEL_table,
                 .enable_time_us = 200,
         },
         {
                 .name = "vdig1",
-                .min_uV = 1200000,
-                .max_uV = 2700000,
+                .vin_name = "vcc6",
                 .n_voltages = ARRAY_SIZE(VDIG1_VSEL_table),
                 .voltage_table = VDIG1_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vdig2",
-                .min_uV = 1000000,
-                .max_uV = 1800000,
+                .vin_name = "vcc6",
                 .n_voltages = ARRAY_SIZE(VDIG2_VSEL_table),
                 .voltage_table = VDIG2_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vpll",
-                .min_uV = 1000000,
-                .max_uV = 2500000,
+                .vin_name = "vcc5",
                 .n_voltages = ARRAY_SIZE(VPLL_VSEL_table),
                 .voltage_table = VPLL_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vdac",
-                .min_uV = 1800000,
-                .max_uV = 2850000,
+                .vin_name = "vcc5",
                 .n_voltages = ARRAY_SIZE(VDAC_VSEL_table),
                 .voltage_table = VDAC_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux1",
-                .min_uV = 1800000,
-                .max_uV = 2850000,
+                .vin_name = "vcc4",
                 .n_voltages = ARRAY_SIZE(VAUX1_VSEL_table),
                 .voltage_table = VAUX1_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux2",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc4",
                 .n_voltages = ARRAY_SIZE(VAUX2_VSEL_table),
                 .voltage_table = VAUX2_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vaux33",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc3",
                 .n_voltages = ARRAY_SIZE(VAUX33_VSEL_table),
                 .voltage_table = VAUX33_VSEL_table,
                 .enable_time_us = 100,
         },
         {
                 .name = "vmmc",
-                .min_uV = 1800000,
-                .max_uV = 3300000,
+                .vin_name = "vcc3",
                 .n_voltages = ARRAY_SIZE(VMMC_VSEL_table),
                 .voltage_table = VMMC_VSEL_table,
                 .enable_time_us = 100,
@@ -194,91 +181,79 @@ static struct tps_info tps65910_regs[] = {
 static struct tps_info tps65911_regs[] = {
         {
                 .name = "vrtc",
+                .vin_name = "vcc7",
                 .enable_time_us = 2200,
         },
         {
                 .name = "vio",
-                .min_uV = 1500000,
-                .max_uV = 3300000,
+                .vin_name = "vccio",
                 .n_voltages = ARRAY_SIZE(VIO_VSEL_table),
                 .voltage_table = VIO_VSEL_table,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd1",
-                .min_uV = 600000,
-                .max_uV = 4500000,
-                .n_voltages = 73,
+                .vin_name = "vcc1",
+                .n_voltages = 0x4C,
                 .enable_time_us = 350,
         },
         {
                 .name = "vdd2",
-                .min_uV = 600000,
-                .max_uV = 4500000,
-                .n_voltages = 73,
+                .vin_name = "vcc2",
+                .n_voltages = 0x4C,
                 .enable_time_us = 350,
         },
         {
                 .name = "vddctrl",
-                .min_uV = 600000,
-                .max_uV = 1400000,
-                .n_voltages = 65,
+                .n_voltages = 0x44,
                 .enable_time_us = 900,
         },
         {
                 .name = "ldo1",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc6",
+                .n_voltages = 0x33,
                 .enable_time_us = 420,
         },
         {
                 .name = "ldo2",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc6",
+                .n_voltages = 0x33,
                 .enable_time_us = 420,
         },
         {
                 .name = "ldo3",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc5",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo4",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 47,
+                .vin_name = "vcc5",
+                .n_voltages = 0x33,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo5",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc4",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo6",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo7",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
         {
                 .name = "ldo8",
-                .min_uV = 1000000,
-                .max_uV = 3300000,
-                .n_voltages = 24,
+                .vin_name = "vcc3",
+                .n_voltages = 0x1A,
                 .enable_time_us = 230,
         },
 };
@@ -321,7 +296,6 @@ struct tps65910_reg {
         struct tps65910 *mfd;
         struct regulator_dev **rdev;
         struct tps_info **info;
-        struct mutex mutex;
         int num_regulators;
         int mode;
         int  (*get_ctrl_reg)(int);
@@ -329,71 +303,6 @@ struct tps65910_reg {
         unsigned int board_ext_control[TPS65910_NUM_REGS];
 };
 
-static inline int tps65910_read(struct tps65910_reg *pmic, u8 reg)
-{
-        unsigned int val;
-        int err;
-
-        err = tps65910_reg_read(pmic->mfd, reg, &val);
-        if (err)
-                return err;
-
-        return val;
-}
-
-static int tps65910_modify_bits(struct tps65910_reg *pmic, u8 reg,
-                                        u8 set_mask, u8 clear_mask)
-{
-        int err, data;
-
-        mutex_lock(&pmic->mutex);
-
-        data = tps65910_read(pmic, reg);
-        if (data < 0) {
-                dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
-                err = data;
-                goto out;
-        }
-
-        data &= ~clear_mask;
-        data |= set_mask;
-        err = tps65910_reg_write(pmic->mfd, reg, data);
-        if (err)
-                dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
-
-out:
-        mutex_unlock(&pmic->mutex);
-        return err;
-}
-
-static int tps65910_reg_read_locked(struct tps65910_reg *pmic, u8 reg)
-{
-        int data;
-
-        mutex_lock(&pmic->mutex);
-
-        data = tps65910_read(pmic, reg);
-        if (data < 0)
-                dev_err(pmic->mfd->dev, "Read from reg 0x%x failed\n", reg);
-
-        mutex_unlock(&pmic->mutex);
-        return data;
-}
-
-static int tps65910_reg_write_locked(struct tps65910_reg *pmic, u8 reg, u8 val)
-{
-        int err;
-
-        mutex_lock(&pmic->mutex);
-
-        err = tps65910_reg_write(pmic->mfd, reg, val);
-        if (err < 0)
-                dev_err(pmic->mfd->dev, "Write for reg 0x%x failed\n", reg);
-
-        mutex_unlock(&pmic->mutex);
-        return err;
-}
-
 static int tps65910_get_ctrl_register(int id)
 {
         switch (id) {
@@ -462,13 +371,6 @@ static int tps65911_get_ctrl_register(int id)
         }
 }
 
-static int tps65910_enable_time(struct regulator_dev *dev)
-{
-        struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        return pmic->info[id]->enable_time_us;
-}
-
 static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
@@ -481,8 +383,9 @@ static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 
         switch (mode) {
         case REGULATOR_MODE_NORMAL:
-                return tps65910_modify_bits(pmic, reg, LDO_ST_ON_BIT,
-                                                        LDO_ST_MODE_BIT);
+                return tps65910_reg_update_bits(pmic->mfd, reg,
+                                                LDO_ST_MODE_BIT | LDO_ST_ON_BIT,
+                                                LDO_ST_ON_BIT);
         case REGULATOR_MODE_IDLE:
                 value = LDO_ST_ON_BIT | LDO_ST_MODE_BIT;
                 return tps65910_reg_set_bits(mfd, reg, value);
@@ -496,15 +399,15 @@ static int tps65910_set_mode(struct regulator_dev *dev, unsigned int mode)
 static unsigned int tps65910_get_mode(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int reg, value, id = rdev_get_id(dev);
+        int ret, reg, value, id = rdev_get_id(dev);
 
         reg = pmic->get_ctrl_reg(id);
         if (reg < 0)
                 return reg;
 
-        value = tps65910_reg_read_locked(pmic, reg);
-        if (value < 0)
-                return value;
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         if (!(value & LDO_ST_ON_BIT))
                 return REGULATOR_MODE_STANDBY;
@@ -517,33 +420,51 @@ static unsigned int tps65910_get_mode(struct regulator_dev *dev)
 static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
+        int ret, id = rdev_get_id(dev);
         int opvsel = 0, srvsel = 0, vselmax = 0, mult = 0, sr = 0;
 
         switch (id) {
         case TPS65910_REG_VDD1:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD1_OP);
-                mult = tps65910_reg_read_locked(pmic, TPS65910_VDD1);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1_OP, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1, &mult);
+                if (ret < 0)
+                        return ret;
                 mult = (mult & VDD1_VGAIN_SEL_MASK) >> VDD1_VGAIN_SEL_SHIFT;
-                srvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD1_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD1_SR, &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDD1_OP_CMD_MASK;
                 opvsel &= VDD1_OP_SEL_MASK;
                 srvsel &= VDD1_SR_SEL_MASK;
                 vselmax = 75;
                 break;
         case TPS65910_REG_VDD2:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD2_OP);
-                mult = tps65910_reg_read_locked(pmic, TPS65910_VDD2);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2_OP, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2, &mult);
+                if (ret < 0)
+                        return ret;
                 mult = (mult & VDD2_VGAIN_SEL_MASK) >> VDD2_VGAIN_SEL_SHIFT;
-                srvsel = tps65910_reg_read_locked(pmic, TPS65910_VDD2_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65910_VDD2_SR, &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDD2_OP_CMD_MASK;
                 opvsel &= VDD2_OP_SEL_MASK;
                 srvsel &= VDD2_SR_SEL_MASK;
                 vselmax = 75;
                 break;
         case TPS65911_REG_VDDCTRL:
-                opvsel = tps65910_reg_read_locked(pmic, TPS65911_VDDCTRL_OP);
-                srvsel = tps65910_reg_read_locked(pmic, TPS65911_VDDCTRL_SR);
+                ret = tps65910_reg_read(pmic->mfd, TPS65911_VDDCTRL_OP,
+                                        &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, TPS65911_VDDCTRL_SR,
+                                        &srvsel);
+                if (ret < 0)
+                        return ret;
                 sr = opvsel & VDDCTRL_OP_CMD_MASK;
                 opvsel &= VDDCTRL_OP_SEL_MASK;
                 srvsel &= VDDCTRL_SR_SEL_MASK;
@@ -577,15 +498,15 @@ static int tps65910_get_voltage_dcdc_sel(struct regulator_dev *dev)
 static int tps65910_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int reg, value, id = rdev_get_id(dev);
+        int ret, reg, value, id = rdev_get_id(dev);
 
         reg = pmic->get_ctrl_reg(id);
         if (reg < 0)
                 return reg;
 
-        value = tps65910_reg_read_locked(pmic, reg);
-        if (value < 0)
-                return value;
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         switch (id) {
         case TPS65910_REG_VIO:
@@ -609,18 +530,20 @@ static int tps65910_get_voltage_sel(struct regulator_dev *dev)
 
 static int tps65910_get_voltage_vdd3(struct regulator_dev *dev)
 {
-        return 5 * 1000 * 1000;
+        return dev->desc->volt_table[0];
 }
 
 static int tps65911_get_voltage_sel(struct regulator_dev *dev)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev);
-        u8 value, reg;
+        int ret, id = rdev_get_id(dev);
+        unsigned int value, reg;
 
         reg = pmic->get_ctrl_reg(id);
 
-        value = tps65910_reg_read_locked(pmic, reg);
+        ret = tps65910_reg_read(pmic->mfd, reg, &value);
+        if (ret < 0)
+                return ret;
 
         switch (id) {
         case TPS65911_REG_LDO1:
@@ -662,10 +585,10 @@ static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,
                         dcdc_mult--;
                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 
-                tps65910_modify_bits(pmic, TPS65910_VDD1,
-                                (dcdc_mult << VDD1_VGAIN_SEL_SHIFT),
-                                                VDD1_VGAIN_SEL_MASK);
-                tps65910_reg_write_locked(pmic, TPS65910_VDD1_OP, vsel);
+                tps65910_reg_update_bits(pmic->mfd, TPS65910_VDD1,
+                                         VDD1_VGAIN_SEL_MASK,
+                                         dcdc_mult << VDD1_VGAIN_SEL_SHIFT);
+                tps65910_reg_write(pmic->mfd, TPS65910_VDD1_OP, vsel);
                 break;
         case TPS65910_REG_VDD2:
                 dcdc_mult = (selector / VDD1_2_NUM_VOLT_FINE) + 1;
@@ -673,14 +596,14 @@ static int tps65910_set_voltage_dcdc_sel(struct regulator_dev *dev,
                         dcdc_mult--;
                 vsel = (selector % VDD1_2_NUM_VOLT_FINE) + 3;
 
-                tps65910_modify_bits(pmic, TPS65910_VDD2,
-                                (dcdc_mult << VDD2_VGAIN_SEL_SHIFT),
-                                                VDD1_VGAIN_SEL_MASK);
-                tps65910_reg_write_locked(pmic, TPS65910_VDD2_OP, vsel);
+                tps65910_reg_update_bits(pmic->mfd, TPS65910_VDD2,
+                                         VDD1_VGAIN_SEL_MASK,
+                                         dcdc_mult << VDD2_VGAIN_SEL_SHIFT);
+                tps65910_reg_write(pmic->mfd, TPS65910_VDD2_OP, vsel);
                 break;
         case TPS65911_REG_VDDCTRL:
                 vsel = selector + 3;
-                tps65910_reg_write_locked(pmic, TPS65911_VDDCTRL_OP, vsel);
+                tps65910_reg_write(pmic->mfd, TPS65911_VDDCTRL_OP, vsel);
         }
 
         return 0;
@@ -706,8 +629,8 @@ static int tps65910_set_voltage_sel(struct regulator_dev *dev,
         case TPS65910_REG_VAUX2:
         case TPS65910_REG_VAUX33:
         case TPS65910_REG_VMMC:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         }
 
         return -EINVAL;
@@ -727,18 +650,18 @@ static int tps65911_set_voltage_sel(struct regulator_dev *dev,
         case TPS65911_REG_LDO1:
         case TPS65911_REG_LDO2:
         case TPS65911_REG_LDO4:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO1_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO1_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         case TPS65911_REG_LDO3:
         case TPS65911_REG_LDO5:
         case TPS65911_REG_LDO6:
         case TPS65911_REG_LDO7:
         case TPS65911_REG_LDO8:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO3_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO3_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         case TPS65910_REG_VIO:
-                return tps65910_modify_bits(pmic, reg,
-                                (selector << LDO_SEL_SHIFT), LDO_SEL_MASK);
+                return tps65910_reg_update_bits(pmic->mfd, reg, LDO_SEL_MASK,
+                                                selector << LDO_SEL_SHIFT);
         }
 
         return -EINVAL;
@@ -768,23 +691,6 @@ static int tps65910_list_voltage_dcdc(struct regulator_dev *dev,
         return  volt * 100 * mult;
 }
 
-static int tps65910_list_voltage(struct regulator_dev *dev,
-                                        unsigned selector)
-{
-        struct tps65910_reg *pmic = rdev_get_drvdata(dev);
-        int id = rdev_get_id(dev), voltage;
-
-        if (id < TPS65910_REG_VIO || id > TPS65910_REG_VMMC)
-                return -EINVAL;
-
-        if (selector >= pmic->info[id]->n_voltages)
-                return -EINVAL;
-        else
-                voltage = pmic->info[id]->voltage_table[selector] * 1000;
-
-        return voltage;
-}
-
 static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
 {
         struct tps65910_reg *pmic = rdev_get_drvdata(dev);
@@ -816,7 +722,7 @@ static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
                 step_mv = 100;
                 break;
         case TPS65910_REG_VIO:
-                return pmic->info[id]->voltage_table[selector] * 1000;
+                return pmic->info[id]->voltage_table[selector];
         default:
                 return -EINVAL;
         }
@@ -824,42 +730,16 @@ static int tps65911_list_voltage(struct regulator_dev *dev, unsigned selector)
         return (LDO_MIN_VOLT + selector * step_mv) * 1000;
 }
 
-static int tps65910_set_voltage_dcdc_time_sel(struct regulator_dev *dev,
-                unsigned int old_selector, unsigned int new_selector)
-{
-        int id = rdev_get_id(dev);
-        int old_volt, new_volt;
-
-        old_volt = tps65910_list_voltage_dcdc(dev, old_selector);
-        if (old_volt < 0)
-                return old_volt;
-
-        new_volt = tps65910_list_voltage_dcdc(dev, new_selector);
-        if (new_volt < 0)
-                return new_volt;
-
-        /* VDD1 and VDD2 are 12.5mV/us, VDDCTRL is 100mV/20us */
-        switch (id) {
-        case TPS65910_REG_VDD1:
-        case TPS65910_REG_VDD2:
-                return DIV_ROUND_UP(abs(old_volt - new_volt), 12500);
-        case TPS65911_REG_VDDCTRL:
-                return DIV_ROUND_UP(abs(old_volt - new_volt), 5000);
-        }
-        return -EINVAL;
-}
-
 /* Regulator ops (except VRTC) */
 static struct regulator_ops tps65910_ops_dcdc = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65910_get_voltage_dcdc_sel,
         .set_voltage_sel        = tps65910_set_voltage_dcdc_sel,
-        .set_voltage_time_sel   = tps65910_set_voltage_dcdc_time_sel,
+        .set_voltage_time_sel   = regulator_set_voltage_time_sel,
         .list_voltage           = tps65910_list_voltage_dcdc,
 };
 
@@ -867,30 +747,27 @@ static struct regulator_ops tps65910_ops_vdd3 = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage            = tps65910_get_voltage_vdd3,
-        .list_voltage           = tps65910_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static struct regulator_ops tps65910_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65910_get_voltage_sel,
         .set_voltage_sel        = tps65910_set_voltage_sel,
-        .list_voltage           = tps65910_list_voltage,
+        .list_voltage           = regulator_list_voltage_table,
 };
 
 static struct regulator_ops tps65911_ops = {
         .is_enabled             = regulator_is_enabled_regmap,
         .enable                 = regulator_enable_regmap,
         .disable                = regulator_disable_regmap,
-        .enable_time            = tps65910_enable_time,
         .set_mode               = tps65910_set_mode,
         .get_mode               = tps65910_get_mode,
         .get_voltage_sel        = tps65911_get_voltage_sel,
@@ -996,19 +873,27 @@ static int tps65910_set_ext_sleep_config(struct tps65910_reg *pmic,
                                 (tps65910_chip_id(mfd) == TPS65911))) {
                 int op_reg_add = pmic->get_ctrl_reg(id) + 1;
                 int sr_reg_add = pmic->get_ctrl_reg(id) + 2;
-                int opvsel = tps65910_reg_read_locked(pmic, op_reg_add);
-                int srvsel = tps65910_reg_read_locked(pmic, sr_reg_add);
+                int opvsel, srvsel;
+
+                ret = tps65910_reg_read(pmic->mfd, op_reg_add, &opvsel);
+                if (ret < 0)
+                        return ret;
+                ret = tps65910_reg_read(pmic->mfd, sr_reg_add, &srvsel);
+                if (ret < 0)
+                        return ret;
+
                 if (opvsel & VDD1_OP_CMD_MASK) {
                         u8 reg_val = srvsel & VDD1_OP_SEL_MASK;
-                        ret = tps65910_reg_write_locked(pmic, op_reg_add,
-                                                        reg_val);
+
+                        ret = tps65910_reg_write(pmic->mfd, op_reg_add,
+                                                 reg_val);
                         if (ret < 0) {
                                 dev_err(mfd->dev,
                                         "Error in configuring op register\n");
                                 return ret;
                         }
                 }
-                ret = tps65910_reg_write_locked(pmic, sr_reg_add, 0);
+                ret = tps65910_reg_write(pmic->mfd, sr_reg_add, 0);
                 if (ret < 0) {
                         dev_err(mfd->dev, "Error in settting sr register\n");
                         return ret;
@@ -1126,6 +1011,7 @@ static struct tps65910_board *tps65910_parse_dt_reg_data(
                                 "ti,regulator-ext-sleep-control", &prop);
                 if (!ret)
                         pmic_plat_data->regulator_ext_sleep_control[idx] = prop;
+
         }
 
         return pmic_plat_data;
@@ -1136,7 +1022,7 @@ static inline struct tps65910_board *tps65910_parse_dt_reg_data(
                         struct of_regulator_match **tps65910_reg_matches)
 {
         *tps65910_reg_matches = NULL;
-        return 0;
+        return NULL;
 }
 #endif
 
@@ -1168,7 +1054,6 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
-        mutex_init(&pmic->mutex);
         pmic->mfd = tps65910;
         platform_set_drvdata(pdev, pmic);
 
@@ -1229,23 +1114,31 @@ static __devinit int tps65910_probe(struct platform_device *pdev)
                 pmic->info[i] = info;
 
                 pmic->desc[i].name = info->name;
+                pmic->desc[i].supply_name = info->vin_name;
                 pmic->desc[i].id = i;
                 pmic->desc[i].n_voltages = info->n_voltages;
+                pmic->desc[i].enable_time = info->enable_time_us;
 
                 if (i == TPS65910_REG_VDD1 || i == TPS65910_REG_VDD2) {
                         pmic->desc[i].ops = &tps65910_ops_dcdc;
                         pmic->desc[i].n_voltages = VDD1_2_NUM_VOLT_FINE *
                                                         VDD1_2_NUM_VOLT_COARSE;
+                        pmic->desc[i].ramp_delay = 12500;
                 } else if (i == TPS65910_REG_VDD3) {
-                        if (tps65910_chip_id(tps65910) == TPS65910)
+                        if (tps65910_chip_id(tps65910) == TPS65910) {
                                 pmic->desc[i].ops = &tps65910_ops_vdd3;
-                        else
+                                pmic->desc[i].volt_table = info->voltage_table;
+                        } else {
                                 pmic->desc[i].ops = &tps65910_ops_dcdc;
+                                pmic->desc[i].ramp_delay = 5000;
+                        }
                 } else {
-                        if (tps65910_chip_id(tps65910) == TPS65910)
+                        if (tps65910_chip_id(tps65910) == TPS65910) {
                                 pmic->desc[i].ops = &tps65910_ops;
-                        else
+                                pmic->desc[i].volt_table = info->voltage_table;
+                        } else {
                                 pmic->desc[i].ops = &tps65911_ops;
+                        }
                 }
 
                 err = tps65910_set_ext_sleep_config(pmic, i,
diff --git a/drivers/regulator/twl-regulator.c b/drivers/regulator/twl-regulator.c
index c7390711d954..242fe90dc565 100644
--- a/drivers/regulator/twl-regulator.c
+++ b/drivers/regulator/twl-regulator.c
@@ -43,9 +43,6 @@ struct twlreg_info {
         u8                      table_len;
         const u16               *table;
 
-        /* regulator specific turn-on delay */
-        u16                     delay;
-
         /* State REMAP default configuration */
         u8                      remap;
 
@@ -223,20 +220,6 @@ static int twl6030reg_enable(struct regulator_dev *rdev)
         return ret;
 }
 
-static int twl4030reg_enable_time(struct regulator_dev *rdev)
-{
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-
-        return info->delay;
-}
-
-static int twl6030reg_enable_time(struct regulator_dev *rdev)
-{
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
-
-        return info->delay;
-}
-
 static int twl4030reg_disable(struct regulator_dev *rdev)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
@@ -508,7 +491,6 @@ static struct regulator_ops twl4030ldo_ops = {
         .enable         = twl4030reg_enable,
         .disable        = twl4030reg_disable,
         .is_enabled     = twl4030reg_is_enabled,
-        .enable_time    = twl4030reg_enable_time,
 
         .set_mode       = twl4030reg_set_mode,
 
@@ -577,59 +559,53 @@ static struct regulator_ops twl6030coresmps_ops = {
         .get_voltage    = twl6030coresmps_get_voltage,
 };
 
-static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned index)
+static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned sel)
 {
-        struct twlreg_info      *info = rdev_get_drvdata(rdev);
+        struct twlreg_info *info = rdev_get_drvdata(rdev);
 
-        return ((info->min_mV + (index * 100)) * 1000);
+        switch (sel) {
+        case 0:
+                return 0;
+        case 1 ... 24:
+                /* Linear mapping from 00000001 to 00011000:
+                 * Absolute voltage value = 1.0 V + 0.1 V × (sel – 00000001)
+                 */
+                return (info->min_mV + 100 * (sel - 1)) * 1000;
+        case 25 ... 30:
+                return -EINVAL;
+        case 31:
+                return 2750000;
+        default:
+                return -EINVAL;
+        }
 }
 
 static int
-twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV,
-                       unsigned *selector)
+twl6030ldo_set_voltage_sel(struct regulator_dev *rdev, unsigned selector)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
-        int                     vsel;
-
-        if ((min_uV/1000 < info->min_mV) || (max_uV/1000 > info->max_mV))
-                return -EDOM;
-
-        /*
-         * Use the below formula to calculate vsel
-         * 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);
 
+        return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE,
+                            selector);
 }
 
-static int twl6030ldo_get_voltage(struct regulator_dev *rdev)
+static int twl6030ldo_get_voltage_sel(struct regulator_dev *rdev)
 {
         struct twlreg_info      *info = rdev_get_drvdata(rdev);
-        int             vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER,
-                                                                VREG_VOLTAGE);
-
-        if (vsel < 0)
-                return vsel;
+        int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE);
 
-        /*
-         * Use the below formula to calculate vsel
-         * mV = 1000mv + 100mv * (vsel - 1)
-         */
-        return (1000 + (100 * (vsel - 1))) * 1000;
+        return vsel;
 }
 
 static struct regulator_ops twl6030ldo_ops = {
         .list_voltage   = twl6030ldo_list_voltage,
 
-        .set_voltage    = twl6030ldo_set_voltage,
-        .get_voltage    = twl6030ldo_get_voltage,
+        .set_voltage_sel = twl6030ldo_set_voltage_sel,
+        .get_voltage_sel = twl6030ldo_get_voltage_sel,
 
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
 
         .set_mode       = twl6030reg_set_mode,
 
@@ -663,7 +639,6 @@ static struct regulator_ops twl4030fixed_ops = {
         .enable         = twl4030reg_enable,
         .disable        = twl4030reg_disable,
         .is_enabled     = twl4030reg_is_enabled,
-        .enable_time    = twl4030reg_enable_time,
 
         .set_mode       = twl4030reg_set_mode,
 
@@ -678,7 +653,6 @@ static struct regulator_ops twl6030fixed_ops = {
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
 
         .set_mode       = twl6030reg_set_mode,
 
@@ -689,7 +663,6 @@ static struct regulator_ops twl6030_fixed_resource = {
         .enable         = twl6030reg_enable,
         .disable        = twl6030reg_disable,
         .is_enabled     = twl6030reg_is_enabled,
-        .enable_time    = twl6030reg_enable_time,
         .get_status     = twl6030reg_get_status,
 };
 
@@ -886,7 +859,6 @@ static struct regulator_ops twlsmps_ops = {
         .enable                 = twl6030reg_enable,
         .disable                = twl6030reg_disable,
         .is_enabled             = twl6030reg_is_enabled,
-        .enable_time            = twl6030reg_enable_time,
 
         .set_mode               = twl6030reg_set_mode,
 
@@ -909,7 +881,6 @@ static struct twlreg_info TWL4030_INFO_##label = { \
         .id = num, \
         .table_len = ARRAY_SIZE(label##_VSEL_table), \
         .table = label##_VSEL_table, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -918,6 +889,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
                 .ops = &twl4030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -925,7 +897,6 @@ static struct twlreg_info TWL4030_INFO_##label = { \
 static struct twlreg_info TWL4030_INFO_##label = { \
         .base = offset, \
         .id = num, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -933,6 +904,7 @@ static struct twlreg_info TWL4030_INFO_##label = { \
                 .ops = &twl4030smps_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -955,7 +927,7 @@ static struct twlreg_info TWL6030_INFO_##label = { \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
-                .n_voltages = (max_mVolts - min_mVolts)/100 + 1, \
+                .n_voltages = 32, \
                 .ops = &twl6030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
@@ -970,7 +942,7 @@ static struct twlreg_info TWL6025_INFO_##label = { \
         .desc = { \
                 .name = #label, \
                 .id = TWL6025_REG_##label, \
-                .n_voltages = ((max_mVolts - min_mVolts)/100) + 1, \
+                .n_voltages = 32, \
                 .ops = &twl6030ldo_ops, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
@@ -983,7 +955,6 @@ static struct twlreg_info TWLFIXED_INFO_##label = { \
         .base = offset, \
         .id = num, \
         .min_mV = mVolts, \
-        .delay = turnon_delay, \
         .remap = remap_conf, \
         .desc = { \
                 .name = #label, \
@@ -992,19 +963,20 @@ static struct twlreg_info TWLFIXED_INFO_##label = { \
                 .ops = &operations, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
 #define TWL6030_FIXED_RESOURCE(label, offset, turnon_delay) \
 static struct twlreg_info TWLRES_INFO_##label = { \
         .base = offset, \
-        .delay = turnon_delay, \
         .desc = { \
                 .name = #label, \
                 .id = TWL6030_REG_##label, \
                 .ops = &twl6030_fixed_resource, \
                 .type = REGULATOR_VOLTAGE, \
                 .owner = THIS_MODULE, \
+                .enable_time = turnon_delay, \
                 }, \
         }
 
@@ -1109,7 +1081,6 @@ static u8 twl_get_smps_mult(void)
 #define TWL6030_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6030, label)
 #define TWL6025_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWL6025, label)
 #define TWLFIXED_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLFIXED, label)
-#define TWLRES_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLRES, label)
 #define TWLSMPS_OF_MATCH(comp, label) TWL_OF_MATCH(comp, TWLSMPS, label)
 
 static const struct of_device_id twl_of_match[] __devinitconst = {
@@ -1157,7 +1128,6 @@ static const struct of_device_id twl_of_match[] __devinitconst = {
         TWLFIXED_OF_MATCH("ti,twl6030-vusb", VUSB),
         TWLFIXED_OF_MATCH("ti,twl6030-v1v8", V1V8),
         TWLFIXED_OF_MATCH("ti,twl6030-v2v1", V2V1),
-        TWLRES_OF_MATCH("ti,twl6030-clk32kg", CLK32KG),
         TWLSMPS_OF_MATCH("ti,twl6025-smps3", SMPS3),
         TWLSMPS_OF_MATCH("ti,twl6025-smps4", SMPS4),
         TWLSMPS_OF_MATCH("ti,twl6025-vio", VIO),
diff --git a/drivers/regulator/wm831x-dcdc.c b/drivers/regulator/wm831x-dcdc.c
index 099da11e989f..7413885be01b 100644
--- a/drivers/regulator/wm831x-dcdc.c
+++ b/drivers/regulator/wm831x-dcdc.c
@@ -215,8 +215,8 @@ static int wm831x_buckv_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_buckv_select_min_voltage(struct regulator_dev *rdev,
-                                           int min_uV, int max_uV)
+static int wm831x_buckv_map_voltage(struct regulator_dev *rdev,
+                                   int min_uV, int max_uV)
 {
         u16 vsel;
 
@@ -251,20 +251,14 @@ static int wm831x_buckv_set_dvs(struct regulator_dev *rdev, int state)
         return 0;
 }
 
-static int wm831x_buckv_set_voltage(struct regulator_dev *rdev,
-                                    int min_uV, int max_uV, unsigned *selector)
+static int wm831x_buckv_set_voltage_sel(struct regulator_dev *rdev,
+                                        unsigned vsel)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
         int on_reg = dcdc->base + WM831X_DCDC_ON_CONFIG;
         int dvs_reg = dcdc->base + WM831X_DCDC_DVS_CONTROL;
-        int vsel, ret;
-
-        vsel = wm831x_buckv_select_min_voltage(rdev, min_uV, max_uV);
-        if (vsel < 0)
-                return vsel;
-
-        *selector = vsel;
+        int ret;
 
         /* If this value is already set then do a GPIO update if we can */
         if (dcdc->dvs_gpio && dcdc->on_vsel == vsel)
@@ -315,7 +309,7 @@ static int wm831x_buckv_set_suspend_voltage(struct regulator_dev *rdev,
         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
         int vsel;
 
-        vsel = wm831x_buckv_select_min_voltage(rdev, uV, uV);
+        vsel = wm831x_buckv_map_voltage(rdev, uV, uV);
         if (vsel < 0)
                 return vsel;
 
@@ -373,9 +367,10 @@ static int wm831x_buckv_get_current_limit(struct regulator_dev *rdev)
 }
 
 static struct regulator_ops wm831x_buckv_ops = {
-        .set_voltage = wm831x_buckv_set_voltage,
+        .set_voltage_sel = wm831x_buckv_set_voltage_sel,
         .get_voltage_sel = wm831x_buckv_get_voltage_sel,
         .list_voltage = wm831x_buckv_list_voltage,
+        .map_voltage = wm831x_buckv_map_voltage,
         .set_suspend_voltage = wm831x_buckv_set_suspend_voltage,
         .set_current_limit = wm831x_buckv_set_current_limit,
         .get_current_limit = wm831x_buckv_get_current_limit,
@@ -599,60 +594,25 @@ static struct platform_driver wm831x_buckv_driver = {
  * BUCKP specifics
  */
 
-static int wm831x_buckp_list_voltage(struct regulator_dev *rdev,
-                                      unsigned selector)
-{
-        if (selector <= WM831X_BUCKP_MAX_SELECTOR)
-                return 850000 + (selector * 25000);
-        else
-                return -EINVAL;
-}
-
-static int wm831x_buckp_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                        int min_uV, int max_uV, int *selector)
+static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         struct wm831x *wm831x = dcdc->wm831x;
-        u16 vsel;
-
-        if (min_uV <= 34000000)
-                vsel = (min_uV - 850000) / 25000;
-        else
-                return -EINVAL;
-
-        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,
-                                    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,
-                                            selector);
-}
-
-static int wm831x_buckp_set_suspend_voltage(struct regulator_dev *rdev,
-                                            int uV)
-{
-        struct wm831x_dcdc *dcdc = rdev_get_drvdata(rdev);
         u16 reg = dcdc->base + WM831X_DCDC_SLEEP_CONTROL;
-        unsigned selector;
+        int sel;
+
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_buckp_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_DC3_ON_VSEL_MASK, sel);
 }
 
 static struct regulator_ops wm831x_buckp_ops = {
-        .set_voltage = wm831x_buckp_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .list_voltage = wm831x_buckp_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .set_suspend_voltage = wm831x_buckp_set_suspend_voltage,
 
         .is_enabled = regulator_is_enabled_regmap,
@@ -715,6 +675,8 @@ static __devinit int wm831x_buckp_probe(struct platform_device *pdev)
         dcdc->desc.vsel_mask = WM831X_DC3_ON_VSEL_MASK;
         dcdc->desc.enable_reg = WM831X_DCDC_ENABLE;
         dcdc->desc.enable_mask = 1 << id;
+        dcdc->desc.min_uV = 850000;
+        dcdc->desc.uV_step = 25000;
 
         config.dev = pdev->dev.parent;
         if (pdata)
diff --git a/drivers/regulator/wm831x-ldo.c b/drivers/regulator/wm831x-ldo.c
index a9a28d8ac185..5cb70ca1e98d 100644
--- a/drivers/regulator/wm831x-ldo.c
+++ b/drivers/regulator/wm831x-ldo.c
@@ -78,13 +78,10 @@ static int wm831x_gp_ldo_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                         int min_uV, int max_uV,
-                                         unsigned *selector)
+static int wm831x_gp_ldo_map_voltage(struct regulator_dev *rdev,
+                                     int min_uV, int max_uV)
 {
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
+        int volt, vsel;
 
         if (min_uV < 900000)
                 vsel = 0;
@@ -94,36 +91,25 @@ static int wm831x_gp_ldo_set_voltage_int(struct regulator_dev *rdev, int reg,
                 vsel = ((min_uV - 1700000) / 100000)
                         + WM831X_GP_LDO_SELECTOR_LOW + 1;
 
-        ret = wm831x_gp_ldo_list_voltage(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        if (ret < min_uV || ret > max_uV)
+        volt = wm831x_gp_ldo_list_voltage(rdev, vsel);
+        if (volt < min_uV || volt > 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,
-                                     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,
-                                             selector);
+        return vsel;
 }
 
 static int wm831x_gp_ldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
-        unsigned int selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
 
-        return wm831x_gp_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        sel = wm831x_gp_ldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
+
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO1_ON_VSEL_MASK, sel);
 }
 
 static unsigned int wm831x_gp_ldo_get_mode(struct regulator_dev *rdev)
@@ -243,8 +229,9 @@ 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,
+        .map_voltage = wm831x_gp_ldo_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_gp_ldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_gp_ldo_set_suspend_voltage,
         .get_mode = wm831x_gp_ldo_get_mode,
         .set_mode = wm831x_gp_ldo_set_mode,
@@ -384,13 +371,10 @@ static int wm831x_aldo_list_voltage(struct regulator_dev *rdev,
         return -EINVAL;
 }
 
-static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
-                                       int min_uV, int max_uV,
-                                       unsigned *selector)
+static int wm831x_aldo_map_voltage(struct regulator_dev *rdev,
+                                   int min_uV, int max_uV)
 {
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
+        int volt, vsel;
 
         if (min_uV < 1000000)
                 vsel = 0;
@@ -400,35 +384,26 @@ static int wm831x_aldo_set_voltage_int(struct regulator_dev *rdev, int reg,
                 vsel = ((min_uV - 1700000) / 100000)
                         + WM831X_ALDO_SELECTOR_LOW + 1;
 
-        ret = wm831x_aldo_list_voltage(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        if (ret < min_uV || ret > max_uV)
+        volt = wm831x_aldo_list_voltage(rdev, vsel);
+        if (volt < min_uV || volt > 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, unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_ON_CONTROL;
+        return vsel;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, min_uV, max_uV,
-                                           selector);
 }
 
 static int wm831x_aldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
-        unsigned int selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_LDO_SLEEP_CONTROL;
+
+        sel = wm831x_aldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_aldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO7_ON_VSEL_MASK, sel);
 }
 
 static unsigned int wm831x_aldo_get_mode(struct regulator_dev *rdev)
@@ -506,8 +481,9 @@ static int wm831x_aldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_aldo_ops = {
         .list_voltage = wm831x_aldo_list_voltage,
+        .map_voltage = wm831x_aldo_map_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_aldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_aldo_set_suspend_voltage,
         .get_mode = wm831x_aldo_get_mode,
         .set_mode = wm831x_aldo_set_mode,
@@ -628,47 +604,18 @@ static struct platform_driver wm831x_aldo_driver = {
 
 #define WM831X_ALIVE_LDO_MAX_SELECTOR 0xf
 
-static int wm831x_alive_ldo_set_voltage_int(struct regulator_dev *rdev,
-                                            int reg,
-                                            int min_uV, int max_uV,
-                                            unsigned *selector)
-{
-        struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        struct wm831x *wm831x = ldo->wm831x;
-        int vsel, ret;
-
-        vsel = (min_uV - 800000) / 50000;
-
-        ret = regulator_list_voltage_linear(rdev, vsel);
-        if (ret < 0)
-                return ret;
-        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,
-                                        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,
-                                                selector);
-}
-
 static int wm831x_alive_ldo_set_suspend_voltage(struct regulator_dev *rdev,
                                              int uV)
 {
         struct wm831x_ldo *ldo = rdev_get_drvdata(rdev);
-        int reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
-        unsigned selector;
+        struct wm831x *wm831x = ldo->wm831x;
+        int sel, reg = ldo->base + WM831X_ALIVE_LDO_SLEEP_CONTROL;
+
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return sel;
 
-        return wm831x_alive_ldo_set_voltage_int(rdev, reg, uV, uV, &selector);
+        return wm831x_set_bits(wm831x, reg, WM831X_LDO11_ON_VSEL_MASK, sel);
 }
 
 static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
@@ -690,8 +637,9 @@ static int wm831x_alive_ldo_get_status(struct regulator_dev *rdev)
 
 static struct regulator_ops wm831x_alive_ldo_ops = {
         .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
-        .set_voltage = wm831x_alive_ldo_set_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .set_suspend_voltage = wm831x_alive_ldo_set_suspend_voltage,
         .get_status = wm831x_alive_ldo_get_status,
 
@@ -753,6 +701,7 @@ static __devinit int wm831x_alive_ldo_probe(struct platform_device *pdev)
         ldo->desc.enable_mask = 1 << id;
         ldo->desc.min_uV = 800000;
         ldo->desc.uV_step = 50000;
+        ldo->desc.enable_time = 1000;
 
         config.dev = pdev->dev.parent;
         if (pdata)
diff --git a/drivers/regulator/wm8350-regulator.c b/drivers/regulator/wm8350-regulator.c
index 94e550dc70b6..7f0fa22ef2aa 100644
--- a/drivers/regulator/wm8350-regulator.c
+++ b/drivers/regulator/wm8350-regulator.c
@@ -108,33 +108,6 @@ static int get_isink_val(int min_uA, int max_uA, u16 *setting)
         return -EINVAL;
 }
 
-static inline int wm8350_ldo_val_to_mvolts(unsigned int val)
-{
-        if (val < 16)
-                return (val * 50) + 900;
-        else
-                return ((val - 16) * 100) + 1800;
-
-}
-
-static inline unsigned int wm8350_ldo_mvolts_to_val(int mV)
-{
-        if (mV < 1800)
-                return (mV - 900) / 50;
-        else
-                return ((mV - 1800) / 100) + 16;
-}
-
-static inline int wm8350_dcdc_val_to_mvolts(unsigned int val)
-{
-        return (val * 25) + 850;
-}
-
-static inline unsigned int wm8350_dcdc_mvolts_to_val(int mV)
-{
-        return (mV - 850) / 25;
-}
-
 static int wm8350_isink_set_current(struct regulator_dev *rdev, int min_uA,
         int max_uA)
 {
@@ -359,104 +332,13 @@ 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, unsigned *selector)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, dcdc = rdev_get_id(rdev), mV,
-                min_mV = min_uV / 1000, max_mV = max_uV / 1000;
-        u16 val;
-
-        if (min_mV < 850 || min_mV > 4025)
-                return -EINVAL;
-        if (max_mV < 850 || max_mV > 4025)
-                return -EINVAL;
-
-        /* step size is 25mV */
-        mV = (min_mV - 826) / 25;
-        if (wm8350_dcdc_val_to_mvolts(mV) > max_mV)
-                return -EINVAL;
-        BUG_ON(wm8350_dcdc_val_to_mvolts(mV) < min_mV);
-
-        switch (dcdc) {
-        case WM8350_DCDC_1:
-                volt_reg = WM8350_DCDC1_CONTROL;
-                break;
-        case WM8350_DCDC_3:
-                volt_reg = WM8350_DCDC3_CONTROL;
-                break;
-        case WM8350_DCDC_4:
-                volt_reg = WM8350_DCDC4_CONTROL;
-                break;
-        case WM8350_DCDC_6:
-                volt_reg = WM8350_DCDC6_CONTROL;
-                break;
-        case WM8350_DCDC_2:
-        case WM8350_DCDC_5:
-        default:
-                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_sel(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, dcdc = rdev_get_id(rdev);
-
-        switch (dcdc) {
-        case WM8350_DCDC_1:
-                volt_reg = WM8350_DCDC1_CONTROL;
-                break;
-        case WM8350_DCDC_3:
-                volt_reg = WM8350_DCDC3_CONTROL;
-                break;
-        case WM8350_DCDC_4:
-                volt_reg = WM8350_DCDC4_CONTROL;
-                break;
-        case WM8350_DCDC_6:
-                volt_reg = WM8350_DCDC6_CONTROL;
-                break;
-        case WM8350_DCDC_2:
-        case WM8350_DCDC_5:
-        default:
-                return -EINVAL;
-        }
-
-        /* all DCDCs have same mV bits */
-        return wm8350_reg_read(wm8350, volt_reg) & WM8350_DC1_VSEL_MASK;
-}
-
-static int wm8350_dcdc_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        if (selector > WM8350_DCDC_MAX_VSEL)
-                return -EINVAL;
-        return wm8350_dcdc_val_to_mvolts(selector) * 1000;
-}
-
 static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, mV = uV / 1000, dcdc = rdev_get_id(rdev);
+        int sel, volt_reg, dcdc = rdev_get_id(rdev);
         u16 val;
 
-        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, mV);
-
-        if (mV && (mV < 850 || mV > 4025)) {
-                dev_err(wm8350->dev,
-                        "DCDC%d suspend voltage %d mV out of range\n",
-                        dcdc, mV);
-                return -EINVAL;
-        }
-        if (mV == 0)
-                mV = 850;
+        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, dcdc, uV / 1000);
 
         switch (dcdc) {
         case WM8350_DCDC_1:
@@ -477,10 +359,13 @@ static int wm8350_dcdc_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return -EINVAL;
         }
 
+        sel = regulator_map_voltage_linear(rdev, uV, uV);
+        if (sel < 0)
+                return -EINVAL;
+
         /* all DCDCs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_DC1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg,
-                         val | wm8350_dcdc_mvolts_to_val(mV));
+        wm8350_reg_write(wm8350, volt_reg, val | sel);
         return 0;
 }
 
@@ -657,19 +542,49 @@ static int wm8350_dcdc_set_suspend_mode(struct regulator_dev *rdev,
         return 0;
 }
 
+static int wm8350_ldo_list_voltage(struct regulator_dev *rdev,
+                                    unsigned selector)
+{
+        if (selector > WM8350_LDO1_VSEL_MASK)
+                return -EINVAL;
+
+        if (selector < 16)
+                return (selector * 50000) + 900000;
+        else
+                return ((selector - 16) * 100000) + 1800000;
+}
+
+static int wm8350_ldo_map_voltage(struct regulator_dev *rdev, int min_uV,
+                                  int max_uV)
+{
+        int volt, sel;
+        int min_mV = min_uV / 1000;
+        int max_mV = max_uV / 1000;
+
+        if (min_mV < 900 || min_mV > 3300)
+                return -EINVAL;
+        if (max_mV < 900 || max_mV > 3300)
+                return -EINVAL;
+
+        if (min_mV < 1800) /* step size is 50mV < 1800mV */
+                sel = DIV_ROUND_UP(min_uV - 900, 50);
+        else /* step size is 100mV > 1800mV */
+                sel = DIV_ROUND_UP(min_uV - 1800, 100) + 16;
+
+        volt = wm8350_ldo_list_voltage(rdev, sel);
+        if (volt < min_uV || volt > max_uV)
+                return -EINVAL;
+
+        return sel;
+}
+
 static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
 {
         struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, mV = uV / 1000, ldo = rdev_get_id(rdev);
+        int sel, volt_reg, ldo = rdev_get_id(rdev);
         u16 val;
 
-        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, mV);
-
-        if (mV < 900 || mV > 3300) {
-                dev_err(wm8350->dev, "LDO%d voltage %d mV out of range\n",
-                        ldo, mV);
-                return -EINVAL;
-        }
+        dev_dbg(wm8350->dev, "%s %d mV %d\n", __func__, ldo, uV / 1000);
 
         switch (ldo) {
         case WM8350_LDO_1:
@@ -688,10 +603,13 @@ static int wm8350_ldo_set_suspend_voltage(struct regulator_dev *rdev, int uV)
                 return -EINVAL;
         }
 
+        sel = wm8350_ldo_map_voltage(rdev, uV, uV);
+        if (sel < 0)
+                return -EINVAL;
+
         /* all LDOs have same mV bits */
         val = wm8350_reg_read(wm8350, volt_reg) & ~WM8350_LDO1_VSEL_MASK;
-        wm8350_reg_write(wm8350, volt_reg,
-                         val | wm8350_ldo_mvolts_to_val(mV));
+        wm8350_reg_write(wm8350, volt_reg, val | sel);
         return 0;
 }
 
@@ -753,92 +671,6 @@ static int wm8350_ldo_set_suspend_disable(struct regulator_dev *rdev)
         return 0;
 }
 
-static int wm8350_ldo_set_voltage(struct regulator_dev *rdev, int min_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,
-                max_mV = max_uV / 1000;
-        u16 val;
-
-        if (min_mV < 900 || min_mV > 3300)
-                return -EINVAL;
-        if (max_mV < 900 || max_mV > 3300)
-                return -EINVAL;
-
-        if (min_mV < 1800) {
-                /* step size is 50mV < 1800mV */
-                mV = (min_mV - 851) / 50;
-                if (wm8350_ldo_val_to_mvolts(mV) > max_mV)
-                        return -EINVAL;
-                BUG_ON(wm8350_ldo_val_to_mvolts(mV) < min_mV);
-        } else {
-                /* step size is 100mV > 1800mV */
-                mV = ((min_mV - 1701) / 100) + 16;
-                if (wm8350_ldo_val_to_mvolts(mV) > max_mV)
-                        return -EINVAL;
-                BUG_ON(wm8350_ldo_val_to_mvolts(mV) < min_mV);
-        }
-
-        switch (ldo) {
-        case WM8350_LDO_1:
-                volt_reg = WM8350_LDO1_CONTROL;
-                break;
-        case WM8350_LDO_2:
-                volt_reg = WM8350_LDO2_CONTROL;
-                break;
-        case WM8350_LDO_3:
-                volt_reg = WM8350_LDO3_CONTROL;
-                break;
-        case WM8350_LDO_4:
-                volt_reg = WM8350_LDO4_CONTROL;
-                break;
-        default:
-                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_sel(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int volt_reg, ldo = rdev_get_id(rdev);
-
-        switch (ldo) {
-        case WM8350_LDO_1:
-                volt_reg = WM8350_LDO1_CONTROL;
-                break;
-        case WM8350_LDO_2:
-                volt_reg = WM8350_LDO2_CONTROL;
-                break;
-        case WM8350_LDO_3:
-                volt_reg = WM8350_LDO3_CONTROL;
-                break;
-        case WM8350_LDO_4:
-                volt_reg = WM8350_LDO4_CONTROL;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        /* all LDOs have same mV bits */
-        return wm8350_reg_read(wm8350, volt_reg) & WM8350_LDO1_VSEL_MASK;
-}
-
-static int wm8350_ldo_list_voltage(struct regulator_dev *rdev,
-                                    unsigned selector)
-{
-        if (selector > WM8350_LDO1_VSEL_MASK)
-                return -EINVAL;
-        return wm8350_ldo_val_to_mvolts(selector) * 1000;
-}
-
 int wm8350_dcdc_set_slot(struct wm8350 *wm8350, int dcdc, u16 start,
                          u16 stop, u16 fault)
 {
@@ -959,63 +791,6 @@ int wm8350_dcdc25_set_mode(struct wm8350 *wm8350, int dcdc, u16 mode,
 }
 EXPORT_SYMBOL_GPL(wm8350_dcdc25_set_mode);
 
-static int wm8350_dcdc_enable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev);
-        u16 shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
-static int wm8350_dcdc_disable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev);
-        u16 shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-
-        return 0;
-}
-
-static int wm8350_ldo_enable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev);
-        u16 shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        wm8350_set_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
-static int wm8350_ldo_disable(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev);
-        u16 shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        wm8350_clear_bits(wm8350, WM8350_DCDC_LDO_REQUESTED, 1 << shift);
-        return 0;
-}
-
 static int force_continuous_enable(struct wm8350 *wm8350, int dcdc, int enable)
 {
         int reg = 0, ret;
@@ -1197,42 +972,17 @@ static unsigned int wm8350_dcdc_get_optimum_mode(struct regulator_dev *rdev,
         return mode;
 }
 
-static int wm8350_dcdc_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int dcdc = rdev_get_id(rdev), shift;
-
-        if (dcdc < WM8350_DCDC_1 || dcdc > WM8350_DCDC_6)
-                return -EINVAL;
-
-        shift = dcdc - WM8350_DCDC_1;
-        return wm8350_reg_read(wm8350, WM8350_DCDC_LDO_REQUESTED)
-            & (1 << shift);
-}
-
-static int wm8350_ldo_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8350 *wm8350 = rdev_get_drvdata(rdev);
-        int ldo = rdev_get_id(rdev), shift;
-
-        if (ldo < WM8350_LDO_1 || ldo > WM8350_LDO_4)
-                return -EINVAL;
-
-        shift = (ldo - WM8350_LDO_1) + 8;
-        return wm8350_reg_read(wm8350, WM8350_DCDC_LDO_REQUESTED)
-            & (1 << shift);
-}
-
 static struct regulator_ops wm8350_dcdc_ops = {
-        .set_voltage = wm8350_dcdc_set_voltage,
-        .get_voltage_sel = wm8350_dcdc_get_voltage_sel,
-        .list_voltage = wm8350_dcdc_list_voltage,
-        .enable = wm8350_dcdc_enable,
-        .disable = wm8350_dcdc_disable,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .get_mode = wm8350_dcdc_get_mode,
         .set_mode = wm8350_dcdc_set_mode,
         .get_optimum_mode = wm8350_dcdc_get_optimum_mode,
-        .is_enabled = wm8350_dcdc_is_enabled,
         .set_suspend_voltage = wm8350_dcdc_set_suspend_voltage,
         .set_suspend_enable = wm8350_dcdc_set_suspend_enable,
         .set_suspend_disable = wm8350_dcdc_set_suspend_disable,
@@ -1240,20 +990,21 @@ static struct regulator_ops wm8350_dcdc_ops = {
 };
 
 static struct regulator_ops wm8350_dcdc2_5_ops = {
-        .enable = wm8350_dcdc_enable,
-        .disable = wm8350_dcdc_disable,
-        .is_enabled = wm8350_dcdc_is_enabled,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .set_suspend_enable = wm8350_dcdc25_set_suspend_enable,
         .set_suspend_disable = wm8350_dcdc25_set_suspend_disable,
 };
 
 static struct regulator_ops wm8350_ldo_ops = {
-        .set_voltage = wm8350_ldo_set_voltage,
-        .get_voltage_sel = wm8350_ldo_get_voltage_sel,
+        .map_voltage = wm8350_ldo_map_voltage,
+        .set_voltage_sel = regulator_set_voltage_sel_regmap,
+        .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .list_voltage = wm8350_ldo_list_voltage,
-        .enable = wm8350_ldo_enable,
-        .disable = wm8350_ldo_disable,
-        .is_enabled = wm8350_ldo_is_enabled,
+        .enable = regulator_enable_regmap,
+        .disable = regulator_disable_regmap,
+        .is_enabled = regulator_is_enabled_regmap,
         .get_mode = wm8350_ldo_get_mode,
         .set_suspend_voltage = wm8350_ldo_set_suspend_voltage,
         .set_suspend_enable = wm8350_ldo_set_suspend_enable,
@@ -1277,6 +1028,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC1,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC1_CONTROL,
+                .vsel_mask = WM8350_DC1_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC1_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1285,6 +1042,8 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .ops = &wm8350_dcdc2_5_ops,
                 .irq = WM8350_IRQ_UV_DC2,
                 .type = REGULATOR_VOLTAGE,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC2_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1294,6 +1053,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC3,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC3_CONTROL,
+                .vsel_mask = WM8350_DC3_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC3_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1303,6 +1068,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC4,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC4_CONTROL,
+                .vsel_mask = WM8350_DC4_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC4_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1311,6 +1082,8 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .ops = &wm8350_dcdc2_5_ops,
                 .irq = WM8350_IRQ_UV_DC5,
                 .type = REGULATOR_VOLTAGE,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC5_ENA,
                 .owner = THIS_MODULE,
          },
         {
@@ -1320,6 +1093,12 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_DC6,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_DCDC_MAX_VSEL + 1,
+                .min_uV = 850000,
+                .uV_step = 25000,
+                .vsel_reg = WM8350_DCDC6_CONTROL,
+                .vsel_mask = WM8350_DC6_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_DC6_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1329,6 +1108,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO1,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO1_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO1_CONTROL,
+                .vsel_mask = WM8350_LDO1_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO1_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1338,6 +1121,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO2,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO2_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO2_CONTROL,
+                .vsel_mask = WM8350_LDO2_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO2_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1347,6 +1134,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO3,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO3_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO3_CONTROL,
+                .vsel_mask = WM8350_LDO3_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO3_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1356,6 +1147,10 @@ static const struct regulator_desc wm8350_reg[NUM_WM8350_REGULATORS] = {
                 .irq = WM8350_IRQ_UV_LDO4,
                 .type = REGULATOR_VOLTAGE,
                 .n_voltages = WM8350_LDO4_VSEL_MASK + 1,
+                .vsel_reg = WM8350_LDO4_CONTROL,
+                .vsel_mask = WM8350_LDO4_VSEL_MASK,
+                .enable_reg = WM8350_DCDC_LDO_REQUESTED,
+                .enable_mask = WM8350_LDO4_ENA,
                 .owner = THIS_MODULE,
         },
         {
@@ -1429,6 +1224,7 @@ static int wm8350_regulator_probe(struct platform_device *pdev)
         config.dev = &pdev->dev;
         config.init_data = pdev->dev.platform_data;
         config.driver_data = dev_get_drvdata(&pdev->dev);
+        config.regmap = wm8350->regmap;
 
         /* register regulator */
         rdev = regulator_register(&wm8350_reg[pdev->id], &config);
diff --git a/drivers/regulator/wm8400-regulator.c b/drivers/regulator/wm8400-regulator.c
index 69a2b7ce5e4a..9035dd053611 100644
--- a/drivers/regulator/wm8400-regulator.c
+++ b/drivers/regulator/wm8400-regulator.c
@@ -28,34 +28,26 @@ static int wm8400_ldo_list_voltage(struct regulator_dev *dev,
         if (selector < 15)
                 return 900000 + (selector * 50000);
         else
-                return 1600000 + ((selector - 14) * 100000);
+                return 1700000 + ((selector - 15) * 100000);
 }
 
 static int wm8400_ldo_map_voltage(struct regulator_dev *dev,
                                   int min_uV, int max_uV)
 {
         u16 val;
+        int volt;
 
         if (min_uV < 900000 || min_uV > 3300000)
                 return -EINVAL;
 
-        if (min_uV < 1700000) {
-                /* Steps of 50mV from 900mV;  */
+        if (min_uV < 1700000) /* Steps of 50mV from 900mV;  */
                 val = DIV_ROUND_UP(min_uV - 900000, 50000);
+        else /* Steps of 100mV from 1700mV */
+                val = DIV_ROUND_UP(min_uV - 1700000, 100000) + 15;
 
-                if ((val * 50000) + 900000 > max_uV)
-                        return -EINVAL;
-                BUG_ON((val * 50000) + 900000 < min_uV);
-        } else {
-                /* Steps of 100mV from 1700mV */
-                val = DIV_ROUND_UP(min_uV - 1700000, 100000);
-
-                if ((val * 100000) + 1700000 > max_uV)
-                        return -EINVAL;
-                BUG_ON((val * 100000) + 1700000 < min_uV);
-
-                val += 0xf;
-        }
+        volt = wm8400_ldo_list_voltage(dev, val);
+        if (volt < min_uV || volt > max_uV)
+                return -EINVAL;
 
         return val;
 }
@@ -152,6 +144,7 @@ static struct regulator_ops wm8400_dcdc_ops = {
         .enable = regulator_enable_regmap,
         .disable = regulator_disable_regmap,
         .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
         .get_mode = wm8400_dcdc_get_mode,
diff --git a/drivers/regulator/wm8994-regulator.c b/drivers/regulator/wm8994-regulator.c
index 9a994316e63c..86bb48db149e 100644
--- a/drivers/regulator/wm8994-regulator.c
+++ b/drivers/regulator/wm8994-regulator.c
@@ -26,8 +26,6 @@
 #include <linux/mfd/wm8994/pdata.h>
 
 struct wm8994_ldo {
-        int enable;
-        bool is_enabled;
         struct regulator_dev *regulator;
         struct wm8994 *wm8994;
 };
@@ -35,64 +33,9 @@ struct wm8994_ldo {
 #define WM8994_LDO1_MAX_SELECTOR 0x7
 #define WM8994_LDO2_MAX_SELECTOR 0x3
 
-static int wm8994_ldo_enable(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        /* If we have no soft control assume that the LDO is always enabled. */
-        if (!ldo->enable)
-                return 0;
-
-        gpio_set_value_cansleep(ldo->enable, 1);
-        ldo->is_enabled = true;
-
-        return 0;
-}
-
-static int wm8994_ldo_disable(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        /* If we have no soft control assume that the LDO is always enabled. */
-        if (!ldo->enable)
-                return -EINVAL;
-
-        gpio_set_value_cansleep(ldo->enable, 0);
-        ldo->is_enabled = false;
-
-        return 0;
-}
-
-static int wm8994_ldo_is_enabled(struct regulator_dev *rdev)
-{
-        struct wm8994_ldo *ldo = rdev_get_drvdata(rdev);
-
-        return ldo->is_enabled;
-}
-
-static int wm8994_ldo_enable_time(struct regulator_dev *rdev)
-{
-        /* 3ms is fairly conservative but this shouldn't be too performance
-         * critical; can be tweaked per-system if required. */
-        return 3000;
-}
-
-static int wm8994_ldo1_list_voltage(struct regulator_dev *rdev,
-                                    unsigned int selector)
-{
-        if (selector > WM8994_LDO1_MAX_SELECTOR)
-                return -EINVAL;
-
-        return (selector * 100000) + 2400000;
-}
-
 static struct regulator_ops wm8994_ldo1_ops = {
-        .enable = wm8994_ldo_enable,
-        .disable = wm8994_ldo_disable,
-        .is_enabled = wm8994_ldo_is_enabled,
-        .enable_time = wm8994_ldo_enable_time,
-
-        .list_voltage = wm8994_ldo1_list_voltage,
+        .list_voltage = regulator_list_voltage_linear,
+        .map_voltage = regulator_map_voltage_linear,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
 };
@@ -124,11 +67,6 @@ static int wm8994_ldo2_list_voltage(struct regulator_dev *rdev,
 }
 
 static struct regulator_ops wm8994_ldo2_ops = {
-        .enable = wm8994_ldo_enable,
-        .disable = wm8994_ldo_disable,
-        .is_enabled = wm8994_ldo_is_enabled,
-        .enable_time = wm8994_ldo_enable_time,
-
         .list_voltage = wm8994_ldo2_list_voltage,
         .get_voltage_sel = regulator_get_voltage_sel_regmap,
         .set_voltage_sel = regulator_set_voltage_sel_regmap,
@@ -143,6 +81,9 @@ static const struct regulator_desc wm8994_ldo_desc[] = {
                 .vsel_reg = WM8994_LDO_1,
                 .vsel_mask = WM8994_LDO1_VSEL_MASK,
                 .ops = &wm8994_ldo1_ops,
+                .min_uV = 2400000,
+                .uV_step = 100000,
+                .enable_time = 3000,
                 .owner = THIS_MODULE,
         },
         {
@@ -153,6 +94,7 @@ static const struct regulator_desc wm8994_ldo_desc[] = {
                 .vsel_reg = WM8994_LDO_2,
                 .vsel_mask = WM8994_LDO2_VSEL_MASK,
                 .ops = &wm8994_ldo2_ops,
+                .enable_time = 3000,
                 .owner = THIS_MODULE,
         },
 };
@@ -176,39 +118,26 @@ static __devinit int wm8994_ldo_probe(struct platform_device *pdev)
 
         ldo->wm8994 = wm8994;
 
-        if (pdata->ldo[id].enable && gpio_is_valid(pdata->ldo[id].enable)) {
-                ldo->enable = pdata->ldo[id].enable;
-
-                ret = gpio_request_one(ldo->enable, 0, "WM8994 LDO enable");
-                if (ret < 0) {
-                        dev_err(&pdev->dev, "Failed to get enable GPIO: %d\n",
-                                ret);
-                        goto err;
-                }
-        } else
-                ldo->is_enabled = true;
-
         config.dev = wm8994->dev;
         config.driver_data = ldo;
         config.regmap = wm8994->regmap;
-        if (pdata)
+        if (pdata) {
                 config.init_data = pdata->ldo[id].init_data;
+                config.ena_gpio = pdata->ldo[id].enable;
+        }
 
         ldo->regulator = regulator_register(&wm8994_ldo_desc[id], &config);
         if (IS_ERR(ldo->regulator)) {
                 ret = PTR_ERR(ldo->regulator);
                 dev_err(wm8994->dev, "Failed to register LDO%d: %d\n",
                         id + 1, ret);
-                goto err_gpio;
+                goto err;
         }
 
         platform_set_drvdata(pdev, ldo);
 
         return 0;
 
-err_gpio:
-        if (gpio_is_valid(ldo->enable))
-                gpio_free(ldo->enable);
 err:
         return ret;
 }
@@ -220,8 +149,6 @@ static __devexit int wm8994_ldo_remove(struct platform_device *pdev)
         platform_set_drvdata(pdev, NULL);
 
         regulator_unregister(ldo->regulator);
-        if (gpio_is_valid(ldo->enable))
-                gpio_free(ldo->enable);
 
         return 0;
 }
diff --git a/drivers/remoteproc/Kconfig b/drivers/remoteproc/Kconfig
index 24d880e78ec6..f8d818abf98c 100644
--- a/drivers/remoteproc/Kconfig
+++ b/drivers/remoteproc/Kconfig
@@ -4,9 +4,11 @@ menu "Remoteproc drivers (EXPERIMENTAL)"
 config REMOTEPROC
         tristate
         depends on EXPERIMENTAL
+        select FW_CONFIG
 
 config OMAP_REMOTEPROC
         tristate "OMAP remoteproc support"
+        depends on EXPERIMENTAL
         depends on ARCH_OMAP4
         depends on OMAP_IOMMU
         select REMOTEPROC
diff --git a/drivers/rpmsg/virtio_rpmsg_bus.c b/drivers/rpmsg/virtio_rpmsg_bus.c
index 75506ec2840e..39d3aa41adda 100644
--- a/drivers/rpmsg/virtio_rpmsg_bus.c
+++ b/drivers/rpmsg/virtio_rpmsg_bus.c
@@ -188,6 +188,26 @@ static int rpmsg_uevent(struct device *dev, struct kobj_uevent_env *env)
                                         rpdev->id.name);
 }
 
+/**
+ * __ept_release() - deallocate an rpmsg endpoint
+ * @kref: the ept's reference count
+ *
+ * This function deallocates an ept, and is invoked when its @kref refcount
+ * drops to zero.
+ *
+ * Never invoke this function directly!
+ */
+static void __ept_release(struct kref *kref)
+{
+        struct rpmsg_endpoint *ept = container_of(kref, struct rpmsg_endpoint,
+                                                  refcount);
+        /*
+         * At this point no one holds a reference to ept anymore,
+         * so we can directly free it
+         */
+        kfree(ept);
+}
+
 /* for more info, see below documentation of rpmsg_create_ept() */
 static struct rpmsg_endpoint *__rpmsg_create_ept(struct virtproc_info *vrp,
                 struct rpmsg_channel *rpdev, rpmsg_rx_cb_t cb,
@@ -206,6 +226,9 @@ static struct rpmsg_endpoint *__rpmsg_create_ept(struct virtproc_info *vrp,
                 return NULL;
         }
 
+        kref_init(&ept->refcount);
+        mutex_init(&ept->cb_lock);
+
         ept->rpdev = rpdev;
         ept->cb = cb;
         ept->priv = priv;
@@ -238,7 +261,7 @@ rem_idr:
         idr_remove(&vrp->endpoints, request);
 free_ept:
         mutex_unlock(&vrp->endpoints_lock);
-        kfree(ept);
+        kref_put(&ept->refcount, __ept_release);
         return NULL;
 }
 
@@ -302,11 +325,17 @@ EXPORT_SYMBOL(rpmsg_create_ept);
 static void
 __rpmsg_destroy_ept(struct virtproc_info *vrp, struct rpmsg_endpoint *ept)
 {
+        /* make sure new inbound messages can't find this ept anymore */
         mutex_lock(&vrp->endpoints_lock);
         idr_remove(&vrp->endpoints, ept->addr);
         mutex_unlock(&vrp->endpoints_lock);
 
-        kfree(ept);
+        /* make sure in-flight inbound messages won't invoke cb anymore */
+        mutex_lock(&ept->cb_lock);
+        ept->cb = NULL;
+        mutex_unlock(&ept->cb_lock);
+
+        kref_put(&ept->refcount, __ept_release);
 }
 
 /**
@@ -790,12 +819,28 @@ static void rpmsg_recv_done(struct virtqueue *rvq)
 
         /* use the dst addr to fetch the callback of the appropriate user */
         mutex_lock(&vrp->endpoints_lock);
+
         ept = idr_find(&vrp->endpoints, msg->dst);
+
+        /* let's make sure no one deallocates ept while we use it */
+        if (ept)
+                kref_get(&ept->refcount);
+
         mutex_unlock(&vrp->endpoints_lock);
 
-        if (ept && ept->cb)
-                ept->cb(ept->rpdev, msg->data, msg->len, ept->priv, msg->src);
-        else
+        if (ept) {
+                /* make sure ept->cb doesn't go away while we use it */
+                mutex_lock(&ept->cb_lock);
+
+                if (ept->cb)
+                        ept->cb(ept->rpdev, msg->data, msg->len, ept->priv,
+                                msg->src);
+
+                mutex_unlock(&ept->cb_lock);
+
+                /* farewell, ept, we don't need you anymore */
+                kref_put(&ept->refcount, __ept_release);
+        } else
                 dev_warn(dev, "msg received with no recepient\n");
 
         /* publish the real size of the buffer */
diff --git a/drivers/rtc/rtc-ab8500.c b/drivers/rtc/rtc-ab8500.c
index 4bcf9ca2818a..370889d0489b 100644
--- a/drivers/rtc/rtc-ab8500.c
+++ b/drivers/rtc/rtc-ab8500.c
@@ -17,6 +17,7 @@
 #include <linux/mfd/abx500.h>
 #include <linux/mfd/abx500/ab8500.h>
 #include <linux/delay.h>
+#include <linux/of.h>
 
 #define AB8500_RTC_SOFF_STAT_REG        0x00
 #define AB8500_RTC_CC_CONF_REG          0x01
@@ -422,7 +423,7 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
         }
 
         err = request_threaded_irq(irq, NULL, rtc_alarm_handler,
-                IRQF_NO_SUSPEND, "ab8500-rtc", rtc);
+                IRQF_NO_SUSPEND | IRQF_ONESHOT, "ab8500-rtc", rtc);
         if (err < 0) {
                 rtc_device_unregister(rtc);
                 return err;
@@ -430,7 +431,6 @@ static int __devinit ab8500_rtc_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, rtc);
 
-
         err = ab8500_sysfs_rtc_register(&pdev->dev);
         if (err) {
                 dev_err(&pdev->dev, "sysfs RTC failed to register\n");
@@ -454,10 +454,16 @@ static int __devexit ab8500_rtc_remove(struct platform_device *pdev)
         return 0;
 }
 
+static const struct of_device_id ab8500_rtc_match[] = {
+        { .compatible = "stericsson,ab8500-rtc", },
+        {}
+};
+
 static struct platform_driver ab8500_rtc_driver = {
         .driver = {
                 .name = "ab8500-rtc",
                 .owner = THIS_MODULE,
+                .of_match_table = ab8500_rtc_match,
         },
         .probe  = ab8500_rtc_probe,
         .remove = __devexit_p(ab8500_rtc_remove),
diff --git a/drivers/rtc/rtc-mxc.c b/drivers/rtc/rtc-mxc.c
index 5e1d64ee5228..e3e50d69baf8 100644
--- a/drivers/rtc/rtc-mxc.c
+++ b/drivers/rtc/rtc-mxc.c
@@ -202,10 +202,11 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
         struct platform_device *pdev = dev_id;
         struct rtc_plat_data *pdata = platform_get_drvdata(pdev);
         void __iomem *ioaddr = pdata->ioaddr;
+        unsigned long flags;
         u32 status;
         u32 events = 0;
 
-        spin_lock_irq(&pdata->rtc->irq_lock);
+        spin_lock_irqsave(&pdata->rtc->irq_lock, flags);
         status = readw(ioaddr + RTC_RTCISR) & readw(ioaddr + RTC_RTCIENR);
         /* clear interrupt sources */
         writew(status, ioaddr + RTC_RTCISR);
@@ -224,7 +225,7 @@ static irqreturn_t mxc_rtc_interrupt(int irq, void *dev_id)
                 events |= (RTC_PF | RTC_IRQF);
 
         rtc_update_irq(pdata->rtc, 1, events);
-        spin_unlock_irq(&pdata->rtc->irq_lock);
+        spin_unlock_irqrestore(&pdata->rtc->irq_lock, flags);
 
         return IRQ_HANDLED;
 }
diff --git a/drivers/rtc/rtc-spear.c b/drivers/rtc/rtc-spear.c
index 1f76320e545b..e2785479113c 100644
--- a/drivers/rtc/rtc-spear.c
+++ b/drivers/rtc/rtc-spear.c
@@ -458,12 +458,12 @@ static int __devexit spear_rtc_remove(struct platform_device *pdev)
         clk_disable(config->clk);
         clk_put(config->clk);
         iounmap(config->ioaddr);
-        kfree(config);
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (res)
                 release_mem_region(res->start, resource_size(res));
         platform_set_drvdata(pdev, NULL);
         rtc_device_unregister(config->rtc);
+        kfree(config);
 
         return 0;
 }
diff --git a/drivers/rtc/rtc-twl.c b/drivers/rtc/rtc-twl.c
index 258abeabf624..c5d06fe83bba 100644
--- a/drivers/rtc/rtc-twl.c
+++ b/drivers/rtc/rtc-twl.c
@@ -510,7 +510,7 @@ static int __devinit twl_rtc_probe(struct platform_device *pdev)
         }
 
         ret = request_threaded_irq(irq, NULL, twl_rtc_interrupt,
-                                   IRQF_TRIGGER_RISING,
+                                   IRQF_TRIGGER_RISING | IRQF_ONESHOT,
                                    dev_name(&rtc->dev), rtc);
         if (ret < 0) {
                 dev_err(&pdev->dev, "IRQ is not free.\n");
diff --git a/drivers/scsi/aic94xx/aic94xx_task.c b/drivers/scsi/aic94xx/aic94xx_task.c
index 532d212b6b2c..393e7ce8e95a 100644
--- a/drivers/scsi/aic94xx/aic94xx_task.c
+++ b/drivers/scsi/aic94xx/aic94xx_task.c
@@ -201,7 +201,7 @@ static void asd_get_response_tasklet(struct asd_ascb *ascb,
 
                 if (SAS_STATUS_BUF_SIZE >= sizeof(*resp)) {
                         resp->frame_len = le16_to_cpu(*(__le16 *)(r+6));
-                        memcpy(&resp->ending_fis[0], r+16, 24);
+                        memcpy(&resp->ending_fis[0], r+16, ATA_RESP_FIS_SIZE);
                         ts->buf_valid_size = sizeof(*resp);
                 }
         }
diff --git a/drivers/scsi/bnx2i/bnx2i.h b/drivers/scsi/bnx2i/bnx2i.h
index 0c53c28dc3d3..7e77cf620291 100644
--- a/drivers/scsi/bnx2i/bnx2i.h
+++ b/drivers/scsi/bnx2i/bnx2i.h
@@ -350,6 +350,7 @@ struct bnx2i_hba {
         struct pci_dev *pcidev;
         struct net_device *netdev;
         void __iomem *regview;
+        resource_size_t reg_base;
 
         u32 age;
         unsigned long cnic_dev_type;
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index ece47e502282..86a12b48e477 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -2724,7 +2724,6 @@ int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep)
                 goto arm_cq;
         }
 
-        reg_base = ep->hba->netdev->base_addr;
         if ((test_bit(BNX2I_NX2_DEV_5709, &ep->hba->cnic_dev_type)) &&
             (ep->hba->mail_queue_access == BNX2I_MQ_BIN_MODE)) {
                 config2 = REG_RD(ep->hba, BNX2_MQ_CONFIG2);
@@ -2740,7 +2739,7 @@ int bnx2i_map_ep_dbell_regs(struct bnx2i_endpoint *ep)
                 /* 5709 device in normal node and 5706/5708 devices */
                 reg_off = CTX_OFFSET + (MB_KERNEL_CTX_SIZE * cid_num);
 
-        ep->qp.ctx_base = ioremap_nocache(reg_base + reg_off,
+        ep->qp.ctx_base = ioremap_nocache(ep->hba->reg_base + reg_off,
                                           MB_KERNEL_CTX_SIZE);
         if (!ep->qp.ctx_base)
                 return -ENOMEM;
diff --git a/drivers/scsi/bnx2i/bnx2i_iscsi.c b/drivers/scsi/bnx2i/bnx2i_iscsi.c
index f8d516b53161..621538b8b544 100644
--- a/drivers/scsi/bnx2i/bnx2i_iscsi.c
+++ b/drivers/scsi/bnx2i/bnx2i_iscsi.c
@@ -811,13 +811,13 @@ struct bnx2i_hba *bnx2i_alloc_hba(struct cnic_dev *cnic)
         bnx2i_identify_device(hba);
         bnx2i_setup_host_queue_size(hba, shost);
 
+        hba->reg_base = pci_resource_start(hba->pcidev, 0);
         if (test_bit(BNX2I_NX2_DEV_5709, &hba->cnic_dev_type)) {
-                hba->regview = ioremap_nocache(hba->netdev->base_addr,
-                                               BNX2_MQ_CONFIG2);
+                hba->regview = pci_iomap(hba->pcidev, 0, BNX2_MQ_CONFIG2);
                 if (!hba->regview)
                         goto ioreg_map_err;
         } else if (test_bit(BNX2I_NX2_DEV_57710, &hba->cnic_dev_type)) {
-                hba->regview = ioremap_nocache(hba->netdev->base_addr, 4096);
+                hba->regview = pci_iomap(hba->pcidev, 0, 4096);
                 if (!hba->regview)
                         goto ioreg_map_err;
         }
@@ -884,7 +884,7 @@ cid_que_err:
         bnx2i_free_mp_bdt(hba);
 mp_bdt_mem_err:
         if (hba->regview) {
-                iounmap(hba->regview);
+                pci_iounmap(hba->pcidev, hba->regview);
                 hba->regview = NULL;
         }
 ioreg_map_err:
@@ -910,7 +910,7 @@ void bnx2i_free_hba(struct bnx2i_hba *hba)
         pci_dev_put(hba->pcidev);
 
         if (hba->regview) {
-                iounmap(hba->regview);
+                pci_iounmap(hba->pcidev, hba->regview);
                 hba->regview = NULL;
         }
         bnx2i_free_mp_bdt(hba);
diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
index 441d88ad99a7..d109cc3a17b6 100644
--- a/drivers/scsi/libsas/sas_ata.c
+++ b/drivers/scsi/libsas/sas_ata.c
@@ -139,12 +139,12 @@ static void sas_ata_task_done(struct sas_task *task)
         if (stat->stat == SAS_PROTO_RESPONSE || stat->stat == SAM_STAT_GOOD ||
             ((stat->stat == SAM_STAT_CHECK_CONDITION &&
               dev->sata_dev.command_set == ATAPI_COMMAND_SET))) {
-                ata_tf_from_fis(resp->ending_fis, &dev->sata_dev.tf);
+                memcpy(dev->sata_dev.fis, resp->ending_fis, ATA_RESP_FIS_SIZE);
 
                 if (!link->sactive) {
-                        qc->err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                        qc->err_mask |= ac_err_mask(dev->sata_dev.fis[2]);
                 } else {
-                        link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.tf.command);
+                        link->eh_info.err_mask |= ac_err_mask(dev->sata_dev.fis[2]);
                         if (unlikely(link->eh_info.err_mask))
                                 qc->flags |= ATA_QCFLAG_FAILED;
                 }
@@ -161,8 +161,8 @@ static void sas_ata_task_done(struct sas_task *task)
                                 qc->flags |= ATA_QCFLAG_FAILED;
                         }
 
-                        dev->sata_dev.tf.feature = 0x04; /* status err */
-                        dev->sata_dev.tf.command = ATA_ERR;
+                        dev->sata_dev.fis[3] = 0x04; /* status err */
+                        dev->sata_dev.fis[2] = ATA_ERR;
                 }
         }
 
@@ -269,7 +269,7 @@ static bool sas_ata_qc_fill_rtf(struct ata_queued_cmd *qc)
 {
         struct domain_device *dev = qc->ap->private_data;
 
-        memcpy(&qc->result_tf, &dev->sata_dev.tf, sizeof(qc->result_tf));
+        ata_tf_from_fis(dev->sata_dev.fis, &qc->result_tf);
         return true;
 }
 
diff --git a/drivers/scsi/qla2xxx/qla_target.c b/drivers/scsi/qla2xxx/qla_target.c
index 6986552b47e6..77759c78cc21 100644
--- a/drivers/scsi/qla2xxx/qla_target.c
+++ b/drivers/scsi/qla2xxx/qla_target.c
@@ -3960,7 +3960,7 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
 {
         struct qla_hw_data *ha = vha->hw;
         struct qla_tgt *tgt = ha->tgt.qla_tgt;
-        int reason_code;
+        int login_code;
 
         ql_dbg(ql_dbg_tgt, vha, 0xe039,
             "scsi(%ld): ha state %d init_done %d oper_mode %d topo %d\n",
@@ -4003,9 +4003,9 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         {
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03b,
                     "qla_target(%d): Async LOOP_UP occured "
-                    "(m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 if (tgt->link_reinit_iocb_pending) {
                         qlt_send_notify_ack(vha, (void *)&tgt->link_reinit_iocb,
                             0, 0, 0, 0, 0, 0);
@@ -4020,23 +4020,24 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         case MBA_RSCN_UPDATE:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03c,
                     "qla_target(%d): Async event %#x occured "
-                    "(m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx, code,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "(m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx, code,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 break;
 
         case MBA_PORT_UPDATE:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03d,
                     "qla_target(%d): Port update async event %#x "
-                    "occured: updating the ports database (m[1]=%x, m[2]=%x, "
-                    "m[3]=%x, m[4]=%x)", vha->vp_idx, code,
-                    le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
-                reason_code = le16_to_cpu(mailbox[2]);
-                if (reason_code == 0x4)
+                    "occured: updating the ports database (m[0]=%x, m[1]=%x, "
+                    "m[2]=%x, m[3]=%x)", vha->vp_idx, code,
+                    le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
+
+                login_code = le16_to_cpu(mailbox[2]);
+                if (login_code == 0x4)
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03e,
                             "Async MB 2: Got PLOGI Complete\n");
-                else if (reason_code == 0x7)
+                else if (login_code == 0x7)
                         ql_dbg(ql_dbg_tgt_mgt, vha, 0xf03f,
                             "Async MB 2: Port Logged Out\n");
                 break;
@@ -4044,9 +4045,9 @@ void qlt_async_event(uint16_t code, struct scsi_qla_host *vha,
         default:
                 ql_dbg(ql_dbg_tgt_mgt, vha, 0xf040,
                     "qla_target(%d): Async event %#x occured: "
-                    "ignore (m[1]=%x, m[2]=%x, m[3]=%x, m[4]=%x)", vha->vp_idx,
-                    code, le16_to_cpu(mailbox[1]), le16_to_cpu(mailbox[2]),
-                    le16_to_cpu(mailbox[3]), le16_to_cpu(mailbox[4]));
+                    "ignore (m[0]=%x, m[1]=%x, m[2]=%x, m[3]=%x)", vha->vp_idx,
+                    code, le16_to_cpu(mailbox[0]), le16_to_cpu(mailbox[1]),
+                    le16_to_cpu(mailbox[2]), le16_to_cpu(mailbox[3]));
                 break;
         }
 
diff --git a/drivers/target/tcm_fc/tfc_sess.c b/drivers/target/tcm_fc/tfc_sess.c
index cb99da920068..87901fa74dd7 100644
--- a/drivers/target/tcm_fc/tfc_sess.c
+++ b/drivers/target/tcm_fc/tfc_sess.c
@@ -58,7 +58,8 @@ static struct ft_tport *ft_tport_create(struct fc_lport *lport)
         struct ft_tport *tport;
         int i;
 
-        tport = rcu_dereference(lport->prov[FC_TYPE_FCP]);
+        tport = rcu_dereference_protected(lport->prov[FC_TYPE_FCP],
+                                          lockdep_is_held(&ft_lport_lock));
         if (tport && tport->tpg)
                 return tport;
 
diff --git a/drivers/tty/hvc/hvc_opal.c b/drivers/tty/hvc/hvc_opal.c
index ced26c8ccd57..0d2ea0c224c3 100644
--- a/drivers/tty/hvc/hvc_opal.c
+++ b/drivers/tty/hvc/hvc_opal.c
@@ -401,7 +401,7 @@ out:
 }
 
 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL_RAW
-void __init udbg_init_debug_opal(void)
+void __init udbg_init_debug_opal_raw(void)
 {
         u32 index = CONFIG_PPC_EARLY_DEBUG_OPAL_VTERMNO;
         hvc_opal_privs[index] = &hvc_opal_boot_priv;
diff --git a/drivers/usb/class/cdc-wdm.c b/drivers/usb/class/cdc-wdm.c
index 8fd398dffced..ee469274a3fe 100644
--- a/drivers/usb/class/cdc-wdm.c
+++ b/drivers/usb/class/cdc-wdm.c
@@ -500,6 +500,8 @@ retry:
                         goto retry;
                 }
                 if (!desc->reslength) { /* zero length read */
+                        dev_dbg(&desc->intf->dev, "%s: zero length - clearing WDM_READ\n", __func__);
+                        clear_bit(WDM_READ, &desc->flags);
                         spin_unlock_irq(&desc->iuspin);
                         goto retry;
                 }
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 25a7422ee657..8fb484984c86 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -2324,12 +2324,16 @@ static unsigned hub_is_wusb(struct usb_hub *hub)
 static int hub_port_reset(struct usb_hub *hub, int port1,
                         struct usb_device *udev, unsigned int delay, bool warm);
 
-/* Is a USB 3.0 port in the Inactive state? */
-static bool hub_port_inactive(struct usb_hub *hub, u16 portstatus)
+/* Is a USB 3.0 port in the Inactive or Complinance Mode state?
+ * Port worm reset is required to recover
+ */
+static bool hub_port_warm_reset_required(struct usb_hub *hub, u16 portstatus)
 {
         return hub_is_superspeed(hub->hdev) &&
-                (portstatus & USB_PORT_STAT_LINK_STATE) ==
-                USB_SS_PORT_LS_SS_INACTIVE;
+                (((portstatus & USB_PORT_STAT_LINK_STATE) ==
+                  USB_SS_PORT_LS_SS_INACTIVE) ||
+                 ((portstatus & USB_PORT_STAT_LINK_STATE) ==
+                  USB_SS_PORT_LS_COMP_MOD)) ;
 }
 
 static int hub_port_wait_reset(struct usb_hub *hub, int port1,
@@ -2365,7 +2369,7 @@ static int hub_port_wait_reset(struct usb_hub *hub, int port1,
                          *
                          * See https://bugzilla.kernel.org/show_bug.cgi?id=41752
                          */
-                        if (hub_port_inactive(hub, portstatus)) {
+                        if (hub_port_warm_reset_required(hub, portstatus)) {
                                 int ret;
 
                                 if ((portchange & USB_PORT_STAT_C_CONNECTION))
@@ -4408,9 +4412,7 @@ static void hub_events(void)
                         /* Warm reset a USB3 protocol port if it's in
                          * SS.Inactive state.
                          */
-                        if (hub_is_superspeed(hub->hdev) &&
-                                (portstatus & USB_PORT_STAT_LINK_STATE)
-                                        == USB_SS_PORT_LS_SS_INACTIVE) {
+                        if (hub_port_warm_reset_required(hub, portstatus)) {
                                 dev_dbg(hub_dev, "warm reset port %d\n", i);
                                 hub_port_reset(hub, i, NULL,
                                                 HUB_BH_RESET_TIME, true);
diff --git a/drivers/usb/host/ehci-omap.c b/drivers/usb/host/ehci-omap.c
index 17cfb8a1131c..c30435499a02 100644
--- a/drivers/usb/host/ehci-omap.c
+++ b/drivers/usb/host/ehci-omap.c
@@ -281,14 +281,13 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                 }
         }
 
+        /* Hold PHYs in reset while initializing EHCI controller */
         if (pdata->phy_reset) {
                 if (gpio_is_valid(pdata->reset_gpio_port[0]))
-                        gpio_request_one(pdata->reset_gpio_port[0],
-                                         GPIOF_OUT_INIT_LOW, "USB1 PHY reset");
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[0], 0);
 
                 if (gpio_is_valid(pdata->reset_gpio_port[1]))
-                        gpio_request_one(pdata->reset_gpio_port[1],
-                                         GPIOF_OUT_INIT_LOW, "USB2 PHY reset");
+                        gpio_set_value_cansleep(pdata->reset_gpio_port[1], 0);
 
                 /* Hold the PHY in RESET for enough time till DIR is high */
                 udelay(10);
@@ -330,6 +329,11 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
         omap_ehci->hcs_params = readl(&omap_ehci->caps->hcs_params);
 
         ehci_reset(omap_ehci);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
+        if (ret) {
+                dev_err(dev, "failed to add hcd with err %d\n", ret);
+                goto err_add_hcd;
+        }
 
         if (pdata->phy_reset) {
                 /* Hold the PHY in RESET for enough time till
@@ -344,12 +348,6 @@ static int ehci_hcd_omap_probe(struct platform_device *pdev)
                         gpio_set_value_cansleep(pdata->reset_gpio_port[1], 1);
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
-        if (ret) {
-                dev_err(dev, "failed to add hcd with err %d\n", ret);
-                goto err_add_hcd;
-        }
-
         /* root ports should always stay powered */
         ehci_port_power(omap_ehci, 1);
 
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index 2732ef660c5c..7b01094d7993 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -462,6 +462,42 @@ void xhci_test_and_clear_bit(struct xhci_hcd *xhci, __le32 __iomem **port_array,
         }
 }
 
+/* Updates Link Status for super Speed port */
+static void xhci_hub_report_link_state(u32 *status, u32 status_reg)
+{
+        u32 pls = status_reg & PORT_PLS_MASK;
+
+        /* resume state is a xHCI internal state.
+         * Do not report it to usb core.
+         */
+        if (pls == XDEV_RESUME)
+                return;
+
+        /* When the CAS bit is set then warm reset
+         * should be performed on port
+         */
+        if (status_reg & PORT_CAS) {
+                /* The CAS bit can be set while the port is
+                 * in any link state.
+                 * Only roothubs have CAS bit, so we
+                 * pretend to be in compliance mode
+                 * unless we're already in compliance
+                 * or the inactive state.
+                 */
+                if (pls != USB_SS_PORT_LS_COMP_MOD &&
+                    pls != USB_SS_PORT_LS_SS_INACTIVE) {
+                        pls = USB_SS_PORT_LS_COMP_MOD;
+                }
+                /* Return also connection bit -
+                 * hub state machine resets port
+                 * when this bit is set.
+                 */
+                pls |= USB_PORT_STAT_CONNECTION;
+        }
+        /* update status field */
+        *status |= pls;
+}
+
 int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                 u16 wIndex, char *buf, u16 wLength)
 {
@@ -606,13 +642,9 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         else
                                 status |= USB_PORT_STAT_POWER;
                 }
-                /* Port Link State */
+                /* Update Port Link State for super speed ports*/
                 if (hcd->speed == HCD_USB3) {
-                        /* resume state is a xHCI internal state.
-                         * Do not report it to usb core.
-                         */
-                        if ((temp & PORT_PLS_MASK) != XDEV_RESUME)
-                                status |= (temp & PORT_PLS_MASK);
+                        xhci_hub_report_link_state(&status, temp);
                 }
                 if (bus_state->port_c_suspend & (1 << wIndex))
                         status |= 1 << USB_PORT_FEAT_C_SUSPEND;
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 23b4aefd1036..8275645889da 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -885,6 +885,17 @@ static void update_ring_for_set_deq_completion(struct xhci_hcd *xhci,
         num_trbs_free_temp = ep_ring->num_trbs_free;
         dequeue_temp = ep_ring->dequeue;
 
+        /* If we get two back-to-back stalls, and the first stalled transfer
+         * ends just before a link TRB, the dequeue pointer will be left on
+         * the link TRB by the code in the while loop.  So we have to update
+         * the dequeue pointer one segment further, or we'll jump off
+         * the segment into la-la-land.
+         */
+        if (last_trb(xhci, ep_ring, ep_ring->deq_seg, ep_ring->dequeue)) {
+                ep_ring->deq_seg = ep_ring->deq_seg->next;
+                ep_ring->dequeue = ep_ring->deq_seg->trbs;
+        }
+
         while (ep_ring->dequeue != dev->eps[ep_index].queued_deq_ptr) {
                 /* We have more usable TRBs */
                 ep_ring->num_trbs_free++;
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index de3d6e3e57be..55c0785810c9 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -341,7 +341,11 @@ struct xhci_op_regs {
 #define PORT_PLC        (1 << 22)
 /* port configure error change - port failed to configure its link partner */
 #define PORT_CEC        (1 << 23)
-/* bit 24 reserved */
+/* Cold Attach Status - xHC can set this bit to report device attached during
+ * Sx state. Warm port reset should be perfomed to clear this bit and move port
+ * to connected state.
+ */
+#define PORT_CAS        (1 << 24)
 /* wake on connect (enable) */
 #define PORT_WKCONN_E   (1 << 25)
 /* wake on disconnect (enable) */
diff --git a/drivers/usb/serial/metro-usb.c b/drivers/usb/serial/metro-usb.c
index 81423f7361db..d47eb06fe463 100644
--- a/drivers/usb/serial/metro-usb.c
+++ b/drivers/usb/serial/metro-usb.c
@@ -222,14 +222,6 @@ static int metrousb_open(struct tty_struct *tty, struct usb_serial_port *port)
         metro_priv->throttled = 0;
         spin_unlock_irqrestore(&metro_priv->lock, flags);
 
-        /*
-         * Force low_latency on so that our tty_push actually forces the data
-         * through, otherwise it is scheduled, and with high data rates (like
-         * with OHCI) data can get lost.
-         */
-        if (tty)
-                tty->low_latency = 1;
-
         /* Clear the urb pipe. */
         usb_clear_halt(serial->dev, port->interrupt_in_urb->pipe);
 
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index adf8ce72be50..417ab1b0aa30 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -497,6 +497,15 @@ static void option_instat_callback(struct urb *urb);
 
 /* MediaTek products */
 #define MEDIATEK_VENDOR_ID                      0x0e8d
+#define MEDIATEK_PRODUCT_DC_1COM                0x00a0
+#define MEDIATEK_PRODUCT_DC_4COM                0x00a5
+#define MEDIATEK_PRODUCT_DC_5COM                0x00a4
+#define MEDIATEK_PRODUCT_7208_1COM              0x7101
+#define MEDIATEK_PRODUCT_7208_2COM              0x7102
+#define MEDIATEK_PRODUCT_FP_1COM                0x0003
+#define MEDIATEK_PRODUCT_FP_2COM                0x0023
+#define MEDIATEK_PRODUCT_FPDC_1COM              0x0043
+#define MEDIATEK_PRODUCT_FPDC_2COM              0x0033
 
 /* Cellient products */
 #define CELLIENT_VENDOR_ID                      0x2692
@@ -554,6 +563,10 @@ static const struct option_blacklist_info net_intf1_blacklist = {
         .reserved = BIT(1),
 };
 
+static const struct option_blacklist_info net_intf2_blacklist = {
+        .reserved = BIT(2),
+};
+
 static const struct option_blacklist_info net_intf3_blacklist = {
         .reserved = BIT(3),
 };
@@ -1099,6 +1112,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1298, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1299, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1300, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x1402, 0xff, 0xff, 0xff),
+                .driver_info = (kernel_ulong_t)&net_intf2_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2002, 0xff,
           0xff, 0xff), .driver_info = (kernel_ulong_t)&zte_k3765_z_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x2003, 0xff, 0xff, 0xff) },
@@ -1240,6 +1255,17 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a1, 0xff, 0x02, 0x01) },
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x00, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, 0x00a2, 0xff, 0x02, 0x01) },        /* MediaTek MT6276M modem & app port */
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_5COM, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_DC_4COM, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_1COM, 0x02, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_7208_2COM, 0x02, 0x02, 0x01) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FP_2COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_1COM, 0x0a, 0x00, 0x00) },
+        { USB_DEVICE_AND_INTERFACE_INFO(MEDIATEK_VENDOR_ID, MEDIATEK_PRODUCT_FPDC_2COM, 0x0a, 0x00, 0x00) },
         { USB_DEVICE(CELLIENT_VENDOR_ID, CELLIENT_PRODUCT_MEN200) },
         { } /* Terminating entry */
 };
diff --git a/drivers/video/omap2/dss/core.c b/drivers/video/omap2/dss/core.c
index 5066eee10ccf..58bd9c27369d 100644
--- a/drivers/video/omap2/dss/core.c
+++ b/drivers/video/omap2/dss/core.c
@@ -32,6 +32,7 @@
 #include <linux/io.h>
 #include <linux/device.h>
 #include <linux/regulator/consumer.h>
+#include <linux/suspend.h>
 
 #include <video/omapdss.h>
 
@@ -201,6 +202,28 @@ int dss_debugfs_create_file(const char *name, void (*write)(struct seq_file *))
 #endif /* CONFIG_DEBUG_FS && CONFIG_OMAP2_DSS_DEBUG_SUPPORT */
 
 /* PLATFORM DEVICE */
+static int omap_dss_pm_notif(struct notifier_block *b, unsigned long v, void *d)
+{
+        DSSDBG("pm notif %lu\n", v);
+
+        switch (v) {
+        case PM_SUSPEND_PREPARE:
+                DSSDBG("suspending displays\n");
+                return dss_suspend_all_devices();
+
+        case PM_POST_SUSPEND:
+                DSSDBG("resuming displays\n");
+                return dss_resume_all_devices();
+
+        default:
+                return 0;
+        }
+}
+
+static struct notifier_block omap_dss_pm_notif_block = {
+        .notifier_call = omap_dss_pm_notif,
+};
+
 static int __init omap_dss_probe(struct platform_device *pdev)
 {
         struct omap_dss_board_info *pdata = pdev->dev.platform_data;
@@ -224,6 +247,8 @@ static int __init omap_dss_probe(struct platform_device *pdev)
         else if (pdata->default_device)
                 core.default_display_name = pdata->default_device->name;
 
+        register_pm_notifier(&omap_dss_pm_notif_block);
+
         return 0;
 
 err_debugfs:
@@ -233,6 +258,8 @@ err_debugfs:
 
 static int omap_dss_remove(struct platform_device *pdev)
 {
+        unregister_pm_notifier(&omap_dss_pm_notif_block);
+
         dss_uninitialize_debugfs();
 
         dss_uninit_overlays(pdev);
@@ -247,25 +274,9 @@ static void omap_dss_shutdown(struct platform_device *pdev)
         dss_disable_all_devices();
 }
 
-static int omap_dss_suspend(struct platform_device *pdev, pm_message_t state)
-{
-        DSSDBG("suspend %d\n", state.event);
-
-        return dss_suspend_all_devices();
-}
-
-static int omap_dss_resume(struct platform_device *pdev)
-{
-        DSSDBG("resume\n");
-
-        return dss_resume_all_devices();
-}
-
 static struct platform_driver omap_dss_driver = {
         .remove         = omap_dss_remove,
         .shutdown       = omap_dss_shutdown,
-        .suspend        = omap_dss_suspend,
-        .resume         = omap_dss_resume,
         .driver         = {
                 .name   = "omapdss",
                 .owner  = THIS_MODULE,
diff --git a/drivers/video/omap2/dss/dispc.c b/drivers/video/omap2/dss/dispc.c
index 4749ac356469..397d4eee11bb 100644
--- a/drivers/video/omap2/dss/dispc.c
+++ b/drivers/video/omap2/dss/dispc.c
@@ -384,7 +384,7 @@ void dispc_runtime_put(void)
         DSSDBG("dispc_runtime_put\n");
 
         r = pm_runtime_put_sync(&dispc.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static inline bool dispc_mgr_is_lcd(enum omap_channel channel)
diff --git a/drivers/video/omap2/dss/dsi.c b/drivers/video/omap2/dss/dsi.c
index ca8382d346e9..14ce8cc079e3 100644
--- a/drivers/video/omap2/dss/dsi.c
+++ b/drivers/video/omap2/dss/dsi.c
@@ -1075,7 +1075,7 @@ void dsi_runtime_put(struct platform_device *dsidev)
         DSSDBG("dsi_runtime_put\n");
 
         r = pm_runtime_put_sync(&dsi->pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 /* source clock for DSI PLL. this could also be PCLKFREE */
diff --git a/drivers/video/omap2/dss/dss.c b/drivers/video/omap2/dss/dss.c
index 770632359a17..d2b57197b292 100644
--- a/drivers/video/omap2/dss/dss.c
+++ b/drivers/video/omap2/dss/dss.c
@@ -731,7 +731,7 @@ static void dss_runtime_put(void)
         DSSDBG("dss_runtime_put\n");
 
         r = pm_runtime_put_sync(&dss.pdev->dev);
-        WARN_ON(r < 0 && r != -EBUSY);
+        WARN_ON(r < 0 && r != -ENOSYS && r != -EBUSY);
 }
 
 /* DEBUGFS */
diff --git a/drivers/video/omap2/dss/hdmi.c b/drivers/video/omap2/dss/hdmi.c
index 8195c7166d20..26a2430a7028 100644
--- a/drivers/video/omap2/dss/hdmi.c
+++ b/drivers/video/omap2/dss/hdmi.c
@@ -138,7 +138,7 @@ static void hdmi_runtime_put(void)
         DSSDBG("hdmi_runtime_put\n");
 
         r = pm_runtime_put_sync(&hdmi.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static int __init hdmi_init_display(struct omap_dss_device *dssdev)
diff --git a/drivers/video/omap2/dss/rfbi.c b/drivers/video/omap2/dss/rfbi.c
index 3d8c206e90e5..7985fa12b9b4 100644
--- a/drivers/video/omap2/dss/rfbi.c
+++ b/drivers/video/omap2/dss/rfbi.c
@@ -141,7 +141,7 @@ static void rfbi_runtime_put(void)
         DSSDBG("rfbi_runtime_put\n");
 
         r = pm_runtime_put_sync(&rfbi.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 void rfbi_bus_lock(void)
diff --git a/drivers/video/omap2/dss/venc.c b/drivers/video/omap2/dss/venc.c
index 2b8973931ff4..3907c8b6ecbc 100644
--- a/drivers/video/omap2/dss/venc.c
+++ b/drivers/video/omap2/dss/venc.c
@@ -402,7 +402,7 @@ static void venc_runtime_put(void)
         DSSDBG("venc_runtime_put\n");
 
         r = pm_runtime_put_sync(&venc.pdev->dev);
-        WARN_ON(r < 0);
+        WARN_ON(r < 0 && r != -ENOSYS);
 }
 
 static const struct venc_config *venc_timings_to_config(
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index bfbc15ca38dd..0908e6044333 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -47,7 +47,7 @@ struct virtio_balloon
         struct task_struct *thread;
 
         /* Waiting for host to ack the pages we released. */
-        struct completion acked;
+        wait_queue_head_t acked;
 
         /* Number of balloon pages we've told the Host we're not using. */
         unsigned int num_pages;
@@ -89,29 +89,25 @@ static struct page *balloon_pfn_to_page(u32 pfn)
 
 static void balloon_ack(struct virtqueue *vq)
 {
-        struct virtio_balloon *vb;
-        unsigned int len;
+        struct virtio_balloon *vb = vq->vdev->priv;
 
-        vb = virtqueue_get_buf(vq, &len);
-        if (vb)
-                complete(&vb->acked);
+        wake_up(&vb->acked);
 }
 
 static void tell_host(struct virtio_balloon *vb, struct virtqueue *vq)
 {
         struct scatterlist sg;
+        unsigned int len;
 
         sg_init_one(&sg, vb->pfns, sizeof(vb->pfns[0]) * vb->num_pfns);
 
-        init_completion(&vb->acked);
-
         /* We should always be able to add one buffer to an empty queue. */
         if (virtqueue_add_buf(vq, &sg, 1, 0, vb, GFP_KERNEL) < 0)
                 BUG();
         virtqueue_kick(vq);
 
         /* When host has read buffer, this completes via balloon_ack */
-        wait_for_completion(&vb->acked);
+        wait_event(vb->acked, virtqueue_get_buf(vq, &len));
 }
 
 static void set_page_pfns(u32 pfns[], struct page *page)
@@ -231,12 +227,8 @@ static void update_balloon_stats(struct virtio_balloon *vb)
  */
 static void stats_request(struct virtqueue *vq)
 {
-        struct virtio_balloon *vb;
-        unsigned int len;
+        struct virtio_balloon *vb = vq->vdev->priv;
 
-        vb = virtqueue_get_buf(vq, &len);
-        if (!vb)
-                return;
         vb->need_stats_update = 1;
         wake_up(&vb->config_change);
 }
@@ -245,11 +237,14 @@ static void stats_handle_request(struct virtio_balloon *vb)
 {
         struct virtqueue *vq;
         struct scatterlist sg;
+        unsigned int len;
 
         vb->need_stats_update = 0;
         update_balloon_stats(vb);
 
         vq = vb->stats_vq;
+        if (!virtqueue_get_buf(vq, &len))
+                return;
         sg_init_one(&sg, vb->stats, sizeof(vb->stats));
         if (virtqueue_add_buf(vq, &sg, 1, 0, vb, GFP_KERNEL) < 0)
                 BUG();
@@ -358,6 +353,7 @@ static int virtballoon_probe(struct virtio_device *vdev)
         INIT_LIST_HEAD(&vb->pages);
         vb->num_pages = 0;
         init_waitqueue_head(&vb->config_change);
+        init_waitqueue_head(&vb->acked);
         vb->vdev = vdev;
         vb->need_stats_update = 0;