Merge branch 'fixes-modulesplit' into fixes

author: Tony Lindgren <tony@atomide.com> 2011-11-07 15:27:23 -0500
committer: Tony Lindgren <tony@atomide.com> 2011-11-07 15:27:23 -0500
commit: d30cc16c8e48368e0518f4975a78711e53e14a0f (patch)
tree: 26b57f7ab5a963cc3d6c57dff6951bd930875583 /include
parent: 41eb2d813f558900884e240c2f723e36c7bd151f (diff)
parent: a1bcc1dcef8451b4291ea2a1b2677cb194102952 (diff)
147 files changed, 3516 insertions, 1297 deletions
diff --git a/include/acpi/platform/aclinux.h b/include/acpi/platform/aclinux.h
index f72403c4b51a..f4b2effe0333 100644
--- a/include/acpi/platform/aclinux.h
+++ b/include/acpi/platform/aclinux.h
@@ -55,7 +55,6 @@
 #include <linux/string.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/ctype.h>
 #include <linux/sched.h>
 #include <asm/system.h>
diff --git a/include/drm/drmP.h b/include/drm/drmP.h
index cf3b446139ea..cf399495d38f 100644
--- a/include/drm/drmP.h
+++ b/include/drm/drmP.h
@@ -42,7 +42,6 @@
 * can build the DRM (part of PI DRI). 4/21/2000 S + B */
 #include <asm/current.h>
 #endif                          /* __alpha__ */
-#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/miscdevice.h>
 #include <linux/fs.h>
@@ -80,6 +79,8 @@
 #define __OS_HAS_AGP (defined(CONFIG_AGP) || (defined(CONFIG_AGP_MODULE) && defined(MODULE)))
 #define __OS_HAS_MTRR (defined(CONFIG_MTRR))
+struct module;
 struct drm_file;
 struct drm_device;
