148 files changed, 4434 insertions, 943 deletions

diff --git a/include/acpi/acpi_bus.h b/include/acpi/acpi_bus.h
index 636c59f2003a..c13c919ab99e 100644
--- a/include/acpi/acpi_bus.h
+++ b/include/acpi/acpi_bus.h
@@ -382,6 +382,7 @@ const char *acpi_power_state_string(int state);
 int acpi_device_get_power(struct acpi_device *device, int *state);
 int acpi_device_set_power(struct acpi_device *device, int state);
 int acpi_bus_init_power(struct acpi_device *device);
+int acpi_device_fix_up_power(struct acpi_device *device);
 int acpi_bus_update_power(acpi_handle handle, int *state_p);
 bool acpi_bus_power_manageable(acpi_handle handle);
 
diff --git a/include/acpi/acpi_drivers.h b/include/acpi/acpi_drivers.h
index e6168a24b9f0..b420939f5eb5 100644
--- a/include/acpi/acpi_drivers.h
+++ b/include/acpi/acpi_drivers.h
@@ -123,7 +123,9 @@ extern int register_dock_notifier(struct notifier_block *nb);
 extern void unregister_dock_notifier(struct notifier_block *nb);
 extern int register_hotplug_dock_device(acpi_handle handle,
                                         const struct acpi_dock_ops *ops,
-                                        void *context);
+                                        void *context,
+                                        void (*init)(void *),
+                                        void (*release)(void *));
 extern void unregister_hotplug_dock_device(acpi_handle handle);
 #else
 static inline int is_dock_device(acpi_handle handle)
@@ -139,7 +141,9 @@ static inline void unregister_dock_notifier(struct notifier_block *nb)
 }
 static inline int register_hotplug_dock_device(acpi_handle handle,
                                                const struct acpi_dock_ops *ops,
-                                               void *context)
+                                               void *context,
+                                               void (*init)(void *),
+                                               void (*release)(void *))
 {
         return -ENODEV;
 }
diff --git a/include/asm-generic/io.h b/include/asm-generic/io.h
index ac9da00e9f2c..d5afe96adba6 100644
--- a/include/asm-generic/io.h
+++ b/include/asm-generic/io.h
@@ -343,8 +343,12 @@ extern void ioport_unmap(void __iomem *p);
 #endif /* CONFIG_GENERIC_IOMAP */
 #endif /* CONFIG_HAS_IOPORT */
 
+#ifndef xlate_dev_kmem_ptr
 #define xlate_dev_kmem_ptr(p)   p
+#endif
+#ifndef xlate_dev_mem_ptr
 #define xlate_dev_mem_ptr(p)    __va(p)
+#endif
 
 #ifdef CONFIG_VIRT_TO_BUS
 #ifndef virt_to_bus
diff --git a/include/asm-generic/kvm_para.h b/include/asm-generic/kvm_para.h
index 9d96605f160a..fa25becbdcaf 100644
--- a/include/asm-generic/kvm_para.h
+++ b/include/asm-generic/kvm_para.h
@@ -18,4 +18,9 @@ static inline unsigned int kvm_arch_para_features(void)
         return 0;
 }
 
+static inline bool kvm_para_available(void)
+{
+        return false;
+}
+
 #endif
diff --git a/include/asm-generic/mutex-dec.h b/include/asm-generic/mutex-dec.h
index f104af7cf437..d4f9fb4e53df 100644
--- a/include/asm-generic/mutex-dec.h
+++ b/include/asm-generic/mutex-dec.h
@@ -28,17 +28,15 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *))
  *  __mutex_fastpath_lock_retval - try to take the lock by moving the count
  *                                 from 1 to a 0 value
  *  @count: pointer of type atomic_t
- *  @fail_fn: function to call if the original value was not 1
  *
- * Change the count from 1 to a value lower than 1, and call <fail_fn> if
- * it wasn't 1 originally. This function returns 0 if the fastpath succeeds,
- * or anything the slow path function returns.
+ * Change the count from 1 to a value lower than 1. This function returns 0
+ * if the fastpath succeeds, or -1 otherwise.
  */
 static inline int
-__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *))
+__mutex_fastpath_lock_retval(atomic_t *count)
 {
         if (unlikely(atomic_dec_return(count) < 0))
-                return fail_fn(count);
+                return -1;
         return 0;
 }
 
diff --git a/include/asm-generic/mutex-null.h b/include/asm-generic/mutex-null.h
index e1bbbc72b6a2..61069ed334e2 100644
--- a/include/asm-generic/mutex-null.h
+++ b/include/asm-generic/mutex-null.h
@@ -11,7 +11,7 @@
 #define _ASM_GENERIC_MUTEX_NULL_H
 
 #define __mutex_fastpath_lock(count, fail_fn)           fail_fn(count)
-#define __mutex_fastpath_lock_retval(count, fail_fn)    fail_fn(count)
+#define __mutex_fastpath_lock_retval(count)             (-1)
 #define __mutex_fastpath_unlock(count, fail_fn)         fail_fn(count)
 #define __mutex_fastpath_trylock(count, fail_fn)        fail_fn(count)
 #define __mutex_slowpath_needs_to_unlock()              1
diff --git a/include/asm-generic/mutex-xchg.h b/include/asm-generic/mutex-xchg.h
index c04e0db8a2d6..f169ec064785 100644
--- a/include/asm-generic/mutex-xchg.h
+++ b/include/asm-generic/mutex-xchg.h
@@ -39,18 +39,16 @@ __mutex_fastpath_lock(atomic_t *count, void (*fail_fn)(atomic_t *))
  *  __mutex_fastpath_lock_retval - try to take the lock by moving the count
  *                                 from 1 to a 0 value
  *  @count: pointer of type atomic_t
- *  @fail_fn: function to call if the original value was not 1
  *
- * Change the count from 1 to a value lower than 1, and call <fail_fn> if it
- * wasn't 1 originally. This function returns 0 if the fastpath succeeds,
- * or anything the slow path function returns
+ * Change the count from 1 to a value lower than 1. This function returns 0
+ * if the fastpath succeeds, or -1 otherwise.
  */
 static inline int
-__mutex_fastpath_lock_retval(atomic_t *count, int (*fail_fn)(atomic_t *))
+__mutex_fastpath_lock_retval(atomic_t *count)
 {
         if (unlikely(atomic_xchg(count, 0) != 1))
                 if (likely(atomic_xchg(count, -1) != 1))
-                        return fail_fn(count);
+                        return -1;
         return 0;
 }
 
diff --git a/include/asm-generic/pgtable.h b/include/asm-generic/pgtable.h
index a59ff51b0166..b1836987d506 100644
--- a/include/asm-generic/pgtable.h
+++ b/include/asm-generic/pgtable.h
@@ -692,4 +692,8 @@ static inline pmd_t pmd_mknuma(pmd_t pmd)
 
 #endif /* !__ASSEMBLY__ */
 
+#ifndef io_remap_pfn_range
+#define io_remap_pfn_range remap_pfn_range
+#endif
+
 #endif /* _ASM_GENERIC_PGTABLE_H */
diff --git a/include/asm-generic/tlb.h b/include/asm-generic/tlb.h
index b1b1fa6ffffe..13821c339a41 100644
--- a/include/asm-generic/tlb.h
+++ b/include/asm-generic/tlb.h
@@ -97,11 +97,9 @@ struct mmu_gather {
         unsigned long           start;
         unsigned long           end;
         unsigned int            need_flush : 1, /* Did free PTEs */
-                                fast_mode  : 1; /* No batching   */
-
         /* we are in the middle of an operation to clear
          * a full mm and can make some optimizations */
-        unsigned int            fullmm : 1,
+                                fullmm : 1,
         /* we have performed an operation which
          * requires a complete flush of the tlb */
                                 need_flush_all : 1;
@@ -114,19 +112,6 @@ struct mmu_gather {
 
 #define HAVE_GENERIC_MMU_GATHER
 
-static inline int tlb_fast_mode(struct mmu_gather *tlb)
-{
-#ifdef CONFIG_SMP
-        return tlb->fast_mode;
-#else
-        /*
-         * For UP we don't need to worry about TLB flush
-         * and page free order so much..
-         */
-        return 1;
-#endif
-}
-
 void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm, bool fullmm);
 void tlb_flush_mmu(struct mmu_gather *tlb);
 void tlb_finish_mmu(struct mmu_gather *tlb, unsigned long start,
diff --git a/include/asm-generic/uaccess.h b/include/asm-generic/uaccess.h
index c184aa8ec8cd..dc1269c74a52 100644
--- a/include/asm-generic/uaccess.h
+++ b/include/asm-generic/uaccess.h
@@ -163,7 +163,7 @@ static inline __must_check long __copy_to_user(void __user *to,
 
 #define put_user(x, ptr)                                        \
 ({                                                              \
-        might_sleep();                                          \
+        might_fault();                                          \
         access_ok(VERIFY_WRITE, ptr, sizeof(*ptr)) ?            \
                 __put_user(x, ptr) :                            \
                 -EFAULT;                                        \
@@ -225,7 +225,7 @@ extern int __put_user_bad(void) __attribute__((noreturn));
 
 #define get_user(x, ptr)                                        \
 ({                                                              \
-        might_sleep();                                          \
+        might_fault();                                          \
         access_ok(VERIFY_READ, ptr, sizeof(*ptr)) ?             \
                 __get_user(x, ptr) :                            \
                 -EFAULT;                                        \
@@ -255,7 +255,7 @@ extern int __get_user_bad(void) __attribute__((noreturn));
 static inline long copy_from_user(void *to,
                 const void __user * from, unsigned long n)
 {
-        might_sleep();
+        might_fault();
         if (access_ok(VERIFY_READ, from, n))
                 return __copy_from_user(to, from, n);
         else
@@ -265,7 +265,7 @@ static inline long copy_from_user(void *to,
 static inline long copy_to_user(void __user *to,
                 const void *from, unsigned long n)
 {
-        might_sleep();
+        might_fault();
         if (access_ok(VERIFY_WRITE, to, n))
                 return __copy_to_user(to, from, n);
         else
@@ -336,7 +336,7 @@ __clear_user(void __user *to, unsigned long n)
 static inline __must_check unsigned long
 clear_user(void __user *to, unsigned long n)
 {
-        might_sleep();
+        might_fault();
         if (!access_ok(VERIFY_WRITE, to, n))
                 return n;
 
diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
index eb58d2d7d971..4f2737208c42 100644
--- a/include/asm-generic/vmlinux.lds.h
+++ b/include/asm-generic/vmlinux.lds.h
@@ -68,14 +68,6 @@
  * are handled as text/data or they can be discarded (which
  * often happens at runtime)
  */
-#ifdef CONFIG_HOTPLUG
-#define DEV_KEEP(sec)    *(.dev##sec)
-#define DEV_DISCARD(sec)
-#else
-#define DEV_KEEP(sec)
-#define DEV_DISCARD(sec) *(.dev##sec)
-#endif
-
 #ifdef CONFIG_HOTPLUG_CPU
 #define CPU_KEEP(sec)    *(.cpu##sec)
 #define CPU_DISCARD(sec)
@@ -182,8 +174,6 @@
         *(.data)                                                        \
         *(.ref.data)                                                    \
         *(.data..shared_aligned) /* percpu related */                   \
-        DEV_KEEP(init.data)                                             \
-        DEV_KEEP(exit.data)                                             \
         CPU_KEEP(init.data)                                             \
         CPU_KEEP(exit.data)                                             \
         MEM_KEEP(init.data)                                             \
@@ -372,8 +362,6 @@
         /* __*init sections */                                          \
         __init_rodata : AT(ADDR(__init_rodata) - LOAD_OFFSET) {         \
                 *(.ref.rodata)                                          \
-                DEV_KEEP(init.rodata)                                   \
-                DEV_KEEP(exit.rodata)                                   \
                 CPU_KEEP(init.rodata)                                   \
                 CPU_KEEP(exit.rodata)                                   \
                 MEM_KEEP(init.rodata)                                   \
@@ -416,8 +404,6 @@
                 *(.text.hot)                                            \
                 *(.text)                                                \
                 *(.ref.text)                                            \
-        DEV_KEEP(init.text)                                             \
-        DEV_KEEP(exit.text)                                             \
         CPU_KEEP(init.text)                                             \
         CPU_KEEP(exit.text)                                             \
         MEM_KEEP(init.text)                                             \
@@ -503,7 +489,6 @@
 /* init and exit section handling */
 #define INIT_DATA                                                       \
         *(.init.data)                                                   \
-        DEV_DISCARD(init.data)                                          \
         CPU_DISCARD(init.data)                                          \
         MEM_DISCARD(init.data)                                          \
         KERNEL_CTORS()                                                  \
@@ -511,7 +496,6 @@
         *(.init.rodata)                                                 \
         FTRACE_EVENTS()                                                 \
         TRACE_SYSCALLS()                                                \
-        DEV_DISCARD(init.rodata)                                        \
         CPU_DISCARD(init.rodata)                                        \
         MEM_DISCARD(init.rodata)                                        \
         CLK_OF_TABLES()                                                 \
@@ -521,14 +505,11 @@
 
 #define INIT_TEXT                                                       \
         *(.init.text)                                                   \
-        DEV_DISCARD(init.text)                                          \
         CPU_DISCARD(init.text)                                          \
         MEM_DISCARD(init.text)
 
 #define EXIT_DATA                                                       \
         *(.exit.data)                                                   \
-        DEV_DISCARD(exit.data)                                          \
-        DEV_DISCARD(exit.rodata)                                        \
         CPU_DISCARD(exit.data)                                          \
         CPU_DISCARD(exit.rodata)                                        \
         MEM_DISCARD(exit.data)                                          \
@@ -536,7 +517,6 @@
 
 #define EXIT_TEXT                                                       \
         *(.exit.text)                                                   \
-        DEV_DISCARD(exit.text)                                          \
         CPU_DISCARD(exit.text)                                          \
         MEM_DISCARD(exit.text)
 
diff --git a/include/clocksource/arm_arch_timer.h b/include/clocksource/arm_arch_timer.h
index e6c9c4cc9b23..c463ce990c48 100644
--- a/include/clocksource/arm_arch_timer.h
+++ b/include/clocksource/arm_arch_timer.h
@@ -32,7 +32,7 @@
 #ifdef CONFIG_ARM_ARCH_TIMER
 
 extern u32 arch_timer_get_rate(void);
-extern u64 (*arch_timer_read_counter)(void);
+extern u64 arch_timer_read_counter(void);
 extern struct timecounter *arch_timer_get_timecounter(void);
 
 #else
diff --git a/include/dt-bindings/clk/exynos-audss-clk.h b/include/dt-bindings/clk/exynos-audss-clk.h
new file mode 100644
index 000000000000..8279f427c60f
--- /dev/null
+++ b/include/dt-bindings/clk/exynos-audss-clk.h
@@ -0,0 +1,25 @@
+/*
+ * This header provides constants for Samsung audio subsystem
+ * clock controller.
+ *
+ * The constants defined in this header are being used in dts
+ * and exynos audss driver.
+ */
+
+#ifndef _DT_BINDINGS_CLK_EXYNOS_AUDSS_H
+#define _DT_BINDINGS_CLK_EXYNOS_AUDSS_H
+
+#define EXYNOS_MOUT_AUDSS       0
+#define EXYNOS_MOUT_I2S 1
+#define EXYNOS_DOUT_SRP 2
+#define EXYNOS_DOUT_AUD_BUS     3
+#define EXYNOS_DOUT_I2S 4
+#define EXYNOS_SRP_CLK          5
+#define EXYNOS_I2S_BUS          6
+#define EXYNOS_SCLK_I2S 7
+#define EXYNOS_PCM_BUS          8
+#define EXYNOS_SCLK_PCM 9
+
+#define EXYNOS_AUDSS_MAX_CLKS   10
+
+#endif
diff --git a/include/dt-bindings/clock/imx6sl-clock.h b/include/dt-bindings/clock/imx6sl-clock.h
new file mode 100644
index 000000000000..7fcdf90879f2
--- /dev/null
+++ b/include/dt-bindings/clock/imx6sl-clock.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2013 Freescale Semiconductor, Inc.
+ *
+ * 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 __DT_BINDINGS_CLOCK_IMX6SL_H
+#define __DT_BINDINGS_CLOCK_IMX6SL_H
+
+#define IMX6SL_CLK_DUMMY                0
+#define IMX6SL_CLK_CKIL                 1
+#define IMX6SL_CLK_OSC                  2
+#define IMX6SL_CLK_PLL1_SYS             3
+#define IMX6SL_CLK_PLL2_BUS             4
+#define IMX6SL_CLK_PLL3_USB_OTG         5
+#define IMX6SL_CLK_PLL4_AUDIO           6
+#define IMX6SL_CLK_PLL5_VIDEO           7
+#define IMX6SL_CLK_PLL6_ENET            8
+#define IMX6SL_CLK_PLL7_USB_HOST        9
+#define IMX6SL_CLK_USBPHY1              10
+#define IMX6SL_CLK_USBPHY2              11
+#define IMX6SL_CLK_USBPHY1_GATE         12
+#define IMX6SL_CLK_USBPHY2_GATE         13
+#define IMX6SL_CLK_PLL4_POST_DIV        14
+#define IMX6SL_CLK_PLL5_POST_DIV        15
+#define IMX6SL_CLK_PLL5_VIDEO_DIV       16
+#define IMX6SL_CLK_ENET_REF             17
+#define IMX6SL_CLK_PLL2_PFD0            18
+#define IMX6SL_CLK_PLL2_PFD1            19
+#define IMX6SL_CLK_PLL2_PFD2            20
+#define IMX6SL_CLK_PLL3_PFD0            21
+#define IMX6SL_CLK_PLL3_PFD1            22
+#define IMX6SL_CLK_PLL3_PFD2            23
+#define IMX6SL_CLK_PLL3_PFD3            24
+#define IMX6SL_CLK_PLL2_198M            25
+#define IMX6SL_CLK_PLL3_120M            26
+#define IMX6SL_CLK_PLL3_80M             27
+#define IMX6SL_CLK_PLL3_60M             28
+#define IMX6SL_CLK_STEP                 29
+#define IMX6SL_CLK_PLL1_SW              30
+#define IMX6SL_CLK_OCRAM_ALT_SEL        31
+#define IMX6SL_CLK_OCRAM_SEL            32
+#define IMX6SL_CLK_PRE_PERIPH2_SEL      33
+#define IMX6SL_CLK_PRE_PERIPH_SEL       34
+#define IMX6SL_CLK_PERIPH2_CLK2_SEL     35
+#define IMX6SL_CLK_PERIPH_CLK2_SEL      36
+#define IMX6SL_CLK_CSI_SEL              37
+#define IMX6SL_CLK_LCDIF_AXI_SEL        38
+#define IMX6SL_CLK_USDHC1_SEL           39
+#define IMX6SL_CLK_USDHC2_SEL           40
+#define IMX6SL_CLK_USDHC3_SEL           41
+#define IMX6SL_CLK_USDHC4_SEL           42
+#define IMX6SL_CLK_SSI1_SEL             43
+#define IMX6SL_CLK_SSI2_SEL             44
+#define IMX6SL_CLK_SSI3_SEL             45
+#define IMX6SL_CLK_PERCLK_SEL           46
+#define IMX6SL_CLK_PXP_AXI_SEL          47
+#define IMX6SL_CLK_EPDC_AXI_SEL         48
+#define IMX6SL_CLK_GPU2D_OVG_SEL        49
+#define IMX6SL_CLK_GPU2D_SEL            50
+#define IMX6SL_CLK_LCDIF_PIX_SEL        51
+#define IMX6SL_CLK_EPDC_PIX_SEL         52
+#define IMX6SL_CLK_SPDIF0_SEL           53
+#define IMX6SL_CLK_SPDIF1_SEL           54
+#define IMX6SL_CLK_EXTERN_AUDIO_SEL     55
+#define IMX6SL_CLK_ECSPI_SEL            56
+#define IMX6SL_CLK_UART_SEL             57
+#define IMX6SL_CLK_PERIPH               58
+#define IMX6SL_CLK_PERIPH2              59
+#define IMX6SL_CLK_OCRAM_PODF           60
+#define IMX6SL_CLK_PERIPH_CLK2_PODF     61
+#define IMX6SL_CLK_PERIPH2_CLK2_PODF    62
+#define IMX6SL_CLK_IPG                  63
+#define IMX6SL_CLK_CSI_PODF             64
+#define IMX6SL_CLK_LCDIF_AXI_PODF       65
+#define IMX6SL_CLK_USDHC1_PODF          66
+#define IMX6SL_CLK_USDHC2_PODF          67
+#define IMX6SL_CLK_USDHC3_PODF          68
+#define IMX6SL_CLK_USDHC4_PODF          69
+#define IMX6SL_CLK_SSI1_PRED            70
+#define IMX6SL_CLK_SSI1_PODF            71
+#define IMX6SL_CLK_SSI2_PRED            72
+#define IMX6SL_CLK_SSI2_PODF            73
+#define IMX6SL_CLK_SSI3_PRED            74
+#define IMX6SL_CLK_SSI3_PODF            75
+#define IMX6SL_CLK_PERCLK               76
+#define IMX6SL_CLK_PXP_AXI_PODF         77
+#define IMX6SL_CLK_EPDC_AXI_PODF        78
+#define IMX6SL_CLK_GPU2D_OVG_PODF       79
+#define IMX6SL_CLK_GPU2D_PODF           80
+#define IMX6SL_CLK_LCDIF_PIX_PRED       81
+#define IMX6SL_CLK_EPDC_PIX_PRED        82
+#define IMX6SL_CLK_LCDIF_PIX_PODF       83
+#define IMX6SL_CLK_EPDC_PIX_PODF        84
+#define IMX6SL_CLK_SPDIF0_PRED          85
+#define IMX6SL_CLK_SPDIF0_PODF          86
+#define IMX6SL_CLK_SPDIF1_PRED          87
+#define IMX6SL_CLK_SPDIF1_PODF          88
+#define IMX6SL_CLK_EXTERN_AUDIO_PRED    89
+#define IMX6SL_CLK_EXTERN_AUDIO_PODF    90
+#define IMX6SL_CLK_ECSPI_ROOT           91
+#define IMX6SL_CLK_UART_ROOT            92
+#define IMX6SL_CLK_AHB                  93
+#define IMX6SL_CLK_MMDC_ROOT            94
+#define IMX6SL_CLK_ARM                  95
+#define IMX6SL_CLK_ECSPI1               96
+#define IMX6SL_CLK_ECSPI2               97
+#define IMX6SL_CLK_ECSPI3               98
+#define IMX6SL_CLK_ECSPI4               99
+#define IMX6SL_CLK_EPIT1                100
+#define IMX6SL_CLK_EPIT2                101
+#define IMX6SL_CLK_EXTERN_AUDIO         102
+#define IMX6SL_CLK_GPT                  103
+#define IMX6SL_CLK_GPT_SERIAL           104
+#define IMX6SL_CLK_GPU2D_OVG            105
+#define IMX6SL_CLK_I2C1                 106
+#define IMX6SL_CLK_I2C2                 107
+#define IMX6SL_CLK_I2C3                 108
+#define IMX6SL_CLK_OCOTP                109
+#define IMX6SL_CLK_CSI                  110
+#define IMX6SL_CLK_PXP_AXI              111
+#define IMX6SL_CLK_EPDC_AXI             112
+#define IMX6SL_CLK_LCDIF_AXI            113
+#define IMX6SL_CLK_LCDIF_PIX            114
+#define IMX6SL_CLK_EPDC_PIX             115
+#define IMX6SL_CLK_OCRAM                116
+#define IMX6SL_CLK_PWM1                 117
+#define IMX6SL_CLK_PWM2                 118
+#define IMX6SL_CLK_PWM3                 119
+#define IMX6SL_CLK_PWM4                 120
+#define IMX6SL_CLK_SDMA                 121
+#define IMX6SL_CLK_SPDIF                122
+#define IMX6SL_CLK_SSI1                 123
+#define IMX6SL_CLK_SSI2                 124
+#define IMX6SL_CLK_SSI3                 125
+#define IMX6SL_CLK_UART                 126
+#define IMX6SL_CLK_UART_SERIAL          127
+#define IMX6SL_CLK_USBOH3               128
+#define IMX6SL_CLK_USDHC1               129
+#define IMX6SL_CLK_USDHC2               130
+#define IMX6SL_CLK_USDHC3               131
+#define IMX6SL_CLK_USDHC4               132
+#define IMX6SL_CLK_CLK_END              133
+
+#endif /* __DT_BINDINGS_CLOCK_IMX6SL_H */
diff --git a/include/dt-bindings/clock/tegra114-car.h b/include/dt-bindings/clock/tegra114-car.h
new file mode 100644
index 000000000000..614aec417902
--- /dev/null
+++ b/include/dt-bindings/clock/tegra114-car.h
@@ -0,0 +1,342 @@
+/*
+ * This header provides constants for binding nvidia,tegra114-car.
+ *
+ * The first 160 clocks are numbered to match the bits in the CAR's CLK_OUT_ENB
+ * registers. These IDs often match those in the CAR's RST_DEVICES registers,
+ * but not in all cases. Some bits in CLK_OUT_ENB affect multiple clocks. In
+ * this case, those clocks are assigned IDs above 160 in order to highlight
+ * this issue. Implementations that interpret these clock IDs as bit values
+ * within the CLK_OUT_ENB or RST_DEVICES registers should be careful to
+ * explicitly handle these special cases.
+ *
+ * The balance of the clocks controlled by the CAR are assigned IDs of 160 and
+ * above.
+ */
+
+#ifndef _DT_BINDINGS_CLOCK_TEGRA114_CAR_H
+#define _DT_BINDINGS_CLOCK_TEGRA114_CAR_H
+
+/* 0 */
+/* 1 */
+/* 2 */
+/* 3 */
+#define TEGRA114_CLK_RTC 4
+#define TEGRA114_CLK_TIMER 5
+#define TEGRA114_CLK_UARTA 6
+/* 7 (register bit affects uartb and vfir) */
+/* 8 */
+#define TEGRA114_CLK_SDMMC2 9
+/* 10 (register bit affects spdif_in and spdif_out) */
+#define TEGRA114_CLK_I2S1 11
+#define TEGRA114_CLK_I2C1 12
+#define TEGRA114_CLK_NDFLASH 13
+#define TEGRA114_CLK_SDMMC1 14
+#define TEGRA114_CLK_SDMMC4 15
+/* 16 */
+#define TEGRA114_CLK_PWM 17
+#define TEGRA114_CLK_I2S2 18
+#define TEGRA114_CLK_EPP 19
+/* 20 (register bit affects vi and vi_sensor) */
+#define TEGRA114_CLK_GR_2D 21
+#define TEGRA114_CLK_USBD 22
+#define TEGRA114_CLK_ISP 23
+#define TEGRA114_CLK_GR_3D 24
+/* 25 */
+#define TEGRA114_CLK_DISP2 26
+#define TEGRA114_CLK_DISP1 27
+#define TEGRA114_CLK_HOST1X 28
+#define TEGRA114_CLK_VCP 29
+#define TEGRA114_CLK_I2S0 30
+/* 31 */
+
+/* 32 */
+/* 33 */
+#define TEGRA114_CLK_APBDMA 34
+/* 35 */
+#define TEGRA114_CLK_KBC 36
+/* 37 */
+/* 38 */
+/* 39 (register bit affects fuse and fuse_burn) */
+#define TEGRA114_CLK_KFUSE 40
+#define TEGRA114_CLK_SBC1 41
+#define TEGRA114_CLK_NOR 42
+/* 43 */
+#define TEGRA114_CLK_SBC2 44
+/* 45 */
+#define TEGRA114_CLK_SBC3 46
+#define TEGRA114_CLK_I2C5 47
+#define TEGRA114_CLK_DSIA 48
+/* 49 */
+#define TEGRA114_CLK_MIPI 50
+#define TEGRA114_CLK_HDMI 51
+#define TEGRA114_CLK_CSI 52
+/* 53 */
+#define TEGRA114_CLK_I2C2 54
+#define TEGRA114_CLK_UARTC 55
+#define TEGRA114_CLK_MIPI_CAL 56
+#define TEGRA114_CLK_EMC 57
+#define TEGRA114_CLK_USB2 58
+#define TEGRA114_CLK_USB3 59
+/* 60 */
+#define TEGRA114_CLK_VDE 61
+#define TEGRA114_CLK_BSEA 62
+#define TEGRA114_CLK_BSEV 63
+
+/* 64 */
+#define TEGRA114_CLK_UARTD 65
+/* 66 */
+#define TEGRA114_CLK_I2C3 67
+#define TEGRA114_CLK_SBC4 68
+#define TEGRA114_CLK_SDMMC3 69
+/* 70 */
+#define TEGRA114_CLK_OWR 71
+/* 72 */
+#define TEGRA114_CLK_CSITE 73
+/* 74 */
+/* 75 */
+#define TEGRA114_CLK_LA 76
+#define TEGRA114_CLK_TRACE 77
+#define TEGRA114_CLK_SOC_THERM 78
+#define TEGRA114_CLK_DTV 79
+#define TEGRA114_CLK_NDSPEED 80
+#define TEGRA114_CLK_I2CSLOW 81
+#define TEGRA114_CLK_DSIB 82
+#define TEGRA114_CLK_TSEC 83
+/* 84 */
+/* 85 */
+/* 86 */
+/* 87 */
+/* 88 */
+#define TEGRA114_CLK_XUSB_HOST 89
+/* 90 */
+#define TEGRA114_CLK_MSENC 91
+#define TEGRA114_CLK_CSUS 92
+/* 93 */
+/* 94 */
+/* 95 (bit affects xusb_dev and xusb_dev_src) */
+
+/* 96 */
+/* 97 */
+/* 98 */
+#define TEGRA114_CLK_MSELECT 99
+#define TEGRA114_CLK_TSENSOR 100
+#define TEGRA114_CLK_I2S3 101
+#define TEGRA114_CLK_I2S4 102
+#define TEGRA114_CLK_I2C4 103
+#define TEGRA114_CLK_SBC5 104
+#define TEGRA114_CLK_SBC6 105
+#define TEGRA114_CLK_D_AUDIO 106
+#define TEGRA114_CLK_APBIF 107
+#define TEGRA114_CLK_DAM0 108
+#define TEGRA114_CLK_DAM1 109
+#define TEGRA114_CLK_DAM2 110
+#define TEGRA114_CLK_HDA2CODEC_2X 111
+/* 112 */
+#define TEGRA114_CLK_AUDIO0_2X 113
+#define TEGRA114_CLK_AUDIO1_2X 114
+#define TEGRA114_CLK_AUDIO2_2X 115
+#define TEGRA114_CLK_AUDIO3_2X 116
+#define TEGRA114_CLK_AUDIO4_2X 117
+#define TEGRA114_CLK_SPDIF_2X 118
+#define TEGRA114_CLK_ACTMON 119
+#define TEGRA114_CLK_EXTERN1 120
+#define TEGRA114_CLK_EXTERN2 121
+#define TEGRA114_CLK_EXTERN3 122
+/* 123 */
+/* 124 */
+#define TEGRA114_CLK_HDA 125
+/* 126 */
+#define TEGRA114_CLK_SE 127
+
+#define TEGRA114_CLK_HDA2HDMI 128
+/* 129 */
+/* 130 */
+/* 131 */
+/* 132 */
+/* 133 */
+/* 134 */
+/* 135 */
+/* 136 */
+/* 137 */
+/* 138 */
+/* 139 */
+/* 140 */
+/* 141 */
+/* 142 */
+/* 143 (bit affects xusb_falcon_src, xusb_fs_src, */
+/*      xusb_host_src and xusb_ss_src) */
+#define TEGRA114_CLK_CILAB 144
+#define TEGRA114_CLK_CILCD 145
+#define TEGRA114_CLK_CILE 146
+#define TEGRA114_CLK_DSIALP 147
+#define TEGRA114_CLK_DSIBLP 148
+/* 149 */
+#define TEGRA114_CLK_DDS 150
+/* 151 */
+#define TEGRA114_CLK_DP2 152
+#define TEGRA114_CLK_AMX 153
+#define TEGRA114_CLK_ADX 154
+/* 155 (bit affects dfll_ref and dfll_soc) */
+#define TEGRA114_CLK_XUSB_SS 156
+/* 157 */
+/* 158 */
+/* 159 */
+
+/* 160 */
+/* 161 */
+/* 162 */
+/* 163 */
+/* 164 */
+/* 165 */
+/* 166 */
+/* 167 */
+/* 168 */
+/* 169 */
+/* 170 */
+/* 171 */
+/* 172 */
+/* 173 */
+/* 174 */
+/* 175 */
+/* 176 */
+/* 177 */
+/* 178 */
+/* 179 */
+/* 180 */
+/* 181 */
+/* 182 */
+/* 183 */
+/* 184 */
+/* 185 */
+/* 186 */
+/* 187 */
+/* 188 */
+/* 189 */
+/* 190 */
+/* 191 */
+
+#define TEGRA114_CLK_UARTB 192
+#define TEGRA114_CLK_VFIR 193
+#define TEGRA114_CLK_SPDIF_IN 194
+#define TEGRA114_CLK_SPDIF_OUT 195
+#define TEGRA114_CLK_VI 196
+#define TEGRA114_CLK_VI_SENSOR 197
+#define TEGRA114_CLK_FUSE 198
+#define TEGRA114_CLK_FUSE_BURN 199
+#define TEGRA114_CLK_CLK_32K 200
+#define TEGRA114_CLK_CLK_M 201
+#define TEGRA114_CLK_CLK_M_DIV2 202
+#define TEGRA114_CLK_CLK_M_DIV4 203
+#define TEGRA114_CLK_PLL_REF 204
+#define TEGRA114_CLK_PLL_C 205
+#define TEGRA114_CLK_PLL_C_OUT1 206
+#define TEGRA114_CLK_PLL_C2 207
+#define TEGRA114_CLK_PLL_C3 208
+#define TEGRA114_CLK_PLL_M 209
+#define TEGRA114_CLK_PLL_M_OUT1 210
+#define TEGRA114_CLK_PLL_P 211
+#define TEGRA114_CLK_PLL_P_OUT1 212
+#define TEGRA114_CLK_PLL_P_OUT2 213
+#define TEGRA114_CLK_PLL_P_OUT3 214
+#define TEGRA114_CLK_PLL_P_OUT4 215
+#define TEGRA114_CLK_PLL_A 216
+#define TEGRA114_CLK_PLL_A_OUT0 217
+#define TEGRA114_CLK_PLL_D 218
+#define TEGRA114_CLK_PLL_D_OUT0 219
+#define TEGRA114_CLK_PLL_D2 220
+#define TEGRA114_CLK_PLL_D2_OUT0 221
+#define TEGRA114_CLK_PLL_U 222
+#define TEGRA114_CLK_PLL_U_480M 223
+
+#define TEGRA114_CLK_PLL_U_60M 224
+#define TEGRA114_CLK_PLL_U_48M 225
+#define TEGRA114_CLK_PLL_U_12M 226
+#define TEGRA114_CLK_PLL_X 227
+#define TEGRA114_CLK_PLL_X_OUT0 228
+#define TEGRA114_CLK_PLL_RE_VCO 229
+#define TEGRA114_CLK_PLL_RE_OUT 230
+#define TEGRA114_CLK_PLL_E_OUT0 231
+#define TEGRA114_CLK_SPDIF_IN_SYNC 232
+#define TEGRA114_CLK_I2S0_SYNC 233
+#define TEGRA114_CLK_I2S1_SYNC 234
+#define TEGRA114_CLK_I2S2_SYNC 235
+#define TEGRA114_CLK_I2S3_SYNC 236
+#define TEGRA114_CLK_I2S4_SYNC 237
+#define TEGRA114_CLK_VIMCLK_SYNC 238
+#define TEGRA114_CLK_AUDIO0 239
+#define TEGRA114_CLK_AUDIO1 240
+#define TEGRA114_CLK_AUDIO2 241
+#define TEGRA114_CLK_AUDIO3 242
+#define TEGRA114_CLK_AUDIO4 243
+#define TEGRA114_CLK_SPDIF 244
+#define TEGRA114_CLK_CLK_OUT_1 245
+#define TEGRA114_CLK_CLK_OUT_2 246
+#define TEGRA114_CLK_CLK_OUT_3 247
+#define TEGRA114_CLK_BLINK 248
+/* 249 */
+/* 250 */
+/* 251 */
+#define TEGRA114_CLK_XUSB_HOST_SRC 252
+#define TEGRA114_CLK_XUSB_FALCON_SRC 253
+#define TEGRA114_CLK_XUSB_FS_SRC 254
+#define TEGRA114_CLK_XUSB_SS_SRC 255
+
+#define TEGRA114_CLK_XUSB_DEV_SRC 256
+#define TEGRA114_CLK_XUSB_DEV 257
+#define TEGRA114_CLK_XUSB_HS_SRC 258
+#define TEGRA114_CLK_SCLK 259
+#define TEGRA114_CLK_HCLK 260
+#define TEGRA114_CLK_PCLK 261
+#define TEGRA114_CLK_CCLK_G 262
+#define TEGRA114_CLK_CCLK_LP 263
+/* 264 */
+/* 265 */
+/* 266 */
+/* 267 */
+/* 268 */
+/* 269 */
+/* 270 */
+/* 271 */
+/* 272 */
+/* 273 */
+/* 274 */
+/* 275 */
+/* 276 */
+/* 277 */
+/* 278 */
+/* 279 */
+/* 280 */
+/* 281 */
+/* 282 */
+/* 283 */
+/* 284 */
+/* 285 */
+/* 286 */
+/* 287 */
+
+/* 288 */
+/* 289 */
+/* 290 */
+/* 291 */
+/* 292 */
+/* 293 */
+/* 294 */
+/* 295 */
+/* 296 */
+/* 297 */
+/* 298 */
+/* 299 */
+#define TEGRA114_CLK_AUDIO0_MUX 300
+#define TEGRA114_CLK_AUDIO1_MUX 301
+#define TEGRA114_CLK_AUDIO2_MUX 302
+#define TEGRA114_CLK_AUDIO3_MUX 303
+#define TEGRA114_CLK_AUDIO4_MUX 304
+#define TEGRA114_CLK_SPDIF_MUX 305
+#define TEGRA114_CLK_CLK_OUT_1_MUX 306
+#define TEGRA114_CLK_CLK_OUT_2_MUX 307
+#define TEGRA114_CLK_CLK_OUT_3_MUX 308
+#define TEGRA114_CLK_DSIA_MUX 309
+#define TEGRA114_CLK_DSIB_MUX 310
+#define TEGRA114_CLK_CLK_MAX 311
+
+#endif  /* _DT_BINDINGS_CLOCK_TEGRA114_CAR_H */
diff --git a/include/dt-bindings/clock/tegra20-car.h b/include/dt-bindings/clock/tegra20-car.h
new file mode 100644
index 000000000000..a1ae9a8fdd6c
--- /dev/null
+++ b/include/dt-bindings/clock/tegra20-car.h
@@ -0,0 +1,158 @@
+/*
+ * This header provides constants for binding nvidia,tegra20-car.
+ *
+ * The first 96 clocks are numbered to match the bits in the CAR's CLK_OUT_ENB
+ * registers. These IDs often match those in the CAR's RST_DEVICES registers,
+ * but not in all cases. Some bits in CLK_OUT_ENB affect multiple clocks. In
+ * this case, those clocks are assigned IDs above 95 in order to highlight
+ * this issue. Implementations that interpret these clock IDs as bit values
+ * within the CLK_OUT_ENB or RST_DEVICES registers should be careful to
+ * explicitly handle these special cases.
+ *
+ * The balance of the clocks controlled by the CAR are assigned IDs of 96 and
+ * above.
+ */
+
+#ifndef _DT_BINDINGS_CLOCK_TEGRA20_CAR_H
+#define _DT_BINDINGS_CLOCK_TEGRA20_CAR_H
+
+#define TEGRA20_CLK_CPU 0
+/* 1 */
+/* 2 */
+#define TEGRA20_CLK_AC97 3
+#define TEGRA20_CLK_RTC 4
+#define TEGRA20_CLK_TIMER 5
+#define TEGRA20_CLK_UARTA 6
+/* 7 (register bit affects uart2 and vfir) */
+#define TEGRA20_CLK_GPIO 8
+#define TEGRA20_CLK_SDMMC2 9
+/* 10 (register bit affects spdif_in and spdif_out) */
+#define TEGRA20_CLK_I2S1 11
+#define TEGRA20_CLK_I2C1 12
+#define TEGRA20_CLK_NDFLASH 13
+#define TEGRA20_CLK_SDMMC1 14
+#define TEGRA20_CLK_SDMMC4 15
+#define TEGRA20_CLK_TWC 16
+#define TEGRA20_CLK_PWM 17
+#define TEGRA20_CLK_I2S2 18
+#define TEGRA20_CLK_EPP 19
+/* 20 (register bit affects vi and vi_sensor) */
+#define TEGRA20_CLK_GR2D 21
+#define TEGRA20_CLK_USBD 22
+#define TEGRA20_CLK_ISP 23
+#define TEGRA20_CLK_GR3D 24
+#define TEGRA20_CLK_IDE 25
+#define TEGRA20_CLK_DISP2 26
+#define TEGRA20_CLK_DISP1 27
+#define TEGRA20_CLK_HOST1X 28
+#define TEGRA20_CLK_VCP 29
+/* 30 */
+#define TEGRA20_CLK_CACHE2 31
+
+#define TEGRA20_CLK_MEM 32
+#define TEGRA20_CLK_AHBDMA 33
+#define TEGRA20_CLK_APBDMA 34
+/* 35 */
+#define TEGRA20_CLK_KBC 36
+#define TEGRA20_CLK_STAT_MON 37
+#define TEGRA20_CLK_PMC 38
+#define TEGRA20_CLK_FUSE 39
+#define TEGRA20_CLK_KFUSE 40
+#define TEGRA20_CLK_SBC1 41
+#define TEGRA20_CLK_NOR 42
+#define TEGRA20_CLK_SPI 43
+#define TEGRA20_CLK_SBC2 44
+#define TEGRA20_CLK_XIO 45
+#define TEGRA20_CLK_SBC3 46
+#define TEGRA20_CLK_DVC 47
+#define TEGRA20_CLK_DSI 48
+/* 49 (register bit affects tvo and cve) */
+#define TEGRA20_CLK_MIPI 50
+#define TEGRA20_CLK_HDMI 51
+#define TEGRA20_CLK_CSI 52
+#define TEGRA20_CLK_TVDAC 53
+#define TEGRA20_CLK_I2C2 54
+#define TEGRA20_CLK_UARTC 55
+/* 56 */
+#define TEGRA20_CLK_EMC 57
+#define TEGRA20_CLK_USB2 58
+#define TEGRA20_CLK_USB3 59
+#define TEGRA20_CLK_MPE 60
+#define TEGRA20_CLK_VDE 61
+#define TEGRA20_CLK_BSEA 62
+#define TEGRA20_CLK_BSEV 63
+
+#define TEGRA20_CLK_SPEEDO 64
+#define TEGRA20_CLK_UARTD 65
+#define TEGRA20_CLK_UARTE 66
+#define TEGRA20_CLK_I2C3 67
+#define TEGRA20_CLK_SBC4 68
+#define TEGRA20_CLK_SDMMC3 69
+#define TEGRA20_CLK_PEX 70
+#define TEGRA20_CLK_OWR 71
+#define TEGRA20_CLK_AFI 72
+#define TEGRA20_CLK_CSITE 73
+#define TEGRA20_CLK_PCIE_XCLK 74
+#define TEGRA20_CLK_AVPUCQ 75
+#define TEGRA20_CLK_LA 76
+/* 77 */
+/* 78 */
+/* 79 */
+/* 80 */
+/* 81 */
+/* 82 */
+/* 83 */
+#define TEGRA20_CLK_IRAMA 84
+#define TEGRA20_CLK_IRAMB 85
+#define TEGRA20_CLK_IRAMC 86
+#define TEGRA20_CLK_IRAMD 87
+#define TEGRA20_CLK_CRAM2 88
+#define TEGRA20_CLK_AUDIO_2X 89 /* a/k/a audio_2x_sync_clk */
+#define TEGRA20_CLK_CLK_D 90
+/* 91 */
+#define TEGRA20_CLK_CSUS 92
+#define TEGRA20_CLK_CDEV2 93
+#define TEGRA20_CLK_CDEV1 94
+/* 95 */
+
+#define TEGRA20_CLK_UARTB 96
+#define TEGRA20_CLK_VFIR 97
+#define TEGRA20_CLK_SPDIF_IN 98
+#define TEGRA20_CLK_SPDIF_OUT 99
+#define TEGRA20_CLK_VI 100
+#define TEGRA20_CLK_VI_SENSOR 101
+#define TEGRA20_CLK_TVO 102
+#define TEGRA20_CLK_CVE 103
+#define TEGRA20_CLK_OSC 104
+#define TEGRA20_CLK_CLK_32K 105 /* a/k/a clk_s */
+#define TEGRA20_CLK_CLK_M 106
+#define TEGRA20_CLK_SCLK 107
+#define TEGRA20_CLK_CCLK 108
+#define TEGRA20_CLK_HCLK 109
+#define TEGRA20_CLK_PCLK 110
+#define TEGRA20_CLK_BLINK 111
+#define TEGRA20_CLK_PLL_A 112
+#define TEGRA20_CLK_PLL_A_OUT0 113
+#define TEGRA20_CLK_PLL_C 114
+#define TEGRA20_CLK_PLL_C_OUT1 115
+#define TEGRA20_CLK_PLL_D 116
+#define TEGRA20_CLK_PLL_D_OUT0 117
+#define TEGRA20_CLK_PLL_E 118
+#define TEGRA20_CLK_PLL_M 119
+#define TEGRA20_CLK_PLL_M_OUT1 120
+#define TEGRA20_CLK_PLL_P 121
+#define TEGRA20_CLK_PLL_P_OUT1 122
+#define TEGRA20_CLK_PLL_P_OUT2 123
+#define TEGRA20_CLK_PLL_P_OUT3 124
+#define TEGRA20_CLK_PLL_P_OUT4 125
+#define TEGRA20_CLK_PLL_S 126
+#define TEGRA20_CLK_PLL_U 127
+
+#define TEGRA20_CLK_PLL_X 128
+#define TEGRA20_CLK_COP 129 /* a/k/a avp */
+#define TEGRA20_CLK_AUDIO 130 /* a/k/a audio_sync_clk */
+#define TEGRA20_CLK_PLL_REF 131
+#define TEGRA20_CLK_TWD 132
+#define TEGRA20_CLK_CLK_MAX 133
+
+#endif  /* _DT_BINDINGS_CLOCK_TEGRA20_CAR_H */
diff --git a/include/dt-bindings/clock/tegra30-car.h b/include/dt-bindings/clock/tegra30-car.h
new file mode 100644
index 000000000000..e40fae8f9a8d
--- /dev/null
+++ b/include/dt-bindings/clock/tegra30-car.h
@@ -0,0 +1,265 @@
+/*
+ * This header provides constants for binding nvidia,tegra30-car.
+ *
+ * The first 130 clocks are numbered to match the bits in the CAR's CLK_OUT_ENB
+ * registers. These IDs often match those in the CAR's RST_DEVICES registers,
+ * but not in all cases. Some bits in CLK_OUT_ENB affect multiple clocks. In
+ * this case, those clocks are assigned IDs above 160 in order to highlight
+ * this issue. Implementations that interpret these clock IDs as bit values
+ * within the CLK_OUT_ENB or RST_DEVICES registers should be careful to
+ * explicitly handle these special cases.
+ *
+ * The balance of the clocks controlled by the CAR are assigned IDs of 160 and
+ * above.
+ */
+
+#ifndef _DT_BINDINGS_CLOCK_TEGRA30_CAR_H
+#define _DT_BINDINGS_CLOCK_TEGRA30_CAR_H
+
+#define TEGRA30_CLK_CPU 0
+/* 1 */
+/* 2 */
+/* 3 */
+#define TEGRA30_CLK_RTC 4
+#define TEGRA30_CLK_TIMER 5
+#define TEGRA30_CLK_UARTA 6
+/* 7 (register bit affects uartb and vfir) */
+#define TEGRA30_CLK_GPIO 8
+#define TEGRA30_CLK_SDMMC2 9
+/* 10 (register bit affects spdif_in and spdif_out) */
+#define TEGRA30_CLK_I2S1 11
+#define TEGRA30_CLK_I2C1 12
+#define TEGRA30_CLK_NDFLASH 13
+#define TEGRA30_CLK_SDMMC1 14
+#define TEGRA30_CLK_SDMMC4 15
+/* 16 */
+#define TEGRA30_CLK_PWM 17
+#define TEGRA30_CLK_I2S2 18
+#define TEGRA30_CLK_EPP 19
+/* 20 (register bit affects vi and vi_sensor) */
+#define TEGRA30_CLK_GR2D 21
+#define TEGRA30_CLK_USBD 22
+#define TEGRA30_CLK_ISP 23
+#define TEGRA30_CLK_GR3D 24
+/* 25 */
+#define TEGRA30_CLK_DISP2 26
+#define TEGRA30_CLK_DISP1 27
+#define TEGRA30_CLK_HOST1X 28
+#define TEGRA30_CLK_VCP 29
+#define TEGRA30_CLK_I2S0 30
+#define TEGRA30_CLK_COP_CACHE 31
+
+#define TEGRA30_CLK_MC 32
+#define TEGRA30_CLK_AHBDMA 33
+#define TEGRA30_CLK_APBDMA 34
+/* 35 */
+#define TEGRA30_CLK_KBC 36
+#define TEGRA30_CLK_STATMON 37
+#define TEGRA30_CLK_PMC 38
+/* 39 (register bit affects fuse and fuse_burn) */
+#define TEGRA30_CLK_KFUSE 40
+#define TEGRA30_CLK_SBC1 41
+#define TEGRA30_CLK_NOR 42
+/* 43 */
+#define TEGRA30_CLK_SBC2 44
+/* 45 */
+#define TEGRA30_CLK_SBC3 46
+#define TEGRA30_CLK_I2C5 47
+#define TEGRA30_CLK_DSIA 48
+/* 49 (register bit affects cve and tvo) */
+#define TEGRA30_CLK_MIPI 50
+#define TEGRA30_CLK_HDMI 51
+#define TEGRA30_CLK_CSI 52
+#define TEGRA30_CLK_TVDAC 53
+#define TEGRA30_CLK_I2C2 54
+#define TEGRA30_CLK_UARTC 55
+/* 56 */
+#define TEGRA30_CLK_EMC 57
+#define TEGRA30_CLK_USB2 58
+#define TEGRA30_CLK_USB3 59
+#define TEGRA30_CLK_MPE 60
+#define TEGRA30_CLK_VDE 61
+#define TEGRA30_CLK_BSEA 62
+#define TEGRA30_CLK_BSEV 63
+
+#define TEGRA30_CLK_SPEEDO 64
+#define TEGRA30_CLK_UARTD 65
+#define TEGRA30_CLK_UARTE 66
+#define TEGRA30_CLK_I2C3 67
+#define TEGRA30_CLK_SBC4 68
+#define TEGRA30_CLK_SDMMC3 69
+#define TEGRA30_CLK_PCIE 70
+#define TEGRA30_CLK_OWR 71
+#define TEGRA30_CLK_AFI 72
+#define TEGRA30_CLK_CSITE 73
+#define TEGRA30_CLK_PCIEX 74
+#define TEGRA30_CLK_AVPUCQ 75
+#define TEGRA30_CLK_LA 76
+/* 77 */
+/* 78 */
+#define TEGRA30_CLK_DTV 79
+#define TEGRA30_CLK_NDSPEED 80
+#define TEGRA30_CLK_I2CSLOW 81
+#define TEGRA30_CLK_DSIB 82
+/* 83 */
+#define TEGRA30_CLK_IRAMA 84
+#define TEGRA30_CLK_IRAMB 85
+#define TEGRA30_CLK_IRAMC 86
+#define TEGRA30_CLK_IRAMD 87
+#define TEGRA30_CLK_CRAM2 88
+/* 89 */
+#define TEGRA30_CLK_AUDIO_2X 90 /* a/k/a audio_2x_sync_clk */
+/* 91 */
+#define TEGRA30_CLK_CSUS 92
+#define TEGRA30_CLK_CDEV2 93
+#define TEGRA30_CLK_CDEV1 94
+/* 95 */
+
+#define TEGRA30_CLK_CPU_G 96
+#define TEGRA30_CLK_CPU_LP 97
+#define TEGRA30_CLK_GR3D2 98
+#define TEGRA30_CLK_MSELECT 99
+#define TEGRA30_CLK_TSENSOR 100
+#define TEGRA30_CLK_I2S3 101
+#define TEGRA30_CLK_I2S4 102
+#define TEGRA30_CLK_I2C4 103
+#define TEGRA30_CLK_SBC5 104
+#define TEGRA30_CLK_SBC6 105
+#define TEGRA30_CLK_D_AUDIO 106
+#define TEGRA30_CLK_APBIF 107
+#define TEGRA30_CLK_DAM0 108
+#define TEGRA30_CLK_DAM1 109
+#define TEGRA30_CLK_DAM2 110
+#define TEGRA30_CLK_HDA2CODEC_2X 111
+#define TEGRA30_CLK_ATOMICS 112
+#define TEGRA30_CLK_AUDIO0_2X 113
+#define TEGRA30_CLK_AUDIO1_2X 114
+#define TEGRA30_CLK_AUDIO2_2X 115
+#define TEGRA30_CLK_AUDIO3_2X 116
+#define TEGRA30_CLK_AUDIO4_2X 117
+#define TEGRA30_CLK_SPDIF_2X 118
+#define TEGRA30_CLK_ACTMON 119
+#define TEGRA30_CLK_EXTERN1 120
+#define TEGRA30_CLK_EXTERN2 121
+#define TEGRA30_CLK_EXTERN3 122
+#define TEGRA30_CLK_SATA_OOB 123
+#define TEGRA30_CLK_SATA 124
+#define TEGRA30_CLK_HDA 125
+/* 126 */
+#define TEGRA30_CLK_SE 127
+
+#define TEGRA30_CLK_HDA2HDMI 128
+#define TEGRA30_CLK_SATA_COLD 129
+/* 130 */
+/* 131 */
+/* 132 */
+/* 133 */
+/* 134 */
+/* 135 */
+/* 136 */
+/* 137 */
+/* 138 */
+/* 139 */
+/* 140 */
+/* 141 */
+/* 142 */
+/* 143 */
+/* 144 */
+/* 145 */
+/* 146 */
+/* 147 */
+/* 148 */
+/* 149 */
+/* 150 */
+/* 151 */
+/* 152 */
+/* 153 */
+/* 154 */
+/* 155 */
+/* 156 */
+/* 157 */
+/* 158 */
+/* 159 */
+
+#define TEGRA30_CLK_UARTB 160
+#define TEGRA30_CLK_VFIR 161
+#define TEGRA30_CLK_SPDIF_IN 162
+#define TEGRA30_CLK_SPDIF_OUT 163
+#define TEGRA30_CLK_VI 164
+#define TEGRA30_CLK_VI_SENSOR 165
+#define TEGRA30_CLK_FUSE 166
+#define TEGRA30_CLK_FUSE_BURN 167
+#define TEGRA30_CLK_CVE 168
+#define TEGRA30_CLK_TVO 169
+#define TEGRA30_CLK_CLK_32K 170
+#define TEGRA30_CLK_CLK_M 171
+#define TEGRA30_CLK_CLK_M_DIV2 172
+#define TEGRA30_CLK_CLK_M_DIV4 173
+#define TEGRA30_CLK_PLL_REF 174
+#define TEGRA30_CLK_PLL_C 175
+#define TEGRA30_CLK_PLL_C_OUT1 176
+#define TEGRA30_CLK_PLL_M 177
+#define TEGRA30_CLK_PLL_M_OUT1 178
+#define TEGRA30_CLK_PLL_P 179
+#define TEGRA30_CLK_PLL_P_OUT1 180
+#define TEGRA30_CLK_PLL_P_OUT2 181
+#define TEGRA30_CLK_PLL_P_OUT3 182
+#define TEGRA30_CLK_PLL_P_OUT4 183
+#define TEGRA30_CLK_PLL_A 184
+#define TEGRA30_CLK_PLL_A_OUT0 185
+#define TEGRA30_CLK_PLL_D 186
+#define TEGRA30_CLK_PLL_D_OUT0 187
+#define TEGRA30_CLK_PLL_D2 188
+#define TEGRA30_CLK_PLL_D2_OUT0 189
+#define TEGRA30_CLK_PLL_U 190
+#define TEGRA30_CLK_PLL_X 191
+
+#define TEGRA30_CLK_PLL_X_OUT0 192
+#define TEGRA30_CLK_PLL_E 193
+#define TEGRA30_CLK_SPDIF_IN_SYNC 194
+#define TEGRA30_CLK_I2S0_SYNC 195
+#define TEGRA30_CLK_I2S1_SYNC 196
+#define TEGRA30_CLK_I2S2_SYNC 197
+#define TEGRA30_CLK_I2S3_SYNC 198
+#define TEGRA30_CLK_I2S4_SYNC 199
+#define TEGRA30_CLK_VIMCLK_SYNC 200
+#define TEGRA30_CLK_AUDIO0 201
+#define TEGRA30_CLK_AUDIO1 202
+#define TEGRA30_CLK_AUDIO2 203
+#define TEGRA30_CLK_AUDIO3 204
+#define TEGRA30_CLK_AUDIO4 205
+#define TEGRA30_CLK_SPDIF 206
+#define TEGRA30_CLK_CLK_OUT_1 207 /* (extern1) */
+#define TEGRA30_CLK_CLK_OUT_2 208 /* (extern2) */
+#define TEGRA30_CLK_CLK_OUT_3 209 /* (extern3) */
+#define TEGRA30_CLK_SCLK 210
+#define TEGRA30_CLK_BLINK 211
+#define TEGRA30_CLK_CCLK_G 212
+#define TEGRA30_CLK_CCLK_LP 213
+#define TEGRA30_CLK_TWD 214
+#define TEGRA30_CLK_CML0 215
+#define TEGRA30_CLK_CML1 216
+#define TEGRA30_CLK_HCLK 217
+#define TEGRA30_CLK_PCLK 218
+/* 219 */
+/* 220 */
+/* 221 */
+/* 222 */
+/* 223 */
+
+/* 288 */
+/* 289 */
+/* 290 */
+/* 291 */
+/* 292 */
+/* 293 */
+/* 294 */
+/* 295 */
+/* 296 */
+/* 297 */
+/* 298 */
+/* 299 */
+#define TEGRA30_CLK_CLK_OUT_1_MUX 300
+#define TEGRA30_CLK_CLK_MAX 301
+
+#endif  /* _DT_BINDINGS_CLOCK_TEGRA30_CAR_H */
diff --git a/include/dt-bindings/clock/vf610-clock.h b/include/dt-bindings/clock/vf610-clock.h
new file mode 100644
index 000000000000..15e997fa78f2
--- /dev/null
+++ b/include/dt-bindings/clock/vf610-clock.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright 2013 Freescale Semiconductor, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef __DT_BINDINGS_CLOCK_VF610_H
+#define __DT_BINDINGS_CLOCK_VF610_H
+
+#define VF610_CLK_DUMMY                 0
+#define VF610_CLK_SIRC_128K             1
+#define VF610_CLK_SIRC_32K              2
+#define VF610_CLK_FIRC                  3
+#define VF610_CLK_SXOSC                 4
+#define VF610_CLK_FXOSC                 5
+#define VF610_CLK_FXOSC_HALF            6
+#define VF610_CLK_SLOW_CLK_SEL          7
+#define VF610_CLK_FASK_CLK_SEL          8
+#define VF610_CLK_AUDIO_EXT             9
+#define VF610_CLK_ENET_EXT              10
+#define VF610_CLK_PLL1_MAIN             11
+#define VF610_CLK_PLL1_PFD1             12
+#define VF610_CLK_PLL1_PFD2             13
+#define VF610_CLK_PLL1_PFD3             14
+#define VF610_CLK_PLL1_PFD4             15
+#define VF610_CLK_PLL2_MAIN             16
+#define VF610_CLK_PLL2_PFD1             17
+#define VF610_CLK_PLL2_PFD2             18
+#define VF610_CLK_PLL2_PFD3             19
+#define VF610_CLK_PLL2_PFD4             20
+#define VF610_CLK_PLL3_MAIN             21
+#define VF610_CLK_PLL3_PFD1             22
+#define VF610_CLK_PLL3_PFD2             23
+#define VF610_CLK_PLL3_PFD3             24
+#define VF610_CLK_PLL3_PFD4             25
+#define VF610_CLK_PLL4_MAIN             26
+#define VF610_CLK_PLL5_MAIN             27
+#define VF610_CLK_PLL6_MAIN             28
+#define VF610_CLK_PLL3_MAIN_DIV         29
+#define VF610_CLK_PLL4_MAIN_DIV         30
+#define VF610_CLK_PLL6_MAIN_DIV         31
+#define VF610_CLK_PLL1_PFD_SEL          32
+#define VF610_CLK_PLL2_PFD_SEL          33
+#define VF610_CLK_SYS_SEL               34
+#define VF610_CLK_DDR_SEL               35
+#define VF610_CLK_SYS_BUS               36
+#define VF610_CLK_PLATFORM_BUS          37
+#define VF610_CLK_IPG_BUS               38
+#define VF610_CLK_UART0                 39
+#define VF610_CLK_UART1                 40
+#define VF610_CLK_UART2                 41
+#define VF610_CLK_UART3                 42
+#define VF610_CLK_UART4                 43
+#define VF610_CLK_UART5                 44
+#define VF610_CLK_PIT                   45
+#define VF610_CLK_I2C0                  46
+#define VF610_CLK_I2C1                  47
+#define VF610_CLK_I2C2                  48
+#define VF610_CLK_I2C3                  49
+#define VF610_CLK_FTM0_EXT_SEL          50
+#define VF610_CLK_FTM0_FIX_SEL          51
+#define VF610_CLK_FTM0_EXT_FIX_EN       52
+#define VF610_CLK_FTM1_EXT_SEL          53
+#define VF610_CLK_FTM1_FIX_SEL          54
+#define VF610_CLK_FTM1_EXT_FIX_EN       55
+#define VF610_CLK_FTM2_EXT_SEL          56
+#define VF610_CLK_FTM2_FIX_SEL          57
+#define VF610_CLK_FTM2_EXT_FIX_EN       58
+#define VF610_CLK_FTM3_EXT_SEL          59
+#define VF610_CLK_FTM3_FIX_SEL          60
+#define VF610_CLK_FTM3_EXT_FIX_EN       61
+#define VF610_CLK_FTM0                  62
+#define VF610_CLK_FTM1                  63
+#define VF610_CLK_FTM2                  64
+#define VF610_CLK_FTM3                  65
+#define VF610_CLK_ENET_50M              66
+#define VF610_CLK_ENET_25M              67
+#define VF610_CLK_ENET_SEL              68
+#define VF610_CLK_ENET                  69
+#define VF610_CLK_ENET_TS_SEL           70
+#define VF610_CLK_ENET_TS               71
+#define VF610_CLK_DSPI0                 72
+#define VF610_CLK_DSPI1                 73
+#define VF610_CLK_DSPI2                 74
+#define VF610_CLK_DSPI3                 75
+#define VF610_CLK_WDT                   76
+#define VF610_CLK_ESDHC0_SEL            77
+#define VF610_CLK_ESDHC0_EN             78
+#define VF610_CLK_ESDHC0_DIV            79
+#define VF610_CLK_ESDHC0                80
+#define VF610_CLK_ESDHC1_SEL            81
+#define VF610_CLK_ESDHC1_EN             82
+#define VF610_CLK_ESDHC1_DIV            83
+#define VF610_CLK_ESDHC1                84
+#define VF610_CLK_DCU0_SEL              85
+#define VF610_CLK_DCU0_EN               86
+#define VF610_CLK_DCU0_DIV              87
+#define VF610_CLK_DCU0                  88
+#define VF610_CLK_DCU1_SEL              89
+#define VF610_CLK_DCU1_EN               90
+#define VF610_CLK_DCU1_DIV              91
+#define VF610_CLK_DCU1                  92
+#define VF610_CLK_ESAI_SEL              93
+#define VF610_CLK_ESAI_EN               94
+#define VF610_CLK_ESAI_DIV              95
+#define VF610_CLK_ESAI                  96
+#define VF610_CLK_SAI0_SEL              97
+#define VF610_CLK_SAI0_EN               98
+#define VF610_CLK_SAI0_DIV              99
+#define VF610_CLK_SAI0                  100
+#define VF610_CLK_SAI1_SEL              101
+#define VF610_CLK_SAI1_EN               102
+#define VF610_CLK_SAI1_DIV              103
+#define VF610_CLK_SAI1                  104
+#define VF610_CLK_SAI2_SEL              105
+#define VF610_CLK_SAI2_EN               106
+#define VF610_CLK_SAI2_DIV              107
+#define VF610_CLK_SAI2                  108
+#define VF610_CLK_SAI3_SEL              109
+#define VF610_CLK_SAI3_EN               110
+#define VF610_CLK_SAI3_DIV              111
+#define VF610_CLK_SAI3                  112
+#define VF610_CLK_USBC0                 113
+#define VF610_CLK_USBC1                 114
+#define VF610_CLK_QSPI0_SEL             115
+#define VF610_CLK_QSPI0_EN              116
+#define VF610_CLK_QSPI0_X4_DIV          117
+#define VF610_CLK_QSPI0_X2_DIV          118
+#define VF610_CLK_QSPI0_X1_DIV          119
+#define VF610_CLK_QSPI1_SEL             120
+#define VF610_CLK_QSPI1_EN              121
+#define VF610_CLK_QSPI1_X4_DIV          122
+#define VF610_CLK_QSPI1_X2_DIV          123
+#define VF610_CLK_QSPI1_X1_DIV          124
+#define VF610_CLK_QSPI0                 125
+#define VF610_CLK_QSPI1                 126
+#define VF610_CLK_NFC_SEL               127
+#define VF610_CLK_NFC_EN                128
+#define VF610_CLK_NFC_PRE_DIV           129
+#define VF610_CLK_NFC_FRAC_DIV          130
+#define VF610_CLK_NFC_INV               131
+#define VF610_CLK_NFC                   132
+#define VF610_CLK_VADC_SEL              133
+#define VF610_CLK_VADC_EN               134
+#define VF610_CLK_VADC_DIV              135
+#define VF610_CLK_VADC_DIV_HALF         136
+#define VF610_CLK_VADC                  137
+#define VF610_CLK_ADC0                  138
+#define VF610_CLK_ADC1                  139
+#define VF610_CLK_DAC0                  140
+#define VF610_CLK_DAC1                  141
+#define VF610_CLK_FLEXCAN0              142
+#define VF610_CLK_FLEXCAN1              143
+#define VF610_CLK_ASRC                  144
+#define VF610_CLK_GPU_SEL               145
+#define VF610_CLK_GPU_EN                146
+#define VF610_CLK_GPU2D                 147
+#define VF610_CLK_END                   148
+
+#endif /* __DT_BINDINGS_CLOCK_VF610_H */
diff --git a/include/dt-bindings/dma/at91.h b/include/dt-bindings/dma/at91.h
new file mode 100644
index 000000000000..e835037a77b4
--- /dev/null
+++ b/include/dt-bindings/dma/at91.h
@@ -0,0 +1,27 @@
+/*
+ * This header provides macros for at91 dma bindings.
+ *
+ * Copyright (C) 2013 Ludovic Desroches <ludovic.desroches@atmel.com>
+ *
+ * GPLv2 only
+ */
+
+#ifndef __DT_BINDINGS_AT91_DMA_H__
+#define __DT_BINDINGS_AT91_DMA_H__
+
+/*
+ * Source and/or destination peripheral ID
+ */
+#define AT91_DMA_CFG_PER_ID_MASK        (0xff)
+#define AT91_DMA_CFG_PER_ID(id)         (id & AT91_DMA_CFG_PER_ID_MASK)
+
+/*
+ * FIFO configuration: it defines when a request is serviced.
+ */
+#define AT91_DMA_CFG_FIFOCFG_OFFSET     (8)
+#define AT91_DMA_CFG_FIFOCFG_MASK       (0xf << AT91_DMA_CFG_FIFOCFG_OFFSET)
+#define AT91_DMA_CFG_FIFOCFG_HALF       (0x0 << AT91_DMA_CFG_FIFOCFG_OFFSET)    /* half FIFO (default behavior) */
+#define AT91_DMA_CFG_FIFOCFG_ALAP       (0x1 << AT91_DMA_CFG_FIFOCFG_OFFSET)    /* largest defined AHB burst */
+#define AT91_DMA_CFG_FIFOCFG_ASAP       (0x2 << AT91_DMA_CFG_FIFOCFG_OFFSET)    /* single AHB access */
+
+#endif /* __DT_BINDINGS_AT91_DMA_H__ */
diff --git a/include/dt-bindings/gpio/tegra-gpio.h b/include/dt-bindings/gpio/tegra-gpio.h
new file mode 100644
index 000000000000..4d179c00f081
--- /dev/null
+++ b/include/dt-bindings/gpio/tegra-gpio.h
@@ -0,0 +1,50 @@
+/*
+ * This header provides constants for binding nvidia,tegra*-gpio.
+ *
+ * The first cell in Tegra's GPIO specifier is the GPIO ID. The macros below
+ * provide names for this.
+ *
+ * The second cell contains standard flag values specified in gpio.h.
+ */
+
+#ifndef _DT_BINDINGS_GPIO_TEGRA_GPIO_H
+#define _DT_BINDINGS_GPIO_TEGRA_GPIO_H
+
+#include <dt-bindings/gpio/gpio.h>
+
+#define TEGRA_GPIO_BANK_ID_A 0
+#define TEGRA_GPIO_BANK_ID_B 1
+#define TEGRA_GPIO_BANK_ID_C 2
+#define TEGRA_GPIO_BANK_ID_D 3
+#define TEGRA_GPIO_BANK_ID_E 4
+#define TEGRA_GPIO_BANK_ID_F 5
+#define TEGRA_GPIO_BANK_ID_G 6
+#define TEGRA_GPIO_BANK_ID_H 7
+#define TEGRA_GPIO_BANK_ID_I 8
+#define TEGRA_GPIO_BANK_ID_J 9
+#define TEGRA_GPIO_BANK_ID_K 10
+#define TEGRA_GPIO_BANK_ID_L 11
+#define TEGRA_GPIO_BANK_ID_M 12
+#define TEGRA_GPIO_BANK_ID_N 13
+#define TEGRA_GPIO_BANK_ID_O 14
+#define TEGRA_GPIO_BANK_ID_P 15
+#define TEGRA_GPIO_BANK_ID_Q 16
+#define TEGRA_GPIO_BANK_ID_R 17
+#define TEGRA_GPIO_BANK_ID_S 18
+#define TEGRA_GPIO_BANK_ID_T 19
+#define TEGRA_GPIO_BANK_ID_U 20
+#define TEGRA_GPIO_BANK_ID_V 21
+#define TEGRA_GPIO_BANK_ID_W 22
+#define TEGRA_GPIO_BANK_ID_X 23
+#define TEGRA_GPIO_BANK_ID_Y 24
+#define TEGRA_GPIO_BANK_ID_Z 25
+#define TEGRA_GPIO_BANK_ID_AA 26
+#define TEGRA_GPIO_BANK_ID_BB 27
+#define TEGRA_GPIO_BANK_ID_CC 28
+#define TEGRA_GPIO_BANK_ID_DD 29
+#define TEGRA_GPIO_BANK_ID_EE 30
+
+#define TEGRA_GPIO(bank, offset) \
+        ((TEGRA_GPIO_BANK_ID_##bank * 8) + offset)
+
+#endif
diff --git a/include/dt-bindings/pinctrl/am33xx.h b/include/dt-bindings/pinctrl/am33xx.h
new file mode 100644
index 000000000000..469e0325e6f4
--- /dev/null
+++ b/include/dt-bindings/pinctrl/am33xx.h
@@ -0,0 +1,42 @@
+/*
+ * This header provides constants specific to AM33XX pinctrl bindings.
+ */
+
+#ifndef _DT_BINDINGS_PINCTRL_AM33XX_H
+#define _DT_BINDINGS_PINCTRL_AM33XX_H
+
+#include <include/dt-bindings/pinctrl/omap.h>
+
+/* am33xx specific mux bit defines */
+#undef PULL_ENA
+#undef INPUT_EN
+
+#define PULL_DISABLE            (1 << 3)
+#define INPUT_EN                (1 << 5)
+#define SLEWCTRL_FAST           (1 << 6)
+
+/* update macro depending on INPUT_EN and PULL_ENA */
+#undef PIN_OUTPUT
+#undef PIN_OUTPUT_PULLUP
+#undef PIN_OUTPUT_PULLDOWN
+#undef PIN_INPUT
+#undef PIN_INPUT_PULLUP
+#undef PIN_INPUT_PULLDOWN
+
+#define PIN_OUTPUT              (PULL_DISABLE)
+#define PIN_OUTPUT_PULLUP       (PULL_UP)
+#define PIN_OUTPUT_PULLDOWN     0
+#define PIN_INPUT               (INPUT_EN | PULL_DISABLE)
+#define PIN_INPUT_PULLUP        (INPUT_EN | PULL_UP)
+#define PIN_INPUT_PULLDOWN      (INPUT_EN)
+
+/* undef non-existing modes */
+#undef PIN_OFF_NONE
+#undef PIN_OFF_OUTPUT_HIGH
+#undef PIN_OFF_OUTPUT_LOW
+#undef PIN_OFF_INPUT_PULLUP
+#undef PIN_OFF_INPUT_PULLDOWN
+#undef PIN_OFF_WAKEUPENABLE
+
+#endif
+
diff --git a/include/dt-bindings/pinctrl/at91.h b/include/dt-bindings/pinctrl/at91.h
new file mode 100644
index 000000000000..d7988b4d8af9
--- /dev/null
+++ b/include/dt-bindings/pinctrl/at91.h
@@ -0,0 +1,35 @@
+/*
+ * This header provides constants for most at91 pinctrl bindings.
+ *
+ * Copyright (C) 2013 Jean-Christophe PLAGNIOL-VILLARD <plagnioj@jcrosoft.com>
+ *
+ * GPLv2 only
+ */
+
+#ifndef __DT_BINDINGS_AT91_PINCTRL_H__
+#define __DT_BINDINGS_AT91_PINCTRL_H__
+
+#define AT91_PINCTRL_NONE               (0 << 0)
+#define AT91_PINCTRL_PULL_UP            (1 << 0)
+#define AT91_PINCTRL_MULTI_DRIVE        (1 << 1)
+#define AT91_PINCTRL_DEGLITCH           (1 << 2)
+#define AT91_PINCTRL_PULL_DOWN          (1 << 3)
+#define AT91_PINCTRL_DIS_SCHMIT         (1 << 4)
+#define AT91_PINCTRL_DEBOUNCE           (1 << 16)
+#define AT91_PINCTRL_DEBOUNCE_VA(x)     (x << 17)
+
+#define AT91_PINCTRL_PULL_UP_DEGLITCH   (AT91_PINCTRL_PULL_UP | AT91_PINCTRL_DEGLITCH)
+
+#define AT91_PIOA       0
+#define AT91_PIOB       1
+#define AT91_PIOC       2
+#define AT91_PIOD       3
+#define AT91_PIOE       4
+
+#define AT91_PERIPH_GPIO        0
+#define AT91_PERIPH_A           1
+#define AT91_PERIPH_B           2
+#define AT91_PERIPH_C           3
+#define AT91_PERIPH_D           4
+
+#endif /* __DT_BINDINGS_AT91_PINCTRL_H__ */
diff --git a/include/dt-bindings/pinctrl/omap.h b/include/dt-bindings/pinctrl/omap.h
new file mode 100644
index 000000000000..edbd250809cb
--- /dev/null
+++ b/include/dt-bindings/pinctrl/omap.h
@@ -0,0 +1,55 @@
+/*
+ * This header provides constants for OMAP pinctrl bindings.
+ *
+ * Copyright (C) 2009 Nokia
+ * Copyright (C) 2009-2010 Texas Instruments
+ */
+
+#ifndef _DT_BINDINGS_PINCTRL_OMAP_H
+#define _DT_BINDINGS_PINCTRL_OMAP_H
+
+/* 34xx mux mode options for each pin. See TRM for options */
+#define MUX_MODE0       0
+#define MUX_MODE1       1
+#define MUX_MODE2       2
+#define MUX_MODE3       3
+#define MUX_MODE4       4
+#define MUX_MODE5       5
+#define MUX_MODE6       6
+#define MUX_MODE7       7
+
+/* 24xx/34xx mux bit defines */
+#define PULL_ENA                (1 << 3)
+#define PULL_UP                 (1 << 4)
+#define ALTELECTRICALSEL        (1 << 5)
+
+/* 34xx specific mux bit defines */
+#define INPUT_EN                (1 << 8)
+#define OFF_EN                  (1 << 9)
+#define OFFOUT_EN               (1 << 10)
+#define OFFOUT_VAL              (1 << 11)
+#define OFF_PULL_EN             (1 << 12)
+#define OFF_PULL_UP             (1 << 13)
+#define WAKEUP_EN               (1 << 14)
+
+/* 44xx specific mux bit defines */
+#define WAKEUP_EVENT            (1 << 15)
+
+/* Active pin states */
+#define PIN_OUTPUT              0
+#define PIN_OUTPUT_PULLUP       (PIN_OUTPUT | PULL_ENA | PULL_UP)
+#define PIN_OUTPUT_PULLDOWN     (PIN_OUTPUT | PULL_ENA)
+#define PIN_INPUT               INPUT_EN
+#define PIN_INPUT_PULLUP        (PULL_ENA | INPUT_EN | PULL_UP)
+#define PIN_INPUT_PULLDOWN      (PULL_ENA | INPUT_EN)
+
+/* Off mode states */
+#define PIN_OFF_NONE            0
+#define PIN_OFF_OUTPUT_HIGH     (OFF_EN | OFFOUT_EN | OFFOUT_VAL)
+#define PIN_OFF_OUTPUT_LOW      (OFF_EN | OFFOUT_EN)
+#define PIN_OFF_INPUT_PULLUP    (OFF_EN | OFF_PULL_EN | OFF_PULL_UP)
+#define PIN_OFF_INPUT_PULLDOWN  (OFF_EN | OFF_PULL_EN)
+#define PIN_OFF_WAKEUPENABLE    WAKEUP_EN
+
+#endif
+
diff --git a/include/linux/arm-cci.h b/include/linux/arm-cci.h
new file mode 100644
index 000000000000..79d6edf446d5
--- /dev/null
+++ b/include/linux/arm-cci.h
@@ -0,0 +1,61 @@
+/*
+ * CCI cache coherent interconnect support
+ *
+ * Copyright (C) 2013 ARM Ltd.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 __LINUX_ARM_CCI_H
+#define __LINUX_ARM_CCI_H
+
+#include <linux/errno.h>
+#include <linux/types.h>
+
+struct device_node;
+
+#ifdef CONFIG_ARM_CCI
+extern bool cci_probed(void);
+extern int cci_ace_get_port(struct device_node *dn);
+extern int cci_disable_port_by_cpu(u64 mpidr);
+extern int __cci_control_port_by_device(struct device_node *dn, bool enable);
+extern int __cci_control_port_by_index(u32 port, bool enable);
+#else
+static inline bool cci_probed(void) { return false; }
+static inline int cci_ace_get_port(struct device_node *dn)
+{
+        return -ENODEV;
+}
+static inline int cci_disable_port_by_cpu(u64 mpidr) { return -ENODEV; }
+static inline int __cci_control_port_by_device(struct device_node *dn,
+                                               bool enable)
+{
+        return -ENODEV;
+}
+static inline int __cci_control_port_by_index(u32 port, bool enable)
+{
+        return -ENODEV;
+}
+#endif
+#define cci_disable_port_by_device(dev) \
+        __cci_control_port_by_device(dev, false)
+#define cci_enable_port_by_device(dev) \
+        __cci_control_port_by_device(dev, true)
+#define cci_disable_port_by_index(dev) \
+        __cci_control_port_by_index(dev, false)
+#define cci_enable_port_by_index(dev) \
+        __cci_control_port_by_index(dev, true)
+
+#endif
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 9e52b0626b39..f5a3b838ddb0 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -198,7 +198,8 @@ extern int buffer_heads_over_limit;
  * Generic address_space_operations implementations for buffer_head-backed
  * address_spaces.
  */
-void block_invalidatepage(struct page *page, unsigned long offset);
+void block_invalidatepage(struct page *page, unsigned int offset,
+                          unsigned int length);
 int block_write_full_page(struct page *page, get_block_t *get_block,
                                 struct writeback_control *wbc);
 int block_write_full_page_endio(struct page *page, get_block_t *get_block,
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 5047355b9a0f..fd097ecfcd97 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -20,6 +20,7 @@
 #include <linux/workqueue.h>
 #include <linux/xattr.h>
 #include <linux/fs.h>
+#include <linux/percpu-refcount.h>
 
 #ifdef CONFIG_CGROUPS
 
@@ -72,13 +73,8 @@ struct cgroup_subsys_state {
          */
         struct cgroup *cgroup;
 
-        /*
-         * State maintained by the cgroup system to allow subsystems
-         * to be "busy". Should be accessed via css_get(),
-         * css_tryget() and css_put().
-         */
-
-        atomic_t refcnt;
+        /* reference count - access via css_[try]get() and css_put() */
+        struct percpu_ref refcnt;
 
         unsigned long flags;
         /* ID for this css, if possible */
@@ -94,56 +90,52 @@ enum {
         CSS_ONLINE      = (1 << 1), /* between ->css_online() and ->css_offline() */
 };
 
-/* Caller must verify that the css is not for root cgroup */
-static inline void __css_get(struct cgroup_subsys_state *css, int count)
-{
-        atomic_add(count, &css->refcnt);
-}
-
-/*
- * Call css_get() to hold a reference on the css; it can be used
- * for a reference obtained via:
- * - an existing ref-counted reference to the css
- * - task->cgroups for a locked task
+/**
+ * css_get - obtain a reference on the specified css
+ * @css: target css
+ *
+ * The caller must already have a reference.
  */
-
 static inline void css_get(struct cgroup_subsys_state *css)
 {
         /* We don't need to reference count the root state */
         if (!(css->flags & CSS_ROOT))
-                __css_get(css, 1);
+                percpu_ref_get(&css->refcnt);
 }
 
-/*
- * Call css_tryget() to take a reference on a css if your existing
- * (known-valid) reference isn't already ref-counted. Returns false if
- * the css has been destroyed.
+/**
+ * css_tryget - try to obtain a reference on the specified css
+ * @css: target css
+ *
+ * Obtain a reference on @css if it's alive.  The caller naturally needs to
+ * ensure that @css is accessible but doesn't have to be holding a
+ * reference on it - IOW, RCU protected access is good enough for this
+ * function.  Returns %true if a reference count was successfully obtained;
+ * %false otherwise.
  */
-
-extern bool __css_tryget(struct cgroup_subsys_state *css);
 static inline bool css_tryget(struct cgroup_subsys_state *css)
 {
         if (css->flags & CSS_ROOT)
                 return true;
-        return __css_tryget(css);
+        return percpu_ref_tryget(&css->refcnt);
 }
 
-/*
- * css_put() should be called to release a reference taken by
- * css_get() or css_tryget()
+/**
+ * css_put - put a css reference
+ * @css: target css
+ *
+ * Put a reference obtained via css_get() and css_tryget().
  */
-
-extern void __css_put(struct cgroup_subsys_state *css);
 static inline void css_put(struct cgroup_subsys_state *css)
 {
         if (!(css->flags & CSS_ROOT))
-                __css_put(css);
+                percpu_ref_put(&css->refcnt);
 }
 
 /* bits in struct cgroup flags field */
 enum {
         /* Control Group is dead */
-        CGRP_REMOVED,
+        CGRP_DEAD,
         /*
          * Control Group has previously had a child cgroup or a task,
          * but no longer (only if CGRP_NOTIFY_ON_RELEASE is set)
@@ -169,12 +161,6 @@ struct cgroup_name {
 struct cgroup {
         unsigned long flags;            /* "unsigned long" so bitops work */
 
-        /*
-         * count users of this cgroup. >0 means busy, but doesn't
-         * necessarily indicate the number of tasks in the cgroup
-         */
-        atomic_t count;
-
         int id;                         /* ida allocated in-hierarchy ID */
 
         /*
@@ -189,6 +175,14 @@ struct cgroup {
         struct dentry *dentry;          /* cgroup fs entry, RCU protected */
 
         /*
+         * Monotonically increasing unique serial number which defines a
+         * uniform order among all cgroups.  It's guaranteed that all
+         * ->children lists are in the ascending order of ->serial_nr.
+         * It's used to allow interrupting and resuming iterations.
+         */
+        u64 serial_nr;
+
+        /*
          * This is a copy of dentry->d_name, and it's needed because
          * we can't use dentry->d_name in cgroup_path().
          *
@@ -207,13 +201,10 @@ struct cgroup {
         struct cgroupfs_root *root;
 
         /*
-         * List of cg_cgroup_links pointing at css_sets with
-         * tasks in this cgroup. Protected by css_set_lock
+         * List of cgrp_cset_links pointing at css_sets with tasks in this
+         * cgroup.  Protected by css_set_lock.
          */
-        struct list_head css_sets;
-
-        struct list_head allcg_node;    /* cgroupfs_root->allcg_list */
-        struct list_head cft_q_node;    /* used during cftype add/rm */
+        struct list_head cset_links;
 
         /*
          * Linked list running through all cgroups that can
@@ -229,9 +220,10 @@ struct cgroup {
         struct list_head pidlists;
         struct mutex pidlist_mutex;
 
-        /* For RCU-protected deletion */
+        /* For css percpu_ref killing and RCU-protected deletion */
         struct rcu_head rcu_head;
-        struct work_struct free_work;
+        struct work_struct destroy_work;
+        atomic_t css_kill_cnt;
 
         /* List of events which userspace want to receive */
         struct list_head event_list;
@@ -269,18 +261,33 @@ enum {
          *
          * - Remount is disallowed.
          *
-         * - memcg: use_hierarchy is on by default and the cgroup file for
-         *   the flag is not created.
+         * - rename(2) is disallowed.
          *
-         * The followings are planned changes.
+         * - "tasks" is removed.  Everything should be at process
+         *   granularity.  Use "cgroup.procs" instead.
          *
-         * - release_agent will be disallowed once replacement notification
-         *   mechanism is implemented.
+         * - "release_agent" and "notify_on_release" are removed.
+         *   Replacement notification mechanism will be implemented.
+         *
+         * - cpuset: tasks will be kept in empty cpusets when hotplug happens
+         *   and take masks of ancestors with non-empty cpus/mems, instead of
+         *   being moved to an ancestor.
+         *
+         * - cpuset: a task can be moved into an empty cpuset, and again it
+         *   takes masks of ancestors.
+         *
+         * - memcg: use_hierarchy is on by default and the cgroup file for
+         *   the flag is not created.
          */
         CGRP_ROOT_SANE_BEHAVIOR = (1 << 0),
 
         CGRP_ROOT_NOPREFIX      = (1 << 1), /* mounted subsystems have no named prefix */
         CGRP_ROOT_XATTR         = (1 << 2), /* supports extended attributes */
+
+        /* mount options live below bit 16 */
+        CGRP_ROOT_OPTION_MASK   = (1 << 16) - 1,
+
+        CGRP_ROOT_SUBSYS_BOUND  = (1 << 16), /* subsystems finished binding */
 };
 
 /*
@@ -291,18 +298,12 @@ enum {
 struct cgroupfs_root {
         struct super_block *sb;
 
-        /*
-         * The bitmask of subsystems intended to be attached to this
-         * hierarchy
-         */
+        /* The bitmask of subsystems attached to this hierarchy */
         unsigned long subsys_mask;
 
         /* Unique id for this hierarchy. */
         int hierarchy_id;
 
-        /* The bitmask of subsystems currently attached to this hierarchy */
-        unsigned long actual_subsys_mask;
-
         /* A list running through the attached subsystems */
         struct list_head subsys_list;
 
@@ -315,9 +316,6 @@ struct cgroupfs_root {
         /* A list running through the active hierarchies */
         struct list_head root_list;
 
-        /* All cgroups on this root, cgroup_mutex protected */
-        struct list_head allcg_list;
-
         /* Hierarchy-specific flags */
         unsigned long flags;
 
@@ -357,11 +355,10 @@ struct css_set {
         struct list_head tasks;
 
         /*
-         * List of cg_cgroup_link objects on link chains from
-         * cgroups referenced from this css_set. Protected by
-         * css_set_lock
+         * List of cgrp_cset_links pointing at cgroups referenced from this
+         * css_set.  Protected by css_set_lock.
          */
-        struct list_head cg_links;
+        struct list_head cgrp_links;
 
         /*
          * Set of subsystem states, one for each subsystem. This array
@@ -394,9 +391,11 @@ 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 on root cg */
-#define CFTYPE_INSANE           (1U << 2)       /* don't create if sane_behavior */
+enum {
+        CFTYPE_ONLY_ON_ROOT     = (1 << 0),     /* only create on root cg */
+        CFTYPE_NOT_ON_ROOT      = (1 << 1),     /* don't create on root cg */
+        CFTYPE_INSANE           = (1 << 2),     /* don't create if sane_behavior */
+};
 
 #define MAX_CFTYPE_NAME         64
 
@@ -442,13 +441,13 @@ struct cftype {
          * entry. The key/value pairs (and their ordering) should not
          * change between reboots.
          */
-        int (*read_map)(struct cgroup *cont, struct cftype *cft,
+        int (*read_map)(struct cgroup *cgrp, struct cftype *cft,
                         struct cgroup_map_cb *cb);
         /*
          * read_seq_string() is used for outputting a simple sequence
          * using seqfile.
          */
-        int (*read_seq_string)(struct cgroup *cont, struct cftype *cft,
+        int (*read_seq_string)(struct cgroup *cgrp, struct cftype *cft,
                                struct seq_file *m);
 
         ssize_t (*write)(struct cgroup *cgrp, struct cftype *cft,
@@ -538,10 +537,11 @@ static inline const char *cgroup_name(const struct cgroup *cgrp)
 int cgroup_add_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
 int cgroup_rm_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
 
-int cgroup_is_removed(const struct cgroup *cgrp);
 bool cgroup_is_descendant(struct cgroup *cgrp, struct cgroup *ancestor);
 
 int cgroup_path(const struct cgroup *cgrp, char *buf, int buflen);
+int task_cgroup_path_from_hierarchy(struct task_struct *task, int hierarchy_id,
+                                    char *buf, size_t buflen);
 
 int cgroup_task_count(const struct cgroup *cgrp);
 
@@ -646,22 +646,60 @@ static inline struct cgroup_subsys_state *cgroup_subsys_state(
         return cgrp->subsys[subsys_id];
 }
 
-/*
- * function to get the cgroup_subsys_state which allows for extra
- * rcu_dereference_check() conditions, such as locks used during the
- * cgroup_subsys::attach() methods.
+/**
+ * task_css_set_check - obtain a task's css_set with extra access conditions
+ * @task: the task to obtain css_set for
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * A task's css_set is RCU protected, initialized and exited while holding
+ * task_lock(), and can only be modified while holding both cgroup_mutex
+ * and task_lock() while the task is alive.  This macro verifies that the
+ * caller is inside proper critical section and returns @task's css_set.
+ *
+ * The caller can also specify additional allowed conditions via @__c, such
+ * as locks used during the cgroup_subsys::attach() methods.
  */
 #ifdef CONFIG_PROVE_RCU
 extern struct mutex cgroup_mutex;
-#define task_subsys_state_check(task, subsys_id, __c)                   \
-        rcu_dereference_check((task)->cgroups->subsys[(subsys_id)],     \
-                              lockdep_is_held(&(task)->alloc_lock) ||   \
-                              lockdep_is_held(&cgroup_mutex) || (__c))
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference_check((task)->cgroups,                          \
+                lockdep_is_held(&(task)->alloc_lock) ||                 \
+                lockdep_is_held(&cgroup_mutex) || (__c))
 #else
-#define task_subsys_state_check(task, subsys_id, __c)                   \
-        rcu_dereference((task)->cgroups->subsys[(subsys_id)])
+#define task_css_set_check(task, __c)                                   \
+        rcu_dereference((task)->cgroups)
 #endif
 
+/**
+ * task_subsys_state_check - obtain css for (task, subsys) w/ extra access conds
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ * @__c: extra condition expression to be passed to rcu_dereference_check()
+ *
+ * Return the cgroup_subsys_state for the (@task, @subsys_id) pair.  The
+ * synchronization rules are the same as task_css_set_check().
+ */
+#define task_subsys_state_check(task, subsys_id, __c)                   \
+        task_css_set_check((task), (__c))->subsys[(subsys_id)]
+
+/**
+ * task_css_set - obtain a task's css_set
+ * @task: the task to obtain css_set for
+ *
+ * See task_css_set_check().
+ */
+static inline struct css_set *task_css_set(struct task_struct *task)
+{
+        return task_css_set_check(task, false);
+}
+
+/**
+ * task_subsys_state - obtain css for (task, subsys)
+ * @task: the target task
+ * @subsys_id: the target subsystem ID
+ *
+ * See task_subsys_state_check().
+ */
 static inline struct cgroup_subsys_state *
 task_subsys_state(struct task_struct *task, int subsys_id)
 {
@@ -674,12 +712,14 @@ static inline struct cgroup* task_cgroup(struct task_struct *task,
         return task_subsys_state(task, subsys_id)->cgroup;
 }
 
+struct cgroup *cgroup_next_sibling(struct cgroup *pos);
+
 /**
  * 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
+ * @cgrp: cgroup whose children to walk
  *
- * Walk @cgroup's children.  Must be called under rcu_read_lock().  A child
+ * Walk @cgrp'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.
@@ -687,9 +727,15 @@ static inline struct cgroup* task_cgroup(struct task_struct *task,
  * 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.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
  */
-#define cgroup_for_each_child(pos, cgroup)                              \
-        list_for_each_entry_rcu(pos, &(cgroup)->children, sibling)
+#define cgroup_for_each_child(pos, cgrp)                                \
+        for ((pos) = list_first_or_null_rcu(&(cgrp)->children,          \
+                                            struct cgroup, sibling);    \
+             (pos); (pos) = cgroup_next_sibling((pos)))
 
 struct cgroup *cgroup_next_descendant_pre(struct cgroup *pos,
                                           struct cgroup *cgroup);
@@ -707,7 +753,7 @@ struct cgroup *cgroup_rightmost_descendant(struct cgroup *pos);
  *
  * 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
+ * iteration, any descendant cgroup which finished ->css_online() is
  * guaranteed to be visible in the future iterations.
  *
  * In other words, the following guarantees that a descendant can't escape
@@ -748,6 +794,10 @@ struct cgroup *cgroup_rightmost_descendant(struct cgroup *pos);
  * Alternatively, a subsystem may choose to use a single global lock to
  * synchronize ->css_online() and ->css_offline() against tree-walking
  * operations.
+ *
+ * It is allowed to temporarily drop RCU read lock during iteration.  The
+ * caller is responsible for ensuring that @pos remains accessible until
+ * the start of the next iteration by, for example, bumping the css refcnt.
  */
 #define cgroup_for_each_descendant_pre(pos, cgroup)                     \
         for (pos = cgroup_next_descendant_pre(NULL, (cgroup)); (pos);   \
@@ -771,7 +821,7 @@ struct cgroup *cgroup_next_descendant_post(struct cgroup *pos,
 
 /* A cgroup_iter should be treated as an opaque object */
 struct cgroup_iter {
-        struct list_head *cg_link;
+        struct list_head *cset_link;
         struct list_head *task;
 };
 
@@ -827,7 +877,6 @@ bool css_is_ancestor(struct cgroup_subsys_state *cg,
 
 /* Get id and depth of css */
 unsigned short css_id(struct cgroup_subsys_state *css);
-unsigned short css_depth(struct cgroup_subsys_state *css);
 struct cgroup_subsys_state *cgroup_css_from_dir(struct file *f, int id);
 
 #else /* !CONFIG_CGROUPS */
@@ -838,8 +887,6 @@ static inline void cgroup_fork(struct task_struct *p) {}
 static inline void cgroup_post_fork(struct task_struct *p) {}
 static inline void cgroup_exit(struct task_struct *p, int callbacks) {}
 
-static inline void cgroup_lock(void) {}
-static inline void cgroup_unlock(void) {}
 static inline int cgroupstats_build(struct cgroupstats *stats,
                                         struct dentry *dentry)
 {
diff --git a/include/linux/clk/mvebu.h b/include/linux/clk/mvebu.h
deleted file mode 100644
index 8c4ae713b063..000000000000
--- a/include/linux/clk/mvebu.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
- */
-
-#ifndef __CLK_MVEBU_H_
-#define __CLK_MVEBU_H_
-
-void __init mvebu_clocks_init(void);
-
-#endif
diff --git a/include/linux/clk/zynq.h b/include/linux/clk/zynq.h
index 56be7cd9aa8b..e062d317ccce 100644
--- a/include/linux/clk/zynq.h
+++ b/include/linux/clk/zynq.h
@@ -1,4 +1,5 @@
 /*
+ * Copyright (C) 2013 Xilinx Inc.
  * Copyright (C) 2012 National Instruments
  *
  * This program is free software; you can redistribute it and/or modify
@@ -19,6 +20,11 @@
 #ifndef __LINUX_CLK_ZYNQ_H_
 #define __LINUX_CLK_ZYNQ_H_
 
-void __init xilinx_zynq_clocks_init(void __iomem *slcr);
+#include <linux/spinlock.h>
 
+void zynq_clock_init(void __iomem *slcr);
+
+struct clk *clk_register_zynq_pll(const char *name, const char *parent,
+                void __iomem *pll_ctrl, void __iomem *pll_status, u8 lock_index,
+                spinlock_t *lock);
 #endif
diff --git a/include/linux/completion.h b/include/linux/completion.h
index 33f0280fd533..3cd574d5b19e 100644
--- a/include/linux/completion.h
+++ b/include/linux/completion.h
@@ -5,7 +5,7 @@
  * (C) Copyright 2001 Linus Torvalds
  *
  * Atomic wait-for-completion handler data structures.
- * See kernel/sched.c for details.
+ * See kernel/sched/core.c for details.
  */
 
 #include <linux/wait.h>
diff --git a/include/linux/console.h b/include/linux/console.h
index 73bab0f58af5..7571a16bd653 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -75,10 +75,7 @@ extern const struct consw newport_con;	/* SGI Newport console  */
 extern const struct consw prom_con;     /* SPARC PROM console */
 
 int con_is_bound(const struct consw *csw);
-int register_con_driver(const struct consw *csw, int first, int last);
-int unregister_con_driver(const struct consw *csw);
 int do_unregister_con_driver(const struct consw *csw);
-int take_over_console(const struct consw *sw, int first, int last, int deflt);
 int do_take_over_console(const struct consw *sw, int first, int last, int deflt);
 void give_up_console(const struct consw *sw);
 #ifdef CONFIG_HW_CONSOLE
diff --git a/include/linux/context_tracking.h b/include/linux/context_tracking.h
index 365f4a61bf04..fc09d7b0dacf 100644
--- a/include/linux/context_tracking.h
+++ b/include/linux/context_tracking.h
@@ -3,6 +3,7 @@
 
 #include <linux/sched.h>
 #include <linux/percpu.h>
+#include <linux/vtime.h>
 #include <asm/ptrace.h>
 
 struct context_tracking {
@@ -19,6 +20,26 @@ struct context_tracking {
         } state;
 };
 
+static inline void __guest_enter(void)
+{
+        /*
+         * This is running in ioctl context so we can avoid
+         * the call to vtime_account() with its unnecessary idle check.
+         */
+        vtime_account_system(current);
+        current->flags |= PF_VCPU;
+}
+
+static inline void __guest_exit(void)
+{
+        /*
+         * This is running in ioctl context so we can avoid
+         * the call to vtime_account() with its unnecessary idle check.
+         */
+        vtime_account_system(current);
+        current->flags &= ~PF_VCPU;
+}
+
 #ifdef CONFIG_CONTEXT_TRACKING
 DECLARE_PER_CPU(struct context_tracking, context_tracking);
 
@@ -35,6 +56,9 @@ static inline bool context_tracking_active(void)
 extern void user_enter(void);
 extern void user_exit(void);
 
+extern void guest_enter(void);
+extern void guest_exit(void);
+
 static inline enum ctx_state exception_enter(void)
 {
         enum ctx_state prev_ctx;
@@ -57,6 +81,17 @@ extern void context_tracking_task_switch(struct task_struct *prev,
 static inline bool context_tracking_in_user(void) { return false; }
 static inline void user_enter(void) { }
 static inline void user_exit(void) { }
+
+static inline void guest_enter(void)
+{
+        __guest_enter();
+}
+
+static inline void guest_exit(void)
+{
+        __guest_exit();
+}
+
 static inline enum ctx_state exception_enter(void) { return 0; }
 static inline void exception_exit(enum ctx_state prev_ctx) { }
 static inline void context_tracking_task_switch(struct task_struct *prev,
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index c6f6e0839b61..9f3c7e81270a 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -175,6 +175,8 @@ extern struct bus_type cpu_subsys;
 
 extern void get_online_cpus(void);
 extern void put_online_cpus(void);
+extern void cpu_hotplug_disable(void);
+extern void cpu_hotplug_enable(void);
 #define hotcpu_notifier(fn, pri)        cpu_notifier(fn, pri)
 #define register_hotcpu_notifier(nb)    register_cpu_notifier(nb)
 #define unregister_hotcpu_notifier(nb)  unregister_cpu_notifier(nb)
@@ -198,6 +200,8 @@ static inline void cpu_hotplug_driver_unlock(void)
 
 #define get_online_cpus()       do { } while (0)
 #define put_online_cpus()       do { } while (0)
+#define cpu_hotplug_disable()   do { } while (0)
+#define cpu_hotplug_enable()    do { } while (0)
 #define hotcpu_notifier(fn, pri)        do { (void)(fn); } while (0)
 /* These aren't inline functions due to a GCC bug. */
 #define register_hotcpu_notifier(nb)    ({ (void)(nb); 0; })
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 1a6bb81f0fe5..f42dbe145479 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -146,10 +146,8 @@ enum dentry_d_lock_class
 struct dentry_operations {
         int (*d_revalidate)(struct dentry *, unsigned int);
         int (*d_weak_revalidate)(struct dentry *, unsigned int);
-        int (*d_hash)(const struct dentry *, const struct inode *,
-                        struct qstr *);
-        int (*d_compare)(const struct dentry *, const struct inode *,
-                        const struct dentry *, const struct inode *,
+        int (*d_hash)(const struct dentry *, struct qstr *);
+        int (*d_compare)(const struct dentry *, const struct dentry *,
                         unsigned int, const char *, const struct qstr *);
         int (*d_delete)(const struct dentry *);
         void (*d_release)(struct dentry *);
@@ -246,6 +244,8 @@ extern struct dentry * d_make_root(struct inode *);
 /* <clickety>-<click> the ramfs-type tree */
 extern void d_genocide(struct dentry *);
 
+extern void d_tmpfile(struct dentry *, struct inode *);
+
 extern struct dentry *d_find_alias(struct inode *);
 extern void d_prune_aliases(struct inode *);
 
@@ -300,8 +300,7 @@ extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
 extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
 extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
 extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
-                                const struct qstr *name,
-                                unsigned *seq, struct inode *inode);
+                                const struct qstr *name, unsigned *seq);
 
 /**
  * __d_rcu_to_refcount - take a refcount on dentry if sequence check is ok
diff --git a/include/linux/debugfs.h b/include/linux/debugfs.h
index 63f2465807d4..d68b4ea7343c 100644
--- a/include/linux/debugfs.h
+++ b/include/linux/debugfs.h
@@ -79,6 +79,8 @@ struct dentry *debugfs_create_x64(const char *name, umode_t mode,
                                   struct dentry *parent, u64 *value);
 struct dentry *debugfs_create_size_t(const char *name, umode_t mode,
                                      struct dentry *parent, size_t *value);
+struct dentry *debugfs_create_atomic_t(const char *name, umode_t mode,
+                                     struct dentry *parent, atomic_t *value);
 struct dentry *debugfs_create_bool(const char *name, umode_t mode,
                                   struct dentry *parent, u32 *value);
 
diff --git a/include/linux/device.h b/include/linux/device.h
index c0a126125325..9d4835a8f8b8 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -80,6 +80,7 @@ extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
  *              bus-specific setup
  * @p:          The private data of the driver core, only the driver core can
  *              touch this.
+ * @lock_key:   Lock class key for use by the lock validator
  *
  * A bus is a channel between the processor and one or more devices. For the
  * purposes of the device model, all devices are connected via a bus, even if
@@ -635,6 +636,7 @@ struct acpi_dev_node {
  *              segment limitations.
  * @dma_pools:  Dma pools (if dma'ble device).
  * @dma_mem:    Internal for coherent mem override.
+ * @cma_area:   Contiguous memory area for dma allocations
  * @archdata:   For arch-specific additions.
  * @of_node:    Associated device tree node.
  * @acpi_node:  Associated ACPI device node.
@@ -648,6 +650,7 @@ struct acpi_dev_node {
  * @release:    Callback to free the device after all references have
  *              gone away. This should be set by the allocator of the
  *              device (i.e. the bus driver that discovered the device).
+ * @iommu_group: IOMMU group the device belongs to.
  *
  * At the lowest level, every device in a Linux system is represented by an
  * instance of struct device. The device structure contains the information
diff --git a/include/linux/dw_apb_timer.h b/include/linux/dw_apb_timer.h
index dd755ce2a5eb..07261d52a6df 100644
--- a/include/linux/dw_apb_timer.h
+++ b/include/linux/dw_apb_timer.h
@@ -53,5 +53,4 @@ void dw_apb_clocksource_start(struct dw_apb_clocksource *dw_cs);
 cycle_t dw_apb_clocksource_read(struct dw_apb_clocksource *dw_cs);
 void dw_apb_clocksource_unregister(struct dw_apb_clocksource *dw_cs);
 
-extern void dw_apb_timer_init(void);
 #endif /* __DW_APB_TIMER_H__ */
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 2bc0ad78d058..21ae6b3c0359 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -287,20 +287,20 @@ typedef struct {
 
 typedef struct {
         efi_table_hdr_t hdr;
-        unsigned long get_time;
-        unsigned long set_time;
-        unsigned long get_wakeup_time;
-        unsigned long set_wakeup_time;
-        unsigned long set_virtual_address_map;
-        unsigned long convert_pointer;
-        unsigned long get_variable;
-        unsigned long get_next_variable;
-        unsigned long set_variable;
-        unsigned long get_next_high_mono_count;
-        unsigned long reset_system;
-        unsigned long update_capsule;
-        unsigned long query_capsule_caps;
-        unsigned long query_variable_info;
+        void *get_time;
+        void *set_time;
+        void *get_wakeup_time;
+        void *set_wakeup_time;
+        void *set_virtual_address_map;
+        void *convert_pointer;
+        void *get_variable;
+        void *get_next_variable;
+        void *set_variable;
+        void *get_next_high_mono_count;
+        void *reset_system;
+        void *update_capsule;
+        void *query_capsule_caps;
+        void *query_variable_info;
 } efi_runtime_services_t;
 
 typedef efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index df6fab82f87e..383d5e39b280 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -20,8 +20,8 @@
 #define F2FS_BLKSIZE                    4096    /* support only 4KB block */
 #define F2FS_MAX_EXTENSION              64      /* # of extension entries */
 
-#define NULL_ADDR               0x0U
-#define NEW_ADDR                -1U
+#define NULL_ADDR               ((block_t)0)    /* used as block_t addresses */
+#define NEW_ADDR                ((block_t)-1)   /* used as block_t addresses */
 
 #define F2FS_ROOT_INO(sbi)      (sbi->root_ino_num)
 #define F2FS_NODE_INO(sbi)      (sbi->node_ino_num)
diff --git a/include/linux/filter.h b/include/linux/filter.h
index c050dcc322a4..f65f5a69db8f 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -46,6 +46,7 @@ extern int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 extern int sk_detach_filter(struct sock *sk);
 extern int sk_chk_filter(struct sock_filter *filter, unsigned int flen);
 extern int sk_get_filter(struct sock *sk, struct sock_filter __user *filter, unsigned len);
+extern void sk_decode_filter(struct sock_filter *filt, struct sock_filter *to);
 
 #ifdef CONFIG_BPF_JIT
 #include <stdarg.h>
diff --git a/include/linux/firmware.h b/include/linux/firmware.h
index e4279fedb93a..e154c1005cd1 100644
--- a/include/linux/firmware.h
+++ b/include/linux/firmware.h
@@ -47,8 +47,6 @@ int request_firmware_nowait(
         void (*cont)(const struct firmware *fw, void *context));
 
 void release_firmware(const struct firmware *fw);
-int cache_firmware(const char *name);
-int uncache_firmware(const char *name);
 #else
 static inline int request_firmware(const struct firmware **fw,
                                    const char *name,
@@ -68,15 +66,6 @@ static inline void release_firmware(const struct firmware *fw)
 {
 }
 
-static inline int cache_firmware(const char *name)
-{
-        return -ENOENT;
-}
-
-static inline int uncache_firmware(const char *name)
-{
-        return -EINVAL;
-}
 #endif
 
 #endif
diff --git a/include/linux/fmc-sdb.h b/include/linux/fmc-sdb.h
new file mode 100644
index 000000000000..1974317a9b3d
--- /dev/null
+++ b/include/linux/fmc-sdb.h
@@ -0,0 +1,36 @@
+/*
+ * This file is separate from sdb.h, because I want that one to remain
+ * unchanged (as far as possible) from the official sdb distribution
+ *
+ * This file and associated functionality are a playground for me to
+ * understand stuff which will later be implemented in more generic places.
+ */
+#include <linux/sdb.h>
+
+/* This is the union of all currently defined types */
+union sdb_record {
+        struct sdb_interconnect ic;
+        struct sdb_device dev;
+        struct sdb_bridge bridge;
+        struct sdb_integration integr;
+        struct sdb_empty empty;
+};
+
+struct fmc_device;
+
+/* Every sdb table is turned into this structure */
+struct sdb_array {
+        int len;
+        int level;
+        unsigned long baseaddr;
+        struct fmc_device *fmc;         /* the device that hosts it */
+        struct sdb_array *parent;       /* NULL at root */
+        union sdb_record *record;       /* copies of the struct */
+        struct sdb_array **subtree;     /* only valid for bridge items */
+};
+
+extern int fmc_scan_sdb_tree(struct fmc_device *fmc, unsigned long address);
+extern void fmc_show_sdb_tree(const struct fmc_device *fmc);
+extern signed long fmc_find_sdb_device(struct sdb_array *tree, uint64_t vendor,
+                                       uint32_t device, unsigned long *sz);
+extern int fmc_free_sdb_tree(struct fmc_device *fmc);
diff --git a/include/linux/fmc.h b/include/linux/fmc.h
new file mode 100644
index 000000000000..a5f0aa5c2a8d
--- /dev/null
+++ b/include/linux/fmc.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (C) 2012 CERN (www.cern.ch)
+ * Author: Alessandro Rubini <rubini@gnudd.com>
+ *
+ * Released according to the GNU GPL, version 2 or any later version.
+ *
+ * This work is part of the White Rabbit project, a research effort led
+ * by CERN, the European Institute for Nuclear Research.
+ */
+#ifndef __LINUX_FMC_H__
+#define __LINUX_FMC_H__
+#include <linux/types.h>
+#include <linux/moduleparam.h>
+#include <linux/device.h>
+#include <linux/list.h>
+#include <linux/interrupt.h>
+#include <linux/io.h>
+
+struct fmc_device;
+struct fmc_driver;
+
+/*
+ * This bus abstraction is developed separately from drivers, so we need
+ * to check the version of the data structures we receive.
+ */
+
+#define FMC_MAJOR       3
+#define FMC_MINOR       0
+#define FMC_VERSION     ((FMC_MAJOR << 16) | FMC_MINOR)
+#define __FMC_MAJOR(x)  ((x) >> 16)
+#define __FMC_MINOR(x)  ((x) & 0xffff)
+
+/*
+ * The device identification, as defined by the IPMI FRU (Field Replaceable
+ * Unit) includes four different strings to describe the device. Here we
+ * only match the "Board Manufacturer" and the "Board Product Name",
+ * ignoring the "Board Serial Number" and "Board Part Number". All 4 are
+ * expected to be strings, so they are treated as zero-terminated C strings.
+ * Unspecified string (NULL) means "any", so if both are unspecified this
+ * is a catch-all driver. So null entries are allowed and we use array
+ * and length. This is unlike pci and usb that use null-terminated arrays
+ */
+struct fmc_fru_id {
+        char *manufacturer;
+        char *product_name;
+};
+
+/*
+ * If the FPGA is already programmed (think Etherbone or the second
+ * SVEC slot), we can match on SDB devices in the memory image. This
+ * match uses an array of devices that must all be present, and the
+ * match is based on vendor and device only. Further checks are expected
+ * to happen in the probe function. Zero means "any" and catch-all is allowed.
+ */
+struct fmc_sdb_one_id {
+        uint64_t vendor;
+        uint32_t device;
+};
+struct fmc_sdb_id {
+        struct fmc_sdb_one_id *cores;
+        int cores_nr;
+};
+
+struct fmc_device_id {
+        struct fmc_fru_id *fru_id;
+        int fru_id_nr;
+        struct fmc_sdb_id *sdb_id;
+        int sdb_id_nr;
+};
+
+/* This sizes the module_param_array used by generic module parameters */
+#define FMC_MAX_CARDS 32
+
+/* The driver is a pretty simple thing */
+struct fmc_driver {
+        unsigned long version;
+        struct device_driver driver;
+        int (*probe)(struct fmc_device *);
+        int (*remove)(struct fmc_device *);
+        const struct fmc_device_id id_table;
+        /* What follows is for generic module parameters */
+        int busid_n;
+        int busid_val[FMC_MAX_CARDS];
+        int gw_n;
+        char *gw_val[FMC_MAX_CARDS];
+};
+#define to_fmc_driver(x) container_of((x), struct fmc_driver, driver)
+
+/* These are the generic parameters, that drivers may instantiate */
+#define FMC_PARAM_BUSID(_d) \
+    module_param_array_named(busid, _d.busid_val, int, &_d.busid_n, 0444)
+#define FMC_PARAM_GATEWARE(_d) \
+    module_param_array_named(gateware, _d.gw_val, charp, &_d.gw_n, 0444)
+
+/*
+ * Drivers may need to configure gpio pins in the carrier. To read input
+ * (a very uncommon operation, and definitely not in the hot paths), just
+ * configure one gpio only and get 0 or 1 as retval of the config method
+ */
+struct fmc_gpio {
+        char *carrier_name; /* name or NULL for virtual pins */
+        int gpio;
+        int _gpio;      /* internal use by the carrier */
+        int mode;       /* GPIOF_DIR_OUT etc, from <linux/gpio.h> */
+        int irqmode;    /* IRQF_TRIGGER_LOW and so on */
+};
+
+/* The numbering of gpio pins allows access to raw pins or virtual roles */
+#define FMC_GPIO_RAW(x)         (x)             /* 4096 of them */
+#define __FMC_GPIO_IS_RAW(x)    ((x) < 0x1000)
+#define FMC_GPIO_IRQ(x)         ((x) + 0x1000)  /*  256 of them */
+#define FMC_GPIO_LED(x)         ((x) + 0x1100)  /*  256 of them */
+#define FMC_GPIO_KEY(x)         ((x) + 0x1200)  /*  256 of them */
+#define FMC_GPIO_TP(x)          ((x) + 0x1300)  /*  256 of them */
+#define FMC_GPIO_USER(x)        ((x) + 0x1400)  /*  256 of them */
+/* We may add SCL and SDA, or other roles if the need arises */
+
+/* GPIOF_DIR_IN etc are missing before 3.0. copy from <linux/gpio.h> */
+#ifndef GPIOF_DIR_IN
+#  define GPIOF_DIR_OUT   (0 << 0)
+#  define GPIOF_DIR_IN    (1 << 0)
+#  define GPIOF_INIT_LOW  (0 << 1)
+#  define GPIOF_INIT_HIGH (1 << 1)
+#endif
+
+/*
+ * The operations are offered by each carrier and should make driver
+ * design completely independent of the carrier. Named GPIO pins may be
+ * the exception.
+ */
+struct fmc_operations {
+        uint32_t (*read32)(struct fmc_device *fmc, int offset);
+        void (*write32)(struct fmc_device *fmc, uint32_t value, int offset);
+        int (*validate)(struct fmc_device *fmc, struct fmc_driver *drv);
+        int (*reprogram)(struct fmc_device *f, struct fmc_driver *d, char *gw);
+        int (*irq_request)(struct fmc_device *fmc, irq_handler_t h,
+                           char *name, int flags);
+        void (*irq_ack)(struct fmc_device *fmc);
+        int (*irq_free)(struct fmc_device *fmc);
+        int (*gpio_config)(struct fmc_device *fmc, struct fmc_gpio *gpio,
+                           int ngpio);
+        int (*read_ee)(struct fmc_device *fmc, int pos, void *d, int l);
+        int (*write_ee)(struct fmc_device *fmc, int pos, const void *d, int l);
+};
+
+/* Prefer this helper rather than calling of fmc->reprogram directly */
+extern int fmc_reprogram(struct fmc_device *f, struct fmc_driver *d, char *gw,
+                     int sdb_entry);
+
+/*
+ * The device reports all information needed to access hw.
+ *
+ * If we have eeprom_len and not contents, the core reads it.
+ * Then, parsing of identifiers is done by the core which fills fmc_fru_id..
+ * Similarly a device that must be matched based on SDB cores must
+ * fill the entry point and the core will scan the bus (FIXME: sdb match)
+ */
+struct fmc_device {
+        unsigned long version;
+        unsigned long flags;
+        struct module *owner;           /* char device must pin it */
+        struct fmc_fru_id id;           /* for EEPROM-based match */
+        struct fmc_operations *op;      /* carrier-provided */
+        int irq;                        /* according to host bus. 0 == none */
+        int eeprom_len;                 /* Usually 8kB, may be less */
+        int eeprom_addr;                /* 0x50, 0x52 etc */
+        uint8_t *eeprom;                /* Full contents or leading part */
+        char *carrier_name;             /* "SPEC" or similar, for special use */
+        void *carrier_data;             /* "struct spec *" or equivalent */
+        __iomem void *fpga_base;        /* May be NULL (Etherbone) */
+        __iomem void *slot_base;        /* Set by the driver */
+        struct fmc_device **devarray;   /* Allocated by the bus */
+        int slot_id;                    /* Index in the slot array */
+        int nr_slots;                   /* Number of slots in this carrier */
+        unsigned long memlen;           /* Used for the char device */
+        struct device dev;              /* For Linux use */
+        struct device *hwdev;           /* The underlying hardware device */
+        unsigned long sdbfs_entry;
+        struct sdb_array *sdb;
+        uint32_t device_id;             /* Filled by the device */
+        char *mezzanine_name;           /* Defaults to ``fmc'' */
+        void *mezzanine_data;
+};
+#define to_fmc_device(x) container_of((x), struct fmc_device, dev)
+
+#define FMC_DEVICE_HAS_GOLDEN           1
+#define FMC_DEVICE_HAS_CUSTOM           2
+#define FMC_DEVICE_NO_MEZZANINE         4
+#define FMC_DEVICE_MATCH_SDB            8 /* fmc-core must scan sdb in fpga */
+
+/*
+ * If fpga_base can be used, the carrier offers no readl/writel methods, and
+ * this expands to a single, fast, I/O access.
+ */
+static inline uint32_t fmc_readl(struct fmc_device *fmc, int offset)
+{
+        if (unlikely(fmc->op->read32))
+                return fmc->op->read32(fmc, offset);
+        return readl(fmc->fpga_base + offset);
+}
+static inline void fmc_writel(struct fmc_device *fmc, uint32_t val, int off)
+{
+        if (unlikely(fmc->op->write32))
+                fmc->op->write32(fmc, val, off);
+        else
+                writel(val, fmc->fpga_base + off);
+}
+
+/* pci-like naming */
+static inline void *fmc_get_drvdata(const struct fmc_device *fmc)
+{
+        return dev_get_drvdata(&fmc->dev);
+}
+
+static inline void fmc_set_drvdata(struct fmc_device *fmc, void *data)
+{
+        dev_set_drvdata(&fmc->dev, data);
+}
+
+/* The 4 access points */
+extern int fmc_driver_register(struct fmc_driver *drv);
+extern void fmc_driver_unregister(struct fmc_driver *drv);
+extern int fmc_device_register(struct fmc_device *tdev);
+extern void fmc_device_unregister(struct fmc_device *tdev);
+
+/* Two more for device sets, all driven by the same FPGA */
+extern int fmc_device_register_n(struct fmc_device **devs, int n);
+extern void fmc_device_unregister_n(struct fmc_device **devs, int n);
+
+/* Internal cross-calls between files; not exported to other modules */
+extern int fmc_match(struct device *dev, struct device_driver *drv);
+extern int fmc_fill_id_info(struct fmc_device *fmc);
+extern void fmc_free_id_info(struct fmc_device *fmc);
+extern void fmc_dump_eeprom(const struct fmc_device *fmc);
+extern void fmc_dump_sdb(const struct fmc_device *fmc);
+
+#endif /* __LINUX_FMC_H__ */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 43db02e9c9fa..2b82c8041490 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -364,7 +364,7 @@ struct address_space_operations {
 
         /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
         sector_t (*bmap)(struct address_space *, sector_t);
-        void (*invalidatepage) (struct page *, unsigned long);
+        void (*invalidatepage) (struct page *, unsigned int, unsigned int);
         int (*releasepage) (struct page *, gfp_t);
         void (*freepage)(struct page *);
         ssize_t (*direct_IO)(int, struct kiocb *, const struct iovec *iov,
@@ -908,6 +908,7 @@ struct file_lock_operations {
 
 struct lock_manager_operations {
         int (*lm_compare_owner)(struct file_lock *, struct file_lock *);
+        unsigned long (*lm_owner_key)(struct file_lock *);
         void (*lm_notify)(struct file_lock *);  /* unblock callback */
         int (*lm_grant)(struct file_lock *, struct file_lock *, int);
         void (*lm_break)(struct file_lock *);
@@ -926,9 +927,27 @@ int locks_in_grace(struct net *);
 /* that will die - we need it for nfs_lock_info */
 #include <linux/nfs_fs_i.h>
 
+/*
+ * struct file_lock represents a generic "file lock". It's used to represent
+ * POSIX byte range locks, BSD (flock) locks, and leases. It's important to
+ * note that the same struct is used to represent both a request for a lock and
+ * the lock itself, but the same object is never used for both.
+ *
+ * FIXME: should we create a separate "struct lock_request" to help distinguish
+ * these two uses?
+ *
+ * The i_flock list is ordered by:
+ *
+ * 1) lock type -- FL_LEASEs first, then FL_FLOCK, and finally FL_POSIX
+ * 2) lock owner
+ * 3) lock range start
+ * 4) lock range end
+ *
+ * Obviously, the last two criteria only matter for POSIX locks.
+ */
 struct file_lock {
         struct file_lock *fl_next;      /* singly linked list for this inode  */
-        struct list_head fl_link;       /* doubly linked list of all locks */
+        struct hlist_node fl_link;      /* node in global lists */
         struct list_head fl_block;      /* circular list of blocked processes */
         fl_owner_t fl_owner;
         unsigned int fl_flags;
@@ -994,7 +1013,7 @@ extern void locks_release_private(struct file_lock *);
 extern void posix_test_lock(struct file *, struct file_lock *);
 extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
 extern int posix_lock_file_wait(struct file *, struct file_lock *);
-extern int posix_unblock_lock(struct file *, struct file_lock *);
+extern int posix_unblock_lock(struct file_lock *);
 extern int vfs_test_lock(struct file *, struct file_lock *);
 extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
@@ -1006,9 +1025,6 @@ extern int vfs_setlease(struct file *, long, struct file_lock **);
 extern int lease_modify(struct file_lock **, int);
 extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
 extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
-extern void locks_delete_block(struct file_lock *waiter);
-extern void lock_flocks(void);
-extern void unlock_flocks(void);
 #else /* !CONFIG_FILE_LOCKING */
 static inline int fcntl_getlk(struct file *file, struct flock __user *user)
 {
@@ -1084,8 +1100,7 @@ static inline int posix_lock_file_wait(struct file *filp, struct file_lock *fl)
         return -ENOLCK;
 }
 
-static inline int posix_unblock_lock(struct file *filp,
-                                     struct file_lock *waiter)
+static inline int posix_unblock_lock(struct file_lock *waiter)
 {
         return -ENOENT;
 }
@@ -1150,19 +1165,6 @@ static inline int lock_may_write(struct inode *inode, loff_t start,
 {
         return 1;
 }
-
-static inline void locks_delete_block(struct file_lock *waiter)
-{
-}
-
-static inline void lock_flocks(void)
-{
-}
-
-static inline void unlock_flocks(void)
-{
-}
-
 #endif /* !CONFIG_FILE_LOCKING */
 
 
@@ -1506,6 +1508,11 @@ int fiemap_check_flags(struct fiemap_extent_info *fieinfo, u32 fs_flags);
  * to have different dirent layouts depending on the binary type.
  */
 typedef int (*filldir_t)(void *, const char *, int, loff_t, u64, unsigned);
+struct dir_context {
+        const filldir_t actor;
+        loff_t pos;
+};
+
 struct block_device_operations;
 
 /* These macros are for out of kernel modules to test that
@@ -1521,7 +1528,7 @@ struct file_operations {
         ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
         ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
         ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
-        int (*readdir) (struct file *, void *, filldir_t);
+        int (*iterate) (struct file *, struct dir_context *);
         unsigned int (*poll) (struct file *, struct poll_table_struct *);
         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
@@ -1575,6 +1582,7 @@ struct inode_operations {
         int (*atomic_open)(struct inode *, struct dentry *,
                            struct file *, unsigned open_flag,
                            umode_t create_mode, int *opened);
+        int (*tmpfile) (struct inode *, struct dentry *, umode_t);
 } ____cacheline_aligned;
 
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
@@ -1738,6 +1746,7 @@ struct super_operations {
 #define I_REFERENCED            (1 << 8)
 #define __I_DIO_WAKEUP          9
 #define I_DIO_WAKEUP            (1 << I_DIO_WAKEUP)
+#define I_LINKABLE              (1 << 10)
 
 #define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
 
@@ -1891,7 +1900,6 @@ extern int current_umask(void);
 extern struct kobject *fs_kobj;
 
 #define MAX_RW_COUNT (INT_MAX & PAGE_CACHE_MASK)
-extern int rw_verify_area(int, struct file *, loff_t *, size_t);
 
 #define FLOCK_VERIFY_READ  1
 #define FLOCK_VERIFY_WRITE 2
@@ -2304,7 +2312,6 @@ extern struct file * open_exec(const char *);
 /* fs/dcache.c -- generic fs support functions */
 extern int is_subdir(struct dentry *, struct dentry *);
 extern int path_is_under(struct path *, struct path *);
-extern ino_t find_inode_number(struct dentry *, struct qstr *);
 
 #include <linux/err.h>
 
@@ -2414,16 +2421,17 @@ extern ssize_t generic_file_splice_write(struct pipe_inode_info *,
                 struct file *, loff_t *, size_t, unsigned int);
 extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
                 struct file *out, loff_t *, size_t len, unsigned int flags);
-extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
-                size_t len, unsigned int flags);
 
 extern void
 file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
 extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
 extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
+extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
 extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
 extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
                 int whence, loff_t maxsize, loff_t eof);
+extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
+                int whence, loff_t size);
 extern int generic_file_open(struct inode * inode, struct file * filp);
 extern int nonseekable_open(struct inode * inode, struct file * filp);
 
@@ -2496,6 +2504,7 @@ loff_t inode_get_bytes(struct inode *inode);
 void inode_set_bytes(struct inode *inode, loff_t bytes);
 
 extern int vfs_readdir(struct file *, filldir_t, void *);
+extern int iterate_dir(struct file *, struct dir_context *);
 
 extern int vfs_stat(const char __user *, struct kstat *);
 extern int vfs_lstat(const char __user *, struct kstat *);
@@ -2526,7 +2535,7 @@ extern void iterate_supers_type(struct file_system_type *,
 extern int dcache_dir_open(struct inode *, struct file *);
 extern int dcache_dir_close(struct inode *, struct file *);
 extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
-extern int dcache_readdir(struct file *, void *, filldir_t);
+extern int dcache_readdir(struct file *, struct dir_context *);
 extern int simple_setattr(struct dentry *, struct iattr *);
 extern int simple_getattr(struct vfsmount *, struct dentry *, struct kstat *);
 extern int simple_statfs(struct dentry *, struct kstatfs *);
@@ -2690,4 +2699,41 @@ static inline void inode_has_no_xattr(struct inode *inode)
                 inode->i_flags |= S_NOSEC;
 }
 
+static inline bool dir_emit(struct dir_context *ctx,
+                            const char *name, int namelen,
+                            u64 ino, unsigned type)
+{
+        return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
+}
+static inline bool dir_emit_dot(struct file *file, struct dir_context *ctx)
+{
+        return ctx->actor(ctx, ".", 1, ctx->pos,
+                          file->f_path.dentry->d_inode->i_ino, DT_DIR) == 0;
+}
+static inline bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
+{
+        return ctx->actor(ctx, "..", 2, ctx->pos,
+                          parent_ino(file->f_path.dentry), DT_DIR) == 0;
+}
+static inline bool dir_emit_dots(struct file *file, struct dir_context *ctx)
+{
+        if (ctx->pos == 0) {
+                if (!dir_emit_dot(file, ctx))
+                        return false;
+                ctx->pos = 1;
+        }
+        if (ctx->pos == 1) {
+                if (!dir_emit_dotdot(file, ctx))
+                        return false;
+                ctx->pos = 2;
+        }
+        return true;
+}
+static inline bool dir_relax(struct inode *inode)
+{
+        mutex_unlock(&inode->i_mutex);
+        mutex_lock(&inode->i_mutex);
+        return !IS_DEADDIR(inode);
+}
+
 #endif /* _LINUX_FS_H */
diff --git a/include/linux/fscache-cache.h b/include/linux/fscache-cache.h
index 5dfa0aa216b6..a9ff9a36b86d 100644
--- a/include/linux/fscache-cache.h
+++ b/include/linux/fscache-cache.h
@@ -97,7 +97,8 @@ struct fscache_operation {
 #define FSCACHE_OP_WAITING      4       /* cleared when op is woken */
 #define FSCACHE_OP_EXCLUSIVE    5       /* exclusive op, other ops must wait */
 #define FSCACHE_OP_DEC_READ_CNT 6       /* decrement object->n_reads on destruction */
-#define FSCACHE_OP_KEEP_FLAGS   0x0070  /* flags to keep when repurposing an op */
+#define FSCACHE_OP_UNUSE_COOKIE 7       /* call fscache_unuse_cookie() on completion */
+#define FSCACHE_OP_KEEP_FLAGS   0x00f0  /* flags to keep when repurposing an op */
 
         enum fscache_operation_state state;
         atomic_t                usage;
@@ -150,7 +151,7 @@ struct fscache_retrieval {
         void                    *context;       /* netfs read context (pinned) */
         struct list_head        to_do;          /* list of things to be done by the backend */
         unsigned long           start_time;     /* time at which retrieval started */
-        unsigned                n_pages;        /* number of pages to be retrieved */
+        atomic_t                n_pages;        /* number of pages to be retrieved */
 };
 
 typedef int (*fscache_page_retrieval_func_t)(struct fscache_retrieval *op,
@@ -194,15 +195,14 @@ static inline void fscache_enqueue_retrieval(struct fscache_retrieval *op)
 static inline void fscache_retrieval_complete(struct fscache_retrieval *op,
                                               int n_pages)
 {
-        op->n_pages -= n_pages;
-        if (op->n_pages <= 0)
+        atomic_sub(n_pages, &op->n_pages);
+        if (atomic_read(&op->n_pages) <= 0)
                 fscache_op_complete(&op->op, true);
 }
 
 /**
  * fscache_put_retrieval - Drop a reference to a retrieval operation
  * @op: The retrieval operation affected
- * @n_pages: The number of pages to account for
  *
  * Drop a reference to a retrieval operation.
  */
@@ -314,6 +314,7 @@ struct fscache_cache_ops {
 struct fscache_cookie {
         atomic_t                        usage;          /* number of users of this cookie */
         atomic_t                        n_children;     /* number of children of this cookie */
+        atomic_t                        n_active;       /* number of active users of netfs ptrs */
         spinlock_t                      lock;
         spinlock_t                      stores_lock;    /* lock on page store tree */
         struct hlist_head               backing_objects; /* object(s) backing this file/index */
@@ -326,13 +327,11 @@ struct fscache_cookie {
 
         unsigned long                   flags;
 #define FSCACHE_COOKIE_LOOKING_UP       0       /* T if non-index cookie being looked up still */
-#define FSCACHE_COOKIE_CREATING         1       /* T if non-index object being created still */
-#define FSCACHE_COOKIE_NO_DATA_YET      2       /* T if new object with no cached data yet */
-#define FSCACHE_COOKIE_PENDING_FILL     3       /* T if pending initial fill on object */
-#define FSCACHE_COOKIE_FILLING          4       /* T if filling object incrementally */
-#define FSCACHE_COOKIE_UNAVAILABLE      5       /* T if cookie is unavailable (error, etc) */
-#define FSCACHE_COOKIE_WAITING_ON_READS 6       /* T if cookie is waiting on reads */
-#define FSCACHE_COOKIE_INVALIDATING     7       /* T if cookie is being invalidated */
+#define FSCACHE_COOKIE_NO_DATA_YET      1       /* T if new object with no cached data yet */
+#define FSCACHE_COOKIE_UNAVAILABLE      2       /* T if cookie is unavailable (error, etc) */
+#define FSCACHE_COOKIE_INVALIDATING     3       /* T if cookie is being invalidated */
+#define FSCACHE_COOKIE_RELINQUISHED     4       /* T if cookie has been relinquished */
+#define FSCACHE_COOKIE_RETIRED          5       /* T if cookie was retired */
 };
 
 extern struct fscache_cookie fscache_fsdef_index;
@@ -341,45 +340,40 @@ extern struct fscache_cookie fscache_fsdef_index;
  * Event list for fscache_object::{event_mask,events}
  */
 enum {
-        FSCACHE_OBJECT_EV_REQUEUE,      /* T if object should be requeued */
+        FSCACHE_OBJECT_EV_NEW_CHILD,    /* T if object has a new child */
+        FSCACHE_OBJECT_EV_PARENT_READY, /* T if object's parent is ready */
         FSCACHE_OBJECT_EV_UPDATE,       /* T if object should be updated */
         FSCACHE_OBJECT_EV_INVALIDATE,   /* T if cache requested object invalidation */
         FSCACHE_OBJECT_EV_CLEARED,      /* T if accessors all gone */
         FSCACHE_OBJECT_EV_ERROR,        /* T if fatal error occurred during processing */
-        FSCACHE_OBJECT_EV_RELEASE,      /* T if netfs requested object release */
-        FSCACHE_OBJECT_EV_RETIRE,       /* T if netfs requested object retirement */
-        FSCACHE_OBJECT_EV_WITHDRAW,     /* T if cache requested object withdrawal */
+        FSCACHE_OBJECT_EV_KILL,         /* T if netfs relinquished or cache withdrew object */
         NR_FSCACHE_OBJECT_EVENTS
 };
 
 #define FSCACHE_OBJECT_EVENTS_MASK ((1UL << NR_FSCACHE_OBJECT_EVENTS) - 1)
 
 /*
+ * States for object state machine.
+ */
+struct fscache_transition {
+        unsigned long events;
+        const struct fscache_state *transit_to;
+};
+
+struct fscache_state {
+        char name[24];
+        char short_name[8];
+        const struct fscache_state *(*work)(struct fscache_object *object,
+                                            int event);
+        const struct fscache_transition transitions[];
+};
+
+/*
  * on-disk cache file or index handle
  */
 struct fscache_object {
-        enum fscache_object_state {
-                FSCACHE_OBJECT_INIT,            /* object in initial unbound state */
-                FSCACHE_OBJECT_LOOKING_UP,      /* looking up object */
-                FSCACHE_OBJECT_CREATING,        /* creating object */
-
-                /* active states */
-                FSCACHE_OBJECT_AVAILABLE,       /* cleaning up object after creation */
-                FSCACHE_OBJECT_ACTIVE,          /* object is usable */
-                FSCACHE_OBJECT_INVALIDATING,    /* object is invalidating */
-                FSCACHE_OBJECT_UPDATING,        /* object is updating */
-
-                /* terminal states */
-                FSCACHE_OBJECT_DYING,           /* object waiting for accessors to finish */
-                FSCACHE_OBJECT_LC_DYING,        /* object cleaning up after lookup/create */
-                FSCACHE_OBJECT_ABORT_INIT,      /* abort the init state */
-                FSCACHE_OBJECT_RELEASING,       /* releasing object */
-                FSCACHE_OBJECT_RECYCLING,       /* retiring object */
-                FSCACHE_OBJECT_WITHDRAWING,     /* withdrawing object */
-                FSCACHE_OBJECT_DEAD,            /* object is now dead */
-                FSCACHE_OBJECT__NSTATES
-        } state;
-
+        const struct fscache_state *state;      /* Object state machine state */
+        const struct fscache_transition *oob_table; /* OOB state transition table */
         int                     debug_id;       /* debugging ID */
         int                     n_children;     /* number of child objects */
         int                     n_ops;          /* number of extant ops on object */
@@ -390,6 +384,7 @@ struct fscache_object {
         spinlock_t              lock;           /* state and operations lock */
 
         unsigned long           lookup_jif;     /* time at which lookup started */
+        unsigned long           oob_event_mask; /* OOB events this object is interested in */
         unsigned long           event_mask;     /* events this object is interested in */
         unsigned long           events;         /* events to be processed by this object
                                                  * (order is important - using fls) */
@@ -398,6 +393,9 @@ struct fscache_object {
 #define FSCACHE_OBJECT_LOCK             0       /* T if object is busy being processed */
 #define FSCACHE_OBJECT_PENDING_WRITE    1       /* T if object has pending write */
 #define FSCACHE_OBJECT_WAITING          2       /* T if object is waiting on its parent */
+#define FSCACHE_OBJECT_IS_LIVE          3       /* T if object is not withdrawn or relinquished */
+#define FSCACHE_OBJECT_IS_LOOKED_UP     4       /* T if object has been looked up */
+#define FSCACHE_OBJECT_IS_AVAILABLE     5       /* T if object has become active */
 
         struct list_head        cache_link;     /* link in cache->object_list */
         struct hlist_node       cookie_link;    /* link in cookie->backing_objects */
@@ -415,62 +413,40 @@ struct fscache_object {
         loff_t                  store_limit_l;  /* current storage limit */
 };
 
-extern const char *fscache_object_states[];
+extern void fscache_object_init(struct fscache_object *, struct fscache_cookie *,
+                                struct fscache_cache *);
+extern void fscache_object_destroy(struct fscache_object *);
 
-#define fscache_object_is_active(obj)                         \
-        (!test_bit(FSCACHE_IOERROR, &(obj)->cache->flags) &&  \
-         (obj)->state >= FSCACHE_OBJECT_AVAILABLE &&          \
-         (obj)->state < FSCACHE_OBJECT_DYING)
+extern void fscache_object_lookup_negative(struct fscache_object *object);
+extern void fscache_obtained_object(struct fscache_object *object);
 
-#define fscache_object_is_dead(obj)                             \
-        (test_bit(FSCACHE_IOERROR, &(obj)->cache->flags) &&     \
-         (obj)->state >= FSCACHE_OBJECT_DYING)
+static inline bool fscache_object_is_live(struct fscache_object *object)
+{
+        return test_bit(FSCACHE_OBJECT_IS_LIVE, &object->flags);
+}
 
-extern void fscache_object_work_func(struct work_struct *work);
+static inline bool fscache_object_is_dying(struct fscache_object *object)
+{
+        return !fscache_object_is_live(object);
+}
 
-/**
- * fscache_object_init - Initialise a cache object description
- * @object: Object description
- *
- * Initialise a cache object description to its basic values.
- *
- * See Documentation/filesystems/caching/backend-api.txt for a complete
- * description.
- */
-static inline
-void fscache_object_init(struct fscache_object *object,
-                         struct fscache_cookie *cookie,
-                         struct fscache_cache *cache)
+static inline bool fscache_object_is_available(struct fscache_object *object)
 {
-        atomic_inc(&cache->object_count);
-
-        object->state = FSCACHE_OBJECT_INIT;
-        spin_lock_init(&object->lock);
-        INIT_LIST_HEAD(&object->cache_link);
-        INIT_HLIST_NODE(&object->cookie_link);
-        INIT_WORK(&object->work, fscache_object_work_func);
-        INIT_LIST_HEAD(&object->dependents);
-        INIT_LIST_HEAD(&object->dep_link);
-        INIT_LIST_HEAD(&object->pending_ops);
-        object->n_children = 0;
-        object->n_ops = object->n_in_progress = object->n_exclusive = 0;
-        object->events = object->event_mask = 0;
-        object->flags = 0;
-        object->store_limit = 0;
-        object->store_limit_l = 0;
-        object->cache = cache;
-        object->cookie = cookie;
-        object->parent = NULL;
+        return test_bit(FSCACHE_OBJECT_IS_AVAILABLE, &object->flags);
 }
 
-extern void fscache_object_lookup_negative(struct fscache_object *object);
-extern void fscache_obtained_object(struct fscache_object *object);
+static inline bool fscache_object_is_active(struct fscache_object *object)
+{
+        return fscache_object_is_available(object) &&
+                fscache_object_is_live(object) &&
+                !test_bit(FSCACHE_IOERROR, &object->cache->flags);
+}
 
-#ifdef CONFIG_FSCACHE_OBJECT_LIST
-extern void fscache_object_destroy(struct fscache_object *object);
-#else
-#define fscache_object_destroy(object) do {} while(0)
-#endif
+static inline bool fscache_object_is_dead(struct fscache_object *object)
+{
+        return fscache_object_is_dying(object) &&
+                test_bit(FSCACHE_IOERROR, &object->cache->flags);
+}
 
 /**
  * fscache_object_destroyed - Note destruction of an object in a cache
@@ -531,6 +507,33 @@ static inline void fscache_end_io(struct fscache_retrieval *op,
         op->end_io_func(page, op->context, error);
 }
 
+/**
+ * fscache_use_cookie - Request usage of cookie attached to an object
+ * @object: Object description
+ * 
+ * Request usage of the cookie attached to an object.  NULL is returned if the
+ * relinquishment had reduced the cookie usage count to 0.
+ */
+static inline bool fscache_use_cookie(struct fscache_object *object)
+{
+        struct fscache_cookie *cookie = object->cookie;
+        return atomic_inc_not_zero(&cookie->n_active) != 0;
+}
+
+/**
+ * fscache_unuse_cookie - Cease usage of cookie attached to an object
+ * @object: Object description
+ * 
+ * Cease usage of the cookie attached to an object.  When the users count
+ * reaches zero then the cookie relinquishment will be permitted to proceed.
+ */
+static inline void fscache_unuse_cookie(struct fscache_object *object)
+{
+        struct fscache_cookie *cookie = object->cookie;
+        if (atomic_dec_and_test(&cookie->n_active))
+                wake_up_atomic_t(&cookie->n_active);
+}
+
 /*
  * out-of-line cache backend functions
  */
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index a78680a92dba..1c804b057fb1 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -38,7 +38,7 @@ static inline int fsnotify_parent(struct path *path, struct dentry *dentry, __u3
 static inline int fsnotify_perm(struct file *file, int mask)
 {
         struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 fsnotify_mask = 0;
         int ret;
 
@@ -192,7 +192,7 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 static inline void fsnotify_access(struct file *file)
 {
         struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_ACCESS;
 
         if (S_ISDIR(inode->i_mode))
@@ -210,7 +210,7 @@ static inline void fsnotify_access(struct file *file)
 static inline void fsnotify_modify(struct file *file)
 {
         struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_MODIFY;
 
         if (S_ISDIR(inode->i_mode))
@@ -228,7 +228,7 @@ static inline void fsnotify_modify(struct file *file)
 static inline void fsnotify_open(struct file *file)
 {
         struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_OPEN;
 
         if (S_ISDIR(inode->i_mode))
diff --git a/include/linux/hardirq.h b/include/linux/hardirq.h
index c1d6555d2567..05bcc0903766 100644
--- a/include/linux/hardirq.h
+++ b/include/linux/hardirq.h
@@ -128,7 +128,7 @@ extern void synchronize_irq(unsigned int irq);
 # define synchronize_irq(irq)   barrier()
 #endif
 
-#if defined(CONFIG_TINY_RCU) || defined(CONFIG_TINY_PREEMPT_RCU)
+#if defined(CONFIG_TINY_RCU)
 
 static inline void rcu_nmi_enter(void)
 {
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 981546ad231c..89d4fbf681e7 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -362,6 +362,17 @@ static inline int hstate_index(struct hstate *h)
         return h - hstates;
 }
 
+pgoff_t __basepage_index(struct page *page);
+
+/* Return page->index in PAGE_SIZE units */
+static inline pgoff_t basepage_index(struct page *page)
+{
+        if (!PageCompound(page))
+                return page->index;
+
+        return __basepage_index(page);
+}
+
 #else   /* CONFIG_HUGETLB_PAGE */
 struct hstate {};
 #define alloc_huge_page_node(h, nid) NULL
@@ -382,6 +393,11 @@ static inline unsigned int pages_per_huge_page(struct hstate *h)
 }
 #define hstate_index_to_shift(index) 0
 #define hstate_index(h) 0
+
+static inline pgoff_t basepage_index(struct page *page)
+{
+        return page->index;
+}
 #endif  /* CONFIG_HUGETLB_PAGE */
 
 #endif /* _LINUX_HUGETLB_H */
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index c2559847d7ee..fae8bac907ef 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -909,6 +909,7 @@ enum vmbus_channel_state {
         CHANNEL_OFFER_STATE,
         CHANNEL_OPENING_STATE,
         CHANNEL_OPEN_STATE,
+        CHANNEL_OPENED_STATE,
 };
 
 struct vmbus_channel_debug_info {
@@ -1046,6 +1047,38 @@ struct vmbus_channel {
          * preserve the earlier behavior.
          */
         u32 target_vp;
+        /*
+         * Support for sub-channels. For high performance devices,
+         * it will be useful to have multiple sub-channels to support
+         * a scalable communication infrastructure with the host.
+         * The support for sub-channels is implemented as an extention
+         * to the current infrastructure.
+         * The initial offer is considered the primary channel and this
+         * offer message will indicate if the host supports sub-channels.
+         * The guest is free to ask for sub-channels to be offerred and can
+         * open these sub-channels as a normal "primary" channel. However,
+         * all sub-channels will have the same type and instance guids as the
+         * primary channel. Requests sent on a given channel will result in a
+         * response on the same channel.
+         */
+
+        /*
+         * Sub-channel creation callback. This callback will be called in
+         * process context when a sub-channel offer is received from the host.
+         * The guest can open the sub-channel in the context of this callback.
+         */
+        void (*sc_creation_callback)(struct vmbus_channel *new_sc);
+
+        spinlock_t sc_lock;
+        /*
+         * All Sub-channels of a primary channel are linked here.
+         */
+        struct list_head sc_list;
+        /*
+         * The primary channel this sub-channel belongs to.
+         * This will be NULL for the primary channel.
+         */
+        struct vmbus_channel *primary_channel;
 };
 
 static inline void set_channel_read_state(struct vmbus_channel *c, bool state)
@@ -1057,6 +1090,34 @@ void vmbus_onmessage(void *context);
 
 int vmbus_request_offers(void);
 
+/*
+ * APIs for managing sub-channels.
+ */
+
+void vmbus_set_sc_create_callback(struct vmbus_channel *primary_channel,
+                        void (*sc_cr_cb)(struct vmbus_channel *new_sc));
+
+/*
+ * Retrieve the (sub) channel on which to send an outgoing request.
+ * When a primary channel has multiple sub-channels, we choose a
+ * channel whose VCPU binding is closest to the VCPU on which
+ * this call is being made.
+ */
+struct vmbus_channel *vmbus_get_outgoing_channel(struct vmbus_channel *primary);
+
+/*
+ * Check if sub-channels have already been offerred. This API will be useful
+ * when the driver is unloaded after establishing sub-channels. In this case,
+ * when the driver is re-loaded, the driver would have to check if the
+ * subchannels have already been established before attempting to request
+ * the creation of sub-channels.
+ * This function returns TRUE to indicate that subchannels have already been
+ * created.
+ * This function should be invoked after setting the callback function for
+ * sub-channel creation.
+ */
+bool vmbus_are_subchannels_present(struct vmbus_channel *primary);
+
 /* The format must be the same as struct vmdata_gpa_direct */
 struct vmbus_channel_packet_page_buffer {
         u16 type;
@@ -1327,6 +1388,15 @@ void vmbus_driver_unregister(struct hv_driver *hv_driver);
                         0x8e, 0x77, 0x05, 0x58, 0xeb, 0x10, 0x73, 0xf8 \
                 }
 
+/*
+ * Synthetic FC GUID
+ * {2f9bcc4a-0069-4af3-b76b-6fd0be528cda}
+ */
+#define HV_SYNTHFC_GUID \
+        .guid = { \
+                        0x4A, 0xCC, 0x9B, 0x2F, 0x69, 0x00, 0xF3, 0x4A, \
+                        0xB7, 0x6B, 0x6F, 0xD0, 0xBE, 0x52, 0x8C, 0xDA \
+                }
 
 /*
  * Common header for Hyper-V ICs
diff --git a/include/linux/if_ether.h b/include/linux/if_ether.h
index 12b4d55a02af..d5569734f672 100644
--- a/include/linux/if_ether.h
+++ b/include/linux/if_ether.h
@@ -30,7 +30,6 @@ static inline struct ethhdr *eth_hdr(const struct sk_buff *skb)
 
 int eth_header_parse(const struct sk_buff *skb, unsigned char *haddr);
 
-int mac_pton(const char *s, u8 *mac);
 extern ssize_t sysfs_format_mac(char *buf, const unsigned char *addr, int len);
 
 #endif  /* _LINUX_IF_ETHER_H */
diff --git a/include/linux/if_team.h b/include/linux/if_team.h
index 4474557904f6..16fae6436d0e 100644
--- a/include/linux/if_team.h
+++ b/include/linux/if_team.h
@@ -249,12 +249,12 @@ team_get_first_port_txable_rcu(struct team *team, struct team_port *port)
                 return port;
         cur = port;
         list_for_each_entry_continue_rcu(cur, &team->port_list, list)
-                if (team_port_txable(port))
+                if (team_port_txable(cur))
                         return cur;
         list_for_each_entry_rcu(cur, &team->port_list, list) {
                 if (cur == port)
                         break;
-                if (team_port_txable(port))
+                if (team_port_txable(cur))
                         return cur;
         }
         return NULL;
diff --git a/include/linux/if_vlan.h b/include/linux/if_vlan.h
index 52bd03b38962..637fa71de0c7 100644
--- a/include/linux/if_vlan.h
+++ b/include/linux/if_vlan.h
@@ -44,7 +44,7 @@ struct vlan_hdr {
  *      struct vlan_ethhdr - vlan ethernet header (ethhdr + vlan_hdr)
  *      @h_dest: destination ethernet address
  *      @h_source: source ethernet address
- *      @h_vlan_proto: ethernet protocol (always 0x8100)
+ *      @h_vlan_proto: ethernet protocol
  *      @h_vlan_TCI: priority and VLAN ID
  *      @h_vlan_encapsulated_proto: packet type ID or len
  */
diff --git a/include/linux/iio/common/st_sensors.h b/include/linux/iio/common/st_sensors.h
index 172c5b23cb84..72b26940730d 100644
--- a/include/linux/iio/common/st_sensors.h
+++ b/include/linux/iio/common/st_sensors.h
@@ -24,14 +24,10 @@
 #define ST_SENSORS_FULLSCALE_AVL_MAX            10
 
 #define ST_SENSORS_NUMBER_ALL_CHANNELS          4
-#define ST_SENSORS_NUMBER_DATA_CHANNELS         3
 #define ST_SENSORS_ENABLE_ALL_AXIS              0x07
-#define ST_SENSORS_BYTE_FOR_CHANNEL             2
 #define ST_SENSORS_SCAN_X                       0
 #define ST_SENSORS_SCAN_Y                       1
 #define ST_SENSORS_SCAN_Z                       2
-#define ST_SENSORS_DEFAULT_12_REALBITS          12
-#define ST_SENSORS_DEFAULT_16_REALBITS          16
 #define ST_SENSORS_DEFAULT_POWER_ON_VALUE       0x01
 #define ST_SENSORS_DEFAULT_POWER_OFF_VALUE      0x00
 #define ST_SENSORS_DEFAULT_WAI_ADDRESS          0x0f
@@ -42,20 +38,20 @@
 #define ST_SENSORS_MAX_NAME                     17
 #define ST_SENSORS_MAX_4WAI                     7
 
-#define ST_SENSORS_LSM_CHANNELS(device_type, index, mod, endian, bits, addr) \
+#define ST_SENSORS_LSM_CHANNELS(device_type, mask, index, mod, \
+                                        ch2, s, endian, rbits, sbits, addr) \
 { \
         .type = device_type, \
-        .modified = 1, \
-        .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
-                        BIT(IIO_CHAN_INFO_SCALE), \
+        .modified = mod, \
+        .info_mask_separate = mask, \
         .scan_index = index, \
-        .channel2 = mod, \
+        .channel2 = ch2, \
         .address = addr, \
         .scan_type = { \
-                .sign = 's', \
-                .realbits = bits, \
-                .shift = 16 - bits, \
-                .storagebits = 16, \
+                .sign = s, \
+                .realbits = rbits, \
+                .shift = sbits - rbits, \
+                .storagebits = sbits, \
                 .endianness = endian, \
         }, \
 }
@@ -204,6 +200,7 @@ struct st_sensors {
  * @multiread_bit: Use or not particular bit for [I2C/SPI] multiread.
  * @buffer_data: Data used by buffer part.
  * @odr: Output data rate of the sensor [Hz].
+ * num_data_channels: Number of data channels used in buffer.
  * @get_irq_data_ready: Function to get the IRQ used for data ready signal.
  * @tf: Transfer function structure used by I/O operations.
  * @tb: Transfer buffers and mutex used by I/O operations.
@@ -220,6 +217,7 @@ struct st_sensor_data {
         char *buffer_data;
 
         unsigned int odr;
+        unsigned int num_data_channels;
 
         unsigned int (*get_irq_data_ready) (struct iio_dev *indio_dev);
 
diff --git a/include/linux/iio/frequency/adf4350.h b/include/linux/iio/frequency/adf4350.h
index be91f344d5fc..ffd8c8f90928 100644
--- a/include/linux/iio/frequency/adf4350.h
+++ b/include/linux/iio/frequency/adf4350.h
@@ -1,7 +1,7 @@
 /*
  * ADF4350/ADF4351 SPI PLL driver
  *
- * Copyright 2012 Analog Devices Inc.
+ * Copyright 2012-2013 Analog Devices Inc.
  *
  * Licensed under the GPL-2.
  */
@@ -41,7 +41,7 @@
 #define ADF4350_REG2_RDIV2_EN                   (1 << 24)
 #define ADF4350_REG2_RMULT2_EN                  (1 << 25)
 #define ADF4350_REG2_MUXOUT(x)                  ((x) << 26)
-#define ADF4350_REG2_NOISE_MODE(x)              ((x) << 29)
+#define ADF4350_REG2_NOISE_MODE(x)              (((unsigned)(x)) << 29)
 #define ADF4350_MUXOUT_THREESTATE               0
 #define ADF4350_MUXOUT_DVDD                     1
 #define ADF4350_MUXOUT_GND                      2
diff --git a/include/linux/ipmi-fru.h b/include/linux/ipmi-fru.h
new file mode 100644
index 000000000000..4d3a76380e32
--- /dev/null
+++ b/include/linux/ipmi-fru.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2012 CERN (www.cern.ch)
+ * Author: Alessandro Rubini <rubini@gnudd.com>
+ *
+ * Released according to the GNU GPL, version 2 or any later version.
+ *
+ * This work is part of the White Rabbit project, a research effort led
+ * by CERN, the European Institute for Nuclear Research.
+ */
+#ifndef __LINUX_IPMI_FRU_H__
+#define __LINUX_IPMI_FRU_H__
+#ifdef __KERNEL__
+#  include <linux/types.h>
+#  include <linux/string.h>
+#else
+#  include <stdint.h>
+#  include <string.h>
+#endif
+
+/*
+ * These structures match the unaligned crap we have in FRU1011.pdf
+ * (http://download.intel.com/design/servers/ipmi/FRU1011.pdf)
+ */
+
+/* chapter 8, page 5 */
+struct fru_common_header {
+        uint8_t format;                 /* 0x01 */
+        uint8_t internal_use_off;       /* multiple of 8 bytes */
+        uint8_t chassis_info_off;       /* multiple of 8 bytes */
+        uint8_t board_area_off;         /* multiple of 8 bytes */
+        uint8_t product_area_off;       /* multiple of 8 bytes */
+        uint8_t multirecord_off;        /* multiple of 8 bytes */
+        uint8_t pad;                    /* must be 0 */
+        uint8_t checksum;               /* sum modulo 256 must be 0 */
+};
+
+/* chapter 9, page 5 -- internal_use: not used by us */
+
+/* chapter 10, page 6 -- chassis info: not used by us */
+
+/* chapter 13, page 9 -- used by board_info_area below */
+struct fru_type_length {
+        uint8_t type_length;
+        uint8_t data[0];
+};
+
+/* chapter 11, page 7 */
+struct fru_board_info_area {
+        uint8_t format;                 /* 0x01 */
+        uint8_t area_len;               /* multiple of 8 bytes */
+        uint8_t language;               /* I hope it's 0 */
+        uint8_t mfg_date[3];            /* LSB, minutes since 1996-01-01 */
+        struct fru_type_length tl[0];   /* type-length stuff follows */
+
+        /*
+         * the TL there are in order:
+         * Board Manufacturer
+         * Board Product Name
+         * Board Serial Number
+         * Board Part Number
+         * FRU File ID (may be null)
+         * more manufacturer-specific stuff
+         * 0xc1 as a terminator
+         * 0x00 pad to a multiple of 8 bytes - 1
+         * checksum (sum of all stuff module 256 must be zero)
+         */
+};
+
+enum fru_type {
+        FRU_TYPE_BINARY         = 0x00,
+        FRU_TYPE_BCDPLUS        = 0x40,
+        FRU_TYPE_ASCII6         = 0x80,
+        FRU_TYPE_ASCII          = 0xc0, /* not ascii: depends on language */
+};
+
+/*
+ * some helpers
+ */
+static inline struct fru_board_info_area *fru_get_board_area(
+        const struct fru_common_header *header)
+{
+        /* we know for sure that the header is 8 bytes in size */
+        return (struct fru_board_info_area *)(header + header->board_area_off);
+}
+
+static inline int fru_type(struct fru_type_length *tl)
+{
+        return tl->type_length & 0xc0;
+}
+
+static inline int fru_length(struct fru_type_length *tl)
+{
+        return (tl->type_length & 0x3f) + 1; /* len of whole record */
+}
+
+/* assume ascii-latin1 encoding */
+static inline int fru_strlen(struct fru_type_length *tl)
+{
+        return fru_length(tl) - 1;
+}
+
+static inline char *fru_strcpy(char *dest, struct fru_type_length *tl)
+{
+        int len = fru_strlen(tl);
+        memcpy(dest, tl->data, len);
+        dest[len] = '\0';
+        return dest;
+}
+
+static inline struct fru_type_length *fru_next_tl(struct fru_type_length *tl)
+{
+        return tl + fru_length(tl);
+}
+
+static inline int fru_is_eof(struct fru_type_length *tl)
+{
+        return tl->type_length == 0xc1;
+}
+
+/*
+ * External functions defined in fru-parse.c.
+ */
+extern int fru_header_cksum_ok(struct fru_common_header *header);
+extern int fru_bia_cksum_ok(struct fru_board_info_area *bia);
+
+/* All these 4 return allocated strings by calling fru_alloc() */
+extern char *fru_get_board_manufacturer(struct fru_common_header *header);
+extern char *fru_get_product_name(struct fru_common_header *header);
+extern char *fru_get_serial_number(struct fru_common_header *header);
+extern char *fru_get_part_number(struct fru_common_header *header);
+
+/* This must be defined by the caller of the above functions */
+extern void *fru_alloc(size_t size);
+
+#endif /* __LINUX_IMPI_FRU_H__ */
diff --git a/include/linux/irq.h b/include/linux/irq.h
index bc4e06611958..f04d3ba335cb 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -119,6 +119,7 @@ struct irq_domain;
 
 /**
  * struct irq_data - per irq and irq chip data passed down to chip functions
+ * @mask:               precomputed bitmask for accessing the chip registers
  * @irq:                interrupt number
  * @hwirq:              hardware interrupt number, local to the interrupt domain
  * @node:               node index useful for balancing
@@ -138,6 +139,7 @@ struct irq_domain;
  * irq_data.
  */
 struct irq_data {
+        u32                     mask;
         unsigned int            irq;
         unsigned long           hwirq;
         unsigned int            node;
@@ -294,6 +296,7 @@ static inline irq_hw_number_t irqd_to_hwirq(struct irq_data *d)
  * @irq_suspend:        function called from core code on suspend once per chip
  * @irq_resume:         function called from core code on resume once per chip
  * @irq_pm_shutdown:    function called from core code on shutdown once per chip
+ * @irq_calc_mask:      Optional function to set irq_data.mask for special cases
  * @irq_print_chip:     optional to print special chip info in show_interrupts
  * @flags:              chip specific flags
  */
@@ -325,6 +328,8 @@ struct irq_chip {
         void            (*irq_resume)(struct irq_data *data);
         void            (*irq_pm_shutdown)(struct irq_data *data);
 
+        void            (*irq_calc_mask)(struct irq_data *data);
+
         void            (*irq_print_chip)(struct irq_data *data, struct seq_file *p);
 
         unsigned long   flags;
@@ -579,6 +584,12 @@ static inline struct msi_desc *irq_data_get_msi(struct irq_data *d)
         return d->msi_desc;
 }
 
+static inline u32 irq_get_trigger_type(unsigned int irq)
+{
+        struct irq_data *d = irq_get_irq_data(irq);
+        return d ? irqd_get_trigger_type(d) : 0;
+}
+
 int __irq_alloc_descs(int irq, unsigned int from, unsigned int cnt, int node,
                 struct module *owner);
 
@@ -644,6 +655,8 @@ struct irq_chip_regs {
  * @regs:               Register offsets for this chip
  * @handler:            Flow handler associated with this chip
  * @type:               Chip can handle these flow types
+ * @mask_cache_priv:    Cached mask register private to the chip type
+ * @mask_cache:         Pointer to cached mask register
  *
  * A irq_generic_chip can have several instances of irq_chip_type when
  * it requires different functions and register offsets for different
@@ -654,6 +667,8 @@ struct irq_chip_type {
         struct irq_chip_regs    regs;
         irq_flow_handler_t      handler;
         u32                     type;
+        u32                     mask_cache_priv;
+        u32                     *mask_cache;
 };
 
 /**
@@ -662,13 +677,16 @@ struct irq_chip_type {
  * @reg_base:           Register base address (virtual)
  * @irq_base:           Interrupt base nr for this chip
  * @irq_cnt:            Number of interrupts handled by this chip
- * @mask_cache:         Cached mask register
+ * @mask_cache:         Cached mask register shared between all chip types
  * @type_cache:         Cached type register
  * @polarity_cache:     Cached polarity register
  * @wake_enabled:       Interrupt can wakeup from suspend
  * @wake_active:        Interrupt is marked as an wakeup from suspend source
  * @num_ct:             Number of available irq_chip_type instances (usually 1)
  * @private:            Private data for non generic chip callbacks
+ * @installed:          bitfield to denote installed interrupts
+ * @unused:             bitfield to denote unused interrupts
+ * @domain:             irq domain pointer
  * @list:               List head for keeping track of instances
  * @chip_types:         Array of interrupt irq_chip_types
  *
@@ -690,6 +708,9 @@ struct irq_chip_generic {
         u32                     wake_active;
         unsigned int            num_ct;
         void                    *private;
+        unsigned long           installed;
+        unsigned long           unused;
+        struct irq_domain       *domain;
         struct list_head        list;
         struct irq_chip_type    chip_types[0];
 };
@@ -700,10 +721,32 @@ struct irq_chip_generic {
  * @IRQ_GC_INIT_NESTED_LOCK:    Set the lock class of the irqs to nested for
  *                              irq chips which need to call irq_set_wake() on
  *                              the parent irq. Usually GPIO implementations
+ * @IRQ_GC_MASK_CACHE_PER_TYPE: Mask cache is chip type private
+ * @IRQ_GC_NO_MASK:             Do not calculate irq_data->mask
  */
 enum irq_gc_flags {
         IRQ_GC_INIT_MASK_CACHE          = 1 << 0,
         IRQ_GC_INIT_NESTED_LOCK         = 1 << 1,
+        IRQ_GC_MASK_CACHE_PER_TYPE      = 1 << 2,
+        IRQ_GC_NO_MASK                  = 1 << 3,
+};
+
+/*
+ * struct irq_domain_chip_generic - Generic irq chip data structure for irq domains
+ * @irqs_per_chip:      Number of interrupts per chip
+ * @num_chips:          Number of chips
+ * @irq_flags_to_set:   IRQ* flags to set on irq setup
+ * @irq_flags_to_clear: IRQ* flags to clear on irq setup
+ * @gc_flags:           Generic chip specific setup flags
+ * @gc:                 Array of pointers to generic interrupt chips
+ */
+struct irq_domain_chip_generic {
+        unsigned int            irqs_per_chip;
+        unsigned int            num_chips;
+        unsigned int            irq_flags_to_clear;
+        unsigned int            irq_flags_to_set;
+        enum irq_gc_flags       gc_flags;
+        struct irq_chip_generic *gc[0];
 };
 
 /* Generic chip callback functions */
@@ -729,6 +772,14 @@ int irq_setup_alt_chip(struct irq_data *d, unsigned int type);
 void irq_remove_generic_chip(struct irq_chip_generic *gc, u32 msk,
                              unsigned int clr, unsigned int set);
 
+struct irq_chip_generic *irq_get_domain_generic_chip(struct irq_domain *d, unsigned int hw_irq);
+int irq_alloc_domain_generic_chips(struct irq_domain *d, int irqs_per_chip,
+                                   int num_ct, const char *name,
+                                   irq_flow_handler_t handler,
+                                   unsigned int clr, unsigned int set,
+                                   enum irq_gc_flags flags);
+
+
 static inline struct irq_chip_type *irq_data_get_chip_type(struct irq_data *d)
 {
         return container_of(d->chip, struct irq_chip_type, chip);
diff --git a/include/linux/irqchip.h b/include/linux/irqchip.h
index e0006f1d35a0..14d79131f53d 100644
--- a/include/linux/irqchip.h
+++ b/include/linux/irqchip.h
@@ -11,6 +11,10 @@
 #ifndef _LINUX_IRQCHIP_H
 #define _LINUX_IRQCHIP_H
 
+#ifdef CONFIG_IRQCHIP
 void irqchip_init(void);
+#else
+static inline void irqchip_init(void) {}
+#endif
 
 #endif
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index 0d5b17bf5e51..ba2c708adcff 100644
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -66,6 +66,10 @@ struct irq_domain_ops {
                      unsigned long *out_hwirq, unsigned int *out_type);
 };
 
+extern struct irq_domain_ops irq_generic_chip_ops;
+
+struct irq_domain_chip_generic;
+
 /**
  * struct irq_domain - Hardware interrupt number translation object
  * @link: Element in global irq_domain list.
@@ -109,8 +113,16 @@ struct irq_domain {
 
         /* Optional device node pointer */
         struct device_node *of_node;
+        /* Optional pointer to generic interrupt chips */
+        struct irq_domain_chip_generic *gc;
 };
 
+#define IRQ_DOMAIN_MAP_LEGACY 0 /* driver allocated fixed range of irqs.
+                                 * ie. legacy 8259, gets irqs 1..15 */
+#define IRQ_DOMAIN_MAP_NOMAP 1 /* no fast reverse mapping */
+#define IRQ_DOMAIN_MAP_LINEAR 2 /* linear map of interrupts */
+#define IRQ_DOMAIN_MAP_TREE 3 /* radix tree */
+
 #ifdef CONFIG_IRQ_DOMAIN
 struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
                                          unsigned int size,
diff --git a/include/linux/jbd.h b/include/linux/jbd.h
index 7e0b622503c4..8685d1be12c7 100644
--- a/include/linux/jbd.h
+++ b/include/linux/jbd.h
@@ -27,7 +27,6 @@
 #include <linux/buffer_head.h>
 #include <linux/journal-head.h>
 #include <linux/stddef.h>
-#include <linux/bit_spinlock.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
 #include <linux/lockdep.h>
@@ -244,6 +243,31 @@ typedef struct journal_superblock_s
 
 #include <linux/fs.h>
 #include <linux/sched.h>
+
+enum jbd_state_bits {
+        BH_JBD                  /* Has an attached ext3 journal_head */
+          = BH_PrivateStart,
+        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
+        BH_Freed,               /* Has been freed (truncated) */
+        BH_Revoked,             /* Has been revoked from the log */
+        BH_RevokeValid,         /* Revoked flag is valid */
+        BH_JBDDirty,            /* Is dirty but journaled */
+        BH_State,               /* Pins most journal_head state */
+        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
+        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
+        BH_JBDPrivateStart,     /* First bit available for private use by FS */
+};
+
+BUFFER_FNS(JBD, jbd)
+BUFFER_FNS(JWrite, jwrite)
+BUFFER_FNS(JBDDirty, jbddirty)
+TAS_BUFFER_FNS(JBDDirty, jbddirty)
+BUFFER_FNS(Revoked, revoked)
+TAS_BUFFER_FNS(Revoked, revoked)
+BUFFER_FNS(RevokeValid, revokevalid)
+TAS_BUFFER_FNS(RevokeValid, revokevalid)
+BUFFER_FNS(Freed, freed)
+
 #include <linux/jbd_common.h>
 
 #define J_ASSERT(assert)        BUG_ON(!(assert))
@@ -840,7 +864,7 @@ extern void	 journal_release_buffer (handle_t *, struct buffer_head *);
 extern int       journal_forget (handle_t *, struct buffer_head *);
 extern void      journal_sync_buffer (struct buffer_head *);
 extern void      journal_invalidatepage(journal_t *,
-                                struct page *, unsigned long);
+                                struct page *, unsigned int, unsigned int);
 extern int       journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
 extern int       journal_stop(handle_t *);
 extern int       journal_flush (journal_t *);
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 6e051f472edb..d5b50a19463c 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -26,7 +26,6 @@
 #include <linux/buffer_head.h>
 #include <linux/journal-head.h>
 #include <linux/stddef.h>
-#include <linux/bit_spinlock.h>
 #include <linux/mutex.h>
 #include <linux/timer.h>
 #include <linux/slab.h>
@@ -57,17 +56,13 @@
  */
 #define JBD2_EXPENSIVE_CHECKING
 extern ushort jbd2_journal_enable_debug;
+void __jbd2_debug(int level, const char *file, const char *func,
+                  unsigned int line, const char *fmt, ...);
 
-#define jbd_debug(n, f, a...)                                           \
-        do {                                                            \
-                if ((n) <= jbd2_journal_enable_debug) {                 \
-                        printk (KERN_DEBUG "(%s, %d): %s: ",            \
-                                __FILE__, __LINE__, __func__);  \
-                        printk (f, ## a);                               \
-                }                                                       \
-        } while (0)
+#define jbd_debug(n, fmt, a...) \
+        __jbd2_debug((n), __FILE__, __func__, __LINE__, (fmt), ##a)
 #else
-#define jbd_debug(f, a...)      /**/
+#define jbd_debug(n, fmt, a...)    /**/
 #endif
 
 extern void *jbd2_alloc(size_t size, gfp_t flags);
@@ -302,6 +297,34 @@ typedef struct journal_superblock_s
 
 #include <linux/fs.h>
 #include <linux/sched.h>
+
+enum jbd_state_bits {
+        BH_JBD                  /* Has an attached ext3 journal_head */
+          = BH_PrivateStart,
+        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
+        BH_Freed,               /* Has been freed (truncated) */
+        BH_Revoked,             /* Has been revoked from the log */
+        BH_RevokeValid,         /* Revoked flag is valid */
+        BH_JBDDirty,            /* Is dirty but journaled */
+        BH_State,               /* Pins most journal_head state */
+        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
+        BH_Shadow,              /* IO on shadow buffer is running */
+        BH_Verified,            /* Metadata block has been verified ok */
+        BH_JBDPrivateStart,     /* First bit available for private use by FS */
+};
+
+BUFFER_FNS(JBD, jbd)
+BUFFER_FNS(JWrite, jwrite)
+BUFFER_FNS(JBDDirty, jbddirty)
+TAS_BUFFER_FNS(JBDDirty, jbddirty)
+BUFFER_FNS(Revoked, revoked)
+TAS_BUFFER_FNS(Revoked, revoked)
+BUFFER_FNS(RevokeValid, revokevalid)
+TAS_BUFFER_FNS(RevokeValid, revokevalid)
+BUFFER_FNS(Freed, freed)
+BUFFER_FNS(Shadow, shadow)
+BUFFER_FNS(Verified, verified)
+
 #include <linux/jbd_common.h>
 
 #define J_ASSERT(assert)        BUG_ON(!(assert))
@@ -382,8 +405,15 @@ struct jbd2_revoke_table_s;
 
 struct jbd2_journal_handle
 {
-        /* Which compound transaction is this update a part of? */
-        transaction_t           *h_transaction;
+        union {
+                /* Which compound transaction is this update a part of? */
+                transaction_t   *h_transaction;
+                /* Which journal handle belongs to - used iff h_reserved set */
+                journal_t       *h_journal;
+        };
+
+        /* Handle reserved for finishing the logical operation */
+        handle_t                *h_rsv_handle;
 
         /* Number of remaining buffers we are allowed to dirty: */
         int                     h_buffer_credits;
@@ -398,6 +428,7 @@ struct jbd2_journal_handle
         /* Flags [no locking] */
         unsigned int    h_sync:         1;      /* sync-on-close */
         unsigned int    h_jdata:        1;      /* force data journaling */
+        unsigned int    h_reserved:     1;      /* handle with reserved credits */
         unsigned int    h_aborted:      1;      /* fatal error on handle */
         unsigned int    h_type:         8;      /* for handle statistics */
         unsigned int    h_line_no:      16;     /* for handle statistics */
@@ -524,12 +555,6 @@ struct transaction_s
         struct journal_head     *t_checkpoint_io_list;
 
         /*
-         * Doubly-linked circular list of temporary buffers currently undergoing
-         * IO in the log [j_list_lock]
-         */
-        struct journal_head     *t_iobuf_list;
-
-        /*
          * Doubly-linked circular list of metadata buffers being shadowed by log
          * IO.  The IO buffers on the iobuf list and the shadow buffers on this
          * list match each other one for one at all times. [j_list_lock]
@@ -537,12 +562,6 @@ struct transaction_s
         struct journal_head     *t_shadow_list;
 
         /*
-         * Doubly-linked circular list of control buffers being written to the
-         * log. [j_list_lock]
-         */
-        struct journal_head     *t_log_list;
-
-        /*
          * List of inodes whose data we've modified in data=ordered mode.
          * [j_list_lock]
          */
@@ -671,11 +690,10 @@ jbd2_time_diff(unsigned long start, unsigned long end)
  *  waiting for checkpointing
  * @j_wait_transaction_locked: Wait queue for waiting for a locked transaction
  *  to start committing, or for a barrier lock to be released
- * @j_wait_logspace: Wait queue for waiting for checkpointing to complete
  * @j_wait_done_commit: Wait queue for waiting for commit to complete
- * @j_wait_checkpoint:  Wait queue to trigger checkpointing
  * @j_wait_commit: Wait queue to trigger commit
  * @j_wait_updates: Wait queue to wait for updates to complete
+ * @j_wait_reserved: Wait queue to wait for reserved buffer credits to drop
  * @j_checkpoint_mutex: Mutex for locking against concurrent checkpoints
  * @j_head: Journal head - identifies the first unused block in the journal
  * @j_tail: Journal tail - identifies the oldest still-used block in the
@@ -689,6 +707,7 @@ jbd2_time_diff(unsigned long start, unsigned long end)
  *     journal
  * @j_fs_dev: Device which holds the client fs.  For internal journal this will
  *     be equal to j_dev
+ * @j_reserved_credits: Number of buffers reserved from the running transaction
  * @j_maxlen: Total maximum capacity of the journal region on disk.
  * @j_list_lock: Protects the buffer lists and internal buffer state.
  * @j_inode: Optional inode where we store the journal.  If present, all journal
@@ -778,21 +797,18 @@ struct journal_s
          */
         wait_queue_head_t       j_wait_transaction_locked;
 
-        /* Wait queue for waiting for checkpointing to complete */
-        wait_queue_head_t       j_wait_logspace;
-
         /* Wait queue for waiting for commit to complete */
         wait_queue_head_t       j_wait_done_commit;
 
-        /* Wait queue to trigger checkpointing */
-        wait_queue_head_t       j_wait_checkpoint;
-
         /* Wait queue to trigger commit */
         wait_queue_head_t       j_wait_commit;
 
         /* Wait queue to wait for updates to complete */
         wait_queue_head_t       j_wait_updates;
 
+        /* Wait queue to wait for reserved buffer credits to drop */
+        wait_queue_head_t       j_wait_reserved;
+
         /* Semaphore for locking against concurrent checkpoints */
         struct mutex            j_checkpoint_mutex;
 
@@ -847,6 +863,9 @@ struct journal_s
         /* Total maximum capacity of the journal region on disk. */
         unsigned int            j_maxlen;
 
+        /* Number of buffers reserved from the running transaction */
+        atomic_t                j_reserved_credits;
+
         /*
          * Protects the buffer lists and internal buffer state.
          */
@@ -991,9 +1010,17 @@ extern void __jbd2_journal_file_buffer(struct journal_head *, transaction_t *, i
 extern void __journal_free_buffer(struct journal_head *bh);
 extern void jbd2_journal_file_buffer(struct journal_head *, transaction_t *, int);
 extern void __journal_clean_data_list(transaction_t *transaction);
+static inline void jbd2_file_log_bh(struct list_head *head, struct buffer_head *bh)
+{
+        list_add_tail(&bh->b_assoc_buffers, head);
+}
+static inline void jbd2_unfile_log_bh(struct buffer_head *bh)
+{
+        list_del_init(&bh->b_assoc_buffers);
+}
 
 /* Log buffer allocation */
-extern struct journal_head * jbd2_journal_get_descriptor_buffer(journal_t *);
+struct buffer_head *jbd2_journal_get_descriptor_buffer(journal_t *journal);
 int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
                               unsigned long *block);
@@ -1039,11 +1066,10 @@ extern void jbd2_buffer_abort_trigger(struct journal_head *jh,
                                       struct jbd2_buffer_trigger_type *triggers);
 
 /* Buffer IO */
-extern int
-jbd2_journal_write_metadata_buffer(transaction_t          *transaction,
-                              struct journal_head  *jh_in,
-                              struct journal_head **jh_out,
-                              unsigned long long   blocknr);
+extern int jbd2_journal_write_metadata_buffer(transaction_t *transaction,
+                                              struct journal_head *jh_in,
+                                              struct buffer_head **bh_out,
+                                              sector_t blocknr);
 
 /* Transaction locking */
 extern void             __wait_on_journal (journal_t *);
@@ -1076,10 +1102,14 @@ static inline handle_t *journal_current_handle(void)
  */
 
 extern handle_t *jbd2_journal_start(journal_t *, int nblocks);
-extern handle_t *jbd2__journal_start(journal_t *, int nblocks, gfp_t gfp_mask,
-                                     unsigned int type, unsigned int line_no);
+extern handle_t *jbd2__journal_start(journal_t *, int blocks, int rsv_blocks,
+                                     gfp_t gfp_mask, unsigned int type,
+                                     unsigned int line_no);
 extern int       jbd2_journal_restart(handle_t *, int nblocks);
 extern int       jbd2__journal_restart(handle_t *, int nblocks, gfp_t gfp_mask);
+extern int       jbd2_journal_start_reserved(handle_t *handle,
+                                unsigned int type, unsigned int line_no);
+extern void      jbd2_journal_free_reserved(handle_t *handle);
 extern int       jbd2_journal_extend (handle_t *, int nblocks);
 extern int       jbd2_journal_get_write_access(handle_t *, struct buffer_head *);
 extern int       jbd2_journal_get_create_access (handle_t *, struct buffer_head *);
@@ -1090,7 +1120,7 @@ extern int	 jbd2_journal_dirty_metadata (handle_t *, struct buffer_head *);
 extern int       jbd2_journal_forget (handle_t *, struct buffer_head *);
 extern void      journal_sync_buffer (struct buffer_head *);
 extern int       jbd2_journal_invalidatepage(journal_t *,
-                                struct page *, unsigned long);
+                                struct page *, unsigned int, unsigned int);
 extern int       jbd2_journal_try_to_free_buffers(journal_t *, struct page *, gfp_t);
 extern int       jbd2_journal_stop(handle_t *);
 extern int       jbd2_journal_flush (journal_t *);
@@ -1125,6 +1155,7 @@ extern void	   jbd2_journal_ack_err    (journal_t *);
 extern int         jbd2_journal_clear_err  (journal_t *);
 extern int         jbd2_journal_bmap(journal_t *, unsigned long, unsigned long long *);
 extern int         jbd2_journal_force_commit(journal_t *);
+extern int         jbd2_journal_force_commit_nested(journal_t *);
 extern int         jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *inode);
 extern int         jbd2_journal_begin_ordered_truncate(journal_t *journal,
                                 struct jbd2_inode *inode, loff_t new_size);
@@ -1178,8 +1209,10 @@ extern int	   jbd2_journal_init_revoke_caches(void);
 extern void        jbd2_journal_destroy_revoke(journal_t *);
 extern int         jbd2_journal_revoke (handle_t *, unsigned long long, struct buffer_head *);
 extern int         jbd2_journal_cancel_revoke(handle_t *, struct journal_head *);
-extern void        jbd2_journal_write_revoke_records(journal_t *,
-                                                     transaction_t *, int);
+extern void        jbd2_journal_write_revoke_records(journal_t *journal,
+                                                     transaction_t *transaction,
+                                                     struct list_head *log_bufs,
+                                                     int write_op);
 
 /* Recovery revoke support */
 extern int      jbd2_journal_set_revoke(journal_t *, unsigned long long, tid_t);
@@ -1195,11 +1228,9 @@ extern void	jbd2_clear_buffer_revoked_flags(journal_t *journal);
  * transitions on demand.
  */
 
-int __jbd2_log_space_left(journal_t *); /* Called with journal locked */
 int jbd2_log_start_commit(journal_t *journal, tid_t tid);
 int __jbd2_log_start_commit(journal_t *journal, tid_t tid);
 int jbd2_journal_start_commit(journal_t *journal, tid_t *tid);
-int jbd2_journal_force_commit_nested(journal_t *journal);
 int jbd2_log_wait_commit(journal_t *journal, tid_t tid);
 int jbd2_complete_transaction(journal_t *journal, tid_t tid);
 int jbd2_log_do_checkpoint(journal_t *journal);
@@ -1235,7 +1266,7 @@ static inline int is_journal_aborted(journal_t *journal)
 
 static inline int is_handle_aborted(handle_t *handle)
 {
-        if (handle->h_aborted)
+        if (handle->h_aborted || !handle->h_transaction)
                 return 1;
         return is_journal_aborted(handle->h_transaction->t_journal);
 }
@@ -1266,16 +1297,37 @@ extern int jbd2_journal_blocks_per_page(struct inode *inode);
 extern size_t journal_tag_bytes(journal_t *journal);
 
 /*
+ * We reserve t_outstanding_credits >> JBD2_CONTROL_BLOCKS_SHIFT for
+ * transaction control blocks.
+ */
+#define JBD2_CONTROL_BLOCKS_SHIFT 5
+
+/*
  * Return the minimum number of blocks which must be free in the journal
  * before a new transaction may be started.  Must be called under j_state_lock.
  */
-static inline int jbd_space_needed(journal_t *journal)
+static inline int jbd2_space_needed(journal_t *journal)
 {
         int nblocks = journal->j_max_transaction_buffers;
-        if (journal->j_committing_transaction)
-                nblocks += atomic_read(&journal->j_committing_transaction->
-                                       t_outstanding_credits);
-        return nblocks;
+        return nblocks + (nblocks >> JBD2_CONTROL_BLOCKS_SHIFT);
+}
+
+/*
+ * Return number of free blocks in the log. Must be called under j_state_lock.
+ */
+static inline unsigned long jbd2_log_space_left(journal_t *journal)
+{
+        /* Allow for rounding errors */
+        unsigned long free = journal->j_free - 32;
+
+        if (journal->j_committing_transaction) {
+                unsigned long committing = atomic_read(&journal->
+                        j_committing_transaction->t_outstanding_credits);
+
+                /* Transaction + control blocks */
+                free -= committing + (committing >> JBD2_CONTROL_BLOCKS_SHIFT);
+        }
+        return free;
 }
 
 /*
@@ -1286,11 +1338,9 @@ static inline int jbd_space_needed(journal_t *journal)
 #define BJ_None         0       /* Not journaled */
 #define BJ_Metadata     1       /* Normal journaled metadata */
 #define BJ_Forget       2       /* Buffer superseded by this transaction */
-#define BJ_IO           3       /* Buffer is for temporary IO use */
-#define BJ_Shadow       4       /* Buffer contents being shadowed to the log */
-#define BJ_LogCtl       5       /* Buffer contains log descriptors */
-#define BJ_Reserved     6       /* Buffer is reserved for access by journal */
-#define BJ_Types        7
+#define BJ_Shadow       3       /* Buffer contents being shadowed to the log */
+#define BJ_Reserved     4       /* Buffer is reserved for access by journal */
+#define BJ_Types        5
 
 extern int jbd_blocks_per_page(struct inode *inode);
 
@@ -1319,6 +1369,19 @@ static inline u32 jbd2_chksum(journal_t *journal, u32 crc,
         return *(u32 *)desc.ctx;
 }
 
+/* Return most recent uncommitted transaction */
+static inline tid_t  jbd2_get_latest_transaction(journal_t *journal)
+{
+        tid_t tid;
+
+        read_lock(&journal->j_state_lock);
+        tid = journal->j_commit_request;
+        if (journal->j_running_transaction)
+                tid = journal->j_running_transaction->t_tid;
+        read_unlock(&journal->j_state_lock);
+        return tid;
+}
+
 #ifdef __KERNEL__
 
 #define buffer_trace_init(bh)   do {} while (0)
diff --git a/include/linux/jbd_common.h b/include/linux/jbd_common.h
index 6133679bc4c0..3dc53432355f 100644
--- a/include/linux/jbd_common.h
+++ b/include/linux/jbd_common.h
@@ -1,31 +1,7 @@
 #ifndef _LINUX_JBD_STATE_H
 #define _LINUX_JBD_STATE_H
 
-enum jbd_state_bits {
-        BH_JBD                  /* Has an attached ext3 journal_head */
-          = BH_PrivateStart,
-        BH_JWrite,              /* Being written to log (@@@ DEBUGGING) */
-        BH_Freed,               /* Has been freed (truncated) */
-        BH_Revoked,             /* Has been revoked from the log */
-        BH_RevokeValid,         /* Revoked flag is valid */
-        BH_JBDDirty,            /* Is dirty but journaled */
-        BH_State,               /* Pins most journal_head state */
-        BH_JournalHead,         /* Pins bh->b_private and jh->b_bh */
-        BH_Unshadow,            /* Dummy bit, for BJ_Shadow wakeup filtering */
-        BH_Verified,            /* Metadata block has been verified ok */
-        BH_JBDPrivateStart,     /* First bit available for private use by FS */
-};
-
-BUFFER_FNS(JBD, jbd)
-BUFFER_FNS(JWrite, jwrite)
-BUFFER_FNS(JBDDirty, jbddirty)
-TAS_BUFFER_FNS(JBDDirty, jbddirty)
-BUFFER_FNS(Revoked, revoked)
-TAS_BUFFER_FNS(Revoked, revoked)
-BUFFER_FNS(RevokeValid, revokevalid)
-TAS_BUFFER_FNS(RevokeValid, revokevalid)
-BUFFER_FNS(Freed, freed)
-BUFFER_FNS(Verified, verified)
+#include <linux/bit_spinlock.h>
 
 static inline struct buffer_head *jh2bh(struct journal_head *jh)
 {
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index e9ef6d6b51d5..7e6b97e77fb9 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -193,13 +193,10 @@ extern int _cond_resched(void);
                 (__x < 0) ? -__x : __x;         \
         })
 
-#ifdef CONFIG_PROVE_LOCKING
+#if defined(CONFIG_PROVE_LOCKING) || defined(CONFIG_DEBUG_ATOMIC_SLEEP)
 void might_fault(void);
 #else
-static inline void might_fault(void)
-{
-        might_sleep();
-}
+static inline void might_fault(void) { }
 #endif
 
 extern struct atomic_notifier_head panic_notifier_list;
@@ -450,6 +447,8 @@ static inline char * __deprecated pack_hex_byte(char *buf, u8 byte)
 extern int hex_to_bin(char ch);
 extern int __must_check hex2bin(u8 *dst, const char *src, size_t count);
 
+int mac_pton(const char *s, u8 *mac);
+
 /*
  * General tracing related utility functions - trace_printk(),
  * tracing_on/tracing_off and tracing_start()/tracing_stop
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index f0eea07d2c2b..8db53cfaccdb 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -23,6 +23,7 @@
 #include <linux/ratelimit.h>
 #include <linux/err.h>
 #include <linux/irqflags.h>
+#include <linux/context_tracking.h>
 #include <asm/signal.h>
 
 #include <linux/kvm.h>
@@ -760,42 +761,6 @@ static inline int kvm_iommu_unmap_guest(struct kvm *kvm)
 }
 #endif
 
-static inline void __guest_enter(void)
-{
-        /*
-         * This is running in ioctl context so we can avoid
-         * the call to vtime_account() with its unnecessary idle check.
-         */
-        vtime_account_system(current);
-        current->flags |= PF_VCPU;
-}
-
-static inline void __guest_exit(void)
-{
-        /*
-         * This is running in ioctl context so we can avoid
-         * the call to vtime_account() with its unnecessary idle check.
-         */
-        vtime_account_system(current);
-        current->flags &= ~PF_VCPU;
-}
-
-#ifdef CONFIG_CONTEXT_TRACKING
-extern void guest_enter(void);
-extern void guest_exit(void);
-
-#else /* !CONFIG_CONTEXT_TRACKING */
-static inline void guest_enter(void)
-{
-        __guest_enter();
-}
-
-static inline void guest_exit(void)
-{
-        __guest_exit();
-}
-#endif /* !CONFIG_CONTEXT_TRACKING */
-
 static inline void kvm_guest_enter(void)
 {
         unsigned long flags;
diff --git a/include/linux/list.h b/include/linux/list.h
index 6a1f8df9144b..b83e5657365a 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -362,6 +362,17 @@ static inline void list_splice_tail_init(struct list_head *list,
         list_entry((ptr)->next, type, member)
 
 /**
+ * list_first_entry_or_null - get the first element from a list
+ * @ptr:        the list head to take the element from.
+ * @type:       the type of the struct this is embedded in.
+ * @member:     the name of the list_struct within the struct.
+ *
+ * Note that if the list is empty, it returns NULL.
+ */
+#define list_first_entry_or_null(ptr, type, member) \
+        (!list_empty(ptr) ? list_first_entry(ptr, type, member) : NULL)
+
+/**
  * list_for_each        -       iterate over a list
  * @pos:        the &struct list_head to use as a loop cursor.
  * @head:       the head for your list.
diff --git a/include/linux/loop.h b/include/linux/loop.h
deleted file mode 100644
index 460b60fa7adf..000000000000
--- a/include/linux/loop.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * include/linux/loop.h
- *
- * Written by Theodore Ts'o, 3/29/93.
- *
- * Copyright 1993 by Theodore Ts'o.  Redistribution of this file is
- * permitted under the GNU General Public License.
- */
-#ifndef _LINUX_LOOP_H
-#define _LINUX_LOOP_H
-
-#include <linux/bio.h>
-#include <linux/blkdev.h>
-#include <linux/spinlock.h>
-#include <linux/mutex.h>
-#include <uapi/linux/loop.h>
-
-/* Possible states of device */
-enum {
-        Lo_unbound,
-        Lo_bound,
-        Lo_rundown,
-};
-
-struct loop_func_table;
-
-struct loop_device {
-        int             lo_number;
-        int             lo_refcnt;
-        loff_t          lo_offset;
-        loff_t          lo_sizelimit;
-        int             lo_flags;
-        int             (*transfer)(struct loop_device *, int cmd,
-                                    struct page *raw_page, unsigned raw_off,
-                                    struct page *loop_page, unsigned loop_off,
-                                    int size, sector_t real_block);
-        char            lo_file_name[LO_NAME_SIZE];
-        char            lo_crypt_name[LO_NAME_SIZE];
-        char            lo_encrypt_key[LO_KEY_SIZE];
-        int             lo_encrypt_key_size;
-        struct loop_func_table *lo_encryption;
-        __u32           lo_init[2];
-        kuid_t          lo_key_owner;   /* Who set the key */
-        int             (*ioctl)(struct loop_device *, int cmd, 
-                                 unsigned long arg); 
-
-        struct file *   lo_backing_file;
-        struct block_device *lo_device;
-        unsigned        lo_blocksize;
-        void            *key_data; 
-
-        gfp_t           old_gfp_mask;
-
-        spinlock_t              lo_lock;
-        struct bio_list         lo_bio_list;
-        unsigned int            lo_bio_count;
-        int                     lo_state;
-        struct mutex            lo_ctl_mutex;
-        struct task_struct      *lo_thread;
-        wait_queue_head_t       lo_event;
-        /* wait queue for incoming requests */
-        wait_queue_head_t       lo_req_wait;
-
-        struct request_queue    *lo_queue;
-        struct gendisk          *lo_disk;
-};
-
-/* Support for loadable transfer modules */
-struct loop_func_table {
-        int number;     /* filter type */ 
-        int (*transfer)(struct loop_device *lo, int cmd,
-                        struct page *raw_page, unsigned raw_off,
-                        struct page *loop_page, unsigned loop_off,
-                        int size, sector_t real_block);
-        int (*init)(struct loop_device *, const struct loop_info64 *); 
-        /* release is called from loop_unregister_transfer or clr_fd */
-        int (*release)(struct loop_device *); 
-        int (*ioctl)(struct loop_device *, int cmd, unsigned long arg);
-        struct module *owner;
-}; 
-
-int loop_register_transfer(struct loop_func_table *funcs);
-int loop_unregister_transfer(int number); 
-
-#endif
diff --git a/include/linux/math64.h b/include/linux/math64.h
index b8ba85544721..2913b86eb12a 100644
--- a/include/linux/math64.h
+++ b/include/linux/math64.h
@@ -6,7 +6,8 @@
 
 #if BITS_PER_LONG == 64
 
-#define div64_long(x,y) div64_s64((x),(y))
+#define div64_long(x, y) div64_s64((x), (y))
+#define div64_ul(x, y)   div64_u64((x), (y))
 
 /**
  * div_u64_rem - unsigned 64bit divide with 32bit divisor with remainder
@@ -47,7 +48,8 @@ static inline s64 div64_s64(s64 dividend, s64 divisor)
 
 #elif BITS_PER_LONG == 32
 
-#define div64_long(x,y) div_s64((x),(y))
+#define div64_long(x, y) div_s64((x), (y))
+#define div64_ul(x, y)   div_u64((x), (y))
 
 #ifndef div_u64_rem
 static inline u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
diff --git a/include/linux/mfd/davinci_voicecodec.h b/include/linux/mfd/davinci_voicecodec.h
index 0ab61320ffa8..7dd6524d2aac 100644
--- a/include/linux/mfd/davinci_voicecodec.h
+++ b/include/linux/mfd/davinci_voicecodec.h
@@ -26,8 +26,7 @@
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/mfd/core.h>
-
-#include <mach/edma.h>
+#include <linux/platform_data/edma.h>
 
 /*
  * Register values.
diff --git a/include/linux/mfd/palmas.h b/include/linux/mfd/palmas.h
index 8f21daf62fb5..9b81b2bdc46b 100644
--- a/include/linux/mfd/palmas.h
+++ b/include/linux/mfd/palmas.h
@@ -20,6 +20,8 @@
 #include <linux/leds.h>
 #include <linux/regmap.h>
 #include <linux/regulator/driver.h>
+#include <linux/extcon.h>
+#include <linux/usb/phy_companion.h>
 
 #define PALMAS_NUM_CLIENTS              3
 
@@ -37,6 +39,12 @@ struct palmas_gpadc;
 struct palmas_resource;
 struct palmas_usb;
 
+enum palmas_usb_state {
+        PALMAS_USB_STATE_DISCONNECT,
+        PALMAS_USB_STATE_VBUS,
+        PALMAS_USB_STATE_ID,
+};
+
 struct palmas {
         struct device *dev;
 
@@ -180,9 +188,6 @@ struct palmas_pmic_platform_data {
 };
 
 struct palmas_usb_platform_data {
-        /* Set this if platform wishes its own vbus control */
-        int no_control_vbus;
-
         /* Do we enable the wakeup comparator on probe */
         int wakeup;
 };
@@ -350,22 +355,19 @@ struct palmas_usb {
         struct palmas *palmas;
         struct device *dev;
 
-        /* for vbus reporting with irqs disabled */
-        spinlock_t lock;
-
-        struct regulator *vbus_reg;
+        struct extcon_dev edev;
 
         /* used to set vbus, in atomic path */
         struct work_struct set_vbus_work;
 
-        int irq1;
-        int irq2;
-        int irq3;
-        int irq4;
+        int id_otg_irq;
+        int id_irq;
+        int vbus_otg_irq;
+        int vbus_irq;
 
         int vbus_enable;
 
-        u8 linkstat;
+        enum palmas_usb_state linkstat;
 };
 
 #define comparator_to_palmas(x) container_of((x), struct palmas_usb, comparator)
diff --git a/include/linux/mfd/syscon/clps711x.h b/include/linux/mfd/syscon/clps711x.h
new file mode 100644
index 000000000000..26355abae515
--- /dev/null
+++ b/include/linux/mfd/syscon/clps711x.h
@@ -0,0 +1,94 @@
+/*
+ *  CLPS711X system register bits definitions
+ *
+ *  Copyright (C) 2013 Alexander Shiyan <shc_work@mail.ru>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#ifndef _LINUX_MFD_SYSCON_CLPS711X_H_
+#define _LINUX_MFD_SYSCON_CLPS711X_H_
+
+#define SYSCON_OFFSET           (0x00)
+#define SYSFLG_OFFSET           (0x40)
+
+#define SYSCON1_KBDSCAN(x)      ((x) & 15)
+#define SYSCON1_KBDSCAN_MASK    (15)
+#define SYSCON1_TC1M            (1 << 4)
+#define SYSCON1_TC1S            (1 << 5)
+#define SYSCON1_TC2M            (1 << 6)
+#define SYSCON1_TC2S            (1 << 7)
+#define SYSCON1_BZTOG           (1 << 9)
+#define SYSCON1_BZMOD           (1 << 10)
+#define SYSCON1_DBGEN           (1 << 11)
+#define SYSCON1_LCDEN           (1 << 12)
+#define SYSCON1_CDENTX          (1 << 13)
+#define SYSCON1_CDENRX          (1 << 14)
+#define SYSCON1_SIREN           (1 << 15)
+#define SYSCON1_ADCKSEL(x)      (((x) & 3) << 16)
+#define SYSCON1_ADCKSEL_MASK    (3 << 16)
+#define SYSCON1_EXCKEN          (1 << 18)
+#define SYSCON1_WAKEDIS         (1 << 19)
+#define SYSCON1_IRTXM           (1 << 20)
+
+#define SYSCON2_SERSEL          (1 << 0)
+#define SYSCON2_KBD6            (1 << 1)
+#define SYSCON2_DRAMZ           (1 << 2)
+#define SYSCON2_KBWEN           (1 << 3)
+#define SYSCON2_SS2TXEN         (1 << 4)
+#define SYSCON2_PCCARD1         (1 << 5)
+#define SYSCON2_PCCARD2         (1 << 6)
+#define SYSCON2_SS2RXEN         (1 << 7)
+#define SYSCON2_SS2MAEN         (1 << 9)
+#define SYSCON2_OSTB            (1 << 12)
+#define SYSCON2_CLKENSL         (1 << 13)
+#define SYSCON2_BUZFREQ         (1 << 14)
+
+#define SYSCON3_ADCCON          (1 << 0)
+#define SYSCON3_CLKCTL0         (1 << 1)
+#define SYSCON3_CLKCTL1         (1 << 2)
+#define SYSCON3_DAISEL          (1 << 3)
+#define SYSCON3_ADCCKNSEN       (1 << 4)
+#define SYSCON3_VERSN(x)        (((x) >> 5) & 7)
+#define SYSCON3_VERSN_MASK      (7 << 5)
+#define SYSCON3_FASTWAKE        (1 << 8)
+#define SYSCON3_DAIEN           (1 << 9)
+#define SYSCON3_128FS           SYSCON3_DAIEN
+#define SYSCON3_ENPD67          (1 << 10)
+
+#define SYSCON_UARTEN           (1 << 8)
+
+#define SYSFLG1_MCDR            (1 << 0)
+#define SYSFLG1_DCDET           (1 << 1)
+#define SYSFLG1_WUDR            (1 << 2)
+#define SYSFLG1_WUON            (1 << 3)
+#define SYSFLG1_CTS             (1 << 8)
+#define SYSFLG1_DSR             (1 << 9)
+#define SYSFLG1_DCD             (1 << 10)
+#define SYSFLG1_NBFLG           (1 << 12)
+#define SYSFLG1_RSTFLG          (1 << 13)
+#define SYSFLG1_PFFLG           (1 << 14)
+#define SYSFLG1_CLDFLG          (1 << 15)
+#define SYSFLG1_CRXFE           (1 << 24)
+#define SYSFLG1_CTXFF           (1 << 25)
+#define SYSFLG1_SSIBUSY         (1 << 26)
+#define SYSFLG1_ID              (1 << 29)
+#define SYSFLG1_VERID(x)        (((x) >> 30) & 3)
+#define SYSFLG1_VERID_MASK      (3 << 30)
+
+#define SYSFLG2_SSRXOF          (1 << 0)
+#define SYSFLG2_RESVAL          (1 << 1)
+#define SYSFLG2_RESFRM          (1 << 2)
+#define SYSFLG2_SS2RXFE         (1 << 3)
+#define SYSFLG2_SS2TXFF         (1 << 4)
+#define SYSFLG2_SS2TXUF         (1 << 5)
+#define SYSFLG2_CKMODE          (1 << 6)
+
+#define SYSFLG_UBUSY            (1 << 11)
+#define SYSFLG_URXFE            (1 << 22)
+#define SYSFLG_UTXFF            (1 << 23)
+
+#endif
diff --git a/include/linux/mm.h b/include/linux/mm.h
index e0c8528a41a4..66d881f1d576 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1041,7 +1041,8 @@ int get_kernel_page(unsigned long start, int write, struct page **pages);
 struct page *get_dump_page(unsigned long addr);
 
 extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
-extern void do_invalidatepage(struct page *page, unsigned long offset);
+extern void do_invalidatepage(struct page *page, unsigned int offset,
+                              unsigned int length);
 
 int __set_page_dirty_nobuffers(struct page *page);
 int __set_page_dirty_no_writeback(struct page *page);
diff --git a/include/linux/mutex-debug.h b/include/linux/mutex-debug.h
index 731d77d6e155..4ac8b1977b73 100644
--- a/include/linux/mutex-debug.h
+++ b/include/linux/mutex-debug.h
@@ -3,6 +3,7 @@
 
 #include <linux/linkage.h>
 #include <linux/lockdep.h>
+#include <linux/debug_locks.h>
 
 /*
  * Mutexes - debugging helpers:
diff --git a/include/linux/mutex.h b/include/linux/mutex.h
index 433da8a1a426..3793ed7feeeb 100644
--- a/include/linux/mutex.h
+++ b/include/linux/mutex.h
@@ -10,6 +10,7 @@
 #ifndef __LINUX_MUTEX_H
 #define __LINUX_MUTEX_H
 
+#include <asm/current.h>
 #include <linux/list.h>
 #include <linux/spinlock_types.h>
 #include <linux/linkage.h>
@@ -77,6 +78,40 @@ struct mutex_waiter {
 #endif
 };
 
+struct ww_class {
+        atomic_long_t stamp;
+        struct lock_class_key acquire_key;
+        struct lock_class_key mutex_key;
+        const char *acquire_name;
+        const char *mutex_name;
+};
+
+struct ww_acquire_ctx {
+        struct task_struct *task;
+        unsigned long stamp;
+        unsigned acquired;
+#ifdef CONFIG_DEBUG_MUTEXES
+        unsigned done_acquire;
+        struct ww_class *ww_class;
+        struct ww_mutex *contending_lock;
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lockdep_map dep_map;
+#endif
+#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+        unsigned deadlock_inject_interval;
+        unsigned deadlock_inject_countdown;
+#endif
+};
+
+struct ww_mutex {
+        struct mutex base;
+        struct ww_acquire_ctx *ctx;
+#ifdef CONFIG_DEBUG_MUTEXES
+        struct ww_class *ww_class;
+#endif
+};
+
 #ifdef CONFIG_DEBUG_MUTEXES
 # include <linux/mutex-debug.h>
 #else
@@ -101,8 +136,11 @@ static inline void mutex_destroy(struct mutex *lock) {}
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 # define __DEP_MAP_MUTEX_INITIALIZER(lockname) \
                 , .dep_map = { .name = #lockname }
+# define __WW_CLASS_MUTEX_INITIALIZER(lockname, ww_class) \
+                , .ww_class = &ww_class
 #else
 # define __DEP_MAP_MUTEX_INITIALIZER(lockname)
+# define __WW_CLASS_MUTEX_INITIALIZER(lockname, ww_class)
 #endif
 
 #define __MUTEX_INITIALIZER(lockname) \
@@ -112,13 +150,49 @@ static inline void mutex_destroy(struct mutex *lock) {}
                 __DEBUG_MUTEX_INITIALIZER(lockname) \
                 __DEP_MAP_MUTEX_INITIALIZER(lockname) }
 
+#define __WW_CLASS_INITIALIZER(ww_class) \
+                { .stamp = ATOMIC_LONG_INIT(0) \
+                , .acquire_name = #ww_class "_acquire" \
+                , .mutex_name = #ww_class "_mutex" }
+
+#define __WW_MUTEX_INITIALIZER(lockname, class) \
+                { .base = { \__MUTEX_INITIALIZER(lockname) } \
+                __WW_CLASS_MUTEX_INITIALIZER(lockname, class) }
+
 #define DEFINE_MUTEX(mutexname) \
         struct mutex mutexname = __MUTEX_INITIALIZER(mutexname)
 
+#define DEFINE_WW_CLASS(classname) \
+        struct ww_class classname = __WW_CLASS_INITIALIZER(classname)
+
+#define DEFINE_WW_MUTEX(mutexname, ww_class) \
+        struct ww_mutex mutexname = __WW_MUTEX_INITIALIZER(mutexname, ww_class)
+
+
 extern void __mutex_init(struct mutex *lock, const char *name,
                          struct lock_class_key *key);
 
 /**
+ * ww_mutex_init - initialize the w/w mutex
+ * @lock: the mutex to be initialized
+ * @ww_class: the w/w class the mutex should belong to
+ *
+ * Initialize the w/w mutex to unlocked state and associate it with the given
+ * class.
+ *
+ * It is not allowed to initialize an already locked mutex.
+ */
+static inline void ww_mutex_init(struct ww_mutex *lock,
+                                 struct ww_class *ww_class)
+{
+        __mutex_init(&lock->base, ww_class->mutex_name, &ww_class->mutex_key);
+        lock->ctx = NULL;
+#ifdef CONFIG_DEBUG_MUTEXES
+        lock->ww_class = ww_class;
+#endif
+}
+
+/**
  * mutex_is_locked - is the mutex locked
  * @lock: the mutex to be queried
  *
@@ -136,6 +210,7 @@ static inline int mutex_is_locked(struct mutex *lock)
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern void mutex_lock_nested(struct mutex *lock, unsigned int subclass);
 extern void _mutex_lock_nest_lock(struct mutex *lock, struct lockdep_map *nest_lock);
+
 extern int __must_check mutex_lock_interruptible_nested(struct mutex *lock,
                                         unsigned int subclass);
 extern int __must_check mutex_lock_killable_nested(struct mutex *lock,
@@ -147,7 +222,7 @@ extern int __must_check mutex_lock_killable_nested(struct mutex *lock,
 
 #define mutex_lock_nest_lock(lock, nest_lock)                           \
 do {                                                                    \
-        typecheck(struct lockdep_map *, &(nest_lock)->dep_map);         \
+        typecheck(struct lockdep_map *, &(nest_lock)->dep_map); \
         _mutex_lock_nest_lock(lock, &(nest_lock)->dep_map);             \
 } while (0)
 
@@ -170,6 +245,292 @@ extern int __must_check mutex_lock_killable(struct mutex *lock);
  */
 extern int mutex_trylock(struct mutex *lock);
 extern void mutex_unlock(struct mutex *lock);
+
+/**
+ * ww_acquire_init - initialize a w/w acquire context
+ * @ctx: w/w acquire context to initialize
+ * @ww_class: w/w class of the context
+ *
+ * Initializes an context to acquire multiple mutexes of the given w/w class.
+ *
+ * Context-based w/w mutex acquiring can be done in any order whatsoever within
+ * a given lock class. Deadlocks will be detected and handled with the
+ * wait/wound logic.
+ *
+ * Mixing of context-based w/w mutex acquiring and single w/w mutex locking can
+ * result in undetected deadlocks and is so forbidden. Mixing different contexts
+ * for the same w/w class when acquiring mutexes can also result in undetected
+ * deadlocks, and is hence also forbidden. Both types of abuse will be caught by
+ * enabling CONFIG_PROVE_LOCKING.
+ *
+ * Nesting of acquire contexts for _different_ w/w classes is possible, subject
+ * to the usual locking rules between different lock classes.
+ *
+ * An acquire context must be released with ww_acquire_fini by the same task
+ * before the memory is freed. It is recommended to allocate the context itself
+ * on the stack.
+ */
+static inline void ww_acquire_init(struct ww_acquire_ctx *ctx,
+                                   struct ww_class *ww_class)
+{
+        ctx->task = current;
+        ctx->stamp = atomic_long_inc_return(&ww_class->stamp);
+        ctx->acquired = 0;
+#ifdef CONFIG_DEBUG_MUTEXES
+        ctx->ww_class = ww_class;
+        ctx->done_acquire = 0;
+        ctx->contending_lock = NULL;
+#endif
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        debug_check_no_locks_freed((void *)ctx, sizeof(*ctx));
+        lockdep_init_map(&ctx->dep_map, ww_class->acquire_name,
+                         &ww_class->acquire_key, 0);
+        mutex_acquire(&ctx->dep_map, 0, 0, _RET_IP_);
+#endif
+#ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
+        ctx->deadlock_inject_interval = 1;
+        ctx->deadlock_inject_countdown = ctx->stamp & 0xf;
+#endif
+}
+
+/**
+ * ww_acquire_done - marks the end of the acquire phase
+ * @ctx: the acquire context
+ *
+ * Marks the end of the acquire phase, any further w/w mutex lock calls using
+ * this context are forbidden.
+ *
+ * Calling this function is optional, it is just useful to document w/w mutex
+ * code and clearly designated the acquire phase from actually using the locked
+ * data structures.
+ */
+static inline void ww_acquire_done(struct ww_acquire_ctx *ctx)
+{
+#ifdef CONFIG_DEBUG_MUTEXES
+        lockdep_assert_held(ctx);
+
+        DEBUG_LOCKS_WARN_ON(ctx->done_acquire);
+        ctx->done_acquire = 1;
+#endif
+}
+
+/**
+ * ww_acquire_fini - releases a w/w acquire context
+ * @ctx: the acquire context to free
+ *
+ * Releases a w/w acquire context. This must be called _after_ all acquired w/w
+ * mutexes have been released with ww_mutex_unlock.
+ */
+static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)
+{
+#ifdef CONFIG_DEBUG_MUTEXES
+        mutex_release(&ctx->dep_map, 0, _THIS_IP_);
+
+        DEBUG_LOCKS_WARN_ON(ctx->acquired);
+        if (!config_enabled(CONFIG_PROVE_LOCKING))
+                /*
+                 * lockdep will normally handle this,
+                 * but fail without anyway
+                 */
+                ctx->done_acquire = 1;
+
+        if (!config_enabled(CONFIG_DEBUG_LOCK_ALLOC))
+                /* ensure ww_acquire_fini will still fail if called twice */
+                ctx->acquired = ~0U;
+#endif
+}
+
+extern int __must_check __ww_mutex_lock(struct ww_mutex *lock,
+                                        struct ww_acquire_ctx *ctx);
+extern int __must_check __ww_mutex_lock_interruptible(struct ww_mutex *lock,
+                                                      struct ww_acquire_ctx *ctx);
+
+/**
+ * ww_mutex_lock - acquire the w/w mutex
+ * @lock: the mutex to be acquired
+ * @ctx: w/w acquire context, or NULL to acquire only a single lock.
+ *
+ * Lock the w/w mutex exclusively for this task.
+ *
+ * Deadlocks within a given w/w class of locks are detected and handled with the
+ * wait/wound algorithm. If the lock isn't immediately avaiable this function
+ * will either sleep until it is (wait case). Or it selects the current context
+ * for backing off by returning -EDEADLK (wound case). Trying to acquire the
+ * same lock with the same context twice is also detected and signalled by
+ * returning -EALREADY. Returns 0 if the mutex was successfully acquired.
+ *
+ * In the wound case the caller must release all currently held w/w mutexes for
+ * the given context and then wait for this contending lock to be available by
+ * calling ww_mutex_lock_slow. Alternatively callers can opt to not acquire this
+ * lock and proceed with trying to acquire further w/w mutexes (e.g. when
+ * scanning through lru lists trying to free resources).
+ *
+ * The mutex must later on be released by the same task that
+ * acquired it. The task may not exit without first unlocking the mutex. Also,
+ * kernel memory where the mutex resides must not be freed with the mutex still
+ * locked. The mutex must first be initialized (or statically defined) before it
+ * can be locked. memset()-ing the mutex to 0 is not allowed. The mutex must be
+ * of the same w/w lock class as was used to initialize the acquire context.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+static inline int ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+        if (ctx)
+                return __ww_mutex_lock(lock, ctx);
+        else {
+                mutex_lock(&lock->base);
+                return 0;
+        }
+}
+
+/**
+ * ww_mutex_lock_interruptible - acquire the w/w mutex, interruptible
+ * @lock: the mutex to be acquired
+ * @ctx: w/w acquire context
+ *
+ * Lock the w/w mutex exclusively for this task.
+ *
+ * Deadlocks within a given w/w class of locks are detected and handled with the
+ * wait/wound algorithm. If the lock isn't immediately avaiable this function
+ * will either sleep until it is (wait case). Or it selects the current context
+ * for backing off by returning -EDEADLK (wound case). Trying to acquire the
+ * same lock with the same context twice is also detected and signalled by
+ * returning -EALREADY. Returns 0 if the mutex was successfully acquired. If a
+ * signal arrives while waiting for the lock then this function returns -EINTR.
+ *
+ * In the wound case the caller must release all currently held w/w mutexes for
+ * the given context and then wait for this contending lock to be available by
+ * calling ww_mutex_lock_slow_interruptible. Alternatively callers can opt to
+ * not acquire this lock and proceed with trying to acquire further w/w mutexes
+ * (e.g. when scanning through lru lists trying to free resources).
+ *
+ * The mutex must later on be released by the same task that
+ * acquired it. The task may not exit without first unlocking the mutex. Also,
+ * kernel memory where the mutex resides must not be freed with the mutex still
+ * locked. The mutex must first be initialized (or statically defined) before it
+ * can be locked. memset()-ing the mutex to 0 is not allowed. The mutex must be
+ * of the same w/w lock class as was used to initialize the acquire context.
+ *
+ * A mutex acquired with this function must be released with ww_mutex_unlock.
+ */
+static inline int __must_check ww_mutex_lock_interruptible(struct ww_mutex *lock,
+                                                           struct ww_acquire_ctx *ctx)
+{
+        if (ctx)
+                return __ww_mutex_lock_interruptible(lock, ctx);
+        else
+                return mutex_lock_interruptible(&lock->base);
+}
+
+/**
+ * ww_mutex_lock_slow - slowpath acquiring of the w/w mutex
+ * @lock: the mutex to be acquired
+ * @ctx: w/w acquire context
+ *
+ * Acquires a w/w mutex with the given context after a wound case. This function
+ * will sleep until the lock becomes available.
+ *
+ * The caller must have released all w/w mutexes already acquired with the
+ * context and then call this function on the contended lock.
+ *
+ * Afterwards the caller may continue to (re)acquire the other w/w mutexes it
+ * needs with ww_mutex_lock. Note that the -EALREADY return code from
+ * ww_mutex_lock can be used to avoid locking this contended mutex twice.
+ *
+ * It is forbidden to call this function with any other w/w mutexes associated
+ * with the context held. It is forbidden to call this on anything else than the
+ * contending mutex.
+ *
+ * Note that the slowpath lock acquiring can also be done by calling
+ * ww_mutex_lock directly. This function here is simply to help w/w mutex
+ * locking code readability by clearly denoting the slowpath.
+ */
+static inline void
+ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
+{
+        int ret;
+#ifdef CONFIG_DEBUG_MUTEXES
+        DEBUG_LOCKS_WARN_ON(!ctx->contending_lock);
+#endif
+        ret = ww_mutex_lock(lock, ctx);
+        (void)ret;
+}
+
+/**
+ * ww_mutex_lock_slow_interruptible - slowpath acquiring of the w/w mutex,
+ *                                    interruptible
+ * @lock: the mutex to be acquired
+ * @ctx: w/w acquire context
+ *
+ * Acquires a w/w mutex with the given context after a wound case. This function
+ * will sleep until the lock becomes available and returns 0 when the lock has
+ * been acquired. If a signal arrives while waiting for the lock then this
+ * function returns -EINTR.
+ *
+ * The caller must have released all w/w mutexes already acquired with the
+ * context and then call this function on the contended lock.
+ *
+ * Afterwards the caller may continue to (re)acquire the other w/w mutexes it
+ * needs with ww_mutex_lock. Note that the -EALREADY return code from
+ * ww_mutex_lock can be used to avoid locking this contended mutex twice.
+ *
+ * It is forbidden to call this function with any other w/w mutexes associated
+ * with the given context held. It is forbidden to call this on anything else
+ * than the contending mutex.
+ *
+ * Note that the slowpath lock acquiring can also be done by calling
+ * ww_mutex_lock_interruptible directly. This function here is simply to help
+ * w/w mutex locking code readability by clearly denoting the slowpath.
+ */
+static inline int __must_check
+ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,
+                                 struct ww_acquire_ctx *ctx)
+{
+#ifdef CONFIG_DEBUG_MUTEXES
+        DEBUG_LOCKS_WARN_ON(!ctx->contending_lock);
+#endif
+        return ww_mutex_lock_interruptible(lock, ctx);
+}
+
+extern void ww_mutex_unlock(struct ww_mutex *lock);
+
+/**
+ * ww_mutex_trylock - tries to acquire the w/w mutex without acquire context
+ * @lock: mutex to lock
+ *
+ * Trylocks a mutex without acquire context, so no deadlock detection is
+ * possible. Returns 1 if the mutex has been acquired successfully, 0 otherwise.
+ */
+static inline int __must_check ww_mutex_trylock(struct ww_mutex *lock)
+{
+        return mutex_trylock(&lock->base);
+}
+
+/***
+ * ww_mutex_destroy - mark a w/w mutex unusable
+ * @lock: the mutex to be destroyed
+ *
+ * This function marks the mutex uninitialized, and any subsequent
+ * use of the mutex is forbidden. The mutex must not be locked when
+ * this function is called.
+ */
+static inline void ww_mutex_destroy(struct ww_mutex *lock)
+{
+        mutex_destroy(&lock->base);
+}
+
+/**
+ * ww_mutex_is_locked - is the w/w mutex locked
+ * @lock: the mutex to be queried
+ *
+ * Returns 1 if the mutex is locked, 0 if unlocked.
+ */
+static inline bool ww_mutex_is_locked(struct ww_mutex *lock)
+{
+        return mutex_is_locked(&lock->base);
+}
+
 extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
 
 #ifndef CONFIG_HAVE_ARCH_MUTEX_CPU_RELAX
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 60584b185a0c..96e4c21e15e0 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -1695,6 +1695,7 @@ extern int		init_dummy_netdev(struct net_device *dev);
 extern struct net_device        *dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *__dev_get_by_index(struct net *net, int ifindex);
 extern struct net_device        *dev_get_by_index_rcu(struct net *net, int ifindex);
+extern int              netdev_get_name(struct net *net, char *name, int ifindex);
 extern int              dev_restart(struct net_device *dev);
 #ifdef CONFIG_NETPOLL_TRAP
 extern int              netpoll_trap(void);
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index 98ffb54988b6..2d4df6ce043e 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -17,6 +17,22 @@ extern __sum16 nf_ip6_checksum(struct sk_buff *skb, unsigned int hook,
 
 extern int ipv6_netfilter_init(void);
 extern void ipv6_netfilter_fini(void);
+
+/*
+ * Hook functions for ipv6 to allow xt_* modules to be built-in even
+ * if IPv6 is a module.
+ */
+struct nf_ipv6_ops {
+        int (*chk_addr)(struct net *net, const struct in6_addr *addr,
+                        const struct net_device *dev, int strict);
+};
+
+extern const struct nf_ipv6_ops __rcu *nf_ipv6_ops;
+static inline const struct nf_ipv6_ops *nf_get_ipv6_ops(void)
+{
+        return rcu_dereference(nf_ipv6_ops);
+}
+
 #else /* CONFIG_NETFILTER */
 static inline int ipv6_netfilter_init(void) { return 0; }
 static inline void ipv6_netfilter_fini(void) { return; }
diff --git a/include/linux/of_address.h b/include/linux/of_address.h
index 0506eb53519b..4c2e6f26432c 100644
--- a/include/linux/of_address.h
+++ b/include/linux/of_address.h
@@ -4,6 +4,36 @@
 #include <linux/errno.h>
 #include <linux/of.h>
 
+struct of_pci_range_parser {
+        struct device_node *node;
+        const __be32 *range;
+        const __be32 *end;
+        int np;
+        int pna;
+};
+
+struct of_pci_range {
+        u32 pci_space;
+        u64 pci_addr;
+        u64 cpu_addr;
+        u64 size;
+        u32 flags;
+};
+
+#define for_each_of_pci_range(parser, range) \
+        for (; of_pci_range_parser_one(parser, range);)
+
+static inline void of_pci_range_to_resource(struct of_pci_range *range,
+                                            struct device_node *np,
+                                            struct resource *res)
+{
+        res->flags = range->flags;
+        res->start = range->cpu_addr;
+        res->end = range->cpu_addr + range->size - 1;
+        res->parent = res->child = res->sibling = NULL;
+        res->name = np->full_name;
+}
+
 #ifdef CONFIG_OF_ADDRESS
 extern u64 of_translate_address(struct device_node *np, const __be32 *addr);
 extern bool of_can_translate_address(struct device_node *dev);
@@ -27,6 +57,11 @@ static inline unsigned long pci_address_to_pio(phys_addr_t addr) { return -1; }
 #define pci_address_to_pio pci_address_to_pio
 #endif
 
+extern int of_pci_range_parser_init(struct of_pci_range_parser *parser,
+                        struct device_node *node);
+extern struct of_pci_range *of_pci_range_parser_one(
+                                        struct of_pci_range_parser *parser,
+                                        struct of_pci_range *range);
 #else /* CONFIG_OF_ADDRESS */
 #ifndef of_address_to_resource
 static inline int of_address_to_resource(struct device_node *dev, int index,
@@ -53,6 +88,19 @@ static inline const __be32 *of_get_address(struct device_node *dev, int index,
 {
         return NULL;
 }
+
+static inline int of_pci_range_parser_init(struct of_pci_range_parser *parser,
+                        struct device_node *node)
+{
+        return -1;
+}
+
+static inline struct of_pci_range *of_pci_range_parser_one(
+                                        struct of_pci_range_parser *parser,
+                                        struct of_pci_range *range)
+{
+        return NULL;
+}
 #endif /* CONFIG_OF_ADDRESS */
 
 
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index bb115deb7612..7a04826018c0 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -10,5 +10,7 @@ int of_irq_map_pci(const struct pci_dev *pdev, struct of_irq *out_irq);
 struct device_node;
 struct device_node *of_pci_find_child_device(struct device_node *parent,
                                              unsigned int devfn);
+int of_pci_get_devfn(struct device_node *np);
+int of_pci_parse_bus_range(struct device_node *node, struct resource *res);
 
 #endif
diff --git a/include/linux/omap-mailbox.h b/include/linux/omap-mailbox.h
new file mode 100644
index 000000000000..f8322d9cd235
--- /dev/null
+++ b/include/linux/omap-mailbox.h
@@ -0,0 +1,29 @@
+/*
+ * omap-mailbox: interprocessor communication module for OMAP
+ *
+ * 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 OMAP_MAILBOX_H
+#define OMAP_MAILBOX_H
+
+typedef u32 mbox_msg_t;
+struct omap_mbox;
+
+typedef int __bitwise omap_mbox_irq_t;
+#define IRQ_TX ((__force omap_mbox_irq_t) 1)
+#define IRQ_RX ((__force omap_mbox_irq_t) 2)
+
+int omap_mbox_msg_send(struct omap_mbox *, mbox_msg_t msg);
+
+struct omap_mbox *omap_mbox_get(const char *, struct notifier_block *nb);
+void omap_mbox_put(struct omap_mbox *mbox, struct notifier_block *nb);
+
+void omap_mbox_save_ctx(struct omap_mbox *mbox);
+void omap_mbox_restore_ctx(struct omap_mbox *mbox);
+void omap_mbox_enable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq);
+void omap_mbox_disable_irq(struct omap_mbox *mbox, omap_mbox_irq_t irq);
+
+#endif /* OMAP_MAILBOX_H */
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
new file mode 100644
index 000000000000..95961f0bf62d
--- /dev/null
+++ b/include/linux/percpu-refcount.h
@@ -0,0 +1,174 @@
+/*
+ * Percpu refcounts:
+ * (C) 2012 Google, Inc.
+ * Author: Kent Overstreet <koverstreet@google.com>
+ *
+ * This implements a refcount with similar semantics to atomic_t - atomic_inc(),
+ * atomic_dec_and_test() - but percpu.
+ *
+ * There's one important difference between percpu refs and normal atomic_t
+ * refcounts; you have to keep track of your initial refcount, and then when you
+ * start shutting down you call percpu_ref_kill() _before_ dropping the initial
+ * refcount.
+ *
+ * The refcount will have a range of 0 to ((1U << 31) - 1), i.e. one bit less
+ * than an atomic_t - this is because of the way shutdown works, see
+ * percpu_ref_kill()/PCPU_COUNT_BIAS.
+ *
+ * Before you call percpu_ref_kill(), percpu_ref_put() does not check for the
+ * refcount hitting 0 - it can't, if it was in percpu mode. percpu_ref_kill()
+ * puts the ref back in single atomic_t mode, collecting the per cpu refs and
+ * issuing the appropriate barriers, and then marks the ref as shutting down so
+ * that percpu_ref_put() will check for the ref hitting 0.  After it returns,
+ * it's safe to drop the initial ref.
+ *
+ * USAGE:
+ *
+ * See fs/aio.c for some example usage; it's used there for struct kioctx, which
+ * is created when userspaces calls io_setup(), and destroyed when userspace
+ * calls io_destroy() or the process exits.
+ *
+ * In the aio code, kill_ioctx() is called when we wish to destroy a kioctx; it
+ * calls percpu_ref_kill(), then hlist_del_rcu() and sychronize_rcu() to remove
+ * the kioctx from the proccess's list of kioctxs - after that, there can't be
+ * any new users of the kioctx (from lookup_ioctx()) and it's then safe to drop
+ * the initial ref with percpu_ref_put().
+ *
+ * Code that does a two stage shutdown like this often needs some kind of
+ * explicit synchronization to ensure the initial refcount can only be dropped
+ * once - percpu_ref_kill() does this for you, it returns true once and false if
+ * someone else already called it. The aio code uses it this way, but it's not
+ * necessary if the code has some other mechanism to synchronize teardown.
+ * around.
+ */
+
+#ifndef _LINUX_PERCPU_REFCOUNT_H
+#define _LINUX_PERCPU_REFCOUNT_H
+
+#include <linux/atomic.h>
+#include <linux/kernel.h>
+#include <linux/percpu.h>
+#include <linux/rcupdate.h>
+
+struct percpu_ref;
+typedef void (percpu_ref_func_t)(struct percpu_ref *);
+
+struct percpu_ref {
+        atomic_t                count;
+        /*
+         * The low bit of the pointer indicates whether the ref is in percpu
+         * mode; if set, then get/put will manipulate the atomic_t (this is a
+         * hack because we need to keep the pointer around for
+         * percpu_ref_kill_rcu())
+         */
+        unsigned __percpu       *pcpu_count;
+        percpu_ref_func_t       *release;
+        percpu_ref_func_t       *confirm_kill;
+        struct rcu_head         rcu;
+};
+
+int __must_check percpu_ref_init(struct percpu_ref *ref,
+                                 percpu_ref_func_t *release);
+void percpu_ref_cancel_init(struct percpu_ref *ref);
+void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
+                                 percpu_ref_func_t *confirm_kill);
+
+/**
+ * percpu_ref_kill - drop the initial ref
+ * @ref: percpu_ref to kill
+ *
+ * Must be used to drop the initial ref on a percpu refcount; must be called
+ * precisely once before shutdown.
+ *
+ * Puts @ref in non percpu mode, then does a call_rcu() before gathering up the
+ * percpu counters and dropping the initial ref.
+ */
+static inline void percpu_ref_kill(struct percpu_ref *ref)
+{
+        return percpu_ref_kill_and_confirm(ref, NULL);
+}
+
+#define PCPU_STATUS_BITS        2
+#define PCPU_STATUS_MASK        ((1 << PCPU_STATUS_BITS) - 1)
+#define PCPU_REF_PTR            0
+#define PCPU_REF_DEAD           1
+
+#define REF_STATUS(count)       (((unsigned long) count) & PCPU_STATUS_MASK)
+
+/**
+ * percpu_ref_get - increment a percpu refcount
+ * @ref: percpu_ref to get
+ *
+ * Analagous to atomic_inc().
+  */
+static inline void percpu_ref_get(struct percpu_ref *ref)
+{
+        unsigned __percpu *pcpu_count;
+
+        rcu_read_lock_sched();
+
+        pcpu_count = ACCESS_ONCE(ref->pcpu_count);
+
+        if (likely(REF_STATUS(pcpu_count) == PCPU_REF_PTR))
+                __this_cpu_inc(*pcpu_count);
+        else
+                atomic_inc(&ref->count);
+
+        rcu_read_unlock_sched();
+}
+
+/**
+ * percpu_ref_tryget - try to increment a percpu refcount
+ * @ref: percpu_ref to try-get
+ *
+ * Increment a percpu refcount unless it has already been killed.  Returns
+ * %true on success; %false on failure.
+ *
+ * Completion of percpu_ref_kill() in itself doesn't guarantee that tryget
+ * will fail.  For such guarantee, percpu_ref_kill_and_confirm() should be
+ * used.  After the confirm_kill callback is invoked, it's guaranteed that
+ * no new reference will be given out by percpu_ref_tryget().
+ */
+static inline bool percpu_ref_tryget(struct percpu_ref *ref)
+{
+        unsigned __percpu *pcpu_count;
+        int ret = false;
+
+        rcu_read_lock_sched();
+
+        pcpu_count = ACCESS_ONCE(ref->pcpu_count);
+
+        if (likely(REF_STATUS(pcpu_count) == PCPU_REF_PTR)) {
+                __this_cpu_inc(*pcpu_count);
+                ret = true;
+        }
+
+        rcu_read_unlock_sched();
+
+        return ret;
+}
+
+/**
+ * percpu_ref_put - decrement a percpu refcount
+ * @ref: percpu_ref to put
+ *
+ * Decrement the refcount, and if 0, call the release function (which was passed
+ * to percpu_ref_init())
+ */
+static inline void percpu_ref_put(struct percpu_ref *ref)
+{
+        unsigned __percpu *pcpu_count;
+
+        rcu_read_lock_sched();
+
+        pcpu_count = ACCESS_ONCE(ref->pcpu_count);
+
+        if (likely(REF_STATUS(pcpu_count) == PCPU_REF_PTR))
+                __this_cpu_dec(*pcpu_count);
+        else if (unlikely(atomic_dec_and_test(&ref->count)))
+                ref->release(ref);
+
+        rcu_read_unlock_sched();
+}
+
+#endif
diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h
index f463a46424e2..8873f82c7baa 100644
--- a/include/linux/perf_event.h
+++ b/include/linux/perf_event.h
@@ -73,13 +73,18 @@ struct perf_raw_record {
  *
  * support for mispred, predicted is optional. In case it
  * is not supported mispred = predicted = 0.
+ *
+ *     in_tx: running in a hardware transaction
+ *     abort: aborting a hardware transaction
  */
 struct perf_branch_entry {
         __u64   from;
         __u64   to;
         __u64   mispred:1,  /* target mispredicted */
                 predicted:1,/* target predicted */
-                reserved:62;
+                in_tx:1,    /* in transaction */
+                abort:1,    /* transaction abort */
+                reserved:60;
 };
 
 /*
@@ -113,6 +118,8 @@ struct hw_perf_event_extra {
         int             idx;    /* index in shared_regs->regs[] */
 };
 
+struct event_constraint;
+
 /**
  * struct hw_perf_event - performance event hardware details:
  */
@@ -131,6 +138,8 @@ struct hw_perf_event {
 
                         struct hw_perf_event_extra extra_reg;
                         struct hw_perf_event_extra branch_reg;
+
+                        struct event_constraint *constraint;
                 };
                 struct { /* software */
                         struct hrtimer  hrtimer;
@@ -188,12 +197,13 @@ struct pmu {
 
         struct device                   *dev;
         const struct attribute_group    **attr_groups;
-        char                            *name;
+        const char                      *name;
         int                             type;
 
         int * __percpu                  pmu_disable_count;
         struct perf_cpu_context * __percpu pmu_cpu_context;
         int                             task_ctx_nr;
+        int                             hrtimer_interval_ms;
 
         /*
          * Fully disable/enable this PMU, can be used to protect from the PMI
@@ -389,8 +399,7 @@ struct perf_event {
         /* mmap bits */
         struct mutex                    mmap_mutex;
         atomic_t                        mmap_count;
-        int                             mmap_locked;
-        struct user_struct              *mmap_user;
+
         struct ring_buffer              *rb;
         struct list_head                rb_entry;
 
@@ -501,8 +510,9 @@ struct perf_cpu_context {
         struct perf_event_context       *task_ctx;
         int                             active_oncpu;
         int                             exclusive;
+        struct hrtimer                  hrtimer;
+        ktime_t                         hrtimer_interval;
         struct list_head                rotation_list;
-        int                             jiffies_interval;
         struct pmu                      *unique_pmu;
         struct perf_cgroup              *cgrp;
 };
@@ -518,7 +528,7 @@ struct perf_output_handle {
 
 #ifdef CONFIG_PERF_EVENTS
 
-extern int perf_pmu_register(struct pmu *pmu, char *name, int type);
+extern int perf_pmu_register(struct pmu *pmu, const char *name, int type);
 extern void perf_pmu_unregister(struct pmu *pmu);
 
 extern int perf_num_counters(void);
@@ -696,10 +706,17 @@ static inline void perf_callchain_store(struct perf_callchain_entry *entry, u64
 extern int sysctl_perf_event_paranoid;
 extern int sysctl_perf_event_mlock;
 extern int sysctl_perf_event_sample_rate;
+extern int sysctl_perf_cpu_time_max_percent;
+
+extern void perf_sample_event_took(u64 sample_len_ns);
 
 extern int perf_proc_update_handler(struct ctl_table *table, int write,
                 void __user *buffer, size_t *lenp,
                 loff_t *ppos);
+extern int perf_cpu_time_max_percent_handler(struct ctl_table *table, int write,
+                void __user *buffer, size_t *lenp,
+                loff_t *ppos);
+
 
 static inline bool perf_paranoid_tracepoint_raw(void)
 {
@@ -743,6 +760,7 @@ extern unsigned int perf_output_skip(struct perf_output_handle *handle,
                                      unsigned int len);
 extern int perf_swevent_get_recursion_context(void);
 extern void perf_swevent_put_recursion_context(int rctx);
+extern u64 perf_swevent_set_period(struct perf_event *event);
 extern void perf_event_enable(struct perf_event *event);
 extern void perf_event_disable(struct perf_event *event);
 extern int __perf_event_disable(void *info);
@@ -782,6 +800,7 @@ static inline void perf_event_fork(struct task_struct *tsk)		{ }
 static inline void perf_event_init(void)                                { }
 static inline int  perf_swevent_get_recursion_context(void)             { return -1; }
 static inline void perf_swevent_put_recursion_context(int rctx)         { }
+static inline u64 perf_swevent_set_period(struct perf_event *event)     { return 0; }
 static inline void perf_event_enable(struct perf_event *event)          { }
 static inline void perf_event_disable(struct perf_event *event)         { }
 static inline int __perf_event_disable(void *info)                      { return -1; }
@@ -803,7 +822,7 @@ static inline void perf_restore_debug_store(void)			{ }
 #define perf_output_put(handle, x) perf_output_copy((handle), &(x), sizeof(x))
 
 /*
- * This has to have a higher priority than migration_notifier in sched.c.
+ * This has to have a higher priority than migration_notifier in sched/core.c.
  */
 #define perf_cpu_notifier(fn)                                           \
 do {                                                                    \
diff --git a/include/linux/platform_data/ad7303.h b/include/linux/platform_data/ad7303.h
new file mode 100644
index 000000000000..de6a7a6b4bbf
--- /dev/null
+++ b/include/linux/platform_data/ad7303.h
@@ -0,0 +1,21 @@
+/*
+ * Analog Devices AD7303 DAC driver
+ *
+ * Copyright 2013 Analog Devices Inc.
+ *
+ * Licensed under the GPL-2.
+ */
+
+#ifndef __IIO_ADC_AD7303_H__
+#define __IIO_ADC_AD7303_H__
+
+/**
+ * struct ad7303_platform_data - AD7303 platform data
+ * @use_external_ref: If set to true use an external voltage reference connected
+ * to the REF pin, otherwise use the internal reference derived from Vdd.
+ */
+struct ad7303_platform_data {
+        bool use_external_ref;
+};
+
+#endif
diff --git a/include/linux/platform_data/dma-ste-dma40.h b/include/linux/platform_data/dma-ste-dma40.h
index 4b781014b0a0..1bb9b1852256 100644
--- a/include/linux/platform_data/dma-ste-dma40.h
+++ b/include/linux/platform_data/dma-ste-dma40.h
@@ -70,23 +70,8 @@ enum stedma40_flow_ctrl {
         STEDMA40_FLOW_CTRL,
 };
 
-enum stedma40_periph_data_width {
-        STEDMA40_BYTE_WIDTH = STEDMA40_ESIZE_8_BIT,
-        STEDMA40_HALFWORD_WIDTH = STEDMA40_ESIZE_16_BIT,
-        STEDMA40_WORD_WIDTH = STEDMA40_ESIZE_32_BIT,
-        STEDMA40_DOUBLEWORD_WIDTH = STEDMA40_ESIZE_64_BIT
-};
-
-enum stedma40_xfer_dir {
-        STEDMA40_MEM_TO_MEM = 1,
-        STEDMA40_MEM_TO_PERIPH,
-        STEDMA40_PERIPH_TO_MEM,
-        STEDMA40_PERIPH_TO_PERIPH
-};
-
-
 /**
- * struct stedma40_chan_cfg - dst/src channel configuration
+ * struct stedma40_half_channel_info - dst/src channel configuration
  *
  * @big_endian: true if the src/dst should be read as big endian
  * @data_width: Data width of the src/dst hardware
@@ -95,7 +80,7 @@ enum stedma40_xfer_dir {
  */
 struct stedma40_half_channel_info {
         bool big_endian;
-        enum stedma40_periph_data_width data_width;
+        enum dma_slave_buswidth data_width;
         int psize;
         enum stedma40_flow_ctrl flow_ctrl;
 };
@@ -109,8 +94,7 @@ struct stedma40_half_channel_info {
  * version 3+, i.e DB8500v2+
  * @mode: channel mode: physical, logical, or operation
  * @mode_opt: options for the chosen channel mode
- * @src_dev_type: Src device type
- * @dst_dev_type: Dst device type
+ * @dev_type: src/dst device type (driver uses dir to figure out which)
  * @src_info: Parameters for dst half channel
  * @dst_info: Parameters for dst half channel
  * @use_fixed_channel: if true, use physical channel specified by phy_channel
@@ -121,13 +105,12 @@ struct stedma40_half_channel_info {
  *
  */
 struct stedma40_chan_cfg {
-        enum stedma40_xfer_dir                   dir;
+        enum dma_transfer_direction              dir;
         bool                                     high_priority;
         bool                                     realtime;
         enum stedma40_mode                       mode;
         enum stedma40_mode_opt                   mode_opt;
-        int                                      src_dev_type;
-        int                                      dst_dev_type;
+        int                                      dev_type;
         struct stedma40_half_channel_info        src_info;
         struct stedma40_half_channel_info        dst_info;
 
@@ -138,13 +121,8 @@ struct stedma40_chan_cfg {
 /**
  * struct stedma40_platform_data - Configuration struct for the dma device.
  *
- * @dev_len: length of dev_tx and dev_rx
  * @dev_tx: mapping between destination event line and io address
  * @dev_rx: mapping between source event line and io address
- * @memcpy: list of memcpy event lines
- * @memcpy_len: length of memcpy
- * @memcpy_conf_phy: default configuration of physical channel memcpy
- * @memcpy_conf_log: default configuration of logical channel memcpy
  * @disabled_channels: A vector, ending with -1, that marks physical channels
  * that are for different reasons not available for the driver.
  * @soft_lli_chans: A vector, that marks physical channels will use LLI by SW
@@ -154,22 +132,17 @@ struct stedma40_chan_cfg {
  * @num_of_soft_lli_chans: The number of channels that needs to be configured
  * to use SoftLLI.
  * @use_esram_lcla: flag for mapping the lcla into esram region
+ * @num_of_memcpy_chans: The number of channels reserved for memcpy.
  * @num_of_phy_chans: The number of physical channels implemented in HW.
  * 0 means reading the number of channels from DMA HW but this is only valid
  * for 'multiple of 4' channels, like 8.
  */
 struct stedma40_platform_data {
-        u32                              dev_len;
-        const dma_addr_t                *dev_tx;
-        const dma_addr_t                *dev_rx;
-        int                             *memcpy;
-        u32                              memcpy_len;
-        struct stedma40_chan_cfg        *memcpy_conf_phy;
-        struct stedma40_chan_cfg        *memcpy_conf_log;
         int                              disabled_channels[STEDMA40_MAX_PHYS];
         int                             *soft_lli_chans;
         int                              num_of_soft_lli_chans;
         bool                             use_esram_lcla;
+        int                              num_of_memcpy_chans;
         int                              num_of_phy_chans;
 };
 
diff --git a/include/linux/platform_data/edma.h b/include/linux/platform_data/edma.h
new file mode 100644
index 000000000000..57300fd7cc03
--- /dev/null
+++ b/include/linux/platform_data/edma.h
@@ -0,0 +1,183 @@
+/*
+ *  TI EDMA definitions
+ *
+ *  Copyright (C) 2006-2013 Texas Instruments.
+ *
+ *  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 EDMA3 programming framework exposes two basic kinds of resource:
+ *
+ *  Channel     Triggers transfers, usually from a hardware event but
+ *              also manually or by "chaining" from DMA completions.
+ *              Each channel is coupled to a Parameter RAM (PaRAM) slot.
+ *
+ *  Slot        Each PaRAM slot holds a DMA transfer descriptor (PaRAM
+ *              "set"), source and destination addresses, a link to a
+ *              next PaRAM slot (if any), options for the transfer, and
+ *              instructions for updating those addresses.  There are
+ *              more than twice as many slots as event channels.
+ *
+ * Each PaRAM set describes a sequence of transfers, either for one large
+ * buffer or for several discontiguous smaller buffers.  An EDMA transfer
+ * is driven only from a channel, which performs the transfers specified
+ * in its PaRAM slot until there are no more transfers.  When that last
+ * transfer completes, the "link" field may be used to reload the channel's
+ * PaRAM slot with a new transfer descriptor.
+ *
+ * The EDMA Channel Controller (CC) maps requests from channels into physical
+ * Transfer Controller (TC) requests when the channel triggers (by hardware
+ * or software events, or by chaining).  The two physical DMA channels provided
+ * by the TCs are thus shared by many logical channels.
+ *
+ * DaVinci hardware also has a "QDMA" mechanism which is not currently
+ * supported through this interface.  (DSP firmware uses it though.)
+ */
+
+#ifndef EDMA_H_
+#define EDMA_H_
+
+/* PaRAM slots are laid out like this */
+struct edmacc_param {
+        unsigned int opt;
+        unsigned int src;
+        unsigned int a_b_cnt;
+        unsigned int dst;
+        unsigned int src_dst_bidx;
+        unsigned int link_bcntrld;
+        unsigned int src_dst_cidx;
+        unsigned int ccnt;
+};
+
+/* fields in edmacc_param.opt */
+#define SAM             BIT(0)
+#define DAM             BIT(1)
+#define SYNCDIM         BIT(2)
+#define STATIC          BIT(3)
+#define EDMA_FWID       (0x07 << 8)
+#define TCCMODE         BIT(11)
+#define EDMA_TCC(t)     ((t) << 12)
+#define TCINTEN         BIT(20)
+#define ITCINTEN        BIT(21)
+#define TCCHEN          BIT(22)
+#define ITCCHEN         BIT(23)
+
+/*ch_status paramater of callback function possible values*/
+#define DMA_COMPLETE 1
+#define DMA_CC_ERROR 2
+#define DMA_TC1_ERROR 3
+#define DMA_TC2_ERROR 4
+
+enum address_mode {
+        INCR = 0,
+        FIFO = 1
+};
+
+enum fifo_width {
+        W8BIT = 0,
+        W16BIT = 1,
+        W32BIT = 2,
+        W64BIT = 3,
+        W128BIT = 4,
+        W256BIT = 5
+};
+
+enum dma_event_q {
+        EVENTQ_0 = 0,
+        EVENTQ_1 = 1,
+        EVENTQ_2 = 2,
+        EVENTQ_3 = 3,
+        EVENTQ_DEFAULT = -1
+};
+
+enum sync_dimension {
+        ASYNC = 0,
+        ABSYNC = 1
+};
+
+#define EDMA_CTLR_CHAN(ctlr, chan)      (((ctlr) << 16) | (chan))
+#define EDMA_CTLR(i)                    ((i) >> 16)
+#define EDMA_CHAN_SLOT(i)               ((i) & 0xffff)
+
+#define EDMA_CHANNEL_ANY                -1      /* for edma_alloc_channel() */
+#define EDMA_SLOT_ANY                   -1      /* for edma_alloc_slot() */
+#define EDMA_CONT_PARAMS_ANY             1001
+#define EDMA_CONT_PARAMS_FIXED_EXACT     1002
+#define EDMA_CONT_PARAMS_FIXED_NOT_EXACT 1003
+
+#define EDMA_MAX_CC               2
+
+/* alloc/free DMA channels and their dedicated parameter RAM slots */
+int edma_alloc_channel(int channel,
+        void (*callback)(unsigned channel, u16 ch_status, void *data),
+        void *data, enum dma_event_q);
+void edma_free_channel(unsigned channel);
+
+/* alloc/free parameter RAM slots */
+int edma_alloc_slot(unsigned ctlr, int slot);
+void edma_free_slot(unsigned slot);
+
+/* alloc/free a set of contiguous parameter RAM slots */
+int edma_alloc_cont_slots(unsigned ctlr, unsigned int id, int slot, int count);
+int edma_free_cont_slots(unsigned slot, int count);
+
+/* calls that operate on part of a parameter RAM slot */
+void edma_set_src(unsigned slot, dma_addr_t src_port,
+                                enum address_mode mode, enum fifo_width);
+void edma_set_dest(unsigned slot, dma_addr_t dest_port,
+                                 enum address_mode mode, enum fifo_width);
+void edma_get_position(unsigned slot, dma_addr_t *src, dma_addr_t *dst);
+void edma_set_src_index(unsigned slot, s16 src_bidx, s16 src_cidx);
+void edma_set_dest_index(unsigned slot, s16 dest_bidx, s16 dest_cidx);
+void edma_set_transfer_params(unsigned slot, u16 acnt, u16 bcnt, u16 ccnt,
+                u16 bcnt_rld, enum sync_dimension sync_mode);
+void edma_link(unsigned from, unsigned to);
+void edma_unlink(unsigned from);
+
+/* calls that operate on an entire parameter RAM slot */
+void edma_write_slot(unsigned slot, const struct edmacc_param *params);
+void edma_read_slot(unsigned slot, struct edmacc_param *params);
+
+/* channel control operations */
+int edma_start(unsigned channel);
+void edma_stop(unsigned channel);
+void edma_clean_channel(unsigned channel);
+void edma_clear_event(unsigned channel);
+void edma_pause(unsigned channel);
+void edma_resume(unsigned channel);
+
+struct edma_rsv_info {
+
+        const s16       (*rsv_chans)[2];
+        const s16       (*rsv_slots)[2];
+};
+
+/* platform_data for EDMA driver */
+struct edma_soc_info {
+
+        /* how many dma resources of each type */
+        unsigned        n_channel;
+        unsigned        n_region;
+        unsigned        n_slot;
+        unsigned        n_tc;
+        unsigned        n_cc;
+        /*
+         * Default queue is expected to be a low-priority queue.
+         * This way, long transfers on the default queue started
+         * by the codec engine will not cause audio defects.
+         */
+        enum dma_event_q        default_queue;
+
+        /* Resource reservation for other cores */
+        struct edma_rsv_info    *rsv;
+
+        s8      (*queue_tc_mapping)[2];
+        s8      (*queue_priority_mapping)[2];
+        const s16       (*xbar_chans)[2];
+};
+
+#endif
diff --git a/include/linux/platform_data/gpio-rcar.h b/include/linux/platform_data/gpio-rcar.h
index b253f77a7ddf..2d8d69432813 100644
--- a/include/linux/platform_data/gpio-rcar.h
+++ b/include/linux/platform_data/gpio-rcar.h
@@ -17,10 +17,13 @@
 #define __GPIO_RCAR_H__
 
 struct gpio_rcar_config {
-        unsigned int gpio_base;
+        int gpio_base;
         unsigned int irq_base;
         unsigned int number_of_pins;
         const char *pctl_name;
+        unsigned has_both_edge_trigger:1;
 };
 
+#define RCAR_GP_PIN(bank, pin)          (((bank) * 32) + (pin))
+
 #endif /* __GPIO_RCAR_H__ */
diff --git a/include/linux/platform_data/mailbox-omap.h b/include/linux/platform_data/mailbox-omap.h
new file mode 100644
index 000000000000..4631dbb4255e
--- /dev/null
+++ b/include/linux/platform_data/mailbox-omap.h
@@ -0,0 +1,58 @@
+/*
+ * mailbox-omap.h
+ *
+ * Copyright (C) 2013 Texas Instruments, Inc.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2 as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef _PLAT_MAILBOX_H
+#define _PLAT_MAILBOX_H
+
+/* Interrupt register configuration types */
+#define MBOX_INTR_CFG_TYPE1     (0)
+#define MBOX_INTR_CFG_TYPE2     (1)
+
+/**
+ * struct omap_mbox_dev_info - OMAP mailbox device attribute info
+ * @name:       name of the mailbox device
+ * @tx_id:      mailbox queue id used for transmitting messages
+ * @rx_id:      mailbox queue id on which messages are received
+ * @irq_id:     irq identifier number to use from the hwmod data
+ * @usr_id:     mailbox user id for identifying the interrupt into
+ *                      the MPU interrupt controller.
+ */
+struct omap_mbox_dev_info {
+        const char *name;
+        u32 tx_id;
+        u32 rx_id;
+        u32 irq_id;
+        u32 usr_id;
+};
+
+/**
+ * struct omap_mbox_pdata - OMAP mailbox platform data
+ * @intr_type:  type of interrupt configuration registers used
+                        while programming mailbox queue interrupts
+ * @num_users:  number of users (processor devices) that the mailbox
+ *                      h/w block can interrupt
+ * @num_fifos:  number of h/w fifos within the mailbox h/w block
+ * @info_cnt:   number of mailbox devices for the platform
+ * @info:       array of mailbox device attributes
+ */
+struct omap_mbox_pdata {
+        u32 intr_type;
+        u32 num_users;
+        u32 num_fifos;
+        u32 info_cnt;
+        struct omap_mbox_dev_info *info;
+};
+
+#endif /* _PLAT_MAILBOX_H */
diff --git a/include/linux/platform_data/omap_ocp2scp.h b/include/linux/platform_data/omap_ocp2scp.h
deleted file mode 100644
index 5c6c3939355f..000000000000
--- a/include/linux/platform_data/omap_ocp2scp.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * omap_ocp2scp.h -- ocp2scp header file
- *
- * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * Author: Kishon Vijay Abraham I <kishon@ti.com>
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef __DRIVERS_OMAP_OCP2SCP_H
-#define __DRIVERS_OMAP_OCP2SCP_H
-
-struct omap_ocp2scp_dev {
-        const char                      *drv_name;
-        struct resource                 *res;
-};
-
-struct omap_ocp2scp_platform_data {
-        int                             dev_cnt;
-        struct omap_ocp2scp_dev         **devices;
-};
-#endif /* __DRIVERS_OMAP_OCP2SCP_H */
diff --git a/include/linux/platform_data/pinctrl-coh901.h b/include/linux/platform_data/pinctrl-coh901.h
deleted file mode 100644
index dfbc65d10484..000000000000
--- a/include/linux/platform_data/pinctrl-coh901.h
+++ /dev/null
@@ -1,22 +0,0 @@
-/*
- * Copyright (C) 2007-2012 ST-Ericsson AB
- * License terms: GNU General Public License (GPL) version 2
- * GPIO block resgister definitions and inline macros for
- * U300 GPIO COH 901 335 or COH 901 571/3
- * Author: Linus Walleij <linus.walleij@stericsson.com>
- */
-
-#ifndef __MACH_U300_GPIO_U300_H
-#define __MACH_U300_GPIO_U300_H
-
-/**
- * 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)
- */
-struct u300_gpio_platform {
-        u8 ports;
-        int gpio_base;
-};
-
-#endif /* __MACH_U300_GPIO_U300_H */
diff --git a/include/linux/platform_data/spi-davinci.h b/include/linux/platform_data/spi-davinci.h
index 7af305b37868..8dc2fa47a2aa 100644
--- a/include/linux/platform_data/spi-davinci.h
+++ b/include/linux/platform_data/spi-davinci.h
@@ -19,7 +19,7 @@
 #ifndef __ARCH_ARM_DAVINCI_SPI_H
 #define __ARCH_ARM_DAVINCI_SPI_H
 
-#include <mach/edma.h>
+#include <linux/platform_data/edma.h>
 
 #define SPI_INTERN_CS   0xFF
 
diff --git a/include/linux/platform_data/usb-musb-ux500.h b/include/linux/platform_data/usb-musb-ux500.h
index 4c1cc50a595a..dd9c83ac7de0 100644
--- a/include/linux/platform_data/usb-musb-ux500.h
+++ b/include/linux/platform_data/usb-musb-ux500.h
@@ -9,14 +9,11 @@
 
 #include <linux/dmaengine.h>
 
-#define UX500_MUSB_DMA_NUM_RX_CHANNELS 8
-#define UX500_MUSB_DMA_NUM_TX_CHANNELS 8
+#define UX500_MUSB_DMA_NUM_RX_TX_CHANNELS 8
 
 struct ux500_musb_board_data {
         void    **dma_rx_param_array;
         void    **dma_tx_param_array;
-        u32     num_rx_channels;
-        u32     num_tx_channels;
         bool (*dma_filter)(struct dma_chan *chan, void *filter_param);
 };
 
diff --git a/include/linux/platform_data/usb-rcar-phy.h b/include/linux/platform_data/usb-rcar-phy.h
new file mode 100644
index 000000000000..8ec6964a32a5
--- /dev/null
+++ b/include/linux/platform_data/usb-rcar-phy.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (C) 2013 Renesas Solutions Corp.
+ * Copyright (C) 2013 Cogent Embedded, Inc.
+ *
+ * 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 __USB_RCAR_PHY_H
+#define __USB_RCAR_PHY_H
+
+#include <linux/types.h>
+
+struct rcar_phy_platform_data {
+        bool ferrite_bead:1;    /* (R8A7778 only)                       */
+
+        bool port1_func:1;      /* true: port 1 used by function, false: host */
+        unsigned penc1:1;       /* Output of the PENC1 pin in function mode */
+        struct {                /* Overcurrent pin control for ports 0..2 */
+                bool select_3_3v:1; /* true: USB_OVCn pin, false: OVCn pin */
+                                /* Set to false on port 1 in function mode */
+                bool active_high:1; /* true: active  high, false: active low */
+                                /* Set to true  on port 1 in function mode */
+        } ovc_pin[3];           /* (R8A7778 only has 2 ports)           */
+};
+
+#endif /* __USB_RCAR_PHY_H */
diff --git a/include/linux/platform_data/usb3503.h b/include/linux/platform_data/usb3503.h
index 85dcc709f7e9..1d1b6ef871f6 100644
--- a/include/linux/platform_data/usb3503.h
+++ b/include/linux/platform_data/usb3503.h
@@ -3,6 +3,10 @@
 
 #define USB3503_I2C_NAME        "usb3503"
 
+#define USB3503_OFF_PORT1       (1 << 1)
+#define USB3503_OFF_PORT2       (1 << 2)
+#define USB3503_OFF_PORT3       (1 << 3)
+
 enum usb3503_mode {
         USB3503_MODE_UNKNOWN,
         USB3503_MODE_HUB,
@@ -11,6 +15,7 @@ enum usb3503_mode {
 
 struct usb3503_platform_data {
         enum usb3503_mode       initial_mode;
+        u8      port_off_mask;
         int     gpio_intn;
         int     gpio_connect;
         int     gpio_reset;
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 9abf1db6aea6..cd46ee58b9dc 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -180,7 +180,13 @@ struct platform_driver {
         const struct platform_device_id *id_table;
 };
 
-extern int platform_driver_register(struct platform_driver *);
+/*
+ * use a macro to avoid include chaining to get THIS_MODULE
+ */
+#define platform_driver_register(drv) \
+        __platform_driver_register(drv, THIS_MODULE)
+extern int __platform_driver_register(struct platform_driver *,
+                                        struct module *);
 extern void platform_driver_unregister(struct platform_driver *);
 
 /* non-hotpluggable platform devices may use this so that probe() and
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 87a03c746f17..f5d4723cdb3d 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -33,9 +33,25 @@ do { \
                 preempt_schedule(); \
 } while (0)
 
+#ifdef CONFIG_CONTEXT_TRACKING
+
+void preempt_schedule_context(void);
+
+#define preempt_check_resched_context() \
+do { \
+        if (unlikely(test_thread_flag(TIF_NEED_RESCHED))) \
+                preempt_schedule_context(); \
+} while (0)
+#else
+
+#define preempt_check_resched_context() preempt_check_resched()
+
+#endif /* CONFIG_CONTEXT_TRACKING */
+
 #else /* !CONFIG_PREEMPT */
 
 #define preempt_check_resched()         do { } while (0)
+#define preempt_check_resched_context() do { } while (0)
 
 #endif /* CONFIG_PREEMPT */
 
@@ -88,7 +104,7 @@ do { \
 do { \
         preempt_enable_no_resched_notrace(); \
         barrier(); \
-        preempt_check_resched(); \
+        preempt_check_resched_context(); \
 } while (0)
 
 #else /* !CONFIG_PREEMPT_COUNT */
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 8089e35d47ac..f4b1001a4676 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -461,6 +461,26 @@ static inline void hlist_add_after_rcu(struct hlist_node *prev,
                         &(pos)->member)), typeof(*(pos)), member))
 
 /**
+ * hlist_for_each_entry_rcu_notrace - iterate over rcu list of given type (for tracing)
+ * @pos:        the type * to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the hlist_node within the struct.
+ *
+ * This list-traversal primitive may safely run concurrently with
+ * the _rcu list-mutation primitives such as hlist_add_head_rcu()
+ * as long as the traversal is guarded by rcu_read_lock().
+ *
+ * This is the same as hlist_for_each_entry_rcu() except that it does
+ * not do any RCU debugging or tracing.
+ */
+#define hlist_for_each_entry_rcu_notrace(pos, head, member)                     \
+        for (pos = hlist_entry_safe (rcu_dereference_raw_notrace(hlist_first_rcu(head)),\
+                        typeof(*(pos)), member);                        \
+                pos;                                                    \
+                pos = hlist_entry_safe(rcu_dereference_raw_notrace(hlist_next_rcu(\
+                        &(pos)->member)), typeof(*(pos)), member))
+
+/**
  * hlist_for_each_entry_rcu_bh - iterate over rcu list of given type
  * @pos:        the type * to use as a loop cursor.
  * @head:       the head for your list.
diff --git a/include/linux/rculist_nulls.h b/include/linux/rculist_nulls.h
index 2ae13714828b..1c33dd7da4a7 100644
--- a/include/linux/rculist_nulls.h
+++ b/include/linux/rculist_nulls.h
@@ -105,9 +105,14 @@ static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n,
  * @head:       the head for your list.
  * @member:     the name of the hlist_nulls_node within the struct.
  *
+ * The barrier() is needed to make sure compiler doesn't cache first element [1],
+ * as this loop can be restarted [2]
+ * [1] Documentation/atomic_ops.txt around line 114
+ * [2] Documentation/RCU/rculist_nulls.txt around line 146
  */
 #define hlist_nulls_for_each_entry_rcu(tpos, pos, head, member)                 \
-        for (pos = rcu_dereference_raw(hlist_nulls_first_rcu(head));            \
+        for (({barrier();}),                                                    \
+             pos = rcu_dereference_raw(hlist_nulls_first_rcu(head));            \
                 (!is_a_nulls(pos)) &&                                           \
                 ({ tpos = hlist_nulls_entry(pos, typeof(*tpos), member); 1; }); \
                 pos = rcu_dereference_raw(hlist_nulls_next_rcu(pos)))
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 4ccd68e49b00..4b14bdc911d7 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -216,6 +216,7 @@ static inline int rcu_preempt_depth(void)
 #endif /* #else #ifdef CONFIG_PREEMPT_RCU */
 
 /* Internal to kernel */
+extern void rcu_init(void);
 extern void rcu_sched_qs(int cpu);
 extern void rcu_bh_qs(int cpu);
 extern void rcu_check_callbacks(int cpu, int user);
@@ -239,8 +240,6 @@ 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);
-
 /**
  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
  * @a: Code that RCU needs to pay attention to.
@@ -277,7 +276,7 @@ void wait_rcu_gp(call_rcu_func_t crf);
 
 #if defined(CONFIG_TREE_RCU) || defined(CONFIG_TREE_PREEMPT_RCU)
 #include <linux/rcutree.h>
-#elif defined(CONFIG_TINY_RCU) || defined(CONFIG_TINY_PREEMPT_RCU)
+#elif defined(CONFIG_TINY_RCU)
 #include <linux/rcutiny.h>
 #else
 #error "Unknown RCU implementation specified to kernel configuration"
@@ -640,6 +639,15 @@ static inline void rcu_preempt_sleep_check(void)
 
 #define rcu_dereference_raw(p) rcu_dereference_check(p, 1) /*@@@ needed? @@@*/
 
+/*
+ * The tracing infrastructure traces RCU (we want that), but unfortunately
+ * some of the RCU checks causes tracing to lock up the system.
+ *
+ * The tracing version of rcu_dereference_raw() must not call
+ * rcu_read_lock_held().
+ */
+#define rcu_dereference_raw_notrace(p) __rcu_dereference_check((p), 1, __rcu)
+
 /**
  * rcu_access_index() - fetch RCU index with no dereferencing
  * @p: The index to read
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 4e56a9c69a35..e31005ee339e 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -27,10 +27,6 @@
 
 #include <linux/cache.h>
 
-static inline void rcu_init(void)
-{
-}
-
 static inline void rcu_barrier_bh(void)
 {
         wait_rcu_gp(call_rcu_bh);
@@ -41,8 +37,6 @@ static inline void rcu_barrier_sched(void)
         wait_rcu_gp(call_rcu_sched);
 }
 
-#ifdef CONFIG_TINY_RCU
-
 static inline void synchronize_rcu_expedited(void)
 {
         synchronize_sched();    /* Only one CPU, so pretty fast anyway!!! */
@@ -53,17 +47,6 @@ static inline void rcu_barrier(void)
         rcu_barrier_sched();  /* Only one CPU, so only one list of callbacks! */
 }
 
-#else /* #ifdef CONFIG_TINY_RCU */
-
-void synchronize_rcu_expedited(void);
-
-static inline void rcu_barrier(void)
-{
-        wait_rcu_gp(call_rcu);
-}
-
-#endif /* #else #ifdef CONFIG_TINY_RCU */
-
 static inline void synchronize_rcu_bh(void)
 {
         synchronize_sched();
@@ -85,35 +68,15 @@ static inline void kfree_call_rcu(struct rcu_head *head,
         call_rcu(head, func);
 }
 
-#ifdef CONFIG_TINY_RCU
-
-static inline void rcu_preempt_note_context_switch(void)
-{
-}
-
 static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
 {
         *delta_jiffies = ULONG_MAX;
         return 0;
 }
 
-#else /* #ifdef CONFIG_TINY_RCU */
-
-void rcu_preempt_note_context_switch(void);
-int rcu_preempt_needs_cpu(void);
-
-static inline int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies)
-{
-        *delta_jiffies = ULONG_MAX;
-        return rcu_preempt_needs_cpu();
-}
-
-#endif /* #else #ifdef CONFIG_TINY_RCU */
-
 static inline void rcu_note_context_switch(int cpu)
 {
         rcu_sched_qs(cpu);
-        rcu_preempt_note_context_switch();
 }
 
 /*
@@ -156,6 +119,10 @@ static inline void rcu_cpu_stall_reset(void)
 {
 }
 
+static inline void exit_rcu(void)
+{
+}
+
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
 extern int rcu_scheduler_active __read_mostly;
 extern void rcu_scheduler_starting(void);
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 952b79339304..226169d1bd2b 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -30,7 +30,6 @@
 #ifndef __LINUX_RCUTREE_H
 #define __LINUX_RCUTREE_H
 
-extern void rcu_init(void);
 extern void rcu_note_context_switch(int cpu);
 extern int rcu_needs_cpu(int cpu, unsigned long *delta_jiffies);
 extern void rcu_cpu_stall_reset(void);
@@ -86,6 +85,8 @@ extern void rcu_force_quiescent_state(void);
 extern void rcu_bh_force_quiescent_state(void);
 extern void rcu_sched_force_quiescent_state(void);
 
+extern void exit_rcu(void);
+
 extern void rcu_scheduler_starting(void);
 extern int rcu_scheduler_active __read_mostly;
 
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index 5951e3f38878..26806775b11b 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -111,6 +111,9 @@ static inline struct page *sg_page(struct scatterlist *sg)
 static inline void sg_set_buf(struct scatterlist *sg, const void *buf,
                               unsigned int buflen)
 {
+#ifdef CONFIG_DEBUG_SG
+        BUG_ON(!virt_addr_valid(buf));
+#endif
         sg_set_page(sg, virt_to_page(buf), buflen, offset_in_page(buf));
 }
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 178a8d909f14..ec80684a0127 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -924,7 +924,7 @@ struct load_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
+         * above by 1024/(1-y).  Thus we only need a u32 to store them for all
          * choices of y < 1-2^(-32)*1024.
          */
         u32 runnable_avg_sum, runnable_avg_period;
@@ -994,12 +994,7 @@ struct sched_entity {
         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)
+#ifdef CONFIG_SMP
         /* Per-entity load-tracking */
         struct sched_avg        avg;
 #endif
diff --git a/include/linux/sdb.h b/include/linux/sdb.h
new file mode 100644
index 000000000000..fbb76a46c8a5
--- /dev/null
+++ b/include/linux/sdb.h
@@ -0,0 +1,159 @@
+/*
+ * This is the official version 1.1 of sdb.h
+ */
+#ifndef __SDB_H__
+#define __SDB_H__
+#ifdef __KERNEL__
+#include <linux/types.h>
+#else
+#include <stdint.h>
+#endif
+
+/*
+ * All structures are 64 bytes long and are expected
+ * to live in an array, one for each interconnect.
+ * Most fields of the structures are shared among the
+ * various types, and most-specific fields are at the
+ * beginning (for alignment reasons, and to keep the
+ * magic number at the head of the interconnect record
+ */
+
+/* Product, 40 bytes at offset 24, 8-byte aligned
+ *
+ * device_id is vendor-assigned; version is device-specific,
+ * date is hex (e.g 0x20120501), name is UTF-8, blank-filled
+ * and not terminated with a 0 byte.
+ */
+struct sdb_product {
+        uint64_t                vendor_id;      /* 0x18..0x1f */
+        uint32_t                device_id;      /* 0x20..0x23 */
+        uint32_t                version;        /* 0x24..0x27 */
+        uint32_t                date;           /* 0x28..0x2b */
+        uint8_t                 name[19];       /* 0x2c..0x3e */
+        uint8_t                 record_type;    /* 0x3f */
+};
+
+/*
+ * Component, 56 bytes at offset 8, 8-byte aligned
+ *
+ * The address range is first to last, inclusive
+ * (for example 0x100000 - 0x10ffff)
+ */
+struct sdb_component {
+        uint64_t                addr_first;     /* 0x08..0x0f */
+        uint64_t                addr_last;      /* 0x10..0x17 */
+        struct sdb_product      product;        /* 0x18..0x3f */
+};
+
+/* Type of the SDB record */
+enum sdb_record_type {
+        sdb_type_interconnect   = 0x00,
+        sdb_type_device         = 0x01,
+        sdb_type_bridge         = 0x02,
+        sdb_type_integration    = 0x80,
+        sdb_type_repo_url       = 0x81,
+        sdb_type_synthesis      = 0x82,
+        sdb_type_empty          = 0xFF,
+};
+
+/* Type 0: interconnect (first of the array)
+ *
+ * sdb_records is the length of the table including this first
+ * record, version is 1. The bus type is enumerated later.
+ */
+#define                         SDB_MAGIC       0x5344422d /* "SDB-" */
+struct sdb_interconnect {
+        uint32_t                sdb_magic;      /* 0x00-0x03 */
+        uint16_t                sdb_records;    /* 0x04-0x05 */
+        uint8_t                 sdb_version;    /* 0x06 */
+        uint8_t                 sdb_bus_type;   /* 0x07 */
+        struct sdb_component    sdb_component;  /* 0x08-0x3f */
+};
+
+/* Type 1: device
+ *
+ * class is 0 for "custom device", other values are
+ * to be standardized; ABI version is for the driver,
+ * bus-specific bits are defined by each bus (see below)
+ */
+struct sdb_device {
+        uint16_t                abi_class;      /* 0x00-0x01 */
+        uint8_t                 abi_ver_major;  /* 0x02 */
+        uint8_t                 abi_ver_minor;  /* 0x03 */
+        uint32_t                bus_specific;   /* 0x04-0x07 */
+        struct sdb_component    sdb_component;  /* 0x08-0x3f */
+};
+
+/* Type 2: bridge
+ *
+ * child is the address of the nested SDB table
+ */
+struct sdb_bridge {
+        uint64_t                sdb_child;      /* 0x00-0x07 */
+        struct sdb_component    sdb_component;  /* 0x08-0x3f */
+};
+
+/* Type 0x80: integration
+ *
+ * all types with bit 7 set are meta-information, so
+ * software can ignore the types it doesn't know. Here we
+ * just provide product information for an aggregate device
+ */
+struct sdb_integration {
+        uint8_t                 reserved[24];   /* 0x00-0x17 */
+        struct sdb_product      product;        /* 0x08-0x3f */
+};
+
+/* Type 0x81: Top module repository url
+ *
+ * again, an informative field that software can ignore
+ */
+struct sdb_repo_url {
+        uint8_t                 repo_url[63];   /* 0x00-0x3e */
+        uint8_t                 record_type;    /* 0x3f */
+};
+
+/* Type 0x82: Synthesis tool information
+ *
+ * this informative record
+ */
+struct sdb_synthesis {
+        uint8_t                 syn_name[16];   /* 0x00-0x0f */
+        uint8_t                 commit_id[16];  /* 0x10-0x1f */
+        uint8_t                 tool_name[8];   /* 0x20-0x27 */
+        uint32_t                tool_version;   /* 0x28-0x2b */
+        uint32_t                date;           /* 0x2c-0x2f */
+        uint8_t                 user_name[15];  /* 0x30-0x3e */
+        uint8_t                 record_type;    /* 0x3f */
+};
+
+/* Type 0xff: empty
+ *
+ * this allows keeping empty slots during development,
+ * so they can be filled later with minimal efforts and
+ * no misleading description is ever shipped -- hopefully.
+ * It can also be used to pad a table to a desired length.
+ */
+struct sdb_empty {
+        uint8_t                 reserved[63];   /* 0x00-0x3e */
+        uint8_t                 record_type;    /* 0x3f */
+};
+
+/* The type of bus, for bus-specific flags */
+enum sdb_bus_type {
+        sdb_wishbone = 0x00,
+        sdb_data     = 0x01,
+};
+
+#define SDB_WB_WIDTH_MASK       0x0f
+#define SDB_WB_ACCESS8                  0x01
+#define SDB_WB_ACCESS16                 0x02
+#define SDB_WB_ACCESS32                 0x04
+#define SDB_WB_ACCESS64                 0x08
+#define SDB_WB_LITTLE_ENDIAN    0x80
+
+#define SDB_DATA_READ           0x04
+#define SDB_DATA_WRITE          0x02
+#define SDB_DATA_EXEC           0x01
+
+#endif /* __SDB_H__ */
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 87d4bbc773fc..b98291ac7f14 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -31,6 +31,13 @@
 #include <linux/sysrq.h>
 #include <uapi/linux/serial_core.h>
 
+#ifdef CONFIG_SERIAL_CORE_CONSOLE
+#define uart_console(port) \
+        ((port)->cons && (port)->cons->index == (port)->line)
+#else
+#define uart_console(port)      (0)
+#endif
+
 struct uart_port;
 struct serial_struct;
 struct device;
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index eb763adf9815..d34049712a4d 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -5,7 +5,7 @@
 #include <linux/sh_dma.h>
 
 /*
- * Generic header for SuperH SCI(F) (used by sh/sh64/h8300 and related parts)
+ * Generic header for SuperH (H)SCI(F) (used by sh/sh64/h8300 and related parts)
  */
 
 #define SCIx_NOT_SUPPORTED      (-1)
@@ -16,6 +16,7 @@ enum {
         SCBRR_ALGO_3,           /* (((clk * 2) + 16 * bps) / (16 * bps) - 1) */
         SCBRR_ALGO_4,           /* (((clk * 2) + 16 * bps) / (32 * bps) - 1) */
         SCBRR_ALGO_5,           /* (((clk * 1000 / 32) / bps) - 1) */
+        SCBRR_ALGO_6,           /* HSCIF variable sample rate algorithm */
 };
 
 #define SCSCR_TIE       (1 << 7)
@@ -37,7 +38,7 @@ enum {
 
 #define SCI_DEFAULT_ERROR_MASK (SCI_PER | SCI_FER)
 
-/* SCxSR SCIF */
+/* SCxSR SCIF, HSCIF */
 #define SCIF_ER    0x0080
 #define SCIF_TEND  0x0040
 #define SCIF_TDFE  0x0020
@@ -55,6 +56,9 @@ enum {
 #define SCSPTR_SPB2IO   (1 << 1)
 #define SCSPTR_SPB2DT   (1 << 0)
 
+/* HSSRR HSCIF */
+#define HSCIF_SRE       0x8000
+
 /* Offsets into the sci_port->irqs array */
 enum {
         SCIx_ERI_IRQ,
@@ -90,6 +94,7 @@ enum {
         SCIx_SH4_SCIF_NO_SCSPTR_REGTYPE,
         SCIx_SH4_SCIF_FIFODATA_REGTYPE,
         SCIx_SH7705_SCIF_REGTYPE,
+        SCIx_HSCIF_REGTYPE,
 
         SCIx_NR_REGTYPES,
 };
@@ -115,6 +120,7 @@ enum {
         SCSMR, SCBRR, SCSCR, SCxSR,
         SCFCR, SCFDR, SCxTDR, SCxRDR,
         SCLSR, SCTFDR, SCRFDR, SCSPTR,
+        HSSRR,
 
         SCIx_NR_REGS,
 };
@@ -137,7 +143,7 @@ struct plat_sci_port {
         unsigned long   mapbase;                /* resource base */
         unsigned int    irqs[SCIx_NR_IRQS];     /* ERI, RXI, TXI, BRI */
         unsigned int    gpios[SCIx_NR_FNS];     /* SCK, RXD, TXD, CTS, RTS */
-        unsigned int    type;                   /* SCI / SCIF / IRDA */
+        unsigned int    type;                   /* SCI / SCIF / IRDA / HSCIF */
         upf_t           flags;                  /* UPF_* flags */
         unsigned long   capabilities;           /* Port features/capabilities */
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 2e0ced1af3b1..dec1748cd002 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -627,6 +627,7 @@ static inline struct rtable *skb_rtable(const struct sk_buff *skb)
 }
 
 extern void kfree_skb(struct sk_buff *skb);
+extern void kfree_skb_list(struct sk_buff *segs);
 extern void skb_tx_error(struct sk_buff *skb);
 extern void consume_skb(struct sk_buff *skb);
 extern void            __kfree_skb(struct sk_buff *skb);
@@ -2852,6 +2853,21 @@ static inline int skb_tnl_header_len(const struct sk_buff *inner_skb)
                 SKB_GSO_CB(inner_skb)->mac_offset;
 }
 
+static inline int gso_pskb_expand_head(struct sk_buff *skb, int extra)
+{
+        int new_headroom, headroom;
+        int ret;
+
+        headroom = skb_headroom(skb);
+        ret = pskb_expand_head(skb, extra, 0, GFP_ATOMIC);
+        if (ret)
+                return ret;
+
+        new_headroom = skb_headroom(skb);
+        SKB_GSO_CB(skb)->mac_offset += (new_headroom - headroom);
+        return 0;
+}
+
 static inline bool skb_is_gso(const struct sk_buff *skb)
 {
         return skb_shinfo(skb)->gso_size;
diff --git a/include/linux/smp.h b/include/linux/smp.h
index e6564c1dc552..c8488763277f 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -11,6 +11,7 @@
 #include <linux/list.h>
 #include <linux/cpumask.h>
 #include <linux/init.h>
+#include <linux/irqflags.h>
 
 extern void cpu_idle(void);
 
@@ -139,13 +140,17 @@ static inline int up_smp_call_function(smp_call_func_t func, void *info)
 }
 #define smp_call_function(func, info, wait) \
                         (up_smp_call_function(func, info))
-#define on_each_cpu(func,info,wait)             \
-        ({                                      \
-                local_irq_disable();            \
-                func(info);                     \
-                local_irq_enable();             \
-                0;                              \
-        })
+
+static inline int on_each_cpu(smp_call_func_t func, void *info, int wait)
+{
+        unsigned long flags;
+
+        local_irq_save(flags);
+        func(info);
+        local_irq_restore(flags);
+        return 0;
+}
+
 /*
  * Note we still need to test the mask even for UP
  * because we actually can get an empty mask from
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 33bf2dfab19d..b10ce4b341ea 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -320,6 +320,9 @@ extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
 struct timespec;
 
+/* The __sys_...msg variants allow MSG_CMSG_COMPAT */
+extern long __sys_recvmsg(int fd, struct msghdr __user *msg, unsigned flags);
+extern long __sys_sendmsg(int fd, struct msghdr __user *msg, unsigned flags);
 extern int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
                           unsigned int flags, struct timespec *timeout);
 extern int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg,
diff --git a/include/linux/spinlock_up.h b/include/linux/spinlock_up.h
index e2369c167dbd..8b3ac0d718eb 100644
--- a/include/linux/spinlock_up.h
+++ b/include/linux/spinlock_up.h
@@ -67,7 +67,7 @@ static inline void arch_spin_unlock(arch_spinlock_t *lock)
 
 #else /* DEBUG_SPINLOCK */
 #define arch_spin_is_locked(lock)       ((void)(lock), 0)
-/* for sched.c and kernel_lock.c: */
+/* for sched/core.c and kernel_lock.c: */
 # define arch_spin_lock(lock)           do { barrier(); (void)(lock); } while (0)
 # define arch_spin_lock_flags(lock, flags)      do { barrier(); (void)(lock); } while (0)
 # define arch_spin_unlock(lock) do { barrier(); (void)(lock); } while (0)
diff --git a/include/linux/splice.h b/include/linux/splice.h
index 09a545a7dfa3..74575cbf2d6f 100644
--- a/include/linux/splice.h
+++ b/include/linux/splice.h
@@ -35,6 +35,7 @@ struct splice_desc {
                 void *data;             /* cookie */
         } u;
         loff_t pos;                     /* file position */
+        loff_t *opos;                   /* sendfile: output position */
         size_t num_spliced;             /* number of bytes already spliced */
         bool need_wakeup;               /* need to wake up writer */
 };
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 04f4121a23ae..c114614ed172 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -237,47 +237,4 @@ static inline void srcu_read_unlock(struct srcu_struct *sp, int idx)
         __srcu_read_unlock(sp, idx);
 }
 
-/**
- * srcu_read_lock_raw - register a new reader for an SRCU-protected structure.
- * @sp: srcu_struct in which to register the new reader.
- *
- * Enter an SRCU read-side critical section.  Similar to srcu_read_lock(),
- * but avoids the RCU-lockdep checking.  This means that it is legal to
- * use srcu_read_lock_raw() in one context, for example, in an exception
- * handler, and then have the matching srcu_read_unlock_raw() in another
- * context, for example in the task that took the exception.
- *
- * However, the entire SRCU read-side critical section must reside within a
- * single task.  For example, beware of using srcu_read_lock_raw() in
- * a device interrupt handler and srcu_read_unlock() in the interrupted
- * task:  This will not work if interrupts are threaded.
- */
-static inline int srcu_read_lock_raw(struct srcu_struct *sp)
-{
-        unsigned long flags;
-        int ret;
-
-        local_irq_save(flags);
-        ret =  __srcu_read_lock(sp);
-        local_irq_restore(flags);
-        return ret;
-}
-
-/**
- * srcu_read_unlock_raw - unregister reader from an SRCU-protected structure.
- * @sp: srcu_struct in which to unregister the old reader.
- * @idx: return value from corresponding srcu_read_lock_raw().
- *
- * Exit an SRCU read-side critical section without lockdep-RCU checking.
- * See srcu_read_lock_raw() for more details.
- */
-static inline void srcu_read_unlock_raw(struct srcu_struct *sp, int idx)
-{
-        unsigned long flags;
-
-        local_irq_save(flags);
-        __srcu_read_unlock(sp, idx);
-        local_irq_restore(flags);
-}
-
 #endif
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 47ead515c811..c5fd30d2a415 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -137,6 +137,7 @@ static inline void make_migration_entry_read(swp_entry_t *entry)
 
 extern void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
                                         unsigned long address);
+extern void migration_entry_wait_huge(struct mm_struct *mm, pte_t *pte);
 #else
 
 #define make_migration_entry(page, write) swp_entry(0, 0)
@@ -148,6 +149,8 @@ static inline int is_migration_entry(swp_entry_t swp)
 static inline void make_migration_entry_read(swp_entry_t *entryp) { }
 static inline void migration_entry_wait(struct mm_struct *mm, pmd_t *pmd,
                                          unsigned long address) { }
+static inline void migration_entry_wait_huge(struct mm_struct *mm,
+                                        pte_t *pte) { }
 static inline int is_write_migration_entry(swp_entry_t entry)
 {
         return 0;
diff --git a/include/linux/syslog.h b/include/linux/syslog.h
index 38911391a139..98a3153c0f96 100644
--- a/include/linux/syslog.h
+++ b/include/linux/syslog.h
@@ -44,8 +44,8 @@
 /* Return size of the log buffer */
 #define SYSLOG_ACTION_SIZE_BUFFER   10
 
-#define SYSLOG_FROM_CALL 0
-#define SYSLOG_FROM_FILE 1
+#define SYSLOG_FROM_READER           0
+#define SYSLOG_FROM_PROC             1
 
 int do_syslog(int type, char __user *buf, int count, bool from_file);
 
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 2f322c38bd4d..ebeab360d851 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -145,8 +145,8 @@ static inline void tracepoint_synchronize_unregister(void)
                                 TP_PROTO(data_proto),                   \
                                 TP_ARGS(data_args),                     \
                                 TP_CONDITION(cond),                     \
-                                rcu_idle_exit(),                        \
-                                rcu_idle_enter());                      \
+                                rcu_irq_enter(),                        \
+                                rcu_irq_exit());                        \
         }
 #else
 #define __DECLARE_TRACE_RCU(name, proto, args, cond, data_proto, data_args)
@@ -378,6 +378,8 @@ static inline void tracepoint_synchronize_unregister(void)
 #define DECLARE_EVENT_CLASS(name, proto, args, tstruct, assign, print)
 #define DEFINE_EVENT(template, name, proto, args)               \
         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
+#define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)\
+        DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
         DECLARE_TRACE(name, PARAMS(proto), PARAMS(args))
 #define DEFINE_EVENT_CONDITION(template, name, proto,           \
diff --git a/include/linux/tty.h b/include/linux/tty.h
index 8780bd2a272a..01ac30efd6a6 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -272,7 +272,6 @@ struct tty_struct {
 #define N_TTY_BUF_SIZE 4096
 
         unsigned char closing:1;
-        unsigned short minimum_to_wake;
         unsigned char *write_buf;
         int write_cnt;
         /* If the tty has a pending do_SAK, queue it here - akpm */
@@ -309,8 +308,6 @@ struct tty_file_private {
 #define TTY_LDISC               9       /* Line discipline attached */
 #define TTY_LDISC_CHANGING      10      /* Line discipline changing */
 #define TTY_LDISC_OPEN          11      /* Line discipline is open */
-#define TTY_HW_COOK_OUT         14      /* Hardware can do output cooking */
-#define TTY_HW_COOK_IN          15      /* Hardware can do input cooking */
 #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() */
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 58390c73df8b..a1b048999821 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -100,6 +100,11 @@
  *      seek to perform this action quickly but should wait until
  *      any pending driver I/O is completed.
  *
+ * void (*fasync)(struct tty_struct *, int on)
+ *
+ *      Notify line discipline when signal-driven I/O is enabled or
+ *      disabled.
+ *
  * void (*dcd_change)(struct tty_struct *tty, unsigned int status)
  *
  *      Tells the discipline that the DCD pin has changed its status.
@@ -110,6 +115,52 @@
 #include <linux/wait.h>
 #include <linux/wait.h>
 
+
+/*
+ * the semaphore definition
+ */
+struct ld_semaphore {
+        long                    count;
+        raw_spinlock_t          wait_lock;
+        unsigned int            wait_readers;
+        struct list_head        read_wait;
+        struct list_head        write_wait;
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+        struct lockdep_map      dep_map;
+#endif
+};
+
+extern void __init_ldsem(struct ld_semaphore *sem, const char *name,
+                         struct lock_class_key *key);
+
+#define init_ldsem(sem)                                         \
+do {                                                            \
+        static struct lock_class_key __key;                     \
+                                                                \
+        __init_ldsem((sem), #sem, &__key);                      \
+} while (0)
+
+
+extern int ldsem_down_read(struct ld_semaphore *sem, long timeout);
+extern int ldsem_down_read_trylock(struct ld_semaphore *sem);
+extern int ldsem_down_write(struct ld_semaphore *sem, long timeout);
+extern int ldsem_down_write_trylock(struct ld_semaphore *sem);
+extern void ldsem_up_read(struct ld_semaphore *sem);
+extern void ldsem_up_write(struct ld_semaphore *sem);
+
+#ifdef CONFIG_DEBUG_LOCK_ALLOC
+extern int ldsem_down_read_nested(struct ld_semaphore *sem, int subclass,
+                                  long timeout);
+extern int ldsem_down_write_nested(struct ld_semaphore *sem, int subclass,
+                                   long timeout);
+#else
+# define ldsem_down_read_nested(sem, subclass, timeout)         \
+                ldsem_down_read(sem, timeout)
+# define ldsem_down_write_nested(sem, subclass, timeout)        \
+                ldsem_down_write(sem, timeout)
+#endif
+
+
 struct tty_ldisc_ops {
         int     magic;
         char    *name;
@@ -143,6 +194,7 @@ struct tty_ldisc_ops {
                                char *fp, int count);
         void    (*write_wakeup)(struct tty_struct *);
         void    (*dcd_change)(struct tty_struct *, unsigned int);
+        void    (*fasync)(struct tty_struct *tty, int on);
 
         struct  module *owner;
 
diff --git a/include/linux/usb.h b/include/linux/usb.h
index a0bee5a28d1a..a232b7ece1f6 100644
--- a/include/linux/usb.h
+++ b/include/linux/usb.h
@@ -394,6 +394,22 @@ enum usb_port_connect_type {
 };
 
 /*
+ * USB 2.0 Link Power Management (LPM) parameters.
+ */
+struct usb2_lpm_parameters {
+        /* Best effort service latency indicate how long the host will drive
+         * resume on an exit from L1.
+         */
+        unsigned int besl;
+
+        /* Timeout value in microseconds for the L1 inactivity (LPM) timer.
+         * When the timer counts to zero, the parent hub will initiate a LPM
+         * transition to L1.
+         */
+        int timeout;
+};
+
+/*
  * USB 3.0 Link Power Management (LPM) parameters.
  *
  * PEL and SEL are USB 3.0 Link PM latencies for device-initiated LPM exit.
@@ -468,6 +484,7 @@ struct usb3_lpm_parameters {
  * @wusb: device is Wireless USB
  * @lpm_capable: device supports LPM
  * @usb2_hw_lpm_capable: device can perform USB2 hardware LPM
+ * @usb2_hw_lpm_besl_capable: device can perform USB2 hardware BESL LPM
  * @usb2_hw_lpm_enabled: USB2 hardware LPM enabled
  * @usb3_lpm_enabled: USB3 hardware LPM enabled
  * @string_langid: language ID for strings
@@ -487,6 +504,7 @@ struct usb3_lpm_parameters {
  *      specific data for the device.
  * @slot_id: Slot ID assigned by xHCI
  * @removable: Device can be physically removed from this port
+ * @l1_params: best effor service latency for USB2 L1 LPM state, and L1 timeout.
  * @u1_params: exit latencies for USB3 U1 LPM state, and hub-initiated timeout.
  * @u2_params: exit latencies for USB3 U2 LPM state, and hub-initiated timeout.
  * @lpm_disable_count: Ref count used by usb_disable_lpm() and usb_enable_lpm()
@@ -538,6 +556,7 @@ struct usb_device {
         unsigned wusb:1;
         unsigned lpm_capable:1;
         unsigned usb2_hw_lpm_capable:1;
+        unsigned usb2_hw_lpm_besl_capable:1;
         unsigned usb2_hw_lpm_enabled:1;
         unsigned usb3_lpm_enabled:1;
         int string_langid;
@@ -566,6 +585,7 @@ struct usb_device {
         struct wusb_dev *wusb_dev;
         int slot_id;
         enum usb_device_removable removable;
+        struct usb2_lpm_parameters l1_params;
         struct usb3_lpm_parameters u1_params;
         struct usb3_lpm_parameters u2_params;
         unsigned lpm_disable_count;
@@ -717,6 +737,7 @@ const struct usb_device_id *usb_match_id(struct usb_interface *interface,
 extern int usb_match_one_id(struct usb_interface *interface,
                             const struct usb_device_id *id);
 
+extern int usb_for_each_dev(void *data, int (*fn)(struct usb_device *, void *));
 extern struct usb_interface *usb_find_interface(struct usb_driver *drv,
                 int minor);
 extern struct usb_interface *usb_ifnum_to_if(const struct usb_device *dev,
diff --git a/include/linux/usb/chipidea.h b/include/linux/usb/chipidea.h
index 544825dde823..25629948c842 100644
--- a/include/linux/usb/chipidea.h
+++ b/include/linux/usb/chipidea.h
@@ -7,32 +7,33 @@
 
 #include <linux/usb/otg.h>
 
-struct ci13xxx;
-struct ci13xxx_platform_data {
+struct ci_hdrc;
+struct ci_hdrc_platform_data {
         const char      *name;
         /* offset of the capability registers */
         uintptr_t        capoffset;
         unsigned         power_budget;
         struct usb_phy  *phy;
+        enum usb_phy_interface phy_mode;
         unsigned long    flags;
-#define CI13XXX_REGS_SHARED             BIT(0)
-#define CI13XXX_REQUIRE_TRANSCEIVER     BIT(1)
-#define CI13XXX_PULLUP_ON_VBUS          BIT(2)
-#define CI13XXX_DISABLE_STREAMING       BIT(3)
-
-#define CI13XXX_CONTROLLER_RESET_EVENT          0
-#define CI13XXX_CONTROLLER_STOPPED_EVENT        1
-        void    (*notify_event) (struct ci13xxx *ci, unsigned event);
+#define CI_HDRC_REGS_SHARED             BIT(0)
+#define CI_HDRC_REQUIRE_TRANSCEIVER     BIT(1)
+#define CI_HDRC_PULLUP_ON_VBUS          BIT(2)
+#define CI_HDRC_DISABLE_STREAMING       BIT(3)
+        enum usb_dr_mode        dr_mode;
+#define CI_HDRC_CONTROLLER_RESET_EVENT          0
+#define CI_HDRC_CONTROLLER_STOPPED_EVENT        1
+        void    (*notify_event) (struct ci_hdrc *ci, unsigned event);
 };
 
 /* Default offset of capability registers */
 #define DEF_CAPOFFSET           0x100
 
-/* Add ci13xxx device */
-struct platform_device *ci13xxx_add_device(struct device *dev,
+/* Add ci hdrc device */
+struct platform_device *ci_hdrc_add_device(struct device *dev,
                         struct resource *res, int nres,
-                        struct ci13xxx_platform_data *platdata);
-/* Remove ci13xxx device */
-void ci13xxx_remove_device(struct platform_device *pdev);
+                        struct ci_hdrc_platform_data *platdata);
+/* Remove ci hdrc device */
+void ci_hdrc_remove_device(struct platform_device *pdev);
 
 #endif
diff --git a/include/linux/usb/ehci_pdriver.h b/include/linux/usb/ehci_pdriver.h
index 99238b096f7e..7eb4dcd0d386 100644
--- a/include/linux/usb/ehci_pdriver.h
+++ b/include/linux/usb/ehci_pdriver.h
@@ -19,6 +19,9 @@
 #ifndef __USB_CORE_EHCI_PDRIVER_H
 #define __USB_CORE_EHCI_PDRIVER_H
 
+struct platform_device;
+struct usb_hcd;
+
 /**
  * struct usb_ehci_pdata - platform_data for generic ehci driver
  *
@@ -50,6 +53,7 @@ struct usb_ehci_pdata {
         /* Turn on only VBUS suspend power and hotplug detection,
          * turn off everything else */
         void (*power_suspend)(struct platform_device *pdev);
+        int (*pre_setup)(struct usb_hcd *hcd);
 };
 
 #endif /* __USB_CORE_EHCI_PDRIVER_H */
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index f5f5c7dfda90..1e88377e22f4 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -218,6 +218,7 @@ struct hc_driver {
 #define HCD_SHARED      0x0004          /* Two (or more) usb_hcds share HW */
 #define HCD_USB11       0x0010          /* USB 1.1 */
 #define HCD_USB2        0x0020          /* USB 2.0 */
+#define HCD_USB25       0x0030          /* Wireless USB 1.0 (USB 2.5)*/
 #define HCD_USB3        0x0040          /* USB 3.0 */
 #define HCD_MASK        0x0070
 
diff --git a/include/linux/usb/of.h b/include/linux/usb/of.h
new file mode 100644
index 000000000000..a0ef405368b8
--- /dev/null
+++ b/include/linux/usb/of.h
@@ -0,0 +1,32 @@
+/*
+ * OF helpers for usb devices.
+ *
+ * This file is released under the GPLv2
+ */
+
+#ifndef __LINUX_USB_OF_H
+#define __LINUX_USB_OF_H
+
+#include <linux/usb/otg.h>
+#include <linux/usb/phy.h>
+
+#if IS_ENABLED(CONFIG_OF)
+enum usb_dr_mode of_usb_get_dr_mode(struct device_node *np);
+#else
+static inline enum usb_dr_mode of_usb_get_dr_mode(struct device_node *np)
+{
+        return USB_DR_MODE_UNKNOWN;
+}
+#endif
+
+#if IS_ENABLED(CONFIG_OF) && IS_ENABLED(CONFIG_USB_PHY)
+enum usb_phy_interface of_usb_get_phy_mode(struct device_node *np);
+#else
+static inline enum usb_phy_interface of_usb_get_phy_mode(struct device_node *np)
+{
+        return USBPHY_INTERFACE_MODE_UNKNOWN;
+}
+
+#endif
+
+#endif /* __LINUX_USB_OF_H */
diff --git a/include/linux/usb/otg.h b/include/linux/usb/otg.h
index 291e01ba32e5..154332b7c8c0 100644
--- a/include/linux/usb/otg.h
+++ b/include/linux/usb/otg.h
@@ -92,4 +92,11 @@ otg_start_srp(struct usb_otg *otg)
 /* for OTG controller drivers (and maybe other stuff) */
 extern int usb_bus_start_enum(struct usb_bus *bus, unsigned port_num);
 
+enum usb_dr_mode {
+        USB_DR_MODE_UNKNOWN,
+        USB_DR_MODE_HOST,
+        USB_DR_MODE_PERIPHERAL,
+        USB_DR_MODE_OTG,
+};
+
 #endif /* __LINUX_USB_OTG_H */
diff --git a/include/linux/usb/phy.h b/include/linux/usb/phy.h
index 6b5978f57633..44036808bf0f 100644
--- a/include/linux/usb/phy.h
+++ b/include/linux/usb/phy.h
@@ -12,6 +12,15 @@
 #include <linux/notifier.h>
 #include <linux/usb.h>
 
+enum usb_phy_interface {
+        USBPHY_INTERFACE_MODE_UNKNOWN,
+        USBPHY_INTERFACE_MODE_UTMI,
+        USBPHY_INTERFACE_MODE_UTMIW,
+        USBPHY_INTERFACE_MODE_ULPI,
+        USBPHY_INTERFACE_MODE_SERIAL,
+        USBPHY_INTERFACE_MODE_HSIC,
+};
+
 enum usb_phy_events {
         USB_EVENT_NONE,         /* no events or cable disconnected */
         USB_EVENT_VBUS,         /* vbus valid event */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 302ddf55d2da..d528b8045150 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -19,10 +19,6 @@
 #include <linux/sysrq.h>
 #include <linux/kfifo.h>
 
-#define SERIAL_TTY_MAJOR        188     /* Nice legal number now */
-#define SERIAL_TTY_MINORS       254     /* loads of devices :) */
-#define SERIAL_TTY_NO_MINOR     255     /* No minor was assigned */
-
 /* The maximum number of ports one device can grab at once */
 #define MAX_NUM_PORTS           8
 
@@ -37,7 +33,8 @@
  * @serial: pointer back to the struct usb_serial owner of this port.
  * @port: pointer to the corresponding tty_port for this port.
  * @lock: spinlock to grab when updating portions of this structure.
- * @number: the number of the port (the minor number).
+ * @minor: the minor number of the port
+ * @port_number: the struct usb_serial port number of this port (starts at 0)
  * @interrupt_in_buffer: pointer to the interrupt in buffer for this port.
  * @interrupt_in_urb: pointer to the interrupt in struct urb for this port.
  * @interrupt_in_endpointAddress: endpoint address for the interrupt in pipe
@@ -80,7 +77,8 @@ struct usb_serial_port {
         struct usb_serial       *serial;
         struct tty_port         port;
         spinlock_t              lock;
-        unsigned char           number;
+        u32                     minor;
+        u8                      port_number;
 
         unsigned char           *interrupt_in_buffer;
         struct urb              *interrupt_in_urb;
@@ -140,7 +138,6 @@ static inline void usb_set_serial_port_data(struct usb_serial_port *port,
  * @dev: pointer to the struct usb_device for this device
  * @type: pointer to the struct usb_serial_driver for this device
  * @interface: pointer to the struct usb_interface for this device
- * @minor: the starting minor number for this device
  * @num_ports: the number of ports this device has
  * @num_interrupt_in: number of interrupt in endpoints we have
  * @num_interrupt_out: number of interrupt out endpoints we have
@@ -159,7 +156,7 @@ struct usb_serial {
         unsigned char                   disconnected:1;
         unsigned char                   suspending:1;
         unsigned char                   attached:1;
-        unsigned char                   minor;
+        unsigned char                   minors_reserved:1;
         unsigned char                   num_ports;
         unsigned char                   num_port_pointers;
         char                            num_interrupt_in;
@@ -319,7 +316,7 @@ static inline void usb_serial_console_disconnect(struct usb_serial *serial) {}
 #endif
 
 /* Functions needed by other parts of the usbserial core */
-extern struct usb_serial *usb_serial_get_by_index(unsigned int minor);
+extern struct usb_serial_port *usb_serial_port_get_by_minor(unsigned int minor);
 extern void usb_serial_put(struct usb_serial *serial);
 extern int usb_serial_generic_open(struct tty_struct *tty,
         struct usb_serial_port *port);
diff --git a/include/linux/usb/tegra_usb_phy.h b/include/linux/usb/tegra_usb_phy.h
index 1b7519a8c0bf..d2ca919a5b73 100644
--- a/include/linux/usb/tegra_usb_phy.h
+++ b/include/linux/usb/tegra_usb_phy.h
@@ -42,6 +42,7 @@ enum tegra_usb_phy_port_speed {
 enum tegra_usb_phy_mode {
         TEGRA_USB_PHY_MODE_DEVICE,
         TEGRA_USB_PHY_MODE_HOST,
+        TEGRA_USB_PHY_MODE_OTG,
 };
 
 struct tegra_xtal_freq;
@@ -61,14 +62,10 @@ struct tegra_usb_phy {
         struct device *dev;
         bool is_legacy_phy;
         bool is_ulpi_phy;
-        void (*set_pts)(struct usb_phy *x, u8 pts_val);
-        void (*set_phcd)(struct usb_phy *x, bool enable);
+        int reset_gpio;
 };
 
-struct tegra_usb_phy *tegra_usb_phy_open(struct device *dev, int instance,
-        void __iomem *regs, void *config, enum tegra_usb_phy_mode phy_mode,
-        void (*set_pts)(struct usb_phy *x, u8 pts_val),
-        void (*set_phcd)(struct usb_phy *x, bool enable));
+struct usb_phy *tegra_usb_get_phy(struct device_node *dn);
 
 void tegra_usb_phy_preresume(struct usb_phy *phy);
 
diff --git a/include/linux/usb/wusb-wa.h b/include/linux/usb/wusb-wa.h
index f9dec37f617b..6be985b2a434 100644
--- a/include/linux/usb/wusb-wa.h
+++ b/include/linux/usb/wusb-wa.h
@@ -92,11 +92,20 @@ struct usb_rpipe_descriptor {
         __le16  wRPipeIndex;
         __le16  wRequests;
         __le16  wBlocks;                /* rw if 0 */
-        __le16  wMaxPacketSize;         /* rw? */
-        u8      bHSHubAddress;          /* reserved: 0 */
-        u8      bHSHubPort;             /* ??? FIXME ??? */
+        __le16  wMaxPacketSize;         /* rw */
+        union {
+                u8      dwa_bHSHubAddress;              /* rw: DWA. */
+                u8      hwa_bMaxBurst;                  /* rw: HWA. */
+        };
+        union {
+                u8      dwa_bHSHubPort;         /*  rw: DWA. */
+                u8      hwa_bDeviceInfoIndex;   /*  rw: HWA. */
+        };
         u8      bSpeed;                 /* rw: xfer rate 'enum uwb_phy_rate' */
-        u8      bDeviceAddress;         /* rw: Target device address */
+        union {
+                u8 dwa_bDeviceAddress;  /* rw: DWA Target device address. */
+                u8 hwa_reserved;                /* rw: HWA. */
+        };
         u8      bEndpointAddress;       /* rw: Target EP address */
         u8      bDataSequence;          /* ro: Current Data sequence */
         __le32  dwCurrentWindow;        /* ro */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 0d33fca48774..8d7634247fb4 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -133,8 +133,6 @@ void change_console(struct vc_data *new_vc);
 void reset_vc(struct vc_data *vc);
 extern int do_unbind_con_driver(const struct consw *csw, int first, int last,
                              int deflt);
-extern int unbind_con_driver(const struct consw *csw, int first, int last,
-                             int deflt);
 int vty_init(const struct file_operations *console_fops);
 
 static inline bool vt_force_oops_output(struct vc_data *vc)
diff --git a/include/linux/vtime.h b/include/linux/vtime.h
index 71a5782d8c59..b1dd2db80076 100644
--- a/include/linux/vtime.h
+++ b/include/linux/vtime.h
@@ -34,7 +34,7 @@ static inline void vtime_user_exit(struct task_struct *tsk)
 }
 extern void vtime_guest_enter(struct task_struct *tsk);
 extern void vtime_guest_exit(struct task_struct *tsk);
-extern void vtime_init_idle(struct task_struct *tsk);
+extern void vtime_init_idle(struct task_struct *tsk, int cpu);
 #else
 static inline void vtime_account_irq_exit(struct task_struct *tsk)
 {
@@ -45,7 +45,7 @@ static inline void vtime_user_enter(struct task_struct *tsk) { }
 static inline void vtime_user_exit(struct task_struct *tsk) { }
 static inline void vtime_guest_enter(struct task_struct *tsk) { }
 static inline void vtime_guest_exit(struct task_struct *tsk) { }
-static inline void vtime_init_idle(struct task_struct *tsk) { }
+static inline void vtime_init_idle(struct task_struct *tsk, int cpu) { }
 #endif
 
 #ifdef CONFIG_IRQ_TIME_ACCOUNTING
diff --git a/include/linux/wait.h b/include/linux/wait.h
index 1133695eb067..f487a4750b7f 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -23,6 +23,7 @@ struct __wait_queue {
 struct wait_bit_key {
         void *flags;
         int bit_nr;
+#define WAIT_ATOMIC_T_BIT_NR -1
 };
 
 struct wait_bit_queue {
@@ -60,6 +61,9 @@ struct task_struct;
 #define __WAIT_BIT_KEY_INITIALIZER(word, bit)                           \
         { .flags = word, .bit_nr = bit, }
 
+#define __WAIT_ATOMIC_T_KEY_INITIALIZER(p)                              \
+        { .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }
+
 extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
 
 #define init_waitqueue_head(q)                          \
@@ -146,8 +150,10 @@ void __wake_up_bit(wait_queue_head_t *, void *, int);
 int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
 int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
 void wake_up_bit(void *, int);
+void wake_up_atomic_t(atomic_t *);
 int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
 int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
+int out_of_line_wait_on_atomic_t(atomic_t *, int (*)(atomic_t *), unsigned);
 wait_queue_head_t *bit_waitqueue(void *, int);
 
 #define wake_up(x)                      __wake_up(x, TASK_NORMAL, 1, NULL)
@@ -902,5 +908,23 @@ static inline int wait_on_bit_lock(void *word, int bit,
                 return 0;
         return out_of_line_wait_on_bit_lock(word, bit, action, mode);
 }
+
+/**
+ * wait_on_atomic_t - Wait for an atomic_t to become 0
+ * @val: The atomic value being waited on, a kernel virtual address
+ * @action: the function used to sleep, which may take special actions
+ * @mode: the task state to sleep in
+ *
+ * Wait for an atomic_t to become 0.  We abuse the bit-wait waitqueue table for
+ * the purpose of getting a waitqueue, but we set the key to a bit number
+ * outside of the target 'word'.
+ */
+static inline
+int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
+{
+        if (atomic_read(val) == 0)
+                return 0;
+        return out_of_line_wait_on_atomic_t(val, action, mode);
+}
         
 #endif
diff --git a/include/linux/workqueue.h b/include/linux/workqueue.h
index 623488fdc1f5..a9f4119c7e2e 100644
--- a/include/linux/workqueue.h
+++ b/include/linux/workqueue.h
@@ -303,6 +303,33 @@ enum {
         WQ_CPU_INTENSIVE        = 1 << 5, /* cpu instensive workqueue */
         WQ_SYSFS                = 1 << 6, /* visible in sysfs, see wq_sysfs_register() */
 
+        /*
+         * Per-cpu workqueues are generally preferred because they tend to
+         * show better performance thanks to cache locality.  Per-cpu
+         * workqueues exclude the scheduler from choosing the CPU to
+         * execute the worker threads, which has an unfortunate side effect
+         * of increasing power consumption.
+         *
+         * The scheduler considers a CPU idle if it doesn't have any task
+         * to execute and tries to keep idle cores idle to conserve power;
+         * however, for example, a per-cpu work item scheduled from an
+         * interrupt handler on an idle CPU will force the scheduler to
+         * excute the work item on that CPU breaking the idleness, which in
+         * turn may lead to more scheduling choices which are sub-optimal
+         * in terms of power consumption.
+         *
+         * Workqueues marked with WQ_POWER_EFFICIENT are per-cpu by default
+         * but become unbound if workqueue.power_efficient kernel param is
+         * specified.  Per-cpu workqueues which are identified to
+         * contribute significantly to power-consumption are identified and
+         * marked with this flag and enabling the power_efficient mode
+         * leads to noticeable power saving at the cost of small
+         * performance disadvantage.
+         *
+         * http://thread.gmane.org/gmane.linux.kernel/1480396
+         */
+        WQ_POWER_EFFICIENT      = 1 << 7,
+
         __WQ_DRAINING           = 1 << 16, /* internal: workqueue is draining */
         __WQ_ORDERED            = 1 << 17, /* internal: workqueue is ordered */
 
@@ -333,11 +360,19 @@ enum {
  *
  * system_freezable_wq is equivalent to system_wq except that it's
  * freezable.
+ *
+ * *_power_efficient_wq are inclined towards saving power and converted
+ * into WQ_UNBOUND variants if 'wq_power_efficient' is enabled; otherwise,
+ * they are same as their non-power-efficient counterparts - e.g.
+ * system_power_efficient_wq is identical to system_wq if
+ * 'wq_power_efficient' is disabled.  See WQ_POWER_EFFICIENT for more info.
  */
 extern struct workqueue_struct *system_wq;
 extern struct workqueue_struct *system_long_wq;
 extern struct workqueue_struct *system_unbound_wq;
 extern struct workqueue_struct *system_freezable_wq;
+extern struct workqueue_struct *system_power_efficient_wq;
+extern struct workqueue_struct *system_freezable_power_efficient_wq;
 
 static inline struct workqueue_struct * __deprecated __system_nrt_wq(void)
 {
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index 579a5007c696..abfe11787af3 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -78,6 +78,7 @@ struct writeback_control {
         unsigned tagged_writepages:1;   /* tag-and-write to avoid livelock */
         unsigned for_reclaim:1;         /* Invoked from the page allocator */
         unsigned range_cyclic:1;        /* range_start is cyclic */
+        unsigned for_sync:1;            /* sync(2) WB_SYNC_ALL writeback */
 };
 
 /*
diff --git a/include/media/v4l2-mem2mem.h b/include/media/v4l2-mem2mem.h
index d3eef01da648..0f4555b2a31b 100644
--- a/include/media/v4l2-mem2mem.h
+++ b/include/media/v4l2-mem2mem.h
@@ -110,6 +110,8 @@ int v4l2_m2m_qbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                   struct v4l2_buffer *buf);
 int v4l2_m2m_dqbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                    struct v4l2_buffer *buf);
+int v4l2_m2m_create_bufs(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
+                         struct v4l2_create_buffers *create);
 
 int v4l2_m2m_expbuf(struct file *file, struct v4l2_m2m_ctx *m2m_ctx,
                    struct v4l2_exportbuffer *eb);
diff --git a/include/net/addrconf.h b/include/net/addrconf.h
index 84a6440f1f19..21f702704f24 100644
--- a/include/net/addrconf.h
+++ b/include/net/addrconf.h
@@ -65,7 +65,7 @@ extern int			addrconf_set_dstaddr(struct net *net,
 
 extern int                      ipv6_chk_addr(struct net *net,
                                               const struct in6_addr *addr,
-                                              struct net_device *dev,
+                                              const struct net_device *dev,
                                               int strict);
 
 #if defined(CONFIG_IPV6_MIP6) || defined(CONFIG_IPV6_MIP6_MODULE)
diff --git a/include/net/bluetooth/hci_core.h b/include/net/bluetooth/hci_core.h
index 35a57cd1704c..7cb6d360d147 100644
--- a/include/net/bluetooth/hci_core.h
+++ b/include/net/bluetooth/hci_core.h
@@ -1117,6 +1117,7 @@ void hci_sock_dev_event(struct hci_dev *hdev, int event);
 int mgmt_control(struct sock *sk, struct msghdr *msg, size_t len);
 int mgmt_index_added(struct hci_dev *hdev);
 int mgmt_index_removed(struct hci_dev *hdev);
+int mgmt_set_powered_failed(struct hci_dev *hdev, int err);
 int mgmt_powered(struct hci_dev *hdev, u8 powered);
 int mgmt_discoverable(struct hci_dev *hdev, u8 discoverable);
 int mgmt_connectable(struct hci_dev *hdev, u8 connectable);
diff --git a/include/net/bluetooth/mgmt.h b/include/net/bluetooth/mgmt.h
index 22980a7c3873..9944c3e68c5d 100644
--- a/include/net/bluetooth/mgmt.h
+++ b/include/net/bluetooth/mgmt.h
@@ -42,6 +42,7 @@
 #define MGMT_STATUS_NOT_POWERED         0x0f
 #define MGMT_STATUS_CANCELLED           0x10
 #define MGMT_STATUS_INVALID_INDEX       0x11
+#define MGMT_STATUS_RFKILLED            0x12
 
 struct mgmt_hdr {
         __le16  opcode;
diff --git a/include/net/ip_tunnels.h b/include/net/ip_tunnels.h
index 4b6f0b28f41f..09b1360e10bf 100644
--- a/include/net/ip_tunnels.h
+++ b/include/net/ip_tunnels.h
@@ -95,10 +95,10 @@ struct ip_tunnel_net {
 int ip_tunnel_init(struct net_device *dev);
 void ip_tunnel_uninit(struct net_device *dev);
 void  ip_tunnel_dellink(struct net_device *dev, struct list_head *head);
-int __net_init ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
-                                  struct rtnl_link_ops *ops, char *devname);
+int ip_tunnel_init_net(struct net *net, int ip_tnl_net_id,
+                       struct rtnl_link_ops *ops, char *devname);
 
-void __net_exit ip_tunnel_delete_net(struct ip_tunnel_net *itn);
+void ip_tunnel_delete_net(struct ip_tunnel_net *itn);
 
 void ip_tunnel_xmit(struct sk_buff *skb, struct net_device *dev,
                     const struct iphdr *tnl_params);
diff --git a/include/net/sch_generic.h b/include/net/sch_generic.h
index f10818fc8804..e7f4e21cc3e1 100644
--- a/include/net/sch_generic.h
+++ b/include/net/sch_generic.h
@@ -679,22 +679,26 @@ static inline struct sk_buff *skb_act_clone(struct sk_buff *skb, gfp_t gfp_mask,
 #endif
 
 struct psched_ratecfg {
-        u64 rate_bps;
-        u32 mult;
-        u32 shift;
+        u64     rate_bps;
+        u32     mult;
+        u16     overhead;
+        u8      shift;
 };
 
 static inline u64 psched_l2t_ns(const struct psched_ratecfg *r,
                                 unsigned int len)
 {
-        return ((u64)len * r->mult) >> r->shift;
+        return ((u64)(len + r->overhead) * r->mult) >> r->shift;
 }
 
-extern void psched_ratecfg_precompute(struct psched_ratecfg *r, u32 rate);
+extern void psched_ratecfg_precompute(struct psched_ratecfg *r, const struct tc_ratespec *conf);
 
-static inline u32 psched_ratecfg_getrate(const struct psched_ratecfg *r)
+static inline void psched_ratecfg_getrate(struct tc_ratespec *res,
+                                          const struct psched_ratecfg *r)
 {
-        return r->rate_bps >> 3;
+        memset(res, 0, sizeof(*res));
+        res->rate = r->rate_bps >> 3;
+        res->overhead = r->overhead;
 }
 
 #endif
diff --git a/include/net/xfrm.h b/include/net/xfrm.h
index ae16531d0d35..94ce082b29dc 100644
--- a/include/net/xfrm.h
+++ b/include/net/xfrm.h
@@ -1160,6 +1160,8 @@ static inline void xfrm_sk_free_policy(struct sock *sk)
         }
 }
 
+extern void xfrm_garbage_collect(struct net *net);
+
 #else
 
 static inline void xfrm_sk_free_policy(struct sock *sk) {}
@@ -1194,6 +1196,9 @@ static inline int xfrm6_policy_check_reverse(struct sock *sk, int dir,
 {
         return 1;
 }
+static inline void xfrm_garbage_collect(struct net *net)
+{
+}
 #endif
 
 static __inline__
diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
index d4609029f014..385c6329a967 100644
--- a/include/sound/soc-dapm.h
+++ b/include/sound/soc-dapm.h
@@ -450,7 +450,8 @@ enum snd_soc_dapm_type {
         snd_soc_dapm_aif_in,            /* audio interface input */
         snd_soc_dapm_aif_out,           /* audio interface output */
         snd_soc_dapm_siggen,            /* signal generator */
-        snd_soc_dapm_dai,               /* link to DAI structure */
+        snd_soc_dapm_dai_in,            /* link to DAI structure */
+        snd_soc_dapm_dai_out,
         snd_soc_dapm_dai_link,          /* link between two DAI structures */
 };
 
diff --git a/include/trace/define_trace.h b/include/trace/define_trace.h
index 1905ca8dd399..02e1003568a4 100644
--- a/include/trace/define_trace.h
+++ b/include/trace/define_trace.h
@@ -44,6 +44,10 @@
 #define DEFINE_EVENT(template, name, proto, args) \
         DEFINE_TRACE(name)
 
+#undef DEFINE_EVENT_FN
+#define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg) \
+        DEFINE_TRACE_FN(name, reg, unreg)
+
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
         DEFINE_TRACE(name)
@@ -91,6 +95,7 @@
 #undef TRACE_EVENT_CONDITION
 #undef DECLARE_EVENT_CLASS
 #undef DEFINE_EVENT
+#undef DEFINE_EVENT_FN
 #undef DEFINE_EVENT_PRINT
 #undef DEFINE_EVENT_CONDITION
 #undef TRACE_HEADER_MULTI_READ
diff --git a/include/trace/events/ext3.h b/include/trace/events/ext3.h
index 15d11a39be47..6797b9de90ed 100644
--- a/include/trace/events/ext3.h
+++ b/include/trace/events/ext3.h
@@ -290,13 +290,14 @@ DEFINE_EVENT(ext3__page_op, ext3_releasepage,
 );
 
 TRACE_EVENT(ext3_invalidatepage,
-        TP_PROTO(struct page *page, unsigned long offset),
+        TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 
-        TP_ARGS(page, offset),
+        TP_ARGS(page, offset, length),
 
         TP_STRUCT__entry(
                 __field(        pgoff_t, index                  )
-                __field(        unsigned long, offset           )
+                __field(        unsigned int, offset            )
+                __field(        unsigned int, length            )
                 __field(        ino_t,  ino                     )
                 __field(        dev_t,  dev                     )
 
@@ -305,14 +306,15 @@ TRACE_EVENT(ext3_invalidatepage,
         TP_fast_assign(
                 __entry->index  = page->index;
                 __entry->offset = offset;
+                __entry->length = length;
                 __entry->ino    = page->mapping->host->i_ino;
                 __entry->dev    = page->mapping->host->i_sb->s_dev;
         ),
 
-        TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
+        TP_printk("dev %d,%d ino %lu page_index %lu offset %u length %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->index, __entry->offset)
+                  __entry->index, __entry->offset, __entry->length)
 );
 
 TRACE_EVENT(ext3_discard_blocks,
diff --git a/include/trace/events/ext4.h b/include/trace/events/ext4.h
index 8ee15b97cd38..2068db241f22 100644
--- a/include/trace/events/ext4.h
+++ b/include/trace/events/ext4.h
@@ -19,6 +19,57 @@ struct extent_status;
 
 #define EXT4_I(inode) (container_of(inode, struct ext4_inode_info, vfs_inode))
 
+#define show_mballoc_flags(flags) __print_flags(flags, "|",     \
+        { EXT4_MB_HINT_MERGE,           "HINT_MERGE" },         \
+        { EXT4_MB_HINT_RESERVED,        "HINT_RESV" },          \
+        { EXT4_MB_HINT_METADATA,        "HINT_MDATA" },         \
+        { EXT4_MB_HINT_FIRST,           "HINT_FIRST" },         \
+        { EXT4_MB_HINT_BEST,            "HINT_BEST" },          \
+        { EXT4_MB_HINT_DATA,            "HINT_DATA" },          \
+        { EXT4_MB_HINT_NOPREALLOC,      "HINT_NOPREALLOC" },    \
+        { EXT4_MB_HINT_GROUP_ALLOC,     "HINT_GRP_ALLOC" },     \
+        { EXT4_MB_HINT_GOAL_ONLY,       "HINT_GOAL_ONLY" },     \
+        { EXT4_MB_HINT_TRY_GOAL,        "HINT_TRY_GOAL" },      \
+        { EXT4_MB_DELALLOC_RESERVED,    "DELALLOC_RESV" },      \
+        { EXT4_MB_STREAM_ALLOC,         "STREAM_ALLOC" },       \
+        { EXT4_MB_USE_ROOT_BLOCKS,      "USE_ROOT_BLKS" },      \
+        { EXT4_MB_USE_RESERVED,         "USE_RESV" })
+
+#define show_map_flags(flags) __print_flags(flags, "|",                 \
+        { EXT4_GET_BLOCKS_CREATE,               "CREATE" },             \
+        { EXT4_GET_BLOCKS_UNINIT_EXT,           "UNINIT" },             \
+        { EXT4_GET_BLOCKS_DELALLOC_RESERVE,     "DELALLOC" },           \
+        { EXT4_GET_BLOCKS_PRE_IO,               "PRE_IO" },             \
+        { EXT4_GET_BLOCKS_CONVERT,              "CONVERT" },            \
+        { EXT4_GET_BLOCKS_METADATA_NOFAIL,      "METADATA_NOFAIL" },    \
+        { EXT4_GET_BLOCKS_NO_NORMALIZE,         "NO_NORMALIZE" },       \
+        { EXT4_GET_BLOCKS_KEEP_SIZE,            "KEEP_SIZE" },          \
+        { EXT4_GET_BLOCKS_NO_LOCK,              "NO_LOCK" },            \
+        { EXT4_GET_BLOCKS_NO_PUT_HOLE,          "NO_PUT_HOLE" })
+
+#define show_mflags(flags) __print_flags(flags, "",     \
+        { EXT4_MAP_NEW,         "N" },                  \
+        { EXT4_MAP_MAPPED,      "M" },                  \
+        { EXT4_MAP_UNWRITTEN,   "U" },                  \
+        { EXT4_MAP_BOUNDARY,    "B" },                  \
+        { EXT4_MAP_UNINIT,      "u" },                  \
+        { EXT4_MAP_FROM_CLUSTER, "C" })
+
+#define show_free_flags(flags) __print_flags(flags, "|",        \
+        { EXT4_FREE_BLOCKS_METADATA,            "METADATA" },   \
+        { EXT4_FREE_BLOCKS_FORGET,              "FORGET" },     \
+        { EXT4_FREE_BLOCKS_VALIDATED,           "VALIDATED" },  \
+        { EXT4_FREE_BLOCKS_NO_QUOT_UPDATE,      "NO_QUOTA" },   \
+        { EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER,"1ST_CLUSTER" },\
+        { EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER, "LAST_CLUSTER" })
+
+#define show_extent_status(status) __print_flags(status, "",    \
+        { (1 << 3),     "W" },                                  \
+        { (1 << 2),     "U" },                                  \
+        { (1 << 1),     "D" },                                  \
+        { (1 << 0),     "H" })
+
+
 TRACE_EVENT(ext4_free_inode,
         TP_PROTO(struct inode *inode),
 
@@ -281,7 +332,7 @@ DEFINE_EVENT(ext4__write_end, ext4_da_write_end,
         TP_ARGS(inode, pos, len, copied)
 );
 
-TRACE_EVENT(ext4_da_writepages,
+TRACE_EVENT(ext4_writepages,
         TP_PROTO(struct inode *inode, struct writeback_control *wbc),
 
         TP_ARGS(inode, wbc),
@@ -324,46 +375,62 @@ TRACE_EVENT(ext4_da_writepages,
 );
 
 TRACE_EVENT(ext4_da_write_pages,
-        TP_PROTO(struct inode *inode, struct mpage_da_data *mpd),
+        TP_PROTO(struct inode *inode, pgoff_t first_page,
+                 struct writeback_control *wbc),
 
-        TP_ARGS(inode, mpd),
+        TP_ARGS(inode, first_page, wbc),
 
         TP_STRUCT__entry(
                 __field(        dev_t,  dev                     )
                 __field(        ino_t,  ino                     )
-                __field(        __u64,  b_blocknr               )
-                __field(        __u32,  b_size                  )
-                __field(        __u32,  b_state                 )
-                __field(        unsigned long,  first_page      )
-                __field(        int,    io_done                 )
-                __field(        int,    pages_written           )
-                __field(        int,    sync_mode               )
+                __field(      pgoff_t,  first_page              )
+                __field(         long,  nr_to_write             )
+                __field(          int,  sync_mode               )
         ),
 
         TP_fast_assign(
                 __entry->dev            = inode->i_sb->s_dev;
                 __entry->ino            = inode->i_ino;
-                __entry->b_blocknr      = mpd->b_blocknr;
-                __entry->b_size         = mpd->b_size;
-                __entry->b_state        = mpd->b_state;
-                __entry->first_page     = mpd->first_page;
-                __entry->io_done        = mpd->io_done;
-                __entry->pages_written  = mpd->pages_written;
-                __entry->sync_mode      = mpd->wbc->sync_mode;
+                __entry->first_page     = first_page;
+                __entry->nr_to_write    = wbc->nr_to_write;
+                __entry->sync_mode      = wbc->sync_mode;
         ),
 
-        TP_printk("dev %d,%d ino %lu b_blocknr %llu b_size %u b_state 0x%04x "
-                  "first_page %lu io_done %d pages_written %d sync_mode %d",
+        TP_printk("dev %d,%d ino %lu first_page %lu nr_to_write %ld "
+                  "sync_mode %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
-                  (unsigned long) __entry->ino,
-                  __entry->b_blocknr, __entry->b_size,
-                  __entry->b_state, __entry->first_page,
-                  __entry->io_done, __entry->pages_written,
-                  __entry->sync_mode
-                  )
+                  (unsigned long) __entry->ino, __entry->first_page,
+                  __entry->nr_to_write, __entry->sync_mode)
 );
 
-TRACE_EVENT(ext4_da_writepages_result,
+TRACE_EVENT(ext4_da_write_pages_extent,
+        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map),
+
+        TP_ARGS(inode, map),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(        ino_t,  ino                     )
+                __field(        __u64,  lblk                    )
+                __field(        __u32,  len                     )
+                __field(        __u32,  flags                   )
+        ),
+
+        TP_fast_assign(
+                __entry->dev            = inode->i_sb->s_dev;
+                __entry->ino            = inode->i_ino;
+                __entry->lblk           = map->m_lblk;
+                __entry->len            = map->m_len;
+                __entry->flags          = map->m_flags;
+        ),
+
+        TP_printk("dev %d,%d ino %lu lblk %llu len %u flags %s",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  (unsigned long) __entry->ino, __entry->lblk, __entry->len,
+                  show_mflags(__entry->flags))
+);
+
+TRACE_EVENT(ext4_writepages_result,
         TP_PROTO(struct inode *inode, struct writeback_control *wbc,
                         int ret, int pages_written),
 
@@ -444,16 +511,16 @@ DEFINE_EVENT(ext4__page_op, ext4_releasepage,
 );
 
 DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
-        TP_PROTO(struct page *page, unsigned long offset),
+        TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 
-        TP_ARGS(page, offset),
+        TP_ARGS(page, offset, length),
 
         TP_STRUCT__entry(
                 __field(        dev_t,  dev                     )
                 __field(        ino_t,  ino                     )
                 __field(        pgoff_t, index                  )
-                __field(        unsigned long, offset           )
-
+                __field(        unsigned int, offset            )
+                __field(        unsigned int, length            )
         ),
 
         TP_fast_assign(
@@ -461,24 +528,26 @@ DECLARE_EVENT_CLASS(ext4_invalidatepage_op,
                 __entry->ino    = page->mapping->host->i_ino;
                 __entry->index  = page->index;
                 __entry->offset = offset;
+                __entry->length = length;
         ),
 
-        TP_printk("dev %d,%d ino %lu page_index %lu offset %lu",
+        TP_printk("dev %d,%d ino %lu page_index %lu offset %u length %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  (unsigned long) __entry->index, __entry->offset)
+                  (unsigned long) __entry->index,
+                  __entry->offset, __entry->length)
 );
 
 DEFINE_EVENT(ext4_invalidatepage_op, ext4_invalidatepage,
-        TP_PROTO(struct page *page, unsigned long offset),
+        TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 
-        TP_ARGS(page, offset)
+        TP_ARGS(page, offset, length)
 );
 
 DEFINE_EVENT(ext4_invalidatepage_op, ext4_journalled_invalidatepage,
-        TP_PROTO(struct page *page, unsigned long offset),
+        TP_PROTO(struct page *page, unsigned int offset, unsigned int length),
 
-        TP_ARGS(page, offset)
+        TP_ARGS(page, offset, length)
 );
 
 TRACE_EVENT(ext4_discard_blocks,
@@ -673,10 +742,10 @@ TRACE_EVENT(ext4_request_blocks,
                 __entry->flags  = ar->flags;
         ),
 
-        TP_printk("dev %d,%d ino %lu flags %u len %u lblk %u goal %llu "
+        TP_printk("dev %d,%d ino %lu flags %s len %u lblk %u goal %llu "
                   "lleft %u lright %u pleft %llu pright %llu ",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
-                  (unsigned long) __entry->ino, __entry->flags,
+                  (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
                   __entry->len, __entry->logical, __entry->goal,
                   __entry->lleft, __entry->lright, __entry->pleft,
                   __entry->pright)
@@ -715,10 +784,10 @@ TRACE_EVENT(ext4_allocate_blocks,
                 __entry->flags  = ar->flags;
         ),
 
-        TP_printk("dev %d,%d ino %lu flags %u len %u block %llu lblk %u "
+        TP_printk("dev %d,%d ino %lu flags %s len %u block %llu lblk %u "
                   "goal %llu lleft %u lright %u pleft %llu pright %llu",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
-                  (unsigned long) __entry->ino, __entry->flags,
+                  (unsigned long) __entry->ino, show_mballoc_flags(__entry->flags),
                   __entry->len, __entry->block, __entry->logical,
                   __entry->goal,  __entry->lleft, __entry->lright,
                   __entry->pleft, __entry->pright)
@@ -748,11 +817,11 @@ TRACE_EVENT(ext4_free_blocks,
                 __entry->mode           = inode->i_mode;
         ),
 
-        TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %d",
+        TP_printk("dev %d,%d ino %lu mode 0%o block %llu count %lu flags %s",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   __entry->mode, __entry->block, __entry->count,
-                  __entry->flags)
+                  show_free_flags(__entry->flags))
 );
 
 TRACE_EVENT(ext4_sync_file_enter,
@@ -903,7 +972,7 @@ TRACE_EVENT(ext4_mballoc_alloc,
         ),
 
         TP_printk("dev %d,%d inode %lu orig %u/%d/%u@%u goal %u/%d/%u@%u "
-                  "result %u/%d/%u@%u blks %u grps %u cr %u flags 0x%04x "
+                  "result %u/%d/%u@%u blks %u grps %u cr %u flags %s "
                   "tail %u broken %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
@@ -914,7 +983,7 @@ TRACE_EVENT(ext4_mballoc_alloc,
                   __entry->result_group, __entry->result_start,
                   __entry->result_len, __entry->result_logical,
                   __entry->found, __entry->groups, __entry->cr,
-                  __entry->flags, __entry->tail,
+                  show_mballoc_flags(__entry->flags), __entry->tail,
                   __entry->buddy ? 1 << __entry->buddy : 0)
 );
 
@@ -1528,10 +1597,10 @@ DECLARE_EVENT_CLASS(ext4__map_blocks_enter,
                 __entry->flags  = flags;
         ),
 
-        TP_printk("dev %d,%d ino %lu lblk %u len %u flags %u",
+        TP_printk("dev %d,%d ino %lu lblk %u len %u flags %s",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->lblk, __entry->len, __entry->flags)
+                  __entry->lblk, __entry->len, show_map_flags(__entry->flags))
 );
 
 DEFINE_EVENT(ext4__map_blocks_enter, ext4_ext_map_blocks_enter,
@@ -1549,47 +1618,53 @@ DEFINE_EVENT(ext4__map_blocks_enter, ext4_ind_map_blocks_enter,
 );
 
 DECLARE_EVENT_CLASS(ext4__map_blocks_exit,
-        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
+        TP_PROTO(struct inode *inode, unsigned flags, struct ext4_map_blocks *map,
+                 int ret),
 
-        TP_ARGS(inode, map, ret),
+        TP_ARGS(inode, flags, map, ret),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev             )
                 __field(        ino_t,          ino             )
+                __field(        unsigned int,   flags           )
                 __field(        ext4_fsblk_t,   pblk            )
                 __field(        ext4_lblk_t,    lblk            )
                 __field(        unsigned int,   len             )
-                __field(        unsigned int,   flags           )
+                __field(        unsigned int,   mflags          )
                 __field(        int,            ret             )
         ),
 
         TP_fast_assign(
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
+                __entry->flags  = flags;
                 __entry->pblk   = map->m_pblk;
                 __entry->lblk   = map->m_lblk;
                 __entry->len    = map->m_len;
-                __entry->flags  = map->m_flags;
+                __entry->mflags = map->m_flags;
                 __entry->ret    = ret;
         ),
 
-        TP_printk("dev %d,%d ino %lu lblk %u pblk %llu len %u flags %x ret %d",
+        TP_printk("dev %d,%d ino %lu flags %s lblk %u pblk %llu len %u "
+                  "mflags %s ret %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
-                  __entry->lblk, __entry->pblk,
-                  __entry->len, __entry->flags, __entry->ret)
+                  show_map_flags(__entry->flags), __entry->lblk, __entry->pblk,
+                  __entry->len, show_mflags(__entry->mflags), __entry->ret)
 );
 
 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ext_map_blocks_exit,
-        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
+        TP_PROTO(struct inode *inode, unsigned flags,
+                 struct ext4_map_blocks *map, int ret),
 
-        TP_ARGS(inode, map, ret)
+        TP_ARGS(inode, flags, map, ret)
 );
 
 DEFINE_EVENT(ext4__map_blocks_exit, ext4_ind_map_blocks_exit,
-        TP_PROTO(struct inode *inode, struct ext4_map_blocks *map, int ret),
+        TP_PROTO(struct inode *inode, unsigned flags,
+                 struct ext4_map_blocks *map, int ret),
 
-        TP_ARGS(inode, map, ret)
+        TP_ARGS(inode, flags, map, ret)
 );
 
 TRACE_EVENT(ext4_ext_load_extent,
@@ -1638,25 +1713,50 @@ TRACE_EVENT(ext4_load_inode,
 );
 
 TRACE_EVENT(ext4_journal_start,
-        TP_PROTO(struct super_block *sb, int nblocks, unsigned long IP),
+        TP_PROTO(struct super_block *sb, int blocks, int rsv_blocks,
+                 unsigned long IP),
 
-        TP_ARGS(sb, nblocks, IP),
+        TP_ARGS(sb, blocks, rsv_blocks, IP),
 
         TP_STRUCT__entry(
                 __field(        dev_t,  dev                     )
                 __field(unsigned long,  ip                      )
-                __field(        int,    nblocks                 )
+                __field(          int,  blocks                  )
+                __field(          int,  rsv_blocks              )
         ),
 
         TP_fast_assign(
-                __entry->dev     = sb->s_dev;
-                __entry->ip      = IP;
-                __entry->nblocks = nblocks;
+                __entry->dev             = sb->s_dev;
+                __entry->ip              = IP;
+                __entry->blocks          = blocks;
+                __entry->rsv_blocks      = rsv_blocks;
         ),
 
-        TP_printk("dev %d,%d nblocks %d caller %pF",
+        TP_printk("dev %d,%d blocks, %d rsv_blocks, %d caller %pF",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
-                  __entry->nblocks, (void *)__entry->ip)
+                  __entry->blocks, __entry->rsv_blocks, (void *)__entry->ip)
+);
+
+TRACE_EVENT(ext4_journal_start_reserved,
+        TP_PROTO(struct super_block *sb, int blocks, unsigned long IP),
+
+        TP_ARGS(sb, blocks, IP),
+
+        TP_STRUCT__entry(
+                __field(        dev_t,  dev                     )
+                __field(unsigned long,  ip                      )
+                __field(          int,  blocks                  )
+        ),
+
+        TP_fast_assign(
+                __entry->dev             = sb->s_dev;
+                __entry->ip              = IP;
+                __entry->blocks          = blocks;
+        ),
+
+        TP_printk("dev %d,%d blocks, %d caller %pF",
+                  MAJOR(__entry->dev), MINOR(__entry->dev),
+                  __entry->blocks, (void *)__entry->ip)
 );
 
 DECLARE_EVENT_CLASS(ext4__trim,
@@ -1736,12 +1836,12 @@ TRACE_EVENT(ext4_ext_handle_uninitialized_extents,
                 __entry->newblk         = newblock;
         ),
 
-        TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %x "
+        TP_printk("dev %d,%d ino %lu m_lblk %u m_pblk %llu m_len %u flags %s "
                   "allocated %d newblock %llu",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   (unsigned) __entry->lblk, (unsigned long long) __entry->pblk,
-                  __entry->len, __entry->flags,
+                  __entry->len, show_map_flags(__entry->flags),
                   (unsigned int) __entry->allocated,
                   (unsigned long long) __entry->newblk)
 );
@@ -1769,10 +1869,10 @@ TRACE_EVENT(ext4_get_implied_cluster_alloc_exit,
                 __entry->ret    = ret;
         ),
 
-        TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %u ret %d",
+        TP_printk("dev %d,%d m_lblk %u m_pblk %llu m_len %u m_flags %s ret %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   __entry->lblk, (unsigned long long) __entry->pblk,
-                  __entry->len, __entry->flags, __entry->ret)
+                  __entry->len, show_mflags(__entry->flags), __entry->ret)
 );
 
 TRACE_EVENT(ext4_ext_put_in_cache,
@@ -1926,7 +2026,7 @@ TRACE_EVENT(ext4_ext_show_extent,
 TRACE_EVENT(ext4_remove_blocks,
             TP_PROTO(struct inode *inode, struct ext4_extent *ex,
                 ext4_lblk_t from, ext4_fsblk_t to,
-                ext4_fsblk_t partial_cluster),
+                long long partial_cluster),
 
         TP_ARGS(inode, ex, from, to, partial_cluster),
 
@@ -1935,7 +2035,7 @@ TRACE_EVENT(ext4_remove_blocks,
                 __field(        ino_t,          ino     )
                 __field(        ext4_lblk_t,    from    )
                 __field(        ext4_lblk_t,    to      )
-                __field(        ext4_fsblk_t,   partial )
+                __field(        long long,      partial )
                 __field(        ext4_fsblk_t,   ee_pblk )
                 __field(        ext4_lblk_t,    ee_lblk )
                 __field(        unsigned short, ee_len  )
@@ -1953,7 +2053,7 @@ TRACE_EVENT(ext4_remove_blocks,
         ),
 
         TP_printk("dev %d,%d ino %lu extent [%u(%llu), %u]"
-                  "from %u to %u partial_cluster %u",
+                  "from %u to %u partial_cluster %lld",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   (unsigned) __entry->ee_lblk,
@@ -1961,19 +2061,20 @@ TRACE_EVENT(ext4_remove_blocks,
                   (unsigned short) __entry->ee_len,
                   (unsigned) __entry->from,
                   (unsigned) __entry->to,
-                  (unsigned) __entry->partial)
+                  (long long) __entry->partial)
 );
 
 TRACE_EVENT(ext4_ext_rm_leaf,
         TP_PROTO(struct inode *inode, ext4_lblk_t start,
-                 struct ext4_extent *ex, ext4_fsblk_t partial_cluster),
+                 struct ext4_extent *ex,
+                 long long partial_cluster),
 
         TP_ARGS(inode, start, ex, partial_cluster),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev     )
                 __field(        ino_t,          ino     )
-                __field(        ext4_fsblk_t,   partial )
+                __field(        long long,      partial )
                 __field(        ext4_lblk_t,    start   )
                 __field(        ext4_lblk_t,    ee_lblk )
                 __field(        ext4_fsblk_t,   ee_pblk )
@@ -1991,14 +2092,14 @@ TRACE_EVENT(ext4_ext_rm_leaf,
         ),
 
         TP_printk("dev %d,%d ino %lu start_lblk %u last_extent [%u(%llu), %u]"
-                  "partial_cluster %u",
+                  "partial_cluster %lld",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   (unsigned) __entry->start,
                   (unsigned) __entry->ee_lblk,
                   (unsigned long long) __entry->ee_pblk,
                   (unsigned short) __entry->ee_len,
-                  (unsigned) __entry->partial)
+                  (long long) __entry->partial)
 );
 
 TRACE_EVENT(ext4_ext_rm_idx,
@@ -2025,14 +2126,16 @@ TRACE_EVENT(ext4_ext_rm_idx,
 );
 
 TRACE_EVENT(ext4_ext_remove_space,
-        TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth),
+        TP_PROTO(struct inode *inode, ext4_lblk_t start,
+                 ext4_lblk_t end, int depth),
 
-        TP_ARGS(inode, start, depth),
+        TP_ARGS(inode, start, end, depth),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev     )
                 __field(        ino_t,          ino     )
                 __field(        ext4_lblk_t,    start   )
+                __field(        ext4_lblk_t,    end     )
                 __field(        int,            depth   )
         ),
 
@@ -2040,28 +2143,31 @@ TRACE_EVENT(ext4_ext_remove_space,
                 __entry->dev    = inode->i_sb->s_dev;
                 __entry->ino    = inode->i_ino;
                 __entry->start  = start;
+                __entry->end    = end;
                 __entry->depth  = depth;
         ),
 
-        TP_printk("dev %d,%d ino %lu since %u depth %d",
+        TP_printk("dev %d,%d ino %lu since %u end %u depth %d",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   (unsigned) __entry->start,
+                  (unsigned) __entry->end,
                   __entry->depth)
 );
 
 TRACE_EVENT(ext4_ext_remove_space_done,
-        TP_PROTO(struct inode *inode, ext4_lblk_t start, int depth,
-                ext4_lblk_t partial, __le16 eh_entries),
+        TP_PROTO(struct inode *inode, ext4_lblk_t start, ext4_lblk_t end,
+                 int depth, long long partial, __le16 eh_entries),
 
-        TP_ARGS(inode, start, depth, partial, eh_entries),
+        TP_ARGS(inode, start, end, depth, partial, eh_entries),
 
         TP_STRUCT__entry(
                 __field(        dev_t,          dev             )
                 __field(        ino_t,          ino             )
                 __field(        ext4_lblk_t,    start           )
+                __field(        ext4_lblk_t,    end             )
                 __field(        int,            depth           )
-                __field(        ext4_lblk_t,    partial         )
+                __field(        long long,      partial         )
                 __field(        unsigned short, eh_entries      )
         ),
 
@@ -2069,18 +2175,20 @@ TRACE_EVENT(ext4_ext_remove_space_done,
                 __entry->dev            = inode->i_sb->s_dev;
                 __entry->ino            = inode->i_ino;
                 __entry->start          = start;
+                __entry->end            = end;
                 __entry->depth          = depth;
                 __entry->partial        = partial;
                 __entry->eh_entries     = le16_to_cpu(eh_entries);
         ),
 
-        TP_printk("dev %d,%d ino %lu since %u depth %d partial %u "
+        TP_printk("dev %d,%d ino %lu since %u end %u depth %d partial %lld "
                   "remaining_entries %u",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   (unsigned) __entry->start,
+                  (unsigned) __entry->end,
                   __entry->depth,
-                  (unsigned) __entry->partial,
+                  (long long) __entry->partial,
                   (unsigned short) __entry->eh_entries)
 );
 
@@ -2095,7 +2203,7 @@ TRACE_EVENT(ext4_es_insert_extent,
                 __field(        ext4_lblk_t,    lblk            )
                 __field(        ext4_lblk_t,    len             )
                 __field(        ext4_fsblk_t,   pblk            )
-                __field(        unsigned long long, status      )
+                __field(        char, status    )
         ),
 
         TP_fast_assign(
@@ -2104,14 +2212,14 @@ TRACE_EVENT(ext4_es_insert_extent,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es);
+                __entry->status = ext4_es_status(es) >> 60;
         ),
 
-        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %llx",
+        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   __entry->lblk, __entry->len,
-                  __entry->pblk, __entry->status)
+                  __entry->pblk, show_extent_status(__entry->status))
 );
 
 TRACE_EVENT(ext4_es_remove_extent,
@@ -2172,7 +2280,7 @@ TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
                 __field(        ext4_lblk_t,    lblk            )
                 __field(        ext4_lblk_t,    len             )
                 __field(        ext4_fsblk_t,   pblk            )
-                __field(        unsigned long long, status      )
+                __field(        char, status    )
         ),
 
         TP_fast_assign(
@@ -2181,14 +2289,14 @@ TRACE_EVENT(ext4_es_find_delayed_extent_range_exit,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es);
+                __entry->status = ext4_es_status(es) >> 60;
         ),
 
-        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %llx",
+        TP_printk("dev %d,%d ino %lu es [%u/%u) mapped %llu status %s",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino,
                   __entry->lblk, __entry->len,
-                  __entry->pblk, __entry->status)
+                  __entry->pblk, show_extent_status(__entry->status))
 );
 
 TRACE_EVENT(ext4_es_lookup_extent_enter,
@@ -2225,7 +2333,7 @@ TRACE_EVENT(ext4_es_lookup_extent_exit,
                 __field(        ext4_lblk_t,    lblk            )
                 __field(        ext4_lblk_t,    len             )
                 __field(        ext4_fsblk_t,   pblk            )
-                __field(        unsigned long long,     status  )
+                __field(        char,           status          )
                 __field(        int,            found           )
         ),
 
@@ -2235,16 +2343,16 @@ TRACE_EVENT(ext4_es_lookup_extent_exit,
                 __entry->lblk   = es->es_lblk;
                 __entry->len    = es->es_len;
                 __entry->pblk   = ext4_es_pblock(es);
-                __entry->status = ext4_es_status(es);
+                __entry->status = ext4_es_status(es) >> 60;
                 __entry->found  = found;
         ),
 
-        TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %llx",
+        TP_printk("dev %d,%d ino %lu found %d [%u/%u) %llu %s",
                   MAJOR(__entry->dev), MINOR(__entry->dev),
                   (unsigned long) __entry->ino, __entry->found,
                   __entry->lblk, __entry->len,
                   __entry->found ? __entry->pblk : 0,
-                  __entry->found ? __entry->status : 0)
+                  show_extent_status(__entry->found ? __entry->status : 0))
 );
 
 TRACE_EVENT(ext4_es_shrink_enter,
diff --git a/include/trace/events/nmi.h b/include/trace/events/nmi.h
new file mode 100644
index 000000000000..da3ee96b8d03
--- /dev/null
+++ b/include/trace/events/nmi.h
@@ -0,0 +1,37 @@
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM nmi
+
+#if !defined(_TRACE_NMI_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_NMI_H
+
+#include <linux/ktime.h>
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(nmi_handler,
+
+        TP_PROTO(void *handler, s64 delta_ns, int handled),
+
+        TP_ARGS(handler, delta_ns, handled),
+
+        TP_STRUCT__entry(
+                __field(        void *,         handler )
+                __field(        s64,            delta_ns)
+                __field(        int,            handled )
+        ),
+
+        TP_fast_assign(
+                __entry->handler = handler;
+                __entry->delta_ns = delta_ns;
+                __entry->handled = handled;
+        ),
+
+        TP_printk("%ps() delta_ns: %lld handled: %d",
+                __entry->handler,
+                __entry->delta_ns,
+                __entry->handled)
+);
+
+#endif /* _TRACE_NMI_H */
+
+/* This part ust be outside protection */
+#include <trace/define_trace.h>
diff --git a/include/trace/ftrace.h b/include/trace/ftrace.h
index 19edd7facaa1..d615f78cc6b6 100644
--- a/include/trace/ftrace.h
+++ b/include/trace/ftrace.h
@@ -71,6 +71,10 @@
         static struct ftrace_event_call __used          \
         __attribute__((__aligned__(4))) event_##name
 
+#undef DEFINE_EVENT_FN
+#define DEFINE_EVENT_FN(template, name, proto, args, reg, unreg)        \
+        DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
+
 #undef DEFINE_EVENT_PRINT
 #define DEFINE_EVENT_PRINT(template, name, proto, args, print)  \
         DEFINE_EVENT(template, name, PARAMS(proto), PARAMS(args))
diff --git a/include/uapi/asm-generic/fcntl.h b/include/uapi/asm-generic/fcntl.h
index a48937d4a5ea..06632beaa6d5 100644
--- a/include/uapi/asm-generic/fcntl.h
+++ b/include/uapi/asm-generic/fcntl.h
@@ -84,6 +84,10 @@
 #define O_PATH          010000000
 #endif
 
+#ifndef O_TMPFILE
+#define O_TMPFILE       020000000
+#endif
+
 #ifndef O_NDELAY
 #define O_NDELAY        O_NONBLOCK
 #endif
diff --git a/include/uapi/asm-generic/unistd.h b/include/uapi/asm-generic/unistd.h
index 0cc74c4403e4..a20a9b4d3871 100644
--- a/include/uapi/asm-generic/unistd.h
+++ b/include/uapi/asm-generic/unistd.h
@@ -361,7 +361,7 @@ __SYSCALL(__NR_syslog, sys_syslog)
 #define __NR_ptrace 117
 __SYSCALL(__NR_ptrace, sys_ptrace)
 
-/* kernel/sched.c */
+/* kernel/sched/core.c */
 #define __NR_sched_setparam 118
 __SYSCALL(__NR_sched_setparam, sys_sched_setparam)
 #define __NR_sched_setscheduler 119
diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild
index ab5d4992e568..bdc6e87ff3eb 100644
--- a/include/uapi/linux/Kbuild
+++ b/include/uapi/linux/Kbuild
@@ -261,6 +261,7 @@ header-y += net_dropmon.h
 header-y += net_tstamp.h
 header-y += netconf.h
 header-y += netdevice.h
+header-y += netlink_diag.h
 header-y += netfilter.h
 header-y += netfilter_arp.h
 header-y += netfilter_bridge.h
diff --git a/include/uapi/linux/const.h b/include/uapi/linux/const.h
index c22c707c455d..c872bfd25e13 100644
--- a/include/uapi/linux/const.h
+++ b/include/uapi/linux/const.h
@@ -21,4 +21,7 @@
 #define _AT(T,X)        ((T)(X))
 #endif
 
+#define _BITUL(x)       (_AC(1,UL) << (x))
+#define _BITULL(x)      (_AC(1,ULL) << (x))
+
 #endif /* !(_LINUX_CONST_H) */
diff --git a/include/uapi/linux/kvm.h b/include/uapi/linux/kvm.h
index aac27640bec2..acccd08be6c7 100644
--- a/include/uapi/linux/kvm.h
+++ b/include/uapi/linux/kvm.h
@@ -785,6 +785,7 @@ struct kvm_dirty_tlb {
 #define KVM_REG_ARM             0x4000000000000000ULL
 #define KVM_REG_S390            0x5000000000000000ULL
 #define KVM_REG_ARM64           0x6000000000000000ULL
+#define KVM_REG_MIPS            0x7000000000000000ULL
 
 #define KVM_REG_SIZE_SHIFT      52
 #define KVM_REG_SIZE_MASK       0x00f0000000000000ULL
diff --git a/include/uapi/linux/perf_event.h b/include/uapi/linux/perf_event.h
index fb104e51496e..0b1df41691e8 100644
--- a/include/uapi/linux/perf_event.h
+++ b/include/uapi/linux/perf_event.h
@@ -157,8 +157,11 @@ enum perf_branch_sample_type {
         PERF_SAMPLE_BRANCH_ANY_CALL     = 1U << 4, /* any call branch */
         PERF_SAMPLE_BRANCH_ANY_RETURN   = 1U << 5, /* any return branch */
         PERF_SAMPLE_BRANCH_IND_CALL     = 1U << 6, /* indirect calls */
+        PERF_SAMPLE_BRANCH_ABORT_TX     = 1U << 7, /* transaction aborts */
+        PERF_SAMPLE_BRANCH_IN_TX        = 1U << 8, /* in transaction */
+        PERF_SAMPLE_BRANCH_NO_TX        = 1U << 9, /* not in transaction */
 
-        PERF_SAMPLE_BRANCH_MAX          = 1U << 7, /* non-ABI */
+        PERF_SAMPLE_BRANCH_MAX          = 1U << 10, /* non-ABI */
 };
 
 #define PERF_SAMPLE_BRANCH_PLM_ALL \
diff --git a/include/uapi/linux/serial_core.h b/include/uapi/linux/serial_core.h
index 74c2bf7211f8..9119cc0977bf 100644
--- a/include/uapi/linux/serial_core.h
+++ b/include/uapi/linux/serial_core.h
@@ -226,4 +226,10 @@
 /* Rocketport EXPRESS/INFINITY */
 #define PORT_RP2        102
 
+/* Freescale lpuart */
+#define PORT_LPUART     103
+
+/* SH-SCI */
+#define PORT_HSCIF      104
+
 #endif /* _UAPILINUX_SERIAL_CORE_H */
diff --git a/include/xen/events.h b/include/xen/events.h
index b2b27c6a0f7b..c9ea10ee2273 100644
--- a/include/xen/events.h
+++ b/include/xen/events.h
@@ -76,6 +76,9 @@ unsigned irq_from_evtchn(unsigned int evtchn);
 
 /* Xen HVM evtchn vector callback */
 void xen_hvm_callback_vector(void);
+#ifdef CONFIG_TRACING
+#define trace_xen_hvm_callback_vector xen_hvm_callback_vector
+#endif
 extern int xen_have_vector_callback;
 int xen_set_callback_via(uint64_t via);
 void xen_evtchn_do_upcall(struct pt_regs *regs);