283 files changed, 7653 insertions, 2248 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 3994d7790b23..f46cfd73a553 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -74,9 +74,10 @@ enum acpi_address_range_id {
 
 /* Table Handlers */
 
-typedef int (*acpi_table_handler) (struct acpi_table_header *table);
+typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);
 
-typedef int (*acpi_table_entry_handler) (struct acpi_subtable_header *header, const unsigned long end);
+typedef int (*acpi_tbl_entry_handler)(struct acpi_subtable_header *header,
+                                      const unsigned long end);
 
 #ifdef CONFIG_ACPI_INITRD_TABLE_OVERRIDE
 void acpi_initrd_override(void *data, size_t size);
@@ -95,10 +96,14 @@ int acpi_mps_check (void);
 int acpi_numa_init (void);
 
 int acpi_table_init (void);
-int acpi_table_parse (char *id, acpi_table_handler handler);
+int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
 int __init acpi_table_parse_entries(char *id, unsigned long table_size,
-        int entry_id, acpi_table_entry_handler handler, unsigned int max_entries);
-int acpi_table_parse_madt (enum acpi_madt_type id, acpi_table_entry_handler handler, unsigned int max_entries);
+                                    int entry_id,
+                                    acpi_tbl_entry_handler handler,
+                                    unsigned int max_entries);
+int acpi_table_parse_madt(enum acpi_madt_type id,
+                          acpi_tbl_entry_handler handler,
+                          unsigned int max_entries);
 int acpi_parse_mcfg (struct acpi_table_header *header);
 void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
 
@@ -358,8 +363,7 @@ extern acpi_status acpi_pci_osc_control_set(acpi_handle handle,
 #if defined(CONFIG_ACPI_HOTPLUG_CPU) &&                 \
         (defined(CONFIG_ACPI_HOTPLUG_MEMORY) ||         \
          defined(CONFIG_ACPI_HOTPLUG_MEMORY_MODULE)) && \
-        (defined(CONFIG_ACPI_CONTAINER) ||              \
-         defined(CONFIG_ACPI_CONTAINER_MODULE))
+        defined(CONFIG_ACPI_CONTAINER)
 #define ACPI_HOTPLUG_OST
 #endif
 
@@ -481,6 +485,14 @@ static inline bool acpi_driver_match_device(struct device *dev,
 
 #endif  /* !CONFIG_ACPI */
 
+#ifdef CONFIG_ACPI_NUMA
+void __init early_parse_srat(void);
+#else
+static inline void early_parse_srat(void)
+{
+}
+#endif
+
 #ifdef CONFIG_ACPI
 void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
                                u32 pm1a_ctrl,  u32 pm1b_ctrl));
@@ -511,7 +523,7 @@ static inline int acpi_subsys_runtime_suspend(struct device *dev) { return 0; }
 static inline int acpi_subsys_runtime_resume(struct device *dev) { return 0; }
 #endif
 
-#ifdef CONFIG_ACPI_SLEEP
+#if defined(CONFIG_ACPI) && defined(CONFIG_PM_SLEEP)
 int acpi_dev_suspend_late(struct device *dev);
 int acpi_dev_resume_early(struct device *dev);
 int acpi_subsys_prepare(struct device *dev);
@@ -526,9 +538,14 @@ static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
 #endif
 
 #if defined(CONFIG_ACPI) && defined(CONFIG_PM)
+struct acpi_device *acpi_dev_pm_get_node(struct device *dev);
 int acpi_dev_pm_attach(struct device *dev, bool power_on);
 void acpi_dev_pm_detach(struct device *dev, bool power_off);
 #else
+static inline struct acpi_device *acpi_dev_pm_get_node(struct device *dev)
+{
+        return NULL;
+}
 static inline int acpi_dev_pm_attach(struct device *dev, bool power_on)
 {
         return -ENODEV;
diff --git a/include/linux/acpi_gpio.h b/include/linux/acpi_gpio.h
index 91615a389b65..b76ebd08ff8e 100644
--- a/include/linux/acpi_gpio.h
+++ b/include/linux/acpi_gpio.h
@@ -2,10 +2,12 @@
 #define _LINUX_ACPI_GPIO_H_
 
 #include <linux/errno.h>
+#include <linux/gpio.h>
 
 #ifdef CONFIG_GPIO_ACPI
 
 int acpi_get_gpio(char *path, int pin);
+void acpi_gpiochip_request_interrupts(struct gpio_chip *chip);
 
 #else /* CONFIG_GPIO_ACPI */
 
@@ -14,6 +16,8 @@ static inline int acpi_get_gpio(char *path, int pin)
         return -ENODEV;
 }
 
+static inline void acpi_gpiochip_request_interrupts(struct gpio_chip *chip) { }
+
 #endif /* CONFIG_GPIO_ACPI */
 
 #endif /* _LINUX_ACPI_GPIO_H_ */
diff --git a/include/linux/aer.h b/include/linux/aer.h
index 544abdb2238c..ec10e1b24c1c 100644
--- a/include/linux/aer.h
+++ b/include/linux/aer.h
@@ -49,8 +49,8 @@ static inline int pci_cleanup_aer_uncorrect_error_status(struct pci_dev *dev)
 }
 #endif
 
-extern void cper_print_aer(const char *prefix, int cper_severity,
-                           struct aer_capability_regs *aer);
+extern void cper_print_aer(const char *prefix, struct pci_dev *dev,
+                           int cper_severity, struct aer_capability_regs *aer);
 extern int cper_severity_to_aer(int cper_severity);
 extern void aer_recover_queue(int domain, unsigned int bus, unsigned int devfn,
                               int severity);
diff --git a/include/linux/amba/pl080.h b/include/linux/amba/pl080.h
new file mode 100644
index 000000000000..3e7b62fbefbd
--- /dev/null
+++ b/include/linux/amba/pl080.h
@@ -0,0 +1,146 @@
+/* include/linux/amba/pl080.h
+ *
+ * Copyright 2008 Openmoko, Inc.
+ * Copyright 2008 Simtec Electronics
+ *      http://armlinux.simtec.co.uk/
+ *      Ben Dooks <ben@simtec.co.uk>
+ *
+ * ARM PrimeCell PL080 DMA controller
+ *
+ * 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.
+*/
+
+/* Note, there are some Samsung updates to this controller block which
+ * make it not entierly compatible with the PL080 specification from
+ * ARM. When in doubt, check the Samsung documentation first.
+ *
+ * The Samsung defines are PL080S, and add an extra control register,
+ * the ability to move more than 2^11 counts of data and some extra
+ * OneNAND features.
+*/
+
+#ifndef ASM_PL080_H
+#define ASM_PL080_H
+
+#define PL080_INT_STATUS                        (0x00)
+#define PL080_TC_STATUS                         (0x04)
+#define PL080_TC_CLEAR                          (0x08)
+#define PL080_ERR_STATUS                        (0x0C)
+#define PL080_ERR_CLEAR                         (0x10)
+#define PL080_RAW_TC_STATUS                     (0x14)
+#define PL080_RAW_ERR_STATUS                    (0x18)
+#define PL080_EN_CHAN                           (0x1c)
+#define PL080_SOFT_BREQ                         (0x20)
+#define PL080_SOFT_SREQ                         (0x24)
+#define PL080_SOFT_LBREQ                        (0x28)
+#define PL080_SOFT_LSREQ                        (0x2C)
+
+#define PL080_CONFIG                            (0x30)
+#define PL080_CONFIG_M2_BE                      (1 << 2)
+#define PL080_CONFIG_M1_BE                      (1 << 1)
+#define PL080_CONFIG_ENABLE                     (1 << 0)
+
+#define PL080_SYNC                              (0x34)
+
+/* Per channel configuration registers */
+
+#define PL080_Cx_STRIDE                         (0x20)
+#define PL080_Cx_BASE(x)                        ((0x100 + (x * 0x20)))
+#define PL080_Cx_SRC_ADDR(x)                    ((0x100 + (x * 0x20)))
+#define PL080_Cx_DST_ADDR(x)                    ((0x104 + (x * 0x20)))
+#define PL080_Cx_LLI(x)                         ((0x108 + (x * 0x20)))
+#define PL080_Cx_CONTROL(x)                     ((0x10C + (x * 0x20)))
+#define PL080_Cx_CONFIG(x)                      ((0x110 + (x * 0x20)))
+#define PL080S_Cx_CONTROL2(x)                   ((0x110 + (x * 0x20)))
+#define PL080S_Cx_CONFIG(x)                     ((0x114 + (x * 0x20)))
+
+#define PL080_CH_SRC_ADDR                       (0x00)
+#define PL080_CH_DST_ADDR                       (0x04)
+#define PL080_CH_LLI                            (0x08)
+#define PL080_CH_CONTROL                        (0x0C)
+#define PL080_CH_CONFIG                         (0x10)
+#define PL080S_CH_CONTROL2                      (0x10)
+#define PL080S_CH_CONFIG                        (0x14)
+
+#define PL080_LLI_ADDR_MASK                     (0x3fffffff << 2)
+#define PL080_LLI_ADDR_SHIFT                    (2)
+#define PL080_LLI_LM_AHB2                       (1 << 0)
+
+#define PL080_CONTROL_TC_IRQ_EN                 (1 << 31)
+#define PL080_CONTROL_PROT_MASK                 (0x7 << 28)
+#define PL080_CONTROL_PROT_SHIFT                (28)
+#define PL080_CONTROL_PROT_CACHE                (1 << 30)
+#define PL080_CONTROL_PROT_BUFF                 (1 << 29)
+#define PL080_CONTROL_PROT_SYS                  (1 << 28)
+#define PL080_CONTROL_DST_INCR                  (1 << 27)
+#define PL080_CONTROL_SRC_INCR                  (1 << 26)
+#define PL080_CONTROL_DST_AHB2                  (1 << 25)
+#define PL080_CONTROL_SRC_AHB2                  (1 << 24)
+#define PL080_CONTROL_DWIDTH_MASK               (0x7 << 21)
+#define PL080_CONTROL_DWIDTH_SHIFT              (21)
+#define PL080_CONTROL_SWIDTH_MASK               (0x7 << 18)
+#define PL080_CONTROL_SWIDTH_SHIFT              (18)
+#define PL080_CONTROL_DB_SIZE_MASK              (0x7 << 15)
+#define PL080_CONTROL_DB_SIZE_SHIFT             (15)
+#define PL080_CONTROL_SB_SIZE_MASK              (0x7 << 12)
+#define PL080_CONTROL_SB_SIZE_SHIFT             (12)
+#define PL080_CONTROL_TRANSFER_SIZE_MASK        (0xfff << 0)
+#define PL080_CONTROL_TRANSFER_SIZE_SHIFT       (0)
+
+#define PL080_BSIZE_1                           (0x0)
+#define PL080_BSIZE_4                           (0x1)
+#define PL080_BSIZE_8                           (0x2)
+#define PL080_BSIZE_16                          (0x3)
+#define PL080_BSIZE_32                          (0x4)
+#define PL080_BSIZE_64                          (0x5)
+#define PL080_BSIZE_128                         (0x6)
+#define PL080_BSIZE_256                         (0x7)
+
+#define PL080_WIDTH_8BIT                        (0x0)
+#define PL080_WIDTH_16BIT                       (0x1)
+#define PL080_WIDTH_32BIT                       (0x2)
+
+#define PL080N_CONFIG_ITPROT                    (1 << 20)
+#define PL080N_CONFIG_SECPROT                   (1 << 19)
+#define PL080_CONFIG_HALT                       (1 << 18)
+#define PL080_CONFIG_ACTIVE                     (1 << 17)  /* RO */
+#define PL080_CONFIG_LOCK                       (1 << 16)
+#define PL080_CONFIG_TC_IRQ_MASK                (1 << 15)
+#define PL080_CONFIG_ERR_IRQ_MASK               (1 << 14)
+#define PL080_CONFIG_FLOW_CONTROL_MASK          (0x7 << 11)
+#define PL080_CONFIG_FLOW_CONTROL_SHIFT         (11)
+#define PL080_CONFIG_DST_SEL_MASK               (0xf << 6)
+#define PL080_CONFIG_DST_SEL_SHIFT              (6)
+#define PL080_CONFIG_SRC_SEL_MASK               (0xf << 1)
+#define PL080_CONFIG_SRC_SEL_SHIFT              (1)
+#define PL080_CONFIG_ENABLE                     (1 << 0)
+
+#define PL080_FLOW_MEM2MEM                      (0x0)
+#define PL080_FLOW_MEM2PER                      (0x1)
+#define PL080_FLOW_PER2MEM                      (0x2)
+#define PL080_FLOW_SRC2DST                      (0x3)
+#define PL080_FLOW_SRC2DST_DST                  (0x4)
+#define PL080_FLOW_MEM2PER_PER                  (0x5)
+#define PL080_FLOW_PER2MEM_PER                  (0x6)
+#define PL080_FLOW_SRC2DST_SRC                  (0x7)
+
+/* DMA linked list chain structure */
+
+struct pl080_lli {
+        u32     src_addr;
+        u32     dst_addr;
+        u32     next_lli;
+        u32     control0;
+};
+
+struct pl080s_lli {
+        u32     src_addr;
+        u32     dst_addr;
+        u32     next_lli;
+        u32     control0;
+        u32     control1;
+};
+
+#endif /* ASM_PL080_H */
diff --git a/include/linux/amba/sp810.h b/include/linux/amba/sp810.h
new file mode 100644
index 000000000000..6636430dd0e6
--- /dev/null
+++ b/include/linux/amba/sp810.h
@@ -0,0 +1,64 @@
+/*
+ * arch/arm/include/asm/hardware/sp810.h
+ *
+ * ARM PrimeXsys System Controller SP810 header file
+ *
+ * Copyright (C) 2009 ST Microelectronics
+ * Viresh Kumar <viresh.linux@gmail.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2. This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef __ASM_ARM_SP810_H
+#define __ASM_ARM_SP810_H
+
+#include <linux/io.h>
+
+/* sysctl registers offset */
+#define SCCTRL                  0x000
+#define SCSYSSTAT               0x004
+#define SCIMCTRL                0x008
+#define SCIMSTAT                0x00C
+#define SCXTALCTRL              0x010
+#define SCPLLCTRL               0x014
+#define SCPLLFCTRL              0x018
+#define SCPERCTRL0              0x01C
+#define SCPERCTRL1              0x020
+#define SCPEREN                 0x024
+#define SCPERDIS                0x028
+#define SCPERCLKEN              0x02C
+#define SCPERSTAT               0x030
+#define SCSYSID0                0xEE0
+#define SCSYSID1                0xEE4
+#define SCSYSID2                0xEE8
+#define SCSYSID3                0xEEC
+#define SCITCR                  0xF00
+#define SCITIR0                 0xF04
+#define SCITIR1                 0xF08
+#define SCITOR                  0xF0C
+#define SCCNTCTRL               0xF10
+#define SCCNTDATA               0xF14
+#define SCCNTSTEP               0xF18
+#define SCPERIPHID0             0xFE0
+#define SCPERIPHID1             0xFE4
+#define SCPERIPHID2             0xFE8
+#define SCPERIPHID3             0xFEC
+#define SCPCELLID0              0xFF0
+#define SCPCELLID1              0xFF4
+#define SCPCELLID2              0xFF8
+#define SCPCELLID3              0xFFC
+
+#define SCCTRL_TIMERENnSEL_SHIFT(n)     (15 + ((n) * 2))
+
+static inline void sysctl_soft_reset(void __iomem *base)
+{
+        /* switch to slow mode */
+        writel(0x2, base + SCCTRL);
+
+        /* writing any value to SCSYSSTAT reg will reset system */
+        writel(0, base + SCSYSSTAT);
+}
+
+#endif  /* __ASM_ARM_SP810_H */
diff --git a/include/linux/async.h b/include/linux/async.h
index 7a24fe9b44b4..a2e3f18b2ad6 100644
--- a/include/linux/async.h
+++ b/include/linux/async.h
@@ -19,8 +19,7 @@ typedef u64 async_cookie_t;
 typedef void (async_func_ptr) (void *data, async_cookie_t cookie);
 struct async_domain {
         struct list_head node;
-        struct list_head domain;
-        int count;
+        struct list_head pending;
         unsigned registered:1;
 };
 
@@ -29,8 +28,7 @@ struct async_domain {
  */
 #define ASYNC_DOMAIN(_name) \
         struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \
-                                      .domain = LIST_HEAD_INIT(_name.domain), \
-                                      .count = 0, \
+                                      .pending = LIST_HEAD_INIT(_name.pending), \
                                       .registered = 1 }
 
 /*
@@ -39,8 +37,7 @@ struct async_domain {
  */
 #define ASYNC_DOMAIN_EXCLUSIVE(_name) \
         struct async_domain _name = { .node = LIST_HEAD_INIT(_name.node), \
-                                      .domain = LIST_HEAD_INIT(_name.domain), \
-                                      .count = 0, \
+                                      .pending = LIST_HEAD_INIT(_name.pending), \
                                       .registered = 0 }
 
 extern async_cookie_t async_schedule(async_func_ptr *ptr, void *data);
@@ -52,4 +49,5 @@ extern void async_synchronize_full_domain(struct async_domain *domain);
 extern void async_synchronize_cookie(async_cookie_t cookie);
 extern void async_synchronize_cookie_domain(async_cookie_t cookie,
                                             struct async_domain *domain);
+extern bool current_is_async(void);
 #endif
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 12731a19ef06..350459910fe1 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -254,6 +254,7 @@ int bdi_set_max_ratio(struct backing_dev_info *bdi, unsigned int max_ratio);
 #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_VMFLAGS \
         (BDI_CAP_READ_MAP | BDI_CAP_WRITE_MAP | BDI_CAP_EXEC_MAP)
@@ -308,6 +309,11 @@ long wait_iff_congested(struct zone *zone, int sync, long timeout);
 int pdflush_proc_obsolete(struct ctl_table *table, int write,
                 void __user *buffer, size_t *lenp, loff_t *ppos);
 
+static inline bool bdi_cap_stable_pages_required(struct backing_dev_info *bdi)
+{
+        return bdi->capabilities & BDI_CAP_STABLE_WRITES;
+}
+
 static inline bool bdi_cap_writeback_dirty(struct backing_dev_info *bdi)
 {
         return !(bdi->capabilities & BDI_CAP_NO_WRITEBACK);
diff --git a/include/linux/bcm2835_timer.h b/include/linux/bcm2835_timer.h
deleted file mode 100644
index 25680fe0903c..000000000000
--- a/include/linux/bcm2835_timer.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2012 Simon Arlott
- *
- * 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 __BCM2835_TIMER_H
-#define __BCM2835_TIMER_H
-
-#include <asm/mach/time.h>
-
-extern struct sys_timer bcm2835_timer;
-
-#endif
diff --git a/include/linux/bcma/bcma_driver_chipcommon.h b/include/linux/bcma/bcma_driver_chipcommon.h
index 9a0e3fa3ca95..1d002b58b60b 100644
--- a/include/linux/bcma/bcma_driver_chipcommon.h
+++ b/include/linux/bcma/bcma_driver_chipcommon.h
@@ -27,7 +27,7 @@
 #define   BCMA_CC_FLASHT_NONE           0x00000000      /* No flash */
 #define   BCMA_CC_FLASHT_STSER          0x00000100      /* ST serial flash */
 #define   BCMA_CC_FLASHT_ATSER          0x00000200      /* Atmel serial flash */
-#define   BCMA_CC_FLASHT_NFLASH         0x00000200      /* NAND flash */
+#define   BCMA_CC_FLASHT_NAND           0x00000300      /* NAND flash */
 #define   BCMA_CC_FLASHT_PARA           0x00000700      /* Parallel flash */
 #define  BCMA_CC_CAP_PLLT               0x00038000      /* PLL Type */
 #define   BCMA_PLLTYPE_NONE             0x00000000
@@ -634,4 +634,6 @@ extern void bcma_chipco_regctl_maskset(struct bcma_drv_cc *cc,
                                        u32 offset, u32 mask, u32 set);
 extern void bcma_pmu_spuravoid_pllupdate(struct bcma_drv_cc *cc, int spuravoid);
 
+extern u32 bcma_pmu_get_bus_clock(struct bcma_drv_cc *cc);
+
 #endif /* LINUX_BCMA_DRIVER_CC_H_ */
diff --git a/include/linux/bcma/bcma_driver_mips.h b/include/linux/bcma/bcma_driver_mips.h
index 0baf8a56b794..fb61f3fb4ddb 100644
--- a/include/linux/bcma/bcma_driver_mips.h
+++ b/include/linux/bcma/bcma_driver_mips.h
@@ -28,6 +28,7 @@
 #define BCMA_MIPS_MIPS74K_GPIOEN        0x0048
 #define BCMA_MIPS_MIPS74K_CLKCTLST      0x01E0
 
+#define BCMA_MIPS_OOBSELINA74           0x004
 #define BCMA_MIPS_OOBSELOUTA30          0x100
 
 struct bcma_device;
@@ -36,19 +37,23 @@ struct bcma_drv_mips {
         struct bcma_device *core;
         u8 setup_done:1;
         u8 early_setup_done:1;
-        unsigned int assigned_irqs;
 };
 
 #ifdef CONFIG_BCMA_DRIVER_MIPS
 extern void bcma_core_mips_init(struct bcma_drv_mips *mcore);
 extern void bcma_core_mips_early_init(struct bcma_drv_mips *mcore);
+
+extern unsigned int bcma_core_irq(struct bcma_device *core);
 #else
 static inline void bcma_core_mips_init(struct bcma_drv_mips *mcore) { }
 static inline void bcma_core_mips_early_init(struct bcma_drv_mips *mcore) { }
+
+static inline unsigned int bcma_core_irq(struct bcma_device *core)
+{
+        return 0;
+}
 #endif
 
 extern u32 bcma_cpu_clock(struct bcma_drv_mips *mcore);
 
-extern unsigned int bcma_core_mips_irq(struct bcma_device *dev);
-
 #endif /* LINUX_BCMA_DRIVER_MIPS_H_ */
diff --git a/include/linux/bcma/bcma_driver_pci.h b/include/linux/bcma/bcma_driver_pci.h
index c48d98d27b77..424760f01b9d 100644
--- a/include/linux/bcma/bcma_driver_pci.h
+++ b/include/linux/bcma/bcma_driver_pci.h
@@ -179,6 +179,8 @@ struct pci_dev;
 #define BCMA_CORE_PCI_CFG_FUN_MASK              7       /* Function mask */
 #define BCMA_CORE_PCI_CFG_OFF_MASK              0xfff   /* Register mask */
 
+#define BCMA_CORE_PCI_CFG_DEVCTRL               0xd8
+
 /* PCIE Root Capability Register bits (Host mode only) */
 #define BCMA_CORE_PCI_RC_CRS_VISIBILITY         0x0001
 
diff --git a/include/linux/bma150.h b/include/linux/bma150.h
index 7911fda23bb4..97ade7cdc870 100644
--- a/include/linux/bma150.h
+++ b/include/linux/bma150.h
@@ -22,6 +22,18 @@
 
 #define BMA150_DRIVER           "bma150"
 
+#define BMA150_RANGE_2G         0
+#define BMA150_RANGE_4G         1
+#define BMA150_RANGE_8G         2
+
+#define BMA150_BW_25HZ          0
+#define BMA150_BW_50HZ          1
+#define BMA150_BW_100HZ         2
+#define BMA150_BW_190HZ         3
+#define BMA150_BW_375HZ         4
+#define BMA150_BW_750HZ         5
+#define BMA150_BW_1500HZ        6
+
 struct bma150_cfg {
         bool any_motion_int;            /* Set to enable any-motion interrupt */
         bool hg_int;                    /* Set to enable high-G interrupt */
@@ -34,8 +46,8 @@ struct bma150_cfg {
         unsigned char lg_hyst;          /* Low-G hysterisis */
         unsigned char lg_dur;           /* Low-G duration */
         unsigned char lg_thres;         /* Low-G threshold */
-        unsigned char range;            /* BMA0150_RANGE_xxx (in G) */
-        unsigned char bandwidth;        /* BMA0150_BW_xxx (in Hz) */
+        unsigned char range;            /* one of BMA0150_RANGE_xxx */
+        unsigned char bandwidth;        /* one of BMA0150_BW_xxx */
 };
 
 struct bma150_platform_data {
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 3f778c27f825..cdc3bab01832 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -53,6 +53,7 @@ extern void free_bootmem_node(pg_data_t *pgdat,
                               unsigned long size);
 extern void free_bootmem(unsigned long physaddr, unsigned long size);
 extern void free_bootmem_late(unsigned long physaddr, unsigned long size);
+extern void __free_pages_bootmem(struct page *page, unsigned int order);
 
 /*
  * Flags for reserve_bootmem (also if CONFIG_HAVE_ARCH_BOOTMEM_NODE,
@@ -99,6 +100,9 @@ void *___alloc_bootmem_node_nopanic(pg_data_t *pgdat,
 extern void *__alloc_bootmem_low(unsigned long size,
                                  unsigned long align,
                                  unsigned long goal);
+void *__alloc_bootmem_low_nopanic(unsigned long size,
+                                 unsigned long align,
+                                 unsigned long goal);
 extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
                                       unsigned long size,
                                       unsigned long align,
@@ -132,6 +136,8 @@ extern void *__alloc_bootmem_low_node(pg_data_t *pgdat,
 
 #define alloc_bootmem_low(x) \
         __alloc_bootmem_low(x, SMP_CACHE_BYTES, 0)
+#define alloc_bootmem_low_pages_nopanic(x) \
+        __alloc_bootmem_low_nopanic(x, PAGE_SIZE, 0)
 #define alloc_bootmem_low_pages(x) \
         __alloc_bootmem_low(x, PAGE_SIZE, 0)
 #define alloc_bootmem_low_pages_node(pgdat, x) \
diff --git a/include/linux/bug.h b/include/linux/bug.h
index b1cf40de847e..7f4818673c41 100644
--- a/include/linux/bug.h
+++ b/include/linux/bug.h
@@ -2,6 +2,7 @@
 #define _LINUX_BUG_H
 
 #include <asm/bug.h>
+#include <linux/compiler.h>
 
 enum bug_trap_type {
         BUG_TRAP_TYPE_NONE = 0,
@@ -12,11 +13,12 @@ enum bug_trap_type {
 struct pt_regs;
 
 #ifdef __CHECKER__
-#define BUILD_BUG_ON_NOT_POWER_OF_2(n)
+#define BUILD_BUG_ON_NOT_POWER_OF_2(n) (0)
 #define BUILD_BUG_ON_ZERO(e) (0)
 #define BUILD_BUG_ON_NULL(e) ((void*)0)
 #define BUILD_BUG_ON_INVALID(e) (0)
-#define BUILD_BUG_ON(condition)
+#define BUILD_BUG_ON_MSG(cond, msg) (0)
+#define BUILD_BUG_ON(condition) (0)
 #define BUILD_BUG() (0)
 #else /* __CHECKER__ */
 
@@ -39,29 +41,37 @@ struct pt_regs;
 #define BUILD_BUG_ON_INVALID(e) ((void)(sizeof((__force long)(e))))
 
 /**
+ * BUILD_BUG_ON_MSG - break compile if a condition is true & emit supplied
+ *                    error message.
+ * @condition: the condition which the compiler should know is false.
+ *
+ * See BUILD_BUG_ON for description.
+ */
+#define BUILD_BUG_ON_MSG(cond, msg) compiletime_assert(!(cond), msg)
+
+/**
  * BUILD_BUG_ON - break compile if a condition is true.
  * @condition: the condition which the compiler should know is false.
  *
  * If you have some code which relies on certain constants being equal, or
- * other compile-time-evaluated condition, you should use BUILD_BUG_ON to
+ * some other compile-time-evaluated condition, you should use BUILD_BUG_ON to
  * detect if someone changes it.
  *
- * The implementation uses gcc's reluctance to create a negative array, but
- * gcc (as of 4.4) only emits that error for obvious cases (eg. not arguments
- * to inline functions).  So as a fallback we use the optimizer; if it can't
- * prove the condition is false, it will cause a link error on the undefined
- * "__build_bug_on_failed".  This error message can be harder to track down
- * though, hence the two different methods.
+ * The implementation uses gcc's reluctance to create a negative array, but gcc
+ * (as of 4.4) only emits that error for obvious cases (e.g. not arguments to
+ * inline functions).  Luckily, in 4.3 they added the "error" function
+ * attribute just for this type of case.  Thus, we use a negative sized array
+ * (should always create an error on gcc versions older than 4.4) and then call
+ * an undefined function with the error attribute (should always create an
+ * error on gcc 4.3 and later).  If for some reason, neither creates a
+ * compile-time error, we'll still have a link-time error, which is harder to
+ * track down.
  */
 #ifndef __OPTIMIZE__
 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
 #else
-extern int __build_bug_on_failed;
-#define BUILD_BUG_ON(condition)                                 \
-        do {                                                    \
-                ((void)sizeof(char[1 - 2*!!(condition)]));      \
-                if (condition) __build_bug_on_failed = 1;       \
-        } while(0)
+#define BUILD_BUG_ON(condition) \
+        BUILD_BUG_ON_MSG(condition, "BUILD_BUG_ON failed: " #condition)
 #endif
 
 /**
@@ -71,12 +81,7 @@ extern int __build_bug_on_failed;
  * build time, you should use BUILD_BUG to detect if it is
  * unexpectedly used.
  */
-#define BUILD_BUG()                                             \
-        do {                                                    \
-                extern void __build_bug_failed(void)            \
-                        __linktime_error("BUILD_BUG failed");   \
-                __build_bug_failed();                           \
-        } while (0)
+#define BUILD_BUG() BUILD_BUG_ON_MSG(1, "BUILD_BUG failed")
 
 #endif  /* __CHECKER__ */
 
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 2b2fc345afca..fb0ab651a041 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -16,6 +16,7 @@
 #include <linux/can.h>
 #include <linux/can/netlink.h>
 #include <linux/can/error.h>
+#include <linux/can/led.h>
 
 /*
  * CAN mode
@@ -52,6 +53,13 @@ struct can_priv {
 
         unsigned int echo_skb_max;
         struct sk_buff **echo_skb;
+
+#ifdef CONFIG_CAN_LEDS
+        struct led_trigger *tx_led_trig;
+        char tx_led_trig_name[CAN_LED_NAME_SZ];
+        struct led_trigger *rx_led_trig;
+        char rx_led_trig_name[CAN_LED_NAME_SZ];
+#endif
 };
 
 /*
@@ -98,6 +106,9 @@ u8 can_len2dlc(u8 len);
 struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max);
 void free_candev(struct net_device *dev);
 
+/* a candev safe wrapper around netdev_priv */
+struct can_priv *safe_candev_priv(struct net_device *dev);
+
 int open_candev(struct net_device *dev);
 void close_candev(struct net_device *dev);
 
diff --git a/include/linux/can/led.h b/include/linux/can/led.h
new file mode 100644
index 000000000000..9c1167baf273
--- /dev/null
+++ b/include/linux/can/led.h
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2012, Fabio Baltieri <fabio.baltieri@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef CAN_LED_H
+#define CAN_LED_H
+
+#include <linux/if.h>
+#include <linux/leds.h>
+
+enum can_led_event {
+        CAN_LED_EVENT_OPEN,
+        CAN_LED_EVENT_STOP,
+        CAN_LED_EVENT_TX,
+        CAN_LED_EVENT_RX,
+};
+
+#ifdef CONFIG_CAN_LEDS
+
+/* keep space for interface name + "-tx"/"-rx" suffix and null terminator */
+#define CAN_LED_NAME_SZ (IFNAMSIZ + 4)
+
+void can_led_event(struct net_device *netdev, enum can_led_event event);
+void devm_can_led_init(struct net_device *netdev);
+int __init can_led_notifier_init(void);
+void __exit can_led_notifier_exit(void);
+
+#else
+
+static inline void can_led_event(struct net_device *netdev,
+                                 enum can_led_event event)
+{
+}
+static inline void devm_can_led_init(struct net_device *netdev)
+{
+}
+static inline int can_led_notifier_init(void)
+{
+        return 0;
+}
+static inline void can_led_notifier_exit(void)
+{
+}
+
+#endif
+
+#endif
diff --git a/include/linux/can/skb.h b/include/linux/can/skb.h
new file mode 100644
index 000000000000..2f0543f7510c
--- /dev/null
+++ b/include/linux/can/skb.h
@@ -0,0 +1,45 @@
+/*
+ * linux/can/skb.h
+ *
+ * Definitions for the CAN network socket buffer
+ *
+ * Copyright (C) 2012 Oliver Hartkopp <socketcan@hartkopp.net>
+ *
+ */
+
+#ifndef CAN_SKB_H
+#define CAN_SKB_H
+
+#include <linux/types.h>
+#include <linux/can.h>
+
+/*
+ * The struct can_skb_priv is used to transport additional information along
+ * with the stored struct can(fd)_frame that can not be contained in existing
+ * struct sk_buff elements.
+ * N.B. that this information must not be modified in cloned CAN sk_buffs.
+ * To modify the CAN frame content or the struct can_skb_priv content
+ * skb_copy() needs to be used instead of skb_clone().
+ */
+
+/**
+ * struct can_skb_priv - private additional data inside CAN sk_buffs
+ * @ifindex:    ifindex of the first interface the CAN frame appeared on
+ * @cf:         align to the following CAN frame at skb->data
+ */
+struct can_skb_priv {
+        int ifindex;
+        struct can_frame cf[0];
+};
+
+static inline struct can_skb_priv *can_skb_prv(struct sk_buff *skb)
+{
+        return (struct can_skb_priv *)(skb->head);
+}
+
+static inline void can_skb_reserve(struct sk_buff *skb)
+{
+        skb_reserve(skb, sizeof(struct can_skb_priv));
+}
+
+#endif /* CAN_SKB_H */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 7d73905dcba2..900af5964f55 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -203,6 +203,7 @@ struct cgroup {
 
         /* For RCU-protected deletion */
         struct rcu_head rcu_head;
+        struct work_struct free_work;
 
         /* List of events which userspace want to receive */
         struct list_head event_list;
@@ -558,6 +559,7 @@ static inline struct cgroup* task_cgroup(struct task_struct *task,
 
 struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
                                           struct cgroup *cgroup);
+struct cgroup *cgroup_rightmost_descendant(struct cgroup *pos);
 
 /**
  * cgroup_for_each_descendant_pre - pre-order walk of a cgroup's descendants
@@ -706,7 +708,6 @@ struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id);
 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) {}
-static inline void cgroup_fork_callbacks(struct task_struct *p) {}
 static inline void cgroup_post_fork(struct task_struct *p) {}
 static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
 
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 4989b8a7bed1..7f197d7addb0 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -379,7 +379,13 @@ struct clk_onecell_data {
 };
 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
 const char *of_clk_get_parent_name(struct device_node *np, int index);
+
 void of_clk_init(const struct of_device_id *matches);
 
+#define CLK_OF_DECLARE(name, compat, fn)                        \
+        static const struct of_device_id __clk_of_table_##name  \
+                __used __section(__clk_of_table)                \
+                = { .compatible = compat, .data = fn };
+
 #endif /* CONFIG_COMMON_CLK */
 #endif /* CLK_PROVIDER_H */
diff --git a/include/linux/clk/sunxi.h b/include/linux/clk/sunxi.h
deleted file mode 100644
index e074fdd5a236..000000000000
--- a/include/linux/clk/sunxi.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright 2012 Maxime Ripard
- *
- * Maxime Ripard <maxime.ripard@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 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_CLK_SUNXI_H_
-#define __LINUX_CLK_SUNXI_H_
-
-void __init sunxi_init_clocks(void);
-
-#endif
diff --git a/include/linux/clk/tegra.h b/include/linux/clk/tegra.h
new file mode 100644
index 000000000000..404d6f940872
--- /dev/null
+++ b/include/linux/clk/tegra.h
@@ -0,0 +1,127 @@
+/*
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * 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.
+ *
+ * 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_CLK_TEGRA_H_
+#define __LINUX_CLK_TEGRA_H_
+
+#include <linux/clk.h>
+
+/*
+ * Tegra CPU clock and reset control ops
+ *
+ * wait_for_reset:
+ *      keep waiting until the CPU in reset state
+ * put_in_reset:
+ *      put the CPU in reset state
+ * out_of_reset:
+ *      release the CPU from reset state
+ * enable_clock:
+ *      CPU clock un-gate
+ * disable_clock:
+ *      CPU clock gate
+ * rail_off_ready:
+ *      CPU is ready for rail off
+ * suspend:
+ *      save the clock settings when CPU go into low-power state
+ * resume:
+ *      restore the clock settings when CPU exit low-power state
+ */
+struct tegra_cpu_car_ops {
+        void (*wait_for_reset)(u32 cpu);
+        void (*put_in_reset)(u32 cpu);
+        void (*out_of_reset)(u32 cpu);
+        void (*enable_clock)(u32 cpu);
+        void (*disable_clock)(u32 cpu);
+#ifdef CONFIG_PM_SLEEP
+        bool (*rail_off_ready)(void);
+        void (*suspend)(void);
+        void (*resume)(void);
+#endif
+};
+
+extern struct tegra_cpu_car_ops *tegra_cpu_car_ops;
+
+static inline void tegra_wait_cpu_in_reset(u32 cpu)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->wait_for_reset))
+                return;
+
+        tegra_cpu_car_ops->wait_for_reset(cpu);
+}
+
+static inline void tegra_put_cpu_in_reset(u32 cpu)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->put_in_reset))
+                return;
+
+        tegra_cpu_car_ops->put_in_reset(cpu);
+}
+
+static inline void tegra_cpu_out_of_reset(u32 cpu)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->out_of_reset))
+                return;
+
+        tegra_cpu_car_ops->out_of_reset(cpu);
+}
+
+static inline void tegra_enable_cpu_clock(u32 cpu)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->enable_clock))
+                return;
+
+        tegra_cpu_car_ops->enable_clock(cpu);
+}
+
+static inline void tegra_disable_cpu_clock(u32 cpu)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->disable_clock))
+                return;
+
+        tegra_cpu_car_ops->disable_clock(cpu);
+}
+
+#ifdef CONFIG_PM_SLEEP
+static inline bool tegra_cpu_rail_off_ready(void)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->rail_off_ready))
+                return false;
+
+        return tegra_cpu_car_ops->rail_off_ready();
+}
+
+static inline void tegra_cpu_clock_suspend(void)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->suspend))
+                return;
+
+        tegra_cpu_car_ops->suspend();
+}
+
+static inline void tegra_cpu_clock_resume(void)
+{
+        if (WARN_ON(!tegra_cpu_car_ops->resume))
+                return;
+
+        tegra_cpu_car_ops->resume();
+}
+#endif
+
+void tegra_periph_reset_deassert(struct clk *c);
+void tegra_periph_reset_assert(struct clk *c);
+void tegra_clocks_init(void);
+
+#endif /* __LINUX_CLK_TEGRA_H_ */
diff --git a/include/linux/clockchips.h b/include/linux/clockchips.h
index 8a7096fcb01e..66346521cb65 100644
--- a/include/linux/clockchips.h
+++ b/include/linux/clockchips.h
@@ -161,6 +161,15 @@ clockevents_calc_mult_shift(struct clock_event_device *ce, u32 freq, u32 minsec)
 extern void clockevents_suspend(void);
 extern void clockevents_resume(void);
 
+#ifdef CONFIG_GENERIC_CLOCKEVENTS_BROADCAST
+#ifdef CONFIG_ARCH_HAS_TICK_BROADCAST
+extern void tick_broadcast(const struct cpumask *mask);
+#else
+#define tick_broadcast  NULL
+#endif
+extern int tick_receive_broadcast(void);
+#endif
+
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 extern void clockevents_notify(unsigned long reason, void *arg);
 #else
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 4dceaf8ae152..27cfda427dd9 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -332,4 +332,15 @@ extern int clocksource_mmio_init(void __iomem *, const char *,
 
 extern int clocksource_i8253_init(void);
 
+#ifdef CONFIG_CLKSRC_OF
+extern void clocksource_of_init(void);
+
+#define CLOCKSOURCE_OF_DECLARE(name, compat, fn)                        \
+        static const struct of_device_id __clksrc_of_table_##name       \
+                __used __section(__clksrc_of_table)                     \
+                 = { .compatible = compat, .data = fn };
+#else
+#define CLOCKSOURCE_OF_DECLARE(name, compat, fn)
+#endif
+
 #endif /* _LINUX_CLOCKSOURCE_H */
diff --git a/include/linux/coda_psdev.h b/include/linux/coda_psdev.h
index 8031d6eef102..5b8721efa948 100644
--- a/include/linux/coda_psdev.h
+++ b/include/linux/coda_psdev.h
@@ -34,7 +34,7 @@ int venus_lookup(struct super_block *sb, struct CodaFid *fid,
                  const char *name, int length, int *type, 
                  struct CodaFid *resfid);
 int venus_close(struct super_block *sb, struct CodaFid *fid, int flags,
-                vuid_t uid);
+                kuid_t uid);
 int venus_open(struct super_block *sb, struct CodaFid *fid, int flags,
                struct file **f);
 int venus_mkdir(struct super_block *sb, struct CodaFid *dirfid, 
diff --git a/include/linux/compaction.h b/include/linux/compaction.h
index cc7bddeaf553..091d72e70d8a 100644
--- a/include/linux/compaction.h
+++ b/include/linux/compaction.h
@@ -23,7 +23,7 @@ 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,
                         bool sync, bool *contended);
-extern int compact_pgdat(pg_data_t *pgdat, int order);
+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);
 
@@ -80,9 +80,8 @@ static inline unsigned long try_to_compact_pages(struct zonelist *zonelist,
         return COMPACT_CONTINUE;
 }
 
-static inline int compact_pgdat(pg_data_t *pgdat, int order)
+static inline void compact_pgdat(pg_data_t *pgdat, int order)
 {
-        return COMPACT_CONTINUE;
 }
 
 static inline void reset_isolation_suitable(pg_data_t *pgdat)
diff --git a/include/linux/compat.h b/include/linux/compat.h
index dec7e2d18875..de095b0462a7 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -68,7 +68,6 @@
 #ifndef compat_user_stack_pointer
 #define compat_user_stack_pointer() current_user_stack_pointer()
 #endif
-#ifdef CONFIG_GENERIC_SIGALTSTACK
 #ifndef compat_sigaltstack      /* we'll need that for MIPS */
 typedef struct compat_sigaltstack {
         compat_uptr_t                   ss_sp;
@@ -76,7 +75,6 @@ typedef struct compat_sigaltstack {
         compat_size_t                   ss_size;
 } compat_stack_t;
 #endif
-#endif
 
 #define compat_jiffies_to_clock_t(x)    \
                 (((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
@@ -142,6 +140,20 @@ typedef struct {
         compat_sigset_word      sig[_COMPAT_NSIG_WORDS];
 } compat_sigset_t;
 
+struct compat_sigaction {
+#ifndef __ARCH_HAS_ODD_SIGACTION
+        compat_uptr_t                   sa_handler;
+        compat_ulong_t                  sa_flags;
+#else
+        compat_ulong_t                  sa_flags;
+        compat_uptr_t                   sa_handler;
+#endif
+#ifdef __ARCH_HAS_SA_RESTORER
+        compat_uptr_t                   sa_restorer;
+#endif
+        compat_sigset_t                 sa_mask __packed;
+};
+
 /*
  * These functions operate strictly on struct compat_time*
  */
@@ -283,6 +295,15 @@ struct compat_robust_list_head {
         compat_uptr_t                   list_op_pending;
 };
 
+#ifdef CONFIG_COMPAT_OLD_SIGACTION
+struct compat_old_sigaction {
+        compat_uptr_t                   sa_handler;
+        compat_old_sigset_t             sa_mask;
+        compat_ulong_t                  sa_flags;
+        compat_uptr_t                   sa_restorer;
+};
+#endif
+
 struct compat_statfs;
 struct compat_statfs64;
 struct compat_old_linux_dirent;
@@ -367,6 +388,11 @@ int get_compat_sigevent(struct sigevent *event,
                 const struct compat_sigevent __user *u_event);
 long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid, compat_pid_t pid, int sig,
                                   struct compat_siginfo __user *uinfo);
+#ifdef CONFIG_COMPAT_OLD_SIGACTION
+asmlinkage long compat_sys_sigaction(int sig,
+                                   const struct compat_old_sigaction __user *act,
+                                   struct compat_old_sigaction __user *oact);
+#endif
 
 static inline int compat_timeval_compare(struct compat_timeval *lhs,
                                         struct compat_timeval *rhs)
@@ -401,7 +427,8 @@ asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 
 extern int compat_printk(const char *fmt, ...);
-extern void sigset_from_compat(sigset_t *set, compat_sigset_t *compat);
+extern void sigset_from_compat(sigset_t *set, const compat_sigset_t *compat);
+extern void sigset_to_compat(compat_sigset_t *compat, const sigset_t *set);
 
 asmlinkage long compat_sys_migrate_pages(compat_pid_t pid,
                 compat_ulong_t maxnode, const compat_ulong_t __user *old_nodes,
@@ -503,7 +530,7 @@ asmlinkage long compat_sys_vmsplice(int fd, const struct compat_iovec __user *,
                                     unsigned int nr_segs, unsigned int flags);
 asmlinkage long compat_sys_open(const char __user *filename, int flags,
                                 umode_t mode);
-asmlinkage long compat_sys_openat(unsigned int dfd, const char __user *filename,
+asmlinkage long compat_sys_openat(int dfd, const char __user *filename,
                                   int flags, umode_t mode);
 asmlinkage long compat_sys_open_by_handle_at(int mountdirfd,
                                              struct file_handle __user *handle,
@@ -592,6 +619,19 @@ asmlinkage long compat_sys_rt_sigtimedwait(compat_sigset_t __user *uthese,
                 struct compat_timespec __user *uts, compat_size_t sigsetsize);
 asmlinkage long compat_sys_rt_sigsuspend(compat_sigset_t __user *unewset,
                                          compat_size_t sigsetsize);
+asmlinkage long compat_sys_rt_sigprocmask(int how, compat_sigset_t __user *set,
+                                          compat_sigset_t __user *oset,
+                                          compat_size_t sigsetsize);
+asmlinkage long compat_sys_rt_sigpending(compat_sigset_t __user *uset,
+                                         compat_size_t sigsetsize);
+#ifndef CONFIG_ODD_RT_SIGACTION
+asmlinkage long compat_sys_rt_sigaction(int,
+                                 const struct compat_sigaction __user *,
+                                 struct compat_sigaction __user *,
+                                 compat_size_t);
+#endif
+asmlinkage long compat_sys_rt_sigqueueinfo(compat_pid_t pid, int sig,
+                                struct compat_siginfo __user *uinfo);
 asmlinkage long compat_sys_sysinfo(struct compat_sysinfo __user *info);
 asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
                                  unsigned long arg);
@@ -642,13 +682,11 @@ asmlinkage ssize_t compat_sys_process_vm_writev(compat_pid_t pid,
 
 asmlinkage long compat_sys_sendfile(int out_fd, int in_fd,
                                     compat_off_t __user *offset, compat_size_t count);
-#ifdef CONFIG_GENERIC_SIGALTSTACK
 asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
                                        compat_stack_t __user *uoss_ptr);
 
 int compat_restore_altstack(const compat_stack_t __user *uss);
 int __compat_save_altstack(compat_stack_t __user *, unsigned long);
-#endif
 
 asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid,
                                                  struct compat_timespec __user *interval);
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 6a6d7aefe12d..24545cd90a25 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -5,6 +5,9 @@
 /*
  * Common definitions for all gcc versions go here.
  */
+#define GCC_VERSION (__GNUC__ * 10000 \
+                   + __GNUC_MINOR__ * 100 \
+                   + __GNUC_PATCHLEVEL__)
 
 
 /* Optimization barrier */
diff --git a/include/linux/compiler-gcc3.h b/include/linux/compiler-gcc3.h
index 37d412436d0f..7d89febe4d79 100644
--- a/include/linux/compiler-gcc3.h
+++ b/include/linux/compiler-gcc3.h
@@ -2,22 +2,22 @@
 #error "Please don't include <linux/compiler-gcc3.h> directly, include <linux/compiler.h> instead."
 #endif
 
-#if __GNUC_MINOR__ < 2
+#if GCC_VERSION < 30200
 # error Sorry, your compiler is too old - please upgrade it.
 #endif
 
-#if __GNUC_MINOR__ >= 3
+#if GCC_VERSION >= 30300
 # define __used                 __attribute__((__used__))
 #else
 # define __used                 __attribute__((__unused__))
 #endif
 
-#if __GNUC_MINOR__ >= 4
+#if GCC_VERSION >= 30400
 #define __must_check            __attribute__((warn_unused_result))
 #endif
 
 #ifdef CONFIG_GCOV_KERNEL
-# if __GNUC_MINOR__ < 4
+# if GCC_VERSION < 30400
 #   error "GCOV profiling support for gcc versions below 3.4 not included"
 # endif /* __GNUC_MINOR__ */
 #endif /* CONFIG_GCOV_KERNEL */
diff --git a/include/linux/compiler-gcc4.h b/include/linux/compiler-gcc4.h
index 662fd1b4c42a..68b162d92254 100644
--- a/include/linux/compiler-gcc4.h
+++ b/include/linux/compiler-gcc4.h
@@ -4,7 +4,7 @@
 
 /* GCC 4.1.[01] miscompiles __weak */
 #ifdef __KERNEL__
-# if __GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ <= 1
+# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
 #  error Your version of gcc miscompiles the __weak directive
 # endif
 #endif
@@ -13,7 +13,11 @@
 #define __must_check            __attribute__((warn_unused_result))
 #define __compiler_offsetof(a,b) __builtin_offsetof(a,b)
 
-#if __GNUC_MINOR__ >= 3
+#if GCC_VERSION >= 40100
+# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
+#endif
+
+#if GCC_VERSION >= 40300
 /* Mark functions as cold. gcc will assume any path leading to a call
    to them will be unlikely.  This means a lot of manual unlikely()s
    are unnecessary now for any paths leading to the usual suspects
@@ -29,11 +33,15 @@
    the kernel context */
 #define __cold                  __attribute__((__cold__))
 
-#define __linktime_error(message) __attribute__((__error__(message)))
-
 #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 
-#if __GNUC_MINOR__ >= 5
+#ifndef __CHECKER__
+# define __compiletime_warning(message) __attribute__((warning(message)))
+# define __compiletime_error(message) __attribute__((error(message)))
+#endif /* __CHECKER__ */
+#endif /* GCC_VERSION >= 40300 */
+
+#if GCC_VERSION >= 40500
 /*
  * Mark a position in code as unreachable.  This can be used to
  * suppress control flow warnings after asm blocks that transfer
@@ -48,30 +56,22 @@
 /* Mark a function definition as prohibited from being cloned. */
 #define __noclone       __attribute__((__noclone__))
 
-#endif
-#endif
+#endif /* GCC_VERSION >= 40500 */
 
-#if __GNUC_MINOR__ >= 6
+#if GCC_VERSION >= 40600
 /*
  * Tell the optimizer that something else uses this function or variable.
  */
 #define __visible __attribute__((externally_visible))
 #endif
 
-#if __GNUC_MINOR__ > 0
-#define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
-#endif
-#if __GNUC_MINOR__ >= 3 && !defined(__CHECKER__)
-#define __compiletime_warning(message) __attribute__((warning(message)))
-#define __compiletime_error(message) __attribute__((error(message)))
-#endif
 
 #ifdef CONFIG_ARCH_USE_BUILTIN_BSWAP
-#if __GNUC_MINOR__ >= 4
+#if GCC_VERSION >= 40400
 #define __HAVE_BUILTIN_BSWAP32__
 #define __HAVE_BUILTIN_BSWAP64__
 #endif
-#if __GNUC_MINOR__ >= 8 || (defined(__powerpc__) && __GNUC_MINOR__ >= 6)
+#if GCC_VERSION >= 40800 || (defined(__powerpc__) && GCC_VERSION >= 40600)
 #define __HAVE_BUILTIN_BSWAP16__
 #endif
-#endif
+#endif /* CONFIG_ARCH_USE_BUILTIN_BSWAP */
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index dd852b73b286..10b8f23fab0f 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -307,10 +307,36 @@ void ftrace_likely_update(struct ftrace_branch_data *f, int val, int expect);
 #endif
 #ifndef __compiletime_error
 # define __compiletime_error(message)
+# define __compiletime_error_fallback(condition) \
+        do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
+#else
+# define __compiletime_error_fallback(condition) do { } while (0)
 #endif
-#ifndef __linktime_error
-# define __linktime_error(message)
-#endif
+
+#define __compiletime_assert(condition, msg, prefix, suffix)            \
+        do {                                                            \
+                bool __cond = !(condition);                             \
+                extern void prefix ## suffix(void) __compiletime_error(msg); \
+                if (__cond)                                             \
+                        prefix ## suffix();                             \
+                __compiletime_error_fallback(__cond);                   \
+        } while (0)
+
+#define _compiletime_assert(condition, msg, prefix, suffix) \
+        __compiletime_assert(condition, msg, prefix, suffix)
+
+/**
+ * compiletime_assert - break build and emit msg if condition is false
+ * @condition: a compile-time constant condition to check
+ * @msg:       a message to emit if condition is false
+ *
+ * In tradition of POSIX assert, this macro will break the build if the
+ * supplied condition is *false*, emitting the supplied error message if the
+ * compiler has support to do so.
+ */
+#define compiletime_assert(condition, msg) \
+        _compiletime_assert(condition, msg, __compiletime_assert_, __LINE__)
+
 /*
  * Prevent the compiler from merging or refetching accesses.  The compiler
  * is also forbidden from reordering successive instances of ACCESS_ONCE(),
diff --git a/include/linux/console.h b/include/linux/console.h
index dedb082fe50f..29680a8cda99 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -77,7 +77,9 @@ extern const struct consw prom_con;	/* SPARC PROM console */
 int con_is_bound(const struct consw *csw);
 int register_con_driver(const struct consw *csw, int first, int last);
 int unregister_con_driver(const struct consw *csw);
+int do_unregister_con_driver(const struct consw *csw);
 int take_over_console(const struct consw *sw, int first, int last, int deflt);
+int do_take_over_console(const struct consw *sw, int first, int last, int deflt);
 void give_up_console(const struct consw *sw);
 #ifdef CONFIG_HW_CONSOLE
 int con_debug_enter(struct vc_data *vc);
@@ -157,7 +159,12 @@ extern int is_console_locked(void);
 extern int braille_register_console(struct console *, int index,
                 char *console_options, char *braille_options);
 extern int braille_unregister_console(struct console *);
+#ifdef CONFIG_TTY
 extern void console_sysfs_notify(void);
+#else
+static inline void console_sysfs_notify(void)
+{ }
+#endif
 extern bool console_suspend_enabled;
 
 /* Suspend and resume console messages over PM events */
diff --git a/include/linux/context_tracking.h b/include/linux/context_tracking.h
index e24339ccb7f0..b28d161c1091 100644
--- a/include/linux/context_tracking.h
+++ b/include/linux/context_tracking.h
@@ -3,12 +3,40 @@
 
 #ifdef CONFIG_CONTEXT_TRACKING
 #include <linux/sched.h>
+#include <linux/percpu.h>
+
+struct context_tracking {
+        /*
+         * When active is false, probes are unset in order
+         * to minimize overhead: TIF flags are cleared
+         * and calls to user_enter/exit are ignored. This
+         * may be further optimized using static keys.
+         */
+        bool active;
+        enum {
+                IN_KERNEL = 0,
+                IN_USER,
+        } state;
+};
+
+DECLARE_PER_CPU(struct context_tracking, context_tracking);
+
+static inline bool context_tracking_in_user(void)
+{
+        return __this_cpu_read(context_tracking.state) == IN_USER;
+}
+
+static inline bool context_tracking_active(void)
+{
+        return __this_cpu_read(context_tracking.active);
+}
 
 extern void user_enter(void);
 extern void user_exit(void);
 extern void context_tracking_task_switch(struct task_struct *prev,
                                          struct task_struct *next);
 #else
+static inline bool context_tracking_in_user(void) { return false; }
 static inline void user_enter(void) { }
 static inline void user_exit(void) { }
 static inline void context_tracking_task_switch(struct task_struct *prev,
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index a55b88eaf96a..a22944ca0526 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -89,11 +89,15 @@ struct cpufreq_real_policy {
 };
 
 struct cpufreq_policy {
-        cpumask_var_t           cpus;   /* CPUs requiring sw coordination */
-        cpumask_var_t           related_cpus; /* CPUs with any coordination */
-        unsigned int            shared_type; /* ANY or ALL affected CPUs
+        /* CPUs sharing clock, require sw coordination */
+        cpumask_var_t           cpus;   /* Online CPUs only */
+        cpumask_var_t           related_cpus; /* Online + Offline CPUs */
+
+        unsigned int            shared_type; /* ACPI: ANY or ALL affected CPUs
                                                 should set cpufreq */
-        unsigned int            cpu;    /* cpu nr of registered CPU */
+        unsigned int            cpu;    /* cpu nr of CPU managing this policy */
+        unsigned int            last_cpu; /* cpu nr of previous CPU that managed
+                                           * this policy */
         struct cpufreq_cpuinfo  cpuinfo;/* see above */
 
         unsigned int            min;    /* in kHz */
@@ -112,16 +116,23 @@ struct cpufreq_policy {
         struct completion       kobj_unregister;
 };
 
-#define CPUFREQ_ADJUST          (0)
-#define CPUFREQ_INCOMPATIBLE    (1)
-#define CPUFREQ_NOTIFY          (2)
-#define CPUFREQ_START           (3)
+#define CPUFREQ_ADJUST                  (0)
+#define CPUFREQ_INCOMPATIBLE            (1)
+#define CPUFREQ_NOTIFY                  (2)
+#define CPUFREQ_START                   (3)
+#define CPUFREQ_UPDATE_POLICY_CPU       (4)
 
+/* Only for ACPI */
 #define CPUFREQ_SHARED_TYPE_NONE (0) /* None */
 #define CPUFREQ_SHARED_TYPE_HW   (1) /* HW does needed coordination */
 #define CPUFREQ_SHARED_TYPE_ALL  (2) /* All dependent CPUs should set freq */
 #define CPUFREQ_SHARED_TYPE_ANY  (3) /* Freq can be set from any dependent CPU*/
 
+static inline bool policy_is_shared(struct cpufreq_policy *policy)
+{
+        return cpumask_weight(policy->cpus) > 1;
+}
+
 /******************** cpufreq transition notifiers *******************/
 
 #define CPUFREQ_PRECHANGE       (0)
@@ -173,6 +184,7 @@ static inline unsigned long cpufreq_scale(unsigned long old, u_int div, u_int mu
 
 struct cpufreq_governor {
         char    name[CPUFREQ_NAME_LEN];
+        int     initialized;
         int     (*governor)     (struct cpufreq_policy *policy,
                                  unsigned int event);
         ssize_t (*show_setspeed)        (struct cpufreq_policy *policy,
@@ -308,6 +320,9 @@ __ATTR(_name, 0444, show_##_name, NULL)
 static struct global_attr _name =               \
 __ATTR(_name, 0644, show_##_name, store_##_name)
 
+struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
+void cpufreq_cpu_put(struct cpufreq_policy *data);
+const char *cpufreq_get_current_driver(void);
 
 /*********************************************************************
  *                        CPUFREQ 2.6. INTERFACE                     *
@@ -397,14 +412,13 @@ int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
 
 /* the following 3 funtions are for cpufreq core use only */
 struct cpufreq_frequency_table *cpufreq_frequency_get_table(unsigned int cpu);
-struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
-void   cpufreq_cpu_put(struct cpufreq_policy *data);
 
 /* the following are really really optional */
 extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
 
 void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
                                       unsigned int cpu);
+void cpufreq_frequency_table_update_policy_cpu(struct cpufreq_policy *policy);
 
 void cpufreq_frequency_table_put_attr(unsigned int cpu);
 #endif /* _LINUX_CPUFREQ_H */
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 24cd1037b6d6..480c14dc1ddd 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -32,8 +32,6 @@ struct cpuidle_driver;
  ****************************/
 
 struct cpuidle_state_usage {
-        void            *driver_data;
-
         unsigned long long      disable;
         unsigned long long      usage;
         unsigned long long      time; /* in US */
@@ -62,26 +60,6 @@ struct cpuidle_state {
 
 #define CPUIDLE_DRIVER_FLAGS_MASK (0xFFFF0000)
 
-/**
- * cpuidle_get_statedata - retrieves private driver state data
- * @st_usage: the state usage statistics
- */
-static inline void *cpuidle_get_statedata(struct cpuidle_state_usage *st_usage)
-{
-        return st_usage->driver_data;
-}
-
-/**
- * cpuidle_set_statedata - stores private driver state data
- * @st_usage: the state usage statistics
- * @data: the private data
- */
-static inline void
-cpuidle_set_statedata(struct cpuidle_state_usage *st_usage, void *data)
-{
-        st_usage->driver_data = data;
-}
-
 struct cpuidle_device {
         unsigned int            registered:1;
         unsigned int            enabled:1;
diff --git a/include/linux/cyclomx.h b/include/linux/cyclomx.h
deleted file mode 100644
index b88f7f428e58..000000000000
--- a/include/linux/cyclomx.h
+++ /dev/null
@@ -1,77 +0,0 @@
-#ifndef _CYCLOMX_H
-#define _CYCLOMX_H
-/*
-* cyclomx.h     Cyclom 2X WAN Link Driver.
-*               User-level API definitions.
-*
-* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
-*
-* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
-*
-* Based on wanpipe.h by Gene Kozin <genek@compuserve.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.
-* ============================================================================
-* 2000/07/13    acme            remove crap #if KERNEL_VERSION > blah
-* 2000/01/21    acme            rename cyclomx_open to cyclomx_mod_inc_use_count
-*                               and cyclomx_close to cyclomx_mod_dec_use_count
-* 1999/05/19    acme            wait_queue_head_t wait_stats(support for 2.3.*)
-* 1999/01/03    acme            judicious use of data types
-* 1998/12/27    acme            cleanup: PACKED not needed
-* 1998/08/08    acme            Version 0.0.1
-*/
-
-#include <linux/wanrouter.h>
-#include <linux/spinlock.h>
-
-#ifdef  __KERNEL__
-/* Kernel Interface */
-
-#include <linux/cycx_drv.h>     /* Cyclom 2X support module API definitions */
-#include <linux/cycx_cfm.h>     /* Cyclom 2X firmware module definitions */
-#ifdef CONFIG_CYCLOMX_X25
-#include <linux/cycx_x25.h>
-#endif
-
-/* Adapter Data Space.
- * This structure is needed because we handle multiple cards, otherwise
- * static data would do it.
- */
-struct cycx_device {
-        char devname[WAN_DRVNAME_SZ + 1];/* card name */
-        struct cycx_hw hw;              /* hardware configuration */
-        struct wan_device wandev;       /* WAN device data space */
-        u32 state_tick;                 /* link state timestamp */
-        spinlock_t lock;
-        char in_isr;                    /* interrupt-in-service flag */
-        char buff_int_mode_unbusy;      /* flag for carrying out dev_tint */
-        wait_queue_head_t wait_stats;  /* to wait for the STATS indication */
-        void __iomem *mbox;                     /* -> mailbox */
-        void (*isr)(struct cycx_device* card);  /* interrupt service routine */
-        int (*exec)(struct cycx_device* card, void* u_cmd, void* u_data);
-        union {
-#ifdef CONFIG_CYCLOMX_X25
-                struct { /* X.25 specific data */
-                        u32 lo_pvc;
-                        u32 hi_pvc;
-                        u32 lo_svc;
-                        u32 hi_svc;
-                        struct cycx_x25_stats stats;
-                        spinlock_t lock;
-                        u32 connection_keys;
-                } x;
-#endif
-        } u;
-};
-
-/* Public Functions */
-void cycx_set_state(struct cycx_device *card, int state);
-
-#ifdef CONFIG_CYCLOMX_X25
-int cycx_x25_wan_init(struct cycx_device *card, wandev_conf_t *conf);
-#endif
-#endif  /* __KERNEL__ */
-#endif  /* _CYCLOMX_H */
diff --git a/include/linux/cycx_drv.h b/include/linux/cycx_drv.h
deleted file mode 100644
index 12fe6b0bfcff..000000000000
--- a/include/linux/cycx_drv.h
+++ /dev/null
@@ -1,64 +0,0 @@
-/*
-* cycx_drv.h    CYCX Support Module.  Kernel API Definitions.
-*
-* Author:       Arnaldo Carvalho de Melo <acme@conectiva.com.br>
-*
-* Copyright:    (c) 1998-2003 Arnaldo Carvalho de Melo
-*
-* Based on sdladrv.h by Gene Kozin <genek@compuserve.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.
-* ============================================================================
-* 1999/10/23    acme            cycxhw_t cleanup
-* 1999/01/03    acme            more judicious use of data types...
-*                               uclong, ucchar, etc deleted, the u8, u16, u32
-*                               types are the portable way to go.
-* 1999/01/03    acme            judicious use of data types... u16, u32, etc
-* 1998/12/26    acme            FIXED_BUFFERS, CONF_OFFSET,
-*                               removal of cy_read{bwl}
-* 1998/08/08    acme            Initial version.
-*/
-#ifndef _CYCX_DRV_H
-#define _CYCX_DRV_H
-
-#define CYCX_WINDOWSIZE 0x4000  /* default dual-port memory window size */
-#define GEN_CYCX_INTR   0x02
-#define RST_ENABLE      0x04
-#define START_CPU       0x06
-#define RST_DISABLE     0x08
-#define FIXED_BUFFERS   0x08
-#define TEST_PATTERN    0xaa55
-#define CMD_OFFSET      0x20
-#define CONF_OFFSET     0x0380
-#define RESET_OFFSET    0x3c00  /* For reset file load */
-#define DATA_OFFSET     0x0100  /* For code and data files load */
-#define START_OFFSET    0x3ff0  /* 80186 starts here */
-
-/**
- *      struct cycx_hw - Adapter hardware configuration
- *      @fwid - firmware ID
- *      @irq - interrupt request level
- *      @dpmbase - dual-port memory base
- *      @dpmsize - dual-port memory size
- *      @reserved - reserved for future use
- */
-struct cycx_hw {
-        u32 fwid;
-        int irq;
-        void __iomem *dpmbase;
-        u32 dpmsize;
-        u32 reserved[5];
-};
-
-/* Function Prototypes */
-extern int cycx_setup(struct cycx_hw *hw, void *sfm, u32 len, unsigned long base);
-extern int cycx_down(struct cycx_hw *hw);
-extern int cycx_peek(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
-extern int cycx_poke(struct cycx_hw *hw, u32 addr, void *buf, u32 len);
-extern int cycx_exec(void __iomem *addr);
-
-extern void cycx_intr(struct cycx_hw *hw);
-#endif  /* _CYCX_DRV_H */
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 66c434f5dd1e..63f2465807d4 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -33,7 +33,7 @@ struct debugfs_reg32 {
 };
 
 struct debugfs_regset32 {
-        struct debugfs_reg32 *regs;
+        const struct debugfs_reg32 *regs;
         int nregs;
         void __iomem *base;
 };
diff --git a/include/linux/device.h b/include/linux/device.h
index 43dcda937ddf..9d6464ea99c6 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -21,6 +21,7 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 #include <linux/mutex.h>
+#include <linux/pinctrl/devinfo.h>
 #include <linux/pm.h>
 #include <linux/atomic.h>
 #include <linux/ratelimit.h>
@@ -395,8 +396,8 @@ extern int class_for_each_device(struct class *class, struct device *start,
                                  void *data,
                                  int (*fn)(struct device *dev, void *data));
 extern struct device *class_find_device(struct class *class,
-                                        struct device *start, void *data,
-                                        int (*match)(struct device *, void *));
+                                        struct device *start, const void *data,
+                                        int (*match)(struct device *, const void *));
 
 struct class_attribute {
         struct attribute attr;
@@ -573,6 +574,7 @@ extern int devres_release_group(struct device *dev, void *id);
 extern void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp);
 extern void devm_kfree(struct device *dev, void *p);
 
+void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
 void __iomem *devm_request_and_ioremap(struct device *dev,
                         struct resource *res);
 
@@ -620,6 +622,8 @@ struct acpi_dev_node {
  * @pm_domain:  Provide callbacks that are executed during system suspend,
  *              hibernation, system resume and during runtime PM transitions
  *              along with subsystem-level and driver-level callbacks.
+ * @pins:       For device pin management.
+ *              See Documentation/pinctrl.txt for details.
  * @numa_node:  NUMA node this device is close to.
  * @dma_mask:   Dma mask (if dma'ble device).
  * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
@@ -672,6 +676,10 @@ struct device {
         struct dev_pm_info      power;
         struct dev_pm_domain    *pm_domain;
 
+#ifdef CONFIG_PINCTRL
+        struct dev_pin_info     *pins;
+#endif
+
 #ifdef CONFIG_NUMA
         int             numa_node;      /* NUMA node this device is close to */
 #endif
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index bd2e52ccc4f2..3d754a394e92 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -53,7 +53,7 @@ struct dma_buf_attachment;
  * @begin_cpu_access: [optional] called before cpu access to invalidate cpu
  *                    caches and allocate backing storage (if not yet done)
  *                    respectively pin the objet into memory.
- * @end_cpu_access: [optional] called after cpu access to flush cashes.
+ * @end_cpu_access: [optional] called after cpu access to flush caches.
  * @kmap_atomic: maps a page from the buffer into kernel address
  *               space, users may not block until the subsequent unmap call.
  *               This callback must not sleep.
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index d3201e438d16..f5939999cb65 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -608,7 +608,10 @@ static inline int dmaengine_device_control(struct dma_chan *chan,
                                            enum dma_ctrl_cmd cmd,
                                            unsigned long arg)
 {
-        return chan->device->device_control(chan, cmd, arg);
+        if (chan->device->device_control)
+                return chan->device->device_control(chan, cmd, arg);
+
+        return -ENOSYS;
 }
 
 static inline int dmaengine_slave_config(struct dma_chan *chan,
@@ -618,6 +621,11 @@ static inline int dmaengine_slave_config(struct dma_chan *chan,
                         (unsigned long)config);
 }
 
+static inline bool is_slave_direction(enum dma_transfer_direction direction)
+{
+        return (direction == DMA_MEM_TO_DEV) || (direction == DMA_DEV_TO_MEM);
+}
+
 static inline struct dma_async_tx_descriptor *dmaengine_prep_slave_single(
         struct dma_chan *chan, dma_addr_t buf, size_t len,
         enum dma_transfer_direction dir, unsigned long flags)
@@ -660,6 +668,13 @@ static inline struct dma_async_tx_descriptor *dmaengine_prep_dma_cyclic(
                                                 period_len, dir, flags, NULL);
 }
 
+static inline struct dma_async_tx_descriptor *dmaengine_prep_interleaved_dma(
+                struct dma_chan *chan, struct dma_interleaved_template *xt,
+                unsigned long flags)
+{
+        return chan->device->device_prep_interleaved_dma(chan, xt, flags);
+}
+
 static inline int dmaengine_terminate_all(struct dma_chan *chan)
 {
         return dmaengine_device_control(chan, DMA_TERMINATE_ALL, 0);
@@ -849,20 +864,6 @@ static inline bool async_tx_test_ack(struct dma_async_tx_descriptor *tx)
         return (tx->flags & DMA_CTRL_ACK) == DMA_CTRL_ACK;
 }
 
-#define first_dma_cap(mask) __first_dma_cap(&(mask))
-static inline int __first_dma_cap(const dma_cap_mask_t *srcp)
-{
-        return min_t(int, DMA_TX_TYPE_END,
-                find_first_bit(srcp->bits, DMA_TX_TYPE_END));
-}
-
-#define next_dma_cap(n, mask) __next_dma_cap((n), &(mask))
-static inline int __next_dma_cap(int n, const dma_cap_mask_t *srcp)
-{
-        return min_t(int, DMA_TX_TYPE_END,
-                find_next_bit(srcp->bits, DMA_TX_TYPE_END, n+1));
-}
-
 #define dma_cap_set(tx, mask) __dma_cap_set((tx), &(mask))
 static inline void
 __dma_cap_set(enum dma_transaction_type tx_type, dma_cap_mask_t *dstp)
@@ -891,9 +892,7 @@ __dma_has_cap(enum dma_transaction_type tx_type, dma_cap_mask_t *srcp)
 }
 
 #define for_each_dma_cap_mask(cap, mask) \
-        for ((cap) = first_dma_cap(mask);       \
-                (cap) < DMA_TX_TYPE_END;        \
-                (cap) = next_dma_cap((cap), (mask)))
+        for_each_set_bit(cap, mask.bits, DMA_TX_TYPE_END)
 
 /**
  * dma_async_issue_pending - flush pending transactions to HW
@@ -907,8 +906,6 @@ static inline void dma_async_issue_pending(struct dma_chan *chan)
         chan->device->device_issue_pending(chan);
 }
 
-#define dma_async_memcpy_issue_pending(chan) dma_async_issue_pending(chan)
-
 /**
  * dma_async_is_tx_complete - poll for transaction completion
  * @chan: DMA channel
@@ -934,16 +931,13 @@ static inline enum dma_status dma_async_is_tx_complete(struct dma_chan *chan,
         return status;
 }
 
-#define dma_async_memcpy_complete(chan, cookie, last, used)\
-        dma_async_is_tx_complete(chan, cookie, last, used)
-
 /**
  * dma_async_is_complete - test a cookie against chan state
  * @cookie: transaction identifier to test status of
  * @last_complete: last know completed transaction
  * @last_used: last cookie value handed out
  *
- * dma_async_is_complete() is used in dma_async_memcpy_complete()
+ * dma_async_is_complete() is used in dma_async_is_tx_complete()
  * the test logic is separated for lightweight testing of multiple cookies
  */
 static inline enum dma_status dma_async_is_complete(dma_cookie_t cookie,
@@ -974,6 +968,7 @@ enum dma_status dma_sync_wait(struct dma_chan *chan, dma_cookie_t cookie);
 enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx);
 void dma_issue_pending_all(void);
 struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask, dma_filter_fn fn, void *fn_param);
+struct dma_chan *dma_request_slave_channel(struct device *dev, char *name);
 void dma_release_channel(struct dma_chan *chan);
 #else
 static inline enum dma_status dma_wait_for_async_tx(struct dma_async_tx_descriptor *tx)
@@ -988,6 +983,11 @@ static inline struct dma_chan *__dma_request_channel(dma_cap_mask_t *mask,
 {
         return NULL;
 }
+static inline struct dma_chan *dma_request_slave_channel(struct device *dev,
+                                                         char *name)
+{
+        return NULL;
+}
 static inline void dma_release_channel(struct dma_chan *chan)
 {
 }
diff --git a/include/linux/dw_apb_timer.h b/include/linux/dw_apb_timer.h
index 1148575fd134..dd755ce2a5eb 100644
--- a/include/linux/dw_apb_timer.h
+++ b/include/linux/dw_apb_timer.h
@@ -53,5 +53,5 @@ void dw_apb_clocksource_start(struct dw_apb_clocksource *dw_cs);
 cycle_t dw_apb_clocksource_read(struct dw_apb_clocksource *dw_cs);
 void dw_apb_clocksource_unregister(struct dw_apb_clocksource *dw_cs);
 
-extern struct sys_timer dw_apb_timer;
+extern void dw_apb_timer_init(void);
 #endif /* __DW_APB_TIMER_H__ */
diff --git a/include/linux/dw_dmac.h b/include/linux/dw_dmac.h
index e1c8c9e919ac..41766de66e33 100644
--- a/include/linux/dw_dmac.h
+++ b/include/linux/dw_dmac.h
@@ -15,14 +15,38 @@
 #include <linux/dmaengine.h>
 
 /**
+ * struct dw_dma_slave - Controller-specific information about a slave
+ *
+ * @dma_dev: required DMA master device. Depricated.
+ * @bus_id: name of this device channel, not just a device name since
+ *          devices may have more than one channel e.g. "foo_tx"
+ * @cfg_hi: Platform-specific initializer for the CFG_HI register
+ * @cfg_lo: Platform-specific initializer for the CFG_LO register
+ * @src_master: src master for transfers on allocated channel.
+ * @dst_master: dest master for transfers on allocated channel.
+ */
+struct dw_dma_slave {
+        struct device           *dma_dev;
+        const char              *bus_id;
+        u32                     cfg_hi;
+        u32                     cfg_lo;
+        u8                      src_master;
+        u8                      dst_master;
+};
+
+/**
  * struct dw_dma_platform_data - Controller configuration parameters
  * @nr_channels: Number of channels supported by hardware (max 8)
  * @is_private: The device channels should be marked as private and not for
  *      by the general purpose DMA channel allocator.
+ * @chan_allocation_order: Allocate channels starting from 0 or 7
+ * @chan_priority: Set channel priority increasing from 0 to 7 or 7 to 0.
  * @block_size: Maximum block size supported by the controller
  * @nr_masters: Number of AHB masters supported by the controller
  * @data_width: Maximum data width supported by hardware per AHB master
  *              (0 - 8bits, 1 - 16bits, ..., 5 - 256bits)
+ * @sd: slave specific data. Used for configuring channels
+ * @sd_count: count of slave data structures passed.
  */
 struct dw_dma_platform_data {
         unsigned int    nr_channels;
@@ -36,6 +60,9 @@ struct dw_dma_platform_data {
         unsigned short  block_size;
         unsigned char   nr_masters;
         unsigned char   data_width[4];
+
+        struct dw_dma_slave *sd;
+        unsigned int sd_count;
 };
 
 /* bursts size */
@@ -50,23 +77,6 @@ enum dw_dma_msize {
         DW_DMA_MSIZE_256,
 };
 
-/**
- * struct dw_dma_slave - Controller-specific information about a slave
- *
- * @dma_dev: required DMA master device
- * @cfg_hi: Platform-specific initializer for the CFG_HI register
- * @cfg_lo: Platform-specific initializer for the CFG_LO register
- * @src_master: src master for transfers on allocated channel.
- * @dst_master: dest master for transfers on allocated channel.
- */
-struct dw_dma_slave {
-        struct device           *dma_dev;
-        u32                     cfg_hi;
-        u32                     cfg_lo;
-        u8                      src_master;
-        u8                      dst_master;
-};
-
 /* Platform-configurable bits in CFG_HI */
 #define DWC_CFGH_FCMODE         (1 << 0)
 #define DWC_CFGH_FIFO_MODE      (1 << 1)
@@ -104,5 +114,6 @@ void dw_dma_cyclic_stop(struct dma_chan *chan);
 dma_addr_t dw_dma_get_src_addr(struct dma_chan *chan);
 
 dma_addr_t dw_dma_get_dst_addr(struct dma_chan *chan);
+bool dw_dma_generic_filter(struct dma_chan *chan, void *param);
 
 #endif /* DW_DMAC_H */
diff --git a/include/linux/dynamic_debug.h b/include/linux/dynamic_debug.h
index 6dd4787a798a..2fe93b26b42f 100644
--- a/include/linux/dynamic_debug.h
+++ b/include/linux/dynamic_debug.h
@@ -95,6 +95,17 @@ do {								\
                                      ##__VA_ARGS__);            \
 } while (0)
 
+#define dynamic_hex_dump(prefix_str, prefix_type, rowsize,      \
+                         groupsize, buf, len, ascii)            \
+do {                                                            \
+        DEFINE_DYNAMIC_DEBUG_METADATA(descriptor,               \
+                __builtin_constant_p(prefix_str) ? prefix_str : "hexdump");\
+        if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT))  \
+                print_hex_dump(KERN_DEBUG, prefix_str,          \
+                               prefix_type, rowsize, groupsize, \
+                               buf, len, ascii);                \
+} while (0)
+
 #else
 
 #include <linux/string.h>
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 7a9498ab3c2d..9bf2f1fcae27 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -740,7 +740,8 @@ struct efivars {
          * 1) ->list - adds, removals, reads, writes
          * 2) ops.[gs]et_variable() calls.
          * It must not be held when creating sysfs entries or calling kmalloc.
-         * ops.get_next_variable() is only called from register_efivars(),
+         * ops.get_next_variable() is only called from register_efivars()
+         * or efivar_update_sysfs_entries(),
          * which is protected by the BKL, so that path is safe.
          */
         spinlock_t lock;
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index c03af7687bb4..186620631750 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -138,6 +138,7 @@ extern void elv_drain_elevator(struct request_queue *);
 /*
  * io scheduler registration
  */
+extern void __init load_default_elevator_module(void);
 extern int elv_register(struct elevator_type *);
 extern void elv_unregister(struct elevator_type *);
 
@@ -206,5 +207,9 @@ enum {
         INIT_LIST_HEAD(&(rq)->csd.list);        \
         } while (0)
 
+#else /* CONFIG_BLOCK */
+
+static inline void load_default_elevator_module(void) { }
+
 #endif /* CONFIG_BLOCK */
 #endif
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 243eea1e33d8..c623861964e4 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -40,6 +40,8 @@ extern int eth_header_cache(const struct neighbour *neigh, struct hh_cache *hh,
 extern void eth_header_cache_update(struct hh_cache *hh,
                                     const struct net_device *dev,
                                     const unsigned char *haddr);
+extern int eth_prepare_mac_addr_change(struct net_device *dev, void *p);
+extern void eth_commit_mac_addr_change(struct net_device *dev, void *p);
 extern int eth_mac_addr(struct net_device *dev, void *p);
 extern int eth_change_mtu(struct net_device *dev, int new_mtu);
 extern int eth_validate_addr(struct net_device *dev);
@@ -192,7 +194,7 @@ static inline void eth_zero_addr(u8 *addr)
  */
 static inline void eth_hw_addr_random(struct net_device *dev)
 {
-        dev->addr_assign_type |= NET_ADDR_RANDOM;
+        dev->addr_assign_type = NET_ADDR_RANDOM;
         eth_random_addr(dev->dev_addr);
 }
 
diff --git a/include/linux/extcon/extcon_gpio.h b/include/linux/extcon/extcon-gpio.h
index 2d8307f7d67d..2d8307f7d67d 100644
--- a/include/linux/extcon/extcon_gpio.h
+++ b/include/linux/extcon/extcon-gpio.h
diff --git a/include/linux/fb.h b/include/linux/fb.h
index c7a95714b1fe..58b98606ac26 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -19,6 +19,8 @@ struct vm_area_struct;
 struct fb_info;
 struct device;
 struct file;
+struct videomode;
+struct device_node;
 
 /* Definitions below are used in the parsed monitor specs */
 #define FB_DPMS_ACTIVE_OFF      1
@@ -714,6 +716,12 @@ extern void fb_destroy_modedb(struct fb_videomode *modedb);
 extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
 extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
 
+extern int of_get_fb_videomode(struct device_node *np,
+                               struct fb_videomode *fb,
+                               int index);
+extern int fb_videomode_from_videomode(const struct videomode *vm,
+                                       struct fb_videomode *fbmode);
+
 /* drivers/video/modedb.c */
 #define VESA_MODEDB_SIZE 34
 extern void fb_var_to_videomode(struct fb_videomode *mode,
diff --git a/include/linux/firmware-map.h b/include/linux/firmware-map.h
index 43fe52fcef0f..71d4fa721db9 100644
--- a/include/linux/firmware-map.h
+++ b/include/linux/firmware-map.h
@@ -25,6 +25,7 @@
 
 int firmware_map_add_early(u64 start, u64 end, const char *type);
 int firmware_map_add_hotplug(u64 start, u64 end, const char *type);
+int firmware_map_remove(u64 start, u64 end, const char *type);
 
 #else /* CONFIG_FIRMWARE_MEMMAP */
 
@@ -38,6 +39,11 @@ static inline int firmware_map_add_hotplug(u64 start, u64 end, const char *type)
         return 0;
 }
 
+static inline int firmware_map_remove(u64 start, u64 end, const char *type)
+{
+        return 0;
+}
+
 #endif /* CONFIG_FIRMWARE_MEMMAP */
 
 #endif /* _LINUX_FIRMWARE_MAP_H */
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index e4238ceaa4d6..e70df40d84f6 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -13,6 +13,11 @@ extern bool pm_freezing;		/* PM freezing in effect */
 extern bool pm_nosig_freezing;          /* PM nosig freezing in effect */
 
 /*
+ * Timeout for stopping processes
+ */
+extern unsigned int freeze_timeout_msecs;
+
+/*
  * Check if a process has been frozen
  */
 static inline bool frozen(struct task_struct *p)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 7617ee04f066..7d2e893ec3d1 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -301,7 +301,7 @@ size_t iov_iter_copy_from_user(struct page *page,
                 struct iov_iter *i, unsigned long offset, size_t bytes);
 void iov_iter_advance(struct iov_iter *i, size_t bytes);
 int iov_iter_fault_in_readable(struct iov_iter *i, size_t bytes);
-size_t iov_iter_single_seg_count(struct iov_iter *i);
+size_t iov_iter_single_seg_count(const struct iov_iter *i);
 
 static inline void iov_iter_init(struct iov_iter *i,
                         const struct iovec *iov, unsigned long nr_segs,
diff --git a/include/linux/fsl/bestcomm/ata.h b/include/linux/fsl/bestcomm/ata.h
new file mode 100644
index 000000000000..0b2371811334
--- /dev/null
+++ b/include/linux/fsl/bestcomm/ata.h
@@ -0,0 +1,30 @@
+/*
+ * Header for Bestcomm ATA task driver
+ *
+ *
+ * Copyright (C) 2006 Freescale - John Rigby
+ * Copyright (C) 2006 Sylvain Munaut <tnt@246tNt.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __BESTCOMM_ATA_H__
+#define __BESTCOMM_ATA_H__
+
+
+struct bcom_ata_bd {
+        u32     status;
+        u32     src_pa;
+        u32     dst_pa;
+};
+
+extern struct bcom_task * bcom_ata_init(int queue_len, int maxbufsize);
+extern void bcom_ata_rx_prepare(struct bcom_task *tsk);
+extern void bcom_ata_tx_prepare(struct bcom_task *tsk);
+extern void bcom_ata_reset_bd(struct bcom_task *tsk);
+extern void bcom_ata_release(struct bcom_task *tsk);
+
+#endif /* __BESTCOMM_ATA_H__ */
+
diff --git a/include/linux/fsl/bestcomm/bestcomm.h b/include/linux/fsl/bestcomm/bestcomm.h
new file mode 100644
index 000000000000..a0e2e6b19b57
--- /dev/null
+++ b/include/linux/fsl/bestcomm/bestcomm.h
@@ -0,0 +1,213 @@
+/*
+ * Public header for the MPC52xx processor BestComm driver
+ *
+ *
+ * Copyright (C) 2006      Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2005      Varma Electronics Oy,
+ *                         ( by Andrey Volkov <avolkov@varma-el.com> )
+ * Copyright (C) 2003-2004 MontaVista, Software, Inc.
+ *                         ( by Dale Farnsworth <dfarnsworth@mvista.com> )
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __BESTCOMM_H__
+#define __BESTCOMM_H__
+
+/**
+ * struct bcom_bd - Structure describing a generic BestComm buffer descriptor
+ * @status: The current status of this buffer. Exact meaning depends on the
+ *          task type
+ * @data: An array of u32 extra data.  Size of array is task dependent.
+ *
+ * Note: Don't dereference a bcom_bd pointer as an array.  The size of the
+ *       bcom_bd is variable.  Use bcom_get_bd() instead.
+ */
+struct bcom_bd {
+        u32     status;
+        u32     data[0];        /* variable payload size */
+};
+
+/* ======================================================================== */
+/* Generic task management                                                   */
+/* ======================================================================== */
+
+/**
+ * struct bcom_task - Structure describing a loaded BestComm task
+ *
+ * This structure is never built by the driver it self. It's built and
+ * filled the intermediate layer of the BestComm API, the task dependent
+ * support code.
+ *
+ * Most likely you don't need to poke around inside this structure. The
+ * fields are exposed in the header just for the sake of inline functions
+ */
+struct bcom_task {
+        unsigned int    tasknum;
+        unsigned int    flags;
+        int             irq;
+
+        struct bcom_bd  *bd;
+        phys_addr_t     bd_pa;
+        void            **cookie;
+        unsigned short  index;
+        unsigned short  outdex;
+        unsigned int    num_bd;
+        unsigned int    bd_size;
+
+        void*           priv;
+};
+
+#define BCOM_FLAGS_NONE         0x00000000ul
+#define BCOM_FLAGS_ENABLE_TASK  (1ul <<  0)
+
+/**
+ * bcom_enable - Enable a BestComm task
+ * @tsk: The BestComm task structure
+ *
+ * This function makes sure the given task is enabled and can be run
+ * by the BestComm engine as needed
+ */
+extern void bcom_enable(struct bcom_task *tsk);
+
+/**
+ * bcom_disable - Disable a BestComm task
+ * @tsk: The BestComm task structure
+ *
+ * This function disable a given task, making sure it's not executed
+ * by the BestComm engine.
+ */
+extern void bcom_disable(struct bcom_task *tsk);
+
+
+/**
+ * bcom_get_task_irq - Returns the irq number of a BestComm task
+ * @tsk: The BestComm task structure
+ */
+static inline int
+bcom_get_task_irq(struct bcom_task *tsk) {
+        return tsk->irq;
+}
+
+/* ======================================================================== */
+/* BD based tasks helpers                                                   */
+/* ======================================================================== */
+
+#define BCOM_BD_READY   0x40000000ul
+
+/** _bcom_next_index - Get next input index.
+ * @tsk: pointer to task structure
+ *
+ * Support function; Device drivers should not call this
+ */
+static inline int
+_bcom_next_index(struct bcom_task *tsk)
+{
+        return ((tsk->index + 1) == tsk->num_bd) ? 0 : tsk->index + 1;
+}
+
+/** _bcom_next_outdex - Get next output index.
+ * @tsk: pointer to task structure
+ *
+ * Support function; Device drivers should not call this
+ */
+static inline int
+_bcom_next_outdex(struct bcom_task *tsk)
+{
+        return ((tsk->outdex + 1) == tsk->num_bd) ? 0 : tsk->outdex + 1;
+}
+
+/**
+ * bcom_queue_empty - Checks if a BestComm task BD queue is empty
+ * @tsk: The BestComm task structure
+ */
+static inline int
+bcom_queue_empty(struct bcom_task *tsk)
+{
+        return tsk->index == tsk->outdex;
+}
+
+/**
+ * bcom_queue_full - Checks if a BestComm task BD queue is full
+ * @tsk: The BestComm task structure
+ */
+static inline int
+bcom_queue_full(struct bcom_task *tsk)
+{
+        return tsk->outdex == _bcom_next_index(tsk);
+}
+
+/**
+ * bcom_get_bd - Get a BD from the queue
+ * @tsk: The BestComm task structure
+ * index: Index of the BD to fetch
+ */
+static inline struct bcom_bd
+*bcom_get_bd(struct bcom_task *tsk, unsigned int index)
+{
+        /* A cast to (void*) so the address can be incremented by the
+         * real size instead of by sizeof(struct bcom_bd) */
+        return ((void *)tsk->bd) + (index * tsk->bd_size);
+}
+
+/**
+ * bcom_buffer_done - Checks if a BestComm 
+ * @tsk: The BestComm task structure
+ */
+static inline int
+bcom_buffer_done(struct bcom_task *tsk)
+{
+        struct bcom_bd *bd;
+        if (bcom_queue_empty(tsk))
+                return 0;
+
+        bd = bcom_get_bd(tsk, tsk->outdex);
+        return !(bd->status & BCOM_BD_READY);
+}
+
+/**
+ * bcom_prepare_next_buffer - clear status of next available buffer.
+ * @tsk: The BestComm task structure
+ *
+ * Returns pointer to next buffer descriptor
+ */
+static inline struct bcom_bd *
+bcom_prepare_next_buffer(struct bcom_task *tsk)
+{
+        struct bcom_bd *bd;
+
+        bd = bcom_get_bd(tsk, tsk->index);
+        bd->status = 0; /* cleanup last status */
+        return bd;
+}
+
+static inline void
+bcom_submit_next_buffer(struct bcom_task *tsk, void *cookie)
+{
+        struct bcom_bd *bd = bcom_get_bd(tsk, tsk->index);
+
+        tsk->cookie[tsk->index] = cookie;
+        mb();   /* ensure the bd is really up-to-date */
+        bd->status |= BCOM_BD_READY;
+        tsk->index = _bcom_next_index(tsk);
+        if (tsk->flags & BCOM_FLAGS_ENABLE_TASK)
+                bcom_enable(tsk);
+}
+
+static inline void *
+bcom_retrieve_buffer(struct bcom_task *tsk, u32 *p_status, struct bcom_bd **p_bd)
+{
+        void *cookie = tsk->cookie[tsk->outdex];
+        struct bcom_bd *bd = bcom_get_bd(tsk, tsk->outdex);
+
+        if (p_status)
+                *p_status = bd->status;
+        if (p_bd)
+                *p_bd = bd;
+        tsk->outdex = _bcom_next_outdex(tsk);
+        return cookie;
+}
+
+#endif /* __BESTCOMM_H__ */
diff --git a/include/linux/fsl/bestcomm/bestcomm_priv.h b/include/linux/fsl/bestcomm/bestcomm_priv.h
new file mode 100644
index 000000000000..3b52f3ffbdf8
--- /dev/null
+++ b/include/linux/fsl/bestcomm/bestcomm_priv.h
@@ -0,0 +1,350 @@
+/*
+ * Private header for the MPC52xx processor BestComm driver
+ *
+ * By private, we mean that driver should not use it directly. It's meant
+ * to be used by the BestComm engine driver itself and by the intermediate
+ * layer between the core and the drivers.
+ *
+ * Copyright (C) 2006      Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2005      Varma Electronics Oy,
+ *                         ( by Andrey Volkov <avolkov@varma-el.com> )
+ * Copyright (C) 2003-2004 MontaVista, Software, Inc.
+ *                         ( by Dale Farnsworth <dfarnsworth@mvista.com> )
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __BESTCOMM_PRIV_H__
+#define __BESTCOMM_PRIV_H__
+
+#include <linux/spinlock.h>
+#include <linux/of.h>
+#include <asm/io.h>
+#include <asm/mpc52xx.h>
+
+#include "sram.h"
+
+
+/* ======================================================================== */
+/* Engine related stuff                                                     */
+/* ======================================================================== */
+
+/* Zones sizes and needed alignments */
+#define BCOM_MAX_TASKS          16
+#define BCOM_MAX_VAR            24
+#define BCOM_MAX_INC            8
+#define BCOM_MAX_FDT            64
+#define BCOM_MAX_CTX            20
+#define BCOM_CTX_SIZE           (BCOM_MAX_CTX * sizeof(u32))
+#define BCOM_CTX_ALIGN          0x100
+#define BCOM_VAR_SIZE           (BCOM_MAX_VAR * sizeof(u32))
+#define BCOM_INC_SIZE           (BCOM_MAX_INC * sizeof(u32))
+#define BCOM_VAR_ALIGN          0x80
+#define BCOM_FDT_SIZE           (BCOM_MAX_FDT * sizeof(u32))
+#define BCOM_FDT_ALIGN          0x100
+
+/**
+ * struct bcom_tdt - Task Descriptor Table Entry
+ *
+ */
+struct bcom_tdt {
+        u32 start;
+        u32 stop;
+        u32 var;
+        u32 fdt;
+        u32 exec_status;        /* used internally by BestComm engine */
+        u32 mvtp;               /* used internally by BestComm engine */
+        u32 context;
+        u32 litbase;
+};
+
+/**
+ * struct bcom_engine
+ *
+ * This holds all info needed globaly to handle the engine
+ */
+struct bcom_engine {
+        struct device_node              *ofnode;
+        struct mpc52xx_sdma __iomem     *regs;
+        phys_addr_t                      regs_base;
+
+        struct bcom_tdt                 *tdt;
+        u32                             *ctx;
+        u32                             *var;
+        u32                             *fdt;
+
+        spinlock_t                      lock;
+};
+
+extern struct bcom_engine *bcom_eng;
+
+
+/* ======================================================================== */
+/* Tasks related stuff                                                      */
+/* ======================================================================== */
+
+/* Tasks image header */
+#define BCOM_TASK_MAGIC         0x4243544B      /* 'BCTK' */
+
+struct bcom_task_header {
+        u32     magic;
+        u8      desc_size;      /* the size fields     */
+        u8      var_size;       /* are given in number */
+        u8      inc_size;       /* of 32-bits words    */
+        u8      first_var;
+        u8      reserved[8];
+};
+
+/* Descriptors structure & co */
+#define BCOM_DESC_NOP           0x000001f8
+#define BCOM_LCD_MASK           0x80000000
+#define BCOM_DRD_EXTENDED       0x40000000
+#define BCOM_DRD_INITIATOR_SHIFT        21
+
+/* Tasks pragma */
+#define BCOM_PRAGMA_BIT_RSV             7       /* reserved pragma bit */
+#define BCOM_PRAGMA_BIT_PRECISE_INC     6       /* increment 0=when possible, */
+                                                /*           1=iter end */
+#define BCOM_PRAGMA_BIT_RST_ERROR_NO    5       /* don't reset errors on */
+                                                /* task enable */
+#define BCOM_PRAGMA_BIT_PACK            4       /* pack data enable */
+#define BCOM_PRAGMA_BIT_INTEGER         3       /* data alignment */
+                                                /* 0=frac(msb), 1=int(lsb) */
+#define BCOM_PRAGMA_BIT_SPECREAD        2       /* XLB speculative read */
+#define BCOM_PRAGMA_BIT_CW              1       /* write line buffer enable */
+#define BCOM_PRAGMA_BIT_RL              0       /* read line buffer enable */
+
+        /* Looks like XLB speculative read generates XLB errors when a buffer
+         * is at the end of the physical memory. i.e. when accessing the
+         * lasts words, the engine tries to prefetch the next but there is no
+         * next ...
+         */
+#define BCOM_STD_PRAGMA         ((0 << BCOM_PRAGMA_BIT_RSV)             | \
+                                 (0 << BCOM_PRAGMA_BIT_PRECISE_INC)     | \
+                                 (0 << BCOM_PRAGMA_BIT_RST_ERROR_NO)    | \
+                                 (0 << BCOM_PRAGMA_BIT_PACK)            | \
+                                 (0 << BCOM_PRAGMA_BIT_INTEGER)         | \
+                                 (0 << BCOM_PRAGMA_BIT_SPECREAD)        | \
+                                 (1 << BCOM_PRAGMA_BIT_CW)              | \
+                                 (1 << BCOM_PRAGMA_BIT_RL))
+
+#define BCOM_PCI_PRAGMA         ((0 << BCOM_PRAGMA_BIT_RSV)             | \
+                                 (0 << BCOM_PRAGMA_BIT_PRECISE_INC)     | \
+                                 (0 << BCOM_PRAGMA_BIT_RST_ERROR_NO)    | \
+                                 (0 << BCOM_PRAGMA_BIT_PACK)            | \
+                                 (1 << BCOM_PRAGMA_BIT_INTEGER)         | \
+                                 (0 << BCOM_PRAGMA_BIT_SPECREAD)        | \
+                                 (1 << BCOM_PRAGMA_BIT_CW)              | \
+                                 (1 << BCOM_PRAGMA_BIT_RL))
+
+#define BCOM_ATA_PRAGMA         BCOM_STD_PRAGMA
+#define BCOM_CRC16_DP_0_PRAGMA  BCOM_STD_PRAGMA
+#define BCOM_CRC16_DP_1_PRAGMA  BCOM_STD_PRAGMA
+#define BCOM_FEC_RX_BD_PRAGMA   BCOM_STD_PRAGMA
+#define BCOM_FEC_TX_BD_PRAGMA   BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_0_PRAGMA    BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_1_PRAGMA    BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_2_PRAGMA    BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_3_PRAGMA    BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_BD_0_PRAGMA BCOM_STD_PRAGMA
+#define BCOM_GEN_DP_BD_1_PRAGMA BCOM_STD_PRAGMA
+#define BCOM_GEN_RX_BD_PRAGMA   BCOM_STD_PRAGMA
+#define BCOM_GEN_TX_BD_PRAGMA   BCOM_STD_PRAGMA
+#define BCOM_GEN_LPC_PRAGMA     BCOM_STD_PRAGMA
+#define BCOM_PCI_RX_PRAGMA      BCOM_PCI_PRAGMA
+#define BCOM_PCI_TX_PRAGMA      BCOM_PCI_PRAGMA
+
+/* Initiators number */
+#define BCOM_INITIATOR_ALWAYS    0
+#define BCOM_INITIATOR_SCTMR_0   1
+#define BCOM_INITIATOR_SCTMR_1   2
+#define BCOM_INITIATOR_FEC_RX    3
+#define BCOM_INITIATOR_FEC_TX    4
+#define BCOM_INITIATOR_ATA_RX    5
+#define BCOM_INITIATOR_ATA_TX    6
+#define BCOM_INITIATOR_SCPCI_RX  7
+#define BCOM_INITIATOR_SCPCI_TX  8
+#define BCOM_INITIATOR_PSC3_RX   9
+#define BCOM_INITIATOR_PSC3_TX  10
+#define BCOM_INITIATOR_PSC2_RX  11
+#define BCOM_INITIATOR_PSC2_TX  12
+#define BCOM_INITIATOR_PSC1_RX  13
+#define BCOM_INITIATOR_PSC1_TX  14
+#define BCOM_INITIATOR_SCTMR_2  15
+#define BCOM_INITIATOR_SCLPC    16
+#define BCOM_INITIATOR_PSC5_RX  17
+#define BCOM_INITIATOR_PSC5_TX  18
+#define BCOM_INITIATOR_PSC4_RX  19
+#define BCOM_INITIATOR_PSC4_TX  20
+#define BCOM_INITIATOR_I2C2_RX  21
+#define BCOM_INITIATOR_I2C2_TX  22
+#define BCOM_INITIATOR_I2C1_RX  23
+#define BCOM_INITIATOR_I2C1_TX  24
+#define BCOM_INITIATOR_PSC6_RX  25
+#define BCOM_INITIATOR_PSC6_TX  26
+#define BCOM_INITIATOR_IRDA_RX  25
+#define BCOM_INITIATOR_IRDA_TX  26
+#define BCOM_INITIATOR_SCTMR_3  27
+#define BCOM_INITIATOR_SCTMR_4  28
+#define BCOM_INITIATOR_SCTMR_5  29
+#define BCOM_INITIATOR_SCTMR_6  30
+#define BCOM_INITIATOR_SCTMR_7  31
+
+/* Initiators priorities */
+#define BCOM_IPR_ALWAYS         7
+#define BCOM_IPR_SCTMR_0        2
+#define BCOM_IPR_SCTMR_1        2
+#define BCOM_IPR_FEC_RX         6
+#define BCOM_IPR_FEC_TX         5
+#define BCOM_IPR_ATA_RX         7
+#define BCOM_IPR_ATA_TX         7
+#define BCOM_IPR_SCPCI_RX       2
+#define BCOM_IPR_SCPCI_TX       2
+#define BCOM_IPR_PSC3_RX        2
+#define BCOM_IPR_PSC3_TX        2
+#define BCOM_IPR_PSC2_RX        2
+#define BCOM_IPR_PSC2_TX        2
+#define BCOM_IPR_PSC1_RX        2
+#define BCOM_IPR_PSC1_TX        2
+#define BCOM_IPR_SCTMR_2        2
+#define BCOM_IPR_SCLPC          2
+#define BCOM_IPR_PSC5_RX        2
+#define BCOM_IPR_PSC5_TX        2
+#define BCOM_IPR_PSC4_RX        2
+#define BCOM_IPR_PSC4_TX        2
+#define BCOM_IPR_I2C2_RX        2
+#define BCOM_IPR_I2C2_TX        2
+#define BCOM_IPR_I2C1_RX        2
+#define BCOM_IPR_I2C1_TX        2
+#define BCOM_IPR_PSC6_RX        2
+#define BCOM_IPR_PSC6_TX        2
+#define BCOM_IPR_IRDA_RX        2
+#define BCOM_IPR_IRDA_TX        2
+#define BCOM_IPR_SCTMR_3        2
+#define BCOM_IPR_SCTMR_4        2
+#define BCOM_IPR_SCTMR_5        2
+#define BCOM_IPR_SCTMR_6        2
+#define BCOM_IPR_SCTMR_7        2
+
+
+/* ======================================================================== */
+/* API                                                                      */
+/* ======================================================================== */
+
+extern struct bcom_task *bcom_task_alloc(int bd_count, int bd_size, int priv_size);
+extern void bcom_task_free(struct bcom_task *tsk);
+extern int bcom_load_image(int task, u32 *task_image);
+extern void bcom_set_initiator(int task, int initiator);
+
+
+#define TASK_ENABLE             0x8000
+
+/**
+ * bcom_disable_prefetch - Hook to disable bus prefetching
+ *
+ * ATA DMA and the original MPC5200 need this due to silicon bugs.  At the
+ * moment disabling prefetch is a one-way street.  There is no mechanism
+ * in place to turn prefetch back on after it has been disabled.  There is
+ * no reason it couldn't be done, it would just be more complex to implement.
+ */
+static inline void bcom_disable_prefetch(void)
+{
+        u16 regval;
+
+        regval = in_be16(&bcom_eng->regs->PtdCntrl);
+        out_be16(&bcom_eng->regs->PtdCntrl, regval | 1);
+};
+
+static inline void
+bcom_enable_task(int task)
+{
+        u16 reg;
+        reg = in_be16(&bcom_eng->regs->tcr[task]);
+        out_be16(&bcom_eng->regs->tcr[task],  reg | TASK_ENABLE);
+}
+
+static inline void
+bcom_disable_task(int task)
+{
+        u16 reg = in_be16(&bcom_eng->regs->tcr[task]);
+        out_be16(&bcom_eng->regs->tcr[task], reg & ~TASK_ENABLE);
+}
+
+
+static inline u32 *
+bcom_task_desc(int task)
+{
+        return bcom_sram_pa2va(bcom_eng->tdt[task].start);
+}
+
+static inline int
+bcom_task_num_descs(int task)
+{
+        return (bcom_eng->tdt[task].stop - bcom_eng->tdt[task].start)/sizeof(u32) + 1;
+}
+
+static inline u32 *
+bcom_task_var(int task)
+{
+        return bcom_sram_pa2va(bcom_eng->tdt[task].var);
+}
+
+static inline u32 *
+bcom_task_inc(int task)
+{
+        return &bcom_task_var(task)[BCOM_MAX_VAR];
+}
+
+
+static inline int
+bcom_drd_is_extended(u32 desc)
+{
+        return (desc) & BCOM_DRD_EXTENDED;
+}
+
+static inline int
+bcom_desc_is_drd(u32 desc)
+{
+        return !(desc & BCOM_LCD_MASK) && desc != BCOM_DESC_NOP;
+}
+
+static inline int
+bcom_desc_initiator(u32 desc)
+{
+        return (desc >> BCOM_DRD_INITIATOR_SHIFT) & 0x1f;
+}
+
+static inline void
+bcom_set_desc_initiator(u32 *desc, int initiator)
+{
+        *desc = (*desc & ~(0x1f << BCOM_DRD_INITIATOR_SHIFT)) |
+                        ((initiator & 0x1f) << BCOM_DRD_INITIATOR_SHIFT);
+}
+
+
+static inline void
+bcom_set_task_pragma(int task, int pragma)
+{
+        u32 *fdt = &bcom_eng->tdt[task].fdt;
+        *fdt = (*fdt & ~0xff) | pragma;
+}
+
+static inline void
+bcom_set_task_auto_start(int task, int next_task)
+{
+        u16 __iomem *tcr = &bcom_eng->regs->tcr[task];
+        out_be16(tcr, (in_be16(tcr) & ~0xff) | 0x00c0 | next_task);
+}
+
+static inline void
+bcom_set_tcr_initiator(int task, int initiator)
+{
+        u16 __iomem *tcr = &bcom_eng->regs->tcr[task];
+        out_be16(tcr, (in_be16(tcr) & ~0x1f00) | ((initiator & 0x1f) << 8));
+}
+
+
+#endif /* __BESTCOMM_PRIV_H__ */
+
diff --git a/include/linux/fsl/bestcomm/fec.h b/include/linux/fsl/bestcomm/fec.h
new file mode 100644
index 000000000000..ee565d94d503
--- /dev/null
+++ b/include/linux/fsl/bestcomm/fec.h
@@ -0,0 +1,61 @@
+/*
+ * Header for Bestcomm FEC tasks driver
+ *
+ *
+ * Copyright (C) 2006-2007 Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2003-2004 MontaVista, Software, Inc.
+ *                         ( by Dale Farnsworth <dfarnsworth@mvista.com> )
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __BESTCOMM_FEC_H__
+#define __BESTCOMM_FEC_H__
+
+
+struct bcom_fec_bd {
+        u32     status;
+        u32     skb_pa;
+};
+
+#define BCOM_FEC_TX_BD_TFD      0x08000000ul    /* transmit frame done */
+#define BCOM_FEC_TX_BD_TC       0x04000000ul    /* transmit CRC */
+#define BCOM_FEC_TX_BD_ABC      0x02000000ul    /* append bad CRC */
+
+#define BCOM_FEC_RX_BD_L        0x08000000ul    /* buffer is last in frame */
+#define BCOM_FEC_RX_BD_BC       0x00800000ul    /* DA is broadcast */
+#define BCOM_FEC_RX_BD_MC       0x00400000ul    /* DA is multicast and not broadcast */
+#define BCOM_FEC_RX_BD_LG       0x00200000ul    /* Rx frame length violation */
+#define BCOM_FEC_RX_BD_NO       0x00100000ul    /* Rx non-octet aligned frame */
+#define BCOM_FEC_RX_BD_CR       0x00040000ul    /* Rx CRC error */
+#define BCOM_FEC_RX_BD_OV       0x00020000ul    /* overrun */
+#define BCOM_FEC_RX_BD_TR       0x00010000ul    /* Rx frame truncated */
+#define BCOM_FEC_RX_BD_LEN_MASK 0x000007fful    /* mask for length of received frame */
+#define BCOM_FEC_RX_BD_ERRORS   (BCOM_FEC_RX_BD_LG | BCOM_FEC_RX_BD_NO | \
+                BCOM_FEC_RX_BD_CR | BCOM_FEC_RX_BD_OV | BCOM_FEC_RX_BD_TR)
+
+
+extern struct bcom_task *
+bcom_fec_rx_init(int queue_len, phys_addr_t fifo, int maxbufsize);
+
+extern int
+bcom_fec_rx_reset(struct bcom_task *tsk);
+
+extern void
+bcom_fec_rx_release(struct bcom_task *tsk);
+
+
+extern struct bcom_task *
+bcom_fec_tx_init(int queue_len, phys_addr_t fifo);
+
+extern int
+bcom_fec_tx_reset(struct bcom_task *tsk);
+
+extern void
+bcom_fec_tx_release(struct bcom_task *tsk);
+
+
+#endif /* __BESTCOMM_FEC_H__ */
+
diff --git a/include/linux/fsl/bestcomm/gen_bd.h b/include/linux/fsl/bestcomm/gen_bd.h
new file mode 100644
index 000000000000..de47260e69da
--- /dev/null
+++ b/include/linux/fsl/bestcomm/gen_bd.h
@@ -0,0 +1,53 @@
+/*
+ * Header for Bestcomm General Buffer Descriptor tasks driver
+ *
+ *
+ * Copyright (C) 2007 Sylvain Munaut <tnt@246tNt.com>
+ * Copyright (C) 2006 AppSpec Computer Technologies Corp.
+ *                    Jeff Gibbons <jeff.gibbons@appspec.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 __BESTCOMM_GEN_BD_H__
+#define __BESTCOMM_GEN_BD_H__
+
+struct bcom_gen_bd {
+        u32     status;
+        u32     buf_pa;
+};
+
+
+extern struct bcom_task *
+bcom_gen_bd_rx_init(int queue_len, phys_addr_t fifo,
+                        int initiator, int ipr, int maxbufsize);
+
+extern int
+bcom_gen_bd_rx_reset(struct bcom_task *tsk);
+
+extern void
+bcom_gen_bd_rx_release(struct bcom_task *tsk);
+
+
+extern struct bcom_task *
+bcom_gen_bd_tx_init(int queue_len, phys_addr_t fifo,
+                        int initiator, int ipr);
+
+extern int
+bcom_gen_bd_tx_reset(struct bcom_task *tsk);
+
+extern void
+bcom_gen_bd_tx_release(struct bcom_task *tsk);
+
+
+/* PSC support utility wrappers */
+struct bcom_task * bcom_psc_gen_bd_rx_init(unsigned psc_num, int queue_len,
+                                           phys_addr_t fifo, int maxbufsize);
+struct bcom_task * bcom_psc_gen_bd_tx_init(unsigned psc_num, int queue_len,
+                                           phys_addr_t fifo);
+#endif  /* __BESTCOMM_GEN_BD_H__ */
+
diff --git a/include/linux/fsl/bestcomm/sram.h b/include/linux/fsl/bestcomm/sram.h
new file mode 100644
index 000000000000..b6d668963cce
--- /dev/null
+++ b/include/linux/fsl/bestcomm/sram.h
@@ -0,0 +1,54 @@
+/*
+ * Handling of a sram zone for bestcomm
+ *
+ *
+ * Copyright (C) 2007 Sylvain Munaut <tnt@246tNt.com>
+ *
+ * This file is licensed under the terms of the GNU General Public License
+ * version 2. This program is licensed "as is" without any warranty of any
+ * kind, whether express or implied.
+ */
+
+#ifndef __BESTCOMM_SRAM_H__
+#define __BESTCOMM_SRAM_H__
+
+#include <asm/rheap.h>
+#include <asm/mmu.h>
+#include <linux/spinlock.h>
+
+
+/* Structure used internally */
+        /* The internals are here for the inline functions
+         * sake, certainly not for the user to mess with !
+         */
+struct bcom_sram {
+        phys_addr_t              base_phys;
+        void                    *base_virt;
+        unsigned int             size;
+        rh_info_t               *rh;
+        spinlock_t               lock;
+};
+
+extern struct bcom_sram *bcom_sram;
+
+
+/* Public API */
+extern int  bcom_sram_init(struct device_node *sram_node, char *owner);
+extern void bcom_sram_cleanup(void);
+
+extern void* bcom_sram_alloc(int size, int align, phys_addr_t *phys);
+extern void  bcom_sram_free(void *ptr);
+
+static inline phys_addr_t bcom_sram_va2pa(void *va) {
+        return bcom_sram->base_phys +
+                (unsigned long)(va - bcom_sram->base_virt);
+}
+
+static inline void *bcom_sram_pa2va(phys_addr_t pa) {
+        return bcom_sram->base_virt +
+                (unsigned long)(pa - bcom_sram->base_phys);
+}
+
+
+#endif  /* __BESTCOMM_SRAM_H__ */
+
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 92691d85c320..e5ca8ef50e9b 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -74,7 +74,7 @@ typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
  * SAVE_REGS - The ftrace_ops wants regs saved at each function called
  *            and passed to the callback. If this flag is set, but the
  *            architecture does not support passing regs
- *            (ARCH_SUPPORTS_FTRACE_SAVE_REGS is not defined), then the
+ *            (CONFIG_DYNAMIC_FTRACE_WITH_REGS is not defined), then the
  *            ftrace_ops will fail to register, unless the next flag
  *            is set.
  * SAVE_REGS_IF_SUPPORTED - This is the same as SAVE_REGS, but if the
@@ -418,7 +418,7 @@ void ftrace_modify_all_code(int command);
 #endif
 
 #ifndef FTRACE_REGS_ADDR
-#ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
 # define FTRACE_REGS_ADDR ((unsigned long)ftrace_regs_caller)
 #else
 # define FTRACE_REGS_ADDR FTRACE_ADDR
@@ -480,7 +480,7 @@ extern int ftrace_make_nop(struct module *mod,
  */
 extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
 
-#ifdef ARCH_SUPPORTS_FTRACE_SAVE_REGS
+#ifdef CONFIG_DYNAMIC_FTRACE_WITH_REGS
 /**
  * ftrace_modify_call - convert from one addr to another (no nop)
  * @rec: the mcount call site record
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index a3d489531d83..13a54d0bdfa8 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -49,7 +49,6 @@ struct trace_entry {
         unsigned char           flags;
         unsigned char           preempt_count;
         int                     pid;
-        int                     padding;
 };
 
 #define FTRACE_MAX_EVENT                                                \
@@ -84,6 +83,9 @@ struct trace_iterator {
         long                    idx;
 
         cpumask_var_t           started;
+
+        /* it's true when current open file is snapshot */
+        bool                    snapshot;
 };
 
 enum trace_iter_flags {
@@ -272,7 +274,7 @@ extern int trace_define_field(struct ftrace_event_call *call, const char *type,
 extern int trace_add_event_call(struct ftrace_event_call *call);
 extern void trace_remove_event_call(struct ftrace_event_call *call);
 
-#define is_signed_type(type)    (((type)(-1)) < 0)
+#define is_signed_type(type)    (((type)(-1)) < (type)0)
 
 int trace_set_clr_event(const char *system, const char *event, int set);
 
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 79b8bba19363..9f3c275e053e 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -231,6 +231,12 @@ static inline void part_pack_uuid(const u8 *uuid_str, u8 *to)
         }
 }
 
+static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
+{
+        part_pack_uuid(uuid_str, to);
+        return 0;
+}
+
 static inline int disk_max_parts(struct gendisk *disk)
 {
         if (disk->flags & GENHD_FL_EXT_DEVT)
@@ -718,6 +724,10 @@ static inline dev_t blk_lookup_devt(const char *name, int partno)
         return devt;
 }
 
+static inline int blk_part_pack_uuid(const u8 *uuid_str, u8 *to)
+{
+        return -EINVAL;
+}
 #endif /* CONFIG_BLOCK */
 
 #endif /* _LINUX_GENHD_H */
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index bfe665621536..f6c7ae3e223b 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -94,24 +94,12 @@ static inline int gpio_request(unsigned gpio, const char *label)
         return -ENOSYS;
 }
 
-static inline int devm_gpio_request(struct device *dev, unsigned gpio,
-                                    const char *label)
-{
-        return -ENOSYS;
-}
-
 static inline int gpio_request_one(unsigned gpio,
                                         unsigned long flags, const char *label)
 {
         return -ENOSYS;
 }
 
-static inline int devm_gpio_request_one(struct device *dev, unsigned gpio,
-                                        unsigned long flags, const char *label)
-{
-        return -ENOSYS;
-}
-
 static inline int gpio_request_array(const struct gpio *array, size_t num)
 {
         return -ENOSYS;
@@ -125,14 +113,6 @@ static inline void gpio_free(unsigned gpio)
         WARN_ON(1);
 }
 
-static inline void devm_gpio_free(struct device *dev, unsigned gpio)
-{
-        might_sleep();
-
-        /* GPIO can never have been requested */
-        WARN_ON(1);
-}
-
 static inline void gpio_free_array(const struct gpio *array, size_t num)
 {
         might_sleep();
@@ -248,4 +228,12 @@ gpiochip_remove_pin_ranges(struct gpio_chip *chip)
 
 #endif /* ! CONFIG_GENERIC_GPIO */
 
+struct device;
+
+/* bindings for managed devices that want to request gpios */
+int devm_gpio_request(struct device *dev, unsigned gpio, const char *label);
+int devm_gpio_request_one(struct device *dev, unsigned gpio,
+                          unsigned long flags, const char *label);
+void devm_gpio_free(struct device *dev, unsigned int gpio);
+
 #endif /* __LINUX_GPIO_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index 624ef3f45c8e..29eb805ea4a6 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -153,7 +153,7 @@ extern void rcu_nmi_exit(void);
  */
 #define __irq_enter()                                   \
         do {                                            \
-                vtime_account_irq_enter(current);       \
+                account_irq_enter_time(current);        \
                 add_preempt_count(HARDIRQ_OFFSET);      \
                 trace_hardirq_enter();                  \
         } while (0)
@@ -169,7 +169,7 @@ extern void irq_enter(void);
 #define __irq_exit()                                    \
         do {                                            \
                 trace_hardirq_exit();                   \
-                vtime_account_irq_exit(current);        \
+                account_irq_exit_time(current);         \
                 sub_preempt_count(HARDIRQ_OFFSET);      \
         } while (0)
 
@@ -180,10 +180,10 @@ extern void irq_exit(void);
 
 #define nmi_enter()                                             \
         do {                                                    \
+                lockdep_off();                                  \
                 ftrace_nmi_enter();                             \
                 BUG_ON(in_nmi());                               \
                 add_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
-                lockdep_off();                                  \
                 rcu_nmi_enter();                                \
                 trace_hardirq_enter();                          \
         } while (0)
@@ -192,10 +192,10 @@ extern void irq_exit(void);
         do {                                                    \
                 trace_hardirq_exit();                           \
                 rcu_nmi_exit();                                 \
-                lockdep_on();                                   \
                 BUG_ON(!in_nmi());                              \
                 sub_preempt_count(NMI_OFFSET + HARDIRQ_OFFSET); \
                 ftrace_nmi_exit();                              \
+                lockdep_on();                                   \
         } while (0)
 
 #endif /* LINUX_HARDIRQ_H */
diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h
new file mode 100644
index 000000000000..3b589440ecfe
--- /dev/null
+++ b/include/linux/hdmi.h
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2012 Avionic Design GmbH
+ *
+ * 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_HDMI_H_
+#define __LINUX_HDMI_H_
+
+#include <linux/types.h>
+
+enum hdmi_infoframe_type {
+        HDMI_INFOFRAME_TYPE_VENDOR = 0x81,
+        HDMI_INFOFRAME_TYPE_AVI = 0x82,
+        HDMI_INFOFRAME_TYPE_SPD = 0x83,
+        HDMI_INFOFRAME_TYPE_AUDIO = 0x84,
+};
+
+#define HDMI_INFOFRAME_HEADER_SIZE  4
+#define HDMI_AVI_INFOFRAME_SIZE    13
+#define HDMI_SPD_INFOFRAME_SIZE    25
+#define HDMI_AUDIO_INFOFRAME_SIZE  10
+
+enum hdmi_colorspace {
+        HDMI_COLORSPACE_RGB,
+        HDMI_COLORSPACE_YUV422,
+        HDMI_COLORSPACE_YUV444,
+};
+
+enum hdmi_scan_mode {
+        HDMI_SCAN_MODE_NONE,
+        HDMI_SCAN_MODE_OVERSCAN,
+        HDMI_SCAN_MODE_UNDERSCAN,
+};
+
+enum hdmi_colorimetry {
+        HDMI_COLORIMETRY_NONE,
+        HDMI_COLORIMETRY_ITU_601,
+        HDMI_COLORIMETRY_ITU_709,
+        HDMI_COLORIMETRY_EXTENDED,
+};
+
+enum hdmi_picture_aspect {
+        HDMI_PICTURE_ASPECT_NONE,
+        HDMI_PICTURE_ASPECT_4_3,
+        HDMI_PICTURE_ASPECT_16_9,
+};
+
+enum hdmi_active_aspect {
+        HDMI_ACTIVE_ASPECT_16_9_TOP = 2,
+        HDMI_ACTIVE_ASPECT_14_9_TOP = 3,
+        HDMI_ACTIVE_ASPECT_16_9_CENTER = 4,
+        HDMI_ACTIVE_ASPECT_PICTURE = 8,
+        HDMI_ACTIVE_ASPECT_4_3 = 9,
+        HDMI_ACTIVE_ASPECT_16_9 = 10,
+        HDMI_ACTIVE_ASPECT_14_9 = 11,
+        HDMI_ACTIVE_ASPECT_4_3_SP_14_9 = 13,
+        HDMI_ACTIVE_ASPECT_16_9_SP_14_9 = 14,
+        HDMI_ACTIVE_ASPECT_16_9_SP_4_3 = 15,
+};
+
+enum hdmi_extended_colorimetry {
+        HDMI_EXTENDED_COLORIMETRY_XV_YCC_601,
+        HDMI_EXTENDED_COLORIMETRY_XV_YCC_709,
+        HDMI_EXTENDED_COLORIMETRY_S_YCC_601,
+        HDMI_EXTENDED_COLORIMETRY_ADOBE_YCC_601,
+        HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB,
+};
+
+enum hdmi_quantization_range {
+        HDMI_QUANTIZATION_RANGE_DEFAULT,
+        HDMI_QUANTIZATION_RANGE_LIMITED,
+        HDMI_QUANTIZATION_RANGE_FULL,
+};
+
+/* non-uniform picture scaling */
+enum hdmi_nups {
+        HDMI_NUPS_UNKNOWN,
+        HDMI_NUPS_HORIZONTAL,
+        HDMI_NUPS_VERTICAL,
+        HDMI_NUPS_BOTH,
+};
+
+enum hdmi_ycc_quantization_range {
+        HDMI_YCC_QUANTIZATION_RANGE_LIMITED,
+        HDMI_YCC_QUANTIZATION_RANGE_FULL,
+};
+
+enum hdmi_content_type {
+        HDMI_CONTENT_TYPE_NONE,
+        HDMI_CONTENT_TYPE_PHOTO,
+        HDMI_CONTENT_TYPE_CINEMA,
+        HDMI_CONTENT_TYPE_GAME,
+};
+
+struct hdmi_avi_infoframe {
+        enum hdmi_infoframe_type type;
+        unsigned char version;
+        unsigned char length;
+        enum hdmi_colorspace colorspace;
+        bool active_info_valid;
+        bool horizontal_bar_valid;
+        bool vertical_bar_valid;
+        enum hdmi_scan_mode scan_mode;
+        enum hdmi_colorimetry colorimetry;
+        enum hdmi_picture_aspect picture_aspect;
+        enum hdmi_active_aspect active_aspect;
+        bool itc;
+        enum hdmi_extended_colorimetry extended_colorimetry;
+        enum hdmi_quantization_range quantization_range;
+        enum hdmi_nups nups;
+        unsigned char video_code;
+        enum hdmi_ycc_quantization_range ycc_quantization_range;
+        enum hdmi_content_type content_type;
+        unsigned char pixel_repeat;
+        unsigned short top_bar;
+        unsigned short bottom_bar;
+        unsigned short left_bar;
+        unsigned short right_bar;
+};
+
+int hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame);
+ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame, void *buffer,
+                                size_t size);
+
+enum hdmi_spd_sdi {
+        HDMI_SPD_SDI_UNKNOWN,
+        HDMI_SPD_SDI_DSTB,
+        HDMI_SPD_SDI_DVDP,
+        HDMI_SPD_SDI_DVHS,
+        HDMI_SPD_SDI_HDDVR,
+        HDMI_SPD_SDI_DVC,
+        HDMI_SPD_SDI_DSC,
+        HDMI_SPD_SDI_VCD,
+        HDMI_SPD_SDI_GAME,
+        HDMI_SPD_SDI_PC,
+        HDMI_SPD_SDI_BD,
+        HDMI_SPD_SDI_SACD,
+        HDMI_SPD_SDI_HDDVD,
+        HDMI_SPD_SDI_PMP,
+};
+
+struct hdmi_spd_infoframe {
+        enum hdmi_infoframe_type type;
+        unsigned char version;
+        unsigned char length;
+        char vendor[8];
+        char product[16];
+        enum hdmi_spd_sdi sdi;
+};
+
+int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame,
+                            const char *vendor, const char *product);
+ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame, void *buffer,
+                                size_t size);
+
+enum hdmi_audio_coding_type {
+        HDMI_AUDIO_CODING_TYPE_STREAM,
+        HDMI_AUDIO_CODING_TYPE_PCM,
+        HDMI_AUDIO_CODING_TYPE_AC3,
+        HDMI_AUDIO_CODING_TYPE_MPEG1,
+        HDMI_AUDIO_CODING_TYPE_MP3,
+        HDMI_AUDIO_CODING_TYPE_MPEG2,
+        HDMI_AUDIO_CODING_TYPE_AAC_LC,
+        HDMI_AUDIO_CODING_TYPE_DTS,
+        HDMI_AUDIO_CODING_TYPE_ATRAC,
+        HDMI_AUDIO_CODING_TYPE_DSD,
+        HDMI_AUDIO_CODING_TYPE_EAC3,
+        HDMI_AUDIO_CODING_TYPE_DTS_HD,
+        HDMI_AUDIO_CODING_TYPE_MLP,
+        HDMI_AUDIO_CODING_TYPE_DST,
+        HDMI_AUDIO_CODING_TYPE_WMA_PRO,
+};
+
+enum hdmi_audio_sample_size {
+        HDMI_AUDIO_SAMPLE_SIZE_STREAM,
+        HDMI_AUDIO_SAMPLE_SIZE_16,
+        HDMI_AUDIO_SAMPLE_SIZE_20,
+        HDMI_AUDIO_SAMPLE_SIZE_24,
+};
+
+enum hdmi_audio_sample_frequency {
+        HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_32000,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_44100,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_48000,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_88200,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_96000,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_176400,
+        HDMI_AUDIO_SAMPLE_FREQUENCY_192000,
+};
+
+enum hdmi_audio_coding_type_ext {
+        HDMI_AUDIO_CODING_TYPE_EXT_STREAM,
+        HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC,
+        HDMI_AUDIO_CODING_TYPE_EXT_HE_AAC_V2,
+        HDMI_AUDIO_CODING_TYPE_EXT_MPEG_SURROUND,
+};
+
+struct hdmi_audio_infoframe {
+        enum hdmi_infoframe_type type;
+        unsigned char version;
+        unsigned char length;
+        unsigned char channels;
+        enum hdmi_audio_coding_type coding_type;
+        enum hdmi_audio_sample_size sample_size;
+        enum hdmi_audio_sample_frequency sample_frequency;
+        enum hdmi_audio_coding_type_ext coding_type_ext;
+        unsigned char channel_allocation;
+        unsigned char level_shift_value;
+        bool downmix_inhibit;
+
+};
+
+int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame);
+ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
+                                  void *buffer, size_t size);
+
+struct hdmi_vendor_infoframe {
+        enum hdmi_infoframe_type type;
+        unsigned char version;
+        unsigned char length;
+        u8 data[27];
+};
+
+ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame,
+                                   void *buffer, size_t size);
+
+#endif /* _DRM_HDMI_H */
diff --git a/include/linux/hid-sensor-hub.h b/include/linux/hid-sensor-hub.h
index 0aa5f4c42ae6..ecefb7311dd6 100644
--- a/include/linux/hid-sensor-hub.h
+++ b/include/linux/hid-sensor-hub.h
@@ -157,4 +157,42 @@ int sensor_hub_set_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
 */
 int sensor_hub_get_feature(struct hid_sensor_hub_device *hsdev, u32 report_id,
                         u32 field_index, s32 *value);
+
+/* hid-sensor-attributes */
+
+/* Common hid sensor iio structure */
+struct hid_sensor_common {
+        struct hid_sensor_hub_device *hsdev;
+        struct platform_device *pdev;
+        unsigned usage_id;
+        bool data_ready;
+        struct hid_sensor_hub_attribute_info poll;
+        struct hid_sensor_hub_attribute_info report_state;
+        struct hid_sensor_hub_attribute_info power_state;
+        struct hid_sensor_hub_attribute_info sensitivity;
+};
+
+/*Convert from hid unit expo to regular exponent*/
+static inline int hid_sensor_convert_exponent(int unit_expo)
+{
+        if (unit_expo < 0x08)
+                return unit_expo;
+        else if (unit_expo <= 0x0f)
+                return -(0x0f-unit_expo+1);
+        else
+                return 0;
+}
+
+int hid_sensor_parse_common_attributes(struct hid_sensor_hub_device *hsdev,
+                                        u32 usage_id,
+                                        struct hid_sensor_common *st);
+int hid_sensor_write_raw_hyst_value(struct hid_sensor_common *st,
+                                        int val1, int val2);
+int hid_sensor_read_raw_hyst_value(struct hid_sensor_common *st,
+                                        int *val1, int *val2);
+int hid_sensor_write_samp_freq_value(struct hid_sensor_common *st,
+                                        int val1, int val2);
+int hid_sensor_read_samp_freq_value(struct hid_sensor_common *st,
+                                        int *val1, int *val2);
+
 #endif
diff --git a/include/linux/hid-sensor-ids.h b/include/linux/hid-sensor-ids.h
index 55f277372fed..6f24446e7669 100644
--- a/include/linux/hid-sensor-ids.h
+++ b/include/linux/hid-sensor-ids.h
@@ -66,6 +66,15 @@
 #define HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Y_AXIS                0x200486
 #define HID_USAGE_SENSOR_ORIENT_MAGN_FLUX_Z_AXIS                0x200487
 
+/* Time (2000a0) */
+#define HID_USAGE_SENSOR_TIME                                   0x2000a0
+#define HID_USAGE_SENSOR_TIME_YEAR                              0x200521
+#define HID_USAGE_SENSOR_TIME_MONTH                             0x200522
+#define HID_USAGE_SENSOR_TIME_DAY                               0x200523
+#define HID_USAGE_SENSOR_TIME_HOUR                              0x200525
+#define HID_USAGE_SENSOR_TIME_MINUTE                            0x200526
+#define HID_USAGE_SENSOR_TIME_SECOND                            0x200527
+
 /* Units */
 #define HID_USAGE_SENSOR_UNITS_NOT_SPECIFIED                    0x00
 #define HID_USAGE_SENSOR_UNITS_LUX                              0x01
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 7330a0fef0c0..e14b465b1146 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -589,6 +589,7 @@ struct hid_usage_id {
  * @raw_event: if report in report_table, this hook is called (NULL means nop)
  * @usage_table: on which events to call event (NULL means all)
  * @event: if usage in usage_table, this hook is called (NULL means nop)
+ * @report: this hook is called after parsing a report (NULL means nop)
  * @report_fixup: called before report descriptor parsing (NULL means nop)
  * @input_mapping: invoked on input registering before mapping an usage
  * @input_mapped: invoked on input registering after mapping an usage
@@ -627,6 +628,7 @@ struct hid_driver {
         const struct hid_usage_id *usage_table;
         int (*event)(struct hid_device *hdev, struct hid_field *field,
                         struct hid_usage *usage, __s32 value);
+        void (*report)(struct hid_device *hdev, struct hid_report *report);
 
         __u8 *(*report_fixup)(struct hid_device *hdev, __u8 *buf,
                         unsigned int *size);
@@ -700,6 +702,18 @@ extern int __must_check __hid_register_driver(struct hid_driver *,
 
 extern void hid_unregister_driver(struct hid_driver *);
 
+/**
+ * module_hid_driver() - Helper macro for registering a HID driver
+ * @__hid_driver: hid_driver struct
+ *
+ * Helper macro for HID drivers which do not do anything special in module
+ * init/exit. This eliminates a lot of boilerplate. Each module may only
+ * use this macro once, and calling it replaces module_init() and module_exit()
+ */
+#define module_hid_driver(__hid_driver) \
+        module_driver(__hid_driver, hid_register_driver, \
+                      hid_unregister_driver)
+
 extern void hidinput_hid_event(struct hid_device *, struct hid_field *, struct hid_usage *, __s32);
 extern void hidinput_report_event(struct hid_device *hid, struct hid_report *report);
 extern int hidinput_connect(struct hid_device *hid, unsigned int force);
@@ -872,9 +886,6 @@ static inline int hid_hw_power(struct hid_device *hdev, int level)
 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, int size,
                 int interrupt);
 
-extern int hid_generic_init(void);
-extern void hid_generic_exit(void);
-
 /* HID quirks API */
 u32 usbhid_lookup_quirk(const u16 idVendor, const u16 idProduct);
 int usbhid_quirks_init(char **quirks_param);
diff --git a/include/linux/highmem.h b/include/linux/highmem.h
index ef788b5b4a35..7fb31da45d03 100644
--- a/include/linux/highmem.h
+++ b/include/linux/highmem.h
@@ -219,12 +219,6 @@ static inline void zero_user(struct page *page,
         zero_user_segments(page, start, start + size, 0, 0);
 }
 
-static inline void __deprecated memclear_highpage_flush(struct page *page,
-                        unsigned int offset, unsigned int size)
-{
-        zero_user(page, offset, size);
-}
-
 #ifndef __HAVE_ARCH_COPY_USER_HIGHPAGE
 
 static inline void copy_user_highpage(struct page *to, struct page *from,
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 1d76f8ca90f0..ee1c244a62a1 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -113,7 +113,7 @@ extern void __split_huge_page_pmd(struct vm_area_struct *vma,
         do {                                                            \
                 pmd_t *____pmd = (__pmd);                               \
                 anon_vma_lock_write(__anon_vma);                        \
-                anon_vma_unlock(__anon_vma);                            \
+                anon_vma_unlock_write(__anon_vma);                      \
                 BUG_ON(pmd_trans_splitting(*____pmd) ||                 \
                        pmd_trans_huge(*____pmd));                       \
         } while (0)
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 0c80d3f57a5b..eedc334fb6f5 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -43,9 +43,9 @@ int hugetlb_mempolicy_sysctl_handler(struct ctl_table *, int,
 #endif
 
 int copy_hugetlb_page_range(struct mm_struct *, struct mm_struct *, struct vm_area_struct *);
-int follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *,
-                        struct page **, struct vm_area_struct **,
-                        unsigned long *, int *, int, unsigned int flags);
+long follow_hugetlb_page(struct mm_struct *, struct vm_area_struct *,
+                         struct page **, struct vm_area_struct **,
+                         unsigned long *, unsigned long *, long, unsigned int);
 void unmap_hugepage_range(struct vm_area_struct *,
                           unsigned long, unsigned long, struct page *);
 void __unmap_hugepage_range_final(struct mmu_gather *tlb,
diff --git a/include/linux/hwmon.h b/include/linux/hwmon.h
index 82b29ae6ebb0..b2514f70d591 100644
--- a/include/linux/hwmon.h
+++ b/include/linux/hwmon.h
@@ -20,16 +20,4 @@ struct device *hwmon_device_register(struct device *dev);
 
 void hwmon_device_unregister(struct device *dev);
 
-/* Scale user input to sensible values */
-static inline int SENSORS_LIMIT(long value, long low, long high)
-{
-        if (value < low)
-                return low;
-        else if (value > high)
-                return high;
-        else
-                return value;
-}
-
 #endif
-
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index e73b852156b1..df77ba9a8166 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -325,14 +325,28 @@ struct hv_ring_buffer {
 
         u32 interrupt_mask;
 
-        /* Pad it to PAGE_SIZE so that data starts on page boundary */
-        u8      reserved[4084];
-
-        /* NOTE:
-         * The interrupt_mask field is used only for channels but since our
-         * vmbus connection also uses this data structure and its data starts
-         * here, we commented out this field.
+        /*
+         * Win8 uses some of the reserved bits to implement
+         * interrupt driven flow management. On the send side
+         * we can request that the receiver interrupt the sender
+         * when the ring transitions from being full to being able
+         * to handle a message of size "pending_send_sz".
+         *
+         * Add necessary state for this enhancement.
          */
+        u32 pending_send_sz;
+
+        u32 reserved1[12];
+
+        union {
+                struct {
+                        u32 feat_pending_send_sz:1;
+                };
+                u32 value;
+        } feature_bits;
+
+        /* Pad it to PAGE_SIZE so that data starts on page boundary */
+        u8      reserved2[4028];
 
         /*
          * Ring data starts here + RingDataStartOffset
@@ -405,12 +419,22 @@ hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
  */
 #define HV_DRV_VERSION           "3.1"
 
-
 /*
- * A revision number of vmbus that is used for ensuring both ends on a
- * partition are using compatible versions.
+ * VMBUS version is 32 bit entity broken up into
+ * two 16 bit quantities: major_number. minor_number.
+ *
+ * 0 . 13 (Windows Server 2008)
+ * 1 . 1  (Windows 7)
+ * 2 . 4  (Windows 8)
  */
-#define VMBUS_REVISION_NUMBER           13
+
+#define VERSION_WS2008  ((0 << 16) | (13))
+#define VERSION_WIN7    ((1 << 16) | (1))
+#define VERSION_WIN8    ((2 << 16) | (4))
+
+#define VERSION_INVAL -1
+
+#define VERSION_CURRENT VERSION_WIN8
 
 /* Make maximum size of pipe payload of 16K */
 #define MAX_PIPE_DATA_PAYLOAD           (sizeof(u8) * 16384)
@@ -432,9 +456,13 @@ hv_get_ringbuffer_availbytes(struct hv_ring_buffer_info *rbi,
 struct vmbus_channel_offer {
         uuid_le if_type;
         uuid_le if_instance;
-        u64 int_latency; /* in 100ns units */
-        u32 if_revision;
-        u32 server_ctx_size;    /* in bytes */
+
+        /*
+         * These two fields are not currently used.
+         */
+        u64 reserved1;
+        u64 reserved2;
+
         u16 chn_flags;
         u16 mmio_megabytes;             /* in bytes * 1024 * 1024 */
 
@@ -456,7 +484,11 @@ struct vmbus_channel_offer {
                         unsigned char user_def[MAX_PIPE_USER_DEFINED_BYTES];
                 } pipe;
         } u;
-        u32 padding;
+        /*
+         * The sub_channel_index is defined in win8.
+         */
+        u16 sub_channel_index;
+        u16 reserved3;
 } __packed;
 
 /* Server Flags */
@@ -652,7 +684,25 @@ struct vmbus_channel_offer_channel {
         struct vmbus_channel_offer offer;
         u32 child_relid;
         u8 monitorid;
-        u8 monitor_allocated;
+        /*
+         * win7 and beyond splits this field into a bit field.
+         */
+        u8 monitor_allocated:1;
+        u8 reserved:7;
+        /*
+         * These are new fields added in win7 and later.
+         * Do not access these fields without checking the
+         * negotiated protocol.
+         *
+         * If "is_dedicated_interrupt" is set, we must not set the
+         * associated bit in the channel bitmap while sending the
+         * interrupt to the host.
+         *
+         * connection_id is to be used in signaling the host.
+         */
+        u16 is_dedicated_interrupt:1;
+        u16 reserved1:15;
+        u32 connection_id;
 } __packed;
 
 /* Rescind Offer parameters */
@@ -683,8 +733,15 @@ struct vmbus_channel_open_channel {
         /* GPADL for the channel's ring buffer. */
         u32 ringbuffer_gpadlhandle;
 
-        /* GPADL for the channel's server context save area. */
-        u32 server_contextarea_gpadlhandle;
+        /*
+         * Starting with win8, this field will be used to specify
+         * the target virtual processor on which to deliver the interrupt for
+         * the host to guest communication.
+         * Prior to win8, incoming channel interrupts would only
+         * be delivered on cpu 0. Setting this value to 0 would
+         * preserve the earlier behavior.
+         */
+        u32 target_vp;
 
         /*
         * The upstream ring buffer begins at offset zero in the memory
@@ -848,6 +905,27 @@ struct vmbus_close_msg {
         struct vmbus_channel_close_channel msg;
 };
 
+/* Define connection identifier type. */
+union hv_connection_id {
+        u32 asu32;
+        struct {
+                u32 id:24;
+                u32 reserved:8;
+        } u;
+};
+
+/* Definition of the hv_signal_event hypercall input structure. */
+struct hv_input_signal_event {
+        union hv_connection_id connectionid;
+        u16 flag_number;
+        u16 rsvdz;
+};
+
+struct hv_input_signal_event_buffer {
+        u64 align8;
+        struct hv_input_signal_event event;
+};
+
 struct vmbus_channel {
         struct list_head listentry;
 
@@ -882,8 +960,42 @@ struct vmbus_channel {
 
         void (*onchannel_callback)(void *context);
         void *channel_callback_context;
+
+        /*
+         * A channel can be marked for efficient (batched)
+         * reading:
+         * If batched_reading is set to "true", we read until the
+         * channel is empty and hold off interrupts from the host
+         * during the entire read process.
+         * If batched_reading is set to "false", the client is not
+         * going to perform batched reading.
+         *
+         * By default we will enable batched reading; specific
+         * drivers that don't want this behavior can turn it off.
+         */
+
+        bool batched_reading;
+
+        bool is_dedicated_interrupt;
+        struct hv_input_signal_event_buffer sig_buf;
+        struct hv_input_signal_event *sig_event;
+
+        /*
+         * Starting with win8, this field will be used to specify
+         * the target virtual processor on which to deliver the interrupt for
+         * the host to guest communication.
+         * Prior to win8, incoming channel interrupts would only
+         * be delivered on cpu 0. Setting this value to 0 would
+         * preserve the earlier behavior.
+         */
+        u32 target_vp;
 };
 
+static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
+{
+        c->batched_reading = state;
+}
+
 void vmbus_onmessage(void *context);
 
 int vmbus_request_offers(void);
@@ -1047,6 +1159,100 @@ void vmbus_driver_unregister(struct hv_driver *hv_driver);
                   g8, g9, ga, gb, gc, gd, ge, gf },
 
 /*
+ * GUID definitions of various offer types - services offered to the guest.
+ */
+
+/*
+ * Network GUID
+ * {f8615163-df3e-46c5-913f-f2d2f965ed0e}
+ */
+#define HV_NIC_GUID \
+        .guid = { \
+                        0x63, 0x51, 0x61, 0xf8, 0x3e, 0xdf, 0xc5, 0x46, \
+                        0x91, 0x3f, 0xf2, 0xd2, 0xf9, 0x65, 0xed, 0x0e \
+                }
+
+/*
+ * IDE GUID
+ * {32412632-86cb-44a2-9b5c-50d1417354f5}
+ */
+#define HV_IDE_GUID \
+        .guid = { \
+                        0x32, 0x26, 0x41, 0x32, 0xcb, 0x86, 0xa2, 0x44, \
+                        0x9b, 0x5c, 0x50, 0xd1, 0x41, 0x73, 0x54, 0xf5 \
+                }
+
+/*
+ * SCSI GUID
+ * {ba6163d9-04a1-4d29-b605-72e2ffb1dc7f}
+ */
+#define HV_SCSI_GUID \
+        .guid = { \
+                        0xd9, 0x63, 0x61, 0xba, 0xa1, 0x04, 0x29, 0x4d, \
+                        0xb6, 0x05, 0x72, 0xe2, 0xff, 0xb1, 0xdc, 0x7f \
+                }
+
+/*
+ * Shutdown GUID
+ * {0e0b6031-5213-4934-818b-38d90ced39db}
+ */
+#define HV_SHUTDOWN_GUID \
+        .guid = { \
+                        0x31, 0x60, 0x0b, 0x0e, 0x13, 0x52, 0x34, 0x49, \
+                        0x81, 0x8b, 0x38, 0xd9, 0x0c, 0xed, 0x39, 0xdb \
+                }
+
+/*
+ * Time Synch GUID
+ * {9527E630-D0AE-497b-ADCE-E80AB0175CAF}
+ */
+#define HV_TS_GUID \
+        .guid = { \
+                        0x30, 0xe6, 0x27, 0x95, 0xae, 0xd0, 0x7b, 0x49, \
+                        0xad, 0xce, 0xe8, 0x0a, 0xb0, 0x17, 0x5c, 0xaf \
+                }
+
+/*
+ * Heartbeat GUID
+ * {57164f39-9115-4e78-ab55-382f3bd5422d}
+ */
+#define HV_HEART_BEAT_GUID \
+        .guid = { \
+                        0x39, 0x4f, 0x16, 0x57, 0x15, 0x91, 0x78, 0x4e, \
+                        0xab, 0x55, 0x38, 0x2f, 0x3b, 0xd5, 0x42, 0x2d \
+                }
+
+/*
+ * KVP GUID
+ * {a9a0f4e7-5a45-4d96-b827-8a841e8c03e6}
+ */
+#define HV_KVP_GUID \
+        .guid = { \
+                        0xe7, 0xf4, 0xa0, 0xa9, 0x45, 0x5a, 0x96, 0x4d, \
+                        0xb8, 0x27, 0x8a, 0x84, 0x1e, 0x8c, 0x3,  0xe6 \
+                }
+
+/*
+ * Dynamic memory GUID
+ * {525074dc-8985-46e2-8057-a307dc18a502}
+ */
+#define HV_DM_GUID \
+        .guid = { \
+                        0xdc, 0x74, 0x50, 0X52, 0x85, 0x89, 0xe2, 0x46, \
+                        0x80, 0x57, 0xa3, 0x07, 0xdc, 0x18, 0xa5, 0x02 \
+                }
+
+/*
+ * Mouse GUID
+ * {cfa8b69e-5b4a-4cc0-b98b-8ba1a1f3f95a}
+ */
+#define HV_MOUSE_GUID \
+        .guid = { \
+                        0x9e, 0xb6, 0xa8, 0xcf, 0x4a, 0x5b, 0xc0, 0x4c, \
+                        0xb9, 0x8b, 0x8b, 0xa1, 0xa1, 0xf3, 0xf9, 0x5a \
+                }
+
+/*
  * Common header for Hyper-V ICs
  */
 
@@ -1150,5 +1356,11 @@ int hv_kvp_init(struct hv_util_service *);
 void hv_kvp_deinit(void);
 void hv_kvp_onchannelcallback(void *);
 
+/*
+ * Negotiated version with the Host.
+ */
+
+extern __u32 vmbus_proto_version;
+
 #endif /* __KERNEL__ */
 #endif /* _HYPERV_H */
diff --git a/include/linux/i2c/twl.h b/include/linux/i2c/twl.h
index 1ff54b114efc..488debbef895 100644
--- a/include/linux/i2c/twl.h
+++ b/include/linux/i2c/twl.h
@@ -39,51 +39,55 @@
  * address each module uses within a given i2c slave.
  */
 
+/* Module IDs for similar functionalities found in twl4030/twl6030 */
+enum twl_module_ids {
+        TWL_MODULE_USB,
+        TWL_MODULE_PIH,
+        TWL_MODULE_MAIN_CHARGE,
+        TWL_MODULE_PM_MASTER,
+        TWL_MODULE_PM_RECEIVER,
+
+        TWL_MODULE_RTC,
+        TWL_MODULE_PWM,
+        TWL_MODULE_LED,
+        TWL_MODULE_SECURED_REG,
+
+        TWL_MODULE_LAST,
+};
+
+/* Modules only available in twl4030 series */
 enum twl4030_module_ids {
-        TWL4030_MODULE_USB = 0,         /* Slave 0 (i2c address 0x48) */
-        TWL4030_MODULE_AUDIO_VOICE,     /* Slave 1 (i2c address 0x49) */
+        TWL4030_MODULE_AUDIO_VOICE = TWL_MODULE_LAST,
         TWL4030_MODULE_GPIO,
         TWL4030_MODULE_INTBR,
-        TWL4030_MODULE_PIH,
-
         TWL4030_MODULE_TEST,
-        TWL4030_MODULE_KEYPAD,          /* Slave 2 (i2c address 0x4a) */
+        TWL4030_MODULE_KEYPAD,
+
         TWL4030_MODULE_MADC,
         TWL4030_MODULE_INTERRUPTS,
-        TWL4030_MODULE_LED,
-
-        TWL4030_MODULE_MAIN_CHARGE,
         TWL4030_MODULE_PRECHARGE,
-        TWL4030_MODULE_PWM0,
-        TWL4030_MODULE_PWM1,
-        TWL4030_MODULE_PWMA,
+        TWL4030_MODULE_BACKUP,
+        TWL4030_MODULE_INT,
 
-        TWL4030_MODULE_PWMB,
         TWL5031_MODULE_ACCESSORY,
         TWL5031_MODULE_INTERRUPTS,
-        TWL4030_MODULE_BACKUP,          /* Slave 3 (i2c address 0x4b) */
-        TWL4030_MODULE_INT,
 
-        TWL4030_MODULE_PM_MASTER,
-        TWL4030_MODULE_PM_RECEIVER,
-        TWL4030_MODULE_RTC,
-        TWL4030_MODULE_SECURED_REG,
         TWL4030_MODULE_LAST,
 };
 
-/* Similar functionalities implemented in TWL4030/6030 */
-#define TWL_MODULE_USB          TWL4030_MODULE_USB
-#define TWL_MODULE_PIH          TWL4030_MODULE_PIH
-#define TWL_MODULE_MAIN_CHARGE  TWL4030_MODULE_MAIN_CHARGE
-#define TWL_MODULE_PM_MASTER    TWL4030_MODULE_PM_MASTER
-#define TWL_MODULE_PM_RECEIVER  TWL4030_MODULE_PM_RECEIVER
-#define TWL_MODULE_RTC          TWL4030_MODULE_RTC
-#define TWL_MODULE_PWM          TWL4030_MODULE_PWM0
-#define TWL_MODULE_LED          TWL4030_MODULE_LED
+/* Modules only available in twl6030 series */
+enum twl6030_module_ids {
+        TWL6030_MODULE_ID0 = TWL_MODULE_LAST,
+        TWL6030_MODULE_ID1,
+        TWL6030_MODULE_ID2,
+        TWL6030_MODULE_GPADC,
+        TWL6030_MODULE_GASGAUGE,
+
+        TWL6030_MODULE_LAST,
+};
 
-#define TWL6030_MODULE_ID0      13
-#define TWL6030_MODULE_ID1      14
-#define TWL6030_MODULE_ID2      15
+/* Until the clients has been converted to use TWL_MODULE_LED */
+#define TWL4030_MODULE_LED      TWL_MODULE_LED
 
 #define GPIO_INTR_OFFSET        0
 #define KEYPAD_INTR_OFFSET      1
@@ -171,20 +175,22 @@ TWL_CLASS_IS(4030, TWL4030_CLASS_ID)
 TWL_CLASS_IS(6030, TWL6030_CLASS_ID)
 
 /*
- * Read and write single 8-bit registers
- */
-int twl_i2c_write_u8(u8 mod_no, u8 val, u8 reg);
-int twl_i2c_read_u8(u8 mod_no, u8 *val, u8 reg);
-
-/*
  * Read and write several 8-bit registers at once.
- *
- * IMPORTANT:  For twl_i2c_write(), allocate num_bytes + 1
- * for the value, and populate your data starting at offset 1.
  */
 int twl_i2c_write(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes);
 int twl_i2c_read(u8 mod_no, u8 *value, u8 reg, unsigned num_bytes);
 
+/*
+ * Read and write single 8-bit registers
+ */
+static inline int twl_i2c_write_u8(u8 mod_no, u8 val, u8 reg) {
+        return twl_i2c_write(mod_no, &val, reg, 1);
+}
+
+static inline int twl_i2c_read_u8(u8 mod_no, u8 *val, u8 reg) {
+        return twl_i2c_read(mod_no, val, reg, 1);
+}
+
 int twl_get_type(void);
 int twl_get_version(void);
 int twl_get_hfclk_rate(void);
diff --git a/include/linux/idr.h b/include/linux/idr.h
index de7e190f1af4..e5eb125effe6 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -136,7 +136,7 @@ struct ida {
         struct ida_bitmap       *free_bitmap;
 };
 
-#define IDA_INIT(name)          { .idr = IDR_INIT(name), .free_bitmap = NULL, }
+#define IDA_INIT(name)          { .idr = IDR_INIT((name).idr), .free_bitmap = NULL, }
 #define DEFINE_IDA(name)        struct ida name = IDA_INIT(name)
 
 int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index f0859cc73861..7e24fe0cfbcd 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -151,6 +151,11 @@
 /* Mesh Control 802.11s */
 #define IEEE80211_QOS_CTL_MESH_CONTROL_PRESENT  0x0100
 
+/* Mesh Power Save Level */
+#define IEEE80211_QOS_CTL_MESH_PS_LEVEL         0x0200
+/* Mesh Receiver Service Period Initiated */
+#define IEEE80211_QOS_CTL_RSPI                  0x0400
+
 /* U-APSD queue for WMM IEs sent by AP */
 #define IEEE80211_WMM_IE_AP_QOSINFO_UAPSD       (1<<7)
 #define IEEE80211_WMM_IE_AP_QOSINFO_PARAM_SET_CNT_MASK  0x0f
@@ -180,7 +185,7 @@ struct ieee80211_hdr {
         u8 addr3[6];
         __le16 seq_ctrl;
         u8 addr4[6];
-} __attribute__ ((packed));
+} __packed;
 
 struct ieee80211_hdr_3addr {
         __le16 frame_control;
@@ -189,7 +194,7 @@ struct ieee80211_hdr_3addr {
         u8 addr2[6];
         u8 addr3[6];
         __le16 seq_ctrl;
-} __attribute__ ((packed));
+} __packed;
 
 struct ieee80211_qos_hdr {
         __le16 frame_control;
@@ -199,7 +204,7 @@ struct ieee80211_qos_hdr {
         u8 addr3[6];
         __le16 seq_ctrl;
         __le16 qos_ctrl;
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * ieee80211_has_tods - check if IEEE80211_FCTL_TODS is set
@@ -576,7 +581,7 @@ struct ieee80211s_hdr {
         __le32 seqnum;
         u8 eaddr1[6];
         u8 eaddr2[6];
-} __attribute__ ((packed));
+} __packed;
 
 /* Mesh flags */
 #define MESH_FLAGS_AE_A4        0x1
@@ -614,7 +619,7 @@ struct ieee80211_quiet_ie {
         u8 period;
         __le16 duration;
         __le16 offset;
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * struct ieee80211_msrment_ie
@@ -626,7 +631,7 @@ struct ieee80211_msrment_ie {
         u8 mode;
         u8 type;
         u8 request[0];
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * struct ieee80211_channel_sw_ie
@@ -637,7 +642,7 @@ struct ieee80211_channel_sw_ie {
         u8 mode;
         u8 new_ch_num;
         u8 count;
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * struct ieee80211_tim
@@ -650,7 +655,7 @@ struct ieee80211_tim_ie {
         u8 bitmap_ctrl;
         /* variable size: 1 - 251 bytes */
         u8 virtual_map[1];
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * struct ieee80211_meshconf_ie
@@ -665,7 +670,7 @@ struct ieee80211_meshconf_ie {
         u8 meshconf_auth;
         u8 meshconf_form;
         u8 meshconf_cap;
-} __attribute__ ((packed));
+} __packed;
 
 /**
  * enum mesh_config_capab_flags - Mesh Configuration IE capability field flags
@@ -675,11 +680,14 @@ struct ieee80211_meshconf_ie {
  * @IEEE80211_MESHCONF_CAPAB_FORWARDING: the STA forwards MSDUs
  * @IEEE80211_MESHCONF_CAPAB_TBTT_ADJUSTING: TBTT adjustment procedure
  *      is ongoing
+ * @IEEE80211_MESHCONF_CAPAB_POWER_SAVE_LEVEL: STA is in deep sleep mode or has
+ *      neighbors in deep sleep mode
  */
 enum mesh_config_capab_flags {
         IEEE80211_MESHCONF_CAPAB_ACCEPT_PLINKS          = 0x01,
         IEEE80211_MESHCONF_CAPAB_FORWARDING             = 0x08,
         IEEE80211_MESHCONF_CAPAB_TBTT_ADJUSTING         = 0x20,
+        IEEE80211_MESHCONF_CAPAB_POWER_SAVE_LEVEL       = 0x40,
 };
 
 /**
@@ -695,12 +703,41 @@ struct ieee80211_rann_ie {
         __le32 rann_seq;
         __le32 rann_interval;
         __le32 rann_metric;
-} __attribute__ ((packed));
+} __packed;
 
 enum ieee80211_rann_flags {
         RANN_FLAG_IS_GATE = 1 << 0,
 };
 
+enum ieee80211_ht_chanwidth_values {
+        IEEE80211_HT_CHANWIDTH_20MHZ = 0,
+        IEEE80211_HT_CHANWIDTH_ANY = 1,
+};
+
+/**
+ * enum ieee80211_opmode_bits - VHT operating mode field bits
+ * @IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK: channel width mask
+ * @IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ: 20 MHz channel width
+ * @IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ: 40 MHz channel width
+ * @IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ: 80 MHz channel width
+ * @IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ: 160 MHz or 80+80 MHz channel width
+ * @IEEE80211_OPMODE_NOTIF_RX_NSS_MASK: number of spatial streams mask
+ *      (the NSS value is the value of this field + 1)
+ * @IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT: number of spatial streams shift
+ * @IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF: indicates streams in SU-MIMO PPDU
+ *      using a beamforming steering matrix
+ */
+enum ieee80211_vht_opmode_bits {
+        IEEE80211_OPMODE_NOTIF_CHANWIDTH_MASK   = 3,
+        IEEE80211_OPMODE_NOTIF_CHANWIDTH_20MHZ  = 0,
+        IEEE80211_OPMODE_NOTIF_CHANWIDTH_40MHZ  = 1,
+        IEEE80211_OPMODE_NOTIF_CHANWIDTH_80MHZ  = 2,
+        IEEE80211_OPMODE_NOTIF_CHANWIDTH_160MHZ = 3,
+        IEEE80211_OPMODE_NOTIF_RX_NSS_MASK      = 0x70,
+        IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT     = 4,
+        IEEE80211_OPMODE_NOTIF_RX_NSS_TYPE_BF   = 0x80,
+};
+
 #define WLAN_SA_QUERY_TR_ID_LEN 2
 
 struct ieee80211_mgmt {
@@ -717,33 +754,33 @@ struct ieee80211_mgmt {
                         __le16 status_code;
                         /* possibly followed by Challenge text */
                         u8 variable[0];
-                } __attribute__ ((packed)) auth;
+                } __packed auth;
                 struct {
                         __le16 reason_code;
-                } __attribute__ ((packed)) deauth;
+                } __packed deauth;
                 struct {
                         __le16 capab_info;
                         __le16 listen_interval;
                         /* followed by SSID and Supported rates */
                         u8 variable[0];
-                } __attribute__ ((packed)) assoc_req;
+                } __packed assoc_req;
                 struct {
                         __le16 capab_info;
                         __le16 status_code;
                         __le16 aid;
                         /* followed by Supported rates */
                         u8 variable[0];
-                } __attribute__ ((packed)) assoc_resp, reassoc_resp;
+                } __packed assoc_resp, reassoc_resp;
                 struct {
                         __le16 capab_info;
                         __le16 listen_interval;
                         u8 current_ap[6];
                         /* followed by SSID and Supported rates */
                         u8 variable[0];
-                } __attribute__ ((packed)) reassoc_req;
+                } __packed reassoc_req;
                 struct {
                         __le16 reason_code;
-                } __attribute__ ((packed)) disassoc;
+                } __packed disassoc;
                 struct {
                         __le64 timestamp;
                         __le16 beacon_int;
@@ -751,11 +788,11 @@ struct ieee80211_mgmt {
                         /* followed by some of SSID, Supported rates,
                          * FH Params, DS Params, CF Params, IBSS Params, TIM */
                         u8 variable[0];
-                } __attribute__ ((packed)) beacon;
+                } __packed beacon;
                 struct {
                         /* only variable items: SSID, Supported rates */
                         u8 variable[0];
-                } __attribute__ ((packed)) probe_req;
+                } __packed probe_req;
                 struct {
                         __le64 timestamp;
                         __le16 beacon_int;
@@ -763,7 +800,7 @@ struct ieee80211_mgmt {
                         /* followed by some of SSID, Supported rates,
                          * FH Params, DS Params, CF Params, IBSS Params */
                         u8 variable[0];
-                } __attribute__ ((packed)) probe_resp;
+                } __packed probe_resp;
                 struct {
                         u8 category;
                         union {
@@ -772,65 +809,73 @@ struct ieee80211_mgmt {
                                         u8 dialog_token;
                                         u8 status_code;
                                         u8 variable[0];
-                                } __attribute__ ((packed)) wme_action;
+                                } __packed wme_action;
                                 struct{
                                         u8 action_code;
                                         u8 element_id;
                                         u8 length;
                                         struct ieee80211_channel_sw_ie sw_elem;
-                                } __attribute__((packed)) chan_switch;
+                                } __packed chan_switch;
                                 struct{
                                         u8 action_code;
                                         u8 dialog_token;
                                         u8 element_id;
                                         u8 length;
                                         struct ieee80211_msrment_ie msr_elem;
-                                } __attribute__((packed)) measurement;
+                                } __packed measurement;
                                 struct{
                                         u8 action_code;
                                         u8 dialog_token;
                                         __le16 capab;
                                         __le16 timeout;
                                         __le16 start_seq_num;
-                                } __attribute__((packed)) addba_req;
+                                } __packed addba_req;
                                 struct{
                                         u8 action_code;
                                         u8 dialog_token;
                                         __le16 status;
                                         __le16 capab;
                                         __le16 timeout;
-                                } __attribute__((packed)) addba_resp;
+                                } __packed addba_resp;
                                 struct{
                                         u8 action_code;
                                         __le16 params;
                                         __le16 reason_code;
-                                } __attribute__((packed)) delba;
+                                } __packed delba;
                                 struct {
                                         u8 action_code;
                                         u8 variable[0];
-                                } __attribute__((packed)) self_prot;
+                                } __packed self_prot;
                                 struct{
                                         u8 action_code;
                                         u8 variable[0];
-                                } __attribute__((packed)) mesh_action;
+                                } __packed mesh_action;
                                 struct {
                                         u8 action;
                                         u8 trans_id[WLAN_SA_QUERY_TR_ID_LEN];
-                                } __attribute__ ((packed)) sa_query;
+                                } __packed sa_query;
                                 struct {
                                         u8 action;
                                         u8 smps_control;
-                                } __attribute__ ((packed)) ht_smps;
+                                } __packed ht_smps;
+                                struct {
+                                        u8 action_code;
+                                        u8 chanwidth;
+                                } __packed ht_notify_cw;
                                 struct {
                                         u8 action_code;
                                         u8 dialog_token;
                                         __le16 capability;
                                         u8 variable[0];
                                 } __packed tdls_discover_resp;
+                                struct {
+                                        u8 action_code;
+                                        u8 operating_mode;
+                                } __packed vht_opmode_notif;
                         } u;
-                } __attribute__ ((packed)) action;
+                } __packed action;
         } u;
-} __attribute__ ((packed));
+} __packed;
 
 /* Supported Rates value encodings in 802.11n-2009 7.3.2.2 */
 #define BSS_MEMBERSHIP_SELECTOR_HT_PHY  127
@@ -846,7 +891,7 @@ struct ieee80211_mmie {
         __le16 key_id;
         u8 sequence_number[6];
         u8 mic[8];
-} __attribute__ ((packed));
+} __packed;
 
 struct ieee80211_vendor_ie {
         u8 element_id;
@@ -861,20 +906,20 @@ struct ieee80211_rts {
         __le16 duration;
         u8 ra[6];
         u8 ta[6];
-} __attribute__ ((packed));
+} __packed;
 
 struct ieee80211_cts {
         __le16 frame_control;
         __le16 duration;
         u8 ra[6];
-} __attribute__ ((packed));
+} __packed;
 
 struct ieee80211_pspoll {
         __le16 frame_control;
         __le16 aid;
         u8 bssid[6];
         u8 ta[6];
-} __attribute__ ((packed));
+} __packed;
 
 /* TDLS */
 
@@ -967,7 +1012,7 @@ struct ieee80211_bar {
         __u8 ta[6];
         __le16 control;
         __le16 start_seq_num;
-} __attribute__((packed));
+} __packed;
 
 /* 802.11 BAR control masks */
 #define IEEE80211_BAR_CTRL_ACK_POLICY_NORMAL    0x0000
@@ -992,7 +1037,7 @@ struct ieee80211_mcs_info {
         __le16 rx_highest;
         u8 tx_params;
         u8 reserved[3];
-} __attribute__((packed));
+} __packed;
 
 /* 802.11n HT capability MSC set */
 #define IEEE80211_HT_MCS_RX_HIGHEST_MASK        0x3ff
@@ -1031,7 +1076,7 @@ struct ieee80211_ht_cap {
         __le16 extended_ht_cap_info;
         __le32 tx_BF_cap_info;
         u8 antenna_selection_info;
-} __attribute__ ((packed));
+} __packed;
 
 /* 802.11n HT capabilities masks (for cap_info) */
 #define IEEE80211_HT_CAP_LDPC_CODING            0x0001
@@ -1102,7 +1147,7 @@ struct ieee80211_ht_operation {
         __le16 operation_mode;
         __le16 stbc_param;
         u8 basic_set[16];
-} __attribute__ ((packed));
+} __packed;
 
 /* for ht_param */
 #define IEEE80211_HT_PARAM_CHA_SEC_OFFSET               0x03
@@ -1256,6 +1301,7 @@ struct ieee80211_vht_operation {
 #define IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454                 0x00000002
 #define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ                0x00000004
 #define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ       0x00000008
+#define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK                  0x0000000C
 #define IEEE80211_VHT_CAP_RXLDPC                                0x00000010
 #define IEEE80211_VHT_CAP_SHORT_GI_80                           0x00000020
 #define IEEE80211_VHT_CAP_SHORT_GI_160                          0x00000040
@@ -1311,16 +1357,21 @@ struct ieee80211_vht_operation {
 #define WLAN_CAPABILITY_SPECTRUM_MGMT   (1<<8)
 #define WLAN_CAPABILITY_QOS             (1<<9)
 #define WLAN_CAPABILITY_SHORT_SLOT_TIME (1<<10)
+#define WLAN_CAPABILITY_APSD            (1<<11)
+#define WLAN_CAPABILITY_RADIO_MEASURE   (1<<12)
 #define WLAN_CAPABILITY_DSSS_OFDM       (1<<13)
+#define WLAN_CAPABILITY_DEL_BACK        (1<<14)
+#define WLAN_CAPABILITY_IMM_BACK        (1<<15)
 
 /* DMG (60gHz) 802.11ad */
 /* type - bits 0..1 */
+#define WLAN_CAPABILITY_DMG_TYPE_MASK           (3<<0)
 #define WLAN_CAPABILITY_DMG_TYPE_IBSS           (1<<0) /* Tx by: STA */
 #define WLAN_CAPABILITY_DMG_TYPE_PBSS           (2<<0) /* Tx by: PCP */
 #define WLAN_CAPABILITY_DMG_TYPE_AP             (3<<0) /* Tx by: AP */
 
 #define WLAN_CAPABILITY_DMG_CBAP_ONLY           (1<<2)
-#define WLAN_CAPABILITY_DMG_CBAP_SOURCE (1<<3)
+#define WLAN_CAPABILITY_DMG_CBAP_SOURCE         (1<<3)
 #define WLAN_CAPABILITY_DMG_PRIVACY             (1<<4)
 #define WLAN_CAPABILITY_DMG_ECPAC               (1<<5)
 
@@ -1576,6 +1627,7 @@ enum ieee80211_eid {
 
         WLAN_EID_VHT_CAPABILITY = 191,
         WLAN_EID_VHT_OPERATION = 192,
+        WLAN_EID_OPMODE_NOTIF = 199,
 
         /* 802.11ad */
         WLAN_EID_NON_TX_BSSID_CAP =  83,
@@ -1630,6 +1682,7 @@ enum ieee80211_category {
         WLAN_CATEGORY_WMM = 17,
         WLAN_CATEGORY_FST = 18,
         WLAN_CATEGORY_UNPROT_DMG = 20,
+        WLAN_CATEGORY_VHT = 21,
         WLAN_CATEGORY_VENDOR_SPECIFIC_PROTECTED = 126,
         WLAN_CATEGORY_VENDOR_SPECIFIC = 127,
 };
@@ -1655,6 +1708,13 @@ enum ieee80211_ht_actioncode {
         WLAN_HT_ACTION_ASEL_IDX_FEEDBACK = 7,
 };
 
+/* VHT action codes */
+enum ieee80211_vht_actioncode {
+        WLAN_VHT_ACTION_COMPRESSED_BF = 0,
+        WLAN_VHT_ACTION_GROUPID_MGMT = 1,
+        WLAN_VHT_ACTION_OPMODE_NOTIF = 2,
+};
+
 /* Self Protected Action codes */
 enum ieee80211_self_protected_actioncode {
         WLAN_SP_RESERVED = 0,
@@ -1716,6 +1776,8 @@ enum ieee80211_tdls_actioncode {
 #define WLAN_EXT_CAPA5_TDLS_ENABLED     BIT(5)
 #define WLAN_EXT_CAPA5_TDLS_PROHIBITED  BIT(6)
 
+#define WLAN_EXT_CAPA8_OPMODE_NOTIF     BIT(6)
+
 /* TDLS specific payload type in the LLC/SNAP header */
 #define WLAN_TDLS_SNAP_RFTYPE   0x2
 
@@ -1834,14 +1896,14 @@ struct ieee80211_country_ie_triplet {
                         u8 first_channel;
                         u8 num_channels;
                         s8 max_power;
-                } __attribute__ ((packed)) chans;
+                } __packed chans;
                 struct {
                         u8 reg_extension_id;
                         u8 reg_class;
                         u8 coverage_class;
-                } __attribute__ ((packed)) ext;
+                } __packed ext;
         };
-} __attribute__ ((packed));
+} __packed;
 
 enum ieee80211_timeout_interval_type {
         WLAN_TIMEOUT_REASSOC_DEADLINE = 1 /* 802.11r */,
@@ -1884,7 +1946,10 @@ enum ieee80211_sa_query_action {
 /* AKM suite selectors */
 #define WLAN_AKM_SUITE_8021X            0x000FAC01
 #define WLAN_AKM_SUITE_PSK              0x000FAC02
-#define WLAN_AKM_SUITE_SAE                      0x000FAC08
+#define WLAN_AKM_SUITE_8021X_SHA256     0x000FAC05
+#define WLAN_AKM_SUITE_PSK_SHA256       0x000FAC06
+#define WLAN_AKM_SUITE_TDLS             0x000FAC07
+#define WLAN_AKM_SUITE_SAE              0x000FAC08
 #define WLAN_AKM_SUITE_FT_OVER_SAE      0x000FAC09
 
 #define WLAN_MAX_KEY_LEN                32
@@ -2089,7 +2154,7 @@ static inline unsigned long ieee80211_tu_to_usec(unsigned long tu)
  * @tim_len: length of the TIM IE
  * @aid: the AID to look for
  */
-static inline bool ieee80211_check_tim(struct ieee80211_tim_ie *tim,
+static inline bool ieee80211_check_tim(const struct ieee80211_tim_ie *tim,
                                        u8 tim_len, u16 aid)
 {
         u8 mask;
diff --git a/include/linux/if_macvlan.h b/include/linux/if_macvlan.h
index f65e8d250f7e..84dde1dd1da4 100644
--- a/include/linux/if_macvlan.h
+++ b/include/linux/if_macvlan.h
@@ -52,6 +52,9 @@ struct macvlan_pcpu_stats {
  */
 #define MAX_MACVTAP_QUEUES      (NR_CPUS < 16 ? NR_CPUS : 16)
 
+#define MACVLAN_MC_FILTER_BITS  8
+#define MACVLAN_MC_FILTER_SZ    (1 << MACVLAN_MC_FILTER_BITS)
+
 struct macvlan_dev {
         struct net_device       *dev;
         struct list_head        list;
@@ -59,6 +62,9 @@ struct macvlan_dev {
         struct macvlan_port     *port;
         struct net_device       *lowerdev;
         struct macvlan_pcpu_stats __percpu *pcpu_stats;
+
+        DECLARE_BITMAP(mc_filter, MACVLAN_MC_FILTER_SZ);
+
         enum macvlan_mode       mode;
         u16                     flags;
         int (*receive)(struct sk_buff *skb);
diff --git a/include/linux/if_team.h b/include/linux/if_team.h
index 0245def2aa93..4648d8021244 100644
--- a/include/linux/if_team.h
+++ b/include/linux/if_team.h
@@ -186,6 +186,7 @@ struct team {
 
         const struct team_mode *mode;
         struct team_mode_ops ops;
+        bool user_carrier_enabled;
         bool queue_override_enabled;
         struct list_head *qom_lists; /* array of queue override mapping lists */
         long mode_priv[TEAM_MODE_PRIV_LONGS];
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index d06cc5c8f58c..218a3b686d90 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -331,7 +331,7 @@ static inline void vlan_set_encap_proto(struct sk_buff *skb,
                                         struct vlan_hdr *vhdr)
 {
         __be16 proto;
-        unsigned char *rawp;
+        unsigned short *rawp;
 
         /*
          * Was a VLAN packet, grab the encapsulated protocol, which the layer
@@ -344,8 +344,8 @@ static inline void vlan_set_encap_proto(struct sk_buff *skb,
                 return;
         }
 
-        rawp = skb->data;
-        if (*(unsigned short *) rawp == 0xFFFF)
+        rawp = (unsigned short *)(vhdr + 1);
+        if (*rawp == 0xFFFF)
                 /*
                  * This is a magic hack to spot IPX packets. Older Novell
                  * breaks the protocol design and runs IPX over 802.3 without
diff --git a/include/linux/iio/buffer.h b/include/linux/iio/buffer.h
index f3eea18fdf46..2bac0eb8948d 100644
--- a/include/linux/iio/buffer.h
+++ b/include/linux/iio/buffer.h
@@ -103,19 +103,6 @@ int iio_update_buffers(struct iio_dev *indio_dev,
  **/
 void iio_buffer_init(struct iio_buffer *buffer);
 
-/**
- * __iio_update_buffer() - update common elements of buffers
- * @buffer:             buffer that is the event source
- * @bytes_per_datum:    size of individual datum including timestamp
- * @length:             number of datums in buffer
- **/
-static inline void __iio_update_buffer(struct iio_buffer *buffer,
-                                       int bytes_per_datum, int length)
-{
-        buffer->bytes_per_datum = bytes_per_datum;
-        buffer->length = length;
-}
-
 int iio_scan_mask_query(struct iio_dev *indio_dev,
                         struct iio_buffer *buffer, int bit);
 
diff --git a/include/linux/iio/common/st_sensors.h b/include/linux/iio/common/st_sensors.h
new file mode 100644
index 000000000000..1f86a97ab2e2
--- /dev/null
+++ b/include/linux/iio/common/st_sensors.h
@@ -0,0 +1,280 @@
+/*
+ * STMicroelectronics sensors library driver
+ *
+ * Copyright 2012-2013 STMicroelectronics Inc.
+ *
+ * Denis Ciocca <denis.ciocca@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef ST_SENSORS_H
+#define ST_SENSORS_H
+
+#include <linux/i2c.h>
+#include <linux/spi/spi.h>
+#include <linux/irqreturn.h>
+#include <linux/iio/trigger.h>
+
+#define ST_SENSORS_TX_MAX_LENGTH                2
+#define ST_SENSORS_RX_MAX_LENGTH                6
+
+#define ST_SENSORS_ODR_LIST_MAX                 10
+#define ST_SENSORS_FULLSCALE_AVL_MAX            10
+
+#define ST_SENSORS_NUMBER_ALL_CHANNELS          4
+#define ST_SENSORS_NUMBER_DATA_CHANNELS         3
+#define ST_SENSORS_ENABLE_ALL_AXIS              0x07
+#define ST_SENSORS_BYTE_FOR_CHANNEL             2
+#define ST_SENSORS_SCAN_X                       0
+#define ST_SENSORS_SCAN_Y                       1
+#define ST_SENSORS_SCAN_Z                       2
+#define ST_SENSORS_DEFAULT_12_REALBITS          12
+#define ST_SENSORS_DEFAULT_16_REALBITS          16
+#define ST_SENSORS_DEFAULT_POWER_ON_VALUE       0x01
+#define ST_SENSORS_DEFAULT_POWER_OFF_VALUE      0x00
+#define ST_SENSORS_DEFAULT_WAI_ADDRESS          0x0f
+#define ST_SENSORS_DEFAULT_AXIS_ADDR            0x20
+#define ST_SENSORS_DEFAULT_AXIS_MASK            0x07
+#define ST_SENSORS_DEFAULT_AXIS_N_BIT           3
+
+#define ST_SENSORS_MAX_NAME                     17
+#define ST_SENSORS_MAX_4WAI                     7
+
+#define ST_SENSORS_LSM_CHANNELS(device_type, index, mod, endian, bits, addr) \
+{ \
+        .type = device_type, \
+        .modified = 1, \
+        .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+                        IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
+        .scan_index = index, \
+        .channel2 = mod, \
+        .address = addr, \
+        .scan_type = { \
+                .sign = 's', \
+                .realbits = bits, \
+                .shift = 16 - bits, \
+                .storagebits = 16, \
+                .endianness = endian, \
+        }, \
+}
+
+#define ST_SENSOR_DEV_ATTR_SAMP_FREQ() \
+                IIO_DEV_ATTR_SAMP_FREQ(S_IWUSR | S_IRUGO, \
+                        st_sensors_sysfs_get_sampling_frequency, \
+                        st_sensors_sysfs_set_sampling_frequency)
+
+#define ST_SENSORS_DEV_ATTR_SAMP_FREQ_AVAIL() \
+                IIO_DEV_ATTR_SAMP_FREQ_AVAIL( \
+                        st_sensors_sysfs_sampling_frequency_avail)
+
+#define ST_SENSORS_DEV_ATTR_SCALE_AVAIL(name) \
+                IIO_DEVICE_ATTR(name, S_IRUGO, \
+                        st_sensors_sysfs_scale_avail, NULL , 0);
+
+struct st_sensor_odr_avl {
+        unsigned int hz;
+        u8 value;
+};
+
+struct st_sensor_odr {
+        u8 addr;
+        u8 mask;
+        struct st_sensor_odr_avl odr_avl[ST_SENSORS_ODR_LIST_MAX];
+};
+
+struct st_sensor_power {
+        u8 addr;
+        u8 mask;
+        u8 value_off;
+        u8 value_on;
+};
+
+struct st_sensor_axis {
+        u8 addr;
+        u8 mask;
+};
+
+struct st_sensor_fullscale_avl {
+        unsigned int num;
+        u8 value;
+        unsigned int gain;
+        unsigned int gain2;
+};
+
+struct st_sensor_fullscale {
+        u8 addr;
+        u8 mask;
+        struct st_sensor_fullscale_avl fs_avl[ST_SENSORS_FULLSCALE_AVL_MAX];
+};
+
+/**
+ * struct st_sensor_bdu - ST sensor device block data update
+ * @addr: address of the register.
+ * @mask: mask to write the block data update flag.
+ */
+struct st_sensor_bdu {
+        u8 addr;
+        u8 mask;
+};
+
+/**
+ * struct st_sensor_data_ready_irq - ST sensor device data-ready interrupt
+ * @addr: address of the register.
+ * @mask: mask to write the on/off value.
+ * struct ig1 - represents the Interrupt Generator 1 of sensors.
+ * @en_addr: address of the enable ig1 register.
+ * @en_mask: mask to write the on/off value for enable.
+ */
+struct st_sensor_data_ready_irq {
+        u8 addr;
+        u8 mask;
+        struct {
+                u8 en_addr;
+                u8 en_mask;
+        } ig1;
+};
+
+/**
+ * struct st_sensor_transfer_buffer - ST sensor device I/O buffer
+ * @buf_lock: Mutex to protect rx and tx buffers.
+ * @tx_buf: Buffer used by SPI transfer function to send data to the sensors.
+ *      This buffer is used to avoid DMA not-aligned issue.
+ * @rx_buf: Buffer used by SPI transfer to receive data from sensors.
+ *      This buffer is used to avoid DMA not-aligned issue.
+ */
+struct st_sensor_transfer_buffer {
+        struct mutex buf_lock;
+        u8 rx_buf[ST_SENSORS_RX_MAX_LENGTH];
+        u8 tx_buf[ST_SENSORS_TX_MAX_LENGTH] ____cacheline_aligned;
+};
+
+/**
+ * struct st_sensor_transfer_function - ST sensor device I/O function
+ * @read_byte: Function used to read one byte.
+ * @write_byte: Function used to write one byte.
+ * @read_multiple_byte: Function used to read multiple byte.
+ */
+struct st_sensor_transfer_function {
+        int (*read_byte) (struct st_sensor_transfer_buffer *tb,
+                                struct device *dev, u8 reg_addr, u8 *res_byte);
+        int (*write_byte) (struct st_sensor_transfer_buffer *tb,
+                                struct device *dev, u8 reg_addr, u8 data);
+        int (*read_multiple_byte) (struct st_sensor_transfer_buffer *tb,
+                struct device *dev, u8 reg_addr, int len, u8 *data,
+                                                        bool multiread_bit);
+};
+
+/**
+ * struct st_sensors - ST sensors list
+ * @wai: Contents of WhoAmI register.
+ * @sensors_supported: List of supported sensors by struct itself.
+ * @ch: IIO channels for the sensor.
+ * @odr: Output data rate register and ODR list available.
+ * @pw: Power register of the sensor.
+ * @enable_axis: Enable one or more axis of the sensor.
+ * @fs: Full scale register and full scale list available.
+ * @bdu: Block data update register.
+ * @drdy_irq: Data ready register of the sensor.
+ * @multi_read_bit: Use or not particular bit for [I2C/SPI] multi-read.
+ * @bootime: samples to discard when sensor passing from power-down to power-up.
+ */
+struct st_sensors {
+        u8 wai;
+        char sensors_supported[ST_SENSORS_MAX_4WAI][ST_SENSORS_MAX_NAME];
+        struct iio_chan_spec *ch;
+        struct st_sensor_odr odr;
+        struct st_sensor_power pw;
+        struct st_sensor_axis enable_axis;
+        struct st_sensor_fullscale fs;
+        struct st_sensor_bdu bdu;
+        struct st_sensor_data_ready_irq drdy_irq;
+        bool multi_read_bit;
+        unsigned int bootime;
+};
+
+/**
+ * struct st_sensor_data - ST sensor device status
+ * @dev: Pointer to instance of struct device (I2C or SPI).
+ * @trig: The trigger in use by the core driver.
+ * @sensor: Pointer to the current sensor struct in use.
+ * @current_fullscale: Maximum range of measure by the sensor.
+ * @enabled: Status of the sensor (false->off, true->on).
+ * @multiread_bit: Use or not particular bit for [I2C/SPI] multiread.
+ * @buffer_data: Data used by buffer part.
+ * @odr: Output data rate of the sensor [Hz].
+ * @get_irq_data_ready: Function to get the IRQ used for data ready signal.
+ * @tf: Transfer function structure used by I/O operations.
+ * @tb: Transfer buffers and mutex used by I/O operations.
+ */
+struct st_sensor_data {
+        struct device *dev;
+        struct iio_trigger *trig;
+        struct st_sensors *sensor;
+        struct st_sensor_fullscale_avl *current_fullscale;
+
+        bool enabled;
+        bool multiread_bit;
+
+        char *buffer_data;
+
+        unsigned int odr;
+
+        unsigned int (*get_irq_data_ready) (struct iio_dev *indio_dev);
+
+        const struct st_sensor_transfer_function *tf;
+        struct st_sensor_transfer_buffer tb;
+};
+
+#ifdef CONFIG_IIO_BUFFER
+int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
+                                const struct iio_trigger_ops *trigger_ops);
+
+void st_sensors_deallocate_trigger(struct iio_dev *indio_dev);
+
+irqreturn_t st_sensors_trigger_handler(int irq, void *p);
+
+int st_sensors_get_buffer_element(struct iio_dev *indio_dev, u8 *buf);
+#else
+static inline int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
+                                const struct iio_trigger_ops *trigger_ops)
+{
+        return 0;
+}
+static inline void st_sensors_deallocate_trigger(struct iio_dev *indio_dev)
+{
+        return;
+}
+#endif
+
+int st_sensors_init_sensor(struct iio_dev *indio_dev);
+
+int st_sensors_set_enable(struct iio_dev *indio_dev, bool enable);
+
+int st_sensors_set_axis_enable(struct iio_dev *indio_dev, u8 axis_enable);
+
+int st_sensors_set_odr(struct iio_dev *indio_dev, unsigned int odr);
+
+int st_sensors_set_dataready_irq(struct iio_dev *indio_dev, bool enable);
+
+int st_sensors_set_fullscale_by_gain(struct iio_dev *indio_dev, int scale);
+
+int st_sensors_read_info_raw(struct iio_dev *indio_dev,
+                                struct iio_chan_spec const *ch, int *val);
+
+int st_sensors_check_device_support(struct iio_dev *indio_dev,
+                        int num_sensors_list, const struct st_sensors *sensors);
+
+ssize_t st_sensors_sysfs_get_sampling_frequency(struct device *dev,
+                                struct device_attribute *attr, char *buf);
+
+ssize_t st_sensors_sysfs_set_sampling_frequency(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t size);
+
+ssize_t st_sensors_sysfs_sampling_frequency_avail(struct device *dev,
+                                struct device_attribute *attr, char *buf);
+
+ssize_t st_sensors_sysfs_scale_avail(struct device *dev,
+                                struct device_attribute *attr, char *buf);
+
+#endif /* ST_SENSORS_H */
diff --git a/include/linux/iio/common/st_sensors_i2c.h b/include/linux/iio/common/st_sensors_i2c.h
new file mode 100644
index 000000000000..67d845385ae2
--- /dev/null
+++ b/include/linux/iio/common/st_sensors_i2c.h
@@ -0,0 +1,20 @@
+/*
+ * STMicroelectronics sensors i2c library driver
+ *
+ * Copyright 2012-2013 STMicroelectronics Inc.
+ *
+ * Denis Ciocca <denis.ciocca@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef ST_SENSORS_I2C_H
+#define ST_SENSORS_I2C_H
+
+#include <linux/i2c.h>
+#include <linux/iio/common/st_sensors.h>
+
+void st_sensors_i2c_configure(struct iio_dev *indio_dev,
+                struct i2c_client *client, struct st_sensor_data *sdata);
+
+#endif /* ST_SENSORS_I2C_H */
diff --git a/include/linux/iio/common/st_sensors_spi.h b/include/linux/iio/common/st_sensors_spi.h
new file mode 100644
index 000000000000..d964a3563dc6
--- /dev/null
+++ b/include/linux/iio/common/st_sensors_spi.h
@@ -0,0 +1,20 @@
+/*
+ * STMicroelectronics sensors spi library driver
+ *
+ * Copyright 2012-2013 STMicroelectronics Inc.
+ *
+ * Denis Ciocca <denis.ciocca@st.com>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef ST_SENSORS_SPI_H
+#define ST_SENSORS_SPI_H
+
+#include <linux/spi/spi.h>
+#include <linux/iio/common/st_sensors.h>
+
+void st_sensors_spi_configure(struct iio_dev *indio_dev,
+                        struct spi_device *spi, struct st_sensor_data *sdata);
+
+#endif /* ST_SENSORS_SPI_H */
diff --git a/include/linux/iio/consumer.h b/include/linux/iio/consumer.h
index 16c35ac045bd..833926c91aa8 100644
--- a/include/linux/iio/consumer.h
+++ b/include/linux/iio/consumer.h
@@ -15,6 +15,7 @@
 
 struct iio_dev;
 struct iio_chan_spec;
+struct device;
 
 /**
  * struct iio_channel - everything needed for a consumer to use a channel
@@ -30,14 +31,15 @@ struct iio_channel {
 
 /**
  * iio_channel_get() - get description of all that is needed to access channel.
- * @name:               Unique name of the device as provided in the iio_map
+ * @dev:                Pointer to consumer device. Device name must match
+ *                      the name of the device as provided in the iio_map
  *                      with which the desired provider to consumer mapping
  *                      was registered.
  * @consumer_channel:   Unique name to identify the channel on the consumer
  *                      side. This typically describes the channels use within
  *                      the consumer. E.g. 'battery_voltage'
  */
-struct iio_channel *iio_channel_get(const char *name,
+struct iio_channel *iio_channel_get(struct device *dev,
                                     const char *consumer_channel);
 
 /**
@@ -48,14 +50,14 @@ void iio_channel_release(struct iio_channel *chan);
 
 /**
  * iio_channel_get_all() - get all channels associated with a client
- * @name:               name of consumer device.
+ * @dev:                Pointer to consumer device.
  *
  * Returns an array of iio_channel structures terminated with one with
  * null iio_dev pointer.
  * This function is used by fairly generic consumers to get all the
  * channels registered as having this consumer.
  */
-struct iio_channel *iio_channel_get_all(const char *name);
+struct iio_channel *iio_channel_get_all(struct device *dev);
 
 /**
  * iio_channel_release_all() - reverse iio_channel_get_all
@@ -66,7 +68,7 @@ void iio_channel_release_all(struct iio_channel *chan);
 struct iio_cb_buffer;
 /**
  * iio_channel_get_all_cb() - register callback for triggered capture
- * @name:               Name of client device.
+ * @dev:                Pointer to client device.
  * @cb:                 Callback function.
  * @private:            Private data passed to callback.
  *
@@ -74,7 +76,7 @@ struct iio_cb_buffer;
  * So if the channels requested come from different devices this will
  * fail.
  */
-struct iio_cb_buffer *iio_channel_get_all_cb(const char *name,
+struct iio_cb_buffer *iio_channel_get_all_cb(struct device *dev,
                                              int (*cb)(u8 *data,
                                                        void *private),
                                              void *private);
diff --git a/include/linux/iio/driver.h b/include/linux/iio/driver.h
index a4f8b2e05af5..7dfb10ee2669 100644
--- a/include/linux/iio/driver.h
+++ b/include/linux/iio/driver.h
@@ -22,13 +22,10 @@ int iio_map_array_register(struct iio_dev *indio_dev,
                            struct iio_map *map);
 
 /**
- * iio_map_array_unregister() - tell the core to remove consumer mappings
+ * iio_map_array_unregister() - tell the core to remove consumer mappings for
+ *                              the given provider device
  * @indio_dev:  provider device
- * @map:        array of mappings to remove. Note these must have same memory
- *              addresses as those originally added not just equal parameter
- *              values.
  */
-int iio_map_array_unregister(struct iio_dev *indio_dev,
-                             struct iio_map *map);
+int iio_map_array_unregister(struct iio_dev *indio_dev);
 
 #endif
diff --git a/include/linux/iio/gyro/itg3200.h b/include/linux/iio/gyro/itg3200.h
new file mode 100644
index 000000000000..c53f16914b77
--- /dev/null
+++ b/include/linux/iio/gyro/itg3200.h
@@ -0,0 +1,154 @@
+/*
+ * itg3200.h -- support InvenSense ITG3200
+ *              Digital 3-Axis Gyroscope driver
+ *
+ * Copyright (c) 2011 Christian Strobel <christian.strobel@iis.fraunhofer.de>
+ * Copyright (c) 2011 Manuel Stahl <manuel.stahl@iis.fraunhofer.de>
+ * Copyright (c) 2012 Thorsten Nowak <thorsten.nowak@iis.fraunhofer.de>
+ *
+ * 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 I2C_ITG3200_H_
+#define I2C_ITG3200_H_
+
+#include <linux/iio/iio.h>
+
+/* Register with I2C address (34h) */
+#define ITG3200_REG_ADDRESS             0x00
+
+/* Sample rate divider
+ * Range: 0 to 255
+ * Default value: 0x00 */
+#define ITG3200_REG_SAMPLE_RATE_DIV     0x15
+
+/* Digital low pass filter settings */
+#define ITG3200_REG_DLPF                0x16
+/* DLPF full scale range */
+#define ITG3200_DLPF_FS_SEL_2000        0x18
+/* Bandwidth (Hz) and internal sample rate
+ * (kHz) of DLPF */
+#define ITG3200_DLPF_256_8              0x00
+#define ITG3200_DLPF_188_1              0x01
+#define ITG3200_DLPF_98_1               0x02
+#define ITG3200_DLPF_42_1               0x03
+#define ITG3200_DLPF_20_1               0x04
+#define ITG3200_DLPF_10_1               0x05
+#define ITG3200_DLPF_5_1                0x06
+
+#define ITG3200_DLPF_CFG_MASK           0x07
+
+/* Configuration for interrupt operations */
+#define ITG3200_REG_IRQ_CONFIG          0x17
+/* Logic level */
+#define ITG3200_IRQ_ACTIVE_LOW          0x80
+#define ITG3200_IRQ_ACTIVE_HIGH         0x00
+/* Drive type */
+#define ITG3200_IRQ_OPEN_DRAIN          0x40
+#define ITG3200_IRQ_PUSH_PULL           0x00
+/* Latch mode */
+#define ITG3200_IRQ_LATCH_UNTIL_CLEARED 0x20
+#define ITG3200_IRQ_LATCH_50US_PULSE    0x00
+/* Latch clear method */
+#define ITG3200_IRQ_LATCH_CLEAR_ANY     0x10
+#define ITG3200_IRQ_LATCH_CLEAR_STATUS  0x00
+/* Enable interrupt when device is ready */
+#define ITG3200_IRQ_DEVICE_RDY_ENABLE   0x04
+/* Enable interrupt when data is available */
+#define ITG3200_IRQ_DATA_RDY_ENABLE     0x01
+
+/* Determine the status of ITG-3200 interrupts */
+#define ITG3200_REG_IRQ_STATUS          0x1A
+/* Status of 'device is ready'-interrupt */
+#define ITG3200_IRQ_DEVICE_RDY_STATUS   0x04
+/* Status of 'data is available'-interrupt */
+#define ITG3200_IRQ_DATA_RDY_STATUS     0x01
+
+/* Sensor registers */
+#define ITG3200_REG_TEMP_OUT_H          0x1B
+#define ITG3200_REG_TEMP_OUT_L          0x1C
+#define ITG3200_REG_GYRO_XOUT_H         0x1D
+#define ITG3200_REG_GYRO_XOUT_L         0x1E
+#define ITG3200_REG_GYRO_YOUT_H         0x1F
+#define ITG3200_REG_GYRO_YOUT_L         0x20
+#define ITG3200_REG_GYRO_ZOUT_H         0x21
+#define ITG3200_REG_GYRO_ZOUT_L         0x22
+
+/* Power management */
+#define ITG3200_REG_POWER_MANAGEMENT    0x3E
+/* Reset device and internal registers to the
+ * power-up-default settings */
+#define ITG3200_RESET                   0x80
+/* Enable low power sleep mode */
+#define ITG3200_SLEEP                   0x40
+/* Put according gyroscope in standby mode */
+#define ITG3200_STANDBY_GYRO_X          0x20
+#define ITG3200_STANDBY_GYRO_Y          0x10
+#define ITG3200_STANDBY_GYRO_Z          0x08
+/* Determine the device clock source */
+#define ITG3200_CLK_INTERNAL            0x00
+#define ITG3200_CLK_GYRO_X              0x01
+#define ITG3200_CLK_GYRO_Y              0x02
+#define ITG3200_CLK_GYRO_Z              0x03
+#define ITG3200_CLK_EXT_32K             0x04
+#define ITG3200_CLK_EXT_19M             0x05
+
+
+/**
+ * struct itg3200 - device instance specific data
+ * @i2c:    actual i2c_client
+ * @trig:   data ready trigger from itg3200 pin
+ **/
+struct itg3200 {
+        struct i2c_client       *i2c;
+        struct iio_trigger      *trig;
+};
+
+enum ITG3200_SCAN_INDEX {
+        ITG3200_SCAN_TEMP,
+        ITG3200_SCAN_GYRO_X,
+        ITG3200_SCAN_GYRO_Y,
+        ITG3200_SCAN_GYRO_Z,
+        ITG3200_SCAN_ELEMENTS,
+};
+
+int itg3200_write_reg_8(struct iio_dev *indio_dev,
+                u8 reg_address, u8 val);
+
+int itg3200_read_reg_8(struct iio_dev *indio_dev,
+                u8 reg_address, u8 *val);
+
+
+#ifdef CONFIG_IIO_BUFFER
+
+void itg3200_remove_trigger(struct iio_dev *indio_dev);
+int itg3200_probe_trigger(struct iio_dev *indio_dev);
+
+int itg3200_buffer_configure(struct iio_dev *indio_dev);
+void itg3200_buffer_unconfigure(struct iio_dev *indio_dev);
+
+#else /* CONFIG_IIO_BUFFER */
+
+static inline void itg3200_remove_trigger(struct iio_dev *indio_dev)
+{
+}
+
+static inline int itg3200_probe_trigger(struct iio_dev *indio_dev)
+{
+        return 0;
+}
+
+static inline int itg3200_buffer_configure(struct iio_dev *indio_dev)
+{
+        return 0;
+}
+
+static inline void itg3200_buffer_unconfigure(struct iio_dev *indio_dev)
+{
+}
+
+#endif  /* CONFIG_IIO_RING_BUFFER */
+
+#endif /* ITG3200_H_ */
diff --git a/include/linux/iio/trigger.h b/include/linux/iio/trigger.h
index 20239da1d0f7..c66e0a96f6e8 100644
--- a/include/linux/iio/trigger.h
+++ b/include/linux/iio/trigger.h
@@ -12,6 +12,7 @@
 #ifndef _IIO_TRIGGER_H_
 #define _IIO_TRIGGER_H_
 
+#ifdef CONFIG_IIO_TRIGGER
 struct iio_subirq {
         bool enabled;
 };
@@ -117,4 +118,8 @@ irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private);
 __printf(1, 2) struct iio_trigger *iio_trigger_alloc(const char *fmt, ...);
 void iio_trigger_free(struct iio_trigger *trig);
 
+#else
+struct iio_trigger;
+struct iio_trigger_ops;
+#endif
 #endif /* _IIO_TRIGGER_H_ */
diff --git a/include/linux/in6.h b/include/linux/in6.h
index 9e2ae26fb598..34edf1f6c9a3 100644
--- a/include/linux/in6.h
+++ b/include/linux/in6.h
@@ -22,6 +22,10 @@
 
 #include <uapi/linux/in6.h>
 
+/* IPv6 Wildcard Address (::) and Loopback Address (::1) defined in RFC2553
+ * NOTE: Be aware the IN6ADDR_* constants and in6addr_* externals are defined
+ * in network byte order, not in host byte order as are the IPv4 equivalents
+ */
 extern const struct in6_addr in6addr_any;
 #define IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
 extern const struct in6_addr in6addr_loopback;
@@ -32,4 +36,13 @@ extern const struct in6_addr in6addr_linklocal_allnodes;
 extern const struct in6_addr in6addr_linklocal_allrouters;
 #define IN6ADDR_LINKLOCAL_ALLROUTERS_INIT \
                 { { { 0xff,2,0,0,0,0,0,0,0,0,0,0,0,0,0,2 } } }
+extern const struct in6_addr in6addr_interfacelocal_allnodes;
+#define IN6ADDR_INTERFACELOCAL_ALLNODES_INIT \
+                { { { 0xff,1,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
+extern const struct in6_addr in6addr_interfacelocal_allrouters;
+#define IN6ADDR_INTERFACELOCAL_ALLROUTERS_INIT \
+                { { { 0xff,1,0,0,0,0,0,0,0,0,0,0,0,0,0,2 } } }
+extern const struct in6_addr in6addr_sitelocal_allrouters;
+#define IN6ADDR_SITELOCAL_ALLROUTERS_INIT \
+                { { { 0xff,5,0,0,0,0,0,0,0,0,0,0,0,0,0,2 } } }
 #endif
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index a9d828976a77..ea1e3b863890 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -166,6 +166,12 @@ struct in_ifaddr {
         unsigned char           ifa_flags;
         unsigned char           ifa_prefixlen;
         char                    ifa_label[IFNAMSIZ];
+
+        /* In seconds, relative to tstamp. Expiry is at tstamp + HZ * lft. */
+        __u32                   ifa_valid_lft;
+        __u32                   ifa_preferred_lft;
+        unsigned long           ifa_cstamp; /* created timestamp */
+        unsigned long           ifa_tstamp; /* updated timestamp */
 };
 
 extern int register_inetaddr_notifier(struct notifier_block *nb);
diff --git a/include/linux/init.h b/include/linux/init.h
index 10ed4f436458..861814710d52 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -153,6 +153,7 @@ extern unsigned int reset_devices;
 /* used by init/main.c */
 void setup_arch(char **);
 void prepare_namespace(void);
+void __init load_default_modules(void);
 
 extern void (*late_time_init)(void);
 
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index 6d087c5f57f7..5cd0f0949927 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -10,7 +10,9 @@
 #include <linux/pid_namespace.h>
 #include <linux/user_namespace.h>
 #include <linux/securebits.h>
+#include <linux/seqlock.h>
 #include <net/net_namespace.h>
+#include <linux/sched/rt.h>
 
 #ifdef CONFIG_SMP
 # define INIT_PUSHABLE_TASKS(tsk)                                       \
@@ -141,6 +143,15 @@ extern struct task_group root_task_group;
 # define INIT_PERF_EVENTS(tsk)
 #endif
 
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
+# define INIT_VTIME(tsk)                                                \
+        .vtime_seqlock = __SEQLOCK_UNLOCKED(tsk.vtime_seqlock), \
+        .vtime_snap = 0,                                \
+        .vtime_snap_whence = VTIME_SYS,
+#else
+# define INIT_VTIME(tsk)
+#endif
+
 #define INIT_TASK_COMM "swapper"
 
 /*
@@ -210,6 +221,7 @@ extern struct task_group root_task_group;
         INIT_TRACE_RECURSION                                            \
         INIT_TASK_RCU_PREEMPT(tsk)                                      \
         INIT_CPUSET_SEQ                                                 \
+        INIT_VTIME(tsk)                                                 \
 }
 
 
diff --git a/include/linux/input/adxl34x.h b/include/linux/input/adxl34x.h
index 57e01a7cb006..010d98175efa 100644
--- a/include/linux/input/adxl34x.h
+++ b/include/linux/input/adxl34x.h
@@ -13,6 +13,8 @@
 #ifndef __LINUX_INPUT_ADXL34X_H__
 #define __LINUX_INPUT_ADXL34X_H__
 
+#include <linux/input.h>
+
 struct adxl34x_platform_data {
 
         /*
diff --git a/include/linux/input/tegra_kbc.h b/include/linux/input/tegra_kbc.h
deleted file mode 100644
index a13025612939..000000000000
--- a/include/linux/input/tegra_kbc.h
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- * Platform definitions for tegra-kbc keyboard input driver
- *
- * Copyright (c) 2010-2011, NVIDIA 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; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
- * more details.
- *
- * You should have received a copy of the GNU General Public License along
- * with this program; if not, write to the Free Software Foundation, Inc.,
- * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
- */
-
-#ifndef ASMARM_ARCH_TEGRA_KBC_H
-#define ASMARM_ARCH_TEGRA_KBC_H
-
-#include <linux/types.h>
-#include <linux/input/matrix_keypad.h>
-
-#define KBC_MAX_GPIO    24
-#define KBC_MAX_KPENT   8
-
-#define KBC_MAX_ROW     16
-#define KBC_MAX_COL     8
-#define KBC_MAX_KEY     (KBC_MAX_ROW * KBC_MAX_COL)
-
-enum tegra_pin_type {
-        PIN_CFG_IGNORE,
-        PIN_CFG_COL,
-        PIN_CFG_ROW,
-};
-
-struct tegra_kbc_pin_cfg {
-        enum tegra_pin_type type;
-        unsigned char num;
-};
-
-struct tegra_kbc_wake_key {
-        u8 row:4;
-        u8 col:4;
-};
-
-struct tegra_kbc_platform_data {
-        unsigned int debounce_cnt;
-        unsigned int repeat_cnt;
-
-        struct tegra_kbc_pin_cfg pin_cfg[KBC_MAX_GPIO];
-        const struct matrix_keymap_data *keymap_data;
-
-        u32 wakeup_key;
-        bool wakeup;
-        bool use_fn_map;
-        bool use_ghost_filter;
-};
-#endif
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index f3b99e1c1042..ba3b8a98a049 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -58,8 +58,10 @@ struct iommu_domain {
 #define IOMMU_CAP_INTR_REMAP            0x2     /* isolates device intrs */
 
 enum iommu_attr {
-        DOMAIN_ATTR_MAX,
         DOMAIN_ATTR_GEOMETRY,
+        DOMAIN_ATTR_PAGING,
+        DOMAIN_ATTR_WINDOWS,
+        DOMAIN_ATTR_MAX,
 };
 
 #ifdef CONFIG_IOMMU_API
@@ -100,6 +102,16 @@ struct iommu_ops {
                                enum iommu_attr attr, void *data);
         int (*domain_set_attr)(struct iommu_domain *domain,
                                enum iommu_attr attr, void *data);
+
+        /* Window handling functions */
+        int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
+                                    phys_addr_t paddr, u64 size);
+        void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
+        /* Set the numer of window per domain */
+        int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
+        /* Get the numer of window per domain */
+        u32 (*domain_get_windows)(struct iommu_domain *domain);
+
         unsigned long pgsize_bitmap;
 };
 
@@ -157,6 +169,10 @@ extern int iommu_domain_get_attr(struct iommu_domain *domain, enum iommu_attr,
 extern int iommu_domain_set_attr(struct iommu_domain *domain, enum iommu_attr,
                                  void *data);
 
+/* Window handling function prototypes */
+extern int iommu_domain_window_enable(struct iommu_domain *domain, u32 wnd_nr,
+                                      phys_addr_t offset, u64 size);
+extern void iommu_domain_window_disable(struct iommu_domain *domain, u32 wnd_nr);
 /**
  * report_iommu_fault() - report about an IOMMU fault to the IOMMU framework
  * @domain: the iommu domain where the fault has happened
@@ -239,6 +255,18 @@ static inline int iommu_unmap(struct iommu_domain *domain, unsigned long iova,
         return -ENODEV;
 }
 
+static inline int iommu_domain_window_enable(struct iommu_domain *domain,
+                                             u32 wnd_nr, phys_addr_t paddr,
+                                             u64 size)
+{
+        return -ENODEV;
+}
+
+static inline void iommu_domain_window_disable(struct iommu_domain *domain,
+                                               u32 wnd_nr)
+{
+}
+
 static inline phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain,
                                              unsigned long iova)
 {
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index faed1e357dd6..850e95bc766c 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -77,11 +77,6 @@ static inline struct ipv6hdr *ipipv6_hdr(const struct sk_buff *skb)
         return (struct ipv6hdr *)skb_transport_header(skb);
 }
 
-static inline __u8 ipv6_tclass(const struct ipv6hdr *iph)
-{
-        return (ntohl(*(__be32 *)iph) >> 20) & 0xff;
-}
-
 /* 
    This structure contains results of exthdrs parsing
    as offsets from skb->nh.
@@ -89,7 +84,7 @@ static inline __u8 ipv6_tclass(const struct ipv6hdr *iph)
 
 struct inet6_skb_parm {
         int                     iif;
-        __u16                   ra;
+        __be16                  ra;
         __u16                   hop;
         __u16                   dst0;
         __u16                   srcrt;
@@ -105,6 +100,7 @@ struct inet6_skb_parm {
 #define IP6SKB_XFRM_TRANSFORMED 1
 #define IP6SKB_FORWARDED        2
 #define IP6SKB_REROUTED         4
+#define IP6SKB_ROUTERALERT      8
 };
 
 #define IP6CB(skb)      ((struct inet6_skb_parm*)((skb)->cb))
@@ -218,7 +214,7 @@ struct ipv6_pinfo {
 
         struct ipv6_mc_socklist __rcu *ipv6_mc_list;
         struct ipv6_ac_socklist *ipv6_ac_list;
-        struct ipv6_fl_socklist *ipv6_fl_list;
+        struct ipv6_fl_socklist __rcu *ipv6_fl_list;
 
         struct ipv6_txoptions   *opt;
         struct sk_buff          *pktoptions;
diff --git a/include/linux/irq.h b/include/linux/irq.h
index fdf2c4a238cc..bc4e06611958 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -509,8 +509,11 @@ static inline void irq_set_percpu_devid_flags(unsigned int irq)
 
 /* Handle dynamic irq creation and destruction */
 extern unsigned int create_irq_nr(unsigned int irq_want, int node);
+extern unsigned int __create_irqs(unsigned int from, unsigned int count,
+                                  int node);
 extern int create_irq(void);
 extern void destroy_irq(unsigned int irq);
+extern void destroy_irqs(unsigned int irq, unsigned int count);
 
 /*
  * Dynamic irq helper functions. Obsolete. Use irq_alloc_desc* and
@@ -528,6 +531,8 @@ extern int irq_set_handler_data(unsigned int irq, void *data);
 extern int irq_set_chip_data(unsigned int irq, void *data);
 extern int irq_set_irq_type(unsigned int irq, unsigned int type);
 extern int irq_set_msi_desc(unsigned int irq, struct msi_desc *entry);
+extern int irq_set_msi_desc_off(unsigned int irq_base, unsigned int irq_offset,
+                                struct msi_desc *entry);
 extern struct irq_data *irq_get_irq_data(unsigned int irq);
 
 static inline struct irq_chip *irq_get_chip(unsigned int irq)
@@ -590,6 +595,9 @@ int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
 #define irq_alloc_desc_from(from, node)         \
         irq_alloc_descs(-1, from, 1, node)
 
+#define irq_alloc_descs_from(from, cnt, node)   \
+        irq_alloc_descs(-1, from, cnt, node)
+
 void irq_free_descs(unsigned int irq, unsigned int cnt);
 int irq_reserve_irqs(unsigned int from, unsigned int cnt);
 
diff --git a/include/linux/irq_work.h b/include/linux/irq_work.h
index 6a9e8f5399e2..f5dbce50466e 100644
--- a/include/linux/irq_work.h
+++ b/include/linux/irq_work.h
@@ -3,6 +3,20 @@
 
 #include <linux/llist.h>
 
+/*
+ * An entry can be in one of four states:
+ *
+ * free      NULL, 0 -> {claimed}       : free to be used
+ * claimed   NULL, 3 -> {pending}       : claimed to be enqueued
+ * pending   next, 3 -> {busy}          : queued, pending callback
+ * busy      NULL, 2 -> {free, claimed} : callback in progress, can be claimed
+ */
+
+#define IRQ_WORK_PENDING        1UL
+#define IRQ_WORK_BUSY           2UL
+#define IRQ_WORK_FLAGS          3UL
+#define IRQ_WORK_LAZY           4UL /* Doesn't want IPI, wait for tick */
+
 struct irq_work {
         unsigned long flags;
         struct llist_node llnode;
@@ -16,8 +30,14 @@ void init_irq_work(struct irq_work *work, void (*func)(struct irq_work *))
         work->func = func;
 }
 
-bool irq_work_queue(struct irq_work *work);
+void irq_work_queue(struct irq_work *work);
 void irq_work_run(void);
 void irq_work_sync(struct irq_work *work);
 
+#ifdef CONFIG_IRQ_WORK
+bool irq_work_needs_cpu(void);
+#else
+static bool irq_work_needs_cpu(void) { return false; }
+#endif
+
 #endif /* _LINUX_IRQ_WORK_H */
diff --git a/include/linux/irqchip.h b/include/linux/irqchip.h
new file mode 100644
index 000000000000..e0006f1d35a0
--- /dev/null
+++ b/include/linux/irqchip.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2012 Thomas Petazzoni
+ *
+ * Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+ *
+ * This file is licensed under the terms of the GNU General Public
+ * License version 2.  This program is licensed "as is" without any
+ * warranty of any kind, whether express or implied.
+ */
+
+#ifndef _LINUX_IRQCHIP_H
+#define _LINUX_IRQCHIP_H
+
+void irqchip_init(void);
+
+#endif
diff --git a/include/linux/irqchip/arm-gic.h b/include/linux/irqchip/arm-gic.h
new file mode 100644
index 000000000000..3fd8e4290a1c
--- /dev/null
+++ b/include/linux/irqchip/arm-gic.h
@@ -0,0 +1,79 @@
+/*
+ *  include/linux/irqchip/arm-gic.h
+ *
+ *  Copyright (C) 2002 ARM Limited, 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 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __LINUX_IRQCHIP_ARM_GIC_H
+#define __LINUX_IRQCHIP_ARM_GIC_H
+
+#define GIC_CPU_CTRL                    0x00
+#define GIC_CPU_PRIMASK                 0x04
+#define GIC_CPU_BINPOINT                0x08
+#define GIC_CPU_INTACK                  0x0c
+#define GIC_CPU_EOI                     0x10
+#define GIC_CPU_RUNNINGPRI              0x14
+#define GIC_CPU_HIGHPRI                 0x18
+
+#define GIC_DIST_CTRL                   0x000
+#define GIC_DIST_CTR                    0x004
+#define GIC_DIST_IGROUP                 0x080
+#define GIC_DIST_ENABLE_SET             0x100
+#define GIC_DIST_ENABLE_CLEAR           0x180
+#define GIC_DIST_PENDING_SET            0x200
+#define GIC_DIST_PENDING_CLEAR          0x280
+#define GIC_DIST_ACTIVE_SET             0x300
+#define GIC_DIST_ACTIVE_CLEAR           0x380
+#define GIC_DIST_PRI                    0x400
+#define GIC_DIST_TARGET                 0x800
+#define GIC_DIST_CONFIG                 0xc00
+#define GIC_DIST_SOFTINT                0xf00
+
+#define GICH_HCR                        0x0
+#define GICH_VTR                        0x4
+#define GICH_VMCR                       0x8
+#define GICH_MISR                       0x10
+#define GICH_EISR0                      0x20
+#define GICH_EISR1                      0x24
+#define GICH_ELRSR0                     0x30
+#define GICH_ELRSR1                     0x34
+#define GICH_APR                        0xf0
+#define GICH_LR0                        0x100
+
+#define GICH_HCR_EN                     (1 << 0)
+#define GICH_HCR_UIE                    (1 << 1)
+
+#define GICH_LR_VIRTUALID               (0x3ff << 0)
+#define GICH_LR_PHYSID_CPUID_SHIFT      (10)
+#define GICH_LR_PHYSID_CPUID            (7 << GICH_LR_PHYSID_CPUID_SHIFT)
+#define GICH_LR_STATE                   (3 << 28)
+#define GICH_LR_PENDING_BIT             (1 << 28)
+#define GICH_LR_ACTIVE_BIT              (1 << 29)
+#define GICH_LR_EOI                     (1 << 19)
+
+#define GICH_MISR_EOI                   (1 << 0)
+#define GICH_MISR_U                     (1 << 1)
+
+#ifndef __ASSEMBLY__
+
+struct device_node;
+
+extern struct irq_chip gic_arch_extn;
+
+void gic_init_bases(unsigned int, int, void __iomem *, void __iomem *,
+                    u32 offset, struct device_node *);
+void gic_secondary_init(unsigned int);
+void gic_cascade_irq(unsigned int gic_nr, unsigned int irq);
+
+static inline void gic_init(unsigned int nr, int start,
+                            void __iomem *dist , void __iomem *cpu)
+{
+        gic_init_bases(nr, start, dist, cpu, 0, NULL);
+}
+
+#endif /* __ASSEMBLY */
+
+#endif
diff --git a/include/linux/irqchip/arm-vic.h b/include/linux/irqchip/arm-vic.h
new file mode 100644
index 000000000000..e3c82dc95756
--- /dev/null
+++ b/include/linux/irqchip/arm-vic.h
@@ -0,0 +1,36 @@
+/*
+ *  arch/arm/include/asm/hardware/vic.h
+ *
+ *  Copyright (c) ARM Limited 2003.  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.
+ *
+ * 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 __ASM_ARM_HARDWARE_VIC_H
+#define __ASM_ARM_HARDWARE_VIC_H
+
+#include <linux/types.h>
+
+#define VIC_RAW_STATUS                  0x08
+#define VIC_INT_ENABLE                  0x10    /* 1 = enable, 0 = disable */
+#define VIC_INT_ENABLE_CLEAR            0x14
+
+struct device_node;
+struct pt_regs;
+
+void __vic_init(void __iomem *base, int irq_start, u32 vic_sources,
+                u32 resume_sources, struct device_node *node);
+void vic_init(void __iomem *base, unsigned int irq_start, u32 vic_sources, u32 resume_sources);
+
+#endif
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index c566927efcbd..80d36874689b 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -398,7 +398,11 @@ extern int panic_on_unrecovered_nmi;
 extern int panic_on_io_nmi;
 extern int sysctl_panic_on_stackoverflow;
 extern const char *print_tainted(void);
-extern void add_taint(unsigned flag);
+enum lockdep_ok {
+        LOCKDEP_STILL_OK,
+        LOCKDEP_NOW_UNRELIABLE
+};
+extern void add_taint(unsigned flag, enum lockdep_ok);
 extern int test_taint(unsigned flag);
 extern unsigned long get_taint(void);
 extern int root_mountflags;
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index 66b70780e910..ed5f6ed6eb77 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -127,7 +127,7 @@ extern void account_system_time(struct task_struct *, int, cputime_t, cputime_t)
 extern void account_steal_time(cputime_t);
 extern void account_idle_time(cputime_t);
 
-#ifdef CONFIG_VIRT_CPU_ACCOUNTING
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
 static inline void account_process_tick(struct task_struct *tsk, int user)
 {
         vtime_account_user(tsk);
diff --git a/include/linux/kexec.h b/include/linux/kexec.h
index d0b8458a703a..d2e6927bbaae 100644
--- a/include/linux/kexec.h
+++ b/include/linux/kexec.h
@@ -191,6 +191,7 @@ extern struct kimage *kexec_crash_image;
 /* Location of a reserved region to hold the crash kernel.
  */
 extern struct resource crashk_res;
+extern struct resource crashk_low_res;
 typedef u32 note_buf_t[KEXEC_NOTE_BYTES/4];
 extern note_buf_t __percpu *crash_notes;
 extern u32 vmcoreinfo_note[VMCOREINFO_NOTE_SIZE/4];
@@ -199,6 +200,8 @@ extern size_t vmcoreinfo_max_size;
 
 int __init parse_crashkernel(char *cmdline, unsigned long long system_ram,
                 unsigned long long *crash_size, unsigned long long *crash_base);
+int parse_crashkernel_low(char *cmdline, unsigned long long system_ram,
+                unsigned long long *crash_size, unsigned long long *crash_base);
 int crash_shrink_memory(unsigned long new_size);
 size_t crash_get_memory_size(void);
 void crash_free_reserved_phys_range(unsigned long begin, unsigned long end);
diff --git a/include/linux/kgdb.h b/include/linux/kgdb.h
index 4dff0c6ed58f..c6e091bf39a5 100644
--- a/include/linux/kgdb.h
+++ b/include/linux/kgdb.h
@@ -13,7 +13,6 @@
 #ifndef _KGDB_H_
 #define _KGDB_H_
 
-#include <linux/serial_8250.h>
 #include <linux/linkage.h>
 #include <linux/init.h>
 #include <linux/atomic.h>
diff --git a/include/linux/kprobes.h b/include/linux/kprobes.h
index 23755ba42abc..4b6ef4d33cc2 100644
--- a/include/linux/kprobes.h
+++ b/include/linux/kprobes.h
@@ -49,16 +49,6 @@
 #define KPROBE_REENTER          0x00000004
 #define KPROBE_HIT_SSDONE       0x00000008
 
-/*
- * If function tracer is enabled and the arch supports full
- * passing of pt_regs to function tracing, then kprobes can
- * optimize on top of function tracing.
- */
-#if defined(CONFIG_FUNCTION_TRACER) && defined(ARCH_SUPPORTS_FTRACE_SAVE_REGS) \
-        && defined(ARCH_SUPPORTS_KPROBES_ON_FTRACE)
-# define KPROBES_CAN_USE_FTRACE
-#endif
-
 /* Attach to insert probes on any functions which should be ignored*/
 #define __kprobes       __attribute__((__section__(".kprobes.text")))
 
@@ -316,7 +306,7 @@ extern int proc_kprobes_optimization_handler(struct ctl_table *table,
 #endif
 
 #endif /* CONFIG_OPTPROBES */
-#ifdef KPROBES_CAN_USE_FTRACE
+#ifdef CONFIG_KPROBES_ON_FTRACE
 extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
                                   struct ftrace_ops *ops, struct pt_regs *regs);
 extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
diff --git a/include/linux/ksm.h b/include/linux/ksm.h
index 3319a6967626..45c9b6a17bcb 100644
--- a/include/linux/ksm.h
+++ b/include/linux/ksm.h
@@ -16,9 +16,6 @@
 struct stable_node;
 struct mem_cgroup;
 
-struct page *ksm_does_need_to_copy(struct page *page,
-                        struct vm_area_struct *vma, unsigned long address);
-
 #ifdef CONFIG_KSM
 int ksm_madvise(struct vm_area_struct *vma, unsigned long start,
                 unsigned long end, int advice, unsigned long *vm_flags);
@@ -73,15 +70,8 @@ static inline void set_page_stable_node(struct page *page,
  * We'd like to make this conditional on vma->vm_flags & VM_MERGEABLE,
  * but what if the vma was unmerged while the page was swapped out?
  */
-static inline int ksm_might_need_to_copy(struct page *page,
-                        struct vm_area_struct *vma, unsigned long address)
-{
-        struct anon_vma *anon_vma = page_anon_vma(page);
-
-        return anon_vma &&
-                (anon_vma->root != vma->anon_vma->root ||
-                 page->index != linear_page_index(vma, address));
-}
+struct page *ksm_might_need_to_copy(struct page *page,
+                        struct vm_area_struct *vma, unsigned long address);
 
 int page_referenced_ksm(struct page *page,
                         struct mem_cgroup *memcg, unsigned long *vm_flags);
@@ -113,10 +103,10 @@ static inline int ksm_madvise(struct vm_area_struct *vma, unsigned long start,
         return 0;
 }
 
-static inline int ksm_might_need_to_copy(struct page *page,
+static inline struct page *ksm_might_need_to_copy(struct page *page,
                         struct vm_area_struct *vma, unsigned long address)
 {
-        return 0;
+        return page;
 }
 
 static inline int page_referenced_ksm(struct page *page,
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 2c497ab0d03d..cad77fe09d77 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -22,6 +22,7 @@
 #include <linux/rcupdate.h>
 #include <linux/ratelimit.h>
 #include <linux/err.h>
+#include <linux/irqflags.h>
 #include <asm/signal.h>
 
 #include <linux/kvm.h>
@@ -122,6 +123,8 @@ static inline bool is_error_page(struct page *page)
 #define KVM_REQ_WATCHDOG          18
 #define KVM_REQ_MASTERCLOCK_UPDATE 19
 #define KVM_REQ_MCLOCK_INPROGRESS 20
+#define KVM_REQ_EPR_EXIT          21
+#define KVM_REQ_EOIBITMAP         22
 
 #define KVM_USERSPACE_IRQ_SOURCE_ID             0
 #define KVM_IRQFD_RESAMPLE_IRQ_SOURCE_ID        1
@@ -266,12 +269,11 @@ static inline int kvm_vcpu_exiting_guest_mode(struct kvm_vcpu *vcpu)
 struct kvm_memory_slot {
         gfn_t base_gfn;
         unsigned long npages;
-        unsigned long flags;
         unsigned long *dirty_bitmap;
         struct kvm_arch_memory_slot arch;
         unsigned long userspace_addr;
-        int user_alloc;
-        int id;
+        u32 flags;
+        short id;
 };
 
 static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memslot)
@@ -313,8 +315,12 @@ struct kvm_irq_routing_table {};
 
 #endif
 
+#ifndef KVM_PRIVATE_MEM_SLOTS
+#define KVM_PRIVATE_MEM_SLOTS 0
+#endif
+
 #ifndef KVM_MEM_SLOTS_NUM
-#define KVM_MEM_SLOTS_NUM (KVM_MEMORY_SLOTS + KVM_PRIVATE_MEM_SLOTS)
+#define KVM_MEM_SLOTS_NUM (KVM_USER_MEM_SLOTS + KVM_PRIVATE_MEM_SLOTS)
 #endif
 
 /*
@@ -326,7 +332,7 @@ struct kvm_memslots {
         u64 generation;
         struct kvm_memory_slot memslots[KVM_MEM_SLOTS_NUM];
         /* The mapping table from slot id to the index in memslots[]. */
-        int id_to_index[KVM_MEM_SLOTS_NUM];
+        short id_to_index[KVM_MEM_SLOTS_NUM];
 };
 
 struct kvm {
@@ -424,7 +430,8 @@ void kvm_exit(void);
 
 void kvm_get_kvm(struct kvm *kvm);
 void kvm_put_kvm(struct kvm *kvm);
-void update_memslots(struct kvm_memslots *slots, struct kvm_memory_slot *new);
+void update_memslots(struct kvm_memslots *slots, struct kvm_memory_slot *new,
+                     u64 last_generation);
 
 static inline struct kvm_memslots *kvm_memslots(struct kvm *kvm)
 {
@@ -447,10 +454,10 @@ id_to_memslot(struct kvm_memslots *slots, int id)
 
 int kvm_set_memory_region(struct kvm *kvm,
                           struct kvm_userspace_memory_region *mem,
-                          int user_alloc);
+                          bool user_alloc);
 int __kvm_set_memory_region(struct kvm *kvm,
                             struct kvm_userspace_memory_region *mem,
-                            int user_alloc);
+                            bool user_alloc);
 void kvm_arch_free_memslot(struct kvm_memory_slot *free,
                            struct kvm_memory_slot *dont);
 int kvm_arch_create_memslot(struct kvm_memory_slot *slot, unsigned long npages);
@@ -458,11 +465,11 @@ int kvm_arch_prepare_memory_region(struct kvm *kvm,
                                 struct kvm_memory_slot *memslot,
                                 struct kvm_memory_slot old,
                                 struct kvm_userspace_memory_region *mem,
-                                int user_alloc);
+                                bool user_alloc);
 void kvm_arch_commit_memory_region(struct kvm *kvm,
                                 struct kvm_userspace_memory_region *mem,
                                 struct kvm_memory_slot old,
-                                int user_alloc);
+                                bool user_alloc);
 bool kvm_largepages_enabled(void);
 void kvm_disable_largepages(void);
 /* flush all memory translations */
@@ -532,6 +539,7 @@ void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
 void kvm_flush_remote_tlbs(struct kvm *kvm);
 void kvm_reload_remote_mmus(struct kvm *kvm);
 void kvm_make_mclock_inprogress_request(struct kvm *kvm);
+void kvm_make_update_eoibitmap_request(struct kvm *kvm);
 
 long kvm_arch_dev_ioctl(struct file *filp,
                         unsigned int ioctl, unsigned long arg);
@@ -549,7 +557,7 @@ int kvm_vm_ioctl_get_dirty_log(struct kvm *kvm,
 int kvm_vm_ioctl_set_memory_region(struct kvm *kvm,
                                    struct
                                    kvm_userspace_memory_region *mem,
-                                   int user_alloc);
+                                   bool user_alloc);
 int kvm_vm_ioctl_irq_line(struct kvm *kvm, struct kvm_irq_level *irq_level);
 long kvm_arch_vm_ioctl(struct file *filp,
                        unsigned int ioctl, unsigned long arg);
@@ -685,6 +693,7 @@ int kvm_set_irq(struct kvm *kvm, int irq_source_id, u32 irq, int level);
 int kvm_set_irq_inatomic(struct kvm *kvm, int irq_source_id, u32 irq, int level);
 int kvm_set_msi(struct kvm_kernel_irq_routing_entry *irq_entry, struct kvm *kvm,
                 int irq_source_id, int level);
+bool kvm_irq_has_notifier(struct kvm *kvm, unsigned irqchip, unsigned pin);
 void kvm_notify_acked_irq(struct kvm *kvm, unsigned irqchip, unsigned pin);
 void kvm_register_irq_ack_notifier(struct kvm *kvm,
                                    struct kvm_irq_ack_notifier *kian);
@@ -740,15 +749,52 @@ static inline int kvm_deassign_device(struct kvm *kvm,
 }
 #endif /* CONFIG_IOMMU_API */
 
-static inline void kvm_guest_enter(void)
+static inline void __guest_enter(void)
 {
-        BUG_ON(preemptible());
         /*
          * This is running in ioctl context so we can avoid
          * the call to vtime_account() with its unnecessary idle check.
          */
-        vtime_account_system_irqsafe(current);
+        vtime_account_system(current);
         current->flags |= PF_VCPU;
+}
+
+static inline void __guest_exit(void)
+{
+        /*
+         * This is running in ioctl context so we can avoid
+         * the call to vtime_account() with its unnecessary idle check.
+         */
+        vtime_account_system(current);
+        current->flags &= ~PF_VCPU;
+}
+
+#ifdef CONFIG_CONTEXT_TRACKING
+extern void guest_enter(void);
+extern void guest_exit(void);
+
+#else /* !CONFIG_CONTEXT_TRACKING */
+static inline void guest_enter(void)
+{
+        __guest_enter();
+}
+
+static inline void guest_exit(void)
+{
+        __guest_exit();
+}
+#endif /* !CONFIG_CONTEXT_TRACKING */
+
+static inline void kvm_guest_enter(void)
+{
+        unsigned long flags;
+
+        BUG_ON(preemptible());
+
+        local_irq_save(flags);
+        guest_enter();
+        local_irq_restore(flags);
+
         /* KVM does not hold any references to rcu protected data when it
          * switches CPU into a guest mode. In fact switching to a guest mode
          * is very similar to exiting to userspase from rcu point of view. In
@@ -761,12 +807,11 @@ static inline void kvm_guest_enter(void)
 
 static inline void kvm_guest_exit(void)
 {
-        /*
-         * This is running in ioctl context so we can avoid
-         * the call to vtime_account() with its unnecessary idle check.
-         */
-        vtime_account_system_irqsafe(current);
-        current->flags &= ~PF_VCPU;
+        unsigned long flags;
+
+        local_irq_save(flags);
+        guest_exit();
+        local_irq_restore(flags);
 }
 
 /*
diff --git a/include/linux/leds-lp5521.h b/include/linux/leds-lp5521.h
deleted file mode 100644
index 3f071ec019b2..000000000000
--- a/include/linux/leds-lp5521.h
+++ /dev/null
@@ -1,73 +0,0 @@
-/*
- * LP5521 LED chip driver.
- *
- * Copyright (C) 2010 Nokia Corporation
- *
- * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#ifndef __LINUX_LP5521_H
-#define __LINUX_LP5521_H
-
-/* See Documentation/leds/leds-lp5521.txt */
-
-struct lp5521_led_config {
-        char            *name;
-        u8              chan_nr;
-        u8              led_current; /* mA x10, 0 if led is not connected */
-        u8              max_current;
-};
-
-struct lp5521_led_pattern {
-        u8 *r;
-        u8 *g;
-        u8 *b;
-        u8 size_r;
-        u8 size_g;
-        u8 size_b;
-};
-
-#define LP5521_CLOCK_AUTO       0
-#define LP5521_CLOCK_INT        1
-#define LP5521_CLOCK_EXT        2
-
-/* Bits in CONFIG register */
-#define LP5521_PWM_HF                   0x40    /* PWM: 0 = 256Hz, 1 = 558Hz */
-#define LP5521_PWRSAVE_EN               0x20    /* 1 = Power save mode */
-#define LP5521_CP_MODE_OFF              0       /* Charge pump (CP) off */
-#define LP5521_CP_MODE_BYPASS           8       /* CP forced to bypass mode */
-#define LP5521_CP_MODE_1X5              0x10    /* CP forced to 1.5x mode */
-#define LP5521_CP_MODE_AUTO             0x18    /* Automatic mode selection */
-#define LP5521_R_TO_BATT                4       /* R out: 0 = CP, 1 = Vbat */
-#define LP5521_CLK_SRC_EXT              0       /* Ext-clk source (CLK_32K) */
-#define LP5521_CLK_INT                  1       /* Internal clock */
-#define LP5521_CLK_AUTO                 2       /* Automatic clock selection */
-
-struct lp5521_platform_data {
-        struct lp5521_led_config *led_config;
-        u8      num_channels;
-        u8      clock_mode;
-        int     (*setup_resources)(void);
-        void    (*release_resources)(void);
-        void    (*enable)(bool state);
-        const char *label;
-        u8      update_config;
-        struct lp5521_led_pattern *patterns;
-        int num_patterns;
-};
-
-#endif /* __LINUX_LP5521_H */
diff --git a/include/linux/leds-lp5523.h b/include/linux/leds-lp5523.h
deleted file mode 100644
index 727877fb406d..000000000000
--- a/include/linux/leds-lp5523.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * LP5523 LED Driver
- *
- * Copyright (C) 2010 Nokia Corporation
- *
- * Contact: Samu Onkalo <samu.p.onkalo@nokia.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- */
-
-#ifndef __LINUX_LP5523_H
-#define __LINUX_LP5523_H
-
-/* See Documentation/leds/leds-lp5523.txt */
-
-struct lp5523_led_config {
-        const char      *name;
-        u8              chan_nr;
-        u8              led_current; /* mA x10, 0 if led is not connected */
-        u8              max_current;
-};
-
-#define LP5523_CLOCK_AUTO       0
-#define LP5523_CLOCK_INT        1
-#define LP5523_CLOCK_EXT        2
-
-struct lp5523_platform_data {
-        struct lp5523_led_config *led_config;
-        u8      num_channels;
-        u8      clock_mode;
-        int     (*setup_resources)(void);
-        void    (*release_resources)(void);
-        void    (*enable)(bool state);
-        const   char *label;
-};
-
-#endif /* __LINUX_LP5523_H */
diff --git a/include/linux/leds_pwm.h b/include/linux/leds_pwm.h
index 33a071167489..a65e9646e4b1 100644
--- a/include/linux/leds_pwm.h
+++ b/include/linux/leds_pwm.h
@@ -7,7 +7,7 @@
 struct led_pwm {
         const char      *name;
         const char      *default_trigger;
-        unsigned        pwm_id;
+        unsigned        pwm_id __deprecated;
         u8              active_low;
         unsigned        max_brightness;
         unsigned        pwm_period_ns;
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 649e5f86b5f0..91c9d109e5f1 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -620,6 +620,9 @@ struct ata_device {
         union acpi_object       *gtf_cache;
         unsigned int            gtf_filter;
 #endif
+#ifdef CONFIG_SATA_ZPODD
+        void                    *zpodd;
+#endif
         struct device           tdev;
         /* n_sector is CLEAR_BEGIN, read comment above CLEAR_BEGIN */
         u64                     n_sectors;      /* size of device, if ATA */
diff --git a/include/linux/libps2.h b/include/linux/libps2.h
index 79603a6c356f..4ad06e824f76 100644
--- a/include/linux/libps2.h
+++ b/include/linux/libps2.h
@@ -36,7 +36,7 @@ struct ps2dev {
         wait_queue_head_t wait;
 
         unsigned long flags;
-        unsigned char cmdbuf[6];
+        unsigned char cmdbuf[8];
         unsigned char cmdcnt;
         unsigned char nak;
 };
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 2bca44b0893c..f1e877b79ed8 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -359,7 +359,9 @@ extern void lockdep_trace_alloc(gfp_t mask);
 
 #define lockdep_depth(tsk)      (debug_locks ? (tsk)->lockdep_depth : 0)
 
-#define lockdep_assert_held(l)  WARN_ON(debug_locks && !lockdep_is_held(l))
+#define lockdep_assert_held(l)  do {                            \
+                WARN_ON(debug_locks && !lockdep_is_held(l));    \
+        } while (0)
 
 #define lockdep_recursing(tsk)  ((tsk)->lockdep_recursion)
 
@@ -410,7 +412,7 @@ struct lock_class_key { };
 
 #define lockdep_depth(tsk)      (0)
 
-#define lockdep_assert_held(l)                  do { } while (0)
+#define lockdep_assert_held(l)                  do { (void)(l); } while (0)
 
 #define lockdep_recursing(tsk)                  (0)
 
diff --git a/include/linux/mailbox.h b/include/linux/mailbox.h
new file mode 100644
index 000000000000..5161f63ec1c8
--- /dev/null
+++ b/include/linux/mailbox.h
@@ -0,0 +1,17 @@
+/*
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+int pl320_ipc_transmit(u32 *data);
+int pl320_ipc_register_notifier(struct notifier_block *nb);
+int pl320_ipc_unregister_notifier(struct notifier_block *nb);
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index d452ee191066..3e5ecb2d790e 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -42,6 +42,7 @@ struct memblock {
 
 extern struct memblock memblock;
 extern int memblock_debug;
+extern struct movablemem_map movablemem_map;
 
 #define memblock_dbg(fmt, ...) \
         if (memblock_debug) printk(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
@@ -60,6 +61,7 @@ int memblock_reserve(phys_addr_t base, phys_addr_t size);
 void memblock_trim_memory(phys_addr_t align);
 
 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
+
 void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
                           unsigned long *out_end_pfn, int *out_nid);
 
@@ -155,6 +157,7 @@ phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align,
 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align,
                                   phys_addr_t max_addr);
 phys_addr_t memblock_phys_mem_size(void);
+phys_addr_t memblock_mem_size(unsigned long limit_pfn);
 phys_addr_t memblock_start_of_DRAM(void);
 phys_addr_t memblock_end_of_DRAM(void);
 void memblock_enforce_memory_limit(phys_addr_t memory_limit);
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 28bd5fa2ff2e..d6183f06d8c1 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -116,7 +116,6 @@ void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
  * For memory reclaim.
  */
 int mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec);
-int mem_cgroup_inactive_file_is_low(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);
@@ -321,12 +320,6 @@ mem_cgroup_inactive_anon_is_low(struct lruvec *lruvec)
         return 1;
 }
 
-static inline int
-mem_cgroup_inactive_file_is_low(struct lruvec *lruvec)
-{
-        return 1;
-}
-
 static inline unsigned long
 mem_cgroup_get_lru_size(struct lruvec *lruvec, enum lru_list lru)
 {
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 4a45c4e50025..b6a3be7d47bf 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -96,6 +96,7 @@ extern void __online_page_free(struct page *page);
 
 #ifdef CONFIG_MEMORY_HOTREMOVE
 extern bool is_pageblock_removable_nolock(struct page *page);
+extern int arch_remove_memory(u64 start, u64 size);
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
 /* reasonably generic interface to expand the physical pages in a zone  */
@@ -173,17 +174,16 @@ static inline void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
 #endif /* CONFIG_NUMA */
 #endif /* CONFIG_HAVE_ARCH_NODEDATA_EXTENSION */
 
-#ifdef CONFIG_SPARSEMEM_VMEMMAP
+#ifdef CONFIG_HAVE_BOOTMEM_INFO_NODE
+extern void register_page_bootmem_info_node(struct pglist_data *pgdat);
+#else
 static inline void register_page_bootmem_info_node(struct pglist_data *pgdat)
 {
 }
-static inline void put_page_bootmem(struct page *page)
-{
-}
-#else
-extern void register_page_bootmem_info_node(struct pglist_data *pgdat);
-extern void put_page_bootmem(struct page *page);
 #endif
+extern void put_page_bootmem(struct page *page);
+extern void get_page_bootmem(unsigned long ingo, struct page *page,
+                             unsigned long type);
 
 /*
  * Lock for memory hotplug guarantees 1) all callbacks for memory hotplug
@@ -233,6 +233,7 @@ static inline void unlock_memory_hotplug(void) {}
 #ifdef CONFIG_MEMORY_HOTREMOVE
 
 extern int is_mem_section_removable(unsigned long pfn, unsigned long nr_pages);
+extern void try_offline_node(int nid);
 
 #else
 static inline int is_mem_section_removable(unsigned long pfn,
@@ -240,6 +241,8 @@ static inline int is_mem_section_removable(unsigned long pfn,
 {
         return 0;
 }
+
+static inline void try_offline_node(int nid) {}
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
 extern int mem_online_node(int nid);
@@ -247,7 +250,8 @@ extern int add_memory(int nid, u64 start, u64 size);
 extern int arch_add_memory(int nid, u64 start, u64 size);
 extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
 extern int offline_memory_block(struct memory_block *mem);
-extern int remove_memory(u64 start, u64 size);
+extern bool is_memblock_offlined(struct memory_block *mem);
+extern int remove_memory(int nid, u64 start, u64 size);
 extern int sparse_add_one_section(struct zone *zone, unsigned long start_pfn,
                                                                 int nr_pages);
 extern void sparse_remove_one_section(struct zone *zone, struct mem_section *ms);
diff --git a/include/linux/mfd/88pm80x.h b/include/linux/mfd/88pm80x.h
index 478672ed0c3d..e94537befabd 100644
--- a/include/linux/mfd/88pm80x.h
+++ b/include/linux/mfd/88pm80x.h
@@ -365,5 +365,5 @@ static inline int pm80x_dev_resume(struct device *dev)
 
 extern int pm80x_init(struct i2c_client *client,
                       const struct i2c_device_id *id);
-extern int pm80x_deinit(struct i2c_client *client);
+extern int pm80x_deinit(void);
 #endif /* __LINUX_MFD_88PM80X_H */
diff --git a/include/linux/mfd/abx500.h b/include/linux/mfd/abx500.h
index e53dcfeaee69..9ead60bc66b7 100644
--- a/include/linux/mfd/abx500.h
+++ b/include/linux/mfd/abx500.h
@@ -131,7 +131,7 @@ struct abx500_maxim_parameters {
  * @nominal_voltage:            Nominal voltage of the battery in mV
  * @termination_vol:            max voltage upto which battery can be charged
  * @termination_curr            battery charging termination current in mA
- * @recharge_vol                battery voltage limit that will trigger a new
+ * @recharge_cap                battery capacity limit that will trigger a new
  *                              full charging cycle in the case where maintenan-
  *                              -ce charging has been disabled
  * @normal_cur_lvl:             charger current in normal state in mA
@@ -160,7 +160,7 @@ struct abx500_battery_type {
         int nominal_voltage;
         int termination_vol;
         int termination_curr;
-        int recharge_vol;
+        int recharge_cap;
         int normal_cur_lvl;
         int normal_vol_lvl;
         int maint_a_cur_lvl;
@@ -224,6 +224,7 @@ struct abx500_bm_charger_parameters {
  * @bkup_bat_v          voltage which we charge the backup battery with
  * @bkup_bat_i          current which we charge the backup battery with
  * @no_maintenance      indicates that maintenance charging is disabled
+ * @capacity_scaling    indicates whether capacity scaling is to be used
  * @abx500_adc_therm    placement of thermistor, batctrl or battemp adc
  * @chg_unknown_bat     flag to enable charging of unknown batteries
  * @enable_overshoot    flag to enable VBAT overshoot control
@@ -253,7 +254,11 @@ struct abx500_bm_data {
         int usb_safety_tmr_h;
         int bkup_bat_v;
         int bkup_bat_i;
+        bool autopower_cfg;
+        bool ac_enabled;
+        bool usb_enabled;
         bool no_maintenance;
+        bool capacity_scaling;
         bool chg_unknown_bat;
         bool enable_overshoot;
         bool auto_trig;
@@ -277,9 +282,9 @@ enum {
         NTC_INTERNAL,
 };
 
-int bmdevs_of_probe(struct device *dev,
-                struct device_node *np,
-                struct abx500_bm_data **battery);
+int ab8500_bm_of_probe(struct device *dev,
+                       struct device_node *np,
+                       struct abx500_bm_data *bm);
 
 int abx500_set_register_interruptible(struct device *dev, u8 bank, u8 reg,
         u8 value);
@@ -306,6 +311,7 @@ int abx500_mask_and_set_register_interruptible(struct device *dev, u8 bank,
 int abx500_get_chip_id(struct device *dev);
 int abx500_event_registers_startup_state_get(struct device *dev, u8 *event);
 int abx500_startup_irq_enabled(struct device *dev, unsigned int irq);
+void abx500_dump_all_banks(void);
 
 struct abx500_ops {
         int (*get_chip_id) (struct device *);
@@ -316,6 +322,7 @@ struct abx500_ops {
         int (*mask_and_set_register) (struct device *, u8, u8, u8, u8);
         int (*event_registers_startup_state_get) (struct device *, u8 *);
         int (*startup_irq_enabled) (struct device *, unsigned int);
+        void (*dump_all_banks) (struct device *);
 };
 
 int abx500_register_ops(struct device *core_dev, struct abx500_ops *ops);
diff --git a/include/linux/mfd/abx500/ab8500-bm.h b/include/linux/mfd/abx500/ab8500-bm.h
index 9bd037df97d9..8d35bfe164c8 100644
--- a/include/linux/mfd/abx500/ab8500-bm.h
+++ b/include/linux/mfd/abx500/ab8500-bm.h
@@ -23,6 +23,7 @@
  * Bank : 0x5
  */
 #define AB8500_USB_LINE_STAT_REG        0x80
+#define AB8500_USB_LINK1_STAT_REG       0x94
 
 /*
  * Charger / status register offfsets
@@ -225,6 +226,8 @@
 /* BatCtrl Current Source Constants */
 #define BAT_CTRL_7U_ENA                 0x01
 #define BAT_CTRL_20U_ENA                0x02
+#define BAT_CTRL_18U_ENA                0x01
+#define BAT_CTRL_16U_ENA                0x02
 #define BAT_CTRL_CMP_ENA                0x04
 #define FORCE_BAT_CTRL_CMP_HIGH         0x08
 #define BAT_CTRL_PULL_UP_ENA            0x10
@@ -355,6 +358,7 @@ struct ab8500_bm_charger_parameters {
  * @bkup_bat_v          voltage which we charge the backup battery with
  * @bkup_bat_i          current which we charge the backup battery with
  * @no_maintenance      indicates that maintenance charging is disabled
+ * @capacity_scaling    indicates whether capacity scaling is to be used
  * @adc_therm           placement of thermistor, batctrl or battemp adc
  * @chg_unknown_bat     flag to enable charging of unknown batteries
  * @enable_overshoot    flag to enable VBAT overshoot control
@@ -383,6 +387,7 @@ struct ab8500_bm_data {
         int bkup_bat_v;
         int bkup_bat_i;
         bool no_maintenance;
+        bool capacity_scaling;
         bool chg_unknown_bat;
         bool enable_overshoot;
         enum abx500_adc_therm adc_therm;
@@ -399,26 +404,6 @@ struct ab8500_bm_data {
         const struct ab8500_fg_parameters *fg_params;
 };
 
-struct ab8500_charger_platform_data {
-        char **supplied_to;
-        size_t num_supplicants;
-        bool autopower_cfg;
-};
-
-struct ab8500_btemp_platform_data {
-        char **supplied_to;
-        size_t num_supplicants;
-};
-
-struct ab8500_fg_platform_data {
-        char **supplied_to;
-        size_t num_supplicants;
-};
-
-struct ab8500_chargalg_platform_data {
-        char **supplied_to;
-        size_t num_supplicants;
-};
 struct ab8500_btemp;
 struct ab8500_gpadc;
 struct ab8500_fg;
@@ -434,20 +419,10 @@ struct ab8500_fg *ab8500_fg_get(void);
 int ab8500_fg_inst_curr_blocking(struct ab8500_fg *dev);
 int ab8500_fg_inst_curr_start(struct ab8500_fg *di);
 int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *res);
+int ab8500_fg_inst_curr_started(struct ab8500_fg *di);
 int ab8500_fg_inst_curr_done(struct ab8500_fg *di);
 
 #else
 static struct abx500_bm_data ab8500_bm_data;
-
-static inline int ab8500_fg_inst_curr_start(struct ab8500_fg *di)
-{
-        return -ENODEV;
-}
-
-static inline int ab8500_fg_inst_curr_finalize(struct ab8500_fg *di, int *res)
-{
-        return -ENODEV;
-}
-
 #endif
 #endif /* _AB8500_BM_H */
diff --git a/include/linux/mfd/abx500/ab8500-gpio.h b/include/linux/mfd/abx500/ab8500-gpio.h
index 2387c207ea86..172b2f201ae0 100644
--- a/include/linux/mfd/abx500/ab8500-gpio.h
+++ b/include/linux/mfd/abx500/ab8500-gpio.h
@@ -14,10 +14,20 @@
  * registers.
  */
 
-struct ab8500_gpio_platform_data {
+struct abx500_gpio_platform_data {
         int gpio_base;
-        u32 irq_base;
-        u8  config_reg[8];
+};
+
+enum abx500_gpio_pull_updown {
+        ABX500_GPIO_PULL_DOWN = 0x0,
+        ABX500_GPIO_PULL_NONE = 0x1,
+        ABX500_GPIO_PULL_UP = 0x3,
+};
+
+enum abx500_gpio_vinsel {
+        ABX500_GPIO_VINSEL_VBAT = 0x0,
+        ABX500_GPIO_VINSEL_VIN_1V8 = 0x1,
+        ABX500_GPIO_VINSEL_VDD_BIF = 0x2,
 };
 
 #endif /* _AB8500_GPIO_H */
diff --git a/include/linux/mfd/abx500/ab8500-sysctrl.h b/include/linux/mfd/abx500/ab8500-sysctrl.h
index 10eb50973c39..ebf12e793db9 100644
--- a/include/linux/mfd/abx500/ab8500-sysctrl.h
+++ b/include/linux/mfd/abx500/ab8500-sysctrl.h
@@ -37,6 +37,11 @@ static inline int ab8500_sysctrl_clear(u16 reg, u8 bits)
         return ab8500_sysctrl_write(reg, bits, 0);
 }
 
+/* Configuration data for SysClkReq1RfClkBuf - SysClkReq8RfClkBuf */
+struct ab8500_sysctrl_platform_data {
+        u8 initial_req_buf_config[8];
+};
+
 /* Registers */
 #define AB8500_TURNONSTATUS             0x100
 #define AB8500_RESETSTATUS              0x101
diff --git a/include/linux/mfd/abx500/ab8500.h b/include/linux/mfd/abx500/ab8500.h
index 1cb5698b4d76..9db0bda446a0 100644
--- a/include/linux/mfd/abx500/ab8500.h
+++ b/include/linux/mfd/abx500/ab8500.h
@@ -24,7 +24,7 @@ enum ab8500_version {
         AB8500_VERSION_AB8500 = 0x0,
         AB8500_VERSION_AB8505 = 0x1,
         AB8500_VERSION_AB9540 = 0x2,
-        AB8500_VERSION_AB8540 = 0x3,
+        AB8500_VERSION_AB8540 = 0x4,
         AB8500_VERSION_UNDEFINED,
 };
 
@@ -32,6 +32,7 @@ enum ab8500_version {
 #define AB8500_CUTEARLY 0x00
 #define AB8500_CUT1P0   0x10
 #define AB8500_CUT1P1   0x11
+#define AB8500_CUT1P2   0x12 /* Only valid for AB8540 */
 #define AB8500_CUT2P0   0x20
 #define AB8500_CUT3P0   0x30
 #define AB8500_CUT3P3   0x33
@@ -39,6 +40,7 @@ enum ab8500_version {
 /*
  * AB8500 bank addresses
  */
+#define AB8500_M_FSM_RANK       0x0
 #define AB8500_SYS_CTRL1_BLOCK  0x1
 #define AB8500_SYS_CTRL2_BLOCK  0x2
 #define AB8500_REGU_CTRL1       0x3
@@ -58,6 +60,7 @@ enum ab8500_version {
 #define AB8500_DEVELOPMENT      0x11
 #define AB8500_DEBUG            0x12
 #define AB8500_PROD_TEST        0x13
+#define AB8500_STE_TEST         0x14
 #define AB8500_OTP_EMUL         0x15
 
 /*
@@ -65,11 +68,11 @@ enum ab8500_version {
  * Values used to index into array ab8500_irq_regoffset[] defined in
  * drivers/mdf/ab8500-core.c
  */
-/* Definitions for AB8500 and AB9540 */
+/* Definitions for AB8500, AB9540 and AB8540 */
 /* ab8500_irq_regoffset[0] -> IT[Source|Latch|Mask]1 */
 #define AB8500_INT_MAIN_EXT_CH_NOT_OK   0 /* not 8505/9540 */
-#define AB8500_INT_UN_PLUG_TV_DET       1 /* not 8505/9540 */
-#define AB8500_INT_PLUG_TV_DET          2 /* not 8505/9540 */
+#define AB8500_INT_UN_PLUG_TV_DET       1 /* not 8505/9540/8540 */
+#define AB8500_INT_PLUG_TV_DET          2 /* not 8505/9540/8540 */
 #define AB8500_INT_TEMP_WARM            3
 #define AB8500_INT_PON_KEY2DB_F         4
 #define AB8500_INT_PON_KEY2DB_R         5
@@ -77,18 +80,19 @@ enum ab8500_version {
 #define AB8500_INT_PON_KEY1DB_R         7
 /* ab8500_irq_regoffset[1] -> IT[Source|Latch|Mask]2 */
 #define AB8500_INT_BATT_OVV             8
-#define AB8500_INT_MAIN_CH_UNPLUG_DET   10 /* not 8505 */
-#define AB8500_INT_MAIN_CH_PLUG_DET     11 /* not 8505 */
+#define AB8500_INT_MAIN_CH_UNPLUG_DET   10 /* not 8505/8540 */
+#define AB8500_INT_MAIN_CH_PLUG_DET     11 /* not 8505/8540 */
 #define AB8500_INT_VBUS_DET_F           14
 #define AB8500_INT_VBUS_DET_R           15
 /* ab8500_irq_regoffset[2] -> IT[Source|Latch|Mask]3 */
 #define AB8500_INT_VBUS_CH_DROP_END     16
 #define AB8500_INT_RTC_60S              17
 #define AB8500_INT_RTC_ALARM            18
+#define AB8540_INT_BIF_INT              19
 #define AB8500_INT_BAT_CTRL_INDB        20
 #define AB8500_INT_CH_WD_EXP            21
 #define AB8500_INT_VBUS_OVV             22
-#define AB8500_INT_MAIN_CH_DROP_END     23 /* not 8505/9540 */
+#define AB8500_INT_MAIN_CH_DROP_END     23 /* not 8505/9540/8540 */
 /* ab8500_irq_regoffset[3] -> IT[Source|Latch|Mask]4 */
 #define AB8500_INT_CCN_CONV_ACC         24
 #define AB8500_INT_INT_AUD              25
@@ -99,7 +103,7 @@ enum ab8500_version {
 #define AB8500_INT_BUP_CHG_NOT_OK       30
 #define AB8500_INT_BUP_CHG_OK           31
 /* ab8500_irq_regoffset[4] -> IT[Source|Latch|Mask]5 */
-#define AB8500_INT_GP_HW_ADC_CONV_END   32 /* not 8505 */
+#define AB8500_INT_GP_HW_ADC_CONV_END   32 /* not 8505/8540 */
 #define AB8500_INT_ACC_DETECT_1DB_F     33
 #define AB8500_INT_ACC_DETECT_1DB_R     34
 #define AB8500_INT_ACC_DETECT_22DB_F    35
@@ -108,23 +112,23 @@ enum ab8500_version {
 #define AB8500_INT_ACC_DETECT_21DB_R    38
 #define AB8500_INT_GP_SW_ADC_CONV_END   39
 /* ab8500_irq_regoffset[5] -> IT[Source|Latch|Mask]7 */
-#define AB8500_INT_GPIO6R               40 /* not 8505/9540 */
-#define AB8500_INT_GPIO7R               41 /* not 8505/9540 */
-#define AB8500_INT_GPIO8R               42 /* not 8505/9540 */
-#define AB8500_INT_GPIO9R               43 /* not 8505/9540 */
-#define AB8500_INT_GPIO10R              44
-#define AB8500_INT_GPIO11R              45
-#define AB8500_INT_GPIO12R              46 /* not 8505 */
-#define AB8500_INT_GPIO13R              47
+#define AB8500_INT_GPIO6R               40 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO7R               41 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO8R               42 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO9R               43 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO10R              44 /* not 8540 */
+#define AB8500_INT_GPIO11R              45 /* not 8540 */
+#define AB8500_INT_GPIO12R              46 /* not 8505/8540 */
+#define AB8500_INT_GPIO13R              47 /* not 8540 */
 /* ab8500_irq_regoffset[6] -> IT[Source|Latch|Mask]8 */
-#define AB8500_INT_GPIO24R              48 /* not 8505 */
-#define AB8500_INT_GPIO25R              49 /* not 8505 */
-#define AB8500_INT_GPIO36R              50 /* not 8505/9540 */
-#define AB8500_INT_GPIO37R              51 /* not 8505/9540 */
-#define AB8500_INT_GPIO38R              52 /* not 8505/9540 */
-#define AB8500_INT_GPIO39R              53 /* not 8505/9540 */
-#define AB8500_INT_GPIO40R              54
-#define AB8500_INT_GPIO41R              55
+#define AB8500_INT_GPIO24R              48 /* not 8505/8540 */
+#define AB8500_INT_GPIO25R              49 /* not 8505/8540 */
+#define AB8500_INT_GPIO36R              50 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO37R              51 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO38R              52 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO39R              53 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO40R              54 /* not 8540 */
+#define AB8500_INT_GPIO41R              55 /* not 8540 */
 /* ab8500_irq_regoffset[7] -> IT[Source|Latch|Mask]9 */
 #define AB8500_INT_GPIO6F               56 /* not 8505/9540 */
 #define AB8500_INT_GPIO7F               57 /* not 8505/9540 */
@@ -135,14 +139,14 @@ enum ab8500_version {
 #define AB8500_INT_GPIO12F              62 /* not 8505 */
 #define AB8500_INT_GPIO13F              63
 /* ab8500_irq_regoffset[8] -> IT[Source|Latch|Mask]10 */
-#define AB8500_INT_GPIO24F              64 /* not 8505 */
-#define AB8500_INT_GPIO25F              65 /* not 8505 */
-#define AB8500_INT_GPIO36F              66 /* not 8505/9540 */
-#define AB8500_INT_GPIO37F              67 /* not 8505/9540 */
-#define AB8500_INT_GPIO38F              68 /* not 8505/9540 */
-#define AB8500_INT_GPIO39F              69 /* not 8505/9540 */
-#define AB8500_INT_GPIO40F              70
-#define AB8500_INT_GPIO41F              71
+#define AB8500_INT_GPIO24F              64 /* not 8505/8540 */
+#define AB8500_INT_GPIO25F              65 /* not 8505/8540 */
+#define AB8500_INT_GPIO36F              66 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO37F              67 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO38F              68 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO39F              69 /* not 8505/9540/8540 */
+#define AB8500_INT_GPIO40F              70 /* not 8540 */
+#define AB8500_INT_GPIO41F              71 /* not 8540 */
 /* ab8500_irq_regoffset[9] -> IT[Source|Latch|Mask]12 */
 #define AB8500_INT_ADP_SOURCE_ERROR     72
 #define AB8500_INT_ADP_SINK_ERROR       73
@@ -160,42 +164,44 @@ enum ab8500_version {
 #define AB8500_INT_SRP_DETECT           88
 #define AB8500_INT_USB_CHARGER_NOT_OKR  89
 #define AB8500_INT_ID_WAKEUP_R          90
+#define AB8500_INT_ID_DET_PLUGR         91 /* 8505/9540 cut2.0 */
 #define AB8500_INT_ID_DET_R1R           92
 #define AB8500_INT_ID_DET_R2R           93
 #define AB8500_INT_ID_DET_R3R           94
 #define AB8500_INT_ID_DET_R4R           95
 /* ab8500_irq_regoffset[12] -> IT[Source|Latch|Mask]21 */
-#define AB8500_INT_ID_WAKEUP_F          96
-#define AB8500_INT_ID_DET_R1F           98
-#define AB8500_INT_ID_DET_R2F           99
-#define AB8500_INT_ID_DET_R3F           100
-#define AB8500_INT_ID_DET_R4F           101
-#define AB8500_INT_CHAUTORESTARTAFTSEC  102
+#define AB8500_INT_ID_WAKEUP_F          96 /* not 8505/9540 */
+#define AB8500_INT_ID_DET_PLUGF         97 /* 8505/9540 cut2.0 */
+#define AB8500_INT_ID_DET_R1F           98 /* not 8505/9540 */
+#define AB8500_INT_ID_DET_R2F           99 /* not 8505/9540 */
+#define AB8500_INT_ID_DET_R3F           100 /* not 8505/9540 */
+#define AB8500_INT_ID_DET_R4F           101 /* not 8505/9540 */
+#define AB8500_INT_CHAUTORESTARTAFTSEC  102 /* not 8505/9540 */
 #define AB8500_INT_CHSTOPBYSEC          103
 /* ab8500_irq_regoffset[13] -> IT[Source|Latch|Mask]22 */
 #define AB8500_INT_USB_CH_TH_PROT_F     104
-#define AB8500_INT_USB_CH_TH_PROT_R    105
+#define AB8500_INT_USB_CH_TH_PROT_R     105
 #define AB8500_INT_MAIN_CH_TH_PROT_F    106 /* not 8505/9540 */
 #define AB8500_INT_MAIN_CH_TH_PROT_R    107 /* not 8505/9540 */
 #define AB8500_INT_CHCURLIMNOHSCHIRP    109
 #define AB8500_INT_CHCURLIMHSCHIRP      110
 #define AB8500_INT_XTAL32K_KO           111
 
-/* Definitions for AB9540 */
+/* Definitions for AB9540 / AB8505 */
 /* ab8500_irq_regoffset[14] -> IT[Source|Latch|Mask]13 */
-#define AB9540_INT_GPIO50R              113
-#define AB9540_INT_GPIO51R              114 /* not 8505 */
-#define AB9540_INT_GPIO52R              115
-#define AB9540_INT_GPIO53R              116
-#define AB9540_INT_GPIO54R              117 /* not 8505 */
+#define AB9540_INT_GPIO50R              113 /* not 8540 */
+#define AB9540_INT_GPIO51R              114 /* not 8505/8540 */
+#define AB9540_INT_GPIO52R              115 /* not 8540 */
+#define AB9540_INT_GPIO53R              116 /* not 8540 */
+#define AB9540_INT_GPIO54R              117 /* not 8505/8540 */
 #define AB9540_INT_IEXT_CH_RF_BFN_R     118
-#define AB9540_INT_IEXT_CH_RF_BFN_F     119
 /* ab8500_irq_regoffset[15] -> IT[Source|Latch|Mask]14 */
-#define AB9540_INT_GPIO50F              121
-#define AB9540_INT_GPIO51F              122 /* not 8505 */
-#define AB9540_INT_GPIO52F              123
-#define AB9540_INT_GPIO53F              124
-#define AB9540_INT_GPIO54F              125 /* not 8505 */
+#define AB9540_INT_GPIO50F              121 /* not 8540 */
+#define AB9540_INT_GPIO51F              122 /* not 8505/8540 */
+#define AB9540_INT_GPIO52F              123 /* not 8540 */
+#define AB9540_INT_GPIO53F              124 /* not 8540 */
+#define AB9540_INT_GPIO54F              125 /* not 8505/8540 */
+#define AB9540_INT_IEXT_CH_RF_BFN_F     126
 /* ab8500_irq_regoffset[16] -> IT[Source|Latch|Mask]25 */
 #define AB8505_INT_KEYSTUCK             128
 #define AB8505_INT_IKR                  129
@@ -204,6 +210,87 @@ enum ab8500_version {
 #define AB8505_INT_KEYDEGLITCH          132
 #define AB8505_INT_MODPWRSTATUSF        134
 #define AB8505_INT_MODPWRSTATUSR        135
+/* ab8500_irq_regoffset[17] -> IT[Source|Latch|Mask]6 */
+#define AB8500_INT_HOOK_DET_NEG_F       138
+#define AB8500_INT_HOOK_DET_NEG_R       139
+#define AB8500_INT_HOOK_DET_POS_F       140
+#define AB8500_INT_HOOK_DET_POS_R       141
+#define AB8500_INT_PLUG_DET_COMP_F      142
+#define AB8500_INT_PLUG_DET_COMP_R      143
+/* ab8500_irq_regoffset[18] -> IT[Source|Latch|Mask]23 */
+#define AB8505_INT_COLL                 144
+#define AB8505_INT_RESERR               145
+#define AB8505_INT_FRAERR               146
+#define AB8505_INT_COMERR               147
+#define AB8505_INT_SPDSET               148
+#define AB8505_INT_DSENT                149
+#define AB8505_INT_DREC                 150
+#define AB8505_INT_ACC_INT              151
+/* ab8500_irq_regoffset[19] -> IT[Source|Latch|Mask]24 */
+#define AB8505_INT_NOPINT               152
+/* ab8540_irq_regoffset[20] -> IT[Source|Latch|Mask]26 */
+#define AB8540_INT_IDPLUGDETCOMPF       160
+#define AB8540_INT_IDPLUGDETCOMPR       161
+#define AB8540_INT_FMDETCOMPLOF         162
+#define AB8540_INT_FMDETCOMPLOR         163
+#define AB8540_INT_FMDETCOMPHIF         164
+#define AB8540_INT_FMDETCOMPHIR         165
+#define AB8540_INT_ID5VDETCOMPF         166
+#define AB8540_INT_ID5VDETCOMPR         167
+/* ab8540_irq_regoffset[21] -> IT[Source|Latch|Mask]27 */
+#define AB8540_INT_GPIO43F              168
+#define AB8540_INT_GPIO43R              169
+#define AB8540_INT_GPIO44F              170
+#define AB8540_INT_GPIO44R              171
+#define AB8540_INT_KEYPOSDETCOMPF       172
+#define AB8540_INT_KEYPOSDETCOMPR       173
+#define AB8540_INT_KEYNEGDETCOMPF       174
+#define AB8540_INT_KEYNEGDETCOMPR       175
+/* ab8540_irq_regoffset[22] -> IT[Source|Latch|Mask]28 */
+#define AB8540_INT_GPIO1VBATF           176
+#define AB8540_INT_GPIO1VBATR           177
+#define AB8540_INT_GPIO2VBATF           178
+#define AB8540_INT_GPIO2VBATR           179
+#define AB8540_INT_GPIO3VBATF           180
+#define AB8540_INT_GPIO3VBATR           181
+#define AB8540_INT_GPIO4VBATF           182
+#define AB8540_INT_GPIO4VBATR           183
+/* ab8540_irq_regoffset[23] -> IT[Source|Latch|Mask]29 */
+#define AB8540_INT_SYSCLKREQ2F          184
+#define AB8540_INT_SYSCLKREQ2R          185
+#define AB8540_INT_SYSCLKREQ3F          186
+#define AB8540_INT_SYSCLKREQ3R          187
+#define AB8540_INT_SYSCLKREQ4F          188
+#define AB8540_INT_SYSCLKREQ4R          189
+#define AB8540_INT_SYSCLKREQ5F          190
+#define AB8540_INT_SYSCLKREQ5R          191
+/* ab8540_irq_regoffset[24] -> IT[Source|Latch|Mask]30 */
+#define AB8540_INT_PWMOUT1F             192
+#define AB8540_INT_PWMOUT1R             193
+#define AB8540_INT_PWMCTRL0F            194
+#define AB8540_INT_PWMCTRL0R            195
+#define AB8540_INT_PWMCTRL1F            196
+#define AB8540_INT_PWMCTRL1R            197
+#define AB8540_INT_SYSCLKREQ6F          198
+#define AB8540_INT_SYSCLKREQ6R          199
+/* ab8540_irq_regoffset[25] -> IT[Source|Latch|Mask]31 */
+#define AB8540_INT_PWMEXTVIBRA1F        200
+#define AB8540_INT_PWMEXTVIBRA1R        201
+#define AB8540_INT_PWMEXTVIBRA2F        202
+#define AB8540_INT_PWMEXTVIBRA2R        203
+#define AB8540_INT_PWMOUT2F             204
+#define AB8540_INT_PWMOUT2R             205
+#define AB8540_INT_PWMOUT3F             206
+#define AB8540_INT_PWMOUT3R             207
+/* ab8540_irq_regoffset[26] -> IT[Source|Latch|Mask]32 */
+#define AB8540_INT_ADDATA2F             208
+#define AB8540_INT_ADDATA2R             209
+#define AB8540_INT_DADATA2F             210
+#define AB8540_INT_DADATA2R             211
+#define AB8540_INT_FSYNC2F              212
+#define AB8540_INT_FSYNC2R              213
+#define AB8540_INT_BITCLK2F             214
+#define AB8540_INT_BITCLK2R             215
 
 /*
  * AB8500_AB9540_NR_IRQS is used when configuring the IRQ numbers for the
@@ -213,13 +300,24 @@ enum ab8500_version {
  * which is larger.
  */
 #define AB8500_NR_IRQS                  112
-#define AB8505_NR_IRQS                  136
-#define AB9540_NR_IRQS                  136
+#define AB8505_NR_IRQS                  153
+#define AB9540_NR_IRQS                  153
+#define AB8540_NR_IRQS                  216
 /* This is set to the roof of any AB8500 chip variant IRQ counts */
-#define AB8500_MAX_NR_IRQS              AB9540_NR_IRQS
+#define AB8500_MAX_NR_IRQS              AB8540_NR_IRQS
 
 #define AB8500_NUM_IRQ_REGS             14
-#define AB9540_NUM_IRQ_REGS             17
+#define AB9540_NUM_IRQ_REGS             20
+#define AB8540_NUM_IRQ_REGS             27
+
+/* Turn On Status Event */
+#define AB8500_POR_ON_VBAT              0x01
+#define AB8500_POW_KEY_1_ON             0x02
+#define AB8500_POW_KEY_2_ON             0x04
+#define AB8500_RTC_ALARM                0x08
+#define AB8500_MAIN_CH_DET              0x10
+#define AB8500_VBUS_DET                 0x20
+#define AB8500_USB_ID_DET               0x40
 
 /**
  * struct ab8500 - ab8500 internal structure
@@ -270,10 +368,12 @@ struct regulator_reg_init;
 struct regulator_init_data;
 struct ab8500_gpio_platform_data;
 struct ab8500_codec_platform_data;
+struct ab8500_sysctrl_platform_data;
 
 /**
  * struct ab8500_platform_data - AB8500 platform data
  * @irq_base: start of AB8500 IRQs, AB8500_NR_IRQS will be used
+ * @pm_power_off: Should machine pm power off hook be registered or not
  * @init: board-specific initialization after detection of ab8500
  * @num_regulator_reg_init: number of regulator init registers
  * @regulator_reg_init: regulator init registers
@@ -282,13 +382,15 @@ struct ab8500_codec_platform_data;
  */
 struct ab8500_platform_data {
         int irq_base;
+        bool pm_power_off;
         void (*init) (struct ab8500 *);
         int num_regulator_reg_init;
         struct ab8500_regulator_reg_init *regulator_reg_init;
         int num_regulator;
         struct regulator_init_data *regulator;
-        struct ab8500_gpio_platform_data *gpio;
+        struct abx500_gpio_platform_data *gpio;
         struct ab8500_codec_platform_data *codec;
+        struct ab8500_sysctrl_platform_data *sysctrl;
 };
 
 extern int ab8500_init(struct ab8500 *ab8500,
@@ -335,10 +437,87 @@ static inline int is_ab8500_2p0_or_earlier(struct ab8500 *ab)
         return (is_ab8500(ab) && (ab->chip_id <= AB8500_CUT2P0));
 }
 
+static inline int is_ab8500_3p3_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab8500(ab) && (ab->chip_id <= AB8500_CUT3P3));
+}
+
 /* exclude also ab8505, ab9540... */
 static inline int is_ab8500_2p0(struct ab8500 *ab)
 {
         return (is_ab8500(ab) && (ab->chip_id == AB8500_CUT2P0));
 }
 
+static inline int is_ab8505_1p0_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab8505(ab) && (ab->chip_id <= AB8500_CUT1P0));
+}
+
+static inline int is_ab8505_2p0(struct ab8500 *ab)
+{
+        return (is_ab8505(ab) && (ab->chip_id == AB8500_CUT2P0));
+}
+
+static inline int is_ab9540_1p0_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab9540(ab) && (ab->chip_id <= AB8500_CUT1P0));
+}
+
+static inline int is_ab9540_2p0(struct ab8500 *ab)
+{
+        return (is_ab9540(ab) && (ab->chip_id == AB8500_CUT2P0));
+}
+
+/*
+ * Be careful, the marketing name for this chip is 2.1
+ * but the value read from the chip is 3.0 (0x30)
+ */
+static inline int is_ab9540_3p0(struct ab8500 *ab)
+{
+        return (is_ab9540(ab) && (ab->chip_id == AB8500_CUT3P0));
+}
+
+static inline int is_ab8540_1p0_or_earlier(struct ab8500 *ab)
+{
+        return is_ab8540(ab) && (ab->chip_id <= AB8500_CUT1P0);
+}
+
+static inline int is_ab8540_1p1_or_earlier(struct ab8500 *ab)
+{
+        return is_ab8540(ab) && (ab->chip_id <= AB8500_CUT1P1);
+}
+
+static inline int is_ab8540_1p2_or_earlier(struct ab8500 *ab)
+{
+        return is_ab8540(ab) && (ab->chip_id <= AB8500_CUT1P2);
+}
+
+static inline int is_ab8540_2p0_or_earlier(struct ab8500 *ab)
+{
+        return is_ab8540(ab) && (ab->chip_id <= AB8500_CUT2P0);
+}
+
+static inline int is_ab8540_2p0(struct ab8500 *ab)
+{
+        return is_ab8540(ab) && (ab->chip_id == AB8500_CUT2P0);
+}
+
+static inline int is_ab8505_2p0_earlier(struct ab8500 *ab)
+{
+        return (is_ab8505(ab) && (ab->chip_id < AB8500_CUT2P0));
+}
+
+static inline int is_ab9540_2p0_or_earlier(struct ab8500 *ab)
+{
+        return (is_ab9540(ab) && (ab->chip_id < AB8500_CUT2P0));
+}
+
+#ifdef CONFIG_AB8500_DEBUG
+void ab8500_dump_all_banks(struct device *dev);
+void ab8500_debug_register_interrupt(int line);
+#else
+static inline void ab8500_dump_all_banks(struct device *dev) {}
+static inline void ab8500_debug_register_interrupt(int line) {}
+#endif
+
 #endif /* MFD_AB8500_H */
diff --git a/include/linux/mfd/abx500/ux500_chargalg.h b/include/linux/mfd/abx500/ux500_chargalg.h
index 9b07725750c9..d43ac0f35526 100644
--- a/include/linux/mfd/abx500/ux500_chargalg.h
+++ b/include/linux/mfd/abx500/ux500_chargalg.h
@@ -27,12 +27,17 @@ struct ux500_charger_ops {
  * @ops                 ux500 charger operations
  * @max_out_volt        maximum output charger voltage in mV
  * @max_out_curr        maximum output charger current in mA
+ * @enabled             indicates if this charger is used or not
+ * @external            external charger unit (pm2xxx)
  */
 struct ux500_charger {
         struct power_supply psy;
         struct ux500_charger_ops ops;
         int max_out_volt;
         int max_out_curr;
+        int wdt_refresh;
+        bool enabled;
+        bool external;
 };
 
 #endif
diff --git a/include/linux/mfd/arizona/core.h b/include/linux/mfd/arizona/core.h
index a580363a7d29..a710255528d7 100644
--- a/include/linux/mfd/arizona/core.h
+++ b/include/linux/mfd/arizona/core.h
@@ -75,8 +75,10 @@ enum arizona_type {
 #define ARIZONA_IRQ_DCS_HP_DONE           47
 #define ARIZONA_IRQ_FLL2_CLOCK_OK         48
 #define ARIZONA_IRQ_FLL1_CLOCK_OK         49
+#define ARIZONA_IRQ_MICD_CLAMP_RISE       50
+#define ARIZONA_IRQ_MICD_CLAMP_FALL       51
 
-#define ARIZONA_NUM_IRQ                   50
+#define ARIZONA_NUM_IRQ                   52
 
 struct snd_soc_dapm_context;
 
diff --git a/include/linux/mfd/arizona/pdata.h b/include/linux/mfd/arizona/pdata.h
index 8b1d1daaae16..455c51d22d6b 100644
--- a/include/linux/mfd/arizona/pdata.h
+++ b/include/linux/mfd/arizona/pdata.h
@@ -56,12 +56,16 @@
 #define ARIZONA_DMIC_MICBIAS2 2
 #define ARIZONA_DMIC_MICBIAS3 3
 
+#define ARIZONA_MAX_MICBIAS 3
+
 #define ARIZONA_INMODE_DIFF 0
 #define ARIZONA_INMODE_SE   1
 #define ARIZONA_INMODE_DMIC 2
 
 #define ARIZONA_MAX_OUTPUT 6
 
+#define ARIZONA_MAX_AIF 3
+
 #define ARIZONA_HAP_ACT_ERM 0
 #define ARIZONA_HAP_ACT_LRA 2
 
@@ -69,6 +73,13 @@
 
 struct regulator_init_data;
 
+struct arizona_micbias {
+        int mV;                    /** Regulated voltage */
+        unsigned int ext_cap:1;    /** External capacitor fitted */
+        unsigned int discharge:1;  /** Actively discharge */
+        unsigned int fast_start:1; /** Enable aggressive startup ramp rate */
+};
+
 struct arizona_micd_config {
         unsigned int src;
         unsigned int bias;
@@ -96,9 +107,37 @@ struct arizona_pdata {
         /** Pin state for GPIO pins */
         int gpio_defaults[ARIZONA_MAX_GPIO];
 
+        /**
+         * Maximum number of channels clocks will be generated for,
+         * useful for systems where and I2S bus with multiple data
+         * lines is mastered.
+         */
+        int max_channels_clocked[ARIZONA_MAX_AIF];
+
+        /** GPIO5 is used for jack detection */
+        bool jd_gpio5;
+
+        /** Use the headphone detect circuit to identify the accessory */
+        bool hpdet_acc_id;
+
+        /** GPIO used for mic isolation with HPDET */
+        int hpdet_id_gpio;
+
         /** GPIO for mic detection polarity */
         int micd_pol_gpio;
 
+        /** Mic detect ramp rate */
+        int micd_bias_start_time;
+
+        /** Mic detect sample rate */
+        int micd_rate;
+
+        /** Mic detect debounce level */
+        int micd_dbtime;
+
+        /** Force MICBIAS on for mic detect */
+        bool micd_force_micbias;
+
         /** Headset polarity configurations */
         struct arizona_micd_config *micd_configs;
         int num_micd_configs;
@@ -106,6 +145,9 @@ struct arizona_pdata {
         /** Reference voltage for DMIC inputs */
         int dmic_ref[ARIZONA_MAX_INPUT];
 
+        /** MICBIAS configurations */
+        struct arizona_micbias micbias[ARIZONA_MAX_MICBIAS];
+
         /** Mode of input structures */
         int inmode[ARIZONA_MAX_INPUT];
 
diff --git a/include/linux/mfd/arizona/registers.h b/include/linux/mfd/arizona/registers.h
index 1f6fe31a4d5c..340355136069 100644
--- a/include/linux/mfd/arizona/registers.h
+++ b/include/linux/mfd/arizona/registers.h
@@ -119,6 +119,8 @@
 #define ARIZONA_ACCESSORY_DETECT_MODE_1          0x293
 #define ARIZONA_HEADPHONE_DETECT_1               0x29B
 #define ARIZONA_HEADPHONE_DETECT_2               0x29C
+#define ARIZONA_HP_DACVAL                        0x29F
+#define ARIZONA_MICD_CLAMP_CONTROL               0x2A2
 #define ARIZONA_MIC_DETECT_1                     0x2A3
 #define ARIZONA_MIC_DETECT_2                     0x2A4
 #define ARIZONA_MIC_DETECT_3                     0x2A5
@@ -982,18 +984,34 @@
 #define ARIZONA_DSP1_STATUS_1                    0x1104
 #define ARIZONA_DSP1_STATUS_2                    0x1105
 #define ARIZONA_DSP1_STATUS_3                    0x1106
+#define ARIZONA_DSP1_SCRATCH_0                   0x1140
+#define ARIZONA_DSP1_SCRATCH_1                   0x1141
+#define ARIZONA_DSP1_SCRATCH_2                   0x1142
+#define ARIZONA_DSP1_SCRATCH_3                   0x1143
 #define ARIZONA_DSP2_CONTROL_1                   0x1200
 #define ARIZONA_DSP2_CLOCKING_1                  0x1201
 #define ARIZONA_DSP2_STATUS_1                    0x1204
 #define ARIZONA_DSP2_STATUS_2                    0x1205
+#define ARIZONA_DSP2_SCRATCH_0                   0x1240
+#define ARIZONA_DSP2_SCRATCH_1                   0x1241
+#define ARIZONA_DSP2_SCRATCH_2                   0x1242
+#define ARIZONA_DSP2_SCRATCH_3                   0x1243
 #define ARIZONA_DSP3_CONTROL_1                   0x1300
 #define ARIZONA_DSP3_CLOCKING_1                  0x1301
 #define ARIZONA_DSP3_STATUS_1                    0x1304
 #define ARIZONA_DSP3_STATUS_2                    0x1305
+#define ARIZONA_DSP3_SCRATCH_0                   0x1340
+#define ARIZONA_DSP3_SCRATCH_1                   0x1341
+#define ARIZONA_DSP3_SCRATCH_2                   0x1342
+#define ARIZONA_DSP3_SCRATCH_3                   0x1343
 #define ARIZONA_DSP4_CONTROL_1                   0x1400
 #define ARIZONA_DSP4_CLOCKING_1                  0x1401
 #define ARIZONA_DSP4_STATUS_1                    0x1404
 #define ARIZONA_DSP4_STATUS_2                    0x1405
+#define ARIZONA_DSP4_SCRATCH_0                   0x1440
+#define ARIZONA_DSP4_SCRATCH_1                   0x1441
+#define ARIZONA_DSP4_SCRATCH_2                   0x1442
+#define ARIZONA_DSP4_SCRATCH_3                   0x1443
 
 /*
  * Field Definitions.
@@ -1194,6 +1212,14 @@
 /*
  * R64 (0x40) - Wake control
  */
+#define ARIZONA_WKUP_MICD_CLAMP_FALL             0x0080  /* WKUP_MICD_CLAMP_FALL */
+#define ARIZONA_WKUP_MICD_CLAMP_FALL_MASK        0x0080  /* WKUP_MICD_CLAMP_FALL */
+#define ARIZONA_WKUP_MICD_CLAMP_FALL_SHIFT            7  /* WKUP_MICD_CLAMP_FALL */
+#define ARIZONA_WKUP_MICD_CLAMP_FALL_WIDTH            1  /* WKUP_MICD_CLAMP_FALL */
+#define ARIZONA_WKUP_MICD_CLAMP_RISE             0x0040  /* WKUP_MICD_CLAMP_RISE */
+#define ARIZONA_WKUP_MICD_CLAMP_RISE_MASK        0x0040  /* WKUP_MICD_CLAMP_RISE */
+#define ARIZONA_WKUP_MICD_CLAMP_RISE_SHIFT            6  /* WKUP_MICD_CLAMP_RISE */
+#define ARIZONA_WKUP_MICD_CLAMP_RISE_WIDTH            1  /* WKUP_MICD_CLAMP_RISE */
 #define ARIZONA_WKUP_GP5_FALL                    0x0020  /* WKUP_GP5_FALL */
 #define ARIZONA_WKUP_GP5_FALL_MASK               0x0020  /* WKUP_GP5_FALL */
 #define ARIZONA_WKUP_GP5_FALL_SHIFT                   5  /* WKUP_GP5_FALL */
@@ -2035,6 +2061,9 @@
 /*
  * R667 (0x29B) - Headphone Detect 1
  */
+#define ARIZONA_HP_IMPEDANCE_RANGE_MASK          0x0600  /* HP_IMPEDANCE_RANGE - [10:9] */
+#define ARIZONA_HP_IMPEDANCE_RANGE_SHIFT              9  /* HP_IMPEDANCE_RANGE - [10:9] */
+#define ARIZONA_HP_IMPEDANCE_RANGE_WIDTH              2  /* HP_IMPEDANCE_RANGE - [10:9] */
 #define ARIZONA_HP_STEP_SIZE                     0x0100  /* HP_STEP_SIZE */
 #define ARIZONA_HP_STEP_SIZE_MASK                0x0100  /* HP_STEP_SIZE */
 #define ARIZONA_HP_STEP_SIZE_SHIFT                    8  /* HP_STEP_SIZE */
@@ -2069,6 +2098,21 @@
 #define ARIZONA_HP_LVL_SHIFT                          0  /* HP_LVL - [6:0] */
 #define ARIZONA_HP_LVL_WIDTH                          7  /* HP_LVL - [6:0] */
 
+#define ARIZONA_HP_DONE_B                        0x8000  /* HP_DONE */
+#define ARIZONA_HP_DONE_B_MASK                   0x8000  /* HP_DONE */
+#define ARIZONA_HP_DONE_B_SHIFT                      15  /* HP_DONE */
+#define ARIZONA_HP_DONE_B_WIDTH                       1  /* HP_DONE */
+#define ARIZONA_HP_LVL_B_MASK                    0x7FFF  /* HP_LVL - [14:0] */
+#define ARIZONA_HP_LVL_B_SHIFT                        0  /* HP_LVL - [14:0] */
+#define ARIZONA_HP_LVL_B_WIDTH                       15  /* HP_LVL - [14:0] */
+
+/*
+ * R674 (0x2A2) - MICD clamp control
+ */
+#define ARIZONA_MICD_CLAMP_MODE_MASK             0x000F  /* MICD_CLAMP_MODE - [3:0] */
+#define ARIZONA_MICD_CLAMP_MODE_SHIFT                 0  /* MICD_CLAMP_MODE - [3:0] */
+#define ARIZONA_MICD_CLAMP_MODE_WIDTH                 4  /* MICD_CLAMP_MODE - [3:0] */
+
 /*
  * R675 (0x2A3) - Mic Detect 1
  */
@@ -5239,6 +5283,14 @@
 /*
  * R3408 (0xD50) - AOD wkup and trig
  */
+#define ARIZONA_MICD_CLAMP_FALL_TRIG_STS         0x0080  /* MICD_CLAMP_FALL_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_FALL_TRIG_STS_MASK    0x0080  /* MICD_CLAMP_FALL_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_FALL_TRIG_STS_SHIFT        7  /* MICD_CLAMP_FALL_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_FALL_TRIG_STS_WIDTH        1  /* MICD_CLAMP_FALL_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_RISE_TRIG_STS         0x0040  /* MICD_CLAMP_RISE_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_RISE_TRIG_STS_MASK    0x0040  /* MICD_CLAMP_RISE_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_RISE_TRIG_STS_SHIFT        6  /* MICD_CLAMP_RISE_TRIG_STS */
+#define ARIZONA_MICD_CLAMP_RISE_TRIG_STS_WIDTH        1  /* MICD_CLAMP_RISE_TRIG_STS */
 #define ARIZONA_GP5_FALL_TRIG_STS                0x0020  /* GP5_FALL_TRIG_STS */
 #define ARIZONA_GP5_FALL_TRIG_STS_MASK           0x0020  /* GP5_FALL_TRIG_STS */
 #define ARIZONA_GP5_FALL_TRIG_STS_SHIFT               5  /* GP5_FALL_TRIG_STS */
@@ -5267,6 +5319,12 @@
 /*
  * R3409 (0xD51) - AOD IRQ1
  */
+#define ARIZONA_MICD_CLAMP_FALL_EINT1            0x0080  /* MICD_CLAMP_FALL_EINT1 */
+#define ARIZONA_MICD_CLAMP_FALL_EINT1_MASK       0x0080  /* MICD_CLAMP_FALL_EINT1 */
+#define ARIZONA_MICD_CLAMP_FALL_EINT1_SHIFT           7  /* MICD_CLAMP_FALL_EINT1 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT1            0x0040  /* MICD_CLAMP_RISE_EINT1 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT1_MASK       0x0040  /* MICD_CLAMP_RISE_EINT1 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT1_SHIFT           6  /* MICD_CLAMP_RISE_EINT1 */
 #define ARIZONA_GP5_FALL_EINT1                   0x0020  /* GP5_FALL_EINT1 */
 #define ARIZONA_GP5_FALL_EINT1_MASK              0x0020  /* GP5_FALL_EINT1 */
 #define ARIZONA_GP5_FALL_EINT1_SHIFT                  5  /* GP5_FALL_EINT1 */
@@ -5295,6 +5353,12 @@
 /*
  * R3410 (0xD52) - AOD IRQ2
  */
+#define ARIZONA_MICD_CLAMP_FALL_EINT2            0x0080  /* MICD_CLAMP_FALL_EINT2 */
+#define ARIZONA_MICD_CLAMP_FALL_EINT2_MASK       0x0080  /* MICD_CLAMP_FALL_EINT2 */
+#define ARIZONA_MICD_CLAMP_FALL_EINT2_SHIFT           7  /* MICD_CLAMP_FALL_EINT2 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT2            0x0040  /* MICD_CLAMP_RISE_EINT2 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT2_MASK       0x0040  /* MICD_CLAMP_RISE_EINT2 */
+#define ARIZONA_MICD_CLAMP_RISE_EINT2_SHIFT           6  /* MICD_CLAMP_RISE_EINT2 */
 #define ARIZONA_GP5_FALL_EINT2                   0x0020  /* GP5_FALL_EINT2 */
 #define ARIZONA_GP5_FALL_EINT2_MASK              0x0020  /* GP5_FALL_EINT2 */
 #define ARIZONA_GP5_FALL_EINT2_SHIFT                  5  /* GP5_FALL_EINT2 */
@@ -5379,6 +5443,10 @@
 /*
  * R3413 (0xD55) - AOD IRQ Raw Status
  */
+#define ARIZONA_MICD_CLAMP_STS                   0x0008  /* MICD_CLAMP_STS */
+#define ARIZONA_MICD_CLAMP_STS_MASK              0x0008  /* MICD_CLAMP_STS */
+#define ARIZONA_MICD_CLAMP_STS_SHIFT                  3  /* MICD_CLAMP_STS */
+#define ARIZONA_MICD_CLAMP_STS_WIDTH                  1  /* MICD_CLAMP_STS */
 #define ARIZONA_GP5_STS                          0x0004  /* GP5_STS */
 #define ARIZONA_GP5_STS_MASK                     0x0004  /* GP5_STS */
 #define ARIZONA_GP5_STS_SHIFT                         2  /* GP5_STS */
@@ -5395,6 +5463,10 @@
 /*
  * R3414 (0xD56) - Jack detect debounce
  */
+#define ARIZONA_MICD_CLAMP_DB                    0x0008  /* MICD_CLAMP_DB */
+#define ARIZONA_MICD_CLAMP_DB_MASK               0x0008  /* MICD_CLAMP_DB */
+#define ARIZONA_MICD_CLAMP_DB_SHIFT                   3  /* MICD_CLAMP_DB */
+#define ARIZONA_MICD_CLAMP_DB_WIDTH                   1  /* MICD_CLAMP_DB */
 #define ARIZONA_JD2_DB                           0x0002  /* JD2_DB */
 #define ARIZONA_JD2_DB_MASK                      0x0002  /* JD2_DB */
 #define ARIZONA_JD2_DB_SHIFT                          1  /* JD2_DB */
diff --git a/include/linux/mfd/db8500-prcmu.h b/include/linux/mfd/db8500-prcmu.h
index 6ee4247df11e..77a46ae2fc17 100644
--- a/include/linux/mfd/db8500-prcmu.h
+++ b/include/linux/mfd/db8500-prcmu.h
@@ -16,12 +16,6 @@
 /*
  * Registers
  */
-#define DB8500_PRCM_GPIOCR 0x138
-#define DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0     BIT(0)
-#define DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD      BIT(9)
-#define DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1     BIT(11)
-#define DB8500_PRCM_GPIOCR_SPI2_SELECT          BIT(23)
-
 #define DB8500_PRCM_LINE_VALUE 0x170
 #define DB8500_PRCM_LINE_VALUE_HSI_CAWAKE0      BIT(3)
 
@@ -493,20 +487,6 @@ struct prcmu_auto_pm_config {
         u8 sva_policy;
 };
 
-#define PRCMU_FW_PROJECT_U8500          2
-#define PRCMU_FW_PROJECT_U9500          4
-#define PRCMU_FW_PROJECT_U8500_C2       7
-#define PRCMU_FW_PROJECT_U9500_C2       11
-#define PRCMU_FW_PROJECT_U8520          13
-#define PRCMU_FW_PROJECT_U8420          14
-
-struct prcmu_fw_version {
-        u8 project;
-        u8 api_version;
-        u8 func_version;
-        u8 errata;
-};
-
 #ifdef CONFIG_MFD_DB8500_PRCMU
 
 void db8500_prcmu_early_init(void);
diff --git a/include/linux/mfd/dbx500-prcmu.h b/include/linux/mfd/dbx500-prcmu.h
index c202d6c4d879..3abcca91eecd 100644
--- a/include/linux/mfd/dbx500-prcmu.h
+++ b/include/linux/mfd/dbx500-prcmu.h
@@ -12,6 +12,10 @@
 #include <linux/notifier.h>
 #include <linux/err.h>
 
+/* Offset for the firmware version within the TCPM */
+#define DB8500_PRCMU_FW_VERSION_OFFSET 0xA4
+#define DBX540_PRCMU_FW_VERSION_OFFSET 0xA8
+
 /* PRCMU Wakeup defines */
 enum prcmu_wakeup_index {
         PRCMU_WAKEUP_INDEX_RTC,
@@ -147,6 +151,18 @@ enum prcmu_clock {
 };
 
 /**
+ * enum prcmu_wdog_id - PRCMU watchdog IDs
+ * @PRCMU_WDOG_ALL: use all timers
+ * @PRCMU_WDOG_CPU1: use first CPU timer only
+ * @PRCMU_WDOG_CPU2: use second CPU timer conly
+ */
+enum prcmu_wdog_id {
+        PRCMU_WDOG_ALL = 0x00,
+        PRCMU_WDOG_CPU1 = 0x01,
+        PRCMU_WDOG_CPU2 = 0x02,
+};
+
+/**
  * enum ape_opp - APE OPP states definition
  * @APE_OPP_INIT:
  * @APE_NO_CHANGE: The APE operating point is unchanged
@@ -214,12 +230,52 @@ enum ddr_pwrst {
         DDR_PWR_STATE_OFFHIGHLAT    = 0x03
 };
 
+#define DB8500_PRCMU_LEGACY_OFFSET              0xDD4
+
+struct prcmu_pdata
+{
+        bool enable_set_ddr_opp;
+        bool enable_ape_opp_100_voltage;
+        struct ab8500_platform_data *ab_platdata;
+        u32 version_offset;
+        u32 legacy_offset;
+        u32 adt_offset;
+};
+
+#define PRCMU_FW_PROJECT_U8500          2
+#define PRCMU_FW_PROJECT_U8400          3
+#define PRCMU_FW_PROJECT_U9500          4 /* Customer specific */
+#define PRCMU_FW_PROJECT_U8500_MBB      5
+#define PRCMU_FW_PROJECT_U8500_C1       6
+#define PRCMU_FW_PROJECT_U8500_C2       7
+#define PRCMU_FW_PROJECT_U8500_C3       8
+#define PRCMU_FW_PROJECT_U8500_C4       9
+#define PRCMU_FW_PROJECT_U9500_MBL      10
+#define PRCMU_FW_PROJECT_U8500_MBL      11 /* Customer specific */
+#define PRCMU_FW_PROJECT_U8500_MBL2     12 /* Customer specific */
+#define PRCMU_FW_PROJECT_U8520          13
+#define PRCMU_FW_PROJECT_U8420          14
+#define PRCMU_FW_PROJECT_A9420          20
+/* [32..63] 9540 and derivatives */
+#define PRCMU_FW_PROJECT_U9540          32
+/* [64..95] 8540 and derivatives */
+#define PRCMU_FW_PROJECT_L8540          64
+/* [96..126] 8580 and derivatives */
+#define PRCMU_FW_PROJECT_L8580          96
+
+#define PRCMU_FW_PROJECT_NAME_LEN       20
+struct prcmu_fw_version {
+        u32 project; /* Notice, project shifted with 8 on ux540 */
+        u8 api_version;
+        u8 func_version;
+        u8 errata;
+        char project_name[PRCMU_FW_PROJECT_NAME_LEN];
+};
+
 #include <linux/mfd/db8500-prcmu.h>
 
 #if defined(CONFIG_UX500_SOC_DB8500)
 
-#include <mach/id.h>
-
 static inline void __init prcmu_early_init(void)
 {
         return db8500_prcmu_early_init();
@@ -626,85 +682,6 @@ static inline void prcmu_clear(unsigned int reg, u32 bits)
         prcmu_write_masked(reg, bits, 0);
 }
 
-#if defined(CONFIG_UX500_SOC_DB8500)
-
-/**
- * prcmu_enable_spi2 - Enables pin muxing for SPI2 on OtherAlternateC1.
- */
-static inline void prcmu_enable_spi2(void)
-{
-        if (cpu_is_u8500())
-                prcmu_set(DB8500_PRCM_GPIOCR, DB8500_PRCM_GPIOCR_SPI2_SELECT);
-}
-
-/**
- * prcmu_disable_spi2 - Disables pin muxing for SPI2 on OtherAlternateC1.
- */
-static inline void prcmu_disable_spi2(void)
-{
-        if (cpu_is_u8500())
-                prcmu_clear(DB8500_PRCM_GPIOCR, DB8500_PRCM_GPIOCR_SPI2_SELECT);
-}
-
-/**
- * prcmu_enable_stm_mod_uart - Enables pin muxing for STMMOD
- * and UARTMOD on OtherAlternateC3.
- */
-static inline void prcmu_enable_stm_mod_uart(void)
-{
-        if (cpu_is_u8500()) {
-                prcmu_set(DB8500_PRCM_GPIOCR,
-                        (DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1 |
-                         DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0));
-        }
-}
-
-/**
- * prcmu_disable_stm_mod_uart - Disables pin muxing for STMMOD
- * and UARTMOD on OtherAlternateC3.
- */
-static inline void prcmu_disable_stm_mod_uart(void)
-{
-        if (cpu_is_u8500()) {
-                prcmu_clear(DB8500_PRCM_GPIOCR,
-                        (DB8500_PRCM_GPIOCR_DBG_STM_MOD_CMD1 |
-                         DB8500_PRCM_GPIOCR_DBG_UARTMOD_CMD0));
-        }
-}
-
-/**
- * prcmu_enable_stm_ape - Enables pin muxing for STM APE on OtherAlternateC1.
- */
-static inline void prcmu_enable_stm_ape(void)
-{
-        if (cpu_is_u8500()) {
-                prcmu_set(DB8500_PRCM_GPIOCR,
-                        DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD);
-        }
-}
-
-/**
- * prcmu_disable_stm_ape - Disables pin muxing for STM APE on OtherAlternateC1.
- */
-static inline void prcmu_disable_stm_ape(void)
-{
-        if (cpu_is_u8500()) {
-                prcmu_clear(DB8500_PRCM_GPIOCR,
-                        DB8500_PRCM_GPIOCR_DBG_STM_APE_CMD);
-        }
-}
-
-#else
-
-static inline void prcmu_enable_spi2(void) {}
-static inline void prcmu_disable_spi2(void) {}
-static inline void prcmu_enable_stm_mod_uart(void) {}
-static inline void prcmu_disable_stm_mod_uart(void) {}
-static inline void prcmu_enable_stm_ape(void) {}
-static inline void prcmu_disable_stm_ape(void) {}
-
-#endif
-
 /* PRCMU QoS APE OPP class */
 #define PRCMU_QOS_APE_OPP 1
 #define PRCMU_QOS_DDR_OPP 2
diff --git a/include/linux/mfd/max77693-private.h b/include/linux/mfd/max77693-private.h
index 1eeae5c07915..5b18ecde69b5 100644
--- a/include/linux/mfd/max77693-private.h
+++ b/include/linux/mfd/max77693-private.h
@@ -106,6 +106,92 @@ enum max77693_muic_reg {
         MAX77693_MUIC_REG_END,
 };
 
+/* MAX77693 MUIC - STATUS1~3 Register */
+#define STATUS1_ADC_SHIFT               (0)
+#define STATUS1_ADCLOW_SHIFT            (5)
+#define STATUS1_ADCERR_SHIFT            (6)
+#define STATUS1_ADC1K_SHIFT             (7)
+#define STATUS1_ADC_MASK                (0x1f << STATUS1_ADC_SHIFT)
+#define STATUS1_ADCLOW_MASK             (0x1 << STATUS1_ADCLOW_SHIFT)
+#define STATUS1_ADCERR_MASK             (0x1 << STATUS1_ADCERR_SHIFT)
+#define STATUS1_ADC1K_MASK              (0x1 << STATUS1_ADC1K_SHIFT)
+
+#define STATUS2_CHGTYP_SHIFT            (0)
+#define STATUS2_CHGDETRUN_SHIFT         (3)
+#define STATUS2_DCDTMR_SHIFT            (4)
+#define STATUS2_DXOVP_SHIFT             (5)
+#define STATUS2_VBVOLT_SHIFT            (6)
+#define STATUS2_VIDRM_SHIFT             (7)
+#define STATUS2_CHGTYP_MASK             (0x7 << STATUS2_CHGTYP_SHIFT)
+#define STATUS2_CHGDETRUN_MASK          (0x1 << STATUS2_CHGDETRUN_SHIFT)
+#define STATUS2_DCDTMR_MASK             (0x1 << STATUS2_DCDTMR_SHIFT)
+#define STATUS2_DXOVP_MASK              (0x1 << STATUS2_DXOVP_SHIFT)
+#define STATUS2_VBVOLT_MASK             (0x1 << STATUS2_VBVOLT_SHIFT)
+#define STATUS2_VIDRM_MASK              (0x1 << STATUS2_VIDRM_SHIFT)
+
+#define STATUS3_OVP_SHIFT               (2)
+#define STATUS3_OVP_MASK                (0x1 << STATUS3_OVP_SHIFT)
+
+/* MAX77693 CDETCTRL1~2 register */
+#define CDETCTRL1_CHGDETEN_SHIFT        (0)
+#define CDETCTRL1_CHGTYPMAN_SHIFT       (1)
+#define CDETCTRL1_DCDEN_SHIFT           (2)
+#define CDETCTRL1_DCD2SCT_SHIFT         (3)
+#define CDETCTRL1_CDDELAY_SHIFT         (4)
+#define CDETCTRL1_DCDCPL_SHIFT          (5)
+#define CDETCTRL1_CDPDET_SHIFT          (7)
+#define CDETCTRL1_CHGDETEN_MASK         (0x1 << CDETCTRL1_CHGDETEN_SHIFT)
+#define CDETCTRL1_CHGTYPMAN_MASK        (0x1 << CDETCTRL1_CHGTYPMAN_SHIFT)
+#define CDETCTRL1_DCDEN_MASK            (0x1 << CDETCTRL1_DCDEN_SHIFT)
+#define CDETCTRL1_DCD2SCT_MASK          (0x1 << CDETCTRL1_DCD2SCT_SHIFT)
+#define CDETCTRL1_CDDELAY_MASK          (0x1 << CDETCTRL1_CDDELAY_SHIFT)
+#define CDETCTRL1_DCDCPL_MASK           (0x1 << CDETCTRL1_DCDCPL_SHIFT)
+#define CDETCTRL1_CDPDET_MASK           (0x1 << CDETCTRL1_CDPDET_SHIFT)
+
+#define CDETCTRL2_VIDRMEN_SHIFT         (1)
+#define CDETCTRL2_DXOVPEN_SHIFT         (3)
+#define CDETCTRL2_VIDRMEN_MASK          (0x1 << CDETCTRL2_VIDRMEN_SHIFT)
+#define CDETCTRL2_DXOVPEN_MASK          (0x1 << CDETCTRL2_DXOVPEN_SHIFT)
+
+/* MAX77693 MUIC - CONTROL1~3 register */
+#define COMN1SW_SHIFT                   (0)
+#define COMP2SW_SHIFT                   (3)
+#define COMN1SW_MASK                    (0x7 << COMN1SW_SHIFT)
+#define COMP2SW_MASK                    (0x7 << COMP2SW_SHIFT)
+#define COMP_SW_MASK                    (COMP2SW_MASK | COMN1SW_MASK)
+#define CONTROL1_SW_USB                 ((1 << COMP2SW_SHIFT) \
+                                                | (1 << COMN1SW_SHIFT))
+#define CONTROL1_SW_AUDIO               ((2 << COMP2SW_SHIFT) \
+                                                | (2 << COMN1SW_SHIFT))
+#define CONTROL1_SW_UART                ((3 << COMP2SW_SHIFT) \
+                                                | (3 << COMN1SW_SHIFT))
+#define CONTROL1_SW_OPEN                ((0 << COMP2SW_SHIFT) \
+                                                | (0 << COMN1SW_SHIFT))
+
+#define CONTROL2_LOWPWR_SHIFT           (0)
+#define CONTROL2_ADCEN_SHIFT            (1)
+#define CONTROL2_CPEN_SHIFT             (2)
+#define CONTROL2_SFOUTASRT_SHIFT        (3)
+#define CONTROL2_SFOUTORD_SHIFT         (4)
+#define CONTROL2_ACCDET_SHIFT           (5)
+#define CONTROL2_USBCPINT_SHIFT         (6)
+#define CONTROL2_RCPS_SHIFT             (7)
+#define CONTROL2_LOWPWR_MASK            (0x1 << CONTROL2_LOWPWR_SHIFT)
+#define CONTROL2_ADCEN_MASK             (0x1 << CONTROL2_ADCEN_SHIFT)
+#define CONTROL2_CPEN_MASK              (0x1 << CONTROL2_CPEN_SHIFT)
+#define CONTROL2_SFOUTASRT_MASK         (0x1 << CONTROL2_SFOUTASRT_SHIFT)
+#define CONTROL2_SFOUTORD_MASK          (0x1 << CONTROL2_SFOUTORD_SHIFT)
+#define CONTROL2_ACCDET_MASK            (0x1 << CONTROL2_ACCDET_SHIFT)
+#define CONTROL2_USBCPINT_MASK          (0x1 << CONTROL2_USBCPINT_SHIFT)
+#define CONTROL2_RCPS_MASK              (0x1 << CONTROL2_RCPS_SHIFT)
+
+#define CONTROL3_JIGSET_SHIFT           (0)
+#define CONTROL3_BTLDSET_SHIFT          (2)
+#define CONTROL3_ADCDBSET_SHIFT         (4)
+#define CONTROL3_JIGSET_MASK            (0x3 << CONTROL3_JIGSET_SHIFT)
+#define CONTROL3_BTLDSET_MASK           (0x3 << CONTROL3_BTLDSET_SHIFT)
+#define CONTROL3_ADCDBSET_MASK          (0x3 << CONTROL3_ADCDBSET_SHIFT)
+
 /* Slave addr = 0x90: Haptic */
 enum max77693_haptic_reg {
         MAX77693_HAPTIC_REG_STATUS              = 0x00,
diff --git a/include/linux/mfd/max77693.h b/include/linux/mfd/max77693.h
index fe03b2d35d4f..3109a6c5c948 100644
--- a/include/linux/mfd/max77693.h
+++ b/include/linux/mfd/max77693.h
@@ -38,6 +38,15 @@ struct max77693_reg_data {
 struct max77693_muic_platform_data {
         struct max77693_reg_data *init_data;
         int num_init_data;
+
+        int detcable_delay_ms;
+
+        /*
+         * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
+         * h/w path of COMP2/COMN1 on CONTROL1 register.
+         */
+        int path_usb;
+        int path_uart;
 };
 
 struct max77693_platform_data {
diff --git a/include/linux/mfd/max8925.h b/include/linux/mfd/max8925.h
index 74d8e2969630..ce8502e9e7dc 100644
--- a/include/linux/mfd/max8925.h
+++ b/include/linux/mfd/max8925.h
@@ -190,6 +190,8 @@ enum {
         MAX8925_NR_IRQS,
 };
 
+
+
 struct max8925_chip {
         struct device           *dev;
         struct i2c_client       *i2c;
@@ -201,7 +203,6 @@ struct max8925_chip {
         int                     irq_base;
         int                     core_irq;
         int                     tsc_irq;
-
         unsigned int            wakeup_flag;
 };
 
diff --git a/include/linux/mfd/max8997-private.h b/include/linux/mfd/max8997-private.h
index 6ae21bf47d64..fb465dfbb59e 100644
--- a/include/linux/mfd/max8997-private.h
+++ b/include/linux/mfd/max8997-private.h
@@ -194,6 +194,70 @@ enum max8997_muic_reg {
         MAX8997_MUIC_REG_END            = 0xf,
 };
 
+/* MAX8997-MUIC STATUS1 register */
+#define STATUS1_ADC_SHIFT               0
+#define STATUS1_ADCLOW_SHIFT            5
+#define STATUS1_ADCERR_SHIFT            6
+#define STATUS1_ADC_MASK                (0x1f << STATUS1_ADC_SHIFT)
+#define STATUS1_ADCLOW_MASK             (0x1 << STATUS1_ADCLOW_SHIFT)
+#define STATUS1_ADCERR_MASK             (0x1 << STATUS1_ADCERR_SHIFT)
+
+/* MAX8997-MUIC STATUS2 register */
+#define STATUS2_CHGTYP_SHIFT            0
+#define STATUS2_CHGDETRUN_SHIFT         3
+#define STATUS2_DCDTMR_SHIFT            4
+#define STATUS2_DBCHG_SHIFT             5
+#define STATUS2_VBVOLT_SHIFT            6
+#define STATUS2_CHGTYP_MASK             (0x7 << STATUS2_CHGTYP_SHIFT)
+#define STATUS2_CHGDETRUN_MASK          (0x1 << STATUS2_CHGDETRUN_SHIFT)
+#define STATUS2_DCDTMR_MASK             (0x1 << STATUS2_DCDTMR_SHIFT)
+#define STATUS2_DBCHG_MASK              (0x1 << STATUS2_DBCHG_SHIFT)
+#define STATUS2_VBVOLT_MASK             (0x1 << STATUS2_VBVOLT_SHIFT)
+
+/* MAX8997-MUIC STATUS3 register */
+#define STATUS3_OVP_SHIFT               2
+#define STATUS3_OVP_MASK                (0x1 << STATUS3_OVP_SHIFT)
+
+/* MAX8997-MUIC CONTROL1 register */
+#define COMN1SW_SHIFT                   0
+#define COMP2SW_SHIFT                   3
+#define COMN1SW_MASK                    (0x7 << COMN1SW_SHIFT)
+#define COMP2SW_MASK                    (0x7 << COMP2SW_SHIFT)
+#define COMP_SW_MASK            (COMP2SW_MASK | COMN1SW_MASK)
+
+#define CONTROL1_SW_USB                 ((1 << COMP2SW_SHIFT) \
+                                                | (1 << COMN1SW_SHIFT))
+#define CONTROL1_SW_AUDIO               ((2 << COMP2SW_SHIFT) \
+                                                | (2 << COMN1SW_SHIFT))
+#define CONTROL1_SW_UART                ((3 << COMP2SW_SHIFT) \
+                                                | (3 << COMN1SW_SHIFT))
+#define CONTROL1_SW_OPEN                ((0 << COMP2SW_SHIFT) \
+                                                | (0 << COMN1SW_SHIFT))
+
+#define CONTROL2_LOWPWR_SHIFT           (0)
+#define CONTROL2_ADCEN_SHIFT            (1)
+#define CONTROL2_CPEN_SHIFT             (2)
+#define CONTROL2_SFOUTASRT_SHIFT        (3)
+#define CONTROL2_SFOUTORD_SHIFT         (4)
+#define CONTROL2_ACCDET_SHIFT           (5)
+#define CONTROL2_USBCPINT_SHIFT         (6)
+#define CONTROL2_RCPS_SHIFT             (7)
+#define CONTROL2_LOWPWR_MASK            (0x1 << CONTROL2_LOWPWR_SHIFT)
+#define CONTROL2_ADCEN_MASK             (0x1 << CONTROL2_ADCEN_SHIFT)
+#define CONTROL2_CPEN_MASK              (0x1 << CONTROL2_CPEN_SHIFT)
+#define CONTROL2_SFOUTASRT_MASK         (0x1 << CONTROL2_SFOUTASRT_SHIFT)
+#define CONTROL2_SFOUTORD_MASK          (0x1 << CONTROL2_SFOUTORD_SHIFT)
+#define CONTROL2_ACCDET_MASK            (0x1 << CONTROL2_ACCDET_SHIFT)
+#define CONTROL2_USBCPINT_MASK          (0x1 << CONTROL2_USBCPINT_SHIFT)
+#define CONTROL2_RCPS_MASK              (0x1 << CONTROL2_RCPS_SHIFT)
+
+#define CONTROL3_JIGSET_SHIFT           (0)
+#define CONTROL3_BTLDSET_SHIFT          (2)
+#define CONTROL3_ADCDBSET_SHIFT         (4)
+#define CONTROL3_JIGSET_MASK            (0x3 << CONTROL3_JIGSET_SHIFT)
+#define CONTROL3_BTLDSET_MASK           (0x3 << CONTROL3_BTLDSET_SHIFT)
+#define CONTROL3_ADCDBSET_MASK          (0x3 << CONTROL3_ADCDBSET_SHIFT)
+
 enum max8997_haptic_reg {
         MAX8997_HAPTIC_REG_GENERAL      = 0x00,
         MAX8997_HAPTIC_REG_CONF1        = 0x01,
diff --git a/include/linux/mfd/max8997.h b/include/linux/mfd/max8997.h
index 1d4a4fe6ac33..cf815577bd68 100644
--- a/include/linux/mfd/max8997.h
+++ b/include/linux/mfd/max8997.h
@@ -78,21 +78,6 @@ struct max8997_regulator_data {
         struct device_node *reg_node;
 };
 
-enum max8997_muic_usb_type {
-        MAX8997_USB_HOST,
-        MAX8997_USB_DEVICE,
-};
-
-enum max8997_muic_charger_type {
-        MAX8997_CHARGER_TYPE_NONE = 0,
-        MAX8997_CHARGER_TYPE_USB,
-        MAX8997_CHARGER_TYPE_DOWNSTREAM_PORT,
-        MAX8997_CHARGER_TYPE_DEDICATED_CHG,
-        MAX8997_CHARGER_TYPE_500MA,
-        MAX8997_CHARGER_TYPE_1A,
-        MAX8997_CHARGER_TYPE_DEAD_BATTERY = 7,
-};
-
 struct max8997_muic_reg_data {
         u8 addr;
         u8 data;
@@ -107,6 +92,16 @@ struct max8997_muic_reg_data {
 struct max8997_muic_platform_data {
         struct max8997_muic_reg_data *init_data;
         int num_init_data;
+
+        /* Check cable state after certain delay */
+        int detcable_delay_ms;
+
+        /*
+         * Default usb/uart path whether UART/USB or AUX_UART/AUX_USB
+         * h/w path of COMP2/COMN1 on CONTROL1 register.
+         */
+        int path_usb;
+        int path_uart;
 };
 
 enum max8997_haptic_motor_type {
diff --git a/include/linux/mfd/palmas.h b/include/linux/mfd/palmas.h
index 29f6616e12f0..a4d13d7cd001 100644
--- a/include/linux/mfd/palmas.h
+++ b/include/linux/mfd/palmas.h
@@ -2789,4 +2789,56 @@ enum usb_irq_events {
 #define PALMAS_GPADC_TRIM15                                     0xE
 #define PALMAS_GPADC_TRIM16                                     0xF
 
+static inline int palmas_read(struct palmas *palmas, unsigned int base,
+                unsigned int reg, unsigned int *val)
+{
+        unsigned int addr =  PALMAS_BASE_TO_REG(base, reg);
+        int slave_id = PALMAS_BASE_TO_SLAVE(base);
+
+        return regmap_read(palmas->regmap[slave_id], addr, val);
+}
+
+static inline int palmas_write(struct palmas *palmas, unsigned int base,
+                unsigned int reg, unsigned int value)
+{
+        unsigned int addr = PALMAS_BASE_TO_REG(base, reg);
+        int slave_id = PALMAS_BASE_TO_SLAVE(base);
+
+        return regmap_write(palmas->regmap[slave_id], addr, value);
+}
+
+static inline int palmas_bulk_write(struct palmas *palmas, unsigned int base,
+        unsigned int reg, const void *val, size_t val_count)
+{
+        unsigned int addr = PALMAS_BASE_TO_REG(base, reg);
+        int slave_id = PALMAS_BASE_TO_SLAVE(base);
+
+        return regmap_bulk_write(palmas->regmap[slave_id], addr,
+                        val, val_count);
+}
+
+static inline int palmas_bulk_read(struct palmas *palmas, unsigned int base,
+                unsigned int reg, void *val, size_t val_count)
+{
+        unsigned int addr = PALMAS_BASE_TO_REG(base, reg);
+        int slave_id = PALMAS_BASE_TO_SLAVE(base);
+
+        return regmap_bulk_read(palmas->regmap[slave_id], addr,
+                val, val_count);
+}
+
+static inline int palmas_update_bits(struct palmas *palmas, unsigned int base,
+        unsigned int reg, unsigned int mask, unsigned int val)
+{
+        unsigned int addr = PALMAS_BASE_TO_REG(base, reg);
+        int slave_id = PALMAS_BASE_TO_SLAVE(base);
+
+        return regmap_update_bits(palmas->regmap[slave_id], addr, mask, val);
+}
+
+static inline int palmas_irq_get_virq(struct palmas *palmas, int irq)
+{
+        return regmap_irq_get_virq(palmas->irq_data, irq);
+}
+
 #endif /*  __LINUX_MFD_PALMAS_H */
diff --git a/include/linux/mfd/rtsx_pci.h b/include/linux/mfd/rtsx_pci.h
index 4b117a3f54d4..26ea7f1b7caf 100644
--- a/include/linux/mfd/rtsx_pci.h
+++ b/include/linux/mfd/rtsx_pci.h
@@ -465,7 +465,7 @@
 #define SD_RSP_TYPE_R6                  0x01
 #define SD_RSP_TYPE_R7                  0x01
 
-/* SD_CONFIURE3 */
+/* SD_CONFIGURE3 */
 #define SD_RSP_80CLK_TIMEOUT_EN         0x01
 
 /* Card Transfer Reset Register */
@@ -581,8 +581,11 @@
 #define CARD_GPIO_DIR                   0xFD57
 #define CARD_GPIO                       0xFD58
 #define CARD_DATA_SOURCE                0xFD5B
+#define SD30_CLK_DRIVE_SEL              0xFD5A
 #define CARD_SELECT                     0xFD5C
 #define SD30_DRIVE_SEL                  0xFD5E
+#define SD30_CMD_DRIVE_SEL              0xFD5E
+#define SD30_DAT_DRIVE_SEL              0xFD5F
 #define CARD_CLK_EN                     0xFD69
 #define SDIO_CTRL                       0xFD6B
 #define CD_PAD_CTL                      0xFD73
@@ -655,6 +658,8 @@
 #define MSGTXDATA3                      0xFE47
 #define MSGTXCTL                        0xFE48
 #define PETXCFG                         0xFE49
+#define LTR_CTL                         0xFE4A
+#define OBFF_CFG                        0xFE4C
 
 #define CDRESUMECTL                     0xFE52
 #define WAKE_SEL_CTL                    0xFE54
@@ -735,6 +740,7 @@ struct rtsx_pcr {
 
         unsigned int                    card_inserted;
         unsigned int                    card_removed;
+        unsigned int                    card_exist;
 
         struct delayed_work             carddet_work;
         struct delayed_work             idle_work;
@@ -799,6 +805,7 @@ int rtsx_pci_switch_clock(struct rtsx_pcr *pcr, unsigned int card_clock,
                 u8 ssc_depth, bool initial_mode, bool double_clk, bool vpclk);
 int rtsx_pci_card_power_on(struct rtsx_pcr *pcr, int card);
 int rtsx_pci_card_power_off(struct rtsx_pcr *pcr, int card);
+int rtsx_pci_card_exclusive_check(struct rtsx_pcr *pcr, int card);
 int rtsx_pci_switch_output_voltage(struct rtsx_pcr *pcr, u8 voltage);
 unsigned int rtsx_pci_card_exist(struct rtsx_pcr *pcr);
 void rtsx_pci_complete_unfinished_transfer(struct rtsx_pcr *pcr);
diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h
index b50c38f8bc48..f0f4de3b4ccc 100644
--- a/include/linux/mfd/samsung/core.h
+++ b/include/linux/mfd/samsung/core.h
@@ -26,6 +26,7 @@ enum sec_device_type {
 /**
  * struct sec_pmic_dev - s5m87xx master device for sub-drivers
  * @dev: master device of the chip (can be used to access platform data)
+ * @pdata: pointer to private data used to pass platform data to child
  * @i2c: i2c client private data for regulator
  * @rtc: i2c client private data for rtc
  * @iolock: mutex for serializing io access
@@ -39,6 +40,7 @@ enum sec_device_type {
  */
 struct sec_pmic_dev {
         struct device *dev;
+        struct sec_platform_data *pdata;
         struct regmap *regmap;
         struct i2c_client *i2c;
         struct i2c_client *rtc;
@@ -82,11 +84,11 @@ struct sec_platform_data {
 
         int                             buck_gpios[3];
         int                             buck_ds[3];
-        int                             buck2_voltage[8];
+        unsigned int                    buck2_voltage[8];
         bool                            buck2_gpiodvs;
-        int                             buck3_voltage[8];
+        unsigned int                    buck3_voltage[8];
         bool                            buck3_gpiodvs;
-        int                             buck4_voltage[8];
+        unsigned int                    buck4_voltage[8];
         bool                            buck4_gpiodvs;
 
         int                             buck_set1;
@@ -127,6 +129,7 @@ struct sec_platform_data {
 struct sec_regulator_data {
         int                             id;
         struct regulator_init_data      *initdata;
+        struct device_node *reg_node;
 };
 
 /*
@@ -136,7 +139,7 @@ struct sec_regulator_data {
  */
 struct sec_opmode_data {
         int id;
-        int mode;
+        unsigned int mode;
 };
 
 /*
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index d83af39815ab..99bf3e665997 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -65,12 +65,6 @@
  */
 #define TMIO_MMC_SDIO_IRQ               (1 << 2)
 /*
- * Some platforms can detect card insertion events with controller powered
- * down, using a GPIO IRQ, in which case they have to fill in cd_irq, cd_gpio,
- * and cd_flags fields of struct tmio_mmc_data.
- */
-#define TMIO_MMC_HAS_COLD_CD            (1 << 3)
-/*
  * Some controllers require waiting for the SD bus to become
  * idle before writing to some registers.
  */
@@ -117,18 +111,6 @@ struct tmio_mmc_data {
 };
 
 /*
- * This function is deprecated and will be removed soon. Please, convert your
- * platform to use drivers/mmc/core/cd-gpio.c
- */
-#include <linux/mmc/host.h>
-static inline void tmio_mmc_cd_wakeup(struct tmio_mmc_data *pdata)
-{
-        if (pdata)
-                mmc_detect_change(dev_get_drvdata(pdata->dev),
-                                  msecs_to_jiffies(100));
-}
-
-/*
  * data for the NAND controller
  */
 struct tmio_nand_data {
diff --git a/include/linux/micrel_phy.h b/include/linux/micrel_phy.h
index adfe8c058f29..9dbb41a4e250 100644
--- a/include/linux/micrel_phy.h
+++ b/include/linux/micrel_phy.h
@@ -21,8 +21,15 @@
 #define PHY_ID_KSZ8021          0x00221555
 #define PHY_ID_KSZ8041          0x00221510
 #define PHY_ID_KSZ8051          0x00221550
-/* both for ks8001 Rev. A/B, and for ks8721 Rev 3. */
+/* same id: ks8001 Rev. A/B, and ks8721 Rev 3. */
 #define PHY_ID_KSZ8001          0x0022161A
+/* same id: KS8081, KS8091 */
+#define PHY_ID_KSZ8081          0x00221560
+#define PHY_ID_KSZ8061          0x00221570
+#define PHY_ID_KSZ9031          0x00221620
+
+#define PHY_ID_KSZ886X          0x00221430
+#define PHY_ID_KSZ8863          0x00221435
 
 /* struct phy_device dev_flags definitions */
 #define MICREL_PHY_50MHZ_CLK    0x00000001
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index 1e9f627967a3..a405d3dc0f61 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -40,11 +40,9 @@ extern void putback_movable_pages(struct list_head *l);
 extern int migrate_page(struct address_space *,
                         struct page *, struct page *, enum migrate_mode);
 extern int migrate_pages(struct list_head *l, new_page_t x,
-                        unsigned long private, bool offlining,
-                        enum migrate_mode mode, int reason);
+                unsigned long private, enum migrate_mode mode, int reason);
 extern int migrate_huge_page(struct page *, new_page_t x,
-                        unsigned long private, bool offlining,
-                        enum migrate_mode mode);
+                unsigned long private, enum migrate_mode mode);
 
 extern int fail_migrate_page(struct address_space *,
                         struct page *, struct page *);
@@ -62,11 +60,11 @@ extern int migrate_huge_page_move_mapping(struct address_space *mapping,
 static inline void putback_lru_pages(struct list_head *l) {}
 static inline void putback_movable_pages(struct list_head *l) {}
 static inline int migrate_pages(struct list_head *l, new_page_t x,
-                unsigned long private, bool offlining,
-                enum migrate_mode mode, int reason) { return -ENOSYS; }
+                unsigned long private, enum migrate_mode mode, int reason)
+        { return -ENOSYS; }
 static inline int migrate_huge_page(struct page *page, new_page_t x,
-                unsigned long private, bool offlining,
-                enum migrate_mode mode) { return -ENOSYS; }
+                unsigned long private, enum migrate_mode mode)
+        { return -ENOSYS; }
 
 static inline int migrate_prep(void) { return -ENOSYS; }
 static inline int migrate_prep_local(void) { return -ENOSYS; }
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 20ea939c22a6..811f91cf5e8c 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -150,7 +150,8 @@ enum {
         MLX4_DEV_CAP_FLAG2_RSS                  = 1LL <<  0,
         MLX4_DEV_CAP_FLAG2_RSS_TOP              = 1LL <<  1,
         MLX4_DEV_CAP_FLAG2_RSS_XOR              = 1LL <<  2,
-        MLX4_DEV_CAP_FLAG2_FS_EN                = 1LL <<  3
+        MLX4_DEV_CAP_FLAG2_FS_EN                = 1LL <<  3,
+        MLX4_DEV_CAP_FLAGS2_REASSIGN_MAC_EN     = 1LL <<  4
 };
 
 enum {
@@ -170,6 +171,7 @@ enum {
 #define MLX4_ATTR_EXTENDED_PORT_INFO    cpu_to_be16(0xff90)
 
 enum {
+        MLX4_BMME_FLAG_WIN_TYPE_2B      = 1 <<  1,
         MLX4_BMME_FLAG_LOCAL_INV        = 1 <<  6,
         MLX4_BMME_FLAG_REMOTE_INV       = 1 <<  7,
         MLX4_BMME_FLAG_TYPE_2_WIN       = 1 <<  9,
@@ -237,7 +239,8 @@ enum {
         MLX4_PERM_LOCAL_WRITE   = 1 << 11,
         MLX4_PERM_REMOTE_READ   = 1 << 12,
         MLX4_PERM_REMOTE_WRITE  = 1 << 13,
-        MLX4_PERM_ATOMIC        = 1 << 14
+        MLX4_PERM_ATOMIC        = 1 << 14,
+        MLX4_PERM_BIND_MW       = 1 << 15,
 };
 
 enum {
@@ -503,6 +506,18 @@ struct mlx4_mr {
         int                     enabled;
 };
 
+enum mlx4_mw_type {
+        MLX4_MW_TYPE_1 = 1,
+        MLX4_MW_TYPE_2 = 2,
+};
+
+struct mlx4_mw {
+        u32                     key;
+        u32                     pd;
+        enum mlx4_mw_type       type;
+        int                     enabled;
+};
+
 struct mlx4_fmr {
         struct mlx4_mr          mr;
         struct mlx4_mpt_entry  *mpt;
@@ -801,8 +816,12 @@ u64 mlx4_mtt_addr(struct mlx4_dev *dev, struct mlx4_mtt *mtt);
 
 int mlx4_mr_alloc(struct mlx4_dev *dev, u32 pd, u64 iova, u64 size, u32 access,
                   int npages, int page_shift, struct mlx4_mr *mr);
-void mlx4_mr_free(struct mlx4_dev *dev, struct mlx4_mr *mr);
+int mlx4_mr_free(struct mlx4_dev *dev, struct mlx4_mr *mr);
 int mlx4_mr_enable(struct mlx4_dev *dev, struct mlx4_mr *mr);
+int mlx4_mw_alloc(struct mlx4_dev *dev, u32 pd, enum mlx4_mw_type type,
+                  struct mlx4_mw *mw);
+void mlx4_mw_free(struct mlx4_dev *dev, struct mlx4_mw *mw);
+int mlx4_mw_enable(struct mlx4_dev *dev, struct mlx4_mw *mw);
 int mlx4_write_mtt(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
                    int start_index, int npages, u64 *page_list);
 int mlx4_buf_write_mtt(struct mlx4_dev *dev, struct mlx4_mtt *mtt,
@@ -955,9 +974,8 @@ int mlx4_SET_MCAST_FLTR(struct mlx4_dev *dev, u8 port, u64 mac, u64 clear, u8 mo
 
 int mlx4_register_mac(struct mlx4_dev *dev, u8 port, u64 mac);
 void mlx4_unregister_mac(struct mlx4_dev *dev, u8 port, u64 mac);
-int mlx4_replace_mac(struct mlx4_dev *dev, u8 port, int qpn, u64 new_mac);
-int mlx4_get_eth_qp(struct mlx4_dev *dev, u8 port, u64 mac, int *qpn);
-void mlx4_put_eth_qp(struct mlx4_dev *dev, u8 port, u64 mac, int qpn);
+int mlx4_get_base_qpn(struct mlx4_dev *dev, u8 port);
+int __mlx4_replace_mac(struct mlx4_dev *dev, u8 port, int qpn, u64 new_mac);
 void mlx4_set_stats_bitmap(struct mlx4_dev *dev, u64 *stats_bitmap);
 int mlx4_SET_PORT_general(struct mlx4_dev *dev, u8 port, int mtu,
                           u8 pptx, u8 pfctx, u8 pprx, u8 pfcrx);
diff --git a/include/linux/mlx4/qp.h b/include/linux/mlx4/qp.h
index 4b4ad6ffef92..67f46ad6920a 100644
--- a/include/linux/mlx4/qp.h
+++ b/include/linux/mlx4/qp.h
@@ -265,6 +265,11 @@ struct mlx4_wqe_lso_seg {
         __be32                  header[0];
 };
 
+enum mlx4_wqe_bind_seg_flags2 {
+        MLX4_WQE_BIND_ZERO_BASED = (1 << 30),
+        MLX4_WQE_BIND_TYPE_2     = (1 << 31),
+};
+
 struct mlx4_wqe_bind_seg {
         __be32                  flags1;
         __be32                  flags2;
@@ -277,9 +282,9 @@ struct mlx4_wqe_bind_seg {
 enum {
         MLX4_WQE_FMR_PERM_LOCAL_READ    = 1 << 27,
         MLX4_WQE_FMR_PERM_LOCAL_WRITE   = 1 << 28,
-        MLX4_WQE_FMR_PERM_REMOTE_READ   = 1 << 29,
-        MLX4_WQE_FMR_PERM_REMOTE_WRITE  = 1 << 30,
-        MLX4_WQE_FMR_PERM_ATOMIC        = 1 << 31
+        MLX4_WQE_FMR_AND_BIND_PERM_REMOTE_READ  = 1 << 29,
+        MLX4_WQE_FMR_AND_BIND_PERM_REMOTE_WRITE = 1 << 30,
+        MLX4_WQE_FMR_AND_BIND_PERM_ATOMIC       = 1 << 31
 };
 
 struct mlx4_wqe_fmr_seg {
@@ -304,12 +309,10 @@ struct mlx4_wqe_fmr_ext_seg {
 };
 
 struct mlx4_wqe_local_inval_seg {
-        __be32                  flags;
-        u32                     reserved1;
+        u64                     reserved1;
         __be32                  mem_key;
-        u32                     reserved2[2];
-        __be32                  guest_id;
-        __be64                  pa;
+        u32                     reserved2;
+        u64                     reserved3[2];
 };
 
 struct mlx4_wqe_raddr_seg {
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 66e2f7c61e5c..e7c3f9a0111a 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -87,6 +87,7 @@ extern unsigned int kobjsize(const void *objp);
 #define VM_PFNMAP       0x00000400      /* Page-ranges managed without "struct page", just pure PFN */
 #define VM_DENYWRITE    0x00000800      /* ETXTBSY on write attempts.. */
 
+#define VM_POPULATE     0x00001000
 #define VM_LOCKED       0x00002000
 #define VM_IO           0x00004000      /* Memory mapped I/O or similar */
 
@@ -366,7 +367,7 @@ static inline struct page *compound_head(struct page *page)
  * both from it and to it can be tracked, using atomic_inc_and_test
  * and atomic_add_negative(-1).
  */
-static inline void reset_page_mapcount(struct page *page)
+static inline void page_mapcount_reset(struct page *page)
 {
         atomic_set(&(page)->_mapcount, -1);
 }
@@ -580,50 +581,11 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
  * sets it, so none of the operations on it need to be atomic.
  */
 
-
-/*
- * page->flags layout:
- *
- * There are three possibilities for how page->flags get
- * laid out.  The first is for the normal case, without
- * sparsemem.  The second is for sparsemem when there is
- * plenty of space for node and section.  The last is when
- * we have run out of space and have to fall back to an
- * alternate (slower) way of determining the node.
- *
- * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE | ... | FLAGS |
- * classic sparse with space for node:| SECTION | NODE | ZONE | ... | FLAGS |
- * classic sparse no space for node:  | SECTION |     ZONE    | ... | FLAGS |
- */
-#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
-#define SECTIONS_WIDTH          SECTIONS_SHIFT
-#else
-#define SECTIONS_WIDTH          0
-#endif
-
-#define ZONES_WIDTH             ZONES_SHIFT
-
-#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
-#define NODES_WIDTH             NODES_SHIFT
-#else
-#ifdef CONFIG_SPARSEMEM_VMEMMAP
-#error "Vmemmap: No space for nodes field in page flags"
-#endif
-#define NODES_WIDTH             0
-#endif
-
-/* Page flags: | [SECTION] | [NODE] | ZONE | ... | FLAGS | */
+/* Page flags: | [SECTION] | [NODE] | ZONE | [LAST_NID] | ... | FLAGS | */
 #define SECTIONS_PGOFF          ((sizeof(unsigned long)*8) - SECTIONS_WIDTH)
 #define NODES_PGOFF             (SECTIONS_PGOFF - NODES_WIDTH)
 #define ZONES_PGOFF             (NODES_PGOFF - ZONES_WIDTH)
-
-/*
- * We are going to use the flags for the page to node mapping if its in
- * there.  This includes the case where there is no node, so it is implicit.
- */
-#if !(NODES_WIDTH > 0 || NODES_SHIFT == 0)
-#define NODE_NOT_IN_PAGE_FLAGS
-#endif
+#define LAST_NID_PGOFF          (ZONES_PGOFF - LAST_NID_WIDTH)
 
 /*
  * Define the bit shifts to access each section.  For non-existent
@@ -633,6 +595,7 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
 #define SECTIONS_PGSHIFT        (SECTIONS_PGOFF * (SECTIONS_WIDTH != 0))
 #define NODES_PGSHIFT           (NODES_PGOFF * (NODES_WIDTH != 0))
 #define ZONES_PGSHIFT           (ZONES_PGOFF * (ZONES_WIDTH != 0))
+#define LAST_NID_PGSHIFT        (LAST_NID_PGOFF * (LAST_NID_WIDTH != 0))
 
 /* NODE:ZONE or SECTION:ZONE is used to ID a zone for the buddy allocator */
 #ifdef NODE_NOT_IN_PAGE_FLAGS
@@ -654,6 +617,7 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
 #define ZONES_MASK              ((1UL << ZONES_WIDTH) - 1)
 #define NODES_MASK              ((1UL << NODES_WIDTH) - 1)
 #define SECTIONS_MASK           ((1UL << SECTIONS_WIDTH) - 1)
+#define LAST_NID_MASK           ((1UL << LAST_NID_WIDTH) - 1)
 #define ZONEID_MASK             ((1UL << ZONEID_SHIFT) - 1)
 
 static inline enum zone_type page_zonenum(const struct page *page)
@@ -661,6 +625,10 @@ static inline enum zone_type page_zonenum(const struct page *page)
         return (page->flags >> ZONES_PGSHIFT) & ZONES_MASK;
 }
 
+#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
+#define SECTION_IN_PAGE_FLAGS
+#endif
+
 /*
  * The identification function is only used by the buddy allocator for
  * determining if two pages could be buddies. We are not really
@@ -693,31 +661,48 @@ static inline int page_to_nid(const struct page *page)
 #endif
 
 #ifdef CONFIG_NUMA_BALANCING
-static inline int page_xchg_last_nid(struct page *page, int nid)
+#ifdef LAST_NID_NOT_IN_PAGE_FLAGS
+static inline int page_nid_xchg_last(struct page *page, int nid)
 {
         return xchg(&page->_last_nid, nid);
 }
 
-static inline int page_last_nid(struct page *page)
+static inline int page_nid_last(struct page *page)
 {
         return page->_last_nid;
 }
-static inline void reset_page_last_nid(struct page *page)
+static inline void page_nid_reset_last(struct page *page)
 {
         page->_last_nid = -1;
 }
 #else
-static inline int page_xchg_last_nid(struct page *page, int nid)
+static inline int page_nid_last(struct page *page)
+{
+        return (page->flags >> LAST_NID_PGSHIFT) & LAST_NID_MASK;
+}
+
+extern int page_nid_xchg_last(struct page *page, int nid);
+
+static inline void page_nid_reset_last(struct page *page)
+{
+        int nid = (1 << LAST_NID_SHIFT) - 1;
+
+        page->flags &= ~(LAST_NID_MASK << LAST_NID_PGSHIFT);
+        page->flags |= (nid & LAST_NID_MASK) << LAST_NID_PGSHIFT;
+}
+#endif /* LAST_NID_NOT_IN_PAGE_FLAGS */
+#else
+static inline int page_nid_xchg_last(struct page *page, int nid)
 {
         return page_to_nid(page);
 }
 
-static inline int page_last_nid(struct page *page)
+static inline int page_nid_last(struct page *page)
 {
         return page_to_nid(page);
 }
 
-static inline void reset_page_last_nid(struct page *page)
+static inline void page_nid_reset_last(struct page *page)
 {
 }
 #endif
@@ -727,7 +712,7 @@ static inline struct zone *page_zone(const struct page *page)
         return &NODE_DATA(page_to_nid(page))->node_zones[page_zonenum(page)];
 }
 
-#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
+#ifdef SECTION_IN_PAGE_FLAGS
 static inline void set_page_section(struct page *page, unsigned long section)
 {
         page->flags &= ~(SECTIONS_MASK << SECTIONS_PGSHIFT);
@@ -757,7 +742,7 @@ static inline void set_page_links(struct page *page, enum zone_type zone,
 {
         set_page_zone(page, zone);
         set_page_node(page, node);
-#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
+#ifdef SECTION_IN_PAGE_FLAGS
         set_page_section(page, pfn_to_section_nr(pfn));
 #endif
 }
@@ -817,18 +802,7 @@ void page_address_init(void);
 #define PAGE_MAPPING_KSM        2
 #define PAGE_MAPPING_FLAGS      (PAGE_MAPPING_ANON | PAGE_MAPPING_KSM)
 
-extern struct address_space swapper_space;
-static inline struct address_space *page_mapping(struct page *page)
-{
-        struct address_space *mapping = page->mapping;
-
-        VM_BUG_ON(PageSlab(page));
-        if (unlikely(PageSwapCache(page)))
-                mapping = &swapper_space;
-        else if ((unsigned long)mapping & PAGE_MAPPING_ANON)
-                mapping = NULL;
-        return mapping;
-}
+extern struct address_space *page_mapping(struct page *page);
 
 /* Neutral page->mapping pointer to address_space or anon_vma or other */
 static inline void *page_rmapping(struct page *page)
@@ -1035,18 +1009,18 @@ static inline int fixup_user_fault(struct task_struct *tsk,
 }
 #endif
 
-extern int make_pages_present(unsigned long addr, unsigned long end);
 extern int access_process_vm(struct task_struct *tsk, unsigned long addr, void *buf, int len, int write);
 extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
                 void *buf, int len, int write);
 
-int __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
-                     unsigned long start, int len, unsigned int foll_flags,
-                     struct page **pages, struct vm_area_struct **vmas,
-                     int *nonblocking);
-int get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
-                        unsigned long start, int nr_pages, int write, int force,
-                        struct page **pages, struct vm_area_struct **vmas);
+long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm,
+                      unsigned long start, unsigned long nr_pages,
+                      unsigned int foll_flags, struct page **pages,
+                      struct vm_area_struct **vmas, int *nonblocking);
+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);
 int get_user_pages_fast(unsigned long start, int nr_pages, int write,
                         struct page **pages);
 struct kvec;
@@ -1359,6 +1333,24 @@ extern void free_bootmem_with_active_regions(int nid,
                                                 unsigned long max_low_pfn);
 extern void sparse_memory_present_with_active_regions(int nid);
 
+#define MOVABLEMEM_MAP_MAX MAX_NUMNODES
+struct movablemem_entry {
+        unsigned long start_pfn;    /* start pfn of memory segment */
+        unsigned long end_pfn;      /* end pfn of memory segment (exclusive) */
+};
+
+struct movablemem_map {
+        bool acpi;      /* true if using SRAT info */
+        int nr_map;
+        struct movablemem_entry map[MOVABLEMEM_MAP_MAX];
+        nodemask_t numa_nodes_hotplug;  /* on which nodes we specify memory */
+        nodemask_t numa_nodes_kernel;   /* on which nodes kernel resides in */
+};
+
+extern void __init insert_movablemem_map(unsigned long start_pfn,
+                                         unsigned long end_pfn);
+extern int __init movablemem_map_overlap(unsigned long start_pfn,
+                                         unsigned long end_pfn);
 #endif /* CONFIG_HAVE_MEMBLOCK_NODE_MAP */
 
 #if !defined(CONFIG_HAVE_MEMBLOCK_NODE_MAP) && \
@@ -1386,7 +1378,6 @@ extern void __init mmap_init(void);
 extern void show_mem(unsigned int flags);
 extern void si_meminfo(struct sysinfo * val);
 extern void si_meminfo_node(struct sysinfo *val, int nid);
-extern int after_bootmem;
 
 extern __printf(3, 4)
 void warn_alloc_failed(gfp_t gfp_mask, int order, const char *fmt, ...);
@@ -1396,6 +1387,9 @@ extern void setup_per_cpu_pageset(void);
 extern void zone_pcp_update(struct zone *zone);
 extern void zone_pcp_reset(struct zone *zone);
 
+/* page_alloc.c */
+extern int min_free_kbytes;
+
 /* nommu.c */
 extern atomic_long_t mmap_pages_allocated;
 extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t);
@@ -1473,13 +1467,24 @@ extern int install_special_mapping(struct mm_struct *mm,
 extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
 
 extern unsigned long mmap_region(struct file *file, unsigned long addr,
-        unsigned long len, unsigned long flags,
-        vm_flags_t vm_flags, unsigned long pgoff);
-extern unsigned long do_mmap_pgoff(struct file *, unsigned long,
-        unsigned long, unsigned long,
-        unsigned long, unsigned long);
+        unsigned long len, vm_flags_t vm_flags, unsigned long pgoff);
+extern unsigned long do_mmap_pgoff(struct file *file, unsigned long addr,
+        unsigned long len, unsigned long prot, unsigned long flags,
+        unsigned long pgoff, unsigned long *populate);
 extern int do_munmap(struct mm_struct *, unsigned long, size_t);
 
+#ifdef CONFIG_MMU
+extern int __mm_populate(unsigned long addr, unsigned long len,
+                         int ignore_errors);
+static inline void mm_populate(unsigned long addr, unsigned long len)
+{
+        /* Ignore errors */
+        (void) __mm_populate(addr, len, 1);
+}
+#else
+static inline void mm_populate(unsigned long addr, unsigned long len) {}
+#endif
+
 /* These take the mm semaphore themselves */
 extern unsigned long vm_brk(unsigned long, unsigned long);
 extern int vm_munmap(unsigned long, size_t);
@@ -1624,8 +1629,17 @@ int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
 int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
                         unsigned long pfn);
 
-struct page *follow_page(struct vm_area_struct *, unsigned long address,
-                        unsigned int foll_flags);
+struct page *follow_page_mask(struct vm_area_struct *vma,
+                              unsigned long address, unsigned int foll_flags,
+                              unsigned int *page_mask);
+
+static inline struct page *follow_page(struct vm_area_struct *vma,
+                unsigned long address, unsigned int foll_flags)
+{
+        unsigned int unused_page_mask;
+        return follow_page_mask(vma, address, foll_flags, &unused_page_mask);
+}
+
 #define FOLL_WRITE      0x01    /* check pte is writable */
 #define FOLL_TOUCH      0x02    /* mark page accessed */
 #define FOLL_GET        0x04    /* do get_page on page */
@@ -1637,6 +1651,7 @@ struct page *follow_page(struct vm_area_struct *, unsigned long address,
 #define FOLL_SPLIT      0x80    /* don't return transhuge pages, split them */
 #define FOLL_HWPOISON   0x100   /* check page is hwpoisoned */
 #define FOLL_NUMA       0x200   /* force NUMA hinting page fault */
+#define FOLL_MIGRATION  0x400   /* wait for page to replace migration entry */
 
 typedef int (*pte_fn_t)(pte_t *pte, pgtable_t token, unsigned long addr,
                         void *data);
@@ -1708,7 +1723,11 @@ int vmemmap_populate_basepages(struct page *start_page,
                                                 unsigned long pages, int node);
 int vmemmap_populate(struct page *start_page, unsigned long pages, int node);
 void vmemmap_populate_print_last(void);
-
+#ifdef CONFIG_MEMORY_HOTPLUG
+void vmemmap_free(struct page *memmap, unsigned long nr_pages);
+#endif
+void register_page_bootmem_memmap(unsigned long section_nr, struct page *map,
+                                  unsigned long size);
 
 enum mf_flags {
         MF_COUNT_INCREASED = 1 << 0,
@@ -1721,7 +1740,7 @@ extern int unpoison_memory(unsigned long pfn);
 extern int sysctl_memory_failure_early_kill;
 extern int sysctl_memory_failure_recovery;
 extern void shake_page(struct page *p, int access);
-extern atomic_long_t mce_bad_pages;
+extern atomic_long_t num_poisoned_pages;
 extern int soft_offline_page(struct page *page, int flags);
 
 extern void dump_page(struct page *page);
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index f8f5162a3571..ace9a5f01c64 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -12,6 +12,7 @@
 #include <linux/cpumask.h>
 #include <linux/page-debug-flags.h>
 #include <linux/uprobes.h>
+#include <linux/page-flags-layout.h>
 #include <asm/page.h>
 #include <asm/mmu.h>
 
@@ -173,7 +174,7 @@ struct page {
         void *shadow;
 #endif
 
-#ifdef CONFIG_NUMA_BALANCING
+#ifdef LAST_NID_NOT_IN_PAGE_FLAGS
         int _last_nid;
 #endif
 }
@@ -414,9 +415,9 @@ struct mm_struct {
 #endif
 #ifdef CONFIG_NUMA_BALANCING
         /*
-         * numa_next_scan is the next time when the PTEs will me marked
-         * pte_numa to gather statistics and migrate pages to new nodes
-         * if necessary
+         * numa_next_scan is the next time that the PTEs will be marked
+         * pte_numa. NUMA hinting faults will gather statistics and migrate
+         * pages to new nodes if necessary.
          */
         unsigned long numa_next_scan;
 
diff --git a/include/linux/mman.h b/include/linux/mman.h
index 9aa863da287f..61c7a87e5d2b 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -79,6 +79,8 @@ calc_vm_flag_bits(unsigned long flags)
 {
         return _calc_vm_trans(flags, MAP_GROWSDOWN,  VM_GROWSDOWN ) |
                _calc_vm_trans(flags, MAP_DENYWRITE,  VM_DENYWRITE ) |
-               _calc_vm_trans(flags, MAP_LOCKED,     VM_LOCKED    );
+               ((flags & MAP_LOCKED) ? (VM_LOCKED | VM_POPULATE) : 0) |
+               (((flags & (MAP_POPULATE | MAP_NONBLOCK)) == MAP_POPULATE) ?
+                                                        VM_POPULATE : 0);
 }
 #endif /* _LINUX_MMAN_H */
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 5c69315d60cc..61b2c30c903b 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -53,6 +53,9 @@ struct mmc_ext_csd {
         u8                      part_config;
         u8                      cache_ctrl;
         u8                      rst_n_function;
+        u8                      max_packed_writes;
+        u8                      max_packed_reads;
+        u8                      packed_event_en;
         unsigned int            part_time;              /* Units: ms */
         unsigned int            sa_timeout;             /* Units: 100ns */
         unsigned int            generic_cmd6_time;      /* Units: 10ms */
@@ -83,7 +86,7 @@ struct mmc_ext_csd {
         unsigned int            data_tag_unit_size;     /* DATA TAG UNIT size */
         unsigned int            boot_ro_lock;           /* ro lock support */
         bool                    boot_ro_lockable;
-        u8                      raw_exception_status;   /* 53 */
+        u8                      raw_exception_status;   /* 54 */
         u8                      raw_partition_support;  /* 160 */
         u8                      raw_rpmb_size_mult;     /* 168 */
         u8                      raw_erased_mem_count;   /* 181 */
@@ -187,6 +190,18 @@ struct sdio_func_tuple;
 
 #define SDIO_MAX_FUNCS          7
 
+enum mmc_blk_status {
+        MMC_BLK_SUCCESS = 0,
+        MMC_BLK_PARTIAL,
+        MMC_BLK_CMD_ERR,
+        MMC_BLK_RETRY,
+        MMC_BLK_ABORT,
+        MMC_BLK_DATA_ERR,
+        MMC_BLK_ECC_ERR,
+        MMC_BLK_NOMEDIUM,
+        MMC_BLK_NEW_REQUEST,
+};
+
 /* The number of MMC physical partitions.  These consist of:
  * boot partitions (2), general purpose partitions (4) in MMC v4.4.
  */
@@ -295,6 +310,11 @@ static inline void mmc_part_add(struct mmc_card *card, unsigned int size,
         card->nr_parts++;
 }
 
+static inline bool mmc_large_sector(struct mmc_card *card)
+{
+        return card->ext_csd.data_sector_size == 4096;
+}
+
 /*
  *  The world is not perfect and supplies us with broken mmc/sdio devices.
  *  For at least some of these bugs we need a work-around.
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 5bf7c2274fcb..39613b9a6fc5 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -18,6 +18,9 @@ struct mmc_request;
 struct mmc_command {
         u32                     opcode;
         u32                     arg;
+#define MMC_CMD23_ARG_REL_WR    (1 << 31)
+#define MMC_CMD23_ARG_PACKED    ((0 << 31) | (1 << 30))
+#define MMC_CMD23_ARG_TAG_REQ   (1 << 29)
         u32                     resp[4];
         unsigned int            flags;          /* expected response type */
 #define MMC_RSP_PRESENT (1 << 0)
@@ -120,6 +123,7 @@ struct mmc_data {
         s32                     host_cookie;    /* host private data */
 };
 
+struct mmc_host;
 struct mmc_request {
         struct mmc_command      *sbc;           /* SET_BLOCK_COUNT for multiblock */
         struct mmc_command      *cmd;
@@ -128,9 +132,9 @@ struct mmc_request {
 
         struct completion       completion;
         void                    (*done)(struct mmc_request *);/* completion function */
+        struct mmc_host         *host;
 };
 
-struct mmc_host;
 struct mmc_card;
 struct mmc_async_req;
 
@@ -147,6 +151,7 @@ extern int mmc_wait_for_app_cmd(struct mmc_host *, struct mmc_card *,
 extern void mmc_start_bkops(struct mmc_card *card, bool from_exception);
 extern int __mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int, bool);
 extern int mmc_switch(struct mmc_card *, u8, u8, u8, unsigned int);
+extern int mmc_send_ext_csd(struct mmc_card *card, u8 *ext_csd);
 
 #define MMC_ERASE_ARG           0x00000000
 #define MMC_SECURE_ERASE_ARG    0x80000000
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 34be4f47293c..198f0fa44e9f 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -209,8 +209,10 @@ struct dw_mci_dma_ops {
 #define DW_MCI_QUIRK_HIGHSPEED                  BIT(2)
 /* Unreliable card detection */
 #define DW_MCI_QUIRK_BROKEN_CARD_DETECTION      BIT(3)
-/* Write Protect detection not available */
-#define DW_MCI_QUIRK_NO_WRITE_PROTECT           BIT(4)
+
+/* Slot level quirks */
+/* This slot has no write protect */
+#define DW_MCI_SLOT_QUIRK_NO_WRITE_PROTECT      BIT(0)
 
 struct dma_pdata;
 
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 61a10c17aabd..d6f20cc6415e 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -131,9 +131,11 @@ struct mmc_host_ops {
 
         int     (*start_signal_voltage_switch)(struct mmc_host *host, struct mmc_ios *ios);
 
+        /* Check if the card is pulling dat[0:3] low */
+        int     (*card_busy)(struct mmc_host *host);
+
         /* The tuning command opcode value is different for SD and eMMC cards */
         int     (*execute_tuning)(struct mmc_host *host, u32 opcode);
-        void    (*enable_preset_value)(struct mmc_host *host, bool enable);
         int     (*select_drive_strength)(unsigned int max_dtr, int host_drv, int card_drv);
         void    (*hw_reset)(struct mmc_host *host);
         void    (*card_event)(struct mmc_host *host);
@@ -170,6 +172,22 @@ struct mmc_slot {
         void *handler_priv;
 };
 
+/**
+ * mmc_context_info - synchronization details for mmc context
+ * @is_done_rcv         wake up reason was done request
+ * @is_new_req          wake up reason was new request
+ * @is_waiting_last_req mmc context waiting for single running request
+ * @wait                wait queue
+ * @lock                lock to protect data fields
+ */
+struct mmc_context_info {
+        bool                    is_done_rcv;
+        bool                    is_new_req;
+        bool                    is_waiting_last_req;
+        wait_queue_head_t       wait;
+        spinlock_t              lock;
+};
+
 struct regulator;
 
 struct mmc_supply {
@@ -258,6 +276,10 @@ struct mmc_host {
 #define MMC_CAP2_HC_ERASE_SZ    (1 << 9)        /* High-capacity erase size */
 #define MMC_CAP2_CD_ACTIVE_HIGH (1 << 10)       /* Card-detect signal active high */
 #define MMC_CAP2_RO_ACTIVE_HIGH (1 << 11)       /* Write-protect signal active high */
+#define MMC_CAP2_PACKED_RD      (1 << 12)       /* Allow packed read */
+#define MMC_CAP2_PACKED_WR      (1 << 13)       /* Allow packed write */
+#define MMC_CAP2_PACKED_CMD     (MMC_CAP2_PACKED_RD | \
+                                 MMC_CAP2_PACKED_WR)
 
         mmc_pm_flag_t           pm_caps;        /* supported pm features */
 
@@ -331,6 +353,7 @@ struct mmc_host {
         struct dentry           *debugfs_root;
 
         struct mmc_async_req    *areq;          /* active async req */
+        struct mmc_context_info context_info;   /* async synchronization info */
 
 #ifdef CONFIG_FAIL_MMC_REQUEST
         struct fault_attr       fail_mmc_request;
@@ -341,10 +364,11 @@ struct mmc_host {
         unsigned long           private[0] ____cacheline_aligned;
 };
 
-extern struct mmc_host *mmc_alloc_host(int extra, struct device *);
-extern int mmc_add_host(struct mmc_host *);
-extern void mmc_remove_host(struct mmc_host *);
-extern void mmc_free_host(struct mmc_host *);
+struct mmc_host *mmc_alloc_host(int extra, struct device *);
+int mmc_add_host(struct mmc_host *);
+void mmc_remove_host(struct mmc_host *);
+void mmc_free_host(struct mmc_host *);
+void mmc_of_parse(struct mmc_host *host);
 
 static inline void *mmc_priv(struct mmc_host *host)
 {
@@ -357,16 +381,16 @@ static inline void *mmc_priv(struct mmc_host *host)
 #define mmc_classdev(x) (&(x)->class_dev)
 #define mmc_hostname(x) (dev_name(&(x)->class_dev))
 
-extern int mmc_suspend_host(struct mmc_host *);
-extern int mmc_resume_host(struct mmc_host *);
+int mmc_suspend_host(struct mmc_host *);
+int mmc_resume_host(struct mmc_host *);
 
-extern int mmc_power_save_host(struct mmc_host *host);
-extern int mmc_power_restore_host(struct mmc_host *host);
+int mmc_power_save_host(struct mmc_host *host);
+int mmc_power_restore_host(struct mmc_host *host);
 
-extern void mmc_detect_change(struct mmc_host *, unsigned long delay);
-extern void mmc_request_done(struct mmc_host *, struct mmc_request *);
+void mmc_detect_change(struct mmc_host *, unsigned long delay);
+void mmc_request_done(struct mmc_host *, struct mmc_request *);
 
-extern int mmc_cache_ctrl(struct mmc_host *, u8);
+int mmc_cache_ctrl(struct mmc_host *, u8);
 
 static inline void mmc_signal_sdio_irq(struct mmc_host *host)
 {
@@ -434,6 +458,19 @@ static inline int mmc_boot_partition_access(struct mmc_host *host)
         return !(host->caps2 & MMC_CAP2_BOOTPART_NOACC);
 }
 
+static inline int mmc_host_uhs(struct mmc_host *host)
+{
+        return host->caps &
+                (MMC_CAP_UHS_SDR12 | MMC_CAP_UHS_SDR25 |
+                 MMC_CAP_UHS_SDR50 | MMC_CAP_UHS_SDR104 |
+                 MMC_CAP_UHS_DDR50);
+}
+
+static inline int mmc_host_packed_wr(struct mmc_host *host)
+{
+        return host->caps2 & MMC_CAP2_PACKED_WR;
+}
+
 #ifdef CONFIG_MMC_CLKGATE
 void mmc_host_clk_hold(struct mmc_host *host);
 void mmc_host_clk_release(struct mmc_host *host);
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 94d532e41c61..50bcde3677ca 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -139,7 +139,7 @@ static inline bool mmc_op_multi(u32 opcode)
 #define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
 #define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
 #define R1_SWITCH_ERROR         (1 << 7)        /* sx, c */
-#define R1_EXCEPTION_EVENT      (1 << 6)        /* sx, a */
+#define R1_EXCEPTION_EVENT      (1 << 6)        /* sr, a */
 #define R1_APP_CMD              (1 << 5)        /* sr, c */
 
 #define R1_STATE_IDLE   0
@@ -275,7 +275,10 @@ struct _mmc_csd {
 #define EXT_CSD_FLUSH_CACHE             32      /* W */
 #define EXT_CSD_CACHE_CTRL              33      /* R/W */
 #define EXT_CSD_POWER_OFF_NOTIFICATION  34      /* R/W */
-#define EXT_CSD_EXP_EVENTS_STATUS       54      /* RO */
+#define EXT_CSD_PACKED_FAILURE_INDEX    35      /* RO */
+#define EXT_CSD_PACKED_CMD_STATUS       36      /* RO */
+#define EXT_CSD_EXP_EVENTS_STATUS       54      /* RO, 2 bytes */
+#define EXT_CSD_EXP_EVENTS_CTRL         56      /* R/W, 2 bytes */
 #define EXT_CSD_DATA_SECTOR_SIZE        61      /* R */
 #define EXT_CSD_GP_SIZE_MULT            143     /* R/W */
 #define EXT_CSD_PARTITION_ATTRIBUTE     156     /* R/W */
@@ -324,6 +327,8 @@ struct _mmc_csd {
 #define EXT_CSD_CACHE_SIZE              249     /* RO, 4 bytes */
 #define EXT_CSD_TAG_UNIT_SIZE           498     /* RO */
 #define EXT_CSD_DATA_TAG_SUPPORT        499     /* RO */
+#define EXT_CSD_MAX_PACKED_WRITES       500     /* RO */
+#define EXT_CSD_MAX_PACKED_READS        501     /* RO */
 #define EXT_CSD_BKOPS_SUPPORT           502     /* RO */
 #define EXT_CSD_HPI_FEATURES            503     /* RO */
 
@@ -385,6 +390,9 @@ struct _mmc_csd {
 #define EXT_CSD_PWR_CL_4BIT_MASK        0x0F    /* 8 bit PWR CLS */
 #define EXT_CSD_PWR_CL_8BIT_SHIFT       4
 #define EXT_CSD_PWR_CL_4BIT_SHIFT       0
+
+#define EXT_CSD_PACKED_EVENT_EN BIT(3)
+
 /*
  * EXCEPTION_EVENT_STATUS field
  */
@@ -393,6 +401,9 @@ struct _mmc_csd {
 #define EXT_CSD_SYSPOOL_EXHAUSTED       BIT(2)
 #define EXT_CSD_PACKED_FAILURE          BIT(3)
 
+#define EXT_CSD_PACKED_GENERIC_ERROR    BIT(0)
+#define EXT_CSD_PACKED_INDEXED_ERROR    BIT(1)
+
 /*
  * BKOPS status level
  */
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 4bbc3301fbbf..b838ffc49e4a 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -94,6 +94,7 @@ struct sdhci_host {
 #define SDHCI_QUIRK2_HOST_NO_CMD23                      (1<<1)
 /* The system physically doesn't support 1.8v, even if the host does */
 #define SDHCI_QUIRK2_NO_1_8_V                           (1<<2)
+#define SDHCI_QUIRK2_PRESET_VALUE_BROKEN                (1<<3)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
diff --git a/include/linux/mmc/sh_mobile_sdhi.h b/include/linux/mmc/sh_mobile_sdhi.h
index b65679ffa880..b76bcf0621f6 100644
--- a/include/linux/mmc/sh_mobile_sdhi.h
+++ b/include/linux/mmc/sh_mobile_sdhi.h
@@ -4,7 +4,6 @@
 #include <linux/types.h>
 
 struct platform_device;
-struct tmio_mmc_data;
 
 #define SH_MOBILE_SDHI_IRQ_CARD_DETECT  "card_detect"
 #define SH_MOBILE_SDHI_IRQ_SDCARD       "sdcard"
@@ -26,7 +25,6 @@ struct sh_mobile_sdhi_info {
         unsigned long tmio_caps2;
         u32 tmio_ocr_mask;      /* available MMC voltages */
         unsigned int cd_gpio;
-        struct tmio_mmc_data *pdata;
         void (*set_pwr)(struct platform_device *pdev, int state);
         int (*get_cd)(struct platform_device *pdev);
 
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 73b64a38b984..ede274957e05 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -15,7 +15,7 @@
 #include <linux/seqlock.h>
 #include <linux/nodemask.h>
 #include <linux/pageblock-flags.h>
-#include <generated/bounds.h>
+#include <linux/page-flags-layout.h>
 #include <linux/atomic.h>
 #include <asm/page.h>
 
@@ -57,7 +57,9 @@ enum {
          */
         MIGRATE_CMA,
 #endif
+#ifdef CONFIG_MEMORY_ISOLATION
         MIGRATE_ISOLATE,        /* can't allocate from here */
+#endif
         MIGRATE_TYPES
 };
 
@@ -308,24 +310,6 @@ enum zone_type {
 
 #ifndef __GENERATING_BOUNDS_H
 
-/*
- * When a memory allocation must conform to specific limitations (such
- * as being suitable for DMA) the caller will pass in hints to the
- * allocator in the gfp_mask, in the zone modifier bits.  These bits
- * are used to select a priority ordered list of memory zones which
- * match the requested limits. See gfp_zone() in include/linux/gfp.h
- */
-
-#if MAX_NR_ZONES < 2
-#define ZONES_SHIFT 0
-#elif MAX_NR_ZONES <= 2
-#define ZONES_SHIFT 1
-#elif MAX_NR_ZONES <= 4
-#define ZONES_SHIFT 2
-#else
-#error ZONES_SHIFT -- too many zones configured adjust calculation
-#endif
-
 struct zone {
         /* Fields commonly accessed by the page allocator */
 
@@ -543,6 +527,26 @@ static inline int zone_is_oom_locked(const struct zone *zone)
         return test_bit(ZONE_OOM_LOCKED, &zone->flags);
 }
 
+static inline unsigned zone_end_pfn(const struct zone *zone)
+{
+        return zone->zone_start_pfn + zone->spanned_pages;
+}
+
+static inline bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
+{
+        return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
+}
+
+static inline bool zone_is_initialized(struct zone *zone)
+{
+        return !!zone->wait_table;
+}
+
+static inline bool zone_is_empty(struct zone *zone)
+{
+        return zone->spanned_pages == 0;
+}
+
 /*
  * The "priority" of VM scanning is how much of the queues we will scan in one
  * go. A value of 12 for DEF_PRIORITY implies that we will scan 1/4096th of the
@@ -752,11 +756,17 @@ typedef struct pglist_data {
 #define nid_page_nr(nid, pagenr)        pgdat_page_nr(NODE_DATA(nid),(pagenr))
 
 #define node_start_pfn(nid)     (NODE_DATA(nid)->node_start_pfn)
+#define node_end_pfn(nid) pgdat_end_pfn(NODE_DATA(nid))
 
-#define node_end_pfn(nid) ({\
-        pg_data_t *__pgdat = NODE_DATA(nid);\
-        __pgdat->node_start_pfn + __pgdat->node_spanned_pages;\
-})
+static inline unsigned long pgdat_end_pfn(pg_data_t *pgdat)
+{
+        return pgdat->node_start_pfn + pgdat->node_spanned_pages;
+}
+
+static inline bool pgdat_is_empty(pg_data_t *pgdat)
+{
+        return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
+}
 
 #include <linux/memory_hotplug.h>
 
@@ -1053,8 +1063,6 @@ static inline unsigned long early_pfn_to_nid(unsigned long pfn)
  * PA_SECTION_SHIFT             physical address to/from section number
  * PFN_SECTION_SHIFT            pfn to/from section number
  */
-#define SECTIONS_SHIFT          (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)
-
 #define PA_SECTION_SHIFT        (SECTION_SIZE_BITS)
 #define PFN_SECTION_SHIFT       (SECTION_SIZE_BITS - PAGE_SHIFT)
 
diff --git a/include/linux/module.h b/include/linux/module.h
index 1375ee3f03aa..ead1b5719a12 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -396,13 +396,13 @@ bool is_module_address(unsigned long addr);
 bool is_module_percpu_address(unsigned long addr);
 bool is_module_text_address(unsigned long addr);
 
-static inline int within_module_core(unsigned long addr, struct module *mod)
+static inline int within_module_core(unsigned long addr, const struct module *mod)
 {
         return (unsigned long)mod->module_core <= addr &&
                addr < (unsigned long)mod->module_core + mod->core_size;
 }
 
-static inline int within_module_init(unsigned long addr, struct module *mod)
+static inline int within_module_init(unsigned long addr, const struct module *mod)
 {
         return (unsigned long)mod->module_init <= addr &&
                addr < (unsigned long)mod->module_init + mod->init_size;
diff --git a/include/linux/mroute.h b/include/linux/mroute.h
index ea00d9162ee5..79aaa9fc1a15 100644
--- a/include/linux/mroute.h
+++ b/include/linux/mroute.h
@@ -9,7 +9,7 @@
 #ifdef CONFIG_IP_MROUTE
 static inline int ip_mroute_opt(int opt)
 {
-        return (opt >= MRT_BASE) && (opt <= MRT_BASE + 10);
+        return (opt >= MRT_BASE) && (opt <= MRT_MAX);
 }
 #else
 static inline int ip_mroute_opt(int opt)
diff --git a/include/linux/mroute6.h b/include/linux/mroute6.h
index a223561ba12e..66982e764051 100644
--- a/include/linux/mroute6.h
+++ b/include/linux/mroute6.h
@@ -10,7 +10,7 @@
 #ifdef CONFIG_IPV6_MROUTE
 static inline int ip6_mroute_opt(int opt)
 {
-        return (opt >= MRT6_BASE) && (opt <= MRT6_BASE + 10);
+        return (opt >= MRT6_BASE) && (opt <= MRT6_MAX);
 }
 #else
 static inline int ip6_mroute_opt(int opt)
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 5ac32123035a..3dd39340430e 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -41,7 +41,7 @@ enum {
         NETIF_F_TSO_ECN_BIT,            /* ... TCP ECN support */
         NETIF_F_TSO6_BIT,               /* ... TCPv6 segmentation */
         NETIF_F_FSO_BIT,                /* ... FCoE segmentation */
-        NETIF_F_GSO_RESERVED1,          /* ... free (fill GSO_MASK to 8 bits) */
+        NETIF_F_GSO_GRE_BIT,            /* ... GRE with TSO */
         /**/NETIF_F_GSO_LAST,           /* [can't be last bit, see GSO_MASK] */
         NETIF_F_GSO_RESERVED2           /* ... free (fill GSO_MASK to 8 bits) */
                 = NETIF_F_GSO_LAST,
@@ -102,6 +102,7 @@ enum {
 #define NETIF_F_VLAN_CHALLENGED __NETIF_F(VLAN_CHALLENGED)
 #define NETIF_F_RXFCS           __NETIF_F(RXFCS)
 #define NETIF_F_RXALL           __NETIF_F(RXALL)
+#define NETIF_F_GRE_GSO         __NETIF_F(GSO_GRE)
 
 /* Features valid for ethtool to change */
 /* = all defined minus driver/device-class-related */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 9ef07d0868b6..b3d00fa4b314 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -67,6 +67,8 @@ extern void netdev_set_default_ethtool_ops(struct net_device *dev,
 #define NET_ADDR_PERM           0       /* address is permanent (default) */
 #define NET_ADDR_RANDOM         1       /* address is generated randomly */
 #define NET_ADDR_STOLEN         2       /* address is stolen from other device */
+#define NET_ADDR_SET            3       /* address is set using
+                                         * dev_set_mac_address() */
 
 /* Backlog congestion levels */
 #define NET_RX_SUCCESS          0       /* keep 'em coming, baby */
@@ -859,8 +861,7 @@ struct netdev_fcoe_hbainfo {
  *      flow_id is a flow ID to be passed to rps_may_expire_flow() later.
  *      Return the filter ID on success, or a negative error code.
  *
- *      Slave management functions (for bridge, bonding, etc). User should
- *      call netdev_set_master() to set dev->master properly.
+ *      Slave management functions (for bridge, bonding, etc).
  * int (*ndo_add_slave)(struct net_device *dev, struct net_device *slave_dev);
  *      Called to make another netdev an underling.
  *
@@ -883,7 +884,8 @@ struct netdev_fcoe_hbainfo {
  *                    struct net_device *dev,
  *                    const unsigned char *addr, u16 flags)
  *      Adds an FDB entry to dev for addr.
- * int (*ndo_fdb_del)(struct ndmsg *ndm, struct net_device *dev,
+ * int (*ndo_fdb_del)(struct ndmsg *ndm, struct nlattr *tb[],
+ *                    struct net_device *dev,
  *                    const unsigned char *addr)
  *      Deletes the FDB entry from dev coresponding to addr.
  * int (*ndo_fdb_dump)(struct sk_buff *skb, struct netlink_callback *cb,
@@ -894,6 +896,14 @@ struct netdev_fcoe_hbainfo {
  * int (*ndo_bridge_setlink)(struct net_device *dev, struct nlmsghdr *nlh)
  * int (*ndo_bridge_getlink)(struct sk_buff *skb, u32 pid, u32 seq,
  *                           struct net_device *dev)
+ *
+ * int (*ndo_change_carrier)(struct net_device *dev, bool new_carrier);
+ *      Called to change device carrier. Soft-devices (like dummy, team, etc)
+ *      which do not represent real hardware may define this to allow their
+ *      userspace components to manage their virtual carrier state. Devices
+ *      that determine carrier state from physical hardware properties (eg
+ *      network cables) or protocol-dependent mechanisms (eg
+ *      USB_CDC_NOTIFY_NETWORK_CONNECTION) should NOT implement this function.
  */
 struct net_device_ops {
         int                     (*ndo_init)(struct net_device *dev);
@@ -999,6 +1009,7 @@ struct net_device_ops {
                                                const unsigned char *addr,
                                                u16 flags);
         int                     (*ndo_fdb_del)(struct ndmsg *ndm,
+                                               struct nlattr *tb[],
                                                struct net_device *dev,
                                                const unsigned char *addr);
         int                     (*ndo_fdb_dump)(struct sk_buff *skb,
@@ -1010,7 +1021,12 @@ struct net_device_ops {
                                                       struct nlmsghdr *nlh);
         int                     (*ndo_bridge_getlink)(struct sk_buff *skb,
                                                       u32 pid, u32 seq,
-                                                      struct net_device *dev);
+                                                      struct net_device *dev,
+                                                      u32 filter_mask);
+        int                     (*ndo_bridge_dellink)(struct net_device *dev,
+                                                      struct nlmsghdr *nlh);
+        int                     (*ndo_change_carrier)(struct net_device *dev,
+                                                      bool new_carrier);
 };
 
 /*
@@ -1161,9 +1177,7 @@ struct net_device {
                                                  * avoid dirtying this cache line.
                                                  */
 
-        struct net_device       *master; /* Pointer to master device of a group,
-                                          * which this device is member of.
-                                          */
+        struct list_head        upper_dev_list; /* List of upper devices */
 
         /* Interface address info used in eth_type_trans() */
         unsigned char           *dev_addr;      /* hw address, (before bcast
@@ -1263,7 +1277,7 @@ struct net_device {
         void (*destructor)(struct net_device *dev);
 
 #ifdef CONFIG_NETPOLL
-        struct netpoll_info     *npinfo;
+        struct netpoll_info __rcu       *npinfo;
 #endif
 
 #ifdef CONFIG_NET_NS
@@ -1277,9 +1291,12 @@ struct net_device {
                 struct pcpu_lstats __percpu     *lstats; /* loopback stats */
                 struct pcpu_tstats __percpu     *tstats; /* tunnel stats */
                 struct pcpu_dstats __percpu     *dstats; /* dummy stats */
+                struct pcpu_vstats __percpu     *vstats; /* veth stats */
         };
         /* GARP */
         struct garp_port __rcu  *garp_port;
+        /* MRP */
+        struct mrp_port __rcu   *mrp_port;
 
         /* class/net/name entry */
         struct device           dev;
@@ -1396,6 +1413,7 @@ static inline void netdev_for_each_tx_queue(struct net_device *dev,
 
 extern struct netdev_queue *netdev_pick_tx(struct net_device *dev,
                                            struct sk_buff *skb);
+extern u16 __netdev_pick_tx(struct net_device *dev, struct sk_buff *skb);
 
 /*
  * Net namespace inlines
@@ -2095,6 +2113,18 @@ static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
                 __netif_schedule(txq->qdisc);
 }
 
+#ifdef CONFIG_XPS
+extern int netif_set_xps_queue(struct net_device *dev, struct cpumask *mask,
+                               u16 index);
+#else
+static inline int netif_set_xps_queue(struct net_device *dev,
+                                      struct cpumask *mask,
+                                      u16 index)
+{
+        return 0;
+}
+#endif
+
 /*
  * Returns a Tx hash for the given packet when dev->real_num_tx_queues is used
  * as a distribution range limit for the returned value.
@@ -2197,6 +2227,8 @@ extern int		dev_set_mtu(struct net_device *, int);
 extern void             dev_set_group(struct net_device *, int);
 extern int              dev_set_mac_address(struct net_device *,
                                             struct sockaddr *);
+extern int              dev_change_carrier(struct net_device *,
+                                           bool new_carrier);
 extern int              dev_hard_start_xmit(struct sk_buff *skb,
                                             struct net_device *dev,
                                             struct netdev_queue *txq);
@@ -2614,7 +2646,6 @@ extern void		netdev_notify_peers(struct net_device *dev);
 extern void             netdev_features_change(struct net_device *dev);
 /* Load a device via the kmod */
 extern void             dev_load(struct net *net, const char *name);
-extern void             dev_mcast_init(void);
 extern struct rtnl_link_stats64 *dev_get_stats(struct net_device *dev,
                                                struct rtnl_link_stats64 *storage);
 extern void netdev_stats_to_stats64(struct rtnl_link_stats64 *stats64,
@@ -2624,12 +2655,30 @@ extern int		netdev_max_backlog;
 extern int              netdev_tstamp_prequeue;
 extern int              weight_p;
 extern int              bpf_jit_enable;
-extern int              netdev_set_master(struct net_device *dev, struct net_device *master);
-extern int netdev_set_bond_master(struct net_device *dev,
-                                  struct net_device *master);
+
+extern bool netdev_has_upper_dev(struct net_device *dev,
+                                 struct net_device *upper_dev);
+extern bool netdev_has_any_upper_dev(struct net_device *dev);
+extern struct net_device *netdev_master_upper_dev_get(struct net_device *dev);
+extern struct net_device *netdev_master_upper_dev_get_rcu(struct net_device *dev);
+extern int netdev_upper_dev_link(struct net_device *dev,
+                                 struct net_device *upper_dev);
+extern int netdev_master_upper_dev_link(struct net_device *dev,
+                                        struct net_device *upper_dev);
+extern void netdev_upper_dev_unlink(struct net_device *dev,
+                                    struct net_device *upper_dev);
 extern int skb_checksum_help(struct sk_buff *skb);
-extern struct sk_buff *skb_gso_segment(struct sk_buff *skb,
-        netdev_features_t features);
+extern struct sk_buff *__skb_gso_segment(struct sk_buff *skb,
+        netdev_features_t features, bool tx_path);
+extern struct sk_buff *skb_mac_gso_segment(struct sk_buff *skb,
+                                          netdev_features_t features);
+
+static inline
+struct sk_buff *skb_gso_segment(struct sk_buff *skb, netdev_features_t features)
+{
+        return __skb_gso_segment(skb, features, true);
+}
+
 #ifdef CONFIG_BUG
 extern void netdev_rx_csum_fault(struct net_device *dev);
 #else
@@ -2642,9 +2691,9 @@ extern void		net_enable_timestamp(void);
 extern void             net_disable_timestamp(void);
 
 #ifdef CONFIG_PROC_FS
-extern void *dev_seq_start(struct seq_file *seq, loff_t *pos);
-extern void *dev_seq_next(struct seq_file *seq, void *v, loff_t *pos);
-extern void dev_seq_stop(struct seq_file *seq, void *v);
+extern int __init dev_proc_init(void);
+#else
+#define dev_proc_init() 0
 #endif
 
 extern int netdev_class_create_file(struct class_attribute *class_attr);
@@ -2846,4 +2895,34 @@ do {								\
 })
 #endif
 
+/*
+ *      The list of packet types we will receive (as opposed to discard)
+ *      and the routines to invoke.
+ *
+ *      Why 16. Because with 16 the only overlap we get on a hash of the
+ *      low nibble of the protocol value is RARP/SNAP/X.25.
+ *
+ *      NOTE:  That is no longer true with the addition of VLAN tags.  Not
+ *             sure which should go first, but I bet it won't make much
+ *             difference if we are running VLANs.  The good news is that
+ *             this protocol won't be in the list unless compiled in, so
+ *             the average user (w/out VLANs) will not be adversely affected.
+ *             --BLG
+ *
+ *              0800    IP
+ *              8100    802.1Q VLAN
+ *              0001    802.3
+ *              0002    AX.25
+ *              0004    802.2
+ *              8035    RARP
+ *              0005    SNAP
+ *              0805    X.25
+ *              0806    ARP
+ *              8137    IPX
+ *              0009    Localtalk
+ *              86DD    IPv6
+ */
+#define PTYPE_HASH_SIZE (16)
+#define PTYPE_HASH_MASK (PTYPE_HASH_SIZE - 1)
+
 #endif  /* _LINUX_NETDEVICE_H */
diff --git a/include/linux/netfilter/nf_conntrack_sip.h b/include/linux/netfilter/nf_conntrack_sip.h
index 387bdd02945d..ba7f571a2b1c 100644
--- a/include/linux/netfilter/nf_conntrack_sip.h
+++ b/include/linux/netfilter/nf_conntrack_sip.h
@@ -4,12 +4,15 @@
 
 #include <net/netfilter/nf_conntrack_expect.h>
 
+#include <linux/types.h>
+
 #define SIP_PORT        5060
 #define SIP_TIMEOUT     3600
 
 struct nf_ct_sip_master {
         unsigned int    register_cseq;
         unsigned int    invite_cseq;
+        __be16          forced_dport;
 };
 
 enum sip_expectation_classes {
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 4966ddec039b..ecbb8e495912 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -34,8 +34,8 @@ extern int nfnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, unsigne
 extern int nfnetlink_set_err(struct net *net, u32 pid, u32 group, int error);
 extern int nfnetlink_unicast(struct sk_buff *skb, struct net *net, u_int32_t pid, int flags);
 
-extern void nfnl_lock(void);
-extern void nfnl_unlock(void);
+extern void nfnl_lock(__u8 subsys_id);
+extern void nfnl_unlock(__u8 subsys_id);
 
 #define MODULE_ALIAS_NFNL_SUBSYS(subsys) \
         MODULE_ALIAS("nfnetlink-subsys-" __stringify(subsys))
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index 66d5379c305e..9d7d8c64f7c8 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -12,28 +12,38 @@
 #include <linux/rcupdate.h>
 #include <linux/list.h>
 
+union inet_addr {
+        __u32           all[4];
+        __be32          ip;
+        __be32          ip6[4];
+        struct in_addr  in;
+        struct in6_addr in6;
+};
+
 struct netpoll {
         struct net_device *dev;
         char dev_name[IFNAMSIZ];
         const char *name;
         void (*rx_hook)(struct netpoll *, int, char *, int);
 
-        __be32 local_ip, remote_ip;
+        union inet_addr local_ip, remote_ip;
+        bool ipv6;
         u16 local_port, remote_port;
         u8 remote_mac[ETH_ALEN];
 
         struct list_head rx; /* rx_np list element */
-        struct rcu_head rcu;
+        struct work_struct cleanup_work;
 };
 
 struct netpoll_info {
         atomic_t refcnt;
 
-        int rx_flags;
+        unsigned long rx_flags;
         spinlock_t rx_lock;
+        struct mutex dev_lock;
         struct list_head rx_np; /* netpolls that registered an rx_hook */
 
-        struct sk_buff_head arp_tx; /* list of arp requests to reply to */
+        struct sk_buff_head neigh_tx; /* list of neigh requests to reply to */
         struct sk_buff_head txq;
 
         struct delayed_work tx_work;
@@ -42,6 +52,14 @@ struct netpoll_info {
         struct rcu_head rcu;
 };
 
+#ifdef CONFIG_NETPOLL
+extern int netpoll_rx_disable(struct net_device *dev);
+extern void netpoll_rx_enable(struct net_device *dev);
+#else
+static inline int netpoll_rx_disable(struct net_device *dev) { return 0; }
+static inline void netpoll_rx_enable(struct net_device *dev) { return; }
+#endif
+
 void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
 void netpoll_print_options(struct netpoll *np);
 int netpoll_parse_options(struct netpoll *np, char *opt);
@@ -50,7 +68,7 @@ int netpoll_setup(struct netpoll *np);
 int netpoll_trap(void);
 void netpoll_set_trap(int trap);
 void __netpoll_cleanup(struct netpoll *np);
-void __netpoll_free_rcu(struct netpoll *np);
+void __netpoll_free_async(struct netpoll *np);
 void netpoll_cleanup(struct netpoll *np);
 int __netpoll_rx(struct sk_buff *skb, struct netpoll_info *npinfo);
 void netpoll_send_skb_on_dev(struct netpoll *np, struct sk_buff *skb,
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index e111fa419a4e..7b8fc73810ad 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -13,6 +13,7 @@
 #define _LINUX_NFS4_H
 
 #include <linux/list.h>
+#include <linux/uidgid.h>
 #include <uapi/linux/nfs4.h>
 
 struct nfs4_ace {
@@ -20,7 +21,10 @@ struct nfs4_ace {
         uint32_t        flag;
         uint32_t        access_mask;
         int             whotype;
-        uid_t           who;
+        union {
+                kuid_t  who_uid;
+                kgid_t  who_gid;
+        };
 };
 
 struct nfs4_acl {
diff --git a/include/linux/nfs_idmap.h b/include/linux/nfs_idmap.h
index 2dcef3ab58b6..0f4b79da6584 100644
--- a/include/linux/nfs_idmap.h
+++ b/include/linux/nfs_idmap.h
@@ -36,6 +36,7 @@
 #ifndef NFS_IDMAP_H
 #define NFS_IDMAP_H
 
+#include <linux/uidgid.h>
 #include <uapi/linux/nfs_idmap.h>
 
 
@@ -67,10 +68,10 @@ void nfs_fattr_init_names(struct nfs_fattr *fattr,
 void nfs_fattr_free_names(struct nfs_fattr *);
 void nfs_fattr_map_and_free_names(struct nfs_server *, struct nfs_fattr *);
 
-int nfs_map_name_to_uid(const struct nfs_server *, const char *, size_t, __u32 *);
-int nfs_map_group_to_gid(const struct nfs_server *, const char *, size_t, __u32 *);
-int nfs_map_uid_to_name(const struct nfs_server *, __u32, char *, size_t);
-int nfs_map_gid_to_group(const struct nfs_server *, __u32, char *, size_t);
+int nfs_map_name_to_uid(const struct nfs_server *, const char *, size_t, kuid_t *);
+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);
 
 extern unsigned int nfs_idmap_cache_timeout;
 #endif /* NFS_IDMAP_H */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 29adb12c7ecf..13441ddac33d 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -48,8 +48,8 @@ struct nfs_fattr {
         unsigned int            valid;          /* which fields are valid */
         umode_t                 mode;
         __u32                   nlink;
-        __u32                   uid;
-        __u32                   gid;
+        kuid_t                  uid;
+        kgid_t                  gid;
         dev_t                   rdev;
         __u64                   size;
         union {
diff --git a/include/linux/nfsd/export.h b/include/linux/nfsd/export.h
index 24c139288db4..7898c997dfea 100644
--- a/include/linux/nfsd/export.h
+++ b/include/linux/nfsd/export.h
@@ -49,8 +49,8 @@ struct svc_export {
         struct auth_domain *    ex_client;
         int                     ex_flags;
         struct path             ex_path;
-        uid_t                   ex_anon_uid;
-        gid_t                   ex_anon_gid;
+        kuid_t                  ex_anon_uid;
+        kgid_t                  ex_anon_gid;
         int                     ex_fsid;
         unsigned char *         ex_uuid; /* 16 byte fsid */
         struct nfsd4_fs_locations ex_fslocs;
diff --git a/include/linux/ntb.h b/include/linux/ntb.h
new file mode 100644
index 000000000000..f6a15205853b
--- /dev/null
+++ b/include/linux/ntb.h
@@ -0,0 +1,83 @@
+/*
+ * This file is provided under a dual BSD/GPLv2 license.  When using or
+ *   redistributing this file, you may do so under either license.
+ *
+ *   GPL LICENSE SUMMARY
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of version 2 of the GNU General Public License as
+ *   published by the Free Software Foundation.
+ *
+ *   BSD LICENSE
+ *
+ *   Copyright(c) 2012 Intel Corporation. All rights reserved.
+ *
+ *   Redistribution and use in source and binary forms, with or without
+ *   modification, are permitted provided that the following conditions
+ *   are met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above copy
+ *       notice, this list of conditions and the following disclaimer in
+ *       the documentation and/or other materials provided with the
+ *       distribution.
+ *     * Neither the name of Intel Corporation nor the names of its
+ *       contributors may be used to endorse or promote products derived
+ *       from this software without specific prior written permission.
+ *
+ *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Intel PCIe NTB Linux driver
+ *
+ * Contact Information:
+ * Jon Mason <jon.mason@intel.com>
+ */
+
+struct ntb_transport_qp;
+
+struct ntb_client {
+        struct device_driver driver;
+        int (*probe) (struct pci_dev *pdev);
+        void (*remove) (struct pci_dev *pdev);
+};
+
+int ntb_register_client(struct ntb_client *drvr);
+void ntb_unregister_client(struct ntb_client *drvr);
+int ntb_register_client_dev(char *device_name);
+void ntb_unregister_client_dev(char *device_name);
+
+struct ntb_queue_handlers {
+        void (*rx_handler) (struct ntb_transport_qp *qp, void *qp_data,
+                            void *data, int len);
+        void (*tx_handler) (struct ntb_transport_qp *qp, void *qp_data,
+                            void *data, int len);
+        void (*event_handler) (void *data, int status);
+};
+
+unsigned char ntb_transport_qp_num(struct ntb_transport_qp *qp);
+unsigned int ntb_transport_max_size(struct ntb_transport_qp *qp);
+struct ntb_transport_qp *
+ntb_transport_create_queue(void *data, struct pci_dev *pdev,
+                           const struct ntb_queue_handlers *handlers);
+void ntb_transport_free_queue(struct ntb_transport_qp *qp);
+int ntb_transport_rx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+int ntb_transport_tx_enqueue(struct ntb_transport_qp *qp, void *cb, void *data,
+                             unsigned int len);
+void *ntb_transport_rx_remove(struct ntb_transport_qp *qp, unsigned int *len);
+void ntb_transport_link_up(struct ntb_transport_qp *qp);
+void ntb_transport_link_down(struct ntb_transport_qp *qp);
+bool ntb_transport_link_query(struct ntb_transport_qp *qp);
diff --git a/include/linux/of.h b/include/linux/of.h
index 5ebcc5c8e423..a0f129284948 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -92,7 +92,7 @@ static inline void of_node_put(struct device_node *node) { }
 extern struct device_node *of_allnodes;
 extern struct device_node *of_chosen;
 extern struct device_node *of_aliases;
-extern rwlock_t devtree_lock;
+extern raw_spinlock_t devtree_lock;
 
 static inline bool of_have_populated_dt(void)
 {
@@ -160,7 +160,7 @@ static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 
 #define OF_BAD_ADDR     ((u64)-1)
 
-static inline const char* of_node_full_name(struct device_node *np)
+static inline const char *of_node_full_name(const struct device_node *np)
 {
         return np ? np->full_name : "<no-node>";
 }
@@ -277,6 +277,8 @@ extern struct device_node *of_parse_phandle(const struct device_node *np,
 extern int of_parse_phandle_with_args(const struct device_node *np,
         const char *list_name, const char *cells_name, int index,
         struct of_phandle_args *out_args);
+extern int of_count_phandle_with_args(const struct device_node *np,
+        const char *list_name, const char *cells_name);
 
 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
 extern int of_alias_get_id(struct device_node *np, const char *stem);
@@ -467,6 +469,13 @@ static inline int of_parse_phandle_with_args(struct device_node *np,
         return -ENOSYS;
 }
 
+static inline int of_count_phandle_with_args(struct device_node *np,
+                                             const char *list_name,
+                                             const char *cells_name)
+{
+        return -ENOSYS;
+}
+
 static inline int of_alias_get_id(struct device_node *np, const char *stem)
 {
         return -ENOSYS;
diff --git a/include/linux/of_dma.h b/include/linux/of_dma.h
new file mode 100644
index 000000000000..d15073e080dd
--- /dev/null
+++ b/include/linux/of_dma.h
@@ -0,0 +1,74 @@
+/*
+ * OF helpers for DMA request / controller
+ *
+ * Based on of_gpio.h
+ *
+ * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com/
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+
+#ifndef __LINUX_OF_DMA_H
+#define __LINUX_OF_DMA_H
+
+#include <linux/of.h>
+#include <linux/dmaengine.h>
+
+struct device_node;
+
+struct of_dma {
+        struct list_head        of_dma_controllers;
+        struct device_node      *of_node;
+        int                     of_dma_nbcells;
+        struct dma_chan         *(*of_dma_xlate)
+                                (struct of_phandle_args *, struct of_dma *);
+        void                    *of_dma_data;
+        int                     use_count;
+};
+
+struct of_dma_filter_info {
+        dma_cap_mask_t  dma_cap;
+        dma_filter_fn   filter_fn;
+};
+
+#ifdef CONFIG_OF
+extern int of_dma_controller_register(struct device_node *np,
+                struct dma_chan *(*of_dma_xlate)
+                (struct of_phandle_args *, struct of_dma *),
+                void *data);
+extern int of_dma_controller_free(struct device_node *np);
+extern struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
+                                                     char *name);
+extern struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
+                struct of_dma *ofdma);
+#else
+static inline int of_dma_controller_register(struct device_node *np,
+                struct dma_chan *(*of_dma_xlate)
+                (struct of_phandle_args *, struct of_dma *),
+                void *data)
+{
+        return -ENODEV;
+}
+
+static inline int of_dma_controller_free(struct device_node *np)
+{
+        return -ENODEV;
+}
+
+static inline struct dma_chan *of_dma_request_slave_channel(struct device_node *np,
+                                                     char *name)
+{
+        return NULL;
+}
+
+static inline struct dma_chan *of_dma_simple_xlate(struct of_phandle_args *dma_spec,
+                struct of_dma *ofdma)
+{
+        return NULL;
+}
+
+#endif
+
+#endif /* __LINUX_OF_DMA_H */
diff --git a/include/linux/of_gpio.h b/include/linux/of_gpio.h
index c454f5796747..a83dc6f5008e 100644
--- a/include/linux/of_gpio.h
+++ b/include/linux/of_gpio.h
@@ -50,9 +50,6 @@ static inline struct of_mm_gpio_chip *to_of_mm_gpio_chip(struct gpio_chip *gc)
 extern int of_get_named_gpio_flags(struct device_node *np,
                 const char *list_name, int index, enum of_gpio_flags *flags);
 
-extern unsigned int of_gpio_named_count(struct device_node *np,
-                                        const char* propname);
-
 extern int of_mm_gpiochip_add(struct device_node *np,
                               struct of_mm_gpio_chip *mm_gc);
 
@@ -71,12 +68,6 @@ static inline int of_get_named_gpio_flags(struct device_node *np,
         return -ENOSYS;
 }
 
-static inline unsigned int of_gpio_named_count(struct device_node *np,
-                                        const char* propname)
-{
-        return 0;
-}
-
 static inline int of_gpio_simple_xlate(struct gpio_chip *gc,
                                        const struct of_phandle_args *gpiospec,
                                        u32 *flags)
@@ -90,22 +81,37 @@ static inline void of_gpiochip_remove(struct gpio_chip *gc) { }
 #endif /* CONFIG_OF_GPIO */
 
 /**
- * of_gpio_count - Count GPIOs for a device
+ * of_gpio_named_count() - Count GPIOs for a device
  * @np:         device node to count GPIOs for
+ * @propname:   property name containing gpio specifier(s)
  *
  * The function returns the count of GPIOs specified for a node.
+ * Note that the empty GPIO specifiers count too. Returns either
+ *   Number of gpios defined in property,
+ *   -EINVAL for an incorrectly formed gpios property, or
+ *   -ENOENT for a missing gpios property
  *
- * Note that the empty GPIO specifiers counts too. For example,
- *
+ * Example:
  * gpios = <0
- *          &pio1 1 2
+ *          &gpio1 1 2
  *          0
- *          &pio2 3 4>;
+ *          &gpio2 3 4>;
+ *
+ * The above example defines four GPIOs, two of which are not specified.
+ * This function will return '4'
+ */
+static inline int of_gpio_named_count(struct device_node *np, const char* propname)
+{
+        return of_count_phandle_with_args(np, propname, "#gpio-cells");
+}
+
+/**
+ * of_gpio_count() - Count GPIOs for a device
+ * @np:         device node to count GPIOs for
  *
- * defines four GPIOs (so this function will return 4), two of which
- * are not specified.
+ * Same as of_gpio_named_count, but hard coded to use the 'gpios' property
  */
-static inline unsigned int of_gpio_count(struct device_node *np)
+static inline int of_gpio_count(struct device_node *np)
 {
         return of_gpio_named_count(np, "gpios");
 }
diff --git a/include/linux/of_serial.h b/include/linux/of_serial.h
deleted file mode 100644
index 4a73ed80b4c0..000000000000
--- a/include/linux/of_serial.h
+++ /dev/null
@@ -1,17 +0,0 @@
-#ifndef __LINUX_OF_SERIAL_H
-#define __LINUX_OF_SERIAL_H
-
-/*
- * FIXME remove this file when tegra finishes conversion to open firmware,
- * expectation is that all quirks will then be self-contained in
- * drivers/tty/serial/of_serial.c.
- */
-#ifdef CONFIG_ARCH_TEGRA
-extern void tegra_serial_handle_break(struct uart_port *port);
-#else
-static inline void tegra_serial_handle_break(struct uart_port *port)
-{
-}
-#endif
-
-#endif /* __LINUX_OF_SERIAL */
diff --git a/include/linux/opp.h b/include/linux/opp.h
index 214e0ebcb84d..3aca2b8def33 100644
--- a/include/linux/opp.h
+++ b/include/linux/opp.h
@@ -47,15 +47,6 @@ int opp_enable(struct device *dev, unsigned long freq);
 int opp_disable(struct device *dev, unsigned long freq);
 
 struct srcu_notifier_head *opp_get_notifier(struct device *dev);
-
-#ifdef CONFIG_OF
-int of_init_opp_table(struct device *dev);
-#else
-static inline int of_init_opp_table(struct device *dev)
-{
-        return -EINVAL;
-}
-#endif /* CONFIG_OF */
 #else
 static inline unsigned long opp_get_voltage(struct opp *opp)
 {
@@ -112,6 +103,15 @@ static inline struct srcu_notifier_head *opp_get_notifier(struct device *dev)
 }
 #endif          /* CONFIG_PM_OPP */
 
+#if defined(CONFIG_PM_OPP) && defined(CONFIG_OF)
+int of_init_opp_table(struct device *dev);
+#else
+static inline int of_init_opp_table(struct device *dev)
+{
+        return -EINVAL;
+}
+#endif
+
 #if defined(CONFIG_CPU_FREQ) && defined(CONFIG_PM_OPP)
 int opp_init_cpufreq_table(struct device *dev,
                             struct cpufreq_frequency_table **table);
diff --git a/include/linux/page-flags-layout.h b/include/linux/page-flags-layout.h
new file mode 100644
index 000000000000..93506a114034
--- /dev/null
+++ b/include/linux/page-flags-layout.h
@@ -0,0 +1,88 @@
+#ifndef PAGE_FLAGS_LAYOUT_H
+#define PAGE_FLAGS_LAYOUT_H
+
+#include <linux/numa.h>
+#include <generated/bounds.h>
+
+/*
+ * When a memory allocation must conform to specific limitations (such
+ * as being suitable for DMA) the caller will pass in hints to the
+ * allocator in the gfp_mask, in the zone modifier bits.  These bits
+ * are used to select a priority ordered list of memory zones which
+ * match the requested limits. See gfp_zone() in include/linux/gfp.h
+ */
+#if MAX_NR_ZONES < 2
+#define ZONES_SHIFT 0
+#elif MAX_NR_ZONES <= 2
+#define ZONES_SHIFT 1
+#elif MAX_NR_ZONES <= 4
+#define ZONES_SHIFT 2
+#else
+#error ZONES_SHIFT -- too many zones configured adjust calculation
+#endif
+
+#ifdef CONFIG_SPARSEMEM
+#include <asm/sparsemem.h>
+
+/* SECTION_SHIFT        #bits space required to store a section # */
+#define SECTIONS_SHIFT  (MAX_PHYSMEM_BITS - SECTION_SIZE_BITS)
+
+#endif /* CONFIG_SPARSEMEM */
+
+/*
+ * page->flags layout:
+ *
+ * There are five possibilities for how page->flags get laid out.  The first
+ * pair is for the normal case without sparsemem. The second pair is for
+ * sparsemem when there is plenty of space for node and section information.
+ * The last is when there is insufficient space in page->flags and a separate
+ * lookup is necessary.
+ *
+ * No sparsemem or sparsemem vmemmap: |       NODE     | ZONE |          ... | FLAGS |
+ *         " plus space for last_nid: |       NODE     | ZONE | LAST_NID ... | FLAGS |
+ * classic sparse with space for node:| SECTION | NODE | ZONE |          ... | FLAGS |
+ *         " plus space for last_nid: | SECTION | NODE | ZONE | LAST_NID ... | FLAGS |
+ * classic sparse no space for node:  | SECTION |     ZONE    | ... | FLAGS |
+ */
+#if defined(CONFIG_SPARSEMEM) && !defined(CONFIG_SPARSEMEM_VMEMMAP)
+#define SECTIONS_WIDTH          SECTIONS_SHIFT
+#else
+#define SECTIONS_WIDTH          0
+#endif
+
+#define ZONES_WIDTH             ZONES_SHIFT
+
+#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
+#define NODES_WIDTH             NODES_SHIFT
+#else
+#ifdef CONFIG_SPARSEMEM_VMEMMAP
+#error "Vmemmap: No space for nodes field in page flags"
+#endif
+#define NODES_WIDTH             0
+#endif
+
+#ifdef CONFIG_NUMA_BALANCING
+#define LAST_NID_SHIFT NODES_SHIFT
+#else
+#define LAST_NID_SHIFT 0
+#endif
+
+#if SECTIONS_WIDTH+ZONES_WIDTH+NODES_SHIFT+LAST_NID_SHIFT <= BITS_PER_LONG - NR_PAGEFLAGS
+#define LAST_NID_WIDTH LAST_NID_SHIFT
+#else
+#define LAST_NID_WIDTH 0
+#endif
+
+/*
+ * We are going to use the flags for the page to node mapping if its in
+ * there.  This includes the case where there is no node, so it is implicit.
+ */
+#if !(NODES_WIDTH > 0 || NODES_SHIFT == 0)
+#define NODE_NOT_IN_PAGE_FLAGS
+#endif
+
+#if defined(CONFIG_NUMA_BALANCING) && LAST_NID_WIDTH == 0
+#define LAST_NID_NOT_IN_PAGE_FLAGS
+#endif
+
+#endif /* _LINUX_PAGE_FLAGS_LAYOUT */
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 70473da47b3f..6d53675c2b54 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -303,21 +303,13 @@ static inline void __SetPageUptodate(struct page *page)
 
 static inline void SetPageUptodate(struct page *page)
 {
-#ifdef CONFIG_S390
-        if (!test_and_set_bit(PG_uptodate, &page->flags))
-                page_set_storage_key(page_to_phys(page), PAGE_DEFAULT_KEY, 0);
-#else
         /*
          * Memory barrier must be issued before setting the PG_uptodate bit,
          * so that all previous stores issued in order to bring the page
          * uptodate are actually visible before PageUptodate becomes true.
-         *
-         * s390 doesn't need an explicit smp_wmb here because the test and
-         * set bit already provides full barriers.
          */
         smp_wmb();
         set_bit(PG_uptodate, &(page)->flags);
-#endif
 }
 
 CLEARPAGEFLAG(Uptodate, uptodate)
diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
index a92061e08d48..3fff8e774067 100644
--- a/include/linux/page-isolation.h
+++ b/include/linux/page-isolation.h
@@ -1,6 +1,25 @@
 #ifndef __LINUX_PAGEISOLATION_H
 #define __LINUX_PAGEISOLATION_H
 
+#ifdef CONFIG_MEMORY_ISOLATION
+static inline bool is_migrate_isolate_page(struct page *page)
+{
+        return get_pageblock_migratetype(page) == MIGRATE_ISOLATE;
+}
+static inline bool is_migrate_isolate(int migratetype)
+{
+        return migratetype == MIGRATE_ISOLATE;
+}
+#else
+static inline bool is_migrate_isolate_page(struct page *page)
+{
+        return false;
+}
+static inline bool is_migrate_isolate(int migratetype)
+{
+        return false;
+}
+#endif
 
 bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
                          bool skip_hwpoisoned_pages);
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index 6da609d14c15..0e38e13eb249 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -414,6 +414,7 @@ static inline void wait_on_page_writeback(struct page *page)
 }
 
 extern void end_page_writeback(struct page *page);
+void wait_for_stable_page(struct page *page);
 
 /*
  * Add an arbitrary waiter to a page's wait queue
diff --git a/include/linux/pci.h b/include/linux/pci.h
index 15472d691ee6..2461033a7987 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -286,6 +286,7 @@ struct pci_dev {
         unsigned int    irq;
         struct resource resource[DEVICE_COUNT_RESOURCE]; /* I/O and memory regions + expansion ROMs */
 
+        bool match_driver;              /* Skip attaching driver */
         /* These fields are used by common fixups */
         unsigned int    transparent:1;  /* Transparent PCI bridge */
         unsigned int    multifunction:1;/* Part of multi-function device */
@@ -378,6 +379,8 @@ void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
                      void (*release_fn)(struct pci_host_bridge *),
                      void *release_data);
 
+int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
+
 /*
  * The first PCI_BRIDGE_RESOURCE_NUM PCI bus resources (those that correspond
  * to P2P or CardBus bridge windows) go in a table.  Additional ones (for
@@ -674,6 +677,7 @@ extern struct list_head pci_root_buses;	/* list of all known PCI buses */
 /* Some device drivers need know if pci is initiated */
 extern int no_pci_devices(void);
 
+void pcibios_resource_survey_bus(struct pci_bus *bus);
 void pcibios_fixup_bus(struct pci_bus *);
 int __must_check pcibios_enable_device(struct pci_dev *, int mask);
 /* Architecture specific versions may override this (weak) */
@@ -1101,6 +1105,12 @@ static inline int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec)
         return -1;
 }
 
+static inline int
+pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec)
+{
+        return -1;
+}
+
 static inline void pci_msi_shutdown(struct pci_dev *dev)
 { }
 static inline void pci_disable_msi(struct pci_dev *dev)
@@ -1132,6 +1142,7 @@ static inline int pci_msi_enabled(void)
 }
 #else
 extern int pci_enable_msi_block(struct pci_dev *dev, unsigned int nvec);
+extern int pci_enable_msi_block_auto(struct pci_dev *dev, unsigned int *maxvec);
 extern void pci_msi_shutdown(struct pci_dev *dev);
 extern void pci_disable_msi(struct pci_dev *dev);
 extern int pci_msix_table_size(struct pci_dev *dev);
@@ -1693,12 +1704,21 @@ static inline bool pci_is_pcie(struct pci_dev *dev)
 }
 
 /**
+ * pcie_caps_reg - get the PCIe Capabilities Register
+ * @dev: PCI device
+ */
+static inline u16 pcie_caps_reg(const struct pci_dev *dev)
+{
+        return dev->pcie_flags_reg;
+}
+
+/**
  * pci_pcie_type - get the PCIe device/port type
  * @dev: PCI device
  */
 static inline int pci_pcie_type(const struct pci_dev *dev)
 {
-        return (dev->pcie_flags_reg & PCI_EXP_FLAGS_TYPE) >> 4;
+        return (pcie_caps_reg(dev) & PCI_EXP_FLAGS_TYPE) >> 4;
 }
 
 void pci_request_acs(void);
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 0eb65796bcb9..31717bd287fd 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1807,6 +1807,8 @@
 #define PCI_VENDOR_ID_ESDGMBH           0x12fe
 #define PCI_DEVICE_ID_ESDGMBH_CPCIASIO4 0x0111
 
+#define PCI_VENDOR_ID_CB                0x1307  /* Measurement Computing */
+
 #define PCI_VENDOR_ID_SIIG              0x131f
 #define PCI_SUBVENDOR_ID_SIIG           0x131f
 #define PCI_DEVICE_ID_SIIG_1S_10x_550   0x1000
@@ -1868,8 +1870,23 @@
 #define PCI_VENDOR_ID_QUATECH           0x135C
 #define PCI_DEVICE_ID_QUATECH_QSC100    0x0010
 #define PCI_DEVICE_ID_QUATECH_DSC100    0x0020
+#define PCI_DEVICE_ID_QUATECH_DSC200    0x0030
+#define PCI_DEVICE_ID_QUATECH_QSC200    0x0040
 #define PCI_DEVICE_ID_QUATECH_ESC100D   0x0050
 #define PCI_DEVICE_ID_QUATECH_ESC100M   0x0060
+#define PCI_DEVICE_ID_QUATECH_QSCP100   0x0120
+#define PCI_DEVICE_ID_QUATECH_DSCP100   0x0130
+#define PCI_DEVICE_ID_QUATECH_QSCP200   0x0140
+#define PCI_DEVICE_ID_QUATECH_DSCP200   0x0150
+#define PCI_DEVICE_ID_QUATECH_QSCLP100  0x0170
+#define PCI_DEVICE_ID_QUATECH_DSCLP100  0x0180
+#define PCI_DEVICE_ID_QUATECH_DSC100E   0x0181
+#define PCI_DEVICE_ID_QUATECH_SSCLP100  0x0190
+#define PCI_DEVICE_ID_QUATECH_QSCLP200  0x01A0
+#define PCI_DEVICE_ID_QUATECH_DSCLP200  0x01B0
+#define PCI_DEVICE_ID_QUATECH_DSC200E   0x01B1
+#define PCI_DEVICE_ID_QUATECH_SSCLP200  0x01C0
+#define PCI_DEVICE_ID_QUATECH_ESCLP100  0x01E0
 #define PCI_DEVICE_ID_QUATECH_SPPXP_100 0x0278
 
 #define PCI_VENDOR_ID_SEALEVEL          0x135e
@@ -2013,6 +2030,10 @@
 #define PCI_DEVICE_ID_CMEDIA_CM8738     0x0111
 #define PCI_DEVICE_ID_CMEDIA_CM8738B    0x0112
 
+#define PCI_VENDOR_ID_ADVANTECH         0x13fe
+
+#define PCI_VENDOR_ID_MEILHAUS          0x1402
+
 #define PCI_VENDOR_ID_LAVA              0x1407
 #define PCI_DEVICE_ID_LAVA_DSERIAL      0x0100 /* 2x 16550 */
 #define PCI_DEVICE_ID_LAVA_QUATRO_A     0x0101 /* 2x 16550, half of 4 port */
@@ -2058,6 +2079,8 @@
 
 #define PCI_VENDOR_ID_CHELSIO           0x1425
 
+#define PCI_VENDOR_ID_ADLINK            0x144a
+
 #define PCI_VENDOR_ID_SAMSUNG           0x144d
 
 #define PCI_VENDOR_ID_GIGABYTE          0x1458
@@ -2091,6 +2114,8 @@
 #define PCI_DEVICE_ID_AFAVLAB_P030      0x2182
 #define PCI_SUBDEVICE_ID_AFAVLAB_P061           0x2150
 
+#define PCI_VENDOR_ID_AMPLICON          0x14dc
+
 #define PCI_VENDOR_ID_BCM_GVC          0x14a4
 #define PCI_VENDOR_ID_BROADCOM          0x14e4
 #define PCI_DEVICE_ID_TIGON3_5752       0x1600
@@ -2127,6 +2152,7 @@
 #define PCI_DEVICE_ID_TIGON3_5754M      0x1672
 #define PCI_DEVICE_ID_TIGON3_5755M      0x1673
 #define PCI_DEVICE_ID_TIGON3_5756       0x1674
+#define PCI_DEVICE_ID_TIGON3_5750       0x1676
 #define PCI_DEVICE_ID_TIGON3_5751       0x1677
 #define PCI_DEVICE_ID_TIGON3_5715       0x1678
 #define PCI_DEVICE_ID_TIGON3_5715S      0x1679
diff --git a/include/linux/percpu_counter.h b/include/linux/percpu_counter.h
index b9df9ed1adc0..d5dd4657c8d6 100644
--- a/include/linux/percpu_counter.h
+++ b/include/linux/percpu_counter.h
@@ -83,7 +83,7 @@ static inline int percpu_counter_initialized(struct percpu_counter *fbc)
         return (fbc->counters != NULL);
 }
 
-#else
+#else /* !CONFIG_SMP */
 
 struct percpu_counter {
         s64 count;
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index 6bfb2faa0b19..e47ee462c2f2 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -135,16 +135,21 @@ struct hw_perf_event {
                 struct { /* software */
                         struct hrtimer  hrtimer;
                 };
+                struct { /* tracepoint */
+                        struct task_struct      *tp_target;
+                        /* for tp_event->class */
+                        struct list_head        tp_list;
+                };
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
                 struct { /* breakpoint */
-                        struct arch_hw_breakpoint       info;
-                        struct list_head                bp_list;
                         /*
                          * Crufty hack to avoid the chicken and egg
                          * problem hw_breakpoint has with context
                          * creation and event initalization.
                          */
                         struct task_struct              *bp_target;
+                        struct arch_hw_breakpoint       info;
+                        struct list_head                bp_list;
                 };
 #endif
         };
@@ -817,6 +822,17 @@ do {									\
 } while (0)
 
 
+struct perf_pmu_events_attr {
+        struct device_attribute attr;
+        u64 id;
+};
+
+#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_FORMAT_ATTR(_name, _format)                                 \
 static ssize_t                                                          \
 _name##_show(struct device *dev,                                        \
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 93b3cf77f564..33999adbf8c8 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -506,13 +506,13 @@ struct phy_device *get_phy_device(struct mii_bus *bus, int addr, bool is_c45);
 int phy_device_register(struct phy_device *phy);
 int phy_init_hw(struct phy_device *phydev);
 struct phy_device * phy_attach(struct net_device *dev,
-                const char *bus_id, u32 flags, phy_interface_t interface);
+                const char *bus_id, phy_interface_t interface);
 struct phy_device *phy_find_first(struct mii_bus *bus);
 int phy_connect_direct(struct net_device *dev, struct phy_device *phydev,
-                void (*handler)(struct net_device *), u32 flags,
+                void (*handler)(struct net_device *),
                 phy_interface_t interface);
 struct phy_device * phy_connect(struct net_device *dev, const char *bus_id,
-                void (*handler)(struct net_device *), u32 flags,
+                void (*handler)(struct net_device *),
                 phy_interface_t interface);
 void phy_disconnect(struct phy_device *phydev);
 void phy_detach(struct phy_device *phydev);
diff --git a/include/linux/pinctrl/devinfo.h b/include/linux/pinctrl/devinfo.h
new file mode 100644
index 000000000000..6e5f8a985ea7
--- /dev/null
+++ b/include/linux/pinctrl/devinfo.h
@@ -0,0 +1,45 @@
+/*
+ * Per-device information from the pin control system.
+ * This is the stuff that get included into the device
+ * core.
+ *
+ * Copyright (C) 2012 ST-Ericsson SA
+ * Written on behalf of Linaro for ST-Ericsson
+ * This interface is used in the core to keep track of pins.
+ *
+ * Author: Linus Walleij <linus.walleij@linaro.org>
+ *
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#ifndef PINCTRL_DEVINFO_H
+#define PINCTRL_DEVINFO_H
+
+#ifdef CONFIG_PINCTRL
+
+/* The device core acts as a consumer toward pinctrl */
+#include <linux/pinctrl/consumer.h>
+
+/**
+ * struct dev_pin_info - pin state container for devices
+ * @p: pinctrl handle for the containing device
+ * @default_state: the default state for the handle, if found
+ */
+struct dev_pin_info {
+        struct pinctrl *p;
+        struct pinctrl_state *default_state;
+};
+
+extern int pinctrl_bind_pins(struct device *dev);
+
+#else
+
+/* Stubs if we're not using pinctrl */
+
+static inline int pinctrl_bind_pins(struct device *dev)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PINCTRL */
+#endif /* PINCTRL_DEVINFO_H */
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index 47a1bdd88878..72474e18f1e0 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -46,7 +46,11 @@
  * @PIN_CONFIG_DRIVE_OPEN_SOURCE: the pin will be driven with open source
  *      (open emitter). Sending this config will enabale open drain mode, the
  *      argument is ignored.
- * @PIN_CONFIG_INPUT_SCHMITT_DISABLE: disable schmitt-trigger mode on the pin.
+ * @PIN_CONFIG_DRIVE_STRENGTH: the pin will output the current passed as
+ *      argument. The argument is in mA.
+ * @PIN_CONFIG_INPUT_SCHMITT_ENABLE: control schmitt-trigger mode on the pin.
+ *      If the argument != 0, schmitt-trigger mode is enabled. If it's 0,
+ *      schmitt-trigger mode is disabled.
  * @PIN_CONFIG_INPUT_SCHMITT: this will configure an input pin to run in
  *      schmitt-trigger mode. If the schmitt-trigger has adjustable hysteresis,
  *      the threshold value is given on a custom format as argument when
@@ -58,10 +62,15 @@
  * @PIN_CONFIG_POWER_SOURCE: if the pin can select between different power
  *      supplies, the argument to this parameter (on a custom format) tells
  *      the driver which alternative power source to use.
+ * @PIN_CONFIG_SLEW_RATE: if the pin can select slew rate, the argument to
+ *      this parameter (on a custom format) tells the driver which alternative
+ *      slew rate to use.
  * @PIN_CONFIG_LOW_POWER_MODE: this will configure the pin for low power
  *      operation, if several modes of operation are supported these can be
  *      passed in the argument on a custom form, else just use argument 1
  *      to indicate low power mode, argument 0 turns low power mode off.
+ * @PIN_CONFIG_OUTPUT: this will configure the pin in output, use argument
+ *      1 to indicate high level, argument 0 to indicate low level.
  * @PIN_CONFIG_END: this is the last enumerator for pin configurations, if
  *      you need to pass in custom configurations to the pin controller, use
  *      PIN_CONFIG_END+1 as the base offset.
@@ -74,11 +83,14 @@ enum pin_config_param {
         PIN_CONFIG_DRIVE_PUSH_PULL,
         PIN_CONFIG_DRIVE_OPEN_DRAIN,
         PIN_CONFIG_DRIVE_OPEN_SOURCE,
-        PIN_CONFIG_INPUT_SCHMITT_DISABLE,
+        PIN_CONFIG_DRIVE_STRENGTH,
+        PIN_CONFIG_INPUT_SCHMITT_ENABLE,
         PIN_CONFIG_INPUT_SCHMITT,
         PIN_CONFIG_INPUT_DEBOUNCE,
         PIN_CONFIG_POWER_SOURCE,
+        PIN_CONFIG_SLEW_RATE,
         PIN_CONFIG_LOW_POWER_MODE,
+        PIN_CONFIG_OUTPUT,
         PIN_CONFIG_END = 0x7FFF,
 };
 
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 04d6700d99af..778804df293f 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -154,6 +154,7 @@ struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
 #endif /* CONFIG_OF */
 
 extern const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev);
+extern const char *pinctrl_dev_get_devname(struct pinctrl_dev *pctldev);
 extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
 #else
 
diff --git a/include/linux/platform_data/cpsw.h b/include/linux/platform_data/cpsw.h
index 24368a2e8b87..798fb80b024b 100644
--- a/include/linux/platform_data/cpsw.h
+++ b/include/linux/platform_data/cpsw.h
@@ -21,6 +21,8 @@ struct cpsw_slave_data {
         char            phy_id[MII_BUS_ID_SIZE];
         int             phy_if;
         u8              mac_addr[ETH_ALEN];
+        u16             dual_emac_res_vlan;     /* Reserved VLAN for DualEMAC */
+
 };
 
 struct cpsw_platform_data {
@@ -35,6 +37,8 @@ struct cpsw_platform_data {
         u32     bd_ram_size;  /*buffer descriptor ram size */
         u32     rx_descs;       /* Number of Rx Descriptios */
         u32     mac_control;    /* Mac control register */
+        u16     default_vlan;   /* Def VLAN for ALE lookup in VLAN aware mode*/
+        bool    dual_emac;      /* Enable Dual EMAC mode */
 };
 
 #endif /* __CPSW_H__ */
diff --git a/include/linux/platform_data/dma-coh901318.h b/include/linux/platform_data/dma-coh901318.h
new file mode 100644
index 000000000000..c4cb9590d115
--- /dev/null
+++ b/include/linux/platform_data/dma-coh901318.h
@@ -0,0 +1,72 @@
+/*
+ * Platform data for the COH901318 DMA controller
+ * Copyright (C) 2007-2013 ST-Ericsson
+ * License terms: GNU General Public License (GPL) version 2
+ */
+
+#ifndef PLAT_COH901318_H
+#define PLAT_COH901318_H
+
+#ifdef CONFIG_COH901318
+
+/* We only support the U300 DMA channels */
+#define U300_DMA_MSL_TX_0               0
+#define U300_DMA_MSL_TX_1               1
+#define U300_DMA_MSL_TX_2               2
+#define U300_DMA_MSL_TX_3               3
+#define U300_DMA_MSL_TX_4               4
+#define U300_DMA_MSL_TX_5               5
+#define U300_DMA_MSL_TX_6               6
+#define U300_DMA_MSL_RX_0               7
+#define U300_DMA_MSL_RX_1               8
+#define U300_DMA_MSL_RX_2               9
+#define U300_DMA_MSL_RX_3               10
+#define U300_DMA_MSL_RX_4               11
+#define U300_DMA_MSL_RX_5               12
+#define U300_DMA_MSL_RX_6               13
+#define U300_DMA_MMCSD_RX_TX            14
+#define U300_DMA_MSPRO_TX               15
+#define U300_DMA_MSPRO_RX               16
+#define U300_DMA_UART0_TX               17
+#define U300_DMA_UART0_RX               18
+#define U300_DMA_APEX_TX                19
+#define U300_DMA_APEX_RX                20
+#define U300_DMA_PCM_I2S0_TX            21
+#define U300_DMA_PCM_I2S0_RX            22
+#define U300_DMA_PCM_I2S1_TX            23
+#define U300_DMA_PCM_I2S1_RX            24
+#define U300_DMA_XGAM_CDI               25
+#define U300_DMA_XGAM_PDI               26
+#define U300_DMA_SPI_TX                 27
+#define U300_DMA_SPI_RX                 28
+#define U300_DMA_GENERAL_PURPOSE_0      29
+#define U300_DMA_GENERAL_PURPOSE_1      30
+#define U300_DMA_GENERAL_PURPOSE_2      31
+#define U300_DMA_GENERAL_PURPOSE_3      32
+#define U300_DMA_GENERAL_PURPOSE_4      33
+#define U300_DMA_GENERAL_PURPOSE_5      34
+#define U300_DMA_GENERAL_PURPOSE_6      35
+#define U300_DMA_GENERAL_PURPOSE_7      36
+#define U300_DMA_GENERAL_PURPOSE_8      37
+#define U300_DMA_UART1_TX               38
+#define U300_DMA_UART1_RX               39
+
+#define U300_DMA_DEVICE_CHANNELS        32
+#define U300_DMA_CHANNELS               40
+
+/**
+ * coh901318_filter_id() - DMA channel filter function
+ * @chan: dma channel handle
+ * @chan_id: id of dma channel to be filter out
+ *
+ * In dma_request_channel() it specifies what channel id to be requested
+ */
+bool coh901318_filter_id(struct dma_chan *chan, void *chan_id);
+#else
+static inline bool coh901318_filter_id(struct dma_chan *chan, void *chan_id)
+{
+        return false;
+}
+#endif
+
+#endif /* PLAT_COH901318_H */
diff --git a/include/linux/platform_data/dma-ste-dma40.h b/include/linux/platform_data/dma-ste-dma40.h
index 9ff93b065686..4b781014b0a0 100644
--- a/include/linux/platform_data/dma-ste-dma40.h
+++ b/include/linux/platform_data/dma-ste-dma40.h
@@ -147,6 +147,16 @@ struct stedma40_chan_cfg {
  * @memcpy_conf_log: default configuration of logical channel memcpy
  * @disabled_channels: A vector, ending with -1, that marks physical channels
  * that are for different reasons not available for the driver.
+ * @soft_lli_chans: A vector, that marks physical channels will use LLI by SW
+ * which avoids HW bug that exists in some versions of the controller.
+ * SoftLLI introduces relink overhead that could impact performace for
+ * certain use cases.
+ * @num_of_soft_lli_chans: The number of channels that needs to be configured
+ * to use SoftLLI.
+ * @use_esram_lcla: flag for mapping the lcla into esram region
+ * @num_of_phy_chans: The number of physical channels implemented in HW.
+ * 0 means reading the number of channels from DMA HW but this is only valid
+ * for 'multiple of 4' channels, like 8.
  */
 struct stedma40_platform_data {
         u32                              dev_len;
@@ -157,7 +167,10 @@ struct stedma40_platform_data {
         struct stedma40_chan_cfg        *memcpy_conf_phy;
         struct stedma40_chan_cfg        *memcpy_conf_log;
         int                              disabled_channels[STEDMA40_MAX_PHYS];
+        int                             *soft_lli_chans;
+        int                              num_of_soft_lli_chans;
         bool                             use_esram_lcla;
+        int                              num_of_phy_chans;
 };
 
 #ifdef CONFIG_STE_DMA40
diff --git a/include/linux/platform_data/i2c-s3c2410.h b/include/linux/platform_data/i2c-s3c2410.h
index 51d52e767a19..2a50048c1c44 100644
--- a/include/linux/platform_data/i2c-s3c2410.h
+++ b/include/linux/platform_data/i2c-s3c2410.h
@@ -15,6 +15,8 @@
 
 #define S3C_IICFLG_FILTER       (1<<0)  /* enable s3c2440 filter */
 
+struct platform_device;
+
 /**
  *      struct s3c2410_platform_i2c - Platform data for s3c I2C.
  *      @bus_num: The bus number to use (if possible).
diff --git a/include/linux/platform_data/invensense_mpu6050.h b/include/linux/platform_data/invensense_mpu6050.h
new file mode 100644
index 000000000000..ad3aa7b95f35
--- /dev/null
+++ b/include/linux/platform_data/invensense_mpu6050.h
@@ -0,0 +1,31 @@
+/*
+* Copyright (C) 2012 Invensense, Inc.
+*
+* This software is licensed under the terms of the GNU General Public
+* License version 2, as published by the Free Software Foundation, and
+* may be copied, distributed, and modified under those terms.
+*
+* 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 __INV_MPU6050_PLATFORM_H_
+#define __INV_MPU6050_PLATFORM_H_
+
+/**
+ * struct inv_mpu6050_platform_data - Platform data for the mpu driver
+ * @orientation:        Orientation matrix of the chip
+ *
+ * Contains platform specific information on how to configure the MPU6050 to
+ * work on this platform.  The orientation matricies are 3x3 rotation matricies
+ * that are applied to the data to rotate from the mounting orientation to the
+ * platform orientation.  The values must be one of 0, 1, or -1 and each row and
+ * column should have exactly 1 non-zero value.
+ */
+struct inv_mpu6050_platform_data {
+        __s8 orientation[9];
+};
+
+#endif
diff --git a/include/linux/platform_data/leds-lp55xx.h b/include/linux/platform_data/leds-lp55xx.h
new file mode 100644
index 000000000000..1509570d5a3f
--- /dev/null
+++ b/include/linux/platform_data/leds-lp55xx.h
@@ -0,0 +1,87 @@
+/*
+ * LP55XX Platform Data Header
+ *
+ * Copyright (C) 2012 Texas Instruments
+ *
+ * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * Derived from leds-lp5521.h, leds-lp5523.h
+ */
+
+#ifndef _LEDS_LP55XX_H
+#define _LEDS_LP55XX_H
+
+/* Clock configuration */
+#define LP55XX_CLOCK_AUTO       0
+#define LP55XX_CLOCK_INT        1
+#define LP55XX_CLOCK_EXT        2
+
+/* Bits in LP5521 CONFIG register. 'update_config' in lp55xx_platform_data */
+#define LP5521_PWM_HF                   0x40    /* PWM: 0 = 256Hz, 1 = 558Hz */
+#define LP5521_PWRSAVE_EN               0x20    /* 1 = Power save mode */
+#define LP5521_CP_MODE_OFF              0       /* Charge pump (CP) off */
+#define LP5521_CP_MODE_BYPASS           8       /* CP forced to bypass mode */
+#define LP5521_CP_MODE_1X5              0x10    /* CP forced to 1.5x mode */
+#define LP5521_CP_MODE_AUTO             0x18    /* Automatic mode selection */
+#define LP5521_R_TO_BATT                4       /* R out: 0 = CP, 1 = Vbat */
+#define LP5521_CLK_SRC_EXT              0       /* Ext-clk source (CLK_32K) */
+#define LP5521_CLK_INT                  1       /* Internal clock */
+#define LP5521_CLK_AUTO                 2       /* Automatic clock selection */
+
+struct lp55xx_led_config {
+        const char *name;
+        u8 chan_nr;
+        u8 led_current; /* mA x10, 0 if led is not connected */
+        u8 max_current;
+};
+
+struct lp55xx_predef_pattern {
+        u8 *r;
+        u8 *g;
+        u8 *b;
+        u8 size_r;
+        u8 size_g;
+        u8 size_b;
+};
+
+/*
+ * struct lp55xx_platform_data
+ * @led_config        : Configurable led class device
+ * @num_channels      : Number of LED channels
+ * @label             : Used for naming LEDs
+ * @clock_mode        : Input clock mode. LP55XX_CLOCK_AUTO or _INT or _EXT
+ * @setup_resources   : Platform specific function before enabling the chip
+ * @release_resources : Platform specific function after  disabling the chip
+ * @enable            : EN pin control by platform side
+ * @patterns          : Predefined pattern data for RGB channels
+ * @num_patterns      : Number of patterns
+ * @update_config     : Value of CONFIG register
+ */
+struct lp55xx_platform_data {
+
+        /* LED channel configuration */
+        struct lp55xx_led_config *led_config;
+        u8 num_channels;
+        const char *label;
+
+        /* Clock configuration */
+        u8 clock_mode;
+
+        /* Platform specific functions */
+        int (*setup_resources)(void);
+        void (*release_resources)(void);
+        void (*enable)(bool state);
+
+        /* Predefined pattern data */
+        struct lp55xx_predef_pattern *patterns;
+        unsigned int num_patterns;
+
+        /* _CONFIG register */
+        u8 update_config;
+};
+
+#endif /* _LEDS_LP55XX_H */
diff --git a/include/linux/platform_data/lp855x.h b/include/linux/platform_data/lp855x.h
index e81f62d24ee2..20ee8b221dbd 100644
--- a/include/linux/platform_data/lp855x.h
+++ b/include/linux/platform_data/lp855x.h
@@ -49,12 +49,24 @@
 #define LP8556_FAST_CONFIG      BIT(7) /* use it if EPROMs should be maintained
                                           when exiting the low power mode */
 
+/* CONFIG register - LP8557 */
+#define LP8557_PWM_STANDBY      BIT(7)
+#define LP8557_PWM_FILTER       BIT(6)
+#define LP8557_RELOAD_EPROM     BIT(3)  /* use it if EPROMs should be reset
+                                           when the backlight turns on */
+#define LP8557_OFF_OPENLEDS     BIT(2)
+#define LP8557_PWM_CONFIG       LP8557_PWM_ONLY
+#define LP8557_I2C_CONFIG       LP8557_I2C_ONLY
+#define LP8557_COMB1_CONFIG     LP8557_COMBINED1
+#define LP8557_COMB2_CONFIG     LP8557_COMBINED2
+
 enum lp855x_chip_id {
         LP8550,
         LP8551,
         LP8552,
         LP8553,
         LP8556,
+        LP8557,
 };
 
 enum lp855x_brightness_ctrl_mode {
@@ -89,6 +101,13 @@ enum lp8556_brightness_source {
         LP8556_COMBINED2,       /* pwm + i2c after the shaper block */
 };
 
+enum lp8557_brightness_source {
+        LP8557_PWM_ONLY,
+        LP8557_I2C_ONLY,
+        LP8557_COMBINED1,       /* pwm + i2c after the shaper block */
+        LP8557_COMBINED2,       /* pwm + i2c before the shaper block */
+};
+
 struct lp855x_rom_data {
         u8 addr;
         u8 val;
diff --git a/include/linux/platform_data/lp8755.h b/include/linux/platform_data/lp8755.h
new file mode 100644
index 000000000000..a7fd0776c9bf
--- /dev/null
+++ b/include/linux/platform_data/lp8755.h
@@ -0,0 +1,71 @@
+/*
+ * LP8755 High Performance Power Management Unit Driver:System Interface Driver
+ *
+ *                      Copyright (C) 2012 Texas Instruments
+ *
+ * Author: Daniel(Geon Si) Jeong <daniel.jeong@ti.com>
+ *             G.Shark Jeong <gshark.jeong@gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ */
+
+#ifndef _LP8755_H
+#define _LP8755_H
+
+#include <linux/regulator/consumer.h>
+
+#define LP8755_NAME "lp8755-regulator"
+/*
+ *PWR FAULT : power fault detected
+ *OCP : over current protect activated
+ *OVP : over voltage protect activated
+ *TEMP_WARN : thermal warning
+ *TEMP_SHDN : thermal shutdonw detected
+ *I_LOAD : current measured
+ */
+#define LP8755_EVENT_PWR_FAULT REGULATOR_EVENT_FAIL
+#define LP8755_EVENT_OCP REGULATOR_EVENT_OVER_CURRENT
+#define LP8755_EVENT_OVP 0x10000
+#define LP8755_EVENT_TEMP_WARN 0x2000
+#define LP8755_EVENT_TEMP_SHDN REGULATOR_EVENT_OVER_TEMP
+#define LP8755_EVENT_I_LOAD     0x40000
+
+enum lp8755_bucks {
+        LP8755_BUCK0 = 0,
+        LP8755_BUCK1,
+        LP8755_BUCK2,
+        LP8755_BUCK3,
+        LP8755_BUCK4,
+        LP8755_BUCK5,
+        LP8755_BUCK_MAX,
+};
+
+/**
+ * multiphase configuration options
+ */
+enum lp8755_mphase_config {
+        MPHASE_CONF0,
+        MPHASE_CONF1,
+        MPHASE_CONF2,
+        MPHASE_CONF3,
+        MPHASE_CONF4,
+        MPHASE_CONF5,
+        MPHASE_CONF6,
+        MPHASE_CONF7,
+        MPHASE_CONF8,
+        MPHASE_CONF_MAX
+};
+
+/**
+ * struct lp8755_platform_data
+ * @mphase_type : Multiphase Switcher Configurations.
+ * @buck_data   : buck0~6 init voltage in uV
+ */
+struct lp8755_platform_data {
+        int mphase;
+        struct regulator_init_data *buck_data[LP8755_BUCK_MAX];
+};
+#endif
diff --git a/include/linux/platform_data/max6697.h b/include/linux/platform_data/max6697.h
new file mode 100644
index 000000000000..ed9d3b3daf02
--- /dev/null
+++ b/include/linux/platform_data/max6697.h
@@ -0,0 +1,36 @@
+/*
+ * max6697.h
+ *     Copyright (c) 2012 Guenter Roeck <linux@roeck-us.net>
+ *
+ * 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 MAX6697_H
+#define MAX6697_H
+
+#include <linux/types.h>
+
+/*
+ * For all bit masks:
+ * bit 0:    local temperature
+ * bit 1..7: remote temperatures
+ */
+struct max6697_platform_data {
+        bool smbus_timeout_disable;     /* set to disable SMBus timeouts */
+        bool extended_range_enable;     /* set to enable extended temp range */
+        bool beta_compensation;         /* set to enable beta compensation */
+        u8 alert_mask;                  /* set bit to 1 to disable alert */
+        u8 over_temperature_mask;       /* set bit to 1 to disable */
+        u8 resistance_cancellation;     /* set bit to 0 to disable
+                                         * bit mask for MAX6581,
+                                         * boolean for other chips
+                                         */
+        u8 ideality_mask;               /* set bit to 0 to disable */
+        u8 ideality_value;              /* transistor ideality as per
+                                         * MAX6581 datasheet
+                                         */
+};
+
+#endif /* MAX6697_H */
diff --git a/include/linux/platform_data/microread.h b/include/linux/platform_data/microread.h
new file mode 100644
index 000000000000..cfda59b226ee
--- /dev/null
+++ b/include/linux/platform_data/microread.h
@@ -0,0 +1,35 @@
+/*
+ * Driver include for the PN544 NFC chip.
+ *
+ * Copyright (C) 2011 Tieto Poland
+ * Copyright (C) 2012 Intel Corporation. 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 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _MICROREAD_H
+#define _MICROREAD_H
+
+#include <linux/i2c.h>
+
+#define MICROREAD_DRIVER_NAME   "microread"
+
+/* board config platform data for microread */
+struct microread_nfc_platform_data {
+        unsigned int rst_gpio;
+        unsigned int irq_gpio;
+        unsigned int ioh_gpio;
+};
+
+#endif /* _MICROREAD_H */
diff --git a/include/linux/platform_data/mmc-esdhc-imx.h b/include/linux/platform_data/mmc-esdhc-imx.h
index aaf97481f413..b4a0521ce411 100644
--- a/include/linux/platform_data/mmc-esdhc-imx.h
+++ b/include/linux/platform_data/mmc-esdhc-imx.h
@@ -39,5 +39,6 @@ struct esdhc_platform_data {
         unsigned int cd_gpio;
         enum wp_types wp_type;
         enum cd_types cd_type;
+        int max_bus_width;
 };
 #endif /* __ASM_ARCH_IMX_ESDHC_H */
diff --git a/include/linux/platform_data/mmc-sdhci-tegra.h b/include/linux/platform_data/mmc-sdhci-tegra.h
deleted file mode 100644
index 8f8430697686..000000000000
--- a/include/linux/platform_data/mmc-sdhci-tegra.h
+++ /dev/null
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2009 Palm, Inc.
- * Author: Yvonne Yip <y@palm.com>
- *
- * This software is licensed under the terms of the GNU General Public
- * License version 2, as published by the Free Software Foundation, and
- * may be copied, distributed, and modified under those terms.
- *
- * 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 __PLATFORM_DATA_TEGRA_SDHCI_H
-#define __PLATFORM_DATA_TEGRA_SDHCI_H
-
-#include <linux/mmc/host.h>
-
-struct tegra_sdhci_platform_data {
-        int cd_gpio;
-        int wp_gpio;
-        int power_gpio;
-        int is_8bit;
-        int pm_flags;
-};
-
-#endif
diff --git a/include/linux/platform_data/mtd-nand-omap2.h b/include/linux/platform_data/mtd-nand-omap2.h
index 24d32ca34bef..6bf9ef43ddb1 100644
--- a/include/linux/platform_data/mtd-nand-omap2.h
+++ b/include/linux/platform_data/mtd-nand-omap2.h
@@ -60,6 +60,8 @@ struct omap_nand_platform_data {
         int                     devsize;
         enum omap_ecc           ecc_opt;
         struct gpmc_nand_regs   reg;
-};
 
+        /* for passing the partitions */
+        struct device_node      *of_node;
+};
 #endif
diff --git a/include/linux/platform_data/mtd-onenand-omap2.h b/include/linux/platform_data/mtd-onenand-omap2.h
index 685af7e8b120..e9a9fb188f97 100644
--- a/include/linux/platform_data/mtd-onenand-omap2.h
+++ b/include/linux/platform_data/mtd-onenand-omap2.h
@@ -29,5 +29,8 @@ struct omap_onenand_platform_data {
         u8                      flags;
         u8                      regulator_can_sleep;
         u8                      skip_initial_unlocking;
+
+        /* for passing the partitions */
+        struct device_node      *of_node;
 };
 #endif
diff --git a/include/linux/platform_data/s3c-hsotg.h b/include/linux/platform_data/s3c-hsotg.h
index 8b79e0967f9c..3f1cbf95ec3b 100644
--- a/include/linux/platform_data/s3c-hsotg.h
+++ b/include/linux/platform_data/s3c-hsotg.h
@@ -15,6 +15,8 @@
 #ifndef __LINUX_USB_S3C_HSOTG_H
 #define __LINUX_USB_S3C_HSOTG_H
 
+struct platform_device;
+
 enum s3c_hsotg_dmamode {
         S3C_HSOTG_DMA_NONE,     /* do not use DMA at-all */
         S3C_HSOTG_DMA_ONLY,     /* always use DMA */
diff --git a/include/linux/platform_data/samsung-usbphy.h b/include/linux/platform_data/samsung-usbphy.h
new file mode 100644
index 000000000000..1bd24cba982b
--- /dev/null
+++ b/include/linux/platform_data/samsung-usbphy.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics Co.Ltd
+ *              http://www.samsung.com/
+ * Author: Praveen Paneri <p.paneri@samsung.com>
+ *
+ * Defines platform data for samsung usb phy driver.
+ *
+ * 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 __SAMSUNG_USBPHY_PLATFORM_H
+#define __SAMSUNG_USBPHY_PLATFORM_H
+
+/**
+ * samsung_usbphy_data - Platform data for USB PHY driver.
+ * @pmu_isolation: Function to control usb phy isolation in PMU.
+ */
+struct samsung_usbphy_data {
+        void (*pmu_isolation)(int on);
+};
+
+extern void samsung_usbphy_set_pdata(struct samsung_usbphy_data *pd);
+
+#endif /* __SAMSUNG_USBPHY_PLATFORM_H */
diff --git a/include/linux/platform_data/sccnxp.h b/include/linux/platform_data/serial-sccnxp.h
index 7311ccd3217f..215574d1e81d 100644
--- a/include/linux/platform_data/sccnxp.h
+++ b/include/linux/platform_data/serial-sccnxp.h
@@ -11,8 +11,8 @@
  *  (at your option) any later version.
  */
 
-#ifndef __SCCNXP_H
-#define __SCCNXP_H
+#ifndef _PLATFORM_DATA_SERIAL_SCCNXP_H_
+#define _PLATFORM_DATA_SERIAL_SCCNXP_H_
 
 #define SCCNXP_MAX_UARTS        2
 
@@ -84,6 +84,8 @@ struct sccnxp_pdata {
         const u8                reg_shift;
         /* Modem control lines configuration */
         const u32               mctrl_cfg[SCCNXP_MAX_UARTS];
+        /* Timer value for polling mode (usecs) */
+        const unsigned int      poll_time_us;
         /* Called during startup */
         void (*init)(void);
         /* Called before finish */
diff --git a/include/linux/platform_data/sh_ipmmu.h b/include/linux/platform_data/sh_ipmmu.h
new file mode 100644
index 000000000000..39f7405cdac5
--- /dev/null
+++ b/include/linux/platform_data/sh_ipmmu.h
@@ -0,0 +1,18 @@
+/* sh_ipmmu.h
+ *
+ * Copyright (C) 2012  Hideki EIRAKU
+ *
+ * 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 __SH_IPMMU_H__
+#define __SH_IPMMU_H__
+
+struct shmobile_ipmmu_platform_data {
+        const char * const *dev_names;
+        unsigned int num_dev_names;
+};
+
+#endif /* __SH_IPMMU_H__ */
diff --git a/include/linux/platform_data/spi-omap2-mcspi.h b/include/linux/platform_data/spi-omap2-mcspi.h
index a65572d53211..c100456eab17 100644
--- a/include/linux/platform_data/spi-omap2-mcspi.h
+++ b/include/linux/platform_data/spi-omap2-mcspi.h
@@ -22,6 +22,9 @@ struct omap2_mcspi_dev_attr {
 
 struct omap2_mcspi_device_config {
         unsigned turbo_mode:1;
+
+        /* toggle chip select after every word */
+        unsigned cs_per_word:1;
 };
 
 #endif
diff --git a/include/linux/platform_data/tsl2563.h b/include/linux/platform_data/tsl2563.h
new file mode 100644
index 000000000000..c90d7a09dda7
--- /dev/null
+++ b/include/linux/platform_data/tsl2563.h
@@ -0,0 +1,8 @@
+#ifndef __LINUX_TSL2563_H
+#define __LINUX_TSL2563_H
+
+struct tsl2563_platform_data {
+        int cover_comp_gain;
+};
+
+#endif /* __LINUX_TSL2563_H */
diff --git a/include/linux/platform_data/usb-omap.h b/include/linux/platform_data/usb-omap.h
index ef65b67c56c3..fa579b4c666b 100644
--- a/include/linux/platform_data/usb-omap.h
+++ b/include/linux/platform_data/usb-omap.h
@@ -55,13 +55,18 @@ struct ohci_hcd_omap_platform_data {
 };
 
 struct usbhs_omap_platform_data {
-        enum usbhs_omap_port_mode               port_mode[OMAP3_HS_USB_PORTS];
+        int                             nports;
+        enum usbhs_omap_port_mode       port_mode[OMAP3_HS_USB_PORTS];
+        int                             reset_gpio_port[OMAP3_HS_USB_PORTS];
+        struct regulator                *regulator[OMAP3_HS_USB_PORTS];
 
         struct ehci_hcd_omap_platform_data      *ehci_data;
         struct ohci_hcd_omap_platform_data      *ohci_data;
 
         /* OMAP3 <= ES2.1 have a single ulpi bypass control bit */
-        unsigned                                single_ulpi_bypass:1;
+        unsigned single_ulpi_bypass:1;
+        unsigned es2_compatibility:1;
+        unsigned phy_reset:1;
 };
 
 /*-------------------------------------------------------------------------*/
diff --git a/include/linux/platform_data/usb3503.h b/include/linux/platform_data/usb3503.h
new file mode 100644
index 000000000000..85dcc709f7e9
--- /dev/null
+++ b/include/linux/platform_data/usb3503.h
@@ -0,0 +1,19 @@
+#ifndef __USB3503_H__
+#define __USB3503_H__
+
+#define USB3503_I2C_NAME        "usb3503"
+
+enum usb3503_mode {
+        USB3503_MODE_UNKNOWN,
+        USB3503_MODE_HUB,
+        USB3503_MODE_STANDBY,
+};
+
+struct usb3503_platform_data {
+        enum usb3503_mode       initial_mode;
+        int     gpio_intn;
+        int     gpio_connect;
+        int     gpio_reset;
+};
+
+#endif
diff --git a/include/linux/platform_data/ux500_wdt.h b/include/linux/platform_data/ux500_wdt.h
new file mode 100644
index 000000000000..1689ff4c3bfd
--- /dev/null
+++ b/include/linux/platform_data/ux500_wdt.h
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) ST Ericsson SA 2011
+ *
+ * License Terms: GNU General Public License v2
+ *
+ * STE Ux500 Watchdog platform data
+ */
+#ifndef __UX500_WDT_H
+#define __UX500_WDT_H
+
+/**
+ * struct ux500_wdt_data
+ */
+struct ux500_wdt_data {
+        unsigned int timeout;
+        bool has_28_bits_resolution;
+};
+
+#endif /* __UX500_WDT_H */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index a9ded9a3c175..c082c71f7225 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -204,6 +204,24 @@ static inline void platform_set_drvdata(struct platform_device *pdev, void *data
         module_driver(__platform_driver, platform_driver_register, \
                         platform_driver_unregister)
 
+/* module_platform_driver_probe() - Helper macro for drivers that don't do
+ * anything special in module init/exit.  This eliminates a lot of
+ * boilerplate.  Each module may only use this macro once, and
+ * calling it replaces module_init() and module_exit()
+ */
+#define module_platform_driver_probe(__platform_driver, __platform_probe) \
+static int __init __platform_driver##_init(void) \
+{ \
+        return platform_driver_probe(&(__platform_driver), \
+                                     __platform_probe);    \
+} \
+module_init(__platform_driver##_init); \
+static void __exit __platform_driver##_exit(void) \
+{ \
+        platform_driver_unregister(&(__platform_driver)); \
+} \
+module_exit(__platform_driver##_exit);
+
 extern struct platform_device *platform_create_bundle(struct platform_driver *driver,
                                         int (*probe)(struct platform_device *),
                                         struct resource *res, unsigned int n_res,
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 03d7bb145311..e5d7230332a4 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -31,7 +31,6 @@
 /*
  * Callbacks for platform drivers to implement.
  */
-extern void (*pm_idle)(void);
 extern void (*pm_power_off)(void);
 extern void (*pm_power_off_prepare)(void);
 
@@ -538,6 +537,7 @@ struct dev_pm_info {
         unsigned int            irq_safe:1;
         unsigned int            use_autosuspend:1;
         unsigned int            timer_autosuspends:1;
+        unsigned int            memalloc_noio:1;
         enum rpm_request        request;
         enum rpm_status         runtime_status;
         int                     runtime_error;
diff --git a/include/linux/pm2301_charger.h b/include/linux/pm2301_charger.h
new file mode 100644
index 000000000000..fc3f026922ae
--- /dev/null
+++ b/include/linux/pm2301_charger.h
@@ -0,0 +1,61 @@
+/*
+ * PM2301 charger driver.
+ *
+ * Copyright (C) 2012 ST Ericsson Corporation
+ *
+ * Contact: Olivier LAUNAY (olivier.launay@stericsson.com
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
+ * 02110-1301 USA
+ */
+
+#ifndef __LINUX_PM2301_H
+#define __LINUX_PM2301_H
+
+/**
+ * struct pm2xxx_bm_charger_parameters - Charger specific parameters
+ * @ac_volt_max:        maximum allowed AC charger voltage in mV
+ * @ac_curr_max:        maximum allowed AC charger current in mA
+ */
+struct pm2xxx_bm_charger_parameters {
+        int ac_volt_max;
+        int ac_curr_max;
+};
+
+/**
+ * struct pm2xxx_bm_data - pm2xxx battery management data
+ * @enable_overshoot    flag to enable VBAT overshoot control
+ * @chg_params    charger parameters
+ */
+struct pm2xxx_bm_data {
+        bool enable_overshoot;
+        const struct pm2xxx_bm_charger_parameters *chg_params;
+};
+
+struct pm2xxx_charger_platform_data {
+        char **supplied_to;
+        size_t num_supplicants;
+        int i2c_bus;
+        const char *label;
+        int irq_number;
+        unsigned int lpn_gpio;
+        int irq_type;
+};
+
+struct pm2xxx_platform_data {
+        struct pm2xxx_charger_platform_data *wall_charger;
+        struct pm2xxx_bm_data *battery;
+};
+
+#endif /* __LINUX_PM2301_H */
diff --git a/include/linux/pm_runtime.h b/include/linux/pm_runtime.h
index f271860c78d5..7d7e09efff9b 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -47,6 +47,7 @@ extern void pm_runtime_set_autosuspend_delay(struct device *dev, int delay);
 extern unsigned long pm_runtime_autosuspend_expiration(struct device *dev);
 extern void pm_runtime_update_max_time_suspended(struct device *dev,
                                                  s64 delta_ns);
+extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
 
 static inline bool pm_children_suspended(struct device *dev)
 {
@@ -80,6 +81,12 @@ static inline bool pm_runtime_suspended(struct device *dev)
                 && !dev->power.disable_depth;
 }
 
+static inline bool pm_runtime_active(struct device *dev)
+{
+        return dev->power.runtime_status == RPM_ACTIVE
+                || dev->power.disable_depth;
+}
+
 static inline bool pm_runtime_status_suspended(struct device *dev)
 {
         return dev->power.runtime_status == RPM_SUSPENDED;
@@ -132,6 +139,7 @@ static inline void pm_runtime_put_noidle(struct device *dev) {}
 static inline bool device_run_wake(struct device *dev) { return false; }
 static inline void device_set_run_wake(struct device *dev, bool enable) {}
 static inline bool pm_runtime_suspended(struct device *dev) { return false; }
+static inline bool pm_runtime_active(struct device *dev) { return true; }
 static inline bool pm_runtime_status_suspended(struct device *dev) { return false; }
 static inline bool pm_runtime_enabled(struct device *dev) { return false; }
 
@@ -149,6 +157,8 @@ static inline void pm_runtime_set_autosuspend_delay(struct device *dev,
                                                 int delay) {}
 static inline unsigned long pm_runtime_autosuspend_expiration(
                                 struct device *dev) { return 0; }
+static inline void pm_runtime_set_memalloc_noio(struct device *dev,
+                                                bool enable){}
 
 #endif /* !CONFIG_PM_RUNTIME */
 
diff --git a/include/linux/power/bq2415x_charger.h b/include/linux/power/bq2415x_charger.h
index 97a1665eaeaf..8dcc0f46fc0a 100644
--- a/include/linux/power/bq2415x_charger.h
+++ b/include/linux/power/bq2415x_charger.h
@@ -75,7 +75,8 @@
 
 /* Supported modes with maximal current limit */
 enum bq2415x_mode {
-        BQ2415X_MODE_NONE,              /* unknown or no charger (100mA) */
+        BQ2415X_MODE_OFF,               /* offline mode (charger disabled) */
+        BQ2415X_MODE_NONE,              /* unknown charger (100mA) */
         BQ2415X_MODE_HOST_CHARGER,      /* usb host/hub charger (500mA) */
         BQ2415X_MODE_DEDICATED_CHARGER, /* dedicated charger (unlimited) */
         BQ2415X_MODE_BOOST,             /* boost mode (charging disabled) */
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index 1f0ab90aff00..002a99f96331 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -54,6 +54,8 @@ enum {
         POWER_SUPPLY_HEALTH_OVERVOLTAGE,
         POWER_SUPPLY_HEALTH_UNSPEC_FAILURE,
         POWER_SUPPLY_HEALTH_COLD,
+        POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE,
+        POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE,
 };
 
 enum {
@@ -224,7 +226,7 @@ struct power_supply_info {
         int use_for_apm;
 };
 
-extern struct power_supply *power_supply_get_by_name(char *name);
+extern struct power_supply *power_supply_get_by_name(const char *name);
 extern void power_supply_changed(struct power_supply *psy);
 extern int power_supply_am_i_supplied(struct power_supply *psy);
 extern int power_supply_set_battery_charged(struct power_supply *psy);
diff --git a/include/linux/pps_kernel.h b/include/linux/pps_kernel.h
index 0cc45ae1afd5..7db3eb93a079 100644
--- a/include/linux/pps_kernel.h
+++ b/include/linux/pps_kernel.h
@@ -43,7 +43,7 @@ struct pps_source_info {
                         int event, void *data); /* PPS echo function */
 
         struct module *owner;
-        struct device *dev;
+        struct device *dev;             /* Parent device for device_create */
 };
 
 struct pps_event_time {
@@ -69,6 +69,7 @@ struct pps_device {
         wait_queue_head_t queue;                /* PPS event queue */
 
         unsigned int id;                        /* PPS source unique ID */
+        void const *lookup_cookie;              /* pps_lookup_dev only */
         struct cdev cdev;
         struct device *dev;
         struct fasync_struct *async_queue;      /* fasync method */
@@ -82,16 +83,26 @@ struct pps_device {
 extern struct device_attribute pps_attrs[];
 
 /*
+ * Internal functions.
+ *
+ * These are not actually part of the exported API, but this is a
+ * convenient header file to put them in.
+ */
+
+extern int pps_register_cdev(struct pps_device *pps);
+extern void pps_unregister_cdev(struct pps_device *pps);
+
+/*
  * Exported functions
  */
 
 extern struct pps_device *pps_register_source(
                 struct pps_source_info *info, int default_params);
 extern void pps_unregister_source(struct pps_device *pps);
-extern int pps_register_cdev(struct pps_device *pps);
-extern void pps_unregister_cdev(struct pps_device *pps);
 extern void pps_event(struct pps_device *pps,
                 struct pps_event_time *ts, int event, void *data);
+/* Look up a pps device by magic cookie */
+struct pps_device *pps_lookup_dev(void const *cookie);
 
 static inline void timespec_to_pps_ktime(struct pps_ktime *kt,
                 struct timespec ts)
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 9afc01e5a0a6..1249a54d17e0 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -98,9 +98,6 @@ int no_printk(const char *fmt, ...)
 extern asmlinkage __printf(1, 2)
 void early_printk(const char *fmt, ...);
 
-extern int printk_needs_cpu(int cpu);
-extern void printk_tick(void);
-
 #ifdef CONFIG_PRINTK
 asmlinkage __printf(5, 0)
 int vprintk_emit(int facility, int level,
@@ -255,6 +252,15 @@ extern void dump_stack(void) __cold;
         printk_once(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
 #define pr_cont_once(fmt, ...)                                  \
         printk_once(KERN_CONT pr_fmt(fmt), ##__VA_ARGS__)
+
+#if defined(DEBUG)
+#define pr_devel_once(fmt, ...)                                 \
+        printk_once(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#else
+#define pr_devel_once(fmt, ...)                                 \
+        no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#endif
+
 /* If you are writing a driver, please use dev_dbg instead */
 #if defined(DEBUG)
 #define pr_debug_once(fmt, ...)                                 \
@@ -298,6 +304,15 @@ extern void dump_stack(void) __cold;
 #define pr_info_ratelimited(fmt, ...)                                   \
         printk_ratelimited(KERN_INFO pr_fmt(fmt), ##__VA_ARGS__)
 /* no pr_cont_ratelimited, don't do that... */
+
+#if defined(DEBUG)
+#define pr_devel_ratelimited(fmt, ...)                                  \
+        printk_ratelimited(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#else
+#define pr_devel_ratelimited(fmt, ...)                                  \
+        no_printk(KERN_DEBUG pr_fmt(fmt), ##__VA_ARGS__)
+#endif
+
 /* If you are writing a driver, please use dev_dbg instead */
 #if defined(DEBUG)
 #define pr_debug_ratelimited(fmt, ...)                                  \
@@ -321,8 +336,13 @@ extern void hex_dump_to_buffer(const void *buf, size_t len,
 extern void print_hex_dump(const char *level, const char *prefix_str,
                            int prefix_type, int rowsize, int groupsize,
                            const void *buf, size_t len, bool ascii);
+#if defined(CONFIG_DYNAMIC_DEBUG)
+#define print_hex_dump_bytes(prefix_str, prefix_type, buf, len) \
+        dynamic_hex_dump(prefix_str, prefix_type, 16, 1, buf, len, true)
+#else
 extern void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
                                  const void *buf, size_t len);
+#endif /* defined(CONFIG_DYNAMIC_DEBUG) */
 #else
 static inline void print_hex_dump(const char *level, const char *prefix_str,
                                   int prefix_type, int rowsize, int groupsize,
@@ -336,4 +356,16 @@ static inline void print_hex_dump_bytes(const char *prefix_str, int prefix_type,
 
 #endif
 
+#if defined(CONFIG_DYNAMIC_DEBUG)
+#define print_hex_dump_debug(prefix_str, prefix_type, rowsize,  \
+                             groupsize, buf, len, ascii)        \
+        dynamic_hex_dump(prefix_str, prefix_type, rowsize,      \
+                         groupsize, buf, len, ascii)
+#else
+#define print_hex_dump_debug(prefix_str, prefix_type, rowsize,          \
+                             groupsize, buf, len, ascii)                \
+        print_hex_dump(KERN_DEBUG, prefix_str, prefix_type, rowsize,    \
+                       groupsize, buf, len, ascii)
+#endif /* defined(CONFIG_DYNAMIC_DEBUG) */
+
 #endif
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 32676b35d2f5..8307f2f94d86 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -127,7 +127,12 @@ extern void pid_ns_release_proc(struct pid_namespace *ns);
  * proc_tty.c
  */
 struct tty_driver;
+#ifdef CONFIG_TTY
 extern void proc_tty_init(void);
+#else
+static inline void proc_tty_init(void)
+{ }
+#endif
 extern void proc_tty_register_driver(struct tty_driver *driver);
 extern void proc_tty_unregister_driver(struct tty_driver *driver);
 
@@ -171,9 +176,6 @@ static inline struct proc_dir_entry *create_proc_read_entry(const char *name,
         return res;
 }
  
-extern struct proc_dir_entry *proc_net_fops_create(struct net *net,
-        const char *name, umode_t mode, const struct file_operations *fops);
-extern void proc_net_remove(struct net *net, const char *name);
 extern struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
         struct proc_dir_entry *parent);
 
@@ -184,21 +186,15 @@ extern int proc_alloc_inum(unsigned int *pino);
 extern void proc_free_inum(unsigned int inum);
 #else
 
-#define proc_net_fops_create(net, name, mode, fops)  ({ (void)(mode), NULL; })
-static inline void proc_net_remove(struct net *net, const char *name) {}
-
 static inline void proc_flush_task(struct task_struct *task)
 {
 }
 
 static inline struct proc_dir_entry *create_proc_entry(const char *name,
         umode_t mode, struct proc_dir_entry *parent) { return NULL; }
-static inline struct proc_dir_entry *proc_create(const char *name,
-        umode_t mode, struct proc_dir_entry *parent,
-        const struct file_operations *proc_fops)
-{
-        return NULL;
-}
+
+#define proc_create(name, mode, parent, fops)  ({ (void)(mode), NULL; })
+
 static inline struct proc_dir_entry *proc_create_data(const char *name,
         umode_t mode, struct proc_dir_entry *parent,
         const struct file_operations *proc_fops, void *data)
diff --git a/include/linux/profile.h b/include/linux/profile.h
index a0fc32279fc0..21123902366d 100644
--- a/include/linux/profile.h
+++ b/include/linux/profile.h
@@ -82,9 +82,6 @@ int task_handoff_unregister(struct notifier_block * n);
 int profile_event_register(enum profile_type, struct notifier_block * n);
 int profile_event_unregister(enum profile_type, struct notifier_block * n);
 
-int register_timer_hook(int (*hook)(struct pt_regs *));
-void unregister_timer_hook(int (*hook)(struct pt_regs *));
-
 struct pt_regs;
 
 #else
@@ -135,16 +132,6 @@ static inline int profile_event_unregister(enum profile_type t, struct notifier_
 #define profile_handoff_task(a) (0)
 #define profile_munmap(a) do { } while (0)
 
-static inline int register_timer_hook(int (*hook)(struct pt_regs *))
-{
-        return -ENOSYS;
-}
-
-static inline void unregister_timer_hook(int (*hook)(struct pt_regs *))
-{
-        return;
-}
-
 #endif /* CONFIG_PROFILING */
 
 #endif /* _LINUX_PROFILE_H */
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 1788909d9a99..75d01760c911 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -68,12 +68,18 @@ struct pstore_info {
 
 #ifdef CONFIG_PSTORE
 extern int pstore_register(struct pstore_info *);
+extern bool pstore_cannot_block_path(enum kmsg_dump_reason reason);
 #else
 static inline int
 pstore_register(struct pstore_info *psi)
 {
         return -ENODEV;
 }
+static inline bool
+pstore_cannot_block_path(enum kmsg_dump_reason reason)
+{
+        return false;
+}
 #endif
 
 #endif /*_LINUX_PSTORE_H*/
diff --git a/include/linux/pwm.h b/include/linux/pwm.h
index 6d661f32e0e4..a4df2042b79c 100644
--- a/include/linux/pwm.h
+++ b/include/linux/pwm.h
@@ -146,6 +146,8 @@ struct pwm_ops {
  * @base: number of first PWM controlled by this chip
  * @npwm: number of PWMs controlled by this chip
  * @pwms: array of PWM devices allocated by the framework
+ * @can_sleep: must be true if the .config(), .enable() or .disable()
+ *             operations may sleep
  */
 struct pwm_chip {
         struct device           *dev;
@@ -159,6 +161,7 @@ struct pwm_chip {
         struct pwm_device *     (*of_xlate)(struct pwm_chip *pc,
                                             const struct of_phandle_args *args);
         unsigned int            of_pwm_n_cells;
+        bool                    can_sleep;
 };
 
 #if IS_ENABLED(CONFIG_PWM)
@@ -174,11 +177,16 @@ struct pwm_device *pwm_request_from_chip(struct pwm_chip *chip,
 struct pwm_device *of_pwm_xlate_with_flags(struct pwm_chip *pc,
                 const struct of_phandle_args *args);
 
-struct pwm_device *pwm_get(struct device *dev, const char *consumer);
+struct pwm_device *pwm_get(struct device *dev, const char *con_id);
+struct pwm_device *of_pwm_get(struct device_node *np, const char *con_id);
 void pwm_put(struct pwm_device *pwm);
 
-struct pwm_device *devm_pwm_get(struct device *dev, const char *consumer);
+struct pwm_device *devm_pwm_get(struct device *dev, const char *con_id);
+struct pwm_device *devm_of_pwm_get(struct device *dev, struct device_node *np,
+                                   const char *con_id);
 void devm_pwm_put(struct device *dev, struct pwm_device *pwm);
+
+bool pwm_can_sleep(struct pwm_device *pwm);
 #else
 static inline int pwm_set_chip_data(struct pwm_device *pwm, void *data)
 {
@@ -213,6 +221,12 @@ static inline struct pwm_device *pwm_get(struct device *dev,
         return ERR_PTR(-ENODEV);
 }
 
+static inline struct pwm_device *of_pwm_get(struct device_node *np,
+                                            const char *con_id)
+{
+        return ERR_PTR(-ENODEV);
+}
+
 static inline void pwm_put(struct pwm_device *pwm)
 {
 }
@@ -223,9 +237,21 @@ static inline struct pwm_device *devm_pwm_get(struct device *dev,
         return ERR_PTR(-ENODEV);
 }
 
+static inline struct pwm_device *devm_of_pwm_get(struct device *dev,
+                                                 struct device_node *np,
+                                                 const char *con_id)
+{
+        return ERR_PTR(-ENODEV);
+}
+
 static inline void devm_pwm_put(struct device *dev, struct pwm_device *pwm)
 {
 }
+
+static inline bool pwm_can_sleep(struct pwm_device *pwm)
+{
+        return false;
+}
 #endif
 
 struct pwm_lookup {
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index f36632061c66..467cc6307b62 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -155,6 +155,14 @@
 #define SSACD_ACDS(x)           ((x) << 0)      /* Audio clock divider select */
 #define SSACD_SCDX8             (1 << 7)        /* SYSCLK division ratio select */
 
+/* LPSS SSP */
+#define SSITF                   0x44            /* TX FIFO trigger level */
+#define SSITF_TxLoThresh(x)     (((x) - 1) << 8)
+#define SSITF_TxHiThresh(x)     ((x) - 1)
+
+#define SSIRF                   0x48            /* RX FIFO trigger level */
+#define SSIRF_RxThresh(x)       ((x) - 1)
+
 enum pxa_ssp_type {
         SSP_UNDEFINED = 0,
         PXA25x_SSP,  /* pxa 210, 250, 255, 26x */
@@ -164,6 +172,7 @@ enum pxa_ssp_type {
         PXA168_SSP,
         PXA910_SSP,
         CE4100_SSP,
+        LPSS_SSP,
 };
 
 struct ssp_device {
@@ -206,6 +215,15 @@ static inline u32 pxa_ssp_read_reg(struct ssp_device *dev, u32 reg)
         return __raw_readl(dev->mmio_base + reg);
 }
 
+#ifdef CONFIG_ARCH_PXA
 struct ssp_device *pxa_ssp_request(int port, const char *label);
 void pxa_ssp_free(struct ssp_device *);
+#else
+static inline struct ssp_device *pxa_ssp_request(int port, const char *label)
+{
+        return NULL;
+}
+static inline void pxa_ssp_free(struct ssp_device *ssp) {}
+#endif
+
 #endif
diff --git a/include/linux/random.h b/include/linux/random.h
index d9846088c2c5..347ce553a306 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -74,4 +74,10 @@ static inline int arch_get_random_int(unsigned int *v)
 }
 #endif
 
+/* Pseudo random number generator from numerical recipes. */
+static inline u32 next_pseudo_random32(u32 seed)
+{
+        return seed * 1664525 + 1013904223;
+}
+
 #endif /* _LINUX_RANDOM_H */
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 275aa3f1062d..b758ce17b309 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -53,7 +53,10 @@ extern int rcutorture_runnable; /* for sysctl */
 extern void rcutorture_record_test_transition(void);
 extern void rcutorture_record_progress(unsigned long vernum);
 extern void do_trace_rcu_torture_read(char *rcutorturename,
-                                      struct rcu_head *rhp);
+                                      struct rcu_head *rhp,
+                                      unsigned long secs,
+                                      unsigned long c_old,
+                                      unsigned long c);
 #else
 static inline void rcutorture_record_test_transition(void)
 {
@@ -63,9 +66,13 @@ static inline void rcutorture_record_progress(unsigned long vernum)
 }
 #ifdef CONFIG_RCU_TRACE
 extern void do_trace_rcu_torture_read(char *rcutorturename,
-                                      struct rcu_head *rhp);
+                                      struct rcu_head *rhp,
+                                      unsigned long secs,
+                                      unsigned long c_old,
+                                      unsigned long c);
 #else
-#define do_trace_rcu_torture_read(rcutorturename, rhp) do { } while (0)
+#define do_trace_rcu_torture_read(rcutorturename, rhp, secs, c_old, c) \
+        do { } while (0)
 #endif
 #endif
 
@@ -749,7 +756,7 @@ static inline void rcu_preempt_sleep_check(void)
  * preemptible RCU implementations (TREE_PREEMPT_RCU and TINY_PREEMPT_RCU)
  * in CONFIG_PREEMPT kernel builds, RCU read-side critical sections may
  * be preempted, but explicit blocking is illegal.  Finally, in preemptible
- * RCU implementations in real-time (CONFIG_PREEMPT_RT) kernel builds,
+ * RCU implementations in real-time (with -rt patchset) kernel builds,
  * RCU read-side critical sections may be preempted and they may also
  * block, but only when acquiring spinlocks that are subject to priority
  * inheritance.
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index b7e95bf942c9..bf77dfdabef9 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -28,7 +28,8 @@ struct regmap_range_cfg;
 enum regcache_type {
         REGCACHE_NONE,
         REGCACHE_RBTREE,
-        REGCACHE_COMPRESSED
+        REGCACHE_COMPRESSED,
+        REGCACHE_FLAT,
 };
 
 /**
@@ -127,7 +128,18 @@ typedef void (*regmap_unlock)(void *);
  * @lock_arg:     this field is passed as the only argument of lock/unlock
  *                functions (ignored in case regular lock/unlock functions
  *                are not overridden).
- *
+ * @reg_read:     Optional callback that if filled will be used to perform
+ *                all the reads from the registers. Should only be provided for
+ *                devices whos read operation cannot be represented as a simple read
+ *                operation on a bus such as SPI, I2C, etc. Most of the devices do
+ *                not need this.
+ * @reg_write:    Same as above for writing.
+ * @fast_io:      Register IO is fast. Use a spinlock instead of a mutex
+ *                to perform locking. This field is ignored if custom lock/unlock
+ *                functions are used (see fields lock/unlock of struct regmap_config).
+ *                This field is a duplicate of a similar file in
+ *                'struct regmap_bus' and serves exact same purpose.
+ *                 Use it only for "no-bus" cases.
  * @max_register: Optional, specifies the maximum valid register index.
  * @wr_table:     Optional, points to a struct regmap_access_table specifying
  *                valid ranges for write access.
@@ -177,6 +189,11 @@ struct regmap_config {
         regmap_unlock unlock;
         void *lock_arg;
 
+        int (*reg_read)(void *context, unsigned int reg, unsigned int *val);
+        int (*reg_write)(void *context, unsigned int reg, unsigned int val);
+
+        bool fast_io;
+
         unsigned int max_register;
         const struct regmap_access_table *wr_table;
         const struct regmap_access_table *rd_table;
@@ -235,14 +252,21 @@ struct regmap_range_cfg {
         unsigned int window_len;
 };
 
+struct regmap_async;
+
 typedef int (*regmap_hw_write)(void *context, const void *data,
                                size_t count);
 typedef int (*regmap_hw_gather_write)(void *context,
                                       const void *reg, size_t reg_len,
                                       const void *val, size_t val_len);
+typedef int (*regmap_hw_async_write)(void *context,
+                                     const void *reg, size_t reg_len,
+                                     const void *val, size_t val_len,
+                                     struct regmap_async *async);
 typedef int (*regmap_hw_read)(void *context,
                               const void *reg_buf, size_t reg_size,
                               void *val_buf, size_t val_size);
+typedef struct regmap_async *(*regmap_hw_async_alloc)(void);
 typedef void (*regmap_hw_free_context)(void *context);
 
 /**
@@ -255,8 +279,11 @@ typedef void (*regmap_hw_free_context)(void *context);
  * @write: Write operation.
  * @gather_write: Write operation with split register/value, return -ENOTSUPP
  *                if not implemented  on a given device.
+ * @async_write: Write operation which completes asynchronously, optional and
+ *               must serialise with respect to non-async I/O.
  * @read: Read operation.  Data is returned in the buffer used to transmit
  *         data.
+ * @async_alloc: Allocate a regmap_async() structure.
  * @read_flag_mask: Mask to be set in the top byte of the register when doing
  *                  a read.
  * @reg_format_endian_default: Default endianness for formatted register
@@ -265,13 +292,16 @@ typedef void (*regmap_hw_free_context)(void *context);
  * @val_format_endian_default: Default endianness for formatted register
  *     values. Used when the regmap_config specifies DEFAULT. If this is
  *     DEFAULT, BIG is assumed.
+ * @async_size: Size of struct used for async work.
  */
 struct regmap_bus {
         bool fast_io;
         regmap_hw_write write;
         regmap_hw_gather_write gather_write;
+        regmap_hw_async_write async_write;
         regmap_hw_read read;
         regmap_hw_free_context free_context;
+        regmap_hw_async_alloc async_alloc;
         u8 read_flag_mask;
         enum regmap_endian reg_format_endian_default;
         enum regmap_endian val_format_endian_default;
@@ -285,9 +315,9 @@ struct regmap *regmap_init_i2c(struct i2c_client *i2c,
                                const struct regmap_config *config);
 struct regmap *regmap_init_spi(struct spi_device *dev,
                                const struct regmap_config *config);
-struct regmap *regmap_init_mmio(struct device *dev,
-                                void __iomem *regs,
-                                const struct regmap_config *config);
+struct regmap *regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                    void __iomem *regs,
+                                    const struct regmap_config *config);
 
 struct regmap *devm_regmap_init(struct device *dev,
                                 const struct regmap_bus *bus,
@@ -297,9 +327,44 @@ struct regmap *devm_regmap_init_i2c(struct i2c_client *i2c,
                                     const struct regmap_config *config);
 struct regmap *devm_regmap_init_spi(struct spi_device *dev,
                                     const struct regmap_config *config);
-struct regmap *devm_regmap_init_mmio(struct device *dev,
-                                     void __iomem *regs,
-                                     const struct regmap_config *config);
+struct regmap *devm_regmap_init_mmio_clk(struct device *dev, const char *clk_id,
+                                         void __iomem *regs,
+                                         const struct regmap_config *config);
+
+/**
+ * regmap_init_mmio(): Initialise register map
+ *
+ * @dev: Device that will be interacted with
+ * @regs: Pointer to memory-mapped IO region
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer to
+ * a struct regmap.
+ */
+static inline struct regmap *regmap_init_mmio(struct device *dev,
+                                        void __iomem *regs,
+                                        const struct regmap_config *config)
+{
+        return regmap_init_mmio_clk(dev, NULL, regs, config);
+}
+
+/**
+ * devm_regmap_init_mmio(): Initialise managed register map
+ *
+ * @dev: Device that will be interacted with
+ * @regs: Pointer to memory-mapped IO region
+ * @config: Configuration for register map
+ *
+ * The return value will be an ERR_PTR() on error or a valid pointer
+ * to a struct regmap.  The regmap will be automatically freed by the
+ * device management code.
+ */
+static inline struct regmap *devm_regmap_init_mmio(struct device *dev,
+                                        void __iomem *regs,
+                                        const struct regmap_config *config)
+{
+        return devm_regmap_init_mmio_clk(dev, NULL, regs, config);
+}
 
 void regmap_exit(struct regmap *map);
 int regmap_reinit_cache(struct regmap *map,
@@ -310,6 +375,8 @@ int regmap_raw_write(struct regmap *map, unsigned int reg,
                      const void *val, size_t val_len);
 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                         size_t val_count);
+int regmap_raw_write_async(struct regmap *map, unsigned int reg,
+                           const void *val, size_t val_len);
 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
 int regmap_raw_read(struct regmap *map, unsigned int reg,
                     void *val, size_t val_len);
@@ -321,6 +388,7 @@ int regmap_update_bits_check(struct regmap *map, unsigned int reg,
                              unsigned int mask, unsigned int val,
                              bool *change);
 int regmap_get_val_bytes(struct regmap *map);
+int regmap_async_complete(struct regmap *map);
 
 int regcache_sync(struct regmap *map);
 int regcache_sync_region(struct regmap *map, unsigned int min,
@@ -381,6 +449,7 @@ struct regmap_irq_chip {
         unsigned int wake_base;
         unsigned int irq_reg_stride;
         unsigned int mask_invert;
+        unsigned int wake_invert;
         bool runtime_pm;
 
         int num_regs;
@@ -422,6 +491,13 @@ static inline int regmap_raw_write(struct regmap *map, unsigned int reg,
         return -EINVAL;
 }
 
+static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
+                                         const void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
                                     const void *val, size_t val_count)
 {
@@ -500,6 +576,11 @@ static inline void regcache_mark_dirty(struct regmap *map)
         WARN_ONCE(1, "regmap API is disabled");
 }
 
+static inline void regmap_async_complete(struct regmap *map)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+}
+
 static inline int regmap_register_patch(struct regmap *map,
                                         const struct reg_default *regs,
                                         int num_regs)
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index d10bb0f39c5e..23070fd83872 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -193,6 +193,10 @@ enum regulator_type {
  *
  * @vsel_reg: Register for selector when using regulator_regmap_X_voltage_
  * @vsel_mask: Mask for register bitfield used for selector
+ * @apply_reg: Register for initiate voltage change on the output when
+ *                using regulator_set_voltage_sel_regmap
+ * @apply_bit: Register bitfield used for initiate voltage change on the
+ *                output when using regulator_set_voltage_sel_regmap
  * @enable_reg: Register for control when using regmap enable/disable ops
  * @enable_mask: Mask for control when using regmap enable/disable ops
  *
@@ -218,6 +222,8 @@ struct regulator_desc {
 
         unsigned int vsel_reg;
         unsigned int vsel_mask;
+        unsigned int apply_reg;
+        unsigned int apply_bit;
         unsigned int enable_reg;
         unsigned int enable_mask;
         unsigned int bypass_reg;
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 519777e3fa01..1342e69542f3 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -167,6 +167,7 @@ unsigned long ring_buffer_entries_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_overrun_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_commit_overrun_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_dropped_events_cpu(struct ring_buffer *buffer, int cpu);
+unsigned long ring_buffer_read_events_cpu(struct ring_buffer *buffer, int cpu);
 
 u64 ring_buffer_time_stamp(struct ring_buffer *buffer, int cpu);
 void ring_buffer_normalize_time_stamp(struct ring_buffer *buffer,
diff --git a/include/linux/rmap.h b/include/linux/rmap.h
index c20635c527a9..6dacb93a6d94 100644
--- a/include/linux/rmap.h
+++ b/include/linux/rmap.h
@@ -123,7 +123,7 @@ static inline void anon_vma_lock_write(struct anon_vma *anon_vma)
         down_write(&anon_vma->root->rwsem);
 }
 
-static inline void anon_vma_unlock(struct anon_vma *anon_vma)
+static inline void anon_vma_unlock_write(struct anon_vma *anon_vma)
 {
         up_write(&anon_vma->root->rwsem);
 }
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 9531845c419f..580b24c8b8ca 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -138,6 +138,7 @@ extern void rtc_device_unregister(struct rtc_device *rtc);
 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);
 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);
@@ -148,7 +149,7 @@ extern int rtc_initialize_alarm(struct rtc_device *rtc,
 extern void rtc_update_irq(struct rtc_device *rtc,
                         unsigned long num, unsigned long events);
 
-extern struct rtc_device *rtc_class_open(char *name);
+extern struct rtc_device *rtc_class_open(const char *name);
 extern void rtc_class_close(struct rtc_device *rtc);
 
 extern int rtc_irq_register(struct rtc_device *rtc,
diff --git a/include/linux/sched.h b/include/linux/sched.h
index d2112477ff5e..0655570c67eb 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -51,6 +51,7 @@ struct sched_param {
 #include <linux/cred.h>
 #include <linux/llist.h>
 #include <linux/uidgid.h>
+#include <linux/gfp.h>
 
 #include <asm/processor.h>
 
@@ -304,19 +305,6 @@ static inline void lockup_detector_init(void)
 }
 #endif
 
-#ifdef CONFIG_DETECT_HUNG_TASK
-extern unsigned int  sysctl_hung_task_panic;
-extern unsigned long sysctl_hung_task_check_count;
-extern unsigned long sysctl_hung_task_timeout_secs;
-extern unsigned long sysctl_hung_task_warnings;
-extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
-                                         void __user *buffer,
-                                         size_t *lenp, loff_t *ppos);
-#else
-/* Avoid need for ifdefs elsewhere in the code */
-enum { sysctl_hung_task_timeout_secs = 0 };
-#endif
-
 /* Attach to any functions which should be ignored in wchan output. */
 #define __sched         __attribute__((__section__(".sched.text")))
 
@@ -338,23 +326,6 @@ extern int mutex_spin_on_owner(struct mutex *lock, struct task_struct *owner);
 struct nsproxy;
 struct user_namespace;
 
-/*
- * Default maximum number of active map areas, this limits the number of vmas
- * per mm struct. Users can overwrite this number by sysctl but there is a
- * problem.
- *
- * When a program's coredump is generated as ELF format, a section is created
- * per a vma. In ELF, the number of sections is represented in unsigned short.
- * This means the number of sections should be smaller than 65535 at coredump.
- * Because the kernel adds some informative sections to a image of program at
- * generating coredump, we need some margin. The number of extra sections is
- * 1-3 now and depends on arch. We use "5" as safe margin, here.
- */
-#define MAPCOUNT_ELF_CORE_MARGIN        (5)
-#define DEFAULT_MAX_MAP_COUNT   (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
-
-extern int sysctl_max_map_count;
-
 #include <linux/aio.h>
 
 #ifdef CONFIG_MMU
@@ -1194,6 +1165,7 @@ struct sched_entity {
         /* rq "owned" by this entity/group: */
         struct cfs_rq           *my_q;
 #endif
+
 /*
  * Load-tracking only depends on SMP, FAIR_GROUP_SCHED dependency below may be
  * removed when useful for applications beyond shares distribution (e.g.
@@ -1208,6 +1180,7 @@ struct sched_entity {
 struct sched_rt_entity {
         struct list_head run_list;
         unsigned long timeout;
+        unsigned long watchdog_stamp;
         unsigned int time_slice;
 
         struct sched_rt_entity *back;
@@ -1220,11 +1193,6 @@ struct sched_rt_entity {
 #endif
 };
 
-/*
- * default timeslice is 100 msecs (used only for SCHED_RR tasks).
- * Timeslices get refilled after they expire.
- */
-#define RR_TIMESLICE            (100 * HZ / 1000)
 
 struct rcu_node;
 
@@ -1368,6 +1336,15 @@ struct task_struct {
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
         struct cputime prev_cputime;
 #endif
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
+        seqlock_t vtime_seqlock;
+        unsigned long long vtime_snap;
+        enum {
+                VTIME_SLEEPING = 0,
+                VTIME_USER,
+                VTIME_SYS,
+        } vtime_snap_whence;
+#endif
         unsigned long nvcsw, nivcsw; /* context switch counts */
         struct timespec start_time;             /* monotonic time */
         struct timespec real_start_time;        /* boot based time */
@@ -1622,37 +1599,6 @@ static inline void set_numabalancing_state(bool enabled)
 }
 #endif
 
-/*
- * Priority of a process goes from 0..MAX_PRIO-1, valid RT
- * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
- * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
- * values are inverted: lower p->prio value means higher priority.
- *
- * The MAX_USER_RT_PRIO value allows the actual maximum
- * RT priority to be separate from the value exported to
- * user-space.  This allows kernel threads to set their
- * priority to a value higher than any user task. Note:
- * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
- */
-
-#define MAX_USER_RT_PRIO        100
-#define MAX_RT_PRIO             MAX_USER_RT_PRIO
-
-#define MAX_PRIO                (MAX_RT_PRIO + 40)
-#define DEFAULT_PRIO            (MAX_RT_PRIO + 20)
-
-static inline int rt_prio(int prio)
-{
-        if (unlikely(prio < MAX_RT_PRIO))
-                return 1;
-        return 0;
-}
-
-static inline int rt_task(struct task_struct *p)
-{
-        return rt_prio(p->prio);
-}
-
 static inline struct pid *task_pid(struct task_struct *task)
 {
         return task->pids[PIDTYPE_PID].pid;
@@ -1792,6 +1738,37 @@ static inline void put_task_struct(struct task_struct *t)
                 __put_task_struct(t);
 }
 
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
+extern void task_cputime(struct task_struct *t,
+                         cputime_t *utime, cputime_t *stime);
+extern void task_cputime_scaled(struct task_struct *t,
+                                cputime_t *utimescaled, cputime_t *stimescaled);
+extern cputime_t task_gtime(struct task_struct *t);
+#else
+static inline void task_cputime(struct task_struct *t,
+                                cputime_t *utime, cputime_t *stime)
+{
+        if (utime)
+                *utime = t->utime;
+        if (stime)
+                *stime = t->stime;
+}
+
+static inline void task_cputime_scaled(struct task_struct *t,
+                                       cputime_t *utimescaled,
+                                       cputime_t *stimescaled)
+{
+        if (utimescaled)
+                *utimescaled = t->utimescaled;
+        if (stimescaled)
+                *stimescaled = t->stimescaled;
+}
+
+static inline cputime_t task_gtime(struct task_struct *t)
+{
+        return t->gtime;
+}
+#endif
 extern void task_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut, cputime_t *st);
 
@@ -1815,6 +1792,7 @@ extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut,
 #define PF_FROZEN       0x00010000      /* frozen for system suspend */
 #define PF_FSTRANS      0x00020000      /* inside a filesystem transaction */
 #define PF_KSWAPD       0x00040000      /* I am kswapd */
+#define PF_MEMALLOC_NOIO 0x00080000     /* Allocating memory without IO involved */
 #define PF_LESS_THROTTLE 0x00100000     /* Throttle me less: I clean memory */
 #define PF_KTHREAD      0x00200000      /* I am a kernel thread */
 #define PF_RANDOMIZE    0x00400000      /* randomize virtual address space */
@@ -1852,6 +1830,26 @@ extern void thread_group_cputime_adjusted(struct task_struct *p, cputime_t *ut,
 #define tsk_used_math(p) ((p)->flags & PF_USED_MATH)
 #define used_math() tsk_used_math(current)
 
+/* __GFP_IO isn't allowed if PF_MEMALLOC_NOIO is set in current->flags */
+static inline gfp_t memalloc_noio_flags(gfp_t flags)
+{
+        if (unlikely(current->flags & PF_MEMALLOC_NOIO))
+                flags &= ~__GFP_IO;
+        return flags;
+}
+
+static inline unsigned int memalloc_noio_save(void)
+{
+        unsigned int flags = current->flags & PF_MEMALLOC_NOIO;
+        current->flags |= PF_MEMALLOC_NOIO;
+        return flags;
+}
+
+static inline void memalloc_noio_restore(unsigned int flags)
+{
+        current->flags = (current->flags & ~PF_MEMALLOC_NOIO) | flags;
+}
+
 /*
  * task->jobctl flags
  */
@@ -2033,58 +2031,7 @@ extern void wake_up_idle_cpu(int cpu);
 static inline void wake_up_idle_cpu(int cpu) { }
 #endif
 
-extern unsigned int sysctl_sched_latency;
-extern unsigned int sysctl_sched_min_granularity;
-extern unsigned int sysctl_sched_wakeup_granularity;
-extern unsigned int sysctl_sched_child_runs_first;
-
-enum sched_tunable_scaling {
-        SCHED_TUNABLESCALING_NONE,
-        SCHED_TUNABLESCALING_LOG,
-        SCHED_TUNABLESCALING_LINEAR,
-        SCHED_TUNABLESCALING_END,
-};
-extern enum sched_tunable_scaling sysctl_sched_tunable_scaling;
-
-extern unsigned int sysctl_numa_balancing_scan_delay;
-extern unsigned int sysctl_numa_balancing_scan_period_min;
-extern unsigned int sysctl_numa_balancing_scan_period_max;
-extern unsigned int sysctl_numa_balancing_scan_period_reset;
-extern unsigned int sysctl_numa_balancing_scan_size;
-extern unsigned int sysctl_numa_balancing_settle_count;
-
-#ifdef CONFIG_SCHED_DEBUG
-extern unsigned int sysctl_sched_migration_cost;
-extern unsigned int sysctl_sched_nr_migrate;
-extern unsigned int sysctl_sched_time_avg;
-extern unsigned int sysctl_timer_migration;
-extern unsigned int sysctl_sched_shares_window;
-
-int sched_proc_update_handler(struct ctl_table *table, int write,
-                void __user *buffer, size_t *length,
-                loff_t *ppos);
-#endif
-#ifdef CONFIG_SCHED_DEBUG
-static inline unsigned int get_sysctl_timer_migration(void)
-{
-        return sysctl_timer_migration;
-}
-#else
-static inline unsigned int get_sysctl_timer_migration(void)
-{
-        return 1;
-}
-#endif
-extern unsigned int sysctl_sched_rt_period;
-extern int sysctl_sched_rt_runtime;
-
-int sched_rt_handler(struct ctl_table *table, int write,
-                void __user *buffer, size_t *lenp,
-                loff_t *ppos);
-
 #ifdef CONFIG_SCHED_AUTOGROUP
-extern unsigned int sysctl_sched_autogroup_enabled;
-
 extern void sched_autogroup_create_attach(struct task_struct *p);
 extern void sched_autogroup_detach(struct task_struct *p);
 extern void sched_autogroup_fork(struct signal_struct *sig);
@@ -2100,30 +2047,6 @@ static inline void sched_autogroup_fork(struct signal_struct *sig) { }
 static inline void sched_autogroup_exit(struct signal_struct *sig) { }
 #endif
 
-#ifdef CONFIG_CFS_BANDWIDTH
-extern unsigned int sysctl_sched_cfs_bandwidth_slice;
-#endif
-
-#ifdef CONFIG_RT_MUTEXES
-extern int rt_mutex_getprio(struct task_struct *p);
-extern void rt_mutex_setprio(struct task_struct *p, int prio);
-extern void rt_mutex_adjust_pi(struct task_struct *p);
-static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
-{
-        return tsk->pi_blocked_on != NULL;
-}
-#else
-static inline int rt_mutex_getprio(struct task_struct *p)
-{
-        return p->normal_prio;
-}
-# define rt_mutex_adjust_pi(p)          do { } while (0)
-static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
-{
-        return false;
-}
-#endif
-
 extern bool yield_to(struct task_struct *p, bool preempt);
 extern void set_user_nice(struct task_struct *p, long nice);
 extern int task_prio(const struct task_struct *p);
@@ -2259,7 +2182,6 @@ extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
 extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
-extern int do_sigaltstack(const stack_t __user *, stack_t __user *, unsigned long);
 
 static inline void restore_saved_sigmask(void)
 {
@@ -2305,6 +2227,17 @@ static inline int sas_ss_flags(unsigned long sp)
                 : on_sig_stack(sp) ? SS_ONSTACK : 0);
 }
 
+static inline unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
+{
+        if (unlikely((ksig->ka.sa.sa_flags & SA_ONSTACK)) && ! sas_ss_flags(sp))
+#ifdef CONFIG_STACK_GROWSUP
+                return current->sas_ss_sp;
+#else
+                return current->sas_ss_sp + current->sas_ss_size;
+#endif
+        return sp;
+}
+
 /*
  * Routines for handling mm_structs
  */
@@ -2753,14 +2686,15 @@ static inline void set_task_cpu(struct task_struct *p, unsigned int cpu)
 extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
 extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 
-extern void normalize_rt_tasks(void);
-
 #ifdef CONFIG_CGROUP_SCHED
 
 extern struct task_group root_task_group;
 
 extern struct task_group *sched_create_group(struct task_group *parent);
+extern void sched_online_group(struct task_group *tg,
+                               struct task_group *parent);
 extern void sched_destroy_group(struct task_group *tg);
+extern void sched_offline_group(struct task_group *tg);
 extern void sched_move_task(struct task_struct *tsk);
 #ifdef CONFIG_FAIR_GROUP_SCHED
 extern int sched_group_set_shares(struct task_group *tg, unsigned long shares);
diff --git a/include/linux/sched/rt.h b/include/linux/sched/rt.h
new file mode 100644
index 000000000000..440434df3627
--- /dev/null
+++ b/include/linux/sched/rt.h
@@ -0,0 +1,64 @@
+#ifndef _SCHED_RT_H
+#define _SCHED_RT_H
+
+/*
+ * Priority of a process goes from 0..MAX_PRIO-1, valid RT
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_NORMAL/SCHED_BATCH
+ * tasks are in the range MAX_RT_PRIO..MAX_PRIO-1. Priority
+ * values are inverted: lower p->prio value means higher priority.
+ *
+ * The MAX_USER_RT_PRIO value allows the actual maximum
+ * RT priority to be separate from the value exported to
+ * user-space.  This allows kernel threads to set their
+ * priority to a value higher than any user task. Note:
+ * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
+ */
+
+#define MAX_USER_RT_PRIO        100
+#define MAX_RT_PRIO             MAX_USER_RT_PRIO
+
+#define MAX_PRIO                (MAX_RT_PRIO + 40)
+#define DEFAULT_PRIO            (MAX_RT_PRIO + 20)
+
+static inline int rt_prio(int prio)
+{
+        if (unlikely(prio < MAX_RT_PRIO))
+                return 1;
+        return 0;
+}
+
+static inline int rt_task(struct task_struct *p)
+{
+        return rt_prio(p->prio);
+}
+
+#ifdef CONFIG_RT_MUTEXES
+extern int rt_mutex_getprio(struct task_struct *p);
+extern void rt_mutex_setprio(struct task_struct *p, int prio);
+extern void rt_mutex_adjust_pi(struct task_struct *p);
+static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
+{
+        return tsk->pi_blocked_on != NULL;
+}
+#else
+static inline int rt_mutex_getprio(struct task_struct *p)
+{
+        return p->normal_prio;
+}
+# define rt_mutex_adjust_pi(p)          do { } while (0)
+static inline bool tsk_is_pi_blocked(struct task_struct *tsk)
+{
+        return false;
+}
+#endif
+
+extern void normalize_rt_tasks(void);
+
+
+/*
+ * default timeslice is 100 msecs (used only for SCHED_RR tasks).
+ * Timeslices get refilled after they expire.
+ */
+#define RR_TIMESLICE            (100 * HZ / 1000)
+
+#endif /* _SCHED_RT_H */
diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h
new file mode 100644
index 000000000000..bf8086b2506e
--- /dev/null
+++ b/include/linux/sched/sysctl.h
@@ -0,0 +1,104 @@
+#ifndef _SCHED_SYSCTL_H
+#define _SCHED_SYSCTL_H
+
+#ifdef CONFIG_DETECT_HUNG_TASK
+extern unsigned int  sysctl_hung_task_panic;
+extern unsigned long sysctl_hung_task_check_count;
+extern unsigned long sysctl_hung_task_timeout_secs;
+extern unsigned long sysctl_hung_task_warnings;
+extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
+                                         void __user *buffer,
+                                         size_t *lenp, loff_t *ppos);
+#else
+/* Avoid need for ifdefs elsewhere in the code */
+enum { sysctl_hung_task_timeout_secs = 0 };
+#endif
+
+/*
+ * Default maximum number of active map areas, this limits the number of vmas
+ * per mm struct. Users can overwrite this number by sysctl but there is a
+ * problem.
+ *
+ * When a program's coredump is generated as ELF format, a section is created
+ * per a vma. In ELF, the number of sections is represented in unsigned short.
+ * This means the number of sections should be smaller than 65535 at coredump.
+ * Because the kernel adds some informative sections to a image of program at
+ * generating coredump, we need some margin. The number of extra sections is
+ * 1-3 now and depends on arch. We use "5" as safe margin, here.
+ */
+#define MAPCOUNT_ELF_CORE_MARGIN        (5)
+#define DEFAULT_MAX_MAP_COUNT   (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
+
+extern int sysctl_max_map_count;
+
+extern unsigned int sysctl_sched_latency;
+extern unsigned int sysctl_sched_min_granularity;
+extern unsigned int sysctl_sched_wakeup_granularity;
+extern unsigned int sysctl_sched_child_runs_first;
+
+enum sched_tunable_scaling {
+        SCHED_TUNABLESCALING_NONE,
+        SCHED_TUNABLESCALING_LOG,
+        SCHED_TUNABLESCALING_LINEAR,
+        SCHED_TUNABLESCALING_END,
+};
+extern enum sched_tunable_scaling sysctl_sched_tunable_scaling;
+
+extern unsigned int sysctl_numa_balancing_scan_delay;
+extern unsigned int sysctl_numa_balancing_scan_period_min;
+extern unsigned int sysctl_numa_balancing_scan_period_max;
+extern unsigned int sysctl_numa_balancing_scan_period_reset;
+extern unsigned int sysctl_numa_balancing_scan_size;
+extern unsigned int sysctl_numa_balancing_settle_count;
+
+#ifdef CONFIG_SCHED_DEBUG
+extern unsigned int sysctl_sched_migration_cost;
+extern unsigned int sysctl_sched_nr_migrate;
+extern unsigned int sysctl_sched_time_avg;
+extern unsigned int sysctl_timer_migration;
+extern unsigned int sysctl_sched_shares_window;
+
+int sched_proc_update_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *length,
+                loff_t *ppos);
+#endif
+#ifdef CONFIG_SCHED_DEBUG
+static inline unsigned int get_sysctl_timer_migration(void)
+{
+        return sysctl_timer_migration;
+}
+#else
+static inline unsigned int get_sysctl_timer_migration(void)
+{
+        return 1;
+}
+#endif
+
+/*
+ *  control realtime throttling:
+ *
+ *  /proc/sys/kernel/sched_rt_period_us
+ *  /proc/sys/kernel/sched_rt_runtime_us
+ */
+extern unsigned int sysctl_sched_rt_period;
+extern int sysctl_sched_rt_runtime;
+
+#ifdef CONFIG_CFS_BANDWIDTH
+extern unsigned int sysctl_sched_cfs_bandwidth_slice;
+#endif
+
+#ifdef CONFIG_SCHED_AUTOGROUP
+extern unsigned int sysctl_sched_autogroup_enabled;
+#endif
+
+extern int sched_rr_timeslice;
+
+extern int sched_rr_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos);
+
+extern int sched_rt_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos);
+
+#endif /* _SCHED_SYSCTL_H */
diff --git a/include/linux/seqlock.h b/include/linux/seqlock.h
index 600060e25ec6..18299057402f 100644
--- a/include/linux/seqlock.h
+++ b/include/linux/seqlock.h
@@ -30,92 +30,12 @@
 #include <linux/preempt.h>
 #include <asm/processor.h>
 
-typedef struct {
-        unsigned sequence;
-        spinlock_t lock;
-} seqlock_t;
-
-/*
- * These macros triggered gcc-3.x compile-time problems.  We think these are
- * OK now.  Be cautious.
- */
-#define __SEQLOCK_UNLOCKED(lockname) \
-                 { 0, __SPIN_LOCK_UNLOCKED(lockname) }
-
-#define seqlock_init(x)                                 \
-        do {                                            \
-                (x)->sequence = 0;                      \
-                spin_lock_init(&(x)->lock);             \
-        } while (0)
-
-#define DEFINE_SEQLOCK(x) \
-                seqlock_t x = __SEQLOCK_UNLOCKED(x)
-
-/* Lock out other writers and update the count.
- * Acts like a normal spin_lock/unlock.
- * Don't need preempt_disable() because that is in the spin_lock already.
- */
-static inline void write_seqlock(seqlock_t *sl)
-{
-        spin_lock(&sl->lock);
-        ++sl->sequence;
-        smp_wmb();
-}
-
-static inline void write_sequnlock(seqlock_t *sl)
-{
-        smp_wmb();
-        sl->sequence++;
-        spin_unlock(&sl->lock);
-}
-
-static inline int write_tryseqlock(seqlock_t *sl)
-{
-        int ret = spin_trylock(&sl->lock);
-
-        if (ret) {
-                ++sl->sequence;
-                smp_wmb();
-        }
-        return ret;
-}
-
-/* Start of read calculation -- fetch last complete writer token */
-static __always_inline unsigned read_seqbegin(const seqlock_t *sl)
-{
-        unsigned ret;
-
-repeat:
-        ret = ACCESS_ONCE(sl->sequence);
-        if (unlikely(ret & 1)) {
-                cpu_relax();
-                goto repeat;
-        }
-        smp_rmb();
-
-        return ret;
-}
-
-/*
- * Test if reader processed invalid data.
- *
- * If sequence value changed then writer changed data while in section.
- */
-static __always_inline int read_seqretry(const seqlock_t *sl, unsigned start)
-{
-        smp_rmb();
-
-        return unlikely(sl->sequence != start);
-}
-
-
 /*
  * Version using sequence counter only.
  * This can be used when code has its own mutex protecting the
  * updating starting before the write_seqcountbeqin() and ending
  * after the write_seqcount_end().
  */
-
 typedef struct seqcount {
         unsigned sequence;
 } seqcount_t;
@@ -218,7 +138,6 @@ static inline int __read_seqcount_retry(const seqcount_t *s, unsigned start)
 static inline int read_seqcount_retry(const seqcount_t *s, unsigned start)
 {
         smp_rmb();
-
         return __read_seqcount_retry(s, start);
 }
 
@@ -252,31 +171,101 @@ static inline void write_seqcount_barrier(seqcount_t *s)
         s->sequence+=2;
 }
 
+typedef struct {
+        struct seqcount seqcount;
+        spinlock_t lock;
+} seqlock_t;
+
 /*
- * Possible sw/hw IRQ protected versions of the interfaces.
+ * These macros triggered gcc-3.x compile-time problems.  We think these are
+ * OK now.  Be cautious.
  */
-#define write_seqlock_irqsave(lock, flags)                              \
-        do { local_irq_save(flags); write_seqlock(lock); } while (0)
-#define write_seqlock_irq(lock)                                         \
-        do { local_irq_disable();   write_seqlock(lock); } while (0)
-#define write_seqlock_bh(lock)                                          \
-        do { local_bh_disable();    write_seqlock(lock); } while (0)
+#define __SEQLOCK_UNLOCKED(lockname)                    \
+        {                                               \
+                .seqcount = SEQCNT_ZERO,                \
+                .lock = __SPIN_LOCK_UNLOCKED(lockname)  \
+        }
+
+#define seqlock_init(x)                                 \
+        do {                                            \
+                seqcount_init(&(x)->seqcount);          \
+                spin_lock_init(&(x)->lock);             \
+        } while (0)
 
-#define write_sequnlock_irqrestore(lock, flags)                         \
-        do { write_sequnlock(lock); local_irq_restore(flags); } while(0)
-#define write_sequnlock_irq(lock)                                       \
-        do { write_sequnlock(lock); local_irq_enable(); } while(0)
-#define write_sequnlock_bh(lock)                                        \
-        do { write_sequnlock(lock); local_bh_enable(); } while(0)
+#define DEFINE_SEQLOCK(x) \
+                seqlock_t x = __SEQLOCK_UNLOCKED(x)
 
-#define read_seqbegin_irqsave(lock, flags)                              \
-        ({ local_irq_save(flags);   read_seqbegin(lock); })
+/*
+ * Read side functions for starting and finalizing a read side section.
+ */
+static inline unsigned read_seqbegin(const seqlock_t *sl)
+{
+        return read_seqcount_begin(&sl->seqcount);
+}
 
-#define read_seqretry_irqrestore(lock, iv, flags)                       \
-        ({                                                              \
-                int ret = read_seqretry(lock, iv);                      \
-                local_irq_restore(flags);                               \
-                ret;                                                    \
-        })
+static inline unsigned read_seqretry(const seqlock_t *sl, unsigned start)
+{
+        return read_seqcount_retry(&sl->seqcount, start);
+}
+
+/*
+ * Lock out other writers and update the count.
+ * Acts like a normal spin_lock/unlock.
+ * Don't need preempt_disable() because that is in the spin_lock already.
+ */
+static inline void write_seqlock(seqlock_t *sl)
+{
+        spin_lock(&sl->lock);
+        write_seqcount_begin(&sl->seqcount);
+}
+
+static inline void write_sequnlock(seqlock_t *sl)
+{
+        write_seqcount_end(&sl->seqcount);
+        spin_unlock(&sl->lock);
+}
+
+static inline void write_seqlock_bh(seqlock_t *sl)
+{
+        spin_lock_bh(&sl->lock);
+        write_seqcount_begin(&sl->seqcount);
+}
+
+static inline void write_sequnlock_bh(seqlock_t *sl)
+{
+        write_seqcount_end(&sl->seqcount);
+        spin_unlock_bh(&sl->lock);
+}
+
+static inline void write_seqlock_irq(seqlock_t *sl)
+{
+        spin_lock_irq(&sl->lock);
+        write_seqcount_begin(&sl->seqcount);
+}
+
+static inline void write_sequnlock_irq(seqlock_t *sl)
+{
+        write_seqcount_end(&sl->seqcount);
+        spin_unlock_irq(&sl->lock);
+}
+
+static inline unsigned long __write_seqlock_irqsave(seqlock_t *sl)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&sl->lock, flags);
+        write_seqcount_begin(&sl->seqcount);
+        return flags;
+}
+
+#define write_seqlock_irqsave(lock, flags)                              \
+        do { flags = __write_seqlock_irqsave(lock); } while (0)
+
+static inline void
+write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
+{
+        write_seqcount_end(&sl->seqcount);
+        spin_unlock_irqrestore(&sl->lock, flags);
+}
 
 #endif /* __LINUX_SEQLOCK_H */
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index c490d20b3fb8..af47a8af6024 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -59,6 +59,8 @@ enum {
         PLAT8250_DEV_SM501,
 };
 
+struct uart_8250_dma;
+
 /*
  * This should be used by drivers which want to register
  * their own 8250 ports without registering their own
@@ -91,6 +93,8 @@ struct uart_8250_port {
 #define MSR_SAVE_FLAGS UART_MSR_ANY_DELTA
         unsigned char           msr_saved_flags;
 
+        struct uart_8250_dma    *dma;
+
         /* 8250 specific callbacks */
         int                     (*dl_read)(struct uart_8250_port *);
         void                    (*dl_write)(struct uart_8250_port *, int);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index c6690a2a27fb..87d4bbc773fc 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -29,7 +29,6 @@
 #include <linux/tty.h>
 #include <linux/mutex.h>
 #include <linux/sysrq.h>
-#include <linux/pps_kernel.h>
 #include <uapi/linux/serial_core.h>
 
 struct uart_port;
@@ -37,8 +36,8 @@ struct serial_struct;
 struct device;
 
 /*
- * This structure describes all the operations that can be
- * done on the physical hardware.
+ * This structure describes all the operations that can be done on the
+ * physical hardware.  See Documentation/serial/driver for details.
  */
 struct uart_ops {
         unsigned int    (*tx_empty)(struct uart_port *);
@@ -65,7 +64,7 @@ struct uart_ops {
         /*
          * Return a string describing the type of the port
          */
-        const char *(*type)(struct uart_port *);
+        const char      *(*type)(struct uart_port *);
 
         /*
          * Release IO and memory resources used by the port.
@@ -83,7 +82,7 @@ struct uart_ops {
         int             (*ioctl)(struct uart_port *, unsigned int, unsigned long);
 #ifdef CONFIG_CONSOLE_POLL
         int             (*poll_init)(struct uart_port *);
-        void    (*poll_put_char)(struct uart_port *, unsigned char);
+        void            (*poll_put_char)(struct uart_port *, unsigned char);
         int             (*poll_get_char)(struct uart_port *);
 #endif
 };
@@ -134,9 +133,8 @@ struct uart_port {
 #define UPIO_HUB6               (1)
 #define UPIO_MEM                (2)
 #define UPIO_MEM32              (3)
-#define UPIO_AU                 (4)                     /* Au1x00 type IO */
+#define UPIO_AU                 (4)                     /* Au1x00 and RT288x type IO */
 #define UPIO_TSI                (5)                     /* Tsi108/109 type IO */
-#define UPIO_RM9000             (6)                     /* RM9000 type IO */
 
         unsigned int            read_status_mask;       /* driver specific */
         unsigned int            ignore_status_mask;     /* driver specific */
@@ -208,13 +206,25 @@ static inline void serial_port_out(struct uart_port *up, int offset, int value)
         up->serial_out(up, offset, value);
 }
 
+/**
+ * enum uart_pm_state - power states for UARTs
+ * @UART_PM_STATE_ON: UART is powered, up and operational
+ * @UART_PM_STATE_OFF: UART is powered off
+ * @UART_PM_STATE_UNDEFINED: sentinel
+ */
+enum uart_pm_state {
+        UART_PM_STATE_ON = 0,
+        UART_PM_STATE_OFF = 3, /* number taken from ACPI */
+        UART_PM_STATE_UNDEFINED,
+};
+
 /*
  * This is the state information which is persistent across opens.
  */
 struct uart_state {
         struct tty_port         port;
 
-        int                     pm_state;
+        enum uart_pm_state      pm_state;
         struct circ_buf         xmit;
 
         struct uart_port        *uart_port;
diff --git a/include/linux/sh_pfc.h b/include/linux/sh_pfc.h
deleted file mode 100644
index c19a0925829a..000000000000
--- a/include/linux/sh_pfc.h
+++ /dev/null
@@ -1,236 +0,0 @@
-/*
- * SuperH Pin Function Controller Support
- *
- * Copyright (c) 2008 Magnus Damm
- *
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- */
-
-#ifndef __SH_PFC_H
-#define __SH_PFC_H
-
-#include <linux/stringify.h>
-#include <asm-generic/gpio.h>
-
-typedef unsigned short pinmux_enum_t;
-typedef unsigned short pinmux_flag_t;
-
-enum {
-        PINMUX_TYPE_NONE,
-
-        PINMUX_TYPE_FUNCTION,
-        PINMUX_TYPE_GPIO,
-        PINMUX_TYPE_OUTPUT,
-        PINMUX_TYPE_INPUT,
-        PINMUX_TYPE_INPUT_PULLUP,
-        PINMUX_TYPE_INPUT_PULLDOWN,
-
-        PINMUX_FLAG_TYPE,       /* must be last */
-};
-
-#define PINMUX_FLAG_DBIT_SHIFT      5
-#define PINMUX_FLAG_DBIT            (0x1f << PINMUX_FLAG_DBIT_SHIFT)
-#define PINMUX_FLAG_DREG_SHIFT      10
-#define PINMUX_FLAG_DREG            (0x3f << PINMUX_FLAG_DREG_SHIFT)
-
-struct pinmux_gpio {
-        pinmux_enum_t enum_id;
-        pinmux_flag_t flags;
-        const char *name;
-};
-
-#define PINMUX_GPIO(gpio, data_or_mark) \
-        [gpio] = { .name = __stringify(gpio), .enum_id = data_or_mark, .flags = PINMUX_TYPE_NONE }
-
-#define PINMUX_DATA(data_or_mark, ids...) data_or_mark, ids, 0
-
-struct pinmux_cfg_reg {
-        unsigned long reg, reg_width, field_width;
-        unsigned long *cnt;
-        pinmux_enum_t *enum_ids;
-        unsigned long *var_field_width;
-};
-
-#define PINMUX_CFG_REG(name, r, r_width, f_width) \
-        .reg = r, .reg_width = r_width, .field_width = f_width,         \
-        .cnt = (unsigned long [r_width / f_width]) {}, \
-        .enum_ids = (pinmux_enum_t [(r_width / f_width) * (1 << f_width)])
-
-#define PINMUX_CFG_REG_VAR(name, r, r_width, var_fw0, var_fwn...) \
-        .reg = r, .reg_width = r_width, \
-        .cnt = (unsigned long [r_width]) {}, \
-        .var_field_width = (unsigned long [r_width]) { var_fw0, var_fwn, 0 }, \
-        .enum_ids = (pinmux_enum_t [])
-
-struct pinmux_data_reg {
-        unsigned long reg, reg_width, reg_shadow;
-        pinmux_enum_t *enum_ids;
-        void __iomem *mapped_reg;
-};
-
-#define PINMUX_DATA_REG(name, r, r_width) \
-        .reg = r, .reg_width = r_width, \
-        .enum_ids = (pinmux_enum_t [r_width]) \
-
-struct pinmux_irq {
-        int irq;
-        pinmux_enum_t *enum_ids;
-};
-
-#define PINMUX_IRQ(irq_nr, ids...)                         \
-        { .irq = irq_nr, .enum_ids = (pinmux_enum_t []) { ids, 0 } }    \
-
-struct pinmux_range {
-        pinmux_enum_t begin;
-        pinmux_enum_t end;
-        pinmux_enum_t force;
-};
-
-struct pfc_window {
-        phys_addr_t phys;
-        void __iomem *virt;
-        unsigned long size;
-};
-
-struct sh_pfc {
-        char *name;
-        pinmux_enum_t reserved_id;
-        struct pinmux_range data;
-        struct pinmux_range input;
-        struct pinmux_range input_pd;
-        struct pinmux_range input_pu;
-        struct pinmux_range output;
-        struct pinmux_range mark;
-        struct pinmux_range function;
-
-        unsigned first_gpio, last_gpio;
-
-        struct pinmux_gpio *gpios;
-        struct pinmux_cfg_reg *cfg_regs;
-        struct pinmux_data_reg *data_regs;
-
-        pinmux_enum_t *gpio_data;
-        unsigned int gpio_data_size;
-
-        struct pinmux_irq *gpio_irq;
-        unsigned int gpio_irq_size;
-
-        spinlock_t lock;
-
-        struct resource *resource;
-        unsigned int num_resources;
-        struct pfc_window *window;
-
-        unsigned long unlock_reg;
-};
-
-/* XXX compat for now */
-#define pinmux_info sh_pfc
-
-/* drivers/sh/pfc/gpio.c */
-int sh_pfc_register_gpiochip(struct sh_pfc *pfc);
-
-/* drivers/sh/pfc/pinctrl.c */
-int sh_pfc_register_pinctrl(struct sh_pfc *pfc);
-
-/* drivers/sh/pfc/core.c */
-int register_sh_pfc(struct sh_pfc *pfc);
-
-int sh_pfc_read_bit(struct pinmux_data_reg *dr, unsigned long in_pos);
-void sh_pfc_write_bit(struct pinmux_data_reg *dr, unsigned long in_pos,
-                      unsigned long value);
-int sh_pfc_get_data_reg(struct sh_pfc *pfc, unsigned gpio,
-                        struct pinmux_data_reg **drp, int *bitp);
-int sh_pfc_gpio_to_enum(struct sh_pfc *pfc, unsigned gpio, int pos,
-                        pinmux_enum_t *enum_idp);
-int sh_pfc_config_gpio(struct sh_pfc *pfc, unsigned gpio, int pinmux_type,
-                       int cfg_mode);
-
-/* xxx */
-static inline int register_pinmux(struct pinmux_info *pip)
-{
-        struct sh_pfc *pfc = pip;
-        return register_sh_pfc(pfc);
-}
-
-enum { GPIO_CFG_DRYRUN, GPIO_CFG_REQ, GPIO_CFG_FREE };
-
-/* helper macro for port */
-#define PORT_1(fn, pfx, sfx) fn(pfx, sfx)
-
-#define PORT_10(fn, pfx, sfx) \
-        PORT_1(fn, pfx##0, sfx), PORT_1(fn, pfx##1, sfx),       \
-        PORT_1(fn, pfx##2, sfx), PORT_1(fn, pfx##3, sfx),       \
-        PORT_1(fn, pfx##4, sfx), PORT_1(fn, pfx##5, sfx),       \
-        PORT_1(fn, pfx##6, sfx), PORT_1(fn, pfx##7, sfx),       \
-        PORT_1(fn, pfx##8, sfx), PORT_1(fn, pfx##9, sfx)
-
-#define PORT_90(fn, pfx, sfx) \
-        PORT_10(fn, pfx##1, sfx), PORT_10(fn, pfx##2, sfx),     \
-        PORT_10(fn, pfx##3, sfx), PORT_10(fn, pfx##4, sfx),     \
-        PORT_10(fn, pfx##5, sfx), PORT_10(fn, pfx##6, sfx),     \
-        PORT_10(fn, pfx##7, sfx), PORT_10(fn, pfx##8, sfx),     \
-        PORT_10(fn, pfx##9, sfx)
-
-#define _PORT_ALL(pfx, sfx) pfx##_##sfx
-#define _GPIO_PORT(pfx, sfx) PINMUX_GPIO(GPIO_PORT##pfx, PORT##pfx##_DATA)
-#define PORT_ALL(str)   CPU_ALL_PORT(_PORT_ALL, PORT, str)
-#define GPIO_PORT_ALL() CPU_ALL_PORT(_GPIO_PORT, , unused)
-#define GPIO_FN(str) PINMUX_GPIO(GPIO_FN_##str, str##_MARK)
-
-/* helper macro for pinmux_enum_t */
-#define PORT_DATA_I(nr) \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_IN)
-
-#define PORT_DATA_I_PD(nr)      \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0,    \
-                    PORT##nr##_IN, PORT##nr##_IN_PD)
-
-#define PORT_DATA_I_PU(nr)      \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0,    \
-                    PORT##nr##_IN, PORT##nr##_IN_PU)
-
-#define PORT_DATA_I_PU_PD(nr)   \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0,                    \
-                    PORT##nr##_IN, PORT##nr##_IN_PD, PORT##nr##_IN_PU)
-
-#define PORT_DATA_O(nr)         \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_OUT)
-
-#define PORT_DATA_IO(nr)        \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_OUT,    \
-                    PORT##nr##_IN)
-
-#define PORT_DATA_IO_PD(nr)     \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_OUT,    \
-                    PORT##nr##_IN, PORT##nr##_IN_PD)
-
-#define PORT_DATA_IO_PU(nr)     \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_OUT,    \
-                    PORT##nr##_IN, PORT##nr##_IN_PU)
-
-#define PORT_DATA_IO_PU_PD(nr)  \
-        PINMUX_DATA(PORT##nr##_DATA, PORT##nr##_FN0, PORT##nr##_OUT,    \
-                    PORT##nr##_IN, PORT##nr##_IN_PD, PORT##nr##_IN_PU)
-
-/* helper macro for top 4 bits in PORTnCR */
-#define _PCRH(in, in_pd, in_pu, out)    \
-        0, (out), (in), 0,              \
-        0, 0, 0, 0,                     \
-        0, 0, (in_pd), 0,               \
-        0, 0, (in_pu), 0
-
-#define PORTCR(nr, reg)                                                 \
-        {                                                               \
-                PINMUX_CFG_REG("PORT" nr "CR", reg, 8, 4) {             \
-                        _PCRH(PORT##nr##_IN, PORT##nr##_IN_PD,          \
-                              PORT##nr##_IN_PU, PORT##nr##_OUT),        \
-                                PORT##nr##_FN0, PORT##nr##_FN1,         \
-                                PORT##nr##_FN2, PORT##nr##_FN3,         \
-                                PORT##nr##_FN4, PORT##nr##_FN5,         \
-                                PORT##nr##_FN6, PORT##nr##_FN7 }        \
-        }
-
-#endif /* __SH_PFC_H */
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 0a89ffc48466..a2dcb94ea49d 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -241,9 +241,6 @@ extern int do_send_sig_info(int sig, struct siginfo *info,
                                 struct task_struct *p, bool group);
 extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
 extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
-extern long do_rt_tgsigqueueinfo(pid_t tgid, pid_t pid, int sig,
-                                 siginfo_t *info);
-extern long do_sigpending(void __user *, unsigned long);
 extern int do_sigtimedwait(const sigset_t *, siginfo_t *,
                                 const struct timespec *);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
@@ -252,10 +249,59 @@ extern void __set_current_blocked(const sigset_t *);
 extern int show_unhandled_signals;
 extern int sigsuspend(sigset_t *);
 
+struct sigaction {
+#ifndef __ARCH_HAS_ODD_SIGACTION
+        __sighandler_t  sa_handler;
+        unsigned long   sa_flags;
+#else
+        unsigned long   sa_flags;
+        __sighandler_t  sa_handler;
+#endif
+#ifdef __ARCH_HAS_SA_RESTORER
+        __sigrestore_t sa_restorer;
+#endif
+        sigset_t        sa_mask;        /* mask last for extensibility */
+};
+
+struct k_sigaction {
+        struct sigaction sa;
+#ifdef __ARCH_HAS_KA_RESTORER
+        __sigrestore_t ka_restorer;
+#endif
+};
+ 
+#ifdef CONFIG_OLD_SIGACTION
+struct old_sigaction {
+        __sighandler_t sa_handler;
+        old_sigset_t sa_mask;
+        unsigned long sa_flags;
+        __sigrestore_t sa_restorer;
+};
+#endif
+
+struct ksignal {
+        struct k_sigaction ka;
+        siginfo_t info;
+        int sig;
+};
+
 extern int get_signal_to_deliver(siginfo_t *info, struct k_sigaction *return_ka, struct pt_regs *regs, void *cookie);
+extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
 extern void signal_delivered(int sig, siginfo_t *info, struct k_sigaction *ka, struct pt_regs *regs, int stepping);
 extern void exit_signals(struct task_struct *tsk);
 
+/*
+ * Eventually that'll replace get_signal_to_deliver(); macro for now,
+ * to avoid nastiness with include order.
+ */
+#define get_signal(ksig)                                        \
+({                                                              \
+        struct ksignal *p = (ksig);                             \
+        p->sig = get_signal_to_deliver(&p->info, &p->ka,        \
+                                        signal_pt_regs(), NULL);\
+        p->sig > 0;                                             \
+})
+
 extern struct kmem_cache *sighand_cachep;
 
 int unhandled_signal(struct task_struct *tsk, int sig);
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 320e976d5ab8..821c7f45d2a7 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -230,6 +230,13 @@ enum {
 
         /* generate wifi status information (where possible) */
         SKBTX_WIFI_STATUS = 1 << 4,
+
+        /* This indicates at least one fragment might be overwritten
+         * (as in vmsplice(), sendfile() ...)
+         * If we need to compute a TX checksum, we'll need to copy
+         * all frags to avoid possible bad checksum
+         */
+        SKBTX_SHARED_FRAG = 1 << 5,
 };
 
 /*
@@ -307,6 +314,8 @@ enum {
         SKB_GSO_TCPV6 = 1 << 4,
 
         SKB_GSO_FCOE = 1 << 5,
+
+        SKB_GSO_GRE = 1 << 6,
 };
 
 #if BITS_PER_LONG > 32
@@ -797,6 +806,16 @@ static inline int skb_cloned(const struct sk_buff *skb)
                (atomic_read(&skb_shinfo(skb)->dataref) & SKB_DATAREF_MASK) != 1;
 }
 
+static inline int skb_unclone(struct sk_buff *skb, gfp_t pri)
+{
+        might_sleep_if(pri & __GFP_WAIT);
+
+        if (skb_cloned(skb))
+                return pskb_expand_head(skb, 0, 0, pri);
+
+        return 0;
+}
+
 /**
  *      skb_header_cloned - is the header a clone
  *      @skb: buffer to check
@@ -1492,6 +1511,11 @@ static inline void skb_set_inner_network_header(struct sk_buff *skb,
         skb->inner_network_header += offset;
 }
 
+static inline bool skb_transport_header_was_set(const struct sk_buff *skb)
+{
+        return skb->transport_header != ~0U;
+}
+
 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
 {
         return skb->head + skb->transport_header;
@@ -1580,6 +1604,11 @@ static inline void skb_set_inner_network_header(struct sk_buff *skb,
         skb->inner_network_header = skb->data + offset;
 }
 
+static inline bool skb_transport_header_was_set(const struct sk_buff *skb)
+{
+        return skb->transport_header != NULL;
+}
+
 static inline unsigned char *skb_transport_header(const struct sk_buff *skb)
 {
         return skb->transport_header;
@@ -1815,6 +1844,10 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
                 kfree_skb(skb);
 }
 
+#define NETDEV_FRAG_PAGE_MAX_ORDER get_order(32768)
+#define NETDEV_FRAG_PAGE_MAX_SIZE  (PAGE_SIZE << NETDEV_FRAG_PAGE_MAX_ORDER)
+#define NETDEV_PAGECNT_MAX_BIAS    NETDEV_FRAG_PAGE_MAX_SIZE
+
 extern void *netdev_alloc_frag(unsigned int fragsz);
 
 extern struct sk_buff *__netdev_alloc_skb(struct net_device *dev,
@@ -2191,6 +2224,19 @@ static inline int skb_linearize(struct sk_buff *skb)
 }
 
 /**
+ * skb_has_shared_frag - can any frag be overwritten
+ * @skb: buffer to test
+ *
+ * Return true if the skb has at least one frag that might be modified
+ * by an external entity (as in vmsplice()/sendfile())
+ */
+static inline bool skb_has_shared_frag(const struct sk_buff *skb)
+{
+        return skb_is_nonlinear(skb) &&
+               skb_shinfo(skb)->tx_flags & SKBTX_SHARED_FRAG;
+}
+
+/**
  *      skb_linearize_cow - make sure skb is linear and writable
  *      @skb: buffer to process
  *
@@ -2688,6 +2734,21 @@ static inline struct sec_path *skb_sec_path(struct sk_buff *skb)
 }
 #endif
 
+/* Keeps track of mac header offset relative to skb->head.
+ * It is useful for TSO of Tunneling protocol. e.g. GRE.
+ * For non-tunnel skb it points to skb_mac_header() and for
+ * tunnel skb it points to outer mac header. */
+struct skb_gso_cb {
+        int mac_offset;
+};
+#define SKB_GSO_CB(skb) ((struct skb_gso_cb *)(skb)->cb)
+
+static inline int skb_tnl_header_len(const struct sk_buff *inner_skb)
+{
+        return (skb_mac_header(inner_skb) - inner_skb->head) -
+                SKB_GSO_CB(inner_skb)->mac_offset;
+}
+
 static inline bool skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
diff --git a/include/linux/smp.h b/include/linux/smp.h
index dd6f06be3c9f..3e07a7df6478 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -89,7 +89,8 @@ void kick_all_cpus_sync(void);
 #ifdef CONFIG_USE_GENERIC_SMP_HELPERS
 void __init call_function_init(void);
 void generic_smp_call_function_single_interrupt(void);
-void generic_smp_call_function_interrupt(void);
+#define generic_smp_call_function_interrupt \
+        generic_smp_call_function_single_interrupt
 #else
 static inline void call_function_init(void) { }
 #endif
diff --git a/include/linux/smpboot.h b/include/linux/smpboot.h
index e0106d8581d3..c65dee059913 100644
--- a/include/linux/smpboot.h
+++ b/include/linux/smpboot.h
@@ -14,6 +14,8 @@ struct smpboot_thread_data;
  * @thread_should_run:  Check whether the thread should run or not. Called with
  *                      preemption disabled.
  * @thread_fn:          The associated thread function
+ * @create:             Optional setup function, called when the thread gets
+ *                      created (Not called from the thread context)
  * @setup:              Optional setup function, called when the thread gets
  *                      operational the first time
  * @cleanup:            Optional cleanup function, called when the thread
@@ -22,6 +24,7 @@ struct smpboot_thread_data;
  *                      parked (cpu offline)
  * @unpark:             Optional unpark function, called when the thread is
  *                      unparked (cpu online)
+ * @selfparking:        Thread is not parked by the park function.
  * @thread_comm:        The base name of the thread
  */
 struct smp_hotplug_thread {
@@ -29,10 +32,12 @@ struct smp_hotplug_thread {
         struct list_head                list;
         int                             (*thread_should_run)(unsigned int cpu);
         void                            (*thread_fn)(unsigned int cpu);
+        void                            (*create)(unsigned int cpu);
         void                            (*setup)(unsigned int cpu);
         void                            (*cleanup)(unsigned int cpu, bool online);
         void                            (*park)(unsigned int cpu);
         void                            (*unpark)(unsigned int cpu);
+        bool                            selfparking;
         const char                      *thread_comm;
 };
 
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 9a546ff853dc..2b9f74b0ffea 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -178,7 +178,8 @@ struct ucred {
 #define AF_CAIF         37      /* CAIF sockets                 */
 #define AF_ALG          38      /* Algorithm sockets            */
 #define AF_NFC          39      /* NFC sockets                  */
-#define AF_MAX          40      /* For now.. */
+#define AF_VSOCK        40      /* vSockets                     */
+#define AF_MAX          41      /* For now.. */
 
 /* Protocol families, same as address families. */
 #define PF_UNSPEC       AF_UNSPEC
@@ -221,6 +222,7 @@ struct ucred {
 #define PF_CAIF         AF_CAIF
 #define PF_ALG          AF_ALG
 #define PF_NFC          AF_NFC
+#define PF_VSOCK        AF_VSOCK
 #define PF_MAX          AF_MAX
 
 /* Maximum queue length specifiable by listen.  */
diff --git a/include/linux/spi/pxa2xx_spi.h b/include/linux/spi/pxa2xx_spi.h
index c73d1445c77e..82d5111cd0c2 100644
--- a/include/linux/spi/pxa2xx_spi.h
+++ b/include/linux/spi/pxa2xx_spi.h
@@ -28,6 +28,15 @@ struct pxa2xx_spi_master {
         u32 clock_enable;
         u16 num_chipselect;
         u8 enable_dma;
+
+        /* DMA engine specific config */
+        int rx_chan_id;
+        int tx_chan_id;
+        int rx_slave_id;
+        int tx_slave_id;
+
+        /* For non-PXA arches */
+        struct ssp_device ssp;
 };
 
 /* spi_board_info.controller_data for SPI slave devices,
@@ -35,6 +44,7 @@ struct pxa2xx_spi_master {
  */
 struct pxa2xx_spi_chip {
         u8 tx_threshold;
+        u8 tx_hi_threshold;
         u8 rx_threshold;
         u8 dma_burst_size;
         u32 timeout;
@@ -50,103 +60,5 @@ struct pxa2xx_spi_chip {
 
 extern void pxa2xx_set_spi_info(unsigned id, struct pxa2xx_spi_master *info);
 
-#else
-/*
- * This is the implemtation for CE4100 on x86. ARM defines them in mach/ or
- * plat/ include path.
- * The CE4100 does not provide DMA support. This bits are here to let the driver
- * compile and will never be used. Maybe we get DMA support at a later point in
- * time.
- */
-
-#define DCSR(n)         (n)
-#define DSADR(n)        (n)
-#define DTADR(n)        (n)
-#define DCMD(n)         (n)
-#define DRCMR(n)        (n)
-
-#define DCSR_RUN        (1 << 31)       /* Run Bit */
-#define DCSR_NODESC     (1 << 30)       /* No-Descriptor Fetch */
-#define DCSR_STOPIRQEN  (1 << 29)       /* Stop Interrupt Enable */
-#define DCSR_REQPEND    (1 << 8)        /* Request Pending (read-only) */
-#define DCSR_STOPSTATE  (1 << 3)        /* Stop State (read-only) */
-#define DCSR_ENDINTR    (1 << 2)        /* End Interrupt */
-#define DCSR_STARTINTR  (1 << 1)        /* Start Interrupt */
-#define DCSR_BUSERR     (1 << 0)        /* Bus Error Interrupt */
-
-#define DCSR_EORIRQEN   (1 << 28)       /* End of Receive Interrupt Enable */
-#define DCSR_EORJMPEN   (1 << 27)       /* Jump to next descriptor on EOR */
-#define DCSR_EORSTOPEN  (1 << 26)       /* STOP on an EOR */
-#define DCSR_SETCMPST   (1 << 25)       /* Set Descriptor Compare Status */
-#define DCSR_CLRCMPST   (1 << 24)       /* Clear Descriptor Compare Status */
-#define DCSR_CMPST      (1 << 10)       /* The Descriptor Compare Status */
-#define DCSR_EORINTR    (1 << 9)        /* The end of Receive */
-
-#define DRCMR_MAPVLD    (1 << 7)        /* Map Valid */
-#define DRCMR_CHLNUM    0x1f            /* mask for Channel Number */
-
-#define DDADR_DESCADDR  0xfffffff0      /* Address of next descriptor */
-#define DDADR_STOP      (1 << 0)        /* Stop */
-
-#define DCMD_INCSRCADDR (1 << 31)       /* Source Address Increment Setting. */
-#define DCMD_INCTRGADDR (1 << 30)       /* Target Address Increment Setting. */
-#define DCMD_FLOWSRC    (1 << 29)       /* Flow Control by the source. */
-#define DCMD_FLOWTRG    (1 << 28)       /* Flow Control by the target. */
-#define DCMD_STARTIRQEN (1 << 22)       /* Start Interrupt Enable */
-#define DCMD_ENDIRQEN   (1 << 21)       /* End Interrupt Enable */
-#define DCMD_ENDIAN     (1 << 18)       /* Device Endian-ness. */
-#define DCMD_BURST8     (1 << 16)       /* 8 byte burst */
-#define DCMD_BURST16    (2 << 16)       /* 16 byte burst */
-#define DCMD_BURST32    (3 << 16)       /* 32 byte burst */
-#define DCMD_WIDTH1     (1 << 14)       /* 1 byte width */
-#define DCMD_WIDTH2     (2 << 14)       /* 2 byte width (HalfWord) */
-#define DCMD_WIDTH4     (3 << 14)       /* 4 byte width (Word) */
-#define DCMD_LENGTH     0x01fff         /* length mask (max = 8K - 1) */
-
-/*
- * Descriptor structure for PXA's DMA engine
- * Note: this structure must always be aligned to a 16-byte boundary.
- */
-
-typedef enum {
-        DMA_PRIO_HIGH = 0,
-        DMA_PRIO_MEDIUM = 1,
-        DMA_PRIO_LOW = 2
-} pxa_dma_prio;
-
-/*
- * DMA registration
- */
-
-static inline int pxa_request_dma(char *name,
-                pxa_dma_prio prio,
-                void (*irq_handler)(int, void *),
-                void *data)
-{
-        return -ENODEV;
-}
-
-static inline void pxa_free_dma(int dma_ch)
-{
-}
-
-/*
- * The CE4100 does not have the clk framework implemented and SPI clock can
- * not be switched on/off or the divider changed.
- */
-static inline void clk_disable(struct clk *clk)
-{
-}
-
-static inline int clk_enable(struct clk *clk)
-{
-        return 0;
-}
-
-static inline unsigned long clk_get_rate(struct clk *clk)
-{
-        return 3686400;
-}
-
 #endif
 #endif
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index f62918946d86..38c2b925923d 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -57,6 +57,8 @@ extern struct bus_type spi_bus_type;
  * @modalias: Name of the driver to use with this device, or an alias
  *      for that name.  This appears in the sysfs "modalias" attribute
  *      for driver coldplugging, and in uevents used for hotplugging
+ * @cs_gpio: gpio number of the chipselect line (optional, -EINVAL when
+ *      when not using a GPIO line)
  *
  * A @spi_device is used to interchange data between an SPI slave
  * (usually a discrete chip) and CPU memory.
@@ -258,6 +260,9 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @unprepare_transfer_hardware: there are currently no more messages on the
  *      queue so the subsystem notifies the driver that it may relax the
  *      hardware by issuing this call
+ * @cs_gpios: Array of GPIOs to use as chip select lines; one per CS
+ *      number. Any individual value may be -EINVAL for CS lines that
+ *      are not GPIOs (driven by the SPI controller itself).
  *
  * Each SPI master controller can communicate with one or more @spi_device
  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
@@ -591,6 +596,26 @@ spi_transfer_del(struct spi_transfer *t)
         list_del(&t->transfer_list);
 }
 
+/**
+ * spi_message_init_with_transfers - Initialize spi_message and append transfers
+ * @m: spi_message to be initialized
+ * @xfers: An array of spi transfers
+ * @num_xfers: Number of items in the xfer array
+ *
+ * This function initializes the given spi_message and adds each spi_transfer in
+ * the given array to the message.
+ */
+static inline void
+spi_message_init_with_transfers(struct spi_message *m,
+struct spi_transfer *xfers, unsigned int num_xfers)
+{
+        unsigned int i;
+
+        spi_message_init(m);
+        for (i = 0; i < num_xfers; ++i)
+                spi_message_add_tail(&xfers[i], m);
+}
+
 /* It's fine to embed message and transaction structures in other data
  * structures so long as you don't free them while they're in use.
  */
@@ -683,6 +708,30 @@ spi_read(struct spi_device *spi, void *buf, size_t len)
         return spi_sync(spi, &m);
 }
 
+/**
+ * spi_sync_transfer - synchronous SPI data transfer
+ * @spi: device with which data will be exchanged
+ * @xfers: An array of spi_transfers
+ * @num_xfers: Number of items in the xfer array
+ * Context: can sleep
+ *
+ * Does a synchronous SPI data transfer of the given spi_transfer array.
+ *
+ * For more specific semantics see spi_sync().
+ *
+ * It returns zero on success, else a negative error code.
+ */
+static inline int
+spi_sync_transfer(struct spi_device *spi, struct spi_transfer *xfers,
+        unsigned int num_xfers)
+{
+        struct spi_message msg;
+
+        spi_message_init_with_transfers(&msg, xfers, num_xfers);
+
+        return spi_sync(spi, &msg);
+}
+
 /* this copies txbuf and rxbuf data; for small transfers only! */
 extern int spi_write_then_read(struct spi_device *spi,
                 const void *txbuf, unsigned n_tx,
diff --git a/include/linux/spi/spi_gpio.h b/include/linux/spi/spi_gpio.h
index 369b3d7d5b95..1634ce31c06d 100644
--- a/include/linux/spi/spi_gpio.h
+++ b/include/linux/spi/spi_gpio.h
@@ -62,8 +62,8 @@
  */
 struct spi_gpio_platform_data {
         unsigned        sck;
-        unsigned        mosi;
-        unsigned        miso;
+        unsigned long   mosi;
+        unsigned long   miso;
 
         u16             num_chipselect;
 };
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 6eb691b08358..04f4121a23ae 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -151,30 +151,14 @@ void srcu_barrier(struct srcu_struct *sp);
  * Checks debug_lockdep_rcu_enabled() to prevent false positives during boot
  * and while lockdep is disabled.
  *
- * Note that if the CPU is in the idle loop from an RCU point of view
- * (ie: that we are in the section between rcu_idle_enter() and
- * rcu_idle_exit()) then srcu_read_lock_held() returns false even if
- * the CPU did an srcu_read_lock().  The reason for this is that RCU
- * ignores CPUs that are in such a section, considering these as in
- * extended quiescent state, so such a CPU is effectively never in an
- * RCU read-side critical section regardless of what RCU primitives it
- * invokes.  This state of affairs is required --- we need to keep an
- * RCU-free window in idle where the CPU may possibly enter into low
- * power mode. This way we can notice an extended quiescent state to
- * other CPUs that started a grace period. Otherwise we would delay any
- * grace period as long as we run in the idle task.
- *
- * Similarly, we avoid claiming an SRCU read lock held if the current
- * CPU is offline.
+ * Note that SRCU is based on its own statemachine and it doesn't
+ * relies on normal RCU, it can be called from the CPU which
+ * is in the idle loop from an RCU point of view or offline.
  */
 static inline int srcu_read_lock_held(struct srcu_struct *sp)
 {
         if (!debug_lockdep_rcu_enabled())
                 return 1;
-        if (rcu_is_cpu_idle())
-                return 0;
-        if (!rcu_lockdep_current_cpu_online())
-                return 0;
         return lock_is_held(&sp->dep_map);
 }
 
@@ -236,8 +220,6 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
         int retval = __srcu_read_lock(sp);
 
         rcu_lock_acquire(&(sp)->dep_map);
-        rcu_lockdep_assert(!rcu_is_cpu_idle(),
-                           "srcu_read_lock() used illegally while idle");
         return retval;
 }
 
@@ -251,8 +233,6 @@ static inline int srcu_read_lock(struct srcu_struct *sp) __acquires(sp)
 static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
         __releases(sp)
 {
-        rcu_lockdep_assert(!rcu_is_cpu_idle(),
-                           "srcu_read_unlock() used illegally while idle");
         rcu_lock_release(&(sp)->dep_map);
         __srcu_read_unlock(sp, idx);
 }
diff --git a/include/linux/ssb/ssb_driver_gige.h b/include/linux/ssb/ssb_driver_gige.h
index 6b05dcd927ff..86a12b0cb239 100644
--- a/include/linux/ssb/ssb_driver_gige.h
+++ b/include/linux/ssb/ssb_driver_gige.h
@@ -97,21 +97,16 @@ static inline bool ssb_gige_must_flush_posted_writes(struct pci_dev *pdev)
         return 0;
 }
 
-#ifdef CONFIG_BCM47XX
-#include <asm/mach-bcm47xx/nvram.h>
 /* Get the device MAC address */
-static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
-{
-        char buf[20];
-        if (nvram_getenv("et0macaddr", buf, sizeof(buf)) < 0)
-                return;
-        nvram_parse_macaddr(buf, macaddr);
-}
-#else
-static inline void ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
+static inline int ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
 {
+        struct ssb_gige *dev = pdev_to_ssb_gige(pdev);
+        if (!dev)
+                return -ENODEV;
+
+        memcpy(macaddr, dev->dev->bus->sprom.et0mac, 6);
+        return 0;
 }
-#endif
 
 extern int ssb_gige_pcibios_plat_dev_init(struct ssb_device *sdev,
                                           struct pci_dev *pdev);
@@ -175,6 +170,10 @@ static inline bool ssb_gige_must_flush_posted_writes(struct pci_dev *pdev)
 {
         return 0;
 }
+static inline int ssb_gige_get_macaddr(struct pci_dev *pdev, u8 *macaddr)
+{
+        return -ENODEV;
+}
 
 #endif /* CONFIG_SSB_DRIVER_GIGE */
 #endif /* LINUX_SSB_DRIVER_GIGE_H_ */
diff --git a/include/linux/ssb/ssb_driver_mips.h b/include/linux/ssb/ssb_driver_mips.h
index 07a9c7a2e088..afe79d40a99e 100644
--- a/include/linux/ssb/ssb_driver_mips.h
+++ b/include/linux/ssb/ssb_driver_mips.h
@@ -45,6 +45,11 @@ void ssb_mipscore_init(struct ssb_mipscore *mcore)
 {
 }
 
+static inline unsigned int ssb_mips_irq(struct ssb_device *dev)
+{
+        return 0;
+}
+
 #endif /* CONFIG_SSB_DRIVER_MIPS */
 
 #endif /* LINUX_SSB_MIPSCORE_H_ */
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index f25ba922baaf..58fda1c3c783 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -17,14 +17,15 @@
 
 #include <linux/atomic.h>
 #include <linux/rcupdate.h>
+#include <linux/uidgid.h>
 
 /* size of the nodename buffer */
 #define UNX_MAXNODENAME 32
 
 /* Work around the lack of a VFS credential */
 struct auth_cred {
-        uid_t   uid;
-        gid_t   gid;
+        kuid_t  uid;
+        kgid_t  gid;
         struct group_info *group_info;
         const char *principal;
         unsigned char machine_cred : 1;
@@ -48,7 +49,7 @@ struct rpc_cred {
         unsigned long           cr_flags;       /* various flags */
         atomic_t                cr_count;       /* ref count */
 
-        uid_t                   cr_uid;
+        kuid_t                  cr_uid;
 
         /* per-flavor data */
 };
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index b64f8eb0b973..84ca436b76c2 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -87,7 +87,6 @@ struct rpc_task {
                                 tk_cred_retry : 2,
                                 tk_rebind_retry : 2;
 };
-#define tk_xprt                 tk_client->cl_xprt
 
 /* support walking a list of tasks on a wait queue */
 #define task_for_each(task, pos, head) \
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index dd74084a9799..ff374ab30839 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -18,8 +18,8 @@
 #include <linux/cred.h>
 
 struct svc_cred {
-        uid_t                   cr_uid;
-        gid_t                   cr_gid;
+        kuid_t                  cr_uid;
+        kgid_t                  cr_gid;
         struct group_info       *cr_group_info;
         u32                     cr_flavor; /* pseudoflavor */
         char                    *cr_principal; /* for gss */
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 951cb9b7d02b..30834be03011 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -117,12 +117,12 @@ struct rpc_xprt_ops {
         void            (*alloc_slot)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*rpcbind)(struct rpc_task *task);
         void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
-        void            (*connect)(struct rpc_task *task);
+        void            (*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
         void *          (*buf_alloc)(struct rpc_task *task, size_t size);
         void            (*buf_free)(void *buffer);
         int             (*send_request)(struct rpc_task *task);
         void            (*set_retrans_timeout)(struct rpc_task *task);
-        void            (*timer)(struct rpc_task *task);
+        void            (*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*release_request)(struct rpc_task *task);
         void            (*close)(struct rpc_xprt *xprt);
         void            (*destroy)(struct rpc_xprt *xprt);
@@ -313,7 +313,7 @@ void			xprt_set_retrans_timeout_rtt(struct rpc_task *task);
 void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
 void                    xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action);
 void                    xprt_write_space(struct rpc_xprt *xprt);
-void                    xprt_adjust_cwnd(struct rpc_task *task, int result);
+void                    xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result);
 struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
 void                    xprt_complete_rqst(struct rpc_task *task, int copied);
 void                    xprt_release_rqst_cong(struct rpc_task *task);
diff --git a/include/linux/sunserialcore.h b/include/linux/sunserialcore.h
index 68e7430bb0fe..dbe4d7fca1b8 100644
--- a/include/linux/sunserialcore.h
+++ b/include/linux/sunserialcore.h
@@ -13,6 +13,10 @@
 #ifndef _SERIAL_SUN_H
 #define _SERIAL_SUN_H
 
+#include <linux/device.h>
+#include <linux/serial_core.h>
+#include <linux/console.h>
+
 /* Serial keyboard defines for L1-A processing... */
 #define SUNKBD_RESET            0xff
 #define SUNKBD_L1               0x01
diff --git a/include/linux/sunxi_timer.h b/include/linux/sunxi_timer.h
index b9165bba6e61..18081787e5f3 100644
--- a/include/linux/sunxi_timer.h
+++ b/include/linux/sunxi_timer.h
@@ -19,6 +19,6 @@
 
 #include <asm/mach/time.h>
 
-extern struct sys_timer sunxi_timer;
+void sunxi_timer_init(void);
 
 #endif
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 0c808d7fa579..d4e3f16d5e89 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -34,8 +34,10 @@ static inline void pm_restore_console(void)
 typedef int __bitwise suspend_state_t;
 
 #define PM_SUSPEND_ON           ((__force suspend_state_t) 0)
-#define PM_SUSPEND_STANDBY      ((__force suspend_state_t) 1)
+#define PM_SUSPEND_FREEZE       ((__force suspend_state_t) 1)
+#define PM_SUSPEND_STANDBY      ((__force suspend_state_t) 2)
 #define PM_SUSPEND_MEM          ((__force suspend_state_t) 3)
+#define PM_SUSPEND_MIN          PM_SUSPEND_FREEZE
 #define PM_SUSPEND_MAX          ((__force suspend_state_t) 4)
 
 enum suspend_stat_step {
@@ -192,6 +194,7 @@ struct platform_suspend_ops {
  */
 extern void suspend_set_ops(const struct platform_suspend_ops *ops);
 extern int suspend_valid_only_mem(suspend_state_t state);
+extern void freeze_wake(void);
 
 /**
  * arch_suspend_disable_irqs - disable IRQs for suspend
@@ -217,6 +220,7 @@ extern int pm_suspend(suspend_state_t state);
 
 static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
+static inline void freeze_wake(void) {}
 #endif /* !CONFIG_SUSPEND */
 
 /* struct pbe is used for creating lists of pages that should be restored
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 68df9c17fbbb..2818a123f3ea 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -8,7 +8,7 @@
 #include <linux/memcontrol.h>
 #include <linux/sched.h>
 #include <linux/node.h>
-
+#include <linux/fs.h>
 #include <linux/atomic.h>
 #include <asm/page.h>
 
@@ -156,7 +156,7 @@ enum {
         SWP_SCANNING    = (1 << 8),     /* refcount in scan_swap_map */
 };
 
-#define SWAP_CLUSTER_MAX 32
+#define SWAP_CLUSTER_MAX 32UL
 #define COMPACT_CLUSTER_MAX SWAP_CLUSTER_MAX
 
 /*
@@ -202,6 +202,18 @@ struct swap_info_struct {
         unsigned long *frontswap_map;   /* frontswap in-use, one bit per page */
         atomic_t frontswap_pages;       /* frontswap pages in-use counter */
 #endif
+        spinlock_t lock;                /*
+                                         * protect map scan related fields like
+                                         * swap_map, lowest_bit, highest_bit,
+                                         * inuse_pages, cluster_next,
+                                         * cluster_nr, lowest_alloc and
+                                         * highest_alloc. other fields are only
+                                         * changed at swapon/swapoff, so are
+                                         * protected by swap_lock. changing
+                                         * flags need hold this lock and
+                                         * swap_lock. If both locks need hold,
+                                         * hold swap_lock first.
+                                         */
 };
 
 struct swap_list_t {
@@ -209,15 +221,12 @@ struct swap_list_t {
         int next;       /* swapfile to be used next */
 };
 
-/* Swap 50% full? Release swapcache more aggressively.. */
-#define vm_swap_full() (nr_swap_pages*2 < total_swap_pages)
-
 /* linux/mm/page_alloc.c */
 extern unsigned long totalram_pages;
 extern unsigned long totalreserve_pages;
 extern unsigned long dirty_balance_reserve;
-extern unsigned int nr_free_buffer_pages(void);
-extern unsigned int nr_free_pagecache_pages(void);
+extern unsigned long nr_free_buffer_pages(void);
+extern unsigned long nr_free_pagecache_pages(void);
 
 /* Definition of global_page_state not available yet */
 #define nr_free_pages() global_page_state(NR_FREE_PAGES)
@@ -266,7 +275,7 @@ extern unsigned long mem_cgroup_shrink_node_zone(struct mem_cgroup *mem,
 extern unsigned long shrink_all_memory(unsigned long nr_pages);
 extern int vm_swappiness;
 extern int remove_mapping(struct address_space *mapping, struct page *page);
-extern long vm_total_pages;
+extern unsigned long vm_total_pages;
 
 #ifdef CONFIG_NUMA
 extern int zone_reclaim_mode;
@@ -330,8 +339,9 @@ int generic_swapfile_activate(struct swap_info_struct *, struct file *,
                 sector_t *);
 
 /* linux/mm/swap_state.c */
-extern struct address_space swapper_space;
-#define total_swapcache_pages  swapper_space.nrpages
+extern struct address_space swapper_spaces[];
+#define swap_address_space(entry) (&swapper_spaces[swp_type(entry)])
+extern unsigned long total_swapcache_pages(void);
 extern void show_swap_cache_info(void);
 extern int add_to_swap(struct page *);
 extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
@@ -346,8 +356,20 @@ extern struct page *swapin_readahead(swp_entry_t, gfp_t,
                         struct vm_area_struct *vma, unsigned long addr);
 
 /* linux/mm/swapfile.c */
-extern long nr_swap_pages;
+extern atomic_long_t nr_swap_pages;
 extern long total_swap_pages;
+
+/* Swap 50% full? Release swapcache more aggressively.. */
+static inline bool vm_swap_full(void)
+{
+        return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
+}
+
+static inline long get_nr_swap_pages(void)
+{
+        return atomic_long_read(&nr_swap_pages);
+}
+
 extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(void);
 extern swp_entry_t get_swap_page_of_type(int);
@@ -380,9 +402,10 @@ mem_cgroup_uncharge_swapcache(struct page *page, swp_entry_t ent, bool swapout)
 
 #else /* CONFIG_SWAP */
 
-#define nr_swap_pages                           0L
+#define get_nr_swap_pages()                     0L
 #define total_swap_pages                        0L
-#define total_swapcache_pages                   0UL
+#define total_swapcache_pages()                 0UL
+#define vm_swap_full()                          0
 
 #define si_swapinfo(val) \
         do { (val)->freeswap = (val)->totalswap = 0; } while (0)
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 071d62c214a6..2de42f9401d2 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -23,7 +23,7 @@ extern int swiotlb_force;
 #define IO_TLB_SHIFT 11
 
 extern void swiotlb_init(int verbose);
-extern void swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
+int swiotlb_init_with_tbl(char *tlb, unsigned long nslabs, int verbose);
 extern unsigned long swiotlb_nr_tbl(void);
 extern int swiotlb_late_init_with_tbl(char *tlb, unsigned long nslabs);
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 45e2db270255..313a8e0a6553 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -68,11 +68,11 @@ struct sigaltstack;
 #include <linux/types.h>
 #include <linux/aio_abi.h>
 #include <linux/capability.h>
+#include <linux/signal.h>
 #include <linux/list.h>
 #include <linux/bug.h>
 #include <linux/sem.h>
 #include <asm/siginfo.h>
-#include <asm/signal.h>
 #include <linux/unistd.h>
 #include <linux/quota.h>
 #include <linux/key.h>
@@ -300,10 +300,8 @@ asmlinkage long sys_personality(unsigned int personality);
 asmlinkage long sys_sigpending(old_sigset_t __user *set);
 asmlinkage long sys_sigprocmask(int how, old_sigset_t __user *set,
                                 old_sigset_t __user *oset);
-#ifdef CONFIG_GENERIC_SIGALTSTACK
 asmlinkage long sys_sigaltstack(const struct sigaltstack __user *uss,
                                 struct sigaltstack __user *uoss);
-#endif
 
 asmlinkage long sys_getitimer(int which, struct itimerval __user *value);
 asmlinkage long sys_setitimer(int which,
@@ -377,6 +375,27 @@ asmlinkage long sys_init_module(void __user *umod, unsigned long len,
 asmlinkage long sys_delete_module(const char __user *name_user,
                                 unsigned int flags);
 
+#ifdef CONFIG_OLD_SIGSUSPEND
+asmlinkage long sys_sigsuspend(old_sigset_t mask);
+#endif
+
+#ifdef CONFIG_OLD_SIGSUSPEND3
+asmlinkage long sys_sigsuspend(int unused1, int unused2, old_sigset_t mask);
+#endif
+
+asmlinkage long sys_rt_sigsuspend(sigset_t __user *unewset, size_t sigsetsize);
+
+#ifdef CONFIG_OLD_SIGACTION
+asmlinkage long sys_sigaction(int, const struct old_sigaction __user *,
+                                struct old_sigaction __user *);
+#endif
+
+#ifndef CONFIG_ODD_RT_SIGACTION
+asmlinkage long sys_rt_sigaction(int,
+                                 const struct sigaction __user *,
+                                 struct sigaction __user *,
+                                 size_t);
+#endif
 asmlinkage long sys_rt_sigprocmask(int how, sigset_t __user *set,
                                 sigset_t __user *oset, size_t sigsetsize);
 asmlinkage long sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize);
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index 381f06db2fe5..e2cee22f578a 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -181,6 +181,10 @@ int sysfs_merge_group(struct kobject *kobj,
                        const struct attribute_group *grp);
 void sysfs_unmerge_group(struct kobject *kobj,
                        const struct attribute_group *grp);
+int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
+                            struct kobject *target, const char *link_name);
+void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
+                                  const char *link_name);
 
 void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
 void sysfs_notify_dirent(struct sysfs_dirent *sd);
@@ -326,6 +330,18 @@ static inline void sysfs_unmerge_group(struct kobject *kobj,
 {
 }
 
+static inline int sysfs_add_link_to_group(struct kobject *kobj,
+                const char *group_name, struct kobject *target,
+                const char *link_name)
+{
+        return 0;
+}
+
+static inline void sysfs_remove_link_from_group(struct kobject *kobj,
+                const char *group_name, const char *link_name)
+{
+}
+
 static inline void sysfs_notify(struct kobject *kobj, const char *dir,
                                 const char *attr)
 {
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 4e1d2283e3cc..f28408c07dc2 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -162,6 +162,8 @@ struct tcp_sock {
         u32     rcv_tstamp;     /* timestamp of last received ACK (for keepalives) */
         u32     lsndtime;       /* timestamp of last sent data packet (for restart window) */
 
+        u32     tsoffset;       /* timestamp offset */
+
         struct list_head tsq_node; /* anchor in tsq_tasklet.head list */
         unsigned long   tsq_flags;
 
@@ -246,7 +248,6 @@ struct tcp_sock {
         u32     sacked_out;     /* SACK'd packets                       */
         u32     fackets_out;    /* FACK'd packets                       */
         u32     tso_deferred;
-        u32     bytes_acked;    /* Appropriate Byte Counting - RFC3465 */
 
         /* from STCP, retrans queue hinting */
         struct sk_buff* lost_skb_hint;
@@ -354,6 +355,7 @@ struct tcp_timewait_sock {
         u32                       tw_rcv_nxt;
         u32                       tw_snd_nxt;
         u32                       tw_rcv_wnd;
+        u32                       tw_ts_offset;
         u32                       tw_ts_recent;
         long                      tw_ts_recent_stamp;
 #ifdef CONFIG_TCP_MD5SIG
diff --git a/include/linux/tegra-soc.h b/include/linux/tegra-soc.h
new file mode 100644
index 000000000000..95f611d78f3a
--- /dev/null
+++ b/include/linux/tegra-soc.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2012, NVIDIA CORPORATION.  All rights reserved.
+ *
+ * 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.
+ *
+ * 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_TEGRA_SOC_H_
+#define __LINUX_TEGRA_SOC_H_
+
+u32 tegra_read_chipid(void);
+
+#endif /* __LINUX_TEGRA_SOC_H_ */
diff --git a/include/linux/tick.h b/include/linux/tick.h
index 1a6567b48492..553272e6af55 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -8,6 +8,8 @@
 
 #include <linux/clockchips.h>
 #include <linux/irqflags.h>
+#include <linux/percpu.h>
+#include <linux/hrtimer.h>
 
 #ifdef CONFIG_GENERIC_CLOCKEVENTS
 
@@ -122,13 +124,26 @@ static inline int tick_oneshot_mode_active(void) { return 0; }
 #endif /* !CONFIG_GENERIC_CLOCKEVENTS */
 
 # ifdef CONFIG_NO_HZ
+DECLARE_PER_CPU(struct tick_sched, tick_cpu_sched);
+
+static inline int tick_nohz_tick_stopped(void)
+{
+        return __this_cpu_read(tick_cpu_sched.tick_stopped);
+}
+
 extern void tick_nohz_idle_enter(void);
 extern void tick_nohz_idle_exit(void);
 extern void tick_nohz_irq_exit(void);
 extern ktime_t tick_nohz_get_sleep_length(void);
 extern u64 get_cpu_idle_time_us(int cpu, u64 *last_update_time);
 extern u64 get_cpu_iowait_time_us(int cpu, u64 *last_update_time);
-# else
+
+# else /* !CONFIG_NO_HZ */
+static inline int tick_nohz_tick_stopped(void)
+{
+        return 0;
+}
+
 static inline void tick_nohz_idle_enter(void) { }
 static inline void tick_nohz_idle_exit(void) { }
 
diff --git a/include/linux/time.h b/include/linux/time.h
index 4d358e9d10f1..d4835dfdf25e 100644
--- a/include/linux/time.h
+++ b/include/linux/time.h
@@ -115,8 +115,20 @@ static inline bool timespec_valid_strict(const struct timespec *ts)
         return true;
 }
 
+extern bool persistent_clock_exist;
+
+#ifdef ALWAYS_USE_PERSISTENT_CLOCK
+#define has_persistent_clock()  true
+#else
+static inline bool has_persistent_clock(void)
+{
+        return persistent_clock_exist;
+}
+#endif
+
 extern void read_persistent_clock(struct timespec *ts);
 extern void read_boot_clock(struct timespec *ts);
+extern int persistent_clock_is_local;
 extern int update_persistent_clock(struct timespec now);
 void timekeeping_init(void);
 extern int timekeeping_suspended;
@@ -142,9 +154,7 @@ void timekeeping_inject_sleeptime(struct timespec *delta);
  * finer then tick granular time.
  */
 #ifdef CONFIG_ARCH_USES_GETTIMEOFFSET
-extern u32 arch_gettimeoffset(void);
-#else
-static inline u32 arch_gettimeoffset(void) { return 0; }
+extern u32 (*arch_gettimeoffset)(void);
 #endif
 
 extern void do_gettimeofday(struct timeval *tv);
@@ -158,6 +168,7 @@ extern int do_setitimer(int which, struct itimerval *value,
                         struct itimerval *ovalue);
 extern unsigned int alarm_setitimer(unsigned int seconds);
 extern int do_getitimer(int which, struct itimerval *value);
+extern int __getnstimeofday(struct timespec *tv);
 extern void getnstimeofday(struct timespec *tv);
 extern void getrawmonotonic(struct timespec *ts);
 extern void getnstime_raw_and_real(struct timespec *ts_raw,
diff --git a/include/linux/tsacct_kern.h b/include/linux/tsacct_kern.h
index 44893e5ec8f7..3251965bf4cc 100644
--- a/include/linux/tsacct_kern.h
+++ b/include/linux/tsacct_kern.h
@@ -23,12 +23,15 @@ static inline void bacct_add_tsk(struct user_namespace *user_ns,
 #ifdef CONFIG_TASK_XACCT
 extern void xacct_add_tsk(struct taskstats *stats, struct task_struct *p);
 extern void acct_update_integrals(struct task_struct *tsk);
+extern void acct_account_cputime(struct task_struct *tsk);
 extern void acct_clear_integrals(struct task_struct *tsk);
 #else
 static inline void xacct_add_tsk(struct taskstats *stats, struct task_struct *p)
 {}
 static inline void acct_update_integrals(struct task_struct *tsk)
 {}
+static inline void acct_account_cputime(struct task_struct *tsk)
+{}
 static inline void acct_clear_integrals(struct task_struct *tsk)
 {}
 #endif /* CONFIG_TASK_XACCT */
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 8db1b569c37a..c75d886b0307 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -202,7 +202,8 @@ struct tty_port {
         unsigned long           iflags;         /* TTYP_ internal flags */
 #define TTYP_FLUSHING                   1  /* Flushing to ldisc in progress */
 #define TTYP_FLUSHPENDING               2  /* Queued buffer flush pending */
-        unsigned char           console:1;      /* port is a console */
+        unsigned char           console:1,      /* port is a console */
+                                low_latency:1;  /* direct buffer flush */
         struct mutex            mutex;          /* Locking */
         struct mutex            buf_mutex;      /* Buffer alloc lock */
         unsigned char           *xmit_buf;      /* Optional buffer */
@@ -254,7 +255,7 @@ struct tty_struct {
         int count;
         struct winsize winsize;         /* termios mutex */
         unsigned char stopped:1, hw_stopped:1, flow_stopped:1, packet:1;
-        unsigned char low_latency:1, warned:1;
+        unsigned char warned:1;
         unsigned char ctrl_status;      /* ctrl_lock */
         unsigned int receive_room;      /* Bytes free for queue */
 
@@ -317,11 +318,43 @@ struct tty_file_private {
 
 #define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
 
+#ifdef CONFIG_TTY
+extern void console_init(void);
+extern void tty_kref_put(struct tty_struct *tty);
+extern struct pid *tty_get_pgrp(struct tty_struct *tty);
+extern void tty_vhangup_self(void);
+extern void disassociate_ctty(int priv);
+extern dev_t tty_devnum(struct tty_struct *tty);
+extern void proc_clear_tty(struct task_struct *p);
+extern struct tty_struct *get_current_tty(void);
+/* tty_io.c */
+extern int __init tty_init(void);
+#else
+static inline void console_init(void)
+{ }
+static inline void tty_kref_put(struct tty_struct *tty)
+{ }
+static inline struct pid *tty_get_pgrp(struct tty_struct *tty)
+{ return NULL; }
+static inline void tty_vhangup_self(void)
+{ }
+static inline void disassociate_ctty(int priv)
+{ }
+static inline dev_t tty_devnum(struct tty_struct *tty)
+{ return 0; }
+static inline void proc_clear_tty(struct task_struct *p)
+{ }
+static inline struct tty_struct *get_current_tty(void)
+{ return NULL; }
+/* tty_io.c */
+static inline int __init tty_init(void)
+{ return 0; }
+#endif
+
 extern void tty_write_flush(struct tty_struct *);
 
 extern struct ktermios tty_std_termios;
 
-extern void console_init(void);
 extern int vcs_init(void);
 
 extern struct class *tty_class;
@@ -341,7 +374,6 @@ static inline struct tty_struct *tty_kref_get(struct tty_struct *tty)
                 kref_get(&tty->kref);
         return tty;
 }
-extern void tty_kref_put(struct tty_struct *tty);
 
 extern int tty_paranoia_check(struct tty_struct *tty, struct inode *inode,
                               const char *routine);
@@ -373,20 +405,16 @@ extern void tty_driver_remove_tty(struct tty_driver *driver,
                                   struct tty_struct *tty);
 extern void tty_free_termios(struct tty_struct *tty);
 extern int is_current_pgrp_orphaned(void);
-extern struct pid *tty_get_pgrp(struct tty_struct *tty);
 extern int is_ignored(int sig);
 extern int tty_signal(int sig, struct tty_struct *tty);
 extern void tty_hangup(struct tty_struct *tty);
 extern void tty_vhangup(struct tty_struct *tty);
 extern void tty_vhangup_locked(struct tty_struct *tty);
-extern void tty_vhangup_self(void);
 extern void tty_unhangup(struct file *filp);
 extern int tty_hung_up_p(struct file *filp);
 extern void do_SAK(struct tty_struct *tty);
 extern void __do_SAK(struct tty_struct *tty);
-extern void disassociate_ctty(int priv);
 extern void no_tty(void);
-extern void tty_flip_buffer_push(struct tty_struct *tty);
 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);
@@ -415,9 +443,6 @@ extern long tty_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
 extern int tty_mode_ioctl(struct tty_struct *tty, struct file *file,
                         unsigned int cmd, unsigned long arg);
 extern int tty_perform_flush(struct tty_struct *tty, unsigned long arg);
-extern dev_t tty_devnum(struct tty_struct *tty);
-extern void proc_clear_tty(struct task_struct *p);
-extern struct tty_struct *get_current_tty(void);
 extern void tty_default_fops(struct file_operations *fops);
 extern struct tty_struct *alloc_tty_struct(void);
 extern int tty_alloc_file(struct file *file);
@@ -543,9 +568,6 @@ static inline int tty_audit_push_task(struct task_struct *tsk,
 }
 #endif
 
-/* tty_io.c */
-extern int __init tty_init(void);
-
 /* tty_ioctl.c */
 extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
                        unsigned int cmd, unsigned long arg);
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index dd976cfb6131..756a60989294 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -40,6 +40,7 @@
  * void (*close)(struct tty_struct * tty, struct file * filp);
  *
  *      This routine is called when a particular tty device is closed.
+ *      Note: called even if the corresponding open() failed.
  *
  *      Required method.
  *
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 2002344ed36a..e0f252633b47 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -1,28 +1,34 @@
 #ifndef _LINUX_TTY_FLIP_H
 #define _LINUX_TTY_FLIP_H
 
-extern int tty_buffer_request_room(struct tty_struct *tty, size_t size);
-extern int tty_insert_flip_string_flags(struct tty_struct *tty, const unsigned char *chars, const char *flags, size_t size);
-extern int tty_insert_flip_string_fixed_flag(struct tty_struct *tty, const unsigned char *chars, char flag, size_t size);
-extern int tty_prepare_flip_string(struct tty_struct *tty, unsigned char **chars, size_t size);
-extern int tty_prepare_flip_string_flags(struct tty_struct *tty, unsigned char **chars, char **flags, size_t size);
-void tty_schedule_flip(struct tty_struct *tty);
+extern int tty_buffer_request_room(struct tty_port *port, size_t size);
+extern int tty_insert_flip_string_flags(struct tty_port *port,
+                const unsigned char *chars, const char *flags, size_t size);
+extern int tty_insert_flip_string_fixed_flag(struct tty_port *port,
+                const unsigned char *chars, char flag, size_t size);
+extern int tty_prepare_flip_string(struct tty_port *port,
+                unsigned char **chars, size_t size);
+extern int tty_prepare_flip_string_flags(struct tty_port *port,
+                unsigned char **chars, char **flags, size_t size);
+extern void tty_flip_buffer_push(struct tty_port *port);
+void tty_schedule_flip(struct tty_port *port);
 
-static inline int tty_insert_flip_char(struct tty_struct *tty,
+static inline int tty_insert_flip_char(struct tty_port *port,
                                         unsigned char ch, char flag)
 {
-        struct tty_buffer *tb = tty->port->buf.tail;
+        struct tty_buffer *tb = port->buf.tail;
         if (tb && tb->used < tb->size) {
                 tb->flag_buf_ptr[tb->used] = flag;
                 tb->char_buf_ptr[tb->used++] = ch;
                 return 1;
         }
-        return tty_insert_flip_string_flags(tty, &ch, &flag, 1);
+        return tty_insert_flip_string_flags(port, &ch, &flag, 1);
 }
 
-static inline int tty_insert_flip_string(struct tty_struct *tty, const unsigned char *chars, size_t size)
+static inline int tty_insert_flip_string(struct tty_port *port,
+                const unsigned char *chars, size_t size)
 {
-        return tty_insert_flip_string_fixed_flag(tty, chars, TTY_NORMAL, size);
+        return tty_insert_flip_string_fixed_flag(port, chars, TTY_NORMAL, size);
 }
 
 #endif /* _LINUX_TTY_FLIP_H */
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index fb79dd8d1537..455a0d7bf220 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -100,16 +100,14 @@
  *      seek to perform this action quickly but should wait until
  *      any pending driver I/O is completed.
  *
- * void (*dcd_change)(struct tty_struct *tty, unsigned int status,
- *                      struct pps_event_time *ts)
+ * void (*dcd_change)(struct tty_struct *tty, unsigned int status)
  *
- *      Tells the discipline that the DCD pin has changed its status and
- *      the relative timestamp. Pointer ts cannot be NULL.
+ *      Tells the discipline that the DCD pin has changed its status.
+ *      Used exclusively by the N_PPS (Pulse-Per-Second) line discipline.
  */
 
 #include <linux/fs.h>
 #include <linux/wait.h>
-#include <linux/pps_kernel.h>
 #include <linux/wait.h>
 
 struct tty_ldisc_ops {
@@ -144,8 +142,7 @@ struct tty_ldisc_ops {
         void    (*receive_buf)(struct tty_struct *, const unsigned char *cp,
                                char *fp, int count);
         void    (*write_wakeup)(struct tty_struct *);
-        void    (*dcd_change)(struct tty_struct *, unsigned int,
-                                struct pps_event_time *);
+        void    (*dcd_change)(struct tty_struct *, unsigned int);
 
         struct  module *owner;
         
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index 4f628a6fc5b4..02b83db8e2c5 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -35,13 +35,20 @@ struct inode;
 # include <asm/uprobes.h>
 #endif
 
+#define UPROBE_HANDLER_REMOVE           1
+#define UPROBE_HANDLER_MASK             1
+
+enum uprobe_filter_ctx {
+        UPROBE_FILTER_REGISTER,
+        UPROBE_FILTER_UNREGISTER,
+        UPROBE_FILTER_MMAP,
+};
+
 struct uprobe_consumer {
         int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs);
-        /*
-         * filter is optional; If a filter exists, handler is run
-         * if and only if filter returns true.
-         */
-        bool (*filter)(struct uprobe_consumer *self, struct task_struct *task);
+        bool (*filter)(struct uprobe_consumer *self,
+                                enum uprobe_filter_ctx ctx,
+                                struct mm_struct *mm);
 
         struct uprobe_consumer *next;
 };
@@ -94,6 +101,7 @@ extern int __weak set_swbp(struct arch_uprobe *aup, struct mm_struct *mm, unsign
 extern int __weak set_orig_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
 extern bool __weak is_swbp_insn(uprobe_opcode_t *insn);
 extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
+extern int uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool);
 extern void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
 extern int uprobe_mmap(struct vm_area_struct *vma);
 extern void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end);
@@ -117,6 +125,11 @@ uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc)
 {
         return -ENOSYS;
 }
+static inline int
+uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool add)
+{
+        return -ENOSYS;
+}
 static inline void
 uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc)
 {
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index b09c37e04a91..3c671c1b37f6 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -77,6 +77,8 @@ struct usb_configuration;
  *      in interface or class descriptors; endpoints; I/O buffers; and so on.
  * @unbind: Reverses @bind; called as a side effect of unregistering the
  *      driver which added this function.
+ * @free_func: free the struct usb_function.
+ * @mod: (internal) points to the module that created this structure.
  * @set_alt: (REQUIRED) Reconfigures altsettings; function drivers may
  *      initialize usb_ep.driver data at this time (when it is used).
  *      Note that setting an interface to its current altsetting resets
@@ -116,6 +118,7 @@ struct usb_configuration;
  * two or more distinct instances within the same configuration, providing
  * several independent logical data links to a USB host.
  */
+
 struct usb_function {
         const char                      *name;
         struct usb_gadget_strings       **strings;
@@ -136,6 +139,8 @@ struct usb_function {
                                         struct usb_function *);
         void                    (*unbind)(struct usb_configuration *,
                                         struct usb_function *);
+        void                    (*free_func)(struct usb_function *f);
+        struct module           *mod;
 
         /* runtime state management */
         int                     (*set_alt)(struct usb_function *,
@@ -156,6 +161,7 @@ struct usb_function {
         /* internals */
         struct list_head                list;
         DECLARE_BITMAP(endpoints, 32);
+        const struct usb_function_instance *fi;
 };
 
 int usb_add_function(struct usb_configuration *, struct usb_function *);
@@ -184,7 +190,8 @@ int config_ep_by_speed(struct usb_gadget *g, struct usb_function *f,
  * @bConfigurationValue: Copied into configuration descriptor.
  * @iConfiguration: Copied into configuration descriptor.
  * @bmAttributes: Copied into configuration descriptor.
- * @bMaxPower: Copied into configuration descriptor.
+ * @MaxPower: Power consumtion in mA. Used to compute bMaxPower in the
+ *      configuration descriptor after considering the bus speed.
  * @cdev: assigned by @usb_add_config() before calling @bind(); this is
  *      the device associated with this configuration.
  *
@@ -230,7 +237,7 @@ struct usb_configuration {
         u8                      bConfigurationValue;
         u8                      iConfiguration;
         u8                      bmAttributes;
-        u8                      bMaxPower;
+        u16                     MaxPower;
 
         struct usb_composite_dev        *cdev;
 
@@ -316,7 +323,15 @@ struct usb_composite_driver {
 extern int usb_composite_probe(struct usb_composite_driver *driver);
 extern void usb_composite_unregister(struct usb_composite_driver *driver);
 extern void usb_composite_setup_continue(struct usb_composite_dev *cdev);
+extern int composite_dev_prepare(struct usb_composite_driver *composite,
+                struct usb_composite_dev *cdev);
+void composite_dev_cleanup(struct usb_composite_dev *cdev);
 
+static inline struct usb_composite_driver *to_cdriver(
+                struct usb_gadget_driver *gdrv)
+{
+        return container_of(gdrv, struct usb_composite_driver, gadget_driver);
+}
 
 /**
  * struct usb_composite_device - represents one composite usb gadget
@@ -360,6 +375,7 @@ struct usb_composite_dev {
         unsigned int                    suspended:1;
         struct usb_device_descriptor    desc;
         struct list_head                configs;
+        struct list_head                gstrings;
         struct usb_composite_driver     *driver;
         u8                              next_string_id;
         char                            *def_manufacturer;
@@ -381,8 +397,15 @@ struct usb_composite_dev {
 extern int usb_string_id(struct usb_composite_dev *c);
 extern int usb_string_ids_tab(struct usb_composite_dev *c,
                               struct usb_string *str);
+extern struct usb_string *usb_gstrings_attach(struct usb_composite_dev *cdev,
+                struct usb_gadget_strings **sp, unsigned n_strings);
+
 extern int usb_string_ids_n(struct usb_composite_dev *c, unsigned n);
 
+extern void composite_disconnect(struct usb_gadget *gadget);
+extern int composite_setup(struct usb_gadget *gadget,
+                const struct usb_ctrlrequest *ctrl);
+
 /*
  * Some systems will need runtime overrides for the  product identifiers
  * published in the device descriptor, either numbers or strings or both.
@@ -431,6 +454,54 @@ static inline u16 get_default_bcdDevice(void)
         return bcdDevice;
 }
 
+struct usb_function_driver {
+        const char *name;
+        struct module *mod;
+        struct list_head list;
+        struct usb_function_instance *(*alloc_inst)(void);
+        struct usb_function *(*alloc_func)(struct usb_function_instance *inst);
+};
+
+struct usb_function_instance {
+        struct usb_function_driver *fd;
+        void (*free_func_inst)(struct usb_function_instance *inst);
+};
+
+void usb_function_unregister(struct usb_function_driver *f);
+int usb_function_register(struct usb_function_driver *newf);
+void usb_put_function_instance(struct usb_function_instance *fi);
+void usb_put_function(struct usb_function *f);
+struct usb_function_instance *usb_get_function_instance(const char *name);
+struct usb_function *usb_get_function(struct usb_function_instance *fi);
+
+struct usb_configuration *usb_get_config(struct usb_composite_dev *cdev,
+                int val);
+int usb_add_config_only(struct usb_composite_dev *cdev,
+                struct usb_configuration *config);
+void usb_remove_function(struct usb_configuration *c, struct usb_function *f);
+
+#define DECLARE_USB_FUNCTION(_name, _inst_alloc, _func_alloc)           \
+        static struct usb_function_driver _name ## usb_func = {         \
+                .name = __stringify(_name),                             \
+                .mod  = THIS_MODULE,                                    \
+                .alloc_inst = _inst_alloc,                              \
+                .alloc_func = _func_alloc,                              \
+        };                                                              \
+        MODULE_ALIAS("usbfunc:"__stringify(_name));
+
+#define DECLARE_USB_FUNCTION_INIT(_name, _inst_alloc, _func_alloc)      \
+        DECLARE_USB_FUNCTION(_name, _inst_alloc, _func_alloc)           \
+        static int __init _name ## mod_init(void)                       \
+        {                                                               \
+                return usb_function_register(&_name ## usb_func);       \
+        }                                                               \
+        static void __exit _name ## mod_exit(void)                      \
+        {                                                               \
+                usb_function_unregister(&_name ## usb_func);            \
+        }                                                               \
+        module_init(_name ## mod_init);                                 \
+        module_exit(_name ## mod_exit)
+
 /* messaging utils */
 #define DBG(d, fmt, args...) \
         dev_dbg(&(d)->gadget->dev , fmt , ## args)
diff --git a/include/linux/usb/dwc3-omap.h b/include/linux/usb/dwc3-omap.h
new file mode 100644
index 000000000000..51eae14477f7
--- /dev/null
+++ b/include/linux/usb/dwc3-omap.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (C) 2013 by Texas Instruments
+ *
+ * The Inventra Controller Driver for Linux 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 __DWC3_OMAP_H__
+#define __DWC3_OMAP_H__
+
+enum omap_dwc3_vbus_id_status {
+        OMAP_DWC3_UNKNOWN = 0,
+        OMAP_DWC3_ID_GROUND,
+        OMAP_DWC3_ID_FLOAT,
+        OMAP_DWC3_VBUS_VALID,
+        OMAP_DWC3_VBUS_OFF,
+};
+
+#if (defined(CONFIG_USB_DWC3) || defined(CONFIG_USB_DWC3_MODULE))
+extern void dwc3_omap_mailbox(enum omap_dwc3_vbus_id_status status);
+#else
+static inline void dwc3_omap_mailbox(enum omap_dwc3_vbus_id_status status)
+{
+        return;
+}
+#endif
+
+#endif  /* __DWC3_OMAP_H__ */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 0af6569b8cc6..2e297e80d59a 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -471,12 +471,6 @@ struct usb_gadget_ops {
                         struct usb_gadget_driver *);
         int     (*udc_stop)(struct usb_gadget *,
                         struct usb_gadget_driver *);
-
-        /* Those two are deprecated */
-        int     (*start)(struct usb_gadget_driver *,
-                        int (*bind)(struct usb_gadget *,
-                                struct usb_gadget_driver *driver));
-        int     (*stop)(struct usb_gadget_driver *);
 };
 
 /**
@@ -880,6 +874,8 @@ int usb_gadget_unregister_driver(struct usb_gadget_driver *driver);
 
 extern int usb_add_gadget_udc(struct device *parent, struct usb_gadget *gadget);
 extern void usb_del_gadget_udc(struct usb_gadget *gadget);
+extern int udc_attach_driver(const char *name,
+                struct usb_gadget_driver *driver);
 
 /*-------------------------------------------------------------------------*/
 
@@ -911,6 +907,11 @@ struct usb_gadget_strings {
         struct usb_string       *strings;
 };
 
+struct usb_gadget_string_container {
+        struct list_head        list;
+        u8                      *stash[0];
+};
+
 /* put descriptor for string with that id into buf (buflen >= 256) */
 int usb_gadget_get_string(struct usb_gadget_strings *table, int id, u8 *buf);
 
diff --git a/include/linux/usb/musb.h b/include/linux/usb/musb.h
index eb505250940a..053c26841cc3 100644
--- a/include/linux/usb/musb.h
+++ b/include/linux/usb/musb.h
@@ -99,6 +99,8 @@ struct musb_hdrc_platform_data {
         /* MUSB_HOST, MUSB_PERIPHERAL, or MUSB_OTG */
         u8              mode;
 
+        u8              has_mailbox:1;
+
         /* for clk_get() */
         const char      *clock;
 
diff --git a/include/linux/usb/omap_control_usb.h b/include/linux/usb/omap_control_usb.h
new file mode 100644
index 000000000000..27b5b8c931b0
--- /dev/null
+++ b/include/linux/usb/omap_control_usb.h
@@ -0,0 +1,92 @@
+/*
+ * omap_control_usb.h - Header file for the USB part of control module.
+ *
+ * Copyright (C) 2013 Texas Instruments Incorporated - http://www.ti.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.
+ *
+ * Author: Kishon Vijay Abraham I <kishon@ti.com>
+ *
+ * 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 __OMAP_CONTROL_USB_H__
+#define __OMAP_CONTROL_USB_H__
+
+struct omap_control_usb {
+        struct device *dev;
+
+        u32 __iomem *dev_conf;
+        u32 __iomem *otghs_control;
+        u32 __iomem *phy_power;
+
+        struct clk *sys_clk;
+
+        u32 type;
+};
+
+struct omap_control_usb_platform_data {
+        u8 type;
+};
+
+enum omap_control_usb_mode {
+        USB_MODE_UNDEFINED = 0,
+        USB_MODE_HOST,
+        USB_MODE_DEVICE,
+        USB_MODE_DISCONNECT,
+};
+
+/* To differentiate ctrl module IP having either mailbox or USB3 PHY power */
+#define OMAP_CTRL_DEV_TYPE1             0x1
+#define OMAP_CTRL_DEV_TYPE2             0x2
+
+#define OMAP_CTRL_DEV_PHY_PD            BIT(0)
+
+#define OMAP_CTRL_DEV_AVALID            BIT(0)
+#define OMAP_CTRL_DEV_BVALID            BIT(1)
+#define OMAP_CTRL_DEV_VBUSVALID         BIT(2)
+#define OMAP_CTRL_DEV_SESSEND           BIT(3)
+#define OMAP_CTRL_DEV_IDDIG             BIT(4)
+
+#define OMAP_CTRL_USB_PWRCTL_CLK_CMD_MASK       0x003FC000
+#define OMAP_CTRL_USB_PWRCTL_CLK_CMD_SHIFT      0xE
+
+#define OMAP_CTRL_USB_PWRCTL_CLK_FREQ_MASK      0xFFC00000
+#define OMAP_CTRL_USB_PWRCTL_CLK_FREQ_SHIFT     0x16
+
+#define OMAP_CTRL_USB3_PHY_TX_RX_POWERON        0x3
+#define OMAP_CTRL_USB3_PHY_TX_RX_POWEROFF       0x0
+
+#if IS_ENABLED(CONFIG_OMAP_CONTROL_USB)
+extern struct device *omap_get_control_dev(void);
+extern void omap_control_usb_phy_power(struct device *dev, int on);
+extern void omap_control_usb3_phy_power(struct device *dev, bool on);
+extern void omap_control_usb_set_mode(struct device *dev,
+        enum omap_control_usb_mode mode);
+#else
+static inline struct device *omap_get_control_dev(void)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline void omap_control_usb_phy_power(struct device *dev, int on)
+{
+}
+
+static inline void omap_control_usb3_phy_power(struct device *dev, int on)
+{
+}
+
+static inline void omap_control_usb_set_mode(struct device *dev,
+        enum omap_control_usb_mode mode)
+{
+}
+#endif
+
+#endif  /* __OMAP_CONTROL_USB_H__ */
diff --git a/include/linux/usb/omap_usb.h b/include/linux/usb/omap_usb.h
index 0ea17f8ae820..6ae29360e1d2 100644
--- a/include/linux/usb/omap_usb.h
+++ b/include/linux/usb/omap_usb.h
@@ -19,19 +19,29 @@
 #ifndef __DRIVERS_OMAP_USB2_H
 #define __DRIVERS_OMAP_USB2_H
 
+#include <linux/io.h>
 #include <linux/usb/otg.h>
 
+struct usb_dpll_params {
+        u16     m;
+        u8      n;
+        u8      freq:3;
+        u8      sd;
+        u32     mf;
+};
+
 struct omap_usb {
         struct usb_phy          phy;
         struct phy_companion    *comparator;
+        void __iomem            *pll_ctrl_base;
         struct device           *dev;
-        u32 __iomem             *control_dev;
+        struct device           *control_dev;
         struct clk              *wkupclk;
+        struct clk              *sys_clk;
+        struct clk              *optclk;
         u8                      is_suspended:1;
 };
 
-#define PHY_PD  0x1
-
 #define phy_to_omapusb(x)       container_of((x), struct omap_usb, phy)
 
 #if defined(CONFIG_OMAP_USB2) || defined(CONFIG_OMAP_USB2_MODULE)
@@ -43,4 +53,15 @@ static inline int omap_usb2_set_comparator(struct phy_companion *comparator)
 }
 #endif
 
+static inline u32 omap_usb_readl(void __iomem *addr, unsigned offset)
+{
+        return __raw_readl(addr + offset);
+}
+
+static inline void omap_usb_writel(void __iomem *addr, unsigned offset,
+        u32 data)
+{
+        __raw_writel(data, addr + offset);
+}
+
 #endif /* __DRIVERS_OMAP_USB_H */
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index a29ae1eb9346..15847cbdb512 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -106,9 +106,25 @@ struct usb_phy {
                         enum usb_device_speed speed);
 };
 
+/**
+ * struct usb_phy_bind - represent the binding for the phy
+ * @dev_name: the device name of the device that will bind to the phy
+ * @phy_dev_name: the device name of the phy
+ * @index: used if a single controller uses multiple phys
+ * @phy: reference to the phy
+ * @list: to maintain a linked list of the binding information
+ */
+struct usb_phy_bind {
+        const char      *dev_name;
+        const char      *phy_dev_name;
+        u8              index;
+        struct usb_phy  *phy;
+        struct list_head list;
+};
 
 /* for board-specific init logic */
 extern int usb_add_phy(struct usb_phy *, enum usb_phy_type type);
+extern int usb_add_phy_dev(struct usb_phy *);
 extern void usb_remove_phy(struct usb_phy *);
 
 /* helpers for direct access thru low-level io interface */
@@ -149,8 +165,14 @@ usb_phy_shutdown(struct usb_phy *x)
 extern struct usb_phy *usb_get_phy(enum usb_phy_type type);
 extern struct usb_phy *devm_usb_get_phy(struct device *dev,
         enum usb_phy_type type);
+extern struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index);
+extern struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index);
+extern struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
+        const char *phandle, u8 index);
 extern void usb_put_phy(struct usb_phy *);
 extern void devm_usb_put_phy(struct device *dev, struct usb_phy *x);
+extern int usb_bind_phy(const char *dev_name, u8 index,
+                                const char *phy_dev_name);
 #else
 static inline struct usb_phy *usb_get_phy(enum usb_phy_type type)
 {
@@ -163,6 +185,22 @@ static inline struct usb_phy *devm_usb_get_phy(struct device *dev,
         return NULL;
 }
 
+static inline struct usb_phy *usb_get_phy_dev(struct device *dev, u8 index)
+{
+        return NULL;
+}
+
+static inline struct usb_phy *devm_usb_get_phy_dev(struct device *dev, u8 index)
+{
+        return NULL;
+}
+
+static inline struct usb_phy *devm_usb_get_phy_by_phandle(struct device *dev,
+        const char *phandle, u8 index)
+{
+        return NULL;
+}
+
 static inline void usb_put_phy(struct usb_phy *x)
 {
 }
@@ -171,6 +209,11 @@ static inline void devm_usb_put_phy(struct device *dev, struct usb_phy *x)
 {
 }
 
+static inline int usb_bind_phy(const char *dev_name, u8 index,
+                                const char *phy_dev_name)
+{
+        return -EOPNOTSUPP;
+}
 #endif
 
 static inline int
diff --git a/include/linux/usb/samsung_usb_phy.h b/include/linux/usb/samsung_usb_phy.h
new file mode 100644
index 000000000000..916782699f1c
--- /dev/null
+++ b/include/linux/usb/samsung_usb_phy.h
@@ -0,0 +1,16 @@
+/*
+ * Copyright (C) 2012 Samsung Electronics Co.Ltd
+ *              http://www.samsung.com/
+ *
+ * Defines phy types for samsung usb phy controllers - HOST or DEIVCE.
+ *
+ * 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.
+ */
+
+enum samsung_usb_phy_type {
+        USB_PHY_TYPE_DEVICE,
+        USB_PHY_TYPE_HOST,
+};
diff --git a/include/linux/usb/tegra_usb_phy.h b/include/linux/usb/tegra_usb_phy.h
index 176b1ca06ae4..9ebebe906925 100644
--- a/include/linux/usb/tegra_usb_phy.h
+++ b/include/linux/usb/tegra_usb_phy.h
@@ -59,22 +59,24 @@ struct tegra_usb_phy {
         struct usb_phy *ulpi;
         struct usb_phy u_phy;
         struct device *dev;
+        bool is_legacy_phy;
+        bool is_ulpi_phy;
 };
 
 struct tegra_usb_phy *tegra_usb_phy_open(struct device *dev, int instance,
         void __iomem *regs, void *config, enum tegra_usb_phy_mode phy_mode);
 
-void tegra_usb_phy_clk_disable(struct tegra_usb_phy *phy);
+void tegra_usb_phy_preresume(struct usb_phy *phy);
 
-void tegra_usb_phy_clk_enable(struct tegra_usb_phy *phy);
+void tegra_usb_phy_postresume(struct usb_phy *phy);
 
-void tegra_usb_phy_preresume(struct tegra_usb_phy *phy);
+void tegra_ehci_phy_restore_start(struct usb_phy *phy,
+                                 enum tegra_usb_phy_port_speed port_speed);
 
-void tegra_usb_phy_postresume(struct tegra_usb_phy *phy);
+void tegra_ehci_phy_restore_end(struct usb_phy *phy);
 
-void tegra_ehci_phy_restore_start(struct tegra_usb_phy *phy,
-                                 enum tegra_usb_phy_port_speed port_speed);
+void tegra_ehci_set_pts(struct usb_phy *x, u8 pts_val);
 
-void tegra_ehci_phy_restore_end(struct tegra_usb_phy *phy);
+void tegra_ehci_set_phcd(struct usb_phy *x, bool enable);
 
 #endif /* __TEGRA_USB_PHY_H */
diff --git a/include/linux/user_namespace.h b/include/linux/user_namespace.h
index b9bd2e6c73cc..4ce009324933 100644
--- a/include/linux/user_namespace.h
+++ b/include/linux/user_namespace.h
@@ -21,7 +21,7 @@ struct user_namespace {
         struct uid_gid_map      uid_map;
         struct uid_gid_map      gid_map;
         struct uid_gid_map      projid_map;
-        struct kref             kref;
+        atomic_t                count;
         struct user_namespace   *parent;
         kuid_t                  owner;
         kgid_t                  group;
@@ -35,18 +35,18 @@ extern struct user_namespace init_user_ns;
 static inline struct user_namespace *get_user_ns(struct user_namespace *ns)
 {
         if (ns)
-                kref_get(&ns->kref);
+                atomic_inc(&ns->count);
         return ns;
 }
 
 extern int create_user_ns(struct cred *new);
 extern int unshare_userns(unsigned long unshare_flags, struct cred **new_cred);
-extern void free_user_ns(struct kref *kref);
+extern void free_user_ns(struct user_namespace *ns);
 
 static inline void put_user_ns(struct user_namespace *ns)
 {
-        if (ns)
-                kref_put(&ns->kref, free_user_ns);
+        if (ns && atomic_dec_and_test(&ns->count))
+                free_user_ns(ns);
 }
 
 struct seq_operations;
diff --git a/include/linux/vexpress.h b/include/linux/vexpress.h
index c52215ff4245..75818744ab59 100644
--- a/include/linux/vexpress.h
+++ b/include/linux/vexpress.h
@@ -27,6 +27,14 @@
 #define VEXPRESS_GPIO_MMC_CARDIN        0
 #define VEXPRESS_GPIO_MMC_WPROT         1
 #define VEXPRESS_GPIO_FLASH_WPn         2
+#define VEXPRESS_GPIO_LED0              3
+#define VEXPRESS_GPIO_LED1              4
+#define VEXPRESS_GPIO_LED2              5
+#define VEXPRESS_GPIO_LED3              6
+#define VEXPRESS_GPIO_LED4              7
+#define VEXPRESS_GPIO_LED5              8
+#define VEXPRESS_GPIO_LED6              9
+#define VEXPRESS_GPIO_LED7              10
 
 #define VEXPRESS_RES_FUNC(_site, _func) \
 {                                       \
diff --git a/include/linux/vm_event_item.h b/include/linux/vm_event_item.h
index fce0a2799d43..bd6cf61142be 100644
--- a/include/linux/vm_event_item.h
+++ b/include/linux/vm_event_item.h
@@ -36,7 +36,6 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
 #endif
                 PGINODESTEAL, SLABS_SCANNED, KSWAPD_INODESTEAL,
                 KSWAPD_LOW_WMARK_HIT_QUICKLY, KSWAPD_HIGH_WMARK_HIT_QUICKLY,
-                KSWAPD_SKIP_CONGESTION_WAIT,
                 PAGEOUTRUN, ALLOCSTALL, PGROTATED,
 #ifdef CONFIG_NUMA_BALANCING
                 NUMA_PTE_UPDATES,
diff --git a/include/linux/vmstat.h b/include/linux/vmstat.h
index a13291f7da88..5fd71a7d0dfd 100644
--- a/include/linux/vmstat.h
+++ b/include/linux/vmstat.h
@@ -85,7 +85,7 @@ static inline void vm_events_fold_cpu(int cpu)
 #define count_vm_numa_events(x, y) count_vm_events(x, y)
 #else
 #define count_vm_numa_event(x) do {} while (0)
-#define count_vm_numa_events(x, y) do {} while (0)
+#define count_vm_numa_events(x, y) do { (void)(y); } while (0)
 #endif /* CONFIG_NUMA_BALANCING */
 
 #define __count_zone_vm_events(item, zone, delta) \
diff --git a/include/linux/vmw_vmci_api.h b/include/linux/vmw_vmci_api.h
new file mode 100644
index 000000000000..023430e265fe
--- /dev/null
+++ b/include/linux/vmw_vmci_api.h
@@ -0,0 +1,82 @@
+/*
+ * VMware VMCI Driver
+ *
+ * Copyright (C) 2012 VMware, Inc. 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 version 2 and no 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 __VMW_VMCI_API_H__
+#define __VMW_VMCI_API_H__
+
+#include <linux/uidgid.h>
+#include <linux/vmw_vmci_defs.h>
+
+#undef  VMCI_KERNEL_API_VERSION
+#define VMCI_KERNEL_API_VERSION_1 1
+#define VMCI_KERNEL_API_VERSION_2 2
+#define VMCI_KERNEL_API_VERSION   VMCI_KERNEL_API_VERSION_2
+
+typedef void (vmci_device_shutdown_fn) (void *device_registration,
+                                        void *user_data);
+
+int vmci_datagram_create_handle(u32 resource_id, u32 flags,
+                                vmci_datagram_recv_cb recv_cb,
+                                void *client_data,
+                                struct vmci_handle *out_handle);
+int vmci_datagram_create_handle_priv(u32 resource_id, u32 flags, u32 priv_flags,
+                                     vmci_datagram_recv_cb recv_cb,
+                                     void *client_data,
+                                     struct vmci_handle *out_handle);
+int vmci_datagram_destroy_handle(struct vmci_handle handle);
+int vmci_datagram_send(struct vmci_datagram *msg);
+int vmci_doorbell_create(struct vmci_handle *handle, u32 flags,
+                         u32 priv_flags,
+                         vmci_callback notify_cb, void *client_data);
+int vmci_doorbell_destroy(struct vmci_handle handle);
+int vmci_doorbell_notify(struct vmci_handle handle, u32 priv_flags);
+u32 vmci_get_context_id(void);
+bool vmci_is_context_owner(u32 context_id, kuid_t uid);
+
+int vmci_event_subscribe(u32 event,
+                         vmci_event_cb callback, void *callback_data,
+                         u32 *subid);
+int vmci_event_unsubscribe(u32 subid);
+u32 vmci_context_get_priv_flags(u32 context_id);
+int vmci_qpair_alloc(struct vmci_qp **qpair,
+                     struct vmci_handle *handle,
+                     u64 produce_qsize,
+                     u64 consume_qsize,
+                     u32 peer, u32 flags, u32 priv_flags);
+int vmci_qpair_detach(struct vmci_qp **qpair);
+int vmci_qpair_get_produce_indexes(const struct vmci_qp *qpair,
+                                   u64 *producer_tail,
+                                   u64 *consumer_head);
+int vmci_qpair_get_consume_indexes(const struct vmci_qp *qpair,
+                                   u64 *consumer_tail,
+                                   u64 *producer_head);
+s64 vmci_qpair_produce_free_space(const struct vmci_qp *qpair);
+s64 vmci_qpair_produce_buf_ready(const struct vmci_qp *qpair);
+s64 vmci_qpair_consume_free_space(const struct vmci_qp *qpair);
+s64 vmci_qpair_consume_buf_ready(const struct vmci_qp *qpair);
+ssize_t vmci_qpair_enqueue(struct vmci_qp *qpair,
+                           const void *buf, size_t buf_size, int mode);
+ssize_t vmci_qpair_dequeue(struct vmci_qp *qpair,
+                           void *buf, size_t buf_size, int mode);
+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);
+ssize_t vmci_qpair_dequev(struct vmci_qp *qpair,
+                          void *iov, size_t iov_size, int mode);
+ssize_t vmci_qpair_peekv(struct vmci_qp *qpair, void *iov, size_t iov_size,
+                         int mode);
+
+#endif /* !__VMW_VMCI_API_H__ */
diff --git a/include/linux/vmw_vmci_defs.h b/include/linux/vmw_vmci_defs.h
new file mode 100644
index 000000000000..65ac54c61c18
--- /dev/null
+++ b/include/linux/vmw_vmci_defs.h
@@ -0,0 +1,880 @@
+/*
+ * VMware VMCI Driver
+ *
+ * Copyright (C) 2012 VMware, Inc. 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 version 2 and no 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 _VMW_VMCI_DEF_H_
+#define _VMW_VMCI_DEF_H_
+
+#include <linux/atomic.h>
+
+/* Register offsets. */
+#define VMCI_STATUS_ADDR      0x00
+#define VMCI_CONTROL_ADDR     0x04
+#define VMCI_ICR_ADDR         0x08
+#define VMCI_IMR_ADDR         0x0c
+#define VMCI_DATA_OUT_ADDR    0x10
+#define VMCI_DATA_IN_ADDR     0x14
+#define VMCI_CAPS_ADDR        0x18
+#define VMCI_RESULT_LOW_ADDR  0x1c
+#define VMCI_RESULT_HIGH_ADDR 0x20
+
+/* Max number of devices. */
+#define VMCI_MAX_DEVICES 1
+
+/* Status register bits. */
+#define VMCI_STATUS_INT_ON     0x1
+
+/* Control register bits. */
+#define VMCI_CONTROL_RESET        0x1
+#define VMCI_CONTROL_INT_ENABLE   0x2
+#define VMCI_CONTROL_INT_DISABLE  0x4
+
+/* Capabilities register bits. */
+#define VMCI_CAPS_HYPERCALL     0x1
+#define VMCI_CAPS_GUESTCALL     0x2
+#define VMCI_CAPS_DATAGRAM      0x4
+#define VMCI_CAPS_NOTIFICATIONS 0x8
+
+/* Interrupt Cause register bits. */
+#define VMCI_ICR_DATAGRAM      0x1
+#define VMCI_ICR_NOTIFICATION  0x2
+
+/* Interrupt Mask register bits. */
+#define VMCI_IMR_DATAGRAM      0x1
+#define VMCI_IMR_NOTIFICATION  0x2
+
+/* Interrupt type. */
+enum {
+        VMCI_INTR_TYPE_INTX = 0,
+        VMCI_INTR_TYPE_MSI = 1,
+        VMCI_INTR_TYPE_MSIX = 2,
+};
+
+/* Maximum MSI/MSI-X interrupt vectors in the device. */
+#define VMCI_MAX_INTRS 2
+
+/*
+ * Supported interrupt vectors.  There is one for each ICR value above,
+ * but here they indicate the position in the vector array/message ID.
+ */
+enum {
+        VMCI_INTR_DATAGRAM = 0,
+        VMCI_INTR_NOTIFICATION = 1,
+};
+
+/*
+ * A single VMCI device has an upper limit of 128MB on the amount of
+ * memory that can be used for queue pairs.
+ */
+#define VMCI_MAX_GUEST_QP_MEMORY (128 * 1024 * 1024)
+
+/*
+ * Queues with pre-mapped data pages must be small, so that we don't pin
+ * too much kernel memory (especially on vmkernel).  We limit a queuepair to
+ * 32 KB, or 16 KB per queue for symmetrical pairs.
+ */
+#define VMCI_MAX_PINNED_QP_MEMORY (32 * 1024)
+
+/*
+ * We have a fixed set of resource IDs available in the VMX.
+ * This allows us to have a very simple implementation since we statically
+ * know how many will create datagram handles. If a new caller arrives and
+ * we have run out of slots we can manually increment the maximum size of
+ * available resource IDs.
+ *
+ * VMCI reserved hypervisor datagram resource IDs.
+ */
+enum {
+        VMCI_RESOURCES_QUERY = 0,
+        VMCI_GET_CONTEXT_ID = 1,
+        VMCI_SET_NOTIFY_BITMAP = 2,
+        VMCI_DOORBELL_LINK = 3,
+        VMCI_DOORBELL_UNLINK = 4,
+        VMCI_DOORBELL_NOTIFY = 5,
+        /*
+         * VMCI_DATAGRAM_REQUEST_MAP and VMCI_DATAGRAM_REMOVE_MAP are
+         * obsoleted by the removal of VM to VM communication.
+         */
+        VMCI_DATAGRAM_REQUEST_MAP = 6,
+        VMCI_DATAGRAM_REMOVE_MAP = 7,
+        VMCI_EVENT_SUBSCRIBE = 8,
+        VMCI_EVENT_UNSUBSCRIBE = 9,
+        VMCI_QUEUEPAIR_ALLOC = 10,
+        VMCI_QUEUEPAIR_DETACH = 11,
+
+        /*
+         * VMCI_VSOCK_VMX_LOOKUP was assigned to 12 for Fusion 3.0/3.1,
+         * WS 7.0/7.1 and ESX 4.1
+         */
+        VMCI_HGFS_TRANSPORT = 13,
+        VMCI_UNITY_PBRPC_REGISTER = 14,
+        VMCI_RPC_PRIVILEGED = 15,
+        VMCI_RPC_UNPRIVILEGED = 16,
+        VMCI_RESOURCE_MAX = 17,
+};
+
+/*
+ * struct vmci_handle - Ownership information structure
+ * @context:    The VMX context ID.
+ * @resource:   The resource ID (used for locating in resource hash).
+ *
+ * The vmci_handle structure is used to track resources used within
+ * vmw_vmci.
+ */
+struct vmci_handle {
+        u32 context;
+        u32 resource;
+};
+
+#define vmci_make_handle(_cid, _rid) \
+        (struct vmci_handle){ .context = _cid, .resource = _rid }
+
+static inline bool vmci_handle_is_equal(struct vmci_handle h1,
+                                        struct vmci_handle h2)
+{
+        return h1.context == h2.context && h1.resource == h2.resource;
+}
+
+#define VMCI_INVALID_ID ~0
+static const struct vmci_handle VMCI_INVALID_HANDLE = {
+        .context = VMCI_INVALID_ID,
+        .resource = VMCI_INVALID_ID
+};
+
+static inline bool vmci_handle_is_invalid(struct vmci_handle h)
+{
+        return vmci_handle_is_equal(h, VMCI_INVALID_HANDLE);
+}
+
+/*
+ * The below defines can be used to send anonymous requests.
+ * This also indicates that no response is expected.
+ */
+#define VMCI_ANON_SRC_CONTEXT_ID   VMCI_INVALID_ID
+#define VMCI_ANON_SRC_RESOURCE_ID  VMCI_INVALID_ID
+static const struct vmci_handle VMCI_ANON_SRC_HANDLE = {
+        .context = VMCI_ANON_SRC_CONTEXT_ID,
+        .resource = VMCI_ANON_SRC_RESOURCE_ID
+};
+
+/* The lowest 16 context ids are reserved for internal use. */
+#define VMCI_RESERVED_CID_LIMIT ((u32) 16)
+
+/*
+ * Hypervisor context id, used for calling into hypervisor
+ * supplied services from the VM.
+ */
+#define VMCI_HYPERVISOR_CONTEXT_ID 0
+
+/*
+ * Well-known context id, a logical context that contains a set of
+ * well-known services. This context ID is now obsolete.
+ */
+#define VMCI_WELL_KNOWN_CONTEXT_ID 1
+
+/*
+ * Context ID used by host endpoints.
+ */
+#define VMCI_HOST_CONTEXT_ID  2
+
+#define VMCI_CONTEXT_IS_VM(_cid) (VMCI_INVALID_ID != (_cid) &&          \
+                                  (_cid) > VMCI_HOST_CONTEXT_ID)
+
+/*
+ * The VMCI_CONTEXT_RESOURCE_ID is used together with vmci_make_handle to make
+ * handles that refer to a specific context.
+ */
+#define VMCI_CONTEXT_RESOURCE_ID 0
+
+/*
+ * VMCI error codes.
+ */
+enum {
+        VMCI_SUCCESS_QUEUEPAIR_ATTACH   = 5,
+        VMCI_SUCCESS_QUEUEPAIR_CREATE   = 4,
+        VMCI_SUCCESS_LAST_DETACH        = 3,
+        VMCI_SUCCESS_ACCESS_GRANTED     = 2,
+        VMCI_SUCCESS_ENTRY_DEAD         = 1,
+        VMCI_SUCCESS                     = 0,
+        VMCI_ERROR_INVALID_RESOURCE      = (-1),
+        VMCI_ERROR_INVALID_ARGS          = (-2),
+        VMCI_ERROR_NO_MEM                = (-3),
+        VMCI_ERROR_DATAGRAM_FAILED       = (-4),
+        VMCI_ERROR_MORE_DATA             = (-5),
+        VMCI_ERROR_NO_MORE_DATAGRAMS     = (-6),
+        VMCI_ERROR_NO_ACCESS             = (-7),
+        VMCI_ERROR_NO_HANDLE             = (-8),
+        VMCI_ERROR_DUPLICATE_ENTRY       = (-9),
+        VMCI_ERROR_DST_UNREACHABLE       = (-10),
+        VMCI_ERROR_PAYLOAD_TOO_LARGE     = (-11),
+        VMCI_ERROR_INVALID_PRIV          = (-12),
+        VMCI_ERROR_GENERIC               = (-13),
+        VMCI_ERROR_PAGE_ALREADY_SHARED   = (-14),
+        VMCI_ERROR_CANNOT_SHARE_PAGE     = (-15),
+        VMCI_ERROR_CANNOT_UNSHARE_PAGE   = (-16),
+        VMCI_ERROR_NO_PROCESS            = (-17),
+        VMCI_ERROR_NO_DATAGRAM           = (-18),
+        VMCI_ERROR_NO_RESOURCES          = (-19),
+        VMCI_ERROR_UNAVAILABLE           = (-20),
+        VMCI_ERROR_NOT_FOUND             = (-21),
+        VMCI_ERROR_ALREADY_EXISTS        = (-22),
+        VMCI_ERROR_NOT_PAGE_ALIGNED      = (-23),
+        VMCI_ERROR_INVALID_SIZE          = (-24),
+        VMCI_ERROR_REGION_ALREADY_SHARED = (-25),
+        VMCI_ERROR_TIMEOUT               = (-26),
+        VMCI_ERROR_DATAGRAM_INCOMPLETE   = (-27),
+        VMCI_ERROR_INCORRECT_IRQL        = (-28),
+        VMCI_ERROR_EVENT_UNKNOWN         = (-29),
+        VMCI_ERROR_OBSOLETE              = (-30),
+        VMCI_ERROR_QUEUEPAIR_MISMATCH    = (-31),
+        VMCI_ERROR_QUEUEPAIR_NOTSET      = (-32),
+        VMCI_ERROR_QUEUEPAIR_NOTOWNER    = (-33),
+        VMCI_ERROR_QUEUEPAIR_NOTATTACHED = (-34),
+        VMCI_ERROR_QUEUEPAIR_NOSPACE     = (-35),
+        VMCI_ERROR_QUEUEPAIR_NODATA      = (-36),
+        VMCI_ERROR_BUSMEM_INVALIDATION   = (-37),
+        VMCI_ERROR_MODULE_NOT_LOADED     = (-38),
+        VMCI_ERROR_DEVICE_NOT_FOUND      = (-39),
+        VMCI_ERROR_QUEUEPAIR_NOT_READY   = (-40),
+        VMCI_ERROR_WOULD_BLOCK           = (-41),
+
+        /* VMCI clients should return error code within this range */
+        VMCI_ERROR_CLIENT_MIN            = (-500),
+        VMCI_ERROR_CLIENT_MAX            = (-550),
+
+        /* Internal error codes. */
+        VMCI_SHAREDMEM_ERROR_BAD_CONTEXT = (-1000),
+};
+
+/* VMCI reserved events. */
+enum {
+        /* Only applicable to guest endpoints */
+        VMCI_EVENT_CTX_ID_UPDATE  = 0,
+
+        /* Applicable to guest and host */
+        VMCI_EVENT_CTX_REMOVED    = 1,
+
+        /* Only applicable to guest endpoints */
+        VMCI_EVENT_QP_RESUMED     = 2,
+
+        /* Applicable to guest and host */
+        VMCI_EVENT_QP_PEER_ATTACH = 3,
+
+        /* Applicable to guest and host */
+        VMCI_EVENT_QP_PEER_DETACH = 4,
+
+        /*
+         * Applicable to VMX and vmk.  On vmk,
+         * this event has the Context payload type.
+         */
+        VMCI_EVENT_MEM_ACCESS_ON  = 5,
+
+        /*
+         * Applicable to VMX and vmk.  Same as
+         * above for the payload type.
+         */
+        VMCI_EVENT_MEM_ACCESS_OFF = 6,
+        VMCI_EVENT_MAX            = 7,
+};
+
+/*
+ * Of the above events, a few are reserved for use in the VMX, and
+ * other endpoints (guest and host kernel) should not use them. For
+ * the rest of the events, we allow both host and guest endpoints to
+ * subscribe to them, to maintain the same API for host and guest
+ * endpoints.
+ */
+#define VMCI_EVENT_VALID_VMX(_event) ((_event) == VMCI_EVENT_MEM_ACCESS_ON || \
+                                      (_event) == VMCI_EVENT_MEM_ACCESS_OFF)
+
+#define VMCI_EVENT_VALID(_event) ((_event) < VMCI_EVENT_MAX &&          \
+                                  !VMCI_EVENT_VALID_VMX(_event))
+
+/* Reserved guest datagram resource ids. */
+#define VMCI_EVENT_HANDLER 0
+
+/*
+ * VMCI coarse-grained privileges (per context or host
+ * process/endpoint. An entity with the restricted flag is only
+ * allowed to interact with the hypervisor and trusted entities.
+ */
+enum {
+        VMCI_NO_PRIVILEGE_FLAGS = 0,
+        VMCI_PRIVILEGE_FLAG_RESTRICTED = 1,
+        VMCI_PRIVILEGE_FLAG_TRUSTED = 2,
+        VMCI_PRIVILEGE_ALL_FLAGS = (VMCI_PRIVILEGE_FLAG_RESTRICTED |
+                                    VMCI_PRIVILEGE_FLAG_TRUSTED),
+        VMCI_DEFAULT_PROC_PRIVILEGE_FLAGS = VMCI_NO_PRIVILEGE_FLAGS,
+        VMCI_LEAST_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_RESTRICTED,
+        VMCI_MAX_PRIVILEGE_FLAGS = VMCI_PRIVILEGE_FLAG_TRUSTED,
+};
+
+/* 0 through VMCI_RESERVED_RESOURCE_ID_MAX are reserved. */
+#define VMCI_RESERVED_RESOURCE_ID_MAX 1023
+
+/*
+ * Driver version.
+ *
+ * Increment major version when you make an incompatible change.
+ * Compatibility goes both ways (old driver with new executable
+ * as well as new driver with old executable).
+ */
+
+/* Never change VMCI_VERSION_SHIFT_WIDTH */
+#define VMCI_VERSION_SHIFT_WIDTH 16
+#define VMCI_MAKE_VERSION(_major, _minor)                       \
+        ((_major) << VMCI_VERSION_SHIFT_WIDTH | (u16) (_minor))
+
+#define VMCI_VERSION_MAJOR(v)  ((u32) (v) >> VMCI_VERSION_SHIFT_WIDTH)
+#define VMCI_VERSION_MINOR(v)  ((u16) (v))
+
+/*
+ * VMCI_VERSION is always the current version.  Subsequently listed
+ * versions are ways of detecting previous versions of the connecting
+ * application (i.e., VMX).
+ *
+ * VMCI_VERSION_NOVMVM: This version removed support for VM to VM
+ * communication.
+ *
+ * VMCI_VERSION_NOTIFY: This version introduced doorbell notification
+ * support.
+ *
+ * VMCI_VERSION_HOSTQP: This version introduced host end point support
+ * for hosted products.
+ *
+ * VMCI_VERSION_PREHOSTQP: This is the version prior to the adoption of
+ * support for host end-points.
+ *
+ * VMCI_VERSION_PREVERS2: This fictional version number is intended to
+ * represent the version of a VMX which doesn't call into the driver
+ * with ioctl VERSION2 and thus doesn't establish its version with the
+ * driver.
+ */
+
+#define VMCI_VERSION                VMCI_VERSION_NOVMVM
+#define VMCI_VERSION_NOVMVM         VMCI_MAKE_VERSION(11, 0)
+#define VMCI_VERSION_NOTIFY         VMCI_MAKE_VERSION(10, 0)
+#define VMCI_VERSION_HOSTQP         VMCI_MAKE_VERSION(9, 0)
+#define VMCI_VERSION_PREHOSTQP      VMCI_MAKE_VERSION(8, 0)
+#define VMCI_VERSION_PREVERS2       VMCI_MAKE_VERSION(1, 0)
+
+#define VMCI_SOCKETS_MAKE_VERSION(_p)                                   \
+        ((((_p)[0] & 0xFF) << 24) | (((_p)[1] & 0xFF) << 16) | ((_p)[2]))
+
+/*
+ * The VMCI IOCTLs.  We use identity code 7, as noted in ioctl-number.h, and
+ * we start at sequence 9f.  This gives us the same values that our shipping
+ * products use, starting at 1951, provided we leave out the direction and
+ * structure size.  Note that VMMon occupies the block following us, starting
+ * at 2001.
+ */
+#define IOCTL_VMCI_VERSION                      _IO(7, 0x9f)    /* 1951 */
+#define IOCTL_VMCI_INIT_CONTEXT                 _IO(7, 0xa0)
+#define IOCTL_VMCI_QUEUEPAIR_SETVA              _IO(7, 0xa4)
+#define IOCTL_VMCI_NOTIFY_RESOURCE              _IO(7, 0xa5)
+#define IOCTL_VMCI_NOTIFICATIONS_RECEIVE        _IO(7, 0xa6)
+#define IOCTL_VMCI_VERSION2                     _IO(7, 0xa7)
+#define IOCTL_VMCI_QUEUEPAIR_ALLOC              _IO(7, 0xa8)
+#define IOCTL_VMCI_QUEUEPAIR_SETPAGEFILE        _IO(7, 0xa9)
+#define IOCTL_VMCI_QUEUEPAIR_DETACH             _IO(7, 0xaa)
+#define IOCTL_VMCI_DATAGRAM_SEND                _IO(7, 0xab)
+#define IOCTL_VMCI_DATAGRAM_RECEIVE             _IO(7, 0xac)
+#define IOCTL_VMCI_CTX_ADD_NOTIFICATION         _IO(7, 0xaf)
+#define IOCTL_VMCI_CTX_REMOVE_NOTIFICATION      _IO(7, 0xb0)
+#define IOCTL_VMCI_CTX_GET_CPT_STATE            _IO(7, 0xb1)
+#define IOCTL_VMCI_CTX_SET_CPT_STATE            _IO(7, 0xb2)
+#define IOCTL_VMCI_GET_CONTEXT_ID               _IO(7, 0xb3)
+#define IOCTL_VMCI_SOCKETS_VERSION              _IO(7, 0xb4)
+#define IOCTL_VMCI_SOCKETS_GET_AF_VALUE         _IO(7, 0xb8)
+#define IOCTL_VMCI_SOCKETS_GET_LOCAL_CID        _IO(7, 0xb9)
+#define IOCTL_VMCI_SET_NOTIFY                   _IO(7, 0xcb)    /* 1995 */
+/*IOCTL_VMMON_START                             _IO(7, 0xd1)*/  /* 2001 */
+
+/*
+ * struct vmci_queue_header - VMCI Queue Header information.
+ *
+ * A Queue cannot stand by itself as designed.  Each Queue's header
+ * contains a pointer into itself (the producer_tail) and into its peer
+ * (consumer_head).  The reason for the separation is one of
+ * accessibility: Each end-point can modify two things: where the next
+ * location to enqueue is within its produce_q (producer_tail); and
+ * where the next dequeue location is in its consume_q (consumer_head).
+ *
+ * An end-point cannot modify the pointers of its peer (guest to
+ * guest; NOTE that in the host both queue headers are mapped r/w).
+ * But, each end-point needs read access to both Queue header
+ * structures in order to determine how much space is used (or left)
+ * in the Queue.  This is because for an end-point to know how full
+ * its produce_q is, it needs to use the consumer_head that points into
+ * the produce_q but -that- consumer_head is in the Queue header for
+ * that end-points consume_q.
+ *
+ * Thoroughly confused?  Sorry.
+ *
+ * producer_tail: the point to enqueue new entrants.  When you approach
+ * a line in a store, for example, you walk up to the tail.
+ *
+ * consumer_head: the point in the queue from which the next element is
+ * dequeued.  In other words, who is next in line is he who is at the
+ * head of the line.
+ *
+ * Also, producer_tail points to an empty byte in the Queue, whereas
+ * consumer_head points to a valid byte of data (unless producer_tail ==
+ * consumer_head in which case consumer_head does not point to a valid
+ * byte of data).
+ *
+ * For a queue of buffer 'size' bytes, the tail and head pointers will be in
+ * the range [0, size-1].
+ *
+ * If produce_q_header->producer_tail == consume_q_header->consumer_head
+ * then the produce_q is empty.
+ */
+struct vmci_queue_header {
+        /* All fields are 64bit and aligned. */
+        struct vmci_handle handle;      /* Identifier. */
+        atomic64_t producer_tail;       /* Offset in this queue. */
+        atomic64_t consumer_head;       /* Offset in peer queue. */
+};
+
+/*
+ * struct vmci_datagram - Base struct for vmci datagrams.
+ * @dst:        A vmci_handle that tracks the destination of the datagram.
+ * @src:        A vmci_handle that tracks the source of the datagram.
+ * @payload_size:       The size of the payload.
+ *
+ * vmci_datagram structs are used when sending vmci datagrams.  They include
+ * the necessary source and destination information to properly route
+ * the information along with the size of the package.
+ */
+struct vmci_datagram {
+        struct vmci_handle dst;
+        struct vmci_handle src;
+        u64 payload_size;
+};
+
+/*
+ * Second flag is for creating a well-known handle instead of a per context
+ * handle.  Next flag is for deferring datagram delivery, so that the
+ * datagram callback is invoked in a delayed context (not interrupt context).
+ */
+#define VMCI_FLAG_DG_NONE          0
+#define VMCI_FLAG_WELLKNOWN_DG_HND 0x1
+#define VMCI_FLAG_ANYCID_DG_HND    0x2
+#define VMCI_FLAG_DG_DELAYED_CB    0x4
+
+/*
+ * Maximum supported size of a VMCI datagram for routable datagrams.
+ * Datagrams going to the hypervisor are allowed to be larger.
+ */
+#define VMCI_MAX_DG_SIZE (17 * 4096)
+#define VMCI_MAX_DG_PAYLOAD_SIZE (VMCI_MAX_DG_SIZE - \
+                                  sizeof(struct vmci_datagram))
+#define VMCI_DG_PAYLOAD(_dg) (void *)((char *)(_dg) +                   \
+                                      sizeof(struct vmci_datagram))
+#define VMCI_DG_HEADERSIZE sizeof(struct vmci_datagram)
+#define VMCI_DG_SIZE(_dg) (VMCI_DG_HEADERSIZE + (size_t)(_dg)->payload_size)
+#define VMCI_DG_SIZE_ALIGNED(_dg) ((VMCI_DG_SIZE(_dg) + 7) & (~((size_t) 0x7)))
+#define VMCI_MAX_DATAGRAM_QUEUE_SIZE (VMCI_MAX_DG_SIZE * 2)
+
+struct vmci_event_payload_qp {
+        struct vmci_handle handle;  /* queue_pair handle. */
+        u32 peer_id;                /* Context id of attaching/detaching VM. */
+        u32 _pad;
+};
+
+/* Flags for VMCI queue_pair API. */
+enum {
+        /* Fail alloc if QP not created by peer. */
+        VMCI_QPFLAG_ATTACH_ONLY = 1 << 0,
+
+        /* Only allow attaches from local context. */
+        VMCI_QPFLAG_LOCAL = 1 << 1,
+
+        /* Host won't block when guest is quiesced. */
+        VMCI_QPFLAG_NONBLOCK = 1 << 2,
+
+        /* Pin data pages in ESX.  Used with NONBLOCK */
+        VMCI_QPFLAG_PINNED = 1 << 3,
+
+        /* Update the following flag when adding new flags. */
+        VMCI_QP_ALL_FLAGS = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QPFLAG_LOCAL |
+                             VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED),
+
+        /* Convenience flags */
+        VMCI_QP_ASYMM = (VMCI_QPFLAG_NONBLOCK | VMCI_QPFLAG_PINNED),
+        VMCI_QP_ASYMM_PEER = (VMCI_QPFLAG_ATTACH_ONLY | VMCI_QP_ASYMM),
+};
+
+/*
+ * We allow at least 1024 more event datagrams from the hypervisor past the
+ * normally allowed datagrams pending for a given context.  We define this
+ * limit on event datagrams from the hypervisor to guard against DoS attack
+ * from a malicious VM which could repeatedly attach to and detach from a queue
+ * pair, causing events to be queued at the destination VM.  However, the rate
+ * at which such events can be generated is small since it requires a VM exit
+ * and handling of queue pair attach/detach call at the hypervisor.  Event
+ * datagrams may be queued up at the destination VM if it has interrupts
+ * disabled or if it is not draining events for some other reason.  1024
+ * datagrams is a grossly conservative estimate of the time for which
+ * interrupts may be disabled in the destination VM, but at the same time does
+ * not exacerbate the memory pressure problem on the host by much (size of each
+ * event datagram is small).
+ */
+#define VMCI_MAX_DATAGRAM_AND_EVENT_QUEUE_SIZE                          \
+        (VMCI_MAX_DATAGRAM_QUEUE_SIZE +                                 \
+         1024 * (sizeof(struct vmci_datagram) +                         \
+                 sizeof(struct vmci_event_data_max)))
+
+/*
+ * Struct used for querying, via VMCI_RESOURCES_QUERY, the availability of
+ * hypervisor resources.  Struct size is 16 bytes. All fields in struct are
+ * aligned to their natural alignment.
+ */
+struct vmci_resource_query_hdr {
+        struct vmci_datagram hdr;
+        u32 num_resources;
+        u32 _padding;
+};
+
+/*
+ * Convenience struct for negotiating vectors. Must match layout of
+ * VMCIResourceQueryHdr minus the struct vmci_datagram header.
+ */
+struct vmci_resource_query_msg {
+        u32 num_resources;
+        u32 _padding;
+        u32 resources[1];
+};
+
+/*
+ * The maximum number of resources that can be queried using
+ * VMCI_RESOURCE_QUERY is 31, as the result is encoded in the lower 31
+ * bits of a positive return value. Negative values are reserved for
+ * errors.
+ */
+#define VMCI_RESOURCE_QUERY_MAX_NUM 31
+
+/* Maximum size for the VMCI_RESOURCE_QUERY request. */
+#define VMCI_RESOURCE_QUERY_MAX_SIZE                            \
+        (sizeof(struct vmci_resource_query_hdr) +               \
+         sizeof(u32) * VMCI_RESOURCE_QUERY_MAX_NUM)
+
+/*
+ * Struct used for setting the notification bitmap.  All fields in
+ * struct are aligned to their natural alignment.
+ */
+struct vmci_notify_bm_set_msg {
+        struct vmci_datagram hdr;
+        u32 bitmap_ppn;
+        u32 _pad;
+};
+
+/*
+ * Struct used for linking a doorbell handle with an index in the
+ * notify bitmap. All fields in struct are aligned to their natural
+ * alignment.
+ */
+struct vmci_doorbell_link_msg {
+        struct vmci_datagram hdr;
+        struct vmci_handle handle;
+        u64 notify_idx;
+};
+
+/*
+ * Struct used for unlinking a doorbell handle from an index in the
+ * notify bitmap. All fields in struct are aligned to their natural
+ * alignment.
+ */
+struct vmci_doorbell_unlink_msg {
+        struct vmci_datagram hdr;
+        struct vmci_handle handle;
+};
+
+/*
+ * Struct used for generating a notification on a doorbell handle. All
+ * fields in struct are aligned to their natural alignment.
+ */
+struct vmci_doorbell_notify_msg {
+        struct vmci_datagram hdr;
+        struct vmci_handle handle;
+};
+
+/*
+ * This struct is used to contain data for events.  Size of this struct is a
+ * multiple of 8 bytes, and all fields are aligned to their natural alignment.
+ */
+struct vmci_event_data {
+        u32 event;              /* 4 bytes. */
+        u32 _pad;
+        /* Event payload is put here. */
+};
+
+/*
+ * Define the different VMCI_EVENT payload data types here.  All structs must
+ * be a multiple of 8 bytes, and fields must be aligned to their natural
+ * alignment.
+ */
+struct vmci_event_payld_ctx {
+        u32 context_id; /* 4 bytes. */
+        u32 _pad;
+};
+
+struct vmci_event_payld_qp {
+        struct vmci_handle handle;  /* queue_pair handle. */
+        u32 peer_id;        /* Context id of attaching/detaching VM. */
+        u32 _pad;
+};
+
+/*
+ * We define the following struct to get the size of the maximum event
+ * data the hypervisor may send to the guest.  If adding a new event
+ * payload type above, add it to the following struct too (inside the
+ * union).
+ */
+struct vmci_event_data_max {
+        struct vmci_event_data event_data;
+        union {
+                struct vmci_event_payld_ctx context_payload;
+                struct vmci_event_payld_qp qp_payload;
+        } ev_data_payload;
+};
+
+/*
+ * Struct used for VMCI_EVENT_SUBSCRIBE/UNSUBSCRIBE and
+ * VMCI_EVENT_HANDLER messages.  Struct size is 32 bytes.  All fields
+ * in struct are aligned to their natural alignment.
+ */
+struct vmci_event_msg {
+        struct vmci_datagram hdr;
+
+        /* Has event type and payload. */
+        struct vmci_event_data event_data;
+
+        /* Payload gets put here. */
+};
+
+/* Event with context payload. */
+struct vmci_event_ctx {
+        struct vmci_event_msg msg;
+        struct vmci_event_payld_ctx payload;
+};
+
+/* Event with QP payload. */
+struct vmci_event_qp {
+        struct vmci_event_msg msg;
+        struct vmci_event_payld_qp payload;
+};
+
+/*
+ * Structs used for queue_pair alloc and detach messages.  We align fields of
+ * these structs to 64bit boundaries.
+ */
+struct vmci_qp_alloc_msg {
+        struct vmci_datagram hdr;
+        struct vmci_handle handle;
+        u32 peer;
+        u32 flags;
+        u64 produce_size;
+        u64 consume_size;
+        u64 num_ppns;
+
+        /* List of PPNs placed here. */
+};
+
+struct vmci_qp_detach_msg {
+        struct vmci_datagram hdr;
+        struct vmci_handle handle;
+};
+
+/* VMCI Doorbell API. */
+#define VMCI_FLAG_DELAYED_CB 0x01
+
+typedef void (*vmci_callback) (void *client_data);
+
+/*
+ * struct vmci_qp - A vmw_vmci queue pair handle.
+ *
+ * This structure is used as a handle to a queue pair created by
+ * VMCI.  It is intentionally left opaque to clients.
+ */
+struct vmci_qp;
+
+/* Callback needed for correctly waiting on events. */
+typedef int (*vmci_datagram_recv_cb) (void *client_data,
+                                      struct vmci_datagram *msg);
+
+/* VMCI Event API. */
+typedef void (*vmci_event_cb) (u32 sub_id, const struct vmci_event_data *ed,
+                               void *client_data);
+
+/*
+ * We use the following inline function to access the payload data
+ * associated with an event data.
+ */
+static inline const void *
+vmci_event_data_const_payload(const struct vmci_event_data *ev_data)
+{
+        return (const char *)ev_data + sizeof(*ev_data);
+}
+
+static inline void *vmci_event_data_payload(struct vmci_event_data *ev_data)
+{
+        return (void *)vmci_event_data_const_payload(ev_data);
+}
+
+/*
+ * Helper to add a given offset to a head or tail pointer. Wraps the
+ * value of the pointer around the max size of the queue.
+ */
+static inline void vmci_qp_add_pointer(atomic64_t *var,
+                                       size_t add,
+                                       u64 size)
+{
+        u64 new_val = atomic64_read(var);
+
+        if (new_val >= size - add)
+                new_val -= size;
+
+        new_val += add;
+
+        atomic64_set(var, new_val);
+}
+
+/*
+ * Helper routine to get the Producer Tail from the supplied queue.
+ */
+static inline u64
+vmci_q_header_producer_tail(const struct vmci_queue_header *q_header)
+{
+        struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header;
+        return atomic64_read(&qh->producer_tail);
+}
+
+/*
+ * Helper routine to get the Consumer Head from the supplied queue.
+ */
+static inline u64
+vmci_q_header_consumer_head(const struct vmci_queue_header *q_header)
+{
+        struct vmci_queue_header *qh = (struct vmci_queue_header *)q_header;
+        return atomic64_read(&qh->consumer_head);
+}
+
+/*
+ * Helper routine to increment the Producer Tail.  Fundamentally,
+ * vmci_qp_add_pointer() is used to manipulate the tail itself.
+ */
+static inline void
+vmci_q_header_add_producer_tail(struct vmci_queue_header *q_header,
+                                size_t add,
+                                u64 queue_size)
+{
+        vmci_qp_add_pointer(&q_header->producer_tail, add, queue_size);
+}
+
+/*
+ * Helper routine to increment the Consumer Head.  Fundamentally,
+ * vmci_qp_add_pointer() is used to manipulate the head itself.
+ */
+static inline void
+vmci_q_header_add_consumer_head(struct vmci_queue_header *q_header,
+                                size_t add,
+                                u64 queue_size)
+{
+        vmci_qp_add_pointer(&q_header->consumer_head, add, queue_size);
+}
+
+/*
+ * Helper routine for getting the head and the tail pointer for a queue.
+ * Both the VMCIQueues are needed to get both the pointers for one queue.
+ */
+static inline void
+vmci_q_header_get_pointers(const struct vmci_queue_header *produce_q_header,
+                           const struct vmci_queue_header *consume_q_header,
+                           u64 *producer_tail,
+                           u64 *consumer_head)
+{
+        if (producer_tail)
+                *producer_tail = vmci_q_header_producer_tail(produce_q_header);
+
+        if (consumer_head)
+                *consumer_head = vmci_q_header_consumer_head(consume_q_header);
+}
+
+static inline void vmci_q_header_init(struct vmci_queue_header *q_header,
+                                      const struct vmci_handle handle)
+{
+        q_header->handle = handle;
+        atomic64_set(&q_header->producer_tail, 0);
+        atomic64_set(&q_header->consumer_head, 0);
+}
+
+/*
+ * Finds available free space in a produce queue to enqueue more
+ * data or reports an error if queue pair corruption is detected.
+ */
+static s64
+vmci_q_header_free_space(const struct vmci_queue_header *produce_q_header,
+                         const struct vmci_queue_header *consume_q_header,
+                         const u64 produce_q_size)
+{
+        u64 tail;
+        u64 head;
+        u64 free_space;
+
+        tail = vmci_q_header_producer_tail(produce_q_header);
+        head = vmci_q_header_consumer_head(consume_q_header);
+
+        if (tail >= produce_q_size || head >= produce_q_size)
+                return VMCI_ERROR_INVALID_SIZE;
+
+        /*
+         * Deduct 1 to avoid tail becoming equal to head which causes
+         * ambiguity. If head and tail are equal it means that the
+         * queue is empty.
+         */
+        if (tail >= head)
+                free_space = produce_q_size - (tail - head) - 1;
+        else
+                free_space = head - tail - 1;
+
+        return free_space;
+}
+
+/*
+ * vmci_q_header_free_space() does all the heavy lifting of
+ * determing the number of free bytes in a Queue.  This routine,
+ * then subtracts that size from the full size of the Queue so
+ * the caller knows how many bytes are ready to be dequeued.
+ * Results:
+ * On success, available data size in bytes (up to MAX_INT64).
+ * On failure, appropriate error code.
+ */
+static inline s64
+vmci_q_header_buf_ready(const struct vmci_queue_header *consume_q_header,
+                        const struct vmci_queue_header *produce_q_header,
+                        const u64 consume_q_size)
+{
+        s64 free_space;
+
+        free_space = vmci_q_header_free_space(consume_q_header,
+                                              produce_q_header, consume_q_size);
+        if (free_space < VMCI_SUCCESS)
+                return free_space;
+
+        return consume_q_size - free_space - 1;
+}
+
+
+#endif /* _VMW_VMCI_DEF_H_ */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 50ae7d0c279e..e8d65718560b 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -47,6 +47,7 @@ int con_set_cmap(unsigned char __user *cmap);
 int con_get_cmap(unsigned char __user *cmap);
 void scrollback(struct vc_data *vc, int lines);
 void scrollfront(struct vc_data *vc, int lines);
+void clear_buffer_attributes(struct vc_data *vc);
 void update_region(struct vc_data *vc, unsigned long start, int count);
 void redraw_screen(struct vc_data *vc, int is_switch);
 #define update_screen(x) redraw_screen(x, 0)
@@ -130,6 +131,8 @@ void vt_event_post(unsigned int event, unsigned int old, unsigned int new);
 int vt_waitactive(int n);
 void change_console(struct vc_data *new_vc);
 void reset_vc(struct vc_data *vc);
+extern int do_unbind_con_driver(const struct consw *csw, int first, int last,
+                             int deflt);
 extern int unbind_con_driver(const struct consw *csw, int first, int last,
                              int deflt);
 int vty_init(const struct file_operations *console_fops);
diff --git a/include/linux/vtime.h b/include/linux/vtime.h
index ae30ab58431a..71a5782d8c59 100644
--- a/include/linux/vtime.h
+++ b/include/linux/vtime.h
@@ -6,15 +6,46 @@ struct task_struct;
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING
 extern void vtime_task_switch(struct task_struct *prev);
 extern void vtime_account_system(struct task_struct *tsk);
-extern void vtime_account_system_irqsafe(struct task_struct *tsk);
 extern void vtime_account_idle(struct task_struct *tsk);
 extern void vtime_account_user(struct task_struct *tsk);
-extern void vtime_account(struct task_struct *tsk);
-#else
+extern void vtime_account_irq_enter(struct task_struct *tsk);
+
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_NATIVE
+static inline bool vtime_accounting_enabled(void) { return true; }
+#endif
+
+#else /* !CONFIG_VIRT_CPU_ACCOUNTING */
+
 static inline void vtime_task_switch(struct task_struct *prev) { }
 static inline void vtime_account_system(struct task_struct *tsk) { }
-static inline void vtime_account_system_irqsafe(struct task_struct *tsk) { }
-static inline void vtime_account(struct task_struct *tsk) { }
+static inline void vtime_account_user(struct task_struct *tsk) { }
+static inline void vtime_account_irq_enter(struct task_struct *tsk) { }
+static inline bool vtime_accounting_enabled(void) { return false; }
+#endif
+
+#ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
+extern void arch_vtime_task_switch(struct task_struct *tsk);
+extern void vtime_account_irq_exit(struct task_struct *tsk);
+extern bool vtime_accounting_enabled(void);
+extern void vtime_user_enter(struct task_struct *tsk);
+static inline void vtime_user_exit(struct task_struct *tsk)
+{
+        vtime_account_user(tsk);
+}
+extern void vtime_guest_enter(struct task_struct *tsk);
+extern void vtime_guest_exit(struct task_struct *tsk);
+extern void vtime_init_idle(struct task_struct *tsk);
+#else
+static inline void vtime_account_irq_exit(struct task_struct *tsk)
+{
+        /* On hard|softirq exit we always account to hard|softirq cputime */
+        vtime_account_system(tsk);
+}
+static inline void vtime_user_enter(struct task_struct *tsk) { }
+static inline void vtime_user_exit(struct task_struct *tsk) { }
+static inline void vtime_guest_enter(struct task_struct *tsk) { }
+static inline void vtime_guest_exit(struct task_struct *tsk) { }
+static inline void vtime_init_idle(struct task_struct *tsk) { }
 #endif
 
 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
@@ -23,25 +54,15 @@ extern void irqtime_account_irq(struct task_struct *tsk);
 static inline void irqtime_account_irq(struct task_struct *tsk) { }
 #endif
 
-static inline void vtime_account_irq_enter(struct task_struct *tsk)
+static inline void account_irq_enter_time(struct task_struct *tsk)
 {
-        /*
-         * Hardirq can interrupt idle task anytime. So we need vtime_account()
-         * that performs the idle check in CONFIG_VIRT_CPU_ACCOUNTING.
-         * Softirq can also interrupt idle task directly if it calls
-         * local_bh_enable(). Such case probably don't exist but we never know.
-         * Ksoftirqd is not concerned because idle time is flushed on context
-         * switch. Softirqs in the end of hardirqs are also not a problem because
-         * the idle time is flushed on hardirq time already.
-         */
-        vtime_account(tsk);
+        vtime_account_irq_enter(tsk);
         irqtime_account_irq(tsk);
 }
 
-static inline void vtime_account_irq_exit(struct task_struct *tsk)
+static inline void account_irq_exit_time(struct task_struct *tsk)
 {
-        /* On hard|softirq exit we always account to hard|softirq cputime */
-        vtime_account_system(tsk);
+        vtime_account_irq_exit(tsk);
         irqtime_account_irq(tsk);
 }
 
diff --git a/include/linux/wanrouter.h b/include/linux/wanrouter.h
index cec4b4159767..8198a63cf459 100644
--- a/include/linux/wanrouter.h
+++ b/include/linux/wanrouter.h
@@ -1,129 +1,10 @@
-/*****************************************************************************
-* wanrouter.h   Definitions for the WAN Multiprotocol Router Module.
-*               This module provides API and common services for WAN Link
-*               Drivers and is completely hardware-independent.
-*
-* Author:       Nenad Corbic <ncorbic@sangoma.com>
-*               Gideon Hack     
-* Additions:    Arnaldo Melo
-*
-* Copyright:    (c) 1995-2000 Sangoma Technologies Inc.
-*
-*               This program is free software; you can redistribute it and/or
-*               modify it under the terms of the GNU General Public License
-*               as published by the Free Software Foundation; either version
-*               2 of the License, or (at your option) any later version.
-* ============================================================================
-* Jul 21, 2000  Nenad Corbic    Added WAN_FT1_READY State
-* Feb 24, 2000  Nenad Corbic    Added support for socket based x25api
-* Jan 28, 2000  Nenad Corbic    Added support for the ASYNC protocol.
-* Oct 04, 1999  Nenad Corbic    Updated for 2.1.0 release
-* Jun 02, 1999  Gideon Hack     Added support for the S514 adapter.
-* May 23, 1999  Arnaldo Melo    Added local_addr to wanif_conf_t
-*                               WAN_DISCONNECTING state added
-* Jul 20, 1998  David Fong      Added Inverse ARP options to 'wanif_conf_t'
-* Jun 12, 1998  David Fong      Added Cisco HDLC support.
-* Dec 16, 1997  Jaspreet Singh  Moved 'enable_IPX' and 'network_number' to
-*                               'wanif_conf_t'
-* Dec 05, 1997  Jaspreet Singh  Added 'pap', 'chap' to 'wanif_conf_t'
-*                               Added 'authenticator' to 'wan_ppp_conf_t'
-* Nov 06, 1997  Jaspreet Singh  Changed Router Driver version to 1.1 from 1.0
-* Oct 20, 1997  Jaspreet Singh  Added 'cir','bc','be' and 'mc' to 'wanif_conf_t'
-*                               Added 'enable_IPX' and 'network_number' to 
-*                               'wan_device_t'.  Also added defines for
-*                               UDP PACKET TYPE, Interrupt test, critical values
-*                               for RACE conditions.
-* Oct 05, 1997  Jaspreet Singh  Added 'dlci_num' and 'dlci[100]' to 
-*                               'wan_fr_conf_t' to configure a list of dlci(s)
-*                               for a NODE 
-* Jul 07, 1997  Jaspreet Singh  Added 'ttl' to 'wandev_conf_t' & 'wan_device_t'
-* May 29, 1997  Jaspreet Singh  Added 'tx_int_enabled' to 'wan_device_t'
-* May 21, 1997  Jaspreet Singh  Added 'udp_port' to 'wan_device_t'
-* Apr 25, 1997  Farhan Thawar   Added 'udp_port' to 'wandev_conf_t'
-* Jan 16, 1997  Gene Kozin      router_devlist made public
-* Jan 02, 1997  Gene Kozin      Initial version (based on wanpipe.h).
-*****************************************************************************/
+/*
+ * wanrouter.h  Legacy declarations kept around until X25 is removed
+ */
+
 #ifndef _ROUTER_H
 #define _ROUTER_H
 
 #include <uapi/linux/wanrouter.h>
 
-/****** Kernel Interface ****************************************************/
-
-#include <linux/fs.h>           /* support for device drivers */
-#include <linux/proc_fs.h>      /* proc filesystem pragmatics */
-#include <linux/netdevice.h>    /* support for network drivers */
-#include <linux/spinlock.h>     /* Support for SMP Locking */
-
-/*----------------------------------------------------------------------------
- * WAN device data space.
- */
-struct wan_device {
-        unsigned magic;                 /* magic number */
-        char* name;                     /* -> WAN device name (ASCIIZ) */
-        void* private;                  /* -> driver private data */
-        unsigned config_id;             /* Configuration ID */
-                                        /****** hardware configuration ******/
-        unsigned ioport;                /* adapter I/O port base #1 */
-        char S514_cpu_no[1];            /* PCI CPU Number */
-        unsigned char S514_slot_no;     /* PCI Slot Number */
-        unsigned long maddr;            /* dual-port memory address */
-        unsigned msize;                 /* dual-port memory size */
-        int irq;                        /* interrupt request level */
-        int dma;                        /* DMA request level */
-        unsigned bps;                   /* data transfer rate */
-        unsigned mtu;                   /* max physical transmit unit size */
-        unsigned udp_port;              /* UDP port for management */
-        unsigned char ttl;              /* Time To Live for UDP security */
-        unsigned enable_tx_int;         /* Transmit Interrupt enabled or not */
-        char interface;                 /* RS-232/V.35, etc. */
-        char clocking;                  /* external/internal */
-        char line_coding;               /* NRZ/NRZI/FM0/FM1, etc. */
-        char station;                   /* DTE/DCE, primary/secondary, etc. */
-        char connection;                /* permanent/switched/on-demand */
-        char signalling;                /* Signalling RS232 or V35 */
-        char read_mode;                 /* read mode: Polling or interrupt */
-        char new_if_cnt;                /* Number of interfaces per wanpipe */ 
-        char del_if_cnt;                /* Number of times del_if() gets called */
-        unsigned char piggyback;        /* Piggibacking a port */
-        unsigned hw_opt[4];             /* other hardware options */
-                                        /****** status and statistics *******/
-        char state;                     /* device state */
-        char api_status;                /* device api status */
-        struct net_device_stats stats;  /* interface statistics */
-        unsigned reserved[16];          /* reserved for future use */
-        unsigned long critical;         /* critical section flag */
-        spinlock_t lock;                /* Support for SMP Locking */
-
-                                        /****** device management methods ***/
-        int (*setup) (struct wan_device *wandev, wandev_conf_t *conf);
-        int (*shutdown) (struct wan_device *wandev);
-        int (*update) (struct wan_device *wandev);
-        int (*ioctl) (struct wan_device *wandev, unsigned cmd,
-                unsigned long arg);
-        int (*new_if)(struct wan_device *wandev, struct net_device *dev,
-                      wanif_conf_t *conf);
-        int (*del_if)(struct wan_device *wandev, struct net_device *dev);
-                                        /****** maintained by the router ****/
-        struct wan_device* next;        /* -> next device */
-        struct net_device* dev;         /* list of network interfaces */
-        unsigned ndev;                  /* number of interfaces */
-        struct proc_dir_entry *dent;    /* proc filesystem entry */
-};
-
-/* Public functions available for device drivers */
-extern int register_wan_device(struct wan_device *wandev);
-extern int unregister_wan_device(char *name);
-
-/* Proc interface functions. These must not be called by the drivers! */
-extern int wanrouter_proc_init(void);
-extern void wanrouter_proc_cleanup(void);
-extern int wanrouter_proc_add(struct wan_device *wandev);
-extern int wanrouter_proc_delete(struct wan_device *wandev);
-extern long wanrouter_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
-
-/* Public Data */
-/* list of registered devices */
-extern struct wan_device *wanrouter_router_devlist;
-
 #endif  /* _ROUTER_H */
diff --git a/include/linux/wl12xx.h b/include/linux/wl12xx.h
index 0d6373195d32..a54fe82e704b 100644
--- a/include/linux/wl12xx.h
+++ b/include/linux/wl12xx.h
@@ -24,6 +24,8 @@
 #ifndef _LINUX_WL12XX_H
 #define _LINUX_WL12XX_H
 
+#include <linux/err.h>
+
 /* Reference clock values */
 enum {
         WL12XX_REFCLOCK_19      = 0, /* 19.2 MHz */
@@ -55,17 +57,17 @@ struct wl12xx_platform_data {
         int board_tcxo_clock;
         unsigned long platform_quirks;
         bool pwr_in_suspend;
-
-        struct wl1271_if_operations *ops;
 };
 
 /* Platform does not support level trigger interrupts */
 #define WL12XX_PLATFORM_QUIRK_EDGE_IRQ  BIT(0)
 
-#ifdef CONFIG_WL12XX_PLATFORM_DATA
+#ifdef CONFIG_WILINK_PLATFORM_DATA
 
 int wl12xx_set_platform_data(const struct wl12xx_platform_data *data);
 
+struct wl12xx_platform_data *wl12xx_get_platform_data(void);
+
 #else
 
 static inline
@@ -74,8 +76,12 @@ int wl12xx_set_platform_data(const struct wl12xx_platform_data *data)
         return -ENOSYS;
 }
 
-#endif
+static inline
+struct wl12xx_platform_data *wl12xx_get_platform_data(void)
+{
+        return ERR_PTR(-ENODATA);
+}
 
-struct wl12xx_platform_data *wl12xx_get_platform_data(void);
+#endif
 
 #endif
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 2b58905d3504..8afab27cdbc2 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -27,7 +27,7 @@ void delayed_work_timer_fn(unsigned long __data);
 enum {
         WORK_STRUCT_PENDING_BIT = 0,    /* work item is pending execution */
         WORK_STRUCT_DELAYED_BIT = 1,    /* work item is delayed */
-        WORK_STRUCT_CWQ_BIT     = 2,    /* data points to cwq */
+        WORK_STRUCT_PWQ_BIT     = 2,    /* data points to pwq */
         WORK_STRUCT_LINKED_BIT  = 3,    /* next work is linked to this one */
 #ifdef CONFIG_DEBUG_OBJECTS_WORK
         WORK_STRUCT_STATIC_BIT  = 4,    /* static initializer (debugobjects) */
@@ -40,7 +40,7 @@ enum {
 
         WORK_STRUCT_PENDING     = 1 << WORK_STRUCT_PENDING_BIT,
         WORK_STRUCT_DELAYED     = 1 << WORK_STRUCT_DELAYED_BIT,
-        WORK_STRUCT_CWQ         = 1 << WORK_STRUCT_CWQ_BIT,
+        WORK_STRUCT_PWQ         = 1 << WORK_STRUCT_PWQ_BIT,
         WORK_STRUCT_LINKED      = 1 << WORK_STRUCT_LINKED_BIT,
 #ifdef CONFIG_DEBUG_OBJECTS_WORK
         WORK_STRUCT_STATIC      = 1 << WORK_STRUCT_STATIC_BIT,
@@ -57,29 +57,36 @@ enum {
 
         /* special cpu IDs */
         WORK_CPU_UNBOUND        = NR_CPUS,
-        WORK_CPU_NONE           = NR_CPUS + 1,
-        WORK_CPU_LAST           = WORK_CPU_NONE,
+        WORK_CPU_END            = NR_CPUS + 1,
 
         /*
-         * Reserve 7 bits off of cwq pointer w/ debugobjects turned
-         * off.  This makes cwqs aligned to 256 bytes and allows 15
-         * workqueue flush colors.
+         * Reserve 7 bits off of pwq pointer w/ debugobjects turned off.
+         * This makes pwqs aligned to 256 bytes and allows 15 workqueue
+         * flush colors.
          */
         WORK_STRUCT_FLAG_BITS   = WORK_STRUCT_COLOR_SHIFT +
                                   WORK_STRUCT_COLOR_BITS,
 
-        /* data contains off-queue information when !WORK_STRUCT_CWQ */
+        /* data contains off-queue information when !WORK_STRUCT_PWQ */
         WORK_OFFQ_FLAG_BASE     = WORK_STRUCT_FLAG_BITS,
 
         WORK_OFFQ_CANCELING     = (1 << WORK_OFFQ_FLAG_BASE),
 
+        /*
+         * When a work item is off queue, its high bits point to the last
+         * pool it was on.  Cap at 31 bits and use the highest number to
+         * indicate that no pool is associated.
+         */
         WORK_OFFQ_FLAG_BITS     = 1,
-        WORK_OFFQ_CPU_SHIFT     = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,
+        WORK_OFFQ_POOL_SHIFT    = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,
+        WORK_OFFQ_LEFT          = BITS_PER_LONG - WORK_OFFQ_POOL_SHIFT,
+        WORK_OFFQ_POOL_BITS     = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31,
+        WORK_OFFQ_POOL_NONE     = (1LU << WORK_OFFQ_POOL_BITS) - 1,
 
         /* convenience constants */
         WORK_STRUCT_FLAG_MASK   = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
         WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
-        WORK_STRUCT_NO_CPU      = (unsigned long)WORK_CPU_NONE << WORK_OFFQ_CPU_SHIFT,
+        WORK_STRUCT_NO_POOL     = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,
 
         /* bit mask for work_busy() return values */
         WORK_BUSY_PENDING       = 1 << 0,
@@ -95,13 +102,16 @@ struct work_struct {
 #endif
 };
 
-#define WORK_DATA_INIT()        ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU)
+#define WORK_DATA_INIT()        ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL)
 #define WORK_DATA_STATIC_INIT() \
-        ATOMIC_LONG_INIT(WORK_STRUCT_NO_CPU | WORK_STRUCT_STATIC)
+        ATOMIC_LONG_INIT(WORK_STRUCT_NO_POOL | WORK_STRUCT_STATIC)
 
 struct delayed_work {
         struct work_struct work;
         struct timer_list timer;
+
+        /* target workqueue and CPU ->timer uses to queue ->work */
+        struct workqueue_struct *wq;
         int cpu;
 };
 
@@ -426,7 +436,6 @@ extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
 extern void workqueue_set_max_active(struct workqueue_struct *wq,
                                      int max_active);
 extern bool workqueue_congested(unsigned int cpu, struct workqueue_struct *wq);
-extern unsigned int work_cpu(struct work_struct *work);
 extern unsigned int work_busy(struct work_struct *work);
 
 /*