255 files changed, 4774 insertions, 2491 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 856d381b1d5b..24c7aa8b1d20 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -27,6 +27,7 @@
 
 #include <linux/errno.h>
 #include <linux/ioport.h>       /* for struct resource */
+#include <linux/resource_ext.h>
 #include <linux/device.h>
 #include <linux/property.h>
 
@@ -147,10 +148,14 @@ void acpi_numa_arch_fixup(void);
 
 #ifdef CONFIG_ACPI_HOTPLUG_CPU
 /* Arch dependent functions for cpu hotplug support */
-int acpi_map_lsapic(acpi_handle handle, int physid, int *pcpu);
-int acpi_unmap_lsapic(int cpu);
+int acpi_map_cpu(acpi_handle handle, int physid, int *pcpu);
+int acpi_unmap_cpu(int cpu);
 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
 
+#ifdef CONFIG_ACPI_HOTPLUG_IOAPIC
+int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
+#endif
+
 int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
 int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
 int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
@@ -288,22 +293,25 @@ extern int pnpacpi_disabled;
 bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
 bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
 bool acpi_dev_resource_address_space(struct acpi_resource *ares,
-                                     struct resource *res);
+                                     struct resource_win *win);
 bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
-                                         struct resource *res);
+                                         struct resource_win *win);
 unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
 bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
                                  struct resource *res);
 
-struct resource_list_entry {
-        struct list_head node;
-        struct resource res;
-};
-
 void acpi_dev_free_resource_list(struct list_head *list);
 int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
                            int (*preproc)(struct acpi_resource *, void *),
                            void *preproc_data);
+int acpi_dev_filter_resource_type(struct acpi_resource *ares,
+                                  unsigned long types);
+
+static inline int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares,
+                                                   void *arg)
+{
+        return acpi_dev_filter_resource_type(ares, (unsigned long)arg);
+}
 
 int acpi_check_resource_conflict(const struct resource *res);
 
diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
index 642d6ae4030c..a270f25ee7c7 100644
--- a/include/linux/ahci_platform.h
+++ b/include/linux/ahci_platform.h
@@ -21,16 +21,20 @@ struct device;
 struct ata_port_info;
 struct ahci_host_priv;
 struct platform_device;
+struct scsi_host_template;
 
 int ahci_platform_enable_clks(struct ahci_host_priv *hpriv);
 void ahci_platform_disable_clks(struct ahci_host_priv *hpriv);
+int ahci_platform_enable_regulators(struct ahci_host_priv *hpriv);
+void ahci_platform_disable_regulators(struct ahci_host_priv *hpriv);
 int ahci_platform_enable_resources(struct ahci_host_priv *hpriv);
 void ahci_platform_disable_resources(struct ahci_host_priv *hpriv);
 struct ahci_host_priv *ahci_platform_get_resources(
         struct platform_device *pdev);
 int ahci_platform_init_host(struct platform_device *pdev,
                             struct ahci_host_priv *hpriv,
-                            const struct ata_port_info *pi_template);
+                            const struct ata_port_info *pi_template,
+                            struct scsi_host_template *sht);
 
 int ahci_platform_suspend_host(struct device *dev);
 int ahci_platform_resume_host(struct device *dev);
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index 2afc618b15ce..50fc66868402 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h
@@ -33,6 +33,7 @@ struct amba_device {
         struct clk              *pclk;
         unsigned int            periphid;
         unsigned int            irq[AMBA_NR_IRQS];
+        char                    *driver_override;
 };
 
 struct amba_driver {
@@ -92,11 +93,15 @@ struct amba_device *amba_find_device(const char *, struct device *, unsigned int
 int amba_request_regions(struct amba_device *, const char *);
 void amba_release_regions(struct amba_device *);
 
-#define amba_pclk_enable(d)     \
-        (IS_ERR((d)->pclk) ? 0 : clk_enable((d)->pclk))
+static inline int amba_pclk_enable(struct amba_device *dev)
+{
+        return clk_enable(dev->pclk);
+}
 
-#define amba_pclk_disable(d)    \
-        do { if (!IS_ERR((d)->pclk)) clk_disable((d)->pclk); } while (0)
+static inline void amba_pclk_disable(struct amba_device *dev)
+{
+        clk_disable(dev->pclk);
+}
 
 static inline int amba_pclk_prepare(struct amba_device *dev)
 {
diff --git a/include/linux/ata.h b/include/linux/ata.h
index f2f4d8da97c0..1648026e06b4 100644
--- a/include/linux/ata.h
+++ b/include/linux/ata.h
@@ -503,7 +503,7 @@ struct ata_bmdma_prd {
 #define ata_id_has_dma(id)      ((id)[ATA_ID_CAPABILITY] & (1 << 8))
 #define ata_id_has_ncq(id)      ((id)[ATA_ID_SATA_CAPABILITY] & (1 << 8))
 #define ata_id_queue_depth(id)  (((id)[ATA_ID_QUEUE_DEPTH] & 0x1f) + 1)
-#define ata_id_removeable(id)   ((id)[ATA_ID_CONFIG] & (1 << 7))
+#define ata_id_removable(id)    ((id)[ATA_ID_CONFIG] & (1 << 7))
 #define ata_id_has_atapi_AN(id) \
         ((((id)[ATA_ID_SATA_CAPABILITY] != 0x0000) && \
           ((id)[ATA_ID_SATA_CAPABILITY] != 0xffff)) && \
diff --git a/include/linux/ata_platform.h b/include/linux/ata_platform.h
index 5c618a084225..619d9e78e644 100644
--- a/include/linux/ata_platform.h
+++ b/include/linux/ata_platform.h
@@ -10,12 +10,15 @@ struct pata_platform_info {
         unsigned int ioport_shift;
 };
 
+struct scsi_host_template;
+
 extern int __pata_platform_probe(struct device *dev,
                                  struct resource *io_res,
                                  struct resource *ctl_res,
                                  struct resource *irq_res,
                                  unsigned int ioport_shift,
-                                 int __pio_mask);
+                                 int __pio_mask,
+                                 struct scsi_host_template *sht);
 
 /*
  * Marvell SATA private data
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 0c04917c2f12..599f3bd2d6c5 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -46,7 +46,7 @@ struct audit_tree;
 struct sk_buff;
 
 struct audit_krule {
-        int                     vers_ops;
+        u32                     pflags;
         u32                     flags;
         u32                     listnr;
         u32                     action;
@@ -64,6 +64,9 @@ struct audit_krule {
         u64                     prio;
 };
 
+/* Flag to indicate legacy AUDIT_LOGINUID unset usage */
+#define AUDIT_LOGINUID_LEGACY           0x1
+
 struct audit_field {
         u32                             type;
         union {
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 5da6012b7a14..d94077fea1f8 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -106,6 +106,8 @@ struct backing_dev_info {
 #endif
 };
 
+struct backing_dev_info *inode_to_bdi(struct inode *inode);
+
 int __must_check bdi_init(struct backing_dev_info *bdi);
 void bdi_destroy(struct backing_dev_info *bdi);
 
@@ -114,7 +116,7 @@ int bdi_register(struct backing_dev_info *bdi, struct device *parent,
                 const char *fmt, ...);
 int bdi_register_dev(struct backing_dev_info *bdi, dev_t dev);
 void bdi_unregister(struct backing_dev_info *bdi);
-int __must_check bdi_setup_and_register(struct backing_dev_info *, char *, unsigned int);
+int __must_check bdi_setup_and_register(struct backing_dev_info *, char *);
 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);
@@ -228,46 +230,17 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
  * BDI_CAP_NO_ACCT_DIRTY:  Dirty pages shouldn't contribute to accounting
  * BDI_CAP_NO_WRITEBACK:   Don't write pages back
  * BDI_CAP_NO_ACCT_WB:     Don't automatically account writeback pages
- *
- * These flags let !MMU mmap() govern direct device mapping vs immediate
- * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
- *
- * BDI_CAP_MAP_COPY:       Copy can be mapped (MAP_PRIVATE)
- * BDI_CAP_MAP_DIRECT:     Can be mapped directly (MAP_SHARED)
- * BDI_CAP_READ_MAP:       Can be mapped for reading
- * BDI_CAP_WRITE_MAP:      Can be mapped for writing
- * BDI_CAP_EXEC_MAP:       Can be mapped for execution
- *
- * BDI_CAP_SWAP_BACKED:    Count shmem/tmpfs objects as swap-backed.
- *
  * BDI_CAP_STRICTLIMIT:    Keep number of dirty pages below bdi threshold.
  */
 #define BDI_CAP_NO_ACCT_DIRTY   0x00000001
 #define BDI_CAP_NO_WRITEBACK    0x00000002
-#define BDI_CAP_MAP_COPY        0x00000004
-#define BDI_CAP_MAP_DIRECT      0x00000008
-#define BDI_CAP_READ_MAP        0x00000010
-#define BDI_CAP_WRITE_MAP       0x00000020
-#define BDI_CAP_EXEC_MAP        0x00000040
-#define BDI_CAP_NO_ACCT_WB      0x00000080
-#define BDI_CAP_SWAP_BACKED     0x00000100
-#define BDI_CAP_STABLE_WRITES   0x00000200
-#define BDI_CAP_STRICTLIMIT     0x00000400
-
-#define BDI_CAP_VMFLAGS \
-        (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
+#define BDI_CAP_NO_ACCT_WB      0x00000004
+#define BDI_CAP_STABLE_WRITES   0x00000008
+#define BDI_CAP_STRICTLIMIT     0x00000010
 
 #define BDI_CAP_NO_ACCT_AND_WRITEBACK \
         (BDI_CAP_NO_WRITEBACK | BDI_CAP_NO_ACCT_DIRTY | BDI_CAP_NO_ACCT_WB)
 
-#if defined(VM_MAYREAD) && \
-        (BDI_CAP_READ_MAP != VM_MAYREAD || \
-         BDI_CAP_WRITE_MAP != VM_MAYWRITE || \
-         BDI_CAP_EXEC_MAP != VM_MAYEXEC)
-#error please change backing_dev_info::capabilities flags
-#endif
-
-extern struct backing_dev_info default_backing_dev_info;
 extern struct backing_dev_info noop_backing_dev_info;
 
 int writeback_in_progress(struct backing_dev_info *bdi);
@@ -329,24 +302,14 @@ static inline bool bdi_cap_account_writeback(struct backing_dev_info *bdi)
                                       BDI_CAP_NO_WRITEBACK));
 }
 
-static inline bool bdi_cap_swap_backed(struct backing_dev_info *bdi)
-{
-        return bdi->capabilities & BDI_CAP_SWAP_BACKED;
-}
-
 static inline bool mapping_cap_writeback_dirty(struct address_space *mapping)
 {
-        return bdi_cap_writeback_dirty(mapping->backing_dev_info);
+        return bdi_cap_writeback_dirty(inode_to_bdi(mapping->host));
 }
 
 static inline bool mapping_cap_account_dirty(struct address_space *mapping)
 {
-        return bdi_cap_account_dirty(mapping->backing_dev_info);
-}
-
-static inline bool mapping_cap_swap_backed(struct address_space *mapping)
-{
-        return bdi_cap_swap_backed(mapping->backing_dev_info);
+        return bdi_cap_account_dirty(inode_to_bdi(mapping->host));
 }
 
 static inline int bdi_sched_wait(void *word)
diff --git a/include/linux/bcma/bcma.h b/include/linux/bcma/bcma.h
index eb1c6a47b67f..994739da827f 100644
--- a/include/linux/bcma/bcma.h
+++ b/include/linux/bcma/bcma.h
@@ -318,6 +318,7 @@ struct bcma_bus {
         const struct bcma_host_ops *ops;
 
         enum bcma_hosttype hosttype;
+        bool host_is_pcie2; /* Used for BCMA_HOSTTYPE_PCI only */
         union {
                 /* Pointer to the PCI bus (only for BCMA_HOSTTYPE_PCI) */
                 struct pci_dev *host_pci;
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index 0333e605ea0d..3f809ae372c4 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -223,6 +223,7 @@ struct bcma_drv_pci_host {
 
 struct bcma_drv_pci {
         struct bcma_device *core;
+        u8 early_setup_done:1;
         u8 setup_done:1;
         u8 hostmode:1;
 
@@ -237,6 +238,7 @@ struct bcma_drv_pci {
 #define pcicore_write16(pc, offset, val)        bcma_write16((pc)->core, offset, val)
 #define pcicore_write32(pc, offset, val)        bcma_write32((pc)->core, offset, val)
 
+extern void bcma_core_pci_early_init(struct bcma_drv_pci *pc);
 extern void bcma_core_pci_init(struct bcma_drv_pci *pc);
 extern int bcma_core_pci_irq_ctl(struct bcma_drv_pci *pc,
                                  struct bcma_device *core, bool enable);
diff --git a/include/linux/bcma/bcma_regs.h b/include/linux/bcma/bcma_regs.h
index e64ae7bf80a1..ebd5c1fcdea4 100644
--- a/include/linux/bcma/bcma_regs.h
+++ b/include/linux/bcma/bcma_regs.h
@@ -64,6 +64,8 @@
 #define  BCMA_PCI_GPIO_XTAL             0x40    /* PCI config space GPIO 14 for Xtal powerup */
 #define  BCMA_PCI_GPIO_PLL              0x80    /* PCI config space GPIO 15 for PLL powerdown */
 
+#define BCMA_PCIE2_BAR0_WIN2            0x70
+
 /* SiliconBackplane Address Map.
  * All regions may not exist on all chips.
  */
diff --git a/include/linux/bcma/bcma_soc.h b/include/linux/bcma/bcma_soc.h
index f24d245f8394..1b5fc0c3b1b5 100644
--- a/include/linux/bcma/bcma_soc.h
+++ b/include/linux/bcma/bcma_soc.h
@@ -5,8 +5,6 @@
 
 struct bcma_soc {
         struct bcma_bus bus;
-        struct bcma_device core_cc;
-        struct bcma_device core_mips;
 };
 
 int __init bcma_host_soc_register(struct bcma_soc *soc);
diff --git a/include/linux/bio.h b/include/linux/bio.h
index efead0b532c4..da3a127c9958 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -428,13 +428,9 @@ extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
 extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
                            unsigned int, unsigned int);
 extern int bio_get_nr_vecs(struct block_device *);
-extern struct bio *bio_map_user(struct request_queue *, struct block_device *,
-                                unsigned long, unsigned int, int, gfp_t);
-struct sg_iovec;
 struct rq_map_data;
 extern struct bio *bio_map_user_iov(struct request_queue *,
-                                    struct block_device *,
-                                    const struct sg_iovec *, int, int, gfp_t);
+                                    const struct iov_iter *, gfp_t);
 extern void bio_unmap_user(struct bio *);
 extern struct bio *bio_map_kern(struct request_queue *, void *, unsigned int,
                                 gfp_t);
@@ -462,12 +458,10 @@ static inline void bio_flush_dcache_pages(struct bio *bi)
 extern void bio_copy_data(struct bio *dst, struct bio *src);
 extern int bio_alloc_pages(struct bio *bio, gfp_t gfp);
 
-extern struct bio *bio_copy_user(struct request_queue *, struct rq_map_data *,
-                                 unsigned long, unsigned int, int, gfp_t);
 extern struct bio *bio_copy_user_iov(struct request_queue *,
                                      struct rq_map_data *,
-                                     const struct sg_iovec *,
-                                     int, int, gfp_t);
+                                     const struct iov_iter *,
+                                     gfp_t);
 extern int bio_uncopy_user(struct bio *);
 void zero_fill_bio(struct bio *bio);
 extern struct bio_vec *bvec_alloc(gfp_t, int, unsigned long *, mempool_t *);
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 202e4034fe26..dbfbf4990005 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -52,16 +52,13 @@
  * bitmap_bitremap(oldbit, old, new, nbits)     newbit = map(old, new)(oldbit)
  * bitmap_onto(dst, orig, relmap, nbits)        *dst = orig relative to relmap
  * bitmap_fold(dst, orig, sz, nbits)            dst bits = orig bits mod sz
- * bitmap_scnprintf(buf, len, src, nbits)       Print bitmap src to buf
  * bitmap_parse(buf, buflen, dst, nbits)        Parse bitmap dst from kernel buf
  * bitmap_parse_user(ubuf, ulen, dst, nbits)    Parse bitmap dst from user buf
- * bitmap_scnlistprintf(buf, len, src, nbits)   Print bitmap src as list to buf
  * bitmap_parselist(buf, dst, nbits)            Parse bitmap dst from kernel buf
  * bitmap_parselist_user(buf, dst, nbits)       Parse bitmap dst from user buf
  * bitmap_find_free_region(bitmap, bits, order) Find and allocate bit region
  * bitmap_release_region(bitmap, pos, order)    Free specified bit region
  * bitmap_allocate_region(bitmap, pos, order)   Allocate specified bit region
- * bitmap_print_to_pagebuf(list, buf, mask, nbits) Print bitmap src as list/hex
  */
 
 /*
@@ -96,10 +93,10 @@ extern int __bitmap_equal(const unsigned long *bitmap1,
                           const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_complement(unsigned long *dst, const unsigned long *src,
                         unsigned int nbits);
-extern void __bitmap_shift_right(unsigned long *dst,
-                        const unsigned long *src, int shift, int bits);
-extern void __bitmap_shift_left(unsigned long *dst,
-                        const unsigned long *src, int shift, int bits);
+extern void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
+                                unsigned int shift, unsigned int nbits);
+extern void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
+                                unsigned int shift, unsigned int nbits);
 extern int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
                         const unsigned long *bitmap2, unsigned int nbits);
 extern void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
@@ -147,31 +144,31 @@ bitmap_find_next_zero_area(unsigned long *map,
                                               align_mask, 0);
 }
 
-extern int bitmap_scnprintf(char *buf, unsigned int len,
-                        const unsigned long *src, int nbits);
 extern int __bitmap_parse(const char *buf, unsigned int buflen, int is_user,
                         unsigned long *dst, int nbits);
 extern int bitmap_parse_user(const char __user *ubuf, unsigned int ulen,
                         unsigned long *dst, int nbits);
-extern int bitmap_scnlistprintf(char *buf, unsigned int len,
-                        const unsigned long *src, int nbits);
 extern int bitmap_parselist(const char *buf, unsigned long *maskp,
                         int nmaskbits);
 extern int bitmap_parselist_user(const char __user *ubuf, unsigned int ulen,
                         unsigned long *dst, int nbits);
 extern void bitmap_remap(unsigned long *dst, const unsigned long *src,
-                const unsigned long *old, const unsigned long *new, int bits);
+                const unsigned long *old, const unsigned long *new, unsigned int nbits);
 extern int bitmap_bitremap(int oldbit,
                 const unsigned long *old, const unsigned long *new, int bits);
 extern void bitmap_onto(unsigned long *dst, const unsigned long *orig,
-                const unsigned long *relmap, int bits);
+                const unsigned long *relmap, unsigned int bits);
 extern void bitmap_fold(unsigned long *dst, const unsigned long *orig,
-                int sz, int bits);
+                unsigned int sz, unsigned int nbits);
 extern int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
 extern void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
 extern int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
-extern void bitmap_copy_le(void *dst, const unsigned long *src, int nbits);
-extern int bitmap_ord_to_pos(const unsigned long *bitmap, int n, int bits);
+#ifdef __BIG_ENDIAN
+extern void bitmap_copy_le(unsigned long *dst, const unsigned long *src, unsigned int nbits);
+#else
+#define bitmap_copy_le bitmap_copy
+#endif
+extern unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);
 extern int bitmap_print_to_pagebuf(bool list, char *buf,
                                    const unsigned long *maskp, int nmaskbits);
 
@@ -185,33 +182,33 @@ extern int bitmap_print_to_pagebuf(bool list, char *buf,
 #define small_const_nbits(nbits) \
         (__builtin_constant_p(nbits) && (nbits) <= BITS_PER_LONG)
 
-static inline void bitmap_zero(unsigned long *dst, int nbits)
+static inline void bitmap_zero(unsigned long *dst, unsigned int nbits)
 {
         if (small_const_nbits(nbits))
                 *dst = 0UL;
         else {
-                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
                 memset(dst, 0, len);
         }
 }
 
-static inline void bitmap_fill(unsigned long *dst, int nbits)
+static inline void bitmap_fill(unsigned long *dst, unsigned int nbits)
 {
-        size_t nlongs = BITS_TO_LONGS(nbits);
+        unsigned int nlongs = BITS_TO_LONGS(nbits);
         if (!small_const_nbits(nbits)) {
-                int len = (nlongs - 1) * sizeof(unsigned long);
+                unsigned int len = (nlongs - 1) * sizeof(unsigned long);
                 memset(dst, 0xff,  len);
         }
         dst[nlongs - 1] = BITMAP_LAST_WORD_MASK(nbits);
 }
 
 static inline void bitmap_copy(unsigned long *dst, const unsigned long *src,
-                        int nbits)
+                        unsigned int nbits)
 {
         if (small_const_nbits(nbits))
                 *dst = *src;
         else {
-                int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
+                unsigned int len = BITS_TO_LONGS(nbits) * sizeof(unsigned long);
                 memcpy(dst, src, len);
         }
 }
@@ -309,22 +306,22 @@ static inline int bitmap_weight(const unsigned long *src, unsigned int nbits)
         return __bitmap_weight(src, nbits);
 }
 
-static inline void bitmap_shift_right(unsigned long *dst,
-                        const unsigned long *src, int n, int nbits)
+static inline void bitmap_shift_right(unsigned long *dst, const unsigned long *src,
+                                unsigned int shift, int nbits)
 {
         if (small_const_nbits(nbits))
-                *dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> n;
+                *dst = (*src & BITMAP_LAST_WORD_MASK(nbits)) >> shift;
         else
-                __bitmap_shift_right(dst, src, n, nbits);
+                __bitmap_shift_right(dst, src, shift, nbits);
 }
 
-static inline void bitmap_shift_left(unsigned long *dst,
-                        const unsigned long *src, int n, int nbits)
+static inline void bitmap_shift_left(unsigned long *dst, const unsigned long *src,
+                                unsigned int shift, unsigned int nbits)
 {
         if (small_const_nbits(nbits))
-                *dst = (*src << n) & BITMAP_LAST_WORD_MASK(nbits);
+                *dst = (*src << shift) & BITMAP_LAST_WORD_MASK(nbits);
         else
-                __bitmap_shift_left(dst, src, n, nbits);
+                __bitmap_shift_left(dst, src, shift, nbits);
 }
 
 static inline int bitmap_parse(const char *buf, unsigned int buflen,
diff --git a/include/linux/bitrev.h b/include/linux/bitrev.h
index 7ffe03f4693d..fb790b8449c1 100644
--- a/include/linux/bitrev.h
+++ b/include/linux/bitrev.h
@@ -3,14 +3,83 @@
 
 #include <linux/types.h>
 
-extern u8 const byte_rev_table[256];
+#ifdef CONFIG_HAVE_ARCH_BITREVERSE
+#include <asm/bitrev.h>
+
+#define __bitrev32 __arch_bitrev32
+#define __bitrev16 __arch_bitrev16
+#define __bitrev8 __arch_bitrev8
 
-static inline u8 bitrev8(u8 byte)
+#else
+extern u8 const byte_rev_table[256];
+static inline u8 __bitrev8(u8 byte)
 {
         return byte_rev_table[byte];
 }
 
-extern u16 bitrev16(u16 in);
-extern u32 bitrev32(u32 in);
+static inline u16 __bitrev16(u16 x)
+{
+        return (__bitrev8(x & 0xff) << 8) | __bitrev8(x >> 8);
+}
+
+static inline u32 __bitrev32(u32 x)
+{
+        return (__bitrev16(x & 0xffff) << 16) | __bitrev16(x >> 16);
+}
+
+#endif /* CONFIG_HAVE_ARCH_BITREVERSE */
+
+#define __constant_bitrev32(x)  \
+({                                      \
+        u32 __x = x;                    \
+        __x = (__x >> 16) | (__x << 16);        \
+        __x = ((__x & (u32)0xFF00FF00UL) >> 8) | ((__x & (u32)0x00FF00FFUL) << 8);      \
+        __x = ((__x & (u32)0xF0F0F0F0UL) >> 4) | ((__x & (u32)0x0F0F0F0FUL) << 4);      \
+        __x = ((__x & (u32)0xCCCCCCCCUL) >> 2) | ((__x & (u32)0x33333333UL) << 2);      \
+        __x = ((__x & (u32)0xAAAAAAAAUL) >> 1) | ((__x & (u32)0x55555555UL) << 1);      \
+        __x;                                                            \
+})
+
+#define __constant_bitrev16(x)  \
+({                                      \
+        u16 __x = x;                    \
+        __x = (__x >> 8) | (__x << 8);  \
+        __x = ((__x & (u16)0xF0F0U) >> 4) | ((__x & (u16)0x0F0FU) << 4);        \
+        __x = ((__x & (u16)0xCCCCU) >> 2) | ((__x & (u16)0x3333U) << 2);        \
+        __x = ((__x & (u16)0xAAAAU) >> 1) | ((__x & (u16)0x5555U) << 1);        \
+        __x;                                                            \
+})
+
+#define __constant_bitrev8(x)   \
+({                                      \
+        u8 __x = x;                     \
+        __x = (__x >> 4) | (__x << 4);  \
+        __x = ((__x & (u8)0xCCU) >> 2) | ((__x & (u8)0x33U) << 2);      \
+        __x = ((__x & (u8)0xAAU) >> 1) | ((__x & (u8)0x55U) << 1);      \
+        __x;                                                            \
+})
+
+#define bitrev32(x) \
+({                      \
+        u32 __x = x;    \
+        __builtin_constant_p(__x) ?     \
+        __constant_bitrev32(__x) :                      \
+        __bitrev32(__x);                                \
+})
+
+#define bitrev16(x) \
+({                      \
+        u16 __x = x;    \
+        __builtin_constant_p(__x) ?     \
+        __constant_bitrev16(__x) :                      \
+        __bitrev16(__x);                                \
+ })
 
+#define bitrev8(x) \
+({                      \
+        u8 __x = x;     \
+        __builtin_constant_p(__x) ?     \
+        __constant_bitrev8(__x) :                       \
+        __bitrev8(__x)  ;                       \
+ })
 #endif /* _LINUX_BITREV_H */
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 8aded9ab2e4e..7aec86127335 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -34,7 +34,6 @@ struct blk_mq_hw_ctx {
         unsigned long           flags;          /* BLK_MQ_F_* flags */
 
         struct request_queue    *queue;
-        unsigned int            queue_num;
         struct blk_flush_queue  *fq;
 
         void                    *driver_data;
@@ -54,7 +53,7 @@ struct blk_mq_hw_ctx {
         unsigned long           dispatched[BLK_MQ_MAX_DISPATCH_ORDER];
 
         unsigned int            numa_node;
-        unsigned int            cmd_size;       /* per-request extra data */
+        unsigned int            queue_num;
 
         atomic_t                nr_active;
 
@@ -147,6 +146,8 @@ enum {
         BLK_MQ_F_SG_MERGE       = 1 << 2,
         BLK_MQ_F_SYSFS_UP       = 1 << 3,
         BLK_MQ_F_DEFER_ISSUE    = 1 << 4,
+        BLK_MQ_F_ALLOC_POLICY_START_BIT = 8,
+        BLK_MQ_F_ALLOC_POLICY_BITS = 1,
 
         BLK_MQ_S_STOPPED        = 0,
         BLK_MQ_S_TAG_ACTIVE     = 1,
@@ -155,6 +156,12 @@ enum {
 
         BLK_MQ_CPU_WORK_BATCH   = 8,
 };
+#define BLK_MQ_FLAG_TO_ALLOC_POLICY(flags) \
+        ((flags >> BLK_MQ_F_ALLOC_POLICY_START_BIT) & \
+                ((1 << BLK_MQ_F_ALLOC_POLICY_BITS) - 1))
+#define BLK_ALLOC_POLICY_TO_MQ_FLAG(policy) \
+        ((policy & ((1 << BLK_MQ_F_ALLOC_POLICY_BITS) - 1)) \
+                << BLK_MQ_F_ALLOC_POLICY_START_BIT)
 
 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *);
 void blk_mq_finish_init(struct request_queue *q);
@@ -167,7 +174,6 @@ void blk_mq_free_tag_set(struct blk_mq_tag_set *set);
 void blk_mq_flush_plug_list(struct blk_plug *plug, bool from_schedule);
 
 void blk_mq_insert_request(struct request *, bool, bool, bool);
-void blk_mq_run_queues(struct request_queue *q, bool async);
 void blk_mq_free_request(struct request *rq);
 void blk_mq_free_hctx_request(struct blk_mq_hw_ctx *, struct request *rq);
 bool blk_mq_can_queue(struct blk_mq_hw_ctx *);
@@ -195,13 +201,16 @@ static inline u16 blk_mq_unique_tag_to_tag(u32 unique_tag)
 struct blk_mq_hw_ctx *blk_mq_map_queue(struct request_queue *, const int ctx_index);
 struct blk_mq_hw_ctx *blk_mq_alloc_single_hw_queue(struct blk_mq_tag_set *, unsigned int, int);
 
+int blk_mq_request_started(struct request *rq);
 void blk_mq_start_request(struct request *rq);
 void blk_mq_end_request(struct request *rq, int error);
 void __blk_mq_end_request(struct request *rq, int error);
 
 void blk_mq_requeue_request(struct request *rq);
 void blk_mq_add_to_requeue_list(struct request *rq, bool at_head);
+void blk_mq_cancel_requeue_work(struct request_queue *q);
 void blk_mq_kick_requeue_list(struct request_queue *q);
+void blk_mq_abort_requeue_list(struct request_queue *q);
 void blk_mq_complete_request(struct request *rq);
 
 void blk_mq_stop_hw_queue(struct blk_mq_hw_ctx *hctx);
@@ -212,6 +221,9 @@ void blk_mq_start_stopped_hw_queues(struct request_queue *q, bool async);
 void blk_mq_delay_queue(struct blk_mq_hw_ctx *hctx, unsigned long msecs);
 void blk_mq_tag_busy_iter(struct blk_mq_hw_ctx *hctx, busy_iter_fn *fn,
                 void *priv);
+void blk_mq_freeze_queue(struct request_queue *q);
+void blk_mq_unfreeze_queue(struct request_queue *q);
+void blk_mq_freeze_queue_start(struct request_queue *q);
 
 /*
  * Driver command data is immediately after the request. So subtract request
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 445d59231bc4..c294e3e25e37 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -190,6 +190,7 @@ enum rq_flag_bits {
         __REQ_PM,               /* runtime pm request */
         __REQ_HASHED,           /* on IO scheduler merge hash */
         __REQ_MQ_INFLIGHT,      /* track inflight for MQ */
+        __REQ_NO_TIMEOUT,       /* requests may never expire */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -243,5 +244,6 @@ enum rq_flag_bits {
 #define REQ_PM                  (1ULL << __REQ_PM)
 #define REQ_HASHED              (1ULL << __REQ_HASHED)
 #define REQ_MQ_INFLIGHT         (1ULL << __REQ_MQ_INFLIGHT)
+#define REQ_NO_TIMEOUT          (1ULL << __REQ_NO_TIMEOUT)
 
 #endif /* __LINUX_BLK_TYPES_H */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 92f4b4b288dd..7f9a516f24de 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -272,7 +272,11 @@ struct blk_queue_tag {
         int max_depth;                  /* what we will send to device */
         int real_max_depth;             /* what the array can hold */
         atomic_t refcnt;                /* map can be shared */
+        int alloc_policy;               /* tag allocation policy */
+        int next_tag;                   /* next tag */
 };
+#define BLK_TAG_ALLOC_FIFO 0 /* allocate starting from 0 */
+#define BLK_TAG_ALLOC_RR 1 /* allocate starting from last allocated tag */
 
 #define BLK_SCSI_MAX_CMDS       (256)
 #define BLK_SCSI_CMD_PER_LONG   (BLK_SCSI_MAX_CMDS / (sizeof(long) * 8))
@@ -516,6 +520,7 @@ struct request_queue {
                                  (1 << QUEUE_FLAG_ADD_RANDOM))
 
 #define QUEUE_FLAG_MQ_DEFAULT   ((1 << QUEUE_FLAG_IO_STAT) |            \
+                                 (1 << QUEUE_FLAG_STACKABLE)    |       \
                                  (1 << QUEUE_FLAG_SAME_COMP))
 
 static inline void queue_lockdep_assert_held(struct request_queue *q)
@@ -850,8 +855,8 @@ extern int blk_rq_map_user(struct request_queue *, struct request *,
 extern int blk_rq_unmap_user(struct bio *);
 extern int blk_rq_map_kern(struct request_queue *, struct request *, void *, unsigned int, gfp_t);
 extern int blk_rq_map_user_iov(struct request_queue *, struct request *,
-                               struct rq_map_data *, const struct sg_iovec *,
-                               int, unsigned int, gfp_t);
+                               struct rq_map_data *, const struct iov_iter *,
+                               gfp_t);
 extern int blk_execute_rq(struct request_queue *, struct gendisk *,
                           struct request *, int);
 extern void blk_execute_rq_nowait(struct request_queue *, struct gendisk *,
@@ -1044,8 +1049,6 @@ extern void blk_queue_flush_queueable(struct request_queue *q, bool queueable);
 extern struct backing_dev_info *blk_get_backing_dev_info(struct block_device *bdev);
 
 extern int blk_rq_map_sg(struct request_queue *, struct request *, struct scatterlist *);
-extern int blk_bio_map_sg(struct request_queue *q, struct bio *bio,
-                          struct scatterlist *sglist);
 extern void blk_dump_rq_flags(struct request *, char *);
 extern long nr_blockdev_pages(void);
 
@@ -1139,11 +1142,11 @@ static inline bool blk_needs_flush_plug(struct task_struct *tsk)
 extern int blk_queue_start_tag(struct request_queue *, struct request *);
 extern struct request *blk_queue_find_tag(struct request_queue *, int);
 extern void blk_queue_end_tag(struct request_queue *, struct request *);
-extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *);
+extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *, int);
 extern void blk_queue_free_tags(struct request_queue *);
 extern int blk_queue_resize_tags(struct request_queue *, int);
 extern void blk_queue_invalidate_tags(struct request_queue *);
-extern struct blk_queue_tag *blk_init_tags(int);
+extern struct blk_queue_tag *blk_init_tags(int, int);
 extern void blk_free_tags(struct blk_queue_tag *);
 
 static inline struct request *blk_map_queue_find_tag(struct blk_queue_tag *bqt,
@@ -1162,7 +1165,7 @@ extern int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
 extern int blkdev_issue_write_same(struct block_device *bdev, sector_t sector,
                 sector_t nr_sects, gfp_t gfp_mask, struct page *page);
 extern int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector,
-                        sector_t nr_sects, gfp_t gfp_mask);
+                sector_t nr_sects, gfp_t gfp_mask, bool discard);
 static inline int sb_issue_discard(struct super_block *sb, sector_t block,
                 sector_t nr_blocks, gfp_t gfp_mask, unsigned long flags)
 {
@@ -1176,7 +1179,7 @@ static inline int sb_issue_zeroout(struct super_block *sb, sector_t block,
         return blkdev_issue_zeroout(sb->s_bdev,
                                     block << (sb->s_blocksize_bits - 9),
                                     nr_blocks << (sb->s_blocksize_bits - 9),
-                                    gfp_mask);
+                                    gfp_mask, true);
 }
 
 extern int blk_verify_command(unsigned char *cmd, fmode_t has_write_perm);
@@ -1601,8 +1604,8 @@ struct block_device_operations {
         int (*rw_page)(struct block_device *, sector_t, struct page *, int rw);
         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
-        int (*direct_access) (struct block_device *, sector_t,
-                                                void **, unsigned long *);
+        long (*direct_access)(struct block_device *, sector_t,
+                                        void **, unsigned long *pfn, long size);
         unsigned int (*check_events) (struct gendisk *disk,
                                       unsigned int clearing);
         /* ->media_changed() is DEPRECATED, use ->check_events() instead */
@@ -1620,6 +1623,8 @@ extern int __blkdev_driver_ioctl(struct block_device *, fmode_t, unsigned int,
 extern int bdev_read_page(struct block_device *, sector_t, struct page *);
 extern int bdev_write_page(struct block_device *, sector_t, struct page *,
                                                 struct writeback_control *);
+extern long bdev_direct_access(struct block_device *, sector_t, void **addr,
+                                                unsigned long *pfn, long size);
 #else /* CONFIG_BLOCK */
 
 struct block_device;
diff --git a/include/linux/cdev.h b/include/linux/cdev.h
index fb4591977b03..f8763615a5f2 100644
--- a/include/linux/cdev.h
+++ b/include/linux/cdev.h
@@ -30,6 +30,4 @@ void cdev_del(struct cdev *);
 
 void cd_forget(struct inode *);
 
-extern struct backing_dev_info directly_mappable_cdev_bdi;
-
 #endif
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 5d86416d35f2..61b19c46bdb3 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -87,8 +87,8 @@ struct ceph_osd_req_op {
                         struct ceph_osd_data osd_data;
                 } extent;
                 struct {
-                        __le32 name_len;
-                        __le32 value_len;
+                        u32 name_len;
+                        u32 value_len;
                         __u8 cmp_op;       /* CEPH_OSD_CMPXATTR_OP_* */
                         __u8 cmp_mode;     /* CEPH_OSD_CMPXATTR_MODE_* */
                         struct ceph_osd_data osd_data;
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index da0dae0600e6..b9cb94c3102a 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -943,6 +943,8 @@ struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
 
 #else /* !CONFIG_CGROUPS */
 
+struct cgroup_subsys_state;
+
 static inline int cgroup_init_early(void) { return 0; }
 static inline int cgroup_init(void) { return 0; }
 static inline void cgroup_fork(struct task_struct *p) {}
@@ -955,6 +957,8 @@ static inline int cgroupstats_build(struct cgroupstats *stats,
         return -EINVAL;
 }
 
+static inline void css_put(struct cgroup_subsys_state *css) {}
+
 /* No cgroups - nothing to do */
 static inline int cgroup_attach_task_all(struct task_struct *from,
                                          struct task_struct *t)
diff --git a/include/linux/cgroup_subsys.h b/include/linux/cgroup_subsys.h
index 98c4f9b12b03..e4a96fb14403 100644
--- a/include/linux/cgroup_subsys.h
+++ b/include/linux/cgroup_subsys.h
@@ -15,6 +15,10 @@ SUBSYS(cpu)
 SUBSYS(cpuacct)
 #endif
 
+#if IS_ENABLED(CONFIG_BLK_CGROUP)
+SUBSYS(blkio)
+#endif
+
 #if IS_ENABLED(CONFIG_MEMCG)
 SUBSYS(memory)
 #endif
@@ -31,10 +35,6 @@ SUBSYS(freezer)
 SUBSYS(net_cls)
 #endif
 
-#if IS_ENABLED(CONFIG_BLK_CGROUP)
-SUBSYS(blkio)
-#endif
-
 #if IS_ENABLED(CONFIG_CGROUP_PERF)
 SUBSYS(perf_event)
 #endif
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index abcafaa20b86..9c78d15d33e4 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -18,8 +18,6 @@
 #include <asm/div64.h>
 #include <asm/io.h>
 
-/* clocksource cycle base type */
-typedef u64 cycle_t;
 struct clocksource;
 struct module;
 
@@ -28,106 +26,6 @@ struct module;
 #endif
 
 /**
- * struct cyclecounter - hardware abstraction for a free running counter
- *      Provides completely state-free accessors to the underlying hardware.
- *      Depending on which hardware it reads, the cycle counter may wrap
- *      around quickly. Locking rules (if necessary) have to be defined
- *      by the implementor and user of specific instances of this API.
- *
- * @read:               returns the current cycle value
- * @mask:               bitmask for two's complement
- *                      subtraction of non 64 bit counters,
- *                      see CLOCKSOURCE_MASK() helper macro
- * @mult:               cycle to nanosecond multiplier
- * @shift:              cycle to nanosecond divisor (power of two)
- */
-struct cyclecounter {
-        cycle_t (*read)(const struct cyclecounter *cc);
-        cycle_t mask;
-        u32 mult;
-        u32 shift;
-};
-
-/**
- * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds
- *      Contains the state needed by timecounter_read() to detect
- *      cycle counter wrap around. Initialize with
- *      timecounter_init(). Also used to convert cycle counts into the
- *      corresponding nanosecond counts with timecounter_cyc2time(). Users
- *      of this code are responsible for initializing the underlying
- *      cycle counter hardware, locking issues and reading the time
- *      more often than the cycle counter wraps around. The nanosecond
- *      counter will only wrap around after ~585 years.
- *
- * @cc:                 the cycle counter used by this instance
- * @cycle_last:         most recent cycle counter value seen by
- *                      timecounter_read()
- * @nsec:               continuously increasing count
- */
-struct timecounter {
-        const struct cyclecounter *cc;
-        cycle_t cycle_last;
-        u64 nsec;
-};
-
-/**
- * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds
- * @cc:         Pointer to cycle counter.
- * @cycles:     Cycles
- *
- * XXX - This could use some mult_lxl_ll() asm optimization. Same code
- * as in cyc2ns, but with unsigned result.
- */
-static inline u64 cyclecounter_cyc2ns(const struct cyclecounter *cc,
-                                      cycle_t cycles)
-{
-        u64 ret = (u64)cycles;
-        ret = (ret * cc->mult) >> cc->shift;
-        return ret;
-}
-
-/**
- * timecounter_init - initialize a time counter
- * @tc:                 Pointer to time counter which is to be initialized/reset
- * @cc:                 A cycle counter, ready to be used.
- * @start_tstamp:       Arbitrary initial time stamp.
- *
- * After this call the current cycle register (roughly) corresponds to
- * the initial time stamp. Every call to timecounter_read() increments
- * the time stamp counter by the number of elapsed nanoseconds.
- */
-extern void timecounter_init(struct timecounter *tc,
-                             const struct cyclecounter *cc,
-                             u64 start_tstamp);
-
-/**
- * timecounter_read - return nanoseconds elapsed since timecounter_init()
- *                    plus the initial time stamp
- * @tc:          Pointer to time counter.
- *
- * In other words, keeps track of time since the same epoch as
- * the function which generated the initial time stamp.
- */
-extern u64 timecounter_read(struct timecounter *tc);
-
-/**
- * timecounter_cyc2time - convert a cycle counter to same
- *                        time base as values returned by
- *                        timecounter_read()
- * @tc:         Pointer to time counter.
- * @cycle_tstamp:       a value returned by tc->cc->read()
- *
- * Cycle counts that are converted correctly as long as they
- * fall into the interval [-1/2 max cycle count, +1/2 max cycle count],
- * with "max cycle count" == cs->mask+1.
- *
- * This allows conversion of cycle counter values which were generated
- * in the past.
- */
-extern u64 timecounter_cyc2time(struct timecounter *tc,
-                                cycle_t cycle_tstamp);
-
-/**
  * struct clocksource - hardware abstraction for a free running counter
  *      Provides mostly state-free accessors to the underlying hardware.
  *      This is the structure used for system time.
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index 3238ffa33f68..a014559e4a49 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -12,6 +12,10 @@
 #define COMPACT_PARTIAL         3
 /* The full zone was compacted */
 #define COMPACT_COMPLETE        4
+/* For more detailed tracepoint output */
+#define COMPACT_NO_SUITABLE_PAGE        5
+#define COMPACT_NOT_SUITABLE_ZONE       6
+/* When adding new state, please change compaction_status_string, too */
 
 /* Used to signal whether compaction detected need_sched() or lock contention */
 /* No contention detected */
@@ -21,6 +25,8 @@
 /* Zone lock or lru_lock was contended in async compaction */
 #define COMPACT_CONTENDED_LOCK  2
 
+struct alloc_context; /* in mm/internal.h */
+
 #ifdef CONFIG_COMPACTION
 extern int sysctl_compact_memory;
 extern int sysctl_compaction_handler(struct ctl_table *table, int write,
@@ -30,81 +36,25 @@ extern int sysctl_extfrag_handler(struct ctl_table *table, int write,
                         void __user *buffer, size_t *length, loff_t *ppos);
 
 extern int fragmentation_index(struct zone *zone, unsigned int order);
-extern unsigned long try_to_compact_pages(struct zonelist *zonelist,
-                        int order, gfp_t gfp_mask, nodemask_t *mask,
-                        enum migrate_mode mode, int *contended,
-                        int alloc_flags, int classzone_idx);
+extern unsigned long try_to_compact_pages(gfp_t gfp_mask, unsigned int order,
+                        int alloc_flags, const struct alloc_context *ac,
+                        enum migrate_mode mode, int *contended);
 extern void compact_pgdat(pg_data_t *pgdat, int order);
 extern void reset_isolation_suitable(pg_data_t *pgdat);
 extern unsigned long compaction_suitable(struct zone *zone, int order,
                                         int alloc_flags, int classzone_idx);
 
-/* Do not skip compaction more than 64 times */
-#define COMPACT_MAX_DEFER_SHIFT 6
-
-/*
- * Compaction is deferred when compaction fails to result in a page
- * allocation success. 1 << compact_defer_limit compactions are skipped up
- * to a limit of 1 << COMPACT_MAX_DEFER_SHIFT
- */
-static inline void defer_compaction(struct zone *zone, int order)
-{
-        zone->compact_considered = 0;
-        zone->compact_defer_shift++;
-
-        if (order < zone->compact_order_failed)
-                zone->compact_order_failed = order;
-
-        if (zone->compact_defer_shift > COMPACT_MAX_DEFER_SHIFT)
-                zone->compact_defer_shift = COMPACT_MAX_DEFER_SHIFT;
-}
-
-/* Returns true if compaction should be skipped this time */
-static inline bool compaction_deferred(struct zone *zone, int order)
-{
-        unsigned long defer_limit = 1UL << zone->compact_defer_shift;
-
-        if (order < zone->compact_order_failed)
-                return false;
-
-        /* Avoid possible overflow */
-        if (++zone->compact_considered > defer_limit)
-                zone->compact_considered = defer_limit;
-
-        return zone->compact_considered < defer_limit;
-}
-
-/*
- * Update defer tracking counters after successful compaction of given order,
- * which means an allocation either succeeded (alloc_success == true) or is
- * expected to succeed.
- */
-static inline void compaction_defer_reset(struct zone *zone, int order,
-                bool alloc_success)
-{
-        if (alloc_success) {
-                zone->compact_considered = 0;
-                zone->compact_defer_shift = 0;
-        }
-        if (order >= zone->compact_order_failed)
-                zone->compact_order_failed = order + 1;
-}
-
-/* Returns true if restarting compaction after many failures */
-static inline bool compaction_restarting(struct zone *zone, int order)
-{
-        if (order < zone->compact_order_failed)
-                return false;
-
-        return zone->compact_defer_shift == COMPACT_MAX_DEFER_SHIFT &&
-                zone->compact_considered >= 1UL << zone->compact_defer_shift;
-}
+extern void defer_compaction(struct zone *zone, int order);
+extern bool compaction_deferred(struct zone *zone, int order);
+extern void compaction_defer_reset(struct zone *zone, int order,
+                                bool alloc_success);
+extern bool compaction_restarting(struct zone *zone, int order);
 
 #else
-static inline unsigned long try_to_compact_pages(struct zonelist *zonelist,
-                        int order, gfp_t gfp_mask, nodemask_t *nodemask,
-                        enum migrate_mode mode, int *contended,
-                        int alloc_flags, int classzone_idx)
+static inline unsigned long try_to_compact_pages(gfp_t gfp_mask,
+                        unsigned int order, int alloc_flags,
+                        const struct alloc_context *ac,
+                        enum migrate_mode mode, int *contended)
 {
         return COMPACT_CONTINUE;
 }
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 7450ca2ac1fc..ab25814690bc 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -689,6 +689,15 @@ asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
 asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
                                        compat_stack_t __user *uoss_ptr);
 
+#ifdef __ARCH_WANT_SYS_SIGPENDING
+asmlinkage long compat_sys_sigpending(compat_old_sigset_t __user *set);
+#endif
+
+#ifdef __ARCH_WANT_SYS_SIGPROCMASK
+asmlinkage long compat_sys_sigprocmask(int how, compat_old_sigset_t __user *nset,
+                                       compat_old_sigset_t __user *oset);
+#endif
+
 int compat_restore_altstack(const compat_stack_t __user *uss);
 int __compat_save_altstack(compat_stack_t __user *, unsigned long);
 #define compat_save_altstack_ex(uss, sp) do { \
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 02ae99e8e6d3..cdf13ca7cac3 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -66,6 +66,7 @@
 #define __deprecated                    __attribute__((deprecated))
 #define __packed                        __attribute__((packed))
 #define __weak                          __attribute__((weak))
+#define __alias(symbol)         __attribute__((alias(#symbol)))
 
 /*
  * it doesn't make sense on ARM (currently the only user of __naked) to trace
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index d1a558239b1a..769e19864632 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -85,3 +85,7 @@
 #define __HAVE_BUILTIN_BSWAP16__
 #endif
 #endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
+
+#if GCC_VERSION >= 40902
+#define KASAN_ABI_VERSION 3
+#endif
diff --git a/include/linux/compiler-gcc5.h b/include/linux/compiler-gcc5.h
index c8c565952548..efee493714eb 100644
--- a/include/linux/compiler-gcc5.h
+++ b/include/linux/compiler-gcc5.h
@@ -63,3 +63,5 @@
 #define __HAVE_BUILTIN_BSWAP64__
 #define __HAVE_BUILTIN_BSWAP16__
 #endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
+
+#define KASAN_ABI_VERSION 4
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index a1c81f80978e..d1ec10a940ff 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -54,7 +54,11 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 #include <linux/compiler-gcc.h>
 #endif
 
+#ifdef CC_USING_HOTPATCH
+#define notrace __attribute__((hotpatch(0,0)))
+#else
 #define notrace __attribute__((no_instrument_function))
+#endif
 
 /* Intel compiler defines __GNUC__. So we will overwrite implementations
  * coming from above header files here
@@ -215,7 +219,7 @@ static __always_inline void __read_once_size(volatile void *p, void *res, int si
         }
 }
 
-static __always_inline void __assign_once_size(volatile void *p, void *res, int size)
+static __always_inline void __write_once_size(volatile void *p, void *res, int size)
 {
         switch (size) {
         case 1: *(volatile __u8 *)p = *(__u8 *)res; break;
@@ -235,15 +239,15 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
 /*
  * Prevent the compiler from merging or refetching reads or writes. The
  * compiler is also forbidden from reordering successive instances of
- * READ_ONCE, ASSIGN_ONCE and ACCESS_ONCE (see below), but only when the
+ * READ_ONCE, WRITE_ONCE and ACCESS_ONCE (see below), but only when the
  * compiler is aware of some particular ordering.  One way to make the
  * compiler aware of ordering is to put the two invocations of READ_ONCE,
- * ASSIGN_ONCE or ACCESS_ONCE() in different C statements.
+ * WRITE_ONCE or ACCESS_ONCE() in different C statements.
  *
  * In contrast to ACCESS_ONCE these two macros will also work on aggregate
  * data types like structs or unions. If the size of the accessed data
  * type exceeds the word size of the machine (e.g., 32 bits or 64 bits)
- * READ_ONCE() and ASSIGN_ONCE()  will fall back to memcpy and print a
+ * READ_ONCE() and WRITE_ONCE()  will fall back to memcpy and print a
  * compile-time warning.
  *
  * Their two major use cases are: (1) Mediating communication between
@@ -257,8 +261,8 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
 #define READ_ONCE(x) \
         ({ typeof(x) __val; __read_once_size(&x, &__val, sizeof(__val)); __val; })
 
-#define ASSIGN_ONCE(val, x) \
-        ({ typeof(x) __val; __val = val; __assign_once_size(&x, &__val, sizeof(__val)); __val; })
+#define WRITE_ONCE(x, val) \
+        ({ typeof(x) __val; __val = val; __write_once_size(&x, &__val, sizeof(__val)); __val; })
 
 #endif /* __KERNEL__ */
 
@@ -385,7 +389,7 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
 
 /* Is this type a native word size -- useful for atomic operations */
 #ifndef __native_word
-# define __native_word(t) (sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
+# define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
 #endif
 
 /* Compile time object size, -1 for unknown */
@@ -447,12 +451,23 @@ static __always_inline void __assign_once_size(volatile void *p, void *res, int
  * to make the compiler aware of ordering is to put the two invocations of
  * ACCESS_ONCE() in different C statements.
  *
- * This macro does absolutely -nothing- to prevent the CPU from reordering,
- * merging, or refetching absolutely anything at any time.  Its main intended
- * use is to mediate communication between process-level code and irq/NMI
- * handlers, all running on the same CPU.
+ * ACCESS_ONCE will only work on scalar types. For union types, ACCESS_ONCE
+ * on a union member will work as long as the size of the member matches the
+ * size of the union and the size is smaller than word size.
+ *
+ * The major use cases of ACCESS_ONCE used to be (1) Mediating communication
+ * between process-level code and irq/NMI handlers, all running on the same CPU,
+ * and (2) Ensuring that the compiler does not  fold, spindle, or otherwise
+ * mutilate accesses that either do not require ordering or that interact
+ * with an explicit memory barrier or atomic instruction that provides the
+ * required ordering.
+ *
+ * If possible use READ_ONCE/ASSIGN_ONCE instead.
  */
-#define ACCESS_ONCE(x) (*(volatile typeof(x) *)&(x))
+#define __ACCESS_ONCE(x) ({ \
+         __maybe_unused typeof(x) __var = (__force typeof(x)) 0; \
+        (volatile typeof(x) *)&(x); })
+#define ACCESS_ONCE(x) (*__ACCESS_ONCE(x))
 
 /* Ignore/forbid kprobes attach on very low level functions marked by this attribute: */
 #ifdef CONFIG_KPROBES
diff --git a/include/linux/coresight.h b/include/linux/coresight.h
index 5d3c54311f7a..3486b9082adb 100644
--- a/include/linux/coresight.h
+++ b/include/linux/coresight.h
@@ -179,15 +179,6 @@ struct coresight_device {
 #define sink_ops(csdev)         csdev->ops->sink_ops
 #define link_ops(csdev)         csdev->ops->link_ops
 
-#define CORESIGHT_DEBUGFS_ENTRY(__name, __entry_name,                   \
-                                 __mode, __get, __set, __fmt)           \
-DEFINE_SIMPLE_ATTRIBUTE(__name ## _ops, __get, __set, __fmt);           \
-static const struct coresight_ops_entry __name ## _entry = {            \
-        .name = __entry_name,                                           \
-        .mode = __mode,                                                 \
-        .ops  = &__name ## _ops                                         \
-}
-
 /**
  * struct coresight_ops_sink - basic operations for a sink
  * Operations available for sinks
@@ -236,13 +227,8 @@ coresight_register(struct coresight_desc *desc);
 extern void coresight_unregister(struct coresight_device *csdev);
 extern int coresight_enable(struct coresight_device *csdev);
 extern void coresight_disable(struct coresight_device *csdev);
-extern int coresight_is_bit_set(u32 val, int position, int value);
 extern int coresight_timeout(void __iomem *addr, u32 offset,
                              int position, int value);
-#ifdef CONFIG_OF
-extern struct coresight_platform_data *of_get_coresight_platform_data(
-                                struct device *dev, struct device_node *node);
-#endif
 #else
 static inline struct coresight_device *
 coresight_register(struct coresight_desc *desc) { return NULL; }
@@ -250,14 +236,16 @@ static inline void coresight_unregister(struct coresight_device *csdev) {}
 static inline int
 coresight_enable(struct coresight_device *csdev) { return -ENOSYS; }
 static inline void coresight_disable(struct coresight_device *csdev) {}
-static inline int coresight_is_bit_set(u32 val, int position, int value)
-                                         { return 0; }
 static inline int coresight_timeout(void __iomem *addr, u32 offset,
                                      int position, int value) { return 1; }
+#endif
+
 #ifdef CONFIG_OF
+extern struct coresight_platform_data *of_get_coresight_platform_data(
+                                struct device *dev, struct device_node *node);
+#else
 static inline struct coresight_platform_data *of_get_coresight_platform_data(
         struct device *dev, struct device_node *node) { return NULL; }
 #endif
-#endif
 
 #endif
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
index c303d383def1..bd955270d5aa 100644
--- a/include/linux/cpu_cooling.h
+++ b/include/linux/cpu_cooling.h
@@ -50,7 +50,7 @@ static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 #endif
 
@@ -65,13 +65,13 @@ unsigned long cpufreq_cooling_get_level(unsigned int cpu, unsigned int freq);
 static inline struct thermal_cooling_device *
 cpufreq_cooling_register(const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 static inline struct thermal_cooling_device *
 of_cpufreq_cooling_register(struct device_node *np,
                             const struct cpumask *clip_cpus)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 static inline
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev)
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index 4d078cebafd2..2ee4888c1f47 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -66,8 +66,6 @@ struct cpufreq_policy {
         unsigned int            shared_type; /* ACPI: ANY or ALL affected CPUs
                                                 should set cpufreq */
         unsigned int            cpu;    /* cpu nr of CPU managing this policy */
-        unsigned int            last_cpu; /* cpu nr of previous CPU that managed
-                                           * this policy */
         struct clk              *clk;
         struct cpufreq_cpuinfo  cpuinfo;/* see above */
 
@@ -113,6 +111,9 @@ struct cpufreq_policy {
         wait_queue_head_t       transition_wait;
         struct task_struct      *transition_task; /* Task which is doing the transition */
 
+        /* cpufreq-stats */
+        struct cpufreq_stats    *stats;
+
         /* For cpufreq driver's internal use */
         void                    *driver_data;
 };
@@ -367,9 +368,8 @@ static inline void cpufreq_resume(void) {}
 #define CPUFREQ_INCOMPATIBLE            (1)
 #define CPUFREQ_NOTIFY                  (2)
 #define CPUFREQ_START                   (3)
-#define CPUFREQ_UPDATE_POLICY_CPU       (4)
-#define CPUFREQ_CREATE_POLICY           (5)
-#define CPUFREQ_REMOVE_POLICY           (6)
+#define CPUFREQ_CREATE_POLICY           (4)
+#define CPUFREQ_REMOVE_POLICY           (5)
 
 #ifdef CONFIG_CPU_FREQ
 int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index a07e087f54b2..ab70f3bc44ad 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -53,7 +53,6 @@ struct cpuidle_state {
 };
 
 /* Idle State Flags */
-#define CPUIDLE_FLAG_TIME_INVALID       (0x01) /* is residency time measurable? */
 #define CPUIDLE_FLAG_COUPLED    (0x02) /* state applies to multiple cpus */
 #define CPUIDLE_FLAG_TIMER_STOP (0x04)  /* timer is stopped on this state */
 
@@ -89,8 +88,6 @@ DECLARE_PER_CPU(struct cpuidle_device, cpuidle_dev);
 /**
  * cpuidle_get_last_residency - retrieves the last state's residency time
  * @dev: the target CPU
- *
- * NOTE: this value is invalid if CPUIDLE_FLAG_TIME_INVALID is set
  */
 static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
 {
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index b950e9d6008b..086549a665e2 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -22,6 +22,14 @@ typedef struct cpumask { DECLARE_BITMAP(bits, NR_CPUS); } cpumask_t;
  */
 #define cpumask_bits(maskp) ((maskp)->bits)
 
+/**
+ * cpumask_pr_args - printf args to output a cpumask
+ * @maskp: cpumask to be printed
+ *
+ * Can be used to provide arguments for '%*pb[l]' when printing a cpumask.
+ */
+#define cpumask_pr_args(maskp)          nr_cpu_ids, cpumask_bits(maskp)
+
 #if NR_CPUS == 1
 #define nr_cpu_ids              1
 #else
@@ -539,21 +547,6 @@ static inline void cpumask_copy(struct cpumask *dstp,
 #define cpumask_of(cpu) (get_cpu_mask(cpu))
 
 /**
- * cpumask_scnprintf - print a cpumask into a string as comma-separated hex
- * @buf: the buffer to sprintf into
- * @len: the length of the buffer
- * @srcp: the cpumask to print
- *
- * If len is zero, returns zero.  Otherwise returns the length of the
- * (nul-terminated) @buf string.
- */
-static inline int cpumask_scnprintf(char *buf, int len,
-                                    const struct cpumask *srcp)
-{
-        return bitmap_scnprintf(buf, len, cpumask_bits(srcp), nr_cpumask_bits);
-}
-
-/**
  * cpumask_parse_user - extract a cpumask from a user string
  * @buf: the buffer to extract from
  * @len: the length of the buffer
@@ -564,7 +557,7 @@ static inline int cpumask_scnprintf(char *buf, int len,
 static inline int cpumask_parse_user(const char __user *buf, int len,
                                      struct cpumask *dstp)
 {
-        return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpumask_bits);
+        return bitmap_parse_user(buf, len, cpumask_bits(dstp), nr_cpu_ids);
 }
 
 /**
@@ -579,23 +572,7 @@ static inline int cpumask_parselist_user(const char __user *buf, int len,
                                      struct cpumask *dstp)
 {
         return bitmap_parselist_user(buf, len, cpumask_bits(dstp),
-                                                        nr_cpumask_bits);
-}
-
-/**
- * cpulist_scnprintf - print a cpumask into a string as comma-separated list
- * @buf: the buffer to sprintf into
- * @len: the length of the buffer
- * @srcp: the cpumask to print
- *
- * If len is zero, returns zero.  Otherwise returns the length of the
- * (nul-terminated) @buf string.
- */
-static inline int cpulist_scnprintf(char *buf, int len,
-                                    const struct cpumask *srcp)
-{
-        return bitmap_scnlistprintf(buf, len, cpumask_bits(srcp),
-                                    nr_cpumask_bits);
+                                     nr_cpu_ids);
 }
 
 /**
@@ -610,7 +587,7 @@ static inline int cpumask_parse(const char *buf, struct cpumask *dstp)
         char *nl = strchr(buf, '\n');
         unsigned int len = nl ? (unsigned int)(nl - buf) : strlen(buf);
 
-        return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpumask_bits);
+        return bitmap_parse(buf, len, cpumask_bits(dstp), nr_cpu_ids);
 }
 
 /**
@@ -622,7 +599,7 @@ static inline int cpumask_parse(const char *buf, struct cpumask *dstp)
  */
 static inline int cpulist_parse(const char *buf, struct cpumask *dstp)
 {
-        return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpumask_bits);
+        return bitmap_parselist(buf, cpumask_bits(dstp), nr_cpu_ids);
 }
 
 /**
@@ -817,7 +794,7 @@ static inline ssize_t
 cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)
 {
         return bitmap_print_to_pagebuf(list, buf, cpumask_bits(mask),
-                                      nr_cpumask_bits);
+                                      nr_cpu_ids);
 }
 
 /*
@@ -905,13 +882,13 @@ static inline void __cpu_clear(int cpu, volatile cpumask_t *dstp)
 }
 
 #define cpus_setall(dst) __cpus_setall(&(dst), NR_CPUS)
-static inline void __cpus_setall(cpumask_t *dstp, int nbits)
+static inline void __cpus_setall(cpumask_t *dstp, unsigned int nbits)
 {
         bitmap_fill(dstp->bits, nbits);
 }
 
 #define cpus_clear(dst) __cpus_clear(&(dst), NR_CPUS)
-static inline void __cpus_clear(cpumask_t *dstp, int nbits)
+static inline void __cpus_clear(cpumask_t *dstp, unsigned int nbits)
 {
         bitmap_zero(dstp->bits, nbits);
 }
@@ -927,21 +904,21 @@ static inline int __cpu_test_and_set(int cpu, cpumask_t *addr)
 
 #define cpus_and(dst, src1, src2) __cpus_and(&(dst), &(src1), &(src2), NR_CPUS)
 static inline int __cpus_and(cpumask_t *dstp, const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         return bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_or(dst, src1, src2) __cpus_or(&(dst), &(src1), &(src2), NR_CPUS)
 static inline void __cpus_or(cpumask_t *dstp, const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_xor(dst, src1, src2) __cpus_xor(&(dst), &(src1), &(src2), NR_CPUS)
 static inline void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
@@ -949,40 +926,40 @@ static inline void __cpus_xor(cpumask_t *dstp, const cpumask_t *src1p,
 #define cpus_andnot(dst, src1, src2) \
                                 __cpus_andnot(&(dst), &(src1), &(src2), NR_CPUS)
 static inline int __cpus_andnot(cpumask_t *dstp, const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         return bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_equal(src1, src2) __cpus_equal(&(src1), &(src2), NR_CPUS)
 static inline int __cpus_equal(const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         return bitmap_equal(src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_intersects(src1, src2) __cpus_intersects(&(src1), &(src2), NR_CPUS)
 static inline int __cpus_intersects(const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         return bitmap_intersects(src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_subset(src1, src2) __cpus_subset(&(src1), &(src2), NR_CPUS)
 static inline int __cpus_subset(const cpumask_t *src1p,
-                                        const cpumask_t *src2p, int nbits)
+                                        const cpumask_t *src2p, unsigned int nbits)
 {
         return bitmap_subset(src1p->bits, src2p->bits, nbits);
 }
 
 #define cpus_empty(src) __cpus_empty(&(src), NR_CPUS)
-static inline int __cpus_empty(const cpumask_t *srcp, int nbits)
+static inline int __cpus_empty(const cpumask_t *srcp, unsigned int nbits)
 {
         return bitmap_empty(srcp->bits, nbits);
 }
 
 #define cpus_weight(cpumask) __cpus_weight(&(cpumask), NR_CPUS)
-static inline int __cpus_weight(const cpumask_t *srcp, int nbits)
+static inline int __cpus_weight(const cpumask_t *srcp, unsigned int nbits)
 {
         return bitmap_weight(srcp->bits, nbits);
 }
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 9c8776d0ada8..fb5ef16d6a12 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -1147,7 +1147,7 @@ static inline void ablkcipher_request_free(struct ablkcipher_request *req)
  * cipher operation completes.
  *
  * The callback function is registered with the ablkcipher_request handle and
- * must comply with the following template:
+ * must comply with the following template
  *
  *      void callback_function(struct crypto_async_request *req, int error)
  */
@@ -1174,7 +1174,7 @@ static inline void ablkcipher_request_set_callback(
  *
  * For encryption, the source is treated as the plaintext and the
  * destination is the ciphertext. For a decryption operation, the use is
- * reversed: the source is the ciphertext and the destination is the plaintext.
+ * reversed - the source is the ciphertext and the destination is the plaintext.
  */
 static inline void ablkcipher_request_set_crypt(
         struct ablkcipher_request *req,
@@ -1412,6 +1412,9 @@ static inline int crypto_aead_encrypt(struct aead_request *req)
  */
 static inline int crypto_aead_decrypt(struct aead_request *req)
 {
+        if (req->cryptlen < crypto_aead_authsize(crypto_aead_reqtfm(req)))
+                return -EINVAL;
+
         return crypto_aead_crt(crypto_aead_reqtfm(req))->decrypt(req);
 }
 
@@ -1506,7 +1509,7 @@ static inline void aead_request_free(struct aead_request *req)
  * completes
  *
  * The callback function is registered with the aead_request handle and
- * must comply with the following template:
+ * must comply with the following template
  *
  *      void callback_function(struct crypto_async_request *req, int error)
  */
@@ -1533,7 +1536,7 @@ static inline void aead_request_set_callback(struct aead_request *req,
  *
  * For encryption, the source is treated as the plaintext and the
  * destination is the ciphertext. For a decryption operation, the use is
- * reversed: the source is the ciphertext and the destination is the plaintext.
+ * reversed - the source is the ciphertext and the destination is the plaintext.
  *
  * IMPORTANT NOTE AEAD requires an authentication tag (MAC). For decryption,
  *                the caller must concatenate the ciphertext followed by the
diff --git a/include/linux/cryptohash.h b/include/linux/cryptohash.h
index 2cd9f1cf9fa3..f4754282c9c2 100644
--- a/include/linux/cryptohash.h
+++ b/include/linux/cryptohash.h
@@ -1,6 +1,8 @@
 #ifndef __CRYPTOHASH_H
 #define __CRYPTOHASH_H
 
+#include <uapi/linux/types.h>
+
 #define SHA_DIGEST_WORDS 5
 #define SHA_MESSAGE_BYTES (512 /*bits*/ / 8)
 #define SHA_WORKSPACE_WORDS 16
diff --git a/include/linux/devfreq-event.h b/include/linux/devfreq-event.h
new file mode 100644
index 000000000000..602fbbfcfeed
--- /dev/null
+++ b/include/linux/devfreq-event.h
@@ -0,0 +1,196 @@
+/*
+ * devfreq-event: a framework to provide raw data and events of devfreq devices
+ *
+ * Copyright (C) 2014 Samsung Electronics
+ * Author: Chanwoo Choi <cw00.choi@samsung.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_DEVFREQ_EVENT_H__
+#define __LINUX_DEVFREQ_EVENT_H__
+
+#include <linux/device.h>
+
+/**
+ * struct devfreq_event_dev - the devfreq-event device
+ *
+ * @node        : Contain the devfreq-event device that have been registered.
+ * @dev         : the device registered by devfreq-event class. dev.parent is
+ *                the device using devfreq-event.
+ * @lock        : a mutex to protect accessing devfreq-event.
+ * @enable_count: the number of enable function have been called.
+ * @desc        : the description for devfreq-event device.
+ *
+ * This structure contains devfreq-event device information.
+ */
+struct devfreq_event_dev {
+        struct list_head node;
+
+        struct device dev;
+        struct mutex lock;
+        u32 enable_count;
+
+        const struct devfreq_event_desc *desc;
+};
+
+/**
+ * struct devfreq_event_data - the devfreq-event data
+ *
+ * @load_count  : load count of devfreq-event device for the given period.
+ * @total_count : total count of devfreq-event device for the given period.
+ *                each count may represent a clock cycle, a time unit
+ *                (ns/us/...), or anything the device driver wants.
+ *                Generally, utilization is load_count / total_count.
+ *
+ * This structure contains the data of devfreq-event device for polling period.
+ */
+struct devfreq_event_data {
+        unsigned long load_count;
+        unsigned long total_count;
+};
+
+/**
+ * struct devfreq_event_ops - the operations of devfreq-event device
+ *
+ * @enable      : Enable the devfreq-event device.
+ * @disable     : Disable the devfreq-event device.
+ * @reset       : Reset all setting of the devfreq-event device.
+ * @set_event   : Set the specific event type for the devfreq-event device.
+ * @get_event   : Get the result of the devfreq-event devie with specific
+ *                event type.
+ *
+ * This structure contains devfreq-event device operations which can be
+ * implemented by devfreq-event device drivers.
+ */
+struct devfreq_event_ops {
+        /* Optional functions */
+        int (*enable)(struct devfreq_event_dev *edev);
+        int (*disable)(struct devfreq_event_dev *edev);
+        int (*reset)(struct devfreq_event_dev *edev);
+
+        /* Mandatory functions */
+        int (*set_event)(struct devfreq_event_dev *edev);
+        int (*get_event)(struct devfreq_event_dev *edev,
+                         struct devfreq_event_data *edata);
+};
+
+/**
+ * struct devfreq_event_desc - the descriptor of devfreq-event device
+ *
+ * @name        : the name of devfreq-event device.
+ * @driver_data : the private data for devfreq-event driver.
+ * @ops         : the operation to control devfreq-event device.
+ *
+ * Each devfreq-event device is described with a this structure.
+ * This structure contains the various data for devfreq-event device.
+ */
+struct devfreq_event_desc {
+        const char *name;
+        void *driver_data;
+
+        struct devfreq_event_ops *ops;
+};
+
+#if defined(CONFIG_PM_DEVFREQ_EVENT)
+extern int devfreq_event_enable_edev(struct devfreq_event_dev *edev);
+extern int devfreq_event_disable_edev(struct devfreq_event_dev *edev);
+extern bool devfreq_event_is_enabled(struct devfreq_event_dev *edev);
+extern int devfreq_event_set_event(struct devfreq_event_dev *edev);
+extern int devfreq_event_get_event(struct devfreq_event_dev *edev,
+                                struct devfreq_event_data *edata);
+extern int devfreq_event_reset_event(struct devfreq_event_dev *edev);
+extern struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(
+                                struct device *dev, int index);
+extern int devfreq_event_get_edev_count(struct device *dev);
+extern struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev,
+                                struct devfreq_event_desc *desc);
+extern int devfreq_event_remove_edev(struct devfreq_event_dev *edev);
+extern struct devfreq_event_dev *devm_devfreq_event_add_edev(struct device *dev,
+                                struct devfreq_event_desc *desc);
+extern void devm_devfreq_event_remove_edev(struct device *dev,
+                                struct devfreq_event_dev *edev);
+static inline void *devfreq_event_get_drvdata(struct devfreq_event_dev *edev)
+{
+        return edev->desc->driver_data;
+}
+#else
+static inline int devfreq_event_enable_edev(struct devfreq_event_dev *edev)
+{
+        return -EINVAL;
+}
+
+static inline int devfreq_event_disable_edev(struct devfreq_event_dev *edev)
+{
+        return -EINVAL;
+}
+
+static inline bool devfreq_event_is_enabled(struct devfreq_event_dev *edev)
+{
+        return false;
+}
+
+static inline int devfreq_event_set_event(struct devfreq_event_dev *edev)
+{
+        return -EINVAL;
+}
+
+static inline int devfreq_event_get_event(struct devfreq_event_dev *edev,
+                                        struct devfreq_event_data *edata)
+{
+        return -EINVAL;
+}
+
+static inline int devfreq_event_reset_event(struct devfreq_event_dev *edev)
+{
+        return -EINVAL;
+}
+
+static inline void *devfreq_event_get_drvdata(struct devfreq_event_dev *edev)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline struct devfreq_event_dev *devfreq_event_get_edev_by_phandle(
+                                        struct device *dev, int index)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline int devfreq_event_get_edev_count(struct device *dev)
+{
+        return -EINVAL;
+}
+
+static inline struct devfreq_event_dev *devfreq_event_add_edev(struct device *dev,
+                                        struct devfreq_event_desc *desc)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline int devfreq_event_remove_edev(struct devfreq_event_dev *edev)
+{
+        return -EINVAL;
+}
+
+static inline struct devfreq_event_dev *devm_devfreq_event_add_edev(
+                                        struct device *dev,
+                                        struct devfreq_event_desc *desc)
+{
+        return ERR_PTR(-EINVAL);
+}
+
+static inline void devm_devfreq_event_remove_edev(struct device *dev,
+                                        struct devfreq_event_dev *edev)
+{
+}
+
+static inline void *devfreq_event_get_drvdata(struct devfreq_event_dev *edev)
+{
+        return NULL;
+}
+#endif /* CONFIG_PM_DEVFREQ_EVENT */
+
+#endif /* __LINUX_DEVFREQ_EVENT_H__ */
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index ca6d2acc5eb7..2646aed1d3fe 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -48,6 +48,11 @@ typedef void (*dm_dtr_fn) (struct dm_target *ti);
 typedef int (*dm_map_fn) (struct dm_target *ti, struct bio *bio);
 typedef int (*dm_map_request_fn) (struct dm_target *ti, struct request *clone,
                                   union map_info *map_context);
+typedef int (*dm_clone_and_map_request_fn) (struct dm_target *ti,
+                                            struct request *rq,
+                                            union map_info *map_context,
+                                            struct request **clone);
+typedef void (*dm_release_clone_request_fn) (struct request *clone);
 
 /*
  * Returns:
@@ -143,6 +148,8 @@ struct target_type {
         dm_dtr_fn dtr;
         dm_map_fn map;
         dm_map_request_fn map_rq;
+        dm_clone_and_map_request_fn clone_and_map_rq;
+        dm_release_clone_request_fn release_clone_rq;
         dm_endio_fn end_io;
         dm_request_endio_fn rq_end_io;
         dm_presuspend_fn presuspend;
@@ -600,9 +607,6 @@ static inline unsigned long to_bytes(sector_t n)
 /*-----------------------------------------------------------------
  * Helper for block layer and dm core operations
  *---------------------------------------------------------------*/
-void dm_dispatch_request(struct request *rq);
-void dm_requeue_unmapped_request(struct request *rq);
-void dm_kill_unmapped_request(struct request *rq, int error);
 int dm_underlying_device_busy(struct request_queue *q);
 
 #endif  /* _LINUX_DEVICE_MAPPER_H */
diff --git a/include/linux/device.h b/include/linux/device.h
index fb506738f7b7..0eb8ee2dc6d1 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -1038,22 +1038,22 @@ extern __printf(3, 4)
 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
 
 extern __printf(3, 4)
-int dev_printk(const char *level, const struct device *dev,
-               const char *fmt, ...);
+void dev_printk(const char *level, const struct device *dev,
+                const char *fmt, ...);
 extern __printf(2, 3)
-int dev_emerg(const struct device *dev, const char *fmt, ...);
+void dev_emerg(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int dev_alert(const struct device *dev, const char *fmt, ...);
+void dev_alert(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int dev_crit(const struct device *dev, const char *fmt, ...);
+void dev_crit(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int dev_err(const struct device *dev, const char *fmt, ...);
+void dev_err(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int dev_warn(const struct device *dev, const char *fmt, ...);
+void dev_warn(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int dev_notice(const struct device *dev, const char *fmt, ...);
+void dev_notice(const struct device *dev, const char *fmt, ...);
 extern __printf(2, 3)
-int _dev_info(const struct device *dev, const char *fmt, ...);
+void _dev_info(const struct device *dev, const char *fmt, ...);
 
 #else
 
@@ -1065,35 +1065,35 @@ static inline __printf(3, 4)
 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...)
 { return 0; }
 
-static inline int __dev_printk(const char *level, const struct device *dev,
-                               struct va_format *vaf)
-{ return 0; }
+static inline void __dev_printk(const char *level, const struct device *dev,
+                                struct va_format *vaf)
+{}
 static inline __printf(3, 4)
-int dev_printk(const char *level, const struct device *dev,
-               const char *fmt, ...)
-{ return 0; }
+void dev_printk(const char *level, const struct device *dev,
+                const char *fmt, ...)
+{}
 
 static inline __printf(2, 3)
-int dev_emerg(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_emerg(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int dev_crit(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_crit(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int dev_alert(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_alert(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int dev_err(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_err(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int dev_warn(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_warn(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int dev_notice(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void dev_notice(const struct device *dev, const char *fmt, ...)
+{}
 static inline __printf(2, 3)
-int _dev_info(const struct device *dev, const char *fmt, ...)
-{ return 0; }
+void _dev_info(const struct device *dev, const char *fmt, ...)
+{}
 
 #endif
 
@@ -1119,7 +1119,6 @@ do {						     \
 ({                                                              \
         if (0)                                                  \
                 dev_printk(KERN_DEBUG, dev, format, ##arg);     \
-        0;                                                      \
 })
 #endif
 
@@ -1156,7 +1155,7 @@ do {									\
 #define dev_info_once(dev, fmt, ...)                                    \
         dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
 #define dev_dbg_once(dev, fmt, ...)                                     \
-        dev_level_once(dev_info, dev, fmt, ##__VA_ARGS__)
+        dev_level_once(dev_dbg, dev, fmt, ##__VA_ARGS__)
 
 #define dev_level_ratelimited(dev_level, dev, fmt, ...)                 \
 do {                                                                    \
@@ -1215,7 +1214,6 @@ do {									\
 ({                                                              \
         if (0)                                                  \
                 dev_printk(KERN_DEBUG, dev, format, ##arg);     \
-        0;                                                      \
 })
 #endif
 
diff --git a/include/linux/dqblk_v1.h b/include/linux/dqblk_v1.h
index 3713a7232dd8..c0d4d1e2a45c 100644
--- a/include/linux/dqblk_v1.h
+++ b/include/linux/dqblk_v1.h
@@ -5,9 +5,6 @@
 #ifndef _LINUX_DQBLK_V1_H
 #define _LINUX_DQBLK_V1_H
 
-/* Root squash turned on */
-#define V1_DQF_RSQUASH 1
-
 /* Numbers of blocks needed for updates */
 #define V1_INIT_ALLOC 1
 #define V1_INIT_REWRITE 1
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 0238d612750e..cf7e431cbc73 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -848,7 +848,7 @@ efi_guidcmp (efi_guid_t left, efi_guid_t right)
 }
 
 static inline char *
-efi_guid_unparse(efi_guid_t *guid, char *out)
+efi_guid_to_str(efi_guid_t *guid, char *out)
 {
         sprintf(out, "%pUl", guid->b);
         return out;
@@ -875,6 +875,8 @@ static inline efi_status_t efi_query_variable_store(u32 attributes, unsigned lon
 #endif
 extern void __iomem *efi_lookup_mapped_addr(u64 phys_addr);
 extern int efi_config_init(efi_config_table_type_t *arch_tables);
+extern int efi_config_parse_tables(void *config_tables, int count, int sz,
+                                   efi_config_table_type_t *arch_tables);
 extern u64 efi_get_iobase (void);
 extern u32 efi_mem_type (unsigned long phys_addr);
 extern u64 efi_mem_attributes (unsigned long phys_addr);
diff --git a/include/linux/enclosure.h b/include/linux/enclosure.h
index 9a33c5f7e126..7be22da321f3 100644
--- a/include/linux/enclosure.h
+++ b/include/linux/enclosure.h
@@ -79,6 +79,12 @@ struct enclosure_component_callbacks {
         int (*set_locate)(struct enclosure_device *,
                           struct enclosure_component *,
                           enum enclosure_component_setting);
+        void (*get_power_status)(struct enclosure_device *,
+                                 struct enclosure_component *);
+        int (*set_power_status)(struct enclosure_device *,
+                                struct enclosure_component *,
+                                int);
+        int (*show_id)(struct enclosure_device *, char *buf);
 };
 
 
@@ -91,7 +97,9 @@ struct enclosure_component {
         int fault;
         int active;
         int locate;
+        int slot;
         enum enclosure_status status;
+        int power_status;
 };
 
 struct enclosure_device {
@@ -120,8 +128,9 @@ enclosure_register(struct device *, const char *, int,
                    struct enclosure_component_callbacks *);
 void enclosure_unregister(struct enclosure_device *);
 struct enclosure_component *
-enclosure_component_register(struct enclosure_device *, unsigned int,
-                                 enum enclosure_component_type, const char *);
+enclosure_component_alloc(struct enclosure_device *, unsigned int,
+                          enum enclosure_component_type, const char *);
+int enclosure_component_register(struct enclosure_component *);
 int enclosure_add_device(struct enclosure_device *enclosure, int component,
                          struct device *dev);
 int enclosure_remove_device(struct enclosure_device *, struct device *);
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 41c891d05f04..1d869d185a0d 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -52,6 +52,10 @@ struct net_device *alloc_etherdev_mqs(int sizeof_priv, unsigned int txqs,
 #define alloc_etherdev(sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)
 #define alloc_etherdev_mq(sizeof_priv, count) alloc_etherdev_mqs(sizeof_priv, count, count)
 
+struct sk_buff **eth_gro_receive(struct sk_buff **head,
+                                 struct sk_buff *skb);
+int eth_gro_complete(struct sk_buff *skb, int nhoff);
+
 /* Reserved Ethernet Addresses per IEEE 802.1Q */
 static const u8 eth_reserved_addr_base[ETH_ALEN] __aligned(2) =
 { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 };
diff --git a/include/linux/exportfs.h b/include/linux/exportfs.h
index 41b223a59a63..fa05e04c5531 100644
--- a/include/linux/exportfs.h
+++ b/include/linux/exportfs.h
@@ -4,6 +4,7 @@
 #include <linux/types.h>
 
 struct dentry;
+struct iattr;
 struct inode;
 struct super_block;
 struct vfsmount;
@@ -180,6 +181,21 @@ struct fid {
  *    get_name is not (which is possibly inconsistent)
  */
 
+/* types of block ranges for multipage write mappings. */
+#define IOMAP_HOLE      0x01    /* no blocks allocated, need allocation */
+#define IOMAP_DELALLOC  0x02    /* delayed allocation blocks */
+#define IOMAP_MAPPED    0x03    /* blocks allocated @blkno */
+#define IOMAP_UNWRITTEN 0x04    /* blocks allocated @blkno in unwritten state */
+
+#define IOMAP_NULL_BLOCK -1LL   /* blkno is not valid */
+
+struct iomap {
+        sector_t        blkno;  /* first sector of mapping */
+        loff_t          offset; /* file offset of mapping, bytes */
+        u64             length; /* length of mapping, bytes */
+        int             type;   /* type of mapping */
+};
+
 struct export_operations {
         int (*encode_fh)(struct inode *inode, __u32 *fh, int *max_len,
                         struct inode *parent);
@@ -191,6 +207,13 @@ struct export_operations {
                         struct dentry *child);
         struct dentry * (*get_parent)(struct dentry *child);
         int (*commit_metadata)(struct inode *inode);
+
+        int (*get_uuid)(struct super_block *sb, u8 *buf, u32 *len, u64 *offset);
+        int (*map_blocks)(struct inode *inode, loff_t offset,
+                          u64 len, struct iomap *iomap,
+                          bool write, u32 *device_generation);
+        int (*commit_blocks)(struct inode *inode, struct iomap *iomaps,
+                             int nr_iomaps, struct iattr *iattr);
 };
 
 extern int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index 87f14e90e984..a23556c32703 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -19,12 +19,16 @@
 #define F2FS_MAX_LOG_SECTOR_SIZE        12      /* 12 bits for 4096 bytes */
 #define F2FS_LOG_SECTORS_PER_BLOCK      3       /* log number for sector/blk */
 #define F2FS_BLKSIZE                    4096    /* support only 4KB block */
+#define F2FS_BLKSIZE_BITS               12      /* bits for F2FS_BLKSIZE */
 #define F2FS_MAX_EXTENSION              64      /* # of extension entries */
 #define F2FS_BLK_ALIGN(x)       (((x) + F2FS_BLKSIZE - 1) / F2FS_BLKSIZE)
 
 #define NULL_ADDR               ((block_t)0)    /* used as block_t addresses */
 #define NEW_ADDR                ((block_t)-1)   /* used as block_t addresses */
 
+#define F2FS_BYTES_TO_BLK(bytes)        ((bytes) >> F2FS_BLKSIZE_BITS)
+#define F2FS_BLK_TO_BYTES(blk)          ((blk) << F2FS_BLKSIZE_BITS)
+
 /* 0, 1(node nid), 2(meta nid) are reserved node id */
 #define F2FS_RESERVED_NODE_NUM          3
 
@@ -87,6 +91,7 @@ struct f2fs_super_block {
 /*
  * For checkpoint
  */
+#define CP_FASTBOOT_FLAG        0x00000020
 #define CP_FSCK_FLAG            0x00000010
 #define CP_ERROR_FLAG           0x00000008
 #define CP_COMPACT_SUM_FLAG     0x00000004
@@ -224,6 +229,8 @@ enum {
         OFFSET_BIT_SHIFT
 };
 
+#define OFFSET_BIT_MASK         (0x07)  /* (0x01 << OFFSET_BIT_SHIFT) - 1 */
+
 struct node_footer {
         __le32 nid;             /* node id */
         __le32 ino;             /* inode nunmber */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 09bb7a18d287..043f3283b71c 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -726,7 +726,9 @@ extern int fb_videomode_from_videomode(const struct videomode *vm,
                                        struct fb_videomode *fbmode);
 
 /* drivers/video/modedb.c */
-#define VESA_MODEDB_SIZE 34
+#define VESA_MODEDB_SIZE 43
+#define DMT_SIZE 0x50
+
 extern void fb_var_to_videomode(struct fb_videomode *mode,
                                 const struct fb_var_screeninfo *var);
 extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
@@ -777,9 +779,17 @@ struct fb_videomode {
         u32 flag;
 };
 
+struct dmt_videomode {
+        u32 dmt_id;
+        u32 std_2byte_code;
+        u32 cvt_3byte_code;
+        const struct fb_videomode *mode;
+};
+
 extern const char *fb_mode_option;
 extern const struct fb_videomode vesa_modes[];
 extern const struct fb_videomode cea_modes[64];
+extern const struct dmt_videomode dmt_modes[];
 
 struct fb_modelist {
         struct list_head list;
diff --git a/include/linux/fec.h b/include/linux/fec.h
index bcff455d1d53..1454a503622d 100644
--- a/include/linux/fec.h
+++ b/include/linux/fec.h
@@ -19,6 +19,7 @@
 struct fec_platform_data {
         phy_interface_t phy;
         unsigned char mac[ETH_ALEN];
+        void (*sleep_mode_enable)(int enabled);
 };
 
 #endif
diff --git a/include/linux/fs.h b/include/linux/fs.h
index f90c0282c114..ed5a0900b94d 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -34,6 +34,7 @@
 #include <asm/byteorder.h>
 #include <uapi/linux/fs.h>
 
+struct backing_dev_info;
 struct export_operations;
 struct hd_geometry;
 struct iovec;
@@ -50,6 +51,7 @@ struct swap_info_struct;
 struct seq_file;
 struct workqueue_struct;
 struct iov_iter;
+struct vm_fault;
 
 extern void __init inode_init(void);
 extern void __init inode_init_early(void);
@@ -135,7 +137,7 @@ typedef void (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define FMODE_CAN_WRITE         ((__force fmode_t)0x40000)
 
 /* File was opened by fanotify and shouldn't generate fanotify events */
-#define FMODE_NONOTIFY          ((__force fmode_t)0x1000000)
+#define FMODE_NONOTIFY          ((__force fmode_t)0x4000000)
 
 /*
  * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
@@ -360,8 +362,6 @@ struct address_space_operations {
         int (*releasepage) (struct page *, gfp_t);
         void (*freepage)(struct page *);
         ssize_t (*direct_IO)(int, struct kiocb *, struct iov_iter *iter, loff_t offset);
-        int (*get_xip_mem)(struct address_space *, pgoff_t, int,
-                                                void **, unsigned long *);
         /*
          * migrate the contents of a page to the specified target. If
          * migrate_mode is MIGRATE_ASYNC, it must not block.
@@ -394,14 +394,12 @@ int pagecache_write_end(struct file *, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned copied,
                                 struct page *page, void *fsdata);
 
-struct backing_dev_info;
 struct address_space {
         struct inode            *host;          /* owner: inode, block_device */
         struct radix_tree_root  page_tree;      /* radix tree of all pages */
         spinlock_t              tree_lock;      /* and lock protecting it */
         atomic_t                i_mmap_writable;/* count VM_SHARED mappings */
         struct rb_root          i_mmap;         /* tree of private and shared mappings */
-        struct list_head        i_mmap_nonlinear;/*list VM_NONLINEAR mappings */
         struct rw_semaphore     i_mmap_rwsem;   /* protect tree, count, list */
         /* Protected by tree_lock together with the radix tree */
         unsigned long           nrpages;        /* number of total pages */
@@ -409,7 +407,6 @@ struct address_space {
         pgoff_t                 writeback_index;/* writeback starts here */
         const struct address_space_operations *a_ops;   /* methods */
         unsigned long           flags;          /* error bits/gfp mask */
-        struct backing_dev_info *backing_dev_info; /* device readahead, etc */
         spinlock_t              private_lock;   /* for use by the address_space */
         struct list_head        private_list;   /* ditto */
         void                    *private_data;  /* ditto */
@@ -493,8 +490,7 @@ static inline void i_mmap_unlock_read(struct address_space *mapping)
  */
 static inline int mapping_mapped(struct address_space *mapping)
 {
-        return  !RB_EMPTY_ROOT(&mapping->i_mmap) ||
-                !list_empty(&mapping->i_mmap_nonlinear);
+        return  !RB_EMPTY_ROOT(&mapping->i_mmap);
 }
 
 /*
@@ -625,7 +621,7 @@ struct inode {
         atomic_t                i_readcount; /* struct files open RO */
 #endif
         const struct file_operations    *i_fop; /* former ->i_op->default_file_ops */
-        struct file_lock        *i_flock;
+        struct file_lock_context        *i_flctx;
         struct address_space    i_data;
         struct list_head        i_devices;
         union {
@@ -875,6 +871,7 @@ static inline struct file *get_file(struct file *f)
 #define FL_DOWNGRADE_PENDING    256 /* Lease is being downgraded */
 #define FL_UNLOCK_PENDING       512 /* Lease is being broken */
 #define FL_OFDLCK       1024    /* lock is "owned" by struct file */
+#define FL_LAYOUT       2048    /* outstanding pNFS layout */
 
 /*
  * Special return value from posix_lock_file() and vfs_lock_file() for
@@ -885,6 +882,8 @@ static inline struct file *get_file(struct file *f)
 /* legacy typedef, should eventually be removed */
 typedef void *fl_owner_t;
 
+struct file_lock;
+
 struct file_lock_operations {
         void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
         void (*fl_release_private)(struct file_lock *);
@@ -898,7 +897,7 @@ struct lock_manager_operations {
         void (*lm_notify)(struct file_lock *);  /* unblock callback */
         int (*lm_grant)(struct file_lock *, int);
         bool (*lm_break)(struct file_lock *);
-        int (*lm_change)(struct file_lock **, int, struct list_head *);
+        int (*lm_change)(struct file_lock *, int, struct list_head *);
         void (*lm_setup)(struct file_lock *, void **);
 };
 
@@ -923,17 +922,17 @@ int locks_in_grace(struct net *);
  * FIXME: should we create a separate "struct lock_request" to help distinguish
  * these two uses?
  *
- * The i_flock list is ordered by:
+ * The varous i_flctx lists are ordered by:
  *
- * 1) lock type -- FL_LEASEs first, then FL_FLOCK, and finally FL_POSIX
- * 2) lock owner
- * 3) lock range start
- * 4) lock range end
+ * 1) lock owner
+ * 2) lock range start
+ * 3) lock range end
  *
  * Obviously, the last two criteria only matter for POSIX locks.
  */
 struct file_lock {
         struct file_lock *fl_next;      /* singly linked list for this inode  */
+        struct list_head fl_list;       /* link into file_lock_context */
         struct hlist_node fl_link;      /* node in global lists */
         struct list_head fl_block;      /* circular list of blocked processes */
         fl_owner_t fl_owner;
@@ -964,6 +963,16 @@ struct file_lock {
         } fl_u;
 };
 
+struct file_lock_context {
+        spinlock_t              flc_lock;
+        struct list_head        flc_flock;
+        struct list_head        flc_posix;
+        struct list_head        flc_lease;
+        int                     flc_flock_cnt;
+        int                     flc_posix_cnt;
+        int                     flc_lease_cnt;
+};
+
 /* The following constant reflects the upper bound of the file/locking space */
 #ifndef OFFSET_MAX
 #define INT_LIMIT(x)    (~((x)1 << (sizeof(x)*8 - 1)))
@@ -990,6 +999,7 @@ extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
 extern int fcntl_getlease(struct file *filp);
 
 /* fs/locks.c */
+void locks_free_lock_context(struct file_lock_context *ctx);
 void locks_free_lock(struct file_lock *fl);
 extern void locks_init_lock(struct file_lock *);
 extern struct file_lock * locks_alloc_lock(void);
@@ -1010,7 +1020,7 @@ extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int t
 extern void lease_get_mtime(struct inode *, struct timespec *time);
 extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
 extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
-extern int lease_modify(struct file_lock **, int, struct list_head *);
+extern int lease_modify(struct file_lock *, int, struct list_head *);
 #else /* !CONFIG_FILE_LOCKING */
 static inline int fcntl_getlk(struct file *file, unsigned int cmd,
                               struct flock __user *user)
@@ -1047,6 +1057,11 @@ static inline int fcntl_getlease(struct file *filp)
         return F_UNLCK;
 }
 
+static inline void
+locks_free_lock_context(struct file_lock_context *ctx)
+{
+}
+
 static inline void locks_init_lock(struct file_lock *fl)
 {
         return;
@@ -1137,7 +1152,7 @@ static inline int vfs_setlease(struct file *filp, long arg,
         return -EINVAL;
 }
 
-static inline int lease_modify(struct file_lock **before, int arg,
+static inline int lease_modify(struct file_lock *fl, int arg,
                                struct list_head *dispose)
 {
         return -EINVAL;
@@ -1184,8 +1199,6 @@ struct mm_struct;
 #define UMOUNT_NOFOLLOW 0x00000008      /* Don't follow symlink on umount */
 #define UMOUNT_UNUSED   0x80000000      /* Flag guaranteed to be unused */
 
-extern struct list_head super_blocks;
-extern spinlock_t sb_lock;
 
 /* Possible states of 'frozen' field */
 enum {
@@ -1502,6 +1515,26 @@ struct block_device_operations;
 #define HAVE_COMPAT_IOCTL 1
 #define HAVE_UNLOCKED_IOCTL 1
 
+/*
+ * These flags let !MMU mmap() govern direct device mapping vs immediate
+ * copying more easily for MAP_PRIVATE, especially for ROM filesystems.
+ *
+ * NOMMU_MAP_COPY:      Copy can be mapped (MAP_PRIVATE)
+ * NOMMU_MAP_DIRECT:    Can be mapped directly (MAP_SHARED)
+ * NOMMU_MAP_READ:      Can be mapped for reading
+ * NOMMU_MAP_WRITE:     Can be mapped for writing
+ * NOMMU_MAP_EXEC:      Can be mapped for execution
+ */
+#define NOMMU_MAP_COPY          0x00000001
+#define NOMMU_MAP_DIRECT        0x00000008
+#define NOMMU_MAP_READ          VM_MAYREAD
+#define NOMMU_MAP_WRITE         VM_MAYWRITE
+#define NOMMU_MAP_EXEC          VM_MAYEXEC
+
+#define NOMMU_VMFLAGS \
+        (NOMMU_MAP_READ | NOMMU_MAP_WRITE | NOMMU_MAP_EXEC)
+
+
 struct iov_iter;
 
 struct file_operations {
@@ -1536,6 +1569,9 @@ struct file_operations {
         long (*fallocate)(struct file *file, int mode, loff_t offset,
                           loff_t len);
         void (*show_fdinfo)(struct seq_file *m, struct file *f);
+#ifndef CONFIG_MMU
+        unsigned (*mmap_capabilities)(struct file *);
+#endif
 };
 
 struct inode_operations {
@@ -1618,8 +1654,10 @@ struct super_operations {
         struct dquot **(*get_dquots)(struct inode *);
 #endif
         int (*bdev_try_to_free_page)(struct super_block*, struct page*, gfp_t);
-        long (*nr_cached_objects)(struct super_block *, int);
-        long (*free_cached_objects)(struct super_block *, long, int);
+        long (*nr_cached_objects)(struct super_block *,
+                                  struct shrink_control *);
+        long (*free_cached_objects)(struct super_block *,
+                                    struct shrink_control *);
 };
 
 /*
@@ -1638,6 +1676,11 @@ struct super_operations {
 #define S_IMA           1024    /* Inode has an associated IMA struct */
 #define S_AUTOMOUNT     2048    /* Automount/referral quasi-directory */
 #define S_NOSEC         4096    /* no suid or xattr security attributes */
+#ifdef CONFIG_FS_DAX
+#define S_DAX           8192    /* Direct Access, avoiding the page cache */
+#else
+#define S_DAX           0       /* Make all the DAX code disappear */
+#endif
 
 /*
  * Note that nosuid etc flags are inode-specific: setting some file-system
@@ -1675,6 +1718,7 @@ struct super_operations {
 #define IS_IMA(inode)           ((inode)->i_flags & S_IMA)
 #define IS_AUTOMOUNT(inode)     ((inode)->i_flags & S_AUTOMOUNT)
 #define IS_NOSEC(inode)         ((inode)->i_flags & S_NOSEC)
+#define IS_DAX(inode)           ((inode)->i_flags & S_DAX)
 
 #define IS_WHITEOUT(inode)      (S_ISCHR(inode->i_mode) && \
                                  (inode)->i_rdev == WHITEOUT_DEV)
@@ -1959,7 +2003,7 @@ static inline int locks_verify_truncate(struct inode *inode,
                                     struct file *filp,
                                     loff_t size)
 {
-        if (inode->i_flock && mandatory_lock(inode))
+        if (inode->i_flctx && mandatory_lock(inode))
                 return locks_mandatory_area(
                         FLOCK_VERIFY_WRITE, inode, filp,
                         size < inode->i_size ? size : inode->i_size,
@@ -1973,11 +2017,12 @@ static inline int break_lease(struct inode *inode, unsigned int mode)
 {
         /*
          * Since this check is lockless, we must ensure that any refcounts
-         * taken are done before checking inode->i_flock. Otherwise, we could
-         * end up racing with tasks trying to set a new lease on this file.
+         * taken are done before checking i_flctx->flc_lease. Otherwise, we
+         * could end up racing with tasks trying to set a new lease on this
+         * file.
          */
         smp_mb();
-        if (inode->i_flock)
+        if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
                 return __break_lease(inode, mode, FL_LEASE);
         return 0;
 }
@@ -1986,11 +2031,12 @@ static inline int break_deleg(struct inode *inode, unsigned int mode)
 {
         /*
          * Since this check is lockless, we must ensure that any refcounts
-         * taken are done before checking inode->i_flock. Otherwise, we could
-         * end up racing with tasks trying to set a new lease on this file.
+         * taken are done before checking i_flctx->flc_lease. Otherwise, we
+         * could end up racing with tasks trying to set a new lease on this
+         * file.
          */
         smp_mb();
-        if (inode->i_flock)
+        if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
                 return __break_lease(inode, mode, FL_DELEG);
         return 0;
 }
@@ -2017,6 +2063,16 @@ static inline int break_deleg_wait(struct inode **delegated_inode)
         return ret;
 }
 
+static inline int break_layout(struct inode *inode, bool wait)
+{
+        smp_mb();
+        if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
+                return __break_lease(inode,
+                                wait ? O_WRONLY : O_WRONLY | O_NONBLOCK,
+                                FL_LAYOUT);
+        return 0;
+}
+
 #else /* !CONFIG_FILE_LOCKING */
 static inline int locks_mandatory_locked(struct file *file)
 {
@@ -2072,6 +2128,11 @@ static inline int break_deleg_wait(struct inode **delegated_inode)
         return 0;
 }
 
+static inline int break_layout(struct inode *inode, bool wait)
+{
+        return 0;
+}
+
 #endif /* CONFIG_FILE_LOCKING */
 
 /* fs/open.c */
@@ -2481,8 +2542,6 @@ extern int sb_min_blocksize(struct super_block *, int);
 
 extern int generic_file_mmap(struct file *, struct vm_area_struct *);
 extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
-extern int generic_file_remap_pages(struct vm_area_struct *, unsigned long addr,
-                unsigned long size, pgoff_t pgoff);
 int generic_write_checks(struct file *file, loff_t *pos, size_t *count, int isblk);
 extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
 extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
@@ -2527,19 +2586,13 @@ extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 
-#ifdef CONFIG_FS_XIP
-extern ssize_t xip_file_read(struct file *filp, char __user *buf, size_t len,
-                             loff_t *ppos);
-extern int xip_file_mmap(struct file * file, struct vm_area_struct * vma);
-extern ssize_t xip_file_write(struct file *filp, const char __user *buf,
-                              size_t len, loff_t *ppos);
-extern int xip_truncate_page(struct address_space *mapping, loff_t from);
-#else
-static inline int xip_truncate_page(struct address_space *mapping, loff_t from)
-{
-        return 0;
-}
-#endif
+ssize_t dax_do_io(int rw, struct kiocb *, struct inode *, struct iov_iter *,
+                loff_t, get_block_t, dio_iodone_t, int flags);
+int dax_clear_blocks(struct inode *, sector_t block, long size);
+int dax_zero_page_range(struct inode *, loff_t from, unsigned len, get_block_t);
+int dax_truncate_page(struct inode *, loff_t from, get_block_t);
+int dax_fault(struct vm_area_struct *, struct vm_fault *, get_block_t);
+#define dax_mkwrite(vma, vmf, gb)       dax_fault(vma, vmf, gb)
 
 #ifdef CONFIG_BLOCK
 typedef void (dio_submit_t)(int rw, struct bio *bio, struct inode *inode,
@@ -2696,6 +2749,11 @@ extern int generic_show_options(struct seq_file *m, struct dentry *root);
 extern void save_mount_options(struct super_block *sb, char *options);
 extern void replace_mount_options(struct super_block *sb, char *options);
 
+static inline bool io_is_direct(struct file *filp)
+{
+        return (filp->f_flags & O_DIRECT) || IS_DAX(file_inode(filp));
+}
+
 static inline ino_t parent_ino(struct dentry *dentry)
 {
         ino_t res;
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index 1c804b057fb1..7ee1774edee5 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -101,8 +101,10 @@ static inline void fsnotify_move(struct inode *old_dir, struct inode *new_dir,
                 new_dir_mask |= FS_ISDIR;
         }
 
-        fsnotify(old_dir, old_dir_mask, old_dir, FSNOTIFY_EVENT_INODE, old_name, fs_cookie);
-        fsnotify(new_dir, new_dir_mask, new_dir, FSNOTIFY_EVENT_INODE, new_name, fs_cookie);
+        fsnotify(old_dir, old_dir_mask, source, FSNOTIFY_EVENT_INODE, old_name,
+                 fs_cookie);
+        fsnotify(new_dir, new_dir_mask, source, FSNOTIFY_EVENT_INODE, new_name,
+                 fs_cookie);
 
         if (target)
                 fsnotify_link_count(target);
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 0bebb5c348b8..c674ee8f7fca 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -44,6 +44,10 @@ const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr,
 const char *ftrace_print_hex_seq(struct trace_seq *p,
                                  const unsigned char *buf, int len);
 
+const char *ftrace_print_array_seq(struct trace_seq *p,
+                                   const void *buf, int buf_len,
+                                   size_t el_size);
+
 struct trace_iterator;
 struct trace_event;
 
@@ -595,7 +599,7 @@ extern int  ftrace_profile_set_filter(struct perf_event *event, int event_id,
                                      char *filter_str);
 extern void ftrace_profile_free_filter(struct perf_event *event);
 extern void *perf_trace_buf_prepare(int size, unsigned short type,
-                                    struct pt_regs *regs, int *rctxp);
+                                    struct pt_regs **regs, int *rctxp);
 
 static inline void
 perf_trace_buf_submit(void *raw_data, int size, int rctx, u64 addr,
diff --git a/include/linux/genetlink.h b/include/linux/genetlink.h
index 55b685719d52..09460d6d6682 100644
--- a/include/linux/genetlink.h
+++ b/include/linux/genetlink.h
@@ -11,6 +11,10 @@ extern void genl_unlock(void);
 extern int lockdep_genl_is_held(void);
 #endif
 
+/* for synchronisation between af_netlink and genetlink */
+extern atomic_t genl_sk_destructing_cnt;
+extern wait_queue_head_t genl_sk_destructing_waitq;
+
 /**
  * rcu_dereference_genl - rcu_dereference with debug checking
  * @p: The pointer to read, prior to dereferencing
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index b840e3b2770d..51bd1e72a917 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -334,18 +334,22 @@ alloc_pages(gfp_t gfp_mask, unsigned int order)
 }
 extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
                         struct vm_area_struct *vma, unsigned long addr,
-                        int node);
+                        int node, bool hugepage);
+#define alloc_hugepage_vma(gfp_mask, vma, addr, order)  \
+        alloc_pages_vma(gfp_mask, order, vma, addr, numa_node_id(), true)
 #else
 #define alloc_pages(gfp_mask, order) \
                 alloc_pages_node(numa_node_id(), gfp_mask, order)
-#define alloc_pages_vma(gfp_mask, order, vma, addr, node)       \
+#define alloc_pages_vma(gfp_mask, order, vma, addr, node, false)\
+        alloc_pages(gfp_mask, order)
+#define alloc_hugepage_vma(gfp_mask, vma, addr, order)  \
         alloc_pages(gfp_mask, order)
 #endif
 #define alloc_page(gfp_mask) alloc_pages(gfp_mask, 0)
 #define alloc_page_vma(gfp_mask, vma, addr)                     \
-        alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id())
+        alloc_pages_vma(gfp_mask, 0, vma, addr, numa_node_id(), false)
 #define alloc_page_vma_node(gfp_mask, vma, addr, node)          \
-        alloc_pages_vma(gfp_mask, 0, vma, addr, node)
+        alloc_pages_vma(gfp_mask, 0, vma, addr, node, false)
 
 extern struct page *alloc_kmem_pages(gfp_t gfp_mask, unsigned int order);
 extern struct page *alloc_kmem_pages_node(int nid, gfp_t gfp_mask,
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index fd85cb120ee0..45afc2dee560 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -340,31 +340,32 @@ static inline int desc_to_gpio(const struct gpio_desc *desc)
  * etc.
  */
 #define __gpiod_get(dev, con_id, flags, ...) __gpiod_get(dev, con_id, flags)
-#define gpiod_get(varargs...) __gpiod_get(varargs, 0)
+#define gpiod_get(varargs...) __gpiod_get(varargs, GPIOD_ASIS)
 #define __gpiod_get_index(dev, con_id, index, flags, ...)               \
         __gpiod_get_index(dev, con_id, index, flags)
-#define gpiod_get_index(varargs...) __gpiod_get_index(varargs, 0)
+#define gpiod_get_index(varargs...) __gpiod_get_index(varargs, GPIOD_ASIS)
 #define __gpiod_get_optional(dev, con_id, flags, ...)                   \
         __gpiod_get_optional(dev, con_id, flags)
-#define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, 0)
+#define gpiod_get_optional(varargs...) __gpiod_get_optional(varargs, GPIOD_ASIS)
 #define __gpiod_get_index_optional(dev, con_id, index, flags, ...)      \
         __gpiod_get_index_optional(dev, con_id, index, flags)
 #define gpiod_get_index_optional(varargs...)                            \
-        __gpiod_get_index_optional(varargs, 0)
+        __gpiod_get_index_optional(varargs, GPIOD_ASIS)
 #define __devm_gpiod_get(dev, con_id, flags, ...)                       \
         __devm_gpiod_get(dev, con_id, flags)
-#define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, 0)
+#define devm_gpiod_get(varargs...) __devm_gpiod_get(varargs, GPIOD_ASIS)
 #define __devm_gpiod_get_index(dev, con_id, index, flags, ...)          \
         __devm_gpiod_get_index(dev, con_id, index, flags)
-#define devm_gpiod_get_index(varargs...) __devm_gpiod_get_index(varargs, 0)
+#define devm_gpiod_get_index(varargs...)                                \
+        __devm_gpiod_get_index(varargs, GPIOD_ASIS)
 #define __devm_gpiod_get_optional(dev, con_id, flags, ...)              \
         __devm_gpiod_get_optional(dev, con_id, flags)
 #define devm_gpiod_get_optional(varargs...)                             \
-        __devm_gpiod_get_optional(varargs, 0)
+        __devm_gpiod_get_optional(varargs, GPIOD_ASIS)
 #define __devm_gpiod_get_index_optional(dev, con_id, index, flags, ...) \
         __devm_gpiod_get_index_optional(dev, con_id, index, flags)
 #define devm_gpiod_get_index_optional(varargs...)                       \
-        __devm_gpiod_get_index_optional(varargs, 0)
+        __devm_gpiod_get_index_optional(varargs, GPIOD_ASIS)
 
 #if IS_ENABLED(CONFIG_GPIOLIB) && IS_ENABLED(CONFIG_GPIO_SYSFS)
 
diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h
index cbb5790a35cd..e9744202fa29 100644
--- a/include/linux/hdmi.h
+++ b/include/linux/hdmi.h
@@ -25,6 +25,7 @@
 #define __LINUX_HDMI_H_
 
 #include <linux/types.h>
+#include <linux/device.h>
 
 enum hdmi_infoframe_type {
         HDMI_INFOFRAME_TYPE_VENDOR = 0x81,
@@ -52,12 +53,18 @@ enum hdmi_colorspace {
         HDMI_COLORSPACE_RGB,
         HDMI_COLORSPACE_YUV422,
         HDMI_COLORSPACE_YUV444,
+        HDMI_COLORSPACE_YUV420,
+        HDMI_COLORSPACE_RESERVED4,
+        HDMI_COLORSPACE_RESERVED5,
+        HDMI_COLORSPACE_RESERVED6,
+        HDMI_COLORSPACE_IDO_DEFINED,
 };
 
 enum hdmi_scan_mode {
         HDMI_SCAN_MODE_NONE,
         HDMI_SCAN_MODE_OVERSCAN,
         HDMI_SCAN_MODE_UNDERSCAN,
+        HDMI_SCAN_MODE_RESERVED,
 };
 
 enum hdmi_colorimetry {
@@ -71,6 +78,7 @@ enum hdmi_picture_aspect {
         HDMI_PICTURE_ASPECT_NONE,
         HDMI_PICTURE_ASPECT_4_3,
         HDMI_PICTURE_ASPECT_16_9,
+        HDMI_PICTURE_ASPECT_RESERVED,
 };
 
 enum hdmi_active_aspect {
@@ -92,12 +100,18 @@ enum hdmi_extended_colorimetry {
         HDMI_EXTENDED_COLORIMETRY_S_YCC_601,
         HDMI_EXTENDED_COLORIMETRY_ADOBE_YCC_601,
         HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB,
+
+        /* The following EC values are only defined in CEA-861-F. */
+        HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM,
+        HDMI_EXTENDED_COLORIMETRY_BT2020,
+        HDMI_EXTENDED_COLORIMETRY_RESERVED,
 };
 
 enum hdmi_quantization_range {
         HDMI_QUANTIZATION_RANGE_DEFAULT,
         HDMI_QUANTIZATION_RANGE_LIMITED,
         HDMI_QUANTIZATION_RANGE_FULL,
+        HDMI_QUANTIZATION_RANGE_RESERVED,
 };
 
 /* non-uniform picture scaling */
@@ -114,7 +128,7 @@ enum hdmi_ycc_quantization_range {
 };
 
 enum hdmi_content_type {
-        HDMI_CONTENT_TYPE_NONE,
+        HDMI_CONTENT_TYPE_GRAPHICS,
         HDMI_CONTENT_TYPE_PHOTO,
         HDMI_CONTENT_TYPE_CINEMA,
         HDMI_CONTENT_TYPE_GAME,
@@ -194,6 +208,7 @@ enum hdmi_audio_coding_type {
         HDMI_AUDIO_CODING_TYPE_MLP,
         HDMI_AUDIO_CODING_TYPE_DST,
         HDMI_AUDIO_CODING_TYPE_WMA_PRO,
+        HDMI_AUDIO_CODING_TYPE_CXT,
 };
 
 enum hdmi_audio_sample_size {
@@ -215,10 +230,25 @@ enum hdmi_audio_sample_frequency {
 };
 
 enum hdmi_audio_coding_type_ext {
-        HDMI_AUDIO_CODING_TYPE_EXT_STREAM,
+        /* Refer to Audio Coding Type (CT) field in Data Byte 1 */
+        HDMI_AUDIO_CODING_TYPE_EXT_CT,
+
+        /*
+         * The next three CXT values are defined in CEA-861-E only.
+         * They do not exist in older versions, and in CEA-861-F they are
+         * defined as 'Not in use'.
+         */
         HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC,
         HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2,
         HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND,
+
+        /* The following CXT values are only defined in CEA-861-F. */
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC,
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_V2,
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC,
+        HDMI_AUDIO_CODING_TYPE_EXT_DRA,
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_HE_AAC_SURROUND,
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG4_AAC_LC_SURROUND = 10,
 };
 
 struct hdmi_audio_infoframe {
@@ -299,5 +329,8 @@ union hdmi_infoframe {
 
 ssize_t
 hdmi_infoframe_pack(union hdmi_infoframe *frame, void *buffer, size_t size);
+int hdmi_infoframe_unpack(union hdmi_infoframe *frame, void *buffer);
+void hdmi_infoframe_log(const char *level, struct device *dev,
+                        union hdmi_infoframe *frame);
 
 #endif /* _DRM_HDMI_H */
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 06c4607744f6..efc7787a41a8 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -574,7 +574,9 @@ static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
 #define HID_GLOBAL_STACK_SIZE 4
 #define HID_COLLECTION_STACK_SIZE 4
 
-#define HID_SCAN_FLAG_MT_WIN_8                  0x00000001
+#define HID_SCAN_FLAG_MT_WIN_8                  BIT(0)
+#define HID_SCAN_FLAG_VENDOR_SPECIFIC           BIT(1)
+#define HID_SCAN_FLAG_GD_POINTER                BIT(2)
 
 struct hid_parser {
         struct hid_global     global;
diff --git a/include/linux/host1x.h b/include/linux/host1x.h
index bb9840fd1e18..464f33814a94 100644
--- a/include/linux/host1x.h
+++ b/include/linux/host1x.h
@@ -250,17 +250,29 @@ void host1x_job_unpin(struct host1x_job *job);
 struct host1x_device;
 
 struct host1x_driver {
+        struct device_driver driver;
+
         const struct of_device_id *subdevs;
         struct list_head list;
-        const char *name;
 
         int (*probe)(struct host1x_device *device);
         int (*remove)(struct host1x_device *device);
+        void (*shutdown)(struct host1x_device *device);
 };
 
-int host1x_driver_register(struct host1x_driver *driver);
+static inline struct host1x_driver *
+to_host1x_driver(struct device_driver *driver)
+{
+        return container_of(driver, struct host1x_driver, driver);
+}
+
+int host1x_driver_register_full(struct host1x_driver *driver,
+                                struct module *owner);
 void host1x_driver_unregister(struct host1x_driver *driver);
 
+#define host1x_driver_register(driver) \
+        host1x_driver_register_full(driver, THIS_MODULE)
+
 struct host1x_device {
         struct host1x_driver *driver;
         struct list_head list;
@@ -272,6 +284,8 @@ struct host1x_device {
 
         struct mutex clients_lock;
         struct list_head clients;
+
+        bool registered;
 };
 
 static inline struct host1x_device *to_host1x_device(struct device *dev)
diff --git a/include/linux/hrtimer.h b/include/linux/hrtimer.h
index a036d058a249..05f6df1fdf5b 100644
--- a/include/linux/hrtimer.h
+++ b/include/linux/hrtimer.h
@@ -170,6 +170,7 @@ enum  hrtimer_base_type {
  * @clock_was_set:      Indicates that clock was set from irq context.
  * @expires_next:       absolute time of the next event which was scheduled
  *                      via clock_set_next_event()
+ * @in_hrtirq:          hrtimer_interrupt() is currently executing
  * @hres_active:        State of high resolution mode
  * @hang_detected:      The last hrtimer interrupt detected a hang
  * @nr_events:          Total number of hrtimer interrupt events
@@ -185,6 +186,7 @@ struct hrtimer_cpu_base {
         unsigned int                    clock_was_set;
 #ifdef CONFIG_HIGH_RES_TIMERS
         ktime_t                         expires_next;
+        int                             in_hrtirq;
         int                             hres_active;
         int                             hang_detected;
         unsigned long                   nr_events;
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index ad9051bab267..f10b20f05159 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -157,6 +157,13 @@ static inline int hpage_nr_pages(struct page *page)
 extern int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_struct *vma,
                                 unsigned long addr, pmd_t pmd, pmd_t *pmdp);
 
+extern struct page *huge_zero_page;
+
+static inline bool is_huge_zero_page(struct page *page)
+{
+        return ACCESS_ONCE(huge_zero_page) == page;
+}
+
 #else /* CONFIG_TRANSPARENT_HUGEPAGE */
 #define HPAGE_PMD_SHIFT ({ BUILD_BUG(); 0; })
 #define HPAGE_PMD_MASK ({ BUILD_BUG(); 0; })
@@ -206,6 +213,11 @@ static inline int do_huge_pmd_numa_page(struct mm_struct *mm, struct vm_area_str
         return 0;
 }
 
+static inline bool is_huge_zero_page(struct page *page)
+{
+        return false;
+}
+
 #endif /* CONFIG_TRANSPARENT_HUGEPAGE */
 
 #endif /* _LINUX_HUGE_MM_H */
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 431b7fc605c9..7b5785032049 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -86,7 +86,7 @@ void free_huge_page(struct page *page);
 pte_t *huge_pmd_share(struct mm_struct *mm, unsigned long addr, pud_t *pud);
 #endif
 
-extern unsigned long hugepages_treat_as_movable;
+extern int hugepages_treat_as_movable;
 extern int sysctl_hugetlb_shm_group;
 extern struct list_head huge_boot_pages;
 
@@ -99,9 +99,9 @@ int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep);
 struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
                               int write);
 struct page *follow_huge_pmd(struct mm_struct *mm, unsigned long address,
-                                pmd_t *pmd, int write);
+                                pmd_t *pmd, int flags);
 struct page *follow_huge_pud(struct mm_struct *mm, unsigned long address,
-                                pud_t *pud, int write);
+                                pud_t *pud, int flags);
 int pmd_huge(pmd_t pmd);
 int pud_huge(pud_t pmd);
 unsigned long hugetlb_change_protection(struct vm_area_struct *vma,
@@ -133,8 +133,8 @@ static inline void hugetlb_report_meminfo(struct seq_file *m)
 static inline void hugetlb_show_meminfo(void)
 {
 }
-#define follow_huge_pmd(mm, addr, pmd, write)   NULL
-#define follow_huge_pud(mm, addr, pud, write)   NULL
+#define follow_huge_pmd(mm, addr, pmd, flags)   NULL
+#define follow_huge_pud(mm, addr, pud, flags)   NULL
 #define prepare_hugepage_range(file, addr, len) (-EINVAL)
 #define pmd_huge(x)     0
 #define pud_huge(x)     0
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index 914bb08cd738..eb7b414d232b 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -12,8 +12,10 @@
 #ifndef LINUX_HWRANDOM_H_
 #define LINUX_HWRANDOM_H_
 
+#include <linux/completion.h>
 #include <linux/types.h>
 #include <linux/list.h>
+#include <linux/kref.h>
 
 /**
  * struct hwrng - Hardware Random Number Generator driver
@@ -44,6 +46,8 @@ struct hwrng {
 
         /* internal. */
         struct list_head list;
+        struct kref ref;
+        struct completion cleanup_done;
 };
 
 /** Register a new Hardware Random Number Generator driver. */
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 476c685ca6f9..5a2ba674795e 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -57,6 +57,18 @@ struct hv_multipage_buffer {
         u64 pfn_array[MAX_MULTIPAGE_BUFFER_COUNT];
 };
 
+/*
+ * Multiple-page buffer array; the pfn array is variable size:
+ * The number of entries in the PFN array is determined by
+ * "len" and "offset".
+ */
+struct hv_mpb_array {
+        /* Length and Offset determines the # of pfns in the array */
+        u32 len;
+        u32 offset;
+        u64 pfn_array[];
+};
+
 /* 0x18 includes the proprietary packet header */
 #define MAX_PAGE_BUFFER_PACKET          (0x18 +                 \
                                         (sizeof(struct hv_page_buffer) * \
@@ -722,7 +734,12 @@ struct vmbus_channel {
          */
         void (*sc_creation_callback)(struct vmbus_channel *new_sc);
 
-        spinlock_t sc_lock;
+        /*
+         * The spinlock to protect the structure. It is being used to protect
+         * test-and-set access to various attributes of the structure as well
+         * as all sc_list operations.
+         */
+        spinlock_t lock;
         /*
          * All Sub-channels of a primary channel are linked here.
          */
@@ -814,6 +831,18 @@ struct vmbus_channel_packet_multipage_buffer {
         struct hv_multipage_buffer range;
 } __packed;
 
+/* The format must be the same as struct vmdata_gpa_direct */
+struct vmbus_packet_mpb_array {
+        u16 type;
+        u16 dataoffset8;
+        u16 length8;
+        u16 flags;
+        u64 transactionid;
+        u32 reserved;
+        u32 rangecount;         /* Always 1 in this case */
+        struct hv_mpb_array range;
+} __packed;
+
 
 extern int vmbus_open(struct vmbus_channel *channel,
                             u32 send_ringbuffersize,
@@ -845,6 +874,13 @@ extern int vmbus_sendpacket_multipagebuffer(struct vmbus_channel *channel,
                                         u32 bufferlen,
                                         u64 requestid);
 
+extern int vmbus_sendpacket_mpb_desc(struct vmbus_channel *channel,
+                                     struct vmbus_packet_mpb_array *mpb,
+                                     u32 desc_size,
+                                     void *buffer,
+                                     u32 bufferlen,
+                                     u64 requestid);
+
 extern int vmbus_establish_gpadl(struct vmbus_channel *channel,
                                       void *kbuffer,
                                       u32 size,
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index e3a1721c8354..7c7695940ddd 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -228,7 +228,9 @@ struct i2c_client {
         struct device dev;              /* the device structure         */
         int irq;                        /* irq issued by device         */
         struct list_head detected;
+#if IS_ENABLED(CONFIG_I2C_SLAVE)
         i2c_slave_cb_t slave_cb;        /* callback for slave mode      */
+#endif
 };
 #define to_i2c_client(d) container_of(d, struct i2c_client, dev)
 
@@ -253,6 +255,7 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
 
 /* I2C slave support */
 
+#if IS_ENABLED(CONFIG_I2C_SLAVE)
 enum i2c_slave_event {
         I2C_SLAVE_REQ_READ_START,
         I2C_SLAVE_REQ_READ_END,
@@ -269,6 +272,7 @@ static inline int i2c_slave_event(struct i2c_client *client,
 {
         return client->slave_cb(client, event, val);
 }
+#endif
 
 /**
  * struct i2c_board_info - template for device creation
@@ -404,8 +408,10 @@ struct i2c_algorithm {
         /* To determine what the adapter supports */
         u32 (*functionality) (struct i2c_adapter *);
 
+#if IS_ENABLED(CONFIG_I2C_SLAVE)
         int (*reg_slave)(struct i2c_client *client);
         int (*unreg_slave)(struct i2c_client *client);
+#endif
 };
 
 /**
diff --git a/include/linux/i2o.h b/include/linux/i2o.h
deleted file mode 100644
index d23c3c20b201..000000000000
--- a/include/linux/i2o.h
+++ /dev/null
@@ -1,988 +0,0 @@
-/*
- * I2O kernel space accessible structures/APIs
- *
- * (c) Copyright 1999, 2000 Red Hat Software
- *
- * 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 header file defined the I2O APIs/structures for use by
- * the I2O kernel modules.
- *
- */
-
-#ifndef _I2O_H
-#define _I2O_H
-
-#include <linux/i2o-dev.h>
-
-/* How many different OSM's are we allowing */
-#define I2O_MAX_DRIVERS         8
-
-#include <linux/pci.h>
-#include <linux/bug.h>
-#include <linux/dma-mapping.h>
-#include <linux/string.h>
-#include <linux/slab.h>
-#include <linux/workqueue.h>    /* work_struct */
-#include <linux/mempool.h>
-#include <linux/mutex.h>
-#include <linux/scatterlist.h>
-#include <linux/semaphore.h>    /* Needed for MUTEX init macros */
-
-#include <asm/io.h>
-
-/* message queue empty */
-#define I2O_QUEUE_EMPTY         0xffffffff
-
-/*
- *      Cache strategies
- */
-
-/*      The NULL strategy leaves everything up to the controller. This tends to be a
- *      pessimal but functional choice.
- */
-#define CACHE_NULL              0
-/*      Prefetch data when reading. We continually attempt to load the next 32 sectors
- *      into the controller cache.
- */
-#define CACHE_PREFETCH          1
-/*      Prefetch data when reading. We sometimes attempt to load the next 32 sectors
- *      into the controller cache. When an I/O is less <= 8K we assume its probably
- *      not sequential and don't prefetch (default)
- */
-#define CACHE_SMARTFETCH        2
-/*      Data is written to the cache and then out on to the disk. The I/O must be
- *      physically on the medium before the write is acknowledged (default without
- *      NVRAM)
- */
-#define CACHE_WRITETHROUGH      17
-/*      Data is written to the cache and then out on to the disk. The controller
- *      is permitted to write back the cache any way it wants. (default if battery
- *      backed NVRAM is present). It can be useful to set this for swap regardless of
- *      battery state.
- */
-#define CACHE_WRITEBACK         18
-/*      Optimise for under powered controllers, especially on RAID1 and RAID0. We
- *      write large I/O's directly to disk bypassing the cache to avoid the extra
- *      memory copy hits. Small writes are writeback cached
- */
-#define CACHE_SMARTBACK         19
-/*      Optimise for under powered controllers, especially on RAID1 and RAID0. We
- *      write large I/O's directly to disk bypassing the cache to avoid the extra
- *      memory copy hits. Small writes are writethrough cached. Suitable for devices
- *      lacking battery backup
- */
-#define CACHE_SMARTTHROUGH      20
-
-/*
- *      Ioctl structures
- */
-
-#define         BLKI2OGRSTRAT   _IOR('2', 1, int)
-#define         BLKI2OGWSTRAT   _IOR('2', 2, int)
-#define         BLKI2OSRSTRAT   _IOW('2', 3, int)
-#define         BLKI2OSWSTRAT   _IOW('2', 4, int)
-
-/*
- *      I2O Function codes
- */
-
-/*
- *      Executive Class
- */
-#define I2O_CMD_ADAPTER_ASSIGN          0xB3
-#define I2O_CMD_ADAPTER_READ            0xB2
-#define I2O_CMD_ADAPTER_RELEASE         0xB5
-#define I2O_CMD_BIOS_INFO_SET           0xA5
-#define I2O_CMD_BOOT_DEVICE_SET         0xA7
-#define I2O_CMD_CONFIG_VALIDATE         0xBB
-#define I2O_CMD_CONN_SETUP              0xCA
-#define I2O_CMD_DDM_DESTROY             0xB1
-#define I2O_CMD_DDM_ENABLE              0xD5
-#define I2O_CMD_DDM_QUIESCE             0xC7
-#define I2O_CMD_DDM_RESET               0xD9
-#define I2O_CMD_DDM_SUSPEND             0xAF
-#define I2O_CMD_DEVICE_ASSIGN           0xB7
-#define I2O_CMD_DEVICE_RELEASE          0xB9
-#define I2O_CMD_HRT_GET                 0xA8
-#define I2O_CMD_ADAPTER_CLEAR           0xBE
-#define I2O_CMD_ADAPTER_CONNECT         0xC9
-#define I2O_CMD_ADAPTER_RESET           0xBD
-#define I2O_CMD_LCT_NOTIFY              0xA2
-#define I2O_CMD_OUTBOUND_INIT           0xA1
-#define I2O_CMD_PATH_ENABLE             0xD3
-#define I2O_CMD_PATH_QUIESCE            0xC5
-#define I2O_CMD_PATH_RESET              0xD7
-#define I2O_CMD_STATIC_MF_CREATE        0xDD
-#define I2O_CMD_STATIC_MF_RELEASE       0xDF
-#define I2O_CMD_STATUS_GET              0xA0
-#define I2O_CMD_SW_DOWNLOAD             0xA9
-#define I2O_CMD_SW_UPLOAD               0xAB
-#define I2O_CMD_SW_REMOVE               0xAD
-#define I2O_CMD_SYS_ENABLE              0xD1
-#define I2O_CMD_SYS_MODIFY              0xC1
-#define I2O_CMD_SYS_QUIESCE             0xC3
-#define I2O_CMD_SYS_TAB_SET             0xA3
-
-/*
- * Utility Class
- */
-#define I2O_CMD_UTIL_NOP                0x00
-#define I2O_CMD_UTIL_ABORT              0x01
-#define I2O_CMD_UTIL_CLAIM              0x09
-#define I2O_CMD_UTIL_RELEASE            0x0B
-#define I2O_CMD_UTIL_PARAMS_GET         0x06
-#define I2O_CMD_UTIL_PARAMS_SET         0x05
-#define I2O_CMD_UTIL_EVT_REGISTER       0x13
-#define I2O_CMD_UTIL_EVT_ACK            0x14
-#define I2O_CMD_UTIL_CONFIG_DIALOG      0x10
-#define I2O_CMD_UTIL_DEVICE_RESERVE     0x0D
-#define I2O_CMD_UTIL_DEVICE_RELEASE     0x0F
-#define I2O_CMD_UTIL_LOCK               0x17
-#define I2O_CMD_UTIL_LOCK_RELEASE       0x19
-#define I2O_CMD_UTIL_REPLY_FAULT_NOTIFY 0x15
-
-/*
- * SCSI Host Bus Adapter Class
- */
-#define I2O_CMD_SCSI_EXEC               0x81
-#define I2O_CMD_SCSI_ABORT              0x83
-#define I2O_CMD_SCSI_BUSRESET           0x27
-
-/*
- * Bus Adapter Class
- */
-#define I2O_CMD_BUS_ADAPTER_RESET       0x85
-#define I2O_CMD_BUS_RESET               0x87
-#define I2O_CMD_BUS_SCAN                0x89
-#define I2O_CMD_BUS_QUIESCE             0x8b
-
-/*
- * Random Block Storage Class
- */
-#define I2O_CMD_BLOCK_READ              0x30
-#define I2O_CMD_BLOCK_WRITE             0x31
-#define I2O_CMD_BLOCK_CFLUSH            0x37
-#define I2O_CMD_BLOCK_MLOCK             0x49
-#define I2O_CMD_BLOCK_MUNLOCK           0x4B
-#define I2O_CMD_BLOCK_MMOUNT            0x41
-#define I2O_CMD_BLOCK_MEJECT            0x43
-#define I2O_CMD_BLOCK_POWER             0x70
-
-#define I2O_CMD_PRIVATE                 0xFF
-
-/* Command status values  */
-
-#define I2O_CMD_IN_PROGRESS     0x01
-#define I2O_CMD_REJECTED        0x02
-#define I2O_CMD_FAILED          0x03
-#define I2O_CMD_COMPLETED       0x04
-
-/* I2O API function return values */
-
-#define I2O_RTN_NO_ERROR                        0
-#define I2O_RTN_NOT_INIT                        1
-#define I2O_RTN_FREE_Q_EMPTY                    2
-#define I2O_RTN_TCB_ERROR                       3
-#define I2O_RTN_TRANSACTION_ERROR               4
-#define I2O_RTN_ADAPTER_ALREADY_INIT            5
-#define I2O_RTN_MALLOC_ERROR                    6
-#define I2O_RTN_ADPTR_NOT_REGISTERED            7
-#define I2O_RTN_MSG_REPLY_TIMEOUT               8
-#define I2O_RTN_NO_STATUS                       9
-#define I2O_RTN_NO_FIRM_VER                     10
-#define I2O_RTN_NO_LINK_SPEED                   11
-
-/* Reply message status defines for all messages */
-
-#define I2O_REPLY_STATUS_SUCCESS                        0x00
-#define I2O_REPLY_STATUS_ABORT_DIRTY                    0x01
-#define I2O_REPLY_STATUS_ABORT_NO_DATA_TRANSFER         0x02
-#define I2O_REPLY_STATUS_ABORT_PARTIAL_TRANSFER         0x03
-#define I2O_REPLY_STATUS_ERROR_DIRTY                    0x04
-#define I2O_REPLY_STATUS_ERROR_NO_DATA_TRANSFER         0x05
-#define I2O_REPLY_STATUS_ERROR_PARTIAL_TRANSFER         0x06
-#define I2O_REPLY_STATUS_PROCESS_ABORT_DIRTY            0x08
-#define I2O_REPLY_STATUS_PROCESS_ABORT_NO_DATA_TRANSFER 0x09
-#define I2O_REPLY_STATUS_PROCESS_ABORT_PARTIAL_TRANSFER 0x0A
-#define I2O_REPLY_STATUS_TRANSACTION_ERROR              0x0B
-#define I2O_REPLY_STATUS_PROGRESS_REPORT                0x80
-
-/* Status codes and Error Information for Parameter functions */
-
-#define I2O_PARAMS_STATUS_SUCCESS               0x00
-#define I2O_PARAMS_STATUS_BAD_KEY_ABORT         0x01
-#define I2O_PARAMS_STATUS_BAD_KEY_CONTINUE      0x02
-#define I2O_PARAMS_STATUS_BUFFER_FULL           0x03
-#define I2O_PARAMS_STATUS_BUFFER_TOO_SMALL      0x04
-#define I2O_PARAMS_STATUS_FIELD_UNREADABLE      0x05
-#define I2O_PARAMS_STATUS_FIELD_UNWRITEABLE     0x06
-#define I2O_PARAMS_STATUS_INSUFFICIENT_FIELDS   0x07
-#define I2O_PARAMS_STATUS_INVALID_GROUP_ID      0x08
-#define I2O_PARAMS_STATUS_INVALID_OPERATION     0x09
-#define I2O_PARAMS_STATUS_NO_KEY_FIELD          0x0A
-#define I2O_PARAMS_STATUS_NO_SUCH_FIELD         0x0B
-#define I2O_PARAMS_STATUS_NON_DYNAMIC_GROUP     0x0C
-#define I2O_PARAMS_STATUS_OPERATION_ERROR       0x0D
-#define I2O_PARAMS_STATUS_SCALAR_ERROR          0x0E
-#define I2O_PARAMS_STATUS_TABLE_ERROR           0x0F
-#define I2O_PARAMS_STATUS_WRONG_GROUP_TYPE      0x10
-
-/* DetailedStatusCode defines for Executive, DDM, Util and Transaction error
- * messages: Table 3-2 Detailed Status Codes.*/
-
-#define I2O_DSC_SUCCESS                        0x0000
-#define I2O_DSC_BAD_KEY                        0x0002
-#define I2O_DSC_TCL_ERROR                      0x0003
-#define I2O_DSC_REPLY_BUFFER_FULL              0x0004
-#define I2O_DSC_NO_SUCH_PAGE                   0x0005
-#define I2O_DSC_INSUFFICIENT_RESOURCE_SOFT     0x0006
-#define I2O_DSC_INSUFFICIENT_RESOURCE_HARD     0x0007
-#define I2O_DSC_CHAIN_BUFFER_TOO_LARGE         0x0009
-#define I2O_DSC_UNSUPPORTED_FUNCTION           0x000A
-#define I2O_DSC_DEVICE_LOCKED                  0x000B
-#define I2O_DSC_DEVICE_RESET                   0x000C
-#define I2O_DSC_INAPPROPRIATE_FUNCTION         0x000D
-#define I2O_DSC_INVALID_INITIATOR_ADDRESS      0x000E
-#define I2O_DSC_INVALID_MESSAGE_FLAGS          0x000F
-#define I2O_DSC_INVALID_OFFSET                 0x0010
-#define I2O_DSC_INVALID_PARAMETER              0x0011
-#define I2O_DSC_INVALID_REQUEST                0x0012
-#define I2O_DSC_INVALID_TARGET_ADDRESS         0x0013
-#define I2O_DSC_MESSAGE_TOO_LARGE              0x0014
-#define I2O_DSC_MESSAGE_TOO_SMALL              0x0015
-#define I2O_DSC_MISSING_PARAMETER              0x0016
-#define I2O_DSC_TIMEOUT                        0x0017
-#define I2O_DSC_UNKNOWN_ERROR                  0x0018
-#define I2O_DSC_UNKNOWN_FUNCTION               0x0019
-#define I2O_DSC_UNSUPPORTED_VERSION            0x001A
-#define I2O_DSC_DEVICE_BUSY                    0x001B
-#define I2O_DSC_DEVICE_NOT_AVAILABLE           0x001C
-
-/* DetailedStatusCode defines for Block Storage Operation: Table 6-7 Detailed
-   Status Codes.*/
-
-#define I2O_BSA_DSC_SUCCESS               0x0000
-#define I2O_BSA_DSC_MEDIA_ERROR           0x0001
-#define I2O_BSA_DSC_ACCESS_ERROR          0x0002
-#define I2O_BSA_DSC_DEVICE_FAILURE        0x0003
-#define I2O_BSA_DSC_DEVICE_NOT_READY      0x0004
-#define I2O_BSA_DSC_MEDIA_NOT_PRESENT     0x0005
-#define I2O_BSA_DSC_MEDIA_LOCKED          0x0006
-#define I2O_BSA_DSC_MEDIA_FAILURE         0x0007
-#define I2O_BSA_DSC_PROTOCOL_FAILURE      0x0008
-#define I2O_BSA_DSC_BUS_FAILURE           0x0009
-#define I2O_BSA_DSC_ACCESS_VIOLATION      0x000A
-#define I2O_BSA_DSC_WRITE_PROTECTED       0x000B
-#define I2O_BSA_DSC_DEVICE_RESET          0x000C
-#define I2O_BSA_DSC_VOLUME_CHANGED        0x000D
-#define I2O_BSA_DSC_TIMEOUT               0x000E
-
-/* FailureStatusCodes, Table 3-3 Message Failure Codes */
-
-#define I2O_FSC_TRANSPORT_SERVICE_SUSPENDED             0x81
-#define I2O_FSC_TRANSPORT_SERVICE_TERMINATED            0x82
-#define I2O_FSC_TRANSPORT_CONGESTION                    0x83
-#define I2O_FSC_TRANSPORT_FAILURE                       0x84
-#define I2O_FSC_TRANSPORT_STATE_ERROR                   0x85
-#define I2O_FSC_TRANSPORT_TIME_OUT                      0x86
-#define I2O_FSC_TRANSPORT_ROUTING_FAILURE               0x87
-#define I2O_FSC_TRANSPORT_INVALID_VERSION               0x88
-#define I2O_FSC_TRANSPORT_INVALID_OFFSET                0x89
-#define I2O_FSC_TRANSPORT_INVALID_MSG_FLAGS             0x8A
-#define I2O_FSC_TRANSPORT_FRAME_TOO_SMALL               0x8B
-#define I2O_FSC_TRANSPORT_FRAME_TOO_LARGE               0x8C
-#define I2O_FSC_TRANSPORT_INVALID_TARGET_ID             0x8D
-#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_ID          0x8E
-#define I2O_FSC_TRANSPORT_INVALID_INITIATOR_CONTEXT     0x8F
-#define I2O_FSC_TRANSPORT_UNKNOWN_FAILURE               0xFF
-
-/* Device Claim Types */
-#define I2O_CLAIM_PRIMARY                                       0x01000000
-#define I2O_CLAIM_MANAGEMENT                                    0x02000000
-#define I2O_CLAIM_AUTHORIZED                                    0x03000000
-#define I2O_CLAIM_SECONDARY                                     0x04000000
-
-/* Message header defines for VersionOffset */
-#define I2OVER15        0x0001
-#define I2OVER20        0x0002
-
-/* Default is 1.5 */
-#define I2OVERSION      I2OVER15
-
-#define SGL_OFFSET_0    I2OVERSION
-#define SGL_OFFSET_4    (0x0040 | I2OVERSION)
-#define SGL_OFFSET_5    (0x0050 | I2OVERSION)
-#define SGL_OFFSET_6    (0x0060 | I2OVERSION)
-#define SGL_OFFSET_7    (0x0070 | I2OVERSION)
-#define SGL_OFFSET_8    (0x0080 | I2OVERSION)
-#define SGL_OFFSET_9    (0x0090 | I2OVERSION)
-#define SGL_OFFSET_10   (0x00A0 | I2OVERSION)
-#define SGL_OFFSET_11   (0x00B0 | I2OVERSION)
-#define SGL_OFFSET_12   (0x00C0 | I2OVERSION)
-#define SGL_OFFSET(x)   (((x)<<4) | I2OVERSION)
-
-/* Transaction Reply Lists (TRL) Control Word structure */
-#define TRL_SINGLE_FIXED_LENGTH         0x00
-#define TRL_SINGLE_VARIABLE_LENGTH      0x40
-#define TRL_MULTIPLE_FIXED_LENGTH       0x80
-
- /* msg header defines for MsgFlags */
-#define MSG_STATIC      0x0100
-#define MSG_64BIT_CNTXT 0x0200
-#define MSG_MULTI_TRANS 0x1000
-#define MSG_FAIL        0x2000
-#define MSG_FINAL       0x4000
-#define MSG_REPLY       0x8000
-
- /* minimum size msg */
-#define THREE_WORD_MSG_SIZE     0x00030000
-#define FOUR_WORD_MSG_SIZE      0x00040000
-#define FIVE_WORD_MSG_SIZE      0x00050000
-#define SIX_WORD_MSG_SIZE       0x00060000
-#define SEVEN_WORD_MSG_SIZE     0x00070000
-#define EIGHT_WORD_MSG_SIZE     0x00080000
-#define NINE_WORD_MSG_SIZE      0x00090000
-#define TEN_WORD_MSG_SIZE       0x000A0000
-#define ELEVEN_WORD_MSG_SIZE    0x000B0000
-#define I2O_MESSAGE_SIZE(x)     ((x)<<16)
-
-/* special TID assignments */
-#define ADAPTER_TID             0
-#define HOST_TID                1
-
-/* outbound queue defines */
-#define I2O_MAX_OUTBOUND_MSG_FRAMES     128
-#define I2O_OUTBOUND_MSG_FRAME_SIZE     128     /* in 32-bit words */
-
-/* inbound queue definitions */
-#define I2O_MSG_INPOOL_MIN              32
-#define I2O_INBOUND_MSG_FRAME_SIZE      128     /* in 32-bit words */
-
-#define I2O_POST_WAIT_OK        0
-#define I2O_POST_WAIT_TIMEOUT   -ETIMEDOUT
-
-#define I2O_CONTEXT_LIST_MIN_LENGTH     15
-#define I2O_CONTEXT_LIST_USED           0x01
-#define I2O_CONTEXT_LIST_DELETED        0x02
-
-/* timeouts */
-#define I2O_TIMEOUT_INIT_OUTBOUND_QUEUE 15
-#define I2O_TIMEOUT_MESSAGE_GET         5
-#define I2O_TIMEOUT_RESET               30
-#define I2O_TIMEOUT_STATUS_GET          5
-#define I2O_TIMEOUT_LCT_GET             360
-#define I2O_TIMEOUT_SCSI_SCB_ABORT      240
-
-/* retries */
-#define I2O_HRT_GET_TRIES               3
-#define I2O_LCT_GET_TRIES               3
-
-/* defines for max_sectors and max_phys_segments */
-#define I2O_MAX_SECTORS                 1024
-#define I2O_MAX_SECTORS_LIMITED         128
-#define I2O_MAX_PHYS_SEGMENTS           BLK_MAX_SEGMENTS
-
-/*
- *      Message structures
- */
-struct i2o_message {
-        union {
-                struct {
-                        u8 version_offset;
-                        u8 flags;
-                        u16 size;
-                        u32 target_tid:12;
-                        u32 init_tid:12;
-                        u32 function:8;
-                        u32 icntxt;     /* initiator context */
-                        u32 tcntxt;     /* transaction context */
-                } s;
-                u32 head[4];
-        } u;
-        /* List follows */
-        u32 body[0];
-};
-
-/* MFA and I2O message used by mempool */
-struct i2o_msg_mfa {
-        u32 mfa;                /* MFA returned by the controller */
-        struct i2o_message msg; /* I2O message */
-};
-
-/*
- *      Each I2O device entity has one of these. There is one per device.
- */
-struct i2o_device {
-        i2o_lct_entry lct_data; /* Device LCT information */
-
-        struct i2o_controller *iop;     /* Controlling IOP */
-        struct list_head list;  /* node in IOP devices list */
-
-        struct device device;
-
-        struct mutex lock;      /* device lock */
-};
-
-/*
- *      Event structure provided to the event handling function
- */
-struct i2o_event {
-        struct work_struct work;
-        struct i2o_device *i2o_dev;     /* I2O device pointer from which the
-                                           event reply was initiated */
-        u16 size;               /* Size of data in 32-bit words */
-        u32 tcntxt;             /* Transaction context used at
-                                   registration */
-        u32 event_indicator;    /* Event indicator from reply */
-        u32 data[0];            /* Event data from reply */
-};
-
-/*
- *      I2O classes which could be handled by the OSM
- */
-struct i2o_class_id {
-        u16 class_id:12;
-};
-
-/*
- *      I2O driver structure for OSMs
- */
-struct i2o_driver {
-        char *name;             /* OSM name */
-        int context;            /* Low 8 bits of the transaction info */
-        struct i2o_class_id *classes;   /* I2O classes that this OSM handles */
-
-        /* Message reply handler */
-        int (*reply) (struct i2o_controller *, u32, struct i2o_message *);
-
-        /* Event handler */
-        work_func_t event;
-
-        struct workqueue_struct *event_queue;   /* Event queue */
-
-        struct device_driver driver;
-
-        /* notification of changes */
-        void (*notify_controller_add) (struct i2o_controller *);
-        void (*notify_controller_remove) (struct i2o_controller *);
-        void (*notify_device_add) (struct i2o_device *);
-        void (*notify_device_remove) (struct i2o_device *);
-
-        struct semaphore lock;
-};
-
-/*
- *      Contains DMA mapped address information
- */
-struct i2o_dma {
-        void *virt;
-        dma_addr_t phys;
-        size_t len;
-};
-
-/*
- *      Contains slab cache and mempool information
- */
-struct i2o_pool {
-        char *name;
-        struct kmem_cache *slab;
-        mempool_t *mempool;
-};
-
-/*
- *      Contains IO mapped address information
- */
-struct i2o_io {
-        void __iomem *virt;
-        unsigned long phys;
-        unsigned long len;
-};
-
-/*
- *      Context queue entry, used for 32-bit context on 64-bit systems
- */
-struct i2o_context_list_element {
-        struct list_head list;
-        u32 context;
-        void *ptr;
-        unsigned long timestamp;
-};
-
-/*
- * Each I2O controller has one of these objects
- */
-struct i2o_controller {
-        char name[16];
-        int unit;
-        int type;
-
-        struct pci_dev *pdev;   /* PCI device */
-
-        unsigned int promise:1; /* Promise controller */
-        unsigned int adaptec:1; /* DPT / Adaptec controller */
-        unsigned int raptor:1;  /* split bar */
-        unsigned int no_quiesce:1;      /* dont quiesce before reset */
-        unsigned int short_req:1;       /* use small block sizes */
-        unsigned int limit_sectors:1;   /* limit number of sectors / request */
-        unsigned int pae_support:1;     /* controller has 64-bit SGL support */
-
-        struct list_head devices;       /* list of I2O devices */
-        struct list_head list;  /* Controller list */
-
-        void __iomem *in_port;  /* Inbout port address */
-        void __iomem *out_port; /* Outbound port address */
-        void __iomem *irq_status;       /* Interrupt status register address */
-        void __iomem *irq_mask; /* Interrupt mask register address */
-
-        struct i2o_dma status;  /* IOP status block */
-
-        struct i2o_dma hrt;     /* HW Resource Table */
-        i2o_lct *lct;           /* Logical Config Table */
-        struct i2o_dma dlct;    /* Temp LCT */
-        struct mutex lct_lock;  /* Lock for LCT updates */
-        struct i2o_dma status_block;    /* IOP status block */
-
-        struct i2o_io base;     /* controller messaging unit */
-        struct i2o_io in_queue; /* inbound message queue Host->IOP */
-        struct i2o_dma out_queue;       /* outbound message queue IOP->Host */
-
-        struct i2o_pool in_msg; /* mempool for inbound messages */
-
-        unsigned int battery:1; /* Has a battery backup */
-        unsigned int io_alloc:1;        /* An I/O resource was allocated */
-        unsigned int mem_alloc:1;       /* A memory resource was allocated */
-
-        struct resource io_resource;    /* I/O resource allocated to the IOP */
-        struct resource mem_resource;   /* Mem resource allocated to the IOP */
-
-        struct device device;
-        struct i2o_device *exec;        /* Executive */
-#if BITS_PER_LONG == 64
-        spinlock_t context_list_lock;   /* lock for context_list */
-        atomic_t context_list_counter;  /* needed for unique contexts */
-        struct list_head context_list;  /* list of context id's
-                                           and pointers */
-#endif
-        spinlock_t lock;        /* lock for controller
-                                   configuration */
-        void *driver_data[I2O_MAX_DRIVERS];     /* storage for drivers */
-};
-
-/*
- * I2O System table entry
- *
- * The system table contains information about all the IOPs in the
- * system.  It is sent to all IOPs so that they can create peer2peer
- * connections between them.
- */
-struct i2o_sys_tbl_entry {
-        u16 org_id;
-        u16 reserved1;
-        u32 iop_id:12;
-        u32 reserved2:20;
-        u16 seg_num:12;
-        u16 i2o_version:4;
-        u8 iop_state;
-        u8 msg_type;
-        u16 frame_size;
-        u16 reserved3;
-        u32 last_changed;
-        u32 iop_capabilities;
-        u32 inbound_low;
-        u32 inbound_high;
-};
-
-struct i2o_sys_tbl {
-        u8 num_entries;
-        u8 version;
-        u16 reserved1;
-        u32 change_ind;
-        u32 reserved2;
-        u32 reserved3;
-        struct i2o_sys_tbl_entry iops[0];
-};
-
-extern struct list_head i2o_controllers;
-
-/* Message functions */
-extern struct i2o_message *i2o_msg_get_wait(struct i2o_controller *, int);
-extern int i2o_msg_post_wait_mem(struct i2o_controller *, struct i2o_message *,
-                                 unsigned long, struct i2o_dma *);
-
-/* IOP functions */
-extern int i2o_status_get(struct i2o_controller *);
-
-extern int i2o_event_register(struct i2o_device *, struct i2o_driver *, int,
-                              u32);
-extern struct i2o_device *i2o_iop_find_device(struct i2o_controller *, u16);
-extern struct i2o_controller *i2o_find_iop(int);
-
-/* Functions needed for handling 64-bit pointers in 32-bit context */
-#if BITS_PER_LONG == 64
-extern u32 i2o_cntxt_list_add(struct i2o_controller *, void *);
-extern void *i2o_cntxt_list_get(struct i2o_controller *, u32);
-extern u32 i2o_cntxt_list_remove(struct i2o_controller *, void *);
-extern u32 i2o_cntxt_list_get_ptr(struct i2o_controller *, void *);
-
-static inline u32 i2o_ptr_low(void *ptr)
-{
-        return (u32) (u64) ptr;
-};
-
-static inline u32 i2o_ptr_high(void *ptr)
-{
-        return (u32) ((u64) ptr >> 32);
-};
-
-static inline u32 i2o_dma_low(dma_addr_t dma_addr)
-{
-        return (u32) (u64) dma_addr;
-};
-
-static inline u32 i2o_dma_high(dma_addr_t dma_addr)
-{
-        return (u32) ((u64) dma_addr >> 32);
-};
-#else
-static inline u32 i2o_cntxt_list_add(struct i2o_controller *c, void *ptr)
-{
-        return (u32) ptr;
-};
-
-static inline void *i2o_cntxt_list_get(struct i2o_controller *c, u32 context)
-{
-        return (void *)context;
-};
-
-static inline u32 i2o_cntxt_list_remove(struct i2o_controller *c, void *ptr)
-{
-        return (u32) ptr;
-};
-
-static inline u32 i2o_cntxt_list_get_ptr(struct i2o_controller *c, void *ptr)
-{
-        return (u32) ptr;
-};
-
-static inline u32 i2o_ptr_low(void *ptr)
-{
-        return (u32) ptr;
-};
-
-static inline u32 i2o_ptr_high(void *ptr)
-{
-        return 0;
-};
-
-static inline u32 i2o_dma_low(dma_addr_t dma_addr)
-{
-        return (u32) dma_addr;
-};
-
-static inline u32 i2o_dma_high(dma_addr_t dma_addr)
-{
-        return 0;
-};
-#endif
-
-extern u16 i2o_sg_tablesize(struct i2o_controller *c, u16 body_size);
-extern dma_addr_t i2o_dma_map_single(struct i2o_controller *c, void *ptr,
-                                            size_t size,
-                                            enum dma_data_direction direction,
-                                            u32 ** sg_ptr);
-extern int i2o_dma_map_sg(struct i2o_controller *c,
-                                 struct scatterlist *sg, int sg_count,
-                                 enum dma_data_direction direction,
-                                 u32 ** sg_ptr);
-extern int i2o_dma_alloc(struct device *dev, struct i2o_dma *addr, size_t len);
-extern void i2o_dma_free(struct device *dev, struct i2o_dma *addr);
-extern int i2o_dma_realloc(struct device *dev, struct i2o_dma *addr,
-                                                                size_t len);
-extern int i2o_pool_alloc(struct i2o_pool *pool, const char *name,
-                                 size_t size, int min_nr);
-extern void i2o_pool_free(struct i2o_pool *pool);
-/* I2O driver (OSM) functions */
-extern int i2o_driver_register(struct i2o_driver *);
-extern void i2o_driver_unregister(struct i2o_driver *);
-
-/**
- *      i2o_driver_notify_controller_add - Send notification of added controller
- *      @drv: I2O driver
- *      @c: I2O controller
- *
- *      Send notification of added controller to a single registered driver.
- */
-static inline void i2o_driver_notify_controller_add(struct i2o_driver *drv,
-                                                    struct i2o_controller *c)
-{
-        if (drv->notify_controller_add)
-                drv->notify_controller_add(c);
-};
-
-/**
- *      i2o_driver_notify_controller_remove - Send notification of removed controller
- *      @drv: I2O driver
- *      @c: I2O controller
- *
- *      Send notification of removed controller to a single registered driver.
- */
-static inline void i2o_driver_notify_controller_remove(struct i2o_driver *drv,
-                                                       struct i2o_controller *c)
-{
-        if (drv->notify_controller_remove)
-                drv->notify_controller_remove(c);
-};
-
-/**
- *      i2o_driver_notify_device_add - Send notification of added device
- *      @drv: I2O driver
- *      @i2o_dev: the added i2o_device
- *
- *      Send notification of added device to a single registered driver.
- */
-static inline void i2o_driver_notify_device_add(struct i2o_driver *drv,
-                                                struct i2o_device *i2o_dev)
-{
-        if (drv->notify_device_add)
-                drv->notify_device_add(i2o_dev);
-};
-
-/**
- *      i2o_driver_notify_device_remove - Send notification of removed device
- *      @drv: I2O driver
- *      @i2o_dev: the added i2o_device
- *
- *      Send notification of removed device to a single registered driver.
- */
-static inline void i2o_driver_notify_device_remove(struct i2o_driver *drv,
-                                                   struct i2o_device *i2o_dev)
-{
-        if (drv->notify_device_remove)
-                drv->notify_device_remove(i2o_dev);
-};
-
-extern void i2o_driver_notify_controller_add_all(struct i2o_controller *);
-extern void i2o_driver_notify_controller_remove_all(struct i2o_controller *);
-extern void i2o_driver_notify_device_add_all(struct i2o_device *);
-extern void i2o_driver_notify_device_remove_all(struct i2o_device *);
-
-/* I2O device functions */
-extern int i2o_device_claim(struct i2o_device *);
-extern int i2o_device_claim_release(struct i2o_device *);
-
-/* Exec OSM functions */
-extern int i2o_exec_lct_get(struct i2o_controller *);
-
-/* device / driver / kobject conversion functions */
-#define to_i2o_driver(drv) container_of(drv,struct i2o_driver, driver)
-#define to_i2o_device(dev) container_of(dev, struct i2o_device, device)
-#define to_i2o_controller(dev) container_of(dev, struct i2o_controller, device)
-
-/**
- *      i2o_out_to_virt - Turn an I2O message to a virtual address
- *      @c: controller
- *      @m: message engine value
- *
- *      Turn a receive message from an I2O controller bus address into
- *      a Linux virtual address. The shared page frame is a linear block
- *      so we simply have to shift the offset. This function does not
- *      work for sender side messages as they are ioremap objects
- *      provided by the I2O controller.
- */
-static inline struct i2o_message *i2o_msg_out_to_virt(struct i2o_controller *c,
-                                                      u32 m)
-{
-        BUG_ON(m < c->out_queue.phys
-               || m >= c->out_queue.phys + c->out_queue.len);
-
-        return c->out_queue.virt + (m - c->out_queue.phys);
-};
-
-/**
- *      i2o_msg_in_to_virt - Turn an I2O message to a virtual address
- *      @c: controller
- *      @m: message engine value
- *
- *      Turn a send message from an I2O controller bus address into
- *      a Linux virtual address. The shared page frame is a linear block
- *      so we simply have to shift the offset. This function does not
- *      work for receive side messages as they are kmalloc objects
- *      in a different pool.
- */
-static inline struct i2o_message __iomem *i2o_msg_in_to_virt(struct
-                                                             i2o_controller *c,
-                                                             u32 m)
-{
-        return c->in_queue.virt + m;
-};
-
-/**
- *      i2o_msg_get - obtain an I2O message from the IOP
- *      @c: I2O controller
- *
- *      This function tries to get a message frame. If no message frame is
- *      available do not wait until one is available (see also i2o_msg_get_wait).
- *      The returned pointer to the message frame is not in I/O memory, it is
- *      allocated from a mempool. But because a MFA is allocated from the
- *      controller too it is guaranteed that i2o_msg_post() will never fail.
- *
- *      On a success a pointer to the message frame is returned. If the message
- *      queue is empty -EBUSY is returned and if no memory is available -ENOMEM
- *      is returned.
- */
-static inline struct i2o_message *i2o_msg_get(struct i2o_controller *c)
-{
-        struct i2o_msg_mfa *mmsg = mempool_alloc(c->in_msg.mempool, GFP_ATOMIC);
-        if (!mmsg)
-                return ERR_PTR(-ENOMEM);
-
-        mmsg->mfa = readl(c->in_port);
-        if (unlikely(mmsg->mfa >= c->in_queue.len)) {
-                u32 mfa = mmsg->mfa;
-
-                mempool_free(mmsg, c->in_msg.mempool);
-
-                if (mfa == I2O_QUEUE_EMPTY)
-                        return ERR_PTR(-EBUSY);
-                return ERR_PTR(-EFAULT);
-        }
-
-        return &mmsg->msg;
-};
-
-/**
- *      i2o_msg_post - Post I2O message to I2O controller
- *      @c: I2O controller to which the message should be send
- *      @msg: message returned by i2o_msg_get()
- *
- *      Post the message to the I2O controller and return immediately.
- */
-static inline void i2o_msg_post(struct i2o_controller *c,
-                                struct i2o_message *msg)
-{
-        struct i2o_msg_mfa *mmsg;
-
-        mmsg = container_of(msg, struct i2o_msg_mfa, msg);
-        memcpy_toio(i2o_msg_in_to_virt(c, mmsg->mfa), msg,
-                    (le32_to_cpu(msg->u.head[0]) >> 16) << 2);
-        writel(mmsg->mfa, c->in_port);
-        mempool_free(mmsg, c->in_msg.mempool);
-};
-
-/**
- *      i2o_msg_post_wait - Post and wait a message and wait until return
- *      @c: controller
- *      @msg: message to post
- *      @timeout: time in seconds to wait
- *
- *      This API allows an OSM to post a message and then be told whether or
- *      not the system received a successful reply. If the message times out
- *      then the value '-ETIMEDOUT' is returned.
- *
- *      Returns 0 on success or negative error code on failure.
- */
-static inline int i2o_msg_post_wait(struct i2o_controller *c,
-                                    struct i2o_message *msg,
-                                    unsigned long timeout)
-{
-        return i2o_msg_post_wait_mem(c, msg, timeout, NULL);
-};
-
-/**
- *      i2o_msg_nop_mfa - Returns a fetched MFA back to the controller
- *      @c: I2O controller from which the MFA was fetched
- *      @mfa: MFA which should be returned
- *
- *      This function must be used for preserved messages, because i2o_msg_nop()
- *      also returns the allocated memory back to the msg_pool mempool.
- */
-static inline void i2o_msg_nop_mfa(struct i2o_controller *c, u32 mfa)
-{
-        struct i2o_message __iomem *msg;
-        u32 nop[3] = {
-                THREE_WORD_MSG_SIZE | SGL_OFFSET_0,
-                I2O_CMD_UTIL_NOP << 24 | HOST_TID << 12 | ADAPTER_TID,
-                0x00000000
-        };
-
-        msg = i2o_msg_in_to_virt(c, mfa);
-        memcpy_toio(msg, nop, sizeof(nop));
-        writel(mfa, c->in_port);
-};
-
-/**
- *      i2o_msg_nop - Returns a message which is not used
- *      @c: I2O controller from which the message was created
- *      @msg: message which should be returned
- *
- *      If you fetch a message via i2o_msg_get, and can't use it, you must
- *      return the message with this function. Otherwise the MFA is lost as well
- *      as the allocated memory from the mempool.
- */
-static inline void i2o_msg_nop(struct i2o_controller *c,
-                               struct i2o_message *msg)
-{
-        struct i2o_msg_mfa *mmsg;
-        mmsg = container_of(msg, struct i2o_msg_mfa, msg);
-
-        i2o_msg_nop_mfa(c, mmsg->mfa);
-        mempool_free(mmsg, c->in_msg.mempool);
-};
-
-/**
- *      i2o_flush_reply - Flush reply from I2O controller
- *      @c: I2O controller
- *      @m: the message identifier
- *
- *      The I2O controller must be informed that the reply message is not needed
- *      anymore. If you forget to flush the reply, the message frame can't be
- *      used by the controller anymore and is therefore lost.
- */
-static inline void i2o_flush_reply(struct i2o_controller *c, u32 m)
-{
-        writel(m, c->out_port);
-};
-
-/*
- *      Endian handling wrapped into the macro - keeps the core code
- *      cleaner.
- */
-
-#define i2o_raw_writel(val, mem)        __raw_writel(cpu_to_le32(val), mem)
-
-extern int i2o_parm_field_get(struct i2o_device *, int, int, void *, int);
-extern int i2o_parm_table_get(struct i2o_device *, int, int, int, void *, int,
-                              void *, int);
-
-/* debugging and troubleshooting/diagnostic helpers. */
-#define osm_printk(level, format, arg...)  \
-        printk(level "%s: " format, OSM_NAME , ## arg)
-
-#ifdef DEBUG
-#define osm_debug(format, arg...) \
-        osm_printk(KERN_DEBUG, format , ## arg)
-#else
-#define osm_debug(format, arg...) \
-        do { } while (0)
-#endif
-
-#define osm_err(format, arg...)         \
-        osm_printk(KERN_ERR, format , ## arg)
-#define osm_info(format, arg...)                \
-        osm_printk(KERN_INFO, format , ## arg)
-#define osm_warn(format, arg...)                \
-        osm_printk(KERN_WARNING, format , ## arg)
-
-/* debugging functions */
-extern void i2o_report_status(const char *, const char *, struct i2o_message *);
-extern void i2o_dump_message(struct i2o_message *);
-extern void i2o_dump_hrt(struct i2o_controller *c);
-extern void i2o_debug_state(struct i2o_controller *c);
-
-#endif                          /* _I2O_H */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 4f4eea8a6288..b9c7897dc566 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1017,6 +1017,15 @@ struct ieee80211_mmie {
         u8 mic[8];
 } __packed;
 
+/* Management MIC information element (IEEE 802.11w) for GMAC and CMAC-256 */
+struct ieee80211_mmie_16 {
+        u8 element_id;
+        u8 length;
+        __le16 key_id;
+        u8 sequence_number[6];
+        u8 mic[16];
+} __packed;
+
 struct ieee80211_vendor_ie {
         u8 element_id;
         u8 len;
@@ -1994,9 +2003,15 @@ enum ieee80211_key_len {
         WLAN_KEY_LEN_WEP40 = 5,
         WLAN_KEY_LEN_WEP104 = 13,
         WLAN_KEY_LEN_CCMP = 16,
+        WLAN_KEY_LEN_CCMP_256 = 32,
         WLAN_KEY_LEN_TKIP = 32,
         WLAN_KEY_LEN_AES_CMAC = 16,
         WLAN_KEY_LEN_SMS4 = 32,
+        WLAN_KEY_LEN_GCMP = 16,
+        WLAN_KEY_LEN_GCMP_256 = 32,
+        WLAN_KEY_LEN_BIP_CMAC_256 = 32,
+        WLAN_KEY_LEN_BIP_GMAC_128 = 16,
+        WLAN_KEY_LEN_BIP_GMAC_256 = 32,
 };
 
 #define IEEE80211_WEP_IV_LEN            4
@@ -2004,9 +2019,16 @@ enum ieee80211_key_len {
 #define IEEE80211_CCMP_HDR_LEN          8
 #define IEEE80211_CCMP_MIC_LEN          8
 #define IEEE80211_CCMP_PN_LEN           6
+#define IEEE80211_CCMP_256_HDR_LEN      8
+#define IEEE80211_CCMP_256_MIC_LEN      16
+#define IEEE80211_CCMP_256_PN_LEN       6
 #define IEEE80211_TKIP_IV_LEN           8
 #define IEEE80211_TKIP_ICV_LEN          4
 #define IEEE80211_CMAC_PN_LEN           6
+#define IEEE80211_GMAC_PN_LEN           6
+#define IEEE80211_GCMP_HDR_LEN          8
+#define IEEE80211_GCMP_MIC_LEN          16
+#define IEEE80211_GCMP_PN_LEN           6
 
 /* Public action codes */
 enum ieee80211_pub_actioncode {
@@ -2230,6 +2252,11 @@ enum ieee80211_sa_query_action {
 #define WLAN_CIPHER_SUITE_WEP104        0x000FAC05
 #define WLAN_CIPHER_SUITE_AES_CMAC      0x000FAC06
 #define WLAN_CIPHER_SUITE_GCMP          0x000FAC08
+#define WLAN_CIPHER_SUITE_GCMP_256      0x000FAC09
+#define WLAN_CIPHER_SUITE_CCMP_256      0x000FAC0A
+#define WLAN_CIPHER_SUITE_BIP_GMAC_128  0x000FAC0B
+#define WLAN_CIPHER_SUITE_BIP_GMAC_256  0x000FAC0C
+#define WLAN_CIPHER_SUITE_BIP_CMAC_256  0x000FAC0D
 
 #define WLAN_CIPHER_SUITE_SMS4          0x00147201
 
diff --git a/include/linux/if_bridge.h b/include/linux/if_bridge.h
index 0a8ce762a47f..a57bca2ea97e 100644
--- a/include/linux/if_bridge.h
+++ b/include/linux/if_bridge.h
@@ -50,24 +50,6 @@ extern void brioctl_set(int (*ioctl_hook)(struct net *, unsigned int, void __use
 typedef int br_should_route_hook_t(struct sk_buff *skb);
 extern br_should_route_hook_t __rcu *br_should_route_hook;
 
-#if IS_ENABLED(CONFIG_BRIDGE)
-int br_fdb_external_learn_add(struct net_device *dev,
-                              const unsigned char *addr, u16 vid);
-int br_fdb_external_learn_del(struct net_device *dev,
-                              const unsigned char *addr, u16 vid);
-#else
-static inline int br_fdb_external_learn_add(struct net_device *dev,
-                                            const unsigned char *addr, u16 vid)
-{
-        return 0;
-}
-static inline int br_fdb_external_learn_del(struct net_device *dev,
-                                            const unsigned char *addr, u16 vid)
-{
-        return 0;
-}
-#endif
-
 #if IS_ENABLED(CONFIG_BRIDGE) && IS_ENABLED(CONFIG_BRIDGE_IGMP_SNOOPING)
 int br_multicast_list_adjacent(struct net_device *dev,
                                struct list_head *br_ip_list);
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 515a35e2a48a..b11b28a30b9e 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -78,9 +78,9 @@ static inline bool is_vlan_dev(struct net_device *dev)
         return dev->priv_flags & IFF_802_1Q_VLAN;
 }
 
-#define vlan_tx_tag_present(__skb)      ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
-#define vlan_tx_tag_get(__skb)          ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
-#define vlan_tx_tag_get_id(__skb)       ((__skb)->vlan_tci & VLAN_VID_MASK)
+#define skb_vlan_tag_present(__skb)     ((__skb)->vlan_tci & VLAN_TAG_PRESENT)
+#define skb_vlan_tag_get(__skb)         ((__skb)->vlan_tci & ~VLAN_TAG_PRESENT)
+#define skb_vlan_tag_get_id(__skb)      ((__skb)->vlan_tci & VLAN_VID_MASK)
 
 /**
  *      struct vlan_pcpu_stats - VLAN percpu rx/tx stats
@@ -376,7 +376,7 @@ static inline struct sk_buff *vlan_insert_tag_set_proto(struct sk_buff *skb,
 static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb)
 {
         skb = vlan_insert_tag_set_proto(skb, skb->vlan_proto,
-                                        vlan_tx_tag_get(skb));
+                                        skb_vlan_tag_get(skb));
         if (likely(skb))
                 skb->vlan_tci = 0;
         return skb;
@@ -393,7 +393,7 @@ static inline struct sk_buff *__vlan_hwaccel_push_inside(struct sk_buff *skb)
  */
 static inline struct sk_buff *vlan_hwaccel_push_inside(struct sk_buff *skb)
 {
-        if (vlan_tx_tag_present(skb))
+        if (skb_vlan_tag_present(skb))
                 skb = __vlan_hwaccel_push_inside(skb);
         return skb;
 }
@@ -442,8 +442,8 @@ static inline int __vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 static inline int __vlan_hwaccel_get_tag(const struct sk_buff *skb,
                                          u16 *vlan_tci)
 {
-        if (vlan_tx_tag_present(skb)) {
-                *vlan_tci = vlan_tx_tag_get(skb);
+        if (skb_vlan_tag_present(skb)) {
+                *vlan_tci = skb_vlan_tag_get(skb);
                 return 0;
         } else {
                 *vlan_tci = 0;
@@ -472,27 +472,59 @@ static inline int vlan_get_tag(const struct sk_buff *skb, u16 *vlan_tci)
 /**
  * vlan_get_protocol - get protocol EtherType.
  * @skb: skbuff to query
+ * @type: first vlan protocol
+ * @depth: buffer to store length of eth and vlan tags in bytes
  *
  * Returns the EtherType of the packet, regardless of whether it is
  * vlan encapsulated (normal or hardware accelerated) or not.
  */
-static inline __be16 vlan_get_protocol(const struct sk_buff *skb)
+static inline __be16 __vlan_get_protocol(struct sk_buff *skb, __be16 type,
+                                         int *depth)
 {
-        __be16 protocol = 0;
-
-        if (vlan_tx_tag_present(skb) ||
-             skb->protocol != cpu_to_be16(ETH_P_8021Q))
-                protocol = skb->protocol;
-        else {
-                __be16 proto, *protop;
-                protop = skb_header_pointer(skb, offsetof(struct vlan_ethhdr,
-                                                h_vlan_encapsulated_proto),
-                                                sizeof(proto), &proto);
-                if (likely(protop))
-                        protocol = *protop;
+        unsigned int vlan_depth = skb->mac_len;
+
+        /* if type is 802.1Q/AD then the header should already be
+         * present at mac_len - VLAN_HLEN (if mac_len > 0), or at
+         * ETH_HLEN otherwise
+         */
+        if (type == htons(ETH_P_8021Q) || type == htons(ETH_P_8021AD)) {
+                if (vlan_depth) {
+                        if (WARN_ON(vlan_depth < VLAN_HLEN))
+                                return 0;
+                        vlan_depth -= VLAN_HLEN;
+                } else {
+                        vlan_depth = ETH_HLEN;
+                }
+                do {
+                        struct vlan_hdr *vh;
+
+                        if (unlikely(!pskb_may_pull(skb,
+                                                    vlan_depth + VLAN_HLEN)))
+                                return 0;
+
+                        vh = (struct vlan_hdr *)(skb->data + vlan_depth);
+                        type = vh->h_vlan_encapsulated_proto;
+                        vlan_depth += VLAN_HLEN;
+                } while (type == htons(ETH_P_8021Q) ||
+                         type == htons(ETH_P_8021AD));
         }
 
-        return protocol;
+        if (depth)
+                *depth = vlan_depth;
+
+        return type;
+}
+
+/**
+ * vlan_get_protocol - get protocol EtherType.
+ * @skb: skbuff to query
+ *
+ * Returns the EtherType of the packet, regardless of whether it is
+ * vlan encapsulated (normal or hardware accelerated) or not.
+ */
+static inline __be16 vlan_get_protocol(struct sk_buff *skb)
+{
+        return __vlan_get_protocol(skb, skb->protocol, NULL);
 }
 
 static inline void vlan_set_encap_proto(struct sk_buff *skb,
diff --git a/include/linux/iio/buffer.h b/include/linux/iio/buffer.h
index 519392763393..b65850a41127 100644
--- a/include/linux/iio/buffer.h
+++ b/include/linux/iio/buffer.h
@@ -25,9 +25,7 @@ struct iio_buffer;
  *                      available.
  * @request_update:     if a parameter change has been marked, update underlying
  *                      storage.
- * @get_bytes_per_datum:get current bytes per datum
  * @set_bytes_per_datum:set number of bytes per datum
- * @get_length:         get number of datums in buffer
  * @set_length:         set number of datums in buffer
  * @release:            called when the last reference to the buffer is dropped,
  *                      should free all resources allocated by the buffer.
@@ -49,9 +47,7 @@ struct iio_buffer_access_funcs {
 
         int (*request_update)(struct iio_buffer *buffer);
 
-        int (*get_bytes_per_datum)(struct iio_buffer *buffer);
         int (*set_bytes_per_datum)(struct iio_buffer *buffer, size_t bpd);
-        int (*get_length)(struct iio_buffer *buffer);
         int (*set_length)(struct iio_buffer *buffer, int length);
 
         void (*release)(struct iio_buffer *buffer);
@@ -85,10 +81,11 @@ struct iio_buffer {
         bool                                    scan_timestamp;
         const struct iio_buffer_access_funcs    *access;
         struct list_head                        scan_el_dev_attr_list;
+        struct attribute_group                  buffer_group;
         struct attribute_group                  scan_el_group;
         wait_queue_head_t                       pollq;
         bool                                    stufftoread;
-        const struct attribute_group *attrs;
+        const struct attribute                  **attrs;
         struct list_head                        demux_list;
         void                                    *demux_bounce;
         struct list_head                        buffer_list;
@@ -117,15 +114,6 @@ int iio_scan_mask_query(struct iio_dev *indio_dev,
                         struct iio_buffer *buffer, int bit);
 
 /**
- * iio_scan_mask_set() - set particular bit in the scan mask
- * @indio_dev           IIO device structure
- * @buffer:             the buffer whose scan mask we are interested in
- * @bit:                the bit to be set.
- **/
-int iio_scan_mask_set(struct iio_dev *indio_dev,
-                      struct iio_buffer *buffer, int bit);
-
-/**
  * iio_push_to_buffers() - push to a registered buffer.
  * @indio_dev:          iio_dev structure for device.
  * @data:               Full scan.
@@ -159,56 +147,6 @@ static inline int iio_push_to_buffers_with_timestamp(struct iio_dev *indio_dev,
 
 int iio_update_demux(struct iio_dev *indio_dev);
 
-/**
- * iio_buffer_register() - register the buffer with IIO core
- * @indio_dev:          device with the buffer to be registered
- * @channels:           the channel descriptions used to construct buffer
- * @num_channels:       the number of channels
- **/
-int iio_buffer_register(struct iio_dev *indio_dev,
-                        const struct iio_chan_spec *channels,
-                        int num_channels);
-
-/**
- * iio_buffer_unregister() - unregister the buffer from IIO core
- * @indio_dev:          the device with the buffer to be unregistered
- **/
-void iio_buffer_unregister(struct iio_dev *indio_dev);
-
-/**
- * iio_buffer_read_length() - attr func to get number of datums in the buffer
- **/
-ssize_t iio_buffer_read_length(struct device *dev,
-                               struct device_attribute *attr,
-                               char *buf);
-/**
- * iio_buffer_write_length() - attr func to set number of datums in the buffer
- **/
-ssize_t iio_buffer_write_length(struct device *dev,
-                              struct device_attribute *attr,
-                              const char *buf,
-                              size_t len);
-/**
- * iio_buffer_store_enable() - attr to turn the buffer on
- **/
-ssize_t iio_buffer_store_enable(struct device *dev,
-                                struct device_attribute *attr,
-                                const char *buf,
-                                size_t len);
-/**
- * iio_buffer_show_enable() - attr to see if the buffer is on
- **/
-ssize_t iio_buffer_show_enable(struct device *dev,
-                               struct device_attribute *attr,
-                               char *buf);
-#define IIO_BUFFER_LENGTH_ATTR DEVICE_ATTR(length, S_IRUGO | S_IWUSR,   \
-                                           iio_buffer_read_length,      \
-                                           iio_buffer_write_length)
-
-#define IIO_BUFFER_ENABLE_ATTR DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,   \
-                                           iio_buffer_show_enable,      \
-                                           iio_buffer_store_enable)
-
 bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
         const unsigned long *mask);
 
@@ -232,16 +170,6 @@ static inline void iio_device_attach_buffer(struct iio_dev *indio_dev,
 
 #else /* CONFIG_IIO_BUFFER */
 
-static inline int iio_buffer_register(struct iio_dev *indio_dev,
-                                           const struct iio_chan_spec *channels,
-                                           int num_channels)
-{
-        return 0;
-}
-
-static inline void iio_buffer_unregister(struct iio_dev *indio_dev)
-{}
-
 static inline void iio_buffer_get(struct iio_buffer *buffer) {}
 static inline void iio_buffer_put(struct iio_buffer *buffer) {}
 
diff --git a/include/linux/iio/common/ssp_sensors.h b/include/linux/iio/common/ssp_sensors.h
new file mode 100644
index 000000000000..f4d1b0edb432
--- /dev/null
+++ b/include/linux/iio/common/ssp_sensors.h
@@ -0,0 +1,82 @@
+/*
+ *  Copyright (C) 2014, Samsung Electronics Co. Ltd. All Rights Reserved.
+ *
+ *  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.
+ *
+ */
+#ifndef _SSP_SENSORS_H_
+#define _SSP_SENSORS_H_
+
+#include <linux/iio/iio.h>
+
+#define SSP_TIME_SIZE                           4
+#define SSP_ACCELEROMETER_SIZE                  6
+#define SSP_GYROSCOPE_SIZE                      6
+#define SSP_BIO_HRM_RAW_SIZE                    8
+#define SSP_BIO_HRM_RAW_FAC_SIZE                36
+#define SSP_BIO_HRM_LIB_SIZE                    8
+
+/**
+ * enum ssp_sensor_type - SSP sensor type
+ */
+enum ssp_sensor_type {
+        SSP_ACCELEROMETER_SENSOR = 0,
+        SSP_GYROSCOPE_SENSOR,
+        SSP_GEOMAGNETIC_UNCALIB_SENSOR,
+        SSP_GEOMAGNETIC_RAW,
+        SSP_GEOMAGNETIC_SENSOR,
+        SSP_PRESSURE_SENSOR,
+        SSP_GESTURE_SENSOR,
+        SSP_PROXIMITY_SENSOR,
+        SSP_TEMPERATURE_HUMIDITY_SENSOR,
+        SSP_LIGHT_SENSOR,
+        SSP_PROXIMITY_RAW,
+        SSP_ORIENTATION_SENSOR,
+        SSP_STEP_DETECTOR,
+        SSP_SIG_MOTION_SENSOR,
+        SSP_GYRO_UNCALIB_SENSOR,
+        SSP_GAME_ROTATION_VECTOR,
+        SSP_ROTATION_VECTOR,
+        SSP_STEP_COUNTER,
+        SSP_BIO_HRM_RAW,
+        SSP_BIO_HRM_RAW_FAC,
+        SSP_BIO_HRM_LIB,
+        SSP_SENSOR_MAX,
+};
+
+struct ssp_data;
+
+/**
+ * struct ssp_sensor_data - Sensor object
+ * @process_data:       Callback to feed sensor data.
+ * @type:               Used sensor type.
+ * @buffer:             Received data buffer.
+ */
+struct ssp_sensor_data {
+        int (*process_data)(struct iio_dev *indio_dev, void *buf,
+                            int64_t timestamp);
+        enum ssp_sensor_type type;
+        u8 *buffer;
+};
+
+void ssp_register_consumer(struct iio_dev *indio_dev,
+                           enum ssp_sensor_type type);
+
+int ssp_enable_sensor(struct ssp_data *data, enum ssp_sensor_type type,
+                      u32 delay);
+
+int ssp_disable_sensor(struct ssp_data *data, enum ssp_sensor_type type);
+
+u32 ssp_get_sensor_delay(struct ssp_data *data, enum ssp_sensor_type);
+
+int ssp_change_delay(struct ssp_data *data, enum ssp_sensor_type type,
+                     u32 delay);
+#endif /* _SSP_SENSORS_H_ */
diff --git a/include/linux/iio/consumer.h b/include/linux/iio/consumer.h
index 651f9a0e2765..26fb8f6342bb 100644
--- a/include/linux/iio/consumer.h
+++ b/include/linux/iio/consumer.h
@@ -151,6 +151,16 @@ int iio_read_channel_average_raw(struct iio_channel *chan, int *val);
 int iio_read_channel_processed(struct iio_channel *chan, int *val);
 
 /**
+ * iio_write_channel_raw() - write to a given channel
+ * @chan:               The channel being queried.
+ * @val:                Value being written.
+ *
+ * Note raw writes to iio channels are in dac counts and hence
+ * scale will need to be applied if standard units required.
+ */
+int iio_write_channel_raw(struct iio_channel *chan, int val);
+
+/**
  * iio_get_channel_type() - get the type of a channel
  * @channel:            The channel being queried.
  * @type:               The type of the channel.
@@ -191,7 +201,7 @@ int iio_read_channel_scale(struct iio_channel *chan, int *val,
  * The scale factor allows to increase the precession of the returned value. For
  * a scale factor of 1 the function will return the result in the normal IIO
  * unit for the channel type. E.g. millivolt for voltage channels, if you want
- * nanovolts instead pass 1000 as the scale factor.
+ * nanovolts instead pass 1000000 as the scale factor.
  */
 int iio_convert_raw_to_processed(struct iio_channel *chan, int raw,
         int *processed, unsigned int scale);
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 3642ce7ef512..80d855061064 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -38,6 +38,11 @@ enum iio_chan_info_enum {
         IIO_CHAN_INFO_HARDWAREGAIN,
         IIO_CHAN_INFO_HYSTERESIS,
         IIO_CHAN_INFO_INT_TIME,
+        IIO_CHAN_INFO_ENABLE,
+        IIO_CHAN_INFO_CALIBHEIGHT,
+        IIO_CHAN_INFO_CALIBWEIGHT,
+        IIO_CHAN_INFO_DEBOUNCE_COUNT,
+        IIO_CHAN_INFO_DEBOUNCE_TIME,
 };
 
 enum iio_shared_by {
@@ -284,10 +289,11 @@ static inline s64 iio_get_time_ns(void)
 /* Device operating modes */
 #define INDIO_DIRECT_MODE               0x01
 #define INDIO_BUFFER_TRIGGERED          0x02
+#define INDIO_BUFFER_SOFTWARE           0x04
 #define INDIO_BUFFER_HARDWARE           0x08
 
 #define INDIO_ALL_BUFFER_MODES                                  \
-        (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE)
+        (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE | INDIO_BUFFER_SOFTWARE)
 
 #define INDIO_MAX_RAW_ELEMENTS          4
 
@@ -591,7 +597,8 @@ void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig);
 static inline bool iio_buffer_enabled(struct iio_dev *indio_dev)
 {
         return indio_dev->currentmode
-                & (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE);
+                & (INDIO_BUFFER_TRIGGERED | INDIO_BUFFER_HARDWARE |
+                   INDIO_BUFFER_SOFTWARE);
 }
 
 /**
diff --git a/include/linux/iio/kfifo_buf.h b/include/linux/iio/kfifo_buf.h
index 25eeac762e84..1683bc710d14 100644
--- a/include/linux/iio/kfifo_buf.h
+++ b/include/linux/iio/kfifo_buf.h
@@ -5,7 +5,10 @@
 #include <linux/iio/iio.h>
 #include <linux/iio/buffer.h>
 
-struct iio_buffer *iio_kfifo_allocate(struct iio_dev *indio_dev);
+struct iio_buffer *iio_kfifo_allocate(void);
 void iio_kfifo_free(struct iio_buffer *r);
 
+struct iio_buffer *devm_iio_kfifo_allocate(struct device *dev);
+void devm_iio_kfifo_free(struct device *dev, struct iio_buffer *r);
+
 #endif
diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h
index 4a2af8adf874..580ed5bdb3fa 100644
--- a/include/linux/iio/types.h
+++ b/include/linux/iio/types.h
@@ -30,6 +30,11 @@ enum iio_chan_type {
         IIO_CCT,
         IIO_PRESSURE,
         IIO_HUMIDITYRELATIVE,
+        IIO_ACTIVITY,
+        IIO_STEPS,
+        IIO_ENERGY,
+        IIO_DISTANCE,
+        IIO_VELOCITY,
 };
 
 enum iio_modifier {
@@ -59,7 +64,12 @@ enum iio_modifier {
         IIO_MOD_NORTH_MAGN,
         IIO_MOD_NORTH_TRUE,
         IIO_MOD_NORTH_MAGN_TILT_COMP,
-        IIO_MOD_NORTH_TRUE_TILT_COMP
+        IIO_MOD_NORTH_TRUE_TILT_COMP,
+        IIO_MOD_RUNNING,
+        IIO_MOD_JOGGING,
+        IIO_MOD_WALKING,
+        IIO_MOD_STILL,
+        IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z,
 };
 
 enum iio_event_type {
@@ -68,6 +78,7 @@ enum iio_event_type {
         IIO_EV_TYPE_ROC,
         IIO_EV_TYPE_THRESH_ADAPTIVE,
         IIO_EV_TYPE_MAG_ADAPTIVE,
+        IIO_EV_TYPE_CHANGE,
 };
 
 enum iio_event_info {
@@ -81,6 +92,7 @@ enum iio_event_direction {
         IIO_EV_DIR_EITHER,
         IIO_EV_DIR_RISING,
         IIO_EV_DIR_FALLING,
+        IIO_EV_DIR_NONE,
 };
 
 #define IIO_VAL_INT 1
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 3037fc085e8e..696d22312b31 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -175,6 +175,13 @@ extern struct task_group root_task_group;
 # define INIT_NUMA_BALANCING(tsk)
 #endif
 
+#ifdef CONFIG_KASAN
+# define INIT_KASAN(tsk)                                                \
+        .kasan_depth = 1,
+#else
+# define INIT_KASAN(tsk)
+#endif
+
 /*
  *  INIT_TASK is used to set up the first task table, touch at
  * your own risk!. Base=0, limit=0x1fffff (=2MB)
@@ -193,6 +200,9 @@ extern struct task_group root_task_group;
         .nr_cpus_allowed= NR_CPUS,                                      \
         .mm             = NULL,                                         \
         .active_mm      = &init_mm,                                     \
+        .restart_block = {                                              \
+                .fn = do_no_restart_syscall,                            \
+        },                                                              \
         .se             = {                                             \
                 .group_node     = LIST_HEAD_INIT(tsk.se.group_node),    \
         },                                                              \
@@ -247,6 +257,7 @@ extern struct task_group root_task_group;
         INIT_RT_MUTEXES(tsk)                                            \
         INIT_VTIME(tsk)                                                 \
         INIT_NUMA_BALANCING(tsk)                                        \
+        INIT_KASAN(tsk)                                                 \
 }
 
 
diff --git a/include/linux/input/mt.h b/include/linux/input/mt.h
index f583ff639776..d7188de4db96 100644
--- a/include/linux/input/mt.h
+++ b/include/linux/input/mt.h
@@ -119,7 +119,8 @@ struct input_mt_pos {
 };
 
 int input_mt_assign_slots(struct input_dev *dev, int *slots,
-                          const struct input_mt_pos *pos, int num_pos);
+                          const struct input_mt_pos *pos, int num_pos,
+                          int dmax);
 
 int input_mt_get_slot_by_key(struct input_dev *dev, int key);
 
diff --git a/include/linux/iopoll.h b/include/linux/iopoll.h
new file mode 100644
index 000000000000..1c30014ed176
--- /dev/null
+++ b/include/linux/iopoll.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (c) 2012-2014 The Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef _LINUX_IOPOLL_H
+#define _LINUX_IOPOLL_H
+
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/hrtimer.h>
+#include <linux/delay.h>
+#include <linux/errno.h>
+#include <linux/io.h>
+
+/**
+ * readx_poll_timeout - Periodically poll an address until a condition is met or a timeout occurs
+ * @op: accessor function (takes @addr as its only argument)
+ * @addr: Address to poll
+ * @val: Variable to read the value into
+ * @cond: Break condition (usually involving @val)
+ * @sleep_us: Maximum time to sleep between reads in us (0
+ *            tight-loops).  Should be less than ~20ms since usleep_range
+ *            is used (see Documentation/timers/timers-howto.txt).
+ * @timeout_us: Timeout in us, 0 means never timeout
+ *
+ * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
+ * case, the last read value at @addr is stored in @val. Must not
+ * be called from atomic context if sleep_us or timeout_us are used.
+ *
+ * When available, you'll probably want to use one of the specialized
+ * macros defined below rather than this macro directly.
+ */
+#define readx_poll_timeout(op, addr, val, cond, sleep_us, timeout_us)   \
+({ \
+        ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \
+        might_sleep_if(sleep_us); \
+        for (;;) { \
+                (val) = op(addr); \
+                if (cond) \
+                        break; \
+                if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
+                        (val) = op(addr); \
+                        break; \
+                } \
+                if (sleep_us) \
+                        usleep_range((sleep_us >> 2) + 1, sleep_us); \
+        } \
+        (cond) ? 0 : -ETIMEDOUT; \
+})
+
+/**
+ * readx_poll_timeout_atomic - Periodically poll an address until a condition is met or a timeout occurs
+ * @op: accessor function (takes @addr as its only argument)
+ * @addr: Address to poll
+ * @val: Variable to read the value into
+ * @cond: Break condition (usually involving @val)
+ * @delay_us: Time to udelay between reads in us (0 tight-loops).  Should
+ *            be less than ~10us since udelay is used (see
+ *            Documentation/timers/timers-howto.txt).
+ * @timeout_us: Timeout in us, 0 means never timeout
+ *
+ * Returns 0 on success and -ETIMEDOUT upon a timeout. In either
+ * case, the last read value at @addr is stored in @val.
+ *
+ * When available, you'll probably want to use one of the specialized
+ * macros defined below rather than this macro directly.
+ */
+#define readx_poll_timeout_atomic(op, addr, val, cond, delay_us, timeout_us) \
+({ \
+        ktime_t timeout = ktime_add_us(ktime_get(), timeout_us); \
+        for (;;) { \
+                (val) = op(addr); \
+                if (cond) \
+                        break; \
+                if (timeout_us && ktime_compare(ktime_get(), timeout) > 0) { \
+                        (val) = op(addr); \
+                        break; \
+                } \
+                if (delay_us) \
+                        udelay(delay_us);       \
+        } \
+        (cond) ? 0 : -ETIMEDOUT; \
+})
+
+
+#define readb_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readb, addr, val, cond, delay_us, timeout_us)
+
+#define readb_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readb, addr, val, cond, delay_us, timeout_us)
+
+#define readw_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readw, addr, val, cond, delay_us, timeout_us)
+
+#define readw_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readw, addr, val, cond, delay_us, timeout_us)
+
+#define readl_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readl, addr, val, cond, delay_us, timeout_us)
+
+#define readl_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readl, addr, val, cond, delay_us, timeout_us)
+
+#define readq_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readq, addr, val, cond, delay_us, timeout_us)
+
+#define readq_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readq, addr, val, cond, delay_us, timeout_us)
+
+#define readb_relaxed_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readb_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readb_relaxed_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readb_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readw_relaxed_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readw_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readw_relaxed_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readw_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readl_relaxed_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readl_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readl_relaxed_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readl_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readq_relaxed_poll_timeout(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout(readq_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#define readq_relaxed_poll_timeout_atomic(addr, val, cond, delay_us, timeout_us) \
+        readx_poll_timeout_atomic(readq_relaxed, addr, val, cond, delay_us, timeout_us)
+
+#endif /* _LINUX_IOPOLL_H */
diff --git a/include/linux/iova.h b/include/linux/iova.h
index 19e81d5ccb6d..3920a19d8194 100644
--- a/include/linux/iova.h
+++ b/include/linux/iova.h
@@ -16,9 +16,6 @@
 #include <linux/rbtree.h>
 #include <linux/dma-mapping.h>
 
-/* IO virtual address start page frame number */
-#define IOVA_START_PFN          (1)
-
 /* iova structure */
 struct iova {
         struct rb_node  node;
@@ -31,6 +28,8 @@ struct iova_domain {
         spinlock_t      iova_rbtree_lock; /* Lock to protect update of rbtree */
         struct rb_root  rbroot;         /* iova domain rbtree root */
         struct rb_node  *cached32_node; /* Save last alloced node */
+        unsigned long   granule;        /* pfn granularity for this domain */
+        unsigned long   start_pfn;      /* Lower limit for this domain */
         unsigned long   dma_32bit_pfn;
 };
 
@@ -39,6 +38,39 @@ static inline unsigned long iova_size(struct iova *iova)
         return iova->pfn_hi - iova->pfn_lo + 1;
 }
 
+static inline unsigned long iova_shift(struct iova_domain *iovad)
+{
+        return __ffs(iovad->granule);
+}
+
+static inline unsigned long iova_mask(struct iova_domain *iovad)
+{
+        return iovad->granule - 1;
+}
+
+static inline size_t iova_offset(struct iova_domain *iovad, dma_addr_t iova)
+{
+        return iova & iova_mask(iovad);
+}
+
+static inline size_t iova_align(struct iova_domain *iovad, size_t size)
+{
+        return ALIGN(size, iovad->granule);
+}
+
+static inline dma_addr_t iova_dma_addr(struct iova_domain *iovad, struct iova *iova)
+{
+        return (dma_addr_t)iova->pfn_lo << iova_shift(iovad);
+}
+
+static inline unsigned long iova_pfn(struct iova_domain *iovad, dma_addr_t iova)
+{
+        return iova >> iova_shift(iovad);
+}
+
+int iommu_iova_cache_init(void);
+void iommu_iova_cache_destroy(void);
+
 struct iova *alloc_iova_mem(void);
 void free_iova_mem(struct iova *iova);
 void free_iova(struct iova_domain *iovad, unsigned long pfn);
@@ -49,7 +81,8 @@ struct iova *alloc_iova(struct iova_domain *iovad, unsigned long size,
 struct iova *reserve_iova(struct iova_domain *iovad, unsigned long pfn_lo,
         unsigned long pfn_hi);
 void copy_reserved_iova(struct iova_domain *from, struct iova_domain *to);
-void init_iova_domain(struct iova_domain *iovad, unsigned long pfn_32bit);
+void init_iova_domain(struct iova_domain *iovad, unsigned long granule,
+        unsigned long start_pfn, unsigned long pfn_32bit);
 struct iova *find_iova(struct iova_domain *iovad, unsigned long pfn);
 void put_iova_domain(struct iova_domain *iovad);
 struct iova *split_and_remove_iova(struct iova_domain *iovad,
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index c694e7baa621..4d5169f5d7d1 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -52,6 +52,7 @@ struct ipv6_devconf {
         __s32           force_tllao;
         __s32           ndisc_notify;
         __s32           suppress_frag_ndisc;
+        __s32           accept_ra_mtu;
         void            *sysctl;
 };
 
@@ -124,6 +125,12 @@ struct ipv6_mc_socklist;
 struct ipv6_ac_socklist;
 struct ipv6_fl_socklist;
 
+struct inet6_cork {
+        struct ipv6_txoptions *opt;
+        u8 hop_limit;
+        u8 tclass;
+};
+
 /**
  * struct ipv6_pinfo - ipv6 private area
  *
@@ -216,11 +223,7 @@ struct ipv6_pinfo {
         struct ipv6_txoptions   *opt;
         struct sk_buff          *pktoptions;
         struct sk_buff          *rxpmtu;
-        struct {
-                struct ipv6_txoptions *opt;
-                u8 hop_limit;
-                u8 tclass;
-        } cork;
+        struct inet6_cork       cork;
 };
 
 /* WARNING: don't change the layout of the members in {raw,udp,tcp}6_sock! */
diff --git a/include/linux/irqchip/arm-gic-v3.h b/include/linux/irqchip/arm-gic-v3.h
index 1e8b0cf30792..800544bc7bfd 100644
--- a/include/linux/irqchip/arm-gic-v3.h
+++ b/include/linux/irqchip/arm-gic-v3.h
@@ -33,6 +33,7 @@
 #define GICD_SETSPI_SR                  0x0050
 #define GICD_CLRSPI_SR                  0x0058
 #define GICD_SEIR                       0x0068
+#define GICD_IGROUPR                    0x0080
 #define GICD_ISENABLER                  0x0100
 #define GICD_ICENABLER                  0x0180
 #define GICD_ISPENDR                    0x0200
@@ -41,14 +42,37 @@
 #define GICD_ICACTIVER                  0x0380
 #define GICD_IPRIORITYR                 0x0400
 #define GICD_ICFGR                      0x0C00
+#define GICD_IGRPMODR                   0x0D00
+#define GICD_NSACR                      0x0E00
 #define GICD_IROUTER                    0x6000
+#define GICD_IDREGS                     0xFFD0
 #define GICD_PIDR2                      0xFFE8
 
+/*
+ * Those registers are actually from GICv2, but the spec demands that they
+ * are implemented as RES0 if ARE is 1 (which we do in KVM's emulated GICv3).
+ */
+#define GICD_ITARGETSR                  0x0800
+#define GICD_SGIR                       0x0F00
+#define GICD_CPENDSGIR                  0x0F10
+#define GICD_SPENDSGIR                  0x0F20
+
 #define GICD_CTLR_RWP                   (1U << 31)
+#define GICD_CTLR_DS                    (1U << 6)
 #define GICD_CTLR_ARE_NS                (1U << 4)
 #define GICD_CTLR_ENABLE_G1A            (1U << 1)
 #define GICD_CTLR_ENABLE_G1             (1U << 0)
 
+/*
+ * In systems with a single security state (what we emulate in KVM)
+ * the meaning of the interrupt group enable bits is slightly different
+ */
+#define GICD_CTLR_ENABLE_SS_G1          (1U << 1)
+#define GICD_CTLR_ENABLE_SS_G0          (1U << 0)
+
+#define GICD_TYPER_LPIS                 (1U << 17)
+#define GICD_TYPER_MBIS                 (1U << 16)
+
 #define GICD_TYPER_ID_BITS(typer)       ((((typer) >> 19) & 0x1f) + 1)
 #define GICD_TYPER_IRQS(typer)          ((((typer) & 0x1f) + 1) * 32)
 #define GICD_TYPER_LPIS                 (1U << 17)
@@ -60,6 +84,8 @@
 #define GIC_PIDR2_ARCH_GICv3            0x30
 #define GIC_PIDR2_ARCH_GICv4            0x40
 
+#define GIC_V3_DIST_SIZE                0x10000
+
 /*
  * Re-Distributor registers, offsets from RD_base
  */
@@ -78,6 +104,7 @@
 #define GICR_SYNCR                      0x00C0
 #define GICR_MOVLPIR                    0x0100
 #define GICR_MOVALLR                    0x0110
+#define GICR_IDREGS                     GICD_IDREGS
 #define GICR_PIDR2                      GICD_PIDR2
 
 #define GICR_CTLR_ENABLE_LPIS           (1UL << 0)
@@ -104,6 +131,7 @@
 /*
  * Re-Distributor registers, offsets from SGI_base
  */
+#define GICR_IGROUPR0                   GICD_IGROUPR
 #define GICR_ISENABLER0                 GICD_ISENABLER
 #define GICR_ICENABLER0                 GICD_ICENABLER
 #define GICR_ISPENDR0                   GICD_ISPENDR
@@ -112,11 +140,15 @@
 #define GICR_ICACTIVER0                 GICD_ICACTIVER
 #define GICR_IPRIORITYR0                GICD_IPRIORITYR
 #define GICR_ICFGR0                     GICD_ICFGR
+#define GICR_IGRPMODR0                  GICD_IGRPMODR
+#define GICR_NSACR                      GICD_NSACR
 
 #define GICR_TYPER_PLPIS                (1U << 0)
 #define GICR_TYPER_VLPIS                (1U << 1)
 #define GICR_TYPER_LAST                 (1U << 4)
 
+#define GIC_V3_REDIST_SIZE              0x20000
+
 #define LPI_PROP_GROUP1                 (1 << 1)
 #define LPI_PROP_ENABLED                (1 << 0)
 
@@ -248,6 +280,18 @@
 #define ICC_SRE_EL2_SRE                 (1 << 0)
 #define ICC_SRE_EL2_ENABLE              (1 << 3)
 
+#define ICC_SGI1R_TARGET_LIST_SHIFT     0
+#define ICC_SGI1R_TARGET_LIST_MASK      (0xffff << ICC_SGI1R_TARGET_LIST_SHIFT)
+#define ICC_SGI1R_AFFINITY_1_SHIFT      16
+#define ICC_SGI1R_AFFINITY_1_MASK       (0xff << ICC_SGI1R_AFFINITY_1_SHIFT)
+#define ICC_SGI1R_SGI_ID_SHIFT          24
+#define ICC_SGI1R_SGI_ID_MASK           (0xff << ICC_SGI1R_SGI_ID_SHIFT)
+#define ICC_SGI1R_AFFINITY_2_SHIFT      32
+#define ICC_SGI1R_AFFINITY_2_MASK       (0xffULL << ICC_SGI1R_AFFINITY_1_SHIFT)
+#define ICC_SGI1R_IRQ_ROUTING_MODE_BIT  40
+#define ICC_SGI1R_AFFINITY_3_SHIFT      48
+#define ICC_SGI1R_AFFINITY_3_MASK       (0xffULL << ICC_SGI1R_AFFINITY_1_SHIFT)
+
 /*
  * System register definitions
  */
diff --git a/include/linux/irqchip/irq-omap-intc.h b/include/linux/irqchip/irq-omap-intc.h
index e06b370cfc0d..2e3d1afeb674 100644
--- a/include/linux/irqchip/irq-omap-intc.h
+++ b/include/linux/irqchip/irq-omap-intc.h
@@ -18,9 +18,7 @@
 #ifndef __INCLUDE_LINUX_IRQCHIP_IRQ_OMAP_INTC_H
 #define __INCLUDE_LINUX_IRQCHIP_IRQ_OMAP_INTC_H
 
-void omap2_init_irq(void);
 void omap3_init_irq(void);
-void ti81xx_init_irq(void);
 
 int omap_irq_pending(void);
 void omap_intc_save_context(void);
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 31229e0be90b..d32615280be9 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -956,15 +956,6 @@ void __log_wait_for_space(journal_t *journal);
 extern void     __journal_drop_transaction(journal_t *, transaction_t *);
 extern int      cleanup_journal_tail(journal_t *);
 
-/* Debugging code only: */
-
-#define jbd_ENOSYS() \
-do {                                                                       \
-        printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
-        current->state = TASK_UNINTERRUPTIBLE;                             \
-        schedule();                                                        \
-} while (1)
-
 /*
  * is_journal_abort
  *
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 704b9a599b26..20e7f78041c8 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -1251,15 +1251,6 @@ void __jbd2_log_wait_for_space(journal_t *journal);
 extern void __jbd2_journal_drop_transaction(journal_t *, transaction_t *);
 extern int jbd2_cleanup_journal_tail(journal_t *);
 
-/* Debugging code only: */
-
-#define jbd_ENOSYS() \
-do {                                                                       \
-        printk (KERN_ERR "JBD unimplemented function %s\n", __func__); \
-        current->state = TASK_UNINTERRUPTIBLE;                             \
-        schedule();                                                        \
-} while (1)
-
 /*
  * is_journal_abort
  *
diff --git a/include/linux/kasan.h b/include/linux/kasan.h
new file mode 100644
index 000000000000..72ba725ddf9c
--- /dev/null
+++ b/include/linux/kasan.h
@@ -0,0 +1,89 @@
+#ifndef _LINUX_KASAN_H
+#define _LINUX_KASAN_H
+
+#include <linux/types.h>
+
+struct kmem_cache;
+struct page;
+
+#ifdef CONFIG_KASAN
+
+#define KASAN_SHADOW_SCALE_SHIFT 3
+#define KASAN_SHADOW_OFFSET _AC(CONFIG_KASAN_SHADOW_OFFSET, UL)
+
+#include <asm/kasan.h>
+#include <linux/sched.h>
+
+static inline void *kasan_mem_to_shadow(const void *addr)
+{
+        return (void *)((unsigned long)addr >> KASAN_SHADOW_SCALE_SHIFT)
+                + KASAN_SHADOW_OFFSET;
+}
+
+/* Enable reporting bugs after kasan_disable_current() */
+static inline void kasan_enable_current(void)
+{
+        current->kasan_depth++;
+}
+
+/* Disable reporting bugs for current task */
+static inline void kasan_disable_current(void)
+{
+        current->kasan_depth--;
+}
+
+void kasan_unpoison_shadow(const void *address, size_t size);
+
+void kasan_alloc_pages(struct page *page, unsigned int order);
+void kasan_free_pages(struct page *page, unsigned int order);
+
+void kasan_poison_slab(struct page *page);
+void kasan_unpoison_object_data(struct kmem_cache *cache, void *object);
+void kasan_poison_object_data(struct kmem_cache *cache, void *object);
+
+void kasan_kmalloc_large(const void *ptr, size_t size);
+void kasan_kfree_large(const void *ptr);
+void kasan_kmalloc(struct kmem_cache *s, const void *object, size_t size);
+void kasan_krealloc(const void *object, size_t new_size);
+
+void kasan_slab_alloc(struct kmem_cache *s, void *object);
+void kasan_slab_free(struct kmem_cache *s, void *object);
+
+#define MODULE_ALIGN (PAGE_SIZE << KASAN_SHADOW_SCALE_SHIFT)
+
+int kasan_module_alloc(void *addr, size_t size);
+void kasan_module_free(void *addr);
+
+#else /* CONFIG_KASAN */
+
+#define MODULE_ALIGN 1
+
+static inline void kasan_unpoison_shadow(const void *address, size_t size) {}
+
+static inline void kasan_enable_current(void) {}
+static inline void kasan_disable_current(void) {}
+
+static inline void kasan_alloc_pages(struct page *page, unsigned int order) {}
+static inline void kasan_free_pages(struct page *page, unsigned int order) {}
+
+static inline void kasan_poison_slab(struct page *page) {}
+static inline void kasan_unpoison_object_data(struct kmem_cache *cache,
+                                        void *object) {}
+static inline void kasan_poison_object_data(struct kmem_cache *cache,
+                                        void *object) {}
+
+static inline void kasan_kmalloc_large(void *ptr, size_t size) {}
+static inline void kasan_kfree_large(const void *ptr) {}
+static inline void kasan_kmalloc(struct kmem_cache *s, const void *object,
+                                size_t size) {}
+static inline void kasan_krealloc(const void *object, size_t new_size) {}
+
+static inline void kasan_slab_alloc(struct kmem_cache *s, void *object) {}
+static inline void kasan_slab_free(struct kmem_cache *s, void *object) {}
+
+static inline int kasan_module_alloc(void *addr, size_t size) { return 0; }
+static inline void kasan_module_free(void *addr) {}
+
+#endif /* CONFIG_KASAN */
+
+#endif /* LINUX_KASAN_H */
diff --git a/include/linux/kdb.h b/include/linux/kdb.h
index 290db1269c4c..75ae2e2631fc 100644
--- a/include/linux/kdb.h
+++ b/include/linux/kdb.h
@@ -13,11 +13,54 @@
  * Copyright (C) 2009 Jason Wessel <jason.wessel@windriver.com>
  */
 
+/* Shifted versions of the command enable bits are be used if the command
+ * has no arguments (see kdb_check_flags). This allows commands, such as
+ * go, to have different permissions depending upon whether it is called
+ * with an argument.
+ */
+#define KDB_ENABLE_NO_ARGS_SHIFT 10
+
 typedef enum {
-        KDB_REPEAT_NONE = 0,    /* Do not repeat this command */
-        KDB_REPEAT_NO_ARGS,     /* Repeat the command without arguments */
-        KDB_REPEAT_WITH_ARGS,   /* Repeat the command including its arguments */
-} kdb_repeat_t;
+        KDB_ENABLE_ALL = (1 << 0), /* Enable everything */
+        KDB_ENABLE_MEM_READ = (1 << 1),
+        KDB_ENABLE_MEM_WRITE = (1 << 2),
+        KDB_ENABLE_REG_READ = (1 << 3),
+        KDB_ENABLE_REG_WRITE = (1 << 4),
+        KDB_ENABLE_INSPECT = (1 << 5),
+        KDB_ENABLE_FLOW_CTRL = (1 << 6),
+        KDB_ENABLE_SIGNAL = (1 << 7),
+        KDB_ENABLE_REBOOT = (1 << 8),
+        /* User exposed values stop here, all remaining flags are
+         * exclusively used to describe a commands behaviour.
+         */
+
+        KDB_ENABLE_ALWAYS_SAFE = (1 << 9),
+        KDB_ENABLE_MASK = (1 << KDB_ENABLE_NO_ARGS_SHIFT) - 1,
+
+        KDB_ENABLE_ALL_NO_ARGS = KDB_ENABLE_ALL << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MEM_READ_NO_ARGS = KDB_ENABLE_MEM_READ
+                                      << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MEM_WRITE_NO_ARGS = KDB_ENABLE_MEM_WRITE
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REG_READ_NO_ARGS = KDB_ENABLE_REG_READ
+                                      << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REG_WRITE_NO_ARGS = KDB_ENABLE_REG_WRITE
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_INSPECT_NO_ARGS = KDB_ENABLE_INSPECT
+                                     << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_FLOW_CTRL_NO_ARGS = KDB_ENABLE_FLOW_CTRL
+                                       << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_SIGNAL_NO_ARGS = KDB_ENABLE_SIGNAL
+                                    << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_REBOOT_NO_ARGS = KDB_ENABLE_REBOOT
+                                    << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_ALWAYS_SAFE_NO_ARGS = KDB_ENABLE_ALWAYS_SAFE
+                                         << KDB_ENABLE_NO_ARGS_SHIFT,
+        KDB_ENABLE_MASK_NO_ARGS = KDB_ENABLE_MASK << KDB_ENABLE_NO_ARGS_SHIFT,
+
+        KDB_REPEAT_NO_ARGS = 0x40000000, /* Repeat the command w/o arguments */
+        KDB_REPEAT_WITH_ARGS = 0x80000000, /* Repeat the command with args */
+} kdb_cmdflags_t;
 
 typedef int (*kdb_func_t)(int, const char **);
 
@@ -62,6 +105,7 @@ extern atomic_t kdb_event;
 #define KDB_BADLENGTH   (-19)
 #define KDB_NOBP        (-20)
 #define KDB_BADADDR     (-21)
+#define KDB_NOPERM      (-22)
 
 /*
  * kdb_diemsg
@@ -146,17 +190,17 @@ static inline const char *kdb_walk_kallsyms(loff_t *pos)
 
 /* Dynamic kdb shell command registration */
 extern int kdb_register(char *, kdb_func_t, char *, char *, short);
-extern int kdb_register_repeat(char *, kdb_func_t, char *, char *,
-                               short, kdb_repeat_t);
+extern int kdb_register_flags(char *, kdb_func_t, char *, char *,
+                              short, kdb_cmdflags_t);
 extern int kdb_unregister(char *);
 #else /* ! CONFIG_KGDB_KDB */
 static inline __printf(1, 2) int kdb_printf(const char *fmt, ...) { return 0; }
 static inline void kdb_init(int level) {}
 static inline int kdb_register(char *cmd, kdb_func_t func, char *usage,
                                char *help, short minlen) { return 0; }
-static inline int kdb_register_repeat(char *cmd, kdb_func_t func, char *usage,
-                                      char *help, short minlen,
-                                      kdb_repeat_t repeat) { return 0; }
+static inline int kdb_register_flags(char *cmd, kdb_func_t func, char *usage,
+                                     char *help, short minlen,
+                                     kdb_cmdflags_t flags) { return 0; }
 static inline int kdb_unregister(char *cmd) { return 0; }
 #endif  /* CONFIG_KGDB_KDB */
 enum {
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 5449d2f4a1ef..d6d630d31ef3 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -176,7 +176,7 @@ extern int _cond_resched(void);
  */
 # define might_sleep() \
         do { __might_sleep(__FILE__, __LINE__, 0); might_resched(); } while (0)
-# define sched_annotate_sleep() __set_current_state(TASK_RUNNING)
+# define sched_annotate_sleep() (current->task_state_change = 0)
 #else
   static inline void ___might_sleep(const char *file, int line,
                                    int preempt_offset) { }
@@ -471,6 +471,7 @@ extern enum system_states {
 #define TAINT_OOT_MODULE                12
 #define TAINT_UNSIGNED_MODULE           13
 #define TAINT_SOFTLOCKUP                14
+#define TAINT_LIVEPATCH                 15
 
 extern const char hex_asc[];
 #define hex_asc_lo(x)   hex_asc[((x) & 0x0f)]
@@ -799,9 +800,6 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
         (type *)( (char *)__mptr - offsetof(type,member) );})
 
-/* Trap pasters of __FUNCTION__ at compile-time */
-#define __FUNCTION__ (__func__)
-
 /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index d4e01b358341..71ecdab1671b 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -43,7 +43,6 @@ enum kernfs_node_flag {
         KERNFS_HAS_SEQ_SHOW     = 0x0040,
         KERNFS_HAS_MMAP         = 0x0080,
         KERNFS_LOCKDEP          = 0x0100,
-        KERNFS_STATIC_NAME      = 0x0200,
         KERNFS_SUICIDAL         = 0x0400,
         KERNFS_SUICIDED         = 0x0800,
 };
@@ -291,7 +290,6 @@ struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
                                          umode_t mode, loff_t size,
                                          const struct kernfs_ops *ops,
                                          void *priv, const void *ns,
-                                         bool name_is_static,
                                          struct lock_class_key *key);
 struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
                                        const char *name,
@@ -369,8 +367,7 @@ kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
 static inline struct kernfs_node *
 __kernfs_create_file(struct kernfs_node *parent, const char *name,
                      umode_t mode, loff_t size, const struct kernfs_ops *ops,
-                     void *priv, const void *ns, bool name_is_static,
-                     struct lock_class_key *key)
+                     void *priv, const void *ns, struct lock_class_key *key)
 { return ERR_PTR(-ENOSYS); }
 
 static inline struct kernfs_node *
@@ -439,7 +436,7 @@ kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
         key = (struct lock_class_key *)&ops->lockdep_key;
 #endif
         return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
-                                    false, key);
+                                    key);
 }
 
 static inline struct kernfs_node *
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 5297f9fa0ef2..1ab54754a86d 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -308,7 +308,8 @@ struct optimized_kprobe {
 /* Architecture dependent functions for direct jump optimization */
 extern int arch_prepared_optinsn(struct arch_optimized_insn *optinsn);
 extern int arch_check_optimized_kprobe(struct optimized_kprobe *op);
-extern int arch_prepare_optimized_kprobe(struct optimized_kprobe *op);
+extern int arch_prepare_optimized_kprobe(struct optimized_kprobe *op,
+                                         struct kprobe *orig);
 extern void arch_remove_optimized_kprobe(struct optimized_kprobe *op);
 extern void arch_optimize_kprobes(struct list_head *oplist);
 extern void arch_unoptimize_kprobes(struct list_head *oplist,
diff --git a/include/linux/ktime.h b/include/linux/ktime.h
index c9d645ad98ff..5fc3d1083071 100644
--- a/include/linux/ktime.h
+++ b/include/linux/ktime.h
@@ -166,7 +166,17 @@ static inline bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
 }
 
 #if BITS_PER_LONG < 64
-extern u64 ktime_divns(const ktime_t kt, s64 div);
+extern u64 __ktime_divns(const ktime_t kt, s64 div);
+static inline u64 ktime_divns(const ktime_t kt, s64 div)
+{
+        if (__builtin_constant_p(div) && !(div >> 32)) {
+                u64 ns = kt.tv64;
+                do_div(ns, div);
+                return ns;
+        } else {
+                return __ktime_divns(kt, div);
+        }
+}
 #else /* BITS_PER_LONG < 64 */
 # define ktime_divns(kt, div)           (u64)((kt).tv64 / (div))
 #endif
@@ -186,6 +196,11 @@ static inline s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
        return ktime_to_us(ktime_sub(later, earlier));
 }
 
+static inline s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)
+{
+        return ktime_to_ms(ktime_sub(later, earlier));
+}
+
 static inline ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
 {
         return ktime_add_ns(kt, usec * NSEC_PER_USEC);
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 26f106022c88..d12b2104d19b 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -33,10 +33,6 @@
 
 #include <asm/kvm_host.h>
 
-#ifndef KVM_MMIO_SIZE
-#define KVM_MMIO_SIZE 8
-#endif
-
 /*
  * The bit 16 ~ bit 31 of kvm_memory_region::flags are internally used
  * in kvm, other bits are visible for userspace which are defined in
@@ -200,17 +196,6 @@ int kvm_setup_async_pf(struct kvm_vcpu *vcpu, gva_t gva, unsigned long hva,
 int kvm_async_pf_wakeup_all(struct kvm_vcpu *vcpu);
 #endif
 
-/*
- * Carry out a gup that requires IO. Allow the mm to relinquish the mmap
- * semaphore if the filemap/swap has to wait on a page lock. pagep == NULL
- * controls whether we retry the gup one more time to completion in that case.
- * Typically this is called after a FAULT_FLAG_RETRY_NOWAIT in the main tdp
- * handler.
- */
-int kvm_get_user_page_io(struct task_struct *tsk, struct mm_struct *mm,
-                         unsigned long addr, bool write_fault,
-                         struct page **pagep);
-
 enum {
         OUTSIDE_GUEST_MODE,
         IN_GUEST_MODE,
@@ -611,6 +596,15 @@ int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext);
 
 int kvm_get_dirty_log(struct kvm *kvm,
                         struct kvm_dirty_log *log, int *is_dirty);
+
+int kvm_get_dirty_log_protect(struct kvm *kvm,
+                        struct kvm_dirty_log *log, bool *is_dirty);
+
+void kvm_arch_mmu_enable_log_dirty_pt_masked(struct kvm *kvm,
+                                        struct kvm_memory_slot *slot,
+                                        gfn_t gfn_offset,
+                                        unsigned long mask);
+
 int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
                                 struct kvm_dirty_log *log);
 
@@ -652,7 +646,7 @@ void kvm_arch_vcpu_load(struct kvm_vcpu *vcpu, int cpu);
 void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu);
 struct kvm_vcpu *kvm_arch_vcpu_create(struct kvm *kvm, unsigned int id);
 int kvm_arch_vcpu_setup(struct kvm_vcpu *vcpu);
-int kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
+void kvm_arch_vcpu_postcreate(struct kvm_vcpu *vcpu);
 void kvm_arch_vcpu_destroy(struct kvm_vcpu *vcpu);
 
 int kvm_arch_hardware_enable(void);
@@ -1042,6 +1036,8 @@ void kvm_unregister_device_ops(u32 type);
 
 extern struct kvm_device_ops kvm_mpic_ops;
 extern struct kvm_device_ops kvm_xics_ops;
+extern struct kvm_device_ops kvm_arm_vgic_v2_ops;
+extern struct kvm_device_ops kvm_arm_vgic_v3_ops;
 
 #ifdef CONFIG_HAVE_KVM_CPU_RELAX_INTERCEPT
 
diff --git a/include/linux/led-class-flash.h b/include/linux/led-class-flash.h
new file mode 100644
index 000000000000..5ba2facd7a51
--- /dev/null
+++ b/include/linux/led-class-flash.h
@@ -0,0 +1,207 @@
+/*
+ * LED Flash class interface
+ *
+ * Copyright (C) 2015 Samsung Electronics Co., Ltd.
+ * Author: Jacek Anaszewski <j.anaszewski@samsung.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_FLASH_LEDS_H_INCLUDED
+#define __LINUX_FLASH_LEDS_H_INCLUDED
+
+#include <linux/leds.h>
+#include <uapi/linux/v4l2-controls.h>
+
+struct device_node;
+struct led_classdev_flash;
+
+/*
+ * Supported led fault bits - must be kept in synch
+ * with V4L2_FLASH_FAULT bits.
+ */
+#define LED_FAULT_OVER_VOLTAGE          (1 << 0)
+#define LED_FAULT_TIMEOUT               (1 << 1)
+#define LED_FAULT_OVER_TEMPERATURE      (1 << 2)
+#define LED_FAULT_SHORT_CIRCUIT         (1 << 3)
+#define LED_FAULT_OVER_CURRENT          (1 << 4)
+#define LED_FAULT_INDICATOR             (1 << 5)
+#define LED_FAULT_UNDER_VOLTAGE         (1 << 6)
+#define LED_FAULT_INPUT_VOLTAGE         (1 << 7)
+#define LED_FAULT_LED_OVER_TEMPERATURE  (1 << 8)
+#define LED_NUM_FLASH_FAULTS            9
+
+#define LED_FLASH_MAX_SYSFS_GROUPS 7
+
+struct led_flash_ops {
+        /* set flash brightness */
+        int (*flash_brightness_set)(struct led_classdev_flash *fled_cdev,
+                                        u32 brightness);
+        /* get flash brightness */
+        int (*flash_brightness_get)(struct led_classdev_flash *fled_cdev,
+                                        u32 *brightness);
+        /* set flash strobe state */
+        int (*strobe_set)(struct led_classdev_flash *fled_cdev, bool state);
+        /* get flash strobe state */
+        int (*strobe_get)(struct led_classdev_flash *fled_cdev, bool *state);
+        /* set flash timeout */
+        int (*timeout_set)(struct led_classdev_flash *fled_cdev, u32 timeout);
+        /* get the flash LED fault */
+        int (*fault_get)(struct led_classdev_flash *fled_cdev, u32 *fault);
+};
+
+/*
+ * Current value of a flash setting along
+ * with its constraints.
+ */
+struct led_flash_setting {
+        /* maximum allowed value */
+        u32 min;
+        /* maximum allowed value */
+        u32 max;
+        /* step value */
+        u32 step;
+        /* current value */
+        u32 val;
+};
+
+struct led_classdev_flash {
+        /* led class device */
+        struct led_classdev led_cdev;
+
+        /* flash led specific ops */
+        const struct led_flash_ops *ops;
+
+        /* flash brightness value in microamperes along with its constraints */
+        struct led_flash_setting brightness;
+
+        /* flash timeout value in microseconds along with its constraints */
+        struct led_flash_setting timeout;
+
+        /* LED Flash class sysfs groups */
+        const struct attribute_group *sysfs_groups[LED_FLASH_MAX_SYSFS_GROUPS];
+
+        /* LEDs available for flash strobe synchronization */
+        struct led_classdev_flash **sync_leds;
+
+        /* Number of LEDs available for flash strobe synchronization */
+        int num_sync_leds;
+
+        /*
+         * The identifier of the sub-led to synchronize the flash strobe with.
+         * Identifiers start from 1, which reflects the first element from the
+         * sync_leds array. 0 means that the flash strobe should not be
+         * synchronized.
+         */
+        u32 sync_led_id;
+};
+
+static inline struct led_classdev_flash *lcdev_to_flcdev(
+                                                struct led_classdev *lcdev)
+{
+        return container_of(lcdev, struct led_classdev_flash, led_cdev);
+}
+
+/**
+ * led_classdev_flash_register - register a new object of led_classdev class
+ *                               with support for flash LEDs
+ * @parent: the flash LED to register
+ * @fled_cdev: the led_classdev_flash structure for this device
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_classdev_flash_register(struct device *parent,
+                                struct led_classdev_flash *fled_cdev);
+
+/**
+ * led_classdev_flash_unregister - unregisters an object of led_classdev class
+ *                                 with support for flash LEDs
+ * @fled_cdev: the flash LED to unregister
+ *
+ * Unregister a previously registered via led_classdev_flash_register object
+ */
+extern void led_classdev_flash_unregister(struct led_classdev_flash *fled_cdev);
+
+/**
+ * led_set_flash_strobe - setup flash strobe
+ * @fled_cdev: the flash LED to set strobe on
+ * @state: 1 - strobe flash, 0 - stop flash strobe
+ *
+ * Strobe the flash LED.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+static inline int led_set_flash_strobe(struct led_classdev_flash *fled_cdev,
+                                        bool state)
+{
+        return fled_cdev->ops->strobe_set(fled_cdev, state);
+}
+
+/**
+ * led_get_flash_strobe - get flash strobe status
+ * @fled_cdev: the flash LED to query
+ * @state: 1 - flash is strobing, 0 - flash is off
+ *
+ * Check whether the flash is strobing at the moment.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+static inline int led_get_flash_strobe(struct led_classdev_flash *fled_cdev,
+                                        bool *state)
+{
+        if (fled_cdev->ops->strobe_get)
+                return fled_cdev->ops->strobe_get(fled_cdev, state);
+
+        return -EINVAL;
+}
+
+/**
+ * led_set_flash_brightness - set flash LED brightness
+ * @fled_cdev: the flash LED to set
+ * @brightness: the brightness to set it to
+ *
+ * Set a flash LED's brightness.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_set_flash_brightness(struct led_classdev_flash *fled_cdev,
+                                        u32 brightness);
+
+/**
+ * led_update_flash_brightness - update flash LED brightness
+ * @fled_cdev: the flash LED to query
+ *
+ * Get a flash LED's current brightness and update led_flash->brightness
+ * member with the obtained value.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_update_flash_brightness(struct led_classdev_flash *fled_cdev);
+
+/**
+ * led_set_flash_timeout - set flash LED timeout
+ * @fled_cdev: the flash LED to set
+ * @timeout: the flash timeout to set it to
+ *
+ * Set the flash strobe duration.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_set_flash_timeout(struct led_classdev_flash *fled_cdev,
+                                        u32 timeout);
+
+/**
+ * led_get_flash_fault - get the flash LED fault
+ * @fled_cdev: the flash LED to query
+ * @fault: bitmask containing flash faults
+ *
+ * Get the flash LED fault.
+ *
+ * Returns: 0 on success or negative error value on failure
+ */
+extern int led_get_flash_fault(struct led_classdev_flash *fled_cdev,
+                                        u32 *fault);
+
+#endif  /* __LINUX_FLASH_LEDS_H_INCLUDED */
diff --git a/include/linux/leds.h b/include/linux/leds.h
index cfceef32c9b3..f70f84f35674 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -46,6 +46,8 @@ struct led_classdev {
 #define LED_SYSFS_DISABLE       (1 << 20)
 #define SET_BRIGHTNESS_ASYNC    (1 << 21)
 #define SET_BRIGHTNESS_SYNC     (1 << 22)
+#define LED_DEV_CAP_FLASH       (1 << 23)
+#define LED_DEV_CAP_SYNC_STROBE (1 << 24)
 
         /* Set LED brightness level */
         /* Must not sleep, use a workqueue if needed */
@@ -81,6 +83,7 @@ struct led_classdev {
         unsigned long            blink_delay_on, blink_delay_off;
         struct timer_list        blink_timer;
         int                      blink_brightness;
+        void                    (*flash_resume)(struct led_classdev *led_cdev);
 
         struct work_struct      set_brightness_work;
         int                     delayed_set_value;
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 2d182413b1db..fc03efa64ffe 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -231,6 +231,7 @@ enum {
         ATA_FLAG_SW_ACTIVITY    = (1 << 22), /* driver supports sw activity
                                               * led */
         ATA_FLAG_NO_DIPM        = (1 << 23), /* host not happy with DIPM */
+        ATA_FLAG_LOWTAG         = (1 << 24), /* host wants lowest available tag */
 
         /* bits 24:31 of ap->flags are reserved for LLD specific flags */
 
@@ -422,6 +423,7 @@ enum {
         ATA_HORKAGE_NO_NCQ_TRIM = (1 << 19),    /* don't use queued TRIM */
         ATA_HORKAGE_NOLPM       = (1 << 20),    /* don't use LPM */
         ATA_HORKAGE_WD_BROKEN_LPM = (1 << 21),  /* some WDs have broken LPM */
+        ATA_HORKAGE_ZERO_AFTER_TRIM = (1 << 22),/* guarantees zero after trim */
 
          /* DMA mask for user DMA control: User visible values; DO NOT
             renumber */
@@ -821,10 +823,10 @@ struct ata_port {
         unsigned int            cbl;    /* cable type; ATA_CBL_xxx */
 
         struct ata_queued_cmd   qcmd[ATA_MAX_QUEUE];
-        unsigned long           qc_allocated;
+        unsigned long           sas_tag_allocated; /* for sas tag allocation only */
         unsigned int            qc_active;
         int                     nr_active_links; /* #links with active qcs */
-        unsigned int            last_tag;       /* track next tag hw expects */
+        unsigned int            sas_last_tag;   /* track next tag hw expects */
 
         struct ata_link         link;           /* host default link */
         struct ata_link         *slave_link;    /* see ata_slave_link_init() */
@@ -1338,12 +1340,19 @@ extern const struct ata_port_operations ata_base_port_ops;
 extern const struct ata_port_operations sata_port_ops;
 extern struct device_attribute *ata_common_sdev_attrs[];
 
+/*
+ * All sht initializers (BASE, PIO, BMDMA, NCQ) must be instantiated
+ * by the edge drivers.  Because the 'module' field of sht must be the
+ * edge driver's module reference, otherwise the driver can be unloaded
+ * even if the scsi_device is being accessed.
+ */
 #define ATA_BASE_SHT(drv_name)                                  \
         .module                 = THIS_MODULE,                  \
         .name                   = drv_name,                     \
         .ioctl                  = ata_scsi_ioctl,               \
         .queuecommand           = ata_scsi_queuecmd,            \
         .can_queue              = ATA_DEF_QUEUE,                \
+        .tag_alloc_policy       = BLK_TAG_ALLOC_RR,             \
         .this_id                = ATA_SHT_THIS_ID,              \
         .cmd_per_lun            = ATA_SHT_CMD_PER_LUN,          \
         .emulated               = ATA_SHT_EMULATED,             \
diff --git a/include/linux/list_lru.h b/include/linux/list_lru.h
index f3434533fbf8..2a6b9947aaa3 100644
--- a/include/linux/list_lru.h
+++ b/include/linux/list_lru.h
@@ -9,6 +9,9 @@
 
 #include <linux/list.h>
 #include <linux/nodemask.h>
+#include <linux/shrinker.h>
+
+struct mem_cgroup;
 
 /* list_lru_walk_cb has to always return one of those */
 enum lru_status {
@@ -21,24 +24,45 @@ enum lru_status {
                                    internally, but has to return locked. */
 };
 
-struct list_lru_node {
-        spinlock_t              lock;
+struct list_lru_one {
         struct list_head        list;
-        /* kept as signed so we can catch imbalance bugs */
+        /* may become negative during memcg reparenting */
         long                    nr_items;
+};
+
+struct list_lru_memcg {
+        /* array of per cgroup lists, indexed by memcg_cache_id */
+        struct list_lru_one     *lru[0];
+};
+
+struct list_lru_node {
+        /* protects all lists on the node, including per cgroup */
+        spinlock_t              lock;
+        /* global list, used for the root cgroup in cgroup aware lrus */
+        struct list_lru_one     lru;
+#ifdef CONFIG_MEMCG_KMEM
+        /* for cgroup aware lrus points to per cgroup lists, otherwise NULL */
+        struct list_lru_memcg   *memcg_lrus;
+#endif
 } ____cacheline_aligned_in_smp;
 
 struct list_lru {
         struct list_lru_node    *node;
-        nodemask_t              active_nodes;
+#ifdef CONFIG_MEMCG_KMEM
+        struct list_head        list;
+#endif
 };
 
 void list_lru_destroy(struct list_lru *lru);
-int list_lru_init_key(struct list_lru *lru, struct lock_class_key *key);
-static inline int list_lru_init(struct list_lru *lru)
-{
-        return list_lru_init_key(lru, NULL);
-}
+int __list_lru_init(struct list_lru *lru, bool memcg_aware,
+                    struct lock_class_key *key);
+
+#define list_lru_init(lru)              __list_lru_init((lru), false, NULL)
+#define list_lru_init_key(lru, key)     __list_lru_init((lru), false, (key))
+#define list_lru_init_memcg(lru)        __list_lru_init((lru), true, NULL)
+
+int memcg_update_all_list_lrus(int num_memcgs);
+void memcg_drain_all_list_lrus(int src_idx, int dst_idx);
 
 /**
  * list_lru_add: add an element to the lru list's tail
@@ -72,32 +96,48 @@ bool list_lru_add(struct list_lru *lru, struct list_head *item);
 bool list_lru_del(struct list_lru *lru, struct list_head *item);
 
 /**
- * list_lru_count_node: return the number of objects currently held by @lru
+ * list_lru_count_one: return the number of objects currently held by @lru
  * @lru: the lru pointer.
  * @nid: the node id to count from.
+ * @memcg: the cgroup to count from.
  *
  * Always return a non-negative number, 0 for empty lists. There is no
  * guarantee that the list is not updated while the count is being computed.
  * Callers that want such a guarantee need to provide an outer lock.
  */
+unsigned long list_lru_count_one(struct list_lru *lru,
+                                 int nid, struct mem_cgroup *memcg);
 unsigned long list_lru_count_node(struct list_lru *lru, int nid);
+
+static inline unsigned long list_lru_shrink_count(struct list_lru *lru,
+                                                  struct shrink_control *sc)
+{
+        return list_lru_count_one(lru, sc->nid, sc->memcg);
+}
+
 static inline unsigned long list_lru_count(struct list_lru *lru)
 {
         long count = 0;
         int nid;
 
-        for_each_node_mask(nid, lru->active_nodes)
+        for_each_node_state(nid, N_NORMAL_MEMORY)
                 count += list_lru_count_node(lru, nid);
 
         return count;
 }
 
-typedef enum lru_status
-(*list_lru_walk_cb)(struct list_head *item, spinlock_t *lock, void *cb_arg);
+void list_lru_isolate(struct list_lru_one *list, struct list_head *item);
+void list_lru_isolate_move(struct list_lru_one *list, struct list_head *item,
+                           struct list_head *head);
+
+typedef enum lru_status (*list_lru_walk_cb)(struct list_head *item,
+                struct list_lru_one *list, spinlock_t *lock, void *cb_arg);
+
 /**
- * list_lru_walk_node: walk a list_lru, isolating and disposing freeable items.
+ * list_lru_walk_one: walk a list_lru, isolating and disposing freeable items.
  * @lru: the lru pointer.
  * @nid: the node id to scan from.
+ * @memcg: the cgroup to scan from.
  * @isolate: callback function that is resposible for deciding what to do with
  *  the item currently being scanned
  * @cb_arg: opaque type that will be passed to @isolate
@@ -115,18 +155,30 @@ typedef enum lru_status
  *
  * Return value: the number of objects effectively removed from the LRU.
  */
+unsigned long list_lru_walk_one(struct list_lru *lru,
+                                int nid, struct mem_cgroup *memcg,
+                                list_lru_walk_cb isolate, void *cb_arg,
+                                unsigned long *nr_to_walk);
 unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
                                  list_lru_walk_cb isolate, void *cb_arg,
                                  unsigned long *nr_to_walk);
 
 static inline unsigned long
+list_lru_shrink_walk(struct list_lru *lru, struct shrink_control *sc,
+                     list_lru_walk_cb isolate, void *cb_arg)
+{
+        return list_lru_walk_one(lru, sc->nid, sc->memcg, isolate, cb_arg,
+                                 &sc->nr_to_scan);
+}
+
+static inline unsigned long
 list_lru_walk(struct list_lru *lru, list_lru_walk_cb isolate,
               void *cb_arg, unsigned long nr_to_walk)
 {
         long isolated = 0;
         int nid;
 
-        for_each_node_mask(nid, lru->active_nodes) {
+        for_each_node_state(nid, N_NORMAL_MEMORY) {
                 isolated += list_lru_walk_node(lru, nid, isolate,
                                                cb_arg, &nr_to_walk);
                 if (nr_to_walk <= 0)
diff --git a/include/linux/list_nulls.h b/include/linux/list_nulls.h
index 5d10ae364b5e..f266661d2666 100644
--- a/include/linux/list_nulls.h
+++ b/include/linux/list_nulls.h
@@ -1,6 +1,9 @@
 #ifndef _LINUX_LIST_NULLS_H
 #define _LINUX_LIST_NULLS_H
 
+#include <linux/poison.h>
+#include <linux/const.h>
+
 /*
  * Special version of lists, where end of list is not a NULL pointer,
  * but a 'nulls' marker, which can have many different values.
@@ -21,8 +24,9 @@ struct hlist_nulls_head {
 struct hlist_nulls_node {
         struct hlist_nulls_node *next, **pprev;
 };
+#define NULLS_MARKER(value) (1UL | (((long)value) << 1))
 #define INIT_HLIST_NULLS_HEAD(ptr, nulls) \
-        ((ptr)->first = (struct hlist_nulls_node *) (1UL | (((long)nulls) << 1)))
+        ((ptr)->first = (struct hlist_nulls_node *) NULLS_MARKER(nulls))
 
 #define hlist_nulls_entry(ptr, type, member) container_of(ptr,type,member)
 /**
diff --git a/include/linux/livepatch.h b/include/linux/livepatch.h
new file mode 100644
index 000000000000..95023fd8b00d
--- /dev/null
+++ b/include/linux/livepatch.h
@@ -0,0 +1,133 @@
+/*
+ * livepatch.h - Kernel Live Patching Core
+ *
+ * Copyright (C) 2014 Seth Jennings <sjenning@redhat.com>
+ * Copyright (C) 2014 SUSE
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef _LINUX_LIVEPATCH_H_
+#define _LINUX_LIVEPATCH_H_
+
+#include <linux/module.h>
+#include <linux/ftrace.h>
+
+#if IS_ENABLED(CONFIG_LIVEPATCH)
+
+#include <asm/livepatch.h>
+
+enum klp_state {
+        KLP_DISABLED,
+        KLP_ENABLED
+};
+
+/**
+ * struct klp_func - function structure for live patching
+ * @old_name:   name of the function to be patched
+ * @new_func:   pointer to the patched function code
+ * @old_addr:   a hint conveying at what address the old function
+ *              can be found (optional, vmlinux patches only)
+ * @kobj:       kobject for sysfs resources
+ * @state:      tracks function-level patch application state
+ * @stack_node: list node for klp_ops func_stack list
+ */
+struct klp_func {
+        /* external */
+        const char *old_name;
+        void *new_func;
+        /*
+         * The old_addr field is optional and can be used to resolve
+         * duplicate symbol names in the vmlinux object.  If this
+         * information is not present, the symbol is located by name
+         * with kallsyms. If the name is not unique and old_addr is
+         * not provided, the patch application fails as there is no
+         * way to resolve the ambiguity.
+         */
+        unsigned long old_addr;
+
+        /* internal */
+        struct kobject kobj;
+        enum klp_state state;
+        struct list_head stack_node;
+};
+
+/**
+ * struct klp_reloc - relocation structure for live patching
+ * @loc:        address where the relocation will be written
+ * @val:        address of the referenced symbol (optional,
+ *              vmlinux patches only)
+ * @type:       ELF relocation type
+ * @name:       name of the referenced symbol (for lookup/verification)
+ * @addend:     offset from the referenced symbol
+ * @external:   symbol is either exported or within the live patch module itself
+ */
+struct klp_reloc {
+        unsigned long loc;
+        unsigned long val;
+        unsigned long type;
+        const char *name;
+        int addend;
+        int external;
+};
+
+/**
+ * struct klp_object - kernel object structure for live patching
+ * @name:       module name (or NULL for vmlinux)
+ * @relocs:     relocation entries to be applied at load time
+ * @funcs:      function entries for functions to be patched in the object
+ * @kobj:       kobject for sysfs resources
+ * @mod:        kernel module associated with the patched object
+ *              (NULL for vmlinux)
+ * @state:      tracks object-level patch application state
+ */
+struct klp_object {
+        /* external */
+        const char *name;
+        struct klp_reloc *relocs;
+        struct klp_func *funcs;
+
+        /* internal */
+        struct kobject *kobj;
+        struct module *mod;
+        enum klp_state state;
+};
+
+/**
+ * struct klp_patch - patch structure for live patching
+ * @mod:        reference to the live patch module
+ * @objs:       object entries for kernel objects to be patched
+ * @list:       list node for global list of registered patches
+ * @kobj:       kobject for sysfs resources
+ * @state:      tracks patch-level application state
+ */
+struct klp_patch {
+        /* external */
+        struct module *mod;
+        struct klp_object *objs;
+
+        /* internal */
+        struct list_head list;
+        struct kobject kobj;
+        enum klp_state state;
+};
+
+extern int klp_register_patch(struct klp_patch *);
+extern int klp_unregister_patch(struct klp_patch *);
+extern int klp_enable_patch(struct klp_patch *);
+extern int klp_disable_patch(struct klp_patch *);
+
+#endif /* CONFIG_LIVEPATCH */
+
+#endif /* _LINUX_LIVEPATCH_H_ */
diff --git a/include/linux/mei_cl_bus.h b/include/linux/mei_cl_bus.h
index 164aad1f9f12..0819d36a3a74 100644
--- a/include/linux/mei_cl_bus.h
+++ b/include/linux/mei_cl_bus.h
@@ -25,8 +25,8 @@ int __mei_cl_driver_register(struct mei_cl_driver *driver,
 
 void mei_cl_driver_unregister(struct mei_cl_driver *driver);
 
-int mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length);
-int mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length);
+ssize_t mei_cl_send(struct mei_cl_device *device, u8 *buf, size_t length);
+ssize_t  mei_cl_recv(struct mei_cl_device *device, u8 *buf, size_t length);
 
 typedef void (*mei_cl_event_cb_t)(struct mei_cl_device *device,
                                u32 events, void *context);
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 7c95af8d552c..72dff5fb0d0c 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -52,7 +52,27 @@ struct mem_cgroup_reclaim_cookie {
         unsigned int generation;
 };
 
+enum mem_cgroup_events_index {
+        MEM_CGROUP_EVENTS_PGPGIN,       /* # of pages paged in */
+        MEM_CGROUP_EVENTS_PGPGOUT,      /* # of pages paged out */
+        MEM_CGROUP_EVENTS_PGFAULT,      /* # of page-faults */
+        MEM_CGROUP_EVENTS_PGMAJFAULT,   /* # of major page-faults */
+        MEM_CGROUP_EVENTS_NSTATS,
+        /* default hierarchy events */
+        MEMCG_LOW = MEM_CGROUP_EVENTS_NSTATS,
+        MEMCG_HIGH,
+        MEMCG_MAX,
+        MEMCG_OOM,
+        MEMCG_NR_EVENTS,
+};
+
 #ifdef CONFIG_MEMCG
+void mem_cgroup_events(struct mem_cgroup *memcg,
+                       enum mem_cgroup_events_index idx,
+                       unsigned int nr);
+
+bool mem_cgroup_low(struct mem_cgroup *root, struct mem_cgroup *memcg);
+
 int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
                           gfp_t gfp_mask, struct mem_cgroup **memcgp);
 void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
@@ -102,6 +122,7 @@ void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
  * For memory reclaim.
  */
 int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec);
+bool mem_cgroup_lruvec_online(struct lruvec *lruvec);
 int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
 unsigned long mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list);
 void mem_cgroup_update_lru_size(struct lruvec *, enum lru_list, int);
@@ -138,12 +159,10 @@ static inline bool mem_cgroup_disabled(void)
         return false;
 }
 
-struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page, bool *locked,
-                                              unsigned long *flags);
-void mem_cgroup_end_page_stat(struct mem_cgroup *memcg, bool *locked,
-                              unsigned long *flags);
+struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page);
 void mem_cgroup_update_page_stat(struct mem_cgroup *memcg,
                                  enum mem_cgroup_stat_index idx, int val);
+void mem_cgroup_end_page_stat(struct mem_cgroup *memcg);
 
 static inline void mem_cgroup_inc_page_stat(struct mem_cgroup *memcg,
                                             enum mem_cgroup_stat_index idx)
@@ -176,6 +195,18 @@ void mem_cgroup_split_huge_fixup(struct page *head);
 #else /* CONFIG_MEMCG */
 struct mem_cgroup;
 
+static inline void mem_cgroup_events(struct mem_cgroup *memcg,
+                                     enum mem_cgroup_events_index idx,
+                                     unsigned int nr)
+{
+}
+
+static inline bool mem_cgroup_low(struct mem_cgroup *root,
+                                  struct mem_cgroup *memcg)
+{
+        return false;
+}
+
 static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
                                         gfp_t gfp_mask,
                                         struct mem_cgroup **memcgp)
@@ -268,6 +299,11 @@ mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
         return 1;
 }
 
+static inline bool mem_cgroup_lruvec_online(struct lruvec *lruvec)
+{
+        return true;
+}
+
 static inline unsigned long
 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
 {
@@ -285,14 +321,12 @@ mem_cgroup_print_oom_info(struct mem_cgroup *memcg, struct task_struct *p)
 {
 }
 
-static inline struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page,
-                                        bool *locked, unsigned long *flags)
+static inline struct mem_cgroup *mem_cgroup_begin_page_stat(struct page *page)
 {
         return NULL;
 }
 
-static inline void mem_cgroup_end_page_stat(struct mem_cgroup *memcg,
-                                        bool *locked, unsigned long *flags)
+static inline void mem_cgroup_end_page_stat(struct mem_cgroup *memcg)
 {
 }
 
@@ -364,7 +398,9 @@ static inline void sock_release_memcg(struct sock *sk)
 #ifdef CONFIG_MEMCG_KMEM
 extern struct static_key memcg_kmem_enabled_key;
 
-extern int memcg_limited_groups_array_size;
+extern int memcg_nr_cache_ids;
+extern void memcg_get_cache_ids(void);
+extern void memcg_put_cache_ids(void);
 
 /*
  * Helper macro to loop through all memcg-specific caches. Callers must still
@@ -372,13 +408,15 @@ extern int memcg_limited_groups_array_size;
  * the slab_mutex must be held when looping through those caches
  */
 #define for_each_memcg_cache_index(_idx)        \
-        for ((_idx) = 0; (_idx) < memcg_limited_groups_array_size; (_idx)++)
+        for ((_idx) = 0; (_idx) < memcg_nr_cache_ids; (_idx)++)
 
 static inline bool memcg_kmem_enabled(void)
 {
         return static_key_false(&memcg_kmem_enabled_key);
 }
 
+bool memcg_kmem_is_active(struct mem_cgroup *memcg);
+
 /*
  * In general, we'll do everything in our power to not incur in any overhead
  * for non-memcg users for the kmem functions. Not even a function call, if we
@@ -398,15 +436,14 @@ void __memcg_kmem_uncharge_pages(struct page *page, int order);
 
 int memcg_cache_id(struct mem_cgroup *memcg);
 
-void memcg_update_array_size(int num_groups);
-
 struct kmem_cache *__memcg_kmem_get_cache(struct kmem_cache *cachep);
 void __memcg_kmem_put_cache(struct kmem_cache *cachep);
 
-int __memcg_charge_slab(struct kmem_cache *cachep, gfp_t gfp, int order);
-void __memcg_uncharge_slab(struct kmem_cache *cachep, int order);
+struct mem_cgroup *__mem_cgroup_from_kmem(void *ptr);
 
-int __memcg_cleanup_cache_params(struct kmem_cache *s);
+int memcg_charge_kmem(struct mem_cgroup *memcg, gfp_t gfp,
+                      unsigned long nr_pages);
+void memcg_uncharge_kmem(struct mem_cgroup *memcg, unsigned long nr_pages);
 
 /**
  * memcg_kmem_newpage_charge: verify if a new kmem allocation is allowed.
@@ -500,6 +537,13 @@ static __always_inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
         if (memcg_kmem_enabled())
                 __memcg_kmem_put_cache(cachep);
 }
+
+static __always_inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
+{
+        if (!memcg_kmem_enabled())
+                return NULL;
+        return __mem_cgroup_from_kmem(ptr);
+}
 #else
 #define for_each_memcg_cache_index(_idx)        \
         for (; NULL; )
@@ -509,6 +553,11 @@ static inline bool memcg_kmem_enabled(void)
         return false;
 }
 
+static inline bool memcg_kmem_is_active(struct mem_cgroup *memcg)
+{
+        return false;
+}
+
 static inline bool
 memcg_kmem_newpage_charge(gfp_t gfp, struct mem_cgroup **memcg, int order)
 {
@@ -529,6 +578,14 @@ static inline int memcg_cache_id(struct mem_cgroup *memcg)
         return -1;
 }
 
+static inline void memcg_get_cache_ids(void)
+{
+}
+
+static inline void memcg_put_cache_ids(void)
+{
+}
+
 static inline struct kmem_cache *
 memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
 {
@@ -538,6 +595,11 @@ memcg_kmem_get_cache(struct kmem_cache *cachep, gfp_t gfp)
 static inline void memcg_kmem_put_cache(struct kmem_cache *cachep)
 {
 }
+
+static inline struct mem_cgroup *mem_cgroup_from_kmem(void *ptr)
+{
+        return NULL;
+}
 #endif /* CONFIG_MEMCG_KMEM */
 #endif /* _LINUX_MEMCONTROL_H */
 
diff --git a/include/linux/mfd/abx500/ab8500-bm.h b/include/linux/mfd/abx500/ab8500-bm.h
index cc892a8d8d6e..12a5b396921e 100644
--- a/include/linux/mfd/abx500/ab8500-bm.h
+++ b/include/linux/mfd/abx500/ab8500-bm.h
@@ -461,7 +461,6 @@ struct ab8500_fg;
 #ifdef CONFIG_AB8500_BM
 extern struct abx500_bm_data ab8500_bm_data;
 
-void ab8500_fg_reinit(void);
 void ab8500_charger_usb_state_changed(u8 bm_usb_state, u16 mA);
 struct ab8500_btemp *ab8500_btemp_get(void);
 int ab8500_btemp_get_batctrl_temp(struct ab8500_btemp *btemp);
diff --git a/include/linux/mfd/max77693-private.h b/include/linux/mfd/max77693-private.h
index 08dae01258b9..955dd990beaf 100644
--- a/include/linux/mfd/max77693-private.h
+++ b/include/linux/mfd/max77693-private.h
@@ -143,10 +143,118 @@ enum max77693_pmic_reg {
 #define FLASH_INT_FLED1_SHORT   BIT(3)
 #define FLASH_INT_OVER_CURRENT  BIT(4)
 
+/* Fast charge timer in in hours */
+#define DEFAULT_FAST_CHARGE_TIMER               4
+/* microamps */
+#define DEFAULT_TOP_OFF_THRESHOLD_CURRENT       150000
+/* minutes */
+#define DEFAULT_TOP_OFF_TIMER                   30
+/* microvolts */
+#define DEFAULT_CONSTANT_VOLT                   4200000
+/* microvolts */
+#define DEFAULT_MIN_SYSTEM_VOLT                 3600000
+/* celsius */
+#define DEFAULT_THERMAL_REGULATION_TEMP         100
+/* microamps */
+#define DEFAULT_BATTERY_OVERCURRENT             3500000
+/* microvolts */
+#define DEFAULT_CHARGER_INPUT_THRESHOLD_VOLT    4300000
+
+/* MAX77693_CHG_REG_CHG_INT_OK register */
+#define CHG_INT_OK_BYP_SHIFT            0
+#define CHG_INT_OK_BAT_SHIFT            3
+#define CHG_INT_OK_CHG_SHIFT            4
+#define CHG_INT_OK_CHGIN_SHIFT          6
+#define CHG_INT_OK_DETBAT_SHIFT         7
+#define CHG_INT_OK_BYP_MASK             BIT(CHG_INT_OK_BYP_SHIFT)
+#define CHG_INT_OK_BAT_MASK             BIT(CHG_INT_OK_BAT_SHIFT)
+#define CHG_INT_OK_CHG_MASK             BIT(CHG_INT_OK_CHG_SHIFT)
+#define CHG_INT_OK_CHGIN_MASK           BIT(CHG_INT_OK_CHGIN_SHIFT)
+#define CHG_INT_OK_DETBAT_MASK          BIT(CHG_INT_OK_DETBAT_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_DETAILS_00 register */
+#define CHG_DETAILS_00_CHGIN_SHIFT      5
+#define CHG_DETAILS_00_CHGIN_MASK       (0x3 << CHG_DETAILS_00_CHGIN_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_DETAILS_01 register */
+#define CHG_DETAILS_01_CHG_SHIFT        0
+#define CHG_DETAILS_01_BAT_SHIFT        4
+#define CHG_DETAILS_01_TREG_SHIFT       7
+#define CHG_DETAILS_01_CHG_MASK         (0xf << CHG_DETAILS_01_CHG_SHIFT)
+#define CHG_DETAILS_01_BAT_MASK         (0x7 << CHG_DETAILS_01_BAT_SHIFT)
+#define CHG_DETAILS_01_TREG_MASK        BIT(7)
+
+/* MAX77693_CHG_REG_CHG_DETAILS_01/CHG field */
+enum max77693_charger_charging_state {
+        MAX77693_CHARGING_PREQUALIFICATION      = 0x0,
+        MAX77693_CHARGING_FAST_CONST_CURRENT,
+        MAX77693_CHARGING_FAST_CONST_VOLTAGE,
+        MAX77693_CHARGING_TOP_OFF,
+        MAX77693_CHARGING_DONE,
+        MAX77693_CHARGING_HIGH_TEMP,
+        MAX77693_CHARGING_TIMER_EXPIRED,
+        MAX77693_CHARGING_THERMISTOR_SUSPEND,
+        MAX77693_CHARGING_OFF,
+        MAX77693_CHARGING_RESERVED,
+        MAX77693_CHARGING_OVER_TEMP,
+        MAX77693_CHARGING_WATCHDOG_EXPIRED,
+};
+
+/* MAX77693_CHG_REG_CHG_DETAILS_01/BAT field */
+enum max77693_charger_battery_state {
+        MAX77693_BATTERY_NOBAT                  = 0x0,
+        /* Dead-battery or low-battery prequalification */
+        MAX77693_BATTERY_PREQUALIFICATION,
+        MAX77693_BATTERY_TIMER_EXPIRED,
+        MAX77693_BATTERY_GOOD,
+        MAX77693_BATTERY_LOWVOLTAGE,
+        MAX77693_BATTERY_OVERVOLTAGE,
+        MAX77693_BATTERY_OVERCURRENT,
+        MAX77693_BATTERY_RESERVED,
+};
+
+/* MAX77693_CHG_REG_CHG_DETAILS_02 register */
+#define CHG_DETAILS_02_BYP_SHIFT        0
+#define CHG_DETAILS_02_BYP_MASK         (0xf << CHG_DETAILS_02_BYP_SHIFT)
+
 /* MAX77693 CHG_CNFG_00 register */
 #define CHG_CNFG_00_CHG_MASK            0x1
 #define CHG_CNFG_00_BUCK_MASK           0x4
 
+/* MAX77693_CHG_REG_CHG_CNFG_01 register */
+#define CHG_CNFG_01_FCHGTIME_SHIFT      0
+#define CHG_CNFG_01_CHGRSTRT_SHIFT      4
+#define CHG_CNFG_01_PQEN_SHIFT          7
+#define CHG_CNFG_01_FCHGTIME_MASK       (0x7 << CHG_CNFG_01_FCHGTIME_SHIFT)
+#define CHG_CNFG_01_CHGRSTRT_MASK       (0x3 << CHG_CNFG_01_CHGRSTRT_SHIFT)
+#define CHG_CNFG_01_PQEN_MAKS           BIT(CHG_CNFG_01_PQEN_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_CNFG_03 register */
+#define CHG_CNFG_03_TOITH_SHIFT         0
+#define CHG_CNFG_03_TOTIME_SHIFT        3
+#define CHG_CNFG_03_TOITH_MASK          (0x7 << CHG_CNFG_03_TOITH_SHIFT)
+#define CHG_CNFG_03_TOTIME_MASK         (0x7 << CHG_CNFG_03_TOTIME_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_CNFG_04 register */
+#define CHG_CNFG_04_CHGCVPRM_SHIFT      0
+#define CHG_CNFG_04_MINVSYS_SHIFT       5
+#define CHG_CNFG_04_CHGCVPRM_MASK       (0x1f << CHG_CNFG_04_CHGCVPRM_SHIFT)
+#define CHG_CNFG_04_MINVSYS_MASK        (0x7 << CHG_CNFG_04_MINVSYS_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_CNFG_06 register */
+#define CHG_CNFG_06_CHGPROT_SHIFT       2
+#define CHG_CNFG_06_CHGPROT_MASK        (0x3 << CHG_CNFG_06_CHGPROT_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_CNFG_07 register */
+#define CHG_CNFG_07_REGTEMP_SHIFT       5
+#define CHG_CNFG_07_REGTEMP_MASK        (0x3 << CHG_CNFG_07_REGTEMP_SHIFT)
+
+/* MAX77693_CHG_REG_CHG_CNFG_12 register */
+#define CHG_CNFG_12_B2SOVRC_SHIFT       0
+#define CHG_CNFG_12_VCHGINREG_SHIFT     3
+#define CHG_CNFG_12_B2SOVRC_MASK        (0x7 << CHG_CNFG_12_B2SOVRC_SHIFT)
+#define CHG_CNFG_12_VCHGINREG_MASK      (0x3 << CHG_CNFG_12_VCHGINREG_SHIFT)
+
 /* MAX77693 CHG_CNFG_09 Register */
 #define CHG_CNFG_09_CHGIN_ILIM_MASK     0x7F
 
diff --git a/include/linux/mfd/samsung/s2mps13.h b/include/linux/mfd/samsung/s2mps13.h
index ce5dda8958fe..b1fd675fa36f 100644
--- a/include/linux/mfd/samsung/s2mps13.h
+++ b/include/linux/mfd/samsung/s2mps13.h
@@ -59,6 +59,7 @@ enum s2mps13_reg {
         S2MPS13_REG_B6CTRL,
         S2MPS13_REG_B6OUT,
         S2MPS13_REG_B7CTRL,
+        S2MPS13_REG_B7SW,
         S2MPS13_REG_B7OUT,
         S2MPS13_REG_B8CTRL,
         S2MPS13_REG_B8OUT,
@@ -102,6 +103,7 @@ enum s2mps13_reg {
         S2MPS13_REG_L26CTRL,
         S2MPS13_REG_L27CTRL,
         S2MPS13_REG_L28CTRL,
+        S2MPS13_REG_L29CTRL,
         S2MPS13_REG_L30CTRL,
         S2MPS13_REG_L31CTRL,
         S2MPS13_REG_L32CTRL,
diff --git a/include/linux/mfd/stmpe.h b/include/linux/mfd/stmpe.h
index 575a86c7fcbd..c9d869027300 100644
--- a/include/linux/mfd/stmpe.h
+++ b/include/linux/mfd/stmpe.h
@@ -50,6 +50,8 @@ enum {
         STMPE_IDX_GPEDR_MSB,
         STMPE_IDX_GPRER_LSB,
         STMPE_IDX_GPFER_LSB,
+        STMPE_IDX_GPPUR_LSB,
+        STMPE_IDX_GPPDR_LSB,
         STMPE_IDX_GPAFR_U_MSB,
         STMPE_IDX_IEGPIOR_LSB,
         STMPE_IDX_ISGPIOR_LSB,
@@ -113,41 +115,9 @@ extern int stmpe_set_altfunc(struct stmpe *stmpe, u32 pins,
 extern int stmpe_enable(struct stmpe *stmpe, unsigned int blocks);
 extern int stmpe_disable(struct stmpe *stmpe, unsigned int blocks);
 
-struct matrix_keymap_data;
-
-/**
- * struct stmpe_keypad_platform_data - STMPE keypad platform data
- * @keymap_data: key map table and size
- * @debounce_ms: debounce interval, in ms.  Maximum is
- *               %STMPE_KEYPAD_MAX_DEBOUNCE.
- * @scan_count: number of key scanning cycles to confirm key data.
- *              Maximum is %STMPE_KEYPAD_MAX_SCAN_COUNT.
- * @no_autorepeat: disable key autorepeat
- */
-struct stmpe_keypad_platform_data {
-        const struct matrix_keymap_data *keymap_data;
-        unsigned int debounce_ms;
-        unsigned int scan_count;
-        bool no_autorepeat;
-};
-
 #define STMPE_GPIO_NOREQ_811_TOUCH      (0xf0)
 
 /**
- * struct stmpe_gpio_platform_data - STMPE GPIO platform data
- * @norequest_mask: bitmask specifying which GPIOs should _not_ be
- *                  requestable due to different usage (e.g. touch, keypad)
- *                  STMPE_GPIO_NOREQ_* macros can be used here.
- * @setup: board specific setup callback.
- * @remove: board specific remove callback
- */
-struct stmpe_gpio_platform_data {
-        unsigned norequest_mask;
-        void (*setup)(struct stmpe *stmpe, unsigned gpio_base);
-        void (*remove)(struct stmpe *stmpe, unsigned gpio_base);
-};
-
-/**
  * struct stmpe_ts_platform_data - stmpe811 touch screen controller platform
  * data
  * @sample_time: ADC converstion time in number of clock.
@@ -198,8 +168,6 @@ struct stmpe_ts_platform_data {
  * @irq_over_gpio: true if gpio is used to get irq
  * @irq_gpio: gpio number over which irq will be requested (significant only if
  *            irq_over_gpio is true)
- * @gpio: GPIO-specific platform data
- * @keypad: keypad-specific platform data
  * @ts: touchscreen-specific platform data
  */
 struct stmpe_platform_data {
@@ -211,8 +179,6 @@ struct stmpe_platform_data {
         int irq_gpio;
         int autosleep_timeout;
 
-        struct stmpe_gpio_platform_data *gpio;
-        struct stmpe_keypad_platform_data *keypad;
         struct stmpe_ts_platform_data *ts;
 };
 
diff --git a/include/linux/mfd/syscon/atmel-matrix.h b/include/linux/mfd/syscon/atmel-matrix.h
new file mode 100644
index 000000000000..8293c3e2a82a
--- /dev/null
+++ b/include/linux/mfd/syscon/atmel-matrix.h
@@ -0,0 +1,117 @@
+/*
+ *  Copyright (C) 2014 Atmel Corporation.
+ *
+ * Memory Controllers (MATRIX, EBI) - System peripherals registers.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _LINUX_MFD_SYSCON_ATMEL_MATRIX_H
+#define _LINUX_MFD_SYSCON_ATMEL_MATRIX_H
+
+#define AT91SAM9260_MATRIX_MCFG                 0x00
+#define AT91SAM9260_MATRIX_SCFG                 0x40
+#define AT91SAM9260_MATRIX_PRS                  0x80
+#define AT91SAM9260_MATRIX_MRCR                 0x100
+#define AT91SAM9260_MATRIX_EBICSA               0x11c
+
+#define AT91SAM9261_MATRIX_MRCR                 0x0
+#define AT91SAM9261_MATRIX_SCFG                 0x4
+#define AT91SAM9261_MATRIX_TCR                  0x24
+#define AT91SAM9261_MATRIX_EBICSA               0x30
+#define AT91SAM9261_MATRIX_USBPUCR              0x34
+
+#define AT91SAM9263_MATRIX_MCFG                 0x00
+#define AT91SAM9263_MATRIX_SCFG                 0x40
+#define AT91SAM9263_MATRIX_PRS                  0x80
+#define AT91SAM9263_MATRIX_MRCR                 0x100
+#define AT91SAM9263_MATRIX_TCR                  0x114
+#define AT91SAM9263_MATRIX_EBI0CSA              0x120
+#define AT91SAM9263_MATRIX_EBI1CSA              0x124
+
+#define AT91SAM9RL_MATRIX_MCFG                  0x00
+#define AT91SAM9RL_MATRIX_SCFG                  0x40
+#define AT91SAM9RL_MATRIX_PRS                   0x80
+#define AT91SAM9RL_MATRIX_MRCR                  0x100
+#define AT91SAM9RL_MATRIX_TCR                   0x114
+#define AT91SAM9RL_MATRIX_EBICSA                0x120
+
+#define AT91SAM9G45_MATRIX_MCFG                 0x00
+#define AT91SAM9G45_MATRIX_SCFG                 0x40
+#define AT91SAM9G45_MATRIX_PRS                  0x80
+#define AT91SAM9G45_MATRIX_MRCR                 0x100
+#define AT91SAM9G45_MATRIX_TCR                  0x110
+#define AT91SAM9G45_MATRIX_DDRMPR               0x118
+#define AT91SAM9G45_MATRIX_EBICSA               0x128
+
+#define AT91SAM9N12_MATRIX_MCFG                 0x00
+#define AT91SAM9N12_MATRIX_SCFG                 0x40
+#define AT91SAM9N12_MATRIX_PRS                  0x80
+#define AT91SAM9N12_MATRIX_MRCR                 0x100
+#define AT91SAM9N12_MATRIX_EBICSA               0x118
+
+#define AT91SAM9X5_MATRIX_MCFG                  0x00
+#define AT91SAM9X5_MATRIX_SCFG                  0x40
+#define AT91SAM9X5_MATRIX_PRS                   0x80
+#define AT91SAM9X5_MATRIX_MRCR                  0x100
+#define AT91SAM9X5_MATRIX_EBICSA                0x120
+
+#define SAMA5D3_MATRIX_MCFG                     0x00
+#define SAMA5D3_MATRIX_SCFG                     0x40
+#define SAMA5D3_MATRIX_PRS                      0x80
+#define SAMA5D3_MATRIX_MRCR                     0x100
+
+#define AT91_MATRIX_MCFG(o, x)                  ((o) + ((x) * 0x4))
+#define AT91_MATRIX_ULBT                        GENMASK(2, 0)
+#define AT91_MATRIX_ULBT_INFINITE               (0 << 0)
+#define AT91_MATRIX_ULBT_SINGLE                 (1 << 0)
+#define AT91_MATRIX_ULBT_FOUR                   (2 << 0)
+#define AT91_MATRIX_ULBT_EIGHT                  (3 << 0)
+#define AT91_MATRIX_ULBT_SIXTEEN                (4 << 0)
+
+#define AT91_MATRIX_SCFG(o, x)                  ((o) + ((x) * 0x4))
+#define AT91_MATRIX_SLOT_CYCLE                  GENMASK(7,  0)
+#define AT91_MATRIX_DEFMSTR_TYPE                GENMASK(17, 16)
+#define AT91_MATRIX_DEFMSTR_TYPE_NONE           (0 << 16)
+#define AT91_MATRIX_DEFMSTR_TYPE_LAST           (1 << 16)
+#define AT91_MATRIX_DEFMSTR_TYPE_FIXED          (2 << 16)
+#define AT91_MATRIX_FIXED_DEFMSTR               GENMASK(20, 18)
+#define AT91_MATRIX_ARBT                        GENMASK(25, 24)
+#define AT91_MATRIX_ARBT_ROUND_ROBIN            (0 << 24)
+#define AT91_MATRIX_ARBT_FIXED_PRIORITY         (1 << 24)
+
+#define AT91_MATRIX_ITCM_SIZE                   GENMASK(3, 0)
+#define AT91_MATRIX_ITCM_0                      (0 << 0)
+#define AT91_MATRIX_ITCM_16                     (5 << 0)
+#define AT91_MATRIX_ITCM_32                     (6 << 0)
+#define AT91_MATRIX_ITCM_64                     (7 << 0)
+#define AT91_MATRIX_DTCM_SIZE                   GENMASK(7, 4)
+#define AT91_MATRIX_DTCM_0                      (0 << 4)
+#define AT91_MATRIX_DTCM_16                     (5 << 4)
+#define AT91_MATRIX_DTCM_32                     (6 << 4)
+#define AT91_MATRIX_DTCM_64                     (7 << 4)
+
+#define AT91_MATRIX_PRAS(o, x)                  ((o) + ((x) * 0x8))
+#define AT91_MATRIX_PRBS(o, x)                  ((o) + ((x) * 0x8) + 0x4)
+#define AT91_MATRIX_MPR(x)                      GENMASK(((x) * 0x4) + 1, ((x) * 0x4))
+
+#define AT91_MATRIX_RCB(x)                      BIT(x)
+
+#define AT91_MATRIX_CSA(cs, val)                (val << (cs))
+#define AT91_MATRIX_DBPUC                       BIT(8)
+#define AT91_MATRIX_DBPDC                       BIT(9)
+#define AT91_MATRIX_VDDIOMSEL                   BIT(16)
+#define AT91_MATRIX_VDDIOMSEL_1_8V              (0 << 16)
+#define AT91_MATRIX_VDDIOMSEL_3_3V              (1 << 16)
+#define AT91_MATRIX_EBI_IOSR                    BIT(17)
+#define AT91_MATRIX_DDR_IOSR                    BIT(18)
+#define AT91_MATRIX_NFD0_SELECT                 BIT(24)
+#define AT91_MATRIX_DDR_MP_EN                   BIT(25)
+#define AT91_MATRIX_EBI_NUM_CS                  8
+
+#define AT91_MATRIX_USBPUCR_PUON                BIT(30)
+
+#endif /* _LINUX_MFD_SYSCON_ATMEL_MATRIX_H */
diff --git a/include/linux/mfd/syscon/atmel-smc.h b/include/linux/mfd/syscon/atmel-smc.h
new file mode 100644
index 000000000000..be6ebe64eebe
--- /dev/null
+++ b/include/linux/mfd/syscon/atmel-smc.h
@@ -0,0 +1,173 @@
+/*
+ * Atmel SMC (Static Memory Controller) register offsets and bit definitions.
+ *
+ * Copyright (C) 2014 Atmel
+ * Copyright (C) 2014 Free Electrons
+ *
+ * Author: Boris Brezillon <boris.brezillon@free-electrons.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_SYSCON_ATMEL_SMC_H_
+#define _LINUX_MFD_SYSCON_ATMEL_SMC_H_
+
+#include <linux/kernel.h>
+#include <linux/regmap.h>
+
+#define AT91SAM9_SMC_GENERIC            0x00
+#define AT91SAM9_SMC_GENERIC_BLK_SZ     0x10
+
+#define SAMA5_SMC_GENERIC               0x600
+#define SAMA5_SMC_GENERIC_BLK_SZ        0x14
+
+#define AT91SAM9_SMC_SETUP(o)           ((o) + 0x00)
+#define AT91SAM9_SMC_NWESETUP(x)        (x)
+#define AT91SAM9_SMC_NCS_WRSETUP(x)     ((x) << 8)
+#define AT91SAM9_SMC_NRDSETUP(x)        ((x) << 16)
+#define AT91SAM9_SMC_NCS_NRDSETUP(x)    ((x) << 24)
+
+#define AT91SAM9_SMC_PULSE(o)           ((o) + 0x04)
+#define AT91SAM9_SMC_NWEPULSE(x)        (x)
+#define AT91SAM9_SMC_NCS_WRPULSE(x)     ((x) << 8)
+#define AT91SAM9_SMC_NRDPULSE(x)        ((x) << 16)
+#define AT91SAM9_SMC_NCS_NRDPULSE(x)    ((x) << 24)
+
+#define AT91SAM9_SMC_CYCLE(o)           ((o) + 0x08)
+#define AT91SAM9_SMC_NWECYCLE(x)        (x)
+#define AT91SAM9_SMC_NRDCYCLE(x)        ((x) << 16)
+
+#define AT91SAM9_SMC_MODE(o)            ((o) + 0x0c)
+#define SAMA5_SMC_MODE(o)               ((o) + 0x10)
+#define AT91_SMC_READMODE               BIT(0)
+#define AT91_SMC_READMODE_NCS           (0 << 0)
+#define AT91_SMC_READMODE_NRD           (1 << 0)
+#define AT91_SMC_WRITEMODE              BIT(1)
+#define AT91_SMC_WRITEMODE_NCS          (0 << 1)
+#define AT91_SMC_WRITEMODE_NWE          (1 << 1)
+#define AT91_SMC_EXNWMODE               GENMASK(5, 4)
+#define AT91_SMC_EXNWMODE_DISABLE       (0 << 4)
+#define AT91_SMC_EXNWMODE_FROZEN        (2 << 4)
+#define AT91_SMC_EXNWMODE_READY         (3 << 4)
+#define AT91_SMC_BAT                    BIT(8)
+#define AT91_SMC_BAT_SELECT             (0 << 8)
+#define AT91_SMC_BAT_WRITE              (1 << 8)
+#define AT91_SMC_DBW                    GENMASK(13, 12)
+#define AT91_SMC_DBW_8                  (0 << 12)
+#define AT91_SMC_DBW_16                 (1 << 12)
+#define AT91_SMC_DBW_32                 (2 << 12)
+#define AT91_SMC_TDF                    GENMASK(19, 16)
+#define AT91_SMC_TDF_(x)                ((((x) - 1) << 16) & AT91_SMC_TDF)
+#define AT91_SMC_TDF_MAX                16
+#define AT91_SMC_TDFMODE_OPTIMIZED      BIT(20)
+#define AT91_SMC_PMEN                   BIT(24)
+#define AT91_SMC_PS                     GENMASK(29, 28)
+#define AT91_SMC_PS_4                   (0 << 28)
+#define AT91_SMC_PS_8                   (1 << 28)
+#define AT91_SMC_PS_16                  (2 << 28)
+#define AT91_SMC_PS_32                  (3 << 28)
+
+
+/*
+ * This function converts a setup timing expressed in nanoseconds into an
+ * encoded value that can be written in the SMC_SETUP register.
+ *
+ * The following formula is described in atmel datasheets (section
+ * "SMC Setup Register"):
+ *
+ * setup length = (128* SETUP[5] + SETUP[4:0])
+ *
+ * where setup length is the timing expressed in cycles.
+ */
+static inline u32 at91sam9_smc_setup_ns_to_cycles(unsigned int clk_rate,
+                                                  u32 timing_ns)
+{
+        u32 clk_period = DIV_ROUND_UP(NSEC_PER_SEC, clk_rate);
+        u32 coded_cycles = 0;
+        u32 cycles;
+
+        cycles = DIV_ROUND_UP(timing_ns, clk_period);
+        if (cycles / 32) {
+                coded_cycles |= 1 << 5;
+                if (cycles < 128)
+                        cycles = 0;
+        }
+
+        coded_cycles |= cycles % 32;
+
+        return coded_cycles;
+}
+
+/*
+ * This function converts a pulse timing expressed in nanoseconds into an
+ * encoded value that can be written in the SMC_PULSE register.
+ *
+ * The following formula is described in atmel datasheets (section
+ * "SMC Pulse Register"):
+ *
+ * pulse length = (256* PULSE[6] + PULSE[5:0])
+ *
+ * where pulse length is the timing expressed in cycles.
+ */
+static inline u32 at91sam9_smc_pulse_ns_to_cycles(unsigned int clk_rate,
+                                                  u32 timing_ns)
+{
+        u32 clk_period = DIV_ROUND_UP(NSEC_PER_SEC, clk_rate);
+        u32 coded_cycles = 0;
+        u32 cycles;
+
+        cycles = DIV_ROUND_UP(timing_ns, clk_period);
+        if (cycles / 64) {
+                coded_cycles |= 1 << 6;
+                if (cycles < 256)
+                        cycles = 0;
+        }
+
+        coded_cycles |= cycles % 64;
+
+        return coded_cycles;
+}
+
+/*
+ * This function converts a cycle timing expressed in nanoseconds into an
+ * encoded value that can be written in the SMC_CYCLE register.
+ *
+ * The following formula is described in atmel datasheets (section
+ * "SMC Cycle Register"):
+ *
+ * cycle length = (CYCLE[8:7]*256 + CYCLE[6:0])
+ *
+ * where cycle length is the timing expressed in cycles.
+ */
+static inline u32 at91sam9_smc_cycle_ns_to_cycles(unsigned int clk_rate,
+                                                  u32 timing_ns)
+{
+        u32 clk_period = DIV_ROUND_UP(NSEC_PER_SEC, clk_rate);
+        u32 coded_cycles = 0;
+        u32 cycles;
+
+        cycles = DIV_ROUND_UP(timing_ns, clk_period);
+        if (cycles / 128) {
+                coded_cycles = cycles / 256;
+                cycles %= 256;
+                if (cycles >= 128) {
+                        coded_cycles++;
+                        cycles = 0;
+                }
+
+                if (coded_cycles > 0x3) {
+                        coded_cycles = 0x3;
+                        cycles = 0x7f;
+                }
+
+                coded_cycles <<= 7;
+        }
+
+        coded_cycles |= cycles % 128;
+
+        return coded_cycles;
+}
+
+#endif /* _LINUX_MFD_SYSCON_ATMEL_SMC_H_ */
diff --git a/include/linux/mfd/syscon/exynos4-pmu.h b/include/linux/mfd/syscon/exynos4-pmu.h
new file mode 100644
index 000000000000..278b1b1549e9
--- /dev/null
+++ b/include/linux/mfd/syscon/exynos4-pmu.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2015 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 version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_
+#define _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_
+
+/* Exynos4 PMU register definitions */
+
+/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
+#define EXYNOS4_MIPI_PHY_CONTROL(n)     (0x710 + (n) * 4)
+#define EXYNOS4_MIPI_PHY_ENABLE         (1 << 0)
+#define EXYNOS4_MIPI_PHY_SRESETN        (1 << 1)
+#define EXYNOS4_MIPI_PHY_MRESETN        (1 << 2)
+#define EXYNOS4_MIPI_PHY_RESET_MASK     (3 << 1)
+
+#endif /* _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_ */
diff --git a/include/linux/mfd/tc3589x.h b/include/linux/mfd/tc3589x.h
index e1c12d84c26a..c203c9c56776 100644
--- a/include/linux/mfd/tc3589x.h
+++ b/include/linux/mfd/tc3589x.h
@@ -163,24 +163,12 @@ struct tc3589x_keypad_platform_data {
 };
 
 /**
- * struct tc3589x_gpio_platform_data - TC3589x GPIO platform data
- * @setup: callback for board-specific initialization
- * @remove: callback for board-specific teardown
- */
-struct tc3589x_gpio_platform_data {
-        void (*setup)(struct tc3589x *tc3589x, unsigned gpio_base);
-        void (*remove)(struct tc3589x *tc3589x, unsigned gpio_base);
-};
-
-/**
  * struct tc3589x_platform_data - TC3589x platform data
  * @block: bitmask of blocks to enable (use TC3589x_BLOCK_*)
- * @gpio: GPIO-specific platform data
  * @keypad: keypad-specific platform data
  */
 struct tc3589x_platform_data {
         unsigned int block;
-        struct tc3589x_gpio_platform_data *gpio;
         const struct tc3589x_keypad_platform_data *keypad;
 };
 
diff --git a/include/linux/mfd/ti_am335x_tscadc.h b/include/linux/mfd/ti_am335x_tscadc.h
index e2e70053470e..3f4e994ace2b 100644
--- a/include/linux/mfd/ti_am335x_tscadc.h
+++ b/include/linux/mfd/ti_am335x_tscadc.h
@@ -52,6 +52,7 @@
 
 /* IRQ enable */
 #define IRQENB_HW_PEN           BIT(0)
+#define IRQENB_EOS              BIT(1)
 #define IRQENB_FIFO0THRES       BIT(2)
 #define IRQENB_FIFO0OVRRUN      BIT(3)
 #define IRQENB_FIFO0UNDRFLW     BIT(4)
@@ -107,7 +108,7 @@
 /* Charge delay */
 #define CHARGEDLY_OPEN_MASK     (0x3FFFF << 0)
 #define CHARGEDLY_OPEN(val)     ((val) << 0)
-#define CHARGEDLY_OPENDLY       CHARGEDLY_OPEN(1)
+#define CHARGEDLY_OPENDLY       CHARGEDLY_OPEN(0x400)
 
 /* Control register */
 #define CNTRLREG_TSCSSENB       BIT(0)
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 57388171610d..605812820e48 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -96,11 +96,6 @@
 #define TMIO_MMC_SDIO_STATUS_QUIRK      (1 << 8)
 
 /*
- * Some controllers have DMA enable/disable register
- */
-#define TMIO_MMC_HAVE_CTL_DMA_REG       (1 << 9)
-
-/*
  * Some controllers allows to set SDx actual clock
  */
 #define TMIO_MMC_CLK_ACTUAL             (1 << 10)
@@ -112,18 +107,6 @@ void tmio_core_mmc_clk_div(void __iomem *cnf, int shift, int state);
 
 struct dma_chan;
 
-struct tmio_mmc_dma {
-        void *chan_priv_tx;
-        void *chan_priv_rx;
-        int slave_id_tx;
-        int slave_id_rx;
-        int alignment_shift;
-        dma_addr_t dma_rx_offset;
-        bool (*filter)(struct dma_chan *chan, void *arg);
-};
-
-struct tmio_mmc_host;
-
 /*
  * data for the MMC controller
  */
@@ -132,19 +115,12 @@ struct tmio_mmc_data {
         unsigned long                   capabilities;
         unsigned long                   capabilities2;
         unsigned long                   flags;
-        unsigned long                   bus_shift;
         u32                             ocr_mask;       /* available voltages */
-        struct tmio_mmc_dma             *dma;
-        struct device                   *dev;
         unsigned int                    cd_gpio;
+        int                             alignment_shift;
+        dma_addr_t                      dma_rx_offset;
         void (*set_pwr)(struct platform_device *host, int state);
         void (*set_clk_div)(struct platform_device *host, int state);
-        int (*write16_hook)(struct tmio_mmc_host *host, int addr);
-        /* clock management callbacks */
-        int (*clk_enable)(struct platform_device *pdev, unsigned int *f);
-        void (*clk_disable)(struct platform_device *pdev);
-        int (*multi_io_quirk)(struct mmc_card *card,
-                              unsigned int direction, int blk_size);
 };
 
 /*
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index fab9b32ace8e..78baed5f2952 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -67,7 +67,6 @@ static inline int migrate_huge_page_move_mapping(struct address_space *mapping,
 
 #ifdef CONFIG_NUMA_BALANCING
 extern bool pmd_trans_migrating(pmd_t pmd);
-extern void wait_migrate_huge_page(struct anon_vma *anon_vma, pmd_t *pmd);
 extern int migrate_misplaced_page(struct page *page,
                                   struct vm_area_struct *vma, int node);
 extern bool migrate_ratelimited(int node);
@@ -76,9 +75,6 @@ static inline bool pmd_trans_migrating(pmd_t pmd)
 {
         return false;
 }
-static inline void wait_migrate_huge_page(struct anon_vma *anon_vma, pmd_t *pmd)
-{
-}
 static inline int migrate_misplaced_page(struct page *page,
                                          struct vm_area_struct *vma, int node)
 {
diff --git a/include/linux/mlx4/cmd.h b/include/linux/mlx4/cmd.h
index 64d25941b329..7b6d4e9ff603 100644
--- a/include/linux/mlx4/cmd.h
+++ b/include/linux/mlx4/cmd.h
@@ -71,6 +71,7 @@ enum {
 
         /*master notify fw on finish for slave's flr*/
         MLX4_CMD_INFORM_FLR_DONE = 0x5b,
+        MLX4_CMD_VIRT_PORT_MAP   = 0x5c,
         MLX4_CMD_GET_OP_REQ      = 0x59,
 
         /* TPT commands */
@@ -165,9 +166,15 @@ enum {
 };
 
 enum {
-        MLX4_CMD_TIME_CLASS_A   = 10000,
-        MLX4_CMD_TIME_CLASS_B   = 10000,
-        MLX4_CMD_TIME_CLASS_C   = 10000,
+        MLX4_CMD_TIME_CLASS_A   = 60000,
+        MLX4_CMD_TIME_CLASS_B   = 60000,
+        MLX4_CMD_TIME_CLASS_C   = 60000,
+};
+
+enum {
+        /* virtual to physical port mapping opcode modifiers */
+        MLX4_GET_PORT_VIRT2PHY = 0x0,
+        MLX4_SET_PORT_VIRT2PHY = 0x1,
 };
 
 enum {
@@ -279,6 +286,8 @@ int mlx4_get_vf_config(struct mlx4_dev *dev, int port, int vf, struct ifla_vf_in
 int mlx4_set_vf_link_state(struct mlx4_dev *dev, int port, int vf, int link_state);
 int mlx4_config_dev_retrieval(struct mlx4_dev *dev,
                               struct mlx4_config_dev_params *params);
+void mlx4_cmd_wake_completions(struct mlx4_dev *dev);
+void mlx4_report_internal_err_comm_event(struct mlx4_dev *dev);
 /*
  * mlx4_get_slave_default_vlan -
  * return true if VST ( default vlan)
@@ -288,5 +297,6 @@ bool mlx4_get_slave_default_vlan(struct mlx4_dev *dev, int port, int slave,
                                  u16 *vlan, u8 *qos);
 
 #define MLX4_COMM_GET_IF_REV(cmd_chan_ver) (u8)((cmd_chan_ver) >> 8)
+#define COMM_CHAN_EVENT_INTERNAL_ERR (1 << 17)
 
 #endif /* MLX4_CMD_H */
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 25c791e295fd..e4ebff7e9d02 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -42,7 +42,7 @@
 
 #include <linux/atomic.h>
 
-#include <linux/clocksource.h>
+#include <linux/timecounter.h>
 
 #define MAX_MSIX_P_PORT         17
 #define MAX_MSIX                64
@@ -70,6 +70,7 @@ enum {
         MLX4_FLAG_SLAVE         = 1 << 3,
         MLX4_FLAG_SRIOV         = 1 << 4,
         MLX4_FLAG_OLD_REG_MAC   = 1 << 6,
+        MLX4_FLAG_BONDED        = 1 << 7
 };
 
 enum {
@@ -97,7 +98,7 @@ enum {
         MLX4_MAX_NUM_PF         = 16,
         MLX4_MAX_NUM_VF         = 126,
         MLX4_MAX_NUM_VF_P_PORT  = 64,
-        MLX4_MFUNC_MAX          = 80,
+        MLX4_MFUNC_MAX          = 128,
         MLX4_MAX_EQ_NUM         = 1024,
         MLX4_MFUNC_EQ_NUM       = 4,
         MLX4_MFUNC_MAX_EQES     = 8,
@@ -200,7 +201,9 @@ enum {
         MLX4_DEV_CAP_FLAG2_CONFIG_DEV           = 1LL <<  16,
         MLX4_DEV_CAP_FLAG2_SYS_EQS              = 1LL <<  17,
         MLX4_DEV_CAP_FLAG2_80_VFS               = 1LL <<  18,
-        MLX4_DEV_CAP_FLAG2_FS_A0                = 1LL <<  19
+        MLX4_DEV_CAP_FLAG2_FS_A0                = 1LL <<  19,
+        MLX4_DEV_CAP_FLAG2_RECOVERABLE_ERROR_EVENT = 1LL << 20,
+        MLX4_DEV_CAP_FLAG2_PORT_REMAP           = 1LL <<  21
 };
 
 enum {
@@ -208,6 +211,10 @@ enum {
         MLX4_QUERY_FUNC_FLAGS_A0_RES_QP         = 1LL << 1
 };
 
+enum {
+        MLX4_VF_CAP_FLAG_RESET                  = 1 << 0
+};
+
 /* bit enums for an 8-bit flags field indicating special use
  * QPs which require special handling in qp_reserve_range.
  * Currently, this only includes QPs used by the ETH interface,
@@ -248,9 +255,14 @@ enum {
         MLX4_BMME_FLAG_TYPE_2_WIN       = 1 <<  9,
         MLX4_BMME_FLAG_RESERVED_LKEY    = 1 << 10,
         MLX4_BMME_FLAG_FAST_REG_WR      = 1 << 11,
+        MLX4_BMME_FLAG_PORT_REMAP       = 1 << 24,
         MLX4_BMME_FLAG_VSD_INIT2RTR     = 1 << 28,
 };
 
+enum {
+        MLX4_FLAG_PORT_REMAP            = MLX4_BMME_FLAG_PORT_REMAP
+};
+
 enum mlx4_event {
         MLX4_EVENT_TYPE_COMP               = 0x00,
         MLX4_EVENT_TYPE_PATH_MIG           = 0x01,
@@ -276,6 +288,7 @@ enum mlx4_event {
         MLX4_EVENT_TYPE_FATAL_WARNING      = 0x1b,
         MLX4_EVENT_TYPE_FLR_EVENT          = 0x1c,
         MLX4_EVENT_TYPE_PORT_MNG_CHG_EVENT = 0x1d,
+        MLX4_EVENT_TYPE_RECOVERABLE_ERROR_EVENT  = 0x3e,
         MLX4_EVENT_TYPE_NONE               = 0xff,
 };
 
@@ -285,6 +298,11 @@ enum {
 };
 
 enum {
+        MLX4_RECOVERABLE_ERROR_EVENT_SUBTYPE_BAD_CABLE          = 1,
+        MLX4_RECOVERABLE_ERROR_EVENT_SUBTYPE_UNSUPPORTED_CABLE  = 2,
+};
+
+enum {
         MLX4_FATAL_WARNING_SUBTYPE_WARMING = 0,
 };
 
@@ -411,6 +429,16 @@ enum {
         MLX4_EQ_PORT_INFO_MSTR_SM_SL_CHANGE_MASK        = 1 << 4,
 };
 
+enum {
+        MLX4_DEVICE_STATE_UP                    = 1 << 0,
+        MLX4_DEVICE_STATE_INTERNAL_ERROR        = 1 << 1,
+};
+
+enum {
+        MLX4_INTERFACE_STATE_UP         = 1 << 0,
+        MLX4_INTERFACE_STATE_DELETION   = 1 << 1,
+};
+
 #define MSTR_SM_CHANGE_MASK (MLX4_EQ_PORT_INFO_MSTR_SM_SL_CHANGE_MASK | \
                              MLX4_EQ_PORT_INFO_MSTR_SM_LID_CHANGE_MASK)
 
@@ -535,6 +563,7 @@ struct mlx4_caps {
         u8                      alloc_res_qp_mask;
         u32                     dmfs_high_rate_qpn_base;
         u32                     dmfs_high_rate_qpn_range;
+        u32                     vf_caps;
 };
 
 struct mlx4_buf_list {
@@ -660,6 +689,8 @@ struct mlx4_cq {
                 void (*comp)(struct mlx4_cq *);
                 void            *priv;
         } tasklet_ctx;
+        int             reset_notify_added;
+        struct list_head        reset_notify;
 };
 
 struct mlx4_qp {
@@ -744,8 +775,23 @@ struct mlx4_vf_dev {
         u8                      n_ports;
 };
 
-struct mlx4_dev {
+struct mlx4_dev_persistent {
         struct pci_dev         *pdev;
+        struct mlx4_dev        *dev;
+        int                     nvfs[MLX4_MAX_PORTS + 1];
+        int                     num_vfs;
+        enum mlx4_port_type curr_port_type[MLX4_MAX_PORTS + 1];
+        enum mlx4_port_type curr_port_poss_type[MLX4_MAX_PORTS + 1];
+        struct work_struct      catas_work;
+        struct workqueue_struct *catas_wq;
+        struct mutex    device_state_mutex; /* protect HW state */
+        u8              state;
+        struct mutex    interface_state_mutex; /* protect SW state */
+        u8      interface_state;
+};
+
+struct mlx4_dev {
+        struct mlx4_dev_persistent *persist;
         unsigned long           flags;
         unsigned long           num_slaves;
         struct mlx4_caps        caps;
@@ -754,13 +800,11 @@ struct mlx4_dev {
         struct radix_tree_root  qp_table_tree;
         u8                      rev_id;
         char                    board_id[MLX4_BOARD_ID_LEN];
-        int                     num_vfs;
         int                     numa_node;
         int                     oper_log_mgm_entry_size;
         u64                     regid_promisc_array[MLX4_MAX_PORTS + 1];
         u64                     regid_allmulti_array[MLX4_MAX_PORTS + 1];
         struct mlx4_vf_dev     *dev_vfs;
-        int                     nvfs[MLX4_MAX_PORTS + 1];
 };
 
 struct mlx4_eqe {
@@ -832,6 +876,11 @@ struct mlx4_eqe {
                                 } __packed tbl_change_info;
                         } params;
                 } __packed port_mgmt_change;
+                struct {
+                        u8 reserved[3];
+                        u8 port;
+                        u32 reserved1[5];
+                } __packed bad_cable;
         }                       event;
         u8                      slave_id;
         u8                      reserved3[2];
@@ -1338,6 +1387,8 @@ int mlx4_phys_to_slave_port(struct mlx4_dev *dev, int slave, int port);
 int mlx4_get_base_gid_ix(struct mlx4_dev *dev, int slave, int port);
 
 int mlx4_config_vxlan_port(struct mlx4_dev *dev, __be16 udp_port);
+int mlx4_disable_rx_port_check(struct mlx4_dev *dev, bool dis);
+int mlx4_virt2phy_port_map(struct mlx4_dev *dev, u32 port1, u32 port2);
 int mlx4_vf_smi_enabled(struct mlx4_dev *dev, int slave, int port);
 int mlx4_vf_get_enable_smi_admin(struct mlx4_dev *dev, int slave, int port);
 int mlx4_vf_set_enable_smi_admin(struct mlx4_dev *dev, int slave, int port,
diff --git a/include/linux/mlx4/driver.h b/include/linux/mlx4/driver.h
index 022055c8fb26..9553a73d2049 100644
--- a/include/linux/mlx4/driver.h
+++ b/include/linux/mlx4/driver.h
@@ -49,6 +49,10 @@ enum mlx4_dev_event {
         MLX4_DEV_EVENT_SLAVE_SHUTDOWN,
 };
 
+enum {
+        MLX4_INTFF_BONDING      = 1 << 0
+};
+
 struct mlx4_interface {
         void *                  (*add)   (struct mlx4_dev *dev);
         void                    (*remove)(struct mlx4_dev *dev, void *context);
@@ -57,11 +61,26 @@ struct mlx4_interface {
         void *                  (*get_dev)(struct mlx4_dev *dev, void *context, u8 port);
         struct list_head        list;
         enum mlx4_protocol      protocol;
+        int                     flags;
 };
 
 int mlx4_register_interface(struct mlx4_interface *intf);
 void mlx4_unregister_interface(struct mlx4_interface *intf);
 
+int mlx4_bond(struct mlx4_dev *dev);
+int mlx4_unbond(struct mlx4_dev *dev);
+static inline int mlx4_is_bonded(struct mlx4_dev *dev)
+{
+        return !!(dev->flags & MLX4_FLAG_BONDED);
+}
+
+struct mlx4_port_map {
+        u8      port1;
+        u8      port2;
+};
+
+int mlx4_port_map_set(struct mlx4_dev *dev, struct mlx4_port_map *v2p);
+
 void *mlx4_get_protocol_dev(struct mlx4_dev *dev, enum mlx4_protocol proto, int port);
 
 static inline u64 mlx4_mac_to_u64(u8 *addr)
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 467ccdf94c98..2bbc62aa818a 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -96,6 +96,7 @@ enum {
         MLX4_QP_BIT_RRE                         = 1 << 15,
         MLX4_QP_BIT_RWE                         = 1 << 14,
         MLX4_QP_BIT_RAE                         = 1 << 13,
+        MLX4_QP_BIT_FPP                         = 1 <<  3,
         MLX4_QP_BIT_RIC                         = 1 <<  4,
 };
 
diff --git a/include/linux/mm.h b/include/linux/mm.h
index f80d0194c9bc..47a93928b90f 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -138,7 +138,6 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_ACCOUNT      0x00100000      /* Is a VM accounted object */
 #define VM_NORESERVE    0x00200000      /* should the VM suppress accounting */
 #define VM_HUGETLB      0x00400000      /* Huge TLB Page VM */
-#define VM_NONLINEAR    0x00800000      /* Is non-linear (remap_file_pages) */
 #define VM_ARCH_1       0x01000000      /* Architecture-specific flag */
 #define VM_ARCH_2       0x02000000
 #define VM_DONTDUMP     0x04000000      /* Do not include in the core dump */
@@ -206,27 +205,26 @@ extern unsigned int kobjsize(const void *objp);
 extern pgprot_t protection_map[16];
 
 #define FAULT_FLAG_WRITE        0x01    /* Fault was a write access */
-#define FAULT_FLAG_NONLINEAR    0x02    /* Fault was via a nonlinear mapping */
-#define FAULT_FLAG_MKWRITE      0x04    /* Fault was mkwrite of existing pte */
-#define FAULT_FLAG_ALLOW_RETRY  0x08    /* Retry fault if blocking */
-#define FAULT_FLAG_RETRY_NOWAIT 0x10    /* Don't drop mmap_sem and wait when retrying */
-#define FAULT_FLAG_KILLABLE     0x20    /* The fault task is in SIGKILL killable region */
-#define FAULT_FLAG_TRIED        0x40    /* second try */
-#define FAULT_FLAG_USER         0x80    /* The fault originated in userspace */
+#define FAULT_FLAG_MKWRITE      0x02    /* Fault was mkwrite of existing pte */
+#define FAULT_FLAG_ALLOW_RETRY  0x04    /* Retry fault if blocking */
+#define FAULT_FLAG_RETRY_NOWAIT 0x08    /* Don't drop mmap_sem and wait when retrying */
+#define FAULT_FLAG_KILLABLE     0x10    /* The fault task is in SIGKILL killable region */
+#define FAULT_FLAG_TRIED        0x20    /* Second try */
+#define FAULT_FLAG_USER         0x40    /* The fault originated in userspace */
 
 /*
  * vm_fault is filled by the the pagefault handler and passed to the vma's
  * ->fault function. The vma's ->fault is responsible for returning a bitmask
  * of VM_FAULT_xxx flags that give details about how the fault was handled.
  *
- * pgoff should be used in favour of virtual_address, if possible. If pgoff
- * is used, one may implement ->remap_pages to get nonlinear mapping support.
+ * pgoff should be used in favour of virtual_address, if possible.
  */
 struct vm_fault {
         unsigned int flags;             /* FAULT_FLAG_xxx flags */
         pgoff_t pgoff;                  /* Logical page offset based on vma */
         void __user *virtual_address;   /* Faulting virtual address */
 
+        struct page *cow_page;          /* Handler may choose to COW */
         struct page *page;              /* ->fault handlers should return a
                                          * page here, unless VM_FAULT_NOPAGE
                                          * is set (which is also implied by
@@ -287,9 +285,13 @@ struct vm_operations_struct {
         struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
                                         unsigned long addr);
 #endif
-        /* called by sys_remap_file_pages() to populate non-linear mapping */
-        int (*remap_pages)(struct vm_area_struct *vma, unsigned long addr,
-                           unsigned long size, pgoff_t pgoff);
+        /*
+         * Called by vm_normal_page() for special PTEs to find the
+         * page for @addr.  This is useful if the default behavior
+         * (using pte_page()) would not find the correct page.
+         */
+        struct page *(*find_special_page)(struct vm_area_struct *vma,
+                                          unsigned long addr);
 };
 
 struct mmu_gather;
@@ -446,6 +448,12 @@ static inline struct page *compound_head_by_tail(struct page *tail)
         return tail;
 }
 
+/*
+ * Since either compound page could be dismantled asynchronously in THP
+ * or we access asynchronously arbitrary positioned struct page, there
+ * would be tail flag race. To handle this race, we should call
+ * smp_rmb() before checking tail flag. compound_head_by_tail() did it.
+ */
 static inline struct page *compound_head(struct page *page)
 {
         if (unlikely(PageTail(page)))
@@ -454,6 +462,18 @@ static inline struct page *compound_head(struct page *page)
 }
 
 /*
+ * If we access compound page synchronously such as access to
+ * allocated page, there is no need to handle tail flag race, so we can
+ * check tail flag directly without any synchronization primitive.
+ */
+static inline struct page *compound_head_fast(struct page *page)
+{
+        if (unlikely(PageTail(page)))
+                return page->first_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).
@@ -465,7 +485,8 @@ static inline void page_mapcount_reset(struct page *page)
 
 static inline int page_mapcount(struct page *page)
 {
-        return atomic_read(&(page)->_mapcount) + 1;
+        VM_BUG_ON_PAGE(PageSlab(page), page);
+        return atomic_read(&page->_mapcount) + 1;
 }
 
 static inline int page_count(struct page *page)
@@ -531,7 +552,14 @@ static inline void get_page(struct page *page)
 static inline struct page *virt_to_head_page(const void *x)
 {
         struct page *page = virt_to_page(x);
-        return compound_head(page);
+
+        /*
+         * We don't need to worry about synchronization of tail flag
+         * when we call virt_to_head_page() since it is only called for
+         * already allocated page and this page won't be freed until
+         * this virt_to_head_page() is finished. So use _fast variant.
+         */
+        return compound_head_fast(page);
 }
 
 /*
@@ -601,29 +629,28 @@ int split_free_page(struct page *page);
  * prototype for that function and accessor functions.
  * These are _only_ valid on the head of a PG_compound page.
  */
-typedef void compound_page_dtor(struct page *);
 
 static inline void set_compound_page_dtor(struct page *page,
                                                 compound_page_dtor *dtor)
 {
-        page[1].lru.next = (void *)dtor;
+        page[1].compound_dtor = dtor;
 }
 
 static inline compound_page_dtor *get_compound_page_dtor(struct page *page)
 {
-        return (compound_page_dtor *)page[1].lru.next;
+        return page[1].compound_dtor;
 }
 
 static inline int compound_order(struct page *page)
 {
         if (!PageHead(page))
                 return 0;
-        return (unsigned long)page[1].lru.prev;
+        return page[1].compound_order;
 }
 
 static inline void set_compound_order(struct page *page, unsigned long order)
 {
-        page[1].lru.prev = (void *)order;
+        page[1].compound_order = order;
 }
 
 #ifdef CONFIG_MMU
@@ -1070,6 +1097,7 @@ static inline int page_mapped(struct page *page)
 #define VM_FAULT_WRITE  0x0008  /* Special case for get_user_pages */
 #define VM_FAULT_HWPOISON 0x0010        /* Hit poisoned small page */
 #define VM_FAULT_HWPOISON_LARGE 0x0020  /* Hit poisoned large page. Index encoded in upper bits */
+#define VM_FAULT_SIGSEGV 0x0040
 
 #define VM_FAULT_NOPAGE 0x0100  /* ->fault installed the pte, not return page */
 #define VM_FAULT_LOCKED 0x0200  /* ->fault locked the returned page */
@@ -1078,8 +1106,9 @@ static inline int page_mapped(struct page *page)
 
 #define VM_FAULT_HWPOISON_LARGE_MASK 0xf000 /* encodes hpage index for large hwpoison */
 
-#define VM_FAULT_ERROR  (VM_FAULT_OOM | VM_FAULT_SIGBUS | VM_FAULT_HWPOISON | \
-                         VM_FAULT_FALLBACK | VM_FAULT_HWPOISON_LARGE)
+#define VM_FAULT_ERROR  (VM_FAULT_OOM | VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV | \
+                         VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE | \
+                         VM_FAULT_FALLBACK)
 
 /* Encode hstate index for a hwpoisoned large page */
 #define VM_FAULT_SET_HINDEX(x) ((x) << 12)
@@ -1119,7 +1148,6 @@ extern void user_shm_unlock(size_t, struct user_struct *);
  * Parameter block passed down to zap_pte_range in exceptional cases.
  */
 struct zap_details {
-        struct vm_area_struct *nonlinear_vma;   /* Check page->index if set */
         struct address_space *check_mapping;    /* Check page->mapping if set */
         pgoff_t first_index;                    /* Lowest page->index to unmap */
         pgoff_t last_index;                     /* Highest page->index to unmap */
@@ -1137,8 +1165,6 @@ void unmap_vmas(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
 
 /**
  * mm_walk - callbacks for walk_page_range
- * @pgd_entry: if set, called for each non-empty PGD (top-level) entry
- * @pud_entry: if set, called for each non-empty PUD (2nd-level) entry
  * @pmd_entry: if set, called for each non-empty PMD (3rd-level) entry
  *             this handler is required to be able to handle
  *             pmd_trans_huge() pmds.  They may simply choose to
@@ -1146,16 +1172,18 @@ void unmap_vmas(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
  * @pte_entry: if set, called for each non-empty PTE (4th-level) entry
  * @pte_hole: if set, called for each hole at all levels
  * @hugetlb_entry: if set, called for each hugetlb entry
- *                 *Caution*: The caller must hold mmap_sem() if @hugetlb_entry
- *                            is used.
+ * @test_walk: caller specific callback function to determine whether
+ *             we walk over the current vma or not. A positive returned
+ *             value means "do page table walk over the current vma,"
+ *             and a negative one means "abort current page table walk
+ *             right now." 0 means "skip the current vma."
+ * @mm:        mm_struct representing the target process of page table walk
+ * @vma:       vma currently walked (NULL if walking outside vmas)
+ * @private:   private data for callbacks' usage
  *
- * (see walk_page_range for more details)
+ * (see the comment on walk_page_range() for more details)
  */
 struct mm_walk {
-        int (*pgd_entry)(pgd_t *pgd, unsigned long addr,
-                         unsigned long next, struct mm_walk *walk);
-        int (*pud_entry)(pud_t *pud, unsigned long addr,
-                         unsigned long next, struct mm_walk *walk);
         int (*pmd_entry)(pmd_t *pmd, unsigned long addr,
                          unsigned long next, struct mm_walk *walk);
         int (*pte_entry)(pte_t *pte, unsigned long addr,
@@ -1165,12 +1193,16 @@ struct mm_walk {
         int (*hugetlb_entry)(pte_t *pte, unsigned long hmask,
                              unsigned long addr, unsigned long next,
                              struct mm_walk *walk);
+        int (*test_walk)(unsigned long addr, unsigned long next,
+                        struct mm_walk *walk);
         struct mm_struct *mm;
+        struct vm_area_struct *vma;
         void *private;
 };
 
 int walk_page_range(unsigned long addr, unsigned long end,
                 struct mm_walk *walk);
+int walk_page_vma(struct vm_area_struct *vma, struct mm_walk *walk);
 void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
                 unsigned long end, unsigned long floor, unsigned long ceiling);
 int copy_page_range(struct mm_struct *dst, struct mm_struct *src,
@@ -1234,6 +1266,17 @@ long get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
                     unsigned long start, unsigned long nr_pages,
                     int write, int force, struct page **pages,
                     struct vm_area_struct **vmas);
+long get_user_pages_locked(struct task_struct *tsk, struct mm_struct *mm,
+                    unsigned long start, unsigned long nr_pages,
+                    int write, int force, struct page **pages,
+                    int *locked);
+long __get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
+                               unsigned long start, unsigned long nr_pages,
+                               int write, int force, struct page **pages,
+                               unsigned int gup_flags);
+long get_user_pages_unlocked(struct task_struct *tsk, struct mm_struct *mm,
+                    unsigned long start, unsigned long nr_pages,
+                    int write, int force, struct page **pages);
 int get_user_pages_fast(unsigned long start, int nr_pages, int write,
                         struct page **pages);
 struct kvec;
@@ -1366,6 +1409,11 @@ static inline void update_hiwater_vm(struct mm_struct *mm)
                 mm->hiwater_vm = mm->total_vm;
 }
 
+static inline void reset_mm_hiwater_rss(struct mm_struct *mm)
+{
+        mm->hiwater_rss = get_mm_rss(mm);
+}
+
 static inline void setmax_mm_hiwater_rss(unsigned long *maxrss,
                                          struct mm_struct *mm)
 {
@@ -1405,14 +1453,45 @@ static inline int __pud_alloc(struct mm_struct *mm, pgd_t *pgd,
 int __pud_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
 #endif
 
-#ifdef __PAGETABLE_PMD_FOLDED
+#if defined(__PAGETABLE_PMD_FOLDED) || !defined(CONFIG_MMU)
 static inline int __pmd_alloc(struct mm_struct *mm, pud_t *pud,
                                                 unsigned long address)
 {
         return 0;
 }
+
+static inline void mm_nr_pmds_init(struct mm_struct *mm) {}
+
+static inline unsigned long mm_nr_pmds(struct mm_struct *mm)
+{
+        return 0;
+}
+
+static inline void mm_inc_nr_pmds(struct mm_struct *mm) {}
+static inline void mm_dec_nr_pmds(struct mm_struct *mm) {}
+
 #else
 int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
+
+static inline void mm_nr_pmds_init(struct mm_struct *mm)
+{
+        atomic_long_set(&mm->nr_pmds, 0);
+}
+
+static inline unsigned long mm_nr_pmds(struct mm_struct *mm)
+{
+        return atomic_long_read(&mm->nr_pmds);
+}
+
+static inline void mm_inc_nr_pmds(struct mm_struct *mm)
+{
+        atomic_long_inc(&mm->nr_pmds);
+}
+
+static inline void mm_dec_nr_pmds(struct mm_struct *mm)
+{
+        atomic_long_dec(&mm->nr_pmds);
+}
 #endif
 
 int __pte_alloc(struct mm_struct *mm, struct vm_area_struct *vma,
@@ -1775,12 +1854,6 @@ struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node,
         for (vma = vma_interval_tree_iter_first(root, start, last);     \
              vma; vma = vma_interval_tree_iter_next(vma, start, last))
 
-static inline void vma_nonlinear_insert(struct vm_area_struct *vma,
-                                        struct list_head *list)
-{
-        list_add_tail(&vma->shared.nonlinear, list);
-}
-
 void anon_vma_interval_tree_insert(struct anon_vma_chain *node,
                                    struct rb_root *root);
 void anon_vma_interval_tree_remove(struct anon_vma_chain *node,
@@ -1952,7 +2025,7 @@ extern int expand_downwards(struct vm_area_struct *vma,
 #if VM_GROWSUP
 extern int expand_upwards(struct vm_area_struct *vma, unsigned long address);
 #else
-  #define expand_upwards(vma, address) do { } while (0)
+  #define expand_upwards(vma, address) (0)
 #endif
 
 /* Look up the first VMA which satisfies  addr < vm_end,  NULL if none. */
@@ -2108,9 +2181,8 @@ int drop_caches_sysctl_handler(struct ctl_table *, int,
                                         void __user *, size_t *, loff_t *);
 #endif
 
-unsigned long shrink_node_slabs(gfp_t gfp_mask, int nid,
-                                unsigned long nr_scanned,
-                                unsigned long nr_eligible);
+void drop_slab(void);
+void drop_slab_node(int nid);
 
 #ifndef CONFIG_MMU
 #define randomize_va_space 0
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 6d34aa266a8c..199a03aab8dc 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -28,6 +28,8 @@ struct mem_cgroup;
                 IS_ENABLED(CONFIG_ARCH_ENABLE_SPLIT_PMD_PTLOCK))
 #define ALLOC_SPLIT_PTLOCKS     (SPINLOCK_SIZE > BITS_PER_LONG/8)
 
+typedef void compound_page_dtor(struct page *);
+
 /*
  * Each physical page in the system has a struct page associated with
  * it to keep track of whatever it is we are using the page for at the
@@ -142,6 +144,12 @@ struct page {
                 struct rcu_head rcu_head;       /* Used by SLAB
                                                  * when destroying via RCU
                                                  */
+                /* First tail page of compound page */
+                struct {
+                        compound_page_dtor *compound_dtor;
+                        unsigned long compound_order;
+                };
+
 #if defined(CONFIG_TRANSPARENT_HUGEPAGE) && USE_SPLIT_PMD_PTLOCKS
                 pgtable_t pmd_huge_pte; /* protected by page->ptl */
 #endif
@@ -273,15 +281,11 @@ struct vm_area_struct {
 
         /*
          * For areas with an address space and backing store,
-         * linkage into the address_space->i_mmap interval tree, or
-         * linkage of vma in the address_space->i_mmap_nonlinear list.
+         * linkage into the address_space->i_mmap interval tree.
          */
-        union {
-                struct {
-                        struct rb_node rb;
-                        unsigned long rb_subtree_last;
-                } linear;
-                struct list_head nonlinear;
+        struct {
+                struct rb_node rb;
+                unsigned long rb_subtree_last;
         } shared;
 
         /*
@@ -359,7 +363,8 @@ struct mm_struct {
         pgd_t * pgd;
         atomic_t mm_users;                      /* How many users with user space? */
         atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
-        atomic_long_t nr_ptes;                  /* Page table pages */
+        atomic_long_t nr_ptes;                  /* PTE page table pages */
+        atomic_long_t nr_pmds;                  /* PMD page table pages */
         int map_count;                          /* number of VMAs */
 
         spinlock_t page_table_lock;             /* Protects page tables and some counters */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 4d69c00497bd..a6cf4c063e4e 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -83,7 +83,7 @@ struct mmc_ext_csd {
         bool                    hpi;                    /* HPI support bit */
         unsigned int            hpi_cmd;                /* cmd used as HPI */
         bool                    bkops;          /* background support bit */
-        bool                    bkops_en;       /* background enable bit */
+        bool                    man_bkops_en;   /* manual bkops enable bit */
         unsigned int            data_sector_size;       /* 512 bytes or 4KB */
         unsigned int            data_tag_unit_size;     /* DATA TAG UNIT size */
         unsigned int            boot_ro_lock;           /* ro lock support */
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index cb2b0400d284..160448f920ac 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -182,7 +182,6 @@ extern int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen);
 extern int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount,
                               bool is_rel_write);
 extern int mmc_hw_reset(struct mmc_host *host);
-extern int mmc_hw_reset_check(struct mmc_host *host);
 extern int mmc_can_reset(struct mmc_card *card);
 
 extern void mmc_set_data_timeout(struct mmc_data *, const struct mmc_card *);
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 42b724e8d503..471fb3116dbe 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -106,6 +106,11 @@ struct mmc_data;
  * @cur_slot, @mrq and @state. These must always be updated
  * at the same time while holding @lock.
  *
+ * @irq_lock is an irq-safe spinlock protecting the INTMASK register
+ * to allow the interrupt handler to modify it directly.  Held for only long
+ * enough to read-modify-write INTMASK and no other locks are grabbed when
+ * holding this one.
+ *
  * The @mrq field of struct dw_mci_slot is also protected by @lock,
  * and must always be written at the same time as the slot is added to
  * @queue.
@@ -125,6 +130,7 @@ struct mmc_data;
  */
 struct dw_mci {
         spinlock_t              lock;
+        spinlock_t              irq_lock;
         void __iomem            *regs;
 
         struct scatterlist      *sg;
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 9f322706f7cb..0c8cbe5d1550 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -166,7 +166,6 @@ struct mmc_async_req {
  * struct mmc_slot - MMC slot functions
  *
  * @cd_irq:             MMC/SD-card slot hotplug detection IRQ or -EINVAL
- * @lock:               protect the @handler_priv pointer
  * @handler_priv:       MMC/SD-card slot context
  *
  * Some MMC/SD host controllers implement slot-functions like card and
@@ -176,7 +175,6 @@ struct mmc_async_req {
  */
 struct mmc_slot {
         int cd_irq;
-        struct mutex lock;
         void *handler_priv;
 };
 
@@ -197,6 +195,7 @@ struct mmc_context_info {
 };
 
 struct regulator;
+struct mmc_pwrseq;
 
 struct mmc_supply {
         struct regulator *vmmc;         /* Card power supply */
@@ -208,6 +207,7 @@ struct mmc_host {
         struct device           class_dev;
         int                     index;
         const struct mmc_host_ops *ops;
+        struct mmc_pwrseq       *pwrseq;
         unsigned int            f_min;
         unsigned int            f_max;
         unsigned int            f_init;
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 49ad7a943638..124f562118b8 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -53,11 +53,6 @@
 #define MMC_SEND_TUNING_BLOCK    19   /* adtc                    R1  */
 #define MMC_SEND_TUNING_BLOCK_HS200     21      /* adtc R1  */
 
-#define MMC_TUNING_BLK_PATTERN_4BIT_SIZE         64
-#define MMC_TUNING_BLK_PATTERN_8BIT_SIZE        128
-extern const u8 tuning_blk_pattern_4bit[MMC_TUNING_BLK_PATTERN_4BIT_SIZE];
-extern const u8 tuning_blk_pattern_8bit[MMC_TUNING_BLK_PATTERN_8BIT_SIZE];
-
   /* class 3 */
 #define MMC_WRITE_DAT_UNTIL_STOP 20   /* adtc [31:0] data addr   R1  */
 
@@ -433,6 +428,11 @@ struct _mmc_csd {
 #define EXT_CSD_BKOPS_LEVEL_2           0x2
 
 /*
+ * BKOPS modes
+ */
+#define EXT_CSD_MANUAL_BKOPS_MASK       0x01
+
+/*
  * MMC_SWITCH access modes
  */
 
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 375af80bde7d..c3e3db196738 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -17,6 +17,11 @@
 #include <linux/io.h>
 #include <linux/mmc/host.h>
 
+struct sdhci_host_next {
+        unsigned int    sg_count;
+        s32             cookie;
+};
+
 struct sdhci_host {
         /* Data set by hardware interface driver */
         const char *hw_name;    /* Hardware bus name */
@@ -106,6 +111,10 @@ struct sdhci_host {
 #define SDHCI_QUIRK2_CLEAR_TRANSFERMODE_REG_BEFORE_CMD  (1<<10)
 /* Capability register bit-63 indicates HS400 support */
 #define SDHCI_QUIRK2_CAPS_BIT63_FOR_HS400               (1<<11)
+/* forced tuned clock */
+#define SDHCI_QUIRK2_TUNING_WORK_AROUND                 (1<<12)
+/* disable the block count for single block transactions */
+#define SDHCI_QUIRK2_SUPPORT_SINGLE                     (1<<13)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
@@ -137,6 +146,7 @@ struct sdhci_host {
 #define SDHCI_SDR104_NEEDS_TUNING (1<<10)       /* SDR104/HS200 needs tuning */
 #define SDHCI_USING_RETUNING_TIMER (1<<11)      /* Host is using a retuning timer for the card */
 #define SDHCI_USE_64_BIT_DMA    (1<<12) /* Use 64-bit DMA */
+#define SDHCI_HS400_TUNING      (1<<13) /* Tuning for HS400 */
 
         unsigned int version;   /* SDHCI spec. version */
 
@@ -202,6 +212,7 @@ struct sdhci_host {
 #define SDHCI_TUNING_MODE_1     0
         struct timer_list       tuning_timer;   /* Timer for tuning */
 
+        struct sdhci_host_next  next_data;
         unsigned long private[0] ____cacheline_aligned;
 };
 #endif /* LINUX_MMC_SDHCI_H */
diff --git a/include/linux/mmc/sdio_ids.h b/include/linux/mmc/sdio_ids.h
index 0f01fe065424..996807963716 100644
--- a/include/linux/mmc/sdio_ids.h
+++ b/include/linux/mmc/sdio_ids.h
@@ -24,13 +24,15 @@
  * Vendors and devices.  Sort key: vendor first, device next.
  */
 #define SDIO_VENDOR_ID_BROADCOM                 0x02d0
-#define SDIO_DEVICE_ID_BROADCOM_43143           43143
+#define SDIO_DEVICE_ID_BROADCOM_43143           0xa887
 #define SDIO_DEVICE_ID_BROADCOM_43241           0x4324
 #define SDIO_DEVICE_ID_BROADCOM_4329            0x4329
 #define SDIO_DEVICE_ID_BROADCOM_4330            0x4330
 #define SDIO_DEVICE_ID_BROADCOM_4334            0x4334
+#define SDIO_DEVICE_ID_BROADCOM_43340           0xa94c
+#define SDIO_DEVICE_ID_BROADCOM_43341           0xa94d
 #define SDIO_DEVICE_ID_BROADCOM_4335_4339       0x4335
-#define SDIO_DEVICE_ID_BROADCOM_43362           43362
+#define SDIO_DEVICE_ID_BROADCOM_43362           0xa962
 #define SDIO_DEVICE_ID_BROADCOM_4354            0x4354
 
 #define SDIO_VENDOR_ID_INTEL                    0x0089
diff --git a/include/linux/mmc/sh_mobile_sdhi.h b/include/linux/mmc/sh_mobile_sdhi.h
index 68927ae50845..da77e5e2041d 100644
--- a/include/linux/mmc/sh_mobile_sdhi.h
+++ b/include/linux/mmc/sh_mobile_sdhi.h
@@ -3,20 +3,10 @@
 
 #include <linux/types.h>
 
-struct platform_device;
-
 #define SH_MOBILE_SDHI_IRQ_CARD_DETECT  "card_detect"
 #define SH_MOBILE_SDHI_IRQ_SDCARD       "sdcard"
 #define SH_MOBILE_SDHI_IRQ_SDIO         "sdio"
 
-/**
- * struct sh_mobile_sdhi_ops - SDHI driver callbacks
- * @cd_wakeup:          trigger a card-detection run
- */
-struct sh_mobile_sdhi_ops {
-        void (*cd_wakeup)(const struct platform_device *pdev);
-};
-
 struct sh_mobile_sdhi_info {
         int dma_slave_tx;
         int dma_slave_rx;
@@ -25,11 +15,6 @@ struct sh_mobile_sdhi_info {
         unsigned long tmio_caps2;
         u32 tmio_ocr_mask;      /* available MMC voltages */
         unsigned int cd_gpio;
-
-        /* callbacks for board specific setup code */
-        int (*init)(struct platform_device *pdev,
-                    const struct sh_mobile_sdhi_ops *ops);
-        void (*cleanup)(struct platform_device *pdev);
 };
 
 #endif /* LINUX_MMC_SH_MOBILE_SDHI_H */
diff --git a/include/linux/mmc/slot-gpio.h b/include/linux/mmc/slot-gpio.h
index e56fa24c9322..3945a8c9d3cb 100644
--- a/include/linux/mmc/slot-gpio.h
+++ b/include/linux/mmc/slot-gpio.h
@@ -15,12 +15,10 @@ struct mmc_host;
 
 int mmc_gpio_get_ro(struct mmc_host *host);
 int mmc_gpio_request_ro(struct mmc_host *host, unsigned int gpio);
-void mmc_gpio_free_ro(struct mmc_host *host);
 
 int mmc_gpio_get_cd(struct mmc_host *host);
 int mmc_gpio_request_cd(struct mmc_host *host, unsigned int gpio,
                         unsigned int debounce);
-void mmc_gpio_free_cd(struct mmc_host *host);
 
 int mmc_gpiod_request_cd(struct mmc_host *host, const char *con_id,
                          unsigned int idx, bool override_active_level,
@@ -28,7 +26,8 @@ int mmc_gpiod_request_cd(struct mmc_host *host, const char *con_id,
 int mmc_gpiod_request_ro(struct mmc_host *host, const char *con_id,
                          unsigned int idx, bool override_active_level,
                          unsigned int debounce, bool *gpio_invert);
-void mmc_gpiod_free_cd(struct mmc_host *host);
+void mmc_gpio_set_cd_isr(struct mmc_host *host,
+                         irqreturn_t (*isr)(int irq, void *dev_id));
 void mmc_gpiod_request_cd_irq(struct mmc_host *host);
 
 #endif
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 2f0856d14b21..f279d9c158cd 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -426,7 +426,7 @@ struct zone {
         const char              *name;
 
         /*
-         * Number of MIGRATE_RESEVE page block. To maintain for just
+         * Number of MIGRATE_RESERVE page block. To maintain for just
          * optimization. Protected by zone->lock.
          */
         int                     nr_migrate_reserve_block;
@@ -970,7 +970,6 @@ static inline int zonelist_node_idx(struct zoneref *zoneref)
  * @z - The cursor used as a starting point for the search
  * @highest_zoneidx - The zone index of the highest zone to return
  * @nodes - An optional nodemask to filter the zonelist with
- * @zone - The first suitable zone found is returned via this parameter
  *
  * This function returns the next zone at or below a given zone index that is
  * within the allowed nodemask using a cursor as the starting point for the
@@ -980,8 +979,7 @@ static inline int zonelist_node_idx(struct zoneref *zoneref)
  */
 struct zoneref *next_zones_zonelist(struct zoneref *z,
                                         enum zone_type highest_zoneidx,
-                                        nodemask_t *nodes,
-                                        struct zone **zone);
+                                        nodemask_t *nodes);
 
 /**
  * first_zones_zonelist - Returns the first zone at or below highest_zoneidx within the allowed nodemask in a zonelist
@@ -1000,8 +998,10 @@ static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
                                         nodemask_t *nodes,
                                         struct zone **zone)
 {
-        return next_zones_zonelist(zonelist->_zonerefs, highest_zoneidx, nodes,
-                                                                zone);
+        struct zoneref *z = next_zones_zonelist(zonelist->_zonerefs,
+                                                        highest_zoneidx, nodes);
+        *zone = zonelist_zone(z);
+        return z;
 }
 
 /**
@@ -1018,7 +1018,8 @@ static inline struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
 #define for_each_zone_zonelist_nodemask(zone, z, zlist, highidx, nodemask) \
         for (z = first_zones_zonelist(zlist, highidx, nodemask, &zone); \
                 zone;                                                   \
-                z = next_zones_zonelist(++z, highidx, nodemask, &zone)) \
+                z = next_zones_zonelist(++z, highidx, nodemask),        \
+                        zone = zonelist_zone(z))                        \
 
 /**
  * for_each_zone_zonelist - helper macro to iterate over valid zones in a zonelist at or below a given zone index
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 745def862580..2e75ab00dbf2 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -53,9 +53,9 @@ struct ieee1394_device_id {
 
 /**
  * struct usb_device_id - identifies USB devices for probing and hotplugging
- * @match_flags: Bit mask controlling of the other fields are used to match
- *      against new devices.  Any field except for driver_info may be used,
- *      although some only make sense in conjunction with other fields.
+ * @match_flags: Bit mask controlling which of the other fields are used to
+ *      match against new devices. Any field except for driver_info may be
+ *      used, although some only make sense in conjunction with other fields.
  *      This is usually set by a USB_DEVICE_*() macro, which sets all
  *      other fields in this structure except for driver_info.
  * @idVendor: USB vendor ID for a device; numbers are assigned
@@ -220,8 +220,7 @@ struct serio_device_id {
 /*
  * Struct used for matching a device
  */
-struct of_device_id
-{
+struct of_device_id {
         char    name[32];
         char    type[32];
         char    compatible[128];
diff --git a/include/linux/module.h b/include/linux/module.h
index ebfb0e153c6a..42999fe2dbd0 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -135,7 +135,7 @@ void trim_init_extable(struct module *m);
 #ifdef MODULE
 /* Creates an alias so file2alias.c can find device table. */
 #define MODULE_DEVICE_TABLE(type, name)                                 \
-  extern const struct type##_device_id __mod_##type##__##name##_device_table \
+extern const typeof(name) __mod_##type##__##name##_device_table         \
   __attribute__ ((unused, alias(__stringify(name))))
 #else  /* !MODULE */
 #define MODULE_DEVICE_TABLE(type, name)
@@ -444,7 +444,7 @@ extern void __module_put_and_exit(struct module *mod, long code)
 #define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code)
 
 #ifdef CONFIG_MODULE_UNLOAD
-unsigned long module_refcount(struct module *mod);
+int module_refcount(struct module *mod);
 void __symbol_put(const char *symbol);
 #define symbol_put(x) __symbol_put(VMLINUX_SYMBOL_STR(x))
 void symbol_put_addr(void *addr);
diff --git a/include/linux/moduleloader.h b/include/linux/moduleloader.h
index 7eeb9bbfb816..f7556261fe3c 100644
--- a/include/linux/moduleloader.h
+++ b/include/linux/moduleloader.h
@@ -26,7 +26,7 @@ unsigned int arch_mod_section_prepend(struct module *mod, unsigned int section);
 void *module_alloc(unsigned long size);
 
 /* Free memory returned from module_alloc. */
-void module_free(struct module *mod, void *module_region);
+void module_memfree(void *module_region);
 
 /*
  * Apply the given relocation to the (simplified) ELF.  Return -error
@@ -82,4 +82,6 @@ int module_finalize(const Elf_Ehdr *hdr,
 /* Any cleanup needed when module leaves. */
 void module_arch_cleanup(struct module *mod);
 
+/* Any cleanup before freeing mod->module_init */
+void module_arch_freeing_init(struct module *mod);
 #endif
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index 031ff3a9a0bd..3301c4c289d6 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -408,4 +408,6 @@ static inline int mtd_is_bitflip_or_eccerr(int err) {
         return mtd_is_bitflip(err) || mtd_is_eccerr(err);
 }
 
+unsigned mtd_mmap_capabilities(struct mtd_info *mtd);
+
 #endif /* __MTD_MTD_H__ */
diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h
index c3918a0684fe..1e271cb559cd 100644
--- a/include/linux/mtd/ubi.h
+++ b/include/linux/mtd/ubi.h
@@ -23,22 +23,32 @@
 
 #include <linux/ioctl.h>
 #include <linux/types.h>
+#include <linux/scatterlist.h>
 #include <mtd/ubi-user.h>
 
 /* All voumes/LEBs */
 #define UBI_ALL -1
 
 /*
+ * Maximum number of scatter gather list entries,
+ * we use only 64 to have a lower memory foot print.
+ */
+#define UBI_MAX_SG_COUNT 64
+
+/*
  * enum ubi_open_mode - UBI volume open mode constants.
  *
  * UBI_READONLY: read-only mode
  * UBI_READWRITE: read-write mode
  * UBI_EXCLUSIVE: exclusive mode
+ * UBI_METAONLY: modify only the volume meta-data,
+ *  i.e. the data stored in the volume table, but not in any of volume LEBs.
  */
 enum {
         UBI_READONLY = 1,
         UBI_READWRITE,
-        UBI_EXCLUSIVE
+        UBI_EXCLUSIVE,
+        UBI_METAONLY
 };
 
 /**
@@ -116,6 +126,35 @@ struct ubi_volume_info {
 };
 
 /**
+ * struct ubi_sgl - UBI scatter gather list data structure.
+ * @list_pos: current position in @sg[]
+ * @page_pos: current position in @sg[@list_pos]
+ * @sg: the scatter gather list itself
+ *
+ * ubi_sgl is a wrapper around a scatter list which keeps track of the
+ * current position in the list and the current list item such that
+ * it can be used across multiple ubi_leb_read_sg() calls.
+ */
+struct ubi_sgl {
+        int list_pos;
+        int page_pos;
+        struct scatterlist sg[UBI_MAX_SG_COUNT];
+};
+
+/**
+ * ubi_sgl_init - initialize an UBI scatter gather list data structure.
+ * @usgl: the UBI scatter gather struct itself
+ *
+ * Please note that you still have to use sg_init_table() or any adequate
+ * function to initialize the unterlaying struct scatterlist.
+ */
+static inline void ubi_sgl_init(struct ubi_sgl *usgl)
+{
+        usgl->list_pos = 0;
+        usgl->page_pos = 0;
+}
+
+/**
  * struct ubi_device_info - UBI device description data structure.
  * @ubi_num: ubi device number
  * @leb_size: logical eraseblock size on this UBI device
@@ -210,6 +249,8 @@ int ubi_unregister_volume_notifier(struct notifier_block *nb);
 void ubi_close_volume(struct ubi_volume_desc *desc);
 int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,
                  int len, int check);
+int ubi_leb_read_sg(struct ubi_volume_desc *desc, int lnum, struct ubi_sgl *sgl,
+                   int offset, int len, int check);
 int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
                   int offset, int len);
 int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,
@@ -230,4 +271,14 @@ static inline int ubi_read(struct ubi_volume_desc *desc, int lnum, char *buf,
 {
         return ubi_leb_read(desc, lnum, buf, offset, len, 0);
 }
+
+/*
+ * This function is the same as the 'ubi_leb_read_sg()' function, but it does
+ * not provide the checking capability.
+ */
+static inline int ubi_read_sg(struct ubi_volume_desc *desc, int lnum,
+                              struct ubi_sgl *sgl, int offset, int len)
+{
+        return ubi_leb_read_sg(desc, lnum, sgl, offset, len, 0);
+}
 #endif /* !__LINUX_UBI_H__ */
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index cc31498fc526..2cb7531e7d7a 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -59,7 +59,6 @@ struct mutex {
         struct optimistic_spin_queue osq; /* Spinner MCS lock */
 #endif
 #ifdef CONFIG_DEBUG_MUTEXES
-        const char              *name;
         void                    *magic;
 #endif
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 8e30685affeb..7d59dc6ab789 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -66,6 +66,7 @@ enum {
         NETIF_F_HW_VLAN_STAG_FILTER_BIT,/* Receive filtering on VLAN STAGs */
         NETIF_F_HW_L2FW_DOFFLOAD_BIT,   /* Allow L2 Forwarding in Hardware */
         NETIF_F_BUSY_POLL_BIT,          /* Busy poll */
+        NETIF_F_HW_SWITCH_OFFLOAD_BIT,  /* HW switch offload */
 
         /*
          * Add your fresh new feature above and remember to update
@@ -124,6 +125,7 @@ enum {
 #define NETIF_F_HW_VLAN_STAG_TX __NETIF_F(HW_VLAN_STAG_TX)
 #define NETIF_F_HW_L2FW_DOFFLOAD        __NETIF_F(HW_L2FW_DOFFLOAD)
 #define NETIF_F_BUSY_POLL       __NETIF_F(BUSY_POLL)
+#define NETIF_F_HW_SWITCH_OFFLOAD       __NETIF_F(HW_SWITCH_OFFLOAD)
 
 /* Features valid for ethtool to change */
 /* = all defined minus driver/device-class-related */
@@ -159,7 +161,9 @@ enum {
  */
 #define NETIF_F_ONE_FOR_ALL     (NETIF_F_GSO_SOFTWARE | NETIF_F_GSO_ROBUST | \
                                  NETIF_F_SG | NETIF_F_HIGHDMA |         \
-                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED)
+                                 NETIF_F_FRAGLIST | NETIF_F_VLAN_CHALLENGED | \
+                                 NETIF_F_HW_SWITCH_OFFLOAD)
+
 /*
  * If one device doesn't support one of these features, then disable it
  * for all in netdev_increment_features.
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index c31f74d76ebd..d115256ed5a2 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -51,6 +51,7 @@
 #include <linux/netdev_features.h>
 #include <linux/neighbour.h>
 #include <uapi/linux/netdevice.h>
+#include <uapi/linux/if_bonding.h>
 
 struct netpoll_info;
 struct device;
@@ -643,39 +644,40 @@ struct rps_dev_flow_table {
 /*
  * The rps_sock_flow_table contains mappings of flows to the last CPU
  * on which they were processed by the application (set in recvmsg).
+ * Each entry is a 32bit value. Upper part is the high order bits
+ * of flow hash, lower part is cpu number.
+ * rps_cpu_mask is used to partition the space, depending on number of
+ * possible cpus : rps_cpu_mask = roundup_pow_of_two(nr_cpu_ids) - 1
+ * For example, if 64 cpus are possible, rps_cpu_mask = 0x3f,
+ * meaning we use 32-6=26 bits for the hash.
  */
 struct rps_sock_flow_table {
-        unsigned int mask;
-        u16 ents[0];
+        u32     mask;
+
+        u32     ents[0] ____cacheline_aligned_in_smp;
 };
-#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (sizeof(struct rps_sock_flow_table) + \
-    ((_num) * sizeof(u16)))
+#define RPS_SOCK_FLOW_TABLE_SIZE(_num) (offsetof(struct rps_sock_flow_table, ents[_num]))
 
 #define RPS_NO_CPU 0xffff
 
+extern u32 rps_cpu_mask;
+extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
+
 static inline void rps_record_sock_flow(struct rps_sock_flow_table *table,
                                         u32 hash)
 {
         if (table && hash) {
-                unsigned int cpu, index = hash & table->mask;
+                unsigned int index = hash & table->mask;
+                u32 val = hash & ~rps_cpu_mask;
 
                 /* We only give a hint, preemption can change cpu under us */
-                cpu = raw_smp_processor_id();
+                val |= raw_smp_processor_id();
 
-                if (table->ents[index] != cpu)
-                        table->ents[index] = cpu;
+                if (table->ents[index] != val)
+                        table->ents[index] = val;
         }
 }
 
-static inline void rps_reset_sock_flow(struct rps_sock_flow_table *table,
-                                       u32 hash)
-{
-        if (table && hash)
-                table->ents[hash & table->mask] = RPS_NO_CPU;
-}
-
-extern struct rps_sock_flow_table __rcu *rps_sock_flow_table;
-
 #ifdef CONFIG_RFS_ACCEL
 bool rps_may_expire_flow(struct net_device *dev, u16 rxq_index, u32 flow_id,
                          u16 filter_id);
@@ -852,11 +854,11 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      3. Update dev->stats asynchronously and atomically, and define
  *         neither operation.
  *
- * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16t vid);
+ * int (*ndo_vlan_rx_add_vid)(struct net_device *dev, __be16 proto, u16 vid);
  *      If device support VLAN filtering this function is called when a
  *      VLAN id is registered.
  *
- * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, unsigned short vid);
+ * int (*ndo_vlan_rx_kill_vid)(struct net_device *dev, __be16 proto, u16 vid);
  *      If device support VLAN filtering this function is called when a
  *      VLAN id is unregistered.
  *
@@ -1012,12 +1014,15 @@ typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
  *      Callback to use for xmit over the accelerated station. This
  *      is used in place of ndo_start_xmit on accelerated net
  *      devices.
- * bool (*ndo_gso_check) (struct sk_buff *skb,
- *                        struct net_device *dev);
+ * netdev_features_t (*ndo_features_check) (struct sk_buff *skb,
+ *                                          struct net_device *dev
+ *                                          netdev_features_t features);
  *      Called by core transmit path to determine if device is capable of
- *      performing GSO on a packet. The device returns true if it is
- *      able to GSO the packet, false otherwise. If the return value is
- *      false the stack will do software GSO.
+ *      performing offload operations on a given packet. This is to give
+ *      the device an opportunity to implement any restrictions that cannot
+ *      be otherwise expressed by feature flags. The check is called with
+ *      the set of features that the stack has calculated and it returns
+ *      those the driver believes to be appropriate.
  *
  * int (*ndo_switch_parent_id_get)(struct net_device *dev,
  *                                 struct netdev_phys_item_id *psid);
@@ -1151,13 +1156,15 @@ struct net_device_ops {
                                                 int idx);
 
         int                     (*ndo_bridge_setlink)(struct net_device *dev,
-                                                      struct nlmsghdr *nlh);
+                                                      struct nlmsghdr *nlh,
+                                                      u16 flags);
         int                     (*ndo_bridge_getlink)(struct sk_buff *skb,
                                                       u32 pid, u32 seq,
                                                       struct net_device *dev,
                                                       u32 filter_mask);
         int                     (*ndo_bridge_dellink)(struct net_device *dev,
-                                                      struct nlmsghdr *nlh);
+                                                      struct nlmsghdr *nlh,
+                                                      u16 flags);
         int                     (*ndo_change_carrier)(struct net_device *dev,
                                                       bool new_carrier);
         int                     (*ndo_get_phys_port_id)(struct net_device *dev,
@@ -1178,8 +1185,9 @@ struct net_device_ops {
                                                         struct net_device *dev,
                                                         void *priv);
         int                     (*ndo_get_lock_subclass)(struct net_device *dev);
-        bool                    (*ndo_gso_check) (struct sk_buff *skb,
-                                                  struct net_device *dev);
+        netdev_features_t       (*ndo_features_check) (struct sk_buff *skb,
+                                                       struct net_device *dev,
+                                                       netdev_features_t features);
 #ifdef CONFIG_NET_SWITCHDEV
         int                     (*ndo_switch_parent_id_get)(struct net_device *dev,
                                                             struct netdev_phys_item_id *psid);
@@ -1510,6 +1518,8 @@ struct net_device {
         struct list_head        napi_list;
         struct list_head        unreg_list;
         struct list_head        close_list;
+        struct list_head        ptype_all;
+        struct list_head        ptype_specific;
 
         struct {
                 struct list_head upper;
@@ -1965,7 +1975,7 @@ struct offload_callbacks {
         struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
                                                 netdev_features_t features);
         struct sk_buff          **(*gro_receive)(struct sk_buff **head,
-                                               struct sk_buff *skb);
+                                                 struct sk_buff *skb);
         int                     (*gro_complete)(struct sk_buff *skb, int nhoff);
 };
 
@@ -1975,10 +1985,21 @@ struct packet_offload {
         struct list_head         list;
 };
 
+struct udp_offload;
+
+struct udp_offload_callbacks {
+        struct sk_buff          **(*gro_receive)(struct sk_buff **head,
+                                                 struct sk_buff *skb,
+                                                 struct udp_offload *uoff);
+        int                     (*gro_complete)(struct sk_buff *skb,
+                                                int nhoff,
+                                                struct udp_offload *uoff);
+};
+
 struct udp_offload {
         __be16                   port;
         u8                       ipproto;
-        struct offload_callbacks callbacks;
+        struct udp_offload_callbacks callbacks;
 };
 
 /* often modified stats are per cpu, other are shared (netdev->stats) */
@@ -2037,6 +2058,7 @@ struct pcpu_sw_netstats {
 #define NETDEV_RESEND_IGMP      0x0016
 #define NETDEV_PRECHANGEMTU     0x0017 /* notify before mtu change happened */
 #define NETDEV_CHANGEINFODATA   0x0018
+#define NETDEV_BONDING_INFO     0x0019
 
 int register_netdevice_notifier(struct notifier_block *nb);
 int unregister_netdevice_notifier(struct notifier_block *nb);
@@ -2081,7 +2103,7 @@ extern rwlock_t				dev_base_lock;		/* Device list lock */
         list_for_each_entry_continue_rcu(d, &(net)->dev_base_head, dev_list)
 #define for_each_netdev_in_bond_rcu(bond, slave)        \
                 for_each_netdev_rcu(&init_net, slave)   \
-                        if (netdev_master_upper_dev_get_rcu(slave) == bond)
+                        if (netdev_master_upper_dev_get_rcu(slave) == (bond))
 #define net_device_entry(lh)    list_entry(lh, struct net_device, dev_list)
 
 static inline struct net_device *next_net_device(struct net_device *dev)
@@ -2299,6 +2321,21 @@ do {									\
                                            compute_pseudo(skb, proto)); \
 } while (0)
 
+static inline void skb_gro_remcsum_process(struct sk_buff *skb, void *ptr,
+                                           int start, int offset)
+{
+        __wsum delta;
+
+        BUG_ON(!NAPI_GRO_CB(skb)->csum_valid);
+
+        delta = remcsum_adjust(ptr, NAPI_GRO_CB(skb)->csum, start, offset);
+
+        /* Adjust skb->csum since we changed the packet */
+        skb->csum = csum_add(skb->csum, delta);
+        NAPI_GRO_CB(skb)->csum = csum_add(NAPI_GRO_CB(skb)->csum, delta);
+}
+
+
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
                                   unsigned short type,
                                   const void *daddr, const void *saddr,
@@ -3460,6 +3497,19 @@ struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
 struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
                                     netdev_features_t features);
 
+struct netdev_bonding_info {
+        ifslave slave;
+        ifbond  master;
+};
+
+struct netdev_notifier_bonding_info {
+        struct netdev_notifier_info info; /* must be first */
+        struct netdev_bonding_info  bonding_info;
+};
+
+void netdev_bonding_info_change(struct net_device *dev,
+                                struct netdev_bonding_info *bonding_info);
+
 static inline
 struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
 {
@@ -3611,8 +3661,6 @@ static inline bool netif_needs_gso(struct net_device *dev, struct sk_buff *skb,
                                    netdev_features_t features)
 {
         return skb_is_gso(skb) && (!skb_gso_ok(skb, features) ||
-                (dev->netdev_ops->ndo_gso_check &&
-                 !dev->netdev_ops->ndo_gso_check(skb, dev)) ||
                 unlikely((skb->ip_summed != CHECKSUM_PARTIAL) &&
                          (skb->ip_summed != CHECKSUM_UNNECESSARY)));
 }
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 9e572daa15d5..02fc86d2348e 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -46,8 +46,8 @@ struct netlink_kernel_cfg {
         unsigned int    flags;
         void            (*input)(struct sk_buff *skb);
         struct mutex    *cb_mutex;
-        int             (*bind)(int group);
-        void            (*unbind)(int group);
+        int             (*bind)(struct net *net, int group);
+        void            (*unbind)(struct net *net, int group);
         bool            (*compare)(struct net *net, struct sock *sk);
 };
 
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 022b761dbf0a..ed43cb74b11d 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -411,6 +411,7 @@ enum lock_type4 {
 #define FATTR4_WORD1_TIME_MODIFY_SET    (1UL << 22)
 #define FATTR4_WORD1_MOUNTED_ON_FILEID  (1UL << 23)
 #define FATTR4_WORD1_FS_LAYOUT_TYPES    (1UL << 30)
+#define FATTR4_WORD2_LAYOUT_TYPES       (1UL << 0)
 #define FATTR4_WORD2_LAYOUT_BLKSIZE     (1UL << 1)
 #define FATTR4_WORD2_MDSTHRESHOLD       (1UL << 4)
 #define FATTR4_WORD2_SECURITY_LABEL     (1UL << 16)
@@ -516,6 +517,8 @@ enum pnfs_layouttype {
         LAYOUT_NFSV4_1_FILES  = 1,
         LAYOUT_OSD2_OBJECTS = 2,
         LAYOUT_BLOCK_VOLUME = 3,
+        LAYOUT_FLEX_FILES = 4,
+        LAYOUT_TYPE_MAX
 };
 
 /* used for both layout return and recall */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 1e37fbb78f7a..5e1273d4de14 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -74,10 +74,9 @@ struct nfs_client {
         /* idmapper */
         struct idmap *          cl_idmap;
 
-        /* Our own IP address, as a null-terminated string.
-         * This is used to generate the mv0 callback address.
-         */
-        char                    cl_ipaddr[48];
+        /* Client owner identifier */
+        const char *            cl_owner_id;
+
         u32                     cl_cb_ident;    /* v4.0 callback identifier */
         const struct nfs4_minor_version_ops *cl_mvops;
         unsigned long           cl_mig_gen;
@@ -105,6 +104,11 @@ struct nfs_client {
 #define NFS_SP4_MACH_CRED_COMMIT   6    /* COMMIT */
 #endif /* CONFIG_NFS_V4 */
 
+        /* Our own IP address, as a null-terminated string.
+         * This is used to generate the mv0 callback address.
+         */
+        char                    cl_ipaddr[48];
+
 #ifdef CONFIG_NFS_FSCACHE
         struct fscache_cookie   *fscache;       /* client index cache cookie */
 #endif
diff --git a/include/linux/nfs_idmap.h b/include/linux/nfs_idmap.h
index 0f4b79da6584..333844e38f66 100644
--- a/include/linux/nfs_idmap.h
+++ b/include/linux/nfs_idmap.h
@@ -73,5 +73,7 @@ int nfs_map_group_to_gid(const struct nfs_server *, const char *, size_t, kgid_t
 int nfs_map_uid_to_name(const struct nfs_server *, kuid_t, char *, size_t);
 int nfs_map_gid_to_group(const struct nfs_server *, kgid_t, char *, size_t);
 
+int nfs_map_string_to_numeric(const char *name, size_t namelen, __u32 *res);
+
 extern unsigned int nfs_idmap_cache_timeout;
 #endif /* NFS_IDMAP_H */
diff --git a/include/linux/nfs_page.h b/include/linux/nfs_page.h
index 6c3e06ee2fb7..3eb072dbce83 100644
--- a/include/linux/nfs_page.h
+++ b/include/linux/nfs_page.h
@@ -58,6 +58,9 @@ struct nfs_pageio_ops {
         size_t  (*pg_test)(struct nfs_pageio_descriptor *, struct nfs_page *,
                            struct nfs_page *);
         int     (*pg_doio)(struct nfs_pageio_descriptor *);
+        unsigned int    (*pg_get_mirror_count)(struct nfs_pageio_descriptor *,
+                                       struct nfs_page *);
+        void    (*pg_cleanup)(struct nfs_pageio_descriptor *);
 };
 
 struct nfs_rw_ops {
@@ -69,18 +72,21 @@ struct nfs_rw_ops {
                         struct inode *);
         void (*rw_result)(struct rpc_task *, struct nfs_pgio_header *);
         void (*rw_initiate)(struct nfs_pgio_header *, struct rpc_message *,
+                            const struct nfs_rpc_ops *,
                             struct rpc_task_setup *, int);
 };
 
-struct nfs_pageio_descriptor {
+struct nfs_pgio_mirror {
         struct list_head        pg_list;
         unsigned long           pg_bytes_written;
         size_t                  pg_count;
         size_t                  pg_bsize;
         unsigned int            pg_base;
-        unsigned char           pg_moreio : 1,
-                                pg_recoalesce : 1;
+        unsigned char           pg_recoalesce : 1;
+};
 
+struct nfs_pageio_descriptor {
+        unsigned char           pg_moreio : 1;
         struct inode            *pg_inode;
         const struct nfs_pageio_ops *pg_ops;
         const struct nfs_rw_ops *pg_rw_ops;
@@ -91,8 +97,18 @@ struct nfs_pageio_descriptor {
         struct pnfs_layout_segment *pg_lseg;
         struct nfs_direct_req   *pg_dreq;
         void                    *pg_layout_private;
+        unsigned int            pg_bsize;       /* default bsize for mirrors */
+
+        u32                     pg_mirror_count;
+        struct nfs_pgio_mirror  *pg_mirrors;
+        struct nfs_pgio_mirror  pg_mirrors_static[1];
+        struct nfs_pgio_mirror  *pg_mirrors_dynamic;
+        u32                     pg_mirror_idx;  /* current mirror */
 };
 
+/* arbitrarily selected limit to number of mirrors */
+#define NFS_PAGEIO_DESCRIPTOR_MIRROR_MAX 16
+
 #define NFS_WBACK_BUSY(req)     (test_bit(PG_BUSY,&(req)->wb_flags))
 
 extern  struct nfs_page *nfs_create_request(struct nfs_open_context *ctx,
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 467c84efb596..38d96ba935c2 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -285,6 +285,7 @@ struct nfs4_layoutcommit_data {
         struct nfs_fattr fattr;
         struct list_head lseg_list;
         struct rpc_cred *cred;
+        struct inode *inode;
         struct nfs4_layoutcommit_args args;
         struct nfs4_layoutcommit_res res;
 };
@@ -293,6 +294,7 @@ struct nfs4_layoutreturn_args {
         struct nfs4_sequence_args seq_args;
         struct pnfs_layout_hdr *layout;
         struct inode *inode;
+        struct pnfs_layout_range range;
         nfs4_stateid stateid;
         __u32   layout_type;
 };
@@ -308,6 +310,7 @@ struct nfs4_layoutreturn {
         struct nfs4_layoutreturn_res res;
         struct rpc_cred *cred;
         struct nfs_client *clp;
+        struct inode *inode;
         int rpc_status;
 };
 
@@ -325,6 +328,7 @@ struct nfs_openargs {
         struct nfs_seqid *      seqid;
         int                     open_flags;
         fmode_t                 fmode;
+        u32                     share_access;
         u32                     access;
         __u64                   clientid;
         struct stateowner_id    id;
@@ -389,9 +393,10 @@ struct nfs_open_confirmres {
 struct nfs_closeargs {
         struct nfs4_sequence_args       seq_args;
         struct nfs_fh *         fh;
-        nfs4_stateid *          stateid;
+        nfs4_stateid            stateid;
         struct nfs_seqid *      seqid;
         fmode_t                 fmode;
+        u32                     share_access;
         const u32 *             bitmask;
 };
 
@@ -416,12 +421,13 @@ struct nfs_lock_args {
         struct nfs_fh *         fh;
         struct file_lock *      fl;
         struct nfs_seqid *      lock_seqid;
-        nfs4_stateid *          lock_stateid;
+        nfs4_stateid            lock_stateid;
         struct nfs_seqid *      open_seqid;
-        nfs4_stateid *          open_stateid;
+        nfs4_stateid            open_stateid;
         struct nfs_lowner       lock_owner;
         unsigned char           block : 1;
         unsigned char           reclaim : 1;
+        unsigned char           new_lock : 1;
         unsigned char           new_lock_owner : 1;
 };
 
@@ -437,7 +443,7 @@ struct nfs_locku_args {
         struct nfs_fh *         fh;
         struct file_lock *      fl;
         struct nfs_seqid *      seqid;
-        nfs4_stateid *          stateid;
+        nfs4_stateid            stateid;
 };
 
 struct nfs_locku_res {
@@ -513,6 +519,7 @@ struct nfs_pgio_res {
         struct nfs4_sequence_res        seq_res;
         struct nfs_fattr *      fattr;
         __u32                   count;
+        __u32                   op_status;
         int                     eof;            /* used by read */
         struct nfs_writeverf *  verf;           /* used by write */
         const struct nfs_server *server;        /* used by write */
@@ -532,6 +539,7 @@ struct nfs_commitargs {
 
 struct nfs_commitres {
         struct nfs4_sequence_res        seq_res;
+        __u32                   op_status;
         struct nfs_fattr        *fattr;
         struct nfs_writeverf    *verf;
         const struct nfs_server *server;
@@ -1325,7 +1333,8 @@ struct nfs_pgio_header {
         __u64                   mds_offset;     /* Filelayout dense stripe */
         struct nfs_page_array   page_array;
         struct nfs_client       *ds_clp;        /* pNFS data server */
-        int                     ds_idx;         /* ds index if ds_clp is set */
+        int                     ds_commit_idx;  /* ds index if ds_clp is set */
+        int                     pgio_mirror_idx;/* mirror index in pgio layer */
 };
 
 struct nfs_mds_commit_info {
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index 83a6aeda899d..6e85889cf9ab 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -8,14 +8,13 @@
  * See detailed comments in the file linux/bitmap.h describing the
  * data type on which these nodemasks are based.
  *
- * For details of nodemask_scnprintf() and nodemask_parse_user(),
- * see bitmap_scnprintf() and bitmap_parse_user() in lib/bitmap.c.
- * For details of nodelist_scnprintf() and nodelist_parse(), see
- * bitmap_scnlistprintf() and bitmap_parselist(), also in bitmap.c.
- * For details of node_remap(), see bitmap_bitremap in lib/bitmap.c.
- * For details of nodes_remap(), see bitmap_remap in lib/bitmap.c.
- * For details of nodes_onto(), see bitmap_onto in lib/bitmap.c.
- * For details of nodes_fold(), see bitmap_fold in lib/bitmap.c.
+ * For details of nodemask_parse_user(), see bitmap_parse_user() in
+ * lib/bitmap.c.  For details of nodelist_parse(), see bitmap_parselist(),
+ * also in bitmap.c.  For details of node_remap(), see bitmap_bitremap in
+ * lib/bitmap.c.  For details of nodes_remap(), see bitmap_remap in
+ * lib/bitmap.c.  For details of nodes_onto(), see bitmap_onto in
+ * lib/bitmap.c.  For details of nodes_fold(), see bitmap_fold in
+ * lib/bitmap.c.
  *
  * The available nodemask operations are:
  *
@@ -52,9 +51,7 @@
  * NODE_MASK_NONE                       Initializer - no bits set
  * unsigned long *nodes_addr(mask)      Array of unsigned long's in mask
  *
- * int nodemask_scnprintf(buf, len, mask) Format nodemask for printing
  * int nodemask_parse_user(ubuf, ulen, mask)    Parse ascii string as nodemask
- * int nodelist_scnprintf(buf, len, mask) Format nodemask as list for printing
  * int nodelist_parse(buf, map)         Parse ascii string as nodelist
  * int node_remap(oldbit, old, new)     newbit = map(old, new)(oldbit)
  * void nodes_remap(dst, src, old, new) *dst = map(old, new)(src)
@@ -98,6 +95,14 @@
 typedef struct { DECLARE_BITMAP(bits, MAX_NUMNODES); } nodemask_t;
 extern nodemask_t _unused_nodemask_arg_;
 
+/**
+ * nodemask_pr_args - printf args to output a nodemask
+ * @maskp: nodemask to be printed
+ *
+ * Can be used to provide arguments for '%*pb[l]' when printing a nodemask.
+ */
+#define nodemask_pr_args(maskp)         MAX_NUMNODES, (maskp)->bits
+
 /*
  * The inline keyword gives the compiler room to decide to inline, or
  * not inline a function as it sees best.  However, as these functions
@@ -120,13 +125,13 @@ static inline void __node_clear(int node, volatile nodemask_t *dstp)
 }
 
 #define nodes_setall(dst) __nodes_setall(&(dst), MAX_NUMNODES)
-static inline void __nodes_setall(nodemask_t *dstp, int nbits)
+static inline void __nodes_setall(nodemask_t *dstp, unsigned int nbits)
 {
         bitmap_fill(dstp->bits, nbits);
 }
 
 #define nodes_clear(dst) __nodes_clear(&(dst), MAX_NUMNODES)
-static inline void __nodes_clear(nodemask_t *dstp, int nbits)
+static inline void __nodes_clear(nodemask_t *dstp, unsigned int nbits)
 {
         bitmap_zero(dstp->bits, nbits);
 }
@@ -144,7 +149,7 @@ static inline int __node_test_and_set(int node, nodemask_t *addr)
 #define nodes_and(dst, src1, src2) \
                         __nodes_and(&(dst), &(src1), &(src2), MAX_NUMNODES)
 static inline void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
@@ -152,7 +157,7 @@ static inline void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
 #define nodes_or(dst, src1, src2) \
                         __nodes_or(&(dst), &(src1), &(src2), MAX_NUMNODES)
 static inline void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
@@ -160,7 +165,7 @@ static inline void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
 #define nodes_xor(dst, src1, src2) \
                         __nodes_xor(&(dst), &(src1), &(src2), MAX_NUMNODES)
 static inline void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
@@ -168,7 +173,7 @@ static inline void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
 #define nodes_andnot(dst, src1, src2) \
                         __nodes_andnot(&(dst), &(src1), &(src2), MAX_NUMNODES)
 static inline void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
 }
@@ -176,7 +181,7 @@ static inline void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
 #define nodes_complement(dst, src) \
                         __nodes_complement(&(dst), &(src), MAX_NUMNODES)
 static inline void __nodes_complement(nodemask_t *dstp,
-                                        const nodemask_t *srcp, int nbits)
+                                        const nodemask_t *srcp, unsigned int nbits)
 {
         bitmap_complement(dstp->bits, srcp->bits, nbits);
 }
@@ -184,7 +189,7 @@ static inline void __nodes_complement(nodemask_t *dstp,
 #define nodes_equal(src1, src2) \
                         __nodes_equal(&(src1), &(src2), MAX_NUMNODES)
 static inline int __nodes_equal(const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         return bitmap_equal(src1p->bits, src2p->bits, nbits);
 }
@@ -192,7 +197,7 @@ static inline int __nodes_equal(const nodemask_t *src1p,
 #define nodes_intersects(src1, src2) \
                         __nodes_intersects(&(src1), &(src2), MAX_NUMNODES)
 static inline int __nodes_intersects(const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         return bitmap_intersects(src1p->bits, src2p->bits, nbits);
 }
@@ -200,25 +205,25 @@ static inline int __nodes_intersects(const nodemask_t *src1p,
 #define nodes_subset(src1, src2) \
                         __nodes_subset(&(src1), &(src2), MAX_NUMNODES)
 static inline int __nodes_subset(const nodemask_t *src1p,
-                                        const nodemask_t *src2p, int nbits)
+                                        const nodemask_t *src2p, unsigned int nbits)
 {
         return bitmap_subset(src1p->bits, src2p->bits, nbits);
 }
 
 #define nodes_empty(src) __nodes_empty(&(src), MAX_NUMNODES)
-static inline int __nodes_empty(const nodemask_t *srcp, int nbits)
+static inline int __nodes_empty(const nodemask_t *srcp, unsigned int nbits)
 {
         return bitmap_empty(srcp->bits, nbits);
 }
 
 #define nodes_full(nodemask) __nodes_full(&(nodemask), MAX_NUMNODES)
-static inline int __nodes_full(const nodemask_t *srcp, int nbits)
+static inline int __nodes_full(const nodemask_t *srcp, unsigned int nbits)
 {
         return bitmap_full(srcp->bits, nbits);
 }
 
 #define nodes_weight(nodemask) __nodes_weight(&(nodemask), MAX_NUMNODES)
-static inline int __nodes_weight(const nodemask_t *srcp, int nbits)
+static inline int __nodes_weight(const nodemask_t *srcp, unsigned int nbits)
 {
         return bitmap_weight(srcp->bits, nbits);
 }
@@ -304,14 +309,6 @@ static inline int __first_unset_node(const nodemask_t *maskp)
 
 #define nodes_addr(src) ((src).bits)
 
-#define nodemask_scnprintf(buf, len, src) \
-                        __nodemask_scnprintf((buf), (len), &(src), MAX_NUMNODES)
-static inline int __nodemask_scnprintf(char *buf, int len,
-                                        const nodemask_t *srcp, int nbits)
-{
-        return bitmap_scnprintf(buf, len, srcp->bits, nbits);
-}
-
 #define nodemask_parse_user(ubuf, ulen, dst) \
                 __nodemask_parse_user((ubuf), (ulen), &(dst), MAX_NUMNODES)
 static inline int __nodemask_parse_user(const char __user *buf, int len,
@@ -320,14 +317,6 @@ static inline int __nodemask_parse_user(const char __user *buf, int len,
         return bitmap_parse_user(buf, len, dstp->bits, nbits);
 }
 
-#define nodelist_scnprintf(buf, len, src) \
-                        __nodelist_scnprintf((buf), (len), &(src), MAX_NUMNODES)
-static inline int __nodelist_scnprintf(char *buf, int len,
-                                        const nodemask_t *srcp, int nbits)
-{
-        return bitmap_scnlistprintf(buf, len, srcp->bits, nbits);
-}
-
 #define nodelist_parse(buf, dst) __nodelist_parse((buf), &(dst), MAX_NUMNODES)
 static inline int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
 {
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 258945fcabf1..19a5d4b23209 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -132,13 +132,12 @@ struct nvme_ns {
  * allocated to store the PRP list.
  */
 struct nvme_iod {
-        void *private;          /* For the use of the submitter of the I/O */
+        unsigned long private;  /* For the use of the submitter of the I/O */
         int npages;             /* In the PRP list. 0 means small pool in use */
         int offset;             /* Of PRP list */
         int nents;              /* Used in scatterlist */
         int length;             /* Of data, in bytes */
         dma_addr_t first_dma;
-        struct list_head node;
         struct scatterlist sg[0];
 };
 
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index 38fc05036015..69dbe312b11b 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -52,6 +52,7 @@ extern int of_get_named_gpio_flags(struct device_node *np,
 
 extern int of_mm_gpiochip_add(struct device_node *np,
                               struct of_mm_gpio_chip *mm_gc);
+extern void of_mm_gpiochip_remove(struct of_mm_gpio_chip *mm_gc);
 
 extern void of_gpiochip_add(struct gpio_chip *gc);
 extern void of_gpiochip_remove(struct gpio_chip *gc);
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 853698c721f7..d5771bed59c9 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -47,6 +47,10 @@ static inline bool oom_task_origin(const struct task_struct *p)
         return !!(p->signal->oom_flags & OOM_FLAG_ORIGIN);
 }
 
+extern void mark_tsk_oom_victim(struct task_struct *tsk);
+
+extern void unmark_oom_victim(void);
+
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
                 unsigned long totalpages);
@@ -68,27 +72,14 @@ extern enum oom_scan_t oom_scan_process_thread(struct task_struct *task,
                 unsigned long totalpages, const nodemask_t *nodemask,
                 bool force_kill);
 
-extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
+extern bool out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                 int order, nodemask_t *mask, bool force_kill);
 extern int register_oom_notifier(struct notifier_block *nb);
 extern int unregister_oom_notifier(struct notifier_block *nb);
 
 extern bool oom_killer_disabled;
-
-static inline void oom_killer_disable(void)
-{
-        oom_killer_disabled = true;
-}
-
-static inline void oom_killer_enable(void)
-{
-        oom_killer_disabled = false;
-}
-
-static inline bool oom_gfp_allowed(gfp_t gfp_mask)
-{
-        return (gfp_mask & __GFP_FS) && !(gfp_mask & __GFP_NORETRY);
-}
+extern bool oom_killer_disable(void);
+extern void oom_killer_enable(void);
 
 extern struct task_struct *find_lock_task_mm(struct task_struct *p);
 
diff --git a/include/linux/osq_lock.h b/include/linux/osq_lock.h
index 90230d5811c5..3a6490e81b28 100644
--- a/include/linux/osq_lock.h
+++ b/include/linux/osq_lock.h
@@ -5,8 +5,11 @@
  * An MCS like lock especially tailored for optimistic spinning for sleeping
  * lock implementations (mutex, rwsem, etc).
  */
-
-#define OSQ_UNLOCKED_VAL (0)
+struct optimistic_spin_node {
+        struct optimistic_spin_node *next, *prev;
+        int locked; /* 1 if lock acquired */
+        int cpu; /* encoded CPU # + 1 value */
+};
 
 struct optimistic_spin_queue {
         /*
@@ -16,6 +19,8 @@ struct optimistic_spin_queue {
         atomic_t tail;
 };
 
+#define OSQ_UNLOCKED_VAL (0)
+
 /* Init macro and function. */
 #define OSQ_LOCK_UNLOCKED { ATOMIC_INIT(OSQ_UNLOCKED_VAL) }
 
@@ -24,4 +29,7 @@ static inline void osq_lock_init(struct optimistic_spin_queue *lock)
         atomic_set(&lock->tail, OSQ_UNLOCKED_VAL);
 }
 
+extern bool osq_lock(struct optimistic_spin_queue *lock);
+extern void osq_unlock(struct optimistic_spin_queue *lock);
+
 #endif
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index e1f5fcd79792..5ed7bdaf22d5 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -121,8 +121,12 @@ enum pageflags {
         PG_fscache = PG_private_2,      /* page backed by cache */
 
         /* XEN */
+        /* Pinned in Xen as a read-only pagetable page. */
         PG_pinned = PG_owner_priv_1,
+        /* Pinned as part of domain save (see xen_mm_pin_all()). */
         PG_savepinned = PG_dirty,
+        /* Has a grant mapping of another (foreign) domain's page. */
+        PG_foreign = PG_owner_priv_1,
 
         /* SLOB */
         PG_slob_free = PG_private,
@@ -215,6 +219,7 @@ __PAGEFLAG(Slab, slab)
 PAGEFLAG(Checked, checked)              /* Used by some filesystems */
 PAGEFLAG(Pinned, pinned) TESTSCFLAG(Pinned, pinned)     /* Xen */
 PAGEFLAG(SavePinned, savepinned);                       /* Xen */
+PAGEFLAG(Foreign, foreign);                             /* Xen */
 PAGEFLAG(Reserved, reserved) __CLEARPAGEFLAG(Reserved, reserved)
 PAGEFLAG(SwapBacked, swapbacked) __CLEARPAGEFLAG(SwapBacked, swapbacked)
         __SETPAGEFLAG(SwapBacked, swapbacked)
diff --git a/include/linux/page_counter.h b/include/linux/page_counter.h
index 955421575d16..17fa4f8de3a6 100644
--- a/include/linux/page_counter.h
+++ b/include/linux/page_counter.h
@@ -41,7 +41,8 @@ int page_counter_try_charge(struct page_counter *counter,
                             struct page_counter **fail);
 void page_counter_uncharge(struct page_counter *counter, unsigned long nr_pages);
 int page_counter_limit(struct page_counter *counter, unsigned long limit);
-int page_counter_memparse(const char *buf, unsigned long *nr_pages);
+int page_counter_memparse(const char *buf, const char *max,
+                          unsigned long *nr_pages);
 
 static inline void page_counter_reset_watermark(struct page_counter *counter)
 {
diff --git a/include/linux/page_ext.h b/include/linux/page_ext.h
index d2a2c84c72d0..c42981cd99aa 100644
--- a/include/linux/page_ext.h
+++ b/include/linux/page_ext.h
@@ -40,7 +40,7 @@ struct page_ext {
 #ifdef CONFIG_PAGE_OWNER
         unsigned int order;
         gfp_t gfp_mask;
-        struct stack_trace trace;
+        unsigned int nr_entries;
         unsigned long trace_entries[8];
 #endif
 };
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 7ea069cd3257..4b3736f7065c 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -251,7 +251,7 @@ pgoff_t page_cache_prev_hole(struct address_space *mapping,
 #define FGP_NOWAIT              0x00000020
 
 struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
-                int fgp_flags, gfp_t cache_gfp_mask, gfp_t radix_gfp_mask);
+                int fgp_flags, gfp_t cache_gfp_mask);
 
 /**
  * find_get_page - find and get a page reference
@@ -266,13 +266,13 @@ struct page *pagecache_get_page(struct address_space *mapping, pgoff_t offset,
 static inline struct page *find_get_page(struct address_space *mapping,
                                         pgoff_t offset)
 {
-        return pagecache_get_page(mapping, offset, 0, 0, 0);
+        return pagecache_get_page(mapping, offset, 0, 0);
 }
 
 static inline struct page *find_get_page_flags(struct address_space *mapping,
                                         pgoff_t offset, int fgp_flags)
 {
-        return pagecache_get_page(mapping, offset, fgp_flags, 0, 0);
+        return pagecache_get_page(mapping, offset, fgp_flags, 0);
 }
 
 /**
@@ -292,7 +292,7 @@ static inline struct page *find_get_page_flags(struct address_space *mapping,
 static inline struct page *find_lock_page(struct address_space *mapping,
                                         pgoff_t offset)
 {
-        return pagecache_get_page(mapping, offset, FGP_LOCK, 0, 0);
+        return pagecache_get_page(mapping, offset, FGP_LOCK, 0);
 }
 
 /**
@@ -319,7 +319,7 @@ static inline struct page *find_or_create_page(struct address_space *mapping,
 {
         return pagecache_get_page(mapping, offset,
                                         FGP_LOCK|FGP_ACCESSED|FGP_CREAT,
-                                        gfp_mask, gfp_mask & GFP_RECLAIM_MASK);
+                                        gfp_mask);
 }
 
 /**
@@ -340,8 +340,7 @@ static inline struct page *grab_cache_page_nowait(struct address_space *mapping,
 {
         return pagecache_get_page(mapping, index,
                         FGP_LOCK|FGP_CREAT|FGP_NOFS|FGP_NOWAIT,
-                        mapping_gfp_mask(mapping),
-                        GFP_NOFS);
+                        mapping_gfp_mask(mapping));
 }
 
 struct page *find_get_entry(struct address_space *mapping, pgoff_t offset);
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 360a966a97a5..211e9da8a7d7 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -29,6 +29,7 @@
 #include <linux/atomic.h>
 #include <linux/device.h>
 #include <linux/io.h>
+#include <linux/resource_ext.h>
 #include <uapi/linux/pci.h>
 
 #include <linux/pci_ids.h>
@@ -175,6 +176,10 @@ enum pci_dev_flags {
         PCI_DEV_FLAGS_DMA_ALIAS_DEVFN = (__force pci_dev_flags_t) (1 << 4),
         /* Use a PCIe-to-PCI bridge alias even if !pci_is_pcie */
         PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS = (__force pci_dev_flags_t) (1 << 5),
+        /* Do not use bus resets for device */
+        PCI_DEV_FLAGS_NO_BUS_RESET = (__force pci_dev_flags_t) (1 << 6),
+        /* Do not use PM reset even if device advertises NoSoftRst- */
+        PCI_DEV_FLAGS_NO_PM_RESET = (__force pci_dev_flags_t) (1 << 7),
 };
 
 enum pci_irq_reroute_variant {
@@ -395,16 +400,10 @@ static inline int pci_channel_offline(struct pci_dev *pdev)
         return (pdev->error_state != pci_channel_io_normal);
 }
 
-struct pci_host_bridge_window {
-        struct list_head list;
-        struct resource *res;           /* host bridge aperture (CPU address) */
-        resource_size_t offset;         /* bus address + offset = CPU address */
-};
-
 struct pci_host_bridge {
         struct device dev;
         struct pci_bus *bus;            /* root bus */
-        struct list_head windows;       /* pci_host_bridge_windows */
+        struct list_head windows;       /* resource_entry */
         void (*release_fn)(struct pci_host_bridge *);
         void *release_data;
 };
@@ -560,6 +559,7 @@ static inline int pcibios_err_to_errno(int err)
 /* Low-level architecture-dependent routines */
 
 struct pci_ops {
+        void __iomem *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);
         int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
         int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
 };
@@ -857,6 +857,16 @@ int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
                               int where, u16 val);
 int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
                                int where, u32 val);
+
+int pci_generic_config_read(struct pci_bus *bus, unsigned int devfn,
+                            int where, int size, u32 *val);
+int pci_generic_config_write(struct pci_bus *bus, unsigned int devfn,
+                            int where, int size, u32 val);
+int pci_generic_config_read32(struct pci_bus *bus, unsigned int devfn,
+                              int where, int size, u32 *val);
+int pci_generic_config_write32(struct pci_bus *bus, unsigned int devfn,
+                               int where, int size, u32 val);
+
 struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
 
 static inline int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val)
@@ -1065,6 +1075,7 @@ resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
 void pci_bus_assign_resources(const struct pci_bus *bus);
 void pci_bus_size_bridges(struct pci_bus *bus);
 int pci_claim_resource(struct pci_dev *, int);
+int pci_claim_bridge_resource(struct pci_dev *bridge, int i);
 void pci_assign_unassigned_resources(void);
 void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
 void pci_assign_unassigned_bus_resources(struct pci_bus *bus);
@@ -1847,6 +1858,8 @@ static inline void pci_set_of_node(struct pci_dev *dev) { }
 static inline void pci_release_of_node(struct pci_dev *dev) { }
 static inline void pci_set_bus_of_node(struct pci_bus *bus) { }
 static inline void pci_release_bus_of_node(struct pci_bus *bus) { }
+static inline struct device_node *
+pci_device_to_OF_node(const struct pci_dev *pdev) { return NULL; }
 #endif  /* CONFIG_OF */
 
 #ifdef CONFIG_EEH
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index b4337646388b..12c9b485beb7 100644
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -128,8 +128,22 @@ static inline void percpu_ref_kill(struct percpu_ref *ref)
 static inline bool __ref_is_percpu(struct percpu_ref *ref,
                                           unsigned long __percpu **percpu_countp)
 {
-        /* paired with smp_store_release() in percpu_ref_reinit() */
-        unsigned long percpu_ptr = lockless_dereference(ref->percpu_count_ptr);
+        unsigned long percpu_ptr;
+
+        /*
+         * The value of @ref->percpu_count_ptr is tested for
+         * !__PERCPU_REF_ATOMIC, which may be set asynchronously, and then
+         * used as a pointer.  If the compiler generates a separate fetch
+         * when using it as a pointer, __PERCPU_REF_ATOMIC may be set in
+         * between contaminating the pointer value, meaning that
+         * ACCESS_ONCE() is required when fetching it.
+         *
+         * Also, we need a data dependency barrier to be paired with
+         * smp_store_release() in __percpu_ref_switch_to_percpu().
+         *
+         * Use lockless deref which contains both.
+         */
+        percpu_ptr = lockless_dereference(ref->percpu_count_ptr);
 
         /*
          * Theoretically, the following could test just ATOMIC; however,
@@ -233,7 +247,7 @@ static inline bool percpu_ref_tryget_live(struct percpu_ref *ref)
         if (__ref_is_percpu(ref, &percpu_count)) {
                 this_cpu_inc(*percpu_count);
                 ret = true;
-        } else if (!(ACCESS_ONCE(ref->percpu_count_ptr) & __PERCPU_REF_DEAD)) {
+        } else if (!(ref->percpu_count_ptr & __PERCPU_REF_DEAD)) {
                 ret = atomic_long_inc_not_zero(&ref->count);
         }
 
@@ -281,6 +295,20 @@ static inline void percpu_ref_put(struct percpu_ref *ref)
 }
 
 /**
+ * percpu_ref_is_dying - test whether a percpu refcount is dying or dead
+ * @ref: percpu_ref to test
+ *
+ * Returns %true if @ref is dying or dead.
+ *
+ * This function is safe to call as long as @ref is between init and exit
+ * and the caller is responsible for synchronizing against state changes.
+ */
+static inline bool percpu_ref_is_dying(struct percpu_ref *ref)
+{
+        return ref->percpu_count_ptr & __PERCPU_REF_DEAD;
+}
+
+/**
  * percpu_ref_is_zero - test whether a percpu refcount reached zero
  * @ref: percpu_ref to test
  *
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 486e84ccb1f9..2b621982938d 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -79,11 +79,6 @@ struct perf_branch_stack {
         struct perf_branch_entry        entries[0];
 };
 
-struct perf_regs {
-        __u64           abi;
-        struct pt_regs  *regs;
-};
-
 struct task_struct;
 
 /*
@@ -207,6 +202,13 @@ struct pmu {
          */
         int (*event_init)               (struct perf_event *event);
 
+        /*
+         * Notification that the event was mapped or unmapped.  Called
+         * in the context of the mapping task.
+         */
+        void (*event_mapped)            (struct perf_event *event); /*optional*/
+        void (*event_unmapped)          (struct perf_event *event); /*optional*/
+
 #define PERF_EF_START   0x01            /* start the counter when adding    */
 #define PERF_EF_RELOAD  0x02            /* reload the counter when starting */
 #define PERF_EF_UPDATE  0x04            /* update the counter when stopping */
@@ -455,11 +457,6 @@ struct perf_event {
 #endif /* CONFIG_PERF_EVENTS */
 };
 
-enum perf_event_context_type {
-        task_context,
-        cpu_context,
-};
-
 /**
  * struct perf_event_context - event context structure
  *
@@ -467,7 +464,6 @@ enum perf_event_context_type {
  */
 struct perf_event_context {
         struct pmu                      *pmu;
-        enum perf_event_context_type    type;
         /*
          * Protect the states of the events in the list,
          * nr_active, and the list:
@@ -480,6 +476,7 @@ struct perf_event_context {
          */
         struct mutex                    mutex;
 
+        struct list_head                active_ctx_list;
         struct list_head                pinned_groups;
         struct list_head                flexible_groups;
         struct list_head                event_list;
@@ -530,7 +527,6 @@ struct perf_cpu_context {
         int                             exclusive;
         struct hrtimer                  hrtimer;
         ktime_t                         hrtimer_interval;
-        struct list_head                rotation_list;
         struct pmu                      *unique_pmu;
         struct perf_cgroup              *cgrp;
 };
@@ -610,7 +606,14 @@ struct perf_sample_data {
                 u32     reserved;
         }                               cpu_entry;
         struct perf_callchain_entry     *callchain;
+
+        /*
+         * regs_user may point to task_pt_regs or to regs_user_copy, depending
+         * on arch details.
+         */
         struct perf_regs                regs_user;
+        struct pt_regs                  regs_user_copy;
+
         struct perf_regs                regs_intr;
         u64                             stack_user_size;
 } ____cacheline_aligned;
@@ -663,6 +666,7 @@ static inline int is_software_event(struct perf_event *event)
 
 extern struct static_key perf_swevent_enabled[PERF_COUNT_SW_MAX];
 
+extern void ___perf_sw_event(u32, u64, struct pt_regs *, u64);
 extern void __perf_sw_event(u32, u64, struct pt_regs *, u64);
 
 #ifndef perf_arch_fetch_caller_regs
@@ -687,14 +691,25 @@ static inline void perf_fetch_caller_regs(struct pt_regs *regs)
 static __always_inline void
 perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)
 {
-        struct pt_regs hot_regs;
+        if (static_key_false(&perf_swevent_enabled[event_id]))
+                __perf_sw_event(event_id, nr, regs, addr);
+}
+
+DECLARE_PER_CPU(struct pt_regs, __perf_regs[4]);
 
+/*
+ * 'Special' version for the scheduler, it hard assumes no recursion,
+ * which is guaranteed by us not actually scheduling inside other swevents
+ * because those disable preemption.
+ */
+static __always_inline void
+perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)
+{
         if (static_key_false(&perf_swevent_enabled[event_id])) {
-                if (!regs) {
-                        perf_fetch_caller_regs(&hot_regs);
-                        regs = &hot_regs;
-                }
-                __perf_sw_event(event_id, nr, regs, addr);
+                struct pt_regs *regs = this_cpu_ptr(&__perf_regs[0]);
+
+                perf_fetch_caller_regs(regs);
+                ___perf_sw_event(event_id, nr, regs, addr);
         }
 }
 
@@ -710,7 +725,7 @@ static inline void perf_event_task_sched_in(struct task_struct *prev,
 static inline void perf_event_task_sched_out(struct task_struct *prev,
                                              struct task_struct *next)
 {
-        perf_sw_event(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, NULL, 0);
+        perf_sw_event_sched(PERF_COUNT_SW_CONTEXT_SWITCHES, 1, 0);
 
         if (static_key_false(&perf_sched_events.key))
                 __perf_event_task_sched_out(prev, next);
@@ -821,6 +836,8 @@ static inline int perf_event_refresh(struct perf_event *event, int refresh)
 static inline void
 perf_sw_event(u32 event_id, u64 nr, struct pt_regs *regs, u64 addr)     { }
 static inline void
+perf_sw_event_sched(u32 event_id, u64 nr, u64 addr)                     { }
+static inline void
 perf_bp_event(struct perf_event *event, void *data)                     { }
 
 static inline int perf_register_guest_info_callbacks
@@ -897,12 +914,22 @@ struct perf_pmu_events_attr {
         const char *event_str;
 };
 
+ssize_t perf_event_sysfs_show(struct device *dev, struct device_attribute *attr,
+                              char *page);
+
 #define PMU_EVENT_ATTR(_name, _var, _id, _show)                         \
 static struct perf_pmu_events_attr _var = {                             \
         .attr = __ATTR(_name, 0444, _show, NULL),                       \
         .id   =  _id,                                                   \
 };
 
+#define PMU_EVENT_ATTR_STRING(_name, _var, _str)                            \
+static struct perf_pmu_events_attr _var = {                                 \
+        .attr           = __ATTR(_name, 0444, perf_event_sysfs_show, NULL), \
+        .id             = 0,                                                \
+        .event_str      = _str,                                             \
+};
+
 #define PMU_FORMAT_ATTR(_name, _format)                                 \
 static ssize_t                                                          \
 _name##_show(struct device *dev,                                        \
diff --git a/include/linux/perf_regs.h b/include/linux/perf_regs.h
index 3c73d5fe18be..a5f98d53d732 100644
--- a/include/linux/perf_regs.h
+++ b/include/linux/perf_regs.h
@@ -1,11 +1,19 @@
 #ifndef _LINUX_PERF_REGS_H
 #define _LINUX_PERF_REGS_H
 
+struct perf_regs {
+        __u64           abi;
+        struct pt_regs  *regs;
+};
+
 #ifdef CONFIG_HAVE_PERF_REGS
 #include <asm/perf_regs.h>
 u64 perf_reg_value(struct pt_regs *regs, int idx);
 int perf_reg_validate(u64 mask);
 u64 perf_reg_abi(struct task_struct *task);
+void perf_get_regs_user(struct perf_regs *regs_user,
+                        struct pt_regs *regs,
+                        struct pt_regs *regs_user_copy);
 #else
 static inline u64 perf_reg_value(struct pt_regs *regs, int idx)
 {
@@ -21,5 +29,13 @@ static inline u64 perf_reg_abi(struct task_struct *task)
 {
         return PERF_SAMPLE_REGS_ABI_NONE;
 }
+
+static inline void perf_get_regs_user(struct perf_regs *regs_user,
+                                      struct pt_regs *regs,
+                                      struct pt_regs *regs_user_copy)
+{
+        regs_user->regs = task_pt_regs(current);
+        regs_user->abi = perf_reg_abi(current);
+}
 #endif /* CONFIG_HAVE_PERF_REGS */
 #endif /* _LINUX_PERF_REGS_H */
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 22af8f8f5802..685809835b5c 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -327,6 +327,8 @@ struct phy_c45_device_ids {
  * c45_ids: 802.3-c45 Device Identifers if is_c45.
  * is_c45:  Set to true if this phy uses clause 45 addressing.
  * is_internal: Set to true if this phy is internal to a MAC.
+ * has_fixups: Set to true if this phy has fixups/quirks.
+ * suspended: Set to true if this phy has been suspended successfully.
  * state: state of the PHY for management purposes
  * dev_flags: Device-specific flags used by the PHY driver.
  * addr: Bus address of PHY
@@ -364,6 +366,7 @@ struct phy_device {
         bool is_c45;
         bool is_internal;
         bool has_fixups;
+        bool suspended;
 
         enum phy_state state;
 
@@ -565,6 +568,15 @@ struct phy_driver {
         void (*write_mmd_indirect)(struct phy_device *dev, int ptrad,
                                    int devnum, int regnum, u32 val);
 
+        /* Get the size and type of the eeprom contained within a plug-in
+         * module */
+        int (*module_info)(struct phy_device *dev,
+                           struct ethtool_modinfo *modinfo);
+
+        /* Get the eeprom information from the plug-in module */
+        int (*module_eeprom)(struct phy_device *dev,
+                             struct ethtool_eeprom *ee, u8 *data);
+
         struct device_driver driver;
 };
 #define to_phy_driver(d) container_of(d, struct phy_driver, driver)
diff --git a/include/linux/phy/omap_control_phy.h b/include/linux/phy/omap_control_phy.h
index e9e6cfbfbb58..eb7d4a135a9e 100644
--- a/include/linux/phy/omap_control_phy.h
+++ b/include/linux/phy/omap_control_phy.h
@@ -66,7 +66,7 @@ enum omap_control_usb_mode {
 #define OMAP_CTRL_PIPE3_PHY_TX_RX_POWEROFF      0x0
 
 #define OMAP_CTRL_PCIE_PCS_MASK                 0xff
-#define OMAP_CTRL_PCIE_PCS_DELAY_COUNT_SHIFT    0x8
+#define OMAP_CTRL_PCIE_PCS_DELAY_COUNT_SHIFT    16
 
 #define OMAP_CTRL_USB2_PHY_PD           BIT(28)
 
@@ -79,7 +79,7 @@ enum omap_control_usb_mode {
 void omap_control_phy_power(struct device *dev, int on);
 void omap_control_usb_set_mode(struct device *dev,
                                enum omap_control_usb_mode mode);
-void omap_control_pcie_pcs(struct device *dev, u8 id, u8 delay);
+void omap_control_pcie_pcs(struct device *dev, u8 delay);
 #else
 
 static inline void omap_control_phy_power(struct device *dev, int on)
@@ -91,7 +91,7 @@ static inline void omap_control_usb_set_mode(struct device *dev,
 {
 }
 
-static inline void omap_control_pcie_pcs(struct device *dev, u8 id, u8 delay)
+static inline void omap_control_pcie_pcs(struct device *dev, u8 delay)
 {
 }
 #endif
diff --git a/include/linux/phy/phy-qcom-ufs.h b/include/linux/phy/phy-qcom-ufs.h
new file mode 100644
index 000000000000..9d18e9f948e9
--- /dev/null
+++ b/include/linux/phy/phy-qcom-ufs.h
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 2013-2015, Linux Foundation. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 and
+ * only version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#ifndef PHY_QCOM_UFS_H_
+#define PHY_QCOM_UFS_H_
+
+#include "phy.h"
+
+/**
+ * ufs_qcom_phy_enable_ref_clk() - Enable the phy
+ * ref clock.
+ * @phy: reference to a generic phy
+ *
+ * returns 0 for success, and non-zero for error.
+ */
+int ufs_qcom_phy_enable_ref_clk(struct phy *phy);
+
+/**
+ * ufs_qcom_phy_disable_ref_clk() - Disable the phy
+ * ref clock.
+ * @phy: reference to a generic phy.
+ */
+void ufs_qcom_phy_disable_ref_clk(struct phy *phy);
+
+/**
+ * ufs_qcom_phy_enable_dev_ref_clk() - Enable the device
+ * ref clock.
+ * @phy: reference to a generic phy.
+ */
+void ufs_qcom_phy_enable_dev_ref_clk(struct phy *phy);
+
+/**
+ * ufs_qcom_phy_disable_dev_ref_clk() - Disable the device
+ * ref clock.
+ * @phy: reference to a generic phy.
+ */
+void ufs_qcom_phy_disable_dev_ref_clk(struct phy *phy);
+
+int ufs_qcom_phy_enable_iface_clk(struct phy *phy);
+void ufs_qcom_phy_disable_iface_clk(struct phy *phy);
+int ufs_qcom_phy_start_serdes(struct phy *phy);
+int ufs_qcom_phy_set_tx_lane_enable(struct phy *phy, u32 tx_lanes);
+int ufs_qcom_phy_calibrate_phy(struct phy *phy, bool is_rate_B);
+int ufs_qcom_phy_is_pcs_ready(struct phy *phy);
+void ufs_qcom_phy_save_controller_version(struct phy *phy,
+                        u8 major, u16 minor, u16 step);
+
+#endif /* PHY_QCOM_UFS_H_ */
diff --git a/include/linux/pinctrl/consumer.h b/include/linux/pinctrl/consumer.h
index 18eccefea06e..72c0415d6c21 100644
--- a/include/linux/pinctrl/consumer.h
+++ b/include/linux/pinctrl/consumer.h
@@ -82,7 +82,7 @@ static inline int pinctrl_gpio_direction_output(unsigned gpio)
 
 static inline struct pinctrl * __must_check pinctrl_get(struct device *dev)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 
 static inline void pinctrl_put(struct pinctrl *p)
@@ -93,7 +93,7 @@ static inline struct pinctrl_state * __must_check pinctrl_lookup_state(
                                                         struct pinctrl *p,
                                                         const char *name)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 
 static inline int pinctrl_select_state(struct pinctrl *p,
@@ -104,7 +104,7 @@ static inline int pinctrl_select_state(struct pinctrl *p,
 
 static inline struct pinctrl * __must_check devm_pinctrl_get(struct device *dev)
 {
-        return NULL;
+        return ERR_PTR(-ENOSYS);
 }
 
 static inline void devm_pinctrl_put(struct pinctrl *p)
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index d578a60eff23..fe65962b264f 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -115,6 +115,18 @@ enum pin_config_param {
         PIN_CONFIG_END = 0x7FFF,
 };
 
+#ifdef CONFIG_DEBUG_FS
+#define PCONFDUMP(a, b, c, d) { .param = a, .display = b, .format = c, \
+                                .has_arg = d }
+
+struct pin_config_item {
+        const enum pin_config_param param;
+        const char * const display;
+        const char * const format;
+        bool has_arg;
+};
+#endif /* CONFIG_DEBUG_FS */
+
 /*
  * Helpful configuration macro to be used in tables etc.
  */
@@ -150,6 +162,12 @@ static inline unsigned long pinconf_to_config_packed(enum pin_config_param param
 struct pinctrl_dev;
 struct pinctrl_map;
 
+struct pinconf_generic_params {
+        const char * const property;
+        enum pin_config_param param;
+        u32 default_value;
+};
+
 int pinconf_generic_dt_subnode_to_map(struct pinctrl_dev *pctldev,
                 struct device_node *np, struct pinctrl_map **map,
                 unsigned *reserved_maps, unsigned *num_maps,
@@ -174,6 +192,17 @@ static inline int pinconf_generic_dt_node_to_map_pin(
                         PIN_MAP_TYPE_CONFIGS_PIN);
 }
 
+static inline int pinconf_generic_dt_node_to_map_all(
+                struct pinctrl_dev *pctldev, struct device_node *np_config,
+                struct pinctrl_map **map, unsigned *num_maps)
+{
+        /*
+         * passing the type as PIN_MAP_TYPE_INVALID causes the underlying parser
+         * to infer the map type from the DT properties used.
+         */
+        return pinconf_generic_dt_node_to_map(pctldev, np_config, map, num_maps,
+                        PIN_MAP_TYPE_INVALID);
+}
 #endif
 
 #endif /* CONFIG_GENERIC_PINCONF */
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index cc8e1aff0e28..66e4697516de 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -24,6 +24,7 @@ struct pinctrl_dev;
 struct pinctrl_map;
 struct pinmux_ops;
 struct pinconf_ops;
+struct pin_config_item;
 struct gpio_chip;
 struct device_node;
 
@@ -117,6 +118,12 @@ struct pinctrl_ops {
  * @confops: pin config operations vtable, if you support pin configuration in
  *      your driver
  * @owner: module providing the pin controller, used for refcounting
+ * @num_custom_params: Number of driver-specific custom parameters to be parsed
+ *      from the hardware description
+ * @custom_params: List of driver_specific custom parameters to be parsed from
+ *      the hardware description
+ * @custom_conf_items: Information how to print @params in debugfs, must be
+ *      the same size as the @custom_params, i.e. @num_custom_params
  */
 struct pinctrl_desc {
         const char *name;
@@ -126,6 +133,11 @@ struct pinctrl_desc {
         const struct pinmux_ops *pmxops;
         const struct pinconf_ops *confops;
         struct module *owner;
+#ifdef CONFIG_GENERIC_PINCONF
+        unsigned int num_custom_params;
+        const struct pinconf_generic_params *custom_params;
+        const struct pin_config_item *custom_conf_items;
+#endif
 };
 
 /* External interface to pin controller */
diff --git a/include/linux/platform_data/cpuidle-exynos.h b/include/linux/platform_data/cpuidle-exynos.h
new file mode 100644
index 000000000000..bfa40e4c5d5f
--- /dev/null
+++ b/include/linux/platform_data/cpuidle-exynos.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ *              http://www.samsung.com
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+*/
+
+#ifndef __CPUIDLE_EXYNOS_H
+#define __CPUIDLE_EXYNOS_H
+
+struct cpuidle_exynos_data {
+        int (*cpu0_enter_aftr)(void);
+        int (*cpu1_powerdown)(void);
+        void (*pre_enter_aftr)(void);
+        void (*post_enter_aftr)(void);
+};
+
+#endif
diff --git a/include/linux/platform_data/ipmmu-vmsa.h b/include/linux/platform_data/ipmmu-vmsa.h
deleted file mode 100644
index 5275b3ac6d37..000000000000
--- a/include/linux/platform_data/ipmmu-vmsa.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * IPMMU VMSA Platform Data
- *
- * Copyright (C) 2014 Renesas Electronics Corporation
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- */
-
-#ifndef __IPMMU_VMSA_H__
-#define __IPMMU_VMSA_H__
-
-struct ipmmu_vmsa_master {
-        const char *name;
-        unsigned int utlb;
-};
-
-struct ipmmu_vmsa_platform_data {
-        const struct ipmmu_vmsa_master *masters;
-        unsigned int num_masters;
-};
-
-#endif /* __IPMMU_VMSA_H__ */
diff --git a/include/linux/platform_data/irda-sa11x0.h b/include/linux/platform_data/irda-sa11x0.h
new file mode 100644
index 000000000000..38f77b5e56cf
--- /dev/null
+++ b/include/linux/platform_data/irda-sa11x0.h
@@ -0,0 +1,20 @@
+/*
+ *  arch/arm/include/asm/mach/irda.h
+ *
+ *  Copyright (C) 2004 Russell King.
+ *
+ * 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 __ASM_ARM_MACH_IRDA_H
+#define __ASM_ARM_MACH_IRDA_H
+
+struct irda_platform_data {
+        int (*startup)(struct device *);
+        void (*shutdown)(struct device *);
+        int (*set_power)(struct device *, unsigned int state);
+        void (*set_speed)(struct device *, unsigned int speed);
+};
+
+#endif
diff --git a/include/linux/platform_data/mmc-omap.h b/include/linux/platform_data/mmc-omap.h
index 5c188f4e9bec..929469291406 100644
--- a/include/linux/platform_data/mmc-omap.h
+++ b/include/linux/platform_data/mmc-omap.h
@@ -31,10 +31,6 @@ struct omap_mmc_platform_data {
         void (*cleanup)(struct device *dev);
         void (*shutdown)(struct device *dev);
 
-        /* To handle board related suspend/resume functionality for MMC */
-        int (*suspend)(struct device *dev, int slot);
-        int (*resume)(struct device *dev, int slot);
-
         /* Return context loss count due to PM states changing */
         int (*get_context_loss_count)(struct device *dev);
 
diff --git a/include/linux/platform_data/regulator-haptic.h b/include/linux/platform_data/regulator-haptic.h
new file mode 100644
index 000000000000..5658e58e0738
--- /dev/null
+++ b/include/linux/platform_data/regulator-haptic.h
@@ -0,0 +1,29 @@
+/*
+ * Regulator Haptic Platform Data
+ *
+ * Copyright (c) 2014 Samsung Electronics Co., Ltd.
+ * Author: Jaewon Kim <jaewon02.kim@samsung.com>
+ * Author: Hyunhee Kim <hyunhee.kim@samsung.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 _REGULATOR_HAPTIC_H
+#define _REGULATOR_HAPTIC_H
+
+/*
+ * struct regulator_haptic_data - Platform device data
+ *
+ * @max_volt: maximum voltage value supplied to the haptic motor.
+ *              <The unit of the voltage is a micro>
+ * @min_volt: minimum voltage value supplied to the haptic motor.
+ *              <The unit of the voltage is a micro>
+ */
+struct regulator_haptic_data {
+        unsigned int max_volt;
+        unsigned int min_volt;
+};
+
+#endif /* _REGULATOR_HAPTIC_H */
diff --git a/include/linux/platform_data/st21nfca.h b/include/linux/platform_data/st21nfca.h
index 5087fff96d86..cc2bdafb0c69 100644
--- a/include/linux/platform_data/st21nfca.h
+++ b/include/linux/platform_data/st21nfca.h
@@ -26,6 +26,8 @@
 struct st21nfca_nfc_platform_data {
         unsigned int gpio_ena;
         unsigned int irq_polarity;
+        bool is_ese_present;
+        bool is_uicc_present;
 };
 
 #endif /* _ST21NFCA_HCI_H_ */
diff --git a/include/linux/platform_data/st21nfcb.h b/include/linux/platform_data/st21nfcb.h
index c3b432f5b63e..b023373d9874 100644
--- a/include/linux/platform_data/st21nfcb.h
+++ b/include/linux/platform_data/st21nfcb.h
@@ -19,8 +19,6 @@
 #ifndef _ST21NFCB_NCI_H_
 #define _ST21NFCB_NCI_H_
 
-#include <linux/i2c.h>
-
 #define ST21NFCB_NCI_DRIVER_NAME "st21nfcb_nci"
 
 struct st21nfcb_nfc_platform_data {
@@ -28,4 +26,4 @@ struct st21nfcb_nfc_platform_data {
         unsigned int irq_polarity;
 };
 
-#endif /* _ST21NFCA_HCI_H_ */
+#endif /* _ST21NFCB_NCI_H_ */
diff --git a/include/linux/platform_data/tpm_stm_st33.h b/include/linux/platform_data/tpm_stm_st33.h
new file mode 100644
index 000000000000..ff75310c0f47
--- /dev/null
+++ b/include/linux/platform_data/tpm_stm_st33.h
@@ -0,0 +1,39 @@
+/*
+ * STMicroelectronics TPM I2C Linux driver for TPM ST33ZP24
+ * Copyright (C) 2009, 2010  STMicroelectronics
+ *
+ * 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, see <http://www.gnu.org/licenses/>.
+ *
+ * STMicroelectronics version 1.2.0, Copyright (C) 2010
+ * STMicroelectronics comes with ABSOLUTELY NO WARRANTY.
+ * This is free software, and you are welcome to redistribute it
+ * under certain conditions.
+ *
+ * @Author: Christophe RICARD tpmsupport@st.com
+ *
+ * @File: stm_st33_tpm.h
+ *
+ * @Date: 09/15/2010
+ */
+#ifndef __STM_ST33_TPM_H__
+#define __STM_ST33_TPM_H__
+
+#define TPM_ST33_I2C                    "st33zp24-i2c"
+#define TPM_ST33_SPI                    "st33zp24-spi"
+
+struct st33zp24_platform_data {
+        int io_lpcpd;
+};
+
+#endif /* __STM_ST33_TPM_H__ */
diff --git a/include/linux/platform_data/vsp1.h b/include/linux/platform_data/vsp1.h
deleted file mode 100644
index 63170e2614b3..000000000000
--- a/include/linux/platform_data/vsp1.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * vsp1.h  --  R-Car VSP1 Platform Data
- *
- * Copyright (C) 2013 Renesas Corporation
- *
- * Contact: Laurent Pinchart (laurent.pinchart@ideasonboard.com)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-#ifndef __PLATFORM_VSP1_H__
-#define __PLATFORM_VSP1_H__
-
-#define VSP1_HAS_LIF            (1 << 0)
-#define VSP1_HAS_LUT            (1 << 1)
-#define VSP1_HAS_SRU            (1 << 2)
-
-struct vsp1_platform_data {
-        unsigned int features;
-        unsigned int rpf_count;
-        unsigned int uds_count;
-        unsigned int wpf_count;
-};
-
-#endif /* __PLATFORM_VSP1_H__ */
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 8b5976364619..e2f1be6dd9dd 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -597,7 +597,7 @@ struct dev_pm_info {
 
 extern void update_pm_runtime_accounting(struct device *dev);
 extern int dev_pm_get_subsys_data(struct device *dev);
-extern int dev_pm_put_subsys_data(struct device *dev);
+extern void dev_pm_put_subsys_data(struct device *dev);
 
 /*
  * Power domains provide callbacks that are executed during system suspend,
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index 6cd20d5e651b..080e778118ba 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -113,8 +113,6 @@ struct generic_pm_domain_data {
         struct pm_domain_data base;
         struct gpd_timing_data td;
         struct notifier_block nb;
-        struct mutex lock;
-        unsigned int refcount;
         int need_restore;
 };
 
@@ -140,7 +138,6 @@ extern int __pm_genpd_name_add_device(const char *domain_name,
 
 extern int pm_genpd_remove_device(struct generic_pm_domain *genpd,
                                   struct device *dev);
-extern void pm_genpd_dev_need_restore(struct device *dev, bool val);
 extern int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                   struct generic_pm_domain *new_subdomain);
 extern int pm_genpd_add_subdomain_names(const char *master_name,
@@ -187,7 +184,6 @@ static inline int pm_genpd_remove_device(struct generic_pm_domain *genpd,
 {
         return -ENOSYS;
 }
-static inline void pm_genpd_dev_need_restore(struct device *dev, bool val) {}
 static inline int pm_genpd_add_subdomain(struct generic_pm_domain *genpd,
                                          struct generic_pm_domain *new_sd)
 {
@@ -271,6 +267,8 @@ typedef struct generic_pm_domain *(*genpd_xlate_t)(struct of_phandle_args *args,
 int __of_genpd_add_provider(struct device_node *np, genpd_xlate_t xlate,
                         void *data);
 void of_genpd_del_provider(struct device_node *np);
+struct generic_pm_domain *of_genpd_get_from_provider(
+                        struct of_phandle_args *genpdspec);
 
 struct generic_pm_domain *__of_genpd_xlate_simple(
                                         struct of_phandle_args *genpdspec,
@@ -288,6 +286,12 @@ static inline int __of_genpd_add_provider(struct device_node *np,
 }
 static inline void of_genpd_del_provider(struct device_node *np) {}
 
+static inline struct generic_pm_domain *of_genpd_get_from_provider(
+                        struct of_phandle_args *genpdspec)
+{
+        return NULL;
+}
+
 #define __of_genpd_xlate_simple         NULL
 #define __of_genpd_xlate_onecell        NULL
 
diff --git a/include/linux/pnp.h b/include/linux/pnp.h
index 195aafc6cd07..6512e9cbc6d5 100644
--- a/include/linux/pnp.h
+++ b/include/linux/pnp.h
@@ -12,6 +12,7 @@
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/mod_devicetable.h>
+#include <linux/console.h>
 
 #define PNP_NAME_LEN            50
 
@@ -309,15 +310,22 @@ struct pnp_fixup {
 #define PNP_DISABLE             0x0004
 #define PNP_CONFIGURABLE        0x0008
 #define PNP_REMOVABLE           0x0010
+#define PNP_CONSOLE             0x0020
 
 #define pnp_can_read(dev)       (((dev)->protocol->get) && \
                                  ((dev)->capabilities & PNP_READ))
 #define pnp_can_write(dev)      (((dev)->protocol->set) && \
                                  ((dev)->capabilities & PNP_WRITE))
-#define pnp_can_disable(dev)    (((dev)->protocol->disable) && \
-                                 ((dev)->capabilities & PNP_DISABLE))
+#define pnp_can_disable(dev)    (((dev)->protocol->disable) &&            \
+                                 ((dev)->capabilities & PNP_DISABLE) &&   \
+                                 (!((dev)->capabilities & PNP_CONSOLE) || \
+                                  console_suspend_enabled))
 #define pnp_can_configure(dev)  ((!(dev)->active) && \
                                  ((dev)->capabilities & PNP_CONFIGURABLE))
+#define pnp_can_suspend(dev)    (((dev)->protocol->suspend) &&            \
+                                 (!((dev)->capabilities & PNP_CONSOLE) || \
+                                  console_suspend_enabled))
+
 
 #ifdef CONFIG_ISAPNP
 extern struct pnp_protocol isapnp_protocol;
diff --git a/include/linux/power/charger-manager.h b/include/linux/power/charger-manager.h
index e97fc656a058..416ebeb6ee1e 100644
--- a/include/linux/power/charger-manager.h
+++ b/include/linux/power/charger-manager.h
@@ -17,6 +17,7 @@
 
 #include <linux/power_supply.h>
 #include <linux/extcon.h>
+#include <linux/alarmtimer.h>
 
 enum data_source {
         CM_BATTERY_PRESENT,
@@ -45,29 +46,6 @@ enum cm_event_types {
 };
 
 /**
- * struct charger_global_desc
- * @rtc_name: the name of RTC used to wake up the system from suspend.
- * @rtc_only_wakeup:
- *      If the system is woken up by waekup-sources other than the RTC or
- *      callbacks, Charger Manager should recognize with
- *      rtc_only_wakeup() returning false.
- *      If the RTC given to CM is the only wakeup reason,
- *      rtc_only_wakeup should return true.
- * @assume_timer_stops_in_suspend:
- *      Assume that the jiffy timer stops in suspend-to-RAM.
- *      When enabled, CM does not rely on jiffies value in
- *      suspend_again and assumes that jiffies value does not
- *      change during suspend.
- */
-struct charger_global_desc {
-        char *rtc_name;
-
-        bool (*rtc_only_wakeup)(void);
-
-        bool assume_timer_stops_in_suspend;
-};
-
-/**
  * struct charger_cable
  * @extcon_name: the name of extcon device.
  * @name: the name of charger cable(external connector).
@@ -266,22 +244,14 @@ struct charger_manager {
         char psy_name_buf[PSY_NAME_MAX + 1];
         struct power_supply charger_psy;
 
-        bool status_save_ext_pwr_inserted;
-        bool status_save_batt;
-
         u64 charging_start_time;
         u64 charging_end_time;
 };
 
 #ifdef CONFIG_CHARGER_MANAGER
-extern int setup_charger_manager(struct charger_global_desc *gd);
-extern bool cm_suspend_again(void);
 extern void cm_notify_event(struct power_supply *psy,
                                 enum cm_event_types type, char *msg);
 #else
-static inline int setup_charger_manager(struct charger_global_desc *gd)
-{ return 0; }
-static inline bool cm_suspend_again(void) { return false; }
 static inline void cm_notify_event(struct power_supply *psy,
                                 enum cm_event_types type, char *msg) { }
 #endif
diff --git a/include/linux/printk.h b/include/linux/printk.h
index c8f170324e64..baa3f97d8ce8 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -10,9 +10,6 @@
 extern const char linux_banner[];
 extern const char linux_proc_banner[];
 
-extern char *log_buf_addr_get(void);
-extern u32 log_buf_len_get(void);
-
 static inline int printk_get_level(const char *buffer)
 {
         if (buffer[0] == KERN_SOH_ASCII && buffer[1]) {
@@ -163,6 +160,8 @@ extern int kptr_restrict;
 
 extern void wake_up_klogd(void);
 
+char *log_buf_addr_get(void);
+u32 log_buf_len_get(void);
 void log_buf_kexec_setup(void);
 void __init setup_log_buf(int early);
 void dump_stack_set_arch_desc(const char *fmt, ...);
@@ -198,6 +197,16 @@ static inline void wake_up_klogd(void)
 {
 }
 
+static inline char *log_buf_addr_get(void)
+{
+        return NULL;
+}
+
+static inline u32 log_buf_len_get(void)
+{
+        return 0;
+}
+
 static inline void log_buf_kexec_setup(void)
 {
 }
@@ -408,9 +417,9 @@ enum {
         DUMP_PREFIX_ADDRESS,
         DUMP_PREFIX_OFFSET
 };
-extern void hex_dump_to_buffer(const void *buf, size_t len,
-                               int rowsize, int groupsize,
-                               char *linebuf, size_t linebuflen, bool ascii);
+extern int hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
+                              int groupsize, char *linebuf, size_t linebuflen,
+                              bool ascii);
 #ifdef CONFIG_PRINTK
 extern void print_hex_dump(const char *level, const char *prefix_str,
                            int prefix_type, int rowsize, int groupsize,
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index ece0c6bbfcc5..8884f6e507f7 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -39,6 +39,7 @@ enum pstore_type_id {
         PSTORE_TYPE_PPC_RTAS    = 4,
         PSTORE_TYPE_PPC_OF      = 5,
         PSTORE_TYPE_PPC_COMMON  = 6,
+        PSTORE_TYPE_PMSG        = 7,
         PSTORE_TYPE_UNKNOWN     = 255
 };
 
diff --git a/include/linux/pstore_ram.h b/include/linux/pstore_ram.h
index 4af3fdc85b01..9c9d6c154c8e 100644
--- a/include/linux/pstore_ram.h
+++ b/include/linux/pstore_ram.h
@@ -81,6 +81,7 @@ struct ramoops_platform_data {
         unsigned long   record_size;
         unsigned long   console_size;
         unsigned long   ftrace_size;
+        unsigned long   pmsg_size;
         int             dump_oops;
         struct persistent_ram_ecc_info ecc_info;
 };
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index 77aed9ea1d26..dab545bb66b3 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -37,6 +37,7 @@
 #define SSDR            (0x10)  /* SSP Data Write/Data Read Register */
 
 #define SSTO            (0x28)  /* SSP Time Out Register */
+#define DDS_RATE        (0x28)  /* SSP DDS Clock Rate Register (Intel Quark) */
 #define SSPSP           (0x2C)  /* SSP Programmable Serial Protocol */
 #define SSTSA           (0x30)  /* SSP Tx Timeslot Active */
 #define SSRSA           (0x34)  /* SSP Rx Timeslot Active */
diff --git a/include/linux/quota.h b/include/linux/quota.h
index 50978b781a19..d534e8ed308a 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -216,19 +216,21 @@ struct mem_dqinfo {
         unsigned long dqi_flags;
         unsigned int dqi_bgrace;
         unsigned int dqi_igrace;
-        qsize_t dqi_maxblimit;
-        qsize_t dqi_maxilimit;
+        qsize_t dqi_max_spc_limit;
+        qsize_t dqi_max_ino_limit;
         void *dqi_priv;
 };
 
 struct super_block;
 
-#define DQF_MASK 0xffff         /* Mask for format specific flags */
-#define DQF_GETINFO_MASK 0x1ffff        /* Mask for flags passed to userspace */
-#define DQF_SETINFO_MASK 0xffff         /* Mask for flags modifiable from userspace */
-#define DQF_SYS_FILE_B          16
-#define DQF_SYS_FILE (1 << DQF_SYS_FILE_B)      /* Quota file stored as system file */
-#define DQF_INFO_DIRTY_B        31
+/* Mask for flags passed to userspace */
+#define DQF_GETINFO_MASK (DQF_ROOT_SQUASH | DQF_SYS_FILE)
+/* Mask for flags modifiable from userspace */
+#define DQF_SETINFO_MASK DQF_ROOT_SQUASH
+
+enum {
+        DQF_INFO_DIRTY_B = DQF_PRIVATE,
+};
 #define DQF_INFO_DIRTY (1 << DQF_INFO_DIRTY_B)  /* Is info dirty? */
 
 extern void mark_info_dirty(struct super_block *sb, int type);
@@ -321,18 +323,61 @@ struct dquot_operations {
 
 struct path;
 
+/* Structure for communicating via ->get_dqblk() & ->set_dqblk() */
+struct qc_dqblk {
+        int d_fieldmask;        /* mask of fields to change in ->set_dqblk() */
+        u64 d_spc_hardlimit;    /* absolute limit on used space */
+        u64 d_spc_softlimit;    /* preferred limit on used space */
+        u64 d_ino_hardlimit;    /* maximum # allocated inodes */
+        u64 d_ino_softlimit;    /* preferred inode limit */
+        u64 d_space;            /* Space owned by the user */
+        u64 d_ino_count;        /* # inodes owned by the user */
+        s64 d_ino_timer;        /* zero if within inode limits */
+                                /* if not, we refuse service */
+        s64 d_spc_timer;        /* similar to above; for space */
+        int d_ino_warns;        /* # warnings issued wrt num inodes */
+        int d_spc_warns;        /* # warnings issued wrt used space */
+        u64 d_rt_spc_hardlimit; /* absolute limit on realtime space */
+        u64 d_rt_spc_softlimit; /* preferred limit on RT space */
+        u64 d_rt_space;         /* realtime space owned */
+        s64 d_rt_spc_timer;     /* similar to above; for RT space */
+        int d_rt_spc_warns;     /* # warnings issued wrt RT space */
+};
+
+/* Field specifiers for ->set_dqblk() in struct qc_dqblk */
+#define QC_INO_SOFT     (1<<0)
+#define QC_INO_HARD     (1<<1)
+#define QC_SPC_SOFT     (1<<2)
+#define QC_SPC_HARD     (1<<3)
+#define QC_RT_SPC_SOFT  (1<<4)
+#define QC_RT_SPC_HARD  (1<<5)
+#define QC_LIMIT_MASK (QC_INO_SOFT | QC_INO_HARD | QC_SPC_SOFT | QC_SPC_HARD | \
+                       QC_RT_SPC_SOFT | QC_RT_SPC_HARD)
+#define QC_SPC_TIMER    (1<<6)
+#define QC_INO_TIMER    (1<<7)
+#define QC_RT_SPC_TIMER (1<<8)
+#define QC_TIMER_MASK (QC_SPC_TIMER | QC_INO_TIMER | QC_RT_SPC_TIMER)
+#define QC_SPC_WARNS    (1<<9)
+#define QC_INO_WARNS    (1<<10)
+#define QC_RT_SPC_WARNS (1<<11)
+#define QC_WARNS_MASK (QC_SPC_WARNS | QC_INO_WARNS | QC_RT_SPC_WARNS)
+#define QC_SPACE        (1<<12)
+#define QC_INO_COUNT    (1<<13)
+#define QC_RT_SPACE     (1<<14)
+#define QC_ACCT_MASK (QC_SPACE | QC_INO_COUNT | QC_RT_SPACE)
+
 /* Operations handling requests from userspace */
 struct quotactl_ops {
         int (*quota_on)(struct super_block *, int, int, struct path *);
-        int (*quota_on_meta)(struct super_block *, int, int);
         int (*quota_off)(struct super_block *, int);
+        int (*quota_enable)(struct super_block *, unsigned int);
+        int (*quota_disable)(struct super_block *, unsigned int);
         int (*quota_sync)(struct super_block *, int);
         int (*get_info)(struct super_block *, int, struct if_dqinfo *);
         int (*set_info)(struct super_block *, int, struct if_dqinfo *);
-        int (*get_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *);
-        int (*set_dqblk)(struct super_block *, struct kqid, struct fs_disk_quota *);
+        int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
+        int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
         int (*get_xstate)(struct super_block *, struct fs_quota_stat *);
-        int (*set_xstate)(struct super_block *, unsigned int, int);
         int (*get_xstatev)(struct super_block *, struct fs_quota_statv *);
         int (*rm_xquota)(struct super_block *, unsigned int);
 };
diff --git a/include/linux/quotaops.h b/include/linux/quotaops.h
index f23538a6e411..df73258cca47 100644
--- a/include/linux/quotaops.h
+++ b/include/linux/quotaops.h
@@ -98,9 +98,9 @@ int dquot_quota_sync(struct super_block *sb, int type);
 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
 int dquot_get_dqblk(struct super_block *sb, struct kqid id,
-                struct fs_disk_quota *di);
+                struct qc_dqblk *di);
 int dquot_set_dqblk(struct super_block *sb, struct kqid id,
-                struct fs_disk_quota *di);
+                struct qc_dqblk *di);
 
 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
 int dquot_transfer(struct inode *inode, struct iattr *iattr);
@@ -166,6 +166,7 @@ static inline bool sb_has_quota_active(struct super_block *sb, int type)
  */
 extern const struct dquot_operations dquot_operations;
 extern const struct quotactl_ops dquot_quotactl_ops;
+extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
 
 #else
 
@@ -386,4 +387,6 @@ static inline void dquot_release_reservation_block(struct inode *inode,
         __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
 }
 
+unsigned int qtype_enforce_flag(int type);
+
 #endif /* _LINUX_QUOTAOPS_ */
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 529bc946f450..a18b16f1dc0e 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -524,11 +524,11 @@ static inline void hlist_add_behind_rcu(struct hlist_node *n,
  * @member:     the name of the hlist_node within the struct.
  */
 #define hlist_for_each_entry_continue_rcu(pos, member)                  \
-        for (pos = hlist_entry_safe(rcu_dereference((pos)->member.next),\
-                        typeof(*(pos)), member);                        \
+        for (pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
+                        &(pos)->member)), typeof(*(pos)), member);      \
              pos;                                                       \
-             pos = hlist_entry_safe(rcu_dereference((pos)->member.next),\
-                        typeof(*(pos)), member))
+             pos = hlist_entry_safe(rcu_dereference_raw(hlist_next_rcu( \
+                        &(pos)->member)), typeof(*(pos)), member))
 
 /**
  * hlist_for_each_entry_continue_rcu_bh - iterate over a hlist continuing after current point
@@ -536,11 +536,11 @@ static inline void hlist_add_behind_rcu(struct hlist_node *n,
  * @member:     the name of the hlist_node within the struct.
  */
 #define hlist_for_each_entry_continue_rcu_bh(pos, member)               \
-        for (pos = hlist_entry_safe(rcu_dereference_bh((pos)->member.next),\
-                        typeof(*(pos)), member);                        \
+        for (pos = hlist_entry_safe(rcu_dereference_bh(hlist_next_rcu(  \
+                        &(pos)->member)), typeof(*(pos)), member);      \
              pos;                                                       \
-             pos = hlist_entry_safe(rcu_dereference_bh((pos)->member.next),\
-                        typeof(*(pos)), member))
+             pos = hlist_entry_safe(rcu_dereference_bh(hlist_next_rcu(  \
+                        &(pos)->member)), typeof(*(pos)), member))
 
 /**
  * hlist_for_each_entry_from_rcu - iterate over a hlist continuing from current point
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index ed4f5939a452..78097491cd99 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -331,12 +331,13 @@ static inline void rcu_init_nohz(void)
 extern struct srcu_struct tasks_rcu_exit_srcu;
 #define rcu_note_voluntary_context_switch(t) \
         do { \
+                rcu_all_qs(); \
                 if (ACCESS_ONCE((t)->rcu_tasks_holdout)) \
                         ACCESS_ONCE((t)->rcu_tasks_holdout) = false; \
         } while (0)
 #else /* #ifdef CONFIG_TASKS_RCU */
 #define TASKS_RCU(x) do { } while (0)
-#define rcu_note_voluntary_context_switch(t)    do { } while (0)
+#define rcu_note_voluntary_context_switch(t)    rcu_all_qs()
 #endif /* #else #ifdef CONFIG_TASKS_RCU */
 
 /**
@@ -582,11 +583,11 @@ static inline void rcu_preempt_sleep_check(void)
 })
 #define __rcu_dereference_check(p, c, space) \
 ({ \
-        typeof(*p) *_________p1 = (typeof(*p) *__force)ACCESS_ONCE(p); \
+        /* Dependency order vs. p above. */ \
+        typeof(*p) *________p1 = (typeof(*p) *__force)lockless_dereference(p); \
         rcu_lockdep_assert(c, "suspicious rcu_dereference_check() usage"); \
         rcu_dereference_sparse(p, space); \
-        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
-        ((typeof(*p) __force __kernel *)(_________p1)); \
+        ((typeof(*p) __force __kernel *)(________p1)); \
 })
 #define __rcu_dereference_protected(p, c, space) \
 ({ \
@@ -603,10 +604,10 @@ static inline void rcu_preempt_sleep_check(void)
 })
 #define __rcu_dereference_index_check(p, c) \
 ({ \
-        typeof(p) _________p1 = ACCESS_ONCE(p); \
+        /* Dependency order vs. p above. */ \
+        typeof(p) _________p1 = lockless_dereference(p); \
         rcu_lockdep_assert(c, \
                            "suspicious rcu_dereference_index_check() usage"); \
-        smp_read_barrier_depends(); /* Dependency order vs. p above. */ \
         (_________p1); \
 })
 
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 0e5366200154..937edaeb150d 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -92,17 +92,49 @@ static inline void rcu_virt_note_context_switch(int cpu)
 }
 
 /*
- * Return the number of grace periods.
+ * Return the number of grace periods started.
  */
-static inline long rcu_batches_completed(void)
+static inline unsigned long rcu_batches_started(void)
 {
         return 0;
 }
 
 /*
- * Return the number of bottom-half grace periods.
+ * Return the number of bottom-half grace periods started.
  */
-static inline long rcu_batches_completed_bh(void)
+static inline unsigned long rcu_batches_started_bh(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of sched grace periods started.
+ */
+static inline unsigned long rcu_batches_started_sched(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of bottom-half grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed_bh(void)
+{
+        return 0;
+}
+
+/*
+ * Return the number of sched grace periods completed.
+ */
+static inline unsigned long rcu_batches_completed_sched(void)
 {
         return 0;
 }
@@ -154,7 +186,10 @@ static inline bool rcu_is_watching(void)
         return true;
 }
 
-
 #endif /* #else defined(CONFIG_DEBUG_LOCK_ALLOC) || defined(CONFIG_RCU_TRACE) */
 
+static inline void rcu_all_qs(void)
+{
+}
+
 #endif /* __LINUX_RCUTINY_H */
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 52953790dcca..d2e583a6aaca 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -81,9 +81,12 @@ void cond_synchronize_rcu(unsigned long oldstate);
 
 extern unsigned long rcutorture_testseq;
 extern unsigned long rcutorture_vernum;
-long rcu_batches_completed(void);
-long rcu_batches_completed_bh(void);
-long rcu_batches_completed_sched(void);
+unsigned long rcu_batches_started(void);
+unsigned long rcu_batches_started_bh(void);
+unsigned long rcu_batches_started_sched(void);
+unsigned long rcu_batches_completed(void);
+unsigned long rcu_batches_completed_bh(void);
+unsigned long rcu_batches_completed_sched(void);
 void show_rcu_gp_kthreads(void);
 
 void rcu_force_quiescent_state(void);
@@ -97,4 +100,6 @@ extern int rcu_scheduler_active __read_mostly;
 
 bool rcu_is_watching(void);
 
+void rcu_all_qs(void);
+
 #endif /* __LINUX_RCUTREE_H */
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 4419b99d8d6e..116655d92269 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -468,7 +468,7 @@ bool regmap_reg_in_ranges(unsigned int reg,
  *
  * @reg: Offset of the register within the regmap bank
  * @lsb: lsb of the register field.
- * @reg: msb of the register field.
+ * @msb: msb of the register field.
  * @id_size: port size if it has some ports
  * @id_offset: address offset for each ports
  */
diff --git a/include/linux/regulator/da9211.h b/include/linux/regulator/da9211.h
index 5479394fefce..5dd65acc2a69 100644
--- a/include/linux/regulator/da9211.h
+++ b/include/linux/regulator/da9211.h
@@ -32,6 +32,8 @@ struct da9211_pdata {
          * 2 : 2 phase 2 buck
          */
         int num_buck;
+        int gpio_ren[DA9211_MAX_REGULATORS];
+        struct device_node *reg_node[DA9211_MAX_REGULATORS];
         struct regulator_init_data *init_data[DA9211_MAX_REGULATORS];
 };
 #endif
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 5f1e9ca47417..d4ad5b5a02bb 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -21,6 +21,7 @@
 
 struct regmap;
 struct regulator_dev;
+struct regulator_config;
 struct regulator_init_data;
 struct regulator_enable_gpio;
 
@@ -205,6 +206,15 @@ enum regulator_type {
  * @supply_name: Identifying the regulator supply
  * @of_match: Name used to identify regulator in DT.
  * @regulators_node: Name of node containing regulator definitions in DT.
+ * @of_parse_cb: Optional callback called only if of_match is present.
+ *               Will be called for each regulator parsed from DT, during
+ *               init_data parsing.
+ *               The regulator_config passed as argument to the callback will
+ *               be a copy of config passed to regulator_register, valid only
+ *               for this particular call. Callback may freely change the
+ *               config but it cannot store it for later usage.
+ *               Callback should return 0 on success or negative ERRNO
+ *               indicating failure.
  * @id: Numerical identifier for the regulator.
  * @ops: Regulator operations table.
  * @irq: Interrupt number for the regulator.
@@ -251,6 +261,9 @@ struct regulator_desc {
         const char *supply_name;
         const char *of_match;
         const char *regulators_node;
+        int (*of_parse_cb)(struct device_node *,
+                            const struct regulator_desc *,
+                            struct regulator_config *);
         int id;
         bool continuous_voltage_range;
         unsigned n_voltages;
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 0b08d05d470b..b07562e082c4 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -191,15 +191,22 @@ struct regulator_init_data {
         void *driver_data;      /* core does not touch this */
 };
 
-int regulator_suspend_prepare(suspend_state_t state);
-int regulator_suspend_finish(void);
-
 #ifdef CONFIG_REGULATOR
 void regulator_has_full_constraints(void);
+int regulator_suspend_prepare(suspend_state_t state);
+int regulator_suspend_finish(void);
 #else
 static inline void regulator_has_full_constraints(void)
 {
 }
+static inline int regulator_suspend_prepare(suspend_state_t state)
+{
+        return 0;
+}
+static inline int regulator_suspend_finish(void)
+{
+        return 0;
+}
 #endif
 
 #endif
diff --git a/include/linux/regulator/mt6397-regulator.h b/include/linux/regulator/mt6397-regulator.h
new file mode 100644
index 000000000000..30cc5963e265
--- /dev/null
+++ b/include/linux/regulator/mt6397-regulator.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2014 MediaTek Inc.
+ * Author: Flora Fu <flora.fu@mediatek.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_REGULATOR_MT6397_H
+#define __LINUX_REGULATOR_MT6397_H
+
+enum {
+        MT6397_ID_VPCA15 = 0,
+        MT6397_ID_VPCA7,
+        MT6397_ID_VSRAMCA15,
+        MT6397_ID_VSRAMCA7,
+        MT6397_ID_VCORE,
+        MT6397_ID_VGPU,
+        MT6397_ID_VDRM,
+        MT6397_ID_VIO18 = 7,
+        MT6397_ID_VTCXO,
+        MT6397_ID_VA28,
+        MT6397_ID_VCAMA,
+        MT6397_ID_VIO28,
+        MT6397_ID_VUSB,
+        MT6397_ID_VMC,
+        MT6397_ID_VMCH,
+        MT6397_ID_VEMC3V3,
+        MT6397_ID_VGP1,
+        MT6397_ID_VGP2,
+        MT6397_ID_VGP3,
+        MT6397_ID_VGP4,
+        MT6397_ID_VGP5,
+        MT6397_ID_VGP6,
+        MT6397_ID_VIBR,
+        MT6397_ID_RG_MAX,
+};
+
+#define MT6397_MAX_REGULATOR    MT6397_ID_RG_MAX
+#define MT6397_REGULATOR_ID97   0x97
+#define MT6397_REGULATOR_ID91   0x91
+
+#endif /* __LINUX_REGULATOR_MT6397_H */
diff --git a/include/linux/regulator/pfuze100.h b/include/linux/regulator/pfuze100.h
index 364f7a7c43db..70c6c66c5bcf 100644
--- a/include/linux/regulator/pfuze100.h
+++ b/include/linux/regulator/pfuze100.h
@@ -49,6 +49,20 @@
 #define PFUZE200_VGEN5          11
 #define PFUZE200_VGEN6          12
 
+#define PFUZE3000_SW1A          0
+#define PFUZE3000_SW1B          1
+#define PFUZE3000_SW2           2
+#define PFUZE3000_SW3           3
+#define PFUZE3000_SWBST         4
+#define PFUZE3000_VSNVS         5
+#define PFUZE3000_VREFDDR       6
+#define PFUZE3000_VLDO1         7
+#define PFUZE3000_VLDO2         8
+#define PFUZE3000_VCCSD         9
+#define PFUZE3000_V33           10
+#define PFUZE3000_VLDO3         11
+#define PFUZE3000_VLDO4         12
+
 struct regulator_init_data;
 
 struct pfuze_regulator_platform_data {
diff --git a/include/linux/resource_ext.h b/include/linux/resource_ext.h
new file mode 100644
index 000000000000..e2bf63d881d4
--- /dev/null
+++ b/include/linux/resource_ext.h
@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2015, Intel Corporation
+ * Author: Jiang Liu <jiang.liu@linux.intel.com>
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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.
+ */
+#ifndef _LINUX_RESOURCE_EXT_H
+#define _LINUX_RESOURCE_EXT_H
+#include <linux/types.h>
+#include <linux/list.h>
+#include <linux/ioport.h>
+#include <linux/slab.h>
+
+/* Represent resource window for bridge devices */
+struct resource_win {
+        struct resource res;            /* In master (CPU) address space */
+        resource_size_t offset;         /* Translation offset for bridge */
+};
+
+/*
+ * Common resource list management data structure and interfaces to support
+ * ACPI, PNP and PCI host bridge etc.
+ */
+struct resource_entry {
+        struct list_head        node;
+        struct resource         *res;   /* In master (CPU) address space */
+        resource_size_t         offset; /* Translation offset for bridge */
+        struct resource         __res;  /* Default storage for res */
+};
+
+extern struct resource_entry *
+resource_list_create_entry(struct resource *res, size_t extra_size);
+extern void resource_list_free(struct list_head *head);
+
+static inline void resource_list_add(struct resource_entry *entry,
+                                     struct list_head *head)
+{
+        list_add(&entry->node, head);
+}
+
+static inline void resource_list_add_tail(struct resource_entry *entry,
+                                          struct list_head *head)
+{
+        list_add_tail(&entry->node, head);
+}
+
+static inline void resource_list_del(struct resource_entry *entry)
+{
+        list_del(&entry->node);
+}
+
+static inline void resource_list_free_entry(struct resource_entry *entry)
+{
+        kfree(entry);
+}
+
+static inline void
+resource_list_destroy_entry(struct resource_entry *entry)
+{
+        resource_list_del(entry);
+        resource_list_free_entry(entry);
+}
+
+#define resource_list_for_each_entry(entry, list)       \
+        list_for_each_entry((entry), (list), node)
+
+#define resource_list_for_each_entry_safe(entry, tmp, list)     \
+        list_for_each_entry_safe((entry), (tmp), (list), node)
+
+#endif /* _LINUX_RESOURCE_EXT_H */
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index b93fd89b2e5e..58851275fed9 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -18,16 +18,45 @@
 #ifndef _LINUX_RHASHTABLE_H
 #define _LINUX_RHASHTABLE_H
 
-#include <linux/rculist.h>
+#include <linux/compiler.h>
+#include <linux/list_nulls.h>
+#include <linux/workqueue.h>
+#include <linux/mutex.h>
+
+/*
+ * The end of the chain is marked with a special nulls marks which has
+ * the following format:
+ *
+ * +-------+-----------------------------------------------------+-+
+ * | Base  |                      Hash                           |1|
+ * +-------+-----------------------------------------------------+-+
+ *
+ * Base (4 bits) : Reserved to distinguish between multiple tables.
+ *                 Specified via &struct rhashtable_params.nulls_base.
+ * Hash (27 bits): Full hash (unmasked) of first element added to bucket
+ * 1 (1 bit)     : Nulls marker (always set)
+ *
+ * The remaining bits of the next pointer remain unused for now.
+ */
+#define RHT_BASE_BITS           4
+#define RHT_HASH_BITS           27
+#define RHT_BASE_SHIFT          RHT_HASH_BITS
 
 struct rhash_head {
         struct rhash_head __rcu         *next;
 };
 
-#define INIT_HASH_HEAD(ptr) ((ptr)->next = NULL)
-
+/**
+ * struct bucket_table - Table of hash buckets
+ * @size: Number of hash buckets
+ * @locks_mask: Mask to apply before accessing locks[]
+ * @locks: Array of spinlocks protecting individual buckets
+ * @buckets: size * hash buckets
+ */
 struct bucket_table {
         size_t                          size;
+        unsigned int                    locks_mask;
+        spinlock_t                      *locks;
         struct rhash_head __rcu         *buckets[];
 };
 
@@ -45,11 +74,16 @@ struct rhashtable;
  * @hash_rnd: Seed to use while hashing
  * @max_shift: Maximum number of shifts while expanding
  * @min_shift: Minimum number of shifts while shrinking
+ * @nulls_base: Base value to generate nulls marker
+ * @locks_mul: Number of bucket locks to allocate per cpu (default: 128)
  * @hashfn: Function to hash key
  * @obj_hashfn: Function to hash object
  * @grow_decision: If defined, may return true if table should expand
  * @shrink_decision: If defined, may return true if table should shrink
- * @mutex_is_held: Must return true if protecting mutex is held
+ *
+ * Note: when implementing the grow and shrink decision function, min/max
+ * shift must be enforced, otherwise, resizing watermarks they set may be
+ * useless.
  */
 struct rhashtable_params {
         size_t                  nelem_hint;
@@ -59,36 +93,95 @@ struct rhashtable_params {
         u32                     hash_rnd;
         size_t                  max_shift;
         size_t                  min_shift;
+        u32                     nulls_base;
+        size_t                  locks_mul;
         rht_hashfn_t            hashfn;
         rht_obj_hashfn_t        obj_hashfn;
         bool                    (*grow_decision)(const struct rhashtable *ht,
                                                  size_t new_size);
         bool                    (*shrink_decision)(const struct rhashtable *ht,
                                                    size_t new_size);
-#ifdef CONFIG_PROVE_LOCKING
-        int                     (*mutex_is_held)(void *parent);
-        void                    *parent;
-#endif
 };
 
 /**
  * struct rhashtable - Hash table handle
  * @tbl: Bucket table
+ * @future_tbl: Table under construction during expansion/shrinking
  * @nelems: Number of elements in table
  * @shift: Current size (1 << shift)
  * @p: Configuration parameters
+ * @run_work: Deferred worker to expand/shrink asynchronously
+ * @mutex: Mutex to protect current/future table swapping
+ * @walkers: List of active walkers
+ * @being_destroyed: True if table is set up for destruction
  */
 struct rhashtable {
         struct bucket_table __rcu       *tbl;
-        size_t                          nelems;
-        size_t                          shift;
+        struct bucket_table __rcu       *future_tbl;
+        atomic_t                        nelems;
+        atomic_t                        shift;
         struct rhashtable_params        p;
+        struct work_struct              run_work;
+        struct mutex                    mutex;
+        struct list_head                walkers;
+        bool                            being_destroyed;
+};
+
+/**
+ * struct rhashtable_walker - Hash table walker
+ * @list: List entry on list of walkers
+ * @resize: Resize event occured
+ */
+struct rhashtable_walker {
+        struct list_head list;
+        bool resize;
 };
 
+/**
+ * struct rhashtable_iter - Hash table iterator, fits into netlink cb
+ * @ht: Table to iterate through
+ * @p: Current pointer
+ * @walker: Associated rhashtable walker
+ * @slot: Current slot
+ * @skip: Number of entries to skip in slot
+ */
+struct rhashtable_iter {
+        struct rhashtable *ht;
+        struct rhash_head *p;
+        struct rhashtable_walker *walker;
+        unsigned int slot;
+        unsigned int skip;
+};
+
+static inline unsigned long rht_marker(const struct rhashtable *ht, u32 hash)
+{
+        return NULLS_MARKER(ht->p.nulls_base + hash);
+}
+
+#define INIT_RHT_NULLS_HEAD(ptr, ht, hash) \
+        ((ptr) = (typeof(ptr)) rht_marker(ht, hash))
+
+static inline bool rht_is_a_nulls(const struct rhash_head *ptr)
+{
+        return ((unsigned long) ptr & 1);
+}
+
+static inline unsigned long rht_get_nulls_value(const struct rhash_head *ptr)
+{
+        return ((unsigned long) ptr) >> 1;
+}
+
 #ifdef CONFIG_PROVE_LOCKING
-int lockdep_rht_mutex_is_held(const struct rhashtable *ht);
+int lockdep_rht_mutex_is_held(struct rhashtable *ht);
+int lockdep_rht_bucket_is_held(const struct bucket_table *tbl, u32 hash);
 #else
-static inline int lockdep_rht_mutex_is_held(const struct rhashtable *ht)
+static inline int lockdep_rht_mutex_is_held(struct rhashtable *ht)
+{
+        return 1;
+}
+
+static inline int lockdep_rht_bucket_is_held(const struct bucket_table *tbl,
+                                             u32 hash)
 {
         return 1;
 }
@@ -96,13 +189,8 @@ static inline int lockdep_rht_mutex_is_held(const struct rhashtable *ht)
 
 int rhashtable_init(struct rhashtable *ht, struct rhashtable_params *params);
 
-u32 rhashtable_hashfn(const struct rhashtable *ht, const void *key, u32 len);
-u32 rhashtable_obj_hashfn(const struct rhashtable *ht, void *ptr);
-
 void rhashtable_insert(struct rhashtable *ht, struct rhash_head *node);
 bool rhashtable_remove(struct rhashtable *ht, struct rhash_head *node);
-void rhashtable_remove_pprev(struct rhashtable *ht, struct rhash_head *obj,
-                             struct rhash_head __rcu **pprev);
 
 bool rht_grow_above_75(const struct rhashtable *ht, size_t new_size);
 bool rht_shrink_below_30(const struct rhashtable *ht, size_t new_size);
@@ -110,11 +198,23 @@ bool rht_shrink_below_30(const struct rhashtable *ht, size_t new_size);
 int rhashtable_expand(struct rhashtable *ht);
 int rhashtable_shrink(struct rhashtable *ht);
 
-void *rhashtable_lookup(const struct rhashtable *ht, const void *key);
-void *rhashtable_lookup_compare(const struct rhashtable *ht, u32 hash,
+void *rhashtable_lookup(struct rhashtable *ht, const void *key);
+void *rhashtable_lookup_compare(struct rhashtable *ht, const void *key,
                                 bool (*compare)(void *, void *), void *arg);
 
-void rhashtable_destroy(const struct rhashtable *ht);
+bool rhashtable_lookup_insert(struct rhashtable *ht, struct rhash_head *obj);
+bool rhashtable_lookup_compare_insert(struct rhashtable *ht,
+                                      struct rhash_head *obj,
+                                      bool (*compare)(void *, void *),
+                                      void *arg);
+
+int rhashtable_walk_init(struct rhashtable *ht, struct rhashtable_iter *iter);
+void rhashtable_walk_exit(struct rhashtable_iter *iter);
+int rhashtable_walk_start(struct rhashtable_iter *iter) __acquires(RCU);
+void *rhashtable_walk_next(struct rhashtable_iter *iter);
+void rhashtable_walk_stop(struct rhashtable_iter *iter) __releases(RCU);
+
+void rhashtable_destroy(struct rhashtable *ht);
 
 #define rht_dereference(p, ht) \
         rcu_dereference_protected(p, lockdep_rht_mutex_is_held(ht))
@@ -122,92 +222,146 @@ void rhashtable_destroy(const struct rhashtable *ht);
 #define rht_dereference_rcu(p, ht) \
         rcu_dereference_check(p, lockdep_rht_mutex_is_held(ht))
 
-#define rht_entry(ptr, type, member) container_of(ptr, type, member)
-#define rht_entry_safe(ptr, type, member) \
-({ \
-        typeof(ptr) __ptr = (ptr); \
-           __ptr ? rht_entry(__ptr, type, member) : NULL; \
-})
+#define rht_dereference_bucket(p, tbl, hash) \
+        rcu_dereference_protected(p, lockdep_rht_bucket_is_held(tbl, hash))
+
+#define rht_dereference_bucket_rcu(p, tbl, hash) \
+        rcu_dereference_check(p, lockdep_rht_bucket_is_held(tbl, hash))
 
-#define rht_next_entry_safe(pos, ht, member) \
-({ \
-        pos ? rht_entry_safe(rht_dereference((pos)->member.next, ht), \
-                             typeof(*(pos)), member) : NULL; \
-})
+#define rht_entry(tpos, pos, member) \
+        ({ tpos = container_of(pos, typeof(*tpos), member); 1; })
+
+/**
+ * rht_for_each_continue - continue iterating over hash chain
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @head:       the previous &struct rhash_head to continue from
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ */
+#define rht_for_each_continue(pos, head, tbl, hash) \
+        for (pos = rht_dereference_bucket(head, tbl, hash); \
+             !rht_is_a_nulls(pos); \
+             pos = rht_dereference_bucket((pos)->next, tbl, hash))
 
 /**
  * rht_for_each - iterate over hash chain
- * @pos:        &struct rhash_head to use as a loop cursor.
- * @head:       head of the hash chain (struct rhash_head *)
- * @ht:         pointer to your struct rhashtable
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
  */
-#define rht_for_each(pos, head, ht) \
-        for (pos = rht_dereference(head, ht); \
-             pos; \
-             pos = rht_dereference((pos)->next, ht))
+#define rht_for_each(pos, tbl, hash) \
+        rht_for_each_continue(pos, (tbl)->buckets[hash], tbl, hash)
+
+/**
+ * rht_for_each_entry_continue - continue iterating over hash chain
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @head:       the previous &struct rhash_head to continue from
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ * @member:     name of the &struct rhash_head within the hashable struct.
+ */
+#define rht_for_each_entry_continue(tpos, pos, head, tbl, hash, member) \
+        for (pos = rht_dereference_bucket(head, tbl, hash);             \
+             (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);    \
+             pos = rht_dereference_bucket((pos)->next, tbl, hash))
 
 /**
  * rht_for_each_entry - iterate over hash chain of given type
- * @pos:        type * to use as a loop cursor.
- * @head:       head of the hash chain (struct rhash_head *)
- * @ht:         pointer to your struct rhashtable
- * @member:     name of the rhash_head within the hashable struct.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ * @member:     name of the &struct rhash_head within the hashable struct.
  */
-#define rht_for_each_entry(pos, head, ht, member) \
-        for (pos = rht_entry_safe(rht_dereference(head, ht), \
-                                   typeof(*(pos)), member); \
-             pos; \
-             pos = rht_next_entry_safe(pos, ht, member))
+#define rht_for_each_entry(tpos, pos, tbl, hash, member)                \
+        rht_for_each_entry_continue(tpos, pos, (tbl)->buckets[hash],    \
+                                    tbl, hash, member)
 
 /**
  * rht_for_each_entry_safe - safely iterate over hash chain of given type
- * @pos:        type * to use as a loop cursor.
- * @n:          type * to use for temporary next object storage
- * @head:       head of the hash chain (struct rhash_head *)
- * @ht:         pointer to your struct rhashtable
- * @member:     name of the rhash_head within the hashable struct.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @next:       the &struct rhash_head to use as next in loop cursor.
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ * @member:     name of the &struct rhash_head within the hashable struct.
  *
  * This hash chain list-traversal primitive allows for the looped code to
  * remove the loop cursor from the list.
  */
-#define rht_for_each_entry_safe(pos, n, head, ht, member)               \
-        for (pos = rht_entry_safe(rht_dereference(head, ht), \
-                                  typeof(*(pos)), member), \
-             n = rht_next_entry_safe(pos, ht, member); \
-             pos; \
-             pos = n, \
-             n = rht_next_entry_safe(pos, ht, member))
+#define rht_for_each_entry_safe(tpos, pos, next, tbl, hash, member)         \
+        for (pos = rht_dereference_bucket((tbl)->buckets[hash], tbl, hash), \
+             next = !rht_is_a_nulls(pos) ?                                  \
+                       rht_dereference_bucket(pos->next, tbl, hash) : NULL; \
+             (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);        \
+             pos = next,                                                    \
+             next = !rht_is_a_nulls(pos) ?                                  \
+                       rht_dereference_bucket(pos->next, tbl, hash) : NULL)
+
+/**
+ * rht_for_each_rcu_continue - continue iterating over rcu hash chain
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @head:       the previous &struct rhash_head to continue from
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ *
+ * This hash chain list-traversal primitive may safely run concurrently with
+ * the _rcu mutation primitives such as rhashtable_insert() as long as the
+ * traversal is guarded by rcu_read_lock().
+ */
+#define rht_for_each_rcu_continue(pos, head, tbl, hash)                 \
+        for (({barrier(); }),                                           \
+             pos = rht_dereference_bucket_rcu(head, tbl, hash);         \
+             !rht_is_a_nulls(pos);                                      \
+             pos = rcu_dereference_raw(pos->next))
 
 /**
  * rht_for_each_rcu - iterate over rcu hash chain
- * @pos:        &struct rhash_head to use as a loop cursor.
- * @head:       head of the hash chain (struct rhash_head *)
- * @ht:         pointer to your struct rhashtable
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ *
+ * This hash chain list-traversal primitive may safely run concurrently with
+ * the _rcu mutation primitives such as rhashtable_insert() as long as the
+ * traversal is guarded by rcu_read_lock().
+ */
+#define rht_for_each_rcu(pos, tbl, hash)                                \
+        rht_for_each_rcu_continue(pos, (tbl)->buckets[hash], tbl, hash)
+
+/**
+ * rht_for_each_entry_rcu_continue - continue iterating over rcu hash chain
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @head:       the previous &struct rhash_head to continue from
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ * @member:     name of the &struct rhash_head within the hashable struct.
  *
  * This hash chain list-traversal primitive may safely run concurrently with
- * the _rcu fkht mutation primitives such as rht_insert() as long as the
+ * the _rcu mutation primitives such as rhashtable_insert() as long as the
  * traversal is guarded by rcu_read_lock().
  */
-#define rht_for_each_rcu(pos, head, ht) \
-        for (pos = rht_dereference_rcu(head, ht); \
-             pos; \
-             pos = rht_dereference_rcu((pos)->next, ht))
+#define rht_for_each_entry_rcu_continue(tpos, pos, head, tbl, hash, member) \
+        for (({barrier(); }),                                               \
+             pos = rht_dereference_bucket_rcu(head, tbl, hash);             \
+             (!rht_is_a_nulls(pos)) && rht_entry(tpos, pos, member);        \
+             pos = rht_dereference_bucket_rcu(pos->next, tbl, hash))
 
 /**
  * rht_for_each_entry_rcu - iterate over rcu hash chain of given type
- * @pos:        type * to use as a loop cursor.
- * @head:       head of the hash chain (struct rhash_head *)
- * @member:     name of the rhash_head within the hashable struct.
+ * @tpos:       the type * to use as a loop cursor.
+ * @pos:        the &struct rhash_head to use as a loop cursor.
+ * @tbl:        the &struct bucket_table
+ * @hash:       the hash value / bucket index
+ * @member:     name of the &struct rhash_head within the hashable struct.
  *
  * This hash chain list-traversal primitive may safely run concurrently with
- * the _rcu fkht mutation primitives such as rht_insert() as long as the
+ * the _rcu mutation primitives such as rhashtable_insert() as long as the
  * traversal is guarded by rcu_read_lock().
  */
-#define rht_for_each_entry_rcu(pos, head, member) \
-        for (pos = rht_entry_safe(rcu_dereference_raw(head), \
-                                  typeof(*(pos)), member); \
-             pos; \
-             pos = rht_entry_safe(rcu_dereference_raw((pos)->member.next), \
-                                  typeof(*(pos)), member))
+#define rht_for_each_entry_rcu(tpos, pos, tbl, hash, member)            \
+        rht_for_each_entry_rcu_continue(tpos, pos, (tbl)->buckets[hash],\
+                                        tbl, hash, member)
 
 #endif /* _LINUX_RHASHTABLE_H */
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index c0c2bce6b0b7..c4c559a45dc8 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -37,6 +37,16 @@ struct anon_vma {
         atomic_t refcount;
 
         /*
+         * Count of child anon_vmas and VMAs which points to this anon_vma.
+         *
+         * This counter is used for making decision about reusing anon_vma
+         * instead of forking new one. See comments in function anon_vma_clone.
+         */
+        unsigned degree;
+
+        struct anon_vma *parent;        /* Parent of this anon_vma */
+
+        /*
          * NOTE: the LSB of the rb_root.rb_node is set by
          * mm_take_all_locks() _after_ taking the above lock. So the
          * rb_root must only be read/written after taking the above lock
@@ -188,7 +198,7 @@ int page_referenced(struct page *, int is_locked,
 int try_to_unmap(struct page *, enum ttu_flags flags);
 
 /*
- * Called from mm/filemap_xip.c to unmap empty zero page
+ * Used by uprobes to replace a userspace page safely
  */
 pte_t *__page_check_address(struct page *, struct mm_struct *,
                                 unsigned long, spinlock_t **, int);
@@ -236,7 +246,6 @@ int page_mapped_in_vma(struct page *page, struct vm_area_struct *vma);
  * arg: passed to rmap_one() and invalid_vma()
  * rmap_one: executed on each vma where page is mapped
  * done: for checking traversing termination condition
- * file_nonlinear: for handling file nonlinear mapping
  * anon_lock: for getting anon_lock by optimized way rather than default
  * invalid_vma: for skipping uninterested vma
  */
@@ -245,7 +254,6 @@ struct rmap_walk_control {
         int (*rmap_one)(struct page *page, struct vm_area_struct *vma,
                                         unsigned long addr, void *arg);
         int (*done)(struct page *page);
-        int (*file_nonlinear)(struct page *, struct address_space *, void *arg);
         struct anon_vma *(*anon_lock)(struct page *page);
         bool (*invalid_vma)(struct vm_area_struct *vma, void *arg);
 };
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 6d6be09a2fe5..dcad7ee0d746 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -161,7 +161,7 @@ extern void devm_rtc_device_unregister(struct device *dev,
 extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm);
 extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm);
 extern int rtc_set_mmss(struct rtc_device *rtc, unsigned long secs);
-extern int rtc_set_ntp_time(struct timespec now);
+extern int rtc_set_ntp_time(struct timespec64 now);
 int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm);
 extern int rtc_read_alarm(struct rtc_device *rtc,
                         struct rtc_wkalrm *alrm);
diff --git a/include/linux/rtc/ds1685.h b/include/linux/rtc/ds1685.h
new file mode 100644
index 000000000000..e6337a56d741
--- /dev/null
+++ b/include/linux/rtc/ds1685.h
@@ -0,0 +1,375 @@
+/*
+ * Definitions for the registers, addresses, and platform data of the
+ * DS1685/DS1687-series RTC chips.
+ *
+ * This Driver also works for the DS17X85/DS17X87 RTC chips.  Functionally
+ * similar to the DS1685/DS1687, they support a few extra features which
+ * include larger, battery-backed NV-SRAM, burst-mode access, and an RTC
+ * write counter.
+ *
+ * Copyright (C) 2011-2014 Joshua Kinard <kumba@gentoo.org>.
+ * Copyright (C) 2009 Matthias Fuchs <matthias.fuchs@esd-electronics.com>.
+ *
+ * References:
+ *    DS1685/DS1687 3V/5V Real-Time Clocks, 19-5215, Rev 4/10.
+ *    DS17x85/DS17x87 3V/5V Real-Time Clocks, 19-5222, Rev 4/10.
+ *    DS1689/DS1693 3V/5V Serialized Real-Time Clocks, Rev 112105.
+ *    Application Note 90, Using the Multiplex Bus RTC Extended Features.
+ *
+ * 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_RTC_DS1685_H_
+#define _LINUX_RTC_DS1685_H_
+
+#include <linux/rtc.h>
+#include <linux/platform_device.h>
+#include <linux/workqueue.h>
+
+/**
+ * struct ds1685_priv - DS1685 private data structure.
+ * @dev: pointer to the rtc_device structure.
+ * @regs: iomapped base address pointer of the RTC registers.
+ * @regstep: padding/step size between registers (optional).
+ * @baseaddr: base address of the RTC device.
+ * @size: resource size.
+ * @lock: private lock variable for spin locking/unlocking.
+ * @work: private workqueue.
+ * @irq: IRQ number assigned to the RTC device.
+ * @prepare_poweroff: pointer to platform pre-poweroff function.
+ * @wake_alarm: pointer to platform wake alarm function.
+ * @post_ram_clear: pointer to platform post ram-clear function.
+ */
+struct ds1685_priv {
+        struct rtc_device *dev;
+        void __iomem *regs;
+        u32 regstep;
+        resource_size_t baseaddr;
+        size_t size;
+        spinlock_t lock;
+        struct work_struct work;
+        int irq_num;
+        bool bcd_mode;
+        bool no_irq;
+        bool uie_unsupported;
+        bool alloc_io_resources;
+        u8 (*read)(struct ds1685_priv *, int);
+        void (*write)(struct ds1685_priv *, int, u8);
+        void (*prepare_poweroff)(void);
+        void (*wake_alarm)(void);
+        void (*post_ram_clear)(void);
+};
+
+
+/**
+ * struct ds1685_rtc_platform_data - platform data structure.
+ * @plat_prepare_poweroff: platform-specific pre-poweroff function.
+ * @plat_wake_alarm: platform-specific wake alarm function.
+ * @plat_post_ram_clear: platform-specific post ram-clear function.
+ *
+ * If your platform needs to use a custom padding/step size between
+ * registers, or uses one or more of the extended interrupts and needs special
+ * handling, then include this header file in your platform definition and
+ * set regstep and the plat_* pointers as appropriate.
+ */
+struct ds1685_rtc_platform_data {
+        const u32 regstep;
+        const bool bcd_mode;
+        const bool no_irq;
+        const bool uie_unsupported;
+        const bool alloc_io_resources;
+        u8 (*plat_read)(struct ds1685_priv *, int);
+        void (*plat_write)(struct ds1685_priv *, int, u8);
+        void (*plat_prepare_poweroff)(void);
+        void (*plat_wake_alarm)(void);
+        void (*plat_post_ram_clear)(void);
+};
+
+
+/*
+ * Time Registers.
+ */
+#define RTC_SECS                0x00    /* Seconds 00-59 */
+#define RTC_SECS_ALARM          0x01    /* Alarm Seconds 00-59 */
+#define RTC_MINS                0x02    /* Minutes 00-59 */
+#define RTC_MINS_ALARM          0x03    /* Alarm Minutes 00-59 */
+#define RTC_HRS                 0x04    /* Hours 01-12 AM/PM || 00-23 */
+#define RTC_HRS_ALARM           0x05    /* Alarm Hours 01-12 AM/PM || 00-23 */
+#define RTC_WDAY                0x06    /* Day of Week 01-07 */
+#define RTC_MDAY                0x07    /* Day of Month 01-31 */
+#define RTC_MONTH               0x08    /* Month 01-12 */
+#define RTC_YEAR                0x09    /* Year 00-99 */
+#define RTC_CENTURY             0x48    /* Century 00-99 */
+#define RTC_MDAY_ALARM          0x49    /* Alarm Day of Month 01-31 */
+
+
+/*
+ * Bit masks for the Time registers in BCD Mode (DM = 0).
+ */
+#define RTC_SECS_BCD_MASK       0x7f    /* - x x x x x x x */
+#define RTC_MINS_BCD_MASK       0x7f    /* - x x x x x x x */
+#define RTC_HRS_12_BCD_MASK     0x1f    /* - - - x x x x x */
+#define RTC_HRS_24_BCD_MASK     0x3f    /* - - x x x x x x */
+#define RTC_MDAY_BCD_MASK       0x3f    /* - - x x x x x x */
+#define RTC_MONTH_BCD_MASK      0x1f    /* - - - x x x x x */
+#define RTC_YEAR_BCD_MASK       0xff    /* x x x x x x x x */
+
+/*
+ * Bit masks for the Time registers in BIN Mode (DM = 1).
+ */
+#define RTC_SECS_BIN_MASK       0x3f    /* - - x x x x x x */
+#define RTC_MINS_BIN_MASK       0x3f    /* - - x x x x x x */
+#define RTC_HRS_12_BIN_MASK     0x0f    /* - - - - x x x x */
+#define RTC_HRS_24_BIN_MASK     0x1f    /* - - - x x x x x */
+#define RTC_MDAY_BIN_MASK       0x1f    /* - - - x x x x x */
+#define RTC_MONTH_BIN_MASK      0x0f    /* - - - - x x x x */
+#define RTC_YEAR_BIN_MASK       0x7f    /* - x x x x x x x */
+
+/*
+ * Bit masks common for the Time registers in BCD or BIN Mode.
+ */
+#define RTC_WDAY_MASK           0x07    /* - - - - - x x x */
+#define RTC_CENTURY_MASK        0xff    /* x x x x x x x x */
+#define RTC_MDAY_ALARM_MASK     0xff    /* x x x x x x x x */
+#define RTC_HRS_AMPM_MASK       BIT(7)  /* Mask for the AM/PM bit */
+
+
+
+/*
+ * Control Registers.
+ */
+#define RTC_CTRL_A              0x0a    /* Control Register A */
+#define RTC_CTRL_B              0x0b    /* Control Register B */
+#define RTC_CTRL_C              0x0c    /* Control Register C */
+#define RTC_CTRL_D              0x0d    /* Control Register D */
+#define RTC_EXT_CTRL_4A         0x4a    /* Extended Control Register 4A */
+#define RTC_EXT_CTRL_4B         0x4b    /* Extended Control Register 4B */
+
+
+/*
+ * Bit names in Control Register A.
+ */
+#define RTC_CTRL_A_UIP          BIT(7)  /* Update In Progress */
+#define RTC_CTRL_A_DV2          BIT(6)  /* Countdown Chain */
+#define RTC_CTRL_A_DV1          BIT(5)  /* Oscillator Enable */
+#define RTC_CTRL_A_DV0          BIT(4)  /* Bank Select */
+#define RTC_CTRL_A_RS2          BIT(2)  /* Rate-Selection Bit 2 */
+#define RTC_CTRL_A_RS3          BIT(3)  /* Rate-Selection Bit 3 */
+#define RTC_CTRL_A_RS1          BIT(1)  /* Rate-Selection Bit 1 */
+#define RTC_CTRL_A_RS0          BIT(0)  /* Rate-Selection Bit 0 */
+#define RTC_CTRL_A_RS_MASK      0x0f    /* RS3 + RS2 + RS1 + RS0 */
+
+/*
+ * Bit names in Control Register B.
+ */
+#define RTC_CTRL_B_SET          BIT(7)  /* SET Bit */
+#define RTC_CTRL_B_PIE          BIT(6)  /* Periodic-Interrupt Enable */
+#define RTC_CTRL_B_AIE          BIT(5)  /* Alarm-Interrupt Enable */
+#define RTC_CTRL_B_UIE          BIT(4)  /* Update-Ended Interrupt-Enable */
+#define RTC_CTRL_B_SQWE         BIT(3)  /* Square-Wave Enable */
+#define RTC_CTRL_B_DM           BIT(2)  /* Data Mode */
+#define RTC_CTRL_B_2412         BIT(1)  /* 12-Hr/24-Hr Mode */
+#define RTC_CTRL_B_DSE          BIT(0)  /* Daylight Savings Enable */
+#define RTC_CTRL_B_PAU_MASK     0x70    /* PIE + AIE + UIE */
+
+
+/*
+ * Bit names in Control Register C.
+ *
+ * BIT(0), BIT(1), BIT(2), & BIT(3) are unused, always return 0, and cannot
+ * be written to.
+ */
+#define RTC_CTRL_C_IRQF         BIT(7)  /* Interrupt-Request Flag */
+#define RTC_CTRL_C_PF           BIT(6)  /* Periodic-Interrupt Flag */
+#define RTC_CTRL_C_AF           BIT(5)  /* Alarm-Interrupt Flag */
+#define RTC_CTRL_C_UF           BIT(4)  /* Update-Ended Interrupt Flag */
+#define RTC_CTRL_C_PAU_MASK     0x70    /* PF + AF + UF */
+
+
+/*
+ * Bit names in Control Register D.
+ *
+ * BIT(0) through BIT(6) are unused, always return 0, and cannot
+ * be written to.
+ */
+#define RTC_CTRL_D_VRT          BIT(7)  /* Valid RAM and Time */
+
+
+/*
+ * Bit names in Extended Control Register 4A.
+ *
+ * On the DS1685/DS1687/DS1689/DS1693, BIT(4) and BIT(5) are reserved for
+ * future use.  They can be read from and written to, but have no effect
+ * on the RTC's operation.
+ *
+ * On the DS17x85/DS17x87, BIT(5) is Burst-Mode Enable (BME), and allows
+ * access to the extended NV-SRAM by automatically incrementing the address
+ * register when they are read from or written to.
+ */
+#define RTC_CTRL_4A_VRT2        BIT(7)  /* Auxillary Battery Status */
+#define RTC_CTRL_4A_INCR        BIT(6)  /* Increment-in-Progress Status */
+#define RTC_CTRL_4A_PAB         BIT(3)  /* Power-Active Bar Control */
+#define RTC_CTRL_4A_RF          BIT(2)  /* RAM-Clear Flag */
+#define RTC_CTRL_4A_WF          BIT(1)  /* Wake-Up Alarm Flag */
+#define RTC_CTRL_4A_KF          BIT(0)  /* Kickstart Flag */
+#if !defined(CONFIG_RTC_DRV_DS1685) && !defined(CONFIG_RTC_DRV_DS1689)
+#define RTC_CTRL_4A_BME         BIT(5)  /* Burst-Mode Enable */
+#endif
+#define RTC_CTRL_4A_RWK_MASK    0x07    /* RF + WF + KF */
+
+
+/*
+ * Bit names in Extended Control Register 4B.
+ */
+#define RTC_CTRL_4B_ABE         BIT(7)  /* Auxillary Battery Enable */
+#define RTC_CTRL_4B_E32K        BIT(6)  /* Enable 32.768Hz on SQW Pin */
+#define RTC_CTRL_4B_CS          BIT(5)  /* Crystal Select */
+#define RTC_CTRL_4B_RCE         BIT(4)  /* RAM Clear-Enable */
+#define RTC_CTRL_4B_PRS         BIT(3)  /* PAB Reset-Select */
+#define RTC_CTRL_4B_RIE         BIT(2)  /* RAM Clear-Interrupt Enable */
+#define RTC_CTRL_4B_WIE         BIT(1)  /* Wake-Up Alarm-Interrupt Enable */
+#define RTC_CTRL_4B_KSE         BIT(0)  /* Kickstart Interrupt-Enable */
+#define RTC_CTRL_4B_RWK_MASK    0x07    /* RIE + WIE + KSE */
+
+
+/*
+ * Misc register names in Bank 1.
+ *
+ * The DV0 bit in Control Register A must be set to 1 for these registers
+ * to become available, including Extended Control Registers 4A & 4B.
+ */
+#define RTC_BANK1_SSN_MODEL     0x40    /* Model Number */
+#define RTC_BANK1_SSN_BYTE_1    0x41    /* 1st Byte of Serial Number */
+#define RTC_BANK1_SSN_BYTE_2    0x42    /* 2nd Byte of Serial Number */
+#define RTC_BANK1_SSN_BYTE_3    0x43    /* 3rd Byte of Serial Number */
+#define RTC_BANK1_SSN_BYTE_4    0x44    /* 4th Byte of Serial Number */
+#define RTC_BANK1_SSN_BYTE_5    0x45    /* 5th Byte of Serial Number */
+#define RTC_BANK1_SSN_BYTE_6    0x46    /* 6th Byte of Serial Number */
+#define RTC_BANK1_SSN_CRC       0x47    /* Serial CRC Byte */
+#define RTC_BANK1_RAM_DATA_PORT 0x53    /* Extended RAM Data Port */
+
+
+/*
+ * Model-specific registers in Bank 1.
+ *
+ * The addresses below differ depending on the model of the RTC chip
+ * selected in the kernel configuration.  Not all of these features are
+ * supported in the main driver at present.
+ *
+ * DS1685/DS1687   - Extended NV-SRAM address (LSB only).
+ * DS1689/DS1693   - Vcc, Vbat, Pwr Cycle Counters & Customer-specific S/N.
+ * DS17x85/DS17x87 - Extended NV-SRAM addresses (MSB & LSB) & Write counter.
+ */
+#if defined(CONFIG_RTC_DRV_DS1685)
+#define RTC_BANK1_RAM_ADDR      0x50    /* NV-SRAM Addr */
+#elif defined(CONFIG_RTC_DRV_DS1689)
+#define RTC_BANK1_VCC_CTR_LSB   0x54    /* Vcc Counter Addr (LSB) */
+#define RTC_BANK1_VCC_CTR_MSB   0x57    /* Vcc Counter Addr (MSB) */
+#define RTC_BANK1_VBAT_CTR_LSB  0x58    /* Vbat Counter Addr (LSB) */
+#define RTC_BANK1_VBAT_CTR_MSB  0x5b    /* Vbat Counter Addr (MSB) */
+#define RTC_BANK1_PWR_CTR_LSB   0x5c    /* Pwr Cycle Counter Addr (LSB) */
+#define RTC_BANK1_PWR_CTR_MSB   0x5d    /* Pwr Cycle Counter Addr (MSB) */
+#define RTC_BANK1_UNIQ_SN       0x60    /* Customer-specific S/N */
+#else /* DS17x85/DS17x87 */
+#define RTC_BANK1_RAM_ADDR_LSB  0x50    /* NV-SRAM Addr (LSB) */
+#define RTC_BANK1_RAM_ADDR_MSB  0x51    /* NV-SRAM Addr (MSB) */
+#define RTC_BANK1_WRITE_CTR     0x5e    /* RTC Write Counter */
+#endif
+
+
+/*
+ * Model numbers.
+ *
+ * The DS1688/DS1691 and DS1689/DS1693 chips share the same model number
+ * and the manual doesn't indicate any major differences.  As such, they
+ * are regarded as the same chip in this driver.
+ */
+#define RTC_MODEL_DS1685        0x71    /* DS1685/DS1687 */
+#define RTC_MODEL_DS17285       0x72    /* DS17285/DS17287 */
+#define RTC_MODEL_DS1689        0x73    /* DS1688/DS1691/DS1689/DS1693 */
+#define RTC_MODEL_DS17485       0x74    /* DS17485/DS17487 */
+#define RTC_MODEL_DS17885       0x78    /* DS17885/DS17887 */
+
+
+/*
+ * Periodic Interrupt Rates / Square-Wave Output Frequency
+ *
+ * Periodic rates are selected by setting the RS3-RS0 bits in Control
+ * Register A and enabled via either the E32K bit in Extended Control
+ * Register 4B or the SQWE bit in Control Register B.
+ *
+ * E32K overrides the settings of RS3-RS0 and outputs a frequency of 32768Hz
+ * on the SQW pin of the RTC chip.  While there are 16 possible selections,
+ * the 1-of-16 decoder is only able to divide the base 32768Hz signal into 13
+ * smaller frequencies.  The values 0x01 and 0x02 are not used and are
+ * synonymous with 0x08 and 0x09, respectively.
+ *
+ * When E32K is set to a logic 1, periodic interrupts are disabled and reading
+ * /dev/rtc will return -EINVAL.  This also applies if the periodic interrupt
+ * frequency is set to 0Hz.
+ *
+ * Not currently used by the rtc-ds1685 driver because the RTC core removed
+ * support for hardware-generated periodic-interrupts in favour of
+ * hrtimer-generated interrupts.  But these defines are kept around for use
+ * in userland, as documentation to the hardware, and possible future use if
+ * hardware-generated periodic interrupts are ever added back.
+ */
+                                        /* E32K RS3 RS2 RS1 RS0 */
+#define RTC_SQW_8192HZ          0x03    /*  0    0   0   1   1  */
+#define RTC_SQW_4096HZ          0x04    /*  0    0   1   0   0  */
+#define RTC_SQW_2048HZ          0x05    /*  0    0   1   0   1  */
+#define RTC_SQW_1024HZ          0x06    /*  0    0   1   1   0  */
+#define RTC_SQW_512HZ           0x07    /*  0    0   1   1   1  */
+#define RTC_SQW_256HZ           0x08    /*  0    1   0   0   0  */
+#define RTC_SQW_128HZ           0x09    /*  0    1   0   0   1  */
+#define RTC_SQW_64HZ            0x0a    /*  0    1   0   1   0  */
+#define RTC_SQW_32HZ            0x0b    /*  0    1   0   1   1  */
+#define RTC_SQW_16HZ            0x0c    /*  0    1   1   0   0  */
+#define RTC_SQW_8HZ             0x0d    /*  0    1   1   0   1  */
+#define RTC_SQW_4HZ             0x0e    /*  0    1   1   1   0  */
+#define RTC_SQW_2HZ             0x0f    /*  0    1   1   1   1  */
+#define RTC_SQW_0HZ             0x00    /*  0    0   0   0   0  */
+#define RTC_SQW_32768HZ         32768   /*  1    -   -   -   -  */
+#define RTC_MAX_USER_FREQ       8192
+
+
+/*
+ * NVRAM data & addresses:
+ *   - 50 bytes of NVRAM are available just past the clock registers.
+ *   - 64 additional bytes are available in Bank0.
+ *
+ * Extended, battery-backed NV-SRAM:
+ *   - DS1685/DS1687    - 128 bytes.
+ *   - DS1689/DS1693    - 0 bytes.
+ *   - DS17285/DS17287  - 2048 bytes.
+ *   - DS17485/DS17487  - 4096 bytes.
+ *   - DS17885/DS17887  - 8192 bytes.
+ */
+#define NVRAM_TIME_BASE         0x0e    /* NVRAM Addr in Time regs */
+#define NVRAM_BANK0_BASE        0x40    /* NVRAM Addr in Bank0 regs */
+#define NVRAM_SZ_TIME           50
+#define NVRAM_SZ_BANK0          64
+#if defined(CONFIG_RTC_DRV_DS1685)
+#  define NVRAM_SZ_EXTND        128
+#elif defined(CONFIG_RTC_DRV_DS1689)
+#  define NVRAM_SZ_EXTND        0
+#elif defined(CONFIG_RTC_DRV_DS17285)
+#  define NVRAM_SZ_EXTND        2048
+#elif defined(CONFIG_RTC_DRV_DS17485)
+#  define NVRAM_SZ_EXTND        4096
+#elif defined(CONFIG_RTC_DRV_DS17885)
+#  define NVRAM_SZ_EXTND        8192
+#endif
+#define NVRAM_TOTAL_SZ_BANK0    (NVRAM_SZ_TIME + NVRAM_SZ_BANK0)
+#define NVRAM_TOTAL_SZ          (NVRAM_TOTAL_SZ_BANK0 + NVRAM_SZ_EXTND)
+
+
+/*
+ * Function Prototypes.
+ */
+extern void __noreturn
+ds1685_rtc_poweroff(struct platform_device *pdev);
+
+#endif /* _LINUX_RTC_DS1685_H_ */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 8db31ef98d2f..41c60e5302d7 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1370,6 +1370,8 @@ struct task_struct {
 
         unsigned long atomic_flags; /* Flags needing atomic access. */
 
+        struct restart_block restart_block;
+
         pid_t pid;
         pid_t tgid;
 
@@ -1662,6 +1664,9 @@ struct task_struct {
         unsigned long timer_slack_ns;
         unsigned long default_timer_slack_ns;
 
+#ifdef CONFIG_KASAN
+        unsigned int kasan_depth;
+#endif
 #ifdef CONFIG_FUNCTION_GRAPH_TRACER
         /* Index of current stored address in ret_stack */
         int curr_ret_stack;
@@ -2145,6 +2150,7 @@ extern unsigned long long notrace sched_clock(void);
  */
 extern u64 cpu_clock(int cpu);
 extern u64 local_clock(void);
+extern u64 running_clock(void);
 extern u64 sched_clock_cpu(int cpu);
 
 
diff --git a/include/linux/security.h b/include/linux/security.h
index ba96471c11ba..a1b7dbd127ff 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -1281,6 +1281,25 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
  *      @alter contains the flag indicating whether changes are to be made.
  *      Return 0 if permission is granted.
  *
+ * @binder_set_context_mgr
+ *      Check whether @mgr is allowed to be the binder context manager.
+ *      @mgr contains the task_struct for the task being registered.
+ *      Return 0 if permission is granted.
+ * @binder_transaction
+ *      Check whether @from is allowed to invoke a binder transaction call
+ *      to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_binder
+ *      Check whether @from is allowed to transfer a binder reference to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @to contains the task_struct for the receiving task.
+ * @binder_transfer_file
+ *      Check whether @from is allowed to transfer @file to @to.
+ *      @from contains the task_struct for the sending task.
+ *      @file contains the struct file being transferred.
+ *      @to contains the task_struct for the receiving task.
+ *
  * @ptrace_access_check:
  *      Check permission before allowing the current process to trace the
  *      @child process.
@@ -1441,6 +1460,14 @@ static inline void security_free_mnt_opts(struct security_mnt_opts *opts)
 struct security_operations {
         char name[SECURITY_NAME_MAX + 1];
 
+        int (*binder_set_context_mgr) (struct task_struct *mgr);
+        int (*binder_transaction) (struct task_struct *from,
+                                   struct task_struct *to);
+        int (*binder_transfer_binder) (struct task_struct *from,
+                                       struct task_struct *to);
+        int (*binder_transfer_file) (struct task_struct *from,
+                                     struct task_struct *to, struct file *file);
+
         int (*ptrace_access_check) (struct task_struct *child, unsigned int mode);
         int (*ptrace_traceme) (struct task_struct *parent);
         int (*capget) (struct task_struct *target,
@@ -1739,6 +1766,13 @@ extern void __init security_fixup_ops(struct security_operations *ops);
 
 
 /* Security operations */
+int security_binder_set_context_mgr(struct task_struct *mgr);
+int security_binder_transaction(struct task_struct *from,
+                                struct task_struct *to);
+int security_binder_transfer_binder(struct task_struct *from,
+                                    struct task_struct *to);
+int security_binder_transfer_file(struct task_struct *from,
+                                  struct task_struct *to, struct file *file);
 int security_ptrace_access_check(struct task_struct *child, unsigned int mode);
 int security_ptrace_traceme(struct task_struct *parent);
 int security_capget(struct task_struct *target,
@@ -1927,6 +1961,30 @@ static inline int security_init(void)
         return 0;
 }
 
+static inline int security_binder_set_context_mgr(struct task_struct *mgr)
+{
+        return 0;
+}
+
+static inline int security_binder_transaction(struct task_struct *from,
+                                              struct task_struct *to)
+{
+        return 0;
+}
+
+static inline int security_binder_transfer_binder(struct task_struct *from,
+                                                  struct task_struct *to)
+{
+        return 0;
+}
+
+static inline int security_binder_transfer_file(struct task_struct *from,
+                                                struct task_struct *to,
+                                                struct file *file)
+{
+        return 0;
+}
+
 static inline int security_ptrace_access_check(struct task_struct *child,
                                              unsigned int mode)
 {
diff --git a/include/linux/seq_buf.h b/include/linux/seq_buf.h
index 9aafe0e24c68..fb7eb9ccb1cd 100644
--- a/include/linux/seq_buf.h
+++ b/include/linux/seq_buf.h
@@ -125,9 +125,6 @@ extern int seq_buf_putmem_hex(struct seq_buf *s, const void *mem,
                               unsigned int len);
 extern int seq_buf_path(struct seq_buf *s, const struct path *path, const char *esc);
 
-extern int seq_buf_bitmask(struct seq_buf *s, const unsigned long *maskp,
-                           int nmaskbits);
-
 #ifdef CONFIG_BINARY_PRINTF
 extern int
 seq_buf_bprintf(struct seq_buf *s, const char *fmt, const u32 *binary);
diff --git a/include/linux/seq_file.h b/include/linux/seq_file.h
index cf6a9daaaf6d..afbb1fd77c77 100644
--- a/include/linux/seq_file.h
+++ b/include/linux/seq_file.h
@@ -126,31 +126,6 @@ int seq_path(struct seq_file *, const struct path *, const char *);
 int seq_dentry(struct seq_file *, struct dentry *, const char *);
 int seq_path_root(struct seq_file *m, const struct path *path,
                   const struct path *root, const char *esc);
-int seq_bitmap(struct seq_file *m, const unsigned long *bits,
-                                   unsigned int nr_bits);
-static inline int seq_cpumask(struct seq_file *m, const struct cpumask *mask)
-{
-        return seq_bitmap(m, cpumask_bits(mask), nr_cpu_ids);
-}
-
-static inline int seq_nodemask(struct seq_file *m, nodemask_t *mask)
-{
-        return seq_bitmap(m, mask->bits, MAX_NUMNODES);
-}
-
-int seq_bitmap_list(struct seq_file *m, const unsigned long *bits,
-                unsigned int nr_bits);
-
-static inline int seq_cpumask_list(struct seq_file *m,
-                                   const struct cpumask *mask)
-{
-        return seq_bitmap_list(m, cpumask_bits(mask), nr_cpu_ids);
-}
-
-static inline int seq_nodemask_list(struct seq_file *m, nodemask_t *mask)
-{
-        return seq_bitmap_list(m, mask->bits, MAX_NUMNODES);
-}
 
 int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
 int single_open_size(struct file *, int (*)(struct seq_file *, void *), void *, size_t);
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index e02acf0a0ec9..a8efa235b7c1 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -85,6 +85,9 @@ struct uart_8250_port {
         unsigned char           mcr_force;      /* mask of forced bits */
         unsigned char           cur_iotype;     /* Running I/O type */
         unsigned int            rpm_tx_active;
+        unsigned char           canary;         /* non-zero during system sleep
+                                                 *   if no_console_suspend
+                                                 */
 
         /*
          * Some bits in registers are cleared on a read, so they must
@@ -126,6 +129,7 @@ extern int serial8250_do_startup(struct uart_port *port);
 extern void serial8250_do_shutdown(struct uart_port *port);
 extern void serial8250_do_pm(struct uart_port *port, unsigned int state,
                              unsigned int oldstate);
+extern void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl);
 extern int fsl8250_handle_irq(struct uart_port *port);
 int serial8250_handle_irq(struct uart_port *port, unsigned int iir);
 unsigned char serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 057038cf2788..baf3e1d08416 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -123,6 +123,7 @@ struct uart_port {
         void                    (*set_termios)(struct uart_port *,
                                                struct ktermios *new,
                                                struct ktermios *old);
+        void                    (*set_mctrl)(struct uart_port *, unsigned int);
         int                     (*startup)(struct uart_port *port);
         void                    (*shutdown)(struct uart_port *port);
         void                    (*throttle)(struct uart_port *port);
@@ -190,8 +191,10 @@ struct uart_port {
 #define UPF_NO_TXEN_TEST        ((__force upf_t) (1 << 15))
 #define UPF_MAGIC_MULTIPLIER    ((__force upf_t) ASYNC_MAGIC_MULTIPLIER /* 16 */ )
 
-/* Port has hardware-assisted h/w flow control (iow, auto-RTS *not* auto-CTS) */
-#define UPF_HARD_FLOW           ((__force upf_t) (1 << 21))
+/* Port has hardware-assisted h/w flow control */
+#define UPF_AUTO_CTS            ((__force upf_t) (1 << 20))
+#define UPF_AUTO_RTS            ((__force upf_t) (1 << 21))
+#define UPF_HARD_FLOW           ((__force upf_t) (UPF_AUTO_CTS | UPF_AUTO_RTS))
 /* Port has hardware-assisted s/w flow control */
 #define UPF_SOFT_FLOW           ((__force upf_t) (1 << 22))
 #define UPF_CONS_FLOW           ((__force upf_t) (1 << 23))
@@ -213,11 +216,17 @@ struct uart_port {
 #error Change mask not equivalent to userspace-visible bit defines
 #endif
 
-        /* status must be updated while holding port lock */
+        /*
+         * Must hold termios_rwsem, port mutex and port lock to change;
+         * can hold any one lock to read.
+         */
         upstat_t                status;
 
 #define UPSTAT_CTS_ENABLE       ((__force upstat_t) (1 << 0))
 #define UPSTAT_DCD_ENABLE       ((__force upstat_t) (1 << 1))
+#define UPSTAT_AUTORTS          ((__force upstat_t) (1 << 2))
+#define UPSTAT_AUTOCTS          ((__force upstat_t) (1 << 3))
+#define UPSTAT_AUTOXOFF         ((__force upstat_t) (1 << 4))
 
         int                     hw_stopped;             /* sw-assisted CTS flow state */
         unsigned int            mctrl;                  /* current modem ctrl settings */
@@ -391,6 +400,13 @@ static inline bool uart_cts_enabled(struct uart_port *uport)
         return !!(uport->status & UPSTAT_CTS_ENABLE);
 }
 
+static inline bool uart_softcts_mode(struct uart_port *uport)
+{
+        upstat_t mask = UPSTAT_CTS_ENABLE | UPSTAT_AUTOCTS;
+
+        return ((uport->status & mask) == UPSTAT_CTS_ENABLE);
+}
+
 /*
  * The following are helper functions for the low level drivers.
  */
diff --git a/include/linux/serial_s3c.h b/include/linux/serial_s3c.h
index e6fc9567690b..a7f004a3c177 100644
--- a/include/linux/serial_s3c.h
+++ b/include/linux/serial_s3c.h
@@ -104,6 +104,31 @@
                                    S3C2410_UCON_RXIRQMODE | \
                                    S3C2410_UCON_RXFIFO_TOI)
 
+#define S3C64XX_UCON_TXBURST_1          (0<<20)
+#define S3C64XX_UCON_TXBURST_4          (1<<20)
+#define S3C64XX_UCON_TXBURST_8          (2<<20)
+#define S3C64XX_UCON_TXBURST_16         (3<<20)
+#define S3C64XX_UCON_TXBURST_MASK       (0xf<<20)
+#define S3C64XX_UCON_RXBURST_1          (0<<16)
+#define S3C64XX_UCON_RXBURST_4          (1<<16)
+#define S3C64XX_UCON_RXBURST_8          (2<<16)
+#define S3C64XX_UCON_RXBURST_16         (3<<16)
+#define S3C64XX_UCON_RXBURST_MASK       (0xf<<16)
+#define S3C64XX_UCON_TIMEOUT_SHIFT      (12)
+#define S3C64XX_UCON_TIMEOUT_MASK       (0xf<<12)
+#define S3C64XX_UCON_EMPTYINT_EN        (1<<11)
+#define S3C64XX_UCON_DMASUS_EN          (1<<10)
+#define S3C64XX_UCON_TXINT_LEVEL        (1<<9)
+#define S3C64XX_UCON_RXINT_LEVEL        (1<<8)
+#define S3C64XX_UCON_TIMEOUT_EN         (1<<7)
+#define S3C64XX_UCON_ERRINT_EN          (1<<6)
+#define S3C64XX_UCON_TXMODE_DMA         (2<<2)
+#define S3C64XX_UCON_TXMODE_CPU         (1<<2)
+#define S3C64XX_UCON_TXMODE_MASK        (3<<2)
+#define S3C64XX_UCON_RXMODE_DMA         (2<<0)
+#define S3C64XX_UCON_RXMODE_CPU         (1<<0)
+#define S3C64XX_UCON_RXMODE_MASK        (3<<0)
+
 #define S3C2410_UFCON_FIFOMODE    (1<<0)
 #define S3C2410_UFCON_TXTRIG0     (0<<6)
 #define S3C2410_UFCON_RXTRIG8     (1<<4)
@@ -155,6 +180,7 @@
 #define S3C2440_UFSTAT_TXMASK     (63<<8)
 #define S3C2440_UFSTAT_RXMASK     (63)
 
+#define S3C2410_UTRSTAT_TIMEOUT   (1<<3)
 #define S3C2410_UTRSTAT_TXE       (1<<2)
 #define S3C2410_UTRSTAT_TXFE      (1<<1)
 #define S3C2410_UTRSTAT_RXDR      (1<<0)
@@ -179,8 +205,10 @@
 #define S3C64XX_UINTM           0x38
 
 #define S3C64XX_UINTM_RXD       (0)
+#define S3C64XX_UINTM_ERROR     (1)
 #define S3C64XX_UINTM_TXD       (2)
 #define S3C64XX_UINTM_RXD_MSK   (1 << S3C64XX_UINTM_RXD)
+#define S3C64XX_UINTM_ERR_MSK   (1 << S3C64XX_UINTM_ERROR)
 #define S3C64XX_UINTM_TXD_MSK   (1 << S3C64XX_UINTM_TXD)
 
 /* Following are specific to S5PV210 */
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
index f4aee75f00b1..4fcacd915d45 100644
--- a/include/linux/shrinker.h
+++ b/include/linux/shrinker.h
@@ -20,6 +20,9 @@ struct shrink_control {
 
         /* current node being shrunk (for NUMA aware shrinkers) */
         int nid;
+
+        /* current memcg being shrunk (for memcg aware shrinkers) */
+        struct mem_cgroup *memcg;
 };
 
 #define SHRINK_STOP (~0UL)
@@ -61,7 +64,8 @@ struct shrinker {
 #define DEFAULT_SEEKS 2 /* A good number if you don't know better. */
 
 /* Flags */
-#define SHRINKER_NUMA_AWARE (1 << 0)
+#define SHRINKER_NUMA_AWARE     (1 << 0)
+#define SHRINKER_MEMCG_AWARE    (1 << 1)
 
 extern int register_shrinker(struct shrinker *);
 extern void unregister_shrinker(struct shrinker *);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 85ab7d72b54c..1bb36edb66b9 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -626,8 +626,11 @@ struct sk_buff {
         __u32                   hash;
         __be16                  vlan_proto;
         __u16                   vlan_tci;
-#ifdef CONFIG_NET_RX_BUSY_POLL
-        unsigned int    napi_id;
+#if defined(CONFIG_NET_RX_BUSY_POLL) || defined(CONFIG_XPS)
+        union {
+                unsigned int    napi_id;
+                unsigned int    sender_cpu;
+        };
 #endif
 #ifdef CONFIG_NETWORK_SECMARK
         __u32                   secmark;
@@ -2484,19 +2487,18 @@ static inline int skb_put_padto(struct sk_buff *skb, unsigned int len)
 }
 
 static inline int skb_add_data(struct sk_buff *skb,
-                               char __user *from, int copy)
+                               struct iov_iter *from, int copy)
 {
         const int off = skb->len;
 
         if (skb->ip_summed == CHECKSUM_NONE) {
-                int err = 0;
-                __wsum csum = csum_and_copy_from_user(from, skb_put(skb, copy),
-                                                            copy, 0, &err);
-                if (!err) {
+                __wsum csum = 0;
+                if (csum_and_copy_from_iter(skb_put(skb, copy), copy,
+                                            &csum, from) == copy) {
                         skb->csum = csum_block_add(skb->csum, csum, off);
                         return 0;
                 }
-        } else if (!copy_from_user(skb_put(skb, copy), from, copy))
+        } else if (copy_from_iter(skb_put(skb, copy), copy, from) == copy)
                 return 0;
 
         __skb_trim(skb, off);
@@ -2693,8 +2695,7 @@ int skb_vlan_push(struct sk_buff *skb, __be16 vlan_proto, u16 vlan_tci);
 
 static inline int memcpy_from_msg(void *data, struct msghdr *msg, int len)
 {
-        /* XXX: stripping const */
-        return memcpy_fromiovec(data, (struct iovec *)msg->msg_iter.iov, len);
+        return copy_from_iter(data, len, &msg->msg_iter) == len ? 0 : -EFAULT;
 }
 
 static inline int memcpy_to_msg(struct msghdr *msg, void *data, int len)
@@ -3071,7 +3072,7 @@ static inline __wsum null_compute_pseudo(struct sk_buff *skb, int proto)
 
 #define skb_checksum_validate_zero_check(skb, proto, check,             \
                                          compute_pseudo)                \
-        __skb_checksum_validate_(skb, proto, true, true, check, compute_pseudo)
+        __skb_checksum_validate(skb, proto, true, true, check, compute_pseudo)
 
 #define skb_checksum_simple_validate(skb)                               \
         __skb_checksum_validate(skb, 0, true, false, 0, null_compute_pseudo)
@@ -3096,6 +3097,27 @@ do {									\
                                        compute_pseudo(skb, proto));     \
 } while (0)
 
+/* Update skbuf and packet to reflect the remote checksum offload operation.
+ * When called, ptr indicates the starting point for skb->csum when
+ * ip_summed is CHECKSUM_COMPLETE. If we need create checksum complete
+ * here, skb_postpull_rcsum is done so skb->csum start is ptr.
+ */
+static inline void skb_remcsum_process(struct sk_buff *skb, void *ptr,
+                                       int start, int offset)
+{
+        __wsum delta;
+
+         if (unlikely(skb->ip_summed != CHECKSUM_COMPLETE)) {
+                __skb_checksum_complete(skb);
+                skb_postpull_rcsum(skb, skb->data, ptr - (void *)skb->data);
+        }
+
+        delta = remcsum_adjust(ptr, skb->csum, start, offset);
+
+        /* Adjust skb->csum since we changed the packet */
+        skb->csum = csum_add(skb->csum, delta);
+}
+
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 void nf_conntrack_destroy(struct nf_conntrack *nfct);
 static inline void nf_conntrack_put(struct nf_conntrack *nfct)
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 9a139b637069..76f1feeabd38 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -104,6 +104,7 @@
                                 (unsigned long)ZERO_SIZE_PTR)
 
 #include <linux/kmemleak.h>
+#include <linux/kasan.h>
 
 struct mem_cgroup;
 /*
@@ -115,14 +116,12 @@ int slab_is_available(void);
 struct kmem_cache *kmem_cache_create(const char *, size_t, size_t,
                         unsigned long,
                         void (*)(void *));
-#ifdef CONFIG_MEMCG_KMEM
-struct kmem_cache *memcg_create_kmem_cache(struct mem_cgroup *,
-                                           struct kmem_cache *,
-                                           const char *);
-#endif
 void kmem_cache_destroy(struct kmem_cache *);
 int kmem_cache_shrink(struct kmem_cache *);
-void kmem_cache_free(struct kmem_cache *, void *);
+
+void memcg_create_kmem_cache(struct mem_cgroup *, struct kmem_cache *);
+void memcg_deactivate_kmem_caches(struct mem_cgroup *);
+void memcg_destroy_kmem_caches(struct mem_cgroup *);
 
 /*
  * Please use this macro to create slab caches. Simply specify the
@@ -289,6 +288,7 @@ static __always_inline int kmalloc_index(size_t size)
 
 void *__kmalloc(size_t size, gfp_t flags);
 void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags);
+void kmem_cache_free(struct kmem_cache *, void *);
 
 #ifdef CONFIG_NUMA
 void *__kmalloc_node(size_t size, gfp_t flags, int node);
@@ -326,7 +326,10 @@ kmem_cache_alloc_node_trace(struct kmem_cache *s,
 static __always_inline void *kmem_cache_alloc_trace(struct kmem_cache *s,
                 gfp_t flags, size_t size)
 {
-        return kmem_cache_alloc(s, flags);
+        void *ret = kmem_cache_alloc(s, flags);
+
+        kasan_kmalloc(s, ret, size);
+        return ret;
 }
 
 static __always_inline void *
@@ -334,7 +337,10 @@ kmem_cache_alloc_node_trace(struct kmem_cache *s,
                               gfp_t gfpflags,
                               int node, size_t size)
 {
-        return kmem_cache_alloc_node(s, gfpflags, node);
+        void *ret = kmem_cache_alloc_node(s, gfpflags, node);
+
+        kasan_kmalloc(s, ret, size);
+        return ret;
 }
 #endif /* CONFIG_TRACING */
 
@@ -474,14 +480,14 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 #ifndef ARCH_SLAB_MINALIGN
 #define ARCH_SLAB_MINALIGN __alignof__(unsigned long long)
 #endif
+
+struct memcg_cache_array {
+        struct rcu_head rcu;
+        struct kmem_cache *entries[0];
+};
+
 /*
  * This is the main placeholder for memcg-related information in kmem caches.
- * struct kmem_cache will hold a pointer to it, so the memory cost while
- * disabled is 1 pointer. The runtime cost while enabled, gets bigger than it
- * would otherwise be if that would be bundled in kmem_cache: we'll need an
- * extra pointer chase. But the trade off clearly lays in favor of not
- * penalizing non-users.
- *
  * Both the root cache and the child caches will have it. For the root cache,
  * this will hold a dynamically allocated array large enough to hold
  * information about the currently limited memcgs in the system. To allow the
@@ -491,19 +497,18 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
  * Child caches will hold extra metadata needed for its operation. Fields are:
  *
  * @memcg: pointer to the memcg this cache belongs to
- * @list: list_head for the list of all caches in this memcg
  * @root_cache: pointer to the global, root cache, this cache was derived from
+ *
+ * Both root and child caches of the same kind are linked into a list chained
+ * through @list.
  */
 struct memcg_cache_params {
         bool is_root_cache;
+        struct list_head list;
         union {
-                struct {
-                        struct rcu_head rcu_head;
-                        struct kmem_cache *memcg_caches[0];
-                };
+                struct memcg_cache_array __rcu *memcg_caches;
                 struct {
                         struct mem_cgroup *memcg;
-                        struct list_head list;
                         struct kmem_cache *root_cache;
                 };
         };
diff --git a/include/linux/slab_def.h b/include/linux/slab_def.h
index b869d1662ba3..33d049066c3d 100644
--- a/include/linux/slab_def.h
+++ b/include/linux/slab_def.h
@@ -70,7 +70,7 @@ struct kmem_cache {
         int obj_offset;
 #endif /* CONFIG_DEBUG_SLAB */
 #ifdef CONFIG_MEMCG_KMEM
-        struct memcg_cache_params *memcg_params;
+        struct memcg_cache_params memcg_params;
 #endif
 
         struct kmem_cache_node *node[MAX_NUMNODES];
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index d82abd40a3c0..33885118523c 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -85,7 +85,7 @@ struct kmem_cache {
         struct kobject kobj;    /* For sysfs */
 #endif
 #ifdef CONFIG_MEMCG_KMEM
-        struct memcg_cache_params *memcg_params;
+        struct memcg_cache_params memcg_params;
         int max_attr_size; /* for propagation, maximum size of a stored attr */
 #ifdef CONFIG_SYSFS
         struct kset *memcg_kset;
@@ -110,4 +110,23 @@ static inline void sysfs_slab_remove(struct kmem_cache *s)
 }
 #endif
 
+
+/**
+ * virt_to_obj - returns address of the beginning of object.
+ * @s: object's kmem_cache
+ * @slab_page: address of slab page
+ * @x: address within object memory range
+ *
+ * Returns address of the beginning of object
+ */
+static inline void *virt_to_obj(struct kmem_cache *s,
+                                const void *slab_page,
+                                const void *x)
+{
+        return (void *)x - ((x - slab_page) % s->size);
+}
+
+void object_err(struct kmem_cache *s, struct page *page,
+                u8 *object, char *reason);
+
 #endif /* _LINUX_SLUB_DEF_H */
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 93dff5fff524..be91db2a7017 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -151,6 +151,13 @@ smp_call_function_any(const struct cpumask *mask, smp_call_func_t func,
 static inline void kick_all_cpus_sync(void) {  }
 static inline void wake_up_all_idle_cpus(void) {  }
 
+#ifdef CONFIG_UP_LATE_INIT
+extern void __init up_late_init(void);
+static inline void smp_init(void) { up_late_init(); }
+#else
+static inline void smp_init(void) { }
+#endif
+
 #endif /* !SMP */
 
 /*
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 6e49a14365dc..5c19cba34dce 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -318,13 +318,6 @@ struct ucred {
 /* IPX options */
 #define IPX_TYPE        1
 
-extern int csum_partial_copy_fromiovecend(unsigned char *kdata, 
-                                          struct iovec *iov, 
-                                          int offset, 
-                                          unsigned int len, __wsum *csump);
-extern unsigned long iov_pages(const struct iovec *iov, int offset,
-                               unsigned long nr_segs);
-
 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
diff --git a/include/linux/spi/at86rf230.h b/include/linux/spi/at86rf230.h
index b2b1afbb3202..cd519a11c2c6 100644
--- a/include/linux/spi/at86rf230.h
+++ b/include/linux/spi/at86rf230.h
@@ -12,10 +12,6 @@
  * 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.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
- *
  * Written by:
  * Dmitry Eremin-Solenikov <dmitry.baryshkov@siemens.com>
  */
diff --git a/include/linux/spi/l4f00242t03.h b/include/linux/spi/l4f00242t03.h
index bc8677c8eba9..e69e9b51b21a 100644
--- a/include/linux/spi/l4f00242t03.h
+++ b/include/linux/spi/l4f00242t03.h
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
 #ifndef _INCLUDE_LINUX_SPI_L4F00242T03_H_
diff --git a/include/linux/spi/lms283gf05.h b/include/linux/spi/lms283gf05.h
index 555d254e6606..fdd1d1d51da5 100644
--- a/include/linux/spi/lms283gf05.h
+++ b/include/linux/spi/lms283gf05.h
@@ -11,10 +11,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
 #ifndef _INCLUDE_LINUX_SPI_LMS283GF05_H_
diff --git a/include/linux/spi/mxs-spi.h b/include/linux/spi/mxs-spi.h
index 4835486f58e5..381d368b91b4 100644
--- a/include/linux/spi/mxs-spi.h
+++ b/include/linux/spi/mxs-spi.h
@@ -15,10 +15,6 @@
  * 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.,
- * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  */
 
 #ifndef __LINUX_SPI_MXS_SPI_H__
diff --git a/include/linux/spi/pxa2xx_spi.h b/include/linux/spi/pxa2xx_spi.h
index d5a316550177..6d36dacec4ba 100644
--- a/include/linux/spi/pxa2xx_spi.h
+++ b/include/linux/spi/pxa2xx_spi.h
@@ -10,10 +10,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 #ifndef __linux_pxa2xx_spi_h
 #define __linux_pxa2xx_spi_h
@@ -57,7 +53,6 @@ struct pxa2xx_spi_chip {
 #if defined(CONFIG_ARCH_PXA) || defined(CONFIG_ARCH_MMP)
 
 #include <linux/clk.h>
-#include <mach/dma.h>
 
 extern void pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_master *info);
 
diff --git a/include/linux/spi/rspi.h b/include/linux/spi/rspi.h
index e546b2ceb623..a693188cc08b 100644
--- a/include/linux/spi/rspi.h
+++ b/include/linux/spi/rspi.h
@@ -11,11 +11,6 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- *
  */
 
 #ifndef __LINUX_SPI_RENESAS_SPI_H__
diff --git a/include/linux/spi/sh_hspi.h b/include/linux/spi/sh_hspi.h
index a1121f872ac1..aa0d440ab4f0 100644
--- a/include/linux/spi/sh_hspi.h
+++ b/include/linux/spi/sh_hspi.h
@@ -9,10 +9,6 @@
  * 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 #ifndef SH_HSPI_H
 #define SH_HSPI_H
diff --git a/include/linux/spi/sh_msiof.h b/include/linux/spi/sh_msiof.h
index 88a14d81c49e..b087a85f5f72 100644
--- a/include/linux/spi/sh_msiof.h
+++ b/include/linux/spi/sh_msiof.h
@@ -7,6 +7,8 @@ struct sh_msiof_spi_info {
         u16 num_chipselect;
         unsigned int dma_tx_id;
         unsigned int dma_rx_id;
+        u32 dtdl;
+        u32 syncdl;
 };
 
 #endif /* __SPI_SH_MSIOF_H__ */
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index a6ef2a8e6de4..ed9489d893a4 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -10,10 +10,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #ifndef __LINUX_SPI_H
@@ -260,6 +256,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @pump_messages: work struct for scheduling work to the message pump
  * @queue_lock: spinlock to syncronise access to message queue
  * @queue: message queue
+ * @idling: the device is entering idle state
  * @cur_msg: the currently in-flight message
  * @cur_msg_prepared: spi_prepare_message was called for the currently
  *                    in-flight message
@@ -425,6 +422,7 @@ struct spi_master {
         spinlock_t                      queue_lock;
         struct list_head                queue;
         struct spi_message              *cur_msg;
+        bool                            idling;
         bool                            busy;
         bool                            running;
         bool                            rt;
diff --git a/include/linux/spi/tle62x0.h b/include/linux/spi/tle62x0.h
index 60b59187e590..414c6fddfcf0 100644
--- a/include/linux/spi/tle62x0.h
+++ b/include/linux/spi/tle62x0.h
@@ -12,10 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
 struct tle62x0_pdata {
diff --git a/include/linux/spi/tsc2005.h b/include/linux/spi/tsc2005.h
index 8f721e465e05..563b3b1799a8 100644
--- a/include/linux/spi/tsc2005.h
+++ b/include/linux/spi/tsc2005.h
@@ -12,11 +12,6 @@
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- *
  */
 
 #ifndef _LINUX_SPI_TSC2005_H
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 262ba4ef9a8e..3e18379dfa6f 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -190,6 +190,8 @@ static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # define raw_spin_lock_nested(lock, subclass) \
         _raw_spin_lock_nested(lock, subclass)
+# define raw_spin_lock_bh_nested(lock, subclass) \
+        _raw_spin_lock_bh_nested(lock, subclass)
 
 # define raw_spin_lock_nest_lock(lock, nest_lock)                       \
          do {                                                           \
@@ -205,6 +207,7 @@ static inline void do_raw_spin_unlock(raw_spinlock_t *lock) __releases(lock)
 # define raw_spin_lock_nested(lock, subclass)           \
         _raw_spin_lock(((void)(subclass), (lock)))
 # define raw_spin_lock_nest_lock(lock, nest_lock)       _raw_spin_lock(lock)
+# define raw_spin_lock_bh_nested(lock, subclass)        _raw_spin_lock_bh(lock)
 #endif
 
 #if defined(CONFIG_SMP) || defined(CONFIG_DEBUG_SPINLOCK)
@@ -324,6 +327,11 @@ do {								\
         raw_spin_lock_nested(spinlock_check(lock), subclass);   \
 } while (0)
 
+#define spin_lock_bh_nested(lock, subclass)                     \
+do {                                                            \
+        raw_spin_lock_bh_nested(spinlock_check(lock), subclass);\
+} while (0)
+
 #define spin_lock_nest_lock(lock, nest_lock)                            \
 do {                                                                    \
         raw_spin_lock_nest_lock(spinlock_check(lock), nest_lock);       \
diff --git a/include/linux/spinlock_api_smp.h b/include/linux/spinlock_api_smp.h
index 42dfab89e740..5344268e6e62 100644
--- a/include/linux/spinlock_api_smp.h
+++ b/include/linux/spinlock_api_smp.h
@@ -22,6 +22,8 @@ int in_lock_functions(unsigned long addr);
 void __lockfunc _raw_spin_lock(raw_spinlock_t *lock)            __acquires(lock);
 void __lockfunc _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)
                                                                 __acquires(lock);
+void __lockfunc _raw_spin_lock_bh_nested(raw_spinlock_t *lock, int subclass)
+                                                                __acquires(lock);
 void __lockfunc
 _raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)
                                                                 __acquires(lock);
diff --git a/include/linux/spinlock_api_up.h b/include/linux/spinlock_api_up.h
index d0d188861ad6..d3afef9d8dbe 100644
--- a/include/linux/spinlock_api_up.h
+++ b/include/linux/spinlock_api_up.h
@@ -57,6 +57,7 @@
 
 #define _raw_spin_lock(lock)                    __LOCK(lock)
 #define _raw_spin_lock_nested(lock, subclass)   __LOCK(lock)
+#define _raw_spin_lock_bh_nested(lock, subclass) __LOCK(lock)
 #define _raw_read_lock(lock)                    __LOCK(lock)
 #define _raw_write_lock(lock)                   __LOCK(lock)
 #define _raw_spin_lock_bh(lock)                 __LOCK_BH(lock)
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index a2783cb5d275..9cfd9623fb03 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -45,7 +45,7 @@ struct rcu_batch {
 #define RCU_BATCH_INIT(name) { NULL, &(name.head) }
 
 struct srcu_struct {
-        unsigned completed;
+        unsigned long completed;
         struct srcu_struct_array __percpu *per_cpu_ref;
         spinlock_t queue_lock; /* protect ->batch_queue, ->running */
         bool running;
@@ -102,13 +102,11 @@ void process_srcu(struct work_struct *work);
  * define and init a srcu struct at build time.
  * dont't call init_srcu_struct() nor cleanup_srcu_struct() on it.
  */
-#define DEFINE_SRCU(name)                                               \
+#define __DEFINE_SRCU(name, is_static)                                  \
         static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
-        struct srcu_struct name = __SRCU_STRUCT_INIT(name);
-
-#define DEFINE_STATIC_SRCU(name)                                        \
-        static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
-        static struct srcu_struct name = __SRCU_STRUCT_INIT(name);
+        is_static struct srcu_struct name = __SRCU_STRUCT_INIT(name)
+#define DEFINE_SRCU(name)               __DEFINE_SRCU(name, /* not static */)
+#define DEFINE_STATIC_SRCU(name)        __DEFINE_SRCU(name, static)
 
 /**
  * call_srcu() - Queue a callback for invocation after an SRCU grace period
@@ -135,7 +133,7 @@ int __srcu_read_lock(struct srcu_struct *sp) __acquires(sp);
 void __srcu_read_unlock(struct srcu_struct *sp, int idx) __releases(sp);
 void synchronize_srcu(struct srcu_struct *sp);
 void synchronize_srcu_expedited(struct srcu_struct *sp);
-long srcu_batches_completed(struct srcu_struct *sp);
+unsigned long srcu_batches_completed(struct srcu_struct *sp);
 void srcu_barrier(struct srcu_struct *sp);
 
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
diff --git a/include/linux/ssb/ssb_regs.h b/include/linux/ssb/ssb_regs.h
index f7b9100686c3..c0f707ac192b 100644
--- a/include/linux/ssb/ssb_regs.h
+++ b/include/linux/ssb/ssb_regs.h
@@ -173,6 +173,7 @@
 #define SSB_SPROMSIZE_BYTES_R123        (SSB_SPROMSIZE_WORDS_R123 * sizeof(u16))
 #define SSB_SPROMSIZE_BYTES_R4          (SSB_SPROMSIZE_WORDS_R4 * sizeof(u16))
 #define SSB_SPROMSIZE_WORDS_R10         230
+#define SSB_SPROMSIZE_WORDS_R11         234
 #define SSB_SPROM_BASE1                 0x1000
 #define SSB_SPROM_BASE31                0x0800
 #define SSB_SPROM_REVISION              0x007E
diff --git a/include/linux/string.h b/include/linux/string.h
index 2e22a2e58f3a..e40099e585c9 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -40,9 +40,6 @@ extern int strcmp(const char *,const char *);
 #ifndef __HAVE_ARCH_STRNCMP
 extern int strncmp(const char *,const char *,__kernel_size_t);
 #endif
-#ifndef __HAVE_ARCH_STRNICMP
-#define strnicmp strncasecmp
-#endif
 #ifndef __HAVE_ARCH_STRCASECMP
 extern int strcasecmp(const char *s1, const char *s2);
 #endif
@@ -115,7 +112,10 @@ extern void * memchr(const void *,int,__kernel_size_t);
 #endif
 void *memchr_inv(const void *s, int c, size_t n);
 
+extern void kfree_const(const void *x);
+
 extern char *kstrdup(const char *s, gfp_t gfp);
+extern const char *kstrdup_const(const char *s, gfp_t gfp);
 extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
 extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
 
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index 6eb567ac56bc..657571817260 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -10,8 +10,8 @@ enum string_size_units {
         STRING_UNITS_2,         /* use binary powers of 2^10 */
 };
 
-int string_get_size(u64 size, enum string_size_units units,
-                    char *buf, int len);
+void string_get_size(u64 size, enum string_size_units units,
+                     char *buf, int len);
 
 #define UNESCAPE_SPACE          0x01
 #define UNESCAPE_OCTAL          0x02
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index d86acc63b25f..598ba80ec30c 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -57,7 +57,7 @@ struct rpc_clnt {
         const struct rpc_timeout *cl_timeout;   /* Timeout strategy */
 
         int                     cl_nodelen;     /* nodename length */
-        char                    cl_nodename[UNX_MAXNODENAME];
+        char                    cl_nodename[UNX_MAXNODENAME+1];
         struct rpc_pipe_dir_head cl_pipedir_objects;
         struct rpc_clnt *       cl_parent;      /* Points to parent of clones */
         struct rpc_rtt          cl_rtt_default;
@@ -112,6 +112,7 @@ struct rpc_create_args {
         struct sockaddr         *saddress;
         const struct rpc_timeout *timeout;
         const char              *servername;
+        const char              *nodename;
         const struct rpc_program *program;
         u32                     prognumber;     /* overrides program->number */
         u32                     version;
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index eecb5a71e6c0..7e61a17030a4 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -79,6 +79,8 @@ struct rpc_clnt;
 struct rpc_iostats *    rpc_alloc_iostats(struct rpc_clnt *);
 void                    rpc_count_iostats(const struct rpc_task *,
                                           struct rpc_iostats *);
+void                    rpc_count_iostats_metrics(const struct rpc_task *,
+                                          struct rpc_iostats *);
 void                    rpc_print_iostats(struct seq_file *, struct rpc_clnt *);
 void                    rpc_free_iostats(struct rpc_iostats *);
 
@@ -87,6 +89,8 @@ void			rpc_free_iostats(struct rpc_iostats *);
 static inline struct rpc_iostats *rpc_alloc_iostats(struct rpc_clnt *clnt) { return NULL; }
 static inline void rpc_count_iostats(const struct rpc_task *task,
                                      struct rpc_iostats *stats) {}
+static inline void rpc_count_iostats_metrics(const struct rpc_task *,
+                                             struct rpc_iostats *) {}
 static inline void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt) {}
 static inline void rpc_free_iostats(struct rpc_iostats *stats) {}
 
diff --git a/include/linux/sunrpc/rpc_rdma.h b/include/linux/sunrpc/rpc_rdma.h
index b78f16b1dea3..f33c5a4d6fe4 100644
--- a/include/linux/sunrpc/rpc_rdma.h
+++ b/include/linux/sunrpc/rpc_rdma.h
@@ -42,6 +42,9 @@
 
 #include <linux/types.h>
 
+#define RPCRDMA_VERSION         1
+#define rpcrdma_version         cpu_to_be32(RPCRDMA_VERSION)
+
 struct rpcrdma_segment {
         __be32 rs_handle;       /* Registered memory handle */
         __be32 rs_length;       /* Length of the chunk in bytes */
@@ -95,7 +98,10 @@ struct rpcrdma_msg {
         } rm_body;
 };
 
-#define RPCRDMA_HDRLEN_MIN      28
+/*
+ * Smallest RPC/RDMA header: rm_xid through rm_type, then rm_nochunks
+ */
+#define RPCRDMA_HDRLEN_MIN      (sizeof(__be32) * 7)
 
 enum rpcrdma_errcode {
         ERR_VERS = 1,
@@ -115,4 +121,10 @@ enum rpcrdma_proc {
         RDMA_ERROR = 4          /* An RPC RDMA encoding error */
 };
 
+#define rdma_msg        cpu_to_be32(RDMA_MSG)
+#define rdma_nomsg      cpu_to_be32(RDMA_NOMSG)
+#define rdma_msgp       cpu_to_be32(RDMA_MSGP)
+#define rdma_done       cpu_to_be32(RDMA_DONE)
+#define rdma_error      cpu_to_be32(RDMA_ERROR)
+
 #endif                          /* _LINUX_SUNRPC_RPC_RDMA_H */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 6f22cfeef5e3..fae6fb947fc8 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -110,7 +110,7 @@ struct svc_serv {
  * We use sv_nrthreads as a reference count.  svc_destroy() drops
  * this refcount, so we need to bump it up around operations that
  * change the number of threads.  Horrible, but there it is.
- * Should be called with the BKL held.
+ * Should be called with the "service mutex" held.
  */
 static inline void svc_get(struct svc_serv *serv)
 {
diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h
index 975da754c778..df8edf8ec914 100644
--- a/include/linux/sunrpc/svc_rdma.h
+++ b/include/linux/sunrpc/svc_rdma.h
@@ -63,8 +63,6 @@ extern atomic_t rdma_stat_rq_prod;
 extern atomic_t rdma_stat_sq_poll;
 extern atomic_t rdma_stat_sq_prod;
 
-#define RPCRDMA_VERSION 1
-
 /*
  * Contexts are built when an RDMA request is created and are a
  * record of the resources that can be recovered when the request
@@ -79,6 +77,7 @@ struct svc_rdma_op_ctxt {
         enum ib_wr_opcode wr_op;
         enum ib_wc_status wc_status;
         u32 byte_len;
+        u32 position;
         struct svcxprt_rdma *xprt;
         unsigned long flags;
         enum dma_data_direction direction;
@@ -150,6 +149,10 @@ struct svcxprt_rdma {
         struct ib_cq         *sc_rq_cq;
         struct ib_cq         *sc_sq_cq;
         struct ib_mr         *sc_phys_mr;       /* MR for server memory */
+        int                  (*sc_reader)(struct svcxprt_rdma *,
+                                          struct svc_rqst *,
+                                          struct svc_rdma_op_ctxt *,
+                                          int *, u32 *, u32, u32, u64, bool);
         u32                  sc_dev_caps;       /* distilled device caps */
         u32                  sc_dma_lkey;       /* local dma key */
         unsigned int         sc_frmr_pg_list_len;
@@ -178,8 +181,6 @@ struct svcxprt_rdma {
 #define RPCRDMA_MAX_REQ_SIZE    4096
 
 /* svc_rdma_marshal.c */
-extern void svc_rdma_rcl_chunk_counts(struct rpcrdma_read_chunk *,
-                                      int *, int *);
 extern int svc_rdma_xdr_decode_req(struct rpcrdma_msg **, struct svc_rqst *);
 extern int svc_rdma_xdr_decode_deferred_req(struct svc_rqst *);
 extern int svc_rdma_xdr_encode_error(struct svcxprt_rdma *,
@@ -197,6 +198,12 @@ extern int svc_rdma_xdr_get_reply_hdr_len(struct rpcrdma_msg *);
 
 /* svc_rdma_recvfrom.c */
 extern int svc_rdma_recvfrom(struct svc_rqst *);
+extern int rdma_read_chunk_lcl(struct svcxprt_rdma *, struct svc_rqst *,
+                               struct svc_rdma_op_ctxt *, int *, u32 *,
+                               u32, u32, u64, bool);
+extern int rdma_read_chunk_frmr(struct svcxprt_rdma *, struct svc_rqst *,
+                                struct svc_rdma_op_ctxt *, int *, u32 *,
+                                u32, u32, u64, bool);
 
 /* svc_rdma_sendto.c */
 extern int svc_rdma_sendto(struct svc_rqst *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 9d27ac45b909..8b93ef53df3c 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -347,6 +347,9 @@ void			xprt_force_disconnect(struct rpc_xprt *xprt);
 void                    xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
 int                     xs_swapper(struct rpc_xprt *xprt, int enable);
 
+bool                    xprt_lock_connect(struct rpc_xprt *, struct rpc_task *, void *);
+void                    xprt_unlock_connect(struct rpc_xprt *, void *);
+
 /*
  * Reserved bit positions in xprt->state
  */
@@ -357,10 +360,7 @@ int			xs_swapper(struct rpc_xprt *xprt, int enable);
 #define XPRT_BOUND              (4)
 #define XPRT_BINDING            (5)
 #define XPRT_CLOSING            (6)
-#define XPRT_CONNECTION_ABORT   (7)
-#define XPRT_CONNECTION_CLOSE   (8)
 #define XPRT_CONGESTED          (9)
-#define XPRT_CONNECTION_REUSE   (10)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 34e8b60ab973..7067eca501e2 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -437,16 +437,6 @@ extern int reuse_swap_page(struct page *);
 extern int try_to_free_swap(struct page *);
 struct backing_dev_info;
 
-#ifdef CONFIG_MEMCG
-extern void
-mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout);
-#else
-static inline void
-mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
-{
-}
-#endif
-
 #else /* CONFIG_SWAP */
 
 #define swap_address_space(entry)               (NULL)
@@ -547,11 +537,6 @@ static inline swp_entry_t get_swap_page(void)
         return entry;
 }
 
-static inline void
-mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent)
-{
-}
-
 #endif /* CONFIG_SWAP */
 #endif /* __KERNEL__*/
 #endif /* _LINUX_SWAP_H */
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 6adfb7bfbf44..cedf3d3c373f 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -54,7 +54,7 @@ static inline pgoff_t swp_offset(swp_entry_t entry)
 /* check whether a pte points to a swap entry */
 static inline int is_swap_pte(pte_t pte)
 {
-        return !pte_none(pte) && !pte_present_nonuma(pte) && !pte_file(pte);
+        return !pte_none(pte) && !pte_present(pte);
 }
 #endif
 
@@ -66,7 +66,6 @@ static inline swp_entry_t pte_to_swp_entry(pte_t pte)
 {
         swp_entry_t arch_entry;
 
-        BUG_ON(pte_file(pte));
         if (pte_swp_soft_dirty(pte))
                 pte = pte_swp_clear_soft_dirty(pte);
         arch_entry = __pte_to_swp_entry(pte);
@@ -82,7 +81,6 @@ static inline pte_t swp_entry_to_pte(swp_entry_t entry)
         swp_entry_t arch_entry;
 
         arch_entry = __swp_entry(swp_type(entry), swp_offset(entry));
-        BUG_ON(pte_file(__swp_entry_to_pte(arch_entry)));
         return __swp_entry_to_pte(arch_entry);
 }
 
@@ -137,6 +135,8 @@ static inline void make_migration_entry_read(swp_entry_t *entry)
         *entry = swp_entry(SWP_MIGRATION_READ, swp_offset(*entry));
 }
 
+extern void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
+                                        spinlock_t *ptl);
 extern void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
                                         unsigned long address);
 extern void migration_entry_wait_huge(struct vm_area_struct *vma,
@@ -150,6 +150,8 @@ static inline int is_migration_entry(swp_entry_t swp)
 }
 #define migration_entry_to_page(swp) NULL
 static inline void make_migration_entry_read(swp_entry_t *entryp) { }
+static inline void __migration_entry_wait(struct mm_struct *mm, pte_t *ptep,
+                                        spinlock_t *ptl) { }
 static inline void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
                                          unsigned long address) { }
 static inline void migration_entry_wait_huge(struct vm_area_struct *vma,
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 85893d744901..76d1e38aabe1 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -410,12 +410,16 @@ asmlinkage long sys_newlstat(const char __user *filename,
                                 struct stat __user *statbuf);
 asmlinkage long sys_newfstat(unsigned int fd, struct stat __user *statbuf);
 asmlinkage long sys_ustat(unsigned dev, struct ustat __user *ubuf);
-#if BITS_PER_LONG == 32
+#if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
 asmlinkage long sys_stat64(const char __user *filename,
                                 struct stat64 __user *statbuf);
 asmlinkage long sys_fstat64(unsigned long fd, struct stat64 __user *statbuf);
 asmlinkage long sys_lstat64(const char __user *filename,
                                 struct stat64 __user *statbuf);
+asmlinkage long sys_fstatat64(int dfd, const char __user *filename,
+                               struct stat64 __user *statbuf, int flag);
+#endif
+#if BITS_PER_LONG == 32
 asmlinkage long sys_truncate64(const char __user *path, loff_t length);
 asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length);
 #endif
@@ -771,8 +775,6 @@ asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
                            umode_t mode);
 asmlinkage long sys_newfstatat(int dfd, const char __user *filename,
                                struct stat __user *statbuf, int flag);
-asmlinkage long sys_fstatat64(int dfd, const char __user *filename,
-                               struct stat64 __user *statbuf, int flag);
 asmlinkage long sys_readlinkat(int dfd, const char __user *path, char __user *buf,
                                int bufsiz);
 asmlinkage long sys_utimensat(int dfd, const char __user *filename,
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 67309ece0772..1a7adb411647 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -115,6 +115,7 @@ struct tcp_request_sock {
         u32                             rcv_isn;
         u32                             snt_isn;
         u32                             snt_synack; /* synack sent time */
+        u32                             last_oow_ack_time; /* last SYNACK */
         u32                             rcv_nxt; /* the ack # by SYNACK. For
                                                   * FastOpen it's the seq#
                                                   * after data-in-SYN.
@@ -152,6 +153,7 @@ struct tcp_sock {
         u32     snd_sml;        /* Last byte of the most recently transmitted small packet */
         u32     rcv_tstamp;     /* timestamp of last received ACK (for keepalives) */
         u32     lsndtime;       /* timestamp of last sent data packet (for restart window) */
+        u32     last_oow_ack_time;  /* timestamp of last out-of-window ACK */
 
         u32     tsoffset;       /* timestamp offset */
 
@@ -340,6 +342,10 @@ struct tcp_timewait_sock {
         u32                       tw_rcv_wnd;
         u32                       tw_ts_offset;
         u32                       tw_ts_recent;
+
+        /* The time we sent the last out-of-window ACK: */
+        u32                       tw_last_oow_ack_time;
+
         long                      tw_ts_recent_stamp;
 #ifdef CONFIG_TCP_MD5SIG
         struct tcp_md5sig_key     *tw_md5_key;
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index c611a02fbc51..fc52e307efab 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -38,7 +38,7 @@
 #define THERMAL_CSTATE_INVALID -1UL
 
 /* No upper/lower limit requirement */
-#define THERMAL_NO_LIMIT        THERMAL_CSTATE_INVALID
+#define THERMAL_NO_LIMIT        ((u32)~0)
 
 /* Unit conversion macros */
 #define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
diff --git a/include/linux/ti_wilink_st.h b/include/linux/ti_wilink_st.h
index 884d6263e962..c78dcfeaf25f 100644
--- a/include/linux/ti_wilink_st.h
+++ b/include/linux/ti_wilink_st.h
@@ -86,6 +86,7 @@ struct st_proto_s {
 extern long st_register(struct st_proto_s *);
 extern long st_unregister(struct st_proto_s *);
 
+extern struct ti_st_plat_data   *dt_pdata;
 
 /*
  * header information used by st_core.c
@@ -261,7 +262,7 @@ struct kim_data_s {
         struct completion kim_rcvd, ldisc_installed;
         char resp_buffer[30];
         const struct firmware *fw_entry;
-        long nshutdown;
+        unsigned nshutdown;
         unsigned long rx_state;
         unsigned long rx_count;
         struct sk_buff *rx_skb;
@@ -269,8 +270,8 @@ struct kim_data_s {
         struct chip_version version;
         unsigned char ldisc_install;
         unsigned char dev_name[UART_DEV_NAME_LEN + 1];
-        unsigned char flow_cntrl;
-        unsigned long baud_rate;
+        unsigned flow_cntrl;
+        unsigned baud_rate;
 };
 
 /**
@@ -436,10 +437,10 @@ struct gps_event_hdr {
  *
  */
 struct ti_st_plat_data {
-        long nshutdown_gpio;
+        u32 nshutdown_gpio;
         unsigned char dev_name[UART_DEV_NAME_LEN]; /* uart name */
-        unsigned char flow_cntrl; /* flow control flag */
-        unsigned long baud_rate;
+        u32 flow_cntrl; /* flow control flag */
+        u32 baud_rate;
         int (*suspend)(struct platform_device *, pm_message_t);
         int (*resume)(struct platform_device *);
         int (*chip_enable) (struct kim_data_s *);
diff --git a/include/linux/time.h b/include/linux/time.h
index 203c2ad40d71..beebe3a02d43 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -110,6 +110,19 @@ static inline bool timespec_valid_strict(const struct timespec *ts)
         return true;
 }
 
+static inline bool timeval_valid(const struct timeval *tv)
+{
+        /* Dates before 1970 are bogus */
+        if (tv->tv_sec < 0)
+                return false;
+
+        /* Can't have more microseconds then a second */
+        if (tv->tv_usec < 0 || tv->tv_usec >= USEC_PER_SEC)
+                return false;
+
+        return true;
+}
+
 extern struct timespec timespec_trunc(struct timespec t, unsigned gran);
 
 #define CURRENT_TIME            (current_kernel_time())
diff --git a/include/linux/timecounter.h b/include/linux/timecounter.h
new file mode 100644
index 000000000000..4382035a75bb
--- /dev/null
+++ b/include/linux/timecounter.h
@@ -0,0 +1,139 @@
+/*
+ * linux/include/linux/timecounter.h
+ *
+ * based on code that migrated away from
+ * linux/include/linux/clocksource.h
+ *
+ * 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.
+ */
+#ifndef _LINUX_TIMECOUNTER_H
+#define _LINUX_TIMECOUNTER_H
+
+#include <linux/types.h>
+
+/* simplify initialization of mask field */
+#define CYCLECOUNTER_MASK(bits) (cycle_t)((bits) < 64 ? ((1ULL<<(bits))-1) : -1)
+
+/**
+ * struct cyclecounter - hardware abstraction for a free running counter
+ *      Provides completely state-free accessors to the underlying hardware.
+ *      Depending on which hardware it reads, the cycle counter may wrap
+ *      around quickly. Locking rules (if necessary) have to be defined
+ *      by the implementor and user of specific instances of this API.
+ *
+ * @read:               returns the current cycle value
+ * @mask:               bitmask for two's complement
+ *                      subtraction of non 64 bit counters,
+ *                      see CYCLECOUNTER_MASK() helper macro
+ * @mult:               cycle to nanosecond multiplier
+ * @shift:              cycle to nanosecond divisor (power of two)
+ */
+struct cyclecounter {
+        cycle_t (*read)(const struct cyclecounter *cc);
+        cycle_t mask;
+        u32 mult;
+        u32 shift;
+};
+
+/**
+ * struct timecounter - layer above a %struct cyclecounter which counts nanoseconds
+ *      Contains the state needed by timecounter_read() to detect
+ *      cycle counter wrap around. Initialize with
+ *      timecounter_init(). Also used to convert cycle counts into the
+ *      corresponding nanosecond counts with timecounter_cyc2time(). Users
+ *      of this code are responsible for initializing the underlying
+ *      cycle counter hardware, locking issues and reading the time
+ *      more often than the cycle counter wraps around. The nanosecond
+ *      counter will only wrap around after ~585 years.
+ *
+ * @cc:                 the cycle counter used by this instance
+ * @cycle_last:         most recent cycle counter value seen by
+ *                      timecounter_read()
+ * @nsec:               continuously increasing count
+ * @mask:               bit mask for maintaining the 'frac' field
+ * @frac:               accumulated fractional nanoseconds
+ */
+struct timecounter {
+        const struct cyclecounter *cc;
+        cycle_t cycle_last;
+        u64 nsec;
+        u64 mask;
+        u64 frac;
+};
+
+/**
+ * cyclecounter_cyc2ns - converts cycle counter cycles to nanoseconds
+ * @cc:         Pointer to cycle counter.
+ * @cycles:     Cycles
+ * @mask:       bit mask for maintaining the 'frac' field
+ * @frac:       pointer to storage for the fractional nanoseconds.
+ */
+static inline u64 cyclecounter_cyc2ns(const struct cyclecounter *cc,
+                                      cycle_t cycles, u64 mask, u64 *frac)
+{
+        u64 ns = (u64) cycles;
+
+        ns = (ns * cc->mult) + *frac;
+        *frac = ns & mask;
+        return ns >> cc->shift;
+}
+
+/**
+ * timecounter_adjtime - Shifts the time of the clock.
+ * @delta:      Desired change in nanoseconds.
+ */
+static inline void timecounter_adjtime(struct timecounter *tc, s64 delta)
+{
+        tc->nsec += delta;
+}
+
+/**
+ * timecounter_init - initialize a time counter
+ * @tc:                 Pointer to time counter which is to be initialized/reset
+ * @cc:                 A cycle counter, ready to be used.
+ * @start_tstamp:       Arbitrary initial time stamp.
+ *
+ * After this call the current cycle register (roughly) corresponds to
+ * the initial time stamp. Every call to timecounter_read() increments
+ * the time stamp counter by the number of elapsed nanoseconds.
+ */
+extern void timecounter_init(struct timecounter *tc,
+                             const struct cyclecounter *cc,
+                             u64 start_tstamp);
+
+/**
+ * timecounter_read - return nanoseconds elapsed since timecounter_init()
+ *                    plus the initial time stamp
+ * @tc:          Pointer to time counter.
+ *
+ * In other words, keeps track of time since the same epoch as
+ * the function which generated the initial time stamp.
+ */
+extern u64 timecounter_read(struct timecounter *tc);
+
+/**
+ * timecounter_cyc2time - convert a cycle counter to same
+ *                        time base as values returned by
+ *                        timecounter_read()
+ * @tc:         Pointer to time counter.
+ * @cycle_tstamp:       a value returned by tc->cc->read()
+ *
+ * Cycle counts that are converted correctly as long as they
+ * fall into the interval [-1/2 max cycle count, +1/2 max cycle count],
+ * with "max cycle count" == cs->mask+1.
+ *
+ * This allows conversion of cycle counter values which were generated
+ * in the past.
+ */
+extern u64 timecounter_cyc2time(struct timecounter *tc,
+                                cycle_t cycle_tstamp);
+
+#endif
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index 9b63d13ba82b..3eaae4754275 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -33,6 +33,7 @@ extern time64_t ktime_get_real_seconds(void);
 
 extern int __getnstimeofday64(struct timespec64 *tv);
 extern void getnstimeofday64(struct timespec64 *tv);
+extern void getboottime64(struct timespec64 *ts);
 
 #if BITS_PER_LONG == 64
 /**
@@ -72,6 +73,11 @@ static inline struct timespec get_monotonic_coarse(void)
 {
         return get_monotonic_coarse64();
 }
+
+static inline void getboottime(struct timespec *ts)
+{
+        return getboottime64(ts);
+}
 #else
 /**
  * Deprecated. Use do_settimeofday64().
@@ -129,9 +135,15 @@ static inline struct timespec get_monotonic_coarse(void)
 {
         return timespec64_to_timespec(get_monotonic_coarse64());
 }
-#endif
 
-extern void getboottime(struct timespec *ts);
+static inline void getboottime(struct timespec *ts)
+{
+        struct timespec64 ts64;
+
+        getboottime64(&ts64);
+        *ts = timespec64_to_timespec(ts64);
+}
+#endif
 
 #define do_posix_clock_monotonic_gettime(ts) ktime_get_ts(ts)
 #define ktime_get_real_ts64(ts) getnstimeofday64(ts)
@@ -217,6 +229,11 @@ static inline void get_monotonic_boottime(struct timespec *ts)
         *ts = ktime_to_timespec(ktime_get_boottime());
 }
 
+static inline void get_monotonic_boottime64(struct timespec64 *ts)
+{
+        *ts = ktime_to_timespec64(ktime_get_boottime());
+}
+
 static inline void timekeeping_clocktai(struct timespec *ts)
 {
         *ts = ktime_to_timespec(ktime_get_clocktai());
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index e08e21e5f601..c72851328ca9 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -173,7 +173,7 @@ extern void syscall_unregfunc(void);
                                 TP_PROTO(data_proto),                   \
                                 TP_ARGS(data_args),                     \
                                 TP_CONDITION(cond),,);                  \
-                if (IS_ENABLED(CONFIG_LOCKDEP)) {                       \
+                if (IS_ENABLED(CONFIG_LOCKDEP) && (cond)) {             \
                         rcu_read_lock_sched_notrace();                  \
                         rcu_dereference_sched(__tracepoint_##name.funcs);\
                         rcu_read_unlock_sched_notrace();                \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 7d66ae508e5c..358a337af598 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -14,6 +14,29 @@
 #include <linux/llist.h>
 
 
+/*
+ * Lock subclasses for tty locks
+ *
+ * TTY_LOCK_NORMAL is for normal ttys and master ptys.
+ * TTY_LOCK_SLAVE is for slave ptys only.
+ *
+ * Lock subclasses are necessary for handling nested locking with pty pairs.
+ * tty locks which use nested locking:
+ *
+ * legacy_mutex - Nested tty locks are necessary for releasing pty pairs.
+ *                The stable lock order is master pty first, then slave pty.
+ * termios_rwsem - The stable lock order is tty_buffer lock->termios_rwsem.
+ *                 Subclassing this lock enables the slave pty to hold its
+ *                 termios_rwsem when claiming the master tty_buffer lock.
+ * tty_buffer lock - slave ptys can claim nested buffer lock when handling
+ *                   signal chars. The stable lock order is slave pty, then
+ *                   master.
+ */
+
+enum {
+        TTY_LOCK_NORMAL = 0,
+        TTY_LOCK_SLAVE,
+};
 
 /*
  * (Note: the *_driver.minor_start values 1, 64, 128, 192 are
@@ -443,6 +466,7 @@ extern void tty_flush_to_ldisc(struct tty_struct *tty);
 extern void tty_buffer_free_all(struct tty_port *port);
 extern void tty_buffer_flush(struct tty_struct *tty, struct tty_ldisc *ld);
 extern void tty_buffer_init(struct tty_port *port);
+extern void tty_buffer_set_lock_subclass(struct tty_port *port);
 extern speed_t tty_termios_baud_rate(struct ktermios *termios);
 extern speed_t tty_termios_input_baud_rate(struct ktermios *termios);
 extern void tty_termios_encode_baud_rate(struct ktermios *termios,
@@ -467,7 +491,6 @@ static inline speed_t tty_get_baud_rate(struct tty_struct *tty)
 
 extern void tty_termios_copy_hw(struct ktermios *new, struct ktermios *old);
 extern int tty_termios_hw_change(struct ktermios *a, struct ktermios *b);
-extern int tty_set_termios(struct tty_struct *tty, struct ktermios *kt);
 
 extern struct tty_ldisc *tty_ldisc_ref(struct tty_struct *);
 extern void tty_ldisc_deref(struct tty_ldisc *);
diff --git a/include/linux/types.h b/include/linux/types.h
index a0bb7048687f..6747247e3f9f 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -135,12 +135,9 @@ typedef unsigned long blkcnt_t;
 #endif
 
 /*
- * The type of an index into the pagecache.  Use a #define so asm/types.h
- * can override it.
+ * The type of an index into the pagecache.
  */
-#ifndef pgoff_t
 #define pgoff_t unsigned long
-#endif
 
 /* A dma_addr_t can hold any valid DMA or bus address for the platform */
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
@@ -213,5 +210,8 @@ struct callback_head {
 };
 #define rcu_head callback_head
 
+/* clocksource cycle base type */
+typedef u64 cycle_t;
+
 #endif /*  __ASSEMBLY__ */
 #endif /* _LINUX_TYPES_H */
diff --git a/include/linux/udp.h b/include/linux/udp.h
index ee3277593222..247cfdcc4b08 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -49,11 +49,7 @@ struct udp_sock {
         unsigned int     corkflag;      /* Cork is required */
         __u8             encap_type;    /* Is this an Encapsulation socket? */
         unsigned char    no_check6_tx:1,/* Send zero UDP6 checksums on TX? */
-                         no_check6_rx:1,/* Allow zero UDP6 checksums on RX? */
-                         convert_csum:1;/* On receive, convert checksum
-                                         * unnecessary to checksum complete
-                                         * if possible.
-                                         */
+                         no_check6_rx:1;/* Allow zero UDP6 checksums on RX? */
         /*
          * Following member retains the information to create a UDP header
          * when the socket is uncorked.
@@ -102,16 +98,6 @@ static inline bool udp_get_no_check6_rx(struct sock *sk)
         return udp_sk(sk)->no_check6_rx;
 }
 
-static inline void udp_set_convert_csum(struct sock *sk, bool val)
-{
-        udp_sk(sk)->convert_csum = val;
-}
-
-static inline bool udp_get_convert_csum(struct sock *sk)
-{
-        return udp_sk(sk)->convert_csum;
-}
-
 #define udp_portaddr_for_each_entry(__sk, node, list) \
         hlist_nulls_for_each_entry(__sk, node, list, __sk_common.skc_portaddr_node)
 
diff --git a/include/linux/uio.h b/include/linux/uio.h
index 1c5e453f7ea9..3e0cb4ea3905 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -135,10 +135,4 @@ static inline void iov_iter_reexpand(struct iov_iter *i, size_t count)
 size_t csum_and_copy_to_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
 size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
 
-int memcpy_fromiovec(unsigned char *kdata, struct iovec *iov, int len);
-int memcpy_fromiovecend(unsigned char *kdata, const struct iovec *iov,
-                        int offset, int len);
-int memcpy_toiovecend(const struct iovec *v, unsigned char *kdata,
-                      int offset, int len);
-
 #endif
diff --git a/include/linux/usb.h b/include/linux/usb.h
index f89c24a03bd9..7ee1b5c3b4cb 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -82,7 +82,7 @@ struct usb_host_interface {
         int extralen;
         unsigned char *extra;   /* Extra descriptors */
 
-        /* array of desc.bNumEndpoint endpoints associated with this
+        /* array of desc.bNumEndpoints endpoints associated with this
          * interface setting.  these will be in no particular order.
          */
         struct usb_host_endpoint *endpoint;
@@ -127,10 +127,6 @@ enum usb_interface_condition {
  *      to the sysfs representation for that device.
  * @pm_usage_cnt: PM usage counter for this interface
  * @reset_ws: Used for scheduling resets from atomic context.
- * @reset_running: set to 1 if the interface is currently running a
- *      queued reset so that usb_cancel_queued_reset() doesn't try to
- *      remove from the workqueue when running inside the worker
- *      thread. See __usb_queue_reset_device().
  * @resetting_device: USB core reset the device, so use alt setting 0 as
  *      current; needs bandwidth alloc after reset.
  *
@@ -181,7 +177,6 @@ struct usb_interface {
         unsigned needs_remote_wakeup:1; /* driver requires remote wakeup */
         unsigned needs_altsetting0:1;   /* switch to altsetting 0 is pending */
         unsigned needs_binding:1;       /* needs delayed unbind/rebind */
-        unsigned reset_running:1;
         unsigned resetting_device:1;    /* true: bandwidth alloc after reset */
 
         struct device dev;              /* interface specific device info */
diff --git a/include/linux/usb/ehci_pdriver.h b/include/linux/usb/ehci_pdriver.h
index 7eb4dcd0d386..db0431b39a63 100644
--- a/include/linux/usb/ehci_pdriver.h
+++ b/include/linux/usb/ehci_pdriver.h
@@ -34,6 +34,8 @@ struct usb_hcd;
  *                      after initialization.
  * @no_io_watchdog:     set to 1 if the controller does not need the I/O
  *                      watchdog to run.
+ * @reset_on_resume:    set to 1 if the controller needs to be reset after
+ *                      a suspend / resume cycle (but can't detect that itself).
  *
  * These are general configuration options for the EHCI controller. All of
  * these options are activating more or less workarounds for some hardware.
@@ -45,6 +47,8 @@ struct usb_ehci_pdata {
         unsigned        big_endian_desc:1;
         unsigned        big_endian_mmio:1;
         unsigned        no_io_watchdog:1;
+        unsigned        reset_on_resume:1;
+        unsigned        dma_mask_64:1;
 
         /* Turn on all power and clocks */
         int (*power_on)(struct platform_device *pdev);
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 70ddb3943b62..e2f00fd8cd47 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -523,6 +523,7 @@ struct usb_gadget_ops {
  *      enabled HNP support.
  * @quirk_ep_out_aligned_size: epout requires buffer size to be aligned to
  *      MaxPacketSize.
+ * @is_selfpowered: if the gadget is self-powered.
  *
  * Gadgets have a mostly-portable "gadget driver" implementing device
  * functions, handling all usb configurations and interfaces.  Gadget
@@ -563,6 +564,7 @@ struct usb_gadget {
         unsigned                        a_hnp_support:1;
         unsigned                        a_alt_hnp_support:1;
         unsigned                        quirk_ep_out_aligned_size:1;
+        unsigned                        is_selfpowered:1;
 };
 #define work_to_gadget(w)       (container_of((w), struct usb_gadget, work))
 
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 086bf13307e6..68b1e836dff1 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -146,6 +146,8 @@ struct usb_hcd {
         unsigned                amd_resume_bug:1; /* AMD remote wakeup quirk */
         unsigned                can_do_streams:1; /* HC supports streams */
         unsigned                tpl_support:1; /* OTG & EH TPL support */
+        unsigned                cant_recv_wakeups:1;
+                        /* wakeup requests from downstream aren't received */
 
         unsigned int            irq;            /* irq allocated */
         void __iomem            *regs;          /* device memory/io */
@@ -453,6 +455,7 @@ extern const struct dev_pm_ops usb_hcd_pci_pm_ops;
 #endif /* CONFIG_PCI */
 
 /* pci-ish (pdev null is ok) buffer alloc/mapping support */
+void usb_init_pool_max(void);
 int hcd_buffer_create(struct usb_hcd *hcd);
 void hcd_buffer_destroy(struct usb_hcd *hcd);
 
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index f499c23e6342..bc91b5d380fd 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -1,5 +1,5 @@
-/* USB OTG (On The Go) defines */
 /*
+ * USB PHY defines
  *
  * These APIs may be used between USB controllers.  USB device drivers
  * (for either host or peripheral roles) don't use these calls; they
@@ -106,7 +106,7 @@ struct usb_phy {
         int     (*set_power)(struct usb_phy *x,
                                 unsigned mA);
 
-        /* for non-OTG B devices: set transceiver into suspend mode */
+        /* Set transceiver into suspend mode */
         int     (*set_suspend)(struct usb_phy *x,
                                 int suspend);
 
diff --git a/include/linux/usb/usb_phy_generic.h b/include/linux/usb/usb_phy_generic.h
index 68adae83affc..c13632d5292e 100644
--- a/include/linux/usb/usb_phy_generic.h
+++ b/include/linux/usb/usb_phy_generic.h
@@ -2,6 +2,7 @@
 #define __LINUX_USB_NOP_XCEIV_H
 
 #include <linux/usb/otg.h>
+#include <linux/gpio/consumer.h>
 
 struct usb_phy_generic_platform_data {
         enum usb_phy_type type;
@@ -11,6 +12,7 @@ struct usb_phy_generic_platform_data {
         unsigned int needs_vcc:1;
         unsigned int needs_reset:1;     /* deprecated */
         int gpio_reset;
+        struct gpio_desc *gpiod_vbus;
 };
 
 #if IS_ENABLED(CONFIG_NOP_USB_XCEIV)
diff --git a/include/linux/vmalloc.h b/include/linux/vmalloc.h
index b87696fdf06a..7d7acb35603d 100644
--- a/include/linux/vmalloc.h
+++ b/include/linux/vmalloc.h
@@ -16,6 +16,7 @@ struct vm_area_struct;		/* vma defining user mapping in mm_types.h */
 #define VM_USERMAP              0x00000008      /* suitable for remap_vmalloc_range */
 #define VM_VPAGES               0x00000010      /* buffer for pages was vmalloc'ed */
 #define VM_UNINITIALIZED        0x00000020      /* vm_struct is not fully initialized */
+#define VM_NO_GUARD             0x00000040      /* don't add guard page */
 /* bits [20..32] reserved for arch specific ioremap internals */
 
 /*
@@ -75,7 +76,9 @@ extern void *vmalloc_32_user(unsigned long size);
 extern void *__vmalloc(unsigned long size, gfp_t gfp_mask, pgprot_t prot);
 extern void *__vmalloc_node_range(unsigned long size, unsigned long align,
                         unsigned long start, unsigned long end, gfp_t gfp_mask,
-                        pgprot_t prot, int node, const void *caller);
+                        pgprot_t prot, unsigned long vm_flags, int node,
+                        const void *caller);
+
 extern void vfree(const void *addr);
 
 extern void *vmap(struct page **pages, unsigned int count,
@@ -96,8 +99,12 @@ void vmalloc_sync_all(void);
 
 static inline size_t get_vm_area_size(const struct vm_struct *area)
 {
-        /* return actual size without guard page */
-        return area->size - PAGE_SIZE;
+        if (!(area->flags & VM_NO_GUARD))
+                /* return actual size without guard page */
+                return area->size - PAGE_SIZE;
+        else
+                return area->size;
+
 }
 
 extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
diff --git a/include/linux/vmw_vmci_api.h b/include/linux/vmw_vmci_api.h
index 5691f752ce8f..63df3a2a8ce5 100644
--- a/include/linux/vmw_vmci_api.h
+++ b/include/linux/vmw_vmci_api.h
@@ -74,7 +74,7 @@ ssize_t vmci_qpair_dequeue(struct vmci_qp *qpair,
 ssize_t vmci_qpair_peek(struct vmci_qp *qpair, void *buf, size_t buf_size,
                         int mode);
 ssize_t vmci_qpair_enquev(struct vmci_qp *qpair,
-                          void *iov, size_t iov_size, int mode);
+                          struct msghdr *msg, size_t iov_size, int mode);
 ssize_t vmci_qpair_dequev(struct vmci_qp *qpair,
                           struct msghdr *msg, size_t iov_size, int mode);
 ssize_t vmci_qpair_peekv(struct vmci_qp *qpair, struct msghdr *msg, size_t iov_size,
diff --git a/include/linux/vt_buffer.h b/include/linux/vt_buffer.h
index 057db7d2f448..f38c10ba3ff5 100644
--- a/include/linux/vt_buffer.h
+++ b/include/linux/vt_buffer.h
@@ -21,10 +21,6 @@
 #ifndef VT_BUF_HAVE_RW
 #define scr_writew(val, addr) (*(addr) = (val))
 #define scr_readw(addr) (*(addr))
-#define scr_memcpyw(d, s, c) memcpy(d, s, c)
-#define scr_memmovew(d, s, c) memmove(d, s, c)
-#define VT_BUF_HAVE_MEMCPYW
-#define VT_BUF_HAVE_MEMMOVEW
 #endif
 
 #ifndef VT_BUF_HAVE_MEMSETW
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 2232ed16635a..2db83349865b 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -267,6 +267,21 @@ do {									\
         __wait_event(wq, condition);                                    \
 } while (0)
 
+#define __io_wait_event(wq, condition)                                  \
+        (void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,  \
+                            io_schedule())
+
+/*
+ * io_wait_event() -- like wait_event() but with io_schedule()
+ */
+#define io_wait_event(wq, condition)                                    \
+do {                                                                    \
+        might_sleep();                                                  \
+        if (condition)                                                  \
+                break;                                                  \
+        __io_wait_event(wq, condition);                                 \
+} while (0)
+
 #define __wait_event_freezable(wq, condition)                           \
         ___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,          \
                             schedule(); try_to_freeze())
@@ -363,7 +378,6 @@ do {									\
  */
 #define wait_event_cmd(wq, condition, cmd1, cmd2)                       \
 do {                                                                    \
-        might_sleep();                                                  \
         if (condition)                                                  \
                 break;                                                  \
         __wait_event_cmd(wq, condition, cmd1, cmd2);                    \
@@ -991,6 +1005,32 @@ wait_on_bit_io(void *word, int bit, unsigned mode)
 }
 
 /**
+ * wait_on_bit_timeout - wait for a bit to be cleared or a timeout elapses
+ * @word: the word being waited on, a kernel virtual address
+ * @bit: the bit of the word being waited on
+ * @mode: the task state to sleep in
+ * @timeout: timeout, in jiffies
+ *
+ * Use the standard hashed waitqueue table to wait for a bit
+ * to be cleared. This is similar to wait_on_bit(), except also takes a
+ * timeout parameter.
+ *
+ * Returned value will be zero if the bit was cleared before the
+ * @timeout elapsed, or non-zero if the @timeout elapsed or process
+ * received a signal and the mode permitted wakeup on that signal.
+ */
+static inline int
+wait_on_bit_timeout(void *word, int bit, unsigned mode, unsigned long timeout)
+{
+        might_sleep();
+        if (!test_bit(bit, word))
+                return 0;
+        return out_of_line_wait_on_bit_timeout(word, bit,
+                                               bit_wait_timeout,
+                                               mode, timeout);
+}
+
+/**
  * wait_on_bit_action - wait for a bit to be cleared
  * @word: the word being waited on, a kernel virtual address
  * @bit: the bit of the word being waited on
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index b996e6cde6bb..74db135f9957 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -220,14 +220,10 @@ static inline unsigned int work_static(struct work_struct *work) { return 0; }
 #endif
 
 #define INIT_WORK(_work, _func)                                         \
-        do {                                                            \
-                __INIT_WORK((_work), (_func), 0);                       \
-        } while (0)
+        __INIT_WORK((_work), (_func), 0)
 
 #define INIT_WORK_ONSTACK(_work, _func)                                 \
-        do {                                                            \
-                __INIT_WORK((_work), (_func), 1);                       \
-        } while (0)
+        __INIT_WORK((_work), (_func), 1)
 
 #define __INIT_DELAYED_WORK(_work, _func, _tflags)                      \
         do {                                                            \
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index a219be961c0a..00048339c23e 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -177,7 +177,6 @@ int write_cache_pages(struct address_space *mapping,
                       struct writeback_control *wbc, writepage_t writepage,
                       void *data);
 int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
-void set_page_dirty_balance(struct page *page);
 void writeback_set_ratelimit(void);
 void tag_pages_for_writeback(struct address_space *mapping,
                              pgoff_t start, pgoff_t end);
diff --git a/include/linux/zpool.h b/include/linux/zpool.h
index f14bd75f08b3..56529b34dc63 100644
--- a/include/linux/zpool.h
+++ b/include/linux/zpool.h
@@ -36,7 +36,8 @@ enum zpool_mapmode {
         ZPOOL_MM_DEFAULT = ZPOOL_MM_RW
 };
 
-struct zpool *zpool_create_pool(char *type, gfp_t gfp, struct zpool_ops *ops);
+struct zpool *zpool_create_pool(char *type, char *name,
+                        gfp_t gfp, struct zpool_ops *ops);
 
 char *zpool_get_type(struct zpool *pool);
 
@@ -80,7 +81,7 @@ struct zpool_driver {
         atomic_t refcount;
         struct list_head list;
 
-        void *(*create)(gfp_t gfp, struct zpool_ops *ops);
+        void *(*create)(char *name, gfp_t gfp, struct zpool_ops *ops);
         void (*destroy)(void *pool);
 
         int (*malloc)(void *pool, size_t size, gfp_t gfp,
diff --git a/include/linux/zsmalloc.h b/include/linux/zsmalloc.h
index 05c214760977..3283c6a55425 100644
--- a/include/linux/zsmalloc.h
+++ b/include/linux/zsmalloc.h
@@ -36,7 +36,7 @@ enum zs_mapmode {
 
 struct zs_pool;
 
-struct zs_pool *zs_create_pool(gfp_t flags);
+struct zs_pool *zs_create_pool(char *name, gfp_t flags);
 void zs_destroy_pool(struct zs_pool *pool);
 
 unsigned long zs_malloc(struct zs_pool *pool, size_t size);