diff --git a/include/linux/aio.h b/include/linux/aio.h
index 2dcb72bff4b6..2314ad8b3c9c 100644
--- a/include/linux/aio.h
+++ b/include/linux/aio.h
@@ -117,6 +117,7 @@ struct kiocb {
        struct list_head        ki_list;        /* the aio core uses this
                                                 * for cancellation */
+        struct list_head        ki_batch;       /* batch allocation */
        /*
         * If the aio_resfd field of the userspace iocb is not zero,
diff --git a/include/linux/amba/pl08x.h b/include/linux/amba/pl08x.h
index e6e28f37d8ec..9eabffbc4e50 100644
--- a/include/linux/amba/pl08x.h
+++ b/include/linux/amba/pl08x.h
@@ -47,6 +47,9 @@ enum {
 * @muxval: a number usually used to poke into some mux regiser to
 * mux in the signal to this channel
 * @cctl_opt: default options for the channel control register
+ * @device_fc: Flow Controller Settings for ccfg register. Only valid for slave
+ * channels. Fill with 'true' if peripheral should be flow controller. Direction
+ * will be selected at Runtime.
 * @addr: source/target address in physical memory for this DMA channel,
 * can be the address of a FIFO register for burst requests for example.
 * This can be left undefined if the PrimeCell API is used for configuring
@@ -65,6 +68,7 @@ struct pl08x_channel_data {
        int max_signal;
        u32 muxval;
        u32 cctl;
+        bool device_fc;
        dma_addr_t addr;
        bool circular_buffer;
        bool single;
@@ -77,13 +81,11 @@ struct pl08x_channel_data {
 * @addr: current address
 * @maxwidth: the maximum width of a transfer on this bus
 * @buswidth: the width of this bus in bytes: 1, 2 or 4
- * @fill_bytes: bytes required to fill to the next bus memory boundary
 */
 struct pl08x_bus_data {
        dma_addr_t addr;
        u8 maxwidth;
        u8 buswidth;
-        size_t fill_bytes;
 };
 /**
@@ -104,17 +106,35 @@ struct pl08x_phy_chan {
 };
 /**
+ * struct pl08x_sg - structure containing data per sg
+ * @src_addr: src address of sg
+ * @dst_addr: dst address of sg
+ * @len: transfer len in bytes
+ * @node: node for txd's dsg_list
+ */
+struct pl08x_sg {
+        dma_addr_t src_addr;
+        dma_addr_t dst_addr;
+        size_t len;
+        struct list_head node;
+};
+/**
 * struct pl08x_txd - wrapper for struct dma_async_tx_descriptor
+ * @tx: async tx descriptor
+ * @node: node for txd list for channels
+ * @dsg_list: list of children sg's
+ * @direction: direction of transfer
 * @llis_bus: DMA memory address (physical) start for the LLIs
 * @llis_va: virtual memory address start for the LLIs
+ * @cctl: control reg values for current txd
+ * @ccfg: config reg values for current txd
 */
 struct pl08x_txd {
        struct dma_async_tx_descriptor tx;
        struct list_head node;
+        struct list_head dsg_list;
        enum dma_data_direction direction;
-        dma_addr_t src_addr;
-        dma_addr_t dst_addr;
-        size_t len;
        dma_addr_t llis_bus;
        struct pl08x_lli *llis_va;
        /* Default cctl value for LLIs */
diff --git a/include/linux/amba/pl330.h b/include/linux/amba/pl330.h
index cbee7de7dd36..d12f077a6daf 100644
--- a/include/linux/amba/pl330.h
+++ b/include/linux/amba/pl330.h
@@ -19,12 +19,8 @@ struct dma_pl330_peri {
         * Peri_Req i/f of the DMAC that is
         * peripheral could be reached from.
         */
-        u8 peri_id; /* {0, 31} */
+        u8 peri_id; /* specific dma id */
        enum pl330_reqtype rqtype;
-        /* For M->D and D->M Channels */
-        int burst_sz; /* in power of 2 */
-        dma_addr_t fifo_addr;
 };
 struct dma_pl330_platdata {
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 3b2f9cb82986..b1038bd686ac 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -40,6 +40,7 @@ typedef int (congested_fn)(void *, int);
 enum bdi_stat_item {
        BDI_RECLAIMABLE,
        BDI_WRITEBACK,
+        BDI_DIRTIED,
        BDI_WRITTEN,
        NR_BDI_STAT_ITEMS
 };
@@ -74,10 +75,20 @@ struct backing_dev_info {
        struct percpu_counter bdi_stat[NR_BDI_STAT_ITEMS];
        unsigned long bw_time_stamp;    /* last time write bw is updated */
+        unsigned long dirtied_stamp;
        unsigned long written_stamp;    /* pages written at bw_time_stamp */
        unsigned long write_bandwidth;  /* the estimated write bandwidth */
        unsigned long avg_write_bandwidth; /* further smoothed write bw */
+        /*
+         * The base dirty throttle rate, re-calculated on every 200ms.
+         * All the bdi tasks' dirty rate will be curbed under it.
+         * @dirty_ratelimit tracks the estimated @balanced_dirty_ratelimit
+         * in small steps and is much more smooth/stable than the latter.
+         */
+        unsigned long dirty_ratelimit;
+        unsigned long balanced_dirty_ratelimit;
        struct prop_local_percpu completions;
        int dirty_exceeded;
@@ -107,7 +118,8 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 void bdi_unregister(struct backing_dev_info *bdi);
 int bdi_setup_and_register(struct backing_dev_info *, char *, unsigned int);
-void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages);
+void bdi_start_writeback(struct backing_dev_info *bdi, long nr_pages,
+                        enum wb_reason reason);
 void bdi_start_background_writeback(struct backing_dev_info *bdi);
 int bdi_writeback_thread(void *data);
 int bdi_has_dirty_io(struct backing_dev_info *bdi);
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index 5dbd7055cb86..4d4b59de9467 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -170,10 +170,9 @@ struct bcma_driver {
 };
 extern
 int __bcma_driver_register(struct bcma_driver *drv, struct module *owner);
-static inline int bcma_driver_register(struct bcma_driver *drv)
+#define bcma_driver_register(drv) \
-{
+        __bcma_driver_register(drv, THIS_MODULE)
-        return __bcma_driver_register(drv, THIS_MODULE);
-}
 extern void bcma_driver_unregister(struct bcma_driver *drv);
 struct bcma_bus {
diff --git a/include/linux/bio.h b/include/linux/bio.h
index ce33e6868a2f..a3c071c9e189 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -269,14 +269,6 @@ extern void bvec_free_bs(struct bio_set *, struct bio_vec *, unsigned int);
 extern unsigned int bvec_nr_vecs(unsigned short idx);
 /*
- * Allow queuer to specify a completion CPU for this bio
- */
-static inline void bio_set_completion_cpu(struct bio *bio, unsigned int cpu)
-{
-        bio->bi_comp_cpu = cpu;
-}
-/*
 * bio_set is used to allow other portions of the IO system to
 * allocate their own private memory pools for bio and iovec structures.
 * These memory pools in turn all allocate from the bio_slab
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 71fc53bb8f1c..4053cbd4490e 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -59,8 +59,6 @@ struct bio {
        unsigned int            bi_max_vecs;    /* max bvl_vecs we can hold */
-        unsigned int            bi_comp_cpu;    /* completion CPU */
        atomic_t                bi_cnt;         /* pin count */
        struct bio_vec          *bi_io_vec;     /* the actual vec list */
@@ -93,11 +91,10 @@ struct bio {
 #define BIO_BOUNCED     5       /* bio is a bounce bio */
 #define BIO_USER_MAPPED 6       /* contains user pages */
 #define BIO_EOPNOTSUPP  7       /* not supported */
-#define BIO_CPU_AFFINE  8       /* complete bio on same CPU as submitted */
+#define BIO_NULL_MAPPED 8       /* contains invalid user pages */
-#define BIO_NULL_MAPPED 9       /* contains invalid user pages */
+#define BIO_FS_INTEGRITY 9      /* fs owns integrity data, not block layer */
-#define BIO_FS_INTEGRITY 10     /* fs owns integrity data, not block layer */
+#define BIO_QUIET       10      /* Make BIO Quiet */
-#define BIO_QUIET       11      /* Make BIO Quiet */
+#define BIO_MAPPED_INTEGRITY 11/* integrity metadata has been remapped */
-#define BIO_MAPPED_INTEGRITY 12/* integrity metadata has been remapped */
 #define bio_flagged(bio, flag)  ((bio)->bi_flags & (1 << (flag)))
 /*
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 7fbaa9103344..c7a6d3b5bc7b 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -14,7 +14,6 @@
 #include <linux/wait.h>
 #include <linux/mempool.h>
 #include <linux/bio.h>
-#include <linux/module.h>
 #include <linux/stringify.h>
 #include <linux/gfp.h>
 #include <linux/bsg.h>
@@ -22,6 +21,7 @@
 #include <asm/scatterlist.h>
+struct module;
 struct scsi_ioctl_command;
 struct request_queue;
@@ -195,7 +195,7 @@ struct request_pm_state
 #include <linux/elevator.h>
 typedef void (request_fn_proc) (struct request_queue *q);
-typedef int (make_request_fn) (struct request_queue *q, struct bio *bio);
+typedef void (make_request_fn) (struct request_queue *q, struct bio *bio);
 typedef int (prep_rq_fn) (struct request_queue *, struct request *);
 typedef void (unprep_rq_fn) (struct request_queue *, struct request *);
@@ -680,6 +680,8 @@ extern int scsi_cmd_ioctl(struct request_queue *, struct gendisk *, fmode_t,
 extern int sg_scsi_ioctl(struct request_queue *, struct gendisk *, fmode_t,
                         struct scsi_ioctl_command __user *);
+extern void blk_queue_bio(struct request_queue *q, struct bio *bio);
 /*
 * A queue has just exitted congestion.  Note this in the global counter of
 * congested queues, and wake up anyone who was waiting for requests to be
@@ -863,16 +865,22 @@ struct request_queue *blk_alloc_queue_node(gfp_t, int);
 extern void blk_put_queue(struct request_queue *);
 /*
- * Note: Code in between changing the blk_plug list/cb_list or element of such
+ * blk_plug permits building a queue of related requests by holding the I/O
- * lists is preemptable, but such code can't do sleep (or be very careful),
+ * fragments for a short period. This allows merging of sequential requests
- * otherwise data is corrupted. For details, please check schedule() where
+ * into single larger request. As the requests are moved from a per-task list to
- * blk_schedule_flush_plug() is called.
+ * the device's request_queue in a batch, this results in improved scalability
+ * as the lock contention for request_queue lock is reduced.
+ *
+ * It is ok not to disable preemption when adding the request to the plug list
+ * or when attempting a merge, because blk_schedule_flush_list() will only flush
+ * the plug list when the task sleeps by itself. For details, please see
+ * schedule() where blk_schedule_flush_plug() is called.
 */
 struct blk_plug {
-        unsigned long magic;
+        unsigned long magic; /* detect uninitialized use-cases */
-        struct list_head list;
+        struct list_head list; /* requests */
-        struct list_head cb_list;
+        struct list_head cb_list; /* md requires an unplug callback */
-        unsigned int should_sort;
+        unsigned int should_sort; /* list to be sorted before flushing? */
 };
 #define BLK_MAX_REQUEST_COUNT 16
@@ -1189,20 +1197,6 @@ static inline uint64_t rq_io_start_time_ns(struct request *req)
 }
 #endif
-#ifdef CONFIG_BLK_DEV_THROTTLING
-extern int blk_throtl_init(struct request_queue *q);
-extern void blk_throtl_exit(struct request_queue *q);
-extern int blk_throtl_bio(struct request_queue *q, struct bio **bio);
-#else /* CONFIG_BLK_DEV_THROTTLING */
-static inline int blk_throtl_bio(struct request_queue *q, struct bio **bio)
-{
-        return 0;
-}
-static inline int blk_throtl_init(struct request_queue *q) { return 0; }
-static inline int blk_throtl_exit(struct request_queue *q) { return 0; }
-#endif /* CONFIG_BLK_DEV_THROTTLING */
 #define MODULE_ALIAS_BLOCKDEV(major,minor) \
        MODULE_ALIAS("block-major-" __stringify(major) "-" __stringify(minor))
 #define MODULE_ALIAS_BLOCKDEV_MAJOR(major) \
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index da7e4bc34e8c..1b7f9d525013 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -516,7 +516,7 @@ struct cgroup_subsys {
        struct list_head sibling;
        /* used when use_id == true */
        struct idr idr;
-        spinlock_t id_lock;
+        rwlock_t id_lock;
        /* should be defined only by modular subsystems */
        struct module *module;
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index b1a635acf72a..6cb60fd2ea84 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -196,13 +196,9 @@ static inline void cpu_hotplug_driver_unlock(void)
 #endif          /* CONFIG_HOTPLUG_CPU */
 #ifdef CONFIG_PM_SLEEP_SMP
-extern int suspend_cpu_hotplug;
 extern int disable_nonboot_cpus(void);
 extern void enable_nonboot_cpus(void);
 #else /* !CONFIG_PM_SLEEP_SMP */
-#define suspend_cpu_hotplug     0
 static inline int disable_nonboot_cpus(void) { return 0; }
 static inline void enable_nonboot_cpus(void) {}
 #endif /* !CONFIG_PM_SLEEP_SMP */
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index b51629e15cfc..583baf22cad2 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -13,7 +13,6 @@
 #include <linux/percpu.h>
 #include <linux/list.h>
-#include <linux/module.h>
 #include <linux/kobject.h>
 #include <linux/completion.h>
@@ -21,6 +20,8 @@
 #define CPUIDLE_NAME_LEN        16
 #define CPUIDLE_DESC_LEN        32
+struct module;
 struct cpuidle_device;
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index de9adec5693c..8a94217b298e 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -18,7 +18,6 @@
 #define _LINUX_CRYPTO_H
 #include <linux/atomic.h>
-#include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
 #include <linux/slab.h>
@@ -510,11 +509,6 @@ static inline int crypto_tfm_alg_priority(struct crypto_tfm *tfm)
        return tfm->__crt_alg->cra_priority;
 }
-static inline const char *crypto_tfm_alg_modname(struct crypto_tfm *tfm)
-{
-        return module_name(tfm->__crt_alg->cra_module);
-}
 static inline u32 crypto_tfm_alg_type(struct crypto_tfm *tfm)
 {
        return tfm->__crt_alg->cra_flags & CRYPTO_ALG_TYPE_MASK;
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 62157c03caf7..4df926199369 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -165,6 +165,7 @@ struct dentry_operations {
                        unsigned int, const char *, const struct qstr *);
        int (*d_delete)(const struct dentry *);
        void (*d_release)(struct dentry *);
+        void (*d_prune)(struct dentry *);
        void (*d_iput)(struct dentry *, struct inode *);
        char *(*d_dname)(struct dentry *, char *, int);
        struct vfsmount *(*d_automount)(struct path *);
@@ -184,8 +185,9 @@ struct dentry_operations {
 #define DCACHE_OP_COMPARE       0x0002
 #define DCACHE_OP_REVALIDATE    0x0004
 #define DCACHE_OP_DELETE        0x0008
+#define DCACHE_OP_PRUNE         0x0010
-#define DCACHE_DISCONNECTED     0x0010
+#define DCACHE_DISCONNECTED     0x0020
     /* This dentry is possibly not currently connected to the dcache tree, in
      * which case its parent will either be itself, or will have this flag as
      * well.  nfsd will not use a dentry with this bit set, but will first
@@ -196,8 +198,8 @@ struct dentry_operations {
      * dentry into place and return that dentry rather than the passed one,
      * typically using d_splice_alias. */
-#define DCACHE_REFERENCED       0x0020  /* Recently used, don't discard. */
+#define DCACHE_REFERENCED       0x0040  /* Recently used, don't discard. */
-#define DCACHE_RCUACCESS        0x0040  /* Entry has ever been RCU-visible */
+#define DCACHE_RCUACCESS        0x0080  /* Entry has ever been RCU-visible */
 #define DCACHE_CANT_MOUNT       0x0100
 #define DCACHE_GENOCIDE         0x0200
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 99e3e50b5c57..98f34b886f95 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -10,6 +10,7 @@
 #include <linux/bio.h>
 #include <linux/blkdev.h>
+#include <linux/ratelimit.h>
 struct dm_dev;
 struct dm_target;
@@ -127,10 +128,6 @@ void dm_put_device(struct dm_target *ti, struct dm_dev *d);
 * Information about a target type
 */
-/*
- * Target features
- */
 struct target_type {
        uint64_t features;
        const char *name;
@@ -159,6 +156,30 @@ struct target_type {
        struct list_head list;
 };
+/*
+ * Target features
+ */
+/*
+ * Any table that contains an instance of this target must have only one.
+ */
+#define DM_TARGET_SINGLETON             0x00000001
+#define dm_target_needs_singleton(type) ((type)->features & DM_TARGET_SINGLETON)
+/*
+ * Indicates that a target does not support read-only devices.
+ */
+#define DM_TARGET_ALWAYS_WRITEABLE      0x00000002
+#define dm_target_always_writeable(type) \
+                ((type)->features & DM_TARGET_ALWAYS_WRITEABLE)
+/*
+ * Any device that contains a table with an instance of this target may never
+ * have tables containing any different target type.
+ */
+#define DM_TARGET_IMMUTABLE             0x00000004
+#define dm_target_is_immutable(type)    ((type)->features & DM_TARGET_IMMUTABLE)
 struct dm_target {
        struct dm_table *table;
        struct target_type *type;
@@ -375,6 +396,14 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
 *---------------------------------------------------------------*/
 #define DM_NAME "device-mapper"
+#ifdef CONFIG_PRINTK
+extern struct ratelimit_state dm_ratelimit_state;
+#define dm_ratelimit()  __ratelimit(&dm_ratelimit_state)
+#else
+#define dm_ratelimit()  0
+#endif
 #define DMCRIT(f, arg...) \
        printk(KERN_CRIT DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
@@ -382,7 +411,7 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
        printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
 #define DMERR_LIMIT(f, arg...) \
        do { \
-                if (printk_ratelimit()) \
+                if (dm_ratelimit())     \
                        printk(KERN_ERR DM_NAME ": " DM_MSG_PREFIX ": " \
                               f "\n", ## arg); \
        } while (0)
@@ -391,7 +420,7 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
        printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
 #define DMWARN_LIMIT(f, arg...) \
        do { \
-                if (printk_ratelimit()) \
+                if (dm_ratelimit())     \
                        printk(KERN_WARNING DM_NAME ": " DM_MSG_PREFIX ": " \
                               f "\n", ## arg); \
        } while (0)
@@ -400,7 +429,7 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
        printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f "\n", ## arg)
 #define DMINFO_LIMIT(f, arg...) \
        do { \
-                if (printk_ratelimit()) \
+                if (dm_ratelimit())     \
                        printk(KERN_INFO DM_NAME ": " DM_MSG_PREFIX ": " f \
                               "\n", ## arg); \
        } while (0)
@@ -410,7 +439,7 @@ void *dm_vcalloc(unsigned long nmemb, unsigned long elem_size);
        printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX " DEBUG: " f "\n", ## arg)
 #  define DMDEBUG_LIMIT(f, arg...) \
        do { \
-                if (printk_ratelimit()) \
+                if (dm_ratelimit())     \
                        printk(KERN_DEBUG DM_NAME ": " DM_MSG_PREFIX ": " f \
                               "\n", ## arg); \
        } while (0)
diff --git a/include/linux/device.h b/include/linux/device.h
index e88abeecfadf..ffbcf95cd97d 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -20,7 +20,7 @@
 #include <linux/lockdep.h>
 #include <linux/compiler.h>
 #include <linux/types.h>
-#include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/pm.h>
 #include <linux/atomic.h>
 #include <asm/device.h>
@@ -29,6 +29,7 @@ struct device;
 struct device_private;
 struct device_driver;
 struct driver_private;
+struct module;
 struct class;
 struct subsys_private;
 struct bus_type;
@@ -723,10 +724,14 @@ extern int dev_set_drvdata(struct device *dev, void *data);
 */
 extern struct device *__root_device_register(const char *name,
                                             struct module *owner);
-static inline struct device *root_device_register(const char *name)
-{
+/*
-        return __root_device_register(name, THIS_MODULE);
+ * This is a macro to avoid include problems with THIS_MODULE,
-}
+ * just as per what is done for device_schedule_callback() above.
+ */
+#define root_device_register(name) \
+        __root_device_register(name, THIS_MODULE)
 extern void root_device_unregister(struct device *root);
 static inline void *dev_get_platdata(const struct device *dev)
diff --git a/include/linux/device_cgroup.h b/include/linux/device_cgroup.h
index 7aad1f440867..8b64221b432b 100644
--- a/include/linux/device_cgroup.h
+++ b/include/linux/device_cgroup.h
@@ -1,4 +1,3 @@
-#include <linux/module.h>
 #include <linux/fs.h>
 #ifdef CONFIG_CGROUP_DEVICE
diff --git a/include/linux/dm-ioctl.h b/include/linux/dm-ioctl.h
index 0cb8eff76bd6..75fd5573516e 100644
--- a/include/linux/dm-ioctl.h
+++ b/include/linux/dm-ioctl.h
@@ -267,9 +267,9 @@ enum {
 #define DM_DEV_SET_GEOMETRY     _IOWR(DM_IOCTL, DM_DEV_SET_GEOMETRY_CMD, struct dm_ioctl)
 #define DM_VERSION_MAJOR        4
-#define DM_VERSION_MINOR        21
+#define DM_VERSION_MINOR        22
 #define DM_VERSION_PATCHLEVEL   0
-#define DM_VERSION_EXTRA        "-ioctl (2011-07-06)"
+#define DM_VERSION_EXTRA        "-ioctl (2011-10-19)"
 /* Status bits */
 #define DM_READONLY_FLAG        (1 << 0) /* In/Out */
diff --git a/include/linux/dm-kcopyd.h b/include/linux/dm-kcopyd.h
index 5e54458e920f..47d9d376e4e7 100644
--- a/include/linux/dm-kcopyd.h
+++ b/include/linux/dm-kcopyd.h
@@ -57,5 +57,9 @@ void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
                                 dm_kcopyd_notify_fn fn, void *context);
 void dm_kcopyd_do_callback(void *job, int read_err, unsigned long write_err);
+int dm_kcopyd_zero(struct dm_kcopyd_client *kc,
+                   unsigned num_dests, struct dm_io_region *dests,
+                   unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_DM_KCOPYD_H */
diff --git a/include/linux/dm-log-userspace.h b/include/linux/dm-log-userspace.h
index eeace7d3ff15..0678c2adc421 100644
--- a/include/linux/dm-log-userspace.h
+++ b/include/linux/dm-log-userspace.h
@@ -52,15 +52,20 @@
 * Payload-to-userspace:
 *      A single string containing all the argv arguments separated by ' 's
 * Payload-to-kernel:
- *      None.  ('data_size' in the dm_ulog_request struct should be 0.)
+ *      A NUL-terminated string that is the name of the device that is used
+ *      as the backing store for the log data.  'dm_get_device' will be called
+ *      on this device.  ('dm_put_device' will be called on this device
+ *      automatically after calling DM_ULOG_DTR.)  If there is no device needed
+ *      for log data, 'data_size' in the dm_ulog_request struct should be 0.
 *
 * The UUID contained in the dm_ulog_request structure is the reference that
 * will be used by all request types to a specific log.  The constructor must
- * record this assotiation with instance created.
+ * record this association with the instance created.
 *
 * When the request has been processed, user-space must return the
- * dm_ulog_request to the kernel - setting the 'error' field and
+ * dm_ulog_request to the kernel - setting the 'error' field, filling the
- * 'data_size' appropriately.
+ * data field with the log device if necessary, and setting 'data_size'
+ * appropriately.
 */
 #define DM_ULOG_CTR                    1
@@ -377,8 +382,11 @@
 * dm_ulog_request or a change in the way requests are
 * issued/handled.  Changes are outlined here:
 *      version 1:  Initial implementation
+ *      version 2:  DM_ULOG_CTR allowed to return a string containing a
+ *                  device name that is to be registered with DM via
+ *                  'dm_get_device'.
 */
-#define DM_ULOG_REQUEST_VERSION 1
+#define DM_ULOG_REQUEST_VERSION 2
 struct dm_ulog_request {
        /*
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 347fdc32177a..e13117cbd2f7 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -1,6 +1,7 @@
 #ifndef _LINUX_DMA_MAPPING_H
 #define _LINUX_DMA_MAPPING_H
+#include <linux/string.h>
 #include <linux/device.h>
 #include <linux/err.h>
 #include <linux/dma-attrs.h>
@@ -41,6 +42,9 @@ struct dma_map_ops {
        int (*mapping_error)(struct device *dev, dma_addr_t dma_addr);
        int (*dma_supported)(struct device *dev, u64 mask);
        int (*set_dma_mask)(struct device *dev, u64 mask);
+#ifdef ARCH_HAS_DMA_GET_REQUIRED_MASK
+        u64 (*get_required_mask)(struct device *dev);
+#endif
        int is_phys;
 };
@@ -117,6 +121,15 @@ static inline int dma_set_seg_boundary(struct device *dev, unsigned long mask)
                return -EIO;
 }
+static inline void *dma_zalloc_coherent(struct device *dev, size_t size,
+                                        dma_addr_t *dma_handle, gfp_t flag)
+{
+        void *ret = dma_alloc_coherent(dev, size, dma_handle, flag);
+        if (ret)
+                memset(ret, 0, size);
+        return ret;
+}
 #ifdef CONFIG_HAS_DMA
 static inline int dma_get_cache_alignment(void)
 {
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 8fbf40e0713c..75f53f874b24 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -24,8 +24,9 @@
 #include <linux/device.h>
 #include <linux/uio.h>
 #include <linux/dma-direction.h>
+#include <linux/scatterlist.h>
-struct scatterlist;
+#include <linux/bitmap.h>
+#include <asm/page.h>
 /**
 * typedef dma_cookie_t - an opaque DMA cookie
@@ -519,6 +520,16 @@ static inline int dmaengine_slave_config(struct dma_chan *chan,
                        (unsigned long)config);
 }
+static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
+        struct dma_chan *chan, void *buf, size_t len,
+        enum dma_data_direction dir, unsigned long flags)
+{
+        struct scatterlist sg;
+        sg_init_one(&sg, buf, len);
+        return chan->device->device_prep_slave_sg(chan, &sg, 1, dir, flags);
+}
 static inline int dmaengine_terminate_all(struct dma_chan *chan)
 {
        return dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
diff --git a/include/linux/edac.h b/include/linux/edac.h
index 4a73257b47d0..055b248bdd53 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -42,4 +42,354 @@ static inline void opstate_init(void)
        return;
 }
+#define EDAC_MC_LABEL_LEN       31
+#define MC_PROC_NAME_MAX_LEN    7
+/* memory devices */
+enum dev_type {
+        DEV_UNKNOWN = 0,
+        DEV_X1,
+        DEV_X2,
+        DEV_X4,
+        DEV_X8,
+        DEV_X16,
+        DEV_X32,                /* Do these parts exist? */
+        DEV_X64                 /* Do these parts exist? */
+};
+#define DEV_FLAG_UNKNOWN        BIT(DEV_UNKNOWN)
+#define DEV_FLAG_X1             BIT(DEV_X1)
+#define DEV_FLAG_X2             BIT(DEV_X2)
+#define DEV_FLAG_X4             BIT(DEV_X4)
+#define DEV_FLAG_X8             BIT(DEV_X8)
+#define DEV_FLAG_X16            BIT(DEV_X16)
+#define DEV_FLAG_X32            BIT(DEV_X32)
+#define DEV_FLAG_X64            BIT(DEV_X64)
+/* memory types */
+enum mem_type {
+        MEM_EMPTY = 0,          /* Empty csrow */
+        MEM_RESERVED,           /* Reserved csrow type */
+        MEM_UNKNOWN,            /* Unknown csrow type */
+        MEM_FPM,                /* Fast page mode */
+        MEM_EDO,                /* Extended data out */
+        MEM_BEDO,               /* Burst Extended data out */
+        MEM_SDR,                /* Single data rate SDRAM */
+        MEM_RDR,                /* Registered single data rate SDRAM */
+        MEM_DDR,                /* Double data rate SDRAM */
+        MEM_RDDR,               /* Registered Double data rate SDRAM */
+        MEM_RMBS,               /* Rambus DRAM */
+        MEM_DDR2,               /* DDR2 RAM */
+        MEM_FB_DDR2,            /* fully buffered DDR2 */
+        MEM_RDDR2,              /* Registered DDR2 RAM */
+        MEM_XDR,                /* Rambus XDR */
+        MEM_DDR3,               /* DDR3 RAM */
+        MEM_RDDR3,              /* Registered DDR3 RAM */
+};
+#define MEM_FLAG_EMPTY          BIT(MEM_EMPTY)
+#define MEM_FLAG_RESERVED       BIT(MEM_RESERVED)
+#define MEM_FLAG_UNKNOWN        BIT(MEM_UNKNOWN)
+#define MEM_FLAG_FPM            BIT(MEM_FPM)
+#define MEM_FLAG_EDO            BIT(MEM_EDO)
+#define MEM_FLAG_BEDO           BIT(MEM_BEDO)
+#define MEM_FLAG_SDR            BIT(MEM_SDR)
+#define MEM_FLAG_RDR            BIT(MEM_RDR)
+#define MEM_FLAG_DDR            BIT(MEM_DDR)
+#define MEM_FLAG_RDDR           BIT(MEM_RDDR)
+#define MEM_FLAG_RMBS           BIT(MEM_RMBS)
+#define MEM_FLAG_DDR2           BIT(MEM_DDR2)
+#define MEM_FLAG_FB_DDR2        BIT(MEM_FB_DDR2)
+#define MEM_FLAG_RDDR2          BIT(MEM_RDDR2)
+#define MEM_FLAG_XDR            BIT(MEM_XDR)
+#define MEM_FLAG_DDR3            BIT(MEM_DDR3)
+#define MEM_FLAG_RDDR3           BIT(MEM_RDDR3)
+/* chipset Error Detection and Correction capabilities and mode */
+enum edac_type {
+        EDAC_UNKNOWN = 0,       /* Unknown if ECC is available */
+        EDAC_NONE,              /* Doesn't support ECC */
+        EDAC_RESERVED,          /* Reserved ECC type */
+        EDAC_PARITY,            /* Detects parity errors */
+        EDAC_EC,                /* Error Checking - no correction */
+        EDAC_SECDED,            /* Single bit error correction, Double detection */
+        EDAC_S2ECD2ED,          /* Chipkill x2 devices - do these exist? */
+        EDAC_S4ECD4ED,          /* Chipkill x4 devices */
+        EDAC_S8ECD8ED,          /* Chipkill x8 devices */
+        EDAC_S16ECD16ED,        /* Chipkill x16 devices */
+};
+#define EDAC_FLAG_UNKNOWN       BIT(EDAC_UNKNOWN)
+#define EDAC_FLAG_NONE          BIT(EDAC_NONE)
+#define EDAC_FLAG_PARITY        BIT(EDAC_PARITY)
+#define EDAC_FLAG_EC            BIT(EDAC_EC)
+#define EDAC_FLAG_SECDED        BIT(EDAC_SECDED)
+#define EDAC_FLAG_S2ECD2ED      BIT(EDAC_S2ECD2ED)
+#define EDAC_FLAG_S4ECD4ED      BIT(EDAC_S4ECD4ED)
+#define EDAC_FLAG_S8ECD8ED      BIT(EDAC_S8ECD8ED)
+#define EDAC_FLAG_S16ECD16ED    BIT(EDAC_S16ECD16ED)
+/* scrubbing capabilities */
+enum scrub_type {
+        SCRUB_UNKNOWN = 0,      /* Unknown if scrubber is available */
+        SCRUB_NONE,             /* No scrubber */
+        SCRUB_SW_PROG,          /* SW progressive (sequential) scrubbing */
+        SCRUB_SW_SRC,           /* Software scrub only errors */
+        SCRUB_SW_PROG_SRC,      /* Progressive software scrub from an error */
+        SCRUB_SW_TUNABLE,       /* Software scrub frequency is tunable */
+        SCRUB_HW_PROG,          /* HW progressive (sequential) scrubbing */
+        SCRUB_HW_SRC,           /* Hardware scrub only errors */
+        SCRUB_HW_PROG_SRC,      /* Progressive hardware scrub from an error */
+        SCRUB_HW_TUNABLE        /* Hardware scrub frequency is tunable */
+};
+#define SCRUB_FLAG_SW_PROG      BIT(SCRUB_SW_PROG)
+#define SCRUB_FLAG_SW_SRC       BIT(SCRUB_SW_SRC)
+#define SCRUB_FLAG_SW_PROG_SRC  BIT(SCRUB_SW_PROG_SRC)
+#define SCRUB_FLAG_SW_TUN       BIT(SCRUB_SW_SCRUB_TUNABLE)
+#define SCRUB_FLAG_HW_PROG      BIT(SCRUB_HW_PROG)
+#define SCRUB_FLAG_HW_SRC       BIT(SCRUB_HW_SRC)
+#define SCRUB_FLAG_HW_PROG_SRC  BIT(SCRUB_HW_PROG_SRC)
+#define SCRUB_FLAG_HW_TUN       BIT(SCRUB_HW_TUNABLE)
+/* FIXME - should have notify capabilities: NMI, LOG, PROC, etc */
+/* EDAC internal operation states */
+#define OP_ALLOC                0x100
+#define OP_RUNNING_POLL         0x201
+#define OP_RUNNING_INTERRUPT    0x202
+#define OP_RUNNING_POLL_INTR    0x203
+#define OP_OFFLINE              0x300
+/*
+ * There are several things to be aware of that aren't at all obvious:
+ *
+ *
+ * SOCKETS, SOCKET SETS, BANKS, ROWS, CHIP-SELECT ROWS, CHANNELS, etc..
+ *
+ * These are some of the many terms that are thrown about that don't always
+ * mean what people think they mean (Inconceivable!).  In the interest of
+ * creating a common ground for discussion, terms and their definitions
+ * will be established.
+ *
+ * Memory devices:      The individual chip on a memory stick.  These devices
+ *                      commonly output 4 and 8 bits each.  Grouping several
+ *                      of these in parallel provides 64 bits which is common
+ *                      for a memory stick.
+ *
+ * Memory Stick:        A printed circuit board that aggregates multiple
+ *                      memory devices in parallel.  This is the atomic
+ *                      memory component that is purchaseable by Joe consumer
+ *                      and loaded into a memory socket.
+ *
+ * Socket:              A physical connector on the motherboard that accepts
+ *                      a single memory stick.
+ *
+ * Channel:             Set of memory devices on a memory stick that must be
+ *                      grouped in parallel with one or more additional
+ *                      channels from other memory sticks.  This parallel
+ *                      grouping of the output from multiple channels are
+ *                      necessary for the smallest granularity of memory access.
+ *                      Some memory controllers are capable of single channel -
+ *                      which means that memory sticks can be loaded
+ *                      individually.  Other memory controllers are only
+ *                      capable of dual channel - which means that memory
+ *                      sticks must be loaded as pairs (see "socket set").
+ *
+ * Chip-select row:     All of the memory devices that are selected together.
+ *                      for a single, minimum grain of memory access.
+ *                      This selects all of the parallel memory devices across
+ *                      all of the parallel channels.  Common chip-select rows
+ *                      for single channel are 64 bits, for dual channel 128
+ *                      bits.
+ *
+ * Single-Ranked stick: A Single-ranked stick has 1 chip-select row of memory.
+ *                      Motherboards commonly drive two chip-select pins to
+ *                      a memory stick. A single-ranked stick, will occupy
+ *                      only one of those rows. The other will be unused.
+ *
+ * Double-Ranked stick: A double-ranked stick has two chip-select rows which
+ *                      access different sets of memory devices.  The two
+ *                      rows cannot be accessed concurrently.
+ *
+ * Double-sided stick:  DEPRECATED TERM, see Double-Ranked stick.
+ *                      A double-sided stick has two chip-select rows which
+ *                      access different sets of memory devices.  The two
+ *                      rows cannot be accessed concurrently.  "Double-sided"
+ *                      is irrespective of the memory devices being mounted
+ *                      on both sides of the memory stick.
+ *
+ * Socket set:          All of the memory sticks that are required for
+ *                      a single memory access or all of the memory sticks
+ *                      spanned by a chip-select row.  A single socket set
+ *                      has two chip-select rows and if double-sided sticks
+ *                      are used these will occupy those chip-select rows.
+ *
+ * Bank:                This term is avoided because it is unclear when
+ *                      needing to distinguish between chip-select rows and
+ *                      socket sets.
+ *
+ * Controller pages:
+ *
+ * Physical pages:
+ *
+ * Virtual pages:
+ *
+ *
+ * STRUCTURE ORGANIZATION AND CHOICES
+ *
+ *
+ *
+ * PS - I enjoyed writing all that about as much as you enjoyed reading it.
+ */
+struct channel_info {
+        int chan_idx;           /* channel index */
+        u32 ce_count;           /* Correctable Errors for this CHANNEL */
+        char label[EDAC_MC_LABEL_LEN + 1];      /* DIMM label on motherboard */
+        struct csrow_info *csrow;       /* the parent */
+};
+struct csrow_info {
+        unsigned long first_page;       /* first page number in dimm */
+        unsigned long last_page;        /* last page number in dimm */
+        unsigned long page_mask;        /* used for interleaving -
+                                         * 0UL for non intlv
+                                         */
+        u32 nr_pages;           /* number of pages in csrow */
+        u32 grain;              /* granularity of reported error in bytes */
+        int csrow_idx;          /* the chip-select row */
+        enum dev_type dtype;    /* memory device type */
+        u32 ue_count;           /* Uncorrectable Errors for this csrow */
+        u32 ce_count;           /* Correctable Errors for this csrow */
+        enum mem_type mtype;    /* memory csrow type */
+        enum edac_type edac_mode;       /* EDAC mode for this csrow */
+        struct mem_ctl_info *mci;       /* the parent */
+        struct kobject kobj;    /* sysfs kobject for this csrow */
+        /* channel information for this csrow */
+        u32 nr_channels;
+        struct channel_info *channels;
+};
+struct mcidev_sysfs_group {
+        const char *name;                               /* group name */
+        const struct mcidev_sysfs_attribute *mcidev_attr; /* group attributes */
+};
+struct mcidev_sysfs_group_kobj {
+        struct list_head list;          /* list for all instances within a mc */
+        struct kobject kobj;            /* kobj for the group */
+        const struct mcidev_sysfs_group *grp;   /* group description table */
+        struct mem_ctl_info *mci;       /* the parent */
+};
+/* mcidev_sysfs_attribute structure
+ *      used for driver sysfs attributes and in mem_ctl_info
+ *      sysfs top level entries
+ */
+struct mcidev_sysfs_attribute {
+        /* It should use either attr or grp */
+        struct attribute attr;
+        const struct mcidev_sysfs_group *grp;   /* Points to a group of attributes */
+        /* Ops for show/store values at the attribute - not used on group */
+        ssize_t (*show)(struct mem_ctl_info *,char *);
+        ssize_t (*store)(struct mem_ctl_info *, const char *,size_t);
+};
+/* MEMORY controller information structure
+ */
+struct mem_ctl_info {
+        struct list_head link;  /* for global list of mem_ctl_info structs */
+        struct module *owner;   /* Module owner of this control struct */
+        unsigned long mtype_cap;        /* memory types supported by mc */
+        unsigned long edac_ctl_cap;     /* Mem controller EDAC capabilities */
+        unsigned long edac_cap; /* configuration capabilities - this is
+                                 * closely related to edac_ctl_cap.  The
+                                 * difference is that the controller may be
+                                 * capable of s4ecd4ed which would be listed
+                                 * in edac_ctl_cap, but if channels aren't
+                                 * capable of s4ecd4ed then the edac_cap would
+                                 * not have that capability.
+                                 */
+        unsigned long scrub_cap;        /* chipset scrub capabilities */
+        enum scrub_type scrub_mode;     /* current scrub mode */
+        /* Translates sdram memory scrub rate given in bytes/sec to the
+           internal representation and configures whatever else needs
+           to be configured.
+         */
+        int (*set_sdram_scrub_rate) (struct mem_ctl_info * mci, u32 bw);
+        /* Get the current sdram memory scrub rate from the internal
+           representation and converts it to the closest matching
+           bandwidth in bytes/sec.
+         */
+        int (*get_sdram_scrub_rate) (struct mem_ctl_info * mci);
+        /* pointer to edac checking routine */
+        void (*edac_check) (struct mem_ctl_info * mci);
+        /*
+         * Remaps memory pages: controller pages to physical pages.
+         * For most MC's, this will be NULL.
+         */
+        /* FIXME - why not send the phys page to begin with? */
+        unsigned long (*ctl_page_to_phys) (struct mem_ctl_info * mci,
+                                           unsigned long page);
+        int mc_idx;
+        int nr_csrows;
+        struct csrow_info *csrows;
+        /*
+         * FIXME - what about controllers on other busses? - IDs must be
+         * unique.  dev pointer should be sufficiently unique, but
+         * BUS:SLOT.FUNC numbers may not be unique.
+         */
+        struct device *dev;
+        const char *mod_name;
+        const char *mod_ver;
+        const char *ctl_name;
+        const char *dev_name;
+        char proc_name[MC_PROC_NAME_MAX_LEN + 1];
+        void *pvt_info;
+        u32 ue_noinfo_count;    /* Uncorrectable Errors w/o info */
+        u32 ce_noinfo_count;    /* Correctable Errors w/o info */
+        u32 ue_count;           /* Total Uncorrectable Errors for this MC */
+        u32 ce_count;           /* Total Correctable Errors for this MC */
+        unsigned long start_time;       /* mci load start time (in jiffies) */
+        struct completion complete;
+        /* edac sysfs device control */
+        struct kobject edac_mci_kobj;
+        /* list for all grp instances within a mc */
+        struct list_head grp_kobj_list;
+        /* Additional top controller level attributes, but specified
+         * by the low level driver.
+         *
+         * Set by the low level driver to provide attributes at the
+         * controller level, same level as 'ue_count' and 'ce_count' above.
+         * An array of structures, NULL terminated
+         *
+         * If attributes are desired, then set to array of attributes
+         * If no attributes are desired, leave NULL
+         */
+        const struct mcidev_sysfs_attribute *mc_driver_sysfs_attributes;
+        /* work struct for this MC */
+        struct delayed_work work;
+        /* the internal state of this controller instance */
+        int op_state;
+};
 #endif
diff --git a/include/linux/edac_mce.h b/include/linux/edac_mce.h
deleted file mode 100644
index f974fc035363..000000000000
--- a/include/linux/edac_mce.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/* Provides edac interface to mcelog events
- *
- * This file may be distributed under the terms of the
- * GNU General Public License version 2.
- *
- * Copyright (c) 2009 by:
- *       Mauro Carvalho Chehab <mchehab@redhat.com>
- *
- * Red Hat Inc. http://www.redhat.com
- */
-#if defined(CONFIG_EDAC_MCE) || \
-                        (defined(CONFIG_EDAC_MCE_MODULE) && defined(MODULE))
-#include <asm/mce.h>
-#include <linux/list.h>
-struct edac_mce {
-        struct list_head list;
-        void *priv;
-        int (*check_error)(void *priv, struct mce *mce);
-};
-int edac_mce_register(struct edac_mce *edac_mce);
-void edac_mce_unregister(struct edac_mce *edac_mce);
-int edac_mce_parse(struct mce *mce);
-#else
-#define edac_mce_parse(mce) (0)
-#endif
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index d800d5142184..1d0f7a2ff73b 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -38,6 +38,12 @@ struct elevator_ops
        elevator_merged_fn *elevator_merged_fn;
        elevator_merge_req_fn *elevator_merge_req_fn;
        elevator_allow_merge_fn *elevator_allow_merge_fn;
+        /*
+         * Used for both plugged list and elevator merging and in the
+         * former case called without queue_lock.  Read comment on top of
+         * attempt_plug_merge() for details.
+         */
        elevator_bio_merged_fn *elevator_bio_merged_fn;
        elevator_dispatch_fn *elevator_dispatch_fn;
diff --git a/include/linux/export.h b/include/linux/export.h
new file mode 100644
index 000000000000..696c0f48afc7
--- /dev/null
+++ b/include/linux/export.h
@@ -0,0 +1,89 @@
+#ifndef _LINUX_EXPORT_H
+#define _LINUX_EXPORT_H
+/*
+ * Export symbols from the kernel to modules.  Forked from module.h
+ * to reduce the amount of pointless cruft we feed to gcc when only
+ * exporting a simple symbol or two.
+ *
+ * If you feel the need to add #include <linux/foo.h> to this file
+ * then you are doing something wrong and should go away silently.
+ */
+/* Some toolchains use a `_' prefix for all user symbols. */
+#ifdef CONFIG_SYMBOL_PREFIX
+#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
+#else
+#define MODULE_SYMBOL_PREFIX ""
+#endif
+struct kernel_symbol
+{
+        unsigned long value;
+        const char *name;
+};
+#ifdef MODULE
+extern struct module __this_module;
+#define THIS_MODULE (&__this_module)
+#else
+#define THIS_MODULE ((struct module *)0)
+#endif
+#ifdef CONFIG_MODULES
+#ifndef __GENKSYMS__
+#ifdef CONFIG_MODVERSIONS
+/* Mark the CRC weak since genksyms apparently decides not to
+ * generate a checksums for some symbols */
+#define __CRC_SYMBOL(sym, sec)                                  \
+        extern void *__crc_##sym __attribute__((weak));         \
+        static const unsigned long __kcrctab_##sym              \
+        __used                                                  \
+        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
+        = (unsigned long) &__crc_##sym;
+#else
+#define __CRC_SYMBOL(sym, sec)
+#endif
+/* For every exported symbol, place a struct in the __ksymtab section */
+#define __EXPORT_SYMBOL(sym, sec)                               \
+        extern typeof(sym) sym;                                 \
+        __CRC_SYMBOL(sym, sec)                                  \
+        static const char __kstrtab_##sym[]                     \
+        __attribute__((section("__ksymtab_strings"), aligned(1))) \
+        = MODULE_SYMBOL_PREFIX #sym;                            \
+        static const struct kernel_symbol __ksymtab_##sym       \
+        __used                                                  \
+        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
+        = { (unsigned long)&sym, __kstrtab_##sym }
+#define EXPORT_SYMBOL(sym)                                      \
+        __EXPORT_SYMBOL(sym, "")
+#define EXPORT_SYMBOL_GPL(sym)                                  \
+        __EXPORT_SYMBOL(sym, "_gpl")
+#define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
+        __EXPORT_SYMBOL(sym, "_gpl_future")
+#ifdef CONFIG_UNUSED_SYMBOLS
+#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
+#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
+#else
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
+#endif
+#endif  /* __GENKSYMS__ */
+#else /* !CONFIG_MODULES... */
+#define EXPORT_SYMBOL(sym)
+#define EXPORT_SYMBOL_GPL(sym)
+#define EXPORT_SYMBOL_GPL_FUTURE(sym)
+#define EXPORT_UNUSED_SYMBOL(sym)
+#define EXPORT_UNUSED_SYMBOL_GPL(sym)
+#endif /* CONFIG_MODULES */
+#endif /* _LINUX_EXPORT_H */
diff --git a/include/linux/ext2_fs.h b/include/linux/ext2_fs.h
index 53792bf36c71..ce1b719e8bd4 100644
--- a/include/linux/ext2_fs.h
+++ b/include/linux/ext2_fs.h
@@ -197,8 +197,8 @@ struct ext2_group_desc
 /* Flags that should be inherited by new inodes from their parent. */
 #define EXT2_FL_INHERITED (EXT2_SECRM_FL | EXT2_UNRM_FL | EXT2_COMPR_FL |\
-                           EXT2_SYNC_FL | EXT2_IMMUTABLE_FL | EXT2_APPEND_FL |\
+                           EXT2_SYNC_FL | EXT2_NODUMP_FL |\
-                           EXT2_NODUMP_FL | EXT2_NOATIME_FL | EXT2_COMPRBLK_FL|\
+                           EXT2_NOATIME_FL | EXT2_COMPRBLK_FL |\
                           EXT2_NOCOMP_FL | EXT2_JOURNAL_DATA_FL |\
                           EXT2_NOTAIL_FL | EXT2_DIRSYNC_FL)
diff --git a/include/linux/ext3_fs.h b/include/linux/ext3_fs.h
index 81965cce6bfa..dec99116a0e4 100644
--- a/include/linux/ext3_fs.h
+++ b/include/linux/ext3_fs.h
@@ -180,8 +180,8 @@ struct ext3_group_desc
 /* Flags that should be inherited by new inodes from their parent. */
 #define EXT3_FL_INHERITED (EXT3_SECRM_FL | EXT3_UNRM_FL | EXT3_COMPR_FL |\
-                           EXT3_SYNC_FL | EXT3_IMMUTABLE_FL | EXT3_APPEND_FL |\
+                           EXT3_SYNC_FL | EXT3_NODUMP_FL |\
-                           EXT3_NODUMP_FL | EXT3_NOATIME_FL | EXT3_COMPRBLK_FL|\
+                           EXT3_NOATIME_FL | EXT3_COMPRBLK_FL |\
                           EXT3_NOCOMPR_FL | EXT3_JOURNAL_DATA_FL |\
                           EXT3_NOTAIL_FL | EXT3_DIRSYNC_FL)
@@ -381,7 +381,7 @@ struct ext3_inode {
 * Mount flags
 */
 #define EXT3_MOUNT_CHECK                0x00001 /* Do mount-time checks */
-#define EXT3_MOUNT_OLDALLOC             0x00002  /* Don't use the new Orlov allocator */
+/* EXT3_MOUNT_OLDALLOC was there */
 #define EXT3_MOUNT_GRPID                0x00004 /* Create files with directory's group */
 #define EXT3_MOUNT_DEBUG                0x00008 /* Some debugging messages */
 #define EXT3_MOUNT_ERRORS_CONT          0x00010 /* Continue on errors */
diff --git a/include/linux/ext3_fs_sb.h b/include/linux/ext3_fs_sb.h
index 258088ab3c6b..64365252f1b0 100644
--- a/include/linux/ext3_fs_sb.h
+++ b/include/linux/ext3_fs_sb.h
@@ -76,10 +76,6 @@ struct ext3_sb_info {
        struct mutex s_resize_lock;
        unsigned long s_commit_interval;
        struct block_device *journal_bdev;
-#ifdef CONFIG_JBD_DEBUG
-        struct timer_list turn_ro_timer;        /* For turning read-only (crash simulation) */
-        wait_queue_head_t ro_wait_queue;        /* For people waiting for the fs to go read-only */
-#endif
 #ifdef CONFIG_QUOTA
        char *s_qf_names[MAXQUOTAS];            /* Names of quota files with journalled quota */
        int s_jquota_fmt;                       /* Format of quota to use */
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index 21b3e7588abd..1e7c01189fa6 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -1,7 +1,6 @@
 #ifndef _LINUX_FIRMWARE_H
 #define _LINUX_FIRMWARE_H
-#include <linux/module.h>
 #include <linux/types.h>
 #include <linux/compiler.h>
 #include <linux/gfp.h>
@@ -15,6 +14,7 @@ struct firmware {
        struct page **pages;
 };
+struct module;
 struct device;
 struct builtin_fw {
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index a49b52934c55..a5386e3ee756 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -143,14 +143,9 @@ static inline void set_freezable_with_signal(void)
 #define wait_event_freezekillable(wq, condition)                        \
 ({                                                                      \
        int __retval;                                                   \
-        do {                                                            \
+        freezer_do_not_count();                                         \
-                __retval = wait_event_killable(wq,                      \
+        __retval = wait_event_killable(wq, (condition));                \
-                                (condition) || freezing(current));      \
+        freezer_count();                                                \
-                if (__retval && !freezing(current))                     \
-                        break;                                          \
-                else if (!(condition))                                  \
-                        __retval = -ERESTARTSYS;                        \
-        } while (try_to_freeze());                                      \
        __retval;                                                       \
 })
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 7a049fd2aa4c..0c4df261af7e 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -768,14 +768,25 @@ struct inode {
        /* Stat data, not accessed from path walking */
        unsigned long           i_ino;
-        unsigned int            i_nlink;
+        /*
+         * Filesystems may only read i_nlink directly.  They shall use the
+         * following functions for modification:
+         *
+         *    (set|clear|inc|drop)_nlink
+         *    inode_(inc|dec)_link_count
+         */
+        union {
+                const unsigned int i_nlink;
+                unsigned int __i_nlink;
+        };
        dev_t                   i_rdev;
-        loff_t                  i_size;
        struct timespec         i_atime;
        struct timespec         i_mtime;
        struct timespec         i_ctime;
-        unsigned int            i_blkbits;
+        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
+        unsigned short          i_bytes;
        blkcnt_t                i_blocks;
+        loff_t                  i_size;
 #ifdef __NEED_I_SIZE_ORDERED
        seqcount_t              i_size_seqcount;
@@ -783,7 +794,6 @@ struct inode {
        /* Misc */
        unsigned long           i_state;
-        spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
        struct mutex            i_mutex;
        unsigned long           dirtied_when;   /* jiffies of first dirtying */
@@ -797,9 +807,10 @@ struct inode {
                struct rcu_head         i_rcu;
        };
        atomic_t                i_count;
+        unsigned int            i_blkbits;
        u64                     i_version;
-        unsigned short          i_bytes;
        atomic_t                i_dio_count;
+        atomic_t                i_writecount;
        const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
        struct file_lock        *i_flock;
        struct address_space    i_data;
@@ -823,7 +834,6 @@ struct inode {
 #ifdef CONFIG_IMA
        atomic_t                i_readcount; /* struct files open RO */
 #endif
-        atomic_t                i_writecount;
        void                    *i_private; /* fs or device private pointer */
 };
@@ -1755,6 +1765,19 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
 }
 /**
+ * set_nlink - directly set an inode's link count
+ * @inode: inode
+ * @nlink: new nlink (should be non-zero)
+ *
+ * This is a low-level filesystem helper to replace any
+ * direct filesystem manipulation of i_nlink.
+ */
+static inline void set_nlink(struct inode *inode, unsigned int nlink)
+{
+        inode->__i_nlink = nlink;
+}
+/**
 * inc_nlink - directly increment an inode's link count
 * @inode: inode
 *
@@ -1764,7 +1787,7 @@ static inline void mark_inode_dirty_sync(struct inode *inode)
 */
 static inline void inc_nlink(struct inode *inode)
 {
-        inode->i_nlink++;
+        inode->__i_nlink++;
 }
 static inline void inode_inc_link_count(struct inode *inode)
@@ -1786,7 +1809,7 @@ static inline void inode_inc_link_count(struct inode *inode)
 */
 static inline void drop_nlink(struct inode *inode)
 {
-        inode->i_nlink--;
+        inode->__i_nlink--;
 }
 /**
@@ -1799,7 +1822,7 @@ static inline void drop_nlink(struct inode *inode)
 */
 static inline void clear_nlink(struct inode *inode)
 {
-        inode->i_nlink = 0;
+        inode->__i_nlink = 0;
 }
 static inline void inode_dec_link_count(struct inode *inode)
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index f0c0e8a47ae6..26eafcef75be 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -10,7 +10,6 @@
 #include <linux/kallsyms.h>
 #include <linux/linkage.h>
 #include <linux/bitops.h>
-#include <linux/module.h>
 #include <linux/ktime.h>
 #include <linux/sched.h>
 #include <linux/types.h>
@@ -19,6 +18,7 @@
 #include <asm/ftrace.h>
+struct module;
 struct ftrace_hash;
 #ifdef CONFIG_FUNCTION_TRACER
diff --git a/include/linux/gameport.h b/include/linux/gameport.h
index 069ee4139105..b456b08d70ed 100644
--- a/include/linux/gameport.h
+++ b/include/linux/gameport.h
@@ -71,10 +71,9 @@ void gameport_close(struct gameport *gameport);
 #if defined(CONFIG_GAMEPORT) || (defined(MODULE) && defined(CONFIG_GAMEPORT_MODULE))
 void __gameport_register_port(struct gameport *gameport, struct module *owner);
-static inline void gameport_register_port(struct gameport *gameport)
+/* use a define to avoid include chaining to get THIS_MODULE */
-{
+#define gameport_register_port(gameport) \
-        __gameport_register_port(gameport, THIS_MODULE);
+        __gameport_register_port(gameport, THIS_MODULE)
-}
 void gameport_unregister_port(struct gameport *gameport);
@@ -145,12 +144,12 @@ static inline void gameport_unpin_driver(struct gameport *gameport)
        mutex_unlock(&gameport->drv_mutex);
 }
-int __gameport_register_driver(struct gameport_driver *drv,
+int __must_check __gameport_register_driver(struct gameport_driver *drv,
                                struct module *owner, const char *mod_name);
-static inline int __must_check gameport_register_driver(struct gameport_driver *drv)
-{
+/* use a define to avoid include chaining to get THIS_MODULE & friends */
-        return __gameport_register_driver(drv, THIS_MODULE, KBUILD_MODNAME);
+#define gameport_register_driver(drv) \
-}
+        __gameport_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
 void gameport_unregister_driver(struct gameport_driver *drv);
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 6957350e122f..9de31bc98c88 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -131,6 +131,7 @@ struct hd_struct {
 #define GENHD_FL_EXT_DEVT                       64 /* allow extended devt */
 #define GENHD_FL_NATIVE_CAPACITY                128
 #define GENHD_FL_BLOCK_EVENTS_ON_EXCL_WRITE     256
+#define GENHD_FL_NO_PART_SCAN                   512
 enum {
        DISK_EVENT_MEDIA_CHANGE                 = 1 << 0, /* media changed */
@@ -238,9 +239,10 @@ static inline int disk_max_parts(struct gendisk *disk)
        return disk->minors;
 }
-static inline bool disk_partitionable(struct gendisk *disk)
+static inline bool disk_part_scan_enabled(struct gendisk *disk)
 {
-        return disk_max_parts(disk) > 1;
+        return disk_max_parts(disk) > 1 &&
+                !(disk->flags & GENHD_FL_NO_PART_SCAN);
 }
 static inline dev_t disk_devt(struct gendisk *disk)
diff --git a/include/linux/hid.h b/include/linux/hid.h
index deed5f9a1e1c..c235e4e8767c 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -697,10 +697,11 @@ extern void hid_destroy_device(struct hid_device *);
 extern int __must_check __hid_register_driver(struct hid_driver *,
                struct module *, const char *mod_name);
-static inline int __must_check hid_register_driver(struct hid_driver *driver)
-{
+/* use a define to avoid include chaining to get THIS_MODULE & friends */
-        return __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
+#define hid_register_driver(driver) \
-}
+        __hid_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 extern void hid_unregister_driver(struct hid_driver *);
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
diff --git a/include/linux/hwspinlock.h b/include/linux/hwspinlock.h
index 8390efc457eb..08a2fee40659 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -20,17 +20,49 @@
 #include <linux/err.h>
 #include <linux/sched.h>
+#include <linux/device.h>
 /* hwspinlock mode argument */
 #define HWLOCK_IRQSTATE 0x01    /* Disable interrupts, save state */
 #define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
 struct hwspinlock;
+struct hwspinlock_device;
+struct hwspinlock_ops;
+/**
+ * struct hwspinlock_pdata - platform data for hwspinlock drivers
+ * @base_id: base id for this hwspinlock device
+ *
+ * hwspinlock devices provide system-wide hardware locks that are used
+ * by remote processors that have no other way to achieve synchronization.
+ *
+ * To achieve that, each physical lock must have a system-wide id number
+ * that is agreed upon, otherwise remote processors can't possibly assume
+ * they're using the same hardware lock.
+ *
+ * Usually boards have a single hwspinlock device, which provides several
+ * hwspinlocks, and in this case, they can be trivially numbered 0 to
+ * (num-of-locks - 1).
+ *
+ * In case boards have several hwspinlocks devices, a different base id
+ * should be used for each hwspinlock device (they can't all use 0 as
+ * a starting id!).
+ *
+ * This platform data structure should be used to provide the base id
+ * for each device (which is trivially 0 when only a single hwspinlock
+ * device exists). It can be shared between different platforms, hence
+ * its location.
+ */
+struct hwspinlock_pdata {
+        int base_id;
+};
 #if defined(CONFIG_HWSPINLOCK) || defined(CONFIG_HWSPINLOCK_MODULE)
-int hwspin_lock_register(struct hwspinlock *lock);
+int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
-struct hwspinlock *hwspin_lock_unregister(unsigned int id);
+                const struct hwspinlock_ops *ops, int base_id, int num_locks);
+int hwspin_lock_unregister(struct hwspinlock_device *bank);
 struct hwspinlock *hwspin_lock_request(void);
 struct hwspinlock *hwspin_lock_request_specific(unsigned int id);
 int hwspin_lock_free(struct hwspinlock *hwlock);
@@ -94,16 +126,6 @@ static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
        return 0;
 }
-static inline int hwspin_lock_register(struct hwspinlock *hwlock)
-{
-        return -ENODEV;
-}
-static inline struct hwspinlock *hwspin_lock_unregister(unsigned int id)
-{
-        return NULL;
-}
 #endif /* !CONFIG_HWSPINLOCK */
 /**
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 38a21c3edd2c..a81bf6d23b3e 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -28,7 +28,6 @@
 #include <linux/types.h>
 #ifdef __KERNEL__
-#include <linux/module.h>
 #include <linux/mod_devicetable.h>
 #include <linux/device.h>       /* for struct device */
 #include <linux/sched.h>        /* for completion */
@@ -49,6 +48,8 @@ struct i2c_driver;
 union i2c_smbus_data;
 struct i2c_board_info;
+struct module;
 #if defined(CONFIG_I2C) || defined(CONFIG_I2C_MODULE)
 /*
 * The master routines are the ones normally used to transmit data to devices
@@ -451,10 +452,9 @@ extern int i2c_add_numbered_adapter(struct i2c_adapter *);
 extern int i2c_register_driver(struct module *, struct i2c_driver *);
 extern void i2c_del_driver(struct i2c_driver *);
-static inline int i2c_add_driver(struct i2c_driver *driver)
+/* use a define to avoid include chaining to get THIS_MODULE */
-{
+#define i2c_add_driver(driver) \
-        return i2c_register_driver(THIS_MODULE, driver);
+        i2c_register_driver(THIS_MODULE, driver)
-}
 extern struct i2c_client *i2c_use_client(struct i2c_client *client);
 extern void i2c_release_client(struct i2c_client *client);
diff --git a/include/linux/i2c/twl4030-madc.h b/include/linux/i2c/twl4030-madc.h
index 6427d298fbfc..530e11ba0738 100644
--- a/include/linux/i2c/twl4030-madc.h
+++ b/include/linux/i2c/twl4030-madc.h
@@ -129,6 +129,10 @@ enum sample_type {
 #define REG_BCICTL2             0x024
 #define TWL4030_BCI_ITHSENS     0x007
+/* Register and bits for GPBR1 register */
+#define TWL4030_REG_GPBR1               0x0c
+#define TWL4030_GPBR1_MADC_HFCLK_EN     (1 << 7)
 struct twl4030_madc_user_parms {
        int channel;
        int average;
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index ca85cf894e33..bbd156bb953b 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -220,10 +220,11 @@ struct kernel_ipmi_msg {
 * The in-kernel interface.
 */
 #include <linux/list.h>
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/proc_fs.h>
+struct module;
 /* Opaque type for a IPMI message user.  One of these is needed to
   send and receive messages. */
 typedef struct ipmi_user *ipmi_user_t;
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index 204f9cd26c16..3ef0d8b6aa6f 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -36,7 +36,6 @@
 #include <linux/ipmi_msgdefs.h>
 #include <linux/proc_fs.h>
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/platform_device.h>
 #include <linux/ipmi.h>
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 59e49c80cc2c..bff29c58da23 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -23,13 +23,13 @@
 #include <linux/errno.h>
 #include <linux/topology.h>
 #include <linux/wait.h>
-#include <linux/module.h>
 #include <asm/irq.h>
 #include <asm/ptrace.h>
 #include <asm/irq_regs.h>
 struct seq_file;
+struct module;
 struct irq_desc;
 struct irq_data;
 typedef void (*irq_flow_handler_t)(unsigned int irq,
@@ -567,29 +567,21 @@ static inline struct msi_desc *irq_data_get_msi(struct irq_data *d)
 int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
                struct module *owner);
-static inline int irq_alloc_descs(int irq, unsigned int from, unsigned int cnt,
+/* use macros to avoid needing export.h for THIS_MODULE */
-                int node)
+#define irq_alloc_descs(irq, from, cnt, node)   \
-{
+        __irq_alloc_descs(irq, from, cnt, node, THIS_MODULE)
-        return __irq_alloc_descs(irq, from, cnt, node, THIS_MODULE);
-}
-void irq_free_descs(unsigned int irq, unsigned int cnt);
+#define irq_alloc_desc(node)                    \
-int irq_reserve_irqs(unsigned int from, unsigned int cnt);
+        irq_alloc_descs(-1, 0, 1, node)
-static inline int irq_alloc_desc(int node)
+#define irq_alloc_desc_at(at, node)             \
-{
+        irq_alloc_descs(at, at, 1, node)
-        return irq_alloc_descs(-1, 0, 1, node);
-}
-static inline int irq_alloc_desc_at(unsigned int at, int node)
+#define irq_alloc_desc_from(from, node)         \
-{
+        irq_alloc_descs(-1, from, 1, node)
-        return irq_alloc_descs(at, at, 1, node);
-}
-static inline int irq_alloc_desc_from(unsigned int from, int node)
+void irq_free_descs(unsigned int irq, unsigned int cnt);
-{
+int irq_reserve_irqs(unsigned int from, unsigned int cnt);
-        return irq_alloc_descs(-1, from, 1, node);
-}
 static inline void irq_free_desc(unsigned int irq)
 {
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index 6b69c2c9dff1..f1e2527006bd 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -11,6 +11,7 @@
 struct irq_affinity_notify;
 struct proc_dir_entry;
 struct timer_rand_state;
+struct module;
 /**
 * struct irq_desc - interrupt descriptor
 * @irq_data:           per irq and chip data passed down to chip functions
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index e6a5e34bed4f..c7acdde3243d 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -244,6 +244,7 @@ typedef struct journal_superblock_s
 #include <linux/fs.h>
 #include <linux/sched.h>
+#include <linux/jbd_common.h>
 #define J_ASSERT(assert)        BUG_ON(!(assert))
@@ -270,69 +271,6 @@ typedef struct journal_superblock_s
 #define J_EXPECT_JH(jh, expr, why...)   __journal_expect(expr, ## why)
 #endif
-enum jbd_state_bits {
-        BH_JBD                  /* Has an attached ext3 journal_head */
-          = BH_PrivateStart,
-        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
-        BH_Freed,               /* Has been freed (truncated) */
-        BH_Revoked,             /* Has been revoked from the log */
-        BH_RevokeValid,         /* Revoked flag is valid */
-        BH_JBDDirty,            /* Is dirty but journaled */
-        BH_State,               /* Pins most journal_head state */
-        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
-        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
-};
-BUFFER_FNS(JBD, jbd)
-BUFFER_FNS(JWrite, jwrite)
-BUFFER_FNS(JBDDirty, jbddirty)
-TAS_BUFFER_FNS(JBDDirty, jbddirty)
-BUFFER_FNS(Revoked, revoked)
-TAS_BUFFER_FNS(Revoked, revoked)
-BUFFER_FNS(RevokeValid, revokevalid)
-TAS_BUFFER_FNS(RevokeValid, revokevalid)
-BUFFER_FNS(Freed, freed)
-static inline struct buffer_head *jh2bh(struct journal_head *jh)
-{
-        return jh->b_bh;
-}
-static inline struct journal_head *bh2jh(struct buffer_head *bh)
-{
-        return bh->b_private;
-}
-static inline void jbd_lock_bh_state(struct buffer_head *bh)
-{
-        bit_spin_lock(BH_State, &bh->b_state);
-}
-static inline int jbd_trylock_bh_state(struct buffer_head *bh)
-{
-        return bit_spin_trylock(BH_State, &bh->b_state);
-}
-static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
-{
-        return bit_spin_is_locked(BH_State, &bh->b_state);
-}
-static inline void jbd_unlock_bh_state(struct buffer_head *bh)
-{
-        bit_spin_unlock(BH_State, &bh->b_state);
-}
-static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
-{
-        bit_spin_lock(BH_JournalHead, &bh->b_state);
-}
-static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
-{
-        bit_spin_unlock(BH_JournalHead, &bh->b_state);
-}
 struct jbd_revoke_table_s;
 /**
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 38f307b8c334..2092ea21e469 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -275,6 +275,7 @@ typedef struct journal_superblock_s
 #include <linux/fs.h>
 #include <linux/sched.h>
+#include <linux/jbd_common.h>
 #define J_ASSERT(assert)        BUG_ON(!(assert))
@@ -302,70 +303,6 @@ typedef struct journal_superblock_s
 #define J_EXPECT_JH(jh, expr, why...)   __journal_expect(expr, ## why)
 #endif
-enum jbd_state_bits {
-        BH_JBD                  /* Has an attached ext3 journal_head */
-          = BH_PrivateStart,
-        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
-        BH_Freed,               /* Has been freed (truncated) */
-        BH_Revoked,             /* Has been revoked from the log */
-        BH_RevokeValid,         /* Revoked flag is valid */
-        BH_JBDDirty,            /* Is dirty but journaled */
-        BH_State,               /* Pins most journal_head state */
-        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
-        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
-        BH_JBDPrivateStart,     /* First bit available for private use by FS */
-};
-BUFFER_FNS(JBD, jbd)
-BUFFER_FNS(JWrite, jwrite)
-BUFFER_FNS(JBDDirty, jbddirty)
-TAS_BUFFER_FNS(JBDDirty, jbddirty)
-BUFFER_FNS(Revoked, revoked)
-TAS_BUFFER_FNS(Revoked, revoked)
-BUFFER_FNS(RevokeValid, revokevalid)
-TAS_BUFFER_FNS(RevokeValid, revokevalid)
-BUFFER_FNS(Freed, freed)
-static inline struct buffer_head *jh2bh(struct journal_head *jh)
-{
-        return jh->b_bh;
-}
-static inline struct journal_head *bh2jh(struct buffer_head *bh)
-{
-        return bh->b_private;
-}
-static inline void jbd_lock_bh_state(struct buffer_head *bh)
-{
-        bit_spin_lock(BH_State, &bh->b_state);
-}
-static inline int jbd_trylock_bh_state(struct buffer_head *bh)
-{
-        return bit_spin_trylock(BH_State, &bh->b_state);
-}
-static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
-{
-        return bit_spin_is_locked(BH_State, &bh->b_state);
-}
-static inline void jbd_unlock_bh_state(struct buffer_head *bh)
-{
-        bit_spin_unlock(BH_State, &bh->b_state);
-}
-static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
-{
-        bit_spin_lock(BH_JournalHead, &bh->b_state);
-}
-static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
-{
-        bit_spin_unlock(BH_JournalHead, &bh->b_state);
-}
 /* Flags in jbd_inode->i_flags */
 #define __JI_COMMIT_RUNNING 0
 /* Commit of the inode data in progress. We use this flag to protect us from
@@ -1106,9 +1043,9 @@ static inline handle_t *journal_current_handle(void)
 */
 extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
-extern handle_t *jbd2__journal_start(journal_t *, int nblocks, int gfp_mask);
+extern handle_t *jbd2__journal_start(journal_t *, int nblocks, gfp_t gfp_mask);
 extern int       jbd2_journal_restart(handle_t *, int nblocks);
-extern int       jbd2__journal_restart(handle_t *, int nblocks, int gfp_mask);
+extern int       jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
 extern int       jbd2_journal_extend (handle_t *, int nblocks);
 extern int       jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
 extern int       jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
diff --git a/include/linux/jbd_common.h b/include/linux/jbd_common.h
new file mode 100644
index 000000000000..6230f8556a4e
--- /dev/null
+++ b/include/linux/jbd_common.h
@@ -0,0 +1,68 @@
+#ifndef _LINUX_JBD_STATE_H
+#define _LINUX_JBD_STATE_H
+enum jbd_state_bits {
+        BH_JBD                  /* Has an attached ext3 journal_head */
+          = BH_PrivateStart,
+        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
+        BH_Freed,               /* Has been freed (truncated) */
+        BH_Revoked,             /* Has been revoked from the log */
+        BH_RevokeValid,         /* Revoked flag is valid */
+        BH_JBDDirty,            /* Is dirty but journaled */
+        BH_State,               /* Pins most journal_head state */
+        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
+        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
+        BH_JBDPrivateStart,     /* First bit available for private use by FS */
+};
+BUFFER_FNS(JBD, jbd)
+BUFFER_FNS(JWrite, jwrite)
+BUFFER_FNS(JBDDirty, jbddirty)
+TAS_BUFFER_FNS(JBDDirty, jbddirty)
+BUFFER_FNS(Revoked, revoked)
+TAS_BUFFER_FNS(Revoked, revoked)
+BUFFER_FNS(RevokeValid, revokevalid)
+TAS_BUFFER_FNS(RevokeValid, revokevalid)
+BUFFER_FNS(Freed, freed)
+static inline struct buffer_head *jh2bh(struct journal_head *jh)
+{
+        return jh->b_bh;
+}
+static inline struct journal_head *bh2jh(struct buffer_head *bh)
+{
+        return bh->b_private;
+}
+static inline void jbd_lock_bh_state(struct buffer_head *bh)
+{
+        bit_spin_lock(BH_State, &bh->b_state);
+}
+static inline int jbd_trylock_bh_state(struct buffer_head *bh)
+{
+        return bit_spin_trylock(BH_State, &bh->b_state);
+}
+static inline int jbd_is_locked_bh_state(struct buffer_head *bh)
+{
+        return bit_spin_is_locked(BH_State, &bh->b_state);
+}
+static inline void jbd_unlock_bh_state(struct buffer_head *bh)
+{
+        bit_spin_unlock(BH_State, &bh->b_state);
+}
+static inline void jbd_lock_bh_journal_head(struct buffer_head *bh)
+{
+        bit_spin_lock(BH_JournalHead, &bh->b_state);
+}
+static inline void jbd_unlock_bh_journal_head(struct buffer_head *bh)
+{
+        bit_spin_unlock(BH_JournalHead, &bh->b_state);
+}
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 4c0d3b2fd5fc..e8b1597b5cf2 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -371,6 +371,7 @@ extern enum system_states {
 #define TAINT_WARN                      9
 #define TAINT_CRAP                      10
 #define TAINT_FIRMWARE_WORKAROUND       11
+#define TAINT_OOT_MODULE                12
 extern const char hex_asc[];
 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
diff --git a/include/linux/loop.h b/include/linux/loop.h
index 683d69890119..11a41a8f08eb 100644
--- a/include/linux/loop.h
+++ b/include/linux/loop.h
@@ -73,8 +73,8 @@ struct loop_device {
 */
 enum {
        LO_FLAGS_READ_ONLY      = 1,
-        LO_FLAGS_USE_AOPS       = 2,
        LO_FLAGS_AUTOCLEAR      = 4,
+        LO_FLAGS_PARTSCAN       = 8,
 };
 #include <asm/posix_types.h>    /* for __kernel_old_dev_t */
diff --git a/include/linux/magic.h b/include/linux/magic.h
index 1e5df2af8d84..2d4beab0d5b7 100644
--- a/include/linux/magic.h
+++ b/include/linux/magic.h
@@ -30,11 +30,11 @@
 #define ANON_INODE_FS_MAGIC     0x09041934
 #define PSTOREFS_MAGIC          0x6165676C
-#define MINIX_SUPER_MAGIC       0x137F          /* original minix fs */
+#define MINIX_SUPER_MAGIC       0x137F          /* minix v1 fs, 14 char names */
-#define MINIX_SUPER_MAGIC2      0x138F          /* minix fs, 30 char names */
+#define MINIX_SUPER_MAGIC2      0x138F          /* minix v1 fs, 30 char names */
-#define MINIX2_SUPER_MAGIC      0x2468          /* minix V2 fs */
+#define MINIX2_SUPER_MAGIC      0x2468          /* minix v2 fs, 14 char names */
-#define MINIX2_SUPER_MAGIC2     0x2478          /* minix V2 fs, 30 char names */
+#define MINIX2_SUPER_MAGIC2     0x2478          /* minix v2 fs, 30 char names */
-#define MINIX3_SUPER_MAGIC      0x4d5a          /* minix V3 fs */
+#define MINIX3_SUPER_MAGIC      0x4d5a          /* minix v3 fs, 60 char names */
 #define MSDOS_SUPER_MAGIC       0x4d44          /* MD */
 #define NCP_SUPER_MAGIC         0x564c          /* Guess, what 0x564c is :-) */
diff --git a/include/linux/mdio-bitbang.h b/include/linux/mdio-bitbang.h
index 8ea9a42a4c02..0fe00cd4c93c 100644
--- a/include/linux/mdio-bitbang.h
+++ b/include/linux/mdio-bitbang.h
@@ -2,7 +2,8 @@
 #define __LINUX_MDIO_BITBANG_H
 #include <linux/phy.h>
-#include <linux/module.h>
+struct module;
 struct mdiobb_ctrl;
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index ac797fa03ef8..b87068a1a09e 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -78,8 +78,8 @@ extern void mem_cgroup_uncharge_end(void);
 extern void mem_cgroup_uncharge_page(struct page *page);
 extern void mem_cgroup_uncharge_cache_page(struct page *page);
-extern void mem_cgroup_out_of_memory(struct mem_cgroup *mem, gfp_t gfp_mask);
+extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask);
-int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *mem);
+int task_in_mem_cgroup(struct task_struct *task, const struct mem_cgroup *memcg);
 extern struct mem_cgroup *try_get_mem_cgroup_from_page(struct page *page);
 extern struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
@@ -88,26 +88,28 @@ extern struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm);
 static inline
 int mm_match_cgroup(const struct mm_struct *mm, const struct mem_cgroup *cgroup)
 {
-        struct mem_cgroup *mem;
+        struct mem_cgroup *memcg;
        rcu_read_lock();
-        mem = mem_cgroup_from_task(rcu_dereference((mm)->owner));
+        memcg = mem_cgroup_from_task(rcu_dereference((mm)->owner));
        rcu_read_unlock();
-        return cgroup == mem;
+        return cgroup == memcg;
 }
-extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem);
+extern struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *memcg);
 extern int
 mem_cgroup_prepare_migration(struct page *page,
        struct page *newpage, struct mem_cgroup **ptr, gfp_t gfp_mask);
-extern void mem_cgroup_end_migration(struct mem_cgroup *mem,
+extern void mem_cgroup_end_migration(struct mem_cgroup *memcg,
        struct page *oldpage, struct page *newpage, bool migration_ok);
 /*
 * For memory reclaim.
 */
-int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg);
+int mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg,
-int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg);
+                                    struct zone *zone);
+int mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg,
+                                    struct zone *zone);
 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_zone_nr_lru_pages(struct mem_cgroup *memcg,
                                        int nid, int zid, unsigned int lrumask);
@@ -148,7 +150,7 @@ static inline void mem_cgroup_dec_page_stat(struct page *page,
 unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
                                                gfp_t gfp_mask,
                                                unsigned long *total_scanned);
-u64 mem_cgroup_get_limit(struct mem_cgroup *mem);
+u64 mem_cgroup_get_limit(struct mem_cgroup *memcg);
 void mem_cgroup_count_vm_event(struct mm_struct *mm, enum vm_event_item idx);
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
@@ -244,18 +246,20 @@ static inline struct mem_cgroup *try_get_mem_cgroup_from_mm(struct mm_struct *mm
        return NULL;
 }
-static inline int mm_match_cgroup(struct mm_struct *mm, struct mem_cgroup *mem)
+static inline int mm_match_cgroup(struct mm_struct *mm,
+                struct mem_cgroup *memcg)
 {
        return 1;
 }
 static inline int task_in_mem_cgroup(struct task_struct *task,
-                                     const struct mem_cgroup *mem)
+                                     const struct mem_cgroup *memcg)
 {
        return 1;
 }
-static inline struct cgroup_subsys_state *mem_cgroup_css(struct mem_cgroup *mem)
+static inline struct cgroup_subsys_state
+                *mem_cgroup_css(struct mem_cgroup *memcg)
 {
        return NULL;
 }
@@ -267,22 +271,22 @@ mem_cgroup_prepare_migration(struct page *page, struct page *newpage,
        return 0;
 }
-static inline void mem_cgroup_end_migration(struct mem_cgroup *mem,
+static inline void mem_cgroup_end_migration(struct mem_cgroup *memcg,
                struct page *oldpage, struct page *newpage, bool migration_ok)
 {
 }
-static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *mem)
+static inline int mem_cgroup_get_reclaim_priority(struct mem_cgroup *memcg)
 {
        return 0;
 }
-static inline void mem_cgroup_note_reclaim_priority(struct mem_cgroup *mem,
+static inline void mem_cgroup_note_reclaim_priority(struct mem_cgroup *memcg,
                                                int priority)
 {
 }
-static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *mem,
+static inline void mem_cgroup_record_reclaim_priority(struct mem_cgroup *memcg,
                                                int priority)
 {
 }
@@ -293,13 +297,13 @@ static inline bool mem_cgroup_disabled(void)
 }
 static inline int
-mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg)
+mem_cgroup_inactive_anon_is_low(struct mem_cgroup *memcg, struct zone *zone)
 {
        return 1;
 }
 static inline int
-mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg)
+mem_cgroup_inactive_file_is_low(struct mem_cgroup *memcg, struct zone *zone)
 {
        return 1;
 }
@@ -348,7 +352,7 @@ unsigned long mem_cgroup_soft_limit_reclaim(struct zone *zone, int order,
 }
 static inline
-u64 mem_cgroup_get_limit(struct mem_cgroup *mem)
+u64 mem_cgroup_get_limit(struct mem_cgroup *memcg)
 {
        return 0;
 }
diff --git a/include/linux/mfd/ab5500/ab5500.h b/include/linux/mfd/ab5500/ab5500.h
new file mode 100644
index 000000000000..a720051ae933
--- /dev/null
+++ b/include/linux/mfd/ab5500/ab5500.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) ST-Ericsson 2011
+ *
+ * License Terms: GNU General Public License v2
+ */
+#ifndef MFD_AB5500_H
+#define MFD_AB5500_H
+#include <linux/device.h>
+enum ab5500_devid {
+        AB5500_DEVID_ADC,
+        AB5500_DEVID_LEDS,
+        AB5500_DEVID_POWER,
+        AB5500_DEVID_REGULATORS,
+        AB5500_DEVID_SIM,
+        AB5500_DEVID_RTC,
+        AB5500_DEVID_CHARGER,
+        AB5500_DEVID_FUELGAUGE,
+        AB5500_DEVID_VIBRATOR,
+        AB5500_DEVID_CODEC,
+        AB5500_DEVID_USB,
+        AB5500_DEVID_OTP,
+        AB5500_DEVID_VIDEO,
+        AB5500_DEVID_DBIECI,
+        AB5500_DEVID_ONSWA,
+        AB5500_NUM_DEVICES,
+};
+enum ab5500_banks {
+        AB5500_BANK_VIT_IO_I2C_CLK_TST_OTP = 0,
+        AB5500_BANK_VDDDIG_IO_I2C_CLK_TST = 1,
+        AB5500_BANK_VDENC = 2,
+        AB5500_BANK_SIM_USBSIM  = 3,
+        AB5500_BANK_LED = 4,
+        AB5500_BANK_ADC  = 5,
+        AB5500_BANK_RTC  = 6,
+        AB5500_BANK_STARTUP  = 7,
+        AB5500_BANK_DBI_ECI  = 8,
+        AB5500_BANK_CHG  = 9,
+        AB5500_BANK_FG_BATTCOM_ACC = 10,
+        AB5500_BANK_USB = 11,
+        AB5500_BANK_IT = 12,
+        AB5500_BANK_VIBRA = 13,
+        AB5500_BANK_AUDIO_HEADSETUSB = 14,
+        AB5500_NUM_BANKS = 15,
+};
+enum ab5500_banks_addr {
+        AB5500_ADDR_VIT_IO_I2C_CLK_TST_OTP = 0x4A,
+        AB5500_ADDR_VDDDIG_IO_I2C_CLK_TST = 0x4B,
+        AB5500_ADDR_VDENC = 0x06,
+        AB5500_ADDR_SIM_USBSIM  = 0x04,
+        AB5500_ADDR_LED = 0x10,
+        AB5500_ADDR_ADC  = 0x0A,
+        AB5500_ADDR_RTC  = 0x0F,
+        AB5500_ADDR_STARTUP  = 0x03,
+        AB5500_ADDR_DBI_ECI  = 0x07,
+        AB5500_ADDR_CHG  = 0x0B,
+        AB5500_ADDR_FG_BATTCOM_ACC = 0x0C,
+        AB5500_ADDR_USB = 0x05,
+        AB5500_ADDR_IT = 0x0E,
+        AB5500_ADDR_VIBRA = 0x02,
+        AB5500_ADDR_AUDIO_HEADSETUSB = 0x0D,
+};
+/*
+ * Interrupt register offsets
+ * Bank : 0x0E
+ */
+#define AB5500_IT_SOURCE0_REG           0x20
+#define AB5500_IT_SOURCE1_REG           0x21
+#define AB5500_IT_SOURCE2_REG           0x22
+#define AB5500_IT_SOURCE3_REG           0x23
+#define AB5500_IT_SOURCE4_REG           0x24
+#define AB5500_IT_SOURCE5_REG           0x25
+#define AB5500_IT_SOURCE6_REG           0x26
+#define AB5500_IT_SOURCE7_REG           0x27
+#define AB5500_IT_SOURCE8_REG           0x28
+#define AB5500_IT_SOURCE9_REG           0x29
+#define AB5500_IT_SOURCE10_REG          0x2A
+#define AB5500_IT_SOURCE11_REG          0x2B
+#define AB5500_IT_SOURCE12_REG          0x2C
+#define AB5500_IT_SOURCE13_REG          0x2D
+#define AB5500_IT_SOURCE14_REG          0x2E
+#define AB5500_IT_SOURCE15_REG          0x2F
+#define AB5500_IT_SOURCE16_REG          0x30
+#define AB5500_IT_SOURCE17_REG          0x31
+#define AB5500_IT_SOURCE18_REG          0x32
+#define AB5500_IT_SOURCE19_REG          0x33
+#define AB5500_IT_SOURCE20_REG          0x34
+#define AB5500_IT_SOURCE21_REG          0x35
+#define AB5500_IT_SOURCE22_REG          0x36
+#define AB5500_IT_SOURCE23_REG          0x37
+#define AB5500_NUM_IRQ_REGS             23
+/**
+ * struct ab5500
+ * @access_mutex: lock out concurrent accesses to the AB registers
+ * @dev: a pointer to the device struct for this chip driver
+ * @ab5500_irq: the analog baseband irq
+ * @irq_base: the platform configuration irq base for subdevices
+ * @chip_name: name of this chip variant
+ * @chip_id: 8 bit chip ID for this chip variant
+ * @irq_lock: a lock to protect the mask
+ * @abb_events: a local bit mask of the prcmu wakeup events
+ * @event_mask: a local copy of the mask event registers
+ * @last_event_mask: a copy of the last event_mask written to hardware
+ * @startup_events: a copy of the first reading of the event registers
+ * @startup_events_read: whether the first events have been read
+ */
+struct ab5500 {
+        struct mutex access_mutex;
+        struct device *dev;
+        unsigned int ab5500_irq;
+        unsigned int irq_base;
+        char chip_name[32];
+        u8 chip_id;
+        struct mutex irq_lock;
+        u32 abb_events;
+        u8 mask[AB5500_NUM_IRQ_REGS];
+        u8 oldmask[AB5500_NUM_IRQ_REGS];
+        u8 startup_events[AB5500_NUM_IRQ_REGS];
+        bool startup_events_read;
+#ifdef CONFIG_DEBUG_FS
+        unsigned int debug_bank;
+        unsigned int debug_address;
+#endif
+};
+struct ab5500_platform_data {
+        struct {unsigned int base; unsigned int count; } irq;
+        void *dev_data[AB5500_NUM_DEVICES];
+        struct abx500_init_settings *init_settings;
+        unsigned int init_settings_sz;
+        bool pm_power_off;
+};
+#endif /* MFD_AB5500_H */
diff --git a/include/linux/mfd/ab8500/gpadc.h b/include/linux/mfd/ab8500/gpadc.h
index 46b954011f16..252966769d93 100644
--- a/include/linux/mfd/ab8500/gpadc.h
+++ b/include/linux/mfd/ab8500/gpadc.h
@@ -27,6 +27,9 @@
 struct ab8500_gpadc;
 struct ab8500_gpadc *ab8500_gpadc_get(char *name);
-int ab8500_gpadc_convert(struct ab8500_gpadc *gpadc, u8 input);
+int ab8500_gpadc_convert(struct ab8500_gpadc *gpadc, u8 channel);
+int ab8500_gpadc_read_raw(struct ab8500_gpadc *gpadc, u8 channel);
+int ab8500_gpadc_ad_to_voltage(struct ab8500_gpadc *gpadc,
+    u8 channel, int ad_value);
 #endif /* _AB8500_GPADC_H */
diff --git a/include/linux/mfd/abx500.h b/include/linux/mfd/abx500.h
index 896b5e47f16e..9970337ff041 100644
--- a/include/linux/mfd/abx500.h
+++ b/include/linux/mfd/abx500.h
@@ -6,7 +6,7 @@
 *
 * ABX500 core access functions.
 * The abx500 interface is used for the Analog Baseband chip
- * ab3100, ab3550, ab5500, and ab8500.
+ * ab3100, ab5500, and ab8500.
 *
 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
 * Author: Mattias Nilsson <mattias.i.nilsson@stericsson.com>
@@ -29,17 +29,16 @@
 #define AB3100_P1G      0xc6
 #define AB3100_R2A      0xc7
 #define AB3100_R2B      0xc8
-#define AB3550_P1A      0x10
 #define AB5500_1_0      0x20
-#define AB5500_2_0      0x21
+#define AB5500_1_1      0x21
-#define AB5500_2_1      0x22
+#define AB5500_2_0      0x24
 /* AB8500 CIDs*/
-#define AB8500_CUTEARLY 0x00
 #define AB8500_CUT1P0   0x10
 #define AB8500_CUT1P1   0x11
 #define AB8500_CUT2P0   0x20
 #define AB8500_CUT3P0   0x30
+#define AB8500_CUT3P3   0x33
 /*
 * AB3100, EVENTA1, A2 and A3 event register flags
@@ -143,39 +142,6 @@ int ab3100_event_register(struct ab3100 *ab3100,
 int ab3100_event_unregister(struct ab3100 *ab3100,
                            struct notifier_block *nb);
-/* AB3550, STR register flags */
-#define AB3550_STR_ONSWA                                (0x01)
-#define AB3550_STR_ONSWB                                (0x02)
-#define AB3550_STR_ONSWC                                (0x04)
-#define AB3550_STR_DCIO                                 (0x08)
-#define AB3550_STR_BOOT_MODE                            (0x10)
-#define AB3550_STR_SIM_OFF                              (0x20)
-#define AB3550_STR_BATT_REMOVAL                         (0x40)
-#define AB3550_STR_VBUS                                 (0x80)
-/* Interrupt mask registers */
-#define AB3550_IMR1 0x29
-#define AB3550_IMR2 0x2a
-#define AB3550_IMR3 0x2b
-#define AB3550_IMR4 0x2c
-#define AB3550_IMR5 0x2d
-enum ab3550_devid {
-        AB3550_DEVID_ADC,
-        AB3550_DEVID_DAC,
-        AB3550_DEVID_LEDS,
-        AB3550_DEVID_POWER,
-        AB3550_DEVID_REGULATORS,
-        AB3550_DEVID_SIM,
-        AB3550_DEVID_UART,
-        AB3550_DEVID_RTC,
-        AB3550_DEVID_CHARGER,
-        AB3550_DEVID_FUELGAUGE,
-        AB3550_DEVID_VIBRATOR,
-        AB3550_DEVID_CODEC,
-        AB3550_NUM_DEVICES,
-};
 /**
 * struct abx500_init_setting
 * Initial value of the registers for driver to use during setup.
@@ -186,18 +152,6 @@ struct abx500_init_settings {
        u8 setting;
 };
-/**
- * struct ab3550_platform_data
- * Data supplied to initialize board connections to the AB3550
- */
-struct ab3550_platform_data {
-        struct {unsigned int base; unsigned int count; } irq;
-        void *dev_data[AB3550_NUM_DEVICES];
-        size_t dev_data_sz[AB3550_NUM_DEVICES];
-        struct abx500_init_settings *init_settings;
-        unsigned int init_settings_sz;
-};
 int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
        u8 value);
 int abx500_get_register_interruptible(struct device *dev, u8 bank, u8 reg,
diff --git a/include/linux/mfd/db5500-prcmu.h b/include/linux/mfd/db5500-prcmu.h
index f0977986402c..9890687f582d 100644
--- a/include/linux/mfd/db5500-prcmu.h
+++ b/include/linux/mfd/db5500-prcmu.h
@@ -5,21 +5,35 @@
 *
 * U5500 PRCMU API.
 */
-#ifndef __MACH_PRCMU_U5500_H
+#ifndef __MFD_DB5500_PRCMU_H
-#define __MACH_PRCMU_U5500_H
+#define __MFD_DB5500_PRCMU_H
-#ifdef CONFIG_UX500_SOC_DB5500
+#ifdef CONFIG_MFD_DB5500_PRCMU
 void db5500_prcmu_early_init(void);
+int db5500_prcmu_set_epod(u16 epod_id, u8 epod_state);
+int db5500_prcmu_set_display_clocks(void);
+int db5500_prcmu_disable_dsipll(void);
+int db5500_prcmu_enable_dsipll(void);
 int db5500_prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
 int db5500_prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
+void db5500_prcmu_enable_wakeups(u32 wakeups);
+int db5500_prcmu_request_clock(u8 clock, bool enable);
+void db5500_prcmu_config_abb_event_readout(u32 abb_events);
+void db5500_prcmu_get_abb_event_buffer(void __iomem **buf);
+int prcmu_resetout(u8 resoutn, u8 state);
+int db5500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll);
+int db5500_prcmu_config_esram0_deep_sleep(u8 state);
+void db5500_prcmu_system_reset(u16 reset_code);
+u16 db5500_prcmu_get_reset_code(void);
+bool db5500_prcmu_is_ac_wake_requested(void);
+int db5500_prcmu_set_arm_opp(u8 opp);
+int db5500_prcmu_get_arm_opp(void);
 #else /* !CONFIG_UX500_SOC_DB5500 */
-static inline void db5500_prcmu_early_init(void)
+static inline void db5500_prcmu_early_init(void) {}
-{
-}
 static inline int db5500_prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
 {
@@ -31,15 +45,75 @@ static inline int db5500_prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
        return -ENOSYS;
 }
-#endif /* CONFIG_UX500_SOC_DB5500 */
+static inline int db5500_prcmu_request_clock(u8 clock, bool enable)
+{
+        return 0;
+}
+static inline int db5500_prcmu_set_display_clocks(void)
+{
+        return 0;
+}
+static inline int db5500_prcmu_disable_dsipll(void)
+{
+        return 0;
+}
+static inline int db5500_prcmu_enable_dsipll(void)
+{
+        return 0;
+}
-static inline int db5500_prcmu_config_abb_event_readout(u32 abb_events)
+static inline int db5500_prcmu_config_esram0_deep_sleep(u8 state)
 {
-#ifdef CONFIG_MACH_U5500_SIMULATOR
        return 0;
-#else
-        return -1;
-#endif
 }
-#endif /* __MACH_PRCMU_U5500_H */
+static inline void db5500_prcmu_enable_wakeups(u32 wakeups) {}
+static inline int prcmu_resetout(u8 resoutn, u8 state)
+{
+        return 0;
+}
+static inline int db5500_prcmu_set_epod(u16 epod_id, u8 epod_state)
+{
+        return 0;
+}
+static inline void db5500_prcmu_get_abb_event_buffer(void __iomem **buf) {}
+static inline void db5500_prcmu_config_abb_event_readout(u32 abb_events) {}
+static inline int db5500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll)
+{
+        return 0;
+}
+static inline void db5500_prcmu_system_reset(u16 reset_code) {}
+static inline u16 db5500_prcmu_get_reset_code(void)
+{
+        return 0;
+}
+static inline bool db5500_prcmu_is_ac_wake_requested(void)
+{
+        return 0;
+}
+static inline int db5500_prcmu_set_arm_opp(u8 opp)
+{
+        return 0;
+}
+static inline int db5500_prcmu_get_arm_opp(void)
+{
+        return 0;
+}
+#endif /* CONFIG_MFD_DB5500_PRCMU */
+#endif /* __MFD_DB5500_PRCMU_H */
diff --git a/include/linux/mfd/db8500-prcmu.h b/include/linux/mfd/db8500-prcmu.h
index 917dbcab701c..60d27f7bfc1f 100644
--- a/include/linux/mfd/db8500-prcmu.h
+++ b/include/linux/mfd/db8500-prcmu.h
@@ -11,7 +11,6 @@
 #define __MFD_DB8500_PRCMU_H
 #include <linux/interrupt.h>
-#include <linux/notifier.h>
 /* This portion previously known as <mach/prcmu-fw-defs_v1.h> */
@@ -133,7 +132,7 @@ enum ap_pwrst {
 * @APEXECUTE_TO_APIDLE: Power state transition from ApExecute to ApIdle
 */
 enum ap_pwrst_trans {
-        NO_TRANSITION                   = 0x00,
+        PRCMU_AP_NO_CHANGE              = 0x00,
        APEXECUTE_TO_APSLEEP            = 0x01,
        APIDLE_TO_APSLEEP               = 0x02, /* To be removed */
        PRCMU_AP_SLEEP                  = 0x01,
@@ -146,54 +145,6 @@ enum ap_pwrst_trans {
 };
 /**
- * enum ddr_pwrst - DDR power states definition
- * @DDR_PWR_STATE_UNCHANGED: SDRAM and DDR controller state is unchanged
- * @DDR_PWR_STATE_ON:
- * @DDR_PWR_STATE_OFFLOWLAT:
- * @DDR_PWR_STATE_OFFHIGHLAT:
- */
-enum ddr_pwrst {
-        DDR_PWR_STATE_UNCHANGED     = 0x00,
-        DDR_PWR_STATE_ON            = 0x01,
-        DDR_PWR_STATE_OFFLOWLAT     = 0x02,
-        DDR_PWR_STATE_OFFHIGHLAT    = 0x03
-};
-/**
- * enum arm_opp - ARM OPP states definition
- * @ARM_OPP_INIT:
- * @ARM_NO_CHANGE: The ARM operating point is unchanged
- * @ARM_100_OPP: The new ARM operating point is arm100opp
- * @ARM_50_OPP: The new ARM operating point is arm50opp
- * @ARM_MAX_OPP: Operating point is "max" (more than 100)
- * @ARM_MAX_FREQ100OPP: Set max opp if available, else 100
- * @ARM_EXTCLK: The new ARM operating point is armExtClk
- */
-enum arm_opp {
-        ARM_OPP_INIT = 0x00,
-        ARM_NO_CHANGE = 0x01,
-        ARM_100_OPP = 0x02,
-        ARM_50_OPP = 0x03,
-        ARM_MAX_OPP = 0x04,
-        ARM_MAX_FREQ100OPP = 0x05,
-        ARM_EXTCLK = 0x07
-};
-/**
- * enum ape_opp - APE OPP states definition
- * @APE_OPP_INIT:
- * @APE_NO_CHANGE: The APE operating point is unchanged
- * @APE_100_OPP: The new APE operating point is ape100opp
- * @APE_50_OPP: 50%
- */
-enum ape_opp {
-        APE_OPP_INIT = 0x00,
-        APE_NO_CHANGE = 0x01,
-        APE_100_OPP = 0x02,
-        APE_50_OPP = 0x03
-};
-/**
 * enum hw_acc_state - State definition for hardware accelerator
 * @HW_NO_CHANGE: The hardware accelerator state must remain unchanged
 * @HW_OFF: The hardware accelerator must be switched off
@@ -469,26 +420,6 @@ enum auto_enable {
 /* End of file previously known as prcmu-fw-defs_v1.h */
-/* PRCMU Wakeup defines */
-enum prcmu_wakeup_index {
-        PRCMU_WAKEUP_INDEX_RTC,
-        PRCMU_WAKEUP_INDEX_RTT0,
-        PRCMU_WAKEUP_INDEX_RTT1,
-        PRCMU_WAKEUP_INDEX_HSI0,
-        PRCMU_WAKEUP_INDEX_HSI1,
-        PRCMU_WAKEUP_INDEX_USB,
-        PRCMU_WAKEUP_INDEX_ABB,
-        PRCMU_WAKEUP_INDEX_ABB_FIFO,
-        PRCMU_WAKEUP_INDEX_ARM,
-        NUM_PRCMU_WAKEUP_INDICES
-};
-#define PRCMU_WAKEUP(_name) (BIT(PRCMU_WAKEUP_INDEX_##_name))
-/* PRCMU QoS APE OPP class */
-#define PRCMU_QOS_APE_OPP 1
-#define PRCMU_QOS_DDR_OPP 2
-#define PRCMU_QOS_DEFAULT_VALUE -1
 /**
 * enum hw_acc_dev - enum for hw accelerators
 * @HW_ACC_SVAMMDSP: for SVAMMDSP
@@ -527,64 +458,6 @@ enum hw_acc_dev {
 };
 /*
- * Ids for all EPODs (power domains)
- * - EPOD_ID_SVAMMDSP: power domain for SVA MMDSP
- * - EPOD_ID_SVAPIPE: power domain for SVA pipe
- * - EPOD_ID_SIAMMDSP: power domain for SIA MMDSP
- * - EPOD_ID_SIAPIPE: power domain for SIA pipe
- * - EPOD_ID_SGA: power domain for SGA
- * - EPOD_ID_B2R2_MCDE: power domain for B2R2 and MCDE
- * - EPOD_ID_ESRAM12: power domain for ESRAM 1 and 2
- * - EPOD_ID_ESRAM34: power domain for ESRAM 3 and 4
- * - NUM_EPOD_ID: number of power domains
- */
-#define EPOD_ID_SVAMMDSP        0
-#define EPOD_ID_SVAPIPE         1
-#define EPOD_ID_SIAMMDSP        2
-#define EPOD_ID_SIAPIPE         3
-#define EPOD_ID_SGA             4
-#define EPOD_ID_B2R2_MCDE       5
-#define EPOD_ID_ESRAM12         6
-#define EPOD_ID_ESRAM34         7
-#define NUM_EPOD_ID             8
-/*
- * state definition for EPOD (power domain)
- * - EPOD_STATE_NO_CHANGE: The EPOD should remain unchanged
- * - EPOD_STATE_OFF: The EPOD is switched off
- * - EPOD_STATE_RAMRET: The EPOD is switched off with its internal RAM in
- *                         retention
- * - EPOD_STATE_ON_CLK_OFF: The EPOD is switched on, clock is still off
- * - EPOD_STATE_ON: Same as above, but with clock enabled
- */
-#define EPOD_STATE_NO_CHANGE    0x00
-#define EPOD_STATE_OFF          0x01
-#define EPOD_STATE_RAMRET       0x02
-#define EPOD_STATE_ON_CLK_OFF   0x03
-#define EPOD_STATE_ON           0x04
-/*
- * CLKOUT sources
- */
-#define PRCMU_CLKSRC_CLK38M             0x00
-#define PRCMU_CLKSRC_ACLK               0x01
-#define PRCMU_CLKSRC_SYSCLK             0x02
-#define PRCMU_CLKSRC_LCDCLK             0x03
-#define PRCMU_CLKSRC_SDMMCCLK           0x04
-#define PRCMU_CLKSRC_TVCLK              0x05
-#define PRCMU_CLKSRC_TIMCLK             0x06
-#define PRCMU_CLKSRC_CLK009             0x07
-/* These are only valid for CLKOUT1: */
-#define PRCMU_CLKSRC_SIAMMDSPCLK        0x40
-#define PRCMU_CLKSRC_I2CCLK             0x41
-#define PRCMU_CLKSRC_MSP02CLK           0x42
-#define PRCMU_CLKSRC_ARMPLL_OBSCLK      0x43
-#define PRCMU_CLKSRC_HSIRXCLK           0x44
-#define PRCMU_CLKSRC_HSITXCLK           0x45
-#define PRCMU_CLKSRC_ARMCLKFIX          0x46
-#define PRCMU_CLKSRC_HDMICLK            0x47
-/*
 * Definitions for autonomous power management configuration.
 */
@@ -620,88 +493,12 @@ struct prcmu_auto_pm_config {
        u8 sva_policy;
 };
-/**
- * enum ddr_opp - DDR OPP states definition
- * @DDR_100_OPP: The new DDR operating point is ddr100opp
- * @DDR_50_OPP: The new DDR operating point is ddr50opp
- * @DDR_25_OPP: The new DDR operating point is ddr25opp
- */
-enum ddr_opp {
-        DDR_100_OPP = 0x00,
-        DDR_50_OPP = 0x01,
-        DDR_25_OPP = 0x02,
-};
-/*
- * Clock identifiers.
- */
-enum prcmu_clock {
-        PRCMU_SGACLK,
-        PRCMU_UARTCLK,
-        PRCMU_MSP02CLK,
-        PRCMU_MSP1CLK,
-        PRCMU_I2CCLK,
-        PRCMU_SDMMCCLK,
-        PRCMU_SLIMCLK,
-        PRCMU_PER1CLK,
-        PRCMU_PER2CLK,
-        PRCMU_PER3CLK,
-        PRCMU_PER5CLK,
-        PRCMU_PER6CLK,
-        PRCMU_PER7CLK,
-        PRCMU_LCDCLK,
-        PRCMU_BMLCLK,
-        PRCMU_HSITXCLK,
-        PRCMU_HSIRXCLK,
-        PRCMU_HDMICLK,
-        PRCMU_APEATCLK,
-        PRCMU_APETRACECLK,
-        PRCMU_MCDECLK,
-        PRCMU_IPI2CCLK,
-        PRCMU_DSIALTCLK,
-        PRCMU_DMACLK,
-        PRCMU_B2R2CLK,
-        PRCMU_TVCLK,
-        PRCMU_SSPCLK,
-        PRCMU_RNGCLK,
-        PRCMU_UICCCLK,
-        PRCMU_NUM_REG_CLOCKS,
-        PRCMU_SYSCLK = PRCMU_NUM_REG_CLOCKS,
-        PRCMU_TIMCLK,
-};
-/*
- * Definitions for controlling ESRAM0 in deep sleep.
- */
-#define ESRAM0_DEEP_SLEEP_STATE_OFF 1
-#define ESRAM0_DEEP_SLEEP_STATE_RET 2
-#ifdef CONFIG_MFD_DB8500_PRCMU
-void __init prcmu_early_init(void);
-int prcmu_set_display_clocks(void);
-int prcmu_disable_dsipll(void);
-int prcmu_enable_dsipll(void);
-#else
-static inline void __init prcmu_early_init(void) {}
-#endif
 #ifdef CONFIG_MFD_DB8500_PRCMU
+void db8500_prcmu_early_init(void);
 int prcmu_set_rc_a2p(enum romcode_write);
 enum romcode_read prcmu_get_rc_p2a(void);
 enum ap_pwrst prcmu_get_xp70_current_state(void);
-int prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
-void prcmu_enable_wakeups(u32 wakeups);
-static inline void prcmu_disable_wakeups(void)
-{
-        prcmu_enable_wakeups(0);
-}
-void prcmu_config_abb_event_readout(u32 abb_events);
-void prcmu_get_abb_event_buffer(void __iomem **buf);
-int prcmu_set_arm_opp(u8 opp);
-int prcmu_get_arm_opp(void);
 bool prcmu_has_arm_maxopp(void);
 bool prcmu_is_u8400(void);
 int prcmu_set_ape_opp(u8 opp);
@@ -710,19 +507,14 @@ int prcmu_request_ape_opp_100_voltage(bool enable);
 int prcmu_release_usb_wakeup_state(void);
 int prcmu_set_ddr_opp(u8 opp);
 int prcmu_get_ddr_opp(void);
-unsigned long prcmu_qos_get_cpufreq_opp_delay(void);
-void prcmu_qos_set_cpufreq_opp_delay(unsigned long);
 /* NOTE! Use regulator framework instead */
 int prcmu_set_hwacc(u16 hw_acc_dev, u8 state);
-int prcmu_set_epod(u16 epod_id, u8 epod_state);
 void prcmu_configure_auto_pm(struct prcmu_auto_pm_config *sleep,
        struct prcmu_auto_pm_config *idle);
 bool prcmu_is_auto_pm_enabled(void);
 int prcmu_config_clkout(u8 clkout, u8 source, u8 div);
-int prcmu_request_clock(u8 clock, bool enable);
 int prcmu_set_clock_divider(u8 clock, u8 divider);
-int prcmu_config_esram0_deep_sleep(u8 state);
 int prcmu_config_hotdog(u8 threshold);
 int prcmu_config_hotmon(u8 low, u8 high);
 int prcmu_start_temp_sense(u16 cycles32k);
@@ -732,14 +524,36 @@ int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
 void prcmu_ac_wake_req(void);
 void prcmu_ac_sleep_req(void);
-void prcmu_system_reset(u16 reset_code);
 void prcmu_modem_reset(void);
-bool prcmu_is_ac_wake_requested(void);
 void prcmu_enable_spi2(void);
 void prcmu_disable_spi2(void);
+int prcmu_config_a9wdog(u8 num, bool sleep_auto_off);
+int prcmu_enable_a9wdog(u8 id);
+int prcmu_disable_a9wdog(u8 id);
+int prcmu_kick_a9wdog(u8 id);
+int prcmu_load_a9wdog(u8 id, u32 val);
+void db8500_prcmu_system_reset(u16 reset_code);
+int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk, bool keep_ap_pll);
+void db8500_prcmu_enable_wakeups(u32 wakeups);
+int db8500_prcmu_set_epod(u16 epod_id, u8 epod_state);
+int db8500_prcmu_request_clock(u8 clock, bool enable);
+int db8500_prcmu_set_display_clocks(void);
+int db8500_prcmu_disable_dsipll(void);
+int db8500_prcmu_enable_dsipll(void);
+void db8500_prcmu_config_abb_event_readout(u32 abb_events);
+void db8500_prcmu_get_abb_event_buffer(void __iomem **buf);
+int db8500_prcmu_config_esram0_deep_sleep(u8 state);
+u16 db8500_prcmu_get_reset_code(void);
+bool db8500_prcmu_is_ac_wake_requested(void);
+int db8500_prcmu_set_arm_opp(u8 opp);
+int db8500_prcmu_get_arm_opp(void);
 #else /* !CONFIG_MFD_DB8500_PRCMU */
+static inline void db8500_prcmu_early_init(void) {}
 static inline int prcmu_set_rc_a2p(enum romcode_write code)
 {
        return 0;
@@ -755,34 +569,12 @@ static inline enum ap_pwrst prcmu_get_xp70_current_state(void)
        return AP_EXECUTE;
 }
-static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+static inline bool prcmu_has_arm_maxopp(void)
-        bool keep_ap_pll)
-{
-        return 0;
-}
-static inline void prcmu_enable_wakeups(u32 wakeups) {}
-static inline void prcmu_disable_wakeups(void) {}
-static inline void prcmu_config_abb_event_readout(u32 abb_events) {}
-static inline int prcmu_set_arm_opp(u8 opp)
-{
-        return 0;
-}
-static inline int prcmu_get_arm_opp(void)
-{
-        return ARM_100_OPP;
-}
-static bool prcmu_has_arm_maxopp(void)
 {
        return false;
 }
-static bool prcmu_is_u8400(void)
+static inline bool prcmu_is_u8400(void)
 {
        return false;
 }
@@ -817,13 +609,6 @@ static inline int prcmu_get_ddr_opp(void)
        return DDR_100_OPP;
 }
-static inline unsigned long prcmu_qos_get_cpufreq_opp_delay(void)
-{
-        return 0;
-}
-static inline void prcmu_qos_set_cpufreq_opp_delay(unsigned long n) {}
 static inline int prcmu_set_hwacc(u16 hw_acc_dev, u8 state)
 {
        return 0;
@@ -844,21 +629,11 @@ static inline int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
        return 0;
 }
-static inline int prcmu_request_clock(u8 clock, bool enable)
-{
-        return 0;
-}
 static inline int prcmu_set_clock_divider(u8 clock, u8 divider)
 {
        return 0;
 }
-int prcmu_config_esram0_deep_sleep(u8 state)
-{
-        return 0;
-}
 static inline int prcmu_config_hotdog(u8 threshold)
 {
        return 0;
@@ -893,86 +668,107 @@ static inline void prcmu_ac_wake_req(void) {}
 static inline void prcmu_ac_sleep_req(void) {}
-static inline void prcmu_system_reset(u16 reset_code) {}
 static inline void prcmu_modem_reset(void) {}
-static inline bool prcmu_is_ac_wake_requested(void)
+static inline int prcmu_enable_spi2(void)
 {
-        return false;
+        return 0;
 }
-#ifndef CONFIG_UX500_SOC_DB5500
+static inline int prcmu_disable_spi2(void)
-static inline int prcmu_set_display_clocks(void)
 {
        return 0;
 }
-static inline int prcmu_disable_dsipll(void)
+static inline void db8500_prcmu_system_reset(u16 reset_code) {}
+static inline int db8500_prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll)
 {
        return 0;
 }
-static inline int prcmu_enable_dsipll(void)
+static inline void db8500_prcmu_enable_wakeups(u32 wakeups) {}
+static inline int db8500_prcmu_set_epod(u16 epod_id, u8 epod_state)
 {
        return 0;
 }
-#endif
-static inline int prcmu_enable_spi2(void)
+static inline int db8500_prcmu_request_clock(u8 clock, bool enable)
 {
        return 0;
 }
-static inline int prcmu_disable_spi2(void)
+static inline int db8500_prcmu_set_display_clocks(void)
 {
        return 0;
 }
-#endif /* !CONFIG_MFD_DB8500_PRCMU */
+static inline int db8500_prcmu_disable_dsipll(void)
+{
+        return 0;
+}
+static inline int db8500_prcmu_enable_dsipll(void)
+{
+        return 0;
+}
+static inline int db8500_prcmu_config_esram0_deep_sleep(u8 state)
+{
+        return 0;
+}
+static inline void db8500_prcmu_config_abb_event_readout(u32 abb_events) {}
-#ifdef CONFIG_UX500_PRCMU_QOS_POWER
+static inline void db8500_prcmu_get_abb_event_buffer(void __iomem **buf) {}
-int prcmu_qos_requirement(int pm_qos_class);
-int prcmu_qos_add_requirement(int pm_qos_class, char *name, s32 value);
+static inline u16 db8500_prcmu_get_reset_code(void)
-int prcmu_qos_update_requirement(int pm_qos_class, char *name, s32 new_value);
-void prcmu_qos_remove_requirement(int pm_qos_class, char *name);
-int prcmu_qos_add_notifier(int prcmu_qos_class,
-                           struct notifier_block *notifier);
-int prcmu_qos_remove_notifier(int prcmu_qos_class,
-                              struct notifier_block *notifier);
-#else
-static inline int prcmu_qos_requirement(int prcmu_qos_class)
 {
        return 0;
 }
-static inline int prcmu_qos_add_requirement(int prcmu_qos_class,
+static inline int prcmu_config_a9wdog(u8 num, bool sleep_auto_off)
-                                            char *name, s32 value)
 {
        return 0;
 }
-static inline int prcmu_qos_update_requirement(int prcmu_qos_class,
+static inline int prcmu_enable_a9wdog(u8 id)
-                                               char *name, s32 new_value)
 {
        return 0;
 }
-static inline void prcmu_qos_remove_requirement(int prcmu_qos_class, char *name)
+static inline int prcmu_disable_a9wdog(u8 id)
 {
+        return 0;
 }
-static inline int prcmu_qos_add_notifier(int prcmu_qos_class,
+static inline int prcmu_kick_a9wdog(u8 id)
-                                         struct notifier_block *notifier)
 {
        return 0;
 }
-static inline int prcmu_qos_remove_notifier(int prcmu_qos_class,
-                                            struct notifier_block *notifier)
+static inline int prcmu_load_a9wdog(u8 id, u32 val)
 {
        return 0;
 }
-#endif
+static inline bool db8500_prcmu_is_ac_wake_requested(void)
+{
+        return 0;
+}
+static inline int db8500_prcmu_set_arm_opp(u8 opp)
+{
+        return 0;
+}
+static inline int db8500_prcmu_get_arm_opp(void)
+{
+        return 0;
+}
+#endif /* !CONFIG_MFD_DB8500_PRCMU */
 #endif /* __MFD_DB8500_PRCMU_H */
diff --git a/include/linux/mfd/dbx500-prcmu.h b/include/linux/mfd/dbx500-prcmu.h
new file mode 100644
index 000000000000..bac942f959c1
--- /dev/null
+++ b/include/linux/mfd/dbx500-prcmu.h
@@ -0,0 +1,549 @@
+/*
+ * Copyright (C) ST Ericsson SA 2011
+ *
+ * License Terms: GNU General Public License v2
+ *
+ * STE Ux500 PRCMU API
+ */
+#ifndef __MACH_PRCMU_H
+#define __MACH_PRCMU_H
+#include <linux/interrupt.h>
+#include <linux/notifier.h>
+#include <asm/mach-types.h>
+/* PRCMU Wakeup defines */
+enum prcmu_wakeup_index {
+        PRCMU_WAKEUP_INDEX_RTC,
+        PRCMU_WAKEUP_INDEX_RTT0,
+        PRCMU_WAKEUP_INDEX_RTT1,
+        PRCMU_WAKEUP_INDEX_HSI0,
+        PRCMU_WAKEUP_INDEX_HSI1,
+        PRCMU_WAKEUP_INDEX_USB,
+        PRCMU_WAKEUP_INDEX_ABB,
+        PRCMU_WAKEUP_INDEX_ABB_FIFO,
+        PRCMU_WAKEUP_INDEX_ARM,
+        PRCMU_WAKEUP_INDEX_CD_IRQ,
+        NUM_PRCMU_WAKEUP_INDICES
+};
+#define PRCMU_WAKEUP(_name) (BIT(PRCMU_WAKEUP_INDEX_##_name))
+/* EPOD (power domain) IDs */
+/*
+ * DB8500 EPODs
+ * - EPOD_ID_SVAMMDSP: power domain for SVA MMDSP
+ * - EPOD_ID_SVAPIPE: power domain for SVA pipe
+ * - EPOD_ID_SIAMMDSP: power domain for SIA MMDSP
+ * - EPOD_ID_SIAPIPE: power domain for SIA pipe
+ * - EPOD_ID_SGA: power domain for SGA
+ * - EPOD_ID_B2R2_MCDE: power domain for B2R2 and MCDE
+ * - EPOD_ID_ESRAM12: power domain for ESRAM 1 and 2
+ * - EPOD_ID_ESRAM34: power domain for ESRAM 3 and 4
+ * - NUM_EPOD_ID: number of power domains
+ *
+ * TODO: These should be prefixed.
+ */
+#define EPOD_ID_SVAMMDSP        0
+#define EPOD_ID_SVAPIPE         1
+#define EPOD_ID_SIAMMDSP        2
+#define EPOD_ID_SIAPIPE         3
+#define EPOD_ID_SGA             4
+#define EPOD_ID_B2R2_MCDE       5
+#define EPOD_ID_ESRAM12         6
+#define EPOD_ID_ESRAM34         7
+#define NUM_EPOD_ID             8
+/*
+ * DB5500 EPODs
+ */
+#define DB5500_EPOD_ID_BASE 0x0100
+#define DB5500_EPOD_ID_SGA (DB5500_EPOD_ID_BASE + 0)
+#define DB5500_EPOD_ID_HVA (DB5500_EPOD_ID_BASE + 1)
+#define DB5500_EPOD_ID_SIA (DB5500_EPOD_ID_BASE + 2)
+#define DB5500_EPOD_ID_DISP (DB5500_EPOD_ID_BASE + 3)
+#define DB5500_EPOD_ID_ESRAM12 (DB5500_EPOD_ID_BASE + 6)
+#define DB5500_NUM_EPOD_ID 7
+/*
+ * state definition for EPOD (power domain)
+ * - EPOD_STATE_NO_CHANGE: The EPOD should remain unchanged
+ * - EPOD_STATE_OFF: The EPOD is switched off
+ * - EPOD_STATE_RAMRET: The EPOD is switched off with its internal RAM in
+ *                         retention
+ * - EPOD_STATE_ON_CLK_OFF: The EPOD is switched on, clock is still off
+ * - EPOD_STATE_ON: Same as above, but with clock enabled
+ */
+#define EPOD_STATE_NO_CHANGE    0x00
+#define EPOD_STATE_OFF          0x01
+#define EPOD_STATE_RAMRET       0x02
+#define EPOD_STATE_ON_CLK_OFF   0x03
+#define EPOD_STATE_ON           0x04
+/*
+ * CLKOUT sources
+ */
+#define PRCMU_CLKSRC_CLK38M             0x00
+#define PRCMU_CLKSRC_ACLK               0x01
+#define PRCMU_CLKSRC_SYSCLK             0x02
+#define PRCMU_CLKSRC_LCDCLK             0x03
+#define PRCMU_CLKSRC_SDMMCCLK           0x04
+#define PRCMU_CLKSRC_TVCLK              0x05
+#define PRCMU_CLKSRC_TIMCLK             0x06
+#define PRCMU_CLKSRC_CLK009             0x07
+/* These are only valid for CLKOUT1: */
+#define PRCMU_CLKSRC_SIAMMDSPCLK        0x40
+#define PRCMU_CLKSRC_I2CCLK             0x41
+#define PRCMU_CLKSRC_MSP02CLK           0x42
+#define PRCMU_CLKSRC_ARMPLL_OBSCLK      0x43
+#define PRCMU_CLKSRC_HSIRXCLK           0x44
+#define PRCMU_CLKSRC_HSITXCLK           0x45
+#define PRCMU_CLKSRC_ARMCLKFIX          0x46
+#define PRCMU_CLKSRC_HDMICLK            0x47
+/*
+ * Clock identifiers.
+ */
+enum prcmu_clock {
+        PRCMU_SGACLK,
+        PRCMU_UARTCLK,
+        PRCMU_MSP02CLK,
+        PRCMU_MSP1CLK,
+        PRCMU_I2CCLK,
+        PRCMU_SDMMCCLK,
+        PRCMU_SLIMCLK,
+        PRCMU_PER1CLK,
+        PRCMU_PER2CLK,
+        PRCMU_PER3CLK,
+        PRCMU_PER5CLK,
+        PRCMU_PER6CLK,
+        PRCMU_PER7CLK,
+        PRCMU_LCDCLK,
+        PRCMU_BMLCLK,
+        PRCMU_HSITXCLK,
+        PRCMU_HSIRXCLK,
+        PRCMU_HDMICLK,
+        PRCMU_APEATCLK,
+        PRCMU_APETRACECLK,
+        PRCMU_MCDECLK,
+        PRCMU_IPI2CCLK,
+        PRCMU_DSIALTCLK,
+        PRCMU_DMACLK,
+        PRCMU_B2R2CLK,
+        PRCMU_TVCLK,
+        PRCMU_SSPCLK,
+        PRCMU_RNGCLK,
+        PRCMU_UICCCLK,
+        PRCMU_PWMCLK,
+        PRCMU_IRDACLK,
+        PRCMU_IRRCCLK,
+        PRCMU_SIACLK,
+        PRCMU_SVACLK,
+        PRCMU_NUM_REG_CLOCKS,
+        PRCMU_SYSCLK = PRCMU_NUM_REG_CLOCKS,
+        PRCMU_TIMCLK,
+        PRCMU_PLLSOC0,
+        PRCMU_PLLSOC1,
+        PRCMU_PLLDDR,
+};
+/**
+ * enum ape_opp - APE OPP states definition
+ * @APE_OPP_INIT:
+ * @APE_NO_CHANGE: The APE operating point is unchanged
+ * @APE_100_OPP: The new APE operating point is ape100opp
+ * @APE_50_OPP: 50%
+ */
+enum ape_opp {
+        APE_OPP_INIT = 0x00,
+        APE_NO_CHANGE = 0x01,
+        APE_100_OPP = 0x02,
+        APE_50_OPP = 0x03
+};
+/**
+ * enum arm_opp - ARM OPP states definition
+ * @ARM_OPP_INIT:
+ * @ARM_NO_CHANGE: The ARM operating point is unchanged
+ * @ARM_100_OPP: The new ARM operating point is arm100opp
+ * @ARM_50_OPP: The new ARM operating point is arm50opp
+ * @ARM_MAX_OPP: Operating point is "max" (more than 100)
+ * @ARM_MAX_FREQ100OPP: Set max opp if available, else 100
+ * @ARM_EXTCLK: The new ARM operating point is armExtClk
+ */
+enum arm_opp {
+        ARM_OPP_INIT = 0x00,
+        ARM_NO_CHANGE = 0x01,
+        ARM_100_OPP = 0x02,
+        ARM_50_OPP = 0x03,
+        ARM_MAX_OPP = 0x04,
+        ARM_MAX_FREQ100OPP = 0x05,
+        ARM_EXTCLK = 0x07
+};
+/**
+ * enum ddr_opp - DDR OPP states definition
+ * @DDR_100_OPP: The new DDR operating point is ddr100opp
+ * @DDR_50_OPP: The new DDR operating point is ddr50opp
+ * @DDR_25_OPP: The new DDR operating point is ddr25opp
+ */
+enum ddr_opp {
+        DDR_100_OPP = 0x00,
+        DDR_50_OPP = 0x01,
+        DDR_25_OPP = 0x02,
+};
+/*
+ * Definitions for controlling ESRAM0 in deep sleep.
+ */
+#define ESRAM0_DEEP_SLEEP_STATE_OFF 1
+#define ESRAM0_DEEP_SLEEP_STATE_RET 2
+/**
+ * enum ddr_pwrst - DDR power states definition
+ * @DDR_PWR_STATE_UNCHANGED: SDRAM and DDR controller state is unchanged
+ * @DDR_PWR_STATE_ON:
+ * @DDR_PWR_STATE_OFFLOWLAT:
+ * @DDR_PWR_STATE_OFFHIGHLAT:
+ */
+enum ddr_pwrst {
+        DDR_PWR_STATE_UNCHANGED     = 0x00,
+        DDR_PWR_STATE_ON            = 0x01,
+        DDR_PWR_STATE_OFFLOWLAT     = 0x02,
+        DDR_PWR_STATE_OFFHIGHLAT    = 0x03
+};
+#include <linux/mfd/db8500-prcmu.h>
+#include <linux/mfd/db5500-prcmu.h>
+#if defined(CONFIG_UX500_SOC_DB8500) || defined(CONFIG_UX500_SOC_DB5500)
+static inline void __init prcmu_early_init(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_early_init();
+        else
+                return db8500_prcmu_early_init();
+}
+static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+                bool keep_ap_pll)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_set_power_state(state, keep_ulp_clk,
+                        keep_ap_pll);
+        else
+                return db8500_prcmu_set_power_state(state, keep_ulp_clk,
+                        keep_ap_pll);
+}
+static inline int prcmu_set_epod(u16 epod_id, u8 epod_state)
+{
+        if (machine_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_set_epod(epod_id, epod_state);
+}
+static inline void prcmu_enable_wakeups(u32 wakeups)
+{
+        if (machine_is_u5500())
+                db5500_prcmu_enable_wakeups(wakeups);
+        else
+                db8500_prcmu_enable_wakeups(wakeups);
+}
+static inline void prcmu_disable_wakeups(void)
+{
+        prcmu_enable_wakeups(0);
+}
+static inline void prcmu_config_abb_event_readout(u32 abb_events)
+{
+        if (machine_is_u5500())
+                db5500_prcmu_config_abb_event_readout(abb_events);
+        else
+                db8500_prcmu_config_abb_event_readout(abb_events);
+}
+static inline void prcmu_get_abb_event_buffer(void __iomem **buf)
+{
+        if (machine_is_u5500())
+                db5500_prcmu_get_abb_event_buffer(buf);
+        else
+                db8500_prcmu_get_abb_event_buffer(buf);
+}
+int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size);
+int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size);
+int prcmu_config_clkout(u8 clkout, u8 source, u8 div);
+static inline int prcmu_request_clock(u8 clock, bool enable)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_request_clock(clock, enable);
+        else
+                return db8500_prcmu_request_clock(clock, enable);
+}
+int prcmu_set_ape_opp(u8 opp);
+int prcmu_get_ape_opp(void);
+int prcmu_set_ddr_opp(u8 opp);
+int prcmu_get_ddr_opp(void);
+static inline int prcmu_set_arm_opp(u8 opp)
+{
+        if (machine_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_set_arm_opp(opp);
+}
+static inline int prcmu_get_arm_opp(void)
+{
+        if (machine_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_get_arm_opp();
+}
+static inline void prcmu_system_reset(u16 reset_code)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_system_reset(reset_code);
+        else
+                return db8500_prcmu_system_reset(reset_code);
+}
+static inline u16 prcmu_get_reset_code(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_get_reset_code();
+        else
+                return db8500_prcmu_get_reset_code();
+}
+void prcmu_ac_wake_req(void);
+void prcmu_ac_sleep_req(void);
+void prcmu_modem_reset(void);
+static inline bool prcmu_is_ac_wake_requested(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_is_ac_wake_requested();
+        else
+                return db8500_prcmu_is_ac_wake_requested();
+}
+static inline int prcmu_set_display_clocks(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_set_display_clocks();
+        else
+                return db8500_prcmu_set_display_clocks();
+}
+static inline int prcmu_disable_dsipll(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_disable_dsipll();
+        else
+                return db8500_prcmu_disable_dsipll();
+}
+static inline int prcmu_enable_dsipll(void)
+{
+        if (machine_is_u5500())
+                return db5500_prcmu_enable_dsipll();
+        else
+                return db8500_prcmu_enable_dsipll();
+}
+static inline int prcmu_config_esram0_deep_sleep(u8 state)
+{
+        if (machine_is_u5500())
+                return -EINVAL;
+        else
+                return db8500_prcmu_config_esram0_deep_sleep(state);
+}
+#else
+static inline void __init prcmu_early_init(void) {}
+static inline int prcmu_set_power_state(u8 state, bool keep_ulp_clk,
+        bool keep_ap_pll)
+{
+        return 0;
+}
+static inline int prcmu_set_epod(u16 epod_id, u8 epod_state)
+{
+        return 0;
+}
+static inline void prcmu_enable_wakeups(u32 wakeups) {}
+static inline void prcmu_disable_wakeups(void) {}
+static inline int prcmu_abb_read(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+static inline int prcmu_abb_write(u8 slave, u8 reg, u8 *value, u8 size)
+{
+        return -ENOSYS;
+}
+static inline int prcmu_config_clkout(u8 clkout, u8 source, u8 div)
+{
+        return 0;
+}
+static inline int prcmu_request_clock(u8 clock, bool enable)
+{
+        return 0;
+}
+static inline int prcmu_set_ape_opp(u8 opp)
+{
+        return 0;
+}
+static inline int prcmu_get_ape_opp(void)
+{
+        return APE_100_OPP;
+}
+static inline int prcmu_set_arm_opp(u8 opp)
+{
+        return 0;
+}
+static inline int prcmu_get_arm_opp(void)
+{
+        return ARM_100_OPP;
+}
+static inline int prcmu_set_ddr_opp(u8 opp)
+{
+        return 0;
+}
+static inline int prcmu_get_ddr_opp(void)
+{
+        return DDR_100_OPP;
+}
+static inline void prcmu_system_reset(u16 reset_code) {}
+static inline u16 prcmu_get_reset_code(void)
+{
+        return 0;
+}
+static inline void prcmu_ac_wake_req(void) {}
+static inline void prcmu_ac_sleep_req(void) {}
+static inline void prcmu_modem_reset(void) {}
+static inline bool prcmu_is_ac_wake_requested(void)
+{
+        return false;
+}
+static inline int prcmu_set_display_clocks(void)
+{
+        return 0;
+}
+static inline int prcmu_disable_dsipll(void)
+{
+        return 0;
+}
+static inline int prcmu_enable_dsipll(void)
+{
+        return 0;
+}
+static inline int prcmu_config_esram0_deep_sleep(u8 state)
+{
+        return 0;
+}
+static inline void prcmu_config_abb_event_readout(u32 abb_events) {}
+static inline void prcmu_get_abb_event_buffer(void __iomem **buf)
+{
+        *buf = NULL;
+}
+#endif
+/* PRCMU QoS APE OPP class */
+#define PRCMU_QOS_APE_OPP 1
+#define PRCMU_QOS_DDR_OPP 2
+#define PRCMU_QOS_DEFAULT_VALUE -1
+#ifdef CONFIG_UX500_PRCMU_QOS_POWER
+unsigned long prcmu_qos_get_cpufreq_opp_delay(void);
+void prcmu_qos_set_cpufreq_opp_delay(unsigned long);
+void prcmu_qos_force_opp(int, s32);
+int prcmu_qos_requirement(int pm_qos_class);
+int prcmu_qos_add_requirement(int pm_qos_class, char *name, s32 value);
+int prcmu_qos_update_requirement(int pm_qos_class, char *name, s32 new_value);
+void prcmu_qos_remove_requirement(int pm_qos_class, char *name);
+int prcmu_qos_add_notifier(int prcmu_qos_class,
+                           struct notifier_block *notifier);
+int prcmu_qos_remove_notifier(int prcmu_qos_class,
+                              struct notifier_block *notifier);
+#else
+static inline unsigned long prcmu_qos_get_cpufreq_opp_delay(void)
+{
+        return 0;
+}
+static inline void prcmu_qos_set_cpufreq_opp_delay(unsigned long n) {}
+static inline void prcmu_qos_force_opp(int prcmu_qos_class, s32 i) {}
+static inline int prcmu_qos_requirement(int prcmu_qos_class)
+{
+        return 0;
+}
+static inline int prcmu_qos_add_requirement(int prcmu_qos_class,
+                                            char *name, s32 value)
+{
+        return 0;
+}
+static inline int prcmu_qos_update_requirement(int prcmu_qos_class,
+                                               char *name, s32 new_value)
+{
+        return 0;
+}
+static inline void prcmu_qos_remove_requirement(int prcmu_qos_class, char *name)
+{
+}
+static inline int prcmu_qos_add_notifier(int prcmu_qos_class,
+                                         struct notifier_block *notifier)
+{
+        return 0;
+}
+static inline int prcmu_qos_remove_notifier(int prcmu_qos_class,
+                                            struct notifier_block *notifier)
+{
+        return 0;
+}
+#endif
+#endif /* __MACH_PRCMU_H */
diff --git a/include/linux/mfd/intel_msic.h b/include/linux/mfd/intel_msic.h
new file mode 100644
index 000000000000..439a7a617bc9
--- /dev/null
+++ b/include/linux/mfd/intel_msic.h
@@ -0,0 +1,456 @@
+/*
+ * include/linux/mfd/intel_msic.h - Core interface for Intel MSIC
+ *
+ * Copyright (C) 2011, Intel Corporation
+ * Author: Mika Westerberg <mika.westerberg@linux.intel.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.
+ */
+#ifndef __LINUX_MFD_INTEL_MSIC_H__
+#define __LINUX_MFD_INTEL_MSIC_H__
+/* ID */
+#define INTEL_MSIC_ID0                  0x000   /* RO */
+#define INTEL_MSIC_ID1                  0x001   /* RO */
+/* IRQ */
+#define INTEL_MSIC_IRQLVL1              0x002
+#define INTEL_MSIC_ADC1INT              0x003
+#define INTEL_MSIC_CCINT                0x004
+#define INTEL_MSIC_PWRSRCINT            0x005
+#define INTEL_MSIC_PWRSRCINT1           0x006
+#define INTEL_MSIC_CHRINT               0x007
+#define INTEL_MSIC_CHRINT1              0x008
+#define INTEL_MSIC_RTCIRQ               0x009
+#define INTEL_MSIC_GPIO0LVIRQ           0x00a
+#define INTEL_MSIC_GPIO1LVIRQ           0x00b
+#define INTEL_MSIC_GPIOHVIRQ            0x00c
+#define INTEL_MSIC_VRINT                0x00d
+#define INTEL_MSIC_OCAUDIO              0x00e
+#define INTEL_MSIC_ACCDET               0x00f
+#define INTEL_MSIC_RESETIRQ1            0x010
+#define INTEL_MSIC_RESETIRQ2            0x011
+#define INTEL_MSIC_MADC1INT             0x012
+#define INTEL_MSIC_MCCINT               0x013
+#define INTEL_MSIC_MPWRSRCINT           0x014
+#define INTEL_MSIC_MPWRSRCINT1          0x015
+#define INTEL_MSIC_MCHRINT              0x016
+#define INTEL_MSIC_MCHRINT1             0x017
+#define INTEL_MSIC_RTCIRQMASK           0x018
+#define INTEL_MSIC_GPIO0LVIRQMASK       0x019
+#define INTEL_MSIC_GPIO1LVIRQMASK       0x01a
+#define INTEL_MSIC_GPIOHVIRQMASK        0x01b
+#define INTEL_MSIC_VRINTMASK            0x01c
+#define INTEL_MSIC_OCAUDIOMASK          0x01d
+#define INTEL_MSIC_ACCDETMASK           0x01e
+#define INTEL_MSIC_RESETIRQ1MASK        0x01f
+#define INTEL_MSIC_RESETIRQ2MASK        0x020
+#define INTEL_MSIC_IRQLVL1MSK           0x021
+#define INTEL_MSIC_PBCONFIG             0x03e
+#define INTEL_MSIC_PBSTATUS             0x03f   /* RO */
+/* GPIO */
+#define INTEL_MSIC_GPIO0LV7CTLO         0x040
+#define INTEL_MSIC_GPIO0LV6CTLO         0x041
+#define INTEL_MSIC_GPIO0LV5CTLO         0x042
+#define INTEL_MSIC_GPIO0LV4CTLO         0x043
+#define INTEL_MSIC_GPIO0LV3CTLO         0x044
+#define INTEL_MSIC_GPIO0LV2CTLO         0x045
+#define INTEL_MSIC_GPIO0LV1CTLO         0x046
+#define INTEL_MSIC_GPIO0LV0CTLO         0x047
+#define INTEL_MSIC_GPIO1LV7CTLOS        0x048
+#define INTEL_MSIC_GPIO1LV6CTLO         0x049
+#define INTEL_MSIC_GPIO1LV5CTLO         0x04a
+#define INTEL_MSIC_GPIO1LV4CTLO         0x04b
+#define INTEL_MSIC_GPIO1LV3CTLO         0x04c
+#define INTEL_MSIC_GPIO1LV2CTLO         0x04d
+#define INTEL_MSIC_GPIO1LV1CTLO         0x04e
+#define INTEL_MSIC_GPIO1LV0CTLO         0x04f
+#define INTEL_MSIC_GPIO0LV7CTLI         0x050
+#define INTEL_MSIC_GPIO0LV6CTLI         0x051
+#define INTEL_MSIC_GPIO0LV5CTLI         0x052
+#define INTEL_MSIC_GPIO0LV4CTLI         0x053
+#define INTEL_MSIC_GPIO0LV3CTLI         0x054
+#define INTEL_MSIC_GPIO0LV2CTLI         0x055
+#define INTEL_MSIC_GPIO0LV1CTLI         0x056
+#define INTEL_MSIC_GPIO0LV0CTLI         0x057
+#define INTEL_MSIC_GPIO1LV7CTLIS        0x058
+#define INTEL_MSIC_GPIO1LV6CTLI         0x059
+#define INTEL_MSIC_GPIO1LV5CTLI         0x05a
+#define INTEL_MSIC_GPIO1LV4CTLI         0x05b
+#define INTEL_MSIC_GPIO1LV3CTLI         0x05c
+#define INTEL_MSIC_GPIO1LV2CTLI         0x05d
+#define INTEL_MSIC_GPIO1LV1CTLI         0x05e
+#define INTEL_MSIC_GPIO1LV0CTLI         0x05f
+#define INTEL_MSIC_PWM0CLKDIV1          0x061
+#define INTEL_MSIC_PWM0CLKDIV0          0x062
+#define INTEL_MSIC_PWM1CLKDIV1          0x063
+#define INTEL_MSIC_PWM1CLKDIV0          0x064
+#define INTEL_MSIC_PWM2CLKDIV1          0x065
+#define INTEL_MSIC_PWM2CLKDIV0          0x066
+#define INTEL_MSIC_PWM0DUTYCYCLE        0x067
+#define INTEL_MSIC_PWM1DUTYCYCLE        0x068
+#define INTEL_MSIC_PWM2DUTYCYCLE        0x069
+#define INTEL_MSIC_GPIO0HV3CTLO         0x06d
+#define INTEL_MSIC_GPIO0HV2CTLO         0x06e
+#define INTEL_MSIC_GPIO0HV1CTLO         0x06f
+#define INTEL_MSIC_GPIO0HV0CTLO         0x070
+#define INTEL_MSIC_GPIO1HV3CTLO         0x071
+#define INTEL_MSIC_GPIO1HV2CTLO         0x072
+#define INTEL_MSIC_GPIO1HV1CTLO         0x073
+#define INTEL_MSIC_GPIO1HV0CTLO         0x074
+#define INTEL_MSIC_GPIO0HV3CTLI         0x075
+#define INTEL_MSIC_GPIO0HV2CTLI         0x076
+#define INTEL_MSIC_GPIO0HV1CTLI         0x077
+#define INTEL_MSIC_GPIO0HV0CTLI         0x078
+#define INTEL_MSIC_GPIO1HV3CTLI         0x079
+#define INTEL_MSIC_GPIO1HV2CTLI         0x07a
+#define INTEL_MSIC_GPIO1HV1CTLI         0x07b
+#define INTEL_MSIC_GPIO1HV0CTLI         0x07c
+/* SVID */
+#define INTEL_MSIC_SVIDCTRL0            0x080
+#define INTEL_MSIC_SVIDCTRL1            0x081
+#define INTEL_MSIC_SVIDCTRL2            0x082
+#define INTEL_MSIC_SVIDTXLASTPKT3       0x083   /* RO */
+#define INTEL_MSIC_SVIDTXLASTPKT2       0x084   /* RO */
+#define INTEL_MSIC_SVIDTXLASTPKT1       0x085   /* RO */
+#define INTEL_MSIC_SVIDTXLASTPKT0       0x086   /* RO */
+#define INTEL_MSIC_SVIDPKTOUTBYTE3      0x087
+#define INTEL_MSIC_SVIDPKTOUTBYTE2      0x088
+#define INTEL_MSIC_SVIDPKTOUTBYTE1      0x089
+#define INTEL_MSIC_SVIDPKTOUTBYTE0      0x08a
+#define INTEL_MSIC_SVIDRXVPDEBUG1       0x08b
+#define INTEL_MSIC_SVIDRXVPDEBUG0       0x08c
+#define INTEL_MSIC_SVIDRXLASTPKT3       0x08d   /* RO */
+#define INTEL_MSIC_SVIDRXLASTPKT2       0x08e   /* RO */
+#define INTEL_MSIC_SVIDRXLASTPKT1       0x08f   /* RO */
+#define INTEL_MSIC_SVIDRXLASTPKT0       0x090   /* RO */
+#define INTEL_MSIC_SVIDRXCHKSTATUS3     0x091   /* RO */
+#define INTEL_MSIC_SVIDRXCHKSTATUS2     0x092   /* RO */
+#define INTEL_MSIC_SVIDRXCHKSTATUS1     0x093   /* RO */
+#define INTEL_MSIC_SVIDRXCHKSTATUS0     0x094   /* RO */
+/* VREG */
+#define INTEL_MSIC_VCCLATCH             0x0c0
+#define INTEL_MSIC_VNNLATCH             0x0c1
+#define INTEL_MSIC_VCCCNT               0x0c2
+#define INTEL_MSIC_SMPSRAMP             0x0c3
+#define INTEL_MSIC_VNNCNT               0x0c4
+#define INTEL_MSIC_VNNAONCNT            0x0c5
+#define INTEL_MSIC_VCC122AONCNT         0x0c6
+#define INTEL_MSIC_V180AONCNT           0x0c7
+#define INTEL_MSIC_V500CNT              0x0c8
+#define INTEL_MSIC_VIHFCNT              0x0c9
+#define INTEL_MSIC_LDORAMP1             0x0ca
+#define INTEL_MSIC_LDORAMP2             0x0cb
+#define INTEL_MSIC_VCC108AONCNT         0x0cc
+#define INTEL_MSIC_VCC108ASCNT          0x0cd
+#define INTEL_MSIC_VCC108CNT            0x0ce
+#define INTEL_MSIC_VCCA100ASCNT         0x0cf
+#define INTEL_MSIC_VCCA100CNT           0x0d0
+#define INTEL_MSIC_VCC180AONCNT         0x0d1
+#define INTEL_MSIC_VCC180CNT            0x0d2
+#define INTEL_MSIC_VCC330CNT            0x0d3
+#define INTEL_MSIC_VUSB330CNT           0x0d4
+#define INTEL_MSIC_VCCSDIOCNT           0x0d5
+#define INTEL_MSIC_VPROG1CNT            0x0d6
+#define INTEL_MSIC_VPROG2CNT            0x0d7
+#define INTEL_MSIC_VEMMCSCNT            0x0d8
+#define INTEL_MSIC_VEMMC1CNT            0x0d9
+#define INTEL_MSIC_VEMMC2CNT            0x0da
+#define INTEL_MSIC_VAUDACNT             0x0db
+#define INTEL_MSIC_VHSPCNT              0x0dc
+#define INTEL_MSIC_VHSNCNT              0x0dd
+#define INTEL_MSIC_VHDMICNT             0x0de
+#define INTEL_MSIC_VOTGCNT              0x0df
+#define INTEL_MSIC_V1P35CNT             0x0e0
+#define INTEL_MSIC_V330AONCNT           0x0e1
+/* RESET */
+#define INTEL_MSIC_CHIPCNTRL            0x100   /* WO */
+#define INTEL_MSIC_ERCONFIG             0x101
+/* BURST */
+#define INTEL_MSIC_BATCURRENTLIMIT12    0x102
+#define INTEL_MSIC_BATTIMELIMIT12       0x103
+#define INTEL_MSIC_BATTIMELIMIT3        0x104
+#define INTEL_MSIC_BATTIMEDB            0x105
+#define INTEL_MSIC_BRSTCONFIGOUTPUTS    0x106
+#define INTEL_MSIC_BRSTCONFIGACTIONS    0x107
+#define INTEL_MSIC_BURSTCONTROLSTATUS   0x108
+/* RTC */
+#define INTEL_MSIC_RTCB1                0x140   /* RO */
+#define INTEL_MSIC_RTCB2                0x141   /* RO */
+#define INTEL_MSIC_RTCB3                0x142   /* RO */
+#define INTEL_MSIC_RTCB4                0x143   /* RO */
+#define INTEL_MSIC_RTCOB1               0x144
+#define INTEL_MSIC_RTCOB2               0x145
+#define INTEL_MSIC_RTCOB3               0x146
+#define INTEL_MSIC_RTCOB4               0x147
+#define INTEL_MSIC_RTCAB1               0x148
+#define INTEL_MSIC_RTCAB2               0x149
+#define INTEL_MSIC_RTCAB3               0x14a
+#define INTEL_MSIC_RTCAB4               0x14b
+#define INTEL_MSIC_RTCWAB1              0x14c
+#define INTEL_MSIC_RTCWAB2              0x14d
+#define INTEL_MSIC_RTCWAB3              0x14e
+#define INTEL_MSIC_RTCWAB4              0x14f
+#define INTEL_MSIC_RTCSC1               0x150
+#define INTEL_MSIC_RTCSC2               0x151
+#define INTEL_MSIC_RTCSC3               0x152
+#define INTEL_MSIC_RTCSC4               0x153
+#define INTEL_MSIC_RTCSTATUS            0x154   /* RO */
+#define INTEL_MSIC_RTCCONFIG1           0x155
+#define INTEL_MSIC_RTCCONFIG2           0x156
+/* CHARGER */
+#define INTEL_MSIC_BDTIMER              0x180
+#define INTEL_MSIC_BATTRMV              0x181
+#define INTEL_MSIC_VBUSDET              0x182
+#define INTEL_MSIC_VBUSDET1             0x183
+#define INTEL_MSIC_ADPHVDET             0x184
+#define INTEL_MSIC_ADPLVDET             0x185
+#define INTEL_MSIC_ADPDETDBDM           0x186
+#define INTEL_MSIC_LOWBATTDET           0x187
+#define INTEL_MSIC_CHRCTRL              0x188
+#define INTEL_MSIC_CHRCVOLTAGE          0x189
+#define INTEL_MSIC_CHRCCURRENT          0x18a
+#define INTEL_MSIC_SPCHARGER            0x18b
+#define INTEL_MSIC_CHRTTIME             0x18c
+#define INTEL_MSIC_CHRCTRL1             0x18d
+#define INTEL_MSIC_PWRSRCLMT            0x18e
+#define INTEL_MSIC_CHRSTWDT             0x18f
+#define INTEL_MSIC_WDTWRITE             0x190   /* WO */
+#define INTEL_MSIC_CHRSAFELMT           0x191
+#define INTEL_MSIC_SPWRSRCINT           0x192   /* RO */
+#define INTEL_MSIC_SPWRSRCINT1          0x193   /* RO */
+#define INTEL_MSIC_CHRLEDPWM            0x194
+#define INTEL_MSIC_CHRLEDCTRL           0x195
+/* ADC */
+#define INTEL_MSIC_ADC1CNTL1            0x1c0
+#define INTEL_MSIC_ADC1CNTL2            0x1c1
+#define INTEL_MSIC_ADC1CNTL3            0x1c2
+#define INTEL_MSIC_ADC1OFFSETH          0x1c3   /* RO */
+#define INTEL_MSIC_ADC1OFFSETL          0x1c4   /* RO */
+#define INTEL_MSIC_ADC1ADDR0            0x1c5
+#define INTEL_MSIC_ADC1ADDR1            0x1c6
+#define INTEL_MSIC_ADC1ADDR2            0x1c7
+#define INTEL_MSIC_ADC1ADDR3            0x1c8
+#define INTEL_MSIC_ADC1ADDR4            0x1c9
+#define INTEL_MSIC_ADC1ADDR5            0x1ca
+#define INTEL_MSIC_ADC1ADDR6            0x1cb
+#define INTEL_MSIC_ADC1ADDR7            0x1cc
+#define INTEL_MSIC_ADC1ADDR8            0x1cd
+#define INTEL_MSIC_ADC1ADDR9            0x1ce
+#define INTEL_MSIC_ADC1ADDR10           0x1cf
+#define INTEL_MSIC_ADC1ADDR11           0x1d0
+#define INTEL_MSIC_ADC1ADDR12           0x1d1
+#define INTEL_MSIC_ADC1ADDR13           0x1d2
+#define INTEL_MSIC_ADC1ADDR14           0x1d3
+#define INTEL_MSIC_ADC1SNS0H            0x1d4   /* RO */
+#define INTEL_MSIC_ADC1SNS0L            0x1d5   /* RO */
+#define INTEL_MSIC_ADC1SNS1H            0x1d6   /* RO */
+#define INTEL_MSIC_ADC1SNS1L            0x1d7   /* RO */
+#define INTEL_MSIC_ADC1SNS2H            0x1d8   /* RO */
+#define INTEL_MSIC_ADC1SNS2L            0x1d9   /* RO */
+#define INTEL_MSIC_ADC1SNS3H            0x1da   /* RO */
+#define INTEL_MSIC_ADC1SNS3L            0x1db   /* RO */
+#define INTEL_MSIC_ADC1SNS4H            0x1dc   /* RO */
+#define INTEL_MSIC_ADC1SNS4L            0x1dd   /* RO */
+#define INTEL_MSIC_ADC1SNS5H            0x1de   /* RO */
+#define INTEL_MSIC_ADC1SNS5L            0x1df   /* RO */
+#define INTEL_MSIC_ADC1SNS6H            0x1e0   /* RO */
+#define INTEL_MSIC_ADC1SNS6L            0x1e1   /* RO */
+#define INTEL_MSIC_ADC1SNS7H            0x1e2   /* RO */
+#define INTEL_MSIC_ADC1SNS7L            0x1e3   /* RO */
+#define INTEL_MSIC_ADC1SNS8H            0x1e4   /* RO */
+#define INTEL_MSIC_ADC1SNS8L            0x1e5   /* RO */
+#define INTEL_MSIC_ADC1SNS9H            0x1e6   /* RO */
+#define INTEL_MSIC_ADC1SNS9L            0x1e7   /* RO */
+#define INTEL_MSIC_ADC1SNS10H           0x1e8   /* RO */
+#define INTEL_MSIC_ADC1SNS10L           0x1e9   /* RO */
+#define INTEL_MSIC_ADC1SNS11H           0x1ea   /* RO */
+#define INTEL_MSIC_ADC1SNS11L           0x1eb   /* RO */
+#define INTEL_MSIC_ADC1SNS12H           0x1ec   /* RO */
+#define INTEL_MSIC_ADC1SNS12L           0x1ed   /* RO */
+#define INTEL_MSIC_ADC1SNS13H           0x1ee   /* RO */
+#define INTEL_MSIC_ADC1SNS13L           0x1ef   /* RO */
+#define INTEL_MSIC_ADC1SNS14H           0x1f0   /* RO */
+#define INTEL_MSIC_ADC1SNS14L           0x1f1   /* RO */
+#define INTEL_MSIC_ADC1BV0H             0x1f2   /* RO */
+#define INTEL_MSIC_ADC1BV0L             0x1f3   /* RO */
+#define INTEL_MSIC_ADC1BV1H             0x1f4   /* RO */
+#define INTEL_MSIC_ADC1BV1L             0x1f5   /* RO */
+#define INTEL_MSIC_ADC1BV2H             0x1f6   /* RO */
+#define INTEL_MSIC_ADC1BV2L             0x1f7   /* RO */
+#define INTEL_MSIC_ADC1BV3H             0x1f8   /* RO */
+#define INTEL_MSIC_ADC1BV3L             0x1f9   /* RO */
+#define INTEL_MSIC_ADC1BI0H             0x1fa   /* RO */
+#define INTEL_MSIC_ADC1BI0L             0x1fb   /* RO */
+#define INTEL_MSIC_ADC1BI1H             0x1fc   /* RO */
+#define INTEL_MSIC_ADC1BI1L             0x1fd   /* RO */
+#define INTEL_MSIC_ADC1BI2H             0x1fe   /* RO */
+#define INTEL_MSIC_ADC1BI2L             0x1ff   /* RO */
+#define INTEL_MSIC_ADC1BI3H             0x200   /* RO */
+#define INTEL_MSIC_ADC1BI3L             0x201   /* RO */
+#define INTEL_MSIC_CCCNTL               0x202
+#define INTEL_MSIC_CCOFFSETH            0x203   /* RO */
+#define INTEL_MSIC_CCOFFSETL            0x204   /* RO */
+#define INTEL_MSIC_CCADCHA              0x205   /* RO */
+#define INTEL_MSIC_CCADCLA              0x206   /* RO */
+/* AUDIO */
+#define INTEL_MSIC_AUDPLLCTRL           0x240
+#define INTEL_MSIC_DMICBUF0123          0x241
+#define INTEL_MSIC_DMICBUF45            0x242
+#define INTEL_MSIC_DMICGPO              0x244
+#define INTEL_MSIC_DMICMUX              0x245
+#define INTEL_MSIC_DMICCLK              0x246
+#define INTEL_MSIC_MICBIAS              0x247
+#define INTEL_MSIC_ADCCONFIG            0x248
+#define INTEL_MSIC_MICAMP1              0x249
+#define INTEL_MSIC_MICAMP2              0x24a
+#define INTEL_MSIC_NOISEMUX             0x24b
+#define INTEL_MSIC_AUDIOMUX12           0x24c
+#define INTEL_MSIC_AUDIOMUX34           0x24d
+#define INTEL_MSIC_AUDIOSINC            0x24e
+#define INTEL_MSIC_AUDIOTXEN            0x24f
+#define INTEL_MSIC_HSEPRXCTRL           0x250
+#define INTEL_MSIC_IHFRXCTRL            0x251
+#define INTEL_MSIC_VOICETXVOL           0x252
+#define INTEL_MSIC_SIDETONEVOL          0x253
+#define INTEL_MSIC_MUSICSHARVOL         0x254
+#define INTEL_MSIC_VOICETXCTRL          0x255
+#define INTEL_MSIC_HSMIXER              0x256
+#define INTEL_MSIC_DACCONFIG            0x257
+#define INTEL_MSIC_SOFTMUTE             0x258
+#define INTEL_MSIC_HSLVOLCTRL           0x259
+#define INTEL_MSIC_HSRVOLCTRL           0x25a
+#define INTEL_MSIC_IHFLVOLCTRL          0x25b
+#define INTEL_MSIC_IHFRVOLCTRL          0x25c
+#define INTEL_MSIC_DRIVEREN             0x25d
+#define INTEL_MSIC_LINEOUTCTRL          0x25e
+#define INTEL_MSIC_VIB1CTRL1            0x25f
+#define INTEL_MSIC_VIB1CTRL2            0x260
+#define INTEL_MSIC_VIB1CTRL3            0x261
+#define INTEL_MSIC_VIB1SPIPCM_1         0x262
+#define INTEL_MSIC_VIB1SPIPCM_2         0x263
+#define INTEL_MSIC_VIB1CTRL5            0x264
+#define INTEL_MSIC_VIB2CTRL1            0x265
+#define INTEL_MSIC_VIB2CTRL2            0x266
+#define INTEL_MSIC_VIB2CTRL3            0x267
+#define INTEL_MSIC_VIB2SPIPCM_1         0x268
+#define INTEL_MSIC_VIB2SPIPCM_2         0x269
+#define INTEL_MSIC_VIB2CTRL5            0x26a
+#define INTEL_MSIC_BTNCTRL1             0x26b
+#define INTEL_MSIC_BTNCTRL2             0x26c
+#define INTEL_MSIC_PCM1TXSLOT01         0x26d
+#define INTEL_MSIC_PCM1TXSLOT23         0x26e
+#define INTEL_MSIC_PCM1TXSLOT45         0x26f
+#define INTEL_MSIC_PCM1RXSLOT0123       0x270
+#define INTEL_MSIC_PCM1RXSLOT045        0x271
+#define INTEL_MSIC_PCM2TXSLOT01         0x272
+#define INTEL_MSIC_PCM2TXSLOT23         0x273
+#define INTEL_MSIC_PCM2TXSLOT45         0x274
+#define INTEL_MSIC_PCM2RXSLOT01         0x275
+#define INTEL_MSIC_PCM2RXSLOT23         0x276
+#define INTEL_MSIC_PCM2RXSLOT45         0x277
+#define INTEL_MSIC_PCM1CTRL1            0x278
+#define INTEL_MSIC_PCM1CTRL2            0x279
+#define INTEL_MSIC_PCM1CTRL3            0x27a
+#define INTEL_MSIC_PCM2CTRL1            0x27b
+#define INTEL_MSIC_PCM2CTRL2            0x27c
+/* HDMI */
+#define INTEL_MSIC_HDMIPUEN             0x280
+#define INTEL_MSIC_HDMISTATUS           0x281   /* RO */
+/* Physical address of the start of the MSIC interrupt tree in SRAM */
+#define INTEL_MSIC_IRQ_PHYS_BASE        0xffff7fc0
+/**
+ * struct intel_msic_gpio_pdata - platform data for the MSIC GPIO driver
+ * @gpio_base: base number for the GPIOs
+ */
+struct intel_msic_gpio_pdata {
+        unsigned        gpio_base;
+};
+/**
+ * struct intel_msic_ocd_pdata - platform data for the MSIC OCD driver
+ * @gpio: GPIO number used for OCD interrupts
+ *
+ * The MSIC MFD driver converts @gpio into an IRQ number and passes it to
+ * the OCD driver as %IORESOURCE_IRQ.
+ */
+struct intel_msic_ocd_pdata {
+        unsigned        gpio;
+};
+/* MSIC embedded blocks (subdevices) */
+enum intel_msic_block {
+        INTEL_MSIC_BLOCK_TOUCH,
+        INTEL_MSIC_BLOCK_ADC,
+        INTEL_MSIC_BLOCK_BATTERY,
+        INTEL_MSIC_BLOCK_GPIO,
+        INTEL_MSIC_BLOCK_AUDIO,
+        INTEL_MSIC_BLOCK_HDMI,
+        INTEL_MSIC_BLOCK_THERMAL,
+        INTEL_MSIC_BLOCK_POWER_BTN,
+        INTEL_MSIC_BLOCK_OCD,
+        INTEL_MSIC_BLOCK_LAST,
+};
+/**
+ * struct intel_msic_platform_data - platform data for the MSIC driver
+ * @irq: array of interrupt numbers, one per device. If @irq is set to %0
+ *       for a given block, the corresponding platform device is not
+ *       created. For devices which don't have an interrupt, use %0xff
+ *       (this is same as in SFI spec).
+ * @gpio: platform data for the MSIC GPIO driver
+ * @ocd: platform data for the MSIC OCD driver
+ *
+ * Once the MSIC driver is initialized, the register interface is ready to
+ * use. All the platform devices for subdevices are created after the
+ * register interface is ready so that we can guarantee its availability to
+ * the subdevice drivers.
+ *
+ * Interrupt numbers are passed to the subdevices via %IORESOURCE_IRQ
+ * resources of the created platform device.
+ */
+struct intel_msic_platform_data {
+        int                             irq[INTEL_MSIC_BLOCK_LAST];
+        struct intel_msic_gpio_pdata    *gpio;
+        struct intel_msic_ocd_pdata     *ocd;
+};
+struct intel_msic;
+extern int intel_msic_reg_read(unsigned short reg, u8 *val);
+extern int intel_msic_reg_write(unsigned short reg, u8 val);
+extern int intel_msic_reg_update(unsigned short reg, u8 val, u8 mask);
+extern int intel_msic_bulk_read(unsigned short *reg, u8 *buf, size_t count);
+extern int intel_msic_bulk_write(unsigned short *reg, u8 *buf, size_t count);
+/*
+ * pdev_to_intel_msic - gets an MSIC instance from the platform device
+ * @pdev: platform device pointer
+ *
+ * The client drivers need to have pointer to the MSIC instance if they
+ * want to call intel_msic_irq_read(). This macro can be used for
+ * convenience to get the MSIC pointer from @pdev where needed. This is
+ * _only_ valid for devices which are managed by the MSIC.
+ */
+#define pdev_to_intel_msic(pdev)        (dev_get_drvdata(pdev->dev.parent))
+extern int intel_msic_irq_read(struct intel_msic *msic, unsigned short reg,
+                               u8 *val);
+#endif /* __LINUX_MFD_INTEL_MSIC_H__ */
diff --git a/include/linux/mfd/max8997-private.h b/include/linux/mfd/max8997-private.h
index 5ff2400ad46c..3f4deb62d6b0 100644
--- a/include/linux/mfd/max8997-private.h
+++ b/include/linux/mfd/max8997-private.h
@@ -326,7 +326,6 @@ struct max8997_dev {
        int irq;
        int ono;
        int irq_base;
-        bool wakeup;
        struct mutex irqlock;
        int irq_masks_cur[MAX8997_IRQ_GROUP_NR];
        int irq_masks_cache[MAX8997_IRQ_GROUP_NR];
diff --git a/include/linux/mfd/mc13783.h b/include/linux/mfd/mc13783.h
index 7d0f3d6a0002..a8eeda773a7b 100644
--- a/include/linux/mfd/mc13783.h
+++ b/include/linux/mfd/mc13783.h
@@ -12,117 +12,6 @@
 #include <linux/mfd/mc13xxx.h>
-struct mc13783;
-struct mc13xxx *mc13783_to_mc13xxx(struct mc13783 *mc13783);
-static inline void mc13783_lock(struct mc13783 *mc13783)
-{
-        mc13xxx_lock(mc13783_to_mc13xxx(mc13783));
-}
-static inline void mc13783_unlock(struct mc13783 *mc13783)
-{
-        mc13xxx_unlock(mc13783_to_mc13xxx(mc13783));
-}
-static inline int mc13783_reg_read(struct mc13783 *mc13783,
-                unsigned int offset, u32 *val)
-{
-        return mc13xxx_reg_read(mc13783_to_mc13xxx(mc13783), offset, val);
-}
-static inline int mc13783_reg_write(struct mc13783 *mc13783,
-                unsigned int offset, u32 val)
-{
-        return mc13xxx_reg_write(mc13783_to_mc13xxx(mc13783), offset, val);
-}
-static inline int mc13783_reg_rmw(struct mc13783 *mc13783,
-                unsigned int offset, u32 mask, u32 val)
-{
-        return mc13xxx_reg_rmw(mc13783_to_mc13xxx(mc13783), offset, mask, val);
-}
-static inline int mc13783_get_flags(struct mc13783 *mc13783)
-{
-        return mc13xxx_get_flags(mc13783_to_mc13xxx(mc13783));
-}
-static inline int mc13783_irq_request(struct mc13783 *mc13783, int irq,
-                irq_handler_t handler, const char *name, void *dev)
-{
-        return mc13xxx_irq_request(mc13783_to_mc13xxx(mc13783), irq,
-                        handler, name, dev);
-}
-static inline int mc13783_irq_request_nounmask(struct mc13783 *mc13783, int irq,
-                irq_handler_t handler, const char *name, void *dev)
-{
-        return mc13xxx_irq_request_nounmask(mc13783_to_mc13xxx(mc13783), irq,
-                        handler, name, dev);
-}
-static inline int mc13783_irq_free(struct mc13783 *mc13783, int irq, void *dev)
-{
-        return mc13xxx_irq_free(mc13783_to_mc13xxx(mc13783), irq, dev);
-}
-static inline int mc13783_irq_mask(struct mc13783 *mc13783, int irq)
-{
-        return mc13xxx_irq_mask(mc13783_to_mc13xxx(mc13783), irq);
-}
-static inline int mc13783_irq_unmask(struct mc13783 *mc13783, int irq)
-{
-        return mc13xxx_irq_unmask(mc13783_to_mc13xxx(mc13783), irq);
-}
-static inline int mc13783_irq_status(struct mc13783 *mc13783, int irq,
-                int *enabled, int *pending)
-{
-        return mc13xxx_irq_status(mc13783_to_mc13xxx(mc13783),
-                        irq, enabled, pending);
-}
-static inline int mc13783_irq_ack(struct mc13783 *mc13783, int irq)
-{
-        return mc13xxx_irq_ack(mc13783_to_mc13xxx(mc13783), irq);
-}
-#define MC13783_ADC0            43
-#define MC13783_ADC0_ADREFEN            (1 << 10)
-#define MC13783_ADC0_ADREFMODE          (1 << 11)
-#define MC13783_ADC0_TSMOD0             (1 << 12)
-#define MC13783_ADC0_TSMOD1             (1 << 13)
-#define MC13783_ADC0_TSMOD2             (1 << 14)
-#define MC13783_ADC0_ADINC1             (1 << 16)
-#define MC13783_ADC0_ADINC2             (1 << 17)
-#define MC13783_ADC0_TSMOD_MASK         (MC13783_ADC0_TSMOD0 | \
-                                        MC13783_ADC0_TSMOD1 | \
-                                        MC13783_ADC0_TSMOD2)
-#define mc13783_regulator_init_data mc13xxx_regulator_init_data
-#define mc13783_regulator_platform_data mc13xxx_regulator_platform_data
-#define mc13783_led_platform_data mc13xxx_led_platform_data
-#define mc13783_leds_platform_data mc13xxx_leds_platform_data
-#define mc13783_platform_data mc13xxx_platform_data
-#define MC13783_USE_TOUCHSCREEN MC13XXX_USE_TOUCHSCREEN
-#define MC13783_USE_CODEC       MC13XXX_USE_CODEC
-#define MC13783_USE_ADC         MC13XXX_USE_ADC
-#define MC13783_USE_RTC         MC13XXX_USE_RTC
-#define MC13783_USE_REGULATOR   MC13XXX_USE_REGULATOR
-#define MC13783_USE_LED         MC13XXX_USE_LED
-#define MC13783_ADC_MODE_TS             1
-#define MC13783_ADC_MODE_SINGLE_CHAN    2
-#define MC13783_ADC_MODE_MULT_CHAN      3
-int mc13783_adc_do_conversion(struct mc13783 *mc13783, unsigned int mode,
-                unsigned int channel, unsigned int *sample);
 #define MC13783_REG_SW1A                0
 #define MC13783_REG_SW1B                1
 #define MC13783_REG_SW2A                2
diff --git a/include/linux/mfd/mc13xxx.h b/include/linux/mfd/mc13xxx.h
index c064beaaccb7..3816c2fac0ad 100644
--- a/include/linux/mfd/mc13xxx.h
+++ b/include/linux/mfd/mc13xxx.h
@@ -37,6 +37,9 @@ int mc13xxx_irq_ack(struct mc13xxx *mc13xxx, int irq);
 int mc13xxx_get_flags(struct mc13xxx *mc13xxx);
+int mc13xxx_adc_do_conversion(struct mc13xxx *mc13xxx,
+                unsigned int mode, unsigned int channel, unsigned int *sample);
 #define MC13XXX_IRQ_ADCDONE     0
 #define MC13XXX_IRQ_ADCBISDONE  1
 #define MC13XXX_IRQ_TS          2
@@ -137,17 +140,48 @@ struct mc13xxx_leds_platform_data {
        char tc3_period;
 };
+struct mc13xxx_buttons_platform_data {
+#define MC13783_BUTTON_DBNC_0MS         0
+#define MC13783_BUTTON_DBNC_30MS        1
+#define MC13783_BUTTON_DBNC_150MS       2
+#define MC13783_BUTTON_DBNC_750MS       3
+#define MC13783_BUTTON_ENABLE           (1 << 2)
+#define MC13783_BUTTON_POL_INVERT       (1 << 3)
+#define MC13783_BUTTON_RESET_EN         (1 << 4)
+        int b1on_flags;
+        unsigned short b1on_key;
+        int b2on_flags;
+        unsigned short b2on_key;
+        int b3on_flags;
+        unsigned short b3on_key;
+};
 struct mc13xxx_platform_data {
 #define MC13XXX_USE_TOUCHSCREEN (1 << 0)
 #define MC13XXX_USE_CODEC       (1 << 1)
 #define MC13XXX_USE_ADC         (1 << 2)
 #define MC13XXX_USE_RTC         (1 << 3)
-#define MC13XXX_USE_REGULATOR   (1 << 4)
-#define MC13XXX_USE_LED         (1 << 5)
        unsigned int flags;
        struct mc13xxx_regulator_platform_data regulators;
        struct mc13xxx_leds_platform_data *leds;
+        struct mc13xxx_buttons_platform_data *buttons;
 };
+#define MC13XXX_ADC_MODE_TS             1
+#define MC13XXX_ADC_MODE_SINGLE_CHAN    2
+#define MC13XXX_ADC_MODE_MULT_CHAN      3
+#define MC13XXX_ADC0            43
+#define MC13XXX_ADC0_ADREFEN            (1 << 10)
+#define MC13XXX_ADC0_TSMOD0             (1 << 12)
+#define MC13XXX_ADC0_TSMOD1             (1 << 13)
+#define MC13XXX_ADC0_TSMOD2             (1 << 14)
+#define MC13XXX_ADC0_ADINC1             (1 << 16)
+#define MC13XXX_ADC0_ADINC2             (1 << 17)
+#define MC13XXX_ADC0_TSMOD_MASK         (MC13XXX_ADC0_TSMOD0 | \
+                                        MC13XXX_ADC0_TSMOD1 | \
+                                        MC13XXX_ADC0_TSMOD2)
 #endif /* ifndef __LINUX_MFD_MC13XXX_H */
diff --git a/include/linux/mfd/pcf50633/core.h b/include/linux/mfd/pcf50633/core.h
index 50d4a047118d..a80840752b4c 100644
--- a/include/linux/mfd/pcf50633/core.h
+++ b/include/linux/mfd/pcf50633/core.h
@@ -21,6 +21,7 @@
 #include <linux/mfd/pcf50633/backlight.h>
 struct pcf50633;
+struct regmap;
 #define PCF50633_NUM_REGULATORS 11
@@ -134,7 +135,7 @@ enum {
 struct pcf50633 {
        struct device *dev;
-        struct i2c_client *i2c_client;
+        struct regmap *regmap;
        struct pcf50633_platform_data *pdata;
        int irq;
diff --git a/include/linux/mfd/wm831x/core.h b/include/linux/mfd/wm831x/core.h
index ed8fe0d04097..4b1211859f74 100644
--- a/include/linux/mfd/wm831x/core.h
+++ b/include/linux/mfd/wm831x/core.h
@@ -382,6 +382,7 @@ struct wm831x {
        /* Used by the interrupt controller code to post writes */
        int gpio_update[WM831X_NUM_GPIO_REGS];
+        bool gpio_level[WM831X_NUM_GPIO_REGS];
        struct mutex auxadc_lock;
        struct list_head auxadc_pending;
diff --git a/include/linux/mfd/wm8994/core.h b/include/linux/mfd/wm8994/core.h
index 626809147624..f44bdb7273bd 100644
--- a/include/linux/mfd/wm8994/core.h
+++ b/include/linux/mfd/wm8994/core.h
@@ -59,6 +59,8 @@ struct wm8994 {
        struct device *dev;
        struct regmap *regmap;
+        bool ldo_ena_always_driven;
        int gpio_base;
        int irq_base;
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index 97cf4f27d647..ea32f306dca6 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -167,6 +167,13 @@ struct wm8994_pdata {
        /* WM8958 microphone bias configuration */
        int micbias[2];
+        /* Disable the internal pull downs on the LDOs if they are
+         * always driven (eg, connected to an always on supply or
+         * GPIO that always drives an output.  If they float power
+         * consumption will rise.
+         */
+        bool ldo_ena_always_driven;
 };
 #endif
diff --git a/include/linux/miscdevice.h b/include/linux/miscdevice.h
index c309b1ecdc1c..c41d7270c6c6 100644
--- a/include/linux/miscdevice.h
+++ b/include/linux/miscdevice.h
@@ -1,7 +1,8 @@
 #ifndef _LINUX_MISCDEVICE_H
 #define _LINUX_MISCDEVICE_H
-#include <linux/module.h>
 #include <linux/major.h>
+#include <linux/list.h>
+#include <linux/types.h>
 /*
 *      These allocations are managed by device@lanana.org. If you use an
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 3b3e3b8bb706..3dc3a8c2c485 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -356,36 +356,50 @@ static inline struct page *compound_head(struct page *page)
        return page;
 }
+/*
+ * The atomic page->_mapcount, starts from -1: so that transitions
+ * both from it and to it can be tracked, using atomic_inc_and_test
+ * and atomic_add_negative(-1).
+ */
+static inline void reset_page_mapcount(struct page *page)
+{
+        atomic_set(&(page)->_mapcount, -1);
+}
+static inline int page_mapcount(struct page *page)
+{
+        return atomic_read(&(page)->_mapcount) + 1;
+}
 static inline int page_count(struct page *page)
 {
        return atomic_read(&compound_head(page)->_count);
 }
+static inline void get_huge_page_tail(struct page *page)
+{
+        /*
+         * __split_huge_page_refcount() cannot run
+         * from under us.
+         */
+        VM_BUG_ON(page_mapcount(page) < 0);
+        VM_BUG_ON(atomic_read(&page->_count) != 0);
+        atomic_inc(&page->_mapcount);
+}
+extern bool __get_page_tail(struct page *page);
 static inline void get_page(struct page *page)
 {
+        if (unlikely(PageTail(page)))
+                if (likely(__get_page_tail(page)))
+                        return;
        /*
         * Getting a normal page or the head of a compound page
-         * requires to already have an elevated page->_count. Only if
+         * requires to already have an elevated page->_count.
-         * we're getting a tail page, the elevated page->_count is
-         * required only in the head page, so for tail pages the
-         * bugcheck only verifies that the page->_count isn't
-         * negative.
         */
-        VM_BUG_ON(atomic_read(&page->_count) < !PageTail(page));
+        VM_BUG_ON(atomic_read(&page->_count) <= 0);
        atomic_inc(&page->_count);
-        /*
-         * Getting a tail page will elevate both the head and tail
-         * page->_count(s).
-         */
-        if (unlikely(PageTail(page))) {
-                /*
-                 * This is safe only because
-                 * __split_huge_page_refcount can't run under
-                 * get_page().
-                 */
-                VM_BUG_ON(atomic_read(&page->first_page->_count) <= 0);
-                atomic_inc(&page->first_page->_count);
-        }
 }
 static inline struct page *virt_to_head_page(const void *x)
@@ -804,21 +818,6 @@ static inline pgoff_t page_index(struct page *page)
 }
 /*
- * The atomic page->_mapcount, like _count, starts from -1:
- * so that transitions both from it and to it can be tracked,
- * using atomic_inc_and_test and atomic_add_negative(-1).
- */
-static inline void reset_page_mapcount(struct page *page)
-{
-        atomic_set(&(page)->_mapcount, -1);
-}
-static inline int page_mapcount(struct page *page)
-{
-        return atomic_read(&(page)->_mapcount) + 1;
-}
-/*
 * Return true if this page is mapped into pagetables.
 */
 static inline int page_mapped(struct page *page)
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 3e01a19a91e8..5b42f1b34eb7 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -62,10 +62,23 @@ struct page {
                        struct {
                                union {
-                                        atomic_t _mapcount;     /* Count of ptes mapped in mms,
+                                        /*
-                                                         * to show when page is mapped
+                                         * Count of ptes mapped in
-                                                         * & limit reverse map searches.
+                                         * mms, to show when page is
-                                                         */
+                                         * mapped & limit reverse map
+                                         * searches.
+                                         *
+                                         * Used also for tail pages
+                                         * refcounting instead of
+                                         * _count. Tail pages cannot
+                                         * be mapped and keeping the
+                                         * tail page _count zero at
+                                         * all times guarantees
+                                         * get_page_unless_zero() will
+                                         * never succeed on tail
+                                         * pages.
+                                         */
+                                        atomic_t _mapcount;
                                        struct {
                                                unsigned inuse:16;
diff --git a/include/linux/module.h b/include/linux/module.h
index 863921637d9f..3cb7839a60b9 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -16,6 +16,7 @@
 #include <linux/kobject.h>
 #include <linux/moduleparam.h>
 #include <linux/tracepoint.h>
+#include <linux/export.h>
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -25,21 +26,8 @@
 /* Not Yet Implemented */
 #define MODULE_SUPPORTED_DEVICE(name)
-/* Some toolchains use a `_' prefix for all user symbols. */
-#ifdef CONFIG_SYMBOL_PREFIX
-#define MODULE_SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
-#else
-#define MODULE_SYMBOL_PREFIX ""
-#endif
 #define MODULE_NAME_LEN MAX_PARAM_PREFIX_LEN
-struct kernel_symbol
-{
-        unsigned long value;
-        const char *name;
-};
 struct modversion_info
 {
        unsigned long crc;
@@ -98,11 +86,8 @@ void trim_init_extable(struct module *m);
 extern const struct gtype##_id __mod_##gtype##_table            \
  __attribute__ ((unused, alias(__stringify(name))))
-extern struct module __this_module;
-#define THIS_MODULE (&__this_module)
 #else  /* !MODULE */
 #define MODULE_GENERIC_TABLE(gtype,name)
-#define THIS_MODULE ((struct module *)0)
 #endif
 /* Generic info of form tag = "info" */
@@ -150,11 +135,6 @@ extern struct module __this_module;
 /* What your module does. */
 #define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
-/* One for each parameter, describing how to use it.  Some files do
-   multiple of these per line, so can't just use MODULE_INFO. */
-#define MODULE_PARM_DESC(_parm, desc) \
-        __MODULE_INFO(parm, _parm, #_parm ":" desc)
 #define MODULE_DEVICE_TABLE(type,name)          \
  MODULE_GENERIC_TABLE(type##_device,name)
@@ -218,52 +198,6 @@ struct module_use {
        struct module *source, *target;
 };
-#ifndef __GENKSYMS__
-#ifdef CONFIG_MODVERSIONS
-/* Mark the CRC weak since genksyms apparently decides not to
- * generate a checksums for some symbols */
-#define __CRC_SYMBOL(sym, sec)                                  \
-        extern void *__crc_##sym __attribute__((weak));         \
-        static const unsigned long __kcrctab_##sym              \
-        __used                                                  \
-        __attribute__((section("___kcrctab" sec "+" #sym), unused))     \
-        = (unsigned long) &__crc_##sym;
-#else
-#define __CRC_SYMBOL(sym, sec)
-#endif
-/* For every exported symbol, place a struct in the __ksymtab section */
-#define __EXPORT_SYMBOL(sym, sec)                               \
-        extern typeof(sym) sym;                                 \
-        __CRC_SYMBOL(sym, sec)                                  \
-        static const char __kstrtab_##sym[]                     \
-        __attribute__((section("__ksymtab_strings"), aligned(1))) \
-        = MODULE_SYMBOL_PREFIX #sym;                            \
-        static const struct kernel_symbol __ksymtab_##sym       \
-        __used                                                  \
-        __attribute__((section("___ksymtab" sec "+" #sym), unused))     \
-        = { (unsigned long)&sym, __kstrtab_##sym }
-#define EXPORT_SYMBOL(sym)                                      \
-        __EXPORT_SYMBOL(sym, "")
-#define EXPORT_SYMBOL_GPL(sym)                                  \
-        __EXPORT_SYMBOL(sym, "_gpl")
-#define EXPORT_SYMBOL_GPL_FUTURE(sym)                           \
-        __EXPORT_SYMBOL(sym, "_gpl_future")
-#ifdef CONFIG_UNUSED_SYMBOLS
-#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
-#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
-#else
-#define EXPORT_UNUSED_SYMBOL(sym)
-#define EXPORT_UNUSED_SYMBOL_GPL(sym)
-#endif
-#endif
 enum module_state
 {
        MODULE_STATE_LIVE,
@@ -581,11 +515,6 @@ int unregister_module_notifier(struct notifier_block * nb);
 extern void print_modules(void);
 #else /* !CONFIG_MODULES... */
-#define EXPORT_SYMBOL(sym)
-#define EXPORT_SYMBOL_GPL(sym)
-#define EXPORT_SYMBOL_GPL_FUTURE(sym)
-#define EXPORT_UNUSED_SYMBOL(sym)
-#define EXPORT_UNUSED_SYMBOL_GPL(sym)
 /* Given an address, look for it in the exception tables. */
 static inline const struct exception_table_entry *
diff --git a/include/linux/moduleparam.h b/include/linux/moduleparam.h
index fffb10bd5514..7939f636c8ba 100644
--- a/include/linux/moduleparam.h
+++ b/include/linux/moduleparam.h
@@ -31,6 +31,11 @@ static const char __module_cat(name,__LINE__)[]				  \
 #define __MODULE_PARM_TYPE(name, _type)                                   \
  __MODULE_INFO(parmtype, name##type, #name ":" _type)
+/* One for each parameter, describing how to use it.  Some files do
+   multiple of these per line, so can't just use MODULE_INFO. */
+#define MODULE_PARM_DESC(_parm, desc) \
+        __MODULE_INFO(parm, _parm, #_parm ":" desc)
 struct kernel_param;
 struct kernel_param_ops {
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 2541fb848daa..37be05bbfbc8 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -21,7 +21,6 @@
 #define __MTD_MTD_H__
 #include <linux/types.h>
-#include <linux/module.h>
 #include <linux/uio.h>
 #include <linux/notifier.h>
 #include <linux/device.h>
@@ -125,6 +124,8 @@ struct nand_ecclayout {
        struct nand_oobfree oobfree[MTD_MAX_OOBFREE_ENTRIES_LARGE];
 };
+struct module;  /* only needed for owner field in mtd_info */
 struct mtd_info {
        u_char type;
        uint32_t flags;
diff --git a/include/linux/namei.h b/include/linux/namei.h
index 409328d1cbbb..ffc02135c483 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -67,6 +67,7 @@ enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
 #define LOOKUP_EMPTY            0x4000
 extern int user_path_at(int, const char __user *, unsigned, struct path *);
+extern int user_path_at_empty(int, const char __user *, unsigned, struct path *, int *empty);
 #define user_path(name, path) user_path_at(AT_FDCWD, name, LOOKUP_FOLLOW, path)
 #define user_lpath(name, path) user_path_at(AT_FDCWD, name, 0, path)
diff --git a/include/linux/netfilter_ipv4/Kbuild b/include/linux/netfilter_ipv4/Kbuild
index f9930c87fff3..c3b45480ecf7 100644
--- a/include/linux/netfilter_ipv4/Kbuild
+++ b/include/linux/netfilter_ipv4/Kbuild
@@ -12,3 +12,4 @@ header-y += ipt_ah.h
 header-y += ipt_ecn.h
 header-y += ipt_realm.h
 header-y += ipt_ttl.h
+header-y += nf_nat.h
diff --git a/include/linux/netfilter_ipv4/nf_nat.h b/include/linux/netfilter_ipv4/nf_nat.h
new file mode 100644
index 000000000000..7a861d09fc86
--- /dev/null
+++ b/include/linux/netfilter_ipv4/nf_nat.h
@@ -0,0 +1,58 @@
+#ifndef _LINUX_NF_NAT_H
+#define _LINUX_NF_NAT_H
+#include <linux/types.h>
+#define IP_NAT_RANGE_MAP_IPS 1
+#define IP_NAT_RANGE_PROTO_SPECIFIED 2
+#define IP_NAT_RANGE_PROTO_RANDOM 4
+#define IP_NAT_RANGE_PERSISTENT 8
+/* The protocol-specific manipulable parts of the tuple. */
+union nf_conntrack_man_proto {
+        /* Add other protocols here. */
+        __be16 all;
+        struct {
+                __be16 port;
+        } tcp;
+        struct {
+                __be16 port;
+        } udp;
+        struct {
+                __be16 id;
+        } icmp;
+        struct {
+                __be16 port;
+        } dccp;
+        struct {
+                __be16 port;
+        } sctp;
+        struct {
+                __be16 key;     /* GRE key is 32bit, PPtP only uses 16bit */
+        } gre;
+};
+/* Single range specification. */
+struct nf_nat_range {
+        /* Set to OR of flags above. */
+        unsigned int flags;
+        /* Inclusive: network order. */
+        __be32 min_ip, max_ip;
+        /* Inclusive: network order */
+        union nf_conntrack_man_proto min, max;
+};
+/* For backwards compat: don't use in modern code. */
+struct nf_nat_multi_range_compat {
+        unsigned int rangesize; /* Must be 1. */
+        /* hangs off end. */
+        struct nf_nat_range range[1];
+};
+#define nf_nat_multi_range nf_nat_multi_range_compat
+#endif
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 60a137b7f171..ab2c6343361a 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -229,6 +229,7 @@ struct nfs_inode {
 #define NFS_INO_COMMIT          (7)             /* inode is committing unstable writes */
 #define NFS_INO_PNFS_COMMIT     (8)             /* use pnfs code for commit */
 #define NFS_INO_LAYOUTCOMMIT    (9)             /* layoutcommit required */
+#define NFS_INO_LAYOUTCOMMITTING (10)           /* layoutcommit inflight */
 static inline struct nfs_inode *NFS_I(const struct inode *inode)
 {
diff --git a/include/linux/of.h b/include/linux/of.h
index f01ba8a209c0..4948552d60f5 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -23,6 +23,7 @@
 #include <linux/spinlock.h>
 #include <asm/byteorder.h>
+#include <asm/errno.h>
 typedef u32 phandle;
 typedef u32 ihandle;
@@ -321,6 +322,16 @@ static inline struct device_node *of_parse_phandle(struct device_node *np,
        return NULL;
 }
+static inline int of_alias_get_id(struct device_node *np, const char *stem)
+{
+        return -ENOSYS;
+}
+static inline int of_machine_is_compatible(const char *compat)
+{
+        return 0;
+}
 #define of_match_ptr(_ptr)      NULL
 #define of_match_node(_matches, _node)  NULL
 #endif /* CONFIG_OF */
diff --git a/include/linux/of_platform.h b/include/linux/of_platform.h
index 5a6f458a4bb7..040ce2f6e8de 100644
--- a/include/linux/of_platform.h
+++ b/include/linux/of_platform.h
@@ -12,7 +12,6 @@
 */
 #ifdef CONFIG_OF_DEVICE
-#include <linux/module.h>
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/pm.h>
diff --git a/include/linux/opp.h b/include/linux/opp.h
index 87a9208f8aec..ee94b33080c2 100644
--- a/include/linux/opp.h
+++ b/include/linux/opp.h
@@ -97,11 +97,11 @@ static inline int opp_disable(struct device *dev, unsigned long freq)
        return 0;
 }
-struct srcu_notifier_head *opp_get_notifier(struct device *dev)
+static inline struct srcu_notifier_head *opp_get_notifier(struct device *dev)
 {
        return ERR_PTR(-EINVAL);
 }
-#endif          /* CONFIG_PM */
+#endif          /* CONFIG_PM_OPP */
 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
 int opp_init_cpufreq_table(struct device *dev,
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index 5d09cbafa7db..45fc162cbdc0 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -132,13 +132,9 @@ extern int pci_hp_deregister(struct hotplug_slot *slot);
 extern int __must_check pci_hp_change_slot_info (struct hotplug_slot *slot,
                                                 struct hotplug_slot_info *info);
-static inline int pci_hp_register(struct hotplug_slot *slot,
+/* use a define to avoid include chaining to get THIS_MODULE & friends */
-                                  struct pci_bus *pbus,
+#define pci_hp_register(slot, pbus, devnr, name) \
-                                  int devnr, const char *name)
+        __pci_hp_register(slot, pbus, devnr, name, THIS_MODULE, KBUILD_MODNAME)
-{
-        return __pci_hp_register(slot, pbus, devnr, name,
-                                 THIS_MODULE, KBUILD_MODNAME);
-}
 /* PCI Setting Record (Type 0) */
 struct hpp_type0 {
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 1679ff6931f9..3fdf251389de 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -2873,3 +2873,5 @@
 #define PCI_VENDOR_ID_XEN               0x5853
 #define PCI_DEVICE_ID_XEN_PLATFORM      0x0001
+#define PCI_VENDOR_ID_OCZ               0x1b85
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index 70b284024d9e..d8d903619642 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -10,6 +10,7 @@
 #define _LINUX_PM_RUNTIME_H
 #include <linux/device.h>
+#include <linux/notifier.h>
 #include <linux/pm.h>
 #include <linux/jiffies.h>
diff --git a/include/linux/pps-gpio.h b/include/linux/pps-gpio.h
new file mode 100644
index 000000000000..0035abe41b9a
--- /dev/null
+++ b/include/linux/pps-gpio.h
@@ -0,0 +1,32 @@
+/*
+ * pps-gpio.h -- PPS client for GPIOs
+ *
+ *
+ * Copyright (C) 2011 James Nuss <jamesnuss@nanometrics.ca>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+#ifndef _PPS_GPIO_H
+#define _PPS_GPIO_H
+struct pps_gpio_platform_data {
+        bool assert_falling_edge;
+        bool capture_clear;
+        unsigned int gpio_pin;
+        const char *gpio_label;
+};
+#endif
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 3daac2d8dc37..690276a642cf 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -15,8 +15,8 @@
 #include <linux/device.h>
 #include <linux/list.h>
-#include <linux/module.h>
+struct module;
 struct i2c_client;
 struct spi_device;
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 12a1aa04b720..52c89ae32f64 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -16,6 +16,7 @@
 #define __LINUX_REGULATOR_DRIVER_H_
 #include <linux/device.h>
+#include <linux/notifier.h>
 #include <linux/regulator/consumer.h>
 struct regulator_dev;
diff --git a/include/linux/rio_ids.h b/include/linux/rio_ids.h
index 0cee0152aca9..b66d13d1bdc0 100644
--- a/include/linux/rio_ids.h
+++ b/include/linux/rio_ids.h
@@ -39,5 +39,6 @@
 #define RIO_DID_IDTCPS1616              0x0379
 #define RIO_DID_IDTVPS1616              0x0377
 #define RIO_DID_IDTSPS1616              0x0378
+#define RIO_DID_TSI721                  0x80ab
 #endif                          /* LINUX_RIO_IDS_H */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index e8acce717d2a..68daf4f27e2c 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1522,6 +1522,13 @@ struct task_struct {
        int make_it_fail;
 #endif
        struct prop_local_single dirties;
+        /*
+         * when (nr_dirtied >= nr_dirtied_pause), it's time to call
+         * balance_dirty_pages() for some dirty throttling pause
+         */
+        int nr_dirtied;
+        int nr_dirtied_pause;
 #ifdef CONFIG_LATENCYTOP
        int latency_record_count;
        struct latency_record latency_record[LT_SAVECOUNT];
diff --git a/include/linux/sem.h b/include/linux/sem.h
index 1feb2de2ee57..10d6b226afc5 100644
--- a/include/linux/sem.h
+++ b/include/linux/sem.h
@@ -83,13 +83,6 @@ struct  seminfo {
 struct task_struct;
-/* One semaphore structure for each semaphore in the system. */
-struct sem {
-        int     semval;         /* current value */
-        int     sempid;         /* pid of last operation */
-        struct list_head sem_pending; /* pending single-sop operations */
-};
 /* One sem_array data structure for each set of semaphores in the system. */
 struct sem_array {
        struct kern_ipc_perm    ____cacheline_aligned_in_smp
@@ -103,51 +96,21 @@ struct sem_array {
        int                     complex_count;  /* pending complex operations */
 };
-/* One queue for each sleeping process in the system. */
+#ifdef CONFIG_SYSVIPC
-struct sem_queue {
-        struct list_head        simple_list; /* queue of pending operations */
-        struct list_head        list;    /* queue of pending operations */
-        struct task_struct      *sleeper; /* this process */
-        struct sem_undo         *undo;   /* undo structure */
-        int                     pid;     /* process id of requesting process */
-        int                     status;  /* completion status of operation */
-        struct sembuf           *sops;   /* array of pending operations */
-        int                     nsops;   /* number of operations */
-        int                     alter;   /* does the operation alter the array? */
-};
-/* Each task has a list of undo requests. They are executed automatically
- * when the process exits.
- */
-struct sem_undo {
-        struct list_head        list_proc;      /* per-process list: all undos from one process. */
-                                                /* rcu protected */
-        struct rcu_head         rcu;            /* rcu struct for sem_undo() */
-        struct sem_undo_list    *ulp;           /* sem_undo_list for the process */
-        struct list_head        list_id;        /* per semaphore array list: all undos for one array */
-        int                     semid;          /* semaphore set identifier */
-        short *                 semadj;         /* array of adjustments, one per semaphore */
-};
-/* sem_undo_list controls shared access to the list of sem_undo structures
- * that may be shared among all a CLONE_SYSVSEM task group.
- */ 
-struct sem_undo_list {
-        atomic_t                refcnt;
-        spinlock_t              lock;
-        struct list_head        list_proc;
-};
 struct sysv_sem {
        struct sem_undo_list *undo_list;
 };
-#ifdef CONFIG_SYSVIPC
 extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
 extern void exit_sem(struct task_struct *tsk);
 #else
+struct sysv_sem {
+        /* empty */
+};
 static inline int copy_semundo(unsigned long clone_flags, struct task_struct *tsk)
 {
        return 0;
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index 8bffe9ae2ca0..0efa1f10bc2b 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -131,8 +131,6 @@ struct plat_sci_port {
        struct plat_sci_port_ops        *ops;
-        struct device   *dma_dev;
        unsigned int    dma_slave_tx;
        unsigned int    dma_slave_rx;
 };
diff --git a/include/linux/serio.h b/include/linux/serio.h
index be7dfb0f12d0..ca82861b0e46 100644
--- a/include/linux/serio.h
+++ b/include/linux/serio.h
@@ -79,19 +79,21 @@ void serio_reconnect(struct serio *serio);
 irqreturn_t serio_interrupt(struct serio *serio, unsigned char data, unsigned int flags);
 void __serio_register_port(struct serio *serio, struct module *owner);
-static inline void serio_register_port(struct serio *serio)
-{
+/* use a define to avoid include chaining to get THIS_MODULE */
-        __serio_register_port(serio, THIS_MODULE);
+#define serio_register_port(serio) \
-}
+        __serio_register_port(serio, THIS_MODULE)
 void serio_unregister_port(struct serio *serio);
 void serio_unregister_child_port(struct serio *serio);
-int __serio_register_driver(struct serio_driver *drv, struct module *owner, const char *mod_name);
+int __must_check __serio_register_driver(struct serio_driver *drv,
-static inline int __must_check serio_register_driver(struct serio_driver *drv)
+                                struct module *owner, const char *mod_name);
-{
-        return __serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME);
+/* use a define to avoid include chaining to get THIS_MODULE & friends */
-}
+#define serio_register_driver(drv) \
+        __serio_register_driver(drv, THIS_MODULE, KBUILD_MODNAME)
 void serio_unregister_driver(struct serio_driver *drv);
 static inline int serio_write(struct serio *serio, unsigned char data)
diff --git a/include/linux/sh_pfc.h b/include/linux/sh_pfc.h
index 30cae70874f4..bc8c9208f7e2 100644
--- a/include/linux/sh_pfc.h
+++ b/include/linux/sh_pfc.h
@@ -61,6 +61,14 @@ struct pinmux_data_reg {
        .reg = r, .reg_width = r_width, \
        .enum_ids = (pinmux_enum_t [r_width]) \
+struct pinmux_irq {
+        int irq;
+        pinmux_enum_t *enum_ids;
+};
+#define PINMUX_IRQ(irq_nr, ids...)                         \
+        { .irq = irq_nr, .enum_ids = (pinmux_enum_t []) { ids, 0 } }    \
 struct pinmux_range {
        pinmux_enum_t begin;
        pinmux_enum_t end;
@@ -87,7 +95,9 @@ struct pinmux_info {
        pinmux_enum_t *gpio_data;
        unsigned int gpio_data_size;
-        unsigned long *gpio_in_use;
+        struct pinmux_irq *gpio_irq;
+        unsigned int gpio_irq_size;
        struct gpio_chip chip;
 };
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 6a6b352326d7..fe864885c1ed 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -1806,12 +1806,12 @@ static inline void skb_frag_set_page(struct sk_buff *skb, int f,
 /**
 * skb_frag_dma_map - maps a paged fragment via the DMA API
- * @device: the device to map the fragment to
+ * @dev: the device to map the fragment to
 * @frag: the paged fragment to map
 * @offset: the offset within the fragment (starting at the
 *          fragment's own offset)
 * @size: the number of bytes to map
- * @direction: the direction of the mapping (%PCI_DMA_*)
+ * @dir: the direction of the mapping (%PCI_DMA_*)
 *
 * Maps the page associated with @frag to @device.
 */
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index f10ed7b4a714..061e560251b4 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -231,10 +231,9 @@ struct ssb_driver {
 #define drv_to_ssb_drv(_drv) container_of(_drv, struct ssb_driver, drv)
 extern int __ssb_driver_register(struct ssb_driver *drv, struct module *owner);
-static inline int ssb_driver_register(struct ssb_driver *drv)
+#define ssb_driver_register(drv) \
-{
+        __ssb_driver_register(drv, THIS_MODULE)
-        return __ssb_driver_register(drv, THIS_MODULE);
-}
 extern void ssb_driver_unregister(struct ssb_driver *drv);
diff --git a/include/linux/stop_machine.h b/include/linux/stop_machine.h
index 2d04ea916760..c170edc3bf5f 100644
--- a/include/linux/stop_machine.h
+++ b/include/linux/stop_machine.h
@@ -3,6 +3,7 @@
 #include <linux/cpu.h>
 #include <linux/cpumask.h>
+#include <linux/smp.h>
 #include <linux/list.h>
 #include <asm/system.h>
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 492486a74484..3d8f9c44e27d 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -136,6 +136,8 @@ void		rpc_shutdown_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
 void            rpc_task_release_client(struct rpc_task *);
+int             rpcb_create_local(void);
+void            rpcb_put_local(void);
 int             rpcb_register(u32, u32, int, unsigned short);
 int             rpcb_v4_register(const u32 program, const u32 version,
                                 const struct sockaddr *address,
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index d8d5d93071b3..35b37b1e9299 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -413,6 +413,7 @@ struct svc_procedure {
 /*
 * Function prototypes.
 */
+void svc_rpcb_cleanup(struct svc_serv *serv);
 struct svc_serv *svc_create(struct svc_program *, unsigned int,
                            void (*shutdown)(struct svc_serv *));
 struct svc_rqst *svc_prepare_thread(struct svc_serv *serv,
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index 7ad9751a0d87..8620f79658d4 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -8,7 +8,8 @@
 #define SUNRPC_SVC_XPRT_H
 #include <linux/sunrpc/svc.h>
-#include <linux/module.h>
+struct module;
 struct svc_xprt_ops {
        struct svc_xprt *(*xpo_create)(struct svc_serv *,
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 9a1ec10fd504..703cfa33a3ca 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -931,6 +931,7 @@ enum
 #ifdef __KERNEL__
 #include <linux/list.h>
 #include <linux/rcupdate.h>
+#include <linux/wait.h>
 /* For the /proc/sys support */
 struct ctl_table;
@@ -1011,6 +1012,26 @@ extern int proc_do_large_bitmap(struct ctl_table *, int,
 * cover common cases.
 */
+/* Support for userspace poll() to watch for changes */
+struct ctl_table_poll {
+        atomic_t event;
+        wait_queue_head_t wait;
+};
+static inline void *proc_sys_poll_event(struct ctl_table_poll *poll)
+{
+        return (void *)(unsigned long)atomic_read(&poll->event);
+}
+void proc_sys_poll_notify(struct ctl_table_poll *poll);
+#define __CTL_TABLE_POLL_INITIALIZER(name) {                            \
+        .event = ATOMIC_INIT(0),                                        \
+        .wait = __WAIT_QUEUE_HEAD_INITIALIZER(name.wait) }
+#define DEFINE_CTL_TABLE_POLL(name)                                     \
+        struct ctl_table_poll name = __CTL_TABLE_POLL_INITIALIZER(name)
 /* A sysctl table is an array of struct ctl_table: */
 struct ctl_table 
 {
@@ -1021,6 +1042,7 @@ struct ctl_table
        struct ctl_table *child;
        struct ctl_table *parent;       /* Automatically set */
        proc_handler *proc_handler;     /* Callback for text formatting */
+        struct ctl_table_poll *poll;
        void *extra1;
        void *extra2;
 };
diff --git a/include/linux/sysdev.h b/include/linux/sysdev.h
index d35e783a598c..20f63d3e6144 100644
--- a/include/linux/sysdev.h
+++ b/include/linux/sysdev.h
@@ -22,7 +22,6 @@
 #define _SYSDEV_H_
 #include <linux/kobject.h>
-#include <linux/module.h>
 #include <linux/pm.h>
diff --git a/include/linux/textsearch.h b/include/linux/textsearch.h
index d9a85d616385..cfaee869146f 100644
--- a/include/linux/textsearch.h
+++ b/include/linux/textsearch.h
@@ -4,10 +4,11 @@
 #include <linux/types.h>
 #include <linux/list.h>
 #include <linux/kernel.h>
-#include <linux/module.h>
 #include <linux/err.h>
 #include <linux/slab.h>
+struct module;
 struct ts_config;
 #define TS_AUTOLOAD     1 /* Automatically load textsearch modules when needed */
diff --git a/include/linux/topology.h b/include/linux/topology.h
index fc839bfa7935..e26db031303b 100644
--- a/include/linux/topology.h
+++ b/include/linux/topology.h
@@ -201,6 +201,10 @@ int arch_update_cpu_topology(void);
        .balance_interval       = 64,                                   \
 }
+#ifndef SD_NODES_PER_DOMAIN
+#define SD_NODES_PER_DOMAIN 16
+#endif
 #ifdef CONFIG_SCHED_BOOK
 #ifndef SD_BOOK_INIT
 #error Please define an appropriate SD_BOOK_INIT in include/asm/topology.h!!!
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index fd99ff9298c6..1ad4724458de 100644
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -14,10 +14,10 @@
 #ifndef _UIO_DRIVER_H_
 #define _UIO_DRIVER_H_
-#include <linux/module.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
+struct module;
 struct uio_map;
 /**
@@ -101,11 +101,11 @@ extern int __must_check
        __uio_register_device(struct module *owner,
                              struct device *parent,
                              struct uio_info *info);
-static inline int __must_check
-        uio_register_device(struct device *parent, struct uio_info *info)
+/* use a define to avoid include chaining to get THIS_MODULE */
-{
+#define uio_register_device(parent, info) \
-        return __uio_register_device(THIS_MODULE, parent, info);
+        __uio_register_device(THIS_MODULE, parent, info)
-}
 extern void uio_unregister_device(struct uio_info *info);
 extern void uio_event_notify(struct uio_info *info);
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 6f49a1b39fa6..d3d0c1374334 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -946,10 +946,11 @@ struct usb_class_driver {
 */
 extern int usb_register_driver(struct usb_driver *, struct module *,
                               const char *);
-static inline int usb_register(struct usb_driver *driver)
-{
+/* use a define to avoid include chaining to get THIS_MODULE & friends */
-        return usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME);
+#define usb_register(driver) \
-}
+        usb_register_driver(driver, THIS_MODULE, KBUILD_MODNAME)
 extern void usb_deregister(struct usb_driver *);
 extern int usb_register_device_driver(struct usb_device_driver *,
diff --git a/include/linux/utsname.h b/include/linux/utsname.h
index 4e5b0213fdc1..c714ed75eae2 100644
--- a/include/linux/utsname.h
+++ b/include/linux/utsname.h
@@ -37,6 +37,14 @@ struct new_utsname {
 #include <linux/nsproxy.h>
 #include <linux/err.h>
+enum uts_proc {
+        UTS_PROC_OSTYPE,
+        UTS_PROC_OSRELEASE,
+        UTS_PROC_VERSION,
+        UTS_PROC_HOSTNAME,
+        UTS_PROC_DOMAINNAME,
+};
 struct user_namespace;
 extern struct user_namespace init_user_ns;
@@ -80,6 +88,14 @@ static inline struct uts_namespace *copy_utsname(unsigned long flags,
 }
 #endif
+#ifdef CONFIG_PROC_SYSCTL
+extern void uts_proc_notify(enum uts_proc proc);
+#else
+static inline void uts_proc_notify(enum uts_proc proc)
+{
+}
+#endif
 static inline struct new_utsname *utsname(void)
 {
        return &current->nsproxy->uts_ns->name;
diff --git a/include/linux/uwb.h b/include/linux/uwb.h
index b0c564ec2160..7dbbee9741b7 100644
--- a/include/linux/uwb.h
+++ b/include/linux/uwb.h
@@ -33,6 +33,7 @@
 #include <linux/wait.h>
 #include <linux/workqueue.h>
 #include <linux/uwb/spec.h>
+#include <asm/page.h>
 struct uwb_dev;
 struct uwb_beca_e;
diff --git a/include/linux/uwb/umc.h b/include/linux/uwb/umc.h
index 7b4842028ca7..891d1d5f3947 100644
--- a/include/linux/uwb/umc.h
+++ b/include/linux/uwb/umc.h
@@ -111,10 +111,9 @@ int __must_check __umc_driver_register(struct umc_driver *umc_drv,
 * umc_driver_register - register a UMC capabiltity driver.
 * @umc_drv:  pointer to the driver.
 */
-static inline int __must_check umc_driver_register(struct umc_driver *umc_drv)
+#define umc_driver_register(umc_drv) \
-{
+        __umc_driver_register(umc_drv, THIS_MODULE, KBUILD_MODNAME)
-        return __umc_driver_register(umc_drv, THIS_MODULE, KBUILD_MODNAME);
-}
 void umc_driver_unregister(struct umc_driver *umc_drv);
 /*
diff --git a/include/linux/vermagic.h b/include/linux/vermagic.h
index cf97b5b9d1fe..6f8fbcf10dfb 100644
--- a/include/linux/vermagic.h
+++ b/include/linux/vermagic.h
@@ -1,5 +1,4 @@
 #include <generated/utsrelease.h>
-#include <linux/module.h>
 /* Simply sanity version stamp for modules. */
 #ifdef CONFIG_SMP
diff --git a/include/linux/videodev2.h b/include/linux/videodev2.h
index 225560c1a10f..4b752d5ee80e 100644
--- a/include/linux/videodev2.h
+++ b/include/linux/videodev2.h
@@ -653,6 +653,10 @@ struct v4l2_buffer {
 #define V4L2_BUF_FLAG_ERROR     0x0040
 #define V4L2_BUF_FLAG_TIMECODE  0x0100  /* timecode field is valid */
 #define V4L2_BUF_FLAG_INPUT     0x0200  /* input field is valid */
+#define V4L2_BUF_FLAG_PREPARED  0x0400  /* Buffer is prepared for queuing */
+/* Cache handling flags */
+#define V4L2_BUF_FLAG_NO_CACHE_INVALIDATE       0x0800
+#define V4L2_BUF_FLAG_NO_CACHE_CLEAN            0x1000
 /*
 *      O V E R L A Y   P R E V I E W
@@ -1165,6 +1169,7 @@ enum v4l2_power_line_frequency {
        V4L2_CID_POWER_LINE_FREQUENCY_DISABLED  = 0,
        V4L2_CID_POWER_LINE_FREQUENCY_50HZ      = 1,
        V4L2_CID_POWER_LINE_FREQUENCY_60HZ      = 2,
+        V4L2_CID_POWER_LINE_FREQUENCY_AUTO      = 3,
 };
 #define V4L2_CID_HUE_AUTO                       (V4L2_CID_BASE+25)
 #define V4L2_CID_WHITE_BALANCE_TEMPERATURE      (V4L2_CID_BASE+26)
@@ -2138,6 +2143,23 @@ struct v4l2_dbg_chip_ident {
        __u32 revision;    /* chip revision, chip specific */
 } __attribute__ ((packed));
+/**
+ * struct v4l2_create_buffers - VIDIOC_CREATE_BUFS argument
+ * @index:      on return, index of the first created buffer
+ * @count:      entry: number of requested buffers,
+ *              return: number of created buffers
+ * @memory:     buffer memory type
+ * @format:     frame format, for which buffers are requested
+ * @reserved:   future extensions
+ */
+struct v4l2_create_buffers {
+        __u32                   index;
+        __u32                   count;
+        enum v4l2_memory        memory;
+        struct v4l2_format      format;
+        __u32                   reserved[8];
+};
 /*
 *      I O C T L   C O D E S   F O R   V I D E O   D E V I C E S
 *
@@ -2228,6 +2250,11 @@ struct v4l2_dbg_chip_ident {
 #define VIDIOC_SUBSCRIBE_EVENT   _IOW('V', 90, struct v4l2_event_subscription)
 #define VIDIOC_UNSUBSCRIBE_EVENT _IOW('V', 91, struct v4l2_event_subscription)
+/* Experimental, the below two ioctls may change over the next couple of kernel
+   versions */
+#define VIDIOC_CREATE_BUFS      _IOWR('V', 92, struct v4l2_create_buffers)
+#define VIDIOC_PREPARE_BUF      _IOWR('V', 93, struct v4l2_buffer)
 /* Reminder: when adding new ioctls please add support for them to
   drivers/media/video/v4l2-compat-ioctl32.c as well! */
diff --git a/include/linux/virtio.h b/include/linux/virtio.h
index 851ebf1a4476..4c069d8bd740 100644
--- a/include/linux/virtio.h
+++ b/include/linux/virtio.h
@@ -131,10 +131,10 @@ void unregister_virtio_device(struct virtio_device *dev);
 * virtio_driver - operations for a virtio I/O driver
 * @driver: underlying device driver (populate name and owner).
 * @id_table: the ids serviced by this driver.
- * @feature_table: an array of feature numbers supported by this device.
+ * @feature_table: an array of feature numbers supported by this driver.
 * @feature_table_size: number of entries in the feature table array.
 * @probe: the function to call when a device is found.  Returns 0 or -errno.
- * @remove: the function when a device is removed.
+ * @remove: the function to call when a device is removed.
 * @config_changed: optional function to call when the device configuration
 *    changes; may be called in interrupt context.
 */
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 39c88c5ad19d..add4790b21fe 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -155,6 +155,9 @@ static inline bool virtio_has_feature(const struct virtio_device *vdev,
 #define virtio_config_val(vdev, fbit, offset, v) \
        virtio_config_buf((vdev), (fbit), (offset), (v), sizeof(*v))
+#define virtio_config_val_len(vdev, fbit, offset, v, len) \
+        virtio_config_buf((vdev), (fbit), (offset), (v), (len))
 static inline int virtio_config_buf(struct virtio_device *vdev,
                                    unsigned int fbit,
                                    unsigned int offset,
diff --git a/include/linux/virtio_mmio.h b/include/linux/virtio_mmio.h
new file mode 100644
index 000000000000..27c7edefbc86
--- /dev/null
+++ b/include/linux/virtio_mmio.h
@@ -0,0 +1,111 @@
+/*
+ * Virtio platform device driver
+ *
+ * Copyright 2011, ARM Ltd.
+ *
+ * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
+ *
+ * This header is BSD licensed so anyone can use the definitions to implement
+ * compatible drivers/servers.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of IBM nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+#ifndef _LINUX_VIRTIO_MMIO_H
+#define _LINUX_VIRTIO_MMIO_H
+/*
+ * Control registers
+ */
+/* Magic value ("virt" string) - Read Only */
+#define VIRTIO_MMIO_MAGIC_VALUE         0x000
+/* Virtio device version - Read Only */
+#define VIRTIO_MMIO_VERSION             0x004
+/* Virtio device ID - Read Only */
+#define VIRTIO_MMIO_DEVICE_ID           0x008
+/* Virtio vendor ID - Read Only */
+#define VIRTIO_MMIO_VENDOR_ID           0x00c
+/* Bitmask of the features supported by the host
+ * (32 bits per set) - Read Only */
+#define VIRTIO_MMIO_HOST_FEATURES       0x010
+/* Host features set selector - Write Only */
+#define VIRTIO_MMIO_HOST_FEATURES_SEL   0x014
+/* Bitmask of features activated by the guest
+ * (32 bits per set) - Write Only */
+#define VIRTIO_MMIO_GUEST_FEATURES      0x020
+/* Activated features set selector - Write Only */
+#define VIRTIO_MMIO_GUEST_FEATURES_SET  0x024
+/* Guest's memory page size in bytes - Write Only */
+#define VIRTIO_MMIO_GUEST_PAGE_SIZE     0x028
+/* Queue selector - Write Only */
+#define VIRTIO_MMIO_QUEUE_SEL           0x030
+/* Maximum size of the currently selected queue - Read Only */
+#define VIRTIO_MMIO_QUEUE_NUM_MAX       0x034
+/* Queue size for the currently selected queue - Write Only */
+#define VIRTIO_MMIO_QUEUE_NUM           0x038
+/* Used Ring alignment for the currently selected queue - Write Only */
+#define VIRTIO_MMIO_QUEUE_ALIGN         0x03c
+/* Guest's PFN for the currently selected queue - Read Write */
+#define VIRTIO_MMIO_QUEUE_PFN           0x040
+/* Queue notifier - Write Only */
+#define VIRTIO_MMIO_QUEUE_NOTIFY        0x050
+/* Interrupt status - Read Only */
+#define VIRTIO_MMIO_INTERRUPT_STATUS    0x060
+/* Interrupt acknowledge - Write Only */
+#define VIRTIO_MMIO_INTERRUPT_ACK       0x064
+/* Device status register - Read Write */
+#define VIRTIO_MMIO_STATUS              0x070
+/* The config space is defined by each driver as
+ * the per-driver configuration space - Read Write */
+#define VIRTIO_MMIO_CONFIG              0x100
+/*
+ * Interrupt flags (re: interrupt status & acknowledge registers)
+ */
+#define VIRTIO_MMIO_INT_VRING           (1 << 0)
+#define VIRTIO_MMIO_INT_CONFIG          (1 << 1)
+#endif
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index 4a32cb6da425..36be0f6e18a9 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -135,13 +135,13 @@ static inline void vring_init(struct vring *vr, unsigned int num, void *p,
        vr->num = num;
        vr->desc = p;
        vr->avail = p + num*sizeof(struct vring_desc);
-        vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + align-1)
+        vr->used = (void *)(((unsigned long)&vr->avail->ring[num] + sizeof(__u16)
-                            & ~(align - 1));
+                + align-1) & ~(align - 1));
 }
 static inline unsigned vring_size(unsigned int num, unsigned long align)
 {
-        return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (2 + num)
+        return ((sizeof(struct vring_desc) * num + sizeof(__u16) * (3 + num)
                 + align - 1) & ~(align - 1))
                + sizeof(__u16) * 3 + sizeof(struct vring_used_elem) * num;
 }
diff --git a/include/linux/vlynq.h b/include/linux/vlynq.h
index 8f6a95882b09..017d4a53d55e 100644
--- a/include/linux/vlynq.h
+++ b/include/linux/vlynq.h
@@ -20,9 +20,10 @@
 #define __VLYNQ_H__
 #include <linux/device.h>
-#include <linux/module.h>
 #include <linux/types.h>
+struct module;
 #define VLYNQ_NUM_IRQS 32
 struct vlynq_mapping {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 2b8963ff0f35..a378c295851f 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -39,6 +39,23 @@ enum writeback_sync_modes {
 };
 /*
+ * why some writeback work was initiated
+ */
+enum wb_reason {
+        WB_REASON_BACKGROUND,
+        WB_REASON_TRY_TO_FREE_PAGES,
+        WB_REASON_SYNC,
+        WB_REASON_PERIODIC,
+        WB_REASON_LAPTOP_TIMER,
+        WB_REASON_FREE_MORE_MEM,
+        WB_REASON_FS_FREE_SPACE,
+        WB_REASON_FORKER_THREAD,
+        WB_REASON_MAX,
+};
+extern const char *wb_reason_name[];
+/*
 * A control structure which tells the writeback code what to do.  These are
 * always on the stack, and hence need no locking.  They are always initialised
 * in a manner such that unspecified fields are set to zero.
@@ -69,14 +86,17 @@ struct writeback_control {
 */     
 struct bdi_writeback;
 int inode_wait(void *);
-void writeback_inodes_sb(struct super_block *);
+void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
-void writeback_inodes_sb_nr(struct super_block *, unsigned long nr);
+void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
-int writeback_inodes_sb_if_idle(struct super_block *);
+                                                        enum wb_reason reason);
-int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr);
+int writeback_inodes_sb_if_idle(struct super_block *, enum wb_reason reason);
+int writeback_inodes_sb_nr_if_idle(struct super_block *, unsigned long nr,
+                                                        enum wb_reason reason);
 void sync_inodes_sb(struct super_block *);
-long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages);
+long writeback_inodes_wb(struct bdi_writeback *wb, long nr_pages,
+                                enum wb_reason reason);
 long wb_do_writeback(struct bdi_writeback *wb, int force_wait);
-void wakeup_flusher_threads(long nr_pages);
+void wakeup_flusher_threads(long nr_pages, enum wb_reason reason);
 /* writeback.h requires fs.h; it, too, is not included from here. */
 static inline void wait_on_inode(struct inode *inode)
@@ -143,6 +163,7 @@ unsigned long bdi_dirty_limit(struct backing_dev_info *bdi,
 void __bdi_update_bandwidth(struct backing_dev_info *bdi,
                            unsigned long thresh,
+                            unsigned long bg_thresh,
                            unsigned long dirty,
                            unsigned long bdi_thresh,
                            unsigned long bdi_dirty,
diff --git a/include/media/ov772x.h b/include/media/ov772x.h
index 548bf1155c83..00dbb7c4feae 100644
--- a/include/media/ov772x.h
+++ b/include/media/ov772x.h
@@ -12,12 +12,9 @@
 #ifndef __OV772X_H__
 #define __OV772X_H__
-#include <media/soc_camera.h>
 /* for flags */
 #define OV772X_FLAG_VFLIP       (1 << 0) /* Vertical flip image */
 #define OV772X_FLAG_HFLIP       (1 << 1) /* Horizontal flip image */
-#define OV772X_FLAG_8BIT        (1 << 2) /* default 10 bit */
 /*
 * for Edge ctrl
@@ -32,22 +29,23 @@ struct ov772x_edge_ctrl {
        unsigned char lower;
 };
-#define OV772X_MANUAL_EDGE_CTRL 0x80 /* un-used bit of strength */
+#define OV772X_MANUAL_EDGE_CTRL         0x80 /* un-used bit of strength */
-#define EDGE_STRENGTH_MASK      0x1F
+#define OV772X_EDGE_STRENGTH_MASK       0x1F
-#define EDGE_THRESHOLD_MASK     0x0F
+#define OV772X_EDGE_THRESHOLD_MASK      0x0F
-#define EDGE_UPPER_MASK         0xFF
+#define OV772X_EDGE_UPPER_MASK          0xFF
-#define EDGE_LOWER_MASK         0xFF
+#define OV772X_EDGE_LOWER_MASK          0xFF
 #define OV772X_AUTO_EDGECTRL(u, l)      \
 {                                       \
-        .upper = (u & EDGE_UPPER_MASK), \
+        .upper = (u & OV772X_EDGE_UPPER_MASK),  \
-        .lower = (l & EDGE_LOWER_MASK), \
+        .lower = (l & OV772X_EDGE_LOWER_MASK),  \
 }
-#define OV772X_MANUAL_EDGECTRL(s, t)                                    \
+#define OV772X_MANUAL_EDGECTRL(s, t)                    \
-{                                                                       \
+{                                                       \
-        .strength  = (s & EDGE_STRENGTH_MASK) | OV772X_MANUAL_EDGE_CTRL,\
+        .strength  = (s & OV772X_EDGE_STRENGTH_MASK) |  \
-        .threshold = (t & EDGE_THRESHOLD_MASK),                         \
+                        OV772X_MANUAL_EDGE_CTRL,        \
+        .threshold = (t & OV772X_EDGE_THRESHOLD_MASK),  \
 }
 /*
diff --git a/include/media/s5k6aa.h b/include/media/s5k6aa.h
new file mode 100644
index 000000000000..ba34f7055e55
--- /dev/null
+++ b/include/media/s5k6aa.h
@@ -0,0 +1,51 @@
+/*
+ * S5K6AAFX camera sensor driver header
+ *
+ * Copyright (C) 2011 Samsung Electronics Co., Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+#ifndef S5K6AA_H
+#define S5K6AA_H
+#include <media/v4l2-mediabus.h>
+/**
+ * struct s5k6aa_gpio - data structure describing a GPIO
+ * @gpio:  GPIO number
+ * @level: indicates active state of the @gpio
+ */
+struct s5k6aa_gpio {
+        int gpio;
+        int level;
+};
+/**
+ * struct s5k6aa_platform_data - s5k6aa driver platform data
+ * @set_power:   an additional callback to the board code, called
+ *               after enabling the regulators and before switching
+ *               the sensor off
+ * @mclk_frequency: sensor's master clock frequency in Hz
+ * @gpio_reset:  GPIO driving RESET pin
+ * @gpio_stby:   GPIO driving STBY pin
+ * @nlanes:      maximum number of MIPI-CSI lanes used
+ * @horiz_flip:  default horizontal image flip value, non zero to enable
+ * @vert_flip:   default vertical image flip value, non zero to enable
+ */
+struct s5k6aa_platform_data {
+        int (*set_power)(int enable);
+        unsigned long mclk_frequency;
+        struct s5k6aa_gpio gpio_reset;
+        struct s5k6aa_gpio gpio_stby;
+        enum v4l2_mbus_type bus_type;
+        u8 nlanes;
+        u8 horiz_flip;
+        u8 vert_flip;
+};
+#endif /* S5K6AA_H */
diff --git a/include/media/saa7146.h b/include/media/saa7146.h
index 5017500eda1b..0f037e8edf9a 100644
--- a/include/media/saa7146.h
+++ b/include/media/saa7146.h
@@ -1,7 +1,6 @@
 #ifndef __SAA7146__
 #define __SAA7146__
-#include <linux/module.h>       /* for module-version */
 #include <linux/delay.h>        /* for delay-stuff */
 #include <linux/slab.h>         /* for kmalloc/kfree */
 #include <linux/pci.h>          /* for pci-config-stuff, vendor ids etc. */
@@ -55,6 +54,8 @@ do {									\
 #define SAA7146_ISR_CLEAR(x,y) \
        saa7146_write(x, ISR, (y));
+struct module;
 struct saa7146_dev;
 struct saa7146_extension;
 struct saa7146_vv;
diff --git a/include/media/soc_camera.h b/include/media/soc_camera.h
index 7582952dceae..b1377b931eb7 100644
--- a/include/media/soc_camera.h
+++ b/include/media/soc_camera.h
@@ -12,12 +12,14 @@
 #ifndef SOC_CAMERA_H
 #define SOC_CAMERA_H
+#include <linux/bitops.h>
 #include <linux/device.h>
 #include <linux/mutex.h>
 #include <linux/pm.h>
 #include <linux/videodev2.h>
 #include <media/videobuf-core.h>
 #include <media/videobuf2-core.h>
+#include <media/v4l2-ctrls.h>
 #include <media/v4l2-device.h>
 struct file;
@@ -37,8 +39,8 @@ struct soc_camera_device {
        unsigned char iface;            /* Host number */
        unsigned char devnum;           /* Device number per host */
        struct soc_camera_sense *sense; /* See comment in struct definition */
-        struct soc_camera_ops *ops;
        struct video_device *vdev;
+        struct v4l2_ctrl_handler ctrl_handler;
        const struct soc_camera_format_xlate *current_fmt;
        struct soc_camera_format_xlate *user_formats;
        int num_user_formats;
@@ -93,14 +95,10 @@ struct soc_camera_host_ops {
        int (*reqbufs)(struct soc_camera_device *, struct v4l2_requestbuffers *);
        int (*querycap)(struct soc_camera_host *, struct v4l2_capability *);
        int (*set_bus_param)(struct soc_camera_device *, __u32);
-        int (*get_ctrl)(struct soc_camera_device *, struct v4l2_control *);
-        int (*set_ctrl)(struct soc_camera_device *, struct v4l2_control *);
        int (*get_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
        int (*set_parm)(struct soc_camera_device *, struct v4l2_streamparm *);
        int (*enum_fsizes)(struct soc_camera_device *, struct v4l2_frmsizeenum *);
        unsigned int (*poll)(struct file *, poll_table *);
-        const struct v4l2_queryctrl *controls;
-        int num_controls;
 };
 #define SOCAM_SENSOR_INVERT_PCLK        (1 << 0)
@@ -193,13 +191,6 @@ struct soc_camera_format_xlate {
        const struct soc_mbus_pixelfmt *host_fmt;
 };
-struct soc_camera_ops {
-        unsigned long (*query_bus_param)(struct soc_camera_device *);
-        int (*set_bus_param)(struct soc_camera_device *, unsigned long);
-        const struct v4l2_queryctrl *controls;
-        int num_controls;
-};
 #define SOCAM_SENSE_PCLK_CHANGED        (1 << 0)
 /**
@@ -226,65 +217,18 @@ struct soc_camera_sense {
        unsigned long pixel_clock;
 };
-static inline struct v4l2_queryctrl const *soc_camera_find_qctrl(
+#define SOCAM_DATAWIDTH(x)      BIT((x) - 1)
-        struct soc_camera_ops *ops, int id)
+#define SOCAM_DATAWIDTH_4       SOCAM_DATAWIDTH(4)
-{
+#define SOCAM_DATAWIDTH_8       SOCAM_DATAWIDTH(8)
-        int i;
+#define SOCAM_DATAWIDTH_9       SOCAM_DATAWIDTH(9)
+#define SOCAM_DATAWIDTH_10      SOCAM_DATAWIDTH(10)
-        for (i = 0; i < ops->num_controls; i++)
+#define SOCAM_DATAWIDTH_15      SOCAM_DATAWIDTH(15)
-                if (ops->controls[i].id == id)
+#define SOCAM_DATAWIDTH_16      SOCAM_DATAWIDTH(16)
-                        return &ops->controls[i];
-        return NULL;
-}
-#define SOCAM_MASTER                    (1 << 0)
-#define SOCAM_SLAVE                     (1 << 1)
-#define SOCAM_HSYNC_ACTIVE_HIGH         (1 << 2)
-#define SOCAM_HSYNC_ACTIVE_LOW          (1 << 3)
-#define SOCAM_VSYNC_ACTIVE_HIGH         (1 << 4)
-#define SOCAM_VSYNC_ACTIVE_LOW          (1 << 5)
-#define SOCAM_DATAWIDTH_4               (1 << 6)
-#define SOCAM_DATAWIDTH_8               (1 << 7)
-#define SOCAM_DATAWIDTH_9               (1 << 8)
-#define SOCAM_DATAWIDTH_10              (1 << 9)
-#define SOCAM_DATAWIDTH_15              (1 << 10)
-#define SOCAM_DATAWIDTH_16              (1 << 11)
-#define SOCAM_PCLK_SAMPLE_RISING        (1 << 12)
-#define SOCAM_PCLK_SAMPLE_FALLING       (1 << 13)
-#define SOCAM_DATA_ACTIVE_HIGH          (1 << 14)
-#define SOCAM_DATA_ACTIVE_LOW           (1 << 15)
-#define SOCAM_MIPI_1LANE                (1 << 16)
-#define SOCAM_MIPI_2LANE                (1 << 17)
-#define SOCAM_MIPI_3LANE                (1 << 18)
-#define SOCAM_MIPI_4LANE                (1 << 19)
-#define SOCAM_MIPI      (SOCAM_MIPI_1LANE | SOCAM_MIPI_2LANE | \
-                        SOCAM_MIPI_3LANE | SOCAM_MIPI_4LANE)
 #define SOCAM_DATAWIDTH_MASK (SOCAM_DATAWIDTH_4 | SOCAM_DATAWIDTH_8 | \
                              SOCAM_DATAWIDTH_9 | SOCAM_DATAWIDTH_10 | \
                              SOCAM_DATAWIDTH_15 | SOCAM_DATAWIDTH_16)
-static inline unsigned long soc_camera_bus_param_compatible(
-                        unsigned long camera_flags, unsigned long bus_flags)
-{
-        unsigned long common_flags, hsync, vsync, pclk, data, buswidth, mode;
-        unsigned long mipi;
-        common_flags = camera_flags & bus_flags;
-        hsync = common_flags & (SOCAM_HSYNC_ACTIVE_HIGH | SOCAM_HSYNC_ACTIVE_LOW);
-        vsync = common_flags & (SOCAM_VSYNC_ACTIVE_HIGH | SOCAM_VSYNC_ACTIVE_LOW);
-        pclk = common_flags & (SOCAM_PCLK_SAMPLE_RISING | SOCAM_PCLK_SAMPLE_FALLING);
-        data = common_flags & (SOCAM_DATA_ACTIVE_HIGH | SOCAM_DATA_ACTIVE_LOW);
-        mode = common_flags & (SOCAM_MASTER | SOCAM_SLAVE);
-        buswidth = common_flags & SOCAM_DATAWIDTH_MASK;
-        mipi = common_flags & SOCAM_MIPI;
-        return ((!hsync || !vsync || !pclk || !data || !mode || !buswidth) && !mipi) ? 0 :
-                common_flags;
-}
 static inline void soc_camera_limit_side(int *start, int *length,
                unsigned int start_min,
                unsigned int length_min, unsigned int length_max)
@@ -300,23 +244,37 @@ static inline void soc_camera_limit_side(int *start, int *length,
                *start = start_min + length_max - *length;
 }
-extern unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
+unsigned long soc_camera_apply_sensor_flags(struct soc_camera_link *icl,
-                                                   unsigned long flags);
+                                            unsigned long flags);
+unsigned long soc_camera_apply_board_flags(struct soc_camera_link *icl,
+                                           const struct v4l2_mbus_config *cfg);
 /* This is only temporary here - until v4l2-subdev begins to link to video_device */
 #include <linux/i2c.h>
-static inline struct video_device *soc_camera_i2c_to_vdev(struct i2c_client *client)
+static inline struct video_device *soc_camera_i2c_to_vdev(const struct i2c_client *client)
+{
+        struct v4l2_subdev *sd = i2c_get_clientdata(client);
+        struct soc_camera_device *icd = (struct soc_camera_device *)sd->grp_id;
+        return icd ? icd->vdev : NULL;
+}
+static inline struct soc_camera_link *soc_camera_i2c_to_link(const struct i2c_client *client)
+{
+        return client->dev.platform_data;
+}
+static inline struct v4l2_subdev *soc_camera_vdev_to_subdev(const struct video_device *vdev)
 {
-        struct soc_camera_device *icd = client->dev.platform_data;
+        struct soc_camera_device *icd = dev_get_drvdata(vdev->parent);
-        return icd->vdev;
+        return soc_camera_to_subdev(icd);
 }
-static inline struct soc_camera_device *soc_camera_from_vb2q(struct vb2_queue *vq)
+static inline struct soc_camera_device *soc_camera_from_vb2q(const struct vb2_queue *vq)
 {
        return container_of(vq, struct soc_camera_device, vb2_vidq);
 }
-static inline struct soc_camera_device *soc_camera_from_vbq(struct videobuf_queue *vq)
+static inline struct soc_camera_device *soc_camera_from_vbq(const struct videobuf_queue *vq)
 {
        return container_of(vq, struct soc_camera_device, vb_vidq);
 }
diff --git a/include/media/soc_camera_platform.h b/include/media/soc_camera_platform.h
index 74f0fa15ca47..8aa4200a0b1d 100644
--- a/include/media/soc_camera_platform.h
+++ b/include/media/soc_camera_platform.h
@@ -13,6 +13,7 @@
 #include <linux/videodev2.h>
 #include <media/soc_camera.h>
+#include <media/v4l2-mediabus.h>
 struct device;
@@ -20,7 +21,8 @@ struct soc_camera_platform_info {
        const char *format_name;
        unsigned long format_depth;
        struct v4l2_mbus_framefmt format;
-        unsigned long bus_param;
+        unsigned long mbus_param;
+        enum v4l2_mbus_type mbus_type;
        struct soc_camera_device *icd;
        int (*set_capture)(struct soc_camera_platform_info *info, int enable);
 };
diff --git a/include/media/soc_mediabus.h b/include/media/soc_mediabus.h
index fae432544b41..73f1e7eb60f3 100644
--- a/include/media/soc_mediabus.h
+++ b/include/media/soc_mediabus.h
@@ -82,5 +82,7 @@ const struct soc_mbus_pixelfmt *soc_mbus_get_fmtdesc(
 s32 soc_mbus_bytes_per_line(u32 width, const struct soc_mbus_pixelfmt *mf);
 int soc_mbus_samples_per_pixel(const struct soc_mbus_pixelfmt *mf,
                        unsigned int *numerator, unsigned int *denominator);
+unsigned int soc_mbus_config_compatible(const struct v4l2_mbus_config *cfg,
+                                        unsigned int flags);
 #endif
diff --git a/include/media/v4l2-int-device.h b/include/media/v4l2-int-device.h
index fbf585561570..e6aa2318367b 100644
--- a/include/media/v4l2-int-device.h
+++ b/include/media/v4l2-int-device.h
@@ -25,7 +25,6 @@
 #ifndef V4L2_INT_DEVICE_H
 #define V4L2_INT_DEVICE_H
-#include <linux/module.h>
 #include <media/v4l2-common.h>
 #define V4L2NAMESIZE 32
@@ -41,6 +40,8 @@ enum v4l2_int_type {
        v4l2_int_type_slave
 };
+struct module;
 struct v4l2_int_device;
 struct v4l2_int_master {
diff --git a/include/media/v4l2-ioctl.h b/include/media/v4l2-ioctl.h
index dd9f1e7b8ff7..4d1c74ad4c84 100644
--- a/include/media/v4l2-ioctl.h
+++ b/include/media/v4l2-ioctl.h
@@ -122,6 +122,8 @@ struct v4l2_ioctl_ops {
        int (*vidioc_qbuf)    (struct file *file, void *fh, struct v4l2_buffer *b);
        int (*vidioc_dqbuf)   (struct file *file, void *fh, struct v4l2_buffer *b);
+        int (*vidioc_create_bufs)(struct file *file, void *fh, struct v4l2_create_buffers *b);
+        int (*vidioc_prepare_buf)(struct file *file, void *fh, struct v4l2_buffer *b);
        int (*vidioc_overlay) (struct file *file, void *fh, unsigned int i);
        int (*vidioc_g_fbuf)   (struct file *file, void *fh,
diff --git a/include/media/v4l2-subdev.h b/include/media/v4l2-subdev.h
index 257da1a30f66..f0f3358d1b1b 100644
--- a/include/media/v4l2-subdev.h
+++ b/include/media/v4l2-subdev.h
@@ -158,6 +158,7 @@ struct v4l2_subdev_core_ops {
        int (*s_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
        int (*try_ext_ctrls)(struct v4l2_subdev *sd, struct v4l2_ext_controls *ctrls);
        int (*querymenu)(struct v4l2_subdev *sd, struct v4l2_querymenu *qm);
+        int (*g_std)(struct v4l2_subdev *sd, v4l2_std_id *norm);
        int (*s_std)(struct v4l2_subdev *sd, v4l2_std_id norm);
        long (*ioctl)(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
 #ifdef CONFIG_VIDEO_ADV_DEBUG
@@ -534,13 +535,13 @@ struct v4l2_subdev {
        void *dev_priv;
        void *host_priv;
        /* subdev device node */
-        struct video_device devnode;
+        struct video_device *devnode;
 };
 #define media_entity_to_v4l2_subdev(ent) \
        container_of(ent, struct v4l2_subdev, entity)
 #define vdev_to_v4l2_subdev(vdev) \
-        container_of(vdev, struct v4l2_subdev, devnode)
+        video_get_drvdata(vdev)
 /*
 * Used for storing subdev information per file handle
diff --git a/include/media/videobuf2-core.h b/include/media/videobuf2-core.h
index ea55c08eddfb..a15d1f1b319e 100644
--- a/include/media/videobuf2-core.h
+++ b/include/media/videobuf2-core.h
@@ -105,6 +105,7 @@ enum vb2_fileio_flags {
 /**
 * enum vb2_buffer_state - current video buffer state
 * @VB2_BUF_STATE_DEQUEUED:     buffer under userspace control
+ * @VB2_BUF_STATE_PREPARED:     buffer prepared in videobuf and by the driver
 * @VB2_BUF_STATE_QUEUED:       buffer queued in videobuf, but not in driver
 * @VB2_BUF_STATE_ACTIVE:       buffer queued in driver and possibly used
 *                              in a hardware operation
@@ -116,6 +117,7 @@ enum vb2_fileio_flags {
 */
 enum vb2_buffer_state {
        VB2_BUF_STATE_DEQUEUED,
+        VB2_BUF_STATE_PREPARED,
        VB2_BUF_STATE_QUEUED,
        VB2_BUF_STATE_ACTIVE,
        VB2_BUF_STATE_DONE,
@@ -167,13 +169,21 @@ struct vb2_buffer {
 /**
 * struct vb2_ops - driver-specific callbacks
 *
- * @queue_setup:        called from a VIDIOC_REQBUFS handler, before
+ * @queue_setup:        called from VIDIOC_REQBUFS and VIDIOC_CREATE_BUFS
- *                      memory allocation; driver should return the required
+ *                      handlers before memory allocation, or, if
- *                      number of buffers in num_buffers, the required number
+ *                      *num_planes != 0, after the allocation to verify a
- *                      of planes per buffer in num_planes; the size of each
+ *                      smaller number of buffers. Driver should return
- *                      plane should be set in the sizes[] array and optional
+ *                      the required number of buffers in *num_buffers, the
- *                      per-plane allocator specific context in alloc_ctxs[]
+ *                      required number of planes per buffer in *num_planes; the
- *                      array
+ *                      size of each plane should be set in the sizes[] array
+ *                      and optional per-plane allocator specific context in the
+ *                      alloc_ctxs[] array. When called from VIDIOC_REQBUFS,
+ *                      fmt == NULL, the driver has to use the currently
+ *                      configured format and *num_buffers is the total number
+ *                      of buffers, that are being allocated. When called from
+ *                      VIDIOC_CREATE_BUFS, fmt != NULL and it describes the
+ *                      target frame format. In this case *num_buffers are being
+ *                      allocated additionally to q->num_buffers.
 * @wait_prepare:       release any locks taken while calling vb2 functions;
 *                      it is called before an ioctl needs to wait for a new
 *                      buffer to arrive; required to avoid a deadlock in
@@ -186,11 +196,11 @@ struct vb2_buffer {
 *                      perform additional buffer-related initialization;
 *                      initialization failure (return != 0) will prevent
 *                      queue setup from completing successfully; optional
- * @buf_prepare:        called every time the buffer is queued from userspace;
+ * @buf_prepare:        called every time the buffer is queued from userspace
- *                      drivers may perform any initialization required before
+ *                      and from the VIDIOC_PREPARE_BUF ioctl; drivers may
- *                      each hardware operation in this callback;
+ *                      perform any initialization required before each hardware
- *                      if an error is returned, the buffer will not be queued
+ *                      operation in this callback; if an error is returned, the
- *                      in driver; optional
+ *                      buffer will not be queued in driver; optional
 * @buf_finish:         called before every dequeue of the buffer back to
 *                      userspace; drivers may perform any operations required
 *                      before userspace accesses the buffer; optional
@@ -216,9 +226,9 @@ struct vb2_buffer {
 *                      pre-queued buffers before calling STREAMON
 */
 struct vb2_ops {
-        int (*queue_setup)(struct vb2_queue *q, unsigned int *num_buffers,
+        int (*queue_setup)(struct vb2_queue *q, const struct v4l2_format *fmt,
-                           unsigned int *num_planes, unsigned int sizes[],
+                           unsigned int *num_buffers, unsigned int *num_planes,
-                           void *alloc_ctxs[]);
+                           unsigned int sizes[], void *alloc_ctxs[]);
        void (*wait_prepare)(struct vb2_queue *q);
        void (*wait_finish)(struct vb2_queue *q);
@@ -298,6 +308,9 @@ int vb2_wait_for_all_buffers(struct vb2_queue *q);
 int vb2_querybuf(struct vb2_queue *q, struct v4l2_buffer *b);
 int vb2_reqbufs(struct vb2_queue *q, struct v4l2_requestbuffers *req);
+int vb2_create_bufs(struct vb2_queue *q, struct v4l2_create_buffers *create);
+int vb2_prepare_buf(struct vb2_queue *q, struct v4l2_buffer *b);
 int vb2_queue_init(struct vb2_queue *q);
 void vb2_queue_release(struct vb2_queue *q);
@@ -309,6 +322,13 @@ int vb2_streamon(struct vb2_queue *q, enum v4l2_buf_type type);
 int vb2_streamoff(struct vb2_queue *q, enum v4l2_buf_type type);
 int vb2_mmap(struct vb2_queue *q, struct vm_area_struct *vma);
+#ifndef CONFIG_MMU
+unsigned long vb2_get_unmapped_area(struct vb2_queue *q,
+                                    unsigned long addr,
+                                    unsigned long len,
+                                    unsigned long pgoff,
+                                    unsigned long flags);
+#endif
 unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait);
 size_t vb2_read(struct vb2_queue *q, char __user *data, size_t count,
                loff_t *ppos, int nonblock);
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 5b924423cf20..3779ea362257 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -513,11 +513,15 @@ static inline void __hci_dev_put(struct hci_dev *d)
                d->destruct(d);
 }
-static inline void hci_dev_put(struct hci_dev *d)
+/*
-{
+ * hci_dev_put and hci_dev_hold are macros to avoid dragging all the
-        __hci_dev_put(d);
+ * overhead of all the modular infrastructure into this header.
-        module_put(d->owner);
+ */
-}
+#define hci_dev_put(d)          \
+do {                            \
+        __hci_dev_put(d);       \
+        module_put(d->owner);   \
+} while (0)
 static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
 {
@@ -525,12 +529,10 @@ static inline struct hci_dev *__hci_dev_hold(struct hci_dev *d)
        return d;
 }
-static inline struct hci_dev *hci_dev_hold(struct hci_dev *d)
+#define hci_dev_hold(d)                                         \
-{
+({                                                              \
-        if (try_module_get(d->owner))
+        try_module_get(d->owner) ? __hci_dev_hold(d) : NULL;    \
-                return __hci_dev_hold(d);
+})
-        return NULL;
-}
 #define hci_dev_lock(d)         spin_lock(&d->lock)
 #define hci_dev_unlock(d)       spin_unlock(&d->lock)
diff --git a/include/net/inet_timewait_sock.h b/include/net/inet_timewait_sock.h
index f91a1fb5da7c..e8c25b981205 100644
--- a/include/net/inet_timewait_sock.h
+++ b/include/net/inet_timewait_sock.h
@@ -18,7 +18,6 @@
 #include <linux/kmemcheck.h>
 #include <linux/list.h>
-#include <linux/module.h>
 #include <linux/timer.h>
 #include <linux/types.h>
 #include <linux/workqueue.h>
diff --git a/include/net/ip_vs.h b/include/net/ip_vs.h
index 8fa4430f99c1..873d5be7926c 100644
--- a/include/net/ip_vs.h
+++ b/include/net/ip_vs.h
@@ -425,9 +425,9 @@ struct ip_vs_protocol {
        const char *(*state_name)(int state);
-        int (*state_transition)(struct ip_vs_conn *cp, int direction,
+        void (*state_transition)(struct ip_vs_conn *cp, int direction,
-                                const struct sk_buff *skb,
+                                 const struct sk_buff *skb,
-                                struct ip_vs_proto_data *pd);
+                                 struct ip_vs_proto_data *pd);
        int (*register_app)(struct net *net, struct ip_vs_app *inc);
@@ -1126,17 +1126,16 @@ int unregister_ip_vs_pe(struct ip_vs_pe *pe);
 struct ip_vs_pe *ip_vs_pe_getbyname(const char *name);
 struct ip_vs_pe *__ip_vs_pe_getbyname(const char *pe_name);
-static inline void ip_vs_pe_get(const struct ip_vs_pe *pe)
+/*
-{
+ * Use a #define to avoid all of module.h just for these trivial ops
-        if (pe && pe->module)
+ */
+#define ip_vs_pe_get(pe)                        \
+        if (pe && pe->module)                   \
                __module_get(pe->module);
-}
-static inline void ip_vs_pe_put(const struct ip_vs_pe *pe)
+#define ip_vs_pe_put(pe)                        \
-{
+        if (pe && pe->module)                   \
-        if (pe && pe->module)
                module_put(pe->module);
-}
 /*
 *      IPVS protocol functions (from ip_vs_proto.c)
@@ -1378,7 +1377,7 @@ static inline int ip_vs_conntrack_enabled(struct netns_ipvs *ipvs)
 extern void ip_vs_update_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp,
                                   int outin);
-extern int ip_vs_confirm_conntrack(struct sk_buff *skb, struct ip_vs_conn *cp);
+extern int ip_vs_confirm_conntrack(struct sk_buff *skb);
 extern void ip_vs_nfct_expect_related(struct sk_buff *skb, struct nf_conn *ct,
                                      struct ip_vs_conn *cp, u_int8_t proto,
                                      const __be16 port, int from_rs);
@@ -1396,8 +1395,7 @@ static inline void ip_vs_update_conntrack(struct sk_buff *skb,
 {
 }
-static inline int ip_vs_confirm_conntrack(struct sk_buff *skb,
+static inline int ip_vs_confirm_conntrack(struct sk_buff *skb)
-                                          struct ip_vs_conn *cp)
 {
        return NF_ACCEPT;
 }
diff --git a/include/net/lib80211.h b/include/net/lib80211.h
index 2ec896bb72b2..d178c26a5558 100644
--- a/include/net/lib80211.h
+++ b/include/net/lib80211.h
@@ -25,7 +25,6 @@
 #include <linux/types.h>
 #include <linux/list.h>
-#include <linux/module.h>
 #include <linux/atomic.h>
 #include <linux/if.h>
 #include <linux/skbuff.h>
@@ -42,6 +41,8 @@ enum {
        IEEE80211_CRYPTO_TKIP_COUNTERMEASURES = (1 << 0),
 };
+struct module;
 struct lib80211_crypto_ops {
        const char *name;
        struct list_head list;
diff --git a/include/net/netfilter/nf_conntrack.h b/include/net/netfilter/nf_conntrack.h
index 0b7f05e4a927..8a2b0ae7dbd2 100644
--- a/include/net/netfilter/nf_conntrack.h
+++ b/include/net/netfilter/nf_conntrack.h
@@ -313,6 +313,8 @@ static inline bool nf_is_loopback_packet(const struct sk_buff *skb)
        return skb->dev && skb->skb_iif && skb->dev->flags & IFF_LOOPBACK;
 }
+struct kernel_param;
 extern int nf_conntrack_set_hashsize(const char *val, struct kernel_param *kp);
 extern unsigned int nf_conntrack_htable_size;
 extern unsigned int nf_conntrack_max;
diff --git a/include/net/netfilter/nf_conntrack_tuple.h b/include/net/netfilter/nf_conntrack_tuple.h
index 7ca6bdd5bae6..2f8fb77bfdd1 100644
--- a/include/net/netfilter/nf_conntrack_tuple.h
+++ b/include/net/netfilter/nf_conntrack_tuple.h
@@ -12,6 +12,7 @@
 #include <linux/netfilter/x_tables.h>
 #include <linux/netfilter/nf_conntrack_tuple_common.h>
+#include <linux/netfilter_ipv4/nf_nat.h>
 #include <linux/list_nulls.h>
 /* A `tuple' is a structure containing the information to uniquely
@@ -24,32 +25,6 @@
 #define NF_CT_TUPLE_L3SIZE      ARRAY_SIZE(((union nf_inet_addr *)NULL)->all)
-/* The protocol-specific manipulable parts of the tuple: always in
-   network order! */
-union nf_conntrack_man_proto {
-        /* Add other protocols here. */
-        __be16 all;
-        struct {
-                __be16 port;
-        } tcp;
-        struct {
-                __be16 port;
-        } udp;
-        struct {
-                __be16 id;
-        } icmp;
-        struct {
-                __be16 port;
-        } dccp;
-        struct {
-                __be16 port;
-        } sctp;
-        struct {
-                __be16 key;     /* GRE key is 32bit, PPtP only uses 16bit */
-        } gre;
-};
 /* The manipulable part of the tuple. */
 struct nf_conntrack_man {
        union nf_inet_addr u3;
diff --git a/include/net/netfilter/nf_nat.h b/include/net/netfilter/nf_nat.h
index 0346b0070864..b8872df7285f 100644
--- a/include/net/netfilter/nf_nat.h
+++ b/include/net/netfilter/nf_nat.h
@@ -1,6 +1,7 @@
 #ifndef _NF_NAT_H
 #define _NF_NAT_H
 #include <linux/netfilter_ipv4.h>
+#include <linux/netfilter_ipv4/nf_nat.h>
 #include <net/netfilter/nf_conntrack_tuple.h>
 #define NF_NAT_MAPPING_TYPE_MAX_NAMELEN 16
@@ -14,11 +15,6 @@ enum nf_nat_manip_type {
 #define HOOK2MANIP(hooknum) ((hooknum) != NF_INET_POST_ROUTING && \
                             (hooknum) != NF_INET_LOCAL_IN)
-#define IP_NAT_RANGE_MAP_IPS 1
-#define IP_NAT_RANGE_PROTO_SPECIFIED 2
-#define IP_NAT_RANGE_PROTO_RANDOM 4
-#define IP_NAT_RANGE_PERSISTENT 8
 /* NAT sequence number modifications */
 struct nf_nat_seq {
        /* position of the last TCP sequence number modification (if any) */
@@ -28,26 +24,6 @@ struct nf_nat_seq {
        int16_t offset_before, offset_after;
 };
-/* Single range specification. */
-struct nf_nat_range {
-        /* Set to OR of flags above. */
-        unsigned int flags;
-        /* Inclusive: network order. */
-        __be32 min_ip, max_ip;
-        /* Inclusive: network order */
-        union nf_conntrack_man_proto min, max;
-};
-/* For backwards compat: don't use in modern code. */
-struct nf_nat_multi_range_compat {
-        unsigned int rangesize; /* Must be 1. */
-        /* hangs off end. */
-        struct nf_nat_range range[1];
-};
 #include <linux/list.h>
 #include <linux/netfilter/nf_conntrack_pptp.h>
 #include <net/netfilter/nf_conntrack_extend.h>
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index 2eb207ea4eaf..f6bb08b73ca4 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -4,7 +4,6 @@
 #include <linux/netdevice.h>
 #include <linux/types.h>
 #include <linux/rcupdate.h>
-#include <linux/module.h>
 #include <linux/pkt_sched.h>
 #include <linux/pkt_cls.h>
 #include <net/gen_stats.h>
diff --git a/include/net/sock.h b/include/net/sock.h
index c6658bef7f32..abb6e0f0c3c3 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -46,7 +46,6 @@
 #include <linux/list_nulls.h>
 #include <linux/timer.h>
 #include <linux/cache.h>
-#include <linux/module.h>
 #include <linux/lockdep.h>
 #include <linux/netdevice.h>
 #include <linux/skbuff.h>       /* struct sk_buff */
@@ -729,6 +728,7 @@ struct request_sock_ops;
 struct timewait_sock_ops;
 struct inet_hashinfo;
 struct raw_hashinfo;
+struct module;
 /* Networking protocol blocks we attach to sockets.
 * socket layer -> transport layer interface
diff --git a/include/net/tcp.h b/include/net/tcp.h
index e147f42d643d..bb18c4d69aba 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -1403,11 +1403,13 @@ enum tcp_seq_states {
        TCP_SEQ_STATE_TIME_WAIT,
 };
+int tcp_seq_open(struct inode *inode, struct file *file);
 struct tcp_seq_afinfo {
-        char                    *name;
+        char                            *name;
-        sa_family_t             family;
+        sa_family_t                     family;
-        struct file_operations  seq_fops;
+        const struct file_operations    *seq_fops;
-        struct seq_operations   seq_ops;
+        struct seq_operations           seq_ops;
 };
 struct tcp_iter_state {
diff --git a/include/net/udp.h b/include/net/udp.h
index 67ea6fcb3ec0..3b285f402f48 100644
--- a/include/net/udp.h
+++ b/include/net/udp.h
@@ -230,12 +230,14 @@ extern struct sock *udp6_lib_lookup(struct net *net, const struct in6_addr *sadd
 #endif
 /* /proc */
+int udp_seq_open(struct inode *inode, struct file *file);
 struct udp_seq_afinfo {
-        char                    *name;
+        char                            *name;
-        sa_family_t             family;
+        sa_family_t                     family;
-        struct udp_table        *udp_table;
+        struct udp_table                *udp_table;
-        struct file_operations  seq_fops;
+        const struct file_operations    *seq_fops;
-        struct seq_operations   seq_ops;
+        struct seq_operations           seq_ops;
 };
 struct udp_iter_state {
diff --git a/include/sound/core.h b/include/sound/core.h
index 91d513879a78..3be5ab782b99 100644
--- a/include/sound/core.h
+++ b/include/sound/core.h
@@ -22,7 +22,6 @@
 *
 */
-#include <linux/module.h>
 #include <linux/sched.h>                /* wake_up() */
 #include <linux/mutex.h>                /* struct mutex */
 #include <linux/rwsem.h>                /* struct rw_semaphore */
@@ -43,6 +42,7 @@
 #ifdef CONFIG_PCI
 struct pci_dev;
 #endif
+struct module;
 /* device allocation stuff */
diff --git a/include/target/target_core_base.h b/include/target/target_core_base.h
index 35aa786f93da..7f5fed3c89e1 100644
--- a/include/target/target_core_base.h
+++ b/include/target/target_core_base.h
@@ -89,7 +89,6 @@ enum transport_state_table {
        TRANSPORT_PROCESS_TMR   = 9,
        TRANSPORT_ISTATE_PROCESSING = 11,
        TRANSPORT_NEW_CMD_MAP   = 16,
-        TRANSPORT_FREE_CMD_INTR = 17,
        TRANSPORT_COMPLETE_QF_WP = 18,
        TRANSPORT_COMPLETE_QF_OK = 19,
 };
@@ -115,7 +114,6 @@ enum se_cmd_flags_table {
        SCF_DELAYED_CMD_FROM_SAM_ATTR   = 0x00080000,
        SCF_UNUSED                      = 0x00100000,
        SCF_PASSTHROUGH_SG_TO_MEM_NOALLOC = 0x00400000,
-        SCF_EMULATE_CDB_ASYNC           = 0x01000000,
 };
 /* struct se_dev_entry->lun_flags and struct se_lun->lun_access */
@@ -426,6 +424,9 @@ struct se_cmd {
        enum transport_state_table t_state;
        /* Transport specific error status */
        int                     transport_error_status;
+        /* Used to signal cmd->se_tfo->check_release_cmd() usage per cmd */
+        int                     check_release:1;
+        int                     cmd_wait_set:1;
        /* See se_cmd_flags_table */
        u32                     se_cmd_flags;
        u32                     se_ordered_id;
@@ -452,8 +453,10 @@ struct se_cmd {
        struct se_session       *se_sess;
        struct se_tmr_req       *se_tmr_req;
        struct list_head        se_queue_node;
+        struct list_head        se_cmd_list;
+        struct completion       cmd_wait_comp;
        struct target_core_fabric_ops *se_tfo;
-        int (*transport_emulate_cdb)(struct se_cmd *);
+        int (*execute_task)(struct se_task *);
        void (*transport_complete_callback)(struct se_cmd *);
        unsigned char           *t_task_cdb;
@@ -559,12 +562,16 @@ struct se_node_acl {
 } ____cacheline_aligned;
 struct se_session {
+        int                     sess_tearing_down:1;
        u64                     sess_bin_isid;
        struct se_node_acl      *se_node_acl;
        struct se_portal_group *se_tpg;
        void                    *fabric_sess_ptr;
        struct list_head        sess_list;
        struct list_head        sess_acl_list;
+        struct list_head        sess_cmd_list;
+        struct list_head        sess_wait_list;
+        spinlock_t              sess_cmd_lock;
 } ____cacheline_aligned;
 struct se_device;
diff --git a/include/target/target_core_device.h b/include/target/target_core_device.h
index 46571912086c..2be31ff8763b 100644
--- a/include/target/target_core_device.h
+++ b/include/target/target_core_device.h
@@ -17,7 +17,7 @@ extern int core_dev_export(struct se_device *, struct se_portal_group *,
                                        struct se_lun *);
 extern void core_dev_unexport(struct se_device *, struct se_portal_group *,
                                        struct se_lun *);
-extern int transport_core_report_lun_response(struct se_cmd *);
+extern int target_report_luns(struct se_task *);
 extern void se_release_device_for_hba(struct se_device *);
 extern void se_release_vpd_for_dev(struct se_device *);
 extern void se_clear_dev_ports(struct se_device *);
diff --git a/include/target/target_core_fabric_ops.h b/include/target/target_core_fabric_ops.h
index 126c675f4f14..0256825f923d 100644
--- a/include/target/target_core_fabric_ops.h
+++ b/include/target/target_core_fabric_ops.h
@@ -46,9 +46,16 @@ struct target_core_fabric_ops {
        int (*new_cmd_map)(struct se_cmd *);
        /*
         * Optional to release struct se_cmd and fabric dependent allocated
-         * I/O descriptor in transport_cmd_check_stop()
+         * I/O descriptor in transport_cmd_check_stop().
+         *
+         * Returning 1 will signal a descriptor has been released.
+         * Returning 0 will signal a descriptor has not been released.
         */
-        void (*check_stop_free)(struct se_cmd *);
+        int (*check_stop_free)(struct se_cmd *);
+        /*
+         * Optional check for active I/O shutdown
+         */
+        int (*check_release_cmd)(struct se_cmd *);
        void (*release_cmd)(struct se_cmd *);
        /*
         * Called with spin_lock_bh(struct se_portal_group->session_lock held.
diff --git a/include/target/target_core_transport.h b/include/target/target_core_transport.h
index a037a1a6fbba..c16e9431dd01 100644
--- a/include/target/target_core_transport.h
+++ b/include/target/target_core_transport.h
@@ -160,17 +160,20 @@ extern int transport_generic_handle_cdb_map(struct se_cmd *);
 extern int transport_generic_handle_data(struct se_cmd *);
 extern void transport_new_cmd_failure(struct se_cmd *);
 extern int transport_generic_handle_tmr(struct se_cmd *);
-extern void transport_generic_free_cmd_intr(struct se_cmd *);
 extern bool target_stop_task(struct se_task *task, unsigned long *flags);
 extern int transport_generic_map_mem_to_cmd(struct se_cmd *cmd, struct scatterlist *, u32,
                                struct scatterlist *, u32);
 extern int transport_clear_lun_from_sessions(struct se_lun *);
-extern void transport_wait_for_tasks(struct se_cmd *);
+extern bool transport_wait_for_tasks(struct se_cmd *);
 extern int transport_check_aborted_status(struct se_cmd *, int);
 extern int transport_send_check_condition_and_sense(struct se_cmd *, u8, int);
 extern void transport_send_task_abort(struct se_cmd *);
 extern void transport_release_cmd(struct se_cmd *);
 extern void transport_generic_free_cmd(struct se_cmd *, int);
+extern void target_get_sess_cmd(struct se_session *, struct se_cmd *);
+extern int target_put_sess_cmd(struct se_session *, struct se_cmd *);
+extern void target_splice_sess_cmd_list(struct se_session *);
+extern void target_wait_for_sess_cmds(struct se_session *, int);
 extern void transport_generic_wait_for_cmds(struct se_cmd *, int);
 extern void transport_do_task_sg_chain(struct se_cmd *);
 extern void transport_generic_process_write(struct se_cmd *);
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index da39b22636f7..b0b4eb24d592 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -21,16 +21,6 @@
 #undef CREATE_TRACE_POINTS
 #include <linux/stringify.h>
-/*
- * module.h includes tracepoints, and because ftrace.h
- * pulls in module.h:
- *  trace/ftrace.h -> linux/ftrace_event.h -> linux/perf_event.h ->
- *  linux/ftrace.h -> linux/module.h
- * we must include module.h here before we play with any of
- * the TRACE_EVENT() macros, otherwise the tracepoints included
- * by module.h may break the build.
- */
-#include <linux/module.h>
 #undef TRACE_EVENT
 #define TRACE_EVENT(name, proto, args, tstruct, assign, print)  \
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index b50a54736242..748ff7cbe555 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -9,9 +9,12 @@
 struct ext4_allocation_context;
 struct ext4_allocation_request;
+struct ext4_extent;
 struct ext4_prealloc_space;
 struct ext4_inode_info;
 struct mpage_da_data;
+struct ext4_map_blocks;
+struct ext4_extent;
 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
@@ -1032,9 +1035,9 @@ TRACE_EVENT(ext4_forget,
 );
 TRACE_EVENT(ext4_da_update_reserve_space,
-        TP_PROTO(struct inode *inode, int used_blocks),
+        TP_PROTO(struct inode *inode, int used_blocks, int quota_claim),
-        TP_ARGS(inode, used_blocks),
+        TP_ARGS(inode, used_blocks, quota_claim),
        TP_STRUCT__entry(
                __field(        dev_t,  dev                     )
@@ -1045,6 +1048,7 @@ TRACE_EVENT(ext4_da_update_reserve_space,
                __field(        int,    reserved_data_blocks    )
                __field(        int,    reserved_meta_blocks    )
                __field(        int,    allocated_meta_blocks   )
+                __field(        int,    quota_claim             )
        ),
        TP_fast_assign(
@@ -1053,19 +1057,24 @@ TRACE_EVENT(ext4_da_update_reserve_space,
                __entry->mode   = inode->i_mode;
                __entry->i_blocks = inode->i_blocks;
                __entry->used_blocks = used_blocks;
-                __entry->reserved_data_blocks = EXT4_I(inode)->i_reserved_data_blocks;
+                __entry->reserved_data_blocks =
-                __entry->reserved_meta_blocks = EXT4_I(inode)->i_reserved_meta_blocks;
+                                EXT4_I(inode)->i_reserved_data_blocks;
-                __entry->allocated_meta_blocks = EXT4_I(inode)->i_allocated_meta_blocks;
+                __entry->reserved_meta_blocks =
+                                EXT4_I(inode)->i_reserved_meta_blocks;
+                __entry->allocated_meta_blocks =
+                                EXT4_I(inode)->i_allocated_meta_blocks;
+                __entry->quota_claim = quota_claim;
        ),
        TP_printk("dev %d,%d ino %lu mode 0%o i_blocks %llu used_blocks %d "
                  "reserved_data_blocks %d reserved_meta_blocks %d "
-                  "allocated_meta_blocks %d",
+                  "allocated_meta_blocks %d quota_claim %d",
                  MAJOR(__entry->dev), MINOR(__entry->dev),
                  (unsigned long) __entry->ino,
                  __entry->mode, __entry->i_blocks,
                  __entry->used_blocks, __entry->reserved_data_blocks,
-                  __entry->reserved_meta_blocks, __entry->allocated_meta_blocks)
+                  __entry->reserved_meta_blocks, __entry->allocated_meta_blocks,
+                  __entry->quota_claim)
 );
 TRACE_EVENT(ext4_da_reserve_space,
@@ -1386,6 +1395,87 @@ DEFINE_EVENT(ext4__truncate, ext4_truncate_exit,
        TP_ARGS(inode)
 );
+/* 'ux' is the uninitialized extent. */
+TRACE_EVENT(ext4_ext_convert_to_initialized_enter,
+        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
+                 struct ext4_extent *ux),
+        TP_ARGS(inode, map, ux),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    m_lblk  )
+                __field(        unsigned,       m_len   )
+                __field(        ext4_lblk_t,    u_lblk  )
+                __field(        unsigned,       u_len   )
+                __field(        ext4_fsblk_t,   u_pblk  )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->m_lblk         = map->m_lblk;
+                __entry->m_len          = map->m_len;
+                __entry->u_lblk         = le32_to_cpu(ux->ee_block);
+                __entry->u_len          = ext4_ext_get_actual_len(ux);
+                __entry->u_pblk         = ext4_ext_pblock(ux);
+        ),
+        TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u u_lblk %u u_len %u "
+                  "u_pblk %llu",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  __entry->m_lblk, __entry->m_len,
+                  __entry->u_lblk, __entry->u_len, __entry->u_pblk)
+);
+/*
+ * 'ux' is the uninitialized extent.
+ * 'ix' is the initialized extent to which blocks are transferred.
+ */
+TRACE_EVENT(ext4_ext_convert_to_initialized_fastpath,
+        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
+                 struct ext4_extent *ux, struct ext4_extent *ix),
+        TP_ARGS(inode, map, ux, ix),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    m_lblk  )
+                __field(        unsigned,       m_len   )
+                __field(        ext4_lblk_t,    u_lblk  )
+                __field(        unsigned,       u_len   )
+                __field(        ext4_fsblk_t,   u_pblk  )
+                __field(        ext4_lblk_t,    i_lblk  )
+                __field(        unsigned,       i_len   )
+                __field(        ext4_fsblk_t,   i_pblk  )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->m_lblk         = map->m_lblk;
+                __entry->m_len          = map->m_len;
+                __entry->u_lblk         = le32_to_cpu(ux->ee_block);
+                __entry->u_len          = ext4_ext_get_actual_len(ux);
+                __entry->u_pblk         = ext4_ext_pblock(ux);
+                __entry->i_lblk         = le32_to_cpu(ix->ee_block);
+                __entry->i_len          = ext4_ext_get_actual_len(ix);
+                __entry->i_pblk         = ext4_ext_pblock(ix);
+        ),
+        TP_printk("dev %d,%d ino %lu m_lblk %u m_len %u "
+                  "u_lblk %u u_len %u u_pblk %llu "
+                  "i_lblk %u i_len %u i_pblk %llu ",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  __entry->m_lblk, __entry->m_len,
+                  __entry->u_lblk, __entry->u_len, __entry->u_pblk,
+                  __entry->i_lblk, __entry->i_len, __entry->i_pblk)
+);
 DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
        TP_PROTO(struct inode *inode, ext4_lblk_t lblk,
                 unsigned int len, unsigned int flags),
@@ -1589,6 +1679,382 @@ DEFINE_EVENT(ext4__trim, ext4_trim_all_free,
        TP_ARGS(sb, group, start, len)
 );
+TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
+        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map,
+                 unsigned int allocated, ext4_fsblk_t newblock),
+        TP_ARGS(inode, map, allocated, newblock),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino             )
+                __field(        dev_t,          dev             )
+                __field(        ext4_lblk_t,    lblk            )
+                __field(        ext4_fsblk_t,   pblk            )
+                __field(        unsigned int,   len             )
+                __field(        int,            flags           )
+                __field(        unsigned int,   allocated       )
+                __field(        ext4_fsblk_t,   newblk          )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->lblk           = map->m_lblk;
+                __entry->pblk           = map->m_pblk;
+                __entry->len            = map->m_len;
+                __entry->flags          = map->m_flags;
+                __entry->allocated      = allocated;
+                __entry->newblk         = newblock;
+        ),
+        TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %d"
+                  "allocated %d newblock %llu",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
+                  __entry->len, __entry->flags,
+                  (unsigned int) __entry->allocated,
+                  (unsigned long long) __entry->newblk)
+);
+TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
+        TP_PROTO(struct super_block *sb, struct ext4_map_blocks *map, int ret),
+        TP_ARGS(sb, map, ret),
+        TP_STRUCT__entry(
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    lblk    )
+                __field(        ext4_fsblk_t,   pblk    )
+                __field(        unsigned int,   len     )
+                __field(        unsigned int,   flags   )
+                __field(        int,            ret     )
+        ),
+        TP_fast_assign(
+                __entry->dev    = sb->s_dev;
+                __entry->lblk   = map->m_lblk;
+                __entry->pblk   = map->m_pblk;
+                __entry->len    = map->m_len;
+                __entry->flags  = map->m_flags;
+                __entry->ret    = ret;
+        ),
+        TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->lblk, (unsigned long long) __entry->pblk,
+                  __entry->len, __entry->flags, __entry->ret)
+);
+TRACE_EVENT(ext4_ext_put_in_cache,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len,
+                 ext4_fsblk_t start),
+        TP_ARGS(inode, lblk, len, start),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    lblk    )
+                __field(        unsigned int,   len     )
+                __field(        ext4_fsblk_t,   start   )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->lblk   = lblk;
+                __entry->len    = len;
+                __entry->start  = start;
+        ),
+        TP_printk("dev %d,%d ino %lu lblk %u len %u start %llu",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->lblk,
+                  __entry->len,
+                  (unsigned long long) __entry->start)
+);
+TRACE_EVENT(ext4_ext_in_cache,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, int ret),
+        TP_ARGS(inode, lblk, ret),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    lblk    )
+                __field(        int,            ret     )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->lblk   = lblk;
+                __entry->ret    = ret;
+        ),
+        TP_printk("dev %d,%d ino %lu lblk %u ret %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->lblk,
+                  __entry->ret)
+);
+TRACE_EVENT(ext4_find_delalloc_range,
+        TP_PROTO(struct inode *inode, ext4_lblk_t from, ext4_lblk_t to,
+                int reverse, int found, ext4_lblk_t found_blk),
+        TP_ARGS(inode, from, to, reverse, found, found_blk),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino             )
+                __field(        dev_t,          dev             )
+                __field(        ext4_lblk_t,    from            )
+                __field(        ext4_lblk_t,    to              )
+                __field(        int,            reverse         )
+                __field(        int,            found           )
+                __field(        ext4_lblk_t,    found_blk       )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->from           = from;
+                __entry->to             = to;
+                __entry->reverse        = reverse;
+                __entry->found          = found;
+                __entry->found_blk      = found_blk;
+        ),
+        TP_printk("dev %d,%d ino %lu from %u to %u reverse %d found %d "
+                  "(blk = %u)",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->from, (unsigned) __entry->to,
+                  __entry->reverse, __entry->found,
+                  (unsigned) __entry->found_blk)
+);
+TRACE_EVENT(ext4_get_reserved_cluster_alloc,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, unsigned int len),
+        TP_ARGS(inode, lblk, len),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    lblk    )
+                __field(        unsigned int,   len     )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->lblk   = lblk;
+                __entry->len    = len;
+        ),
+        TP_printk("dev %d,%d ino %lu lblk %u len %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->lblk,
+                  __entry->len)
+);
+TRACE_EVENT(ext4_ext_show_extent,
+        TP_PROTO(struct inode *inode, ext4_lblk_t lblk, ext4_fsblk_t pblk,
+                 unsigned short len),
+        TP_ARGS(inode, lblk, pblk, len),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    lblk    )
+                __field(        ext4_fsblk_t,   pblk    )
+                __field(        unsigned short, len     )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->lblk   = lblk;
+                __entry->pblk   = pblk;
+                __entry->len    = len;
+        ),
+        TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->lblk,
+                  (unsigned long long) __entry->pblk,
+                  (unsigned short) __entry->len)
+);
+TRACE_EVENT(ext4_remove_blocks,
+            TP_PROTO(struct inode *inode, struct ext4_extent *ex,
+                ext4_lblk_t from, ext4_fsblk_t to,
+                ext4_fsblk_t partial_cluster),
+        TP_ARGS(inode, ex, from, to, partial_cluster),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    ee_lblk )
+                __field(        ext4_fsblk_t,   ee_pblk )
+                __field(        unsigned short, ee_len  )
+                __field(        ext4_lblk_t,    from    )
+                __field(        ext4_lblk_t,    to      )
+                __field(        ext4_fsblk_t,   partial )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ee_lblk        = cpu_to_le32(ex->ee_block);
+                __entry->ee_pblk        = ext4_ext_pblock(ex);
+                __entry->ee_len         = ext4_ext_get_actual_len(ex);
+                __entry->from           = from;
+                __entry->to             = to;
+                __entry->partial        = partial_cluster;
+        ),
+        TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
+                  "from %u to %u partial_cluster %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->ee_lblk,
+                  (unsigned long long) __entry->ee_pblk,
+                  (unsigned short) __entry->ee_len,
+                  (unsigned) __entry->from,
+                  (unsigned) __entry->to,
+                  (unsigned) __entry->partial)
+);
+TRACE_EVENT(ext4_ext_rm_leaf,
+        TP_PROTO(struct inode *inode, ext4_lblk_t start,
+                 struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
+        TP_ARGS(inode, start, ex, partial_cluster),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    start   )
+                __field(        ext4_lblk_t,    ee_lblk )
+                __field(        ext4_fsblk_t,   ee_pblk )
+                __field(        short,          ee_len  )
+                __field(        ext4_fsblk_t,   partial )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->start          = start;
+                __entry->ee_lblk        = le32_to_cpu(ex->ee_block);
+                __entry->ee_pblk        = ext4_ext_pblock(ex);
+                __entry->ee_len         = ext4_ext_get_actual_len(ex);
+                __entry->partial        = partial_cluster;
+        ),
+        TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
+                  "partial_cluster %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->start,
+                  (unsigned) __entry->ee_lblk,
+                  (unsigned long long) __entry->ee_pblk,
+                  (unsigned short) __entry->ee_len,
+                  (unsigned) __entry->partial)
+);
+TRACE_EVENT(ext4_ext_rm_idx,
+        TP_PROTO(struct inode *inode, ext4_fsblk_t pblk),
+        TP_ARGS(inode, pblk),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_fsblk_t,   pblk    )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->pblk   = pblk;
+        ),
+        TP_printk("dev %d,%d ino %lu index_pblk %llu",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned long long) __entry->pblk)
+);
+TRACE_EVENT(ext4_ext_remove_space,
+        TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
+        TP_ARGS(inode, start, depth),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino     )
+                __field(        dev_t,          dev     )
+                __field(        ext4_lblk_t,    start   )
+                __field(        int,            depth   )
+        ),
+        TP_fast_assign(
+                __entry->ino    = inode->i_ino;
+                __entry->dev    = inode->i_sb->s_dev;
+                __entry->start  = start;
+                __entry->depth  = depth;
+        ),
+        TP_printk("dev %d,%d ino %lu since %u depth %d",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->start,
+                  __entry->depth)
+);
+TRACE_EVENT(ext4_ext_remove_space_done,
+        TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
+                ext4_lblk_t partial, unsigned short eh_entries),
+        TP_ARGS(inode, start, depth, partial, eh_entries),
+        TP_STRUCT__entry(
+                __field(        ino_t,          ino             )
+                __field(        dev_t,          dev             )
+                __field(        ext4_lblk_t,    start           )
+                __field(        int,            depth           )
+                __field(        ext4_lblk_t,    partial         )
+                __field(        unsigned short, eh_entries      )
+        ),
+        TP_fast_assign(
+                __entry->ino            = inode->i_ino;
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->start          = start;
+                __entry->depth          = depth;
+                __entry->partial        = partial;
+                __entry->eh_entries     = eh_entries;
+        ),
+        TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
+                  "remaining_entries %u",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino,
+                  (unsigned) __entry->start,
+                  __entry->depth,
+                  (unsigned) __entry->partial,
+                  (unsigned short) __entry->eh_entries)
+);
 #endif /* _TRACE_EXT4_H */
 /* This part must be outside protection */
diff --git a/include/trace/events/module.h b/include/trace/events/module.h
index 21a546d27c0c..161932737416 100644
--- a/include/trace/events/module.h
+++ b/include/trace/events/module.h
@@ -1,6 +1,6 @@
 /*
 * Because linux/module.h has tracepoints in the header, and ftrace.h
- * eventually includes this file, define_trace.h includes linux/module.h
+ * used to include this file, define_trace.h includes linux/module.h
 * But we do not want the module.h to override the TRACE_SYSTEM macro
 * variable that define_trace.h is processing, so we only set it
 * when module events are being processed, which would happen when
diff --git a/include/trace/events/writeback.h b/include/trace/events/writeback.h
index 5f172703eb4f..b99caa8b780c 100644
--- a/include/trace/events/writeback.h
+++ b/include/trace/events/writeback.h
@@ -34,6 +34,7 @@ DECLARE_EVENT_CLASS(writeback_work_class,
                __field(int, for_kupdate)
                __field(int, range_cyclic)
                __field(int, for_background)
+                __field(int, reason)
        ),
        TP_fast_assign(
                strncpy(__entry->name, dev_name(bdi->dev), 32);
@@ -43,16 +44,18 @@ DECLARE_EVENT_CLASS(writeback_work_class,
                __entry->for_kupdate = work->for_kupdate;
                __entry->range_cyclic = work->range_cyclic;
                __entry->for_background = work->for_background;
+                __entry->reason = work->reason;
        ),
        TP_printk("bdi %s: sb_dev %d:%d nr_pages=%ld sync_mode=%d "
-                  "kupdate=%d range_cyclic=%d background=%d",
+                  "kupdate=%d range_cyclic=%d background=%d reason=%s",
                  __entry->name,
                  MAJOR(__entry->sb_dev), MINOR(__entry->sb_dev),
                  __entry->nr_pages,
                  __entry->sync_mode,
                  __entry->for_kupdate,
                  __entry->range_cyclic,
-                  __entry->for_background
+                  __entry->for_background,
+                  wb_reason_name[__entry->reason]
        )
 );
 #define DEFINE_WRITEBACK_WORK_EVENT(name) \
@@ -104,30 +107,6 @@ DEFINE_WRITEBACK_EVENT(writeback_bdi_register);
 DEFINE_WRITEBACK_EVENT(writeback_bdi_unregister);
 DEFINE_WRITEBACK_EVENT(writeback_thread_start);
 DEFINE_WRITEBACK_EVENT(writeback_thread_stop);
-DEFINE_WRITEBACK_EVENT(balance_dirty_start);
-DEFINE_WRITEBACK_EVENT(balance_dirty_wait);
-TRACE_EVENT(balance_dirty_written,
-        TP_PROTO(struct backing_dev_info *bdi, int written),
-        TP_ARGS(bdi, written),
-        TP_STRUCT__entry(
-                __array(char,   name, 32)
-                __field(int,    written)
-        ),
-        TP_fast_assign(
-                strncpy(__entry->name, dev_name(bdi->dev), 32);
-                __entry->written = written;
-        ),
-        TP_printk("bdi %s written %d",
-                  __entry->name,
-                  __entry->written
-        )
-);
 DECLARE_EVENT_CLASS(wbc_class,
        TP_PROTO(struct writeback_control *wbc, struct backing_dev_info *bdi),
@@ -181,27 +160,31 @@ DEFINE_WBC_EVENT(wbc_writepage);
 TRACE_EVENT(writeback_queue_io,
        TP_PROTO(struct bdi_writeback *wb,
-                 unsigned long *older_than_this,
+                 struct wb_writeback_work *work,
                 int moved),
-        TP_ARGS(wb, older_than_this, moved),
+        TP_ARGS(wb, work, moved),
        TP_STRUCT__entry(
                __array(char,           name, 32)
                __field(unsigned long,  older)
                __field(long,           age)
                __field(int,            moved)
+                __field(int,            reason)
        ),
        TP_fast_assign(
+                unsigned long *older_than_this = work->older_than_this;
                strncpy(__entry->name, dev_name(wb->bdi->dev), 32);
                __entry->older  = older_than_this ?  *older_than_this : 0;
                __entry->age    = older_than_this ?
                                  (jiffies - *older_than_this) * 1000 / HZ : -1;
                __entry->moved  = moved;
+                __entry->reason = work->reason;
        ),
-        TP_printk("bdi %s: older=%lu age=%ld enqueue=%d",
+        TP_printk("bdi %s: older=%lu age=%ld enqueue=%d reason=%s",
                __entry->name,
                __entry->older, /* older_than_this in jiffies */
                __entry->age,   /* older_than_this in relative milliseconds */
-                __entry->moved)
+                __entry->moved,
+                wb_reason_name[__entry->reason])
 );
 TRACE_EVENT(global_dirty_state,
@@ -250,6 +233,124 @@ TRACE_EVENT(global_dirty_state,
        )
 );
+#define KBps(x)                 ((x) << (PAGE_SHIFT - 10))
+TRACE_EVENT(bdi_dirty_ratelimit,
+        TP_PROTO(struct backing_dev_info *bdi,
+                 unsigned long dirty_rate,
+                 unsigned long task_ratelimit),
+        TP_ARGS(bdi, dirty_rate, task_ratelimit),
+        TP_STRUCT__entry(
+                __array(char,           bdi, 32)
+                __field(unsigned long,  write_bw)
+                __field(unsigned long,  avg_write_bw)
+                __field(unsigned long,  dirty_rate)
+                __field(unsigned long,  dirty_ratelimit)
+                __field(unsigned long,  task_ratelimit)
+                __field(unsigned long,  balanced_dirty_ratelimit)
+        ),
+        TP_fast_assign(
+                strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
+                __entry->write_bw       = KBps(bdi->write_bandwidth);
+                __entry->avg_write_bw   = KBps(bdi->avg_write_bandwidth);
+                __entry->dirty_rate     = KBps(dirty_rate);
+                __entry->dirty_ratelimit = KBps(bdi->dirty_ratelimit);
+                __entry->task_ratelimit = KBps(task_ratelimit);
+                __entry->balanced_dirty_ratelimit =
+                                          KBps(bdi->balanced_dirty_ratelimit);
+        ),
+        TP_printk("bdi %s: "
+                  "write_bw=%lu awrite_bw=%lu dirty_rate=%lu "
+                  "dirty_ratelimit=%lu task_ratelimit=%lu "
+                  "balanced_dirty_ratelimit=%lu",
+                  __entry->bdi,
+                  __entry->write_bw,            /* write bandwidth */
+                  __entry->avg_write_bw,        /* avg write bandwidth */
+                  __entry->dirty_rate,          /* bdi dirty rate */
+                  __entry->dirty_ratelimit,     /* base ratelimit */
+                  __entry->task_ratelimit, /* ratelimit with position control */
+                  __entry->balanced_dirty_ratelimit /* the balanced ratelimit */
+        )
+);
+TRACE_EVENT(balance_dirty_pages,
+        TP_PROTO(struct backing_dev_info *bdi,
+                 unsigned long thresh,
+                 unsigned long bg_thresh,
+                 unsigned long dirty,
+                 unsigned long bdi_thresh,
+                 unsigned long bdi_dirty,
+                 unsigned long dirty_ratelimit,
+                 unsigned long task_ratelimit,
+                 unsigned long dirtied,
+                 long pause,
+                 unsigned long start_time),
+        TP_ARGS(bdi, thresh, bg_thresh, dirty, bdi_thresh, bdi_dirty,
+                dirty_ratelimit, task_ratelimit,
+                dirtied, pause, start_time),
+        TP_STRUCT__entry(
+                __array(         char,  bdi, 32)
+                __field(unsigned long,  limit)
+                __field(unsigned long,  setpoint)
+                __field(unsigned long,  dirty)
+                __field(unsigned long,  bdi_setpoint)
+                __field(unsigned long,  bdi_dirty)
+                __field(unsigned long,  dirty_ratelimit)
+                __field(unsigned long,  task_ratelimit)
+                __field(unsigned int,   dirtied)
+                __field(unsigned int,   dirtied_pause)
+                __field(unsigned long,  paused)
+                __field(         long,  pause)
+        ),
+        TP_fast_assign(
+                unsigned long freerun = (thresh + bg_thresh) / 2;
+                strlcpy(__entry->bdi, dev_name(bdi->dev), 32);
+                __entry->limit          = global_dirty_limit;
+                __entry->setpoint       = (global_dirty_limit + freerun) / 2;
+                __entry->dirty          = dirty;
+                __entry->bdi_setpoint   = __entry->setpoint *
+                                                bdi_thresh / (thresh + 1);
+                __entry->bdi_dirty      = bdi_dirty;
+                __entry->dirty_ratelimit = KBps(dirty_ratelimit);
+                __entry->task_ratelimit = KBps(task_ratelimit);
+                __entry->dirtied        = dirtied;
+                __entry->dirtied_pause  = current->nr_dirtied_pause;
+                __entry->pause          = pause * 1000 / HZ;
+                __entry->paused         = (jiffies - start_time) * 1000 / HZ;
+        ),
+        TP_printk("bdi %s: "
+                  "limit=%lu setpoint=%lu dirty=%lu "
+                  "bdi_setpoint=%lu bdi_dirty=%lu "
+                  "dirty_ratelimit=%lu task_ratelimit=%lu "
+                  "dirtied=%u dirtied_pause=%u "
+                  "paused=%lu pause=%ld",
+                  __entry->bdi,
+                  __entry->limit,
+                  __entry->setpoint,
+                  __entry->dirty,
+                  __entry->bdi_setpoint,
+                  __entry->bdi_dirty,
+                  __entry->dirty_ratelimit,
+                  __entry->task_ratelimit,
+                  __entry->dirtied,
+                  __entry->dirtied_pause,
+                  __entry->paused,      /* ms */
+                  __entry->pause        /* ms */
+          )
+);
 DECLARE_EVENT_CLASS(writeback_congest_waited_template,
        TP_PROTO(unsigned int usec_timeout, unsigned int usec_delayed),
diff --git a/include/xen/grant_table.h b/include/xen/grant_table.h
index 6b99bfbd785d..11e2dfce42f8 100644
--- a/include/xen/grant_table.h
+++ b/include/xen/grant_table.h
@@ -43,7 +43,6 @@
 #include <xen/interface/grant_table.h>
 #include <asm/xen/hypervisor.h>
-#include <asm/xen/grant_table.h>
 #include <xen/features.h>
diff --git a/include/xen/interface/io/blkif.h b/include/xen/interface/io/blkif.h
index 3d5d6db864fe..9324488f23f0 100644
--- a/include/xen/interface/io/blkif.h
+++ b/include/xen/interface/io/blkif.h
@@ -57,6 +57,36 @@ typedef uint64_t blkif_sector_t;
 * "feature-flush-cache" node!
 */
 #define BLKIF_OP_FLUSH_DISKCACHE   3
+/*
+ * Recognised only if "feature-discard" is present in backend xenbus info.
+ * The "feature-discard" node contains a boolean indicating whether trim
+ * (ATA) or unmap (SCSI) - conviently called discard requests are likely
+ * to succeed or fail. Either way, a discard request
+ * may fail at any time with BLKIF_RSP_EOPNOTSUPP if it is unsupported by
+ * the underlying block-device hardware. The boolean simply indicates whether
+ * or not it is worthwhile for the frontend to attempt discard requests.
+ * If a backend does not recognise BLKIF_OP_DISCARD, it should *not*
+ * create the "feature-discard" node!
+ *
+ * Discard operation is a request for the underlying block device to mark
+ * extents to be erased. However, discard does not guarantee that the blocks
+ * will be erased from the device - it is just a hint to the device
+ * controller that these blocks are no longer in use. What the device
+ * controller does with that information is left to the controller.
+ * Discard operations are passed with sector_number as the
+ * sector index to begin discard operations at and nr_sectors as the number of
+ * sectors to be discarded. The specified sectors should be discarded if the
+ * underlying block device supports trim (ATA) or unmap (SCSI) operations,
+ * or a BLKIF_RSP_EOPNOTSUPP  should be returned.
+ * More information about trim/unmap operations at:
+ * http://t13.org/Documents/UploadedDocuments/docs2008/
+ *     e07154r6-Data_Set_Management_Proposal_for_ATA-ACS2.doc
+ * http://www.seagate.com/staticfiles/support/disc/manuals/
+ *     Interface%20manuals/100293068c.pdf
+ */
+#define BLKIF_OP_DISCARD           5
 /*
 * Maximum scatter/gather segments per request.
 * This is carefully chosen so that sizeof(struct blkif_ring) <= PAGE_SIZE.
@@ -74,6 +104,11 @@ struct blkif_request_rw {
        } seg[BLKIF_MAX_SEGMENTS_PER_REQUEST];
 };
+struct blkif_request_discard {
+        blkif_sector_t sector_number;
+        uint64_t nr_sectors;
+};
 struct blkif_request {
        uint8_t        operation;    /* BLKIF_OP_???                         */
        uint8_t        nr_segments;  /* number of segments                   */
@@ -81,6 +116,7 @@ struct blkif_request {
        uint64_t       id;           /* private guest value, echoed in resp  */
        union {
                struct blkif_request_rw rw;
+                struct blkif_request_discard discard;
        } u;
 };
diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h
index b9f9fb5af0d8..b1b6676c1c43 100644
--- a/include/xen/xenbus.h
+++ b/include/xen/xenbus.h
@@ -37,6 +37,7 @@
 #include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/mutex.h>
+#include <linux/export.h>
 #include <linux/completion.h>
 #include <linux/init.h>
 #include <linux/slab.h>
author	Tony Lindgren <tony@atomide.com>	2011-11-07 15:27:23 -0500
committer	Tony Lindgren <tony@atomide.com>	2011-11-07 15:27:23 -0500
commit	d30cc16c8e48368e0518f4975a78711e53e14a0f (patch)
tree	26b57f7ab5a963cc3d6c57dff6951bd930875583 /include
parent	41eb2d813f558900884e240c2f723e36c7bd151f (diff)
parent	a1bcc1dcef8451b4291ea2a1b2677cb194102952 (diff)