165 files changed, 4668 insertions, 758 deletions

diff --git a/include/acpi/acconfig.h b/include/acpi/acconfig.h
index 03f14856bd09..0943457e0fa5 100644
--- a/include/acpi/acconfig.h
+++ b/include/acpi/acconfig.h
@@ -241,6 +241,7 @@
  *****************************************************************************/
 
 #define ACPI_DEBUGGER_MAX_ARGS          8       /* Must be max method args + 1 */
+#define ACPI_DB_LINE_BUFFER_SIZE        512
 
 #define ACPI_DEBUGGER_COMMAND_PROMPT    '-'
 #define ACPI_DEBUGGER_EXECUTE_PROMPT    '%'
diff --git a/include/acpi/acexcep.h b/include/acpi/acexcep.h
index 19503449814f..6c3890e02140 100644
--- a/include/acpi/acexcep.h
+++ b/include/acpi/acexcep.h
@@ -122,7 +122,7 @@
 #define AE_CODE_TBL_MAX                 0x0005
 
 /*
- * AML exceptions.  These are caused by problems with
+ * AML exceptions. These are caused by problems with
  * the actual AML byte stream
  */
 #define AE_AML_BAD_OPCODE               (acpi_status) (0x0001 | AE_CODE_AML)
diff --git a/include/acpi/acnames.h b/include/acpi/acnames.h
index 745dd24e3cb5..7665df663284 100644
--- a/include/acpi/acnames.h
+++ b/include/acpi/acnames.h
@@ -50,6 +50,7 @@
 #define METHOD_NAME__HID        "_HID"
 #define METHOD_NAME__CID        "_CID"
 #define METHOD_NAME__UID        "_UID"
+#define METHOD_NAME__SUB        "_SUB"
 #define METHOD_NAME__ADR        "_ADR"
 #define METHOD_NAME__INI        "_INI"
 #define METHOD_NAME__STA        "_STA"
diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 0daa0fbd8654..7ced5dc20dd3 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -144,12 +144,11 @@ struct acpi_device_flags {
         u32 bus_address:1;
         u32 removable:1;
         u32 ejectable:1;
-        u32 lockable:1;
         u32 suprise_removal_ok:1;
         u32 power_manageable:1;
         u32 performance_manageable:1;
         u32 eject_pending:1;
-        u32 reserved:23;
+        u32 reserved:24;
 };
 
 /* File System */
@@ -180,6 +179,7 @@ struct acpi_device_pnp {
         acpi_device_name device_name;   /* Driver-determined */
         acpi_device_class device_class; /*        "          */
         union acpi_object *str_obj;     /* unicode string for _STR method */
+        unsigned long sun;              /* _SUN */
 };
 
 #define acpi_device_bid(d)      ((d)->pnp.bus_id)
@@ -201,6 +201,7 @@ struct acpi_device_power_flags {
 struct acpi_device_power_state {
         struct {
                 u8 valid:1;
+                u8 os_accessible:1;
                 u8 explicit_set:1;      /* _PSx present? */
                 u8 reserved:6;
         } flags;
@@ -339,6 +340,7 @@ acpi_status acpi_bus_get_status_handle(acpi_handle handle,
                                        unsigned long long *sta);
 int acpi_bus_get_status(struct acpi_device *device);
 int acpi_bus_set_power(acpi_handle handle, int state);
+int acpi_device_set_power(struct acpi_device *device, int state);
 int acpi_bus_update_power(acpi_handle handle, int *state_p);
 bool acpi_bus_power_manageable(acpi_handle handle);
 bool acpi_bus_can_wakeup(acpi_handle handle);
@@ -410,36 +412,100 @@ acpi_handle acpi_get_child(acpi_handle, u64);
 int acpi_is_root_bridge(acpi_handle);
 acpi_handle acpi_get_pci_rootbridge_handle(unsigned int, unsigned int);
 struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
-#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)((dev)->archdata.acpi_handle))
+#define DEVICE_ACPI_HANDLE(dev) ((acpi_handle)ACPI_HANDLE(dev))
 
 int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
 int acpi_disable_wakeup_device_power(struct acpi_device *dev);
 
 #ifdef CONFIG_PM
+acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
+                                 acpi_notify_handler handler, void *context);
+acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
+                                    acpi_notify_handler handler);
+int acpi_device_power_state(struct device *dev, struct acpi_device *adev,
+                            u32 target_state, int d_max_in, int *d_min_p);
 int acpi_pm_device_sleep_state(struct device *, int *, int);
 #else
-static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
+static inline acpi_status acpi_add_pm_notifier(struct acpi_device *adev,
+                                               acpi_notify_handler handler,
+                                               void *context)
+{
+        return AE_SUPPORT;
+}
+static inline acpi_status acpi_remove_pm_notifier(struct acpi_device *adev,
+                                                  acpi_notify_handler handler)
+{
+        return AE_SUPPORT;
+}
+static inline int __acpi_device_power_state(int m, int *p)
 {
         if (p)
                 *p = ACPI_STATE_D0;
         return (m >= ACPI_STATE_D0 && m <= ACPI_STATE_D3) ? m : ACPI_STATE_D0;
 }
+static inline int acpi_device_power_state(struct device *dev,
+                                          struct acpi_device *adev,
+                                          u32 target_state, int d_max_in,
+                                          int *d_min_p)
+{
+        return __acpi_device_power_state(d_max_in, d_min_p);
+}
+static inline int acpi_pm_device_sleep_state(struct device *d, int *p, int m)
+{
+        return __acpi_device_power_state(m, p);
+}
 #endif
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_PM_RUNTIME
+int __acpi_device_run_wake(struct acpi_device *, bool);
 int acpi_pm_device_run_wake(struct device *, bool);
-int acpi_pm_device_sleep_wake(struct device *, bool);
 #else
+static inline int __acpi_device_run_wake(struct acpi_device *adev, bool en)
+{
+        return -ENODEV;
+}
 static inline int acpi_pm_device_run_wake(struct device *dev, bool enable)
 {
         return -ENODEV;
 }
+#endif
+
+#ifdef CONFIG_PM_SLEEP
+int __acpi_device_sleep_wake(struct acpi_device *, u32, bool);
+int acpi_pm_device_sleep_wake(struct device *, bool);
+#else
+static inline int __acpi_device_sleep_wake(struct acpi_device *adev,
+                                           u32 target_state, bool enable)
+{
+        return -ENODEV;
+}
 static inline int acpi_pm_device_sleep_wake(struct device *dev, bool enable)
 {
         return -ENODEV;
 }
 #endif
 
+#ifdef CONFIG_ACPI_SLEEP
+u32 acpi_target_system_state(void);
+#else
+static inline u32 acpi_target_system_state(void) { return ACPI_STATE_S0; }
+#endif
+
+static inline bool acpi_device_power_manageable(struct acpi_device *adev)
+{
+        return adev->flags.power_manageable;
+}
+
+static inline bool acpi_device_can_wakeup(struct acpi_device *adev)
+{
+        return adev->wakeup.flags.valid;
+}
+
+static inline bool acpi_device_can_poweroff(struct acpi_device *adev)
+{
+        return adev->power.states[ACPI_STATE_D3_COLD].flags.os_accessible;
+}
+
 #else   /* CONFIG_ACPI */
 
 static inline int register_acpi_bus_type(void *bus) { return 0; }
diff --git a/include/acpi/acpiosxf.h b/include/acpi/acpiosxf.h
index 1222ba93d80a..43152742b46f 100644
--- a/include/acpi/acpiosxf.h
+++ b/include/acpi/acpiosxf.h
@@ -1,7 +1,6 @@
-
 /******************************************************************************
  *
- * Name: acpiosxf.h - All interfaces to the OS Services Layer (OSL).  These
+ * Name: acpiosxf.h - All interfaces to the OS Services Layer (OSL). These
  *                    interfaces must be implemented by OSL to interface the
  *                    ACPI components to the host operating system.
  *
diff --git a/include/acpi/acpixf.h b/include/acpi/acpixf.h
index 8b891dbead66..3d88395d4d6f 100644
--- a/include/acpi/acpixf.h
+++ b/include/acpi/acpixf.h
@@ -1,4 +1,3 @@
-
 /******************************************************************************
  *
  * Name: acpixf.h - External interfaces to the ACPI subsystem
@@ -47,7 +46,7 @@
 
 /* Current ACPICA subsystem version in YYYYMMDD format */
 
-#define ACPI_CA_VERSION                 0x20120913
+#define ACPI_CA_VERSION                 0x20121018
 
 #include <acpi/acconfig.h>
 #include <acpi/actypes.h>
@@ -178,8 +177,7 @@ acpi_status acpi_unload_table_id(acpi_owner_id id);
 
 acpi_status
 acpi_get_table_header(acpi_string signature,
-                      u32 instance,
-                      struct acpi_table_header *out_table_header);
+                      u32 instance, struct acpi_table_header *out_table_header);
 
 acpi_status
 acpi_get_table_with_size(acpi_string signature,
@@ -190,8 +188,7 @@ acpi_get_table(acpi_string signature,
                u32 instance, struct acpi_table_header **out_table);
 
 acpi_status
-acpi_get_table_by_index(u32 table_index,
-                        struct acpi_table_header **out_table);
+acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table);
 
 acpi_status
 acpi_install_table_handler(acpi_tbl_handler handler, void *context);
@@ -274,7 +271,7 @@ acpi_install_initialization_handler(acpi_init_handler handler, u32 function);
 
 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
                                 acpi_install_global_event_handler
-                                (ACPI_GBL_EVENT_HANDLER handler, void *context))
+                                (acpi_gbl_event_handler handler, void *context))
 
 ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
                                  acpi_install_fixed_event_handler(u32
@@ -300,10 +297,9 @@ ACPI_HW_DEPENDENT_RETURN_STATUS(acpi_status
                                                          u32 gpe_number,
                                                          acpi_gpe_handler
                                                          address))
-acpi_status
-acpi_install_notify_handler(acpi_handle device,
-                            u32 handler_type,
-                            acpi_notify_handler handler, void *context);
+acpi_status acpi_install_notify_handler(acpi_handle device, u32 handler_type,
+                                        acpi_notify_handler handler,
+                                        void *context);
 
 acpi_status
 acpi_remove_notify_handler(acpi_handle device,
diff --git a/include/acpi/actbl3.h b/include/acpi/actbl3.h
index 8c61b5fe42a4..6585141e4b97 100644
--- a/include/acpi/actbl3.h
+++ b/include/acpi/actbl3.h
@@ -277,10 +277,10 @@ struct acpi_table_gtdt {
  ******************************************************************************/
 
 #define ACPI_MPST_CHANNEL_INFO \
-        u16                             reserved1; \
         u8                              channel_id; \
-        u8                              reserved2; \
-        u16                             power_node_count;
+        u8                              reserved1[3]; \
+        u16                             power_node_count; \
+        u16                             reserved2;
 
 /* Main table */
 
@@ -304,9 +304,8 @@ struct acpi_mpst_power_node {
         u32 length;
         u64 range_address;
         u64 range_length;
-        u8 num_power_states;
-        u8 num_physical_components;
-        u16 reserved2;
+        u32 num_power_states;
+        u32 num_physical_components;
 };
 
 /* Values for Flags field above */
@@ -332,10 +331,11 @@ struct acpi_mpst_component {
 
 struct acpi_mpst_data_hdr {
         u16 characteristics_count;
+        u16 reserved;
 };
 
 struct acpi_mpst_power_data {
-        u8 revision;
+        u8 structure_id;
         u8 flags;
         u16 reserved1;
         u32 average_power;
@@ -356,10 +356,10 @@ struct acpi_mpst_shared {
         u32 signature;
         u16 pcc_command;
         u16 pcc_status;
-        u16 command_register;
-        u16 status_register;
-        u16 power_state_id;
-        u16 power_node_id;
+        u32 command_register;
+        u32 status_register;
+        u32 power_state_id;
+        u32 power_node_id;
         u64 energy_consumed;
         u64 average_power;
 };
diff --git a/include/acpi/actypes.h b/include/acpi/actypes.h
index a85bae968262..4f43f1fba132 100644
--- a/include/acpi/actypes.h
+++ b/include/acpi/actypes.h
@@ -453,10 +453,14 @@ typedef u64 acpi_integer;
 #define ACPI_PHYSADDR_TO_PTR(i)         ACPI_TO_POINTER(i)
 #define ACPI_PTR_TO_PHYSADDR(i)         ACPI_TO_INTEGER(i)
 
+/* Optimizations for 4-character (32-bit) acpi_name manipulation */
+
 #ifndef ACPI_MISALIGNMENT_NOT_SUPPORTED
 #define ACPI_COMPARE_NAME(a,b)          (*ACPI_CAST_PTR (u32, (a)) == *ACPI_CAST_PTR (u32, (b)))
+#define ACPI_MOVE_NAME(dest,src)        (*ACPI_CAST_PTR (u32, (dest)) = *ACPI_CAST_PTR (u32, (src)))
 #else
 #define ACPI_COMPARE_NAME(a,b)          (!ACPI_STRNCMP (ACPI_CAST_PTR (char, (a)), ACPI_CAST_PTR (char, (b)), ACPI_NAME_SIZE))
+#define ACPI_MOVE_NAME(dest,src)        (ACPI_STRNCPY (ACPI_CAST_PTR (char, (dest)), ACPI_CAST_PTR (char, (src)), ACPI_NAME_SIZE))
 #endif
 
 /*******************************************************************************
@@ -796,11 +800,11 @@ typedef u8 acpi_adr_space_type;
 
 /* Sleep function dispatch */
 
-typedef acpi_status(*ACPI_SLEEP_FUNCTION) (u8 sleep_state);
+typedef acpi_status(*acpi_sleep_function) (u8 sleep_state);
 
 struct acpi_sleep_functions {
-        ACPI_SLEEP_FUNCTION legacy_function;
-        ACPI_SLEEP_FUNCTION extended_function;
+        acpi_sleep_function legacy_function;
+        acpi_sleep_function extended_function;
 };
 
 /*
@@ -922,7 +926,8 @@ struct acpi_system_info {
 /*
  * Types specific to the OS service interfaces
  */
-typedef u32(ACPI_SYSTEM_XFACE * acpi_osd_handler) (void *context);
+typedef u32
+ (ACPI_SYSTEM_XFACE * acpi_osd_handler) (void *context);
 
 typedef void
  (ACPI_SYSTEM_XFACE * acpi_osd_exec_callback) (void *context);
@@ -931,14 +936,15 @@ typedef void
  * Various handlers and callback procedures
  */
 typedef
-void (*ACPI_GBL_EVENT_HANDLER) (u32 event_type,
+void (*acpi_gbl_event_handler) (u32 event_type,
                                acpi_handle device,
                                u32 event_number, void *context);
 
 #define ACPI_EVENT_TYPE_GPE         0
 #define ACPI_EVENT_TYPE_FIXED       1
 
-typedef u32(*acpi_event_handler) (void *context);
+typedef
+u32(*acpi_event_handler) (void *context);
 
 typedef
 u32 (*acpi_gpe_handler) (acpi_handle gpe_device, u32 gpe_number, void *context);
@@ -1018,17 +1024,17 @@ u32 (*acpi_interface_handler) (acpi_string interface_name, u32 supported);
 
 #define ACPI_UUID_LENGTH                16
 
-/* Structures used for device/processor HID, UID, CID */
+/* Structures used for device/processor HID, UID, CID, and SUB */
 
-struct acpica_device_id {
+struct acpi_pnp_device_id {
         u32 length;             /* Length of string + null */
         char *string;
 };
 
-struct acpica_device_id_list {
+struct acpi_pnp_device_id_list {
         u32 count;              /* Number of IDs in Ids array */
         u32 list_size;          /* Size of list, including ID strings */
-        struct acpica_device_id ids[1]; /* ID array */
+        struct acpi_pnp_device_id ids[1];       /* ID array */
 };
 
 /*
@@ -1046,9 +1052,10 @@ struct acpi_device_info {
         u8 lowest_dstates[5];   /* _sx_w values: 0xFF indicates not valid */
         u32 current_status;     /* _STA value */
         u64 address;    /* _ADR value */
-        struct acpica_device_id hardware_id;    /* _HID value */
-        struct acpica_device_id unique_id;      /* _UID value */
-        struct acpica_device_id_list compatible_id_list;        /* _CID list <must be last> */
+        struct acpi_pnp_device_id hardware_id;  /* _HID value */
+        struct acpi_pnp_device_id unique_id;    /* _UID value */
+        struct acpi_pnp_device_id subsystem_id; /* _SUB value */
+        struct acpi_pnp_device_id_list compatible_id_list;      /* _CID list <must be last> */
 };
 
 /* Values for Flags field above (acpi_get_object_info) */
@@ -1061,11 +1068,12 @@ struct acpi_device_info {
 #define ACPI_VALID_ADR                  0x02
 #define ACPI_VALID_HID                  0x04
 #define ACPI_VALID_UID                  0x08
-#define ACPI_VALID_CID                  0x10
-#define ACPI_VALID_SXDS                 0x20
-#define ACPI_VALID_SXWS                 0x40
+#define ACPI_VALID_SUB                  0x10
+#define ACPI_VALID_CID                  0x20
+#define ACPI_VALID_SXDS                 0x40
+#define ACPI_VALID_SXWS                 0x80
 
-/* Flags for _STA method */
+/* Flags for _STA return value (current_status above) */
 
 #define ACPI_STA_DEVICE_PRESENT         0x01
 #define ACPI_STA_DEVICE_ENABLED         0x02
diff --git a/include/asm-generic/gpio.h b/include/asm-generic/gpio.h
index eb70ca295971..20ca7663975f 100644
--- a/include/asm-generic/gpio.h
+++ b/include/asm-generic/gpio.h
@@ -5,6 +5,7 @@
 #include <linux/types.h>
 #include <linux/errno.h>
 #include <linux/of.h>
+#include <linux/pinctrl/pinctrl.h>
 
 #ifdef CONFIG_GPIOLIB
 
@@ -137,6 +138,15 @@ struct gpio_chip {
         int (*of_xlate)(struct gpio_chip *gc,
                         const struct of_phandle_args *gpiospec, u32 *flags);
 #endif
+#ifdef CONFIG_PINCTRL
+        /*
+         * If CONFIG_PINCTRL is enabled, then gpio controllers can optionally
+         * describe the actual pin range which they serve in an SoC. This
+         * information would be used by pinctrl subsystem to configure
+         * corresponding pins for gpio usage.
+         */
+        struct list_head pin_ranges;
+#endif
 };
 
 extern const char *gpiochip_is_requested(struct gpio_chip *chip,
@@ -260,4 +270,41 @@ static inline void gpio_unexport(unsigned gpio)
 }
 #endif  /* CONFIG_GPIO_SYSFS */
 
+#ifdef CONFIG_PINCTRL
+
+/**
+ * struct gpio_pin_range - pin range controlled by a gpio chip
+ * @head: list for maintaining set of pin ranges, used internally
+ * @pctldev: pinctrl device which handles corresponding pins
+ * @range: actual range of pins controlled by a gpio controller
+ */
+
+struct gpio_pin_range {
+        struct list_head node;
+        struct pinctrl_dev *pctldev;
+        struct pinctrl_gpio_range range;
+};
+
+int gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
+                           unsigned int gpio_offset, unsigned int pin_offset,
+                           unsigned int npins);
+void gpiochip_remove_pin_ranges(struct gpio_chip *chip);
+
+#else
+
+static inline int
+gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
+                       unsigned int gpio_offset, unsigned int pin_offset,
+                       unsigned int npins)
+{
+        return 0;
+}
+
+static inline void
+gpiochip_remove_pin_ranges(struct gpio_chip *chip)
+{
+}
+
+#endif /* CONFIG_PINCTRL */
+
 #endif /* _ASM_GENERIC_GPIO_H */
diff --git a/include/asm-generic/trace_clock.h b/include/asm-generic/trace_clock.h
new file mode 100644
index 000000000000..6726f1bafb5e
--- /dev/null
+++ b/include/asm-generic/trace_clock.h
@@ -0,0 +1,16 @@
+#ifndef _ASM_GENERIC_TRACE_CLOCK_H
+#define _ASM_GENERIC_TRACE_CLOCK_H
+/*
+ * Arch-specific trace clocks.
+ */
+
+/*
+ * Additional trace clocks added to the trace_clocks
+ * array in kernel/trace/trace.c
+ * None if the architecture has not defined it.
+ */
+#ifndef ARCH_TRACE_CLOCKS
+# define ARCH_TRACE_CLOCKS
+#endif
+
+#endif  /* _ASM_GENERIC_TRACE_CLOCK_H */
diff --git a/include/drm/drm_pciids.h b/include/drm/drm_pciids.h
index af1cbaf535ed..c5c35e629426 100644
--- a/include/drm/drm_pciids.h
+++ b/include/drm/drm_pciids.h
@@ -210,6 +210,7 @@
         {0x1002, 0x6798, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x6799, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x679A, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
+        {0x1002, 0x679B, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x679E, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x679F, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_TAHITI|RADEON_NEW_MEMMAP}, \
         {0x1002, 0x6800, PCI_ANY_ID, PCI_ANY_ID, 0, 0, CHIP_PITCAIRN|RADEON_IS_MOBILITY|RADEON_NEW_MEMMAP}, \
diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 90be98981102..c33fa3ce9b7c 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -25,7 +25,9 @@
 #ifndef _LINUX_ACPI_H
 #define _LINUX_ACPI_H
 
+#include <linux/errno.h>
 #include <linux/ioport.h>       /* for struct resource */
+#include <linux/device.h>
 
 #ifdef  CONFIG_ACPI
 
@@ -250,6 +252,26 @@ extern int pnpacpi_disabled;
 
 #define PXM_INVAL       (-1)
 
+bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
+bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
+bool acpi_dev_resource_address_space(struct acpi_resource *ares,
+                                     struct resource *res);
+bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
+                                         struct resource *res);
+unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
+bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
+                                 struct resource *res);
+
+struct resource_list_entry {
+        struct list_head node;
+        struct resource res;
+};
+
+void acpi_dev_free_resource_list(struct list_head *list);
+int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
+                           int (*preproc)(struct acpi_resource *, void *),
+                           void *preproc_data);
+
 int acpi_check_resource_conflict(const struct resource *res);
 
 int acpi_check_region(resource_size_t start, resource_size_t n,
@@ -257,10 +279,14 @@ int acpi_check_region(resource_size_t start, resource_size_t n,
 
 int acpi_resources_are_enforced(void);
 
-#ifdef CONFIG_PM_SLEEP
+#ifdef CONFIG_HIBERNATION
 void __init acpi_no_s4_hw_signature(void);
+#endif
+
+#ifdef CONFIG_PM_SLEEP
 void __init acpi_old_suspend_ordering(void);
 void __init acpi_nvs_nosave(void);
+void __init acpi_nvs_nosave_s3(void);
 #endif /* CONFIG_PM_SLEEP */
 
 struct acpi_osc_context {
@@ -364,6 +390,17 @@ extern int acpi_nvs_register(__u64 start, __u64 size);
 extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
                                     void *data);
 
+const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
+                                               const struct device *dev);
+
+static inline bool acpi_driver_match_device(struct device *dev,
+                                            const struct device_driver *drv)
+{
+        return !!acpi_match_device(drv->acpi_match_table, dev);
+}
+
+#define ACPI_PTR(_ptr)  (_ptr)
+
 #else   /* !CONFIG_ACPI */
 
 #define acpi_disabled 1
@@ -418,6 +455,22 @@ static inline int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
         return 0;
 }
 
+struct acpi_device_id;
+
+static inline const struct acpi_device_id *acpi_match_device(
+        const struct acpi_device_id *ids, const struct device *dev)
+{
+        return NULL;
+}
+
+static inline bool acpi_driver_match_device(struct device *dev,
+                                            const struct device_driver *drv)
+{
+        return false;
+}
+
+#define ACPI_PTR(_ptr)  (NULL)
+
 #endif  /* !CONFIG_ACPI */
 
 #ifdef CONFIG_ACPI
@@ -430,4 +483,84 @@ acpi_status acpi_os_prepare_sleep(u8 sleep_state,
 #define acpi_os_set_prepare_sleep(func, pm1a_ctrl, pm1b_ctrl) do { } while (0)
 #endif
 
+#if defined(CONFIG_ACPI) && defined(CONFIG_PM_RUNTIME)
+int acpi_dev_runtime_suspend(struct device *dev);
+int acpi_dev_runtime_resume(struct device *dev);
+int acpi_subsys_runtime_suspend(struct device *dev);
+int acpi_subsys_runtime_resume(struct device *dev);
+#else
+static inline int acpi_dev_runtime_suspend(struct device *dev) { return 0; }
+static inline int acpi_dev_runtime_resume(struct device *dev) { return 0; }
+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
+int acpi_dev_suspend_late(struct device *dev);
+int acpi_dev_resume_early(struct device *dev);
+int acpi_subsys_prepare(struct device *dev);
+int acpi_subsys_suspend_late(struct device *dev);
+int acpi_subsys_resume_early(struct device *dev);
+#else
+static inline int acpi_dev_suspend_late(struct device *dev) { return 0; }
+static inline int acpi_dev_resume_early(struct device *dev) { return 0; }
+static inline int acpi_subsys_prepare(struct device *dev) { return 0; }
+static inline int acpi_subsys_suspend_late(struct device *dev) { return 0; }
+static inline int acpi_subsys_resume_early(struct device *dev) { return 0; }
+#endif
+
+#if defined(CONFIG_ACPI) && defined(CONFIG_PM)
+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 int acpi_dev_pm_attach(struct device *dev, bool power_on)
+{
+        return -ENODEV;
+}
+static inline void acpi_dev_pm_detach(struct device *dev, bool power_off) {}
+#endif
+
+#ifdef CONFIG_ACPI
+__printf(3, 4)
+void acpi_handle_printk(const char *level, acpi_handle handle,
+                        const char *fmt, ...);
+#else   /* !CONFIG_ACPI */
+static inline __printf(3, 4) void
+acpi_handle_printk(const char *level, void *handle, const char *fmt, ...) {}
+#endif  /* !CONFIG_ACPI */
+
+/*
+ * acpi_handle_<level>: Print message with ACPI prefix and object path
+ *
+ * These interfaces acquire the global namespace mutex to obtain an object
+ * path.  In interrupt context, it shows the object path as <n/a>.
+ */
+#define acpi_handle_emerg(handle, fmt, ...)                             \
+        acpi_handle_printk(KERN_EMERG, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_alert(handle, fmt, ...)                             \
+        acpi_handle_printk(KERN_ALERT, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_crit(handle, fmt, ...)                              \
+        acpi_handle_printk(KERN_CRIT, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_err(handle, fmt, ...)                               \
+        acpi_handle_printk(KERN_ERR, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_warn(handle, fmt, ...)                              \
+        acpi_handle_printk(KERN_WARNING, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_notice(handle, fmt, ...)                            \
+        acpi_handle_printk(KERN_NOTICE, handle, fmt, ##__VA_ARGS__)
+#define acpi_handle_info(handle, fmt, ...)                              \
+        acpi_handle_printk(KERN_INFO, handle, fmt, ##__VA_ARGS__)
+
+/* REVISIT: Support CONFIG_DYNAMIC_DEBUG when necessary */
+#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
+#define acpi_handle_debug(handle, fmt, ...)                             \
+        acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__)
+#else
+#define acpi_handle_debug(handle, fmt, ...)                             \
+({                                                                      \
+        if (0)                                                          \
+                acpi_handle_printk(KERN_DEBUG, handle, fmt, ##__VA_ARGS__); \
+        0;                                                              \
+})
+#endif
+
 #endif  /*_LINUX_ACPI_H*/
diff --git a/include/linux/acpi_gpio.h b/include/linux/acpi_gpio.h
new file mode 100644
index 000000000000..91615a389b65
--- /dev/null
+++ b/include/linux/acpi_gpio.h
@@ -0,0 +1,19 @@
+#ifndef _LINUX_ACPI_GPIO_H_
+#define _LINUX_ACPI_GPIO_H_
+
+#include <linux/errno.h>
+
+#ifdef CONFIG_GPIO_ACPI
+
+int acpi_get_gpio(char *path, int pin);
+
+#else /* CONFIG_GPIO_ACPI */
+
+static inline int acpi_get_gpio(char *path, int pin)
+{
+        return -ENODEV;
+}
+
+#endif /* CONFIG_GPIO_ACPI */
+
+#endif /* _LINUX_ACPI_GPIO_H_ */
diff --git a/include/linux/amba/bus.h b/include/linux/amba/bus.h
index d36417158d8f..43ec7e247a80 100644
--- a/include/linux/amba/bus.h
+++ b/include/linux/amba/bus.h
@@ -71,6 +71,16 @@ struct amba_device *amba_ahb_device_add(struct device *parent, const char *name,
                                         resource_size_t base, size_t size,
                                         int irq1, int irq2, void *pdata,
                                         unsigned int periphid);
+struct amba_device *
+amba_apb_device_add_res(struct device *parent, const char *name,
+                        resource_size_t base, size_t size, int irq1,
+                        int irq2, void *pdata, unsigned int periphid,
+                        struct resource *resbase);
+struct amba_device *
+amba_ahb_device_add_res(struct device *parent, const char *name,
+                        resource_size_t base, size_t size, int irq1,
+                        int irq2, void *pdata, unsigned int periphid,
+                        struct resource *resbase);
 void amba_device_unregister(struct amba_device *);
 struct amba_device *amba_find_device(const char *, struct device *, unsigned int, unsigned int);
 int amba_request_regions(struct amba_device *, const char *);
diff --git a/include/linux/balloon_compaction.h b/include/linux/balloon_compaction.h
new file mode 100644
index 000000000000..f7f1d7169b11
--- /dev/null
+++ b/include/linux/balloon_compaction.h
@@ -0,0 +1,272 @@
+/*
+ * include/linux/balloon_compaction.h
+ *
+ * Common interface definitions for making balloon pages movable by compaction.
+ *
+ * Despite being perfectly possible to perform ballooned pages migration, they
+ * make a special corner case to compaction scans because balloon pages are not
+ * enlisted at any LRU list like the other pages we do compact / migrate.
+ *
+ * As the page isolation scanning step a compaction thread does is a lockless
+ * procedure (from a page standpoint), it might bring some racy situations while
+ * performing balloon page compaction. In order to sort out these racy scenarios
+ * and safely perform balloon's page compaction and migration we must, always,
+ * ensure following these three simple rules:
+ *
+ *   i. when updating a balloon's page ->mapping element, strictly do it under
+ *      the following lock order, independently of the far superior
+ *      locking scheme (lru_lock, balloon_lock):
+ *          +-page_lock(page);
+ *            +--spin_lock_irq(&b_dev_info->pages_lock);
+ *                  ... page->mapping updates here ...
+ *
+ *  ii. before isolating or dequeueing a balloon page from the balloon device
+ *      pages list, the page reference counter must be raised by one and the
+ *      extra refcount must be dropped when the page is enqueued back into
+ *      the balloon device page list, thus a balloon page keeps its reference
+ *      counter raised only while it is under our special handling;
+ *
+ * iii. after the lockless scan step have selected a potential balloon page for
+ *      isolation, re-test the page->mapping flags and the page ref counter
+ *      under the proper page lock, to ensure isolating a valid balloon page
+ *      (not yet isolated, nor under release procedure)
+ *
+ * The functions provided by this interface are placed to help on coping with
+ * the aforementioned balloon page corner case, as well as to ensure the simple
+ * set of exposed rules are satisfied while we are dealing with balloon pages
+ * compaction / migration.
+ *
+ * Copyright (C) 2012, Red Hat, Inc.  Rafael Aquini <aquini@redhat.com>
+ */
+#ifndef _LINUX_BALLOON_COMPACTION_H
+#define _LINUX_BALLOON_COMPACTION_H
+#include <linux/pagemap.h>
+#include <linux/page-flags.h>
+#include <linux/migrate.h>
+#include <linux/gfp.h>
+#include <linux/err.h>
+
+/*
+ * Balloon device information descriptor.
+ * This struct is used to allow the common balloon compaction interface
+ * procedures to find the proper balloon device holding memory pages they'll
+ * have to cope for page compaction / migration, as well as it serves the
+ * balloon driver as a page book-keeper for its registered balloon devices.
+ */
+struct balloon_dev_info {
+        void *balloon_device;           /* balloon device descriptor */
+        struct address_space *mapping;  /* balloon special page->mapping */
+        unsigned long isolated_pages;   /* # of isolated pages for migration */
+        spinlock_t pages_lock;          /* Protection to pages list */
+        struct list_head pages;         /* Pages enqueued & handled to Host */
+};
+
+extern struct page *balloon_page_enqueue(struct balloon_dev_info *b_dev_info);
+extern struct page *balloon_page_dequeue(struct balloon_dev_info *b_dev_info);
+extern struct balloon_dev_info *balloon_devinfo_alloc(
+                                                void *balloon_dev_descriptor);
+
+static inline void balloon_devinfo_free(struct balloon_dev_info *b_dev_info)
+{
+        kfree(b_dev_info);
+}
+
+/*
+ * balloon_page_free - release a balloon page back to the page free lists
+ * @page: ballooned page to be set free
+ *
+ * This function must be used to properly set free an isolated/dequeued balloon
+ * page at the end of a sucessful page migration, or at the balloon driver's
+ * page release procedure.
+ */
+static inline void balloon_page_free(struct page *page)
+{
+        /*
+         * Balloon pages always get an extra refcount before being isolated
+         * and before being dequeued to help on sorting out fortuite colisions
+         * between a thread attempting to isolate and another thread attempting
+         * to release the very same balloon page.
+         *
+         * Before we handle the page back to Buddy, lets drop its extra refcnt.
+         */
+        put_page(page);
+        __free_page(page);
+}
+
+#ifdef CONFIG_BALLOON_COMPACTION
+extern bool balloon_page_isolate(struct page *page);
+extern void balloon_page_putback(struct page *page);
+extern int balloon_page_migrate(struct page *newpage,
+                                struct page *page, enum migrate_mode mode);
+extern struct address_space
+*balloon_mapping_alloc(struct balloon_dev_info *b_dev_info,
+                        const struct address_space_operations *a_ops);
+
+static inline void balloon_mapping_free(struct address_space *balloon_mapping)
+{
+        kfree(balloon_mapping);
+}
+
+/*
+ * page_flags_cleared - helper to perform balloon @page ->flags tests.
+ *
+ * As balloon pages are obtained from buddy and we do not play with page->flags
+ * at driver level (exception made when we get the page lock for compaction),
+ * we can safely identify a ballooned page by checking if the
+ * PAGE_FLAGS_CHECK_AT_PREP page->flags are all cleared.  This approach also
+ * helps us skip ballooned pages that are locked for compaction or release, thus
+ * mitigating their racy check at balloon_page_movable()
+ */
+static inline bool page_flags_cleared(struct page *page)
+{
+        return !(page->flags & PAGE_FLAGS_CHECK_AT_PREP);
+}
+
+/*
+ * __is_movable_balloon_page - helper to perform @page mapping->flags tests
+ */
+static inline bool __is_movable_balloon_page(struct page *page)
+{
+        struct address_space *mapping = page->mapping;
+        return mapping_balloon(mapping);
+}
+
+/*
+ * balloon_page_movable - test page->mapping->flags to identify balloon pages
+ *                        that can be moved by compaction/migration.
+ *
+ * This function is used at core compaction's page isolation scheme, therefore
+ * most pages exposed to it are not enlisted as balloon pages and so, to avoid
+ * undesired side effects like racing against __free_pages(), we cannot afford
+ * holding the page locked while testing page->mapping->flags here.
+ *
+ * As we might return false positives in the case of a balloon page being just
+ * released under us, the page->mapping->flags need to be re-tested later,
+ * under the proper page lock, at the functions that will be coping with the
+ * balloon page case.
+ */
+static inline bool balloon_page_movable(struct page *page)
+{
+        /*
+         * Before dereferencing and testing mapping->flags, let's make sure
+         * this is not a page that uses ->mapping in a different way
+         */
+        if (page_flags_cleared(page) && !page_mapped(page) &&
+            page_count(page) == 1)
+                return __is_movable_balloon_page(page);
+
+        return false;
+}
+
+/*
+ * balloon_page_insert - insert a page into the balloon's page list and make
+ *                       the page->mapping assignment accordingly.
+ * @page    : page to be assigned as a 'balloon page'
+ * @mapping : allocated special 'balloon_mapping'
+ * @head    : balloon's device page list head
+ *
+ * Caller must ensure the page is locked and the spin_lock protecting balloon
+ * pages list is held before inserting a page into the balloon device.
+ */
+static inline void balloon_page_insert(struct page *page,
+                                       struct address_space *mapping,
+                                       struct list_head *head)
+{
+        page->mapping = mapping;
+        list_add(&page->lru, head);
+}
+
+/*
+ * balloon_page_delete - delete a page from balloon's page list and clear
+ *                       the page->mapping assignement accordingly.
+ * @page    : page to be released from balloon's page list
+ *
+ * Caller must ensure the page is locked and the spin_lock protecting balloon
+ * pages list is held before deleting a page from the balloon device.
+ */
+static inline void balloon_page_delete(struct page *page)
+{
+        page->mapping = NULL;
+        list_del(&page->lru);
+}
+
+/*
+ * balloon_page_device - get the b_dev_info descriptor for the balloon device
+ *                       that enqueues the given page.
+ */
+static inline struct balloon_dev_info *balloon_page_device(struct page *page)
+{
+        struct address_space *mapping = page->mapping;
+        if (likely(mapping))
+                return mapping->private_data;
+
+        return NULL;
+}
+
+static inline gfp_t balloon_mapping_gfp_mask(void)
+{
+        return GFP_HIGHUSER_MOVABLE;
+}
+
+static inline bool balloon_compaction_check(void)
+{
+        return true;
+}
+
+#else /* !CONFIG_BALLOON_COMPACTION */
+
+static inline void *balloon_mapping_alloc(void *balloon_device,
+                                const struct address_space_operations *a_ops)
+{
+        return ERR_PTR(-EOPNOTSUPP);
+}
+
+static inline void balloon_mapping_free(struct address_space *balloon_mapping)
+{
+        return;
+}
+
+static inline void balloon_page_insert(struct page *page,
+                                       struct address_space *mapping,
+                                       struct list_head *head)
+{
+        list_add(&page->lru, head);
+}
+
+static inline void balloon_page_delete(struct page *page)
+{
+        list_del(&page->lru);
+}
+
+static inline bool balloon_page_movable(struct page *page)
+{
+        return false;
+}
+
+static inline bool balloon_page_isolate(struct page *page)
+{
+        return false;
+}
+
+static inline void balloon_page_putback(struct page *page)
+{
+        return;
+}
+
+static inline int balloon_page_migrate(struct page *newpage,
+                                struct page *page, enum migrate_mode mode)
+{
+        return 0;
+}
+
+static inline gfp_t balloon_mapping_gfp_mask(void)
+{
+        return GFP_HIGHUSER;
+}
+
+static inline bool balloon_compaction_check(void)
+{
+        return false;
+}
+#endif /* CONFIG_BALLOON_COMPACTION */
+#endif /* _LINUX_BALLOON_COMPACTION_H */
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 6d6795d46a75..7b74452c5317 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -51,8 +51,8 @@ extern unsigned long free_all_bootmem(void);
 extern void free_bootmem_node(pg_data_t *pgdat,
                               unsigned long addr,
                               unsigned long size);
-extern void free_bootmem(unsigned long addr, unsigned long size);
-extern void free_bootmem_late(unsigned long addr, unsigned long size);
+extern void free_bootmem(unsigned long physaddr, unsigned long size);
+extern void free_bootmem_late(unsigned long physaddr, unsigned long size);
 
 /*
  * Flags for reserve_bootmem (also if CONFIG_HAVE_ARCH_BOOTMEM_NODE,
diff --git a/include/linux/bug.h b/include/linux/bug.h
index aaac4bba6f5c..b1cf40de847e 100644
--- a/include/linux/bug.h
+++ b/include/linux/bug.h
@@ -15,6 +15,7 @@ struct pt_regs;
 #define BUILD_BUG_ON_NOT_POWER_OF_2(n)
 #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() (0)
 #else /* __CHECKER__ */
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index f8a030ced0c7..7d73905dcba2 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -12,6 +12,7 @@
 #include <linux/cpumask.h>
 #include <linux/nodemask.h>
 #include <linux/rcupdate.h>
+#include <linux/rculist.h>
 #include <linux/cgroupstats.h>
 #include <linux/prio_heap.h>
 #include <linux/rwsem.h>
@@ -34,7 +35,6 @@ extern int cgroup_lock_is_held(void);
 extern bool cgroup_lock_live_group(struct cgroup *cgrp);
 extern void cgroup_unlock(void);
 extern void cgroup_fork(struct task_struct *p);
-extern void cgroup_fork_callbacks(struct task_struct *p);
 extern void cgroup_post_fork(struct task_struct *p);
 extern void cgroup_exit(struct task_struct *p, int run_callbacks);
 extern int cgroupstats_build(struct cgroupstats *stats,
@@ -66,7 +66,7 @@ struct cgroup_subsys_state {
         /*
          * State maintained by the cgroup system to allow subsystems
          * to be "busy". Should be accessed via css_get(),
-         * css_tryget() and and css_put().
+         * css_tryget() and css_put().
          */
 
         atomic_t refcnt;
@@ -81,9 +81,8 @@ struct cgroup_subsys_state {
 
 /* bits in struct cgroup_subsys_state flags field */
 enum {
-        CSS_ROOT, /* This CSS is the root of the subsystem */
-        CSS_REMOVED, /* This CSS is dead */
-        CSS_CLEAR_CSS_REFS,             /* @ss->__DEPRECATED_clear_css_refs */
+        CSS_ROOT        = (1 << 0), /* this CSS is the root of the subsystem */
+        CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
 };
 
 /* Caller must verify that the css is not for root cgroup */
@@ -102,15 +101,10 @@ static inline void __css_get(struct cgroup_subsys_state *css, int count)
 static inline void css_get(struct cgroup_subsys_state *css)
 {
         /* We don't need to reference count the root state */
-        if (!test_bit(CSS_ROOT, &css->flags))
+        if (!(css->flags & CSS_ROOT))
                 __css_get(css, 1);
 }
 
-static inline bool css_is_removed(struct cgroup_subsys_state *css)
-{
-        return test_bit(CSS_REMOVED, &css->flags);
-}
-
 /*
  * Call css_tryget() to take a reference on a css if your existing
  * (known-valid) reference isn't already ref-counted. Returns false if
@@ -120,7 +114,7 @@ static inline bool css_is_removed(struct cgroup_subsys_state *css)
 extern bool __css_tryget(struct cgroup_subsys_state *css);
 static inline bool css_tryget(struct cgroup_subsys_state *css)
 {
-        if (test_bit(CSS_ROOT, &css->flags))
+        if (css->flags & CSS_ROOT)
                 return true;
         return __css_tryget(css);
 }
@@ -133,7 +127,7 @@ static inline bool css_tryget(struct cgroup_subsys_state *css)
 extern void __css_put(struct cgroup_subsys_state *css);
 static inline void css_put(struct cgroup_subsys_state *css)
 {
-        if (!test_bit(CSS_ROOT, &css->flags))
+        if (!(css->flags & CSS_ROOT))
                 __css_put(css);
 }
 
@@ -149,13 +143,11 @@ enum {
         /* Control Group requires release notifications to userspace */
         CGRP_NOTIFY_ON_RELEASE,
         /*
-         * A thread in rmdir() is wating for this cgroup.
-         */
-        CGRP_WAIT_ON_RMDIR,
-        /*
-         * Clone cgroup values when creating a new child cgroup
+         * Clone the parent's configuration when creating a new child
+         * cpuset cgroup.  For historical reasons, this option can be
+         * specified at mount time and thus is implemented here.
          */
-        CGRP_CLONE_CHILDREN,
+        CGRP_CPUSET_CLONE_CHILDREN,
 };
 
 struct cgroup {
@@ -167,6 +159,8 @@ struct cgroup {
          */
         atomic_t count;
 
+        int id;                         /* ida allocated in-hierarchy ID */
+
         /*
          * We link our 'sibling' struct into our parent's 'children'.
          * Our children link their 'sibling' into our 'children'.
@@ -176,7 +170,7 @@ struct cgroup {
         struct list_head files;         /* my files */
 
         struct cgroup *parent;          /* my parent */
-        struct dentry __rcu *dentry;    /* cgroup fs entry, RCU protected */
+        struct dentry *dentry;          /* cgroup fs entry, RCU protected */
 
         /* Private pointers for each registered subsystem */
         struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
@@ -282,7 +276,7 @@ struct cgroup_map_cb {
 
 /* cftype->flags */
 #define CFTYPE_ONLY_ON_ROOT     (1U << 0)       /* only create on root cg */
-#define CFTYPE_NOT_ON_ROOT      (1U << 1)       /* don't create onp root cg */
+#define CFTYPE_NOT_ON_ROOT      (1U << 1)       /* don't create on root cg */
 
 #define MAX_CFTYPE_NAME         64
 
@@ -422,23 +416,6 @@ int cgroup_task_count(const struct cgroup *cgrp);
 int cgroup_is_descendant(const struct cgroup *cgrp, struct task_struct *task);
 
 /*
- * When the subsys has to access css and may add permanent refcnt to css,
- * it should take care of racy conditions with rmdir(). Following set of
- * functions, is for stop/restart rmdir if necessary.
- * Because these will call css_get/put, "css" should be alive css.
- *
- *  cgroup_exclude_rmdir();
- *  ...do some jobs which may access arbitrary empty cgroup
- *  cgroup_release_and_wakeup_rmdir();
- *
- *  When someone removes a cgroup while cgroup_exclude_rmdir() holds it,
- *  it sleeps and cgroup_release_and_wakeup_rmdir() will wake him up.
- */
-
-void cgroup_exclude_rmdir(struct cgroup_subsys_state *css);
-void cgroup_release_and_wakeup_rmdir(struct cgroup_subsys_state *css);
-
-/*
  * Control Group taskset, used to pass around set of tasks to cgroup_subsys
  * methods.
  */
@@ -466,16 +443,17 @@ int cgroup_taskset_size(struct cgroup_taskset *tset);
  */
 
 struct cgroup_subsys {
-        struct cgroup_subsys_state *(*create)(struct cgroup *cgrp);
-        int (*pre_destroy)(struct cgroup *cgrp);
-        void (*destroy)(struct cgroup *cgrp);
+        struct cgroup_subsys_state *(*css_alloc)(struct cgroup *cgrp);
+        int (*css_online)(struct cgroup *cgrp);
+        void (*css_offline)(struct cgroup *cgrp);
+        void (*css_free)(struct cgroup *cgrp);
+
         int (*can_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
         void (*cancel_attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
         void (*attach)(struct cgroup *cgrp, struct cgroup_taskset *tset);
         void (*fork)(struct task_struct *task);
         void (*exit)(struct cgroup *cgrp, struct cgroup *old_cgrp,
                      struct task_struct *task);
-        void (*post_clone)(struct cgroup *cgrp);
         void (*bind)(struct cgroup *root);
 
         int subsys_id;
@@ -489,17 +467,6 @@ struct cgroup_subsys {
         bool use_id;
 
         /*
-         * If %true, cgroup removal will try to clear css refs by retrying
-         * ss->pre_destroy() until there's no css ref left.  This behavior
-         * is strictly for backward compatibility and will be removed as
-         * soon as the current user (memcg) is updated.
-         *
-         * If %false, ss->pre_destroy() can't fail and cgroup removal won't
-         * wait for css refs to drop to zero before proceeding.
-         */
-        bool __DEPRECATED_clear_css_refs;
-
-        /*
          * If %false, this subsystem is properly hierarchical -
          * configuration, resource accounting and restriction on a parent
          * cgroup cover those of its children.  If %true, hierarchy support
@@ -572,6 +539,100 @@ static inline struct cgroup* task_cgroup(struct task_struct *task,
         return task_subsys_state(task, subsys_id)->cgroup;
 }
 
+/**
+ * cgroup_for_each_child - iterate through children of a cgroup
+ * @pos: the cgroup * to use as the loop cursor
+ * @cgroup: cgroup whose children to walk
+ *
+ * Walk @cgroup's children.  Must be called under rcu_read_lock().  A child
+ * cgroup which hasn't finished ->css_online() or already has finished
+ * ->css_offline() may show up during traversal and it's each subsystem's
+ * responsibility to verify that each @pos is alive.
+ *
+ * If a subsystem synchronizes against the parent in its ->css_online() and
+ * before starting iterating, a cgroup which finished ->css_online() is
+ * guaranteed to be visible in the future iterations.
+ */
+#define cgroup_for_each_child(pos, cgroup)                              \
+        list_for_each_entry_rcu(pos, &(cgroup)->children, sibling)
+
+struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
+                                          struct cgroup *cgroup);
+
+/**
+ * cgroup_for_each_descendant_pre - pre-order walk of a cgroup's descendants
+ * @pos: the cgroup * to use as the loop cursor
+ * @cgroup: cgroup whose descendants to walk
+ *
+ * Walk @cgroup's descendants.  Must be called under rcu_read_lock().  A
+ * descendant cgroup which hasn't finished ->css_online() or already has
+ * finished ->css_offline() may show up during traversal and it's each
+ * subsystem's responsibility to verify that each @pos is alive.
+ *
+ * If a subsystem synchronizes against the parent in its ->css_online() and
+ * before starting iterating, and synchronizes against @pos on each
+ * iteration, any descendant cgroup which finished ->css_offline() is
+ * guaranteed to be visible in the future iterations.
+ *
+ * In other words, the following guarantees that a descendant can't escape
+ * state updates of its ancestors.
+ *
+ * my_online(@cgrp)
+ * {
+ *      Lock @cgrp->parent and @cgrp;
+ *      Inherit state from @cgrp->parent;
+ *      Unlock both.
+ * }
+ *
+ * my_update_state(@cgrp)
+ * {
+ *      Lock @cgrp;
+ *      Update @cgrp's state;
+ *      Unlock @cgrp;
+ *
+ *      cgroup_for_each_descendant_pre(@pos, @cgrp) {
+ *              Lock @pos;
+ *              Verify @pos is alive and inherit state from @pos->parent;
+ *              Unlock @pos;
+ *      }
+ * }
+ *
+ * As long as the inheriting step, including checking the parent state, is
+ * enclosed inside @pos locking, double-locking the parent isn't necessary
+ * while inheriting.  The state update to the parent is guaranteed to be
+ * visible by walking order and, as long as inheriting operations to the
+ * same @pos are atomic to each other, multiple updates racing each other
+ * still result in the correct state.  It's guaranateed that at least one
+ * inheritance happens for any cgroup after the latest update to its
+ * parent.
+ *
+ * If checking parent's state requires locking the parent, each inheriting
+ * iteration should lock and unlock both @pos->parent and @pos.
+ *
+ * Alternatively, a subsystem may choose to use a single global lock to
+ * synchronize ->css_online() and ->css_offline() against tree-walking
+ * operations.
+ */
+#define cgroup_for_each_descendant_pre(pos, cgroup)                     \
+        for (pos = cgroup_next_descendant_pre(NULL, (cgroup)); (pos);   \
+             pos = cgroup_next_descendant_pre((pos), (cgroup)))
+
+struct cgroup *cgroup_next_descendant_post(struct cgroup *pos,
+                                           struct cgroup *cgroup);
+
+/**
+ * cgroup_for_each_descendant_post - post-order walk of a cgroup's descendants
+ * @pos: the cgroup * to use as the loop cursor
+ * @cgroup: cgroup whose descendants to walk
+ *
+ * Similar to cgroup_for_each_descendant_pre() but performs post-order
+ * traversal instead.  Note that the walk visibility guarantee described in
+ * pre-order walk doesn't apply the same to post-order walks.
+ */
+#define cgroup_for_each_descendant_post(pos, cgroup)                    \
+        for (pos = cgroup_next_descendant_post(NULL, (cgroup)); (pos);  \
+             pos = cgroup_next_descendant_post((pos), (cgroup)))
+
 /* A cgroup_iter should be treated as an opaque object */
 struct cgroup_iter {
         struct list_head *cg_link;
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 172d5bdaf03d..4989b8a7bed1 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -57,6 +57,11 @@ struct clk_hw;
  *              This function must not sleep. Optional, if this op is not
  *              set then the enable count will be used.
  *
+ * @disable_unused: Disable the clock atomically.  Only called from
+ *              clk_disable_unused for gate clocks with special needs.
+ *              Called with enable_lock held.  This function must not
+ *              sleep.
+ *
  * @recalc_rate Recalculate the rate of this clock, by querying hardware. The
  *              parent rate is an input parameter.  It is up to the caller to
  *              ensure that the prepare_mutex is held across this call.
@@ -106,6 +111,7 @@ struct clk_ops {
         int             (*enable)(struct clk_hw *hw);
         void            (*disable)(struct clk_hw *hw);
         int             (*is_enabled)(struct clk_hw *hw);
+        void            (*disable_unused)(struct clk_hw *hw);
         unsigned long   (*recalc_rate)(struct clk_hw *hw,
                                         unsigned long parent_rate);
         long            (*round_rate)(struct clk_hw *hw, unsigned long,
@@ -331,8 +337,10 @@ struct clk *clk_register_fixed_factor(struct device *dev, const char *name,
  * error code; drivers must test for an error code after calling clk_register.
  */
 struct clk *clk_register(struct device *dev, struct clk_hw *hw);
+struct clk *devm_clk_register(struct device *dev, struct clk_hw *hw);
 
 void clk_unregister(struct clk *clk);
+void devm_clk_unregister(struct device *dev, struct clk *clk);
 
 /* helper functions */
 const char *__clk_get_name(struct clk *clk);
diff --git a/include/linux/context_tracking.h b/include/linux/context_tracking.h
new file mode 100644
index 000000000000..e24339ccb7f0
--- /dev/null
+++ b/include/linux/context_tracking.h
@@ -0,0 +1,18 @@
+#ifndef _LINUX_CONTEXT_TRACKING_H
+#define _LINUX_CONTEXT_TRACKING_H
+
+#ifdef CONFIG_CONTEXT_TRACKING
+#include <linux/sched.h>
+
+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 void user_enter(void) { }
+static inline void user_exit(void) { }
+static inline void context_tracking_task_switch(struct task_struct *prev,
+                                                struct task_struct *next) { }
+#endif /* !CONFIG_CONTEXT_TRACKING */
+
+#endif
diff --git a/include/linux/cpu_cooling.h b/include/linux/cpu_cooling.h
index 851530128e65..40b4ef54cc7d 100644
--- a/include/linux/cpu_cooling.h
+++ b/include/linux/cpu_cooling.h
@@ -29,13 +29,13 @@
 #define CPUFREQ_COOLING_START           0
 #define CPUFREQ_COOLING_STOP            1
 
-#ifdef CONFIG_CPU_THERMAL
+#if defined(CONFIG_CPU_THERMAL) || defined(CONFIG_CPU_THERMAL_MODULE)
 /**
  * cpufreq_cooling_register - function to create cpufreq cooling device.
  * @clip_cpus: cpumask of cpus where the frequency constraints will happen
  */
 struct thermal_cooling_device *cpufreq_cooling_register(
-                struct cpumask *clip_cpus);
+                const struct cpumask *clip_cpus);
 
 /**
  * cpufreq_cooling_unregister - function to remove cpufreq cooling device.
@@ -44,7 +44,7 @@ struct thermal_cooling_device *cpufreq_cooling_register(
 void cpufreq_cooling_unregister(struct thermal_cooling_device *cdev);
 #else /* !CONFIG_CPU_THERMAL */
 static inline struct thermal_cooling_device *cpufreq_cooling_register(
-        struct cpumask *clip_cpus)
+        const struct cpumask *clip_cpus)
 {
         return NULL;
 }
diff --git a/include/linux/cpufreq.h b/include/linux/cpufreq.h
index b60f6ba01d0c..a55b88eaf96a 100644
--- a/include/linux/cpufreq.h
+++ b/include/linux/cpufreq.h
@@ -11,6 +11,7 @@
 #ifndef _LINUX_CPUFREQ_H
 #define _LINUX_CPUFREQ_H
 
+#include <asm/cputime.h>
 #include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/threads.h>
@@ -22,6 +23,8 @@
 #include <asm/div64.h>
 
 #define CPUFREQ_NAME_LEN 16
+/* Print length for names. Extra 1 space for accomodating '\n' in prints */
+#define CPUFREQ_NAME_PLEN (CPUFREQ_NAME_LEN + 1)
 
 
 /*********************************************************************
@@ -404,6 +407,4 @@ void cpufreq_frequency_table_get_attr(struct cpufreq_frequency_table *table,
                                       unsigned int cpu);
 
 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 279b1eaa8b73..3711b34dc4f9 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -82,13 +82,6 @@ cpuidle_set_statedata(struct cpuidle_state_usage *st_usage, void *data)
         st_usage->driver_data = data;
 }
 
-struct cpuidle_state_kobj {
-        struct cpuidle_state *state;
-        struct cpuidle_state_usage *state_usage;
-        struct completion kobj_unregister;
-        struct kobject kobj;
-};
-
 struct cpuidle_device {
         unsigned int            registered:1;
         unsigned int            enabled:1;
@@ -98,7 +91,7 @@ struct cpuidle_device {
         int                     state_count;
         struct cpuidle_state_usage      states_usage[CPUIDLE_STATE_MAX];
         struct cpuidle_state_kobj *kobjs[CPUIDLE_STATE_MAX];
-
+        struct cpuidle_driver_kobj *kobj_driver;
         struct list_head        device_list;
         struct kobject          kobj;
         struct completion       kobj_unregister;
@@ -131,6 +124,7 @@ static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
 struct cpuidle_driver {
         const char              *name;
         struct module           *owner;
+        int                     refcnt;
 
         unsigned int            power_specified:1;
         /* set to 1 to use the core cpuidle time keeping (for all states). */
@@ -163,6 +157,10 @@ extern int cpuidle_wrap_enter(struct cpuidle_device *dev,
                                         struct cpuidle_driver *drv, int index));
 extern int cpuidle_play_dead(void);
 
+extern struct cpuidle_driver *cpuidle_get_cpu_driver(struct cpuidle_device *dev);
+extern int cpuidle_register_cpu_driver(struct cpuidle_driver *drv, int cpu);
+extern void cpuidle_unregister_cpu_driver(struct cpuidle_driver *drv, int cpu);
+
 #else
 static inline void disable_cpuidle(void) { }
 static inline int cpuidle_idle_call(void) { return -ENODEV; }
@@ -189,7 +187,6 @@ static inline int cpuidle_wrap_enter(struct cpuidle_device *dev,
                                         struct cpuidle_driver *drv, int index))
 { return -ENODEV; }
 static inline int cpuidle_play_dead(void) {return -ENODEV; }
-
 #endif
 
 #ifdef CONFIG_ARCH_NEEDS_CPU_IDLE_COUPLED
diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index 281c72a3b9d5..e83ef39b3bea 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -25,12 +25,12 @@ struct devfreq;
  * struct devfreq_dev_status - Data given from devfreq user device to
  *                           governors. Represents the performance
  *                           statistics.
- * @total_time          The total time represented by this instance of
+ * @total_time:         The total time represented by this instance of
  *                      devfreq_dev_status
- * @busy_time           The time that the device was working among the
+ * @busy_time:          The time that the device was working among the
  *                      total_time.
- * @current_frequency   The operating frequency.
- * @private_data        An entry not specified by the devfreq framework.
+ * @current_frequency:  The operating frequency.
+ * @private_data:       An entry not specified by the devfreq framework.
  *                      A device and a specific governor may have their
  *                      own protocol with private_data. However, because
  *                      this is governor-specific, a governor using this
@@ -54,23 +54,27 @@ struct devfreq_dev_status {
 
 /**
  * struct devfreq_dev_profile - Devfreq's user device profile
- * @initial_freq        The operating frequency when devfreq_add_device() is
+ * @initial_freq:       The operating frequency when devfreq_add_device() is
  *                      called.
- * @polling_ms          The polling interval in ms. 0 disables polling.
- * @target              The device should set its operating frequency at
+ * @polling_ms:         The polling interval in ms. 0 disables polling.
+ * @target:             The device should set its operating frequency at
  *                      freq or lowest-upper-than-freq value. If freq is
  *                      higher than any operable frequency, set maximum.
  *                      Before returning, target function should set
  *                      freq at the current frequency.
  *                      The "flags" parameter's possible values are
  *                      explained above with "DEVFREQ_FLAG_*" macros.
- * @get_dev_status      The device should provide the current performance
+ * @get_dev_status:     The device should provide the current performance
  *                      status to devfreq, which is used by governors.
- * @exit                An optional callback that is called when devfreq
+ * @get_cur_freq:       The device should provide the current frequency
+ *                      at which it is operating.
+ * @exit:               An optional callback that is called when devfreq
  *                      is removing the devfreq object due to error or
  *                      from devfreq_remove_device() call. If the user
  *                      has registered devfreq->nb at a notifier-head,
  *                      this is the time to unregister it.
+ * @freq_table: Optional list of frequencies to support statistics.
+ * @max_state:  The size of freq_table.
  */
 struct devfreq_dev_profile {
         unsigned long initial_freq;
@@ -79,63 +83,63 @@ struct devfreq_dev_profile {
         int (*target)(struct device *dev, unsigned long *freq, u32 flags);
         int (*get_dev_status)(struct device *dev,
                               struct devfreq_dev_status *stat);
+        int (*get_cur_freq)(struct device *dev, unsigned long *freq);
         void (*exit)(struct device *dev);
+
+        unsigned int *freq_table;
+        unsigned int max_state;
 };
 
 /**
  * struct devfreq_governor - Devfreq policy governor
- * @name                Governor's name
- * @get_target_freq     Returns desired operating frequency for the device.
+ * @node:               list node - contains registered devfreq governors
+ * @name:               Governor's name
+ * @get_target_freq:    Returns desired operating frequency for the device.
  *                      Basically, get_target_freq will run
  *                      devfreq_dev_profile.get_dev_status() to get the
  *                      status of the device (load = busy_time / total_time).
  *                      If no_central_polling is set, this callback is called
  *                      only with update_devfreq() notified by OPP.
- * @init                Called when the devfreq is being attached to a device
- * @exit                Called when the devfreq is being removed from a
- *                      device. Governor should stop any internal routines
- *                      before return because related data may be
- *                      freed after exit().
- * @no_central_polling  Do not use devfreq's central polling mechanism.
- *                      When this is set, devfreq will not call
- *                      get_target_freq with devfreq_monitor(). However,
- *                      devfreq will call get_target_freq with
- *                      devfreq_update() notified by OPP framework.
+ * @event_handler:      Callback for devfreq core framework to notify events
+ *                      to governors. Events include per device governor
+ *                      init and exit, opp changes out of devfreq, suspend
+ *                      and resume of per device devfreq during device idle.
  *
  * Note that the callbacks are called with devfreq->lock locked by devfreq.
  */
 struct devfreq_governor {
+        struct list_head node;
+
         const char name[DEVFREQ_NAME_LEN];
         int (*get_target_freq)(struct devfreq *this, unsigned long *freq);
-        int (*init)(struct devfreq *this);
-        void (*exit)(struct devfreq *this);
-        const bool no_central_polling;
+        int (*event_handler)(struct devfreq *devfreq,
+                                unsigned int event, void *data);
 };
 
 /**
  * struct devfreq - Device devfreq structure
- * @node        list node - contains the devices with devfreq that have been
+ * @node:       list node - contains the devices with devfreq that have been
  *              registered.
- * @lock        a mutex to protect accessing devfreq.
- * @dev         device registered by devfreq class. dev.parent is the device
+ * @lock:       a mutex to protect accessing devfreq.
+ * @dev:        device registered by devfreq class. dev.parent is the device
  *              using devfreq.
- * @profile     device-specific devfreq profile
- * @governor    method how to choose frequency based on the usage.
- * @nb          notifier block used to notify devfreq object that it should
+ * @profile:    device-specific devfreq profile
+ * @governor:   method how to choose frequency based on the usage.
+ * @governor_name:      devfreq governor name for use with this devfreq
+ * @nb:         notifier block used to notify devfreq object that it should
  *              reevaluate operable frequencies. Devfreq users may use
  *              devfreq.nb to the corresponding register notifier call chain.
- * @polling_jiffies     interval in jiffies.
- * @previous_freq       previously configured frequency value.
- * @next_polling        the number of remaining jiffies to poll with
- *                      "devfreq_monitor" executions to reevaluate
- *                      frequency/voltage of the device. Set by
- *                      profile's polling_ms interval.
- * @data        Private data of the governor. The devfreq framework does not
+ * @work:       delayed work for load monitoring.
+ * @previous_freq:      previously configured frequency value.
+ * @data:       Private data of the governor. The devfreq framework does not
  *              touch this.
- * @being_removed       a flag to mark that this object is being removed in
- *                      order to prevent trying to remove the object multiple times.
- * @min_freq    Limit minimum frequency requested by user (0: none)
- * @max_freq    Limit maximum frequency requested by user (0: none)
+ * @min_freq:   Limit minimum frequency requested by user (0: none)
+ * @max_freq:   Limit maximum frequency requested by user (0: none)
+ * @stop_polling:        devfreq polling status of a device.
+ * @total_trans:        Number of devfreq transitions
+ * @trans_table:        Statistics of devfreq transitions
+ * @time_in_state:      Statistics of devfreq states
+ * @last_stat_updated:  The last time stat updated
  *
  * This structure stores the devfreq information for a give device.
  *
@@ -152,26 +156,33 @@ struct devfreq {
         struct device dev;
         struct devfreq_dev_profile *profile;
         const struct devfreq_governor *governor;
+        char governor_name[DEVFREQ_NAME_LEN];
         struct notifier_block nb;
+        struct delayed_work work;
 
-        unsigned long polling_jiffies;
         unsigned long previous_freq;
-        unsigned int next_polling;
 
         void *data; /* private data for governors */
 
-        bool being_removed;
-
         unsigned long min_freq;
         unsigned long max_freq;
+        bool stop_polling;
+
+        /* information for device freqeuncy transition */
+        unsigned int total_trans;
+        unsigned int *trans_table;
+        unsigned long *time_in_state;
+        unsigned long last_stat_updated;
 };
 
 #if defined(CONFIG_PM_DEVFREQ)
 extern struct devfreq *devfreq_add_device(struct device *dev,
                                   struct devfreq_dev_profile *profile,
-                                  const struct devfreq_governor *governor,
+                                  const char *governor_name,
                                   void *data);
 extern int devfreq_remove_device(struct devfreq *devfreq);
+extern int devfreq_suspend_device(struct devfreq *devfreq);
+extern int devfreq_resume_device(struct devfreq *devfreq);
 
 /* Helper functions for devfreq user device driver with OPP. */
 extern struct opp *devfreq_recommended_opp(struct device *dev,
@@ -181,23 +192,13 @@ extern int devfreq_register_opp_notifier(struct device *dev,
 extern int devfreq_unregister_opp_notifier(struct device *dev,
                                            struct devfreq *devfreq);
 
-#ifdef CONFIG_DEVFREQ_GOV_POWERSAVE
-extern const struct devfreq_governor devfreq_powersave;
-#endif
-#ifdef CONFIG_DEVFREQ_GOV_PERFORMANCE
-extern const struct devfreq_governor devfreq_performance;
-#endif
-#ifdef CONFIG_DEVFREQ_GOV_USERSPACE
-extern const struct devfreq_governor devfreq_userspace;
-#endif
-#ifdef CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND
-extern const struct devfreq_governor devfreq_simple_ondemand;
+#if IS_ENABLED(CONFIG_DEVFREQ_GOV_SIMPLE_ONDEMAND)
 /**
  * struct devfreq_simple_ondemand_data - void *data fed to struct devfreq
  *      and devfreq_add_device
- * @ upthreshold        If the load is over this value, the frequency jumps.
+ * @upthreshold:        If the load is over this value, the frequency jumps.
  *                      Specify 0 to use the default. Valid value = 0 to 100.
- * @ downdifferential   If the load is under upthreshold - downdifferential,
+ * @downdifferential:   If the load is under upthreshold - downdifferential,
  *                      the governor may consider slowing the frequency down.
  *                      Specify 0 to use the default. Valid value = 0 to 100.
  *                      downdifferential < upthreshold must hold.
@@ -214,7 +215,7 @@ struct devfreq_simple_ondemand_data {
 #else /* !CONFIG_PM_DEVFREQ */
 static struct devfreq *devfreq_add_device(struct device *dev,
                                           struct devfreq_dev_profile *profile,
-                                          struct devfreq_governor *governor,
+                                          const char *governor_name,
                                           void *data)
 {
         return NULL;
@@ -225,6 +226,16 @@ static int devfreq_remove_device(struct devfreq *devfreq)
         return 0;
 }
 
+static int devfreq_suspend_device(struct devfreq *devfreq)
+{
+        return 0;
+}
+
+static int devfreq_resume_device(struct devfreq *devfreq)
+{
+        return 0;
+}
+
 static struct opp *devfreq_recommended_opp(struct device *dev,
                                            unsigned long *freq, u32 flags)
 {
@@ -243,11 +254,6 @@ static int devfreq_unregister_opp_notifier(struct device *dev,
         return -EINVAL;
 }
 
-#define devfreq_powersave       NULL
-#define devfreq_performance     NULL
-#define devfreq_userspace       NULL
-#define devfreq_simple_ondemand NULL
-
 #endif /* CONFIG_PM_DEVFREQ */
 
 #endif /* __LINUX_DEVFREQ_H__ */
diff --git a/include/linux/device.h b/include/linux/device.h
index 86ef6ab553b1..05292e488346 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -190,6 +190,7 @@ extern struct klist *bus_get_device_klist(struct bus_type *bus);
  * @mod_name:   Used for built-in modules.
  * @suppress_bind_attrs: Disables bind/unbind via sysfs.
  * @of_match_table: The open firmware table.
+ * @acpi_match_table: The ACPI match table.
  * @probe:      Called to query the existence of a specific device,
  *              whether this driver can work with it, and bind the driver
  *              to a specific device.
@@ -223,6 +224,7 @@ struct device_driver {
         bool suppress_bind_attrs;       /* disables bind/unbind via sysfs */
 
         const struct of_device_id       *of_match_table;
+        const struct acpi_device_id     *acpi_match_table;
 
         int (*probe) (struct device *dev);
         int (*remove) (struct device *dev);
@@ -576,6 +578,12 @@ struct device_dma_parameters {
         unsigned long segment_boundary_mask;
 };
 
+struct acpi_dev_node {
+#ifdef CONFIG_ACPI
+        void    *handle;
+#endif
+};
+
 /**
  * struct device - The basic device structure
  * @parent:     The device's "parent" device, the device to which it is attached.
@@ -616,6 +624,7 @@ struct device_dma_parameters {
  * @dma_mem:    Internal for coherent mem override.
  * @archdata:   For arch-specific additions.
  * @of_node:    Associated device tree node.
+ * @acpi_node:  Associated ACPI device node.
  * @devt:       For creating the sysfs "dev".
  * @id:         device instance
  * @devres_lock: Spinlock to protect the resource of the device.
@@ -680,6 +689,7 @@ struct device {
         struct dev_archdata     archdata;
 
         struct device_node      *of_node; /* associated device tree node */
+        struct acpi_dev_node    acpi_node; /* associated ACPI device node */
 
         dev_t                   devt;   /* dev_t, creates the sysfs "dev" */
         u32                     id;     /* device instance */
@@ -700,6 +710,14 @@ static inline struct device *kobj_to_dev(struct kobject *kobj)
         return container_of(kobj, struct device, kobj);
 }
 
+#ifdef CONFIG_ACPI
+#define ACPI_HANDLE(dev)        ((dev)->acpi_node.handle)
+#define ACPI_HANDLE_SET(dev, _handle_)  (dev)->acpi_node.handle = (_handle_)
+#else
+#define ACPI_HANDLE(dev)        (NULL)
+#define ACPI_HANDLE_SET(dev, _handle_)  do { } while (0)
+#endif
+
 /* Get the wakeup routines, which depend on struct device */
 #include <linux/pm_wakeup.h>
 
diff --git a/include/linux/devpts_fs.h b/include/linux/devpts_fs.h
index 5ce0e5fd712e..251a2090a554 100644
--- a/include/linux/devpts_fs.h
+++ b/include/linux/devpts_fs.h
@@ -20,28 +20,28 @@
 int devpts_new_index(struct inode *ptmx_inode);
 void devpts_kill_index(struct inode *ptmx_inode, int idx);
 /* mknod in devpts */
-int devpts_pty_new(struct inode *ptmx_inode, struct tty_struct *tty);
-/* get tty structure */
-struct tty_struct *devpts_get_tty(struct inode *pts_inode, int number);
+struct inode *devpts_pty_new(struct inode *ptmx_inode, dev_t device, int index,
+                void *priv);
+/* get private structure */
+void *devpts_get_priv(struct inode *pts_inode);
 /* unlink */
-void devpts_pty_kill(struct tty_struct *tty);
+void devpts_pty_kill(struct inode *inode);
 
 #else
 
 /* Dummy stubs in the no-pty case */
 static inline int devpts_new_index(struct inode *ptmx_inode) { return -EINVAL; }
 static inline void devpts_kill_index(struct inode *ptmx_inode, int idx) { }
-static inline int devpts_pty_new(struct inode *ptmx_inode,
-                                struct tty_struct *tty)
+static inline struct inode *devpts_pty_new(struct inode *ptmx_inode,
+                dev_t device, int index, void *priv)
 {
-        return -EINVAL;
+        return ERR_PTR(-EINVAL);
 }
-static inline struct tty_struct *devpts_get_tty(struct inode *pts_inode,
-                int number)
+static inline void *devpts_get_priv(struct inode *pts_inode)
 {
         return NULL;
 }
-static inline void devpts_pty_kill(struct tty_struct *tty) { }
+static inline void devpts_pty_kill(struct inode *inode) { }
 
 #endif
 
diff --git a/include/linux/dma-contiguous.h b/include/linux/dma-contiguous.h
index 2f303e4b7ed3..01b5c84be828 100644
--- a/include/linux/dma-contiguous.h
+++ b/include/linux/dma-contiguous.h
@@ -68,7 +68,7 @@ struct device;
 extern struct cma *dma_contiguous_default_area;
 
 void dma_contiguous_reserve(phys_addr_t addr_limit);
-int dma_declare_contiguous(struct device *dev, unsigned long size,
+int dma_declare_contiguous(struct device *dev, phys_addr_t size,
                            phys_addr_t base, phys_addr_t limit);
 
 struct page *dma_alloc_from_contiguous(struct device *dev, int count,
@@ -83,7 +83,7 @@ bool dma_release_from_contiguous(struct device *dev, struct page *pages,
 static inline void dma_contiguous_reserve(phys_addr_t limit) { }
 
 static inline
-int dma_declare_contiguous(struct device *dev, unsigned long size,
+int dma_declare_contiguous(struct device *dev, phys_addr_t size,
                            phys_addr_t base, phys_addr_t limit)
 {
         return -ENOSYS;
diff --git a/include/linux/edac.h b/include/linux/edac.h
index bab9f8473dc1..1b8c02b36f76 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -533,6 +533,7 @@ struct csrow_info {
 
         u32 ue_count;           /* Uncorrectable Errors for this csrow */
         u32 ce_count;           /* Correctable Errors for this csrow */
+        u32 nr_pages;           /* combined pages count of all channels */
 
         struct mem_ctl_info *mci;       /* the parent */
 
@@ -667,6 +668,8 @@ struct mem_ctl_info {
         u32 fake_inject_ue;
         u16 fake_inject_count;
 #endif
+        __u8 csbased : 1,       /* csrow-based memory controller */
+             __resv  : 7;
 };
 
 #endif
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 8670eb1eb8cd..c47ec36f3f39 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -643,6 +643,7 @@ struct efivar_operations {
         efi_get_variable_t *get_variable;
         efi_get_next_variable_t *get_next_variable;
         efi_set_variable_t *set_variable;
+        efi_query_variable_info_t *query_variable_info;
 };
 
 struct efivars {
diff --git a/include/linux/freezer.h b/include/linux/freezer.h
index d09af4b67cf1..e4238ceaa4d6 100644
--- a/include/linux/freezer.h
+++ b/include/linux/freezer.h
@@ -75,35 +75,68 @@ static inline bool cgroup_freezing(struct task_struct *task)
  */
 
 
-/* Tell the freezer not to count the current task as freezable. */
+/**
+ * freezer_do_not_count - tell freezer to ignore %current
+ *
+ * Tell freezers to ignore the current task when determining whether the
+ * target frozen state is reached.  IOW, the current task will be
+ * considered frozen enough by freezers.
+ *
+ * The caller shouldn't do anything which isn't allowed for a frozen task
+ * until freezer_cont() is called.  Usually, freezer[_do_not]_count() pair
+ * wrap a scheduling operation and nothing much else.
+ */
 static inline void freezer_do_not_count(void)
 {
         current->flags |= PF_FREEZER_SKIP;
 }
 
-/*
- * Tell the freezer to count the current task as freezable again and try to
- * freeze it.
+/**
+ * freezer_count - tell freezer to stop ignoring %current
+ *
+ * Undo freezer_do_not_count().  It tells freezers that %current should be
+ * considered again and tries to freeze if freezing condition is already in
+ * effect.
  */
 static inline void freezer_count(void)
 {
         current->flags &= ~PF_FREEZER_SKIP;
+        /*
+         * If freezing is in progress, the following paired with smp_mb()
+         * in freezer_should_skip() ensures that either we see %true
+         * freezing() or freezer_should_skip() sees !PF_FREEZER_SKIP.
+         */
+        smp_mb();
         try_to_freeze();
 }
 
-/*
- * Check if the task should be counted as freezable by the freezer
+/**
+ * freezer_should_skip - whether to skip a task when determining frozen
+ *                       state is reached
+ * @p: task in quesion
+ *
+ * This function is used by freezers after establishing %true freezing() to
+ * test whether a task should be skipped when determining the target frozen
+ * state is reached.  IOW, if this function returns %true, @p is considered
+ * frozen enough.
  */
-static inline int freezer_should_skip(struct task_struct *p)
+static inline bool freezer_should_skip(struct task_struct *p)
 {
-        return !!(p->flags & PF_FREEZER_SKIP);
+        /*
+         * The following smp_mb() paired with the one in freezer_count()
+         * ensures that either freezer_count() sees %true freezing() or we
+         * see cleared %PF_FREEZER_SKIP and return %false.  This makes it
+         * impossible for a task to slip frozen state testing after
+         * clearing %PF_FREEZER_SKIP.
+         */
+        smp_mb();
+        return p->flags & PF_FREEZER_SKIP;
 }
 
 /*
- * These macros are intended to be used whenever you want allow a task that's
- * sleeping in TASK_UNINTERRUPTIBLE or TASK_KILLABLE state to be frozen. Note
- * that neither return any clear indication of whether a freeze event happened
- * while in this function.
+ * These macros are intended to be used whenever you want allow a sleeping
+ * task to be frozen. Note that neither return any clear indication of
+ * whether a freeze event happened while in this function.
  */
 
 /* Like schedule(), but should not block the freezer. */
@@ -177,6 +210,7 @@ static inline int freeze_kernel_threads(void) { return -ENOSYS; }
 static inline void thaw_processes(void) {}
 static inline void thaw_kernel_threads(void) {}
 
+static inline bool try_to_freeze_nowarn(void) { return false; }
 static inline bool try_to_freeze(void) { return false; }
 
 static inline void freezer_do_not_count(void) {}
diff --git a/include/linux/fs.h b/include/linux/fs.h
index b33cfc97b9ca..408fb1e77a0a 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -418,7 +418,7 @@ struct address_space {
         struct backing_dev_info *backing_dev_info; /* device readahead, etc */
         spinlock_t              private_lock;   /* for use by the address_space */
         struct list_head        private_list;   /* ditto */
-        struct address_space    *assoc_mapping; /* ditto */
+        void                    *private_data;  /* ditto */
 } __attribute__((aligned(sizeof(long))));
         /*
          * On most architectures that alignment is already the case; but
@@ -462,8 +462,6 @@ struct block_device {
         int                     bd_fsfreeze_count;
         /* Mutex for freeze */
         struct mutex            bd_fsfreeze_mutex;
-        /* A semaphore that prevents I/O while block size is being changed */
-        struct percpu_rw_semaphore      bd_block_size_semaphore;
 };
 
 /*
@@ -2049,7 +2047,6 @@ extern void unregister_blkdev(unsigned int, const char *);
 extern struct block_device *bdget(dev_t);
 extern struct block_device *bdgrab(struct block_device *bdev);
 extern void bd_set_size(struct block_device *, loff_t size);
-extern sector_t blkdev_max_block(struct block_device *bdev);
 extern void bd_forget(struct inode *inode);
 extern void bdput(struct block_device *);
 extern void invalidate_bdev(struct block_device *);
@@ -2379,8 +2376,6 @@ extern int generic_segment_checks(const struct iovec *iov,
                 unsigned long *nr_segs, size_t *count, int access_flags);
 
 /* fs/block_dev.c */
-extern ssize_t blkdev_aio_read(struct kiocb *iocb, const struct iovec *iov,
-                               unsigned long nr_segs, loff_t pos);
 extern ssize_t blkdev_aio_write(struct kiocb *iocb, const struct iovec *iov,
                                 unsigned long nr_segs, loff_t pos);
 extern int blkdev_fsync(struct file *filp, loff_t start, loff_t end,
diff --git a/include/linux/ftrace_event.h b/include/linux/ftrace_event.h
index 642928cf57b4..a3d489531d83 100644
--- a/include/linux/ftrace_event.h
+++ b/include/linux/ftrace_event.h
@@ -86,6 +86,12 @@ struct trace_iterator {
         cpumask_var_t           started;
 };
 
+enum trace_iter_flags {
+        TRACE_FILE_LAT_FMT      = 1,
+        TRACE_FILE_ANNOTATE     = 2,
+        TRACE_FILE_TIME_IN_NS   = 4,
+};
+
 
 struct trace_event;
 
@@ -127,13 +133,13 @@ trace_current_buffer_lock_reserve(struct ring_buffer **current_buffer,
 void trace_current_buffer_unlock_commit(struct ring_buffer *buffer,
                                         struct ring_buffer_event *event,
                                         unsigned long flags, int pc);
-void trace_nowake_buffer_unlock_commit(struct ring_buffer *buffer,
-                                       struct ring_buffer_event *event,
-                                        unsigned long flags, int pc);
-void trace_nowake_buffer_unlock_commit_regs(struct ring_buffer *buffer,
-                                            struct ring_buffer_event *event,
-                                            unsigned long flags, int pc,
-                                            struct pt_regs *regs);
+void trace_buffer_unlock_commit(struct ring_buffer *buffer,
+                                struct ring_buffer_event *event,
+                                unsigned long flags, int pc);
+void trace_buffer_unlock_commit_regs(struct ring_buffer *buffer,
+                                     struct ring_buffer_event *event,
+                                     unsigned long flags, int pc,
+                                     struct pt_regs *regs);
 void trace_current_buffer_discard_commit(struct ring_buffer *buffer,
                                          struct ring_buffer_event *event);
 
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 02c1c9710be0..31e8041274f6 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -31,6 +31,7 @@ struct vm_area_struct;
 #define ___GFP_THISNODE         0x40000u
 #define ___GFP_RECLAIMABLE      0x80000u
 #define ___GFP_NOTRACK          0x200000u
+#define ___GFP_NO_KSWAPD        0x400000u
 #define ___GFP_OTHER_NODE       0x800000u
 #define ___GFP_WRITE            0x1000000u
 
@@ -85,6 +86,7 @@ struct vm_area_struct;
 #define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE) /* Page is reclaimable */
 #define __GFP_NOTRACK   ((__force gfp_t)___GFP_NOTRACK)  /* Don't track with kmemcheck */
 
+#define __GFP_NO_KSWAPD ((__force gfp_t)___GFP_NO_KSWAPD)
 #define __GFP_OTHER_NODE ((__force gfp_t)___GFP_OTHER_NODE) /* On behalf of other node */
 #define __GFP_WRITE     ((__force gfp_t)___GFP_WRITE)   /* Allocator intends to dirty page */
 
@@ -114,7 +116,8 @@ struct vm_area_struct;
                                  __GFP_MOVABLE)
 #define GFP_IOFS        (__GFP_IO | __GFP_FS)
 #define GFP_TRANSHUGE   (GFP_HIGHUSER_MOVABLE | __GFP_COMP | \
-                         __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN)
+                         __GFP_NOMEMALLOC | __GFP_NORETRY | __GFP_NOWARN | \
+                         __GFP_NO_KSWAPD)
 
 #ifdef CONFIG_NUMA
 #define GFP_THISNODE    (__GFP_THISNODE | __GFP_NOWARN | __GFP_NORETRY)
@@ -263,7 +266,7 @@ static inline enum zone_type gfp_zone(gfp_t flags)
 
 static inline int gfp_zonelist(gfp_t flags)
 {
-        if (NUMA_BUILD && unlikely(flags & __GFP_THISNODE))
+        if (IS_ENABLED(CONFIG_NUMA) && unlikely(flags & __GFP_THISNODE))
                 return 1;
 
         return 0;
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 2e31e8b3a190..bfe665621536 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -72,9 +72,9 @@ static inline int irq_to_gpio(unsigned int irq)
         return -EINVAL;
 }
 
-#endif
+#endif /* ! CONFIG_ARCH_HAVE_CUSTOM_GPIO_H */
 
-#else
+#else /* ! CONFIG_GENERIC_GPIO */
 
 #include <linux/kernel.h>
 #include <linux/types.h>
@@ -231,6 +231,21 @@ static inline int irq_to_gpio(unsigned irq)
         return -EINVAL;
 }
 
-#endif
+static inline int
+gpiochip_add_pin_range(struct gpio_chip *chip, const char *pinctl_name,
+                       unsigned int gpio_offset, unsigned int pin_offset,
+                       unsigned int npins)
+{
+        WARN_ON(1);
+        return -EINVAL;
+}
+
+static inline void
+gpiochip_remove_pin_ranges(struct gpio_chip *chip)
+{
+        WARN_ON(1);
+}
+
+#endif /* ! CONFIG_GENERIC_GPIO */
 
 #endif /* __LINUX_GPIO_H */
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index cab3da3d0949..624ef3f45c8e 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -4,6 +4,7 @@
 #include <linux/preempt.h>
 #include <linux/lockdep.h>
 #include <linux/ftrace_irq.h>
+#include <linux/vtime.h>
 #include <asm/hardirq.h>
 
 /*
@@ -129,16 +130,6 @@ extern void synchronize_irq(unsigned int irq);
 # define synchronize_irq(irq)   barrier()
 #endif
 
-struct task_struct;
-
-#if !defined(CONFIG_VIRT_CPU_ACCOUNTING) && !defined(CONFIG_IRQ_TIME_ACCOUNTING)
-static inline void vtime_account(struct task_struct *tsk)
-{
-}
-#else
-extern void vtime_account(struct task_struct *tsk);
-#endif
-
 #if defined(CONFIG_TINY_RCU) || defined(CONFIG_TINY_PREEMPT_RCU)
 
 static inline void rcu_nmi_enter(void)
@@ -162,7 +153,7 @@ extern void rcu_nmi_exit(void);
  */
 #define __irq_enter()                                   \
         do {                                            \
-                vtime_account(current);         \
+                vtime_account_irq_enter(current);       \
                 add_preempt_count(HARDIRQ_OFFSET);      \
                 trace_hardirq_enter();                  \
         } while (0)
@@ -178,7 +169,7 @@ extern void irq_enter(void);
 #define __irq_exit()                                    \
         do {                                            \
                 trace_hardirq_exit();                   \
-                vtime_account(current);         \
+                vtime_account_irq_exit(current);        \
                 sub_preempt_count(HARDIRQ_OFFSET);      \
         } while (0)
 
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index b31cb7da0346..1af477552459 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -8,6 +8,10 @@ extern int do_huge_pmd_anonymous_page(struct mm_struct *mm,
 extern int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
                          pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
                          struct vm_area_struct *vma);
+extern void huge_pmd_set_accessed(struct mm_struct *mm,
+                                  struct vm_area_struct *vma,
+                                  unsigned long address, pmd_t *pmd,
+                                  pmd_t orig_pmd, int dirty);
 extern int do_huge_pmd_wp_page(struct mm_struct *mm, struct vm_area_struct *vma,
                                unsigned long address, pmd_t *pmd,
                                pmd_t orig_pmd);
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 225164842ab6..3e7fa1acf09c 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -183,7 +183,8 @@ extern const struct file_operations hugetlbfs_file_operations;
 extern const struct vm_operations_struct hugetlb_vm_ops;
 struct file *hugetlb_file_setup(const char *name, unsigned long addr,
                                 size_t size, vm_flags_t acct,
-                                struct user_struct **user, int creat_flags);
+                                struct user_struct **user, int creat_flags,
+                                int page_size_log);
 
 static inline int is_file_hugepages(struct file *file)
 {
@@ -195,12 +196,14 @@ static inline int is_file_hugepages(struct file *file)
         return 0;
 }
 
+
 #else /* !CONFIG_HUGETLBFS */
 
 #define is_file_hugepages(file)                 0
 static inline struct file *
 hugetlb_file_setup(const char *name, unsigned long addr, size_t size,
-                vm_flags_t acctflag, struct user_struct **user, int creat_flags)
+                vm_flags_t acctflag, struct user_struct **user, int creat_flags,
+                int page_size_log)
 {
         return ERR_PTR(-ENOSYS);
 }
diff --git a/include/linux/hw_breakpoint.h b/include/linux/hw_breakpoint.h
index 6ae9c631a1be..0464c85e63fd 100644
--- a/include/linux/hw_breakpoint.h
+++ b/include/linux/hw_breakpoint.h
@@ -1,35 +1,8 @@
 #ifndef _LINUX_HW_BREAKPOINT_H
 #define _LINUX_HW_BREAKPOINT_H
 
-enum {
-        HW_BREAKPOINT_LEN_1 = 1,
-        HW_BREAKPOINT_LEN_2 = 2,
-        HW_BREAKPOINT_LEN_4 = 4,
-        HW_BREAKPOINT_LEN_8 = 8,
-};
-
-enum {
-        HW_BREAKPOINT_EMPTY     = 0,
-        HW_BREAKPOINT_R         = 1,
-        HW_BREAKPOINT_W         = 2,
-        HW_BREAKPOINT_RW        = HW_BREAKPOINT_R | HW_BREAKPOINT_W,
-        HW_BREAKPOINT_X         = 4,
-        HW_BREAKPOINT_INVALID   = HW_BREAKPOINT_RW | HW_BREAKPOINT_X,
-};
-
-enum bp_type_idx {
-        TYPE_INST       = 0,
-#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
-        TYPE_DATA       = 0,
-#else
-        TYPE_DATA       = 1,
-#endif
-        TYPE_MAX
-};
-
-#ifdef __KERNEL__
-
 #include <linux/perf_event.h>
+#include <uapi/linux/hw_breakpoint.h>
 
 #ifdef CONFIG_HAVE_HW_BREAKPOINT
 
@@ -151,6 +124,4 @@ static inline struct arch_hw_breakpoint *counter_arch_bp(struct perf_event *bp)
 }
 
 #endif /* CONFIG_HAVE_HW_BREAKPOINT */
-#endif /* __KERNEL__ */
-
 #endif /* _LINUX_HW_BREAKPOINT_H */
diff --git a/include/linux/i2c-omap.h b/include/linux/i2c-omap.h
index df804ba73e0b..92a0dc75bc74 100644
--- a/include/linux/i2c-omap.h
+++ b/include/linux/i2c-omap.h
@@ -34,6 +34,7 @@ struct omap_i2c_bus_platform_data {
         u32             clkrate;
         u32             rev;
         u32             flags;
+        void            (*set_mpu_wkup_lat)(struct device *dev, long set);
 };
 
 #endif
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 800de224336b..d0c4db7b4872 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -259,6 +259,7 @@ static inline void i2c_set_clientdata(struct i2c_client *dev, void *data)
  * @platform_data: stored in i2c_client.dev.platform_data
  * @archdata: copied into i2c_client.dev.archdata
  * @of_node: pointer to OpenFirmware device node
+ * @acpi_node: ACPI device node
  * @irq: stored in i2c_client.irq
  *
  * I2C doesn't actually support hardware probing, although controllers and
@@ -279,6 +280,7 @@ struct i2c_board_info {
         void            *platform_data;
         struct dev_archdata     *archdata;
         struct device_node *of_node;
+        struct acpi_dev_node acpi_node;
         int             irq;
 };
 
@@ -501,4 +503,11 @@ static inline int i2c_adapter_id(struct i2c_adapter *adap)
                         i2c_del_driver)
 
 #endif /* I2C */
+
+#if IS_ENABLED(CONFIG_ACPI_I2C)
+extern void acpi_i2c_register_devices(struct i2c_adapter *adap);
+#else
+static inline void acpi_i2c_register_devices(struct i2c_adapter *adap) {}
+#endif
+
 #endif /* _LINUX_I2C_H */
diff --git a/include/linux/i2c/pcf857x.h b/include/linux/i2c/pcf857x.h
index 781e6bd06c34..0767a2a6b2f1 100644
--- a/include/linux/i2c/pcf857x.h
+++ b/include/linux/i2c/pcf857x.h
@@ -10,7 +10,6 @@
  * @setup: optional callback issued once the GPIOs are valid
  * @teardown: optional callback issued before the GPIOs are invalidated
  * @context: optional parameter passed to setup() and teardown()
- * @irq: optional interrupt number
  *
  * In addition to the I2C_BOARD_INFO() state appropriate to each chip,
  * the i2c_board_info used with the pcf875x driver must provide its
@@ -40,8 +39,6 @@ struct pcf857x_platform_data {
                                         int gpio, unsigned ngpio,
                                         void *context);
         void            *context;
-
-        int             irq;
 };
 
 #endif /* __LINUX_PCF857X_H */
diff --git a/include/linux/iio/buffer.h b/include/linux/iio/buffer.h
index c629b3a1d9a9..f3eea18fdf46 100644
--- a/include/linux/iio/buffer.h
+++ b/include/linux/iio/buffer.h
@@ -66,7 +66,8 @@ struct iio_buffer_access_funcs {
  * @stufftoread:        [INTERN] flag to indicate new data.
  * @demux_list:         [INTERN] list of operations required to demux the scan.
  * @demux_bounce:       [INTERN] buffer for doing gather from incoming scan.
- **/
+ * @buffer_list:        [INTERN] entry in the devices list of current buffers.
+ */
 struct iio_buffer {
         int                                     length;
         int                                     bytes_per_datum;
@@ -81,9 +82,22 @@ struct iio_buffer {
         const struct attribute_group *attrs;
         struct list_head                        demux_list;
         unsigned char                           *demux_bounce;
+        struct list_head                        buffer_list;
 };
 
 /**
+ * iio_update_buffers() - add or remove buffer from active list
+ * @indio_dev:          device to add buffer to
+ * @insert_buffer:      buffer to insert
+ * @remove_buffer:      buffer_to_remove
+ *
+ * Note this will tear down the all buffering and build it up again
+ */
+int iio_update_buffers(struct iio_dev *indio_dev,
+                       struct iio_buffer *insert_buffer,
+                       struct iio_buffer *remove_buffer);
+
+/**
  * iio_buffer_init() - Initialize the buffer structure
  * @buffer:             buffer to be initialized
  **/
@@ -115,11 +129,11 @@ int iio_scan_mask_set(struct iio_dev *indio_dev,
                       struct iio_buffer *buffer, int bit);
 
 /**
- * iio_push_to_buffer() - push to a registered buffer.
- * @buffer:             IIO buffer structure for device
- * @data:               the data to push to the buffer
+ * iio_push_to_buffers() - push to a registered buffer.
+ * @indio_dev:          iio_dev structure for device.
+ * @data:               Full scan.
  */
-int iio_push_to_buffer(struct iio_buffer *buffer, unsigned char *data);
+int iio_push_to_buffers(struct iio_dev *indio_dev, unsigned char *data);
 
 int iio_update_demux(struct iio_dev *indio_dev);
 
@@ -181,7 +195,7 @@ bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
 #else /* CONFIG_IIO_BUFFER */
 
 static inline int iio_buffer_register(struct iio_dev *indio_dev,
-                                           struct iio_chan_spec *channels,
+                                           const struct iio_chan_spec *channels,
                                            int num_channels)
 {
         return 0;
diff --git a/include/linux/iio/consumer.h b/include/linux/iio/consumer.h
index e875bcf0478f..16c35ac045bd 100644
--- a/include/linux/iio/consumer.h
+++ b/include/linux/iio/consumer.h
@@ -9,6 +9,8 @@
  */
 #ifndef _IIO_INKERN_CONSUMER_H_
 #define _IIO_INKERN_CONSUMER_H_
+
+#include <linux/types.h>
 #include <linux/iio/types.h>
 
 struct iio_dev;
@@ -18,10 +20,12 @@ struct iio_chan_spec;
  * struct iio_channel - everything needed for a consumer to use a channel
  * @indio_dev:          Device on which the channel exists.
  * @channel:            Full description of the channel.
+ * @data:               Data about the channel used by consumer.
  */
 struct iio_channel {
         struct iio_dev *indio_dev;
         const struct iio_chan_spec *channel;
+        void *data;
 };
 
 /**
@@ -59,6 +63,52 @@ struct iio_channel *iio_channel_get_all(const char *name);
  */
 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.
+ * @cb:                 Callback function.
+ * @private:            Private data passed to callback.
+ *
+ * NB right now we have no ability to mux data from multiple devices.
+ * So if the channels requested come from different devices this will
+ * fail.
+ */
+struct iio_cb_buffer *iio_channel_get_all_cb(const char *name,
+                                             int (*cb)(u8 *data,
+                                                       void *private),
+                                             void *private);
+/**
+ * iio_channel_release_all_cb() - release and unregister the callback.
+ * @cb_buffer:          The callback buffer that was allocated.
+ */
+void iio_channel_release_all_cb(struct iio_cb_buffer *cb_buffer);
+
+/**
+ * iio_channel_start_all_cb() - start the flow of data through callback.
+ * @cb_buff:            The callback buffer we are starting.
+ */
+int iio_channel_start_all_cb(struct iio_cb_buffer *cb_buff);
+
+/**
+ * iio_channel_stop_all_cb() - stop the flow of data through the callback.
+ * @cb_buff:            The callback buffer we are stopping.
+ */
+void iio_channel_stop_all_cb(struct iio_cb_buffer *cb_buff);
+
+/**
+ * iio_channel_cb_get_channels() - get access to the underlying channels.
+ * @cb_buff:            The callback buffer from whom we want the channel
+ *                      information.
+ *
+ * This function allows one to obtain information about the channels.
+ * Whilst this may allow direct reading if all buffers are disabled, the
+ * primary aim is to allow drivers that are consuming a channel to query
+ * things like scaling of the channel.
+ */
+struct iio_channel
+*iio_channel_cb_get_channels(const struct iio_cb_buffer *cb_buffer);
+
 /**
  * iio_read_channel_raw() - read from a given channel
  * @chan:               The channel being queried.
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 7806c24e5bc8..da8c776ba0bd 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -410,6 +410,7 @@ struct iio_buffer_setup_ops {
  *                      and owner
  * @event_interface:    [INTERN] event chrdevs associated with interrupt lines
  * @buffer:             [DRIVER] any buffer present
+ * @buffer_list:        [INTERN] list of all buffers currently attached
  * @scan_bytes:         [INTERN] num bytes captured to be fed to buffer demux
  * @mlock:              [INTERN] lock used to prevent simultaneous device state
  *                      changes
@@ -448,6 +449,7 @@ struct iio_dev {
         struct iio_event_interface      *event_interface;
 
         struct iio_buffer               *buffer;
+        struct list_head                buffer_list;
         int                             scan_bytes;
         struct mutex                    mlock;
 
@@ -618,6 +620,9 @@ static inline struct dentry *iio_get_debugfs_dentry(struct iio_dev *indio_dev)
 };
 #endif
 
+int iio_str_to_fixpoint(const char *str, int fract_mult, int *integer,
+        int *fract);
+
 /**
  * IIO_DEGREE_TO_RAD() - Convert degree to rad
  * @deg: A value in degree
diff --git a/include/linux/iio/imu/adis.h b/include/linux/iio/imu/adis.h
new file mode 100644
index 000000000000..ff781dca2e9a
--- /dev/null
+++ b/include/linux/iio/imu/adis.h
@@ -0,0 +1,280 @@
+/*
+ * Common library for ADIS16XXX devices
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *   Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * Licensed under the GPL-2 or later.
+ */
+
+#ifndef __IIO_ADIS_H__
+#define __IIO_ADIS_H__
+
+#include <linux/spi/spi.h>
+#include <linux/interrupt.h>
+#include <linux/iio/types.h>
+
+#define ADIS_WRITE_REG(reg) ((0x80 | (reg)))
+#define ADIS_READ_REG(reg) ((reg) & 0x7f)
+
+#define ADIS_PAGE_SIZE 0x80
+#define ADIS_REG_PAGE_ID 0x00
+
+struct adis;
+
+/**
+ * struct adis_data - ADIS chip variant specific data
+ * @read_delay: SPI delay for read operations in us
+ * @write_delay: SPI delay for write operations in us
+ * @glob_cmd_reg: Register address of the GLOB_CMD register
+ * @msc_ctrl_reg: Register address of the MSC_CTRL register
+ * @diag_stat_reg: Register address of the DIAG_STAT register
+ * @status_error_msgs: Array of error messgaes
+ * @status_error_mask:
+ */
+struct adis_data {
+        unsigned int read_delay;
+        unsigned int write_delay;
+
+        unsigned int glob_cmd_reg;
+        unsigned int msc_ctrl_reg;
+        unsigned int diag_stat_reg;
+
+        unsigned int self_test_mask;
+        unsigned int startup_delay;
+
+        const char * const *status_error_msgs;
+        unsigned int status_error_mask;
+
+        int (*enable_irq)(struct adis *adis, bool enable);
+
+        bool has_paging;
+};
+
+struct adis {
+        struct spi_device       *spi;
+        struct iio_trigger      *trig;
+
+        const struct adis_data  *data;
+
+        struct mutex            txrx_lock;
+        struct spi_message      msg;
+        struct spi_transfer     *xfer;
+        unsigned int            current_page;
+        void                    *buffer;
+
+        uint8_t                 tx[10] ____cacheline_aligned;
+        uint8_t                 rx[4];
+};
+
+int adis_init(struct adis *adis, struct iio_dev *indio_dev,
+        struct spi_device *spi, const struct adis_data *data);
+int adis_reset(struct adis *adis);
+
+int adis_write_reg(struct adis *adis, unsigned int reg,
+        unsigned int val, unsigned int size);
+int adis_read_reg(struct adis *adis, unsigned int reg,
+        unsigned int *val, unsigned int size);
+
+/**
+ * adis_write_reg_8() - Write single byte to a register
+ * @adis: The adis device
+ * @reg: The address of the register to be written
+ * @value: The value to write
+ */
+static inline int adis_write_reg_8(struct adis *adis, unsigned int reg,
+        uint8_t val)
+{
+        return adis_write_reg(adis, reg, val, 1);
+}
+
+/**
+ * adis_write_reg_16() - Write 2 bytes to a pair of registers
+ * @adis: The adis device
+ * @reg: The address of the lower of the two registers
+ * @value: Value to be written
+ */
+static inline int adis_write_reg_16(struct adis *adis, unsigned int reg,
+        uint16_t val)
+{
+        return adis_write_reg(adis, reg, val, 2);
+}
+
+/**
+ * adis_write_reg_32() - write 4 bytes to four registers
+ * @adis: The adis device
+ * @reg: The address of the lower of the four register
+ * @value: Value to be written
+ */
+static inline int adis_write_reg_32(struct adis *adis, unsigned int reg,
+        uint32_t val)
+{
+        return adis_write_reg(adis, reg, val, 4);
+}
+
+/**
+ * adis_read_reg_16() - read 2 bytes from a 16-bit register
+ * @adis: The adis device
+ * @reg: The address of the lower of the two registers
+ * @val: The value read back from the device
+ */
+static inline int adis_read_reg_16(struct adis *adis, unsigned int reg,
+        uint16_t *val)
+{
+        unsigned int tmp;
+        int ret;
+
+        ret = adis_read_reg(adis, reg, &tmp, 2);
+        *val = tmp;
+
+        return ret;
+}
+
+/**
+ * adis_read_reg_32() - read 4 bytes from a 32-bit register
+ * @adis: The adis device
+ * @reg: The address of the lower of the two registers
+ * @val: The value read back from the device
+ */
+static inline int adis_read_reg_32(struct adis *adis, unsigned int reg,
+        uint32_t *val)
+{
+        unsigned int tmp;
+        int ret;
+
+        ret = adis_read_reg(adis, reg, &tmp, 4);
+        *val = tmp;
+
+        return ret;
+}
+
+int adis_enable_irq(struct adis *adis, bool enable);
+int adis_check_status(struct adis *adis);
+
+int adis_initial_startup(struct adis *adis);
+
+int adis_single_conversion(struct iio_dev *indio_dev,
+        const struct iio_chan_spec *chan, unsigned int error_mask,
+        int *val);
+
+#define ADIS_VOLTAGE_CHAN(addr, si, chan, name, bits) { \
+        .type = IIO_VOLTAGE, \
+        .indexed = 1, \
+        .channel = (chan), \
+        .extend_name = name, \
+        .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+                IIO_CHAN_INFO_SCALE_SEPARATE_BIT, \
+        .address = (addr), \
+        .scan_index = (si), \
+        .scan_type = { \
+                .sign = 'u', \
+                .realbits = (bits), \
+                .storagebits = 16, \
+                .endianness = IIO_BE, \
+        }, \
+}
+
+#define ADIS_SUPPLY_CHAN(addr, si, bits) \
+        ADIS_VOLTAGE_CHAN(addr, si, 0, "supply", bits)
+
+#define ADIS_AUX_ADC_CHAN(addr, si, bits) \
+        ADIS_VOLTAGE_CHAN(addr, si, 1, NULL, bits)
+
+#define ADIS_TEMP_CHAN(addr, si, bits) { \
+        .type = IIO_TEMP, \
+        .indexed = 1, \
+        .channel = 0, \
+        .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+                IIO_CHAN_INFO_SCALE_SEPARATE_BIT | \
+                IIO_CHAN_INFO_OFFSET_SEPARATE_BIT, \
+        .address = (addr), \
+        .scan_index = (si), \
+        .scan_type = { \
+                .sign = 'u', \
+                .realbits = (bits), \
+                .storagebits = 16, \
+                .endianness = IIO_BE, \
+        }, \
+}
+
+#define ADIS_MOD_CHAN(_type, mod, addr, si, info, bits) { \
+        .type = (_type), \
+        .modified = 1, \
+        .channel2 = IIO_MOD_ ## mod, \
+        .info_mask = IIO_CHAN_INFO_RAW_SEPARATE_BIT | \
+                 IIO_CHAN_INFO_SCALE_SHARED_BIT | \
+                 info, \
+        .address = (addr), \
+        .scan_index = (si), \
+        .scan_type = { \
+                .sign = 's', \
+                .realbits = (bits), \
+                .storagebits = 16, \
+                .endianness = IIO_BE, \
+        }, \
+}
+
+#define ADIS_ACCEL_CHAN(mod, addr, si, info, bits) \
+        ADIS_MOD_CHAN(IIO_ACCEL, mod, addr, si, info, bits)
+
+#define ADIS_GYRO_CHAN(mod, addr, si, info, bits) \
+        ADIS_MOD_CHAN(IIO_ANGL_VEL, mod, addr, si, info, bits)
+
+#define ADIS_INCLI_CHAN(mod, addr, si, info, bits) \
+        ADIS_MOD_CHAN(IIO_INCLI, mod, addr, si, info, bits)
+
+#define ADIS_ROT_CHAN(mod, addr, si, info, bits) \
+        ADIS_MOD_CHAN(IIO_ROT, mod, addr, si, info, bits)
+
+#ifdef CONFIG_IIO_ADIS_LIB_BUFFER
+
+int adis_setup_buffer_and_trigger(struct adis *adis,
+        struct iio_dev *indio_dev, irqreturn_t (*trigger_handler)(int, void *));
+void adis_cleanup_buffer_and_trigger(struct adis *adis,
+        struct iio_dev *indio_dev);
+
+int adis_probe_trigger(struct adis *adis, struct iio_dev *indio_dev);
+void adis_remove_trigger(struct adis *adis);
+
+int adis_update_scan_mode(struct iio_dev *indio_dev,
+        const unsigned long *scan_mask);
+
+#else /* CONFIG_IIO_BUFFER */
+
+static inline int adis_setup_buffer_and_trigger(struct adis *adis,
+        struct iio_dev *indio_dev, irqreturn_t (*trigger_handler)(int, void *))
+{
+        return 0;
+}
+
+static inline void adis_cleanup_buffer_and_trigger(struct adis *adis,
+        struct iio_dev *indio_dev)
+{
+}
+
+static inline int adis_probe_trigger(struct adis *adis,
+        struct iio_dev *indio_dev)
+{
+        return 0;
+}
+
+static inline void adis_remove_trigger(struct adis *adis)
+{
+}
+
+#define adis_update_scan_mode NULL
+
+#endif /* CONFIG_IIO_BUFFER */
+
+#ifdef CONFIG_DEBUG_FS
+
+int adis_debugfs_reg_access(struct iio_dev *indio_dev,
+        unsigned int reg, unsigned int writeval, unsigned int *readval);
+
+#else
+
+#define adis_debugfs_reg_access NULL
+
+#endif
+
+#endif
diff --git a/include/linux/iio/machine.h b/include/linux/iio/machine.h
index 809a3f08d5a5..1601a2a63a72 100644
--- a/include/linux/iio/machine.h
+++ b/include/linux/iio/machine.h
@@ -19,11 +19,13 @@
  * @consumer_dev_name:  Name to uniquely identify the consumer device.
  * @consumer_channel:   Unique name used to identify the channel on the
  *                      consumer side.
+ * @consumer_data:      Data about the channel for use by the consumer driver.
  */
 struct iio_map {
         const char *adc_channel_label;
         const char *consumer_dev_name;
         const char *consumer_channel;
+        void *consumer_data;
 };
 
 #endif
diff --git a/include/linux/iio/types.h b/include/linux/iio/types.h
index 5c647ecfd5ba..88bf0f0d27b4 100644
--- a/include/linux/iio/types.h
+++ b/include/linux/iio/types.h
@@ -28,6 +28,7 @@ enum iio_chan_type {
         IIO_CAPACITANCE,
         IIO_ALTVOLTAGE,
         IIO_CCT,
+        IIO_PRESSURE,
 };
 
 enum iio_modifier {
@@ -58,5 +59,6 @@ enum iio_modifier {
 #define IIO_VAL_INT_PLUS_NANO 3
 #define IIO_VAL_INT_PLUS_MICRO_DB 4
 #define IIO_VAL_FRACTIONAL 10
+#define IIO_VAL_FRACTIONAL_LOG2 11
 
 #endif /* _IIO_TYPES_H_ */
diff --git a/include/linux/init.h b/include/linux/init.h
index e59041e21df3..f63692d6902e 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -93,13 +93,13 @@
 
 #define __exit          __section(.exit.text) __exitused __cold notrace
 
-/* Used for HOTPLUG */
-#define __devinit        __section(.devinit.text) __cold notrace
-#define __devinitdata    __section(.devinit.data)
-#define __devinitconst   __constsection(.devinit.rodata)
-#define __devexit        __section(.devexit.text) __exitused __cold notrace
-#define __devexitdata    __section(.devexit.data)
-#define __devexitconst   __constsection(.devexit.rodata)
+/* Used for HOTPLUG, but that is always enabled now, so just make them noops */
+#define __devinit
+#define __devinitdata
+#define __devinitconst
+#define __devexit
+#define __devexitdata
+#define __devexitconst
 
 /* Used for HOTPLUG_CPU */
 #define __cpuinit        __section(.cpuinit.text) __cold notrace
@@ -126,10 +126,6 @@
 #define __INITRODATA    .section        ".init.rodata","a",%progbits
 #define __FINITDATA     .previous
 
-#define __DEVINIT        .section       ".devinit.text", "ax"
-#define __DEVINITDATA    .section       ".devinit.data", "aw"
-#define __DEVINITRODATA  .section       ".devinit.rodata", "a"
-
 #define __CPUINIT        .section       ".cpuinit.text", "ax"
 #define __CPUINITDATA    .section       ".cpuinit.data", "aw"
 #define __CPUINITRODATA  .section       ".cpuinit.rodata", "a"
diff --git a/include/linux/ipack.h b/include/linux/ipack.h
new file mode 100644
index 000000000000..fea12cbb2aeb
--- /dev/null
+++ b/include/linux/ipack.h
@@ -0,0 +1,245 @@
+/*
+ * Industry-pack bus.
+ *
+ * Copyright (C) 2011-2012 CERN (www.cern.ch)
+ * Author: Samuel Iglesias Gonsalvez <siglesias@igalia.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; version 2 of the License.
+ */
+
+#include <linux/mod_devicetable.h>
+#include <linux/device.h>
+#include <linux/interrupt.h>
+
+#define IPACK_IDPROM_OFFSET_I                   0x01
+#define IPACK_IDPROM_OFFSET_P                   0x03
+#define IPACK_IDPROM_OFFSET_A                   0x05
+#define IPACK_IDPROM_OFFSET_C                   0x07
+#define IPACK_IDPROM_OFFSET_MANUFACTURER_ID     0x09
+#define IPACK_IDPROM_OFFSET_MODEL               0x0B
+#define IPACK_IDPROM_OFFSET_REVISION            0x0D
+#define IPACK_IDPROM_OFFSET_RESERVED            0x0F
+#define IPACK_IDPROM_OFFSET_DRIVER_ID_L         0x11
+#define IPACK_IDPROM_OFFSET_DRIVER_ID_H         0x13
+#define IPACK_IDPROM_OFFSET_NUM_BYTES           0x15
+#define IPACK_IDPROM_OFFSET_CRC                 0x17
+
+/*
+ * IndustryPack Fromat, Vendor and Device IDs.
+ */
+
+/* ID section format versions */
+#define IPACK_ID_VERSION_INVALID        0x00
+#define IPACK_ID_VERSION_1              0x01
+#define IPACK_ID_VERSION_2              0x02
+
+/* Vendors and devices. Sort key: vendor first, device next. */
+#define IPACK1_VENDOR_ID_RESERVED1      0x00
+#define IPACK1_VENDOR_ID_RESERVED2      0xFF
+#define IPACK1_VENDOR_ID_UNREGISTRED01  0x01
+#define IPACK1_VENDOR_ID_UNREGISTRED02  0x02
+#define IPACK1_VENDOR_ID_UNREGISTRED03  0x03
+#define IPACK1_VENDOR_ID_UNREGISTRED04  0x04
+#define IPACK1_VENDOR_ID_UNREGISTRED05  0x05
+#define IPACK1_VENDOR_ID_UNREGISTRED06  0x06
+#define IPACK1_VENDOR_ID_UNREGISTRED07  0x07
+#define IPACK1_VENDOR_ID_UNREGISTRED08  0x08
+#define IPACK1_VENDOR_ID_UNREGISTRED09  0x09
+#define IPACK1_VENDOR_ID_UNREGISTRED10  0x0A
+#define IPACK1_VENDOR_ID_UNREGISTRED11  0x0B
+#define IPACK1_VENDOR_ID_UNREGISTRED12  0x0C
+#define IPACK1_VENDOR_ID_UNREGISTRED13  0x0D
+#define IPACK1_VENDOR_ID_UNREGISTRED14  0x0E
+#define IPACK1_VENDOR_ID_UNREGISTRED15  0x0F
+
+#define IPACK1_VENDOR_ID_SBS            0xF0
+#define IPACK1_DEVICE_ID_SBS_OCTAL_232  0x22
+#define IPACK1_DEVICE_ID_SBS_OCTAL_422  0x2A
+#define IPACK1_DEVICE_ID_SBS_OCTAL_485  0x48
+
+struct ipack_bus_ops;
+struct ipack_driver;
+
+enum ipack_space {
+        IPACK_IO_SPACE    = 0,
+        IPACK_ID_SPACE,
+        IPACK_INT_SPACE,
+        IPACK_MEM8_SPACE,
+        IPACK_MEM16_SPACE,
+        /* Dummy for counting the number of entries.  Must remain the last
+         * entry */
+        IPACK_SPACE_COUNT,
+};
+
+/**
+ */
+struct ipack_region {
+        phys_addr_t start;
+        size_t      size;
+};
+
+/**
+ *      struct ipack_device
+ *
+ *      @slot: Slot where the device is plugged in the carrier board
+ *      @bus: ipack_bus_device where the device is plugged to.
+ *      @id_space: Virtual address to ID space.
+ *      @io_space: Virtual address to IO space.
+ *      @mem_space: Virtual address to MEM space.
+ *      @dev: device in kernel representation.
+ *
+ * Warning: Direct access to mapped memory is possible but the endianness
+ * is not the same with PCI carrier or VME carrier. The endianness is managed
+ * by the carrier board throught bus->ops.
+ */
+struct ipack_device {
+        unsigned int slot;
+        struct ipack_bus_device *bus;
+        struct device dev;
+        void (*release) (struct ipack_device *dev);
+        struct ipack_region      region[IPACK_SPACE_COUNT];
+        u8                      *id;
+        size_t                   id_avail;
+        u32                      id_vendor;
+        u32                      id_device;
+        u8                       id_format;
+        unsigned int             id_crc_correct:1;
+        unsigned int             speed_8mhz:1;
+        unsigned int             speed_32mhz:1;
+};
+
+/**
+ * struct ipack_driver_ops -- Callbacks to IPack device driver
+ *
+ * @probe:  Probe function
+ * @remove: Prepare imminent removal of the device.  Services provided by the
+ *          device should be revoked.
+ */
+
+struct ipack_driver_ops {
+        int (*probe) (struct ipack_device *dev);
+        void (*remove) (struct ipack_device *dev);
+};
+
+/**
+ * struct ipack_driver -- Specific data to each ipack device driver
+ *
+ * @driver: Device driver kernel representation
+ * @ops:    Callbacks provided by the IPack device driver
+ */
+struct ipack_driver {
+        struct device_driver driver;
+        const struct ipack_device_id *id_table;
+        const struct ipack_driver_ops *ops;
+};
+
+/**
+ *      struct ipack_bus_ops - available operations on a bridge module
+ *
+ *      @map_space: map IP address space
+ *      @unmap_space: unmap IP address space
+ *      @request_irq: request IRQ
+ *      @free_irq: free IRQ
+ *      @get_clockrate: Returns the clockrate the carrier is currently
+ *              communicating with the device at.
+ *      @set_clockrate: Sets the clock-rate for carrier / module communication.
+ *              Should return -EINVAL if the requested speed is not supported.
+ *      @get_error: Returns the error state for the slot the device is attached
+ *              to.
+ *      @get_timeout: Returns 1 if the communication with the device has
+ *              previously timed out.
+ *      @reset_timeout: Resets the state returned by get_timeout.
+ */
+struct ipack_bus_ops {
+        int (*request_irq) (struct ipack_device *dev,
+                            irqreturn_t (*handler)(void *), void *arg);
+        int (*free_irq) (struct ipack_device *dev);
+        int (*get_clockrate) (struct ipack_device *dev);
+        int (*set_clockrate) (struct ipack_device *dev, int mherz);
+        int (*get_error) (struct ipack_device *dev);
+        int (*get_timeout) (struct ipack_device *dev);
+        int (*reset_timeout) (struct ipack_device *dev);
+};
+
+/**
+ *      struct ipack_bus_device
+ *
+ *      @dev: pointer to carrier device
+ *      @slots: number of slots available
+ *      @bus_nr: ipack bus number
+ *      @ops: bus operations for the mezzanine drivers
+ */
+struct ipack_bus_device {
+        struct device *parent;
+        int slots;
+        int bus_nr;
+        const struct ipack_bus_ops *ops;
+};
+
+/**
+ *      ipack_bus_register -- register a new ipack bus
+ *
+ * @parent: pointer to the parent device, if any.
+ * @slots: number of slots available in the bus device.
+ * @ops: bus operations for the mezzanine drivers.
+ *
+ * The carrier board device should call this function to register itself as
+ * available bus device in ipack.
+ */
+struct ipack_bus_device *ipack_bus_register(struct device *parent, int slots,
+                                            const struct ipack_bus_ops *ops);
+
+/**
+ *      ipack_bus_unregister -- unregister an ipack bus
+ */
+int ipack_bus_unregister(struct ipack_bus_device *bus);
+
+/**
+ * ipack_driver_register -- Register a new ipack device driver
+ *
+ * Called by a ipack driver to register itself as a driver
+ * that can manage ipack devices.
+ */
+int ipack_driver_register(struct ipack_driver *edrv, struct module *owner,
+                          const char *name);
+void ipack_driver_unregister(struct ipack_driver *edrv);
+
+/**
+ *      ipack_device_register -- register an IPack device with the kernel
+ *      @dev: the new device to register.
+ *
+ *      Register a new IPack device ("module" in IndustryPack jargon). The call
+ *      is done by the carrier driver.  The carrier should populate the fields
+ *      bus and slot as well as the region array of @dev prior to calling this
+ *      function.  The rest of the fields will be allocated and populated
+ *      during registration.
+ *
+ *      Return zero on success or error code on failure.
+ */
+int ipack_device_register(struct ipack_device *dev);
+void ipack_device_unregister(struct ipack_device *dev);
+
+/**
+ * DEFINE_IPACK_DEVICE_TABLE - macro used to describe a IndustryPack table
+ * @_table: device table name
+ *
+ * This macro is used to create a struct ipack_device_id array (a device table)
+ * in a generic manner.
+ */
+#define DEFINE_IPACK_DEVICE_TABLE(_table) \
+        const struct ipack_device_id _table[]
+/**
+ * IPACK_DEVICE - macro used to describe a specific IndustryPack device
+ * @_format: the format version (currently either 1 or 2, 8 bit value)
+ * @vend:    the 8 or 24 bit IndustryPack Vendor ID
+ * @dev:     the 8 or 16  bit IndustryPack Device ID
+ *
+ * This macro is used to create a struct ipack_device_id that matches a specific
+ * device.
+ */
+#define IPACK_DEVICE(_format, vend, dev) \
+         .format = (_format), \
+         .vendor = (vend), \
+         .device = (dev)
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 216b0ba109d7..526f10a637c1 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -392,6 +392,15 @@ static inline void irq_move_masked_irq(struct irq_data *data) { }
 
 extern int no_irq_affinity;
 
+#ifdef CONFIG_HARDIRQS_SW_RESEND
+int irq_set_parent(int irq, int parent_irq);
+#else
+static inline int irq_set_parent(int irq, int parent_irq)
+{
+        return 0;
+}
+#endif
+
 /*
  * Built-in IRQ handlers for various IRQ types,
  * callable via desc->handle_irq()
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index 0ba014c55056..623325e2ff97 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -11,6 +11,8 @@
 struct irq_affinity_notify;
 struct proc_dir_entry;
 struct module;
+struct irq_desc;
+
 /**
  * struct irq_desc - interrupt descriptor
  * @irq_data:           per irq and chip data passed down to chip functions
@@ -65,6 +67,7 @@ struct irq_desc {
 #ifdef CONFIG_PROC_FS
         struct proc_dir_entry   *dir;
 #endif
+        int                     parent_irq;
         struct module           *owner;
         const char              *name;
 } ____cacheline_internodealigned_in_smp;
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index 6b87413da9d6..82ed068b1ebe 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -70,11 +70,12 @@ extern int register_refined_jiffies(long clock_tick_rate);
 
 /*
  * The 64-bit value is not atomic - you MUST NOT read it
- * without sampling the sequence number in xtime_lock.
+ * without sampling the sequence number in jiffies_lock.
  * get_jiffies_64() will do this for you as appropriate.
  */
 extern u64 __jiffy_data jiffies_64;
 extern unsigned long volatile __jiffy_data jiffies;
+extern seqlock_t jiffies_lock;
 
 #if (BITS_PER_LONG < 64)
 u64 get_jiffies_64(void);
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index a123b13b70fd..d97ed5897447 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -527,9 +527,6 @@ __ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
 
 extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
 #else
-static inline __printf(1, 2)
-int trace_printk(const char *fmt, ...);
-
 static inline void tracing_start(void) { }
 static inline void tracing_stop(void) { }
 static inline void ftrace_off_permanent(void) { }
@@ -539,8 +536,8 @@ static inline void tracing_on(void) { }
 static inline void tracing_off(void) { }
 static inline int tracing_is_on(void) { return 0; }
 
-static inline int
-trace_printk(const char *fmt, ...)
+static inline __printf(1, 2)
+int trace_printk(const char *fmt, ...)
 {
         return 0;
 }
@@ -687,18 +684,11 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
 /* Trap pasters of __FUNCTION__ at compile-time */
 #define __FUNCTION__ (__func__)
 
-/* This helps us to avoid #ifdef CONFIG_NUMA */
-#ifdef CONFIG_NUMA
-#define NUMA_BUILD 1
-#else
-#define NUMA_BUILD 0
-#endif
-
-/* This helps us avoid #ifdef CONFIG_COMPACTION */
-#ifdef CONFIG_COMPACTION
-#define COMPACTION_BUILD 1
+/* This helps us to avoid #ifdef CONFIG_SYMBOL_PREFIX */
+#ifdef CONFIG_SYMBOL_PREFIX
+#define SYMBOL_PREFIX CONFIG_SYMBOL_PREFIX
 #else
-#define COMPACTION_BUILD 0
+#define SYMBOL_PREFIX ""
 #endif
 
 /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h
index 36d12f0884c3..66b70780e910 100644
--- a/include/linux/kernel_stat.h
+++ b/include/linux/kernel_stat.h
@@ -7,6 +7,7 @@
 #include <linux/cpumask.h>
 #include <linux/interrupt.h>
 #include <linux/sched.h>
+#include <linux/vtime.h>
 #include <asm/irq.h>
 #include <asm/cputime.h>
 
@@ -126,16 +127,16 @@ 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);
 
-extern void account_process_tick(struct task_struct *, int user);
-extern void account_steal_ticks(unsigned long ticks);
-extern void account_idle_ticks(unsigned long ticks);
-
 #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_idle(struct task_struct *tsk);
+static inline void account_process_tick(struct task_struct *tsk, int user)
+{
+        vtime_account_user(tsk);
+}
 #else
-static inline void vtime_task_switch(struct task_struct *prev) { }
+extern void account_process_tick(struct task_struct *, int user);
 #endif
 
+extern void account_steal_ticks(unsigned long ticks);
+extern void account_idle_ticks(unsigned long ticks);
+
 #endif /* _LINUX_KERNEL_STAT_H */
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 1e57449395b1..939b11268c86 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -203,7 +203,6 @@ extern struct kobject *power_kobj;
 /* The global /sys/firmware/ kobject for people to chain off of */
 extern struct kobject *firmware_kobj;
 
-#if defined(CONFIG_HOTPLUG)
 int kobject_uevent(struct kobject *kobj, enum kobject_action action);
 int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
                         char *envp[]);
@@ -213,22 +212,5 @@ int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);
 
 int kobject_action_type(const char *buf, size_t count,
                         enum kobject_action *type);
-#else
-static inline int kobject_uevent(struct kobject *kobj,
-                                 enum kobject_action action)
-{ return 0; }
-static inline int kobject_uevent_env(struct kobject *kobj,
-                                      enum kobject_action action,
-                                      char *envp[])
-{ return 0; }
-
-static inline __printf(2, 3)
-int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...)
-{ return -ENOMEM; }
-
-static inline int kobject_action_type(const char *buf, size_t count,
-                                      enum kobject_action *type)
-{ return -EINVAL; }
-#endif
 
 #endif /* _KOBJECT_H_ */
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index ecc554374e44..d5cddd8dcc5c 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -726,7 +726,11 @@ static inline int kvm_deassign_device(struct kvm *kvm,
 static inline void kvm_guest_enter(void)
 {
         BUG_ON(preemptible());
-        vtime_account(current);
+        /*
+         * 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;
         /* 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
@@ -740,7 +744,11 @@ static inline void kvm_guest_enter(void)
 
 static inline void kvm_guest_exit(void)
 {
-        vtime_account(current);
+        /*
+         * 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;
 }
 
diff --git a/include/linux/memory.h b/include/linux/memory.h
index ff9a9f8e0ed9..a09216d0dcc7 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -53,6 +53,7 @@ int arch_get_memory_phys_device(unsigned long start_pfn);
 struct memory_notify {
         unsigned long start_pfn;
         unsigned long nr_pages;
+        int status_change_nid_normal;
         int status_change_nid;
 };
 
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 95573ec4ee6c..4a45c4e50025 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -26,6 +26,13 @@ enum {
         MEMORY_HOTPLUG_MAX_BOOTMEM_TYPE = NODE_INFO,
 };
 
+/* Types for control the zone type of onlined memory */
+enum {
+        ONLINE_KEEP,
+        ONLINE_KERNEL,
+        ONLINE_MOVABLE,
+};
+
 /*
  * pgdat resizing functions
  */
@@ -46,6 +53,10 @@ void pgdat_resize_init(struct pglist_data *pgdat)
 }
 /*
  * Zone resizing functions
+ *
+ * Note: any attempt to resize a zone should has pgdat_resize_lock()
+ * zone_span_writelock() both held. This ensure the size of a zone
+ * can't be changed while pgdat_resize_lock() held.
  */
 static inline unsigned zone_span_seqbegin(struct zone *zone)
 {
@@ -71,7 +82,7 @@ extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
 extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
 extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
 /* VM interface that may be used by firmware interface */
-extern int online_pages(unsigned long, unsigned long);
+extern int online_pages(unsigned long, unsigned long, int);
 extern void __offline_isolated_pages(unsigned long, unsigned long);
 
 typedef void (*online_page_callback_t)(struct page *page);
diff --git a/include/linux/mempolicy.h b/include/linux/mempolicy.h
index e5ccb9ddd90e..dbd212723b74 100644
--- a/include/linux/mempolicy.h
+++ b/include/linux/mempolicy.h
@@ -82,16 +82,6 @@ static inline void mpol_cond_put(struct mempolicy *pol)
                 __mpol_put(pol);
 }
 
-extern struct mempolicy *__mpol_cond_copy(struct mempolicy *tompol,
-                                          struct mempolicy *frompol);
-static inline struct mempolicy *mpol_cond_copy(struct mempolicy *tompol,
-                                                struct mempolicy *frompol)
-{
-        if (!frompol)
-                return frompol;
-        return __mpol_cond_copy(tompol, frompol);
-}
-
 extern struct mempolicy *__mpol_dup(struct mempolicy *pol);
 static inline struct mempolicy *mpol_dup(struct mempolicy *pol)
 {
@@ -215,12 +205,6 @@ static inline void mpol_cond_put(struct mempolicy *pol)
 {
 }
 
-static inline struct mempolicy *mpol_cond_copy(struct mempolicy *to,
-                                                struct mempolicy *from)
-{
-        return from;
-}
-
 static inline void mpol_get(struct mempolicy *pol)
 {
 }
diff --git a/include/linux/mfd/88pm80x.h b/include/linux/mfd/88pm80x.h
index a0ca0dca1244..478672ed0c3d 100644
--- a/include/linux/mfd/88pm80x.h
+++ b/include/linux/mfd/88pm80x.h
@@ -364,6 +364,6 @@ static inline int pm80x_dev_resume(struct device *dev)
 #endif
 
 extern int pm80x_init(struct i2c_client *client,
-                             const struct i2c_device_id *id) __devinit;
+                      const struct i2c_device_id *id);
 extern int pm80x_deinit(struct i2c_client *client);
 #endif /* __LINUX_MFD_88PM80X_H */
diff --git a/include/linux/mfd/abx500/ab8500.h b/include/linux/mfd/abx500/ab8500.h
index 1491044efa10..1cb5698b4d76 100644
--- a/include/linux/mfd/abx500/ab8500.h
+++ b/include/linux/mfd/abx500/ab8500.h
@@ -291,9 +291,9 @@ struct ab8500_platform_data {
         struct ab8500_codec_platform_data *codec;
 };
 
-extern int __devinit ab8500_init(struct ab8500 *ab8500,
+extern int ab8500_init(struct ab8500 *ab8500,
                                  enum ab8500_version version);
-extern int __devexit ab8500_exit(struct ab8500 *ab8500);
+extern int ab8500_exit(struct ab8500 *ab8500);
 
 extern int ab8500_suspend(struct ab8500 *ab8500);
 
diff --git a/include/linux/mfd/menelaus.h b/include/linux/mfd/menelaus.h
new file mode 100644
index 000000000000..f097e89134cb
--- /dev/null
+++ b/include/linux/mfd/menelaus.h
@@ -0,0 +1,47 @@
+/*
+ * Functions to access Menelaus power management chip
+ */
+
+#ifndef __ASM_ARCH_MENELAUS_H
+#define __ASM_ARCH_MENELAUS_H
+
+struct device;
+
+struct menelaus_platform_data {
+        int (* late_init)(struct device *dev);
+};
+
+extern int menelaus_register_mmc_callback(void (*callback)(void *data, u8 card_mask),
+                                          void *data);
+extern void menelaus_unregister_mmc_callback(void);
+extern int menelaus_set_mmc_opendrain(int slot, int enable);
+extern int menelaus_set_mmc_slot(int slot, int enable, int power, int cd_on);
+
+extern int menelaus_set_vmem(unsigned int mV);
+extern int menelaus_set_vio(unsigned int mV);
+extern int menelaus_set_vmmc(unsigned int mV);
+extern int menelaus_set_vaux(unsigned int mV);
+extern int menelaus_set_vdcdc(int dcdc, unsigned int mV);
+extern int menelaus_set_slot_sel(int enable);
+extern int menelaus_get_slot_pin_states(void);
+extern int menelaus_set_vcore_sw(unsigned int mV);
+extern int menelaus_set_vcore_hw(unsigned int roof_mV, unsigned int floor_mV);
+
+#define EN_VPLL_SLEEP   (1 << 7)
+#define EN_VMMC_SLEEP   (1 << 6)
+#define EN_VAUX_SLEEP   (1 << 5)
+#define EN_VIO_SLEEP    (1 << 4)
+#define EN_VMEM_SLEEP   (1 << 3)
+#define EN_DC3_SLEEP    (1 << 2)
+#define EN_DC2_SLEEP    (1 << 1)
+#define EN_VC_SLEEP     (1 << 0)
+
+extern int menelaus_set_regulator_sleep(int enable, u32 val);
+
+#if defined(CONFIG_ARCH_OMAP2) && defined(CONFIG_MENELAUS)
+#define omap_has_menelaus()     1
+#else
+#define omap_has_menelaus()     0
+#endif
+
+#endif
diff --git a/include/linux/mfd/pm8xxx/irq.h b/include/linux/mfd/pm8xxx/irq.h
index 4b21769f4483..f83d6b43ecbb 100644
--- a/include/linux/mfd/pm8xxx/irq.h
+++ b/include/linux/mfd/pm8xxx/irq.h
@@ -37,21 +37,21 @@ struct pm_irq_chip;
 
 #ifdef CONFIG_MFD_PM8XXX_IRQ
 int pm8xxx_get_irq_stat(struct pm_irq_chip *chip, int irq);
-struct pm_irq_chip * __devinit pm8xxx_irq_init(struct device *dev,
+struct pm_irq_chip *pm8xxx_irq_init(struct device *dev,
                                 const struct pm8xxx_irq_platform_data *pdata);
-int __devexit pm8xxx_irq_exit(struct pm_irq_chip *chip);
+int pm8xxx_irq_exit(struct pm_irq_chip *chip);
 #else
 static inline int pm8xxx_get_irq_stat(struct pm_irq_chip *chip, int irq)
 {
         return -ENXIO;
 }
-static inline struct pm_irq_chip * __devinit pm8xxx_irq_init(
+static inline struct pm_irq_chip *pm8xxx_irq_init(
                                 const struct device *dev,
                                 const struct pm8xxx_irq_platform_data *pdata)
 {
         return ERR_PTR(-ENXIO);
 }
-static inline int __devexit pm8xxx_irq_exit(struct pm_irq_chip *chip)
+static inline int pm8xxx_irq_exit(struct pm_irq_chip *chip)
 {
         return -ENXIO;
 }
diff --git a/include/linux/mfd/rtsx_common.h b/include/linux/mfd/rtsx_common.h
new file mode 100644
index 000000000000..a8d393e3066b
--- /dev/null
+++ b/include/linux/mfd/rtsx_common.h
@@ -0,0 +1,48 @@
+/* Driver for Realtek driver-based card reader
+ *
+ * Copyright(c) 2009 Realtek Semiconductor Corp. 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, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Wei WANG <wei_wang@realsil.com.cn>
+ *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
+ */
+
+#ifndef __RTSX_COMMON_H
+#define __RTSX_COMMON_H
+
+#define DRV_NAME_RTSX_PCI               "rtsx_pci"
+#define DRV_NAME_RTSX_PCI_SDMMC         "rtsx_pci_sdmmc"
+#define DRV_NAME_RTSX_PCI_MS            "rtsx_pci_ms"
+
+#define RTSX_REG_PAIR(addr, val)        (((u32)(addr) << 16) | (u8)(val))
+
+#define RTSX_SSC_DEPTH_4M               0x01
+#define RTSX_SSC_DEPTH_2M               0x02
+#define RTSX_SSC_DEPTH_1M               0x03
+#define RTSX_SSC_DEPTH_500K             0x04
+#define RTSX_SSC_DEPTH_250K             0x05
+
+#define RTSX_SD_CARD                    0
+#define RTSX_MS_CARD                    1
+
+struct platform_device;
+
+struct rtsx_slot {
+        struct platform_device  *p_dev;
+        void                    (*card_event)(struct platform_device *p_dev);
+};
+
+#endif
diff --git a/include/linux/mfd/rtsx_pci.h b/include/linux/mfd/rtsx_pci.h
new file mode 100644
index 000000000000..060b721fcbfb
--- /dev/null
+++ b/include/linux/mfd/rtsx_pci.h
@@ -0,0 +1,794 @@
+/* Driver for Realtek PCI-Express card reader
+ *
+ * Copyright(c) 2009 Realtek Semiconductor Corp. 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, or (at your option) any
+ * later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, see <http://www.gnu.org/licenses/>.
+ *
+ * Author:
+ *   Wei WANG <wei_wang@realsil.com.cn>
+ *   No. 450, Shenhu Road, Suzhou Industry Park, Suzhou, China
+ */
+
+#ifndef __RTSX_PCI_H
+#define __RTSX_PCI_H
+
+#include <linux/sched.h>
+#include <linux/pci.h>
+
+#include "rtsx_common.h"
+
+#define MAX_RW_REG_CNT                  1024
+
+/* PCI Operation Register Address */
+#define RTSX_HCBAR                      0x00
+#define RTSX_HCBCTLR                    0x04
+#define RTSX_HDBAR                      0x08
+#define RTSX_HDBCTLR                    0x0C
+#define RTSX_HAIMR                      0x10
+#define RTSX_BIPR                       0x14
+#define RTSX_BIER                       0x18
+
+/* Host command buffer control register */
+#define STOP_CMD                        (0x01 << 28)
+
+/* Host data buffer control register */
+#define SDMA_MODE                       0x00
+#define ADMA_MODE                       (0x02 << 26)
+#define STOP_DMA                        (0x01 << 28)
+#define TRIG_DMA                        (0x01 << 31)
+
+/* Host access internal memory register */
+#define HAIMR_TRANS_START               (0x01 << 31)
+#define HAIMR_READ                      0x00
+#define HAIMR_WRITE                     (0x01 << 30)
+#define HAIMR_READ_START                (HAIMR_TRANS_START | HAIMR_READ)
+#define HAIMR_WRITE_START               (HAIMR_TRANS_START | HAIMR_WRITE)
+#define HAIMR_TRANS_END                 (HAIMR_TRANS_START)
+
+/* Bus interrupt pending register */
+#define CMD_DONE_INT                    (1 << 31)
+#define DATA_DONE_INT                   (1 << 30)
+#define TRANS_OK_INT                    (1 << 29)
+#define TRANS_FAIL_INT                  (1 << 28)
+#define XD_INT                          (1 << 27)
+#define MS_INT                          (1 << 26)
+#define SD_INT                          (1 << 25)
+#define GPIO0_INT                       (1 << 24)
+#define OC_INT                          (1 << 23)
+#define SD_WRITE_PROTECT                (1 << 19)
+#define XD_EXIST                        (1 << 18)
+#define MS_EXIST                        (1 << 17)
+#define SD_EXIST                        (1 << 16)
+#define DELINK_INT                      GPIO0_INT
+#define MS_OC_INT                       (1 << 23)
+#define SD_OC_INT                       (1 << 22)
+
+#define CARD_INT                (XD_INT | MS_INT | SD_INT)
+#define NEED_COMPLETE_INT       (DATA_DONE_INT | TRANS_OK_INT | TRANS_FAIL_INT)
+#define RTSX_INT                (CMD_DONE_INT | NEED_COMPLETE_INT | \
+                                        CARD_INT | GPIO0_INT | OC_INT)
+
+#define CARD_EXIST              (XD_EXIST | MS_EXIST | SD_EXIST)
+
+/* Bus interrupt enable register */
+#define CMD_DONE_INT_EN         (1 << 31)
+#define DATA_DONE_INT_EN        (1 << 30)
+#define TRANS_OK_INT_EN         (1 << 29)
+#define TRANS_FAIL_INT_EN       (1 << 28)
+#define XD_INT_EN               (1 << 27)
+#define MS_INT_EN               (1 << 26)
+#define SD_INT_EN               (1 << 25)
+#define GPIO0_INT_EN            (1 << 24)
+#define OC_INT_EN               (1 << 23)
+#define DELINK_INT_EN           GPIO0_INT_EN
+#define MS_OC_INT_EN            (1 << 23)
+#define SD_OC_INT_EN            (1 << 22)
+
+#define READ_REG_CMD            0
+#define WRITE_REG_CMD           1
+#define CHECK_REG_CMD           2
+
+/*
+ * macros for easy use
+ */
+#define rtsx_pci_writel(pcr, reg, value) \
+        iowrite32(value, (pcr)->remap_addr + reg)
+#define rtsx_pci_readl(pcr, reg) \
+        ioread32((pcr)->remap_addr + reg)
+#define rtsx_pci_writew(pcr, reg, value) \
+        iowrite16(value, (pcr)->remap_addr + reg)
+#define rtsx_pci_readw(pcr, reg) \
+        ioread16((pcr)->remap_addr + reg)
+#define rtsx_pci_writeb(pcr, reg, value) \
+        iowrite8(value, (pcr)->remap_addr + reg)
+#define rtsx_pci_readb(pcr, reg) \
+        ioread8((pcr)->remap_addr + reg)
+
+#define rtsx_pci_read_config_byte(pcr, where, val) \
+        pci_read_config_byte((pcr)->pci, where, val)
+
+#define rtsx_pci_write_config_byte(pcr, where, val) \
+        pci_write_config_byte((pcr)->pci, where, val)
+
+#define rtsx_pci_read_config_dword(pcr, where, val) \
+        pci_read_config_dword((pcr)->pci, where, val)
+
+#define rtsx_pci_write_config_dword(pcr, where, val) \
+        pci_write_config_dword((pcr)->pci, where, val)
+
+#define STATE_TRANS_NONE        0
+#define STATE_TRANS_CMD         1
+#define STATE_TRANS_BUF         2
+#define STATE_TRANS_SG          3
+
+#define TRANS_NOT_READY         0
+#define TRANS_RESULT_OK         1
+#define TRANS_RESULT_FAIL       2
+#define TRANS_NO_DEVICE         3
+
+#define RTSX_RESV_BUF_LEN       4096
+#define HOST_CMDS_BUF_LEN       1024
+#define HOST_SG_TBL_BUF_LEN     (RTSX_RESV_BUF_LEN - HOST_CMDS_BUF_LEN)
+#define HOST_SG_TBL_ITEMS       (HOST_SG_TBL_BUF_LEN / 8)
+#define MAX_SG_ITEM_LEN         0x80000
+
+#define HOST_TO_DEVICE          0
+#define DEVICE_TO_HOST          1
+
+#define MAX_PHASE               31
+#define RX_TUNING_CNT           3
+
+/* SG descriptor */
+#define SG_INT                  0x04
+#define SG_END                  0x02
+#define SG_VALID                0x01
+
+#define SG_NO_OP                0x00
+#define SG_TRANS_DATA           (0x02 << 4)
+#define SG_LINK_DESC            (0x03 << 4)
+
+/* SD bank voltage */
+#define SD_IO_3V3               0
+#define SD_IO_1V8               1
+
+
+/* Card Clock Enable Register */
+#define SD_CLK_EN                       0x04
+#define MS_CLK_EN                       0x08
+
+/* Card Select Register */
+#define SD_MOD_SEL                      2
+#define MS_MOD_SEL                      3
+
+/* Card Output Enable Register */
+#define SD_OUTPUT_EN                    0x04
+#define MS_OUTPUT_EN                    0x08
+
+/* CARD_SHARE_MODE */
+#define CARD_SHARE_MASK                 0x0F
+#define CARD_SHARE_MULTI_LUN            0x00
+#define CARD_SHARE_NORMAL               0x00
+#define CARD_SHARE_48_SD                0x04
+#define CARD_SHARE_48_MS                0x08
+/* CARD_SHARE_MODE for barossa */
+#define CARD_SHARE_BAROSSA_SD           0x01
+#define CARD_SHARE_BAROSSA_MS           0x02
+
+/* SD30_DRIVE_SEL */
+#define DRIVER_TYPE_A                   0x05
+#define DRIVER_TYPE_B                   0x03
+#define DRIVER_TYPE_C                   0x02
+#define DRIVER_TYPE_D                   0x01
+
+/* FPDCTL */
+#define SSC_POWER_DOWN                  0x01
+#define SD_OC_POWER_DOWN                0x02
+#define ALL_POWER_DOWN                  0x07
+#define OC_POWER_DOWN                   0x06
+
+/* CLK_CTL */
+#define CHANGE_CLK                      0x01
+
+/* LDO_CTL */
+#define BPP_LDO_POWB                    0x03
+#define BPP_LDO_ON                      0x00
+#define BPP_LDO_SUSPEND                 0x02
+#define BPP_LDO_OFF                     0x03
+
+/* CD_PAD_CTL */
+#define CD_DISABLE_MASK                 0x07
+#define MS_CD_DISABLE                   0x04
+#define SD_CD_DISABLE                   0x02
+#define XD_CD_DISABLE                   0x01
+#define CD_DISABLE                      0x07
+#define CD_ENABLE                       0x00
+#define MS_CD_EN_ONLY                   0x03
+#define SD_CD_EN_ONLY                   0x05
+#define XD_CD_EN_ONLY                   0x06
+#define FORCE_CD_LOW_MASK               0x38
+#define FORCE_CD_XD_LOW                 0x08
+#define FORCE_CD_SD_LOW                 0x10
+#define FORCE_CD_MS_LOW                 0x20
+#define CD_AUTO_DISABLE                 0x40
+
+/* SD_STAT1 */
+#define SD_CRC7_ERR                     0x80
+#define SD_CRC16_ERR                    0x40
+#define SD_CRC_WRITE_ERR                0x20
+#define SD_CRC_WRITE_ERR_MASK           0x1C
+#define GET_CRC_TIME_OUT                0x02
+#define SD_TUNING_COMPARE_ERR           0x01
+
+/* SD_STAT2 */
+#define SD_RSP_80CLK_TIMEOUT            0x01
+
+/* SD_BUS_STAT */
+#define SD_CLK_TOGGLE_EN                0x80
+#define SD_CLK_FORCE_STOP               0x40
+#define SD_DAT3_STATUS                  0x10
+#define SD_DAT2_STATUS                  0x08
+#define SD_DAT1_STATUS                  0x04
+#define SD_DAT0_STATUS                  0x02
+#define SD_CMD_STATUS                   0x01
+
+/* SD_PAD_CTL */
+#define SD_IO_USING_1V8                 0x80
+#define SD_IO_USING_3V3                 0x7F
+#define TYPE_A_DRIVING                  0x00
+#define TYPE_B_DRIVING                  0x01
+#define TYPE_C_DRIVING                  0x02
+#define TYPE_D_DRIVING                  0x03
+
+/* SD_SAMPLE_POINT_CTL */
+#define DDR_FIX_RX_DAT                  0x00
+#define DDR_VAR_RX_DAT                  0x80
+#define DDR_FIX_RX_DAT_EDGE             0x00
+#define DDR_FIX_RX_DAT_14_DELAY         0x40
+#define DDR_FIX_RX_CMD                  0x00
+#define DDR_VAR_RX_CMD                  0x20
+#define DDR_FIX_RX_CMD_POS_EDGE         0x00
+#define DDR_FIX_RX_CMD_14_DELAY         0x10
+#define SD20_RX_POS_EDGE                0x00
+#define SD20_RX_14_DELAY                0x08
+#define SD20_RX_SEL_MASK                0x08
+
+/* SD_PUSH_POINT_CTL */
+#define DDR_FIX_TX_CMD_DAT              0x00
+#define DDR_VAR_TX_CMD_DAT              0x80
+#define DDR_FIX_TX_DAT_14_TSU           0x00
+#define DDR_FIX_TX_DAT_12_TSU           0x40
+#define DDR_FIX_TX_CMD_NEG_EDGE         0x00
+#define DDR_FIX_TX_CMD_14_AHEAD         0x20
+#define SD20_TX_NEG_EDGE                0x00
+#define SD20_TX_14_AHEAD                0x10
+#define SD20_TX_SEL_MASK                0x10
+#define DDR_VAR_SDCLK_POL_SWAP          0x01
+
+/* SD_TRANSFER */
+#define SD_TRANSFER_START               0x80
+#define SD_TRANSFER_END                 0x40
+#define SD_STAT_IDLE                    0x20
+#define SD_TRANSFER_ERR                 0x10
+/* SD Transfer Mode definition */
+#define SD_TM_NORMAL_WRITE              0x00
+#define SD_TM_AUTO_WRITE_3              0x01
+#define SD_TM_AUTO_WRITE_4              0x02
+#define SD_TM_AUTO_READ_3               0x05
+#define SD_TM_AUTO_READ_4               0x06
+#define SD_TM_CMD_RSP                   0x08
+#define SD_TM_AUTO_WRITE_1              0x09
+#define SD_TM_AUTO_WRITE_2              0x0A
+#define SD_TM_NORMAL_READ               0x0C
+#define SD_TM_AUTO_READ_1               0x0D
+#define SD_TM_AUTO_READ_2               0x0E
+#define SD_TM_AUTO_TUNING               0x0F
+
+/* SD_VPTX_CTL / SD_VPRX_CTL */
+#define PHASE_CHANGE                    0x80
+#define PHASE_NOT_RESET                 0x40
+
+/* SD_DCMPS_TX_CTL / SD_DCMPS_RX_CTL */
+#define DCMPS_CHANGE                    0x80
+#define DCMPS_CHANGE_DONE               0x40
+#define DCMPS_ERROR                     0x20
+#define DCMPS_CURRENT_PHASE             0x1F
+
+/* SD Configure 1 Register */
+#define SD_CLK_DIVIDE_0                 0x00
+#define SD_CLK_DIVIDE_256               0xC0
+#define SD_CLK_DIVIDE_128               0x80
+#define SD_BUS_WIDTH_1BIT               0x00
+#define SD_BUS_WIDTH_4BIT               0x01
+#define SD_BUS_WIDTH_8BIT               0x02
+#define SD_ASYNC_FIFO_NOT_RST           0x10
+#define SD_20_MODE                      0x00
+#define SD_DDR_MODE                     0x04
+#define SD_30_MODE                      0x08
+
+#define SD_CLK_DIVIDE_MASK              0xC0
+
+/* SD_CMD_STATE */
+#define SD_CMD_IDLE                     0x80
+
+/* SD_DATA_STATE */
+#define SD_DATA_IDLE                    0x80
+
+/* DCM_DRP_CTL */
+#define DCM_RESET                       0x08
+#define DCM_LOCKED                      0x04
+#define DCM_208M                        0x00
+#define DCM_TX                          0x01
+#define DCM_RX                          0x02
+
+/* DCM_DRP_TRIG */
+#define DRP_START                       0x80
+#define DRP_DONE                        0x40
+
+/* DCM_DRP_CFG */
+#define DRP_WRITE                       0x80
+#define DRP_READ                        0x00
+#define DCM_WRITE_ADDRESS_50            0x50
+#define DCM_WRITE_ADDRESS_51            0x51
+#define DCM_READ_ADDRESS_00             0x00
+#define DCM_READ_ADDRESS_51             0x51
+
+/* IRQSTAT0 */
+#define DMA_DONE_INT                    0x80
+#define SUSPEND_INT                     0x40
+#define LINK_RDY_INT                    0x20
+#define LINK_DOWN_INT                   0x10
+
+/* DMACTL */
+#define DMA_RST                         0x80
+#define DMA_BUSY                        0x04
+#define DMA_DIR_TO_CARD                 0x00
+#define DMA_DIR_FROM_CARD               0x02
+#define DMA_EN                          0x01
+#define DMA_128                         (0 << 4)
+#define DMA_256                         (1 << 4)
+#define DMA_512                         (2 << 4)
+#define DMA_1024                        (3 << 4)
+#define DMA_PACK_SIZE_MASK              0x30
+
+/* SSC_CTL1 */
+#define SSC_RSTB                        0x80
+#define SSC_8X_EN                       0x40
+#define SSC_FIX_FRAC                    0x20
+#define SSC_SEL_1M                      0x00
+#define SSC_SEL_2M                      0x08
+#define SSC_SEL_4M                      0x10
+#define SSC_SEL_8M                      0x18
+
+/* SSC_CTL2 */
+#define SSC_DEPTH_MASK                  0x07
+#define SSC_DEPTH_DISALBE               0x00
+#define SSC_DEPTH_4M                    0x01
+#define SSC_DEPTH_2M                    0x02
+#define SSC_DEPTH_1M                    0x03
+#define SSC_DEPTH_500K                  0x04
+#define SSC_DEPTH_250K                  0x05
+
+/* System Clock Control Register */
+#define CLK_LOW_FREQ                    0x01
+
+/* System Clock Divider Register */
+#define CLK_DIV_1                       0x01
+#define CLK_DIV_2                       0x02
+#define CLK_DIV_4                       0x03
+#define CLK_DIV_8                       0x04
+
+/* MS_CFG */
+#define SAMPLE_TIME_RISING              0x00
+#define SAMPLE_TIME_FALLING             0x80
+#define PUSH_TIME_DEFAULT               0x00
+#define PUSH_TIME_ODD                   0x40
+#define NO_EXTEND_TOGGLE                0x00
+#define EXTEND_TOGGLE_CHK               0x20
+#define MS_BUS_WIDTH_1                  0x00
+#define MS_BUS_WIDTH_4                  0x10
+#define MS_BUS_WIDTH_8                  0x18
+#define MS_2K_SECTOR_MODE               0x04
+#define MS_512_SECTOR_MODE              0x00
+#define MS_TOGGLE_TIMEOUT_EN            0x00
+#define MS_TOGGLE_TIMEOUT_DISEN         0x01
+#define MS_NO_CHECK_INT                 0x02
+
+/* MS_TRANS_CFG */
+#define WAIT_INT                        0x80
+#define NO_WAIT_INT                     0x00
+#define NO_AUTO_READ_INT_REG            0x00
+#define AUTO_READ_INT_REG               0x40
+#define MS_CRC16_ERR                    0x20
+#define MS_RDY_TIMEOUT                  0x10
+#define MS_INT_CMDNK                    0x08
+#define MS_INT_BREQ                     0x04
+#define MS_INT_ERR                      0x02
+#define MS_INT_CED                      0x01
+
+/* MS_TRANSFER */
+#define MS_TRANSFER_START               0x80
+#define MS_TRANSFER_END                 0x40
+#define MS_TRANSFER_ERR                 0x20
+#define MS_BS_STATE                     0x10
+#define MS_TM_READ_BYTES                0x00
+#define MS_TM_NORMAL_READ               0x01
+#define MS_TM_WRITE_BYTES               0x04
+#define MS_TM_NORMAL_WRITE              0x05
+#define MS_TM_AUTO_READ                 0x08
+#define MS_TM_AUTO_WRITE                0x0C
+
+/* SD Configure 2 Register */
+#define SD_CALCULATE_CRC7               0x00
+#define SD_NO_CALCULATE_CRC7            0x80
+#define SD_CHECK_CRC16                  0x00
+#define SD_NO_CHECK_CRC16               0x40
+#define SD_NO_CHECK_WAIT_CRC_TO         0x20
+#define SD_WAIT_BUSY_END                0x08
+#define SD_NO_WAIT_BUSY_END             0x00
+#define SD_CHECK_CRC7                   0x00
+#define SD_NO_CHECK_CRC7                0x04
+#define SD_RSP_LEN_0                    0x00
+#define SD_RSP_LEN_6                    0x01
+#define SD_RSP_LEN_17                   0x02
+/* SD/MMC Response Type Definition */
+#define SD_RSP_TYPE_R0                  0x04
+#define SD_RSP_TYPE_R1                  0x01
+#define SD_RSP_TYPE_R1b                 0x09
+#define SD_RSP_TYPE_R2                  0x02
+#define SD_RSP_TYPE_R3                  0x05
+#define SD_RSP_TYPE_R4                  0x05
+#define SD_RSP_TYPE_R5                  0x01
+#define SD_RSP_TYPE_R6                  0x01
+#define SD_RSP_TYPE_R7                  0x01
+
+/* SD_CONFIURE3 */
+#define SD_RSP_80CLK_TIMEOUT_EN         0x01
+
+/* Card Transfer Reset Register */
+#define SPI_STOP                        0x01
+#define XD_STOP                         0x02
+#define SD_STOP                         0x04
+#define MS_STOP                         0x08
+#define SPI_CLR_ERR                     0x10
+#define XD_CLR_ERR                      0x20
+#define SD_CLR_ERR                      0x40
+#define MS_CLR_ERR                      0x80
+
+/* Card Data Source Register */
+#define PINGPONG_BUFFER                 0x01
+#define RING_BUFFER                     0x00
+
+/* Card Power Control Register */
+#define PMOS_STRG_MASK                  0x10
+#define PMOS_STRG_800mA                 0x10
+#define PMOS_STRG_400mA                 0x00
+#define SD_POWER_OFF                    0x03
+#define SD_PARTIAL_POWER_ON             0x01
+#define SD_POWER_ON                     0x00
+#define SD_POWER_MASK                   0x03
+#define MS_POWER_OFF                    0x0C
+#define MS_PARTIAL_POWER_ON             0x04
+#define MS_POWER_ON                     0x00
+#define MS_POWER_MASK                   0x0C
+#define BPP_POWER_OFF                   0x0F
+#define BPP_POWER_5_PERCENT_ON          0x0E
+#define BPP_POWER_10_PERCENT_ON         0x0C
+#define BPP_POWER_15_PERCENT_ON         0x08
+#define BPP_POWER_ON                    0x00
+#define BPP_POWER_MASK                  0x0F
+
+/* PWR_GATE_CTRL */
+#define PWR_GATE_EN                     0x01
+#define LDO3318_PWR_MASK                0x06
+#define LDO_ON                          0x00
+#define LDO_SUSPEND                     0x04
+#define LDO_OFF                         0x06
+
+/* CARD_CLK_SOURCE */
+#define CRC_FIX_CLK                     (0x00 << 0)
+#define CRC_VAR_CLK0                    (0x01 << 0)
+#define CRC_VAR_CLK1                    (0x02 << 0)
+#define SD30_FIX_CLK                    (0x00 << 2)
+#define SD30_VAR_CLK0                   (0x01 << 2)
+#define SD30_VAR_CLK1                   (0x02 << 2)
+#define SAMPLE_FIX_CLK                  (0x00 << 4)
+#define SAMPLE_VAR_CLK0                 (0x01 << 4)
+#define SAMPLE_VAR_CLK1                 (0x02 << 4)
+
+#define MS_CFG                          0xFD40
+#define MS_TPC                          0xFD41
+#define MS_TRANS_CFG                    0xFD42
+#define MS_TRANSFER                     0xFD43
+#define MS_INT_REG                      0xFD44
+#define MS_BYTE_CNT                     0xFD45
+#define MS_SECTOR_CNT_L                 0xFD46
+#define MS_SECTOR_CNT_H                 0xFD47
+#define MS_DBUS_H                       0xFD48
+
+#define SD_CFG1                         0xFDA0
+#define SD_CFG2                         0xFDA1
+#define SD_CFG3                         0xFDA2
+#define SD_STAT1                        0xFDA3
+#define SD_STAT2                        0xFDA4
+#define SD_BUS_STAT                     0xFDA5
+#define SD_PAD_CTL                      0xFDA6
+#define SD_SAMPLE_POINT_CTL             0xFDA7
+#define SD_PUSH_POINT_CTL               0xFDA8
+#define SD_CMD0                         0xFDA9
+#define SD_CMD1                         0xFDAA
+#define SD_CMD2                         0xFDAB
+#define SD_CMD3                         0xFDAC
+#define SD_CMD4                         0xFDAD
+#define SD_CMD5                         0xFDAE
+#define SD_BYTE_CNT_L                   0xFDAF
+#define SD_BYTE_CNT_H                   0xFDB0
+#define SD_BLOCK_CNT_L                  0xFDB1
+#define SD_BLOCK_CNT_H                  0xFDB2
+#define SD_TRANSFER                     0xFDB3
+#define SD_CMD_STATE                    0xFDB5
+#define SD_DATA_STATE                   0xFDB6
+
+#define SRCTL                           0xFC13
+
+#define DCM_DRP_CTL                     0xFC23
+#define DCM_DRP_TRIG                    0xFC24
+#define DCM_DRP_CFG                     0xFC25
+#define DCM_DRP_WR_DATA_L               0xFC26
+#define DCM_DRP_WR_DATA_H               0xFC27
+#define DCM_DRP_RD_DATA_L               0xFC28
+#define DCM_DRP_RD_DATA_H               0xFC29
+#define SD_VPCLK0_CTL                   0xFC2A
+#define SD_VPCLK1_CTL                   0xFC2B
+#define SD_DCMPS0_CTL                   0xFC2C
+#define SD_DCMPS1_CTL                   0xFC2D
+#define SD_VPTX_CTL                     SD_VPCLK0_CTL
+#define SD_VPRX_CTL                     SD_VPCLK1_CTL
+#define SD_DCMPS_TX_CTL                 SD_DCMPS0_CTL
+#define SD_DCMPS_RX_CTL                 SD_DCMPS1_CTL
+#define CARD_CLK_SOURCE                 0xFC2E
+
+#define CARD_PWR_CTL                    0xFD50
+#define CARD_CLK_SWITCH                 0xFD51
+#define CARD_SHARE_MODE                 0xFD52
+#define CARD_DRIVE_SEL                  0xFD53
+#define CARD_STOP                       0xFD54
+#define CARD_OE                         0xFD55
+#define CARD_AUTO_BLINK                 0xFD56
+#define CARD_GPIO_DIR                   0xFD57
+#define CARD_GPIO                       0xFD58
+#define CARD_DATA_SOURCE                0xFD5B
+#define CARD_SELECT                     0xFD5C
+#define SD30_DRIVE_SEL                  0xFD5E
+#define CARD_CLK_EN                     0xFD69
+#define SDIO_CTRL                       0xFD6B
+#define CD_PAD_CTL                      0xFD73
+
+#define FPDCTL                          0xFC00
+#define PDINFO                          0xFC01
+
+#define CLK_CTL                         0xFC02
+#define CLK_DIV                         0xFC03
+#define CLK_SEL                         0xFC04
+
+#define SSC_DIV_N_0                     0xFC0F
+#define SSC_DIV_N_1                     0xFC10
+#define SSC_CTL1                        0xFC11
+#define SSC_CTL2                        0xFC12
+
+#define RCCTL                           0xFC14
+
+#define FPGA_PULL_CTL                   0xFC1D
+#define OLT_LED_CTL                     0xFC1E
+#define GPIO_CTL                        0xFC1F
+
+#define LDO_CTL                         0xFC1E
+#define SYS_VER                         0xFC32
+
+#define CARD_PULL_CTL1                  0xFD60
+#define CARD_PULL_CTL2                  0xFD61
+#define CARD_PULL_CTL3                  0xFD62
+#define CARD_PULL_CTL4                  0xFD63
+#define CARD_PULL_CTL5                  0xFD64
+#define CARD_PULL_CTL6                  0xFD65
+
+/* PCI Express Related Registers */
+#define IRQEN0                          0xFE20
+#define IRQSTAT0                        0xFE21
+#define IRQEN1                          0xFE22
+#define IRQSTAT1                        0xFE23
+#define TLPRIEN                         0xFE24
+#define TLPRISTAT                       0xFE25
+#define TLPTIEN                         0xFE26
+#define TLPTISTAT                       0xFE27
+#define DMATC0                          0xFE28
+#define DMATC1                          0xFE29
+#define DMATC2                          0xFE2A
+#define DMATC3                          0xFE2B
+#define DMACTL                          0xFE2C
+#define BCTL                            0xFE2D
+#define RBBC0                           0xFE2E
+#define RBBC1                           0xFE2F
+#define RBDAT                           0xFE30
+#define RBCTL                           0xFE34
+#define CFGADDR0                        0xFE35
+#define CFGADDR1                        0xFE36
+#define CFGDATA0                        0xFE37
+#define CFGDATA1                        0xFE38
+#define CFGDATA2                        0xFE39
+#define CFGDATA3                        0xFE3A
+#define CFGRWCTL                        0xFE3B
+#define PHYRWCTL                        0xFE3C
+#define PHYDATA0                        0xFE3D
+#define PHYDATA1                        0xFE3E
+#define PHYADDR                         0xFE3F
+#define MSGRXDATA0                      0xFE40
+#define MSGRXDATA1                      0xFE41
+#define MSGRXDATA2                      0xFE42
+#define MSGRXDATA3                      0xFE43
+#define MSGTXDATA0                      0xFE44
+#define MSGTXDATA1                      0xFE45
+#define MSGTXDATA2                      0xFE46
+#define MSGTXDATA3                      0xFE47
+#define MSGTXCTL                        0xFE48
+#define PETXCFG                         0xFE49
+
+#define CDRESUMECTL                     0xFE52
+#define WAKE_SEL_CTL                    0xFE54
+#define PME_FORCE_CTL                   0xFE56
+#define ASPM_FORCE_CTL                  0xFE57
+#define PM_CLK_FORCE_CTL                0xFE58
+#define PERST_GLITCH_WIDTH              0xFE5C
+#define CHANGE_LINK_STATE               0xFE5B
+#define RESET_LOAD_REG                  0xFE5E
+#define EFUSE_CONTENT                   0xFE5F
+#define HOST_SLEEP_STATE                0xFE60
+#define SDIO_CFG                        0xFE70
+
+#define NFTS_TX_CTRL                    0xFE72
+
+#define PWR_GATE_CTRL                   0xFE75
+#define PWD_SUSPEND_EN                  0xFE76
+#define LDO_PWR_SEL                     0xFE78
+
+#define DUMMY_REG_RESET_0               0xFE90
+
+/* Memory mapping */
+#define SRAM_BASE                       0xE600
+#define RBUF_BASE                       0xF400
+#define PPBUF_BASE1                     0xF800
+#define PPBUF_BASE2                     0xFA00
+#define IMAGE_FLAG_ADDR0                0xCE80
+#define IMAGE_FLAG_ADDR1                0xCE81
+
+#define rtsx_pci_init_cmd(pcr)          ((pcr)->ci = 0)
+
+struct rtsx_pcr;
+
+struct pcr_handle {
+        struct rtsx_pcr                 *pcr;
+};
+
+struct pcr_ops {
+        int             (*extra_init_hw)(struct rtsx_pcr *pcr);
+        int             (*optimize_phy)(struct rtsx_pcr *pcr);
+        int             (*turn_on_led)(struct rtsx_pcr *pcr);
+        int             (*turn_off_led)(struct rtsx_pcr *pcr);
+        int             (*enable_auto_blink)(struct rtsx_pcr *pcr);
+        int             (*disable_auto_blink)(struct rtsx_pcr *pcr);
+        int             (*card_power_on)(struct rtsx_pcr *pcr, int card);
+        int             (*card_power_off)(struct rtsx_pcr *pcr, int card);
+        unsigned int    (*cd_deglitch)(struct rtsx_pcr *pcr);
+};
+
+enum PDEV_STAT  {PDEV_STAT_IDLE, PDEV_STAT_RUN};
+
+struct rtsx_pcr {
+        struct pci_dev                  *pci;
+        unsigned int                    id;
+
+        /* pci resources */
+        unsigned long                   addr;
+        void __iomem                    *remap_addr;
+        int                             irq;
+
+        /* host reserved buffer */
+        void                            *rtsx_resv_buf;
+        dma_addr_t                      rtsx_resv_buf_addr;
+
+        void                            *host_cmds_ptr;
+        dma_addr_t                      host_cmds_addr;
+        int                             ci;
+
+        void                            *host_sg_tbl_ptr;
+        dma_addr_t                      host_sg_tbl_addr;
+        int                             sgi;
+
+        u32                             bier;
+        char                            trans_result;
+
+        unsigned int                    card_inserted;
+        unsigned int                    card_removed;
+
+        struct delayed_work             carddet_work;
+        struct delayed_work             idle_work;
+
+        spinlock_t                      lock;
+        struct mutex                    pcr_mutex;
+        struct completion               *done;
+        struct completion               *finish_me;
+
+        unsigned int                    cur_clock;
+        bool                            ms_pmos;
+        bool                            remove_pci;
+        bool                            msi_en;
+
+#define EXTRA_CAPS_SD_SDR50             (1 << 0)
+#define EXTRA_CAPS_SD_SDR104            (1 << 1)
+#define EXTRA_CAPS_SD_DDR50             (1 << 2)
+#define EXTRA_CAPS_MMC_HSDDR            (1 << 3)
+#define EXTRA_CAPS_MMC_HS200            (1 << 4)
+#define EXTRA_CAPS_MMC_8BIT             (1 << 5)
+        u32                             extra_caps;
+
+#define IC_VER_A                        0
+#define IC_VER_B                        1
+#define IC_VER_C                        2
+#define IC_VER_D                        3
+        u8                              ic_version;
+
+        const u32                       *sd_pull_ctl_enable_tbl;
+        const u32                       *sd_pull_ctl_disable_tbl;
+        const u32                       *ms_pull_ctl_enable_tbl;
+        const u32                       *ms_pull_ctl_disable_tbl;
+
+        const struct pcr_ops            *ops;
+        enum PDEV_STAT                  state;
+
+        int                             num_slots;
+        struct rtsx_slot                *slots;
+};
+
+#define CHK_PCI_PID(pcr, pid)           ((pcr)->pci->device == (pid))
+#define PCI_VID(pcr)                    ((pcr)->pci->vendor)
+#define PCI_PID(pcr)                    ((pcr)->pci->device)
+
+void rtsx_pci_start_run(struct rtsx_pcr *pcr);
+int rtsx_pci_write_register(struct rtsx_pcr *pcr, u16 addr, u8 mask, u8 data);
+int rtsx_pci_read_register(struct rtsx_pcr *pcr, u16 addr, u8 *data);
+int rtsx_pci_write_phy_register(struct rtsx_pcr *pcr, u8 addr, u16 val);
+int rtsx_pci_read_phy_register(struct rtsx_pcr *pcr, u8 addr, u16 *val);
+void rtsx_pci_stop_cmd(struct rtsx_pcr *pcr);
+void rtsx_pci_add_cmd(struct rtsx_pcr *pcr,
+                u8 cmd_type, u16 reg_addr, u8 mask, u8 data);
+void rtsx_pci_send_cmd_no_wait(struct rtsx_pcr *pcr);
+int rtsx_pci_send_cmd(struct rtsx_pcr *pcr, int timeout);
+int rtsx_pci_transfer_data(struct rtsx_pcr *pcr, struct scatterlist *sglist,
+                int num_sg, bool read, int timeout);
+int rtsx_pci_read_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len);
+int rtsx_pci_write_ppbuf(struct rtsx_pcr *pcr, u8 *buf, int buf_len);
+int rtsx_pci_card_pull_ctl_enable(struct rtsx_pcr *pcr, int card);
+int rtsx_pci_card_pull_ctl_disable(struct rtsx_pcr *pcr, int card);
+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);
+unsigned int rtsx_pci_card_exist(struct rtsx_pcr *pcr);
+void rtsx_pci_complete_unfinished_transfer(struct rtsx_pcr *pcr);
+
+static inline u8 *rtsx_pci_get_cmd_data(struct rtsx_pcr *pcr)
+{
+        return (u8 *)(pcr->host_cmds_ptr);
+}
+
+#endif
diff --git a/include/linux/migrate.h b/include/linux/migrate.h
index ce7e6671968b..0b5865c61efd 100644
--- a/include/linux/migrate.h
+++ b/include/linux/migrate.h
@@ -7,9 +7,27 @@
 
 typedef struct page *new_page_t(struct page *, unsigned long private, int **);
 
+/*
+ * Return values from addresss_space_operations.migratepage():
+ * - negative errno on page migration failure;
+ * - zero on page migration success;
+ *
+ * The balloon page migration introduces this special case where a 'distinct'
+ * return code is used to flag a successful page migration to unmap_and_move().
+ * This approach is necessary because page migration can race against balloon
+ * deflation procedure, and for such case we could introduce a nasty page leak
+ * if a successfully migrated balloon page gets released concurrently with
+ * migration's unmap_and_move() wrap-up steps.
+ */
+#define MIGRATEPAGE_SUCCESS             0
+#define MIGRATEPAGE_BALLOON_SUCCESS     1 /* special ret code for balloon page
+                                           * sucessful migration case.
+                                           */
+
 #ifdef CONFIG_MIGRATION
 
 extern void putback_lru_pages(struct list_head *l);
+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,
@@ -33,6 +51,7 @@ extern int migrate_huge_page_move_mapping(struct address_space *mapping,
 #else
 
 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) { return -ENOSYS; }
diff --git a/include/linux/mm.h b/include/linux/mm.h
index bcaab4e6fe91..4af4f0b1be4c 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1456,6 +1456,37 @@ extern unsigned long vm_mmap(struct file *, unsigned long,
         unsigned long, unsigned long,
         unsigned long, unsigned long);
 
+struct vm_unmapped_area_info {
+#define VM_UNMAPPED_AREA_TOPDOWN 1
+        unsigned long flags;
+        unsigned long length;
+        unsigned long low_limit;
+        unsigned long high_limit;
+        unsigned long align_mask;
+        unsigned long align_offset;
+};
+
+extern unsigned long unmapped_area(struct vm_unmapped_area_info *info);
+extern unsigned long unmapped_area_topdown(struct vm_unmapped_area_info *info);
+
+/*
+ * Search for an unmapped address range.
+ *
+ * We are looking for a range that:
+ * - does not intersect with any VMA;
+ * - is contained within the [low_limit, high_limit) interval;
+ * - is at least the desired size.
+ * - satisfies (begin_addr & align_mask) == (align_offset & align_mask)
+ */
+static inline unsigned long
+vm_unmapped_area(struct vm_unmapped_area_info *info)
+{
+        if (!(info->flags & VM_UNMAPPED_AREA_TOPDOWN))
+                return unmapped_area(info);
+        else
+                return unmapped_area_topdown(info);
+}
+
 /* truncate.c */
 extern void truncate_inode_pages(struct address_space *, loff_t);
 extern void truncate_inode_pages_range(struct address_space *,
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 31f8a3af7d94..7ade2731b5d6 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -224,7 +224,8 @@ struct vm_region {
  * library, the executable area etc).
  */
 struct vm_area_struct {
-        struct mm_struct * vm_mm;       /* The address space we belong to. */
+        /* The first cache line has the info for VMA tree walking. */
+
         unsigned long vm_start;         /* Our start address within vm_mm. */
         unsigned long vm_end;           /* The first byte after our end address
                                            within vm_mm. */
@@ -232,11 +233,22 @@ struct vm_area_struct {
         /* linked list of VM areas per task, sorted by address */
         struct vm_area_struct *vm_next, *vm_prev;
 
+        struct rb_node vm_rb;
+
+        /*
+         * Largest free memory gap in bytes to the left of this VMA.
+         * Either between this VMA and vma->vm_prev, or between one of the
+         * VMAs below us in the VMA rbtree and its ->vm_prev. This helps
+         * get_unmapped_area find a free area of the right size.
+         */
+        unsigned long rb_subtree_gap;
+
+        /* Second cache line starts here. */
+
+        struct mm_struct *vm_mm;        /* The address space we belong to. */
         pgprot_t vm_page_prot;          /* Access permissions of this VMA. */
         unsigned long vm_flags;         /* Flags, see mm.h. */
 
-        struct rb_node vm_rb;
-
         /*
          * For areas with an address space and backing store,
          * linkage into the address_space->i_mmap interval tree, or
@@ -322,6 +334,7 @@ struct mm_struct {
         unsigned long task_size;                /* size of task vm space */
         unsigned long cached_hole_size;         /* if non-zero, the largest hole below free_area_cache */
         unsigned long free_area_cache;          /* first hole of size cached_hole_size or larger */
+        unsigned long highest_vm_end;           /* highest vma end address */
         pgd_t * pgd;
         atomic_t mm_users;                      /* How many users with user space? */
         atomic_t mm_count;                      /* How many references to "struct mm_struct" (users count as 1) */
diff --git a/include/linux/mman.h b/include/linux/mman.h
index d09dde1e57fb..9aa863da287f 100644
--- a/include/linux/mman.h
+++ b/include/linux/mman.h
@@ -11,6 +11,8 @@ extern int sysctl_overcommit_memory;
 extern int sysctl_overcommit_ratio;
 extern struct percpu_counter vm_committed_as;
 
+unsigned long vm_memory_committed(void);
+
 static inline void vm_acct_memory(long pages)
 {
         percpu_counter_add(&vm_committed_as, pages);
diff --git a/include/linux/mmc/card.h b/include/linux/mmc/card.h
index 943550dfe9ea..5c69315d60cc 100644
--- a/include/linux/mmc/card.h
+++ b/include/linux/mmc/card.h
@@ -85,6 +85,7 @@ struct mmc_ext_csd {
         bool                    boot_ro_lockable;
         u8                      raw_exception_status;   /* 53 */
         u8                      raw_partition_support;  /* 160 */
+        u8                      raw_rpmb_size_mult;     /* 168 */
         u8                      raw_erased_mem_count;   /* 181 */
         u8                      raw_ext_csd_structure;  /* 194 */
         u8                      raw_card_type;          /* 196 */
@@ -206,6 +207,7 @@ struct mmc_part {
 #define MMC_BLK_DATA_AREA_MAIN  (1<<0)
 #define MMC_BLK_DATA_AREA_BOOT  (1<<1)
 #define MMC_BLK_DATA_AREA_GP    (1<<2)
+#define MMC_BLK_DATA_AREA_RPMB  (1<<3)
 };
 
 /*
diff --git a/include/linux/mmc/core.h b/include/linux/mmc/core.h
index 9b9cdafc7737..5bf7c2274fcb 100644
--- a/include/linux/mmc/core.h
+++ b/include/linux/mmc/core.h
@@ -170,6 +170,8 @@ extern int mmc_erase_group_aligned(struct mmc_card *card, unsigned int from,
 extern unsigned int mmc_calc_max_discard(struct mmc_card *card);
 
 extern int mmc_set_blocklen(struct mmc_card *card, unsigned int blocklen);
+extern int mmc_set_blockcount(struct mmc_card *card, unsigned int blockcount,
+                              bool is_rel_write);
 extern int mmc_hw_reset(struct mmc_host *host);
 extern int mmc_hw_reset_check(struct mmc_host *host);
 extern int mmc_can_reset(struct mmc_card *card);
diff --git a/include/linux/mmc/dw_mmc.h b/include/linux/mmc/dw_mmc.h
index 96531664a061..34be4f47293c 100644
--- a/include/linux/mmc/dw_mmc.h
+++ b/include/linux/mmc/dw_mmc.h
@@ -229,8 +229,9 @@ struct dw_mci_board {
         u32 quirks; /* Workaround / Quirk flags */
         unsigned int bus_hz; /* Clock speed at the cclk_in pad */
 
-        unsigned int caps;      /* Capabilities */
-        unsigned int caps2;     /* More capabilities */
+        u32 caps;       /* Capabilities */
+        u32 caps2;      /* More capabilities */
+        u32 pm_caps;    /* PM capabilities */
         /*
          * Override fifo depth. If 0, autodetect it from the FIFOTH register,
          * but note that this may not be reliable after a bootloader has used
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 7abb0e1f7bda..61a10c17aabd 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -53,12 +53,12 @@ struct mmc_ios {
 #define MMC_TIMING_LEGACY       0
 #define MMC_TIMING_MMC_HS       1
 #define MMC_TIMING_SD_HS        2
-#define MMC_TIMING_UHS_SDR12    MMC_TIMING_LEGACY
-#define MMC_TIMING_UHS_SDR25    MMC_TIMING_SD_HS
-#define MMC_TIMING_UHS_SDR50    3
-#define MMC_TIMING_UHS_SDR104   4
-#define MMC_TIMING_UHS_DDR50    5
-#define MMC_TIMING_MMC_HS200    6
+#define MMC_TIMING_UHS_SDR12    3
+#define MMC_TIMING_UHS_SDR25    4
+#define MMC_TIMING_UHS_SDR50    5
+#define MMC_TIMING_UHS_SDR104   6
+#define MMC_TIMING_UHS_DDR50    7
+#define MMC_TIMING_MMC_HS200    8
 
 #define MMC_SDR_MODE            0
 #define MMC_1_2V_DDR_MODE       1
@@ -136,6 +136,7 @@ struct mmc_host_ops {
         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);
 };
 
 struct mmc_card;
@@ -211,7 +212,7 @@ struct mmc_host {
 #define MMC_VDD_34_35           0x00400000      /* VDD voltage 3.4 ~ 3.5 */
 #define MMC_VDD_35_36           0x00800000      /* VDD voltage 3.5 ~ 3.6 */
 
-        unsigned long           caps;           /* Host capabilities */
+        u32                     caps;           /* Host capabilities */
 
 #define MMC_CAP_4_BIT_DATA      (1 << 0)        /* Can the host do 4 bit transfers */
 #define MMC_CAP_MMC_HIGHSPEED   (1 << 1)        /* Can do MMC high-speed timing */
@@ -241,7 +242,7 @@ struct mmc_host {
 #define MMC_CAP_CMD23           (1 << 30)       /* CMD23 supported. */
 #define MMC_CAP_HW_RESET        (1 << 31)       /* Hardware reset */
 
-        unsigned int            caps2;          /* More host capabilities */
+        u32                     caps2;          /* More host capabilities */
 
 #define MMC_CAP2_BOOTPART_NOACC (1 << 0)        /* Boot partition no access */
 #define MMC_CAP2_CACHE_CTRL     (1 << 1)        /* Allow cache control */
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 01e4b394029b..94d532e41c61 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -286,6 +286,7 @@ struct _mmc_csd {
 #define EXT_CSD_BKOPS_START             164     /* W */
 #define EXT_CSD_SANITIZE_START          165     /* W */
 #define EXT_CSD_WR_REL_PARAM            166     /* RO */
+#define EXT_CSD_RPMB_MULT               168     /* RO */
 #define EXT_CSD_BOOT_WP                 173     /* R/W */
 #define EXT_CSD_ERASE_GROUP_DEF         175     /* R/W */
 #define EXT_CSD_PART_CONFIG             179     /* R/W */
@@ -339,6 +340,7 @@ struct _mmc_csd {
 
 #define EXT_CSD_PART_CONFIG_ACC_MASK    (0x7)
 #define EXT_CSD_PART_CONFIG_ACC_BOOT0   (0x1)
+#define EXT_CSD_PART_CONFIG_ACC_RPMB    (0x3)
 #define EXT_CSD_PART_CONFIG_ACC_GP0     (0x4)
 
 #define EXT_CSD_PART_SUPPORT_PART_EN    (0x1)
diff --git a/include/linux/mmc/mxs-mmc.h b/include/linux/mmc/mxs-mmc.h
deleted file mode 100644
index 7c2ad3a7f2f3..000000000000
--- a/include/linux/mmc/mxs-mmc.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Copyright 2011 Freescale Semiconductor, 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 version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef __LINUX_MMC_MXS_MMC_H__
-#define __LINUX_MMC_MXS_MMC_H__
-
-struct mxs_mmc_platform_data {
-        int wp_gpio;    /* write protect pin */
-        unsigned int flags;
-#define SLOTF_4_BIT_CAPABLE     (1 << 0)
-#define SLOTF_8_BIT_CAPABLE     (1 << 1)
-};
-
-#endif /* __LINUX_MMC_MXS_MMC_H__ */
diff --git a/include/linux/mmc/sdhci.h b/include/linux/mmc/sdhci.h
index 1edcb4dad8c4..4bbc3301fbbf 100644
--- a/include/linux/mmc/sdhci.h
+++ b/include/linux/mmc/sdhci.h
@@ -92,6 +92,8 @@ struct sdhci_host {
 
 #define SDHCI_QUIRK2_HOST_OFF_CARD_ON                   (1<<0)
 #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)
 
         int irq;                /* Device IRQ */
         void __iomem *ioaddr;   /* Mapped address */
@@ -158,8 +160,8 @@ struct sdhci_host {
 
         struct timer_list timer;        /* Timer for timeouts */
 
-        unsigned int caps;      /* Alternative CAPABILITY_0 */
-        unsigned int caps1;     /* Alternative CAPABILITY_1 */
+        u32 caps;               /* Alternative CAPABILITY_0 */
+        u32 caps1;              /* Alternative CAPABILITY_1 */
 
         unsigned int            ocr_avail_sdio; /* OCR bit masks */
         unsigned int            ocr_avail_sd;
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index a23923ba8263..0c0b1d608a69 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -63,10 +63,8 @@ enum {
 
 #ifdef CONFIG_CMA
 #  define is_migrate_cma(migratetype) unlikely((migratetype) == MIGRATE_CMA)
-#  define cma_wmark_pages(zone) zone->min_cma_pages
 #else
 #  define is_migrate_cma(migratetype) false
-#  define cma_wmark_pages(zone) 0
 #endif
 
 #define for_each_migratetype_order(order, type) \
@@ -383,13 +381,6 @@ struct zone {
         /* see spanned/present_pages for more description */
         seqlock_t               span_seqlock;
 #endif
-#ifdef CONFIG_CMA
-        /*
-         * CMA needs to increase watermark levels during the allocation
-         * process to make sure that the system is not starved.
-         */
-        unsigned long           min_cma_pages;
-#endif
         struct free_area        free_area[MAX_ORDER];
 
 #ifndef CONFIG_SPARSEMEM
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index f8eda0276f03..a848ffc327f4 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1488,6 +1488,9 @@ struct napi_gro_cb {
 
         /* Used in ipv6_gro_receive() */
         int     proto;
+
+        /* used in skb_gro_receive() slow path */
+        struct sk_buff *last;
 };
 
 #define NAPI_GRO_CB(skb) ((struct napi_gro_cb *)(skb)->cb)
diff --git a/include/linux/node.h b/include/linux/node.h
index 624e53cecc02..2115ad5d6f19 100644
--- a/include/linux/node.h
+++ b/include/linux/node.h
@@ -27,10 +27,9 @@ struct node {
 };
 
 struct memory_block;
-extern struct node node_devices[];
+extern struct node *node_devices[];
 typedef  void (*node_registration_func_t)(struct node *);
 
-extern int register_node(struct node *, int, struct node *);
 extern void unregister_node(struct node *node);
 #ifdef CONFIG_NUMA
 extern int register_one_node(int nid);
diff --git a/include/linux/of.h b/include/linux/of.h
index b4e50d56fc74..60053bd7e79a 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -46,7 +46,7 @@ struct device_node {
         const char *name;
         const char *type;
         phandle phandle;
-        char    *full_name;
+        const char *full_name;
 
         struct  property *properties;
         struct  property *deadprops;    /* removed properties */
@@ -60,7 +60,7 @@ struct device_node {
         unsigned long _flags;
         void    *data;
 #if defined(CONFIG_SPARC)
-        char    *path_component_name;
+        const char *path_component_name;
         unsigned int unique_id;
         struct of_irq_controller *irq_trans;
 #endif
@@ -88,14 +88,14 @@ static inline void of_node_put(struct device_node *node) { }
 #ifdef CONFIG_OF
 
 /* Pointer for first entry in chain of all nodes. */
-extern struct device_node *allnodes;
+extern struct device_node *of_allnodes;
 extern struct device_node *of_chosen;
 extern struct device_node *of_aliases;
 extern rwlock_t devtree_lock;
 
 static inline bool of_have_populated_dt(void)
 {
-        return allnodes != NULL;
+        return of_allnodes != NULL;
 }
 
 static inline bool of_node_is_root(const struct device_node *node)
@@ -179,11 +179,22 @@ extern struct device_node *of_find_compatible_node(struct device_node *from,
 #define for_each_compatible_node(dn, type, compatible) \
         for (dn = of_find_compatible_node(NULL, type, compatible); dn; \
              dn = of_find_compatible_node(dn, type, compatible))
-extern struct device_node *of_find_matching_node(struct device_node *from,
-        const struct of_device_id *matches);
+extern struct device_node *of_find_matching_node_and_match(
+        struct device_node *from,
+        const struct of_device_id *matches,
+        const struct of_device_id **match);
+static inline struct device_node *of_find_matching_node(
+        struct device_node *from,
+        const struct of_device_id *matches)
+{
+        return of_find_matching_node_and_match(from, matches, NULL);
+}
 #define for_each_matching_node(dn, matches) \
         for (dn = of_find_matching_node(NULL, matches); dn; \
              dn = of_find_matching_node(dn, matches))
+#define for_each_matching_node_and_match(dn, matches, match) \
+        for (dn = of_find_matching_node_and_match(NULL, matches, match); \
+             dn; dn = of_find_matching_node_and_match(dn, matches, match))
 extern struct device_node *of_find_node_by_path(const char *path);
 extern struct device_node *of_find_node_by_phandle(phandle handle);
 extern struct device_node *of_get_parent(const struct device_node *node);
@@ -223,6 +234,10 @@ extern struct device_node *of_find_node_with_property(
 extern struct property *of_find_property(const struct device_node *np,
                                          const char *name,
                                          int *lenp);
+extern int of_property_read_u8_array(const struct device_node *np,
+                        const char *propname, u8 *out_values, size_t sz);
+extern int of_property_read_u16_array(const struct device_node *np,
+                        const char *propname, u16 *out_values, size_t sz);
 extern int of_property_read_u32_array(const struct device_node *np,
                                       const char *propname,
                                       u32 *out_values,
@@ -255,7 +270,7 @@ extern int of_n_size_cells(struct device_node *np);
 extern const struct of_device_id *of_match_node(
         const struct of_device_id *matches, const struct device_node *node);
 extern int of_modalias_node(struct device_node *node, char *modalias, int len);
-extern struct device_node *of_parse_phandle(struct device_node *np,
+extern struct device_node *of_parse_phandle(const struct device_node *np,
                                             const char *phandle_name,
                                             int index);
 extern int of_parse_phandle_with_args(struct device_node *np,
@@ -364,6 +379,18 @@ static inline struct device_node *of_find_compatible_node(
         return NULL;
 }
 
+static inline int of_property_read_u8_array(const struct device_node *np,
+                        const char *propname, u8 *out_values, size_t sz)
+{
+        return -ENOSYS;
+}
+
+static inline int of_property_read_u16_array(const struct device_node *np,
+                        const char *propname, u16 *out_values, size_t sz)
+{
+        return -ENOSYS;
+}
+
 static inline int of_property_read_u32_array(const struct device_node *np,
                                              const char *propname,
                                              u32 *out_values, size_t sz)
@@ -411,7 +438,7 @@ static inline int of_property_match_string(struct device_node *np,
         return -ENOSYS;
 }
 
-static inline struct device_node *of_parse_phandle(struct device_node *np,
+static inline struct device_node *of_parse_phandle(const struct device_node *np,
                                                    const char *phandle_name,
                                                    int index)
 {
@@ -470,6 +497,20 @@ static inline bool of_property_read_bool(const struct device_node *np,
         return prop ? true : false;
 }
 
+static inline int of_property_read_u8(const struct device_node *np,
+                                       const char *propname,
+                                       u8 *out_value)
+{
+        return of_property_read_u8_array(np, propname, out_value, 1);
+}
+
+static inline int of_property_read_u16(const struct device_node *np,
+                                       const char *propname,
+                                       u16 *out_value)
+{
+        return of_property_read_u16_array(np, propname, out_value, 1);
+}
+
 static inline int of_property_read_u32(const struct device_node *np,
                                        const char *propname,
                                        u32 *out_value)
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index e20e3af68fb6..0506eb53519b 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -42,10 +42,12 @@ static inline struct device_node *of_find_matching_node_by_address(
 {
         return NULL;
 }
+#ifndef of_iomap
 static inline void __iomem *of_iomap(struct device_node *device, int index)
 {
         return NULL;
 }
+#endif
 static inline const __be32 *of_get_address(struct device_node *dev, int index,
                                         u64 *size, unsigned int *flags)
 {
diff --git a/include/linux/omap-iommu.h b/include/linux/omap-iommu.h
new file mode 100644
index 000000000000..cac78de09c07
--- /dev/null
+++ b/include/linux/omap-iommu.h
@@ -0,0 +1,52 @@
+/*
+ * omap iommu: simple virtual address space management
+ *
+ * Copyright (C) 2008-2009 Nokia Corporation
+ *
+ * Written by Hiroshi DOYU <Hiroshi.DOYU@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.
+ */
+
+#ifndef _INTEL_IOMMU_H_
+#define _INTEL_IOMMU_H_
+
+struct iovm_struct {
+        struct omap_iommu       *iommu; /* iommu object which this belongs to */
+        u32                     da_start; /* area definition */
+        u32                     da_end;
+        u32                     flags; /* IOVMF_: see below */
+        struct list_head        list; /* linked in ascending order */
+        const struct sg_table   *sgt; /* keep 'page' <-> 'da' mapping */
+        void                    *va; /* mpu side mapped address */
+};
+
+#define MMU_RAM_ENDIAN_SHIFT    9
+#define MMU_RAM_ENDIAN_LITTLE   (0 << MMU_RAM_ENDIAN_SHIFT)
+#define MMU_RAM_ELSZ_8          (0 << MMU_RAM_ELSZ_SHIFT)
+#define IOVMF_ENDIAN_LITTLE     MMU_RAM_ENDIAN_LITTLE
+#define MMU_RAM_ELSZ_SHIFT      7
+#define IOVMF_ELSZ_8            MMU_RAM_ELSZ_8
+
+struct iommu_domain;
+
+extern struct iovm_struct *omap_find_iovm_area(struct device *dev, u32 da);
+extern u32
+omap_iommu_vmap(struct iommu_domain *domain, struct device *dev, u32 da,
+                        const struct sg_table *sgt, u32 flags);
+extern struct sg_table *omap_iommu_vunmap(struct iommu_domain *domain,
+                                struct device *dev, u32 da);
+extern u32
+omap_iommu_vmalloc(struct iommu_domain *domain, struct device *dev,
+                                u32 da, size_t bytes, u32 flags);
+extern void
+omap_iommu_vfree(struct iommu_domain *domain, struct device *dev,
+                                const u32 da);
+extern void *omap_da_to_va(struct device *dev, u32 da);
+
+extern void omap_iommu_save_ctx(struct device *dev);
+extern void omap_iommu_restore_ctx(struct device *dev);
+
+#endif
diff --git a/include/linux/oom.h b/include/linux/oom.h
index fb9826847b89..da60007075b5 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -29,8 +29,23 @@ enum oom_scan_t {
         OOM_SCAN_SELECT,        /* always select this thread first */
 };
 
-extern void compare_swap_oom_score_adj(int old_val, int new_val);
-extern int test_set_oom_score_adj(int new_val);
+/* Thread is the potential origin of an oom condition; kill first on oom */
+#define OOM_FLAG_ORIGIN         ((__force oom_flags_t)0x1)
+
+static inline void set_current_oom_origin(void)
+{
+        current->signal->oom_flags |= OOM_FLAG_ORIGIN;
+}
+
+static inline void clear_current_oom_origin(void)
+{
+        current->signal->oom_flags &= ~OOM_FLAG_ORIGIN;
+}
+
+static inline bool oom_task_origin(const struct task_struct *p)
+{
+        return !!(p->signal->oom_flags & OOM_FLAG_ORIGIN);
+}
 
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
@@ -49,8 +64,6 @@ extern void check_panic_on_oom(enum oom_constraint constraint, gfp_t gfp_mask,
 extern enum oom_scan_t oom_scan_process_thread(struct task_struct *task,
                 unsigned long totalpages, const nodemask_t *nodemask,
                 bool force_kill);
-extern void mem_cgroup_out_of_memory(struct mem_cgroup *memcg, gfp_t gfp_mask,
-                                     int order);
 
 extern void out_of_memory(struct zonelist *zonelist, gfp_t gfp_mask,
                 int order, nodemask_t *mask, bool force_kill);
diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
index 76a9539cfd3f..a92061e08d48 100644
--- a/include/linux/page-isolation.h
+++ b/include/linux/page-isolation.h
@@ -2,7 +2,8 @@
 #define __LINUX_PAGEISOLATION_H
 
 
-bool has_unmovable_pages(struct zone *zone, struct page *page, int count);
+bool has_unmovable_pages(struct zone *zone, struct page *page, int count,
+                         bool skip_hwpoisoned_pages);
 void set_pageblock_migratetype(struct page *page, int migratetype);
 int move_freepages_block(struct zone *zone, struct page *page,
                                 int migratetype);
@@ -21,7 +22,7 @@ int move_freepages(struct zone *zone,
  */
 int
 start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
-                         unsigned migratetype);
+                         unsigned migratetype, bool skip_hwpoisoned_pages);
 
 /*
  * Changes MIGRATE_ISOLATE to MIGRATE_MOVABLE.
@@ -34,12 +35,13 @@ undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
 /*
  * Test all pages in [start_pfn, end_pfn) are isolated or not.
  */
-int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn);
+int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
+                        bool skip_hwpoisoned_pages);
 
 /*
  * Internal functions. Changes pageblock's migrate type.
  */
-int set_migratetype_isolate(struct page *page);
+int set_migratetype_isolate(struct page *page, bool skip_hwpoisoned_pages);
 void unset_migratetype_isolate(struct page *page, unsigned migratetype);
 struct page *alloc_migrate_target(struct page *page, unsigned long private,
                                 int **resultp);
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index e42c762f0dc7..6da609d14c15 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -24,6 +24,7 @@ enum mapping_flags {
         AS_ENOSPC       = __GFP_BITS_SHIFT + 1, /* ENOSPC on async write */
         AS_MM_ALL_LOCKS = __GFP_BITS_SHIFT + 2, /* under mm_take_all_locks() */
         AS_UNEVICTABLE  = __GFP_BITS_SHIFT + 3, /* e.g., ramdisk, SHM_LOCK */
+        AS_BALLOON_MAP  = __GFP_BITS_SHIFT + 4, /* balloon page special map */
 };
 
 static inline void mapping_set_error(struct address_space *mapping, int error)
@@ -53,6 +54,21 @@ static inline int mapping_unevictable(struct address_space *mapping)
         return !!mapping;
 }
 
+static inline void mapping_set_balloon(struct address_space *mapping)
+{
+        set_bit(AS_BALLOON_MAP, &mapping->flags);
+}
+
+static inline void mapping_clear_balloon(struct address_space *mapping)
+{
+        clear_bit(AS_BALLOON_MAP, &mapping->flags);
+}
+
+static inline int mapping_balloon(struct address_space *mapping)
+{
+        return mapping && test_bit(AS_BALLOON_MAP, &mapping->flags);
+}
+
 static inline gfp_t mapping_gfp_mask(struct address_space * mapping)
 {
         return (__force gfp_t)mapping->flags & __GFP_BITS_MASK;
diff --git a/include/linux/pci.h b/include/linux/pci.h
index ee2179546c63..d03d2463efac 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -588,7 +588,7 @@ struct pci_driver {
  * in a generic manner.
  */
 #define DEFINE_PCI_DEVICE_TABLE(_table) \
-        const struct pci_device_id _table[] __devinitconst
+        const struct pci_device_id _table[]
 
 /**
  * PCI_DEVICE - macro used to describe a specific pci device
@@ -686,7 +686,7 @@ struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
 int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
 int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
 void pci_bus_release_busn_res(struct pci_bus *b);
-struct pci_bus * __devinit pci_scan_root_bus(struct device *parent, int bus,
+struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
                                              struct pci_ops *ops, void *sysdata,
                                              struct list_head *resources);
 struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
@@ -941,10 +941,8 @@ void set_pcie_hotplug_bridge(struct pci_dev *pdev);
 
 /* Functions for PCI Hotplug drivers to use */
 int pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
-#ifdef CONFIG_HOTPLUG
 unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
 unsigned int pci_rescan_bus(struct pci_bus *bus);
-#endif
 
 /* Vital product data routines */
 ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
@@ -1580,7 +1578,7 @@ extern int pci_pci_problems;
 
 extern unsigned long pci_cardbus_io_size;
 extern unsigned long pci_cardbus_mem_size;
-extern u8 __devinitdata pci_dfl_cache_line_size;
+extern u8 pci_dfl_cache_line_size;
 extern u8 pci_cache_line_size;
 
 extern unsigned long pci_hotplug_io_size;
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 9d36b829533a..0f8447376ddb 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1985,6 +1985,9 @@
 #define PCI_DEVICE_ID_EXAR_XR17C152     0x0152
 #define PCI_DEVICE_ID_EXAR_XR17C154     0x0154
 #define PCI_DEVICE_ID_EXAR_XR17C158     0x0158
+#define PCI_DEVICE_ID_EXAR_XR17V352     0x0352
+#define PCI_DEVICE_ID_EXAR_XR17V354     0x0354
+#define PCI_DEVICE_ID_EXAR_XR17V358     0x0358
 
 #define PCI_VENDOR_ID_MICROGATE         0x13c0
 #define PCI_DEVICE_ID_MICROGATE_USC     0x0010
@@ -2323,6 +2326,8 @@
 
 #define PCI_VENDOR_ID_TOPSPIN           0x1867
 
+#define PCI_VENDOR_ID_COMMTECH          0x18f7
+
 #define PCI_VENDOR_ID_SILAN             0x1904
 
 #define PCI_VENDOR_ID_RENESAS           0x1912
diff --git a/include/linux/percpu-rwsem.h b/include/linux/percpu-rwsem.h
index 250a4acddb2b..bd1e86071e57 100644
--- a/include/linux/percpu-rwsem.h
+++ b/include/linux/percpu-rwsem.h
@@ -13,7 +13,7 @@ struct percpu_rw_semaphore {
 };
 
 #define light_mb()      barrier()
-#define heavy_mb()      synchronize_sched()
+#define heavy_mb()      synchronize_sched_expedited()
 
 static inline void percpu_down_read(struct percpu_rw_semaphore *p)
 {
@@ -51,7 +51,7 @@ static inline void percpu_down_write(struct percpu_rw_semaphore *p)
 {
         mutex_lock(&p->mtx);
         p->locked = true;
-        synchronize_sched(); /* make sure that all readers exit the rcu_read_lock_sched region */
+        synchronize_sched_expedited(); /* make sure that all readers exit the rcu_read_lock_sched region */
         while (__percpu_count(p->counters))
                 msleep(1);
         heavy_mb(); /* C, between read of p->counter and write to data, paired with B */
diff --git a/include/linux/pinctrl/pinconf-generic.h b/include/linux/pinctrl/pinconf-generic.h
index 4f0abb9f1c09..47a1bdd88878 100644
--- a/include/linux/pinctrl/pinconf-generic.h
+++ b/include/linux/pinctrl/pinconf-generic.h
@@ -46,11 +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_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
- *      setting pins to this mode. The argument zero turns the schmitt trigger
- *      off.
+ *      setting pins to this mode.
  * @PIN_CONFIG_INPUT_DEBOUNCE: this will configure the pin to debounce mode,
  *      which means it will wait for signals to settle when reading inputs. The
  *      argument gives the debounce time on a custom format. Setting the
@@ -74,6 +74,7 @@ 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_INPUT_SCHMITT,
         PIN_CONFIG_INPUT_DEBOUNCE,
         PIN_CONFIG_POWER_SOURCE,
diff --git a/include/linux/pinctrl/pinctrl.h b/include/linux/pinctrl/pinctrl.h
index 7d087f03e91e..04d6700d99af 100644
--- a/include/linux/pinctrl/pinctrl.h
+++ b/include/linux/pinctrl/pinctrl.h
@@ -134,6 +134,25 @@ extern void pinctrl_add_gpio_range(struct pinctrl_dev *pctldev,
 extern void pinctrl_add_gpio_ranges(struct pinctrl_dev *pctldev,
                                 struct pinctrl_gpio_range *ranges,
                                 unsigned nranges);
+extern void pinctrl_remove_gpio_range(struct pinctrl_dev *pctldev,
+                                struct pinctrl_gpio_range *range);
+
+extern struct pinctrl_dev *pinctrl_find_and_add_gpio_range(const char *devname,
+                struct pinctrl_gpio_range *range);
+extern struct pinctrl_gpio_range *
+pinctrl_find_gpio_range_from_pin(struct pinctrl_dev *pctldev,
+                                 unsigned int pin);
+
+#ifdef CONFIG_OF
+extern struct pinctrl_dev *of_pinctrl_get(struct device_node *np);
+#else
+static inline
+struct pinctrl_dev *of_pinctrl_get(struct device_node *np)
+{
+        return NULL;
+}
+#endif /* CONFIG_OF */
+
 extern const char *pinctrl_dev_get_name(struct pinctrl_dev *pctldev);
 extern void *pinctrl_dev_get_drvdata(struct pinctrl_dev *pctldev);
 #else
diff --git a/include/linux/platform_data/ad5449.h b/include/linux/platform_data/ad5449.h
new file mode 100644
index 000000000000..bd712bd4b94e
--- /dev/null
+++ b/include/linux/platform_data/ad5449.h
@@ -0,0 +1,40 @@
+/*
+ * AD5415, AD5426, AD5429, AD5432, AD5439, AD5443, AD5449 Digital to Analog
+ * Converter driver.
+ *
+ * Copyright 2012 Analog Devices Inc.
+ *  Author: Lars-Peter Clausen <lars@metafoo.de>
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_AD5449_H__
+#define __LINUX_PLATFORM_DATA_AD5449_H__
+
+/**
+ * enum ad5449_sdo_mode - AD5449 SDO pin configuration
+ * @AD5449_SDO_DRIVE_FULL: Drive the SDO pin with full strength.
+ * @AD5449_SDO_DRIVE_WEAK: Drive the SDO pin with not full strength.
+ * @AD5449_SDO_OPEN_DRAIN: Operate the SDO pin in open-drain mode.
+ * @AD5449_SDO_DISABLED: Disable the SDO pin, in this mode it is not possible to
+ *                      read back from the device.
+ */
+enum ad5449_sdo_mode {
+        AD5449_SDO_DRIVE_FULL = 0x0,
+        AD5449_SDO_DRIVE_WEAK = 0x1,
+        AD5449_SDO_OPEN_DRAIN = 0x2,
+        AD5449_SDO_DISABLED = 0x3,
+};
+
+/**
+ * struct ad5449_platform_data - Platform data for the ad5449 DAC driver
+ * @sdo_mode: SDO pin mode
+ * @hardware_clear_to_midscale: Whether asserting the hardware CLR pin sets the
+ *                      outputs to midscale (true) or to zero scale(false).
+ */
+struct ad5449_platform_data {
+        enum ad5449_sdo_mode sdo_mode;
+        bool hardware_clear_to_midscale;
+};
+
+#endif
diff --git a/include/linux/platform_data/ad7298.h b/include/linux/platform_data/ad7298.h
new file mode 100644
index 000000000000..fbf8adf1363a
--- /dev/null
+++ b/include/linux/platform_data/ad7298.h
@@ -0,0 +1,20 @@
+/*
+ * AD7298 SPI ADC driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_AD7298_H__
+#define __LINUX_PLATFORM_DATA_AD7298_H__
+
+/**
+ * struct ad7298_platform_data - Platform data for the ad7298 ADC driver
+ * @ext_ref: Whether to use an external reference voltage.
+ **/
+struct ad7298_platform_data {
+        bool ext_ref;
+};
+
+#endif /* IIO_ADC_AD7298_H_ */
diff --git a/include/linux/platform_data/ad7793.h b/include/linux/platform_data/ad7793.h
new file mode 100644
index 000000000000..7ea6751aae6d
--- /dev/null
+++ b/include/linux/platform_data/ad7793.h
@@ -0,0 +1,112 @@
+/*
+ * AD7792/AD7793 SPI ADC driver
+ *
+ * Copyright 2011 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+#ifndef __LINUX_PLATFORM_DATA_AD7793_H__
+#define __LINUX_PLATFORM_DATA_AD7793_H__
+
+/**
+ * enum ad7793_clock_source - AD7793 clock source selection
+ * @AD7793_CLK_SRC_INT: Internal 64 kHz clock, not available at the CLK pin.
+ * @AD7793_CLK_SRC_INT_CO: Internal 64 kHz clock, available at the CLK pin.
+ * @AD7793_CLK_SRC_EXT: Use external clock.
+ * @AD7793_CLK_SRC_EXT_DIV2: Use external clock divided by 2.
+ */
+enum ad7793_clock_source {
+        AD7793_CLK_SRC_INT,
+        AD7793_CLK_SRC_INT_CO,
+        AD7793_CLK_SRC_EXT,
+        AD7793_CLK_SRC_EXT_DIV2,
+};
+
+/**
+ * enum ad7793_bias_voltage - AD7793 bias voltage selection
+ * @AD7793_BIAS_VOLTAGE_DISABLED: Bias voltage generator disabled
+ * @AD7793_BIAS_VOLTAGE_AIN1: Bias voltage connected to AIN1(-).
+ * @AD7793_BIAS_VOLTAGE_AIN2: Bias voltage connected to AIN2(-).
+ * @AD7793_BIAS_VOLTAGE_AIN3: Bias voltage connected to AIN3(-).
+ *      Only valid for AD7795/AD7796.
+ */
+enum ad7793_bias_voltage {
+        AD7793_BIAS_VOLTAGE_DISABLED,
+        AD7793_BIAS_VOLTAGE_AIN1,
+        AD7793_BIAS_VOLTAGE_AIN2,
+        AD7793_BIAS_VOLTAGE_AIN3,
+};
+
+/**
+ * enum ad7793_refsel - AD7793 reference voltage selection
+ * @AD7793_REFSEL_REFIN1: External reference applied between REFIN1(+)
+ *      and REFIN1(-).
+ * @AD7793_REFSEL_REFIN2: External reference applied between REFIN2(+) and
+ *      and REFIN1(-). Only valid for AD7795/AD7796.
+ * @AD7793_REFSEL_INTERNAL: Internal 1.17 V reference.
+ */
+enum ad7793_refsel {
+        AD7793_REFSEL_REFIN1 = 0,
+        AD7793_REFSEL_REFIN2 = 1,
+        AD7793_REFSEL_INTERNAL = 2,
+};
+
+/**
+ * enum ad7793_current_source_direction - AD7793 excitation current direction
+ * @AD7793_IEXEC1_IOUT1_IEXEC2_IOUT2: Current source IEXC1 connected to pin
+ *      IOUT1, current source IEXC2 connected to pin IOUT2.
+ * @AD7793_IEXEC1_IOUT2_IEXEC2_IOUT1: Current source IEXC2 connected to pin
+ *      IOUT1, current source IEXC1 connected to pin IOUT2.
+ * @AD7793_IEXEC1_IEXEC2_IOUT1: Both current sources connected to pin IOUT1.
+ *      Only valid when the current sources are set to 10 uA or 210 uA.
+ * @AD7793_IEXEC1_IEXEC2_IOUT2: Both current sources connected to Pin IOUT2.
+ *      Only valid when the current ources are set to 10 uA or 210 uA.
+ */
+enum ad7793_current_source_direction {
+        AD7793_IEXEC1_IOUT1_IEXEC2_IOUT2 = 0,
+        AD7793_IEXEC1_IOUT2_IEXEC2_IOUT1 = 1,
+        AD7793_IEXEC1_IEXEC2_IOUT1 = 2,
+        AD7793_IEXEC1_IEXEC2_IOUT2 = 3,
+};
+
+/**
+ * enum ad7793_excitation_current - AD7793 excitation current selection
+ * @AD7793_IX_DISABLED: Excitation current Disabled.
+ * @AD7793_IX_10uA: Enable 10 micro-ampere excitation current.
+ * @AD7793_IX_210uA: Enable 210 micro-ampere excitation current.
+ * @AD7793_IX_1mA: Enable 1 milli-Ampere excitation current.
+ */
+enum ad7793_excitation_current {
+        AD7793_IX_DISABLED = 0,
+        AD7793_IX_10uA = 1,
+        AD7793_IX_210uA = 2,
+        AD7793_IX_1mA = 3,
+};
+
+/**
+ * struct ad7793_platform_data - AD7793 platform data
+ * @clock_src: Clock source selection
+ * @burnout_current: If set to true the 100nA burnout current is enabled.
+ * @boost_enable: Enable boost for the bias voltage generator.
+ * @buffered: If set to true configure the device for buffered input mode.
+ * @unipolar: If set to true sample in unipolar mode, if set to false sample in
+ *              bipolar mode.
+ * @refsel: Reference voltage selection
+ * @bias_voltage: Bias voltage selection
+ * @exitation_current: Excitation current selection
+ * @current_source_direction: Excitation current direction selection
+ */
+struct ad7793_platform_data {
+        enum ad7793_clock_source clock_src;
+        bool burnout_current;
+        bool boost_enable;
+        bool buffered;
+        bool unipolar;
+
+        enum ad7793_refsel refsel;
+        enum ad7793_bias_voltage bias_voltage;
+        enum ad7793_excitation_current exitation_current;
+        enum ad7793_current_source_direction current_source_direction;
+};
+
+#endif /* IIO_ADC_AD7793_H_ */
diff --git a/include/linux/platform_data/ad7887.h b/include/linux/platform_data/ad7887.h
new file mode 100644
index 000000000000..1e06eac3174d
--- /dev/null
+++ b/include/linux/platform_data/ad7887.h
@@ -0,0 +1,26 @@
+/*
+ * AD7887 SPI ADC driver
+ *
+ * Copyright 2010 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2 or later.
+ */
+#ifndef IIO_ADC_AD7887_H_
+#define IIO_ADC_AD7887_H_
+
+/**
+ * struct ad7887_platform_data - AD7887 ADC driver platform data
+ * @en_dual: Whether to use dual channel mode. If set to true AIN1 becomes the
+ *      second input channel, and Vref is internally connected to Vdd. If set to
+ *      false the device is used in single channel mode and AIN1/Vref is used as
+ *      VREF input.
+ * @use_onchip_ref: Whether to use the onchip reference. If set to true the
+ *      internal 2.5V reference is used. If set to false a external reference is
+ *      used.
+ */
+struct ad7887_platform_data {
+        bool en_dual;
+        bool use_onchip_ref;
+};
+
+#endif /* IIO_ADC_AD7887_H_ */
diff --git a/include/linux/platform_data/ads7828.h b/include/linux/platform_data/ads7828.h
new file mode 100644
index 000000000000..3245f45f9d77
--- /dev/null
+++ b/include/linux/platform_data/ads7828.h
@@ -0,0 +1,29 @@
+/*
+ * TI ADS7828 A/D Converter platform data definition
+ *
+ * Copyright (c) 2012 Savoir-faire Linux Inc.
+ *          Vivien Didelot <vivien.didelot@savoirfairelinux.com>
+ *
+ * For further information, see the Documentation/hwmon/ads7828 file.
+ *
+ * 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 _PDATA_ADS7828_H
+#define _PDATA_ADS7828_H
+
+/**
+ * struct ads7828_platform_data - optional ADS7828 connectivity info
+ * @diff_input:         Differential input mode.
+ * @ext_vref:           Use an external voltage reference.
+ * @vref_mv:            Voltage reference value, if external.
+ */
+struct ads7828_platform_data {
+        bool diff_input;
+        bool ext_vref;
+        unsigned int vref_mv;
+};
+
+#endif /* _PDATA_ADS7828_H */
diff --git a/include/linux/platform_data/atmel.h b/include/linux/platform_data/atmel.h
index b0f2c56a8ea2..6a293b7fff3b 100644
--- a/include/linux/platform_data/atmel.h
+++ b/include/linux/platform_data/atmel.h
@@ -8,6 +8,55 @@
 #define __ATMEL_H__
 
 #include <linux/mtd/nand.h>
+#include <linux/mtd/partitions.h>
+#include <linux/device.h>
+#include <linux/i2c.h>
+#include <linux/leds.h>
+#include <linux/spi/spi.h>
+#include <linux/usb/atmel_usba_udc.h>
+#include <linux/atmel-mci.h>
+#include <sound/atmel-ac97c.h>
+#include <linux/serial.h>
+#include <linux/platform_data/macb.h>
+
+/*
+ * at91: 6 USARTs and one DBGU port (SAM9260)
+ * avr32: 4
+ */
+#define ATMEL_MAX_UART  7
+
+ /* USB Device */
+struct at91_udc_data {
+        int     vbus_pin;               /* high == host powering us */
+        u8      vbus_active_low;        /* vbus polarity */
+        u8      vbus_polled;            /* Use polling, not interrupt */
+        int     pullup_pin;             /* active == D+ pulled up */
+        u8      pullup_active_low;      /* true == pullup_pin is active low */
+};
+
+ /* Compact Flash */
+struct at91_cf_data {
+        int     irq_pin;                /* I/O IRQ */
+        int     det_pin;                /* Card detect */
+        int     vcc_pin;                /* power switching */
+        int     rst_pin;                /* card reset */
+        u8      chipselect;             /* EBI Chip Select number */
+        u8      flags;
+#define AT91_CF_TRUE_IDE        0x01
+#define AT91_IDE_SWAP_A0_A2     0x02
+};
+
+ /* USB Host */
+#define AT91_MAX_USBH_PORTS     3
+struct at91_usbh_data {
+        int             vbus_pin[AT91_MAX_USBH_PORTS];  /* port power-control pin */
+        int             overcurrent_pin[AT91_MAX_USBH_PORTS];
+        u8              ports;                          /* number of ports on root hub */
+        u8              overcurrent_supported;
+        u8              vbus_pin_active_low[AT91_MAX_USBH_PORTS];
+        u8              overcurrent_status[AT91_MAX_USBH_PORTS];
+        u8              overcurrent_changed[AT91_MAX_USBH_PORTS];
+};
 
  /* NAND / SmartMedia */
 struct atmel_nand_data {
@@ -24,4 +73,28 @@ struct atmel_nand_data {
         unsigned int    num_parts;
 };
 
+ /* Serial */
+struct atmel_uart_data {
+        int                     num;            /* port num */
+        short                   use_dma_tx;     /* use transmit DMA? */
+        short                   use_dma_rx;     /* use receive DMA? */
+        void __iomem            *regs;          /* virt. base address, if any */
+        struct serial_rs485     rs485;          /* rs485 settings */
+};
+
+ /* Touchscreen Controller */
+struct at91_tsadcc_data {
+        unsigned int    adc_clock;
+        u8              pendet_debounce;
+        u8              ts_sample_hold_time;
+};
+
+/* CAN */
+struct at91_can_data {
+        void (*transceiver_switch)(int on);
+};
+
+/* FIXME: this needs a better location, but gets stuff building again */
+extern int at91_suspend_entering_slow_clock(void);
+
 #endif /* __ATMEL_H__ */
diff --git a/include/linux/platform_data/clk-integrator.h b/include/linux/platform_data/clk-integrator.h
index 83fe9c283bb8..280edac9d0a5 100644
--- a/include/linux/platform_data/clk-integrator.h
+++ b/include/linux/platform_data/clk-integrator.h
@@ -1 +1,3 @@
 void integrator_clk_init(bool is_cp);
+void integrator_impd1_clk_init(void __iomem *base, unsigned int id);
+void integrator_impd1_clk_exit(unsigned int id);
diff --git a/include/linux/platform_data/db8500_thermal.h b/include/linux/platform_data/db8500_thermal.h
new file mode 100644
index 000000000000..3bf60902e902
--- /dev/null
+++ b/include/linux/platform_data/db8500_thermal.h
@@ -0,0 +1,38 @@
+/*
+ * db8500_thermal.h - DB8500 Thermal Management Implementation
+ *
+ * Copyright (C) 2012 ST-Ericsson
+ * Copyright (C) 2012 Linaro Ltd.
+ *
+ * Author: Hongbo Zhang <hongbo.zhang@linaro.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 _DB8500_THERMAL_H_
+#define _DB8500_THERMAL_H_
+
+#include <linux/thermal.h>
+
+#define COOLING_DEV_MAX 8
+
+struct db8500_trip_point {
+        unsigned long temp;
+        enum thermal_trip_type type;
+        char cdev_name[COOLING_DEV_MAX][THERMAL_NAME_LENGTH];
+};
+
+struct db8500_thsens_platform_data {
+        struct db8500_trip_point trip_points[THERMAL_MAX_TRIPS];
+        int num_trips;
+};
+
+#endif /* _DB8500_THERMAL_H_ */
diff --git a/include/linux/platform_data/dmtimer-omap.h b/include/linux/platform_data/dmtimer-omap.h
new file mode 100644
index 000000000000..a19b78d826e9
--- /dev/null
+++ b/include/linux/platform_data/dmtimer-omap.h
@@ -0,0 +1,31 @@
+/*
+ * DMTIMER platform data for TI OMAP platforms
+ *
+ * Copyright (C) 2012 Texas Instruments
+ * Author: Jon Hunter <jon-hunter@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.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along with
+ * this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef __PLATFORM_DATA_DMTIMER_OMAP_H__
+#define __PLATFORM_DATA_DMTIMER_OMAP_H__
+
+struct dmtimer_platform_data {
+        /* set_timer_src - Only used for OMAP1 devices */
+        int (*set_timer_src)(struct platform_device *pdev, int source);
+        u32 timer_capability;
+        u32 timer_errata;
+        int (*get_context_loss_count)(struct device *);
+};
+
+#endif /* __PLATFORM_DATA_DMTIMER_OMAP_H__ */
diff --git a/include/linux/platform_data/gpio-omap.h b/include/linux/platform_data/gpio-omap.h
index e8741c2678d5..5d50b25a73d7 100644
--- a/include/linux/platform_data/gpio-omap.h
+++ b/include/linux/platform_data/gpio-omap.h
@@ -26,7 +26,6 @@
 
 #include <linux/io.h>
 #include <linux/platform_device.h>
-#include <mach/irqs.h>
 
 #define OMAP1_MPUIO_BASE                        0xfffb5000
 
diff --git a/include/linux/platform_data/gpio-ts5500.h b/include/linux/platform_data/gpio-ts5500.h
new file mode 100644
index 000000000000..b10d11c9bb49
--- /dev/null
+++ b/include/linux/platform_data/gpio-ts5500.h
@@ -0,0 +1,27 @@
+/*
+ * GPIO (DIO) header for Technologic Systems TS-5500
+ *
+ * Copyright (c) 2012 Savoir-faire Linux Inc.
+ *      Vivien Didelot <vivien.didelot@savoirfairelinux.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 _PDATA_GPIO_TS5500_H
+#define _PDATA_GPIO_TS5500_H
+
+/**
+ * struct ts5500_dio_platform_data - TS-5500 pin block configuration
+ * @base:       The GPIO base number to use.
+ * @strap:      The only pin connected to an interrupt in a block is input-only.
+ *              If you need a bidirectional line which can trigger an IRQ, you
+ *              may strap it with an in/out pin. This flag indicates this case.
+ */
+struct ts5500_dio_platform_data {
+        int base;
+        bool strap;
+};
+
+#endif /* _PDATA_GPIO_TS5500_H */
diff --git a/include/linux/platform_data/iommu-omap.h b/include/linux/platform_data/iommu-omap.h
new file mode 100644
index 000000000000..c677b9f2fefa
--- /dev/null
+++ b/include/linux/platform_data/iommu-omap.h
@@ -0,0 +1,49 @@
+/*
+ * omap iommu: main structures
+ *
+ * Copyright (C) 2008-2009 Nokia Corporation
+ *
+ * Written by Hiroshi DOYU <Hiroshi.DOYU@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.
+ */
+
+#define MMU_REG_SIZE            256
+
+/**
+ * struct iommu_arch_data - omap iommu private data
+ * @name: name of the iommu device
+ * @iommu_dev: handle of the iommu device
+ *
+ * This is an omap iommu private data object, which binds an iommu user
+ * to its iommu device. This object should be placed at the iommu user's
+ * dev_archdata so generic IOMMU API can be used without having to
+ * utilize omap-specific plumbing anymore.
+ */
+struct omap_iommu_arch_data {
+        const char *name;
+        struct omap_iommu *iommu_dev;
+};
+
+/**
+ * struct omap_mmu_dev_attr - OMAP mmu device attributes for omap_hwmod
+ * @da_start:           device address where the va space starts.
+ * @da_end:             device address where the va space ends.
+ * @nr_tlb_entries:     number of entries supported by the translation
+ *                      look-aside buffer (TLB).
+ */
+struct omap_mmu_dev_attr {
+        u32 da_start;
+        u32 da_end;
+        int nr_tlb_entries;
+};
+
+struct iommu_platform_data {
+        const char *name;
+        const char *clk_name;
+        const int nr_tlb_entries;
+        u32 da_start;
+        u32 da_end;
+};
diff --git a/include/linux/platform_data/leds-omap.h b/include/linux/platform_data/leds-omap.h
new file mode 100644
index 000000000000..56c9b2a0ada5
--- /dev/null
+++ b/include/linux/platform_data/leds-omap.h
@@ -0,0 +1,22 @@
+/*
+ *  Copyright (C) 2006 Samsung Electronics
+ *  Kyungmin Park <kyungmin.park@samsung.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef ASMARM_ARCH_LED_H
+#define ASMARM_ARCH_LED_H
+
+struct omap_led_config {
+        struct led_classdev     cdev;
+        s16                     gpio;
+};
+
+struct omap_led_platform_data {
+        s16                     nr_leds;
+        struct omap_led_config  *leds;
+};
+
+#endif
diff --git a/include/linux/platform_data/mmc-omap.h b/include/linux/platform_data/mmc-omap.h
new file mode 100644
index 000000000000..2bf1b30cb5dc
--- /dev/null
+++ b/include/linux/platform_data/mmc-omap.h
@@ -0,0 +1,151 @@
+/*
+ * MMC definitions for OMAP2
+ *
+ * Copyright (C) 2006 Nokia Corporation
+ *
+ * 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.
+ */
+
+#define OMAP_MMC_MAX_SLOTS      2
+
+/*
+ * struct omap_mmc_dev_attr.flags possibilities
+ *
+ * OMAP_HSMMC_SUPPORTS_DUAL_VOLT: Some HSMMC controller instances can
+ *    operate with either 1.8Vdc or 3.0Vdc card voltages; this flag
+ *    should be set if this is the case.  See for example Section 22.5.3
+ *    "MMC/SD/SDIO1 Bus Voltage Selection" of the OMAP34xx Multimedia
+ *    Device Silicon Revision 3.1.x Revision ZR (July 2011) (SWPU223R).
+ *
+ * OMAP_HSMMC_BROKEN_MULTIBLOCK_READ: Multiple-block read transfers
+ *    don't work correctly on some MMC controller instances on some
+ *    OMAP3 SoCs; this flag should be set if this is the case.  See
+ *    for example Advisory 2.1.1.128 "MMC: Multiple Block Read
+ *    Operation Issue" in _OMAP3530/3525/3515/3503 Silicon Errata_
+ *    Revision F (October 2010) (SPRZ278F).
+ */
+#define OMAP_HSMMC_SUPPORTS_DUAL_VOLT           BIT(0)
+#define OMAP_HSMMC_BROKEN_MULTIBLOCK_READ       BIT(1)
+
+struct mmc_card;
+
+struct omap_mmc_dev_attr {
+        u8 flags;
+};
+
+struct omap_mmc_platform_data {
+        /* back-link to device */
+        struct device *dev;
+
+        /* number of slots per controller */
+        unsigned nr_slots:2;
+
+        /* set if your board has components or wiring that limits the
+         * maximum frequency on the MMC bus */
+        unsigned int max_freq;
+
+        /* switch the bus to a new slot */
+        int (*switch_slot)(struct device *dev, int slot);
+        /* initialize board-specific MMC functionality, can be NULL if
+         * not supported */
+        int (*init)(struct device *dev);
+        void (*cleanup)(struct device *dev);
+        void (*shutdown)(struct device *dev);
+
+        /* To handle board related suspend/resume functionality for MMC */
+        int (*suspend)(struct device *dev, int slot);
+        int (*resume)(struct device *dev, int slot);
+
+        /* Return context loss count due to PM states changing */
+        int (*get_context_loss_count)(struct device *dev);
+
+        /* Integrating attributes from the omap_hwmod layer */
+        u8 controller_flags;
+
+        /* Register offset deviation */
+        u16 reg_offset;
+
+        struct omap_mmc_slot_data {
+
+                /*
+                 * 4/8 wires and any additional host capabilities
+                 * need to OR'd all capabilities (ref. linux/mmc/host.h)
+                 */
+                u8  wires;      /* Used for the MMC driver on omap1 and 2420 */
+                u32 caps;       /* Used for the MMC driver on 2430 and later */
+                u32 pm_caps;    /* PM capabilities of the mmc */
+
+                /*
+                 * nomux means "standard" muxing is wrong on this board, and
+                 * that board-specific code handled it before common init logic.
+                 */
+                unsigned nomux:1;
+
+                /* switch pin can be for card detect (default) or card cover */
+                unsigned cover:1;
+
+                /* use the internal clock */
+                unsigned internal_clock:1;
+
+                /* nonremovable e.g. eMMC */
+                unsigned nonremovable:1;
+
+                /* Try to sleep or power off when possible */
+                unsigned power_saving:1;
+
+                /* If using power_saving and the MMC power is not to go off */
+                unsigned no_off:1;
+
+                /* eMMC does not handle power off when not in sleep state */
+                unsigned no_regulator_off_init:1;
+
+                /* Regulator off remapped to sleep */
+                unsigned vcc_aux_disable_is_sleep:1;
+
+                /* we can put the features above into this variable */
+#define HSMMC_HAS_PBIAS         (1 << 0)
+#define HSMMC_HAS_UPDATED_RESET (1 << 1)
+#define HSMMC_HAS_HSPE_SUPPORT  (1 << 2)
+#define MMC_OMAP7XX             (1 << 3)
+#define MMC_OMAP15XX            (1 << 4)
+#define MMC_OMAP16XX            (1 << 5)
+                unsigned features;
+
+                int switch_pin;                 /* gpio (card detect) */
+                int gpio_wp;                    /* gpio (write protect) */
+
+                int (*set_bus_mode)(struct device *dev, int slot, int bus_mode);
+                int (*set_power)(struct device *dev, int slot,
+                                 int power_on, int vdd);
+                int (*get_ro)(struct device *dev, int slot);
+                void (*remux)(struct device *dev, int slot, int power_on);
+                /* Call back before enabling / disabling regulators */
+                void (*before_set_reg)(struct device *dev, int slot,
+                                       int power_on, int vdd);
+                /* Call back after enabling / disabling regulators */
+                void (*after_set_reg)(struct device *dev, int slot,
+                                      int power_on, int vdd);
+                /* if we have special card, init it using this callback */
+                void (*init_card)(struct mmc_card *card);
+
+                /* return MMC cover switch state, can be NULL if not supported.
+                 *
+                 * possible return values:
+                 *   0 - closed
+                 *   1 - open
+                 */
+                int (*get_cover_state)(struct device *dev, int slot);
+
+                const char *name;
+                u32 ocr_mask;
+
+                /* Card detection IRQs */
+                int card_detect_irq;
+                int (*card_detect)(struct device *dev, int slot);
+
+                unsigned int ban_openended:1;
+
+        } slots[OMAP_MMC_MAX_SLOTS];
+};
diff --git a/include/linux/platform_data/mtd-nand-omap2.h b/include/linux/platform_data/mtd-nand-omap2.h
index 1a68c1e5fe53..24d32ca34bef 100644
--- a/include/linux/platform_data/mtd-nand-omap2.h
+++ b/include/linux/platform_data/mtd-nand-omap2.h
@@ -8,9 +8,13 @@
  * published by the Free Software Foundation.
  */
 
-#include <plat/gpmc.h>
+#ifndef _MTD_NAND_OMAP2_H
+#define _MTD_NAND_OMAP2_H
+
 #include <linux/mtd/partitions.h>
 
+#define GPMC_BCH_NUM_REMAINDER  8
+
 enum nand_io {
         NAND_OMAP_PREFETCH_POLLED = 0,  /* prefetch polled mode, default */
         NAND_OMAP_POLLED,               /* polled mode, without prefetch */
@@ -18,10 +22,38 @@ enum nand_io {
         NAND_OMAP_PREFETCH_IRQ          /* prefetch enabled irq mode */
 };
 
+enum omap_ecc {
+                /* 1-bit ecc: stored at end of spare area */
+        OMAP_ECC_HAMMING_CODE_DEFAULT = 0, /* Default, s/w method */
+        OMAP_ECC_HAMMING_CODE_HW, /* gpmc to detect the error */
+                /* 1-bit ecc: stored at beginning of spare area as romcode */
+        OMAP_ECC_HAMMING_CODE_HW_ROMCODE, /* gpmc method & romcode layout */
+        OMAP_ECC_BCH4_CODE_HW, /* 4-bit BCH ecc code */
+        OMAP_ECC_BCH8_CODE_HW, /* 8-bit BCH ecc code */
+};
+
+struct gpmc_nand_regs {
+        void __iomem    *gpmc_status;
+        void __iomem    *gpmc_nand_command;
+        void __iomem    *gpmc_nand_address;
+        void __iomem    *gpmc_nand_data;
+        void __iomem    *gpmc_prefetch_config1;
+        void __iomem    *gpmc_prefetch_config2;
+        void __iomem    *gpmc_prefetch_control;
+        void __iomem    *gpmc_prefetch_status;
+        void __iomem    *gpmc_ecc_config;
+        void __iomem    *gpmc_ecc_control;
+        void __iomem    *gpmc_ecc_size_config;
+        void __iomem    *gpmc_ecc1_result;
+        void __iomem    *gpmc_bch_result0[GPMC_BCH_NUM_REMAINDER];
+        void __iomem    *gpmc_bch_result1[GPMC_BCH_NUM_REMAINDER];
+        void __iomem    *gpmc_bch_result2[GPMC_BCH_NUM_REMAINDER];
+        void __iomem    *gpmc_bch_result3[GPMC_BCH_NUM_REMAINDER];
+};
+
 struct omap_nand_platform_data {
         int                     cs;
         struct mtd_partition    *parts;
-        struct gpmc_timings     *gpmc_t;
         int                     nr_parts;
         bool                    dev_ready;
         enum nand_io            xfer_type;
@@ -30,14 +62,4 @@ struct omap_nand_platform_data {
         struct gpmc_nand_regs   reg;
 };
 
-/* minimum size for IO mapping */
-#define NAND_IO_SIZE    4
-
-#if defined(CONFIG_MTD_NAND_OMAP2) || defined(CONFIG_MTD_NAND_OMAP2_MODULE)
-extern int gpmc_nand_init(struct omap_nand_platform_data *d);
-#else
-static inline int gpmc_nand_init(struct omap_nand_platform_data *d)
-{
-        return 0;
-}
 #endif
diff --git a/include/linux/platform_data/mtd-onenand-omap2.h b/include/linux/platform_data/mtd-onenand-omap2.h
index 2858667d2e4f..685af7e8b120 100644
--- a/include/linux/platform_data/mtd-onenand-omap2.h
+++ b/include/linux/platform_data/mtd-onenand-omap2.h
@@ -9,17 +9,15 @@
  * published by the Free Software Foundation.
  */
 
+#ifndef __MTD_ONENAND_OMAP2_H
+#define __MTD_ONENAND_OMAP2_H
+
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/partitions.h>
 
 #define ONENAND_SYNC_READ       (1 << 0)
 #define ONENAND_SYNC_READWRITE  (1 << 1)
-
-struct onenand_freq_info {
-        u16                     maf_id;
-        u16                     dev_id;
-        u16                     ver_id;
-};
+#define ONENAND_IN_OMAP34XX     (1 << 2)
 
 struct omap_onenand_platform_data {
         int                     cs;
@@ -27,27 +25,9 @@ struct omap_onenand_platform_data {
         struct mtd_partition    *parts;
         int                     nr_parts;
         int                     (*onenand_setup)(void __iomem *, int *freq_ptr);
-        int             (*get_freq)(const struct onenand_freq_info *freq_info,
-                                    bool *clk_dep);
         int                     dma_channel;
         u8                      flags;
         u8                      regulator_can_sleep;
         u8                      skip_initial_unlocking;
 };
-
-#define ONENAND_MAX_PARTITIONS 8
-
-#if defined(CONFIG_MTD_ONENAND_OMAP2) || \
-        defined(CONFIG_MTD_ONENAND_OMAP2_MODULE)
-
-extern void gpmc_onenand_init(struct omap_onenand_platform_data *d);
-
-#else
-
-#define board_onenand_data      NULL
-
-static inline void gpmc_onenand_init(struct omap_onenand_platform_data *d)
-{
-}
-
 #endif
diff --git a/include/linux/platform_data/omap-wd-timer.h b/include/linux/platform_data/omap-wd-timer.h
new file mode 100644
index 000000000000..d75f5f802d98
--- /dev/null
+++ b/include/linux/platform_data/omap-wd-timer.h
@@ -0,0 +1,38 @@
+/*
+ * OMAP2+ WDTIMER-specific function prototypes
+ *
+ * Copyright (C) 2012 Texas Instruments, Inc.
+ * Paul Walmsley
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_OMAP_WD_TIMER_H
+#define __LINUX_PLATFORM_DATA_OMAP_WD_TIMER_H
+
+#include <linux/types.h>
+
+/*
+ * Standardized OMAP reset source bits
+ *
+ * This is a subset of the ones listed in arch/arm/mach-omap2/prm.h
+ * and are the only ones needed in the watchdog driver.
+ */
+#define OMAP_MPU_WD_RST_SRC_ID_SHIFT                            3
+
+/**
+ * struct omap_wd_timer_platform_data - WDTIMER integration to the host SoC
+ * @read_reset_sources - fn ptr for the SoC to indicate the last reset cause
+ *
+ * The function pointed to by @read_reset_sources must return its data
+ * in a standard format - search for RST_SRC_ID_SHIFT in
+ * arch/arm/mach-omap2
+ */
+struct omap_wd_timer_platform_data {
+        u32 (*read_reset_sources)(void);
+};
+
+#endif
diff --git a/include/linux/platform_data/omap_drm.h b/include/linux/platform_data/omap_drm.h
index 3da73bdc2031..f4e4a237ebd2 100644
--- a/include/linux/platform_data/omap_drm.h
+++ b/include/linux/platform_data/omap_drm.h
@@ -46,6 +46,7 @@ struct omap_kms_platform_data {
 };
 
 struct omap_drm_platform_data {
+        uint32_t omaprev;
         struct omap_kms_platform_data *kms_pdata;
 };
 
diff --git a/include/linux/platform_data/pinctrl-coh901.h b/include/linux/platform_data/pinctrl-coh901.h
index 30dea251b835..dfbc65d10484 100644
--- a/include/linux/platform_data/pinctrl-coh901.h
+++ b/include/linux/platform_data/pinctrl-coh901.h
@@ -13,14 +13,10 @@
  * struct u300_gpio_platform - U300 GPIO platform data
  * @ports: number of GPIO block ports
  * @gpio_base: first GPIO number for this block (use a free range)
- * @gpio_irq_base: first GPIO IRQ number for this block (use a free range)
- * @pinctrl_device: pin control device to spawn as child
  */
 struct u300_gpio_platform {
         u8 ports;
         int gpio_base;
-        int gpio_irq_base;
-        struct platform_device *pinctrl_device;
 };
 
 #endif /* __MACH_U300_GPIO_U300_H */
diff --git a/include/linux/platform_data/pinctrl-nomadik.h b/include/linux/platform_data/pinctrl-nomadik.h
new file mode 100644
index 000000000000..f73b2f0c55b7
--- /dev/null
+++ b/include/linux/platform_data/pinctrl-nomadik.h
@@ -0,0 +1,266 @@
+/*
+ * Structures and registers for GPIO access in the Nomadik SoC
+ *
+ * Copyright (C) 2008 STMicroelectronics
+ *     Author: Prafulla WADASKAR <prafulla.wadaskar@st.com>
+ * Copyright (C) 2009 Alessandro Rubini <rubini@unipv.it>
+ *
+ * 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 __PLAT_NOMADIK_GPIO
+#define __PLAT_NOMADIK_GPIO
+
+/*
+ * pin configurations are represented by 32-bit integers:
+ *
+ *      bit  0.. 8 - Pin Number (512 Pins Maximum)
+ *      bit  9..10 - Alternate Function Selection
+ *      bit 11..12 - Pull up/down state
+ *      bit     13 - Sleep mode behaviour
+ *      bit     14 - Direction
+ *      bit     15 - Value (if output)
+ *      bit 16..18 - SLPM pull up/down state
+ *      bit 19..20 - SLPM direction
+ *      bit 21..22 - SLPM Value (if output)
+ *      bit 23..25 - PDIS value (if input)
+ *      bit     26 - Gpio mode
+ *      bit     27 - Sleep mode
+ *
+ * to facilitate the definition, the following macros are provided
+ *
+ * PIN_CFG_DEFAULT - default config (0):
+ *                   pull up/down = disabled
+ *                   sleep mode = input/wakeup
+ *                   direction = input
+ *                   value = low
+ *                   SLPM direction = same as normal
+ *                   SLPM pull = same as normal
+ *                   SLPM value = same as normal
+ *
+ * PIN_CFG         - default config with alternate function
+ */
+
+typedef unsigned long pin_cfg_t;
+
+#define PIN_NUM_MASK            0x1ff
+#define PIN_NUM(x)              ((x) & PIN_NUM_MASK)
+
+#define PIN_ALT_SHIFT           9
+#define PIN_ALT_MASK            (0x3 << PIN_ALT_SHIFT)
+#define PIN_ALT(x)              (((x) & PIN_ALT_MASK) >> PIN_ALT_SHIFT)
+#define PIN_GPIO                (NMK_GPIO_ALT_GPIO << PIN_ALT_SHIFT)
+#define PIN_ALT_A               (NMK_GPIO_ALT_A << PIN_ALT_SHIFT)
+#define PIN_ALT_B               (NMK_GPIO_ALT_B << PIN_ALT_SHIFT)
+#define PIN_ALT_C               (NMK_GPIO_ALT_C << PIN_ALT_SHIFT)
+
+#define PIN_PULL_SHIFT          11
+#define PIN_PULL_MASK           (0x3 << PIN_PULL_SHIFT)
+#define PIN_PULL(x)             (((x) & PIN_PULL_MASK) >> PIN_PULL_SHIFT)
+#define PIN_PULL_NONE           (NMK_GPIO_PULL_NONE << PIN_PULL_SHIFT)
+#define PIN_PULL_UP             (NMK_GPIO_PULL_UP << PIN_PULL_SHIFT)
+#define PIN_PULL_DOWN           (NMK_GPIO_PULL_DOWN << PIN_PULL_SHIFT)
+
+#define PIN_SLPM_SHIFT          13
+#define PIN_SLPM_MASK           (0x1 << PIN_SLPM_SHIFT)
+#define PIN_SLPM(x)             (((x) & PIN_SLPM_MASK) >> PIN_SLPM_SHIFT)
+#define PIN_SLPM_MAKE_INPUT     (NMK_GPIO_SLPM_INPUT << PIN_SLPM_SHIFT)
+#define PIN_SLPM_NOCHANGE       (NMK_GPIO_SLPM_NOCHANGE << PIN_SLPM_SHIFT)
+/* These two replace the above in DB8500v2+ */
+#define PIN_SLPM_WAKEUP_ENABLE  (NMK_GPIO_SLPM_WAKEUP_ENABLE << PIN_SLPM_SHIFT)
+#define PIN_SLPM_WAKEUP_DISABLE (NMK_GPIO_SLPM_WAKEUP_DISABLE << PIN_SLPM_SHIFT)
+#define PIN_SLPM_USE_MUX_SETTINGS_IN_SLEEP PIN_SLPM_WAKEUP_DISABLE
+
+#define PIN_SLPM_GPIO  PIN_SLPM_WAKEUP_ENABLE /* In SLPM, pin is a gpio */
+#define PIN_SLPM_ALTFUNC PIN_SLPM_WAKEUP_DISABLE /* In SLPM, pin is altfunc */
+
+#define PIN_DIR_SHIFT           14
+#define PIN_DIR_MASK            (0x1 << PIN_DIR_SHIFT)
+#define PIN_DIR(x)              (((x) & PIN_DIR_MASK) >> PIN_DIR_SHIFT)
+#define PIN_DIR_INPUT           (0 << PIN_DIR_SHIFT)
+#define PIN_DIR_OUTPUT          (1 << PIN_DIR_SHIFT)
+
+#define PIN_VAL_SHIFT           15
+#define PIN_VAL_MASK            (0x1 << PIN_VAL_SHIFT)
+#define PIN_VAL(x)              (((x) & PIN_VAL_MASK) >> PIN_VAL_SHIFT)
+#define PIN_VAL_LOW             (0 << PIN_VAL_SHIFT)
+#define PIN_VAL_HIGH            (1 << PIN_VAL_SHIFT)
+
+#define PIN_SLPM_PULL_SHIFT     16
+#define PIN_SLPM_PULL_MASK      (0x7 << PIN_SLPM_PULL_SHIFT)
+#define PIN_SLPM_PULL(x)        \
+        (((x) & PIN_SLPM_PULL_MASK) >> PIN_SLPM_PULL_SHIFT)
+#define PIN_SLPM_PULL_NONE      \
+        ((1 + NMK_GPIO_PULL_NONE) << PIN_SLPM_PULL_SHIFT)
+#define PIN_SLPM_PULL_UP        \
+        ((1 + NMK_GPIO_PULL_UP) << PIN_SLPM_PULL_SHIFT)
+#define PIN_SLPM_PULL_DOWN      \
+        ((1 + NMK_GPIO_PULL_DOWN) << PIN_SLPM_PULL_SHIFT)
+
+#define PIN_SLPM_DIR_SHIFT      19
+#define PIN_SLPM_DIR_MASK       (0x3 << PIN_SLPM_DIR_SHIFT)
+#define PIN_SLPM_DIR(x)         \
+        (((x) & PIN_SLPM_DIR_MASK) >> PIN_SLPM_DIR_SHIFT)
+#define PIN_SLPM_DIR_INPUT      ((1 + 0) << PIN_SLPM_DIR_SHIFT)
+#define PIN_SLPM_DIR_OUTPUT     ((1 + 1) << PIN_SLPM_DIR_SHIFT)
+
+#define PIN_SLPM_VAL_SHIFT      21
+#define PIN_SLPM_VAL_MASK       (0x3 << PIN_SLPM_VAL_SHIFT)
+#define PIN_SLPM_VAL(x)         \
+        (((x) & PIN_SLPM_VAL_MASK) >> PIN_SLPM_VAL_SHIFT)
+#define PIN_SLPM_VAL_LOW        ((1 + 0) << PIN_SLPM_VAL_SHIFT)
+#define PIN_SLPM_VAL_HIGH       ((1 + 1) << PIN_SLPM_VAL_SHIFT)
+
+#define PIN_SLPM_PDIS_SHIFT             23
+#define PIN_SLPM_PDIS_MASK              (0x3 << PIN_SLPM_PDIS_SHIFT)
+#define PIN_SLPM_PDIS(x)        \
+        (((x) & PIN_SLPM_PDIS_MASK) >> PIN_SLPM_PDIS_SHIFT)
+#define PIN_SLPM_PDIS_NO_CHANGE         (0 << PIN_SLPM_PDIS_SHIFT)
+#define PIN_SLPM_PDIS_DISABLED          (1 << PIN_SLPM_PDIS_SHIFT)
+#define PIN_SLPM_PDIS_ENABLED           (2 << PIN_SLPM_PDIS_SHIFT)
+
+#define PIN_LOWEMI_SHIFT        25
+#define PIN_LOWEMI_MASK         (0x1 << PIN_LOWEMI_SHIFT)
+#define PIN_LOWEMI(x)           (((x) & PIN_LOWEMI_MASK) >> PIN_LOWEMI_SHIFT)
+#define PIN_LOWEMI_DISABLED     (0 << PIN_LOWEMI_SHIFT)
+#define PIN_LOWEMI_ENABLED      (1 << PIN_LOWEMI_SHIFT)
+
+#define PIN_GPIOMODE_SHIFT      26
+#define PIN_GPIOMODE_MASK       (0x1 << PIN_GPIOMODE_SHIFT)
+#define PIN_GPIOMODE(x)         (((x) & PIN_GPIOMODE_MASK) >> PIN_GPIOMODE_SHIFT)
+#define PIN_GPIOMODE_DISABLED   (0 << PIN_GPIOMODE_SHIFT)
+#define PIN_GPIOMODE_ENABLED    (1 << PIN_GPIOMODE_SHIFT)
+
+#define PIN_SLEEPMODE_SHIFT     27
+#define PIN_SLEEPMODE_MASK      (0x1 << PIN_SLEEPMODE_SHIFT)
+#define PIN_SLEEPMODE(x)        (((x) & PIN_SLEEPMODE_MASK) >> PIN_SLEEPMODE_SHIFT)
+#define PIN_SLEEPMODE_DISABLED  (0 << PIN_SLEEPMODE_SHIFT)
+#define PIN_SLEEPMODE_ENABLED   (1 << PIN_SLEEPMODE_SHIFT)
+
+
+/* Shortcuts.  Use these instead of separate DIR, PULL, and VAL.  */
+#define PIN_INPUT_PULLDOWN      (PIN_DIR_INPUT | PIN_PULL_DOWN)
+#define PIN_INPUT_PULLUP        (PIN_DIR_INPUT | PIN_PULL_UP)
+#define PIN_INPUT_NOPULL        (PIN_DIR_INPUT | PIN_PULL_NONE)
+#define PIN_OUTPUT_LOW          (PIN_DIR_OUTPUT | PIN_VAL_LOW)
+#define PIN_OUTPUT_HIGH         (PIN_DIR_OUTPUT | PIN_VAL_HIGH)
+
+#define PIN_SLPM_INPUT_PULLDOWN (PIN_SLPM_DIR_INPUT | PIN_SLPM_PULL_DOWN)
+#define PIN_SLPM_INPUT_PULLUP   (PIN_SLPM_DIR_INPUT | PIN_SLPM_PULL_UP)
+#define PIN_SLPM_INPUT_NOPULL   (PIN_SLPM_DIR_INPUT | PIN_SLPM_PULL_NONE)
+#define PIN_SLPM_OUTPUT_LOW     (PIN_SLPM_DIR_OUTPUT | PIN_SLPM_VAL_LOW)
+#define PIN_SLPM_OUTPUT_HIGH    (PIN_SLPM_DIR_OUTPUT | PIN_SLPM_VAL_HIGH)
+
+#define PIN_CFG_DEFAULT         (0)
+
+#define PIN_CFG(num, alt)               \
+        (PIN_CFG_DEFAULT |\
+         (PIN_NUM(num) | PIN_##alt))
+
+#define PIN_CFG_INPUT(num, alt, pull)           \
+        (PIN_CFG_DEFAULT |\
+         (PIN_NUM(num) | PIN_##alt | PIN_INPUT_##pull))
+
+#define PIN_CFG_OUTPUT(num, alt, val)           \
+        (PIN_CFG_DEFAULT |\
+         (PIN_NUM(num) | PIN_##alt | PIN_OUTPUT_##val))
+
+/*
+ * "nmk_gpio" and "NMK_GPIO" stand for "Nomadik GPIO", leaving
+ * the "gpio" namespace for generic and cross-machine functions
+ */
+
+#define GPIO_BLOCK_SHIFT 5
+#define NMK_GPIO_PER_CHIP (1 << GPIO_BLOCK_SHIFT)
+
+/* Register in the logic block */
+#define NMK_GPIO_DAT    0x00
+#define NMK_GPIO_DATS   0x04
+#define NMK_GPIO_DATC   0x08
+#define NMK_GPIO_PDIS   0x0c
+#define NMK_GPIO_DIR    0x10
+#define NMK_GPIO_DIRS   0x14
+#define NMK_GPIO_DIRC   0x18
+#define NMK_GPIO_SLPC   0x1c
+#define NMK_GPIO_AFSLA  0x20
+#define NMK_GPIO_AFSLB  0x24
+#define NMK_GPIO_LOWEMI 0x28
+
+#define NMK_GPIO_RIMSC  0x40
+#define NMK_GPIO_FIMSC  0x44
+#define NMK_GPIO_IS     0x48
+#define NMK_GPIO_IC     0x4c
+#define NMK_GPIO_RWIMSC 0x50
+#define NMK_GPIO_FWIMSC 0x54
+#define NMK_GPIO_WKS    0x58
+/* These appear in DB8540 and later ASICs */
+#define NMK_GPIO_EDGELEVEL 0x5C
+#define NMK_GPIO_LEVEL  0x60
+
+/* Alternate functions: function C is set in hw by setting both A and B */
+#define NMK_GPIO_ALT_GPIO       0
+#define NMK_GPIO_ALT_A  1
+#define NMK_GPIO_ALT_B  2
+#define NMK_GPIO_ALT_C  (NMK_GPIO_ALT_A | NMK_GPIO_ALT_B)
+
+#define NMK_GPIO_ALT_CX_SHIFT 2
+#define NMK_GPIO_ALT_C1 ((1<<NMK_GPIO_ALT_CX_SHIFT) | NMK_GPIO_ALT_C)
+#define NMK_GPIO_ALT_C2 ((2<<NMK_GPIO_ALT_CX_SHIFT) | NMK_GPIO_ALT_C)
+#define NMK_GPIO_ALT_C3 ((3<<NMK_GPIO_ALT_CX_SHIFT) | NMK_GPIO_ALT_C)
+#define NMK_GPIO_ALT_C4 ((4<<NMK_GPIO_ALT_CX_SHIFT) | NMK_GPIO_ALT_C)
+
+/* Pull up/down values */
+enum nmk_gpio_pull {
+        NMK_GPIO_PULL_NONE,
+        NMK_GPIO_PULL_UP,
+        NMK_GPIO_PULL_DOWN,
+};
+
+/* Sleep mode */
+enum nmk_gpio_slpm {
+        NMK_GPIO_SLPM_INPUT,
+        NMK_GPIO_SLPM_WAKEUP_ENABLE = NMK_GPIO_SLPM_INPUT,
+        NMK_GPIO_SLPM_NOCHANGE,
+        NMK_GPIO_SLPM_WAKEUP_DISABLE = NMK_GPIO_SLPM_NOCHANGE,
+};
+
+/* Older deprecated pin config API that should go away soon */
+extern int nmk_config_pin(pin_cfg_t cfg, bool sleep);
+extern int nmk_config_pins(pin_cfg_t *cfgs, int num);
+extern int nmk_config_pins_sleep(pin_cfg_t *cfgs, int num);
+extern int nmk_gpio_set_slpm(int gpio, enum nmk_gpio_slpm mode);
+extern int nmk_gpio_set_pull(int gpio, enum nmk_gpio_pull pull);
+#ifdef CONFIG_PINCTRL_NOMADIK
+extern int nmk_gpio_set_mode(int gpio, int gpio_mode);
+#else
+static inline int nmk_gpio_set_mode(int gpio, int gpio_mode)
+{
+        return -ENODEV;
+}
+#endif
+extern int nmk_gpio_get_mode(int gpio);
+
+extern void nmk_gpio_wakeups_suspend(void);
+extern void nmk_gpio_wakeups_resume(void);
+
+extern void nmk_gpio_clocks_enable(void);
+extern void nmk_gpio_clocks_disable(void);
+
+extern void nmk_gpio_read_pull(int gpio_bank, u32 *pull_up);
+
+/*
+ * Platform data to register a block: only the initial gpio/irq number.
+ */
+struct nmk_gpio_platform_data {
+        char *name;
+        int first_gpio;
+        int first_irq;
+        int num_gpio;
+        u32 (*get_secondary_status)(unsigned int bank);
+        void (*set_ioforce)(bool enable);
+        bool supports_sleepmode;
+};
+
+#endif /* __PLAT_NOMADIK_GPIO */
diff --git a/include/linux/platform_data/pxa2xx_udc.h b/include/linux/platform_data/pxa2xx_udc.h
new file mode 100644
index 000000000000..c6c5e98b5b82
--- /dev/null
+++ b/include/linux/platform_data/pxa2xx_udc.h
@@ -0,0 +1,27 @@
+/*
+ * This supports machine-specific differences in how the PXA2xx
+ * USB Device Controller (UDC) is wired.
+ *
+ * It is set in linux/arch/arm/mach-pxa/<machine>.c or in
+ * linux/arch/mach-ixp4xx/<machine>.c and used in
+ * the probe routine of linux/drivers/usb/gadget/pxa2xx_udc.c
+ */
+#ifndef PXA2XX_UDC_H
+#define PXA2XX_UDC_H
+
+struct pxa2xx_udc_mach_info {
+        int  (*udc_is_connected)(void);         /* do we see host? */
+        void (*udc_command)(int cmd);
+#define PXA2XX_UDC_CMD_CONNECT          0       /* let host see us */
+#define PXA2XX_UDC_CMD_DISCONNECT       1       /* so host won't see us */
+
+        /* Boards following the design guidelines in the developer's manual,
+         * with on-chip GPIOs not Lubbock's weird hardware, can have a sane
+         * VBUS IRQ and omit the methods above.  Store the GPIO number
+         * here.  Note that sometimes the signals go through inverters...
+         */
+        bool    gpio_pullup_inverted;
+        int     gpio_pullup;                    /* high == pullup activated */
+};
+
+#endif
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
index 59acd987ed34..27d3156d093a 100644
--- a/include/linux/platform_data/pxa_sdhci.h
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -38,6 +38,7 @@
  * @max_speed: the maximum speed supported
  * @host_caps: Standard MMC host capabilities bit field.
  * @quirks: quirks of platfrom
+ * @quirks2: quirks2 of platfrom
  * @pm_caps: pm_caps of platfrom
  */
 struct sdhci_pxa_platdata {
@@ -48,9 +49,10 @@ struct sdhci_pxa_platdata {
         unsigned int    ext_cd_gpio;
         bool            ext_cd_gpio_invert;
         unsigned int    max_speed;
-        unsigned int    host_caps;
-        unsigned int    host_caps2;
+        u32             host_caps;
+        u32             host_caps2;
         unsigned int    quirks;
+        unsigned int    quirks2;
         unsigned int    pm_caps;
 };
 
diff --git a/include/linux/platform_data/sa11x0-serial.h b/include/linux/platform_data/sa11x0-serial.h
new file mode 100644
index 000000000000..4504d5d592f0
--- /dev/null
+++ b/include/linux/platform_data/sa11x0-serial.h
@@ -0,0 +1,33 @@
+/*
+ *  Author: Nicolas Pitre
+ *
+ * Moved and changed lots, Russell King
+ *
+ * Low level machine dependent UART functions.
+ */
+#ifndef SA11X0_SERIAL_H
+#define SA11X0_SERIAL_H
+
+struct uart_port;
+struct uart_info;
+
+/*
+ * This is a temporary structure for registering these
+ * functions; it is intended to be discarded after boot.
+ */
+struct sa1100_port_fns {
+        void    (*set_mctrl)(struct uart_port *, u_int);
+        u_int   (*get_mctrl)(struct uart_port *);
+        void    (*pm)(struct uart_port *, u_int, u_int);
+        int     (*set_wake)(struct uart_port *, u_int);
+};
+
+#ifdef CONFIG_SERIAL_SA1100
+void sa1100_register_uart_fns(struct sa1100_port_fns *fns);
+void sa1100_register_uart(int idx, int port);
+#else
+#define sa1100_register_uart_fns(fns) do { } while (0)
+#define sa1100_register_uart(idx,port) do { } while (0)
+#endif
+
+#endif
diff --git a/include/linux/platform_data/uio_dmem_genirq.h b/include/linux/platform_data/uio_dmem_genirq.h
new file mode 100644
index 000000000000..973c1bb32168
--- /dev/null
+++ b/include/linux/platform_data/uio_dmem_genirq.h
@@ -0,0 +1,26 @@
+/*
+ * include/linux/platform_data/uio_dmem_genirq.h
+ *
+ * Copyright (C) 2012 Damian Hobson-Garcia
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation version 2.
+ *
+ * This program is distributed "as is" WITHOUT ANY WARRANTY of any
+ * kind, whether express or implied; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _UIO_DMEM_GENIRQ_H
+#define _UIO_DMEM_GENIRQ_H
+
+#include <linux/uio_driver.h>
+
+struct uio_dmem_genirq_pdata {
+        struct uio_info uioinfo;
+        unsigned int *dynamic_region_sizes;
+        unsigned int num_dynamic_regions;
+};
+#endif /* _UIO_DMEM_GENIRQ_H */
diff --git a/include/linux/platform_data/usb-omap.h b/include/linux/platform_data/usb-omap.h
new file mode 100644
index 000000000000..8570bcfe6311
--- /dev/null
+++ b/include/linux/platform_data/usb-omap.h
@@ -0,0 +1,80 @@
+/*
+ * usb-omap.h - Platform data for the various OMAP USB IPs
+ *
+ * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
+ *
+ * This software is distributed under the terms of the GNU General Public
+ * License ("GPL") version 2, as published by the Free Software Foundation.
+ *
+ * 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.
+ */
+
+#define OMAP3_HS_USB_PORTS      3
+
+enum usbhs_omap_port_mode {
+        OMAP_USBHS_PORT_MODE_UNUSED,
+        OMAP_EHCI_PORT_MODE_PHY,
+        OMAP_EHCI_PORT_MODE_TLL,
+        OMAP_EHCI_PORT_MODE_HSIC,
+        OMAP_OHCI_PORT_MODE_PHY_6PIN_DATSE0,
+        OMAP_OHCI_PORT_MODE_PHY_6PIN_DPDM,
+        OMAP_OHCI_PORT_MODE_PHY_3PIN_DATSE0,
+        OMAP_OHCI_PORT_MODE_PHY_4PIN_DPDM,
+        OMAP_OHCI_PORT_MODE_TLL_6PIN_DATSE0,
+        OMAP_OHCI_PORT_MODE_TLL_6PIN_DPDM,
+        OMAP_OHCI_PORT_MODE_TLL_3PIN_DATSE0,
+        OMAP_OHCI_PORT_MODE_TLL_4PIN_DPDM,
+        OMAP_OHCI_PORT_MODE_TLL_2PIN_DATSE0,
+        OMAP_OHCI_PORT_MODE_TLL_2PIN_DPDM
+};
+
+struct usbtll_omap_platform_data {
+        enum usbhs_omap_port_mode               port_mode[OMAP3_HS_USB_PORTS];
+};
+
+struct ehci_hcd_omap_platform_data {
+        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];
+        unsigned                        phy_reset:1;
+};
+
+struct ohci_hcd_omap_platform_data {
+        enum usbhs_omap_port_mode       port_mode[OMAP3_HS_USB_PORTS];
+        unsigned                        es2_compatibility:1;
+};
+
+struct usbhs_omap_platform_data {
+        enum usbhs_omap_port_mode               port_mode[OMAP3_HS_USB_PORTS];
+
+        struct ehci_hcd_omap_platform_data      *ehci_data;
+        struct ohci_hcd_omap_platform_data      *ohci_data;
+};
+
+/*-------------------------------------------------------------------------*/
+
+struct omap_musb_board_data {
+        u8      interface_type;
+        u8      mode;
+        u16     power;
+        unsigned extvbus:1;
+        void    (*set_phy_power)(u8 on);
+        void    (*clear_irq)(void);
+        void    (*set_mode)(u8 mode);
+        void    (*reset)(void);
+};
+
+enum musb_interface {
+        MUSB_INTERFACE_ULPI,
+        MUSB_INTERFACE_UTMI
+};
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 5711e9525a2a..a9ded9a3c175 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -55,6 +55,7 @@ extern int platform_add_devices(struct platform_device **, int);
 
 struct platform_device_info {
                 struct device *parent;
+                struct acpi_dev_node acpi_node;
 
                 const char *name;
                 int id;
diff --git a/include/linux/pm.h b/include/linux/pm.h
index 007e687c4f69..03d7bb145311 100644
--- a/include/linux/pm.h
+++ b/include/linux/pm.h
@@ -546,10 +546,9 @@ struct dev_pm_info {
         unsigned long           active_jiffies;
         unsigned long           suspended_jiffies;
         unsigned long           accounting_timestamp;
-        struct dev_pm_qos_request *pq_req;
 #endif
         struct pm_subsys_data   *subsys_data;  /* Owned by the subsystem. */
-        struct pm_qos_constraints *constraints;
+        struct dev_pm_qos       *qos;
 };
 
 extern void update_pm_runtime_accounting(struct device *dev);
diff --git a/include/linux/pm_qos.h b/include/linux/pm_qos.h
index 9924ea1f22e0..5a95013905c8 100644
--- a/include/linux/pm_qos.h
+++ b/include/linux/pm_qos.h
@@ -20,6 +20,13 @@ enum {
         PM_QOS_NUM_CLASSES,
 };
 
+enum pm_qos_flags_status {
+        PM_QOS_FLAGS_UNDEFINED = -1,
+        PM_QOS_FLAGS_NONE,
+        PM_QOS_FLAGS_SOME,
+        PM_QOS_FLAGS_ALL,
+};
+
 #define PM_QOS_DEFAULT_VALUE -1
 
 #define PM_QOS_CPU_DMA_LAT_DEFAULT_VALUE        (2000 * USEC_PER_SEC)
@@ -27,14 +34,31 @@ enum {
 #define PM_QOS_NETWORK_THROUGHPUT_DEFAULT_VALUE 0
 #define PM_QOS_DEV_LAT_DEFAULT_VALUE            0
 
+#define PM_QOS_FLAG_NO_POWER_OFF        (1 << 0)
+#define PM_QOS_FLAG_REMOTE_WAKEUP       (1 << 1)
+
 struct pm_qos_request {
         struct plist_node node;
         int pm_qos_class;
         struct delayed_work work; /* for pm_qos_update_request_timeout */
 };
 
+struct pm_qos_flags_request {
+        struct list_head node;
+        s32 flags;      /* Do not change to 64 bit */
+};
+
+enum dev_pm_qos_req_type {
+        DEV_PM_QOS_LATENCY = 1,
+        DEV_PM_QOS_FLAGS,
+};
+
 struct dev_pm_qos_request {
-        struct plist_node node;
+        enum dev_pm_qos_req_type type;
+        union {
+                struct plist_node pnode;
+                struct pm_qos_flags_request flr;
+        } data;
         struct device *dev;
 };
 
@@ -45,8 +69,8 @@ enum pm_qos_type {
 };
 
 /*
- * Note: The lockless read path depends on the CPU accessing
- * target_value atomically.  Atomic access is only guaranteed on all CPU
+ * Note: The lockless read path depends on the CPU accessing target_value
+ * or effective_flags atomically.  Atomic access is only guaranteed on all CPU
  * types linux supports for 32 bit quantites
  */
 struct pm_qos_constraints {
@@ -57,6 +81,18 @@ struct pm_qos_constraints {
         struct blocking_notifier_head *notifiers;
 };
 
+struct pm_qos_flags {
+        struct list_head list;
+        s32 effective_flags;    /* Do not change to 64 bit */
+};
+
+struct dev_pm_qos {
+        struct pm_qos_constraints latency;
+        struct pm_qos_flags flags;
+        struct dev_pm_qos_request *latency_req;
+        struct dev_pm_qos_request *flags_req;
+};
+
 /* Action requested to pm_qos_update_target */
 enum pm_qos_req_action {
         PM_QOS_ADD_REQ,         /* Add a new request */
@@ -71,6 +107,9 @@ static inline int dev_pm_qos_request_active(struct dev_pm_qos_request *req)
 
 int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
                          enum pm_qos_req_action action, int value);
+bool pm_qos_update_flags(struct pm_qos_flags *pqf,
+                         struct pm_qos_flags_request *req,
+                         enum pm_qos_req_action action, s32 val);
 void pm_qos_add_request(struct pm_qos_request *req, int pm_qos_class,
                         s32 value);
 void pm_qos_update_request(struct pm_qos_request *req,
@@ -86,10 +125,12 @@ int pm_qos_request_active(struct pm_qos_request *req);
 s32 pm_qos_read_value(struct pm_qos_constraints *c);
 
 #ifdef CONFIG_PM
+enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask);
+enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask);
 s32 __dev_pm_qos_read_value(struct device *dev);
 s32 dev_pm_qos_read_value(struct device *dev);
 int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
-                           s32 value);
+                           enum dev_pm_qos_req_type type, s32 value);
 int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value);
 int dev_pm_qos_remove_request(struct dev_pm_qos_request *req);
 int dev_pm_qos_add_notifier(struct device *dev,
@@ -103,12 +144,19 @@ void dev_pm_qos_constraints_destroy(struct device *dev);
 int dev_pm_qos_add_ancestor_request(struct device *dev,
                                     struct dev_pm_qos_request *req, s32 value);
 #else
+static inline enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev,
+                                                          s32 mask)
+                        { return PM_QOS_FLAGS_UNDEFINED; }
+static inline enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev,
+                                                        s32 mask)
+                        { return PM_QOS_FLAGS_UNDEFINED; }
 static inline s32 __dev_pm_qos_read_value(struct device *dev)
                         { return 0; }
 static inline s32 dev_pm_qos_read_value(struct device *dev)
                         { return 0; }
 static inline int dev_pm_qos_add_request(struct device *dev,
                                          struct dev_pm_qos_request *req,
+                                         enum dev_pm_qos_req_type type,
                                          s32 value)
                         { return 0; }
 static inline int dev_pm_qos_update_request(struct dev_pm_qos_request *req,
@@ -144,10 +192,31 @@ static inline int dev_pm_qos_add_ancestor_request(struct device *dev,
 #ifdef CONFIG_PM_RUNTIME
 int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
 void dev_pm_qos_hide_latency_limit(struct device *dev);
+int dev_pm_qos_expose_flags(struct device *dev, s32 value);
+void dev_pm_qos_hide_flags(struct device *dev);
+int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set);
+
+static inline s32 dev_pm_qos_requested_latency(struct device *dev)
+{
+        return dev->power.qos->latency_req->data.pnode.prio;
+}
+
+static inline s32 dev_pm_qos_requested_flags(struct device *dev)
+{
+        return dev->power.qos->flags_req->data.flr.flags;
+}
 #else
 static inline int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value)
                         { return 0; }
 static inline void dev_pm_qos_hide_latency_limit(struct device *dev) {}
+static inline int dev_pm_qos_expose_flags(struct device *dev, s32 value)
+                        { return 0; }
+static inline void dev_pm_qos_hide_flags(struct device *dev) {}
+static inline int dev_pm_qos_update_flags(struct device *dev, s32 m, bool set)
+                        { return 0; }
+
+static inline s32 dev_pm_qos_requested_latency(struct device *dev) { return 0; }
+static inline s32 dev_pm_qos_requested_flags(struct device *dev) { return 0; }
 #endif
 
 #endif
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index ee3034a40884..1788909d9a99 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -50,16 +50,18 @@ struct pstore_info {
         int             (*open)(struct pstore_info *psi);
         int             (*close)(struct pstore_info *psi);
         ssize_t         (*read)(u64 *id, enum pstore_type_id *type,
-                        struct timespec *time, char **buf,
+                        int *count, struct timespec *time, char **buf,
                         struct pstore_info *psi);
         int             (*write)(enum pstore_type_id type,
                         enum kmsg_dump_reason reason, u64 *id,
-                        unsigned int part, size_t size, struct pstore_info *psi);
+                        unsigned int part, int count, size_t size,
+                        struct pstore_info *psi);
         int             (*write_buf)(enum pstore_type_id type,
                         enum kmsg_dump_reason reason, u64 *id,
                         unsigned int part, const char *buf, size_t size,
                         struct pstore_info *psi);
         int             (*erase)(enum pstore_type_id type, u64 id,
+                        int count, struct timespec time,
                         struct pstore_info *psi);
         void            *data;
 };
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index e0f0fab20415..c92dd28eaa6c 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -286,23 +286,6 @@ static inline void list_splice_init_rcu(struct list_head *list,
                 &pos->member != (head); \
                 pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 
-
-/**
- * list_for_each_continue_rcu
- * @pos:        the &struct list_head to use as a loop cursor.
- * @head:       the head for your list.
- *
- * Iterate over an rcu-protected list, continuing after current point.
- *
- * This list-traversal primitive may safely run concurrently with
- * the _rcu list-mutation primitives such as list_add_rcu()
- * as long as the traversal is guarded by rcu_read_lock().
- */
-#define list_for_each_continue_rcu(pos, head) \
-        for ((pos) = rcu_dereference_raw(list_next_rcu(pos)); \
-                (pos) != (head); \
-                (pos) = rcu_dereference_raw(list_next_rcu(pos)))
-
 /**
  * list_for_each_entry_continue_rcu - continue iteration over list of given type
  * @pos:        the type * to use as a loop cursor.
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 7c968e4f929e..275aa3f1062d 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -90,6 +90,25 @@ extern void do_trace_rcu_torture_read(char *rcutorturename,
  * that started after call_rcu() was invoked.  RCU read-side critical
  * sections are delimited by rcu_read_lock() and rcu_read_unlock(),
  * and may be nested.
+ *
+ * Note that all CPUs must agree that the grace period extended beyond
+ * all pre-existing RCU read-side critical section.  On systems with more
+ * than one CPU, this means that when "func()" is invoked, each CPU is
+ * guaranteed to have executed a full memory barrier since the end of its
+ * last RCU read-side critical section whose beginning preceded the call
+ * to call_rcu().  It also means that each CPU executing an RCU read-side
+ * critical section that continues beyond the start of "func()" must have
+ * executed a memory barrier after the call_rcu() but before the beginning
+ * of that RCU read-side critical section.  Note that these guarantees
+ * include CPUs that are offline, idle, or executing in user mode, as
+ * well as CPUs that are executing in the kernel.
+ *
+ * Furthermore, if CPU A invoked call_rcu() and CPU B invoked the
+ * resulting RCU callback function "func()", then both CPU A and CPU B are
+ * guaranteed to execute a full memory barrier during the time interval
+ * between the call to call_rcu() and the invocation of "func()" -- even
+ * if CPU A and CPU B are the same CPU (but again only if the system has
+ * more than one CPU).
  */
 extern void call_rcu(struct rcu_head *head,
                               void (*func)(struct rcu_head *head));
@@ -118,6 +137,9 @@ extern void call_rcu(struct rcu_head *head,
  *  OR
  *  - rcu_read_lock_bh() and rcu_read_unlock_bh(), if in process context.
  *  These may be nested.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
  */
 extern void call_rcu_bh(struct rcu_head *head,
                         void (*func)(struct rcu_head *head));
@@ -137,6 +159,9 @@ extern void call_rcu_bh(struct rcu_head *head,
  *  OR
  *  anything that disables preemption.
  *  These may be nested.
+ *
+ * See the description of call_rcu() for more detailed information on
+ * memory ordering guarantees.
  */
 extern void call_rcu_sched(struct rcu_head *head,
                            void (*func)(struct rcu_head *rcu));
@@ -197,13 +222,13 @@ extern void rcu_user_enter(void);
 extern void rcu_user_exit(void);
 extern void rcu_user_enter_after_irq(void);
 extern void rcu_user_exit_after_irq(void);
-extern void rcu_user_hooks_switch(struct task_struct *prev,
-                                  struct task_struct *next);
 #else
 static inline void rcu_user_enter(void) { }
 static inline void rcu_user_exit(void) { }
 static inline void rcu_user_enter_after_irq(void) { }
 static inline void rcu_user_exit_after_irq(void) { }
+static inline void rcu_user_hooks_switch(struct task_struct *prev,
+                                         struct task_struct *next) { }
 #endif /* CONFIG_RCU_USER_QS */
 
 extern void exit_rcu(void);
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index e3bcc3f4dcb8..b7e95bf942c9 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -19,6 +19,7 @@
 struct module;
 struct device;
 struct i2c_client;
+struct irq_domain;
 struct spi_device;
 struct regmap;
 struct regmap_range_cfg;
@@ -54,6 +55,39 @@ enum regmap_endian {
 };
 
 /**
+ * A register range, used for access related checks
+ * (readable/writeable/volatile/precious checks)
+ *
+ * @range_min: address of first register
+ * @range_max: address of last register
+ */
+struct regmap_range {
+        unsigned int range_min;
+        unsigned int range_max;
+};
+
+/*
+ * A table of ranges including some yes ranges and some no ranges.
+ * If a register belongs to a no_range, the corresponding check function
+ * will return false. If a register belongs to a yes range, the corresponding
+ * check function will return true. "no_ranges" are searched first.
+ *
+ * @yes_ranges : pointer to an array of regmap ranges used as "yes ranges"
+ * @n_yes_ranges: size of the above array
+ * @no_ranges: pointer to an array of regmap ranges used as "no ranges"
+ * @n_no_ranges: size of the above array
+ */
+struct regmap_access_table {
+        const struct regmap_range *yes_ranges;
+        unsigned int n_yes_ranges;
+        const struct regmap_range *no_ranges;
+        unsigned int n_no_ranges;
+};
+
+typedef void (*regmap_lock)(void *);
+typedef void (*regmap_unlock)(void *);
+
+/**
  * Configuration for the register map of a device.
  *
  * @name: Optional name of the regmap. Useful when a device has multiple
@@ -67,16 +101,39 @@ enum regmap_endian {
  * @val_bits: Number of bits in a register value, mandatory.
  *
  * @writeable_reg: Optional callback returning true if the register
- *                 can be written to.
+ *                 can be written to. If this field is NULL but wr_table
+ *                 (see below) is not, the check is performed on such table
+ *                 (a register is writeable if it belongs to one of the ranges
+ *                  specified by wr_table).
  * @readable_reg: Optional callback returning true if the register
- *                can be read from.
+ *                can be read from. If this field is NULL but rd_table
+ *                 (see below) is not, the check is performed on such table
+ *                 (a register is readable if it belongs to one of the ranges
+ *                  specified by rd_table).
  * @volatile_reg: Optional callback returning true if the register
- *                value can't be cached.
+ *                value can't be cached. If this field is NULL but
+ *                volatile_table (see below) is not, the check is performed on
+ *                such table (a register is volatile if it belongs to one of
+ *                the ranges specified by volatile_table).
  * @precious_reg: Optional callback returning true if the rgister
- *                should not be read outside of a call from the driver
- *                (eg, a clear on read interrupt status register).
+ *                should not be read outside of a call from the driver
+ *                (eg, a clear on read interrupt status register). If this
+ *                field is NULL but precious_table (see below) is not, the
+ *                check is performed on such table (a register is precious if
+ *                it belongs to one of the ranges specified by precious_table).
+ * @lock:         Optional lock callback (overrides regmap's default lock
+ *                function, based on spinlock or mutex).
+ * @unlock:       As above for unlocking.
+ * @lock_arg:     this field is passed as the only argument of lock/unlock
+ *                functions (ignored in case regular lock/unlock functions
+ *                are not overridden).
  *
  * @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.
+ * @rd_table:     As above, for read access.
+ * @volatile_table: As above, for volatile registers.
+ * @precious_table: As above, for precious registers.
  * @reg_defaults: Power on reset values for registers (for use with
  *                register cache support).
  * @num_reg_defaults: Number of elements in reg_defaults.
@@ -116,8 +173,15 @@ struct regmap_config {
         bool (*readable_reg)(struct device *dev, unsigned int reg);
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+        regmap_lock lock;
+        regmap_unlock unlock;
+        void *lock_arg;
 
         unsigned int max_register;
+        const struct regmap_access_table *wr_table;
+        const struct regmap_access_table *rd_table;
+        const struct regmap_access_table *volatile_table;
+        const struct regmap_access_table *precious_table;
         const struct reg_default *reg_defaults;
         unsigned int num_reg_defaults;
         enum regcache_type cache_type;
@@ -133,7 +197,7 @@ struct regmap_config {
         enum regmap_endian val_format_endian;
 
         const struct regmap_range_cfg *ranges;
-        unsigned int n_ranges;
+        unsigned int num_ranges;
 };
 
 /**
@@ -142,6 +206,8 @@ struct regmap_config {
  *     1. page selector register update;
  *     2. access through data window registers.
  *
+ * @name: Descriptive name for diagnostics
+ *
  * @range_min: Address of the lowest register address in virtual range.
  * @range_max: Address of the highest register in virtual range.
  *
@@ -153,6 +219,8 @@ struct regmap_config {
  * @window_len: Number of registers in data window.
  */
 struct regmap_range_cfg {
+        const char *name;
+
         /* Registers of virtual address range */
         unsigned int range_min;
         unsigned int range_max;
@@ -181,7 +249,9 @@ typedef void (*regmap_hw_free_context)(void *context);
  * Description of a hardware bus for the register map infrastructure.
  *
  * @fast_io: Register IO is fast. Use a spinlock instead of a mutex
- *           to perform locking.
+ *           to perform locking. This field is ignored if custom lock/unlock
+ *           functions are used (see fields lock/unlock of
+ *           struct regmap_config).
  * @write: Write operation.
  * @gather_write: Write operation with split register/value, return -ENOTSUPP
  *                if not implemented  on a given device.
@@ -262,6 +332,16 @@ void regcache_mark_dirty(struct regmap *map);
 int regmap_register_patch(struct regmap *map, const struct reg_default *regs,
                           int num_regs);
 
+static inline bool regmap_reg_in_range(unsigned int reg,
+                                       const struct regmap_range *range)
+{
+        return reg >= range->range_min && reg <= range->range_max;
+}
+
+bool regmap_reg_in_ranges(unsigned int reg,
+                          const struct regmap_range *ranges,
+                          unsigned int nranges);
+
 /**
  * Description of an IRQ for the generic regmap irq_chip.
  *
@@ -317,6 +397,7 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
 void regmap_del_irq_chip(int irq, struct regmap_irq_chip_data *data);
 int regmap_irq_chip_get_base(struct regmap_irq_chip_data *data);
 int regmap_irq_get_virq(struct regmap_irq_chip_data *data, int irq);
+struct irq_domain *regmap_irq_get_domain(struct regmap_irq_chip_data *data);
 
 #else
 
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 6c8835f74f79..519777e3fa01 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -159,13 +159,14 @@ int ring_buffer_record_is_on(struct ring_buffer *buffer);
 void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu);
 void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu);
 
-unsigned long ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu);
+u64 ring_buffer_oldest_event_ts(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_bytes_cpu(struct ring_buffer *buffer, int cpu);
 unsigned long ring_buffer_entries(struct ring_buffer *buffer);
 unsigned long ring_buffer_overruns(struct ring_buffer *buffer);
 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);
 
 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/sched.h b/include/linux/sched.h
index 0dd42a02df2e..b96ff1e43ada 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -109,6 +109,8 @@ extern void update_cpu_load_nohz(void);
 
 extern unsigned long get_parent_ip(unsigned long addr);
 
+extern void dump_cpu_task(int cpu);
+
 struct seq_file;
 struct cfs_rq;
 struct task_group;
@@ -434,13 +436,28 @@ struct cpu_itimer {
 };
 
 /**
+ * struct cputime - snaphsot of system and user cputime
+ * @utime: time spent in user mode
+ * @stime: time spent in system mode
+ *
+ * Gathers a generic snapshot of user and system time.
+ */
+struct cputime {
+        cputime_t utime;
+        cputime_t stime;
+};
+
+/**
  * struct task_cputime - collected CPU time counts
  * @utime:              time spent in user mode, in &cputime_t units
  * @stime:              time spent in kernel mode, in &cputime_t units
  * @sum_exec_runtime:   total time spent on the CPU, in nanoseconds
  *
- * This structure groups together three kinds of CPU time that are
- * tracked for threads and thread groups.  Most things considering
+ * This is an extension of struct cputime that includes the total runtime
+ * spent by the task from the scheduler point of view.
+ *
+ * As a result, this structure groups together three kinds of CPU time
+ * that are tracked for threads and thread groups.  Most things considering
  * CPU time want to group these counts together and treat all three
  * of them in parallel.
  */
@@ -581,7 +598,7 @@ struct signal_struct {
         cputime_t gtime;
         cputime_t cgtime;
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
-        cputime_t prev_utime, prev_stime;
+        struct cputime prev_cputime;
 #endif
         unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
         unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
@@ -631,9 +648,10 @@ struct signal_struct {
         struct rw_semaphore group_rwsem;
 #endif
 
-        int oom_score_adj;      /* OOM kill score adjustment */
-        int oom_score_adj_min;  /* OOM kill score adjustment minimum value.
-                                 * Only settable by CAP_SYS_RESOURCE. */
+        oom_flags_t oom_flags;
+        short oom_score_adj;            /* OOM kill score adjustment */
+        short oom_score_adj_min;        /* OOM kill score adjustment min value.
+                                         * Only settable by CAP_SYS_RESOURCE. */
 
         struct mutex cred_guard_mutex;  /* guard against foreign influences on
                                          * credential calculations
@@ -1061,6 +1079,7 @@ struct sched_class {
 
 #ifdef CONFIG_SMP
         int  (*select_task_rq)(struct task_struct *p, int sd_flag, int flags);
+        void (*migrate_task_rq)(struct task_struct *p, int next_cpu);
 
         void (*pre_schedule) (struct rq *this_rq, struct task_struct *task);
         void (*post_schedule) (struct rq *this_rq);
@@ -1095,6 +1114,18 @@ struct load_weight {
         unsigned long weight, inv_weight;
 };
 
+struct sched_avg {
+        /*
+         * These sums represent an infinite geometric series and so are bound
+         * above by 1024/(1-y).  Thus we only need a u32 to store them for for all
+         * choices of y < 1-2^(-32)*1024.
+         */
+        u32 runnable_avg_sum, runnable_avg_period;
+        u64 last_runnable_update;
+        s64 decay_count;
+        unsigned long load_avg_contrib;
+};
+
 #ifdef CONFIG_SCHEDSTATS
 struct sched_statistics {
         u64                     wait_start;
@@ -1155,6 +1186,15 @@ 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.
+ * load-balance).
+ */
+#if defined(CONFIG_SMP) && defined(CONFIG_FAIR_GROUP_SCHED)
+        /* Per-entity load-tracking */
+        struct sched_avg        avg;
+#endif
 };
 
 struct sched_rt_entity {
@@ -1318,7 +1358,7 @@ struct task_struct {
         cputime_t utime, stime, utimescaled, stimescaled;
         cputime_t gtime;
 #ifndef CONFIG_VIRT_CPU_ACCOUNTING
-        cputime_t prev_utime, prev_stime;
+        struct cputime prev_cputime;
 #endif
         unsigned long nvcsw, nivcsw; /* context switch counts */
         struct timespec start_time;             /* monotonic time */
@@ -1729,8 +1769,8 @@ static inline void put_task_struct(struct task_struct *t)
                 __put_task_struct(t);
 }
 
-extern void task_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
-extern void thread_group_times(struct task_struct *p, cputime_t *ut, cputime_t *st);
+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);
 
 /*
  * Per process flags
@@ -1844,14 +1884,6 @@ static inline void rcu_copy_process(struct task_struct *p)
 
 #endif
 
-static inline void rcu_switch(struct task_struct *prev,
-                              struct task_struct *next)
-{
-#ifdef CONFIG_RCU_USER_QS
-        rcu_user_hooks_switch(prev, next);
-#endif
-}
-
 static inline void tsk_restore_flags(struct task_struct *task,
                                 unsigned long orig_flags, unsigned long flags)
 {
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index c174c90fb3fb..c490d20b3fb8 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -105,6 +105,8 @@ extern int early_serial_setup(struct uart_port *port);
 
 extern int serial8250_find_port(struct uart_port *p);
 extern int serial8250_find_port_for_earlycon(void);
+extern unsigned int serial8250_early_in(struct uart_port *port, int offset);
+extern void serial8250_early_out(struct uart_port *port, int offset, int value);
 extern int setup_early_serial8250_console(char *cmdline);
 extern void serial8250_do_set_termios(struct uart_port *port,
                 struct ktermios *termios, struct ktermios *old);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 3c430228d232..c6690a2a27fb 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -46,6 +46,8 @@ struct uart_ops {
         unsigned int    (*get_mctrl)(struct uart_port *);
         void            (*stop_tx)(struct uart_port *);
         void            (*start_tx)(struct uart_port *);
+        void            (*throttle)(struct uart_port *);
+        void            (*unthrottle)(struct uart_port *);
         void            (*send_xchar)(struct uart_port *, char ch);
         void            (*stop_rx)(struct uart_port *);
         void            (*enable_ms)(struct uart_port *);
@@ -163,6 +165,10 @@ struct uart_port {
 #define UPF_BUGGY_UART          ((__force upf_t) (1 << 14))
 #define UPF_NO_TXEN_TEST        ((__force upf_t) (1 << 15))
 #define UPF_MAGIC_MULTIPLIER    ((__force upf_t) (1 << 16))
+/* Port has hardware-assisted h/w flow control (iow, auto-RTS *not* auto-CTS) */
+#define UPF_HARD_FLOW           ((__force upf_t) (1 << 21))
+/* Port has hardware-assisted s/w flow control */
+#define UPF_SOFT_FLOW           ((__force upf_t) (1 << 22))
 #define UPF_CONS_FLOW           ((__force upf_t) (1 << 23))
 #define UPF_SHARE_IRQ           ((__force upf_t) (1 << 24))
 #define UPF_EXAR_EFR            ((__force upf_t) (1 << 25))
diff --git a/include/linux/shm.h b/include/linux/shm.h
index bcf8a6a3ec00..429c1995d756 100644
--- a/include/linux/shm.h
+++ b/include/linux/shm.h
@@ -29,6 +29,21 @@ struct shmid_kernel /* private to the kernel */
 #define SHM_HUGETLB     04000   /* segment will use huge TLB pages */
 #define SHM_NORESERVE   010000  /* don't check for reservations */
 
+/* Bits [26:31] are reserved */
+
+/*
+ * When SHM_HUGETLB is set bits [26:31] encode the log2 of the huge page size.
+ * This gives us 6 bits, which is enough until someone invents 128 bit address
+ * spaces.
+ *
+ * Assume these are all power of twos.
+ * When 0 use the default page size.
+ */
+#define SHM_HUGE_SHIFT  26
+#define SHM_HUGE_MASK   0x3f
+#define SHM_HUGE_2MB    (21 << SHM_HUGE_SHIFT)
+#define SHM_HUGE_1GB    (30 << SHM_HUGE_SHIFT)
+
 #ifdef CONFIG_SYSVIPC
 long do_shmat(int shmid, char __user *shmaddr, int shmflg, unsigned long *addr,
               unsigned long shmlba);
diff --git a/include/linux/spi/ads7846.h b/include/linux/spi/ads7846.h
index c64de9dd7631..2f694f3846a9 100644
--- a/include/linux/spi/ads7846.h
+++ b/include/linux/spi/ads7846.h
@@ -46,8 +46,9 @@ struct ads7846_platform_data {
         u16     debounce_rep;           /* additional consecutive good readings
                                          * required after the first two */
         int     gpio_pendown;           /* the GPIO used to decide the pendown
-                                         * state if get_pendown_state == NULL
-                                         */
+                                         * state if get_pendown_state == NULL */
+        int     gpio_pendown_debounce;  /* platform specific debounce time for
+                                         * the gpio_pendown */
         int     (*get_pendown_state)(void);
         int     (*filter_init)  (const struct ads7846_platform_data *pdata,
                                  void **filter_data);
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 55a5c52cbb25..6eb691b08358 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -16,8 +16,10 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  *
  * Copyright (C) IBM Corporation, 2006
+ * Copyright (C) Fujitsu, 2012
  *
  * Author: Paul McKenney <paulmck@us.ibm.com>
+ *         Lai Jiangshan <laijs@cn.fujitsu.com>
  *
  * For detailed explanation of Read-Copy Update mechanism see -
  *              Documentation/RCU/ *.txt
@@ -40,6 +42,8 @@ struct rcu_batch {
         struct rcu_head *head, **tail;
 };
 
+#define RCU_BATCH_INIT(name) { NULL, &(name.head) }
+
 struct srcu_struct {
         unsigned completed;
         struct srcu_struct_array __percpu *per_cpu_ref;
@@ -70,12 +74,42 @@ int __init_srcu_struct(struct srcu_struct *sp, const char *name,
         __init_srcu_struct((sp), #sp, &__srcu_key); \
 })
 
+#define __SRCU_DEP_MAP_INIT(srcu_name)  .dep_map = { .name = #srcu_name },
 #else /* #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
 int init_srcu_struct(struct srcu_struct *sp);
 
+#define __SRCU_DEP_MAP_INIT(srcu_name)
 #endif /* #else #ifdef CONFIG_DEBUG_LOCK_ALLOC */
 
+void process_srcu(struct work_struct *work);
+
+#define __SRCU_STRUCT_INIT(name)                                        \
+        {                                                               \
+                .completed = -300,                                      \
+                .per_cpu_ref = &name##_srcu_array,                      \
+                .queue_lock = __SPIN_LOCK_UNLOCKED(name.queue_lock),    \
+                .running = false,                                       \
+                .batch_queue = RCU_BATCH_INIT(name.batch_queue),        \
+                .batch_check0 = RCU_BATCH_INIT(name.batch_check0),      \
+                .batch_check1 = RCU_BATCH_INIT(name.batch_check1),      \
+                .batch_done = RCU_BATCH_INIT(name.batch_done),          \
+                .work = __DELAYED_WORK_INITIALIZER(name.work, process_srcu, 0),\
+                __SRCU_DEP_MAP_INIT(name)                               \
+        }
+
+/*
+ * define and init a srcu struct at build time.
+ * dont't call init_srcu_struct() nor cleanup_srcu_struct() on it.
+ */
+#define DEFINE_SRCU(name)                                               \
+        static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
+        struct srcu_struct name = __SRCU_STRUCT_INIT(name);
+
+#define DEFINE_STATIC_SRCU(name)                                        \
+        static DEFINE_PER_CPU(struct srcu_struct_array, name##_srcu_array);\
+        static struct srcu_struct name = __SRCU_STRUCT_INIT(name);
+
 /**
  * call_srcu() - Queue a callback for invocation after an SRCU grace period
  * @sp: srcu_struct in queue the callback
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 91b34812cd84..fe82022478e7 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -29,6 +29,32 @@
 #include <linux/device.h>
 #include <linux/workqueue.h>
 
+#define THERMAL_TRIPS_NONE      -1
+#define THERMAL_MAX_TRIPS       12
+#define THERMAL_NAME_LENGTH     20
+
+/* No upper/lower limit requirement */
+#define THERMAL_NO_LIMIT        -1UL
+
+/* Unit conversion macros */
+#define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
+                                ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
+#define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
+
+/* Adding event notification support elements */
+#define THERMAL_GENL_FAMILY_NAME                "thermal_event"
+#define THERMAL_GENL_VERSION                    0x01
+#define THERMAL_GENL_MCAST_GROUP_NAME           "thermal_mc_group"
+
+/* Default Thermal Governor */
+#if defined(CONFIG_THERMAL_DEFAULT_GOV_STEP_WISE)
+#define DEFAULT_THERMAL_GOVERNOR       "step_wise"
+#elif defined(CONFIG_THERMAL_DEFAULT_GOV_FAIR_SHARE)
+#define DEFAULT_THERMAL_GOVERNOR       "fair_share"
+#elif defined(CONFIG_THERMAL_DEFAULT_GOV_USER_SPACE)
+#define DEFAULT_THERMAL_GOVERNOR       "user_space"
+#endif
+
 struct thermal_zone_device;
 struct thermal_cooling_device;
 
@@ -50,6 +76,30 @@ enum thermal_trend {
         THERMAL_TREND_DROPPING, /* temperature is dropping */
 };
 
+/* Events supported by Thermal Netlink */
+enum events {
+        THERMAL_AUX0,
+        THERMAL_AUX1,
+        THERMAL_CRITICAL,
+        THERMAL_DEV_FAULT,
+};
+
+/* attributes of thermal_genl_family */
+enum {
+        THERMAL_GENL_ATTR_UNSPEC,
+        THERMAL_GENL_ATTR_EVENT,
+        __THERMAL_GENL_ATTR_MAX,
+};
+#define THERMAL_GENL_ATTR_MAX (__THERMAL_GENL_ATTR_MAX - 1)
+
+/* commands supported by the thermal_genl_family */
+enum {
+        THERMAL_GENL_CMD_UNSPEC,
+        THERMAL_GENL_CMD_EVENT,
+        __THERMAL_GENL_CMD_MAX,
+};
+#define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
+
 struct thermal_zone_device_ops {
         int (*bind) (struct thermal_zone_device *,
                      struct thermal_cooling_device *);
@@ -83,11 +133,6 @@ struct thermal_cooling_device_ops {
         int (*set_cur_state) (struct thermal_cooling_device *, unsigned long);
 };
 
-#define THERMAL_NO_LIMIT -1UL /* no upper/lower limit requirement */
-
-#define THERMAL_TRIPS_NONE -1
-#define THERMAL_MAX_TRIPS 12
-#define THERMAL_NAME_LENGTH 20
 struct thermal_cooling_device {
         int id;
         char type[THERMAL_NAME_LENGTH];
@@ -100,10 +145,6 @@ struct thermal_cooling_device {
         struct list_head node;
 };
 
-#define KELVIN_TO_CELSIUS(t)    (long)(((long)t-2732 >= 0) ?    \
-                                ((long)t-2732+5)/10 : ((long)t-2732-5)/10)
-#define CELSIUS_TO_KELVIN(t)    ((t)*10+2732)
-
 struct thermal_attr {
         struct device_attribute attr;
         char name[THERMAL_NAME_LENGTH];
@@ -125,46 +166,61 @@ struct thermal_zone_device {
         int passive;
         unsigned int forced_passive;
         const struct thermal_zone_device_ops *ops;
+        const struct thermal_zone_params *tzp;
+        struct thermal_governor *governor;
         struct list_head thermal_instances;
         struct idr idr;
         struct mutex lock; /* protect thermal_instances list */
         struct list_head node;
         struct delayed_work poll_queue;
 };
-/* Adding event notification support elements */
-#define THERMAL_GENL_FAMILY_NAME                "thermal_event"
-#define THERMAL_GENL_VERSION                    0x01
-#define THERMAL_GENL_MCAST_GROUP_NAME           "thermal_mc_group"
 
-enum events {
-        THERMAL_AUX0,
-        THERMAL_AUX1,
-        THERMAL_CRITICAL,
-        THERMAL_DEV_FAULT,
+/* Structure that holds thermal governor information */
+struct thermal_governor {
+        char name[THERMAL_NAME_LENGTH];
+        int (*throttle)(struct thermal_zone_device *tz, int trip);
+        struct list_head        governor_list;
+        struct module           *owner;
 };
 
-struct thermal_genl_event {
-        u32 orig;
-        enum events event;
+/* Structure that holds binding parameters for a zone */
+struct thermal_bind_params {
+        struct thermal_cooling_device *cdev;
+
+        /*
+         * This is a measure of 'how effectively these devices can
+         * cool 'this' thermal zone. The shall be determined by platform
+         * characterization. This is on a 'percentage' scale.
+         * See Documentation/thermal/sysfs-api.txt for more information.
+         */
+        int weight;
+
+        /*
+         * This is a bit mask that gives the binding relation between this
+         * thermal zone and cdev, for a particular trip point.
+         * See Documentation/thermal/sysfs-api.txt for more information.
+         */
+        int trip_mask;
+        int (*match) (struct thermal_zone_device *tz,
+                        struct thermal_cooling_device *cdev);
 };
-/* attributes of thermal_genl_family */
-enum {
-        THERMAL_GENL_ATTR_UNSPEC,
-        THERMAL_GENL_ATTR_EVENT,
-        __THERMAL_GENL_ATTR_MAX,
+
+/* Structure to define Thermal Zone parameters */
+struct thermal_zone_params {
+        char governor_name[THERMAL_NAME_LENGTH];
+        int num_tbps;   /* Number of tbp entries */
+        struct thermal_bind_params *tbp;
 };
-#define THERMAL_GENL_ATTR_MAX (__THERMAL_GENL_ATTR_MAX - 1)
 
-/* commands supported by the thermal_genl_family */
-enum {
-        THERMAL_GENL_CMD_UNSPEC,
-        THERMAL_GENL_CMD_EVENT,
-        __THERMAL_GENL_CMD_MAX,
+struct thermal_genl_event {
+        u32 orig;
+        enum events event;
 };
-#define THERMAL_GENL_CMD_MAX (__THERMAL_GENL_CMD_MAX - 1)
 
+/* Function declarations */
 struct thermal_zone_device *thermal_zone_device_register(const char *, int, int,
-                void *, const struct thermal_zone_device_ops *, int, int);
+                void *, const struct thermal_zone_device_ops *,
+                const struct thermal_zone_params *, int, int);
 void thermal_zone_device_unregister(struct thermal_zone_device *);
 
 int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
@@ -173,10 +229,20 @@ int thermal_zone_bind_cooling_device(struct thermal_zone_device *, int,
 int thermal_zone_unbind_cooling_device(struct thermal_zone_device *, int,
                                        struct thermal_cooling_device *);
 void thermal_zone_device_update(struct thermal_zone_device *);
+
 struct thermal_cooling_device *thermal_cooling_device_register(char *, void *,
                 const struct thermal_cooling_device_ops *);
 void thermal_cooling_device_unregister(struct thermal_cooling_device *);
 
+int get_tz_trend(struct thermal_zone_device *, int);
+struct thermal_instance *get_thermal_instance(struct thermal_zone_device *,
+                struct thermal_cooling_device *, int);
+void thermal_cdev_update(struct thermal_cooling_device *);
+void notify_thermal_framework(struct thermal_zone_device *, int);
+
+int thermal_register_governor(struct thermal_governor *);
+void thermal_unregister_governor(struct thermal_governor *);
+
 #ifdef CONFIG_NET
 extern int thermal_generate_netlink_event(u32 orig, enum events event);
 #else
diff --git a/include/linux/tick.h b/include/linux/tick.h
index f37fceb69b73..1a6567b48492 100644
--- a/include/linux/tick.h
+++ b/include/linux/tick.h
@@ -142,4 +142,10 @@ static inline u64 get_cpu_idle_time_us(int cpu, u64 *unused) { return -1; }
 static inline u64 get_cpu_iowait_time_us(int cpu, u64 *unused) { return -1; }
 # endif /* !NO_HZ */
 
+# ifdef CONFIG_CPU_IDLE_GOV_MENU
+extern void menu_hrtimer_cancel(void);
+# else
+static inline void menu_hrtimer_cancel(void) {}
+# endif /* CONFIG_CPU_IDLE_GOV_MENU */
+
 #endif
diff --git a/include/linux/trace_clock.h b/include/linux/trace_clock.h
index 4eb490237d4c..d563f37e1a1d 100644
--- a/include/linux/trace_clock.h
+++ b/include/linux/trace_clock.h
@@ -12,6 +12,8 @@
 #include <linux/compiler.h>
 #include <linux/types.h>
 
+#include <asm/trace_clock.h>
+
 extern u64 notrace trace_clock_local(void);
 extern u64 notrace trace_clock(void);
 extern u64 notrace trace_clock_global(void);
diff --git a/include/linux/tty.h b/include/linux/tty.h
index f0b4eb47297c..8db1b569c37a 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -188,7 +188,9 @@ struct tty_port_operations {
 };
         
 struct tty_port {
+        struct tty_bufhead      buf;            /* Locked internally */
         struct tty_struct       *tty;           /* Back pointer */
+        struct tty_struct       *itty;          /* internal back ptr */
         const struct tty_port_operations *ops;  /* Port operations */
         spinlock_t              lock;           /* Lock protecting tty field */
         int                     blocked_open;   /* Waiting to open */
@@ -197,6 +199,9 @@ struct tty_port {
         wait_queue_head_t       close_wait;     /* Close waiters */
         wait_queue_head_t       delta_msr_wait; /* Modem status change */
         unsigned long           flags;          /* TTY flags ASY_*/
+        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 */
         struct mutex            mutex;          /* Locking */
         struct mutex            buf_mutex;      /* Buffer alloc lock */
@@ -235,6 +240,7 @@ struct tty_struct {
         struct mutex ldisc_mutex;
         struct tty_ldisc *ldisc;
 
+        struct mutex atomic_write_lock;
         struct mutex legacy_mutex;
         struct mutex termios_mutex;
         spinlock_t ctrl_lock;
@@ -254,7 +260,6 @@ struct tty_struct {
 
         struct tty_struct *link;
         struct fasync_struct *fasync;
-        struct tty_bufhead buf;         /* Locked internally */
         int alt_speed;          /* For magic substitution of 38400 bps */
         wait_queue_head_t write_wait;
         wait_queue_head_t read_wait;
@@ -265,37 +270,10 @@ struct tty_struct {
 
 #define N_TTY_BUF_SIZE 4096
 
-        /*
-         * The following is data for the N_TTY line discipline.  For
-         * historical reasons, this is included in the tty structure.
-         * Mostly locked by the BKL.
-         */
-        unsigned int column;
-        unsigned char lnext:1, erasing:1, raw:1, real_raw:1, icanon:1;
         unsigned char closing:1;
-        unsigned char echo_overrun:1;
         unsigned short minimum_to_wake;
-        unsigned long overrun_time;
-        int num_overrun;
-        unsigned long process_char_map[256/(8*sizeof(unsigned long))];
-        char *read_buf;
-        int read_head;
-        int read_tail;
-        int read_cnt;
-        unsigned long read_flags[N_TTY_BUF_SIZE/(8*sizeof(unsigned long))];
-        unsigned char *echo_buf;
-        unsigned int echo_pos;
-        unsigned int echo_cnt;
-        int canon_data;
-        unsigned long canon_head;
-        unsigned int canon_column;
-        struct mutex atomic_read_lock;
-        struct mutex atomic_write_lock;
-        struct mutex output_lock;
-        struct mutex echo_lock;
         unsigned char *write_buf;
         int write_cnt;
-        spinlock_t read_lock;
         /* If the tty has a pending do_SAK, queue it here - akpm */
         struct work_struct SAK_work;
         struct tty_port *port;
@@ -335,8 +313,6 @@ struct tty_file_private {
 #define TTY_PTY_LOCK            16      /* pty private */
 #define TTY_NO_WRITE_SPLIT      17      /* Preserve write boundaries to driver */
 #define TTY_HUPPED              18      /* Post driver->hangup() */
-#define TTY_FLUSHING            19      /* Flushing to ldisc in progress */
-#define TTY_FLUSHPENDING        20      /* Queued buffer flush pending */
 #define TTY_HUPPING             21      /* ->hangup() in progress */
 
 #define TTY_WRITE_FLUSH(tty) tty_write_flush((tty))
@@ -412,9 +388,9 @@ 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_struct *tty);
+extern void tty_buffer_free_all(struct tty_port *port);
 extern void tty_buffer_flush(struct tty_struct *tty);
-extern void tty_buffer_init(struct tty_struct *tty);
+extern void tty_buffer_init(struct tty_port *port);
 extern speed_t tty_get_baud_rate(struct tty_struct *tty);
 extern speed_t tty_termios_baud_rate(struct ktermios *termios);
 extern speed_t tty_termios_input_baud_rate(struct ktermios *termios);
@@ -479,6 +455,7 @@ extern struct device *tty_port_register_device_attr(struct tty_port *port,
                 const struct attribute_group **attr_grp);
 extern int tty_port_alloc_xmit_buf(struct tty_port *port);
 extern void tty_port_free_xmit_buf(struct tty_port *port);
+extern void tty_port_destroy(struct tty_port *port);
 extern void tty_port_put(struct tty_port *port);
 
 static inline struct tty_port *tty_port_get(struct tty_port *port)
@@ -535,7 +512,7 @@ extern void n_tty_inherit_ops(struct tty_ldisc_ops *ops);
 /* tty_audit.c */
 #ifdef CONFIG_AUDIT
 extern void tty_audit_add_data(struct tty_struct *tty, unsigned char *data,
-                               size_t size);
+                               size_t size, unsigned icanon);
 extern void tty_audit_exit(void);
 extern void tty_audit_fork(struct signal_struct *sig);
 extern void tty_audit_tiocsti(struct tty_struct *tty, char ch);
@@ -544,7 +521,7 @@ extern int tty_audit_push_task(struct task_struct *tsk,
                                kuid_t loginuid, u32 sessionid);
 #else
 static inline void tty_audit_add_data(struct tty_struct *tty,
-                                      unsigned char *data, size_t size)
+                unsigned char *data, size_t size, unsigned icanon)
 {
 }
 static inline void tty_audit_tiocsti(struct tty_struct *tty, char ch)
diff --git a/include/linux/tty_flip.h b/include/linux/tty_flip.h
index 9239d033a0a3..2002344ed36a 100644
--- a/include/linux/tty_flip.h
+++ b/include/linux/tty_flip.h
@@ -11,7 +11,7 @@ void tty_schedule_flip(struct tty_struct *tty);
 static inline int tty_insert_flip_char(struct tty_struct *tty,
                                         unsigned char ch, char flag)
 {
-        struct tty_buffer *tb = tty->buf.tail;
+        struct tty_buffer *tb = tty->port->buf.tail;
         if (tb && tb->used < tb->size) {
                 tb->flag_buf_ptr[tb->used] = flag;
                 tb->char_buf_ptr[tb->used++] = ch;
diff --git a/include/linux/types.h b/include/linux/types.h
index 1cc0e4b9a048..4d118ba11349 100644
--- a/include/linux/types.h
+++ b/include/linux/types.h
@@ -156,6 +156,7 @@ typedef u32 dma_addr_t;
 #endif
 typedef unsigned __bitwise__ gfp_t;
 typedef unsigned __bitwise__ fmode_t;
+typedef unsigned __bitwise__ oom_flags_t;
 
 #ifdef CONFIG_PHYS_ADDR_T_64BIT
 typedef u64 phys_addr_t;
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index 24594571c5a3..4f628a6fc5b4 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -97,12 +97,12 @@ extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_con
 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);
+extern void uprobe_start_dup_mmap(void);
+extern void uprobe_end_dup_mmap(void);
 extern void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm);
 extern void uprobe_free_utask(struct task_struct *t);
 extern void uprobe_copy_process(struct task_struct *t);
 extern unsigned long __weak uprobe_get_swbp_addr(struct pt_regs *regs);
-extern void __weak arch_uprobe_enable_step(struct arch_uprobe *arch);
-extern void __weak arch_uprobe_disable_step(struct arch_uprobe *arch);
 extern int uprobe_post_sstep_notifier(struct pt_regs *regs);
 extern int uprobe_pre_sstep_notifier(struct pt_regs *regs);
 extern void uprobe_notify_resume(struct pt_regs *regs);
@@ -129,6 +129,12 @@ static inline void
 uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end)
 {
 }
+static inline void uprobe_start_dup_mmap(void)
+{
+}
+static inline void uprobe_end_dup_mmap(void)
+{
+}
 static inline void
 uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm)
 {
diff --git a/include/linux/usb.h b/include/linux/usb.h
index 10278d18709c..689b14b26c8d 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -482,6 +482,7 @@ struct usb3_lpm_parameters {
  * @connect_time: time device was first connected
  * @do_remote_wakeup:  remote wakeup should be enabled
  * @reset_resume: needs reset instead of resume
+ * @port_is_suspended: the upstream port is suspended (L2 or U3)
  * @wusb_dev: if this is a Wireless USB device, link to the WUSB
  *      specific data for the device.
  * @slot_id: Slot ID assigned by xHCI
@@ -560,6 +561,7 @@ struct usb_device {
 
         unsigned do_remote_wakeup:1;
         unsigned reset_resume:1;
+        unsigned port_is_suspended:1;
 #endif
         struct wusb_dev *wusb_dev;
         int slot_id;
@@ -588,8 +590,9 @@ extern struct usb_device *usb_hub_find_child(struct usb_device *hdev,
  */
 #define usb_hub_for_each_child(hdev, port1, child) \
         for (port1 = 1, child = usb_hub_find_child(hdev, port1); \
-                port1 <= hdev->maxchild; \
-                child = usb_hub_find_child(hdev, ++port1))
+                        port1 <= hdev->maxchild; \
+                        child = usb_hub_find_child(hdev, ++port1)) \
+                if (!child) continue; else
 
 /* USB device locking */
 #define usb_lock_device(udev)           device_lock(&(udev)->dev)
@@ -805,6 +808,22 @@ static inline int usb_make_path(struct usb_device *dev, char *buf, size_t size)
         .bcdDevice_hi = (hi)
 
 /**
+ * USB_DEVICE_INTERFACE_CLASS - describe a usb device with a specific interface class
+ * @vend: the 16 bit USB Vendor ID
+ * @prod: the 16 bit USB Product ID
+ * @cl: bInterfaceClass value
+ *
+ * This macro is used to create a struct usb_device_id that matches a
+ * specific interface class of devices.
+ */
+#define USB_DEVICE_INTERFACE_CLASS(vend, prod, cl) \
+        .match_flags = USB_DEVICE_ID_MATCH_DEVICE | \
+                       USB_DEVICE_ID_MATCH_INT_CLASS, \
+        .idVendor = (vend), \
+        .idProduct = (prod), \
+        .bInterfaceClass = (cl)
+
+/**
  * USB_DEVICE_INTERFACE_PROTOCOL - describe a usb device with a specific interface protocol
  * @vend: the 16 bit USB Vendor ID
  * @prod: the 16 bit USB Product ID
@@ -1129,8 +1148,8 @@ extern int usb_disabled(void);
  * Note: URB_DIR_IN/OUT is automatically set in usb_submit_urb().
  */
 #define URB_SHORT_NOT_OK        0x0001  /* report short reads as errors */
-#define URB_ISO_ASAP            0x0002  /* iso-only, urb->start_frame
-                                         * ignored */
+#define URB_ISO_ASAP            0x0002  /* iso-only; use the first unexpired
+                                         * slot in the schedule */
 #define URB_NO_TRANSFER_DMA_MAP 0x0004  /* urb->transfer_dma valid on submit */
 #define URB_NO_FSBR             0x0020  /* UHCI-specific */
 #define URB_ZERO_PACKET         0x0040  /* Finish bulk OUT with short packet */
@@ -1309,15 +1328,20 @@ typedef void (*usb_complete_t)(struct urb *);
  * the transfer interval in the endpoint descriptor is logarithmic.
  * Device drivers must convert that value to linear units themselves.)
  *
- * Isochronous URBs normally use the URB_ISO_ASAP transfer flag, telling
- * the host controller to schedule the transfer as soon as bandwidth
- * utilization allows, and then set start_frame to reflect the actual frame
- * selected during submission.  Otherwise drivers must specify the start_frame
- * and handle the case where the transfer can't begin then.  However, drivers
- * won't know how bandwidth is currently allocated, and while they can
- * find the current frame using usb_get_current_frame_number () they can't
- * know the range for that frame number.  (Ranges for frame counter values
- * are HC-specific, and can go from 256 to 65536 frames from "now".)
+ * If an isochronous endpoint queue isn't already running, the host
+ * controller will schedule a new URB to start as soon as bandwidth
+ * utilization allows.  If the queue is running then a new URB will be
+ * scheduled to start in the first transfer slot following the end of the
+ * preceding URB, if that slot has not already expired.  If the slot has
+ * expired (which can happen when IRQ delivery is delayed for a long time),
+ * the scheduling behavior depends on the URB_ISO_ASAP flag.  If the flag
+ * is clear then the URB will be scheduled to start in the expired slot,
+ * implying that some of its packets will not be transferred; if the flag
+ * is set then the URB will be scheduled in the first unexpired slot,
+ * breaking the queue's synchronization.  Upon URB completion, the
+ * start_frame field will be set to the (micro)frame number in which the
+ * transfer was scheduled.  Ranges for frame counter values are HC-specific
+ * and can go from as low as 256 to as high as 65536 frames.
  *
  * Isochronous URBs have a different data transfer model, in part because
  * the quality of service is only "best effort".  Callers provide specially
diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h
index f8dda0621800..b09c37e04a91 100644
--- a/include/linux/usb/composite.h
+++ b/include/linux/usb/composite.h
@@ -38,6 +38,7 @@
 #include <linux/version.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
+#include <linux/log2.h>
 
 /*
  * USB function drivers should return USB_GADGET_DELAYED_STATUS if they
@@ -51,6 +52,7 @@
 /* big enough to hold our biggest descriptor */
 #define USB_COMP_EP0_BUFSIZ     1024
 
+#define USB_MS_TO_HS_INTERVAL(x)        (ilog2((x * 1000 / 125)) + 1)
 struct usb_configuration;
 
 /**
@@ -117,7 +119,7 @@ struct usb_configuration;
 struct usb_function {
         const char                      *name;
         struct usb_gadget_strings       **strings;
-        struct usb_descriptor_header    **descriptors;
+        struct usb_descriptor_header    **fs_descriptors;
         struct usb_descriptor_header    **hs_descriptors;
         struct usb_descriptor_header    **ss_descriptors;
 
diff --git a/include/linux/usb/ehci_pdriver.h b/include/linux/usb/ehci_pdriver.h
index c9d09f8b7ff2..99238b096f7e 100644
--- a/include/linux/usb/ehci_pdriver.h
+++ b/include/linux/usb/ehci_pdriver.h
@@ -29,6 +29,8 @@
  *                      initialization.
  * @port_power_off:     set to 1 if the controller needs to be powered down
  *                      after initialization.
+ * @no_io_watchdog:     set to 1 if the controller does not need the I/O
+ *                      watchdog to run.
  *
  * These are general configuration options for the EHCI controller. All of
  * these options are activating more or less workarounds for some hardware.
@@ -39,8 +41,7 @@ struct usb_ehci_pdata {
         unsigned        has_synopsys_hc_bug:1;
         unsigned        big_endian_desc:1;
         unsigned        big_endian_mmio:1;
-        unsigned        port_power_on:1;
-        unsigned        port_power_off:1;
+        unsigned        no_io_watchdog:1;
 
         /* Turn on all power and clocks */
         int (*power_on)(struct platform_device *pdev);
diff --git a/include/linux/usb/ezusb.h b/include/linux/usb/ezusb.h
index fc618d8d1e92..639ee45779fb 100644
--- a/include/linux/usb/ezusb.h
+++ b/include/linux/usb/ezusb.h
@@ -1,16 +1,8 @@
 #ifndef __EZUSB_H
 #define __EZUSB_H
 
-
-extern int ezusb_writememory(struct usb_device *dev, int address,
-                             unsigned char *data, int length, __u8 bRequest);
-
 extern int ezusb_fx1_set_reset(struct usb_device *dev, unsigned char reset_bit);
-extern int ezusb_fx2_set_reset(struct usb_device *dev, unsigned char reset_bit);
-
 extern int ezusb_fx1_ihex_firmware_download(struct usb_device *dev,
                                             const char *firmware_path);
-extern int ezusb_fx2_ihex_firmware_download(struct usb_device *dev,
-                                            const char *firmware_path);
 
 #endif /* __EZUSB_H */
diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h
index 5b6e50888248..0af6569b8cc6 100644
--- a/include/linux/usb/gadget.h
+++ b/include/linux/usb/gadget.h
@@ -939,6 +939,13 @@ static inline void usb_free_descriptors(struct usb_descriptor_header **v)
         kfree(v);
 }
 
+struct usb_function;
+int usb_assign_descriptors(struct usb_function *f,
+                struct usb_descriptor_header **fs,
+                struct usb_descriptor_header **hs,
+                struct usb_descriptor_header **ss);
+void usb_free_all_descriptors(struct usb_function *f);
+
 /*-------------------------------------------------------------------------*/
 
 /* utility to simplify map/unmap of usb_requests to/from DMA */
diff --git a/include/linux/usb/ohci_pdriver.h b/include/linux/usb/ohci_pdriver.h
index 74e7755168b7..012f2b7eb2b6 100644
--- a/include/linux/usb/ohci_pdriver.h
+++ b/include/linux/usb/ohci_pdriver.h
@@ -25,6 +25,7 @@
  * @big_endian_desc:    BE descriptors
  * @big_endian_mmio:    BE registers
  * @no_big_frame_no:    no big endian frame_no shift
+ * @num_ports:          number of ports
  *
  * These are general configuration options for the OHCI controller. All of
  * these options are activating more or less workarounds for some hardware.
@@ -33,6 +34,7 @@ struct usb_ohci_pdata {
         unsigned        big_endian_desc:1;
         unsigned        big_endian_mmio:1;
         unsigned        no_big_frame_no:1;
+        unsigned int    num_ports;
 
         /* Turn on all power and clocks */
         int (*power_on)(struct platform_device *pdev);
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index 06b5bae35b29..a29ae1eb9346 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -10,6 +10,7 @@
 #define __LINUX_USB_PHY_H
 
 #include <linux/notifier.h>
+#include <linux/usb.h>
 
 enum usb_phy_events {
         USB_EVENT_NONE,         /* no events or cable disconnected */
@@ -99,8 +100,10 @@ struct usb_phy {
                                 int suspend);
 
         /* notify phy connect status change */
-        int     (*notify_connect)(struct usb_phy *x, int port);
-        int     (*notify_disconnect)(struct usb_phy *x, int port);
+        int     (*notify_connect)(struct usb_phy *x,
+                        enum usb_device_speed speed);
+        int     (*notify_disconnect)(struct usb_phy *x,
+                        enum usb_device_speed speed);
 };
 
 
@@ -189,19 +192,19 @@ usb_phy_set_suspend(struct usb_phy *x, int suspend)
 }
 
 static inline int
-usb_phy_notify_connect(struct usb_phy *x, int port)
+usb_phy_notify_connect(struct usb_phy *x, enum usb_device_speed speed)
 {
         if (x->notify_connect)
-                return x->notify_connect(x, port);
+                return x->notify_connect(x, speed);
         else
                 return 0;
 }
 
 static inline int
-usb_phy_notify_disconnect(struct usb_phy *x, int port)
+usb_phy_notify_disconnect(struct usb_phy *x, enum usb_device_speed speed)
 {
         if (x->notify_disconnect)
-                return x->notify_disconnect(x, port);
+                return x->notify_disconnect(x, speed);
         else
                 return 0;
 }
diff --git a/include/linux/vtime.h b/include/linux/vtime.h
new file mode 100644
index 000000000000..ae30ab58431a
--- /dev/null
+++ b/include/linux/vtime.h
@@ -0,0 +1,48 @@
+#ifndef _LINUX_KERNEL_VTIME_H
+#define _LINUX_KERNEL_VTIME_H
+
+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
+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) { }
+#endif
+
+#ifdef CONFIG_IRQ_TIME_ACCOUNTING
+extern void irqtime_account_irq(struct task_struct *tsk);
+#else
+static inline void irqtime_account_irq(struct task_struct *tsk) { }
+#endif
+
+static inline void vtime_account_irq_enter(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);
+        irqtime_account_irq(tsk);
+}
+
+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);
+        irqtime_account_irq(tsk);
+}
+
+#endif /* _LINUX_KERNEL_VTIME_H */
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 50c3e8fa06a8..b82a83aba311 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -161,14 +161,7 @@ void __bdi_update_bandwidth(struct backing_dev_info *bdi,
                             unsigned long start_time);
 
 void page_writeback_init(void);
-void balance_dirty_pages_ratelimited_nr(struct address_space *mapping,
-                                        unsigned long nr_pages_dirtied);
-
-static inline void
-balance_dirty_pages_ratelimited(struct address_space *mapping)
-{
-        balance_dirty_pages_ratelimited_nr(mapping, 1);
-}
+void balance_dirty_pages_ratelimited(struct address_space *mapping);
 
 typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
                                 void *data);
diff --git a/include/media/adv7604.h b/include/media/adv7604.h
index 171b957db743..dc004bc926c9 100644
--- a/include/media/adv7604.h
+++ b/include/media/adv7604.h
@@ -40,14 +40,6 @@ enum adv7604_op_ch_sel {
         ADV7604_OP_CH_SEL_RBG = 5,
 };
 
-/* Primary mode (IO register 0x01, [3:0]) */
-enum adv7604_prim_mode {
-        ADV7604_PRIM_MODE_COMP = 1,
-        ADV7604_PRIM_MODE_RGB = 2,
-        ADV7604_PRIM_MODE_HDMI_COMP = 5,
-        ADV7604_PRIM_MODE_HDMI_GR = 6,
-};
-
 /* Input Color Space (IO register 0x02, [7:4]) */
 enum adv7604_inp_color_space {
         ADV7604_INP_COLOR_SPACE_LIM_RGB = 0,
@@ -103,9 +95,6 @@ struct adv7604_platform_data {
         /* Bus rotation and reordering */
         enum adv7604_op_ch_sel op_ch_sel;
 
-        /* Primary mode */
-        enum adv7604_prim_mode prim_mode;
-
         /* Select output format */
         enum adv7604_op_format_sel op_format_sel;
 
@@ -142,6 +131,16 @@ struct adv7604_platform_data {
         u8 i2c_vdp;
 };
 
+/*
+ * Mode of operation.
+ * This is used as the input argument of the s_routing video op.
+ */
+enum adv7604_mode {
+        ADV7604_MODE_COMP,
+        ADV7604_MODE_GR,
+        ADV7604_MODE_HDMI,
+};
+
 #define V4L2_CID_ADV_RX_ANALOG_SAMPLING_PHASE   (V4L2_CID_DV_CLASS_BASE + 0x1000)
 #define V4L2_CID_ADV_RX_FREE_RUN_COLOR_MANUAL   (V4L2_CID_DV_CLASS_BASE + 0x1001)
 #define V4L2_CID_ADV_RX_FREE_RUN_COLOR          (V4L2_CID_DV_CLASS_BASE + 0x1002)
diff --git a/include/net/netprio_cgroup.h b/include/net/netprio_cgroup.h
index 2760f4f4ae9b..1d04b6f0fbd4 100644
--- a/include/net/netprio_cgroup.h
+++ b/include/net/netprio_cgroup.h
@@ -27,7 +27,6 @@ struct netprio_map {
 
 struct cgroup_netprio_state {
         struct cgroup_subsys_state css;
-        u32 prioidx;
 };
 
 extern void sock_update_netprioidx(struct sock *sk, struct task_struct *task);
@@ -36,13 +35,12 @@ extern void sock_update_netprioidx(struct sock *sk, struct task_struct *task);
 
 static inline u32 task_netprioidx(struct task_struct *p)
 {
-        struct cgroup_netprio_state *state;
+        struct cgroup_subsys_state *css;
         u32 idx;
 
         rcu_read_lock();
-        state = container_of(task_subsys_state(p, net_prio_subsys_id),
-                             struct cgroup_netprio_state, css);
-        idx = state->prioidx;
+        css = task_subsys_state(p, net_prio_subsys_id);
+        idx = css->cgroup->id;
         rcu_read_unlock();
         return idx;
 }
@@ -57,8 +55,7 @@ static inline u32 task_netprioidx(struct task_struct *p)
         rcu_read_lock();
         css = task_subsys_state(p, net_prio_subsys_id);
         if (css)
-                idx = container_of(css,
-                                   struct cgroup_netprio_state, css)->prioidx;
+                idx = css->cgroup->id;
         rcu_read_unlock();
         return idx;
 }
diff --git a/include/net/tcp.h b/include/net/tcp.h
index 6feeccd83dd7..4af45e33105d 100644
--- a/include/net/tcp.h
+++ b/include/net/tcp.h
@@ -525,6 +525,7 @@ static inline __u32 cookie_v6_init_sequence(struct sock *sk,
 extern void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
                                       int nonagle);
 extern bool tcp_may_send_now(struct sock *sk);
+extern int __tcp_retransmit_skb(struct sock *, struct sk_buff *);
 extern int tcp_retransmit_skb(struct sock *, struct sk_buff *);
 extern void tcp_retransmit_timer(struct sock *sk);
 extern void tcp_xmit_retransmit_queue(struct sock *);
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index 6f0ba01afe73..63445ede48bb 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -1351,7 +1351,7 @@ struct xfrm6_tunnel {
 };
 
 extern void xfrm_init(void);
-extern void xfrm4_init(int rt_hash_size);
+extern void xfrm4_init(void);
 extern int xfrm_state_init(struct net *net);
 extern void xfrm_state_fini(struct net *net);
 extern void xfrm4_state_init(void);
diff --git a/include/scsi/scsi_device.h b/include/scsi/scsi_device.h
index 88fae8d20154..55367b04dc94 100644
--- a/include/scsi/scsi_device.h
+++ b/include/scsi/scsi_device.h
@@ -135,6 +135,8 @@ struct scsi_device {
                                      * because we did a bus reset. */
         unsigned use_10_for_rw:1; /* first try 10-byte read / write */
         unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
+        unsigned no_report_opcodes:1;   /* no REPORT SUPPORTED OPERATION CODES */
+        unsigned no_write_same:1;       /* no WRITE SAME command */
         unsigned skip_ms_page_8:1;      /* do not use MODE SENSE page 0x08 */
         unsigned skip_ms_page_3f:1;     /* do not use MODE SENSE page 0x3f */
         unsigned skip_vpd_pages:1;      /* do not read VPD pages */
@@ -362,6 +364,8 @@ extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
                                 int retries, struct scsi_sense_hdr *sshdr);
 extern int scsi_get_vpd_page(struct scsi_device *, u8 page, unsigned char *buf,
                              int buf_len);
+extern int scsi_report_opcode(struct scsi_device *sdev, unsigned char *buffer,
+                              unsigned int len, unsigned char opcode);
 extern int scsi_device_set_state(struct scsi_device *sdev,
                                  enum scsi_device_state state);
 extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
diff --git a/include/trace/events/gfpflags.h b/include/trace/events/gfpflags.h
index 9391706e9254..d6fd8e5b14b7 100644
--- a/include/trace/events/gfpflags.h
+++ b/include/trace/events/gfpflags.h
@@ -36,6 +36,7 @@
         {(unsigned long)__GFP_RECLAIMABLE,      "GFP_RECLAIMABLE"},     \
         {(unsigned long)__GFP_MOVABLE,          "GFP_MOVABLE"},         \
         {(unsigned long)__GFP_NOTRACK,          "GFP_NOTRACK"},         \
+        {(unsigned long)__GFP_NO_KSWAPD,        "GFP_NO_KSWAPD"},       \
         {(unsigned long)__GFP_OTHER_NODE,       "GFP_OTHER_NODE"}       \
         ) : "GFP_NOWAIT"
 
diff --git a/include/trace/events/oom.h b/include/trace/events/oom.h
index dd4ba3b92002..1e974983757e 100644
--- a/include/trace/events/oom.h
+++ b/include/trace/events/oom.h
@@ -14,7 +14,7 @@ TRACE_EVENT(oom_score_adj_update,
         TP_STRUCT__entry(
                 __field(        pid_t,  pid)
                 __array(        char,   comm,   TASK_COMM_LEN )
-                __field(         int,   oom_score_adj)
+                __field(        short,  oom_score_adj)
         ),
 
         TP_fast_assign(
@@ -23,7 +23,7 @@ TRACE_EVENT(oom_score_adj_update,
                 __entry->oom_score_adj = task->signal->oom_score_adj;
         ),
 
-        TP_printk("pid=%d comm=%s oom_score_adj=%d",
+        TP_printk("pid=%d comm=%s oom_score_adj=%hd",
                 __entry->pid, __entry->comm, __entry->oom_score_adj)
 );
 
diff --git a/include/trace/events/rcu.h b/include/trace/events/rcu.h
index 5bde94d8585b..d4f559b1ec34 100644
--- a/include/trace/events/rcu.h
+++ b/include/trace/events/rcu.h
@@ -549,6 +549,7 @@ TRACE_EVENT(rcu_torture_read,
  *      "EarlyExit": rcu_barrier_callback() piggybacked, thus early exit.
  *      "Inc1": rcu_barrier_callback() piggyback check counter incremented.
  *      "Offline": rcu_barrier_callback() found offline CPU
+ *      "OnlineNoCB": rcu_barrier_callback() found online no-CBs CPU.
  *      "OnlineQ": rcu_barrier_callback() found online CPU with callbacks.
  *      "OnlineNQ": rcu_barrier_callback() found online CPU, no callbacks.
  *      "IRQ": An rcu_barrier_callback() callback posted on remote CPU.
diff --git a/include/trace/events/task.h b/include/trace/events/task.h
index b53add02e929..102a646e1996 100644
--- a/include/trace/events/task.h
+++ b/include/trace/events/task.h
@@ -15,7 +15,7 @@ TRACE_EVENT(task_newtask,
                 __field(        pid_t,  pid)
                 __array(        char,   comm, TASK_COMM_LEN)
                 __field( unsigned long, clone_flags)
-                __field(        int,    oom_score_adj)
+                __field(        short,  oom_score_adj)
         ),
 
         TP_fast_assign(
@@ -25,7 +25,7 @@ TRACE_EVENT(task_newtask,
                 __entry->oom_score_adj = task->signal->oom_score_adj;
         ),
 
-        TP_printk("pid=%d comm=%s clone_flags=%lx oom_score_adj=%d",
+        TP_printk("pid=%d comm=%s clone_flags=%lx oom_score_adj=%hd",
                 __entry->pid, __entry->comm,
                 __entry->clone_flags, __entry->oom_score_adj)
 );
@@ -40,7 +40,7 @@ TRACE_EVENT(task_rename,
                 __field(        pid_t,  pid)
                 __array(        char, oldcomm,  TASK_COMM_LEN)
                 __array(        char, newcomm,  TASK_COMM_LEN)
-                __field(        int, oom_score_adj)
+                __field(        short,  oom_score_adj)
         ),
 
         TP_fast_assign(
@@ -50,7 +50,7 @@ TRACE_EVENT(task_rename,
                 __entry->oom_score_adj = task->signal->oom_score_adj;
         ),
 
-        TP_printk("pid=%d oldcomm=%s newcomm=%s oom_score_adj=%d",
+        TP_printk("pid=%d oldcomm=%s newcomm=%s oom_score_adj=%hd",
                 __entry->pid, __entry->oldcomm,
                 __entry->newcomm, __entry->oom_score_adj)
 );
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index a763888a36f9..40dc5e8fe340 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -545,8 +545,7 @@ ftrace_raw_event_##call(void *__data, proto)				\
         { assign; }                                                     \
                                                                         \
         if (!filter_current_check_discard(buffer, event_call, entry, event)) \
-                trace_nowake_buffer_unlock_commit(buffer,               \
-                                                  event, irq_flags, pc); \
+                trace_buffer_unlock_commit(buffer, event, irq_flags, pc); \
 }
 /*
  * The ftrace_test_probe is compiled out, it is only here as a build time check
@@ -620,79 +619,6 @@ __attribute__((section("_ftrace_events"))) *__event_##call = &event_##call
 
 #include TRACE_INCLUDE(TRACE_INCLUDE_FILE)
 
-/*
- * Define the insertion callback to perf events
- *
- * The job is very similar to ftrace_raw_event_<call> except that we don't
- * insert in the ring buffer but in a perf counter.
- *
- * static void ftrace_perf_<call>(proto)
- * {
- *      struct ftrace_data_offsets_<call> __maybe_unused __data_offsets;
- *      struct ftrace_event_call *event_call = &event_<call>;
- *      extern void perf_tp_event(int, u64, u64, void *, int);
- *      struct ftrace_raw_##call *entry;
- *      struct perf_trace_buf *trace_buf;
- *      u64 __addr = 0, __count = 1;
- *      unsigned long irq_flags;
- *      struct trace_entry *ent;
- *      int __entry_size;
- *      int __data_size;
- *      int __cpu
- *      int pc;
- *
- *      pc = preempt_count();
- *
- *      __data_size = ftrace_get_offsets_<call>(&__data_offsets, args);
- *
- *      // Below we want to get the aligned size by taking into account
- *      // the u32 field that will later store the buffer size
- *      __entry_size = ALIGN(__data_size + sizeof(*entry) + sizeof(u32),
- *                           sizeof(u64));
- *      __entry_size -= sizeof(u32);
- *
- *      // Protect the non nmi buffer
- *      // This also protects the rcu read side
- *      local_irq_save(irq_flags);
- *      __cpu = smp_processor_id();
- *
- *      if (in_nmi())
- *              trace_buf = rcu_dereference_sched(perf_trace_buf_nmi);
- *      else
- *              trace_buf = rcu_dereference_sched(perf_trace_buf);
- *
- *      if (!trace_buf)
- *              goto end;
- *
- *      trace_buf = per_cpu_ptr(trace_buf, __cpu);
- *
- *      // Avoid recursion from perf that could mess up the buffer
- *      if (trace_buf->recursion++)
- *              goto end_recursion;
- *
- *      raw_data = trace_buf->buf;
- *
- *      // Make recursion update visible before entering perf_tp_event
- *      // so that we protect from perf recursions.
- *
- *      barrier();
- *
- *      //zero dead bytes from alignment to avoid stack leak to userspace:
- *      *(u64 *)(&raw_data[__entry_size - sizeof(u64)]) = 0ULL;
- *      entry = (struct ftrace_raw_<call> *)raw_data;
- *      ent = &entry->ent;
- *      tracing_generic_entry_update(ent, irq_flags, pc);
- *      ent->type = event_call->id;
- *
- *      <tstruct> <- do some jobs with dynamic arrays
- *
- *      <assign>  <- affect our values
- *
- *      perf_tp_event(event_call->id, __addr, __count, entry,
- *                   __entry_size);  <- submit them to perf counter
- *
- * }
- */
 
 #ifdef CONFIG_PERF_EVENTS
 
diff --git a/include/trace/syscall.h b/include/trace/syscall.h
index 31966a4fb8cc..84bc4197e736 100644
--- a/include/trace/syscall.h
+++ b/include/trace/syscall.h
@@ -31,27 +31,4 @@ struct syscall_metadata {
         struct ftrace_event_call *exit_event;
 };
 
-#ifdef CONFIG_FTRACE_SYSCALLS
-extern unsigned long arch_syscall_addr(int nr);
-extern int init_syscall_trace(struct ftrace_event_call *call);
-
-extern int reg_event_syscall_enter(struct ftrace_event_call *call);
-extern void unreg_event_syscall_enter(struct ftrace_event_call *call);
-extern int reg_event_syscall_exit(struct ftrace_event_call *call);
-extern void unreg_event_syscall_exit(struct ftrace_event_call *call);
-extern int
-ftrace_format_syscall(struct ftrace_event_call *call, struct trace_seq *s);
-enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags,
-                                      struct trace_event *event);
-enum print_line_t print_syscall_exit(struct trace_iterator *iter, int flags,
-                                     struct trace_event *event);
-#endif
-
-#ifdef CONFIG_PERF_EVENTS
-int perf_sysenter_enable(struct ftrace_event_call *call);
-void perf_sysenter_disable(struct ftrace_event_call *call);
-int perf_sysexit_enable(struct ftrace_event_call *call);
-void perf_sysexit_disable(struct ftrace_event_call *call);
-#endif
-
 #endif /* _TRACE_SYSCALL_H */
diff --git a/include/uapi/asm-generic/ioctls.h b/include/uapi/asm-generic/ioctls.h
index 199975fac395..143dacbb7d9a 100644
--- a/include/uapi/asm-generic/ioctls.h
+++ b/include/uapi/asm-generic/ioctls.h
@@ -74,6 +74,9 @@
 #define TCSETXW         0x5435
 #define TIOCSIG         _IOW('T', 0x36, int)  /* pty: generate signal */
 #define TIOCVHANGUP     0x5437
+#define TIOCGPKT        _IOR('T', 0x38, int) /* Get packet mode state */
+#define TIOCGPTLCK      _IOR('T', 0x39, int) /* Get Pty lock state */
+#define TIOCGEXCL       _IOR('T', 0x40, int) /* Get exclusive mode state */
 
 #define FIONCLEX        0x5450
 #define FIOCLEX         0x5451
diff --git a/include/uapi/asm-generic/mman-common.h b/include/uapi/asm-generic/mman-common.h
index d030d2c2647a..4164529a94f9 100644
--- a/include/uapi/asm-generic/mman-common.h
+++ b/include/uapi/asm-generic/mman-common.h
@@ -55,4 +55,15 @@
 /* compatibility flags */
 #define MAP_FILE        0
 
+/*
+ * When MAP_HUGETLB is set bits [26:31] encode the log2 of the huge page size.
+ * This gives us 6 bits, which is enough until someone invents 128 bit address
+ * spaces.
+ *
+ * Assume these are all power of twos.
+ * When 0 use the default page size.
+ */
+#define MAP_HUGE_SHIFT  26
+#define MAP_HUGE_MASK   0x3f
+
 #endif /* __ASM_GENERIC_MMAN_COMMON_H */
diff --git a/include/uapi/asm-generic/mman.h b/include/uapi/asm-generic/mman.h
index 32c8bd6a196d..e9fe6fd2a074 100644
--- a/include/uapi/asm-generic/mman.h
+++ b/include/uapi/asm-generic/mman.h
@@ -13,6 +13,8 @@
 #define MAP_STACK       0x20000         /* give out an address that is best suited for process/thread stacks */
 #define MAP_HUGETLB     0x40000         /* create a huge page mapping */
 
+/* Bits [26:31] are reserved, see mman-common.h for MAP_HUGETLB usage */
+
 #define MCL_CURRENT     1               /* lock all current mappings */
 #define MCL_FUTURE      2               /* lock all future mappings */
 
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index e194387ef784..19e765fbfef7 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -415,3 +415,4 @@ header-y += wireless.h
 header-y += x25.h
 header-y += xattr.h
 header-y += xfrm.h
+header-y += hw_breakpoint.h
diff --git a/include/uapi/linux/hw_breakpoint.h b/include/uapi/linux/hw_breakpoint.h
new file mode 100644
index 000000000000..b04000a2296a
--- /dev/null
+++ b/include/uapi/linux/hw_breakpoint.h
@@ -0,0 +1,30 @@
+#ifndef _UAPI_LINUX_HW_BREAKPOINT_H
+#define _UAPI_LINUX_HW_BREAKPOINT_H
+
+enum {
+        HW_BREAKPOINT_LEN_1 = 1,
+        HW_BREAKPOINT_LEN_2 = 2,
+        HW_BREAKPOINT_LEN_4 = 4,
+        HW_BREAKPOINT_LEN_8 = 8,
+};
+
+enum {
+        HW_BREAKPOINT_EMPTY     = 0,
+        HW_BREAKPOINT_R         = 1,
+        HW_BREAKPOINT_W         = 2,
+        HW_BREAKPOINT_RW        = HW_BREAKPOINT_R | HW_BREAKPOINT_W,
+        HW_BREAKPOINT_X         = 4,
+        HW_BREAKPOINT_INVALID   = HW_BREAKPOINT_RW | HW_BREAKPOINT_X,
+};
+
+enum bp_type_idx {
+        TYPE_INST       = 0,
+#ifdef CONFIG_HAVE_MIXED_BREAKPOINTS_REGS
+        TYPE_DATA       = 0,
+#else
+        TYPE_DATA       = 1,
+#endif
+        TYPE_MAX
+};
+
+#endif /* _UAPI_LINUX_HW_BREAKPOINT_H */
diff --git a/include/uapi/linux/serial_core.h b/include/uapi/linux/serial_core.h
index 7e1ab20adc03..78f99d97475b 100644
--- a/include/uapi/linux/serial_core.h
+++ b/include/uapi/linux/serial_core.h
@@ -49,7 +49,8 @@
 #define PORT_XR17D15X   21      /* Exar XR17D15x UART */
 #define PORT_LPC3220    22      /* NXP LPC32xx SoC "Standard" UART */
 #define PORT_8250_CIR   23      /* CIR infrared port, has its own driver */
-#define PORT_MAX_8250   23      /* max port ID */
+#define PORT_XR17V35X   24      /* Exar XR17V35x UARTs */
+#define PORT_MAX_8250   24      /* max port ID */
 
 /*
  * ARM specific type numbers.  These are not currently guaranteed
@@ -215,5 +216,7 @@
 /* Energy Micro efm32 SoC */
 #define PORT_EFMUART   100
 
+/* ARC (Synopsys) on-chip UART */
+#define PORT_ARC       101
 
 #endif /* _UAPILINUX_SERIAL_CORE_H */
diff --git a/include/uapi/linux/serial_reg.h b/include/uapi/linux/serial_reg.h
index 5ed325e88a81..e6322605b138 100644
--- a/include/uapi/linux/serial_reg.h
+++ b/include/uapi/linux/serial_reg.h
@@ -367,5 +367,23 @@
 #define UART_OMAP_MDR1_CIR_MODE         0x06    /* CIR mode */
 #define UART_OMAP_MDR1_DISABLE          0x07    /* Disable (default state) */
 
+/*
+ * These are definitions for the Exar XR17V35X and XR17(C|D)15X
+ */
+#define UART_EXAR_8XMODE        0x88    /* 8X sampling rate select */
+#define UART_EXAR_SLEEP         0x8b    /* Sleep mode */
+#define UART_EXAR_DVID          0x8d    /* Device identification */
+
+#define UART_EXAR_FCTR          0x08    /* Feature Control Register */
+#define UART_FCTR_EXAR_IRDA     0x08    /* IrDa data encode select */
+#define UART_FCTR_EXAR_485      0x10    /* Auto 485 half duplex dir ctl */
+#define UART_FCTR_EXAR_TRGA     0x00    /* FIFO trigger table A */
+#define UART_FCTR_EXAR_TRGB     0x60    /* FIFO trigger table B */
+#define UART_FCTR_EXAR_TRGC     0x80    /* FIFO trigger table C */
+#define UART_FCTR_EXAR_TRGD     0xc0    /* FIFO trigger table D programmable */
+
+#define UART_EXAR_TXTRG         0x0a    /* Tx FIFO trigger level write-only */
+#define UART_EXAR_RXTRG         0x0b    /* Rx FIFO trigger level write-only */
+
 #endif /* _LINUX_SERIAL_REG_H */
 
diff --git a/include/video/omapdss.h b/include/video/omapdss.h
index 3729173b7fbc..88c829466fc1 100644
--- a/include/video/omapdss.h
+++ b/include/video/omapdss.h
@@ -314,6 +314,19 @@ int dsi_vc_send_bta_sync(struct omap_dss_device *dssdev, int channel);
 int dsi_enable_video_output(struct omap_dss_device *dssdev, int channel);
 void dsi_disable_video_output(struct omap_dss_device *dssdev, int channel);
 
+enum omapdss_version {
+        OMAPDSS_VER_UNKNOWN = 0,
+        OMAPDSS_VER_OMAP24xx,
+        OMAPDSS_VER_OMAP34xx_ES1,       /* OMAP3430 ES1.0, 2.0 */
+        OMAPDSS_VER_OMAP34xx_ES3,       /* OMAP3430 ES3.0+ */
+        OMAPDSS_VER_OMAP3630,
+        OMAPDSS_VER_AM35xx,
+        OMAPDSS_VER_OMAP4430_ES1,       /* OMAP4430 ES1.0 */
+        OMAPDSS_VER_OMAP4430_ES2,       /* OMAP4430 ES2.0, 2.1, 2.2 */
+        OMAPDSS_VER_OMAP4,              /* All other OMAP4s */
+        OMAPDSS_VER_OMAP5,
+};
+
 /* Board specific data */
 struct omap_dss_board_info {
         int (*get_context_loss_count)(struct device *dev);
@@ -323,6 +336,7 @@ struct omap_dss_board_info {
         int (*dsi_enable_pads)(int dsi_id, unsigned lane_mask);
         void (*dsi_disable_pads)(int dsi_id, unsigned lane_mask);
         int (*set_min_bus_tput)(struct device *dev, unsigned long r);
+        enum omapdss_version version;
 };
 
 /* Init with the board info */
diff --git a/include/video/omapvrfb.h b/include/video/omapvrfb.h
new file mode 100644
index 000000000000..bb0bd89f8bc6
--- /dev/null
+++ b/include/video/omapvrfb.h
@@ -0,0 +1,68 @@
+/*
+ * VRFB Rotation Engine
+ *
+ * Copyright (C) 2009 Nokia Corporation
+ * Author: Tomi Valkeinen <tomi.valkeinen@nokia.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+ */
+
+#ifndef __OMAP_VRFB_H__
+#define __OMAP_VRFB_H__
+
+#define OMAP_VRFB_LINE_LEN 2048
+
+struct vrfb {
+        u8 context;
+        void __iomem *vaddr[4];
+        unsigned long paddr[4];
+        u16 xres;
+        u16 yres;
+        u16 xoffset;
+        u16 yoffset;
+        u8 bytespp;
+        bool yuv_mode;
+};
+
+#ifdef CONFIG_OMAP2_VRFB
+extern bool omap_vrfb_supported(void);
+extern int omap_vrfb_request_ctx(struct vrfb *vrfb);
+extern void omap_vrfb_release_ctx(struct vrfb *vrfb);
+extern void omap_vrfb_adjust_size(u16 *width, u16 *height,
+                u8 bytespp);
+extern u32 omap_vrfb_min_phys_size(u16 width, u16 height, u8 bytespp);
+extern u16 omap_vrfb_max_height(u32 phys_size, u16 width, u8 bytespp);
+extern void omap_vrfb_setup(struct vrfb *vrfb, unsigned long paddr,
+                u16 width, u16 height,
+                unsigned bytespp, bool yuv_mode);
+extern int omap_vrfb_map_angle(struct vrfb *vrfb, u16 height, u8 rot);
+extern void omap_vrfb_restore_context(void);
+
+#else
+static inline bool omap_vrfb_supported(void) { return false; }
+static inline int omap_vrfb_request_ctx(struct vrfb *vrfb) { return 0; }
+static inline void omap_vrfb_release_ctx(struct vrfb *vrfb) {}
+static inline void omap_vrfb_adjust_size(u16 *width, u16 *height,
+                u8 bytespp) {}
+static inline u32 omap_vrfb_min_phys_size(u16 width, u16 height, u8 bytespp)
+                { return 0; }
+static inline u16 omap_vrfb_max_height(u32 phys_size, u16 width, u8 bytespp)
+                { return 0; }
+static inline void omap_vrfb_setup(struct vrfb *vrfb, unsigned long paddr,
+                u16 width, u16 height, unsigned bytespp, bool yuv_mode) {}
+static inline int omap_vrfb_map_angle(struct vrfb *vrfb, u16 height, u8 rot)
+                { return 0; }
+static inline void omap_vrfb_restore_context(void) {}
+#endif
+#endif /* __VRFB_H